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 #define AGORA_CPP_API __declspec(dllexport)
37 #else
38 #define AGORA_API extern "C" __declspec(dllimport)
39 #define AGORA_CPP_API __declspec(dllimport)
40 #endif // AGORARTC_EXPORT
41 
42 #define AGORA_CALL __cdecl
43 
44 #define __deprecated
45 
46 #elif defined(__APPLE__)
47 
48 #include <TargetConditionals.h>
49 
50 #define AGORA_API extern "C" __attribute__((visibility("default")))
51 #define AGORA_CPP_API __attribute__((visibility("default")))
52 #define AGORA_CALL
53 
54 #elif defined(__ANDROID__) || defined(__linux__)
55 
56 #define AGORA_API extern "C" __attribute__((visibility("default")))
57 #define AGORA_CPP_API __attribute__((visibility("default")))
58 #define AGORA_CALL
59 
60 #define __deprecated
61 
62 #else // !_WIN32 && !__APPLE__ && !(__ANDROID__ || __linux__)
63 
64 #define AGORA_API extern "C"
65 #define AGORA_CPP_API
66 #define AGORA_CALL
67 
68 #define __deprecated
69 
70 #endif // _WIN32
71 
72 #ifndef OPTIONAL_ENUM_SIZE_T
73 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
74 #define OPTIONAL_ENUM_SIZE_T enum : size_t
75 #else
76 #define OPTIONAL_ENUM_SIZE_T enum
77 #endif
78 #endif
79 
80 #ifndef OPTIONAL_NULLPTR
81 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
82 #define OPTIONAL_NULLPTR nullptr
83 #else
84 #define OPTIONAL_NULLPTR NULL
85 #endif
86 #endif
87 
88 #define INVALID_DISPLAY_ID (-2)
89 
90 namespace agora {
91 namespace util {
92 
93 template <class T>
94 class AutoPtr {
95  protected:
96  typedef T value_type;
97  typedef T* pointer_type;
98 
99  public:
100  explicit AutoPtr(pointer_type p = OPTIONAL_NULLPTR) : ptr_(p) {}
101 
102  ~AutoPtr() {
103  if (ptr_) {
104  ptr_->release();
105  ptr_ = OPTIONAL_NULLPTR;
106  }
107  }
108 
109  operator bool() const { return (ptr_ != OPTIONAL_NULLPTR); }
110 
111  value_type& operator*() const { return *get(); }
112 
113  pointer_type operator->() const { return get(); }
114 
115  pointer_type get() const { return ptr_; }
116 
117  pointer_type release() {
118  pointer_type ret = ptr_;
119  ptr_ = 0;
120  return ret;
121  }
122 
123  void reset(pointer_type ptr = OPTIONAL_NULLPTR) {
124  if (ptr != ptr_ && ptr_) {
125  ptr_->release();
126  }
127 
128  ptr_ = ptr;
129  }
130 
131  template <class C1, class C2>
132  bool queryInterface(C1* c, C2 iid) {
133  pointer_type p = OPTIONAL_NULLPTR;
134  if (c && !c->queryInterface(iid, reinterpret_cast<void**>(&p))) {
135  reset(p);
136  }
137 
138  return (p != OPTIONAL_NULLPTR);
139  }
140 
141  private:
142  AutoPtr(const AutoPtr&);
143  AutoPtr& operator=(const AutoPtr&);
144 
145  private:
146  pointer_type ptr_;
147 };
148 
149 template <class T>
150 class CopyableAutoPtr : public AutoPtr<T> {
151  typedef typename AutoPtr<T>::pointer_type pointer_type;
152 
153  public:
154  explicit CopyableAutoPtr(pointer_type p = 0) : AutoPtr<T>(p) {}
155  CopyableAutoPtr(const CopyableAutoPtr& rhs) { this->reset(rhs.clone()); }
156  CopyableAutoPtr& operator=(const CopyableAutoPtr& rhs) {
157  if (this != &rhs) this->reset(rhs.clone());
158  return *this;
159  }
160  pointer_type clone() const {
161  if (!this->get()) return OPTIONAL_NULLPTR;
162  return this->get()->clone();
163  }
164 };
165 
166 class IString {
167  public:
168  virtual bool empty() const = 0;
169  virtual const char* c_str() = 0;
170  virtual const char* data() = 0;
171  virtual size_t length() = 0;
172  virtual IString* clone() = 0;
173  virtual void release() = 0;
174  virtual ~IString() {}
175 };
177 
178 class IIterator {
179  public:
180  virtual void* current() = 0;
181  virtual const void* const_current() const = 0;
182  virtual bool next() = 0;
183  virtual void release() = 0;
184  virtual ~IIterator() {}
185 };
186 
187 class IContainer {
188  public:
189  virtual IIterator* begin() = 0;
190  virtual size_t size() const = 0;
191  virtual void release() = 0;
192  virtual ~IContainer() {}
193 };
194 
195 template <class T>
197  IIterator* p;
198 
199  public:
200  typedef T value_type;
201  typedef value_type& reference;
202  typedef const value_type& const_reference;
203  typedef value_type* pointer;
204  typedef const value_type* const_pointer;
205  explicit AOutputIterator(IIterator* it = OPTIONAL_NULLPTR) : p(it) {}
206  ~AOutputIterator() {
207  if (p) p->release();
208  }
209  AOutputIterator(const AOutputIterator& rhs) : p(rhs.p) {}
210  AOutputIterator& operator++() {
211  p->next();
212  return *this;
213  }
214  bool operator==(const AOutputIterator& rhs) const {
215  if (p && rhs.p)
216  return p->current() == rhs.p->current();
217  else
218  return valid() == rhs.valid();
219  }
220  bool operator!=(const AOutputIterator& rhs) const { return !this->operator==(rhs); }
221  reference operator*() { return *reinterpret_cast<pointer>(p->current()); }
222  const_reference operator*() const { return *reinterpret_cast<const_pointer>(p->const_current()); }
223  bool valid() const { return p && p->current() != OPTIONAL_NULLPTR; }
224 };
225 
226 template <class T>
227 class AList {
228  IContainer* container;
229  bool owner;
230 
231  public:
232  typedef T value_type;
233  typedef value_type& reference;
234  typedef const value_type& const_reference;
235  typedef value_type* pointer;
236  typedef const value_type* const_pointer;
237  typedef size_t size_type;
240 
241  public:
242  AList() : container(OPTIONAL_NULLPTR), owner(false) {}
243  AList(IContainer* c, bool take_ownership) : container(c), owner(take_ownership) {}
244  ~AList() { reset(); }
245  void reset(IContainer* c = OPTIONAL_NULLPTR, bool take_ownership = false) {
246  if (owner && container) container->release();
247  container = c;
248  owner = take_ownership;
249  }
250  iterator begin() { return container ? iterator(container->begin()) : iterator(OPTIONAL_NULLPTR); }
251  iterator end() { return iterator(OPTIONAL_NULLPTR); }
252  size_type size() const { return container ? container->size() : 0; }
253  bool empty() const { return size() == 0; }
254 };
255 
256 } // namespace util
257 
261 enum CHANNEL_PROFILE_TYPE {
267  CHANNEL_PROFILE_COMMUNICATION = 0,
273  CHANNEL_PROFILE_LIVE_BROADCASTING = 1,
278  CHANNEL_PROFILE_GAME __deprecated = 2,
284  CHANNEL_PROFILE_CLOUD_GAMING __deprecated = 3,
285 
290  CHANNEL_PROFILE_COMMUNICATION_1v1 __deprecated = 4,
291 };
292 
296 enum WARN_CODE_TYPE {
301  WARN_INVALID_VIEW = 8,
306  WARN_INIT_VIDEO = 16,
311  WARN_PENDING = 20,
316  WARN_NO_AVAILABLE_CHANNEL = 103,
322  WARN_LOOKUP_CHANNEL_TIMEOUT = 104,
327  WARN_LOOKUP_CHANNEL_REJECTED = 105,
333  WARN_OPEN_CHANNEL_TIMEOUT = 106,
338  WARN_OPEN_CHANNEL_REJECTED = 107,
339 
340  // sdk: 100~1000
344  WARN_SWITCH_LIVE_VIDEO_TIMEOUT = 111,
348  WARN_SET_CLIENT_ROLE_TIMEOUT = 118,
352  WARN_OPEN_CHANNEL_INVALID_TICKET = 121,
356  WARN_OPEN_CHANNEL_TRY_NEXT_VOS = 122,
360  WARN_CHANNEL_CONNECTION_UNRECOVERABLE = 131,
364  WARN_CHANNEL_CONNECTION_IP_CHANGED = 132,
368  WARN_CHANNEL_CONNECTION_PORT_CHANGED = 133,
371  WARN_CHANNEL_SOCKET_ERROR = 134,
375  WARN_AUDIO_MIXING_OPEN_ERROR = 701,
379  WARN_ADM_RUNTIME_PLAYOUT_WARNING = 1014,
383  WARN_ADM_RUNTIME_RECORDING_WARNING = 1016,
387  WARN_ADM_RECORD_AUDIO_SILENCE = 1019,
391  WARN_ADM_PLAYOUT_MALFUNCTION = 1020,
395  WARN_ADM_RECORD_MALFUNCTION = 1021,
399  WARN_ADM_RECORD_AUDIO_LOWLEVEL = 1031,
403  WARN_ADM_PLAYOUT_AUDIO_LOWLEVEL = 1032,
411  WARN_ADM_WINDOWS_NO_DATA_READY_EVENT = 1040,
415  WARN_APM_HOWLING = 1051,
419  WARN_ADM_GLITCH_STATE = 1052,
423  WARN_ADM_IMPROPER_SETTINGS = 1053,
427  WARN_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
432  WARN_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
440  WARN_ADM_WIN_CORE_IMPROPER_CAPTURE_RELEASE = 1324,
441 };
442 
446 enum ERROR_CODE_TYPE {
450  ERR_OK = 0,
451  // 1~1000
455  ERR_FAILED = 1,
460  ERR_INVALID_ARGUMENT = 2,
467  ERR_NOT_READY = 3,
471  ERR_NOT_SUPPORTED = 4,
475  ERR_REFUSED = 5,
479  ERR_BUFFER_TOO_SMALL = 6,
483  ERR_NOT_INITIALIZED = 7,
487  ERR_INVALID_STATE = 8,
492  ERR_NO_PERMISSION = 9,
498  ERR_TIMEDOUT = 10,
503  ERR_CANCELED = 11,
509  ERR_TOO_OFTEN = 12,
515  ERR_BIND_SOCKET = 13,
520  ERR_NET_DOWN = 14,
526  ERR_JOIN_CHANNEL_REJECTED = 17,
533  ERR_LEAVE_CHANNEL_REJECTED = 18,
537  ERR_ALREADY_IN_USE = 19,
542  ERR_ABORTED = 20,
547  ERR_INIT_NET_ENGINE = 21,
552  ERR_RESOURCE_LIMITED = 22,
558  ERR_INVALID_APP_ID = 101,
563  ERR_INVALID_CHANNEL_NAME = 102,
569  ERR_NO_SERVER_RESOURCES = 103,
582  ERR_TOKEN_EXPIRED = 109,
599  ERR_INVALID_TOKEN = 110,
604  ERR_CONNECTION_INTERRUPTED = 111, // only used in web sdk
609  ERR_CONNECTION_LOST = 112, // only used in web sdk
614  ERR_NOT_IN_CHANNEL = 113,
619  ERR_SIZE_TOO_LARGE = 114,
624  ERR_BITRATE_LIMIT = 115,
629  ERR_TOO_MANY_DATA_STREAMS = 116,
633  ERR_STREAM_MESSAGE_TIMEOUT = 117,
637  ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED = 119,
642  ERR_DECRYPTION_FAILED = 120,
646  ERR_INVALID_USER_ID = 121,
651  ERR_DATASTREAM_DECRYPTION_FAILED = 122,
655  ERR_CLIENT_IS_BANNED_BY_SERVER = 123,
661  ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH = 130,
662 
666  ERR_LICENSE_CREDENTIAL_INVALID = 131,
667 
671  ERR_INVALID_USER_ACCOUNT = 134,
672 
678  ERR_MODULE_NOT_FOUND = 157,
679 
680  // Licensing, keep the license error code same as the main version
681  ERR_CERT_RAW = 157,
682  ERR_CERT_JSON_PART = 158,
683  ERR_CERT_JSON_INVAL = 159,
684  ERR_CERT_JSON_NOMEM = 160,
685  ERR_CERT_CUSTOM = 161,
686  ERR_CERT_CREDENTIAL = 162,
687  ERR_CERT_SIGN = 163,
688  ERR_CERT_FAIL = 164,
689  ERR_CERT_BUF = 165,
690  ERR_CERT_NULL = 166,
691  ERR_CERT_DUEDATE = 167,
692  ERR_CERT_REQUEST = 168,
693 
694  // PcmSend Error num
695  ERR_PCMSEND_FORMAT = 200, // unsupport pcm format
696  ERR_PCMSEND_BUFFEROVERFLOW = 201, // buffer overflow, the pcm send rate too quickly
697 
699  // signaling: 400~600
700  ERR_LOGIN_ALREADY_LOGIN = 428,
701 
703  // 1001~2000
707  ERR_LOAD_MEDIA_ENGINE = 1001,
713  ERR_ADM_GENERAL_ERROR = 1005,
718  ERR_ADM_INIT_PLAYOUT = 1008,
722  ERR_ADM_START_PLAYOUT = 1009,
726  ERR_ADM_STOP_PLAYOUT = 1010,
731  ERR_ADM_INIT_RECORDING = 1011,
735  ERR_ADM_START_RECORDING = 1012,
739  ERR_ADM_STOP_RECORDING = 1013,
743  ERR_VDM_CAMERA_NOT_AUTHORIZED = 1501,
744 };
745 
746 enum LICENSE_ERROR_TYPE {
750  LICENSE_ERR_INVALID = 1,
754  LICENSE_ERR_EXPIRE = 2,
758  LICENSE_ERR_MINUTES_EXCEED = 3,
762  LICENSE_ERR_LIMITED_PERIOD = 4,
766  LICENSE_ERR_DIFF_DEVICES = 5,
770  LICENSE_ERR_INTERNAL = 99,
771 };
772 
776 enum AUDIO_SESSION_OPERATION_RESTRICTION {
780  AUDIO_SESSION_OPERATION_RESTRICTION_NONE = 0,
784  AUDIO_SESSION_OPERATION_RESTRICTION_SET_CATEGORY = 1,
788  AUDIO_SESSION_OPERATION_RESTRICTION_CONFIGURE_SESSION = 1 << 1,
793  AUDIO_SESSION_OPERATION_RESTRICTION_DEACTIVATE_SESSION = 1 << 2,
798  AUDIO_SESSION_OPERATION_RESTRICTION_ALL = 1 << 7,
799 };
800 
801 typedef const char* user_id_t;
802 typedef void* view_t;
803 
807 struct UserInfo {
817  bool hasAudio;
823  bool hasVideo;
824 
825  UserInfo() : hasAudio(false), hasVideo(false) {}
826 };
827 
828 typedef util::AList<UserInfo> UserList;
829 
830 // Shared between Agora Service and Rtc Engine
831 namespace rtc {
832 
836 enum USER_OFFLINE_REASON_TYPE {
840  USER_OFFLINE_QUIT = 0,
846  USER_OFFLINE_DROPPED = 1,
850  USER_OFFLINE_BECOME_AUDIENCE = 2,
851 };
852 
853 enum INTERFACE_ID_TYPE {
854  AGORA_IID_AUDIO_DEVICE_MANAGER = 1,
855  AGORA_IID_VIDEO_DEVICE_MANAGER = 2,
856  AGORA_IID_PARAMETER_ENGINE = 3,
857  AGORA_IID_MEDIA_ENGINE = 4,
858  AGORA_IID_AUDIO_ENGINE = 5,
859  AGORA_IID_VIDEO_ENGINE = 6,
860  AGORA_IID_RTC_CONNECTION = 7,
861  AGORA_IID_SIGNALING_ENGINE = 8,
862  AGORA_IID_MEDIA_ENGINE_REGULATOR = 9,
863  AGORA_IID_LOCAL_SPATIAL_AUDIO = 11,
864  AGORA_IID_STATE_SYNC = 13,
865  AGORA_IID_META_SERVICE = 14,
866  AGORA_IID_MUSIC_CONTENT_CENTER = 15,
867  AGORA_IID_H265_TRANSCODER = 16,
868 };
869 
873 enum QUALITY_TYPE {
878  QUALITY_UNKNOWN __deprecated = 0,
882  QUALITY_EXCELLENT = 1,
887  QUALITY_GOOD = 2,
891  QUALITY_POOR = 3,
895  QUALITY_BAD = 4,
899  QUALITY_VBAD = 5,
903  QUALITY_DOWN = 6,
907  QUALITY_UNSUPPORTED = 7,
911  QUALITY_DETECTING = 8,
912 };
913 
917 enum FIT_MODE_TYPE {
922  MODE_COVER = 1,
923 
929  MODE_CONTAIN = 2,
930 };
931 
935 enum VIDEO_ORIENTATION {
939  VIDEO_ORIENTATION_0 = 0,
943  VIDEO_ORIENTATION_90 = 90,
947  VIDEO_ORIENTATION_180 = 180,
951  VIDEO_ORIENTATION_270 = 270
952 };
953 
957 enum FRAME_RATE {
961  FRAME_RATE_FPS_1 = 1,
965  FRAME_RATE_FPS_7 = 7,
969  FRAME_RATE_FPS_10 = 10,
973  FRAME_RATE_FPS_15 = 15,
977  FRAME_RATE_FPS_24 = 24,
981  FRAME_RATE_FPS_30 = 30,
985  FRAME_RATE_FPS_60 = 60,
986 };
987 
988 enum FRAME_WIDTH {
989  FRAME_WIDTH_960 = 960,
990 };
991 
992 enum FRAME_HEIGHT {
993  FRAME_HEIGHT_540 = 540,
994 };
995 
996 
1000 enum VIDEO_FRAME_TYPE {
1002  VIDEO_FRAME_TYPE_BLANK_FRAME = 0,
1004  VIDEO_FRAME_TYPE_KEY_FRAME = 3,
1006  VIDEO_FRAME_TYPE_DELTA_FRAME = 4,
1008  VIDEO_FRAME_TYPE_B_FRAME = 5,
1010  VIDEO_FRAME_TYPE_DROPPABLE_FRAME = 6,
1012  VIDEO_FRAME_TYPE_UNKNOW
1013 };
1014 
1018 enum ORIENTATION_MODE {
1026  ORIENTATION_MODE_ADAPTIVE = 0,
1033  ORIENTATION_MODE_FIXED_LANDSCAPE = 1,
1040  ORIENTATION_MODE_FIXED_PORTRAIT = 2,
1041 };
1042 
1046 enum DEGRADATION_PREFERENCE {
1054  MAINTAIN_QUALITY = 0,
1060  MAINTAIN_FRAMERATE = 1,
1067  MAINTAIN_BALANCED = 2,
1071  MAINTAIN_RESOLUTION = 3,
1075  DISABLED = 100,
1076 };
1077 
1085  int width;
1089  int height;
1090  VideoDimensions() : width(640), height(480) {}
1091  VideoDimensions(int w, int h) : width(w), height(h) {}
1092  bool operator==(const VideoDimensions& rhs) const {
1093  return width == rhs.width && height == rhs.height;
1094  }
1095 };
1096 
1102 const int STANDARD_BITRATE = 0;
1103 
1111 const int COMPATIBLE_BITRATE = -1;
1112 
1116 const int DEFAULT_MIN_BITRATE = -1;
1117 
1121 const int DEFAULT_MIN_BITRATE_EQUAL_TO_TARGET_BITRATE = -2;
1122 
1126 enum SCREEN_CAPTURE_FRAMERATE_CAPABILITY {
1127  SCREEN_CAPTURE_FRAMERATE_CAPABILITY_15_FPS = 0,
1128  SCREEN_CAPTURE_FRAMERATE_CAPABILITY_30_FPS = 1,
1129  SCREEN_CAPTURE_FRAMERATE_CAPABILITY_60_FPS = 2,
1130 };
1131 
1135 enum VIDEO_CODEC_CAPABILITY_LEVEL {
1137  CODEC_CAPABILITY_LEVEL_UNSPECIFIED = -1,
1139  CODEC_CAPABILITY_LEVEL_BASIC_SUPPORT = 5,
1141  CODEC_CAPABILITY_LEVEL_1080P30FPS = 10,
1143  CODEC_CAPABILITY_LEVEL_1080P60FPS = 20,
1145  CODEC_CAPABILITY_LEVEL_4K60FPS = 30,
1146 };
1147 
1151 enum VIDEO_CODEC_TYPE {
1152  VIDEO_CODEC_NONE = 0,
1156  VIDEO_CODEC_VP8 = 1,
1160  VIDEO_CODEC_H264 = 2,
1164  VIDEO_CODEC_H265 = 3,
1169  VIDEO_CODEC_GENERIC = 6,
1173  VIDEO_CODEC_GENERIC_H264 = 7,
1178  VIDEO_CODEC_AV1 = 12,
1182  VIDEO_CODEC_VP9 = 13,
1186  VIDEO_CODEC_GENERIC_JPEG = 20,
1187 };
1188 
1192 enum CAMERA_FOCAL_LENGTH_TYPE {
1196  CAMERA_FOCAL_LENGTH_DEFAULT = 0,
1200  CAMERA_FOCAL_LENGTH_WIDE_ANGLE = 1,
1204  CAMERA_FOCAL_LENGTH_ULTRA_WIDE = 2,
1208  CAMERA_FOCAL_LENGTH_TELEPHOTO = 3,
1209 };
1210 
1214 enum TCcMode {
1218  CC_ENABLED,
1222  CC_DISABLED,
1223 };
1224 
1232  TCcMode ccMode;
1236  VIDEO_CODEC_TYPE codecType;
1237 
1295 
1296  SenderOptions()
1297  : ccMode(CC_ENABLED),
1298  codecType(VIDEO_CODEC_H265),
1299  targetBitrate(6500) {}
1300 };
1301 
1305 enum AUDIO_CODEC_TYPE {
1309  AUDIO_CODEC_OPUS = 1,
1310  // kIsac = 2,
1314  AUDIO_CODEC_PCMA = 3,
1318  AUDIO_CODEC_PCMU = 4,
1322  AUDIO_CODEC_G722 = 5,
1323  // kIlbc = 6,
1325  // AUDIO_CODEC_AAC = 7,
1329  AUDIO_CODEC_AACLC = 8,
1333  AUDIO_CODEC_HEAAC = 9,
1337  AUDIO_CODEC_JC1 = 10,
1341  AUDIO_CODEC_HEAAC2 = 11,
1345  AUDIO_CODEC_LPCNET = 12,
1346 };
1347 
1351 enum AUDIO_ENCODING_TYPE {
1356  AUDIO_ENCODING_TYPE_AAC_16000_LOW = 0x010101,
1361  AUDIO_ENCODING_TYPE_AAC_16000_MEDIUM = 0x010102,
1366  AUDIO_ENCODING_TYPE_AAC_32000_LOW = 0x010201,
1371  AUDIO_ENCODING_TYPE_AAC_32000_MEDIUM = 0x010202,
1376  AUDIO_ENCODING_TYPE_AAC_32000_HIGH = 0x010203,
1381  AUDIO_ENCODING_TYPE_AAC_48000_MEDIUM = 0x010302,
1386  AUDIO_ENCODING_TYPE_AAC_48000_HIGH = 0x010303,
1391  AUDIO_ENCODING_TYPE_OPUS_16000_LOW = 0x020101,
1396  AUDIO_ENCODING_TYPE_OPUS_16000_MEDIUM = 0x020102,
1401  AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM = 0x020302,
1406  AUDIO_ENCODING_TYPE_OPUS_48000_HIGH = 0x020303,
1407 };
1408 
1412 enum WATERMARK_FIT_MODE {
1417  FIT_MODE_COVER_POSITION,
1422  FIT_MODE_USE_IMAGE_RATIO
1423 };
1424 
1430  : speech(true),
1431  sendEvenIfEmpty(true) {}
1432 
1438  bool speech;
1445 };
1446 
1452  : codec(AUDIO_CODEC_AACLC),
1453  sampleRateHz(0),
1454  samplesPerChannel(0),
1455  numberOfChannels(0),
1456  captureTimeMs(0) {}
1457 
1459  : codec(rhs.codec),
1468  AUDIO_CODEC_TYPE codec;
1487 
1491  int64_t captureTimeMs;
1492 };
1497  AudioPcmDataInfo() : samplesPerChannel(0), channelNum(0), samplesOut(0), elapsedTimeMs(0), ntpTimeMs(0) {}
1498 
1501  channelNum(rhs.channelNum),
1502  samplesOut(rhs.samplesOut),
1504  ntpTimeMs(rhs.ntpTimeMs) {}
1505 
1510 
1511  int16_t channelNum;
1512 
1513  // Output
1517  size_t samplesOut;
1521  int64_t elapsedTimeMs;
1525  int64_t ntpTimeMs;
1526 };
1530 enum H264PacketizeMode {
1534  NonInterleaved = 0, // Mode 1 - STAP-A, FU-A is allowed
1538  SingleNalUnit, // Mode 0 - only single NALU allowed
1539 };
1540 
1544 enum VIDEO_STREAM_TYPE {
1548  VIDEO_STREAM_HIGH = 0,
1552  VIDEO_STREAM_LOW = 1,
1553 };
1554 
1569 
1571 };
1572 
1573 
1576 enum MAX_USER_ACCOUNT_LENGTH_TYPE
1577 {
1580  MAX_USER_ACCOUNT_LENGTH = 256
1581 };
1582 
1588  : uid(0),
1589  codecType(VIDEO_CODEC_H264),
1590  width(0),
1591  height(0),
1592  framesPerSecond(0),
1593  frameType(VIDEO_FRAME_TYPE_BLANK_FRAME),
1594  rotation(VIDEO_ORIENTATION_0),
1595  trackId(0),
1596  captureTimeMs(0),
1597  decodeTimeMs(0),
1598  streamType(VIDEO_STREAM_HIGH),
1599  presentationMs(-1) {}
1600 
1602  : uid(rhs.uid),
1603  codecType(rhs.codecType),
1604  width(rhs.width),
1605  height(rhs.height),
1607  frameType(rhs.frameType),
1608  rotation(rhs.rotation),
1609  trackId(rhs.trackId),
1612  streamType(rhs.streamType),
1613  presentationMs(rhs.presentationMs) {}
1614 
1615  EncodedVideoFrameInfo& operator=(const EncodedVideoFrameInfo& rhs) {
1616  if (this == &rhs) return *this;
1617  uid = rhs.uid;
1618  codecType = rhs.codecType;
1619  width = rhs.width;
1620  height = rhs.height;
1622  frameType = rhs.frameType;
1623  rotation = rhs.rotation;
1624  trackId = rhs.trackId;
1626  decodeTimeMs = rhs.decodeTimeMs;
1627  streamType = rhs.streamType;
1628  presentationMs = rhs.presentationMs;
1629  return *this;
1630  }
1631 
1635  uid_t uid;
1639  VIDEO_CODEC_TYPE codecType;
1643  int width;
1647  int height;
1657  VIDEO_FRAME_TYPE frameType;
1661  VIDEO_ORIENTATION rotation;
1665  int trackId; // This can be reserved for multiple video tracks, we need to create different ssrc
1666  // and additional payload for later implementation.
1670  int64_t captureTimeMs;
1674  int64_t decodeTimeMs;
1678  VIDEO_STREAM_TYPE streamType;
1679 
1680  // @technical preview
1681  int64_t presentationMs;
1682 };
1683 
1687 enum COMPRESSION_PREFERENCE {
1691  PREFER_LOW_LATENCY,
1695  PREFER_QUALITY,
1696 };
1697 
1701 enum ENCODING_PREFERENCE {
1705  PREFER_AUTO = -1,
1709  PREFER_SOFTWARE = 0,
1713  PREFER_HARDWARE = 1,
1714 };
1715 
1720 
1724  ENCODING_PREFERENCE encodingPreference;
1725 
1729  COMPRESSION_PREFERENCE compressionPreference;
1730 
1731  AdvanceOptions() : encodingPreference(PREFER_AUTO),
1732  compressionPreference(PREFER_LOW_LATENCY) {}
1733 
1734  AdvanceOptions(ENCODING_PREFERENCE encoding_preference,
1735  COMPRESSION_PREFERENCE compression_preference) :
1736  encodingPreference(encoding_preference),
1737  compressionPreference(compression_preference) {}
1738 
1739  bool operator==(const AdvanceOptions& rhs) const {
1740  return encodingPreference == rhs.encodingPreference &&
1741  compressionPreference == rhs.compressionPreference;
1742  }
1743 
1744 };
1745 
1749 enum VIDEO_MIRROR_MODE_TYPE {
1753  VIDEO_MIRROR_MODE_AUTO = 0,
1757  VIDEO_MIRROR_MODE_ENABLED = 1,
1761  VIDEO_MIRROR_MODE_DISABLED = 2,
1762 };
1763 
1764 
1766 enum CODEC_CAP_MASK {
1768  CODEC_CAP_MASK_NONE = 0,
1769 
1771  CODEC_CAP_MASK_HW_DEC = 1 << 0,
1772 
1774  CODEC_CAP_MASK_HW_ENC = 1 << 1,
1775 
1777  CODEC_CAP_MASK_SW_DEC = 1 << 2,
1778 
1780  CODEC_CAP_MASK_SW_ENC = 1 << 3,
1781 };
1782 
1784  VIDEO_CODEC_CAPABILITY_LEVEL hwDecodingLevel;
1785  VIDEO_CODEC_CAPABILITY_LEVEL swDecodingLevel;
1786 
1787  CodecCapLevels(): hwDecodingLevel(CODEC_CAPABILITY_LEVEL_UNSPECIFIED), swDecodingLevel(CODEC_CAPABILITY_LEVEL_UNSPECIFIED) {}
1788 };
1789 
1793  VIDEO_CODEC_TYPE codecType;
1798 
1799  CodecCapInfo(): codecType(VIDEO_CODEC_NONE), codecCapMask(0) {}
1800 };
1801 
1807  CAMERA_FOCAL_LENGTH_TYPE focalLengthType;
1808 };
1809 
1817  VIDEO_CODEC_TYPE codecType;
1882  int bitrate;
1883 
1903  ORIENTATION_MODE orientationMode;
1907  DEGRADATION_PREFERENCE degradationPreference;
1908 
1913  VIDEO_MIRROR_MODE_TYPE mirrorMode;
1914 
1919 
1920  VideoEncoderConfiguration(const VideoDimensions& d, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
1921  : codecType(VIDEO_CODEC_NONE),
1922  dimensions(d),
1923  frameRate(f),
1924  bitrate(b),
1925  minBitrate(DEFAULT_MIN_BITRATE),
1926  orientationMode(m),
1927  degradationPreference(MAINTAIN_QUALITY),
1928  mirrorMode(mirror),
1929  advanceOptions(PREFER_AUTO, PREFER_LOW_LATENCY) {}
1930  VideoEncoderConfiguration(int width, int height, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
1931  : codecType(VIDEO_CODEC_NONE),
1932  dimensions(width, height),
1933  frameRate(f),
1934  bitrate(b),
1935  minBitrate(DEFAULT_MIN_BITRATE),
1936  orientationMode(m),
1937  degradationPreference(MAINTAIN_QUALITY),
1938  mirrorMode(mirror),
1939  advanceOptions(PREFER_AUTO, PREFER_LOW_LATENCY) {}
1940  VideoEncoderConfiguration(const VideoEncoderConfiguration& config)
1941  : codecType(config.codecType),
1942  dimensions(config.dimensions),
1943  frameRate(config.frameRate),
1944  bitrate(config.bitrate),
1945  minBitrate(config.minBitrate),
1948  mirrorMode(config.mirrorMode),
1949  advanceOptions(config.advanceOptions) {}
1950  VideoEncoderConfiguration()
1951  : codecType(VIDEO_CODEC_NONE),
1952  dimensions(FRAME_WIDTH_960, FRAME_HEIGHT_540),
1953  frameRate(FRAME_RATE_FPS_15),
1954  bitrate(STANDARD_BITRATE),
1955  minBitrate(DEFAULT_MIN_BITRATE),
1956  orientationMode(ORIENTATION_MODE_ADAPTIVE),
1957  degradationPreference(MAINTAIN_QUALITY),
1958  mirrorMode(VIDEO_MIRROR_MODE_DISABLED),
1959  advanceOptions(PREFER_AUTO, PREFER_LOW_LATENCY) {}
1960 
1961  VideoEncoderConfiguration& operator=(const VideoEncoderConfiguration& rhs) {
1962  if (this == &rhs) return *this;
1963  codecType = rhs.codecType;
1964  dimensions = rhs.dimensions;
1965  frameRate = rhs.frameRate;
1966  bitrate = rhs.bitrate;
1967  minBitrate = rhs.minBitrate;
1968  orientationMode = rhs.orientationMode;
1969  degradationPreference = rhs.degradationPreference;
1970  mirrorMode = rhs.mirrorMode;
1971  advanceOptions = rhs.advanceOptions;
1972  return *this;
1973  }
1974 };
1975 
1999  bool ordered;
2000 };
2001 
2005 enum SIMULCAST_STREAM_MODE {
2006  /*
2007  * disable simulcast stream until receive request for enable simulcast stream by other broadcaster
2008  */
2009  AUTO_SIMULCAST_STREAM = -1,
2010  /*
2011  * disable simulcast stream
2012  */
2013  DISABLE_SIMULCAST_STREAM = 0,
2014  /*
2015  * always enable simulcast stream
2016  */
2017  ENABLE_SIMULCAST_STREAM = 1,
2018 };
2019 
2036  SimulcastStreamConfig() : dimensions(160, 120), kBitrate(65), framerate(5) {}
2037  bool operator==(const SimulcastStreamConfig& rhs) const {
2038  return dimensions == rhs.dimensions && kBitrate == rhs.kBitrate && framerate == rhs.framerate;
2039  }
2040 };
2041 
2046 struct Rectangle {
2050  int x;
2054  int y;
2058  int width;
2062  int height;
2063 
2064  Rectangle() : x(0), y(0), width(0), height(0) {}
2065  Rectangle(int xx, int yy, int ww, int hh) : x(xx), y(yy), width(ww), height(hh) {}
2066 };
2067 
2082  float xRatio;
2088  float yRatio;
2094  float widthRatio;
2095 
2096  WatermarkRatio() : xRatio(0.0), yRatio(0.0), widthRatio(0.0) {}
2097  WatermarkRatio(float x, float y, float width) : xRatio(x), yRatio(y), widthRatio(width) {}
2098 };
2099 
2128  WATERMARK_FIT_MODE mode;
2129 
2131  : visibleInPreview(true),
2132  positionInLandscapeMode(0, 0, 0, 0),
2133  positionInPortraitMode(0, 0, 0, 0),
2134  mode(FIT_MODE_COVER_POSITION) {}
2135 };
2136 
2140 struct RtcStats {
2144  unsigned int duration;
2148  unsigned int txBytes;
2152  unsigned int rxBytes;
2156  unsigned int txAudioBytes;
2160  unsigned int txVideoBytes;
2164  unsigned int rxAudioBytes;
2168  unsigned int rxVideoBytes;
2172  unsigned short txKBitRate;
2176  unsigned short rxKBitRate;
2180  unsigned short rxAudioKBitRate;
2184  unsigned short txAudioKBitRate;
2188  unsigned short rxVideoKBitRate;
2192  unsigned short txVideoKBitRate;
2196  unsigned short lastmileDelay;
2200  unsigned int userCount;
2207  double cpuAppUsage;
2297  RtcStats()
2298  : duration(0),
2299  txBytes(0),
2300  rxBytes(0),
2301  txAudioBytes(0),
2302  txVideoBytes(0),
2303  rxAudioBytes(0),
2304  rxVideoBytes(0),
2305  txKBitRate(0),
2306  rxKBitRate(0),
2307  rxAudioKBitRate(0),
2308  txAudioKBitRate(0),
2309  rxVideoKBitRate(0),
2310  txVideoKBitRate(0),
2311  lastmileDelay(0),
2312  userCount(0),
2313  cpuAppUsage(0.0),
2314  cpuTotalUsage(0.0),
2315  gatewayRtt(0),
2316  memoryAppUsageRatio(0.0),
2317  memoryTotalUsageRatio(0.0),
2319  connectTimeMs(0),
2329  txPacketLossRate(0),
2330  rxPacketLossRate(0) {}
2331 };
2332 
2336 enum CLIENT_ROLE_TYPE {
2340  CLIENT_ROLE_BROADCASTER = 1,
2344  CLIENT_ROLE_AUDIENCE = 2,
2345 };
2346 
2350 enum QUALITY_ADAPT_INDICATION {
2354  ADAPT_NONE = 0,
2358  ADAPT_UP_BANDWIDTH = 1,
2362  ADAPT_DOWN_BANDWIDTH = 2,
2363 };
2364 
2369 enum AUDIENCE_LATENCY_LEVEL_TYPE
2370 {
2374  AUDIENCE_LATENCY_LEVEL_LOW_LATENCY = 1,
2378  AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY = 2,
2379 };
2380 
2385 {
2389  AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel;
2390 
2392  : audienceLatencyLevel(AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY) {}
2393 };
2394 
2398 enum EXPERIENCE_QUALITY_TYPE {
2400  EXPERIENCE_QUALITY_GOOD = 0,
2402  EXPERIENCE_QUALITY_BAD = 1,
2403 };
2404 
2408 enum EXPERIENCE_POOR_REASON {
2412  EXPERIENCE_REASON_NONE = 0,
2416  REMOTE_NETWORK_QUALITY_POOR = 1,
2420  LOCAL_NETWORK_QUALITY_POOR = 2,
2424  WIRELESS_SIGNAL_POOR = 4,
2429  WIFI_BLUETOOTH_COEXIST = 8,
2430 };
2431 
2435 enum AUDIO_AINS_MODE {
2439  AINS_MODE_BALANCED = 0,
2443  AINS_MODE_AGGRESSIVE = 1,
2447  AINS_MODE_ULTRALOWLATENCY = 2
2448 };
2449 
2453 enum AUDIO_PROFILE_TYPE {
2462  AUDIO_PROFILE_DEFAULT = 0,
2466  AUDIO_PROFILE_SPEECH_STANDARD = 1,
2470  AUDIO_PROFILE_MUSIC_STANDARD = 2,
2477  AUDIO_PROFILE_MUSIC_STANDARD_STEREO = 3,
2481  AUDIO_PROFILE_MUSIC_HIGH_QUALITY = 4,
2488  AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO = 5,
2492  AUDIO_PROFILE_IOT = 6,
2493  AUDIO_PROFILE_NUM = 7
2494 };
2495 
2499 enum AUDIO_SCENARIO_TYPE {
2504  AUDIO_SCENARIO_DEFAULT = 0,
2510  AUDIO_SCENARIO_GAME_STREAMING = 3,
2516  AUDIO_SCENARIO_CHATROOM = 5,
2520  AUDIO_SCENARIO_CHORUS = 7,
2524  AUDIO_SCENARIO_MEETING = 8,
2528  AUDIO_SCENARIO_NUM = 9,
2529 };
2530 
2534 struct VideoFormat {
2535  OPTIONAL_ENUM_SIZE_T {
2537  kMaxWidthInPixels = 3840,
2539  kMaxHeightInPixels = 2160,
2541  kMaxFps = 60,
2542  };
2543 
2547  int width; // Number of pixels.
2551  int height; // Number of pixels.
2555  int fps;
2556  VideoFormat() : width(FRAME_WIDTH_960), height(FRAME_HEIGHT_540), fps(FRAME_RATE_FPS_15) {}
2557  VideoFormat(int w, int h, int f) : width(w), height(h), fps(f) {}
2558 
2559  bool operator<(const VideoFormat& fmt) const {
2560  if (height != fmt.height) {
2561  return height < fmt.height;
2562  } else if (width != fmt.width) {
2563  return width < fmt.width;
2564  } else {
2565  return fps < fmt.fps;
2566  }
2567  }
2568  bool operator==(const VideoFormat& fmt) const {
2569  return width == fmt.width && height == fmt.height && fps == fmt.fps;
2570  }
2571  bool operator!=(const VideoFormat& fmt) const {
2572  return !operator==(fmt);
2573  }
2574 };
2575 
2579 enum VIDEO_CONTENT_HINT {
2583  CONTENT_HINT_NONE,
2590  CONTENT_HINT_MOTION,
2596  CONTENT_HINT_DETAILS
2597 };
2601 enum SCREEN_SCENARIO_TYPE {
2607  SCREEN_SCENARIO_DOCUMENT = 1,
2612  SCREEN_SCENARIO_GAMING = 2,
2617  SCREEN_SCENARIO_VIDEO = 3,
2623  SCREEN_SCENARIO_RDC = 4,
2624 };
2625 
2626 
2630 enum VIDEO_APPLICATION_SCENARIO_TYPE {
2634  APPLICATION_SCENARIO_GENERAL = 0,
2638  APPLICATION_SCENARIO_MEETING = 1,
2639 };
2640 
2644 enum VIDEO_QOE_PREFERENCE_TYPE {
2648  VIDEO_QOE_PREFERENCE_BALANCE = 1,
2652  VIDEO_QOE_PREFERENCE_DELAY_FIRST = 2,
2656  VIDEO_QOE_PREFERENCE_PICTURE_QUALITY_FIRST = 3,
2660  VIDEO_QOE_PREFERENCE_FLUENCY_FIRST = 4,
2661 
2662 };
2663 
2667 enum CAPTURE_BRIGHTNESS_LEVEL_TYPE {
2671  CAPTURE_BRIGHTNESS_LEVEL_INVALID = -1,
2674  CAPTURE_BRIGHTNESS_LEVEL_NORMAL = 0,
2677  CAPTURE_BRIGHTNESS_LEVEL_BRIGHT = 1,
2680  CAPTURE_BRIGHTNESS_LEVEL_DARK = 2,
2681 };
2682 
2683 enum CAMERA_STABILIZATION_MODE {
2686  CAMERA_STABILIZATION_MODE_OFF = -1,
2689  CAMERA_STABILIZATION_MODE_AUTO = 0,
2692  CAMERA_STABILIZATION_MODE_LEVEL_1 = 1,
2695  CAMERA_STABILIZATION_MODE_LEVEL_2 = 2,
2698  CAMERA_STABILIZATION_MODE_LEVEL_3 = 3,
2701  CAMERA_STABILIZATION_MODE_MAX_LEVEL = CAMERA_STABILIZATION_MODE_LEVEL_3,
2702 };
2703 
2707 enum LOCAL_AUDIO_STREAM_STATE {
2711  LOCAL_AUDIO_STREAM_STATE_STOPPED = 0,
2715  LOCAL_AUDIO_STREAM_STATE_RECORDING = 1,
2719  LOCAL_AUDIO_STREAM_STATE_ENCODING = 2,
2723  LOCAL_AUDIO_STREAM_STATE_FAILED = 3
2724 };
2725 
2729 enum LOCAL_AUDIO_STREAM_REASON {
2733  LOCAL_AUDIO_STREAM_REASON_OK = 0,
2737  LOCAL_AUDIO_STREAM_REASON_FAILURE = 1,
2741  LOCAL_AUDIO_STREAM_REASON_DEVICE_NO_PERMISSION = 2,
2748  LOCAL_AUDIO_STREAM_REASON_DEVICE_BUSY = 3,
2752  LOCAL_AUDIO_STREAM_REASON_RECORD_FAILURE = 4,
2756  LOCAL_AUDIO_STREAM_REASON_ENCODE_FAILURE = 5,
2759  LOCAL_AUDIO_STREAM_REASON_NO_RECORDING_DEVICE = 6,
2762  LOCAL_AUDIO_STREAM_REASON_NO_PLAYOUT_DEVICE = 7,
2766  LOCAL_AUDIO_STREAM_REASON_INTERRUPTED = 8,
2769  LOCAL_AUDIO_STREAM_REASON_RECORD_INVALID_ID = 9,
2772  LOCAL_AUDIO_STREAM_REASON_PLAYOUT_INVALID_ID = 10,
2773 };
2774 
2777 enum LOCAL_VIDEO_STREAM_STATE {
2781  LOCAL_VIDEO_STREAM_STATE_STOPPED = 0,
2786  LOCAL_VIDEO_STREAM_STATE_CAPTURING = 1,
2790  LOCAL_VIDEO_STREAM_STATE_ENCODING = 2,
2794  LOCAL_VIDEO_STREAM_STATE_FAILED = 3
2795 };
2796 
2800 enum LOCAL_VIDEO_STREAM_REASON {
2804  LOCAL_VIDEO_STREAM_REASON_OK = 0,
2808  LOCAL_VIDEO_STREAM_REASON_FAILURE = 1,
2813  LOCAL_VIDEO_STREAM_REASON_DEVICE_NO_PERMISSION = 2,
2818  LOCAL_VIDEO_STREAM_REASON_DEVICE_BUSY = 3,
2824  LOCAL_VIDEO_STREAM_REASON_CAPTURE_FAILURE = 4,
2828  LOCAL_VIDEO_STREAM_REASON_CODEC_NOT_SUPPORT = 5,
2833  LOCAL_VIDEO_STREAM_REASON_CAPTURE_INBACKGROUND = 6,
2840  LOCAL_VIDEO_STREAM_REASON_CAPTURE_MULTIPLE_FOREGROUND_APPS = 7,
2846  LOCAL_VIDEO_STREAM_REASON_DEVICE_NOT_FOUND = 8,
2851  LOCAL_VIDEO_STREAM_REASON_DEVICE_DISCONNECTED = 9,
2856  LOCAL_VIDEO_STREAM_REASON_DEVICE_INVALID_ID = 10,
2861  LOCAL_VIDEO_STREAM_REASON_DEVICE_INTERRUPT = 14,
2866  LOCAL_VIDEO_STREAM_REASON_DEVICE_FATAL_ERROR = 15,
2870  LOCAL_VIDEO_STREAM_REASON_DEVICE_SYSTEM_PRESSURE = 101,
2876  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_MINIMIZED = 11,
2891  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_CLOSED = 12,
2893  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_OCCLUDED = 13,
2895  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_NOT_SUPPORTED = 20,
2897  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_FAILURE = 21,
2899  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_NO_PERMISSION = 22,
2905  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_AUTO_FALLBACK = 24,
2907  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_HIDDEN = 25,
2909  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_HIDDEN = 26,
2911  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_MINIMIZED = 27,
2919  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_PAUSED = 28,
2921  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_RESUMED = 29,
2922 
2923 };
2924 
2928 enum REMOTE_AUDIO_STATE
2929 {
2935  REMOTE_AUDIO_STATE_STOPPED = 0, // Default state, audio is started or remote user disabled/muted audio stream
2939  REMOTE_AUDIO_STATE_STARTING = 1, // The first audio frame packet has been received
2945  REMOTE_AUDIO_STATE_DECODING = 2, // The first remote audio frame has been decoded or fronzen state ends
2950  REMOTE_AUDIO_STATE_FROZEN = 3, // Remote audio is frozen, probably due to network issue
2955  REMOTE_AUDIO_STATE_FAILED = 4, // Remote audio play failed
2956 };
2957 
2961 enum REMOTE_AUDIO_STATE_REASON
2962 {
2966  REMOTE_AUDIO_REASON_INTERNAL = 0,
2970  REMOTE_AUDIO_REASON_NETWORK_CONGESTION = 1,
2974  REMOTE_AUDIO_REASON_NETWORK_RECOVERY = 2,
2979  REMOTE_AUDIO_REASON_LOCAL_MUTED = 3,
2984  REMOTE_AUDIO_REASON_LOCAL_UNMUTED = 4,
2989  REMOTE_AUDIO_REASON_REMOTE_MUTED = 5,
2994  REMOTE_AUDIO_REASON_REMOTE_UNMUTED = 6,
2998  REMOTE_AUDIO_REASON_REMOTE_OFFLINE = 7,
3002  REMOTE_AUDIO_REASON_NO_PACKET_RECEIVE = 8,
3006  REMOTE_AUDIO_REASON_LOCAL_PLAY_FAILED = 9,
3007 };
3008 
3012 enum REMOTE_VIDEO_STATE {
3018  REMOTE_VIDEO_STATE_STOPPED = 0,
3022  REMOTE_VIDEO_STATE_STARTING = 1,
3028  REMOTE_VIDEO_STATE_DECODING = 2,
3032  REMOTE_VIDEO_STATE_FROZEN = 3,
3036  REMOTE_VIDEO_STATE_FAILED = 4,
3037 };
3041 enum REMOTE_VIDEO_STATE_REASON {
3045  REMOTE_VIDEO_STATE_REASON_INTERNAL = 0,
3049  REMOTE_VIDEO_STATE_REASON_NETWORK_CONGESTION = 1,
3053  REMOTE_VIDEO_STATE_REASON_NETWORK_RECOVERY = 2,
3057  REMOTE_VIDEO_STATE_REASON_LOCAL_MUTED = 3,
3061  REMOTE_VIDEO_STATE_REASON_LOCAL_UNMUTED = 4,
3065  REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED = 5,
3069  REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED = 6,
3073  REMOTE_VIDEO_STATE_REASON_REMOTE_OFFLINE = 7,
3077  REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK = 8,
3081  REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK_RECOVERY = 9,
3084  REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_LOW = 10,
3087  REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_HIGH = 11,
3090  REMOTE_VIDEO_STATE_REASON_SDK_IN_BACKGROUND = 12,
3091 
3094  REMOTE_VIDEO_STATE_REASON_CODEC_NOT_SUPPORT = 13,
3095 
3096 };
3097 
3101 enum REMOTE_USER_STATE {
3105  USER_STATE_MUTE_AUDIO = (1 << 0),
3109  USER_STATE_MUTE_VIDEO = (1 << 1),
3113  USER_STATE_ENABLE_VIDEO = (1 << 4),
3117  USER_STATE_ENABLE_LOCAL_VIDEO = (1 << 8),
3118 };
3119 
3125  VideoTrackInfo()
3126  : isLocal(false), ownerUid(0), trackId(0), channelId(OPTIONAL_NULLPTR)
3127  , codecType(VIDEO_CODEC_H265)
3128  , encodedFrameOnly(false), sourceType(VIDEO_SOURCE_CAMERA_PRIMARY)
3129  , observationPosition(agora::media::base::POSITION_POST_CAPTURER) {}
3135  bool isLocal;
3139  uid_t ownerUid;
3143  track_id_t trackId;
3147  const char* channelId;
3151  VIDEO_CODEC_TYPE codecType;
3161  VIDEO_SOURCE_TYPE sourceType;
3166 };
3167 
3171 enum REMOTE_VIDEO_DOWNSCALE_LEVEL {
3175  REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE,
3179  REMOTE_VIDEO_DOWNSCALE_LEVEL_1,
3183  REMOTE_VIDEO_DOWNSCALE_LEVEL_2,
3187  REMOTE_VIDEO_DOWNSCALE_LEVEL_3,
3191  REMOTE_VIDEO_DOWNSCALE_LEVEL_4,
3192 };
3193 
3204  uid_t uid;
3210  unsigned int volume; // [0,255]
3220  unsigned int vad;
3226  double voicePitch;
3227 
3228  AudioVolumeInfo() : uid(0), volume(0), vad(0), voicePitch(0.0) {}
3229 };
3230 
3234 struct DeviceInfo {
3235  /*
3236  * Whether the audio device supports ultra-low-latency capture and playback:
3237  * - `true`: The device supports ultra-low-latency capture and playback.
3238  * - `false`: The device does not support ultra-low-latency capture and playback.
3239  */
3240  bool isLowLatencyAudioSupported;
3241 
3242  DeviceInfo() : isLowLatencyAudioSupported(false) {}
3243 };
3244 
3249  public:
3250  virtual ~IPacketObserver() {}
3254  struct Packet {
3260  const unsigned char* buffer;
3264  unsigned int size;
3265 
3266  Packet() : buffer(OPTIONAL_NULLPTR), size(0) {}
3267  };
3275  virtual bool onSendAudioPacket(Packet& packet) = 0;
3283  virtual bool onSendVideoPacket(Packet& packet) = 0;
3291  virtual bool onReceiveAudioPacket(Packet& packet) = 0;
3299  virtual bool onReceiveVideoPacket(Packet& packet) = 0;
3300 };
3301 
3305 enum AUDIO_SAMPLE_RATE_TYPE {
3309  AUDIO_SAMPLE_RATE_32000 = 32000,
3313  AUDIO_SAMPLE_RATE_44100 = 44100,
3317  AUDIO_SAMPLE_RATE_48000 = 48000,
3318 };
3322 enum VIDEO_CODEC_TYPE_FOR_STREAM {
3326  VIDEO_CODEC_H264_FOR_STREAM = 1,
3330  VIDEO_CODEC_H265_FOR_STREAM = 2,
3331 };
3332 
3336 enum VIDEO_CODEC_PROFILE_TYPE {
3340  VIDEO_CODEC_PROFILE_BASELINE = 66,
3344  VIDEO_CODEC_PROFILE_MAIN = 77,
3348  VIDEO_CODEC_PROFILE_HIGH = 100,
3349 };
3350 
3351 
3355 enum AUDIO_CODEC_PROFILE_TYPE {
3359  AUDIO_CODEC_PROFILE_LC_AAC = 0,
3363  AUDIO_CODEC_PROFILE_HE_AAC = 1,
3367  AUDIO_CODEC_PROFILE_HE_AAC_V2 = 2,
3368 };
3369 
3374 {
3394  unsigned short txPacketLossRate;
3411 };
3412 
3413 
3417 enum RTMP_STREAM_PUBLISH_STATE {
3421  RTMP_STREAM_PUBLISH_STATE_IDLE = 0,
3425  RTMP_STREAM_PUBLISH_STATE_CONNECTING = 1,
3429  RTMP_STREAM_PUBLISH_STATE_RUNNING = 2,
3435  RTMP_STREAM_PUBLISH_STATE_RECOVERING = 3,
3439  RTMP_STREAM_PUBLISH_STATE_FAILURE = 4,
3443  RTMP_STREAM_PUBLISH_STATE_DISCONNECTING = 5,
3444 };
3445 
3449 enum RTMP_STREAM_PUBLISH_REASON {
3453  RTMP_STREAM_PUBLISH_REASON_OK = 0,
3458  RTMP_STREAM_PUBLISH_REASON_INVALID_ARGUMENT = 1,
3462  RTMP_STREAM_PUBLISH_REASON_ENCRYPTED_STREAM_NOT_ALLOWED = 2,
3466  RTMP_STREAM_PUBLISH_REASON_CONNECTION_TIMEOUT = 3,
3470  RTMP_STREAM_PUBLISH_REASON_INTERNAL_SERVER_ERROR = 4,
3474  RTMP_STREAM_PUBLISH_REASON_RTMP_SERVER_ERROR = 5,
3478  RTMP_STREAM_PUBLISH_REASON_TOO_OFTEN = 6,
3482  RTMP_STREAM_PUBLISH_REASON_REACH_LIMIT = 7,
3486  RTMP_STREAM_PUBLISH_REASON_NOT_AUTHORIZED = 8,
3490  RTMP_STREAM_PUBLISH_REASON_STREAM_NOT_FOUND = 9,
3494  RTMP_STREAM_PUBLISH_REASON_FORMAT_NOT_SUPPORTED = 10,
3498  RTMP_STREAM_PUBLISH_REASON_NOT_BROADCASTER = 11, // Note: match to ERR_PUBLISH_STREAM_NOT_BROADCASTER in AgoraBase.h
3502  RTMP_STREAM_PUBLISH_REASON_TRANSCODING_NO_MIX_STREAM = 13, // Note: match to ERR_PUBLISH_STREAM_TRANSCODING_NO_MIX_STREAM in AgoraBase.h
3506  RTMP_STREAM_PUBLISH_REASON_NET_DOWN = 14, // Note: match to ERR_NET_DOWN in AgoraBase.h
3510  RTMP_STREAM_PUBLISH_REASON_INVALID_APPID = 15, // Note: match to ERR_PUBLISH_STREAM_APPID_INVALID in AgoraBase.h
3512  RTMP_STREAM_PUBLISH_REASON_INVALID_PRIVILEGE = 16,
3516  RTMP_STREAM_UNPUBLISH_REASON_OK = 100,
3517 };
3518 
3520 enum RTMP_STREAMING_EVENT {
3524  RTMP_STREAMING_EVENT_FAILED_LOAD_IMAGE = 1,
3528  RTMP_STREAMING_EVENT_URL_ALREADY_IN_USE = 2,
3532  RTMP_STREAMING_EVENT_ADVANCED_FEATURE_NOT_SUPPORT = 3,
3536  RTMP_STREAMING_EVENT_REQUEST_TOO_OFTEN = 4,
3537 };
3538 
3542 typedef struct RtcImage {
3546  const char* url;
3550  int x;
3554  int y;
3558  int width;
3562  int height;
3570  int zOrder;
3576  double alpha;
3577 
3578  RtcImage() : url(OPTIONAL_NULLPTR), x(0), y(0), width(0), height(0), zOrder(0), alpha(1.0) {}
3579 } RtcImage;
3586  LiveStreamAdvancedFeature() : featureName(OPTIONAL_NULLPTR), opened(false) {}
3587  LiveStreamAdvancedFeature(const char* feat_name, bool open) : featureName(feat_name), opened(open) {}
3589  // static const char* LBHQ = "lbhq";
3591  // static const char* VEO = "veo";
3592 
3596  const char* featureName;
3597 
3603  bool opened;
3604 } ;
3605 
3609 enum CONNECTION_STATE_TYPE
3610 {
3616  CONNECTION_STATE_DISCONNECTED = 1,
3625  CONNECTION_STATE_CONNECTING = 2,
3633  CONNECTION_STATE_CONNECTED = 3,
3643  CONNECTION_STATE_RECONNECTING = 4,
3652  CONNECTION_STATE_FAILED = 5,
3653 };
3654 
3662  uid_t uid;
3666  int x;
3670  int y;
3674  int width;
3678  int height;
3686  int zOrder;
3692  double alpha;
3706 
3707  TranscodingUser()
3708  : uid(0),
3709  x(0),
3710  y(0),
3711  width(0),
3712  height(0),
3713  zOrder(0),
3714  alpha(1.0),
3715  audioChannel(0) {}
3716 };
3717 
3728  int width;
3735  int height;
3746 
3753 
3761  VIDEO_CODEC_PROFILE_TYPE videoCodecProfile;
3764  unsigned int backgroundColor;
3766  VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType;
3770  unsigned int userCount;
3779 
3782  const char* metadata;
3791  unsigned int watermarkCount;
3792 
3801  unsigned int backgroundImageCount;
3802 
3805  AUDIO_SAMPLE_RATE_TYPE audioSampleRate;
3819  AUDIO_CODEC_PROFILE_TYPE audioCodecProfile;
3823 
3825  unsigned int advancedFeatureCount;
3826 
3827  LiveTranscoding()
3828  : width(360),
3829  height(640),
3830  videoBitrate(400),
3831  videoFramerate(15),
3832  lowLatency(false),
3833  videoGop(30),
3834  videoCodecProfile(VIDEO_CODEC_PROFILE_HIGH),
3835  backgroundColor(0x000000),
3836  videoCodecType(VIDEO_CODEC_H264_FOR_STREAM),
3837  userCount(0),
3838  transcodingUsers(OPTIONAL_NULLPTR),
3839  transcodingExtraInfo(OPTIONAL_NULLPTR),
3840  metadata(OPTIONAL_NULLPTR),
3841  watermark(OPTIONAL_NULLPTR),
3842  watermarkCount(0),
3843  backgroundImage(OPTIONAL_NULLPTR),
3845  audioSampleRate(AUDIO_SAMPLE_RATE_48000),
3846  audioBitrate(48),
3847  audioChannels(1),
3848  audioCodecProfile(AUDIO_CODEC_PROFILE_LC_AAC),
3849  advancedFeatures(OPTIONAL_NULLPTR),
3850  advancedFeatureCount(0) {}
3851 };
3852 
3860  VIDEO_SOURCE_TYPE sourceType;
3870  const char* imageUrl;
3878  int x;
3882  int y;
3886  int width;
3890  int height;
3896  int zOrder;
3900  double alpha;
3907  bool mirror;
3908 
3910  : sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
3911  remoteUserUid(0),
3912  imageUrl(OPTIONAL_NULLPTR),
3913  x(0),
3914  y(0),
3915  width(0),
3916  height(0),
3917  zOrder(0),
3918  alpha(1.0),
3919  mirror(false) {}
3920 };
3921 
3929  unsigned int streamCount;
3944 
3946 };
3947 
3948 enum VIDEO_TRANSCODER_ERROR {
3952  VT_ERR_VIDEO_SOURCE_NOT_READY = 1,
3956  VT_ERR_INVALID_VIDEO_SOURCE_TYPE = 2,
3960  VT_ERR_INVALID_IMAGE_PATH = 3,
3964  VT_ERR_UNSUPPORT_IMAGE_FORMAT = 4,
3968  VT_ERR_INVALID_LAYOUT = 5,
3972  VT_ERR_INTERNAL = 20
3973 };
3974 
4001 };
4002 
4006 enum LASTMILE_PROBE_RESULT_STATE {
4010  LASTMILE_PROBE_RESULT_COMPLETE = 1,
4014  LASTMILE_PROBE_RESULT_INCOMPLETE_NO_BWE = 2,
4018  LASTMILE_PROBE_RESULT_UNAVAILABLE = 3
4019 };
4020 
4028  unsigned int packetLossRate;
4032  unsigned int jitter;
4036  unsigned int availableBandwidth;
4037 
4039  jitter(0),
4040  availableBandwidth(0) {}
4041 };
4042 
4050  LASTMILE_PROBE_RESULT_STATE state;
4062  unsigned int rtt;
4063 
4065  : state(LASTMILE_PROBE_RESULT_UNAVAILABLE),
4066  rtt(0) {}
4067 };
4068 
4072 enum CONNECTION_CHANGED_REASON_TYPE
4073 {
4077  CONNECTION_CHANGED_CONNECTING = 0,
4081  CONNECTION_CHANGED_JOIN_SUCCESS = 1,
4085  CONNECTION_CHANGED_INTERRUPTED = 2,
4089  CONNECTION_CHANGED_BANNED_BY_SERVER = 3,
4093  CONNECTION_CHANGED_JOIN_FAILED = 4,
4097  CONNECTION_CHANGED_LEAVE_CHANNEL = 5,
4101  CONNECTION_CHANGED_INVALID_APP_ID = 6,
4105  CONNECTION_CHANGED_INVALID_CHANNEL_NAME = 7,
4111  CONNECTION_CHANGED_INVALID_TOKEN = 8,
4115  CONNECTION_CHANGED_TOKEN_EXPIRED = 9,
4121  CONNECTION_CHANGED_REJECTED_BY_SERVER = 10,
4125  CONNECTION_CHANGED_SETTING_PROXY_SERVER = 11,
4129  CONNECTION_CHANGED_RENEW_TOKEN = 12,
4133  CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED = 13,
4137  CONNECTION_CHANGED_KEEP_ALIVE_TIMEOUT = 14,
4141  CONNECTION_CHANGED_REJOIN_SUCCESS = 15,
4145  CONNECTION_CHANGED_LOST = 16,
4149  CONNECTION_CHANGED_ECHO_TEST = 17,
4153  CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED_BY_USER = 18,
4157  CONNECTION_CHANGED_SAME_UID_LOGIN = 19,
4161  CONNECTION_CHANGED_TOO_MANY_BROADCASTERS = 20,
4162 
4166  CONNECTION_CHANGED_LICENSE_VALIDATION_FAILURE = 21,
4167  /*
4168  * 22: The connection is failed due to certification verify failure.
4169  */
4170  CONNECTION_CHANGED_CERTIFICATION_VERYFY_FAILURE = 22,
4174  CONNECTION_CHANGED_STREAM_CHANNEL_NOT_AVAILABLE = 23,
4178  CONNECTION_CHANGED_INCONSISTENT_APPID = 24,
4179 };
4180 
4184 enum CLIENT_ROLE_CHANGE_FAILED_REASON {
4188  CLIENT_ROLE_CHANGE_FAILED_TOO_MANY_BROADCASTERS = 1,
4192  CLIENT_ROLE_CHANGE_FAILED_NOT_AUTHORIZED = 2,
4196  CLIENT_ROLE_CHANGE_FAILED_REQUEST_TIME_OUT = 3,
4200  CLIENT_ROLE_CHANGE_FAILED_CONNECTION_FAILED = 4,
4201 };
4202 
4206 enum WLACC_MESSAGE_REASON {
4210  WLACC_MESSAGE_REASON_WEAK_SIGNAL = 0,
4214  WLACC_MESSAGE_REASON_CHANNEL_CONGESTION = 1,
4215 };
4216 
4220 enum WLACC_SUGGEST_ACTION {
4224  WLACC_SUGGEST_ACTION_CLOSE_TO_WIFI = 0,
4228  WLACC_SUGGEST_ACTION_CONNECT_SSID = 1,
4232  WLACC_SUGGEST_ACTION_CHECK_5G = 2,
4236  WLACC_SUGGEST_ACTION_MODIFY_SSID = 3,
4237 };
4238 
4242 struct WlAccStats {
4246  unsigned short e2eDelayPercent;
4250  unsigned short frozenRatioPercent;
4254  unsigned short lossRatePercent;
4255 };
4256 
4260 enum NETWORK_TYPE {
4264  NETWORK_TYPE_UNKNOWN = -1,
4268  NETWORK_TYPE_DISCONNECTED = 0,
4272  NETWORK_TYPE_LAN = 1,
4276  NETWORK_TYPE_WIFI = 2,
4280  NETWORK_TYPE_MOBILE_2G = 3,
4284  NETWORK_TYPE_MOBILE_3G = 4,
4288  NETWORK_TYPE_MOBILE_4G = 5,
4292  NETWORK_TYPE_MOBILE_5G = 6,
4293 };
4294 
4298 enum VIDEO_VIEW_SETUP_MODE {
4302  VIDEO_VIEW_SETUP_REPLACE = 0,
4306  VIDEO_VIEW_SETUP_ADD = 1,
4310  VIDEO_VIEW_SETUP_REMOVE = 2,
4311 };
4312 
4316 struct VideoCanvas {
4320  uid_t uid;
4321 
4325  uid_t subviewUid;
4329  view_t view;
4338  media::base::RENDER_MODE_TYPE renderMode;
4348  VIDEO_MIRROR_MODE_TYPE mirrorMode;
4353  VIDEO_VIEW_SETUP_MODE setupMode;
4358  VIDEO_SOURCE_TYPE sourceType;
4381  media::base::VIDEO_MODULE_POSITION position;
4382 
4383  VideoCanvas()
4384  : uid(0), subviewUid(0), view(NULL), backgroundColor(0x00000000), renderMode(media::base::RENDER_MODE_HIDDEN), mirrorMode(VIDEO_MIRROR_MODE_AUTO),
4385  setupMode(VIDEO_VIEW_SETUP_REPLACE), sourceType(VIDEO_SOURCE_CAMERA_PRIMARY), mediaPlayerId(-ERR_NOT_READY),
4386  cropArea(0, 0, 0, 0), enableAlphaMask(false), position(media::base::POSITION_POST_CAPTURER) {}
4387 
4388  VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt)
4389  : uid(0), subviewUid(0), view(v), backgroundColor(0x00000000), renderMode(m), mirrorMode(mt), setupMode(VIDEO_VIEW_SETUP_REPLACE),
4390  sourceType(VIDEO_SOURCE_CAMERA_PRIMARY), mediaPlayerId(-ERR_NOT_READY),
4391  cropArea(0, 0, 0, 0), enableAlphaMask(false), position(media::base::POSITION_POST_CAPTURER) {}
4392 
4393  VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u)
4394  : uid(u), subviewUid(0), view(v), backgroundColor(0x00000000), renderMode(m), mirrorMode(mt), setupMode(VIDEO_VIEW_SETUP_REPLACE),
4395  sourceType(VIDEO_SOURCE_CAMERA_PRIMARY), mediaPlayerId(-ERR_NOT_READY),
4396  cropArea(0, 0, 0, 0), enableAlphaMask(false), position(media::base::POSITION_POST_CAPTURER) {}
4397 
4398  VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u, uid_t subu)
4399  : uid(u), subviewUid(subu), view(v), backgroundColor(0x00000000), renderMode(m), mirrorMode(mt), setupMode(VIDEO_VIEW_SETUP_REPLACE),
4400  sourceType(VIDEO_SOURCE_CAMERA_PRIMARY), mediaPlayerId(-ERR_NOT_READY),
4401  cropArea(0, 0, 0, 0), enableAlphaMask(false), position(media::base::POSITION_POST_CAPTURER) {}
4402 };
4403 
4416  };
4417 
4421 
4424 
4428 
4432 
4436 
4437  BeautyOptions(LIGHTENING_CONTRAST_LEVEL contrastLevel, float lightening, float smoothness, float redness, float sharpness) : lighteningContrastLevel(contrastLevel), lighteningLevel(lightening), smoothnessLevel(smoothness), rednessLevel(redness), sharpnessLevel(sharpness) {}
4438 
4440 };
4441 
4451  };
4464  };
4465 
4469 
4473 
4474  LowlightEnhanceOptions(LOW_LIGHT_ENHANCE_MODE lowlightMode, LOW_LIGHT_ENHANCE_LEVEL lowlightLevel) : mode(lowlightMode), level(lowlightLevel) {}
4475 
4477 };
4491  };
4512  };
4516 
4520 
4521  VideoDenoiserOptions(VIDEO_DENOISER_MODE denoiserMode, VIDEO_DENOISER_LEVEL denoiserLevel) : mode(denoiserMode), level(denoiserLevel) {}
4522 
4524 };
4525 
4534 
4540 
4541  ColorEnhanceOptions(float stength, float skinProtect) : strengthLevel(stength), skinProtectLevel(skinProtect) {}
4542 
4544 };
4545 
4573  };
4574 
4584  };
4585 
4589 
4598  unsigned int color;
4599 
4606  const char* source;
4607 
4612 
4614 };
4615 
4617 
4618  enum SEG_MODEL_TYPE {
4619 
4620  SEG_MODEL_AI = 1,
4621  SEG_MODEL_GREEN = 2
4622  };
4623 
4624  SEG_MODEL_TYPE modelType;
4625 
4626  float greenCapacity;
4627 
4628 
4629  SegmentationProperty() : modelType(SEG_MODEL_AI), greenCapacity(0.5){}
4630 };
4631 
4634 enum AUDIO_TRACK_TYPE {
4638  AUDIO_TRACK_INVALID = -1,
4645  AUDIO_TRACK_MIXABLE = 0,
4651  AUDIO_TRACK_DIRECT = 1,
4652 };
4653 
4663 
4665  : enableLocalPlayback(true) {}
4666 };
4667 
4688 enum VOICE_BEAUTIFIER_PRESET {
4691  VOICE_BEAUTIFIER_OFF = 0x00000000,
4697  CHAT_BEAUTIFIER_MAGNETIC = 0x01010100,
4703  CHAT_BEAUTIFIER_FRESH = 0x01010200,
4709  CHAT_BEAUTIFIER_VITALITY = 0x01010300,
4718  SINGING_BEAUTIFIER = 0x01020100,
4721  TIMBRE_TRANSFORMATION_VIGOROUS = 0x01030100,
4724  TIMBRE_TRANSFORMATION_DEEP = 0x01030200,
4727  TIMBRE_TRANSFORMATION_MELLOW = 0x01030300,
4730  TIMBRE_TRANSFORMATION_FALSETTO = 0x01030400,
4733  TIMBRE_TRANSFORMATION_FULL = 0x01030500,
4736  TIMBRE_TRANSFORMATION_CLEAR = 0x01030600,
4739  TIMBRE_TRANSFORMATION_RESOUNDING = 0x01030700,
4742  TIMBRE_TRANSFORMATION_RINGING = 0x01030800,
4752  ULTRA_HIGH_QUALITY_VOICE = 0x01040100
4753 };
4754 
4775 enum AUDIO_EFFECT_PRESET {
4778  AUDIO_EFFECT_OFF = 0x00000000,
4781  ROOM_ACOUSTICS_KTV = 0x02010100,
4784  ROOM_ACOUSTICS_VOCAL_CONCERT = 0x02010200,
4787  ROOM_ACOUSTICS_STUDIO = 0x02010300,
4790  ROOM_ACOUSTICS_PHONOGRAPH = 0x02010400,
4797  ROOM_ACOUSTICS_VIRTUAL_STEREO = 0x02010500,
4800  ROOM_ACOUSTICS_SPACIAL = 0x02010600,
4803  ROOM_ACOUSTICS_ETHEREAL = 0x02010700,
4815  ROOM_ACOUSTICS_3D_VOICE = 0x02010800,
4826  ROOM_ACOUSTICS_VIRTUAL_SURROUND_SOUND = 0x02010900,
4834  ROOM_ACOUSTICS_CHORUS = 0x02010D00,
4841  VOICE_CHANGER_EFFECT_UNCLE = 0x02020100,
4847  VOICE_CHANGER_EFFECT_OLDMAN = 0x02020200,
4853  VOICE_CHANGER_EFFECT_BOY = 0x02020300,
4860  VOICE_CHANGER_EFFECT_SISTER = 0x02020400,
4866  VOICE_CHANGER_EFFECT_GIRL = 0x02020500,
4870  VOICE_CHANGER_EFFECT_PIGKING = 0x02020600,
4873  VOICE_CHANGER_EFFECT_HULK = 0x02020700,
4880  STYLE_TRANSFORMATION_RNB = 0x02030100,
4887  STYLE_TRANSFORMATION_POPULAR = 0x02030200,
4892  PITCH_CORRECTION = 0x02040100,
4893 
4897 };
4898 
4901 enum VOICE_CONVERSION_PRESET {
4904  VOICE_CONVERSION_OFF = 0x00000000,
4907  VOICE_CHANGER_NEUTRAL = 0x03010100,
4910  VOICE_CHANGER_SWEET = 0x03010200,
4913  VOICE_CHANGER_SOLID = 0x03010300,
4916  VOICE_CHANGER_BASS = 0x03010400,
4919  VOICE_CHANGER_CARTOON = 0x03010500,
4922  VOICE_CHANGER_CHILDLIKE = 0x03010600,
4925  VOICE_CHANGER_PHONE_OPERATOR = 0x03010700,
4928  VOICE_CHANGER_MONSTER = 0x03010800,
4931  VOICE_CHANGER_TRANSFORMERS = 0x03010900,
4934  VOICE_CHANGER_GROOT = 0x03010A00,
4937  VOICE_CHANGER_DARTH_VADER = 0x03010B00,
4940  VOICE_CHANGER_IRON_LADY = 0x03010C00,
4943  VOICE_CHANGER_SHIN_CHAN = 0x03010D00,
4946  VOICE_CHANGER_GIRLISH_MAN = 0x03010E00,
4949  VOICE_CHANGER_CHIPMUNK = 0x03010F00,
4950 
4951 };
4952 
4955 enum HEADPHONE_EQUALIZER_PRESET {
4958  HEADPHONE_EQUALIZER_OFF = 0x00000000,
4961  HEADPHONE_EQUALIZER_OVEREAR = 0x04000001,
4964  HEADPHONE_EQUALIZER_INEAR = 0x04000002
4965 };
4966 
4996  int bitrate;
5019 
5027  unsigned int highLightColor;
5036 
5038  : dimensions(1920, 1080), frameRate(5), bitrate(STANDARD_BITRATE), captureMouseCursor(true), windowFocus(false), excludeWindowList(OPTIONAL_NULLPTR), excludeWindowCount(0), highLightWidth(0), highLightColor(0), enableHighLight(false) {}
5039  ScreenCaptureParameters(const VideoDimensions& d, int f, int b)
5041  ScreenCaptureParameters(int width, int height, int f, int b)
5042  : dimensions(width, height), frameRate(f), bitrate(b), captureMouseCursor(true), windowFocus(false), excludeWindowList(OPTIONAL_NULLPTR), excludeWindowCount(0), highLightWidth(0), highLightColor(0), enableHighLight(false){}
5043  ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs)
5044  : dimensions(width, height), frameRate(f), bitrate(b), captureMouseCursor(cur), windowFocus(fcs), excludeWindowList(OPTIONAL_NULLPTR), excludeWindowCount(0), highLightWidth(0), highLightColor(0), enableHighLight(false) {}
5045  ScreenCaptureParameters(int width, int height, int f, int b, view_t *ex, int cnt)
5047  ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs, view_t *ex, int cnt)
5049 };
5050 
5054 enum AUDIO_RECORDING_QUALITY_TYPE {
5058  AUDIO_RECORDING_QUALITY_LOW = 0,
5062  AUDIO_RECORDING_QUALITY_MEDIUM = 1,
5066  AUDIO_RECORDING_QUALITY_HIGH = 2,
5070  AUDIO_RECORDING_QUALITY_ULTRA_HIGH = 3,
5071 };
5072 
5076 enum AUDIO_FILE_RECORDING_TYPE {
5080  AUDIO_FILE_RECORDING_MIC = 1,
5084  AUDIO_FILE_RECORDING_PLAYBACK = 2,
5088  AUDIO_FILE_RECORDING_MIXED = 3,
5089 };
5090 
5094 enum AUDIO_ENCODED_FRAME_OBSERVER_POSITION {
5098  AUDIO_ENCODED_FRAME_OBSERVER_POSITION_RECORD = 1,
5102  AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK = 2,
5106  AUDIO_ENCODED_FRAME_OBSERVER_POSITION_MIXED = 3,
5107 };
5108 
5117  const char* filePath;
5123  bool encode;
5137  AUDIO_FILE_RECORDING_TYPE fileRecordingType;
5142  AUDIO_RECORDING_QUALITY_TYPE quality;
5143 
5150 
5152  : filePath(OPTIONAL_NULLPTR),
5153  encode(false),
5154  sampleRate(32000),
5155  fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
5156  quality(AUDIO_RECORDING_QUALITY_LOW),
5157  recordingChannel(1) {}
5158 
5159  AudioRecordingConfiguration(const char* file_path, int sample_rate, AUDIO_RECORDING_QUALITY_TYPE quality_type, int channel)
5160  : filePath(file_path),
5161  encode(false),
5162  sampleRate(sample_rate),
5163  fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
5164  quality(quality_type),
5165  recordingChannel(channel) {}
5166 
5167  AudioRecordingConfiguration(const char* file_path, bool enc, int sample_rate, AUDIO_FILE_RECORDING_TYPE type, AUDIO_RECORDING_QUALITY_TYPE quality_type, int channel)
5168  : filePath(file_path),
5169  encode(enc),
5170  sampleRate(sample_rate),
5171  fileRecordingType(type),
5172  quality(quality_type),
5173  recordingChannel(channel) {}
5174 
5175  AudioRecordingConfiguration(const AudioRecordingConfiguration &rhs)
5176  : filePath(rhs.filePath),
5177  encode(rhs.encode),
5178  sampleRate(rhs.sampleRate),
5180  quality(rhs.quality),
5182 };
5183 
5191  AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType;
5195  AUDIO_ENCODING_TYPE encodingType;
5196 
5198  : postionType(AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK),
5199  encodingType(AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM){}
5200 
5201 };
5206 public:
5217 virtual void onRecordAudioEncodedFrame(const uint8_t* frameBuffer, int length, const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
5218 
5229 virtual void onPlaybackAudioEncodedFrame(const uint8_t* frameBuffer, int length, const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
5230 
5241 virtual void onMixedAudioEncodedFrame(const uint8_t* frameBuffer, int length, const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
5242 
5243 virtual ~IAudioEncodedFrameObserver () {}
5244 };
5245 
5248 enum AREA_CODE {
5252  AREA_CODE_CN = 0x00000001,
5256  AREA_CODE_NA = 0x00000002,
5260  AREA_CODE_EU = 0x00000004,
5264  AREA_CODE_AS = 0x00000008,
5268  AREA_CODE_JP = 0x00000010,
5272  AREA_CODE_IN = 0x00000020,
5276  AREA_CODE_GLOB = (0xFFFFFFFF)
5277 };
5278 
5279 enum AREA_CODE_EX {
5283  AREA_CODE_OC = 0x00000040,
5287  AREA_CODE_SA = 0x00000080,
5291  AREA_CODE_AF = 0x00000100,
5295  AREA_CODE_KR = 0x00000200,
5299  AREA_CODE_HKMC = 0x00000400,
5303  AREA_CODE_US = 0x00000800,
5307  AREA_CODE_OVS = 0xFFFFFFFE
5308 };
5309 
5313 enum CHANNEL_MEDIA_RELAY_ERROR {
5316  RELAY_OK = 0,
5319  RELAY_ERROR_SERVER_ERROR_RESPONSE = 1,
5325  RELAY_ERROR_SERVER_NO_RESPONSE = 2,
5328  RELAY_ERROR_NO_RESOURCE_AVAILABLE = 3,
5331  RELAY_ERROR_FAILED_JOIN_SRC = 4,
5334  RELAY_ERROR_FAILED_JOIN_DEST = 5,
5337  RELAY_ERROR_FAILED_PACKET_RECEIVED_FROM_SRC = 6,
5340  RELAY_ERROR_FAILED_PACKET_SENT_TO_DEST = 7,
5344  RELAY_ERROR_SERVER_CONNECTION_LOST = 8,
5347  RELAY_ERROR_INTERNAL_ERROR = 9,
5350  RELAY_ERROR_SRC_TOKEN_EXPIRED = 10,
5353  RELAY_ERROR_DEST_TOKEN_EXPIRED = 11,
5354 };
5355 
5359 enum CHANNEL_MEDIA_RELAY_STATE {
5363  RELAY_STATE_IDLE = 0,
5366  RELAY_STATE_CONNECTING = 1,
5369  RELAY_STATE_RUNNING = 2,
5372  RELAY_STATE_FAILURE = 3,
5373 };
5374 
5380  uid_t uid;
5384  const char* channelName;
5388  const char* token;
5389 
5390  ChannelMediaInfo() : uid(0), channelName(NULL), token(NULL) {}
5391  ChannelMediaInfo(const char* c, const char* t, uid_t u) : uid(u), channelName(c), token(t) {}
5392 };
5393 
5430 
5431  ChannelMediaRelayConfiguration() : srcInfo(OPTIONAL_NULLPTR), destInfos(OPTIONAL_NULLPTR), destCount(0) {}
5432 };
5433 
5442 
5444 
5445  bool operator==(const UplinkNetworkInfo& rhs) const {
5447  }
5448 };
5449 
5455  const char* userId;
5459  VIDEO_STREAM_TYPE stream_type;
5463  REMOTE_VIDEO_DOWNSCALE_LEVEL current_downscale_level;
5468 
5470  : userId(OPTIONAL_NULLPTR),
5471  stream_type(VIDEO_STREAM_HIGH),
5472  current_downscale_level(REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE),
5473  expected_bitrate_bps(-1) {}
5474 
5476  : stream_type(rhs.stream_type),
5479  if (rhs.userId != OPTIONAL_NULLPTR) {
5480  const int len = std::strlen(rhs.userId);
5481  char* buf = new char[len + 1];
5482  std::memcpy(buf, rhs.userId, len);
5483  buf[len] = '\0';
5484  userId = buf;
5485  }
5486  }
5487 
5488  PeerDownlinkInfo& operator=(const PeerDownlinkInfo& rhs) {
5489  if (this == &rhs) return *this;
5490  userId = OPTIONAL_NULLPTR;
5491  stream_type = rhs.stream_type;
5492  current_downscale_level = rhs.current_downscale_level;
5493  expected_bitrate_bps = rhs.expected_bitrate_bps;
5494  if (rhs.userId != OPTIONAL_NULLPTR) {
5495  const int len = std::strlen(rhs.userId);
5496  char* buf = new char[len + 1];
5497  std::memcpy(buf, rhs.userId, len);
5498  buf[len] = '\0';
5499  userId = buf;
5500  }
5501  return *this;
5502  }
5503 
5504  ~PeerDownlinkInfo() { delete[] userId; }
5505  };
5506 
5527 
5532  peer_downlink_info(OPTIONAL_NULLPTR),
5534 
5539  peer_downlink_info(OPTIONAL_NULLPTR),
5541  if (total_received_video_count <= 0) return;
5542  peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
5543  for (int i = 0; i < total_received_video_count; ++i)
5545  }
5546 
5547  DownlinkNetworkInfo& operator=(const DownlinkNetworkInfo& rhs) {
5548  if (this == &rhs) return *this;
5549  lastmile_buffer_delay_time_ms = rhs.lastmile_buffer_delay_time_ms;
5550  bandwidth_estimation_bps = rhs.bandwidth_estimation_bps;
5551  total_downscale_level_count = rhs.total_downscale_level_count;
5552  peer_downlink_info = OPTIONAL_NULLPTR;
5553  total_received_video_count = rhs.total_received_video_count;
5554  if (total_received_video_count > 0) {
5555  peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
5556  for (int i = 0; i < total_received_video_count; ++i)
5557  peer_downlink_info[i] = rhs.peer_downlink_info[i];
5558  }
5559  return *this;
5560  }
5561 
5562  ~DownlinkNetworkInfo() { delete[] peer_downlink_info; }
5563 };
5564 
5571 enum ENCRYPTION_MODE {
5574  AES_128_XTS = 1,
5577  AES_128_ECB = 2,
5580  AES_256_XTS = 3,
5583  SM4_128_ECB = 4,
5586  AES_128_GCM = 5,
5589  AES_256_GCM = 6,
5593  AES_128_GCM2 = 7,
5596  AES_256_GCM2 = 8,
5599  MODE_END,
5600 };
5601 
5608  ENCRYPTION_MODE encryptionMode;
5614  const char* encryptionKey;
5621  uint8_t encryptionKdfSalt[32];
5622 
5623  bool datastreamEncryptionEnabled;
5624 
5626  : encryptionMode(AES_128_GCM2),
5627  encryptionKey(OPTIONAL_NULLPTR),
5628  datastreamEncryptionEnabled(false)
5629  {
5630  memset(encryptionKdfSalt, 0, sizeof(encryptionKdfSalt));
5631  }
5632 
5634  const char* getEncryptionString() const {
5635  switch(encryptionMode) {
5636  case AES_128_XTS:
5637  return "aes-128-xts";
5638  case AES_128_ECB:
5639  return "aes-128-ecb";
5640  case AES_256_XTS:
5641  return "aes-256-xts";
5642  case SM4_128_ECB:
5643  return "sm4-128-ecb";
5644  case AES_128_GCM:
5645  return "aes-128-gcm";
5646  case AES_256_GCM:
5647  return "aes-256-gcm";
5648  case AES_128_GCM2:
5649  return "aes-128-gcm-2";
5650  case AES_256_GCM2:
5651  return "aes-256-gcm-2";
5652  default:
5653  return "aes-128-gcm-2";
5654  }
5655  return "aes-128-gcm-2";
5656  }
5658 };
5659 
5662 enum ENCRYPTION_ERROR_TYPE {
5666  ENCRYPTION_ERROR_INTERNAL_FAILURE = 0,
5670  ENCRYPTION_ERROR_DECRYPTION_FAILURE = 1,
5674  ENCRYPTION_ERROR_ENCRYPTION_FAILURE = 2,
5678  ENCRYPTION_ERROR_DATASTREAM_DECRYPTION_FAILURE = 3,
5682  ENCRYPTION_ERROR_DATASTREAM_ENCRYPTION_FAILURE = 4,
5683 };
5684 
5685 enum UPLOAD_ERROR_REASON
5686 {
5687  UPLOAD_SUCCESS = 0,
5688  UPLOAD_NET_ERROR = 1,
5689  UPLOAD_SERVER_ERROR = 2,
5690 };
5691 
5694 enum PERMISSION_TYPE {
5698  RECORD_AUDIO = 0,
5702  CAMERA = 1,
5703 
5704  SCREEN_CAPTURE = 2,
5705 };
5706 
5710 enum STREAM_SUBSCRIBE_STATE {
5714  SUB_STATE_IDLE = 0,
5727  SUB_STATE_NO_SUBSCRIBED = 1,
5731  SUB_STATE_SUBSCRIBING = 2,
5735  SUB_STATE_SUBSCRIBED = 3
5736 };
5737 
5741 enum STREAM_PUBLISH_STATE {
5745  PUB_STATE_IDLE = 0,
5753  PUB_STATE_NO_PUBLISHED = 1,
5757  PUB_STATE_PUBLISHING = 2,
5761  PUB_STATE_PUBLISHED = 3
5762 };
5763 
5768  view_t view;
5769  bool enableAudio;
5770  bool enableVideo;
5771  const char* token;
5772  const char* channelId;
5773  int intervalInSeconds;
5774 
5775  EchoTestConfiguration(view_t v, bool ea, bool ev, const char* t, const char* c, const int is)
5776  : view(v), enableAudio(ea), enableVideo(ev), token(t), channelId(c), intervalInSeconds(is) {}
5777 
5779  : view(OPTIONAL_NULLPTR), enableAudio(true), enableVideo(true), token(OPTIONAL_NULLPTR), channelId(OPTIONAL_NULLPTR), intervalInSeconds(2) {}
5780 };
5781 
5785 struct UserInfo {
5789  uid_t uid;
5793  char userAccount[MAX_USER_ACCOUNT_LENGTH];
5794 
5795  UserInfo() : uid(0) {
5796  userAccount[0] = '\0';
5797  }
5798 };
5799 
5803 enum EAR_MONITORING_FILTER_TYPE {
5807  EAR_MONITORING_FILTER_NONE = (1<<0),
5812  EAR_MONITORING_FILTER_BUILT_IN_AUDIO_FILTERS = (1<<1),
5816  EAR_MONITORING_FILTER_NOISE_SUPPRESSION = (1<<2),
5821  EAR_MONITORING_FILTER_REUSE_POST_PROCESSING_FILTER = (1<<15),
5822 };
5823 
5827 enum THREAD_PRIORITY_TYPE {
5831  LOWEST = 0,
5835  LOW = 1,
5839  NORMAL = 2,
5843  HIGH = 3,
5847  HIGHEST = 4,
5851  CRITICAL = 5,
5852 };
5853 
5854 #if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS)
5855 
5859 struct ScreenVideoParameters {
5886  VideoDimensions dimensions;
5892  int frameRate = 15;
5897  int bitrate;
5898  /*
5899  * The content hint of the screen sharing:
5900  */
5901  VIDEO_CONTENT_HINT contentHint = VIDEO_CONTENT_HINT::CONTENT_HINT_MOTION;
5902 
5903  ScreenVideoParameters() : dimensions(1280, 720) {}
5904 };
5905 
5909 struct ScreenAudioParameters {
5913  int sampleRate = 16000;
5917  int channels = 2;
5922  int captureSignalVolume = 100;
5923 };
5924 
5928 struct ScreenCaptureParameters2 {
5938  bool captureAudio = false;
5942  ScreenAudioParameters audioParams;
5952  bool captureVideo = true;
5956  ScreenVideoParameters videoParams;
5957 };
5958 #endif
5959 
5963 enum MEDIA_TRACE_EVENT {
5967  MEDIA_TRACE_EVENT_VIDEO_RENDERED = 0,
5971  MEDIA_TRACE_EVENT_VIDEO_DECODED,
5972 };
5973 
6027 };
6028 
6029 enum CONFIG_FETCH_TYPE {
6033  CONFIG_FETCH_TYPE_INITIALIZE = 1,
6037  CONFIG_FETCH_TYPE_JOIN_CHANNEL = 2,
6038 };
6039 
6040 
6042 enum LOCAL_PROXY_MODE {
6045  ConnectivityFirst = 0,
6048  LocalOnly = 1,
6049 };
6050 
6054  const char* serverDomain;
6057  const char* serverPath;
6066 
6067  LogUploadServerInfo() : serverDomain(NULL), serverPath(NULL), serverPort(0), serverHttps(true) {}
6068 
6069  LogUploadServerInfo(const char* domain, const char* path, int port, bool https) : serverDomain(domain), serverPath(path), serverPort(port), serverHttps(https) {}
6070 };
6071 
6076 };
6077 
6081  const char** ipList;
6087  const char** domainList;
6094  const char* verifyDomainName;
6097  LOCAL_PROXY_MODE mode;
6107  LocalAccessPointConfiguration() : ipList(NULL), ipListSize(0), domainList(NULL), domainListSize(0), verifyDomainName(NULL), mode(ConnectivityFirst), disableAut(true) {}
6108 };
6109 
6114  const char* channelId;
6118  uid_t uid;
6122  RecorderStreamInfo() : channelId(NULL), uid(0) {}
6123  RecorderStreamInfo(const char* channelId, uid_t uid) : channelId(channelId), uid(uid) {}
6124 };
6125 } // namespace rtc
6126 
6127 namespace base {
6128 
6130  public:
6131  virtual int queryInterface(rtc::INTERFACE_ID_TYPE iid, void** inter) = 0;
6132  virtual ~IEngineBase() {}
6133 };
6134 
6135 class AParameter : public agora::util::AutoPtr<IAgoraParameter> {
6136  public:
6137  AParameter(IEngineBase& engine) { initialize(&engine); }
6138  AParameter(IEngineBase* engine) { initialize(engine); }
6140 
6141  private:
6142  bool initialize(IEngineBase* engine) {
6143  IAgoraParameter* p = OPTIONAL_NULLPTR;
6144  if (engine && !engine->queryInterface(rtc::AGORA_IID_PARAMETER_ENGINE, (void**)&p)) reset(p);
6145  return p != OPTIONAL_NULLPTR;
6146  }
6147 };
6148 
6150  public:
6151  virtual ~LicenseCallback() {}
6152  virtual void onCertificateRequired() = 0;
6153  virtual void onLicenseRequest() = 0;
6154  virtual void onLicenseValidated() = 0;
6155  virtual void onLicenseError(int result) = 0;
6156 };
6157 
6158 } // namespace base
6159 
6196 };
6201 {
6205  const char* channelId;
6209  rtc::uid_t uid;
6213  user_id_t strUid;
6217  uint32_t x;
6221  uint32_t y;
6225  uint32_t width;
6229  uint32_t height;
6234  uint32_t videoState;
6235 
6236  VideoLayout() : channelId(OPTIONAL_NULLPTR), uid(0), strUid(OPTIONAL_NULLPTR), x(0), y(0), width(0), height(0), videoState(0) {}
6237 };
6238 } // namespace agora
6239 
6245 AGORA_API const char* AGORA_CALL getAgoraSdkVersion(int* build);
6246 
6252 AGORA_API const char* AGORA_CALL getAgoraSdkErrorDescription(int err);
6253 
6254 AGORA_API int AGORA_CALL setAgoraSdkExternalSymbolLoader(void* (*func)(const char* symname));
6255 
6263 AGORA_API int AGORA_CALL createAgoraCredential(agora::util::AString &credential);
6264 
6278 AGORA_API int AGORA_CALL getAgoraCertificateVerifyResult(const char *credential_buf, int credential_len,
6279  const char *certificate_buf, int certificate_len);
6280 
6288 AGORA_API void setAgoraLicenseCallback(agora::base::LicenseCallback *callback);
6289 
6297 AGORA_API agora::base::LicenseCallback* getAgoraLicenseCallback();
6298 
6299 /*
6300  * Get monotonic time in ms which can be used by capture time,
6301  * typical scenario is as follows:
6302  *
6303  * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
6304  * | // custom audio/video base capture time, e.g. the first audio/video capture time. |
6305  * | int64_t custom_capture_time_base; |
6306  * | |
6307  * | int64_t agora_monotonic_time = getAgoraCurrentMonotonicTimeInMs(); |
6308  * | |
6309  * | // offset is fixed once calculated in the begining. |
6310  * | const int64_t offset = agora_monotonic_time - custom_capture_time_base; |
6311  * | |
6312  * | // realtime_custom_audio/video_capture_time is the origin capture time that customer provided.|
6313  * | // actual_audio/video_capture_time is the actual capture time transfered to sdk. |
6314  * | int64_t actual_audio_capture_time = realtime_custom_audio_capture_time + offset; |
6315  * | int64_t actual_video_capture_time = realtime_custom_video_capture_time + offset; |
6316  * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
6317  *
6318  * @return
6319  * - >= 0: Success.
6320  * - < 0: Failure.
6321  */
6322 AGORA_API int64_t AGORA_CALL getAgoraCurrentMonotonicTimeInMs();
agora::rtc::LiveTranscoding::transcodingUsers
TranscodingUser * transcodingUsers
Definition: AgoraBase.h:3773
agora::rtc::LogUploadServerInfo::serverDomain
const char * serverDomain
Definition: AgoraBase.h:6054
agora::rtc::IPacketObserver::onReceiveVideoPacket
virtual bool onReceiveVideoPacket(Packet &packet)=0
agora::rtc::VideoCanvas::mediaPlayerId
int mediaPlayerId
Definition: AgoraBase.h:4364
agora::rtc::RtcImage::width
int width
Definition: AgoraBase.h:3558
agora::rtc::TranscodingVideoStream::zOrder
int zOrder
Definition: AgoraBase.h:3896
agora::rtc::RtcStats::firstAudioPacketDuration
int firstAudioPacketDuration
Definition: AgoraBase.h:2248
agora::VideoLayout
Definition: AgoraBase.h:6201
agora::VideoLayout::channelId
const char * channelId
Definition: AgoraBase.h:6205
agora::rtc::UserInfo
Definition: AgoraBase.h:5785
agora::rtc::TranscodingVideoStream::alpha
double alpha
Definition: AgoraBase.h:3900
agora::rtc::EncodedAudioFrameInfo::captureTimeMs
int64_t captureTimeMs
Definition: AgoraBase.h:1491
agora::rtc::VideoEncoderConfiguration::degradationPreference
DEGRADATION_PREFERENCE degradationPreference
Definition: AgoraBase.h:1907
agora::rtc::LastmileProbeResult
Definition: AgoraBase.h:4046
agora::rtc::AudioEncodedFrameObserverConfig
Definition: AgoraBase.h:5187
agora::rtc::ScreenCaptureParameters
Definition: AgoraBase.h:4970
agora::VideoLayout::x
uint32_t x
Definition: AgoraBase.h:6217
agora::rtc::WatermarkRatio
Definition: AgoraBase.h:2076
agora::rtc::AudioVolumeInfo
Definition: AgoraBase.h:3197
agora::rtc::VirtualBackgroundSource::BACKGROUND_BLUR_DEGREE
BACKGROUND_BLUR_DEGREE
Definition: AgoraBase.h:4577
agora::rtc::LastmileProbeResult::uplinkReport
LastmileProbeOneWayResult uplinkReport
Definition: AgoraBase.h:4054
agora::rtc::EncodedVideoFrameInfo::rotation
VIDEO_ORIENTATION rotation
Definition: AgoraBase.h:1661
agora::rtc::AdvancedConfigInfo::logUploadServer
LogUploadServerInfo logUploadServer
Definition: AgoraBase.h:6075
agora::rtc::BeautyOptions
Definition: AgoraBase.h:4406
agora::rtc::SenderOptions
Definition: AgoraBase.h:1228
agora::rtc::ScreenCaptureParameters::bitrate
int bitrate
Definition: AgoraBase.h:4996
agora::rtc::BeautyOptions::lighteningLevel
float lighteningLevel
Definition: AgoraBase.h:4423
agora::rtc::RtcStats::txVideoBytes
unsigned int txVideoBytes
Definition: AgoraBase.h:2160
agora::rtc::VirtualBackgroundSource::BACKGROUND_BLUR
@ BACKGROUND_BLUR
Definition: AgoraBase.h:4568
agora::rtc::LiveTranscoding::backgroundColor
unsigned int backgroundColor
Definition: AgoraBase.h:3764
agora::base::IAgoraParameter
Definition: IAgoraParameter.h:148
agora::rtc::AudioVolumeInfo::voicePitch
double voicePitch
Definition: AgoraBase.h:3226
agora::rtc::LastmileProbeConfig
Definition: AgoraBase.h:3978
agora::rtc::TranscodingUser::y
int y
Definition: AgoraBase.h:3670
agora::rtc::ScreenCaptureParameters::highLightWidth
int highLightWidth
Definition: AgoraBase.h:5023
agora::rtc::RtcStats::rxKBitRate
unsigned short rxKBitRate
Definition: AgoraBase.h:2176
agora::rtc::RtcStats::memoryTotalUsageRatio
double memoryTotalUsageRatio
Definition: AgoraBase.h:2233
agora::rtc::LocalAudioStats::txPacketLossRate
unsigned short txPacketLossRate
Definition: AgoraBase.h:3394
agora::rtc::VideoFormat::fps
int fps
Definition: AgoraBase.h:2555
agora::SpatialAudioParams::speaker_elevation
Optional< double > speaker_elevation
Definition: AgoraBase.h:6171
agora::rtc::VideoEncoderConfiguration::minBitrate
int minBitrate
Definition: AgoraBase.h:1899
agora::rtc::ScreenCaptureParameters::enableHighLight
bool enableHighLight
Definition: AgoraBase.h:5035
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_AUTO
@ VIDEO_DENOISER_AUTO
Definition: AgoraBase.h:4488
agora::rtc::VideoCanvas::setupMode
VIDEO_VIEW_SETUP_MODE setupMode
Definition: AgoraBase.h:4353
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY
@ LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY
Definition: AgoraBase.h:4459
agora::rtc::TranscodingUser::audioChannel
int audioChannel
Definition: AgoraBase.h:3705
agora::rtc::RtcStats::firstAudioPacketDurationAfterUnmute
int firstAudioPacketDurationAfterUnmute
Definition: AgoraBase.h:2268
agora::rtc::VideoFormat::width
int width
Definition: AgoraBase.h:2547
agora::rtc::ScreenCaptureParameters::windowFocus
bool windowFocus
Definition: AgoraBase.h:5007
agora::rtc::AudioEncodedFrameObserverConfig::encodingType
AUDIO_ENCODING_TYPE encodingType
Definition: AgoraBase.h:5195
agora::rtc::SenderOptions::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1236
agora::rtc::EncodedAudioFrameInfo::codec
AUDIO_CODEC_TYPE codec
Definition: AgoraBase.h:1468
agora::rtc::LiveTranscoding::videoGop
int videoGop
Definition: AgoraBase.h:3756
agora::rtc::ChannelMediaRelayConfiguration::destCount
int destCount
Definition: AgoraBase.h:5429
agora::rtc::LocalAudioStats::audioDeviceDelay
int audioDeviceDelay
Definition: AgoraBase.h:3398
agora::rtc::LastmileProbeOneWayResult::jitter
unsigned int jitter
Definition: AgoraBase.h:4032
agora::rtc::BeautyOptions::smoothnessLevel
float smoothnessLevel
Definition: AgoraBase.h:4427
agora::rtc::VideoDenoiserOptions::level
VIDEO_DENOISER_LEVEL level
Definition: AgoraBase.h:4519
agora::rtc::VideoCanvas::mirrorMode
VIDEO_MIRROR_MODE_TYPE mirrorMode
Definition: AgoraBase.h:4348
agora::rtc::RtcStats::duration
unsigned int duration
Definition: AgoraBase.h:2144
agora::rtc::SimulcastStreamConfig::framerate
int framerate
Definition: AgoraBase.h:2035
agora::rtc::VideoDimensions::height
int height
Definition: AgoraBase.h:1089
agora::rtc::LocalAccessPointConfiguration::mode
LOCAL_PROXY_MODE mode
Definition: AgoraBase.h:6097
agora::rtc::LastmileProbeConfig::probeUplink
bool probeUplink
Definition: AgoraBase.h:3985
agora::rtc::LocalAccessPointConfiguration
Definition: AgoraBase.h:6078
agora::rtc::LiveTranscoding::videoCodecType
VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType
Definition: AgoraBase.h:3766
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_MODE
VIDEO_DENOISER_MODE
Definition: AgoraBase.h:4486
agora::rtc::LiveTranscoding
Definition: AgoraBase.h:3721
agora::rtc::RtcStats::txBytes
unsigned int txBytes
Definition: AgoraBase.h:2148
agora::rtc::VideoFormat::height
int height
Definition: AgoraBase.h:2551
agora::rtc::Rectangle
Definition: AgoraBase.h:2046
agora::rtc::LocalAccessPointConfiguration::ipList
const char ** ipList
Definition: AgoraBase.h:6081
agora::rtc::VideoCanvas::uid
uid_t uid
Definition: AgoraBase.h:4320
agora::rtc::RtcStats::firstVideoPacketDuration
int firstVideoPacketDuration
Definition: AgoraBase.h:2253
agora::rtc::AudioRecordingConfiguration::filePath
const char * filePath
Definition: AgoraBase.h:5117
agora::rtc::EncodedVideoFrameInfo
Definition: AgoraBase.h:1586
agora::rtc::ColorEnhanceOptions::strengthLevel
float strengthLevel
Definition: AgoraBase.h:4533
agora::SpatialAudioParams::speaker_distance
Optional< double > speaker_distance
Definition: AgoraBase.h:6175
agora::rtc::VirtualBackgroundSource::BACKGROUND_NONE
@ BACKGROUND_NONE
Definition: AgoraBase.h:4556
agora::rtc::BeautyOptions::rednessLevel
float rednessLevel
Definition: AgoraBase.h:4431
agora::rtc::RtcStats::rxVideoBytes
unsigned int rxVideoBytes
Definition: AgoraBase.h:2168
agora::rtc::TranscodingVideoStream::remoteUserUid
uid_t remoteUserUid
Definition: AgoraBase.h:3865
agora::rtc::VideoEncoderConfiguration::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:1821
agora::rtc::EncodedVideoFrameInfo::uid
uid_t uid
Definition: AgoraBase.h:1635
agora::rtc::EncodedAudioFrameInfo
Definition: AgoraBase.h:1450
agora::util::AutoPtr
Definition: AgoraBase.h:94
agora::rtc::LastmileProbeOneWayResult::packetLossRate
unsigned int packetLossRate
Definition: AgoraBase.h:4028
agora::UserInfo::hasAudio
bool hasAudio
Definition: AgoraBase.h:817
agora::rtc::ScreenCaptureParameters::excludeWindowCount
int excludeWindowCount
Definition: AgoraBase.h:5018
agora::rtc::IPacketObserver::Packet
Definition: AgoraBase.h:3254
agora::rtc::AudioTrackConfig::enableLocalPlayback
bool enableLocalPlayback
Definition: AgoraBase.h:4662
agora::rtc::LiveTranscoding::audioCodecProfile
AUDIO_CODEC_PROFILE_TYPE audioCodecProfile
Definition: AgoraBase.h:3819
agora::rtc::RecorderStreamInfo::uid
uid_t uid
Definition: AgoraBase.h:6118
agora::rtc::VideoEncoderConfiguration
Definition: AgoraBase.h:1813
agora::rtc::Rectangle::width
int width
Definition: AgoraBase.h:2058
agora::rtc::VideoEncoderConfiguration::bitrate
int bitrate
Definition: AgoraBase.h:1882
agora::rtc::VideoRenderingTracingInfo::remoteJoined2UnmuteVideo
int remoteJoined2UnmuteVideo
Definition: AgoraBase.h:6017
agora::util::AList
Definition: AgoraBase.h:227
agora::rtc::RtcStats::firstVideoKeyFrameDecodedDurationAfterUnmute
int firstVideoKeyFrameDecodedDurationAfterUnmute
Definition: AgoraBase.h:2283
agora::rtc::VideoSubscriptionOptions
Definition: AgoraBase.h:1555
agora::rtc::TranscodingUser
Definition: AgoraBase.h:3658
agora::rtc::EchoTestConfiguration
Definition: AgoraBase.h:5767
agora::rtc::RtcImage
Definition: AgoraBase.h:3542
agora::rtc::TranscodingUser::x
int x
Definition: AgoraBase.h:3666
agora::rtc::ChannelMediaInfo::token
const char * token
Definition: AgoraBase.h:5388
agora::rtc::VideoRenderingTracingInfo::remoteJoined2PacketReceived
int remoteJoined2PacketReceived
Definition: AgoraBase.h:6026
agora::rtc::AudioRecordingConfiguration::encode
bool encode
Definition: AgoraBase.h:5123
agora::rtc::BeautyOptions::lighteningContrastLevel
LIGHTENING_CONTRAST_LEVEL lighteningContrastLevel
Definition: AgoraBase.h:4420
agora::rtc::WatermarkRatio::yRatio
float yRatio
Definition: AgoraBase.h:2088
agora::SpatialAudioParams::enable_blur
Optional< bool > enable_blur
Definition: AgoraBase.h:6183
agora::rtc::SimulcastStreamConfig
Definition: AgoraBase.h:2023
agora::rtc::LiveTranscoding::audioBitrate
int audioBitrate
Definition: AgoraBase.h:3808
agora::rtc::ChannelMediaRelayConfiguration::destInfos
ChannelMediaInfo * destInfos
Definition: AgoraBase.h:5424
agora::rtc::RtcImage::x
int x
Definition: AgoraBase.h:3550
agora::rtc::VirtualBackgroundSource::background_source_type
BACKGROUND_SOURCE_TYPE background_source_type
Definition: AgoraBase.h:4588
agora::rtc::TranscodingVideoStream::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:3860
agora::rtc::LocalTranscoderConfiguration::syncWithPrimaryCamera
bool syncWithPrimaryCamera
Definition: AgoraBase.h:3943
agora::rtc::RtcImage::zOrder
int zOrder
Definition: AgoraBase.h:3570
agora::rtc::ClientRoleOptions::audienceLatencyLevel
AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel
Definition: AgoraBase.h:2389
agora::rtc::AudioVolumeInfo::volume
unsigned int volume
Definition: AgoraBase.h:3210
agora::rtc::TranscodingUser::uid
uid_t uid
Definition: AgoraBase.h:3662
agora::rtc::VideoCanvas::enableAlphaMask
bool enableAlphaMask
Definition: AgoraBase.h:4376
agora::rtc::VideoRenderingTracingInfo::elapsedTime
int elapsedTime
Definition: AgoraBase.h:5981
agora::rtc::LiveStreamAdvancedFeature::featureName
const char * featureName
Definition: AgoraBase.h:3596
agora::rtc::AdvancedConfigInfo
Definition: AgoraBase.h:6072
agora::rtc::Rectangle::y
int y
Definition: AgoraBase.h:2054
agora::rtc::LocalAudioStats::sentBitrate
int sentBitrate
Definition: AgoraBase.h:3386
agora::rtc::RtcImage::url
const char * url
Definition: AgoraBase.h:3546
agora::rtc::IPacketObserver::Packet::buffer
const unsigned char * buffer
Definition: AgoraBase.h:3260
agora::rtc::EncodedVideoFrameInfo::decodeTimeMs
int64_t decodeTimeMs
Definition: AgoraBase.h:1674
agora::rtc::RtcStats::firstVideoKeyFrameRenderedDurationAfterUnmute
int firstVideoKeyFrameRenderedDurationAfterUnmute
Definition: AgoraBase.h:2288
agora::rtc::ColorEnhanceOptions
Definition: AgoraBase.h:4530
agora::rtc::AudioRecordingConfiguration::sampleRate
int sampleRate
Definition: AgoraBase.h:5133
agora::UserInfo::userId
util::AString userId
Definition: AgoraBase.h:811
agora::rtc::WatermarkOptions::positionInPortraitMode
Rectangle positionInPortraitMode
Definition: AgoraBase.h:2119
agora::rtc::LocalAccessPointConfiguration::advancedConfig
AdvancedConfigInfo advancedConfig
Definition: AgoraBase.h:6100
agora::rtc::LastmileProbeResult::downlinkReport
LastmileProbeOneWayResult downlinkReport
Definition: AgoraBase.h:4058
agora::rtc::LiveTranscoding::watermarkCount
unsigned int watermarkCount
Definition: AgoraBase.h:3791
agora::rtc::Rectangle::x
int x
Definition: AgoraBase.h:2050
agora::rtc::LocalTranscoderConfiguration::videoInputStreams
TranscodingVideoStream * videoInputStreams
Definition: AgoraBase.h:3933
agora::util::IString
Definition: AgoraBase.h:166
agora::rtc::LocalAccessPointConfiguration::verifyDomainName
const char * verifyDomainName
Definition: AgoraBase.h:6094
agora::SpatialAudioParams::enable_air_absorb
Optional< bool > enable_air_absorb
Definition: AgoraBase.h:6187
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_LEVEL
LOW_LIGHT_ENHANCE_LEVEL
Definition: AgoraBase.h:4455
agora::rtc::EncodedAudioFrameInfo::advancedSettings
EncodedAudioFrameAdvancedSettings advancedSettings
Definition: AgoraBase.h:1486
agora::rtc::LocalTranscoderConfiguration
Definition: AgoraBase.h:3925
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_LEVEL
LIGHTENING_CONTRAST_LEVEL
Definition: AgoraBase.h:4409
agora::rtc::WatermarkRatio::xRatio
float xRatio
Definition: AgoraBase.h:2082
agora::rtc::LocalAudioStats::sentSampleRate
int sentSampleRate
Definition: AgoraBase.h:3382
agora::rtc::VideoSubscriptionOptions::type
Optional< VIDEO_STREAM_TYPE > type
Definition: AgoraBase.h:1562
agora::rtc::LastmileProbeConfig::expectedDownlinkBitrate
unsigned int expectedDownlinkBitrate
Definition: AgoraBase.h:4000
agora::rtc::RtcStats::cpuTotalUsage
double cpuTotalUsage
Definition: AgoraBase.h:2217
agora::rtc::IPacketObserver::Packet::size
unsigned int size
Definition: AgoraBase.h:3264
agora::rtc::LiveTranscoding::advancedFeatures
LiveStreamAdvancedFeature * advancedFeatures
Definition: AgoraBase.h:3822
agora::rtc::LiveTranscoding::backgroundImageCount
unsigned int backgroundImageCount
Definition: AgoraBase.h:3801
agora::rtc::IPacketObserver
Definition: AgoraBase.h:3248
agora::rtc::LiveTranscoding::backgroundImage
RtcImage * backgroundImage
Definition: AgoraBase.h:3797
agora::rtc::RtcStats::cpuAppUsage
double cpuAppUsage
Definition: AgoraBase.h:2207
agora::VideoLayout::width
uint32_t width
Definition: AgoraBase.h:6225
agora::rtc::VideoFormat
Definition: AgoraBase.h:2534
agora::rtc::AdvanceOptions
Definition: AgoraBase.h:1719
agora::rtc::TranscodingUser::alpha
double alpha
Definition: AgoraBase.h:3692
agora::rtc::WatermarkOptions::watermarkRatio
WatermarkRatio watermarkRatio
Definition: AgoraBase.h:2124
agora::rtc::DataStreamConfig
Definition: AgoraBase.h:1979
agora::rtc::AdvanceOptions::compressionPreference
COMPRESSION_PREFERENCE compressionPreference
Definition: AgoraBase.h:1729
agora::rtc::RtcStats::txAudioBytes
unsigned int txAudioBytes
Definition: AgoraBase.h:2156
agora::rtc::RtcStats::connectTimeMs
int connectTimeMs
Definition: AgoraBase.h:2243
agora::rtc::LastmileProbeResult::state
LASTMILE_PROBE_RESULT_STATE state
Definition: AgoraBase.h:4050
agora::rtc::VideoEncoderConfiguration::advanceOptions
AdvanceOptions advanceOptions
Definition: AgoraBase.h:1918
agora::rtc::VideoCanvas::position
media::base::VIDEO_MODULE_POSITION position
Definition: AgoraBase.h:4381
agora::rtc::ChannelMediaInfo::channelName
const char * channelName
Definition: AgoraBase.h:5384
agora::rtc::LiveTranscoding::height
int height
Definition: AgoraBase.h:3735
agora::rtc::EncodedAudioFrameAdvancedSettings::speech
bool speech
Definition: AgoraBase.h:1438
agora::rtc::EncodedVideoFrameInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1639
agora::rtc::RtcStats::txVideoKBitRate
unsigned short txVideoKBitRate
Definition: AgoraBase.h:2192
agora::rtc::RtcStats::rxAudioBytes
unsigned int rxAudioBytes
Definition: AgoraBase.h:2164
agora::rtc::EncodedAudioFrameAdvancedSettings::sendEvenIfEmpty
bool sendEvenIfEmpty
Definition: AgoraBase.h:1444
agora::SpatialAudioParams::enable_doppler
Optional< bool > enable_doppler
Definition: AgoraBase.h:6195
agora::rtc::RtcStats::txAudioKBitRate
unsigned short txAudioKBitRate
Definition: AgoraBase.h:2184
agora::VideoLayout::height
uint32_t height
Definition: AgoraBase.h:6229
agora::rtc::AudioVolumeInfo::uid
uid_t uid
Definition: AgoraBase.h:3204
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_LOW
@ LIGHTENING_CONTRAST_LOW
Definition: AgoraBase.h:4411
agora::rtc::LiveTranscoding::videoBitrate
int videoBitrate
Definition: AgoraBase.h:3740
agora::rtc::VideoTrackInfo::trackId
track_id_t trackId
Definition: AgoraBase.h:3143
agora::rtc::VideoTrackInfo::encodedFrameOnly
bool encodedFrameOnly
Definition: AgoraBase.h:3157
agora::rtc::TranscodingUser::width
int width
Definition: AgoraBase.h:3674
agora::rtc::ScreenCaptureParameters::highLightColor
unsigned int highLightColor
Definition: AgoraBase.h:5027
agora::base::AParameter
Definition: AgoraBase.h:6135
agora::rtc::BeautyOptions::sharpnessLevel
float sharpnessLevel
Definition: AgoraBase.h:4435
agora::rtc::EncryptionConfig::encryptionMode
ENCRYPTION_MODE encryptionMode
Definition: AgoraBase.h:5608
agora::util::AOutputIterator
Definition: AgoraBase.h:196
agora::rtc::WatermarkOptions::positionInLandscapeMode
Rectangle positionInLandscapeMode
Definition: AgoraBase.h:2114
agora::rtc::IAudioEncodedFrameObserver
Definition: AgoraBase.h:5205
agora::rtc::EncodedVideoFrameInfo::width
int width
Definition: AgoraBase.h:1643
agora::rtc::VideoTrackInfo::ownerUid
uid_t ownerUid
Definition: AgoraBase.h:3139
agora::rtc::VideoRenderingTracingInfo::join2JoinSuccess
int join2JoinSuccess
Definition: AgoraBase.h:5992
agora::rtc::LastmileProbeOneWayResult::availableBandwidth
unsigned int availableBandwidth
Definition: AgoraBase.h:4036
agora::rtc::EncodedVideoFrameInfo::captureTimeMs
int64_t captureTimeMs
Definition: AgoraBase.h:1670
agora::rtc::EncodedVideoFrameInfo::framesPerSecond
int framesPerSecond
Definition: AgoraBase.h:1653
agora::rtc::LiveTranscoding::transcodingExtraInfo
const char * transcodingExtraInfo
Definition: AgoraBase.h:3778
agora::rtc::VideoTrackInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:3151
agora::rtc::LiveTranscoding::metadata
const char * metadata
Definition: AgoraBase.h:3782
agora::rtc::LiveTranscoding::audioSampleRate
AUDIO_SAMPLE_RATE_TYPE audioSampleRate
Definition: AgoraBase.h:3805
agora::rtc::ChannelMediaRelayConfiguration
Definition: AgoraBase.h:5396
agora::rtc::VirtualBackgroundSource::blur_degree
BACKGROUND_BLUR_DEGREE blur_degree
Definition: AgoraBase.h:4611
agora::rtc::UserInfo::uid
uid_t uid
Definition: AgoraBase.h:5789
agora::rtc::DataStreamConfig::ordered
bool ordered
Definition: AgoraBase.h:1999
agora::rtc::LiveStreamAdvancedFeature
Definition: AgoraBase.h:3585
agora::rtc::VirtualBackgroundSource::color
unsigned int color
Definition: AgoraBase.h:4598
agora::rtc::LastmileProbeOneWayResult
Definition: AgoraBase.h:4024
agora::rtc::VideoDenoiserOptions
Definition: AgoraBase.h:4483
agora::rtc::WatermarkRatio::widthRatio
float widthRatio
Definition: AgoraBase.h:2094
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL_HIGH_QUALITY
@ VIDEO_DENOISER_LEVEL_HIGH_QUALITY
Definition: AgoraBase.h:4500
agora::rtc::VideoCanvas::cropArea
Rectangle cropArea
Definition: AgoraBase.h:4370
agora::rtc::AudioPcmDataInfo::samplesOut
size_t samplesOut
Definition: AgoraBase.h:1517
agora::rtc::VideoEncoderConfiguration::frameRate
int frameRate
Definition: AgoraBase.h:1825
agora::rtc::Rectangle::height
int height
Definition: AgoraBase.h:2062
agora::rtc::AudioPcmDataInfo::elapsedTimeMs
int64_t elapsedTimeMs
Definition: AgoraBase.h:1521
agora::rtc::WatermarkOptions::mode
WATERMARK_FIT_MODE mode
Definition: AgoraBase.h:2128
agora::rtc::EncodedAudioFrameInfo::sampleRateHz
int sampleRateHz
Definition: AgoraBase.h:1472
agora::UserInfo
Definition: AgoraBase.h:807
agora::rtc::RtcStats::txPacketLossRate
int txPacketLossRate
Definition: AgoraBase.h:2292
agora::rtc::VirtualBackgroundSource
Definition: AgoraBase.h:4549
agora::rtc::WlAccStats::frozenRatioPercent
unsigned short frozenRatioPercent
Definition: AgoraBase.h:4250
agora::rtc::LowlightEnhanceOptions::level
LOW_LIGHT_ENHANCE_LEVEL level
Definition: AgoraBase.h:4472
agora::rtc::VideoCanvas::view
view_t view
Definition: AgoraBase.h:4329
agora::rtc::TranscodingVideoStream::imageUrl
const char * imageUrl
Definition: AgoraBase.h:3870
agora::rtc::AudioEncodedFrameObserverConfig::postionType
AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType
Definition: AgoraBase.h:5191
agora::rtc::IPacketObserver::onSendAudioPacket
virtual bool onSendAudioPacket(Packet &packet)=0
agora::rtc::EncryptionConfig::encryptionKdfSalt
uint8_t encryptionKdfSalt[32]
Definition: AgoraBase.h:5621
agora::rtc::WlAccStats::lossRatePercent
unsigned short lossRatePercent
Definition: AgoraBase.h:4254
agora::rtc::VirtualBackgroundSource::BACKGROUND_IMG
@ BACKGROUND_IMG
Definition: AgoraBase.h:4564
agora::rtc::LiveTranscoding::watermark
RtcImage * watermark
Definition: AgoraBase.h:3787
agora::rtc::AudioVolumeInfo::vad
unsigned int vad
Definition: AgoraBase.h:3220
agora::rtc::ChannelMediaInfo
Definition: AgoraBase.h:5377
agora::UserInfo::hasVideo
bool hasVideo
Definition: AgoraBase.h:823
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_MANUAL
@ LOW_LIGHT_ENHANCE_MANUAL
Definition: AgoraBase.h:4450
agora::VideoLayout::y
uint32_t y
Definition: AgoraBase.h:6221
agora::rtc::WlAccStats
Definition: AgoraBase.h:4242
agora::rtc::RecorderStreamInfo::RecorderStreamInfo
RecorderStreamInfo()
Definition: AgoraBase.h:6122
agora::rtc::LocalAudioStats::aecEstimatedDelay
int aecEstimatedDelay
Definition: AgoraBase.h:3410
agora::rtc::VideoCanvas::renderMode
media::base::RENDER_MODE_TYPE renderMode
Definition: AgoraBase.h:4338
agora::SpatialAudioParams::speaker_orientation
Optional< int > speaker_orientation
Definition: AgoraBase.h:6179
agora::rtc::LocalAudioStats::earMonitorDelay
int earMonitorDelay
Definition: AgoraBase.h:3406
agora::rtc::VideoTrackInfo::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:3161
agora::rtc::RtcStats::txKBitRate
unsigned short txKBitRate
Definition: AgoraBase.h:2172
agora::rtc::EncodedAudioFrameInfo::numberOfChannels
int numberOfChannels
Definition: AgoraBase.h:1482
agora::rtc::EncodedVideoFrameInfo::streamType
VIDEO_STREAM_TYPE streamType
Definition: AgoraBase.h:1678
agora::rtc::LocalAudioStats::audioPlayoutDelay
int audioPlayoutDelay
Definition: AgoraBase.h:3402
agora::SpatialAudioParams::speaker_attenuation
Optional< double > speaker_attenuation
Definition: AgoraBase.h:6191
agora::rtc::VideoTrackInfo::observationPosition
uint32_t observationPosition
Definition: AgoraBase.h:3165
agora::VideoLayout::strUid
user_id_t strUid
Definition: AgoraBase.h:6213
agora::rtc::LogUploadServerInfo
Definition: AgoraBase.h:6051
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL
VIDEO_DENOISER_LEVEL
Definition: AgoraBase.h:4495
agora::rtc::VideoCanvas::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:4358
agora::rtc::CodecCapInfo
Definition: AgoraBase.h:1791
agora::rtc::ScreenCaptureParameters::frameRate
int frameRate
Definition: AgoraBase.h:4990
agora::rtc::AudioRecordingConfiguration::recordingChannel
int recordingChannel
Definition: AgoraBase.h:5149
agora::rtc::RtcStats::firstVideoKeyFramePacketDurationAfterUnmute
int firstVideoKeyFramePacketDurationAfterUnmute
Definition: AgoraBase.h:2278
agora::rtc::LiveTranscoding::audioChannels
int audioChannels
Definition: AgoraBase.h:3816
agora::rtc::RtcImage::height
int height
Definition: AgoraBase.h:3562
agora::rtc::SimulcastStreamConfig::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:2027
agora::rtc::EncodedVideoFrameInfo::frameType
VIDEO_FRAME_TYPE frameType
Definition: AgoraBase.h:1657
agora::rtc::LastmileProbeConfig::probeDownlink
bool probeDownlink
Definition: AgoraBase.h:3991
agora::rtc::RtcStats::userCount
unsigned int userCount
Definition: AgoraBase.h:2200
agora::rtc::LocalTranscoderConfiguration::streamCount
unsigned int streamCount
Definition: AgoraBase.h:3929
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_HIGH
@ LIGHTENING_CONTRAST_HIGH
Definition: AgoraBase.h:4415
agora::base::LicenseCallback
Definition: AgoraBase.h:6149
agora::rtc::EncryptionConfig
Definition: AgoraBase.h:5603
agora::rtc::LiveTranscoding::videoCodecProfile
VIDEO_CODEC_PROFILE_TYPE videoCodecProfile
Definition: AgoraBase.h:3761
agora::rtc::VirtualBackgroundSource::BACKGROUND_SOURCE_TYPE
BACKGROUND_SOURCE_TYPE
Definition: AgoraBase.h:4552
agora::rtc::VideoRenderingTracingInfo::start2JoinChannel
int start2JoinChannel
Definition: AgoraBase.h:5988
agora::rtc::VideoCanvas::backgroundColor
uint32_t backgroundColor
Definition: AgoraBase.h:4333
agora::rtc::LocalAccessPointConfiguration::disableAut
bool disableAut
Definition: AgoraBase.h:6106
agora::rtc::ScreenCaptureParameters::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:4984
agora::rtc::VideoDimensions::width
int width
Definition: AgoraBase.h:1085
agora::rtc::TranscodingVideoStream::x
int x
Definition: AgoraBase.h:3878
agora::rtc::LiveTranscoding::lowLatency
bool lowLatency
Definition: AgoraBase.h:3752
agora::rtc::TranscodingVideoStream
Definition: AgoraBase.h:3856
agora::rtc::VirtualBackgroundSource::source
const char * source
Definition: AgoraBase.h:4606
agora::rtc::LogUploadServerInfo::serverPath
const char * serverPath
Definition: AgoraBase.h:6057
agora::VideoLayout::videoState
uint32_t videoState
Definition: AgoraBase.h:6234
agora::rtc::RtcStats
Definition: AgoraBase.h:2140
agora::rtc::VideoSubscriptionOptions::encodedFrameOnly
Optional< bool > encodedFrameOnly
Definition: AgoraBase.h:1568
agora::rtc::IAudioEncodedFrameObserver::onRecordAudioEncodedFrame
virtual void onRecordAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
agora::rtc::VirtualBackgroundSource::BACKGROUND_VIDEO
@ BACKGROUND_VIDEO
Definition: AgoraBase.h:4572
agora::rtc::WatermarkOptions::visibleInPreview
bool visibleInPreview
Definition: AgoraBase.h:2109
agora::rtc::LowlightEnhanceOptions
Definition: AgoraBase.h:4442
agora::rtc::TranscodingUser::zOrder
int zOrder
Definition: AgoraBase.h:3686
agora::rtc::LiveTranscoding::width
int width
Definition: AgoraBase.h:3728
agora::rtc::AudioPcmDataInfo
Definition: AgoraBase.h:1496
agora::rtc::RtcStats::rxBytes
unsigned int rxBytes
Definition: AgoraBase.h:2152
agora::rtc::RtcStats::rxVideoKBitRate
unsigned short rxVideoKBitRate
Definition: AgoraBase.h:2188
agora::rtc::VideoDenoiserOptions::mode
VIDEO_DENOISER_MODE mode
Definition: AgoraBase.h:4515
agora::rtc::RtcStats::rxAudioKBitRate
unsigned short rxAudioKBitRate
Definition: AgoraBase.h:2180
agora::rtc::LocalAudioStats::numChannels
int numChannels
Definition: AgoraBase.h:3378
agora::rtc::VideoRenderingTracingInfo::remoteJoined2SetView
int remoteJoined2SetView
Definition: AgoraBase.h:6008
agora::rtc::WatermarkOptions
Definition: AgoraBase.h:2103
agora::rtc::VideoEncoderConfiguration::mirrorMode
VIDEO_MIRROR_MODE_TYPE mirrorMode
Definition: AgoraBase.h:1913
agora::rtc::LocalAudioStats
Definition: AgoraBase.h:3374
agora::rtc::RecorderStreamInfo
Definition: AgoraBase.h:6113
agora::rtc::LogUploadServerInfo::serverPort
int serverPort
Definition: AgoraBase.h:6060
agora::rtc::ScreenCaptureParameters::captureMouseCursor
bool captureMouseCursor
Definition: AgoraBase.h:5001
agora::rtc::RtcImage::y
int y
Definition: AgoraBase.h:3554
agora::rtc::FocalLengthInfo::focalLengthType
CAMERA_FOCAL_LENGTH_TYPE focalLengthType
Definition: AgoraBase.h:1807
agora::rtc::EncodedAudioFrameAdvancedSettings
Definition: AgoraBase.h:1428
agora::rtc::RtcStats::memoryAppUsageRatio
double memoryAppUsageRatio
Definition: AgoraBase.h:2228
agora::rtc::RtcStats::gatewayRtt
int gatewayRtt
Definition: AgoraBase.h:2223
agora::rtc::LastmileProbeConfig::expectedUplinkBitrate
unsigned int expectedUplinkBitrate
Definition: AgoraBase.h:3996
agora::rtc::VideoTrackInfo::isLocal
bool isLocal
Definition: AgoraBase.h:3135
agora::rtc::IAudioEncodedFrameObserver::onPlaybackAudioEncodedFrame
virtual void onPlaybackAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
agora::rtc::AdvanceOptions::encodingPreference
ENCODING_PREFERENCE encodingPreference
Definition: AgoraBase.h:1724
agora::rtc::VideoTrackInfo::channelId
const char * channelId
Definition: AgoraBase.h:3147
agora::rtc::IAudioEncodedFrameObserver::onMixedAudioEncodedFrame
virtual void onMixedAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_LEVEL_FAST
@ LOW_LIGHT_ENHANCE_LEVEL_FAST
Definition: AgoraBase.h:4463
agora::rtc::RtcStats::firstVideoKeyFramePacketDuration
int firstVideoKeyFramePacketDuration
Definition: AgoraBase.h:2258
agora::rtc::CodecCapInfo::codecLevels
CodecCapLevels codecLevels
Definition: AgoraBase.h:1797
agora::rtc::LiveTranscoding::advancedFeatureCount
unsigned int advancedFeatureCount
Definition: AgoraBase.h:3825
agora::rtc::CodecCapInfo::codecCapMask
int codecCapMask
Definition: AgoraBase.h:1795
agora::rtc::AudioRecordingConfiguration
Definition: AgoraBase.h:5112
agora::SpatialAudioParams::speaker_azimuth
Optional< double > speaker_azimuth
Definition: AgoraBase.h:6167
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_MODE
LOW_LIGHT_ENHANCE_MODE
Definition: AgoraBase.h:4446
agora::util::IContainer
Definition: AgoraBase.h:187
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_HIGH
@ BLUR_DEGREE_HIGH
Definition: AgoraBase.h:4583
agora::rtc::VideoDimensions
Definition: AgoraBase.h:1081
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_LOW
@ BLUR_DEGREE_LOW
Definition: AgoraBase.h:4579
agora::rtc::VideoRenderingTracingInfo::joinSuccess2RemoteJoined
int joinSuccess2RemoteJoined
Definition: AgoraBase.h:6000
agora::rtc::TranscodingVideoStream::height
int height
Definition: AgoraBase.h:3890
agora::rtc::DataStreamConfig::syncWithAudio
bool syncWithAudio
Definition: AgoraBase.h:1991
agora::rtc::LowlightEnhanceOptions::mode
LOW_LIGHT_ENHANCE_MODE mode
Definition: AgoraBase.h:4468
agora::rtc::LiveTranscoding::userCount
unsigned int userCount
Definition: AgoraBase.h:3770
agora::util::CopyableAutoPtr
Definition: AgoraBase.h:150
agora::rtc::CodecCapInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1793
agora::rtc::AudioTrackConfig
Definition: AgoraBase.h:4656
agora::rtc::FocalLengthInfo::cameraDirection
int cameraDirection
Definition: AgoraBase.h:1805
agora::rtc::LocalAccessPointConfiguration::ipListSize
int ipListSize
Definition: AgoraBase.h:6084
agora::rtc::TranscodingVideoStream::width
int width
Definition: AgoraBase.h:3886
agora::rtc::TranscodingVideoStream::mirror
bool mirror
Definition: AgoraBase.h:3907
agora::rtc::SimulcastStreamConfig::kBitrate
int kBitrate
Definition: AgoraBase.h:2031
agora::rtc::RtcImage::alpha
double alpha
Definition: AgoraBase.h:3576
agora::rtc::TranscodingVideoStream::mediaPlayerId
int mediaPlayerId
Definition: AgoraBase.h:3874
agora::rtc::VideoCanvas::subviewUid
uid_t subviewUid
Definition: AgoraBase.h:4325
agora::rtc::EncryptionConfig::encryptionKey
const char * encryptionKey
Definition: AgoraBase.h:5614
agora::rtc::EncodedVideoFrameInfo::trackId
int trackId
Definition: AgoraBase.h:1665
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_MEDIUM
@ BLUR_DEGREE_MEDIUM
Definition: AgoraBase.h:4581
agora::rtc::ScreenCaptureParameters::excludeWindowList
view_t * excludeWindowList
Definition: AgoraBase.h:5014
agora::rtc::LocalAccessPointConfiguration::domainList
const char ** domainList
Definition: AgoraBase.h:6087
agora::rtc::IPacketObserver::onSendVideoPacket
virtual bool onSendVideoPacket(Packet &packet)=0
agora::rtc::AudioPcmDataInfo::samplesPerChannel
size_t samplesPerChannel
Definition: AgoraBase.h:1509
agora::rtc::VideoTrackInfo
Definition: AgoraBase.h:3124
agora::rtc::LocalTranscoderConfiguration::videoOutputConfiguration
VideoEncoderConfiguration videoOutputConfiguration
Definition: AgoraBase.h:3937
agora::rtc::SenderOptions::ccMode
TCcMode ccMode
Definition: AgoraBase.h:1232
agora::rtc::VirtualBackgroundSource::BACKGROUND_COLOR
@ BACKGROUND_COLOR
Definition: AgoraBase.h:4560
agora::rtc::AudioPcmDataInfo::ntpTimeMs
int64_t ntpTimeMs
Definition: AgoraBase.h:1525
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_AUTO
@ LOW_LIGHT_ENHANCE_AUTO
Definition: AgoraBase.h:4448
agora::rtc::RtcStats::firstVideoPacketDurationAfterUnmute
int firstVideoPacketDurationAfterUnmute
Definition: AgoraBase.h:2273
agora::rtc::LiveTranscoding::videoFramerate
int videoFramerate
Definition: AgoraBase.h:3745
agora::rtc::RtcStats::rxPacketLossRate
int rxPacketLossRate
Definition: AgoraBase.h:2296
agora::rtc::RtcStats::lastmileDelay
unsigned short lastmileDelay
Definition: AgoraBase.h:2196
agora::rtc::CodecCapLevels
Definition: AgoraBase.h:1783
agora::SpatialAudioParams
Definition: AgoraBase.h:6163
agora::rtc::ColorEnhanceOptions::skinProtectLevel
float skinProtectLevel
Definition: AgoraBase.h:4539
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL_FAST
@ VIDEO_DENOISER_LEVEL_FAST
Definition: AgoraBase.h:4505
agora::rtc::VideoEncoderConfiguration::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1817
agora::rtc::LastmileProbeResult::rtt
unsigned int rtt
Definition: AgoraBase.h:4062
agora::rtc::TranscodingVideoStream::y
int y
Definition: AgoraBase.h:3882
agora::rtc::RtcStats::packetsBeforeFirstKeyFramePacket
int packetsBeforeFirstKeyFramePacket
Definition: AgoraBase.h:2263
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_NORMAL
@ LIGHTENING_CONTRAST_NORMAL
Definition: AgoraBase.h:4413
agora::rtc::ChannelMediaRelayConfiguration::srcInfo
ChannelMediaInfo * srcInfo
Definition: AgoraBase.h:5409
agora::rtc::VideoEncoderConfiguration::orientationMode
ORIENTATION_MODE orientationMode
Definition: AgoraBase.h:1903
agora::rtc::WlAccStats::e2eDelayPercent
unsigned short e2eDelayPercent
Definition: AgoraBase.h:4246
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL_STRENGTH
@ VIDEO_DENOISER_LEVEL_STRENGTH
Definition: AgoraBase.h:4511
agora::rtc::LiveStreamAdvancedFeature::opened
bool opened
Definition: AgoraBase.h:3603
agora::rtc::FocalLengthInfo
Definition: AgoraBase.h:1803
agora::rtc::DeviceInfo
Definition: AgoraBase.h:3234
agora::base::IEngineBase
Definition: AgoraBase.h:6129
agora::rtc::SenderOptions::targetBitrate
int targetBitrate
Definition: AgoraBase.h:1294
agora::rtc::AudioRecordingConfiguration::quality
AUDIO_RECORDING_QUALITY_TYPE quality
Definition: AgoraBase.h:5142
agora::util::IIterator
Definition: AgoraBase.h:178
agora::rtc::UserInfo::userAccount
char userAccount[MAX_USER_ACCOUNT_LENGTH]
Definition: AgoraBase.h:5793
agora::rtc::VideoRenderingTracingInfo
Definition: AgoraBase.h:5977
agora::rtc::LogUploadServerInfo::serverHttps
bool serverHttps
Definition: AgoraBase.h:6065
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_MANUAL
@ VIDEO_DENOISER_MANUAL
Definition: AgoraBase.h:4490
agora::rtc::EncodedAudioFrameInfo::samplesPerChannel
int samplesPerChannel
Definition: AgoraBase.h:1478
agora::rtc::EncodedVideoFrameInfo::height
int height
Definition: AgoraBase.h:1647
agora::rtc::RtcStats::memoryAppUsageInKbytes
int memoryAppUsageInKbytes
Definition: AgoraBase.h:2238
agora::VideoLayout::uid
rtc::uid_t uid
Definition: AgoraBase.h:6209
agora::Optional< VIDEO_STREAM_TYPE >
agora::rtc::LocalAccessPointConfiguration::domainListSize
int domainListSize
Definition: AgoraBase.h:6090
agora::rtc::ClientRoleOptions
Definition: AgoraBase.h:2385
agora::rtc::TranscodingUser::height
int height
Definition: AgoraBase.h:3678
agora::rtc::IPacketObserver::onReceiveAudioPacket
virtual bool onReceiveAudioPacket(Packet &packet)=0
agora::rtc::VideoCanvas
Definition: AgoraBase.h:4316
agora::rtc::LocalAudioStats::internalCodec
int internalCodec
Definition: AgoraBase.h:3390
agora::rtc::AudioRecordingConfiguration::fileRecordingType
AUDIO_FILE_RECORDING_TYPE fileRecordingType
Definition: AgoraBase.h:5137
agora::rtc::SegmentationProperty
Definition: AgoraBase.h:4616
agora::rtc::ChannelMediaInfo::uid
uid_t uid
Definition: AgoraBase.h:5380