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 #define AGORA_CPP_INTERNAL_API extern
47
48 #elif defined(__APPLE__)
49
50 #include <TargetConditionals.h>
51
52 #define AGORA_API extern "C" __attribute__((visibility("default")))
53 #define AGORA_CPP_API __attribute__((visibility("default")))
54 #define AGORA_CALL
55
56 #define AGORA_CPP_INTERNAL_API __attribute__((visibility("hidden")))
57
58 #elif defined(__ANDROID__) || defined(__linux__)
59
60 #define AGORA_API extern "C" __attribute__((visibility("default")))
61 #define AGORA_CPP_API __attribute__((visibility("default")))
62 #define AGORA_CALL
63
64 #define __deprecated
65
66 #define AGORA_CPP_INTERNAL_API __attribute__((visibility("hidden")))
67
68 #else // !_WIN32 && !__APPLE__ && !(__ANDROID__ || __linux__)
69
70 #define AGORA_API extern "C"
71 #define AGORA_CPP_API
72 #define AGORA_CALL
73
74 #define __deprecated
75
76 #endif // _WIN32
77
78 #ifndef OPTIONAL_ENUM_SIZE_T
79 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
80 #define OPTIONAL_ENUM_SIZE_T enum : size_t
81 #else
82 #define OPTIONAL_ENUM_SIZE_T enum
83 #endif
84 #endif
85
86 #ifndef OPTIONAL_NULLPTR
87 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
88 #define OPTIONAL_NULLPTR nullptr
89 #else
90 #define OPTIONAL_NULLPTR NULL
91 #endif
92 #endif
93
94 #define INVALID_DISPLAY_ID (-2)
95
96 namespace agora {
97 namespace util {
98
99 template <class T>
100 class AutoPtr {
101 protected:
102 typedef T value_type;
103 typedef T* pointer_type;
104
105 public:
106 explicit AutoPtr(pointer_type p = OPTIONAL_NULLPTR) : ptr_(p) {}
107
108 ~AutoPtr() {
109 if (ptr_) {
110 ptr_->release();
111 ptr_ = OPTIONAL_NULLPTR;
112 }
113 }
114
115 operator bool() const { return (ptr_ != OPTIONAL_NULLPTR); }
116
117 value_type& operator*() const { return *get(); }
118
119 pointer_type operator->() const { return get(); }
120
121 pointer_type get() const { return ptr_; }
122
123 pointer_type release() {
124 pointer_type ret = ptr_;
125 ptr_ = 0;
126 return ret;
127 }
128
129 void reset(pointer_type ptr = OPTIONAL_NULLPTR) {
130 if (ptr != ptr_ && ptr_) {
131 ptr_->release();
132 }
133
134 ptr_ = ptr;
135 }
136
137 template <class C1, class C2>
138 bool queryInterface(C1* c, C2 iid) {
139 pointer_type p = OPTIONAL_NULLPTR;
140 if (c && !c->queryInterface(iid, reinterpret_cast<void**>(&p))) {
141 reset(p);
142 }
143
144 return (p != OPTIONAL_NULLPTR);
145 }
146
147 private:
148 AutoPtr(const AutoPtr&);
149 AutoPtr& operator=(const AutoPtr&);
150
151 private:
152 pointer_type ptr_;
153 };
154
155 template <class T>
156 class CopyableAutoPtr : public AutoPtr<T> {
157 typedef typename AutoPtr<T>::pointer_type pointer_type;
158
159 public:
160 explicit CopyableAutoPtr(pointer_type p = 0) : AutoPtr<T>(p) {}
161 CopyableAutoPtr(const CopyableAutoPtr& rhs) { this->reset(rhs.clone()); }
162 CopyableAutoPtr& operator=(const CopyableAutoPtr& rhs) {
163 if (this != &rhs) this->reset(rhs.clone());
164 return *this;
165 }
166 pointer_type clone() const {
167 if (!this->get()) return OPTIONAL_NULLPTR;
168 return this->get()->clone();
169 }
170 };
171
172 class IString {
173 public:
174 virtual bool empty() const = 0;
175 virtual const char* c_str() = 0;
176 virtual const char* data() = 0;
177 virtual size_t length() = 0;
178 virtual IString* clone() = 0;
179 virtual void release() = 0;
180 virtual ~IString() {}
181 };
182 typedef CopyableAutoPtr<IString> AString;
183
184 class IIterator {
185 public:
186 virtual void* current() = 0;
187 virtual const void* const_current() const = 0;
188 virtual bool next() = 0;
189 virtual void release() = 0;
190 virtual ~IIterator() {}
191 };
192
193 class IContainer {
194 public:
195 virtual IIterator* begin() = 0;
196 virtual size_t size() const = 0;
197 virtual void release() = 0;
198 virtual ~IContainer() {}
199 };
200
201 template <class T>
202 class AOutputIterator {
203 IIterator* p;
204
205 public:
206 typedef T value_type;
207 typedef value_type& reference;
208 typedef const value_type& const_reference;
209 typedef value_type* pointer;
210 typedef const value_type* const_pointer;
211 explicit AOutputIterator(IIterator* it = OPTIONAL_NULLPTR) : p(it) {}
212 ~AOutputIterator() {
213 if (p) p->release();
214 }
215 AOutputIterator(const AOutputIterator& rhs) : p(rhs.p) {}
216 AOutputIterator& operator++() {
217 p->next();
218 return *this;
219 }
220 bool operator==(const AOutputIterator& rhs) const {
221 if (p && rhs.p)
222 return p->current() == rhs.p->current();
223 else
224 return valid() == rhs.valid();
225 }
226 bool operator!=(const AOutputIterator& rhs) const { return !this->operator==(rhs); }
227 reference operator*() { return *reinterpret_cast<pointer>(p->current()); }
228 const_reference operator*() const { return *reinterpret_cast<const_pointer>(p->const_current()); }
229 bool valid() const { return p && p->current() != OPTIONAL_NULLPTR; }
230 };
231
232 template <class T>
233 class AList {
234 IContainer* container;
235 bool owner;
236
237 public:
238 typedef T value_type;
239 typedef value_type& reference;
240 typedef const value_type& const_reference;
241 typedef value_type* pointer;
242 typedef const value_type* const_pointer;
243 typedef size_t size_type;
244 typedef AOutputIterator<value_type> iterator;
245 typedef const AOutputIterator<value_type> const_iterator;
246
247 public:
248 AList() : container(OPTIONAL_NULLPTR), owner(false) {}
249 AList(IContainer* c, bool take_ownership) : container(c), owner(take_ownership) {}
250 ~AList() { reset(); }
251 void reset(IContainer* c = OPTIONAL_NULLPTR, bool take_ownership = false) {
252 if (owner && container) container->release();
253 container = c;
254 owner = take_ownership;
255 }
256 iterator begin() { return container ? iterator(container->begin()) : iterator(OPTIONAL_NULLPTR); }
257 iterator end() { return iterator(OPTIONAL_NULLPTR); }
258 size_type size() const { return container ? container->size() : 0; }
259 bool empty() const { return size() == 0; }
260 };
261
262 } // namespace util
263
267 enum CHANNEL_PROFILE_TYPE {
271 CHANNEL_PROFILE_COMMUNICATION = 0,
275 CHANNEL_PROFILE_LIVE_BROADCASTING = 1,
280 CHANNEL_PROFILE_GAME __deprecated = 2,
286 CHANNEL_PROFILE_CLOUD_GAMING __deprecated = 3,
287
292 CHANNEL_PROFILE_COMMUNICATION_1v1 __deprecated = 4,
293 };
294
298 enum WARN_CODE_TYPE {
303 WARN_INVALID_VIEW = 8,
308 WARN_INIT_VIDEO = 16,
313 WARN_PENDING = 20,
318 WARN_NO_AVAILABLE_CHANNEL = 103,
324 WARN_LOOKUP_CHANNEL_TIMEOUT = 104,
329 WARN_LOOKUP_CHANNEL_REJECTED = 105,
335 WARN_OPEN_CHANNEL_TIMEOUT = 106,
340 WARN_OPEN_CHANNEL_REJECTED = 107,
341
342 // sdk: 100~1000
346 WARN_SWITCH_LIVE_VIDEO_TIMEOUT = 111,
350 WARN_SET_CLIENT_ROLE_TIMEOUT = 118,
354 WARN_OPEN_CHANNEL_INVALID_TICKET = 121,
358 WARN_OPEN_CHANNEL_TRY_NEXT_VOS = 122,
362 WARN_CHANNEL_CONNECTION_UNRECOVERABLE = 131,
366 WARN_CHANNEL_CONNECTION_IP_CHANGED = 132,
370 WARN_CHANNEL_CONNECTION_PORT_CHANGED = 133,
373 WARN_CHANNEL_SOCKET_ERROR = 134,
377 WARN_AUDIO_MIXING_OPEN_ERROR = 701,
381 WARN_ADM_RUNTIME_PLAYOUT_WARNING = 1014,
385 WARN_ADM_RUNTIME_RECORDING_WARNING = 1016,
389 WARN_ADM_RECORD_AUDIO_SILENCE = 1019,
393 WARN_ADM_PLAYOUT_MALFUNCTION = 1020,
397 WARN_ADM_RECORD_MALFUNCTION = 1021,
401 WARN_ADM_RECORD_AUDIO_LOWLEVEL = 1031,
405 WARN_ADM_PLAYOUT_AUDIO_LOWLEVEL = 1032,
413 WARN_ADM_WINDOWS_NO_DATA_READY_EVENT = 1040,
417 WARN_APM_HOWLING = 1051,
421 WARN_ADM_GLITCH_STATE = 1052,
425 WARN_ADM_IMPROPER_SETTINGS = 1053,
429 WARN_ADM_POP_STATE = 1055,
433 WARN_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
438 WARN_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
446 WARN_ADM_WIN_CORE_IMPROPER_CAPTURE_RELEASE = 1324,
447 };
448
458 enum ERROR_CODE_TYPE {
462 ERR_OK = 0,
463 // 1~1000
467 ERR_FAILED = 1,
472 ERR_INVALID_ARGUMENT = 2,
482 ERR_NOT_READY = 3,
488 ERR_NOT_SUPPORTED = 4,
497 ERR_REFUSED = 5,
501 ERR_BUFFER_TOO_SMALL = 6,
506 ERR_NOT_INITIALIZED = 7,
510 ERR_INVALID_STATE = 8,
515 ERR_NO_PERMISSION = 9,
520 ERR_TIMEDOUT = 10,
525 ERR_CANCELED = 11,
531 ERR_TOO_OFTEN = 12,
537 ERR_BIND_SOCKET = 13,
542 ERR_NET_DOWN = 14,
552 ERR_JOIN_CHANNEL_REJECTED = 17,
562 ERR_LEAVE_CHANNEL_REJECTED = 18,
566 ERR_ALREADY_IN_USE = 19,
571 ERR_ABORTED = 20,
576 ERR_INIT_NET_ENGINE = 21,
581 ERR_RESOURCE_LIMITED = 22,
586 ERR_FUNC_IS_PROHIBITED = 23,
590 ERR_INVALID_APP_ID = 101,
595 ERR_INVALID_CHANNEL_NAME = 102,
600 ERR_NO_SERVER_RESOURCES = 103,
604 ERR_TOKEN_EXPIRED = 109,
611 ERR_INVALID_TOKEN = 110,
616 ERR_CONNECTION_INTERRUPTED = 111, // only used in web sdk
621 ERR_CONNECTION_LOST = 112, // only used in web sdk
625 ERR_NOT_IN_CHANNEL = 113,
629 ERR_SIZE_TOO_LARGE = 114,
633 ERR_BITRATE_LIMIT = 115,
638 ERR_TOO_MANY_DATA_STREAMS = 116,
642 ERR_STREAM_MESSAGE_TIMEOUT = 117,
646 ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED = 119,
651 ERR_DECRYPTION_FAILED = 120,
655 ERR_INVALID_USER_ID = 121,
660 ERR_DATASTREAM_DECRYPTION_FAILED = 122,
664 ERR_CLIENT_IS_BANNED_BY_SERVER = 123,
668 ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH = 130,
669
673 ERR_LICENSE_CREDENTIAL_INVALID = 131,
674
678 ERR_INVALID_USER_ACCOUNT = 134,
679
686 ERR_MODULE_NOT_FOUND = 157,
687
688 // Licensing, keep the license error code same as the main version
689 ERR_CERT_RAW = 157,
690 ERR_CERT_JSON_PART = 158,
691 ERR_CERT_JSON_INVAL = 159,
692 ERR_CERT_JSON_NOMEM = 160,
693 ERR_CERT_CUSTOM = 161,
694 ERR_CERT_CREDENTIAL = 162,
695 ERR_CERT_SIGN = 163,
696 ERR_CERT_FAIL = 164,
697 ERR_CERT_BUF = 165,
698 ERR_CERT_NULL = 166,
699 ERR_CERT_DUEDATE = 167,
700 ERR_CERT_REQUEST = 168,
701
702 // PcmSend Error num
706 ERR_PCMSEND_FORMAT = 200, // unsupport pcm format
710 ERR_PCMSEND_BUFFEROVERFLOW = 201, // buffer overflow, the pcm send rate too quickly
711
713 // RDT error code: 250~270
718 ERR_RDT_USER_NOT_EXIST = 250,
723 ERR_RDT_USER_NOT_READY = 251,
728 ERR_RDT_DATA_BLOCKED = 252,
733 ERR_RDT_CMD_EXCEED_LIMIT = 253,
738 ERR_RDT_DATA_EXCEED_LIMIT = 254,
743 ERR_RDT_ENCRYPTION = 255,
745
747 // signaling: 400~600
748 ERR_LOGIN_ALREADY_LOGIN = 428,
749
751 // 1001~2000
755 ERR_LOAD_MEDIA_ENGINE = 1001,
760 ERR_ADM_GENERAL_ERROR = 1005,
765 ERR_ADM_INIT_PLAYOUT = 1008,
769 ERR_ADM_START_PLAYOUT = 1009,
773 ERR_ADM_STOP_PLAYOUT = 1010,
778 ERR_ADM_INIT_RECORDING = 1011,
782 ERR_ADM_START_RECORDING = 1012,
786 ERR_ADM_STOP_RECORDING = 1013,
791 ERR_VDM_CAMERA_NOT_AUTHORIZED = 1501,
792 };
793
794 enum LICENSE_ERROR_TYPE {
798 LICENSE_ERR_INVALID = 1,
802 LICENSE_ERR_EXPIRE = 2,
806 LICENSE_ERR_MINUTES_EXCEED = 3,
810 LICENSE_ERR_LIMITED_PERIOD = 4,
814 LICENSE_ERR_DIFF_DEVICES = 5,
818 LICENSE_ERR_INTERNAL = 99,
819 };
820
824 enum AUDIO_SESSION_OPERATION_RESTRICTION {
828 AUDIO_SESSION_OPERATION_RESTRICTION_NONE = 0,
832 AUDIO_SESSION_OPERATION_RESTRICTION_SET_CATEGORY = 1,
836 AUDIO_SESSION_OPERATION_RESTRICTION_CONFIGURE_SESSION = 1 << 1,
841 AUDIO_SESSION_OPERATION_RESTRICTION_DEACTIVATE_SESSION = 1 << 2,
846 AUDIO_SESSION_OPERATION_RESTRICTION_ALL = 1 << 7,
847 };
848
849 typedef const char* user_id_t;
850 typedef void* view_t;
851
855 struct UserInfo {
859 util::AString userId;
865 bool hasAudio;
871 bool hasVideo;
872
873 UserInfo() : hasAudio(false), hasVideo(false) {}
874 };
875
876 typedef util::AList<UserInfo> UserList;
877
878 // Shared between Agora Service and Rtc Engine
879 namespace rtc {
880
884 enum USER_OFFLINE_REASON_TYPE {
888 USER_OFFLINE_QUIT = 0,
895 USER_OFFLINE_DROPPED = 1,
899 USER_OFFLINE_BECOME_AUDIENCE = 2,
900 };
901
905 enum INTERFACE_ID_TYPE {
909 AGORA_IID_AUDIO_DEVICE_MANAGER = 1,
913 AGORA_IID_VIDEO_DEVICE_MANAGER = 2,
917 AGORA_IID_PARAMETER_ENGINE = 3,
921 AGORA_IID_MEDIA_ENGINE = 4,
922 AGORA_IID_AUDIO_ENGINE = 5,
923 AGORA_IID_VIDEO_ENGINE = 6,
924 AGORA_IID_RTC_CONNECTION = 7,
928 AGORA_IID_SIGNALING_ENGINE = 8,
929 AGORA_IID_MEDIA_ENGINE_REGULATOR = 9,
930 AGORA_IID_LOCAL_SPATIAL_AUDIO = 11,
931 AGORA_IID_STATE_SYNC = 13,
932 AGORA_IID_META_SERVICE = 14,
933 AGORA_IID_MUSIC_CONTENT_CENTER = 15,
934 AGORA_IID_H265_TRANSCODER = 16,
935 };
936
940 enum QUALITY_TYPE {
945 QUALITY_UNKNOWN __deprecated = 0,
949 QUALITY_EXCELLENT = 1,
953 QUALITY_GOOD = 2,
957 QUALITY_POOR = 3,
961 QUALITY_BAD = 4,
965 QUALITY_VBAD = 5,
969 QUALITY_DOWN = 6,
973 QUALITY_UNSUPPORTED = 7,
977 QUALITY_DETECTING = 8,
978 };
979
983 enum FIT_MODE_TYPE {
988 MODE_COVER = 1,
989
995 MODE_CONTAIN = 2,
996 };
997
1001 enum VIDEO_ORIENTATION {
1005 VIDEO_ORIENTATION_0 = 0,
1009 VIDEO_ORIENTATION_90 = 90,
1013 VIDEO_ORIENTATION_180 = 180,
1017 VIDEO_ORIENTATION_270 = 270
1018 };
1019
1023 enum FRAME_RATE {
1027 FRAME_RATE_FPS_1 = 1,
1031 FRAME_RATE_FPS_7 = 7,
1035 FRAME_RATE_FPS_10 = 10,
1039 FRAME_RATE_FPS_15 = 15,
1043 FRAME_RATE_FPS_24 = 24,
1047 FRAME_RATE_FPS_30 = 30,
1052 FRAME_RATE_FPS_60 = 60,
1053 };
1054
1055 enum FRAME_WIDTH {
1056 FRAME_WIDTH_960 = 960,
1057 };
1058
1059 enum FRAME_HEIGHT {
1060 FRAME_HEIGHT_540 = 540,
1061 };
1062
1066 enum VIDEO_FRAME_TYPE {
1070 VIDEO_FRAME_TYPE_BLANK_FRAME = 0,
1074 VIDEO_FRAME_TYPE_KEY_FRAME = 3,
1078 VIDEO_FRAME_TYPE_DELTA_FRAME = 4,
1082 VIDEO_FRAME_TYPE_B_FRAME = 5,
1086 VIDEO_FRAME_TYPE_DROPPABLE_FRAME = 6,
1090 VIDEO_FRAME_TYPE_UNKNOW
1091 };
1092
1096 enum ORIENTATION_MODE {
1104 ORIENTATION_MODE_ADAPTIVE = 0,
1111 ORIENTATION_MODE_FIXED_LANDSCAPE = 1,
1117 ORIENTATION_MODE_FIXED_PORTRAIT = 2,
1118 };
1119
1123 enum DEGRADATION_PREFERENCE {
1129 MAINTAIN_AUTO = -1,
1135 MAINTAIN_QUALITY = 0,
1141 MAINTAIN_FRAMERATE = 1,
1150 MAINTAIN_BALANCED = 2,
1156 MAINTAIN_RESOLUTION = 3,
1160 DISABLED = 100,
1161 };
1162
1166 struct VideoDimensions {
1170 int width;
1174 int height;
1175 VideoDimensions() : width(640), height(480) {}
1176 VideoDimensions(int w, int h) : width(w), height(h) {}
1177 bool operator==(const VideoDimensions& rhs) const {
1178 return width == rhs.width && height == rhs.height;
1179 }
1180 };
1181
1187 const int STANDARD_BITRATE = 0;
1188
1196 const int COMPATIBLE_BITRATE = -1;
1197
1201 const int DEFAULT_MIN_BITRATE = -1;
1202
1206 const int DEFAULT_MIN_BITRATE_EQUAL_TO_TARGET_BITRATE = -2;
1207
1211 enum SCREEN_CAPTURE_FRAMERATE_CAPABILITY {
1215 SCREEN_CAPTURE_FRAMERATE_CAPABILITY_15_FPS = 0,
1219 SCREEN_CAPTURE_FRAMERATE_CAPABILITY_30_FPS = 1,
1223 SCREEN_CAPTURE_FRAMERATE_CAPABILITY_60_FPS = 2,
1224 };
1225
1229 enum VIDEO_CODEC_CAPABILITY_LEVEL {
1234 CODEC_CAPABILITY_LEVEL_UNSPECIFIED = -1,
1238 CODEC_CAPABILITY_LEVEL_BASIC_SUPPORT = 5,
1242 CODEC_CAPABILITY_LEVEL_1080P30FPS = 10,
1246 CODEC_CAPABILITY_LEVEL_1080P60FPS = 20,
1250 CODEC_CAPABILITY_LEVEL_4K60FPS = 30,
1251 };
1252
1256 enum VIDEO_CODEC_TYPE {
1261 VIDEO_CODEC_NONE = 0,
1265 VIDEO_CODEC_VP8 = 1,
1269 VIDEO_CODEC_H264 = 2,
1273 VIDEO_CODEC_H265 = 3,
1279 VIDEO_CODEC_GENERIC = 6,
1284 VIDEO_CODEC_GENERIC_H264 = 7,
1289 VIDEO_CODEC_AV1 = 12,
1293 VIDEO_CODEC_VP9 = 13,
1297 VIDEO_CODEC_GENERIC_JPEG = 20,
1298 };
1299
1306 enum CAMERA_FOCAL_LENGTH_TYPE {
1310 CAMERA_FOCAL_LENGTH_DEFAULT = 0,
1314 CAMERA_FOCAL_LENGTH_WIDE_ANGLE = 1,
1318 CAMERA_FOCAL_LENGTH_ULTRA_WIDE = 2,
1322 CAMERA_FOCAL_LENGTH_TELEPHOTO = 3,
1323 };
1324
1328 enum TCcMode {
1332 CC_ENABLED,
1336 CC_DISABLED,
1337 };
1338
1342 struct SenderOptions {
1346 TCcMode ccMode;
1351 VIDEO_CODEC_TYPE codecType;
1352
1412 int targetBitrate;
1413
1414 SenderOptions() : ccMode(CC_ENABLED), codecType(VIDEO_CODEC_H265), targetBitrate(6500) {}
1415 };
1416
1420 enum AUDIO_CODEC_TYPE {
1424 AUDIO_CODEC_OPUS = 1,
1425 // kIsac = 2,
1429 AUDIO_CODEC_PCMA = 3,
1433 AUDIO_CODEC_PCMU = 4,
1437 AUDIO_CODEC_G722 = 5,
1438 // kIlbc = 6,
1440 // AUDIO_CODEC_AAC = 7,
1444 AUDIO_CODEC_AACLC = 8,
1448 AUDIO_CODEC_HEAAC = 9,
1452 AUDIO_CODEC_JC1 = 10,
1456 AUDIO_CODEC_HEAAC2 = 11,
1460 AUDIO_CODEC_LPCNET = 12,
1464 AUDIO_CODEC_OPUSMC = 13,
1465 };
1466
1470 enum AUDIO_ENCODING_TYPE {
1475 AUDIO_ENCODING_TYPE_AAC_16000_LOW = 0x010101,
1480 AUDIO_ENCODING_TYPE_AAC_16000_MEDIUM = 0x010102,
1485 AUDIO_ENCODING_TYPE_AAC_32000_LOW = 0x010201,
1490 AUDIO_ENCODING_TYPE_AAC_32000_MEDIUM = 0x010202,
1495 AUDIO_ENCODING_TYPE_AAC_32000_HIGH = 0x010203,
1500 AUDIO_ENCODING_TYPE_AAC_48000_MEDIUM = 0x010302,
1505 AUDIO_ENCODING_TYPE_AAC_48000_HIGH = 0x010303,
1510 AUDIO_ENCODING_TYPE_OPUS_16000_LOW = 0x020101,
1515 AUDIO_ENCODING_TYPE_OPUS_16000_MEDIUM = 0x020102,
1520 AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM = 0x020302,
1525 AUDIO_ENCODING_TYPE_OPUS_48000_HIGH = 0x020303,
1526 };
1527
1531 enum WATERMARK_FIT_MODE {
1536 FIT_MODE_COVER_POSITION = 0,
1541 FIT_MODE_USE_IMAGE_RATIO = 1,
1542 };
1543
1547 struct EncodedAudioFrameAdvancedSettings {
1548 EncodedAudioFrameAdvancedSettings() : speech(true), sendEvenIfEmpty(true) {}
1549
1555 bool speech;
1561 bool sendEvenIfEmpty;
1562 };
1563
1567 struct EncodedAudioFrameInfo {
1568 EncodedAudioFrameInfo()
1569 : codec(AUDIO_CODEC_AACLC),
1570 sampleRateHz(0),
1571 samplesPerChannel(0),
1572 numberOfChannels(0),
1573 captureTimeMs(0) {}
1574
1575 EncodedAudioFrameInfo(const EncodedAudioFrameInfo& rhs)
1576 : codec(rhs.codec),
1577 sampleRateHz(rhs.sampleRateHz),
1578 samplesPerChannel(rhs.samplesPerChannel),
1579 numberOfChannels(rhs.numberOfChannels),
1580 advancedSettings(rhs.advancedSettings),
1581 captureTimeMs(rhs.captureTimeMs) {}
1585 AUDIO_CODEC_TYPE codec;
1589 int sampleRateHz;
1593 int samplesPerChannel;
1597 int numberOfChannels;
1601 EncodedAudioFrameAdvancedSettings advancedSettings;
1602
1606 int64_t captureTimeMs;
1607 };
1611 struct AudioPcmDataInfo {
1612 AudioPcmDataInfo()
1613 : samplesPerChannel(0), channelNum(0), samplesOut(0), elapsedTimeMs(0), ntpTimeMs(0) {}
1614
1615 AudioPcmDataInfo(const AudioPcmDataInfo& rhs)
1616 : samplesPerChannel(rhs.samplesPerChannel),
1617 channelNum(rhs.channelNum),
1618 samplesOut(rhs.samplesOut),
1619 elapsedTimeMs(rhs.elapsedTimeMs),
1620 ntpTimeMs(rhs.ntpTimeMs) {}
1621
1625 size_t samplesPerChannel;
1626
1627 int16_t channelNum;
1628
1629 // Output
1633 size_t samplesOut;
1637 int64_t elapsedTimeMs;
1641 int64_t ntpTimeMs;
1642 };
1646 enum H264PacketizeMode {
1650 NonInterleaved = 0, // Mode 1 - STAP-A, FU-A is allowed
1654 SingleNalUnit, // Mode 0 - only single NALU allowed
1655 };
1656
1660 enum VIDEO_STREAM_TYPE {
1664 VIDEO_STREAM_HIGH = 0,
1668 VIDEO_STREAM_LOW = 1,
1673 VIDEO_STREAM_LAYER_1 = 4,
1678 VIDEO_STREAM_LAYER_2 = 5,
1683 VIDEO_STREAM_LAYER_3 = 6,
1688 VIDEO_STREAM_LAYER_4 = 7,
1693 VIDEO_STREAM_LAYER_5 = 8,
1698 VIDEO_STREAM_LAYER_6 = 9,
1699
1700 };
1701
1705 struct VideoSubscriptionOptions {
1710 Optional<VIDEO_STREAM_TYPE> type;
1717 Optional<bool> encodedFrameOnly;
1718
1719 VideoSubscriptionOptions() {}
1720 };
1721
1725 enum MAX_USER_ACCOUNT_LENGTH_TYPE {
1729 MAX_USER_ACCOUNT_LENGTH = 256
1730 };
1731
1735 struct EncodedVideoFrameInfo {
1736 EncodedVideoFrameInfo()
1737 : codecType(VIDEO_CODEC_H264),
1738 width(0),
1739 height(0),
1740 framesPerSecond(0),
1741 frameType(VIDEO_FRAME_TYPE_BLANK_FRAME),
1742 rotation(VIDEO_ORIENTATION_0),
1743 trackId(0),
1744 captureTimeMs(0),
1745 decodeTimeMs(0),
1746 streamType(VIDEO_STREAM_HIGH),
1747 presentationMs(-1) {}
1748
1749 EncodedVideoFrameInfo(const EncodedVideoFrameInfo& rhs)
1750 : codecType(rhs.codecType),
1751 width(rhs.width),
1752 height(rhs.height),
1753 framesPerSecond(rhs.framesPerSecond),
1754 frameType(rhs.frameType),
1755 rotation(rhs.rotation),
1756 trackId(rhs.trackId),
1757 captureTimeMs(rhs.captureTimeMs),
1758 decodeTimeMs(rhs.decodeTimeMs),
1759 streamType(rhs.streamType),
1760 presentationMs(rhs.presentationMs) {}
1761
1762 EncodedVideoFrameInfo& operator=(const EncodedVideoFrameInfo& rhs) {
1763 if (this == &rhs) return *this;
1764 codecType = rhs.codecType;
1765 width = rhs.width;
1766 height = rhs.height;
1767 framesPerSecond = rhs.framesPerSecond;
1768 frameType = rhs.frameType;
1769 rotation = rhs.rotation;
1770 trackId = rhs.trackId;
1771 captureTimeMs = rhs.captureTimeMs;
1772 decodeTimeMs = rhs.decodeTimeMs;
1773 streamType = rhs.streamType;
1774 presentationMs = rhs.presentationMs;
1775 return *this;
1776 }
1777
1782 VIDEO_CODEC_TYPE codecType;
1786 int width;
1790 int height;
1796 int framesPerSecond;
1800 VIDEO_FRAME_TYPE frameType;
1804 VIDEO_ORIENTATION rotation;
1808 int trackId; // This can be reserved for multiple video tracks, we need to create different ssrc
1809 // and additional payload for later implementation.
1813 int64_t captureTimeMs;
1817 int64_t decodeTimeMs;
1821 VIDEO_STREAM_TYPE streamType;
1822
1823 // @technical preview
1824 int64_t presentationMs;
1825 };
1826
1830 enum COMPRESSION_PREFERENCE {
1835 PREFER_COMPRESSION_AUTO = -1,
1840 PREFER_LOW_LATENCY = 0,
1845 PREFER_QUALITY = 1,
1846 };
1847
1851 enum ENCODING_PREFERENCE {
1856 PREFER_AUTO = -1,
1860 PREFER_SOFTWARE = 0,
1867 PREFER_HARDWARE = 1,
1868 };
1869
1873 struct AdvanceOptions {
1877 ENCODING_PREFERENCE encodingPreference;
1878
1882 COMPRESSION_PREFERENCE compressionPreference;
1883
1889 bool encodeAlpha;
1890
1891 AdvanceOptions() : encodingPreference(PREFER_AUTO),
1892 compressionPreference(PREFER_COMPRESSION_AUTO),
1893 encodeAlpha(false) {}
1894
1895 AdvanceOptions(ENCODING_PREFERENCE encoding_preference,
1896 COMPRESSION_PREFERENCE compression_preference,
1897 bool encode_alpha) :
1898 encodingPreference(encoding_preference),
1899 compressionPreference(compression_preference),
1900 encodeAlpha(encode_alpha) {}
1901
1902 bool operator==(const AdvanceOptions& rhs) const {
1903 return encodingPreference == rhs.encodingPreference &&
1904 compressionPreference == rhs.compressionPreference &&
1905 encodeAlpha == rhs.encodeAlpha;
1906 }
1907 };
1908
1912 enum VIDEO_MIRROR_MODE_TYPE {
1919 VIDEO_MIRROR_MODE_AUTO = 0,
1923 VIDEO_MIRROR_MODE_ENABLED = 1,
1927 VIDEO_MIRROR_MODE_DISABLED = 2,
1928 };
1929
1930 #if defined(__APPLE__) && TARGET_OS_IOS
1931
1934 enum CAMERA_FORMAT_TYPE {
1936 CAMERA_FORMAT_NV12,
1938 CAMERA_FORMAT_BGRA,
1939 };
1940 #endif
1941
1942 enum VIDEO_MODULE_TYPE {
1944 VIDEO_MODULE_CAPTURER = 0,
1946 VIDEO_MODULE_SOFTWARE_ENCODER = 1,
1948 VIDEO_MODULE_HARDWARE_ENCODER = 2,
1950 VIDEO_MODULE_SOFTWARE_DECODER = 3,
1952 VIDEO_MODULE_HARDWARE_DECODER = 4,
1954 VIDEO_MODULE_RENDERER = 5,
1955 };
1956
1957 enum HDR_CAPABILITY {
1959 HDR_CAPABILITY_UNKNOWN = -1,
1961 HDR_CAPABILITY_UNSUPPORTED = 0,
1963 HDR_CAPABILITY_SUPPORTED = 1,
1964 };
1965
1969 enum CODEC_CAP_MASK {
1973 CODEC_CAP_MASK_NONE = 0,
1974
1978 CODEC_CAP_MASK_HW_DEC = 1 << 0,
1979
1983 CODEC_CAP_MASK_HW_ENC = 1 << 1,
1984
1988 CODEC_CAP_MASK_SW_DEC = 1 << 2,
1989
1993 CODEC_CAP_MASK_SW_ENC = 1 << 3,
1994 };
1995
1999 struct CodecCapLevels {
2004 VIDEO_CODEC_CAPABILITY_LEVEL hwDecodingLevel;
2009 VIDEO_CODEC_CAPABILITY_LEVEL swDecodingLevel;
2010
2011 CodecCapLevels()
2012 : hwDecodingLevel(CODEC_CAPABILITY_LEVEL_UNSPECIFIED),
2013 swDecodingLevel(CODEC_CAPABILITY_LEVEL_UNSPECIFIED) {}
2014 };
2015
2019 struct CodecCapInfo {
2023 VIDEO_CODEC_TYPE codecType;
2027 int codecCapMask;
2031 CodecCapLevels codecLevels;
2032
2033 CodecCapInfo() : codecType(VIDEO_CODEC_NONE), codecCapMask(0) {}
2034 };
2035
2043 struct FocalLengthInfo {
2047 int cameraDirection;
2051 CAMERA_FOCAL_LENGTH_TYPE focalLengthType;
2052 };
2053
2057 struct VideoEncoderConfiguration {
2061 VIDEO_CODEC_TYPE codecType;
2067 VideoDimensions dimensions;
2071 int frameRate;
2081 int bitrate;
2082
2091 int minBitrate;
2095 ORIENTATION_MODE orientationMode;
2102 DEGRADATION_PREFERENCE degradationPreference;
2103
2109 VIDEO_MIRROR_MODE_TYPE mirrorMode;
2110
2114 AdvanceOptions advanceOptions;
2115
2116 VideoEncoderConfiguration(const VideoDimensions& d, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
2117 : codecType(VIDEO_CODEC_NONE),
2118 dimensions(d),
2119 frameRate(f),
2120 bitrate(b),
2121 minBitrate(DEFAULT_MIN_BITRATE),
2122 orientationMode(m),
2123 degradationPreference(MAINTAIN_AUTO),
2124 mirrorMode(mirror),
2125 advanceOptions(PREFER_AUTO, PREFER_COMPRESSION_AUTO, false) {}
2126 VideoEncoderConfiguration(int width, int height, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
2127 : codecType(VIDEO_CODEC_NONE),
2128 dimensions(width, height),
2129 frameRate(f),
2130 bitrate(b),
2131 minBitrate(DEFAULT_MIN_BITRATE),
2132 orientationMode(m),
2133 degradationPreference(MAINTAIN_AUTO),
2134 mirrorMode(mirror),
2135 advanceOptions(PREFER_AUTO, PREFER_COMPRESSION_AUTO, false) {}
2136 VideoEncoderConfiguration(const VideoEncoderConfiguration& config)
2137 : codecType(config.codecType),
2138 dimensions(config.dimensions),
2139 frameRate(config.frameRate),
2140 bitrate(config.bitrate),
2141 minBitrate(config.minBitrate),
2142 orientationMode(config.orientationMode),
2143 degradationPreference(config.degradationPreference),
2144 mirrorMode(config.mirrorMode),
2145 advanceOptions(config.advanceOptions) {}
2146 VideoEncoderConfiguration()
2147 : codecType(VIDEO_CODEC_NONE),
2148 dimensions(FRAME_WIDTH_960, FRAME_HEIGHT_540),
2149 frameRate(FRAME_RATE_FPS_15),
2150 bitrate(STANDARD_BITRATE),
2151 minBitrate(DEFAULT_MIN_BITRATE),
2152 orientationMode(ORIENTATION_MODE_ADAPTIVE),
2153 degradationPreference(MAINTAIN_AUTO),
2154 mirrorMode(VIDEO_MIRROR_MODE_DISABLED),
2155 advanceOptions(PREFER_AUTO, PREFER_COMPRESSION_AUTO, false) {}
2156
2157 VideoEncoderConfiguration& operator=(const VideoEncoderConfiguration& rhs) {
2158 if (this == &rhs) return *this;
2159 codecType = rhs.codecType;
2160 dimensions = rhs.dimensions;
2161 frameRate = rhs.frameRate;
2162 bitrate = rhs.bitrate;
2163 minBitrate = rhs.minBitrate;
2164 orientationMode = rhs.orientationMode;
2165 degradationPreference = rhs.degradationPreference;
2166 mirrorMode = rhs.mirrorMode;
2167 advanceOptions = rhs.advanceOptions;
2168 return *this;
2169 }
2170 };
2171
2185 struct DataStreamConfig {
2196 bool syncWithAudio;
2204 bool ordered;
2205 };
2206
2210 enum SIMULCAST_STREAM_MODE {
2216 AUTO_SIMULCAST_STREAM = -1,
2220 DISABLE_SIMULCAST_STREAM = 0,
2224 ENABLE_SIMULCAST_STREAM = 1,
2225 };
2226
2230 struct SimulcastStreamConfig {
2235 VideoDimensions dimensions;
2241 int kBitrate;
2245 int framerate;
2246 SimulcastStreamConfig() : dimensions(160, 120), kBitrate(65), framerate(5) {}
2247 SimulcastStreamConfig(const SimulcastStreamConfig& other) : dimensions(other.dimensions), kBitrate(other.kBitrate), framerate(other.framerate) {}
2248 bool operator==(const SimulcastStreamConfig& rhs) const {
2249 return dimensions == rhs.dimensions && kBitrate == rhs.kBitrate && framerate == rhs.framerate;
2250 }
2251 };
2252
2258 struct SimulcastConfig {
2262 enum StreamLayerIndex {
2266 STREAM_LAYER_1 = 0,
2270 STREAM_LAYER_2 = 1,
2274 STREAM_LAYER_3 = 2,
2278 STREAM_LAYER_4 = 3,
2282 STREAM_LAYER_5 = 4,
2286 STREAM_LAYER_6 = 5,
2290 STREAM_LOW = 6,
2294 STREAM_LAYER_COUNT_MAX = 7
2295 };
2304 struct StreamLayerConfig {
2308 VideoDimensions dimensions;
2312 int framerate;
2318 bool enable;
2319 StreamLayerConfig() : dimensions(0, 0), framerate(0), enable(false) {}
2320 };
2321
2325 StreamLayerConfig configs[STREAM_LAYER_COUNT_MAX];
2334 bool publish_fallback_enable;
2335
2336 SimulcastConfig(): publish_fallback_enable(false) {}
2337 };
2342 struct Rectangle {
2346 int x;
2350 int y;
2354 int width;
2358 int height;
2359
2360 Rectangle() : x(0), y(0), width(0), height(0) {}
2361 Rectangle(int xx, int yy, int ww, int hh) : x(xx), y(yy), width(ww), height(hh) {}
2362 };
2363
2376 struct WatermarkRatio {
2382 float xRatio;
2388 float yRatio;
2395 float widthRatio;
2396
2397 WatermarkRatio() : xRatio(0.0), yRatio(0.0), widthRatio(0.0) {}
2398 WatermarkRatio(float x, float y, float width) : xRatio(x), yRatio(y), widthRatio(width) {}
2399 };
2400
2408 struct WatermarkOptions {
2414 bool visibleInPreview;
2419 Rectangle positionInLandscapeMode;
2424 Rectangle positionInPortraitMode;
2429 WatermarkRatio watermarkRatio;
2433 WATERMARK_FIT_MODE mode;
2437 int zOrder;
2438
2439 WatermarkOptions()
2440 : visibleInPreview(true),
2441 positionInLandscapeMode(0, 0, 0, 0),
2442 positionInPortraitMode(0, 0, 0, 0),
2443 mode(FIT_MODE_COVER_POSITION),
2444 zOrder(0) {}
2445 };
2446
2452 enum WATERMARK_SOURCE_TYPE {
2456 IMAGE = 0,
2460 BUFFER = 1,
2466 LITERAL = 2,
2472 TIMESTAMPS = 3,
2473 };
2474
2481 struct WatermarkTimestamp{
2485 int fontSize;
2492 const char* fontFilePath;
2496 int strokeWidth;
2504 const char* format;
2505
2506 WatermarkTimestamp() : fontSize(10), fontFilePath(NULL), strokeWidth(1), format(NULL) {}
2507 };
2508
2515 struct WatermarkLiteral {
2516
2520 int fontSize;
2524 int strokeWidth;
2530 const char* wmLiteral;
2537 const char* fontFilePath;
2538
2539 WatermarkLiteral() : wmLiteral(NULL), fontFilePath(NULL), fontSize(10), strokeWidth(1) {}
2540 };
2541
2552 struct WatermarkBuffer {
2553
2557 int width;
2561 int height;
2565 int length;
2571 media::base::VIDEO_PIXEL_FORMAT format;
2572
2576 const uint8_t* buffer;
2577
2578 WatermarkBuffer() : buffer(NULL), width(0), height(0), length(0), format(media::base::VIDEO_PIXEL_I420) {}
2579 };
2580
2586 struct WatermarkConfig {
2590 const char* id;
2594 WATERMARK_SOURCE_TYPE type;
2595 union {
2599 WatermarkBuffer buffer;
2605 WatermarkTimestamp timestamp;
2611 WatermarkLiteral literal;
2615 const char* imageUrl;
2616 };
2617
2621 WatermarkOptions options;
2622
2623 WatermarkConfig() : id(NULL), type(IMAGE), imageUrl(NULL) {}
2624 };
2625
2631 enum MultipathMode {
2636 Duplicate= 0,
2641 Dynamic
2642 };
2643
2649 enum MultipathType {
2653 LAN = 0,
2657 WIFI,
2661 Mobile,
2665 Unknown = 99
2666 };
2667
2673 struct PathStats {
2677 MultipathType type;
2681 int txKBitRate;
2685 int rxKBitRate;
2686 PathStats() : type(Unknown), txKBitRate(0), rxKBitRate(0) {}
2687 PathStats(MultipathType t, int tx, int rx) : type(t), txKBitRate(tx), rxKBitRate(rx) {}
2688 };
2689
2695 struct MultipathStats {
2699 uint32_t lanTxBytes;
2703 uint32_t lanRxBytes;
2707 uint32_t wifiTxBytes;
2711 uint32_t wifiRxBytes;
2715 uint32_t mobileTxBytes;
2719 uint32_t mobileRxBytes;
2723 int activePathNum;
2727 const PathStats* pathStats;
2728 MultipathStats()
2729 : lanTxBytes(0),
2730 lanRxBytes(0),
2731 wifiTxBytes(0),
2732 wifiRxBytes(0),
2733 mobileTxBytes(0),
2734 mobileRxBytes(0),
2735 activePathNum(0),
2736 pathStats(nullptr) {}
2737 };
2738
2742 struct RtcStats {
2746 unsigned int duration;
2750 unsigned int txBytes;
2754 unsigned int rxBytes;
2758 unsigned int txAudioBytes;
2762 unsigned int txVideoBytes;
2766 unsigned int rxAudioBytes;
2770 unsigned int rxVideoBytes;
2774 unsigned short txKBitRate;
2778 unsigned short rxKBitRate;
2782 unsigned short rxAudioKBitRate;
2786 unsigned short txAudioKBitRate;
2790 unsigned short rxVideoKBitRate;
2794 unsigned short txVideoKBitRate;
2798 unsigned short lastmileDelay;
2802 unsigned int userCount;
2809 double cpuAppUsage;
2818 double cpuTotalUsage;
2828 int gatewayRtt;
2833 double memoryAppUsageRatio;
2838 double memoryTotalUsageRatio;
2843 int memoryAppUsageInKbytes;
2848 int connectTimeMs;
2853 int firstAudioPacketDuration;
2858 int firstVideoPacketDuration;
2863 int firstVideoKeyFramePacketDuration;
2868 int packetsBeforeFirstKeyFramePacket;
2873 int firstAudioPacketDurationAfterUnmute;
2878 int firstVideoPacketDurationAfterUnmute;
2883 int firstVideoKeyFramePacketDurationAfterUnmute;
2888 int firstVideoKeyFrameDecodedDurationAfterUnmute;
2893 int firstVideoKeyFrameRenderedDurationAfterUnmute;
2898 int txPacketLossRate;
2903 int rxPacketLossRate;
2909 int lanAccelerateState;
2910
2911 RtcStats()
2912 : duration(0),
2913 txBytes(0),
2914 rxBytes(0),
2915 txAudioBytes(0),
2916 txVideoBytes(0),
2917 rxAudioBytes(0),
2918 rxVideoBytes(0),
2919 txKBitRate(0),
2920 rxKBitRate(0),
2921 rxAudioKBitRate(0),
2922 txAudioKBitRate(0),
2923 rxVideoKBitRate(0),
2924 txVideoKBitRate(0),
2925 lastmileDelay(0),
2926 userCount(0),
2927 cpuAppUsage(0.0),
2928 cpuTotalUsage(0.0),
2929 gatewayRtt(0),
2930 memoryAppUsageRatio(0.0),
2931 memoryTotalUsageRatio(0.0),
2932 memoryAppUsageInKbytes(0),
2933 connectTimeMs(0),
2934 firstAudioPacketDuration(0),
2935 firstVideoPacketDuration(0),
2936 firstVideoKeyFramePacketDuration(0),
2937 packetsBeforeFirstKeyFramePacket(0),
2938 firstAudioPacketDurationAfterUnmute(0),
2939 firstVideoPacketDurationAfterUnmute(0),
2940 firstVideoKeyFramePacketDurationAfterUnmute(0),
2941 firstVideoKeyFrameDecodedDurationAfterUnmute(0),
2942 firstVideoKeyFrameRenderedDurationAfterUnmute(0),
2943 txPacketLossRate(0),
2944 rxPacketLossRate(0),
2945 lanAccelerateState(0) {}
2946 };
2947
2951 enum CLIENT_ROLE_TYPE {
2955 CLIENT_ROLE_BROADCASTER = 1,
2959 CLIENT_ROLE_AUDIENCE = 2,
2960 };
2961
2966 enum QUALITY_ADAPT_INDICATION {
2970 ADAPT_NONE = 0,
2974 ADAPT_UP_BANDWIDTH = 1,
2978 ADAPT_DOWN_BANDWIDTH = 2,
2979 };
2980
2985 enum AUDIENCE_LATENCY_LEVEL_TYPE {
2989 AUDIENCE_LATENCY_LEVEL_LOW_LATENCY = 1,
2993 AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY = 2,
2994 };
2995
2999 struct ClientRoleOptions {
3004 AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel;
3005
3006 ClientRoleOptions() : audienceLatencyLevel(AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY) {}
3007 };
3008
3012 enum EXPERIENCE_QUALITY_TYPE {
3016 EXPERIENCE_QUALITY_GOOD = 0,
3020 EXPERIENCE_QUALITY_BAD = 1,
3021 };
3022
3026 enum EXPERIENCE_POOR_REASON {
3030 EXPERIENCE_REASON_NONE = 0,
3034 REMOTE_NETWORK_QUALITY_POOR = 1,
3038 LOCAL_NETWORK_QUALITY_POOR = 2,
3042 WIRELESS_SIGNAL_POOR = 4,
3047 WIFI_BLUETOOTH_COEXIST = 8,
3048 };
3049
3053 enum AUDIO_AINS_MODE {
3058 AINS_MODE_BALANCED = 0,
3064 AINS_MODE_AGGRESSIVE = 1,
3070 AINS_MODE_ULTRALOWLATENCY = 2
3071 };
3072
3076 enum AUDIO_PROFILE_TYPE {
3086 AUDIO_PROFILE_DEFAULT = 0,
3090 AUDIO_PROFILE_SPEECH_STANDARD = 1,
3094 AUDIO_PROFILE_MUSIC_STANDARD = 2,
3100 AUDIO_PROFILE_MUSIC_STANDARD_STEREO = 3,
3104 AUDIO_PROFILE_MUSIC_HIGH_QUALITY = 4,
3110 AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO = 5,
3114 AUDIO_PROFILE_IOT = 6,
3118 AUDIO_PROFILE_NUM = 7
3119 };
3120
3124 enum AUDIO_SCENARIO_TYPE {
3129 AUDIO_SCENARIO_DEFAULT = 0,
3133 AUDIO_SCENARIO_GAME_STREAMING = 3,
3138 AUDIO_SCENARIO_CHATROOM = 5,
3143 AUDIO_SCENARIO_CHORUS = 7,
3147 AUDIO_SCENARIO_MEETING = 8,
3152 AUDIO_SCENARIO_AI_SERVER = 9,
3157 AUDIO_SCENARIO_AI_CLIENT = 10,
3161 AUDIO_SCENARIO_NUM = 11,
3162 };
3163
3167 struct VideoFormat {
3168 OPTIONAL_ENUM_SIZE_T{
3170 kMaxWidthInPixels = 3840,
3172 kMaxHeightInPixels = 2160,
3174 kMaxFps = 60,
3175 };
3176
3180 int width; // Number of pixels.
3184 int height; // Number of pixels.
3188 int fps;
3189 VideoFormat() : width(FRAME_WIDTH_960), height(FRAME_HEIGHT_540), fps(FRAME_RATE_FPS_15) {}
3190 VideoFormat(int w, int h, int f) : width(w), height(h), fps(f) {}
3191
3192 bool operator<(const VideoFormat& fmt) const {
3193 if (height != fmt.height) {
3194 return height < fmt.height;
3195 } else if (width != fmt.width) {
3196 return width < fmt.width;
3197 } else {
3198 return fps < fmt.fps;
3199 }
3200 }
3201 bool operator==(const VideoFormat& fmt) const {
3202 return width == fmt.width && height == fmt.height && fps == fmt.fps;
3203 }
3204 bool operator!=(const VideoFormat& fmt) const { return !operator==(fmt); }
3205 };
3206
3210 enum VIDEO_CONTENT_HINT {
3214 CONTENT_HINT_NONE,
3219 CONTENT_HINT_MOTION,
3224 CONTENT_HINT_DETAILS
3225 };
3229 enum SCREEN_SCENARIO_TYPE {
3235 SCREEN_SCENARIO_DOCUMENT = 1,
3240 SCREEN_SCENARIO_GAMING = 2,
3245 SCREEN_SCENARIO_VIDEO = 3,
3251 SCREEN_SCENARIO_RDC = 4,
3252 };
3253
3257 enum VIDEO_APPLICATION_SCENARIO_TYPE {
3261 APPLICATION_SCENARIO_GENERAL = 0,
3297 APPLICATION_SCENARIO_MEETING = 1,
3306 APPLICATION_SCENARIO_1V1 = 2,
3317 APPLICATION_SCENARIO_LIVESHOW = 3,
3318 };
3319
3323 enum VIDEO_QOE_PREFERENCE_TYPE {
3327 VIDEO_QOE_PREFERENCE_BALANCE = 1,
3331 VIDEO_QOE_PREFERENCE_DELAY_FIRST = 2,
3335 VIDEO_QOE_PREFERENCE_PICTURE_QUALITY_FIRST = 3,
3339 VIDEO_QOE_PREFERENCE_FLUENCY_FIRST = 4,
3340
3341 };
3342
3346 enum CAPTURE_BRIGHTNESS_LEVEL_TYPE {
3351 CAPTURE_BRIGHTNESS_LEVEL_INVALID = -1,
3355 CAPTURE_BRIGHTNESS_LEVEL_NORMAL = 0,
3359 CAPTURE_BRIGHTNESS_LEVEL_BRIGHT = 1,
3363 CAPTURE_BRIGHTNESS_LEVEL_DARK = 2,
3364 };
3365
3374 enum CAMERA_STABILIZATION_MODE {
3378 CAMERA_STABILIZATION_MODE_OFF = -1,
3384 CAMERA_STABILIZATION_MODE_AUTO = 0,
3388 CAMERA_STABILIZATION_MODE_LEVEL_1 = 1,
3392 CAMERA_STABILIZATION_MODE_LEVEL_2 = 2,
3396 CAMERA_STABILIZATION_MODE_LEVEL_3 = 3,
3399 CAMERA_STABILIZATION_MODE_MAX_LEVEL = CAMERA_STABILIZATION_MODE_LEVEL_3,
3400 };
3401
3405 enum LOCAL_AUDIO_STREAM_STATE {
3409 LOCAL_AUDIO_STREAM_STATE_STOPPED = 0,
3413 LOCAL_AUDIO_STREAM_STATE_RECORDING = 1,
3417 LOCAL_AUDIO_STREAM_STATE_ENCODING = 2,
3421 LOCAL_AUDIO_STREAM_STATE_FAILED = 3
3422 };
3423
3427 enum LOCAL_AUDIO_STREAM_REASON {
3431 LOCAL_AUDIO_STREAM_REASON_OK = 0,
3436 LOCAL_AUDIO_STREAM_REASON_FAILURE = 1,
3440 LOCAL_AUDIO_STREAM_REASON_DEVICE_NO_PERMISSION = 2,
3447 LOCAL_AUDIO_STREAM_REASON_DEVICE_BUSY = 3,
3451 LOCAL_AUDIO_STREAM_REASON_RECORD_FAILURE = 4,
3455 LOCAL_AUDIO_STREAM_REASON_ENCODE_FAILURE = 5,
3461 LOCAL_AUDIO_STREAM_REASON_NO_RECORDING_DEVICE = 6,
3467 LOCAL_AUDIO_STREAM_REASON_NO_PLAYOUT_DEVICE = 7,
3473 LOCAL_AUDIO_STREAM_REASON_INTERRUPTED = 8,
3478 LOCAL_AUDIO_STREAM_REASON_RECORD_INVALID_ID = 9,
3483 LOCAL_AUDIO_STREAM_REASON_PLAYOUT_INVALID_ID = 10,
3484 };
3485
3489 enum LOCAL_VIDEO_STREAM_STATE {
3493 LOCAL_VIDEO_STREAM_STATE_STOPPED = 0,
3498 LOCAL_VIDEO_STREAM_STATE_CAPTURING = 1,
3502 LOCAL_VIDEO_STREAM_STATE_ENCODING = 2,
3506 LOCAL_VIDEO_STREAM_STATE_FAILED = 3
3507 };
3508
3513 enum LOCAL_VIDEO_EVENT_TYPE {
3517 LOCAL_VIDEO_EVENT_TYPE_SCREEN_CAPTURE_WINDOW_HIDDEN = 1,
3521 LOCAL_VIDEO_EVENT_TYPE_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_HIDDEN = 2,
3525 LOCAL_VIDEO_EVENT_TYPE_SCREEN_CAPTURE_STOPPED_BY_USER = 3,
3529 LOCAL_VIDEO_EVENT_TYPE_SCREEN_CAPTURE_SYSTEM_INTERNAL_ERROR = 4,
3530 };
3531
3535 enum LOCAL_VIDEO_STREAM_REASON {
3539 LOCAL_VIDEO_STREAM_REASON_OK = 0,
3543 LOCAL_VIDEO_STREAM_REASON_FAILURE = 1,
3548 LOCAL_VIDEO_STREAM_REASON_DEVICE_NO_PERMISSION = 2,
3553 LOCAL_VIDEO_STREAM_REASON_DEVICE_BUSY = 3,
3558 LOCAL_VIDEO_STREAM_REASON_CAPTURE_FAILURE = 4,
3562 LOCAL_VIDEO_STREAM_REASON_CODEC_NOT_SUPPORT = 5,
3567 LOCAL_VIDEO_STREAM_REASON_CAPTURE_INBACKGROUND = 6,
3574 LOCAL_VIDEO_STREAM_REASON_CAPTURE_MULTIPLE_FOREGROUND_APPS = 7,
3580 LOCAL_VIDEO_STREAM_REASON_DEVICE_NOT_FOUND = 8,
3585 LOCAL_VIDEO_STREAM_REASON_DEVICE_DISCONNECTED = 9,
3590 LOCAL_VIDEO_STREAM_REASON_DEVICE_INVALID_ID = 10,
3599 LOCAL_VIDEO_STREAM_REASON_DEVICE_INTERRUPT = 14,
3605 LOCAL_VIDEO_STREAM_REASON_DEVICE_FATAL_ERROR = 15,
3609 LOCAL_VIDEO_STREAM_REASON_DEVICE_SYSTEM_PRESSURE = 101,
3615 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_MINIMIZED = 11,
3629 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_CLOSED = 12,
3634 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_OCCLUDED = 13,
3636 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_NOT_SUPPORTED = 20,
3640 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_FAILURE = 21,
3644 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_NO_PERMISSION = 22,
3654 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_AUTO_FALLBACK = 24,
3659 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_HIDDEN = 25,
3663 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_HIDDEN = 26,
3668 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_MINIMIZED = 27,
3674 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_PAUSED = 28,
3678 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_RESUMED = 29,
3683 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_DISPLAY_DISCONNECTED = 30,
3684 /* 30: (HMOS only) ScreenCapture stopped by user */
3685 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_STOPPED_BY_USER = 31,
3686 /* 31: (HMOS only) ScreenCapture interrupted by other screen capture */
3687 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_INTERRUPTED_BY_OTHER = 32,
3688 /* 32: (HMOS only) ScreenCapture stopped by SIM call */
3689 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_STOPPED_BY_CALL = 33,
3691 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_EXCLUDE_WINDOW_FAILED = 34,
3692 };
3693
3697 enum REMOTE_AUDIO_STATE {
3703 REMOTE_AUDIO_STATE_STOPPED =
3704 0, // Default state, audio is started or remote user disabled/muted audio stream
3708 REMOTE_AUDIO_STATE_STARTING = 1, // The first audio frame packet has been received
3714 REMOTE_AUDIO_STATE_DECODING =
3715 2, // The first remote audio frame has been decoded or fronzen state ends
3720 REMOTE_AUDIO_STATE_FROZEN = 3, // Remote audio is frozen, probably due to network issue
3725 REMOTE_AUDIO_STATE_FAILED = 4, // Remote audio play failed
3726 };
3727
3731 enum REMOTE_AUDIO_STATE_REASON {
3735 REMOTE_AUDIO_REASON_INTERNAL = 0,
3739 REMOTE_AUDIO_REASON_NETWORK_CONGESTION = 1,
3743 REMOTE_AUDIO_REASON_NETWORK_RECOVERY = 2,
3747 REMOTE_AUDIO_REASON_LOCAL_MUTED = 3,
3751 REMOTE_AUDIO_REASON_LOCAL_UNMUTED = 4,
3755 REMOTE_AUDIO_REASON_REMOTE_MUTED = 5,
3759 REMOTE_AUDIO_REASON_REMOTE_UNMUTED = 6,
3763 REMOTE_AUDIO_REASON_REMOTE_OFFLINE = 7,
3767 REMOTE_AUDIO_REASON_NO_PACKET_RECEIVE = 8,
3771 REMOTE_AUDIO_REASON_LOCAL_PLAY_FAILED = 9,
3772 };
3773
3777 enum REMOTE_VIDEO_STATE {
3783 REMOTE_VIDEO_STATE_STOPPED = 0,
3787 REMOTE_VIDEO_STATE_STARTING = 1,
3794 REMOTE_VIDEO_STATE_DECODING = 2,
3799 REMOTE_VIDEO_STATE_FROZEN = 3,
3804 REMOTE_VIDEO_STATE_FAILED = 4,
3805 };
3809 enum REMOTE_VIDEO_STATE_REASON {
3813 REMOTE_VIDEO_STATE_REASON_INTERNAL = 0,
3817 REMOTE_VIDEO_STATE_REASON_NETWORK_CONGESTION = 1,
3821 REMOTE_VIDEO_STATE_REASON_NETWORK_RECOVERY = 2,
3825 REMOTE_VIDEO_STATE_REASON_LOCAL_MUTED = 3,
3829 REMOTE_VIDEO_STATE_REASON_LOCAL_UNMUTED = 4,
3833 REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED = 5,
3837 REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED = 6,
3841 REMOTE_VIDEO_STATE_REASON_REMOTE_OFFLINE = 7,
3846 REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK = 8,
3851 REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK_RECOVERY = 9,
3854 REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_LOW = 10,
3857 REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_HIGH = 11,
3861 REMOTE_VIDEO_STATE_REASON_SDK_IN_BACKGROUND = 12,
3862
3866 REMOTE_VIDEO_STATE_REASON_CODEC_NOT_SUPPORT = 13,
3867
3868 };
3869
3873 enum REMOTE_USER_STATE {
3877 USER_STATE_MUTE_AUDIO = (1 << 0),
3881 USER_STATE_MUTE_VIDEO = (1 << 1),
3885 USER_STATE_ENABLE_VIDEO = (1 << 4),
3889 USER_STATE_ENABLE_LOCAL_VIDEO = (1 << 8),
3890 };
3891
3896 struct VideoTrackInfo {
3897 VideoTrackInfo()
3898 : isLocal(false),
3899 ownerUid(0),
3900 trackId(0),
3901 channelId(OPTIONAL_NULLPTR),
3902 codecType(VIDEO_CODEC_H265),
3903 encodedFrameOnly(false),
3904 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
3905 observationPosition(agora::media::base::POSITION_POST_CAPTURER) {}
3911 bool isLocal;
3915 uid_t ownerUid;
3919 track_id_t trackId;
3923 const char* channelId;
3927 VIDEO_CODEC_TYPE codecType;
3933 bool encodedFrameOnly;
3937 VIDEO_SOURCE_TYPE sourceType;
3941 uint32_t observationPosition;
3942 };
3943
3948 enum REMOTE_VIDEO_DOWNSCALE_LEVEL {
3952 REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE,
3956 REMOTE_VIDEO_DOWNSCALE_LEVEL_1,
3960 REMOTE_VIDEO_DOWNSCALE_LEVEL_2,
3964 REMOTE_VIDEO_DOWNSCALE_LEVEL_3,
3968 REMOTE_VIDEO_DOWNSCALE_LEVEL_4,
3969 };
3970
3974 struct AudioVolumeInfo {
3981 uid_t uid;
3990 unsigned int volume; // [0,255]
4001 unsigned int vad;
4007 double voicePitch;
4008
4009 AudioVolumeInfo() : uid(0), volume(0), vad(0), voicePitch(0.0) {}
4010 };
4011
4018 struct DeviceInfo {
4024 bool isLowLatencyAudioSupported;
4025
4026 DeviceInfo() : isLowLatencyAudioSupported(false) {}
4027 };
4028
4032 class IPacketObserver {
4033 public:
4034 virtual ~IPacketObserver() {}
4038 struct Packet {
4044 const unsigned char* buffer;
4048 unsigned int size;
4049
4050 Packet() : buffer(OPTIONAL_NULLPTR), size(0) {}
4051 };
4061 virtual bool onSendAudioPacket(Packet& packet) = 0;
4071 virtual bool onSendVideoPacket(Packet& packet) = 0;
4081 virtual bool onReceiveAudioPacket(Packet& packet) = 0;
4091 virtual bool onReceiveVideoPacket(Packet& packet) = 0;
4092 };
4093
4097 enum AUDIO_SAMPLE_RATE_TYPE {
4101 AUDIO_SAMPLE_RATE_32000 = 32000,
4105 AUDIO_SAMPLE_RATE_44100 = 44100,
4109 AUDIO_SAMPLE_RATE_48000 = 48000,
4110 };
4114 enum VIDEO_CODEC_TYPE_FOR_STREAM {
4118 VIDEO_CODEC_H264_FOR_STREAM = 1,
4122 VIDEO_CODEC_H265_FOR_STREAM = 2,
4123 };
4124
4128 enum VIDEO_CODEC_PROFILE_TYPE {
4132 VIDEO_CODEC_PROFILE_BASELINE = 66,
4137 VIDEO_CODEC_PROFILE_MAIN = 77,
4142 VIDEO_CODEC_PROFILE_HIGH = 100,
4143 };
4144
4148 enum AUDIO_CODEC_PROFILE_TYPE {
4152 AUDIO_CODEC_PROFILE_LC_AAC = 0,
4156 AUDIO_CODEC_PROFILE_HE_AAC = 1,
4160 AUDIO_CODEC_PROFILE_HE_AAC_V2 = 2,
4161 };
4162
4166 struct LocalAudioStats {
4170 int numChannels;
4174 int sentSampleRate;
4178 int sentBitrate;
4182 int internalCodec;
4187 unsigned short txPacketLossRate;
4191 int audioDeviceDelay;
4195 int audioPlayoutDelay;
4199 int earMonitorDelay;
4204 int aecEstimatedDelay;
4205 };
4206
4210 enum RTMP_STREAM_PUBLISH_STATE {
4214 RTMP_STREAM_PUBLISH_STATE_IDLE = 0,
4218 RTMP_STREAM_PUBLISH_STATE_CONNECTING = 1,
4223 RTMP_STREAM_PUBLISH_STATE_RUNNING = 2,
4232 RTMP_STREAM_PUBLISH_STATE_RECOVERING = 3,
4237 RTMP_STREAM_PUBLISH_STATE_FAILURE = 4,
4243 RTMP_STREAM_PUBLISH_STATE_DISCONNECTING = 5,
4244 };
4245
4249 enum RTMP_STREAM_PUBLISH_REASON {
4253 RTMP_STREAM_PUBLISH_REASON_OK = 0,
4257 RTMP_STREAM_PUBLISH_REASON_INVALID_ARGUMENT = 1,
4261 RTMP_STREAM_PUBLISH_REASON_ENCRYPTED_STREAM_NOT_ALLOWED = 2,
4265 RTMP_STREAM_PUBLISH_REASON_CONNECTION_TIMEOUT = 3,
4269 RTMP_STREAM_PUBLISH_REASON_INTERNAL_SERVER_ERROR = 4,
4273 RTMP_STREAM_PUBLISH_REASON_RTMP_SERVER_ERROR = 5,
4277 RTMP_STREAM_PUBLISH_REASON_TOO_OFTEN = 6,
4281 RTMP_STREAM_PUBLISH_REASON_REACH_LIMIT = 7,
4286 RTMP_STREAM_PUBLISH_REASON_NOT_AUTHORIZED = 8,
4290 RTMP_STREAM_PUBLISH_REASON_STREAM_NOT_FOUND = 9,
4295 RTMP_STREAM_PUBLISH_REASON_FORMAT_NOT_SUPPORTED = 10,
4300 RTMP_STREAM_PUBLISH_REASON_NOT_BROADCASTER =
4301 11, // Note: match to ERR_PUBLISH_STREAM_NOT_BROADCASTER in AgoraBase.h
4306 RTMP_STREAM_PUBLISH_REASON_TRANSCODING_NO_MIX_STREAM =
4307 13, // Note: match to ERR_PUBLISH_STREAM_TRANSCODING_NO_MIX_STREAM in AgoraBase.h
4311 RTMP_STREAM_PUBLISH_REASON_NET_DOWN = 14, // Note: match to ERR_NET_DOWN in AgoraBase.h
4315 RTMP_STREAM_PUBLISH_REASON_INVALID_APPID =
4316 15, // Note: match to ERR_PUBLISH_STREAM_APPID_INVALID in AgoraBase.h
4320 RTMP_STREAM_PUBLISH_REASON_INVALID_PRIVILEGE = 16,
4325 RTMP_STREAM_UNPUBLISH_REASON_OK = 100,
4326 };
4327
4331 enum RTMP_STREAMING_EVENT {
4335 RTMP_STREAMING_EVENT_FAILED_LOAD_IMAGE = 1,
4340 RTMP_STREAMING_EVENT_URL_ALREADY_IN_USE = 2,
4344 RTMP_STREAMING_EVENT_ADVANCED_FEATURE_NOT_SUPPORT = 3,
4348 RTMP_STREAMING_EVENT_REQUEST_TOO_OFTEN = 4,
4349 };
4350
4358 typedef struct RtcImage {
4363 const char* url;
4368 int x;
4373 int y;
4377 int width;
4381 int height;
4389 int zOrder;
4395 double alpha;
4396
4397 RtcImage() : url(OPTIONAL_NULLPTR), x(0), y(0), width(0), height(0), zOrder(0), alpha(1.0) {}
4398 } RtcImage;
4407 struct LiveStreamAdvancedFeature {
4408 LiveStreamAdvancedFeature() : featureName(OPTIONAL_NULLPTR), opened(false) {}
4409 LiveStreamAdvancedFeature(const char* feat_name, bool open)
4410 : featureName(feat_name), opened(open) {}
4412 // static const char* LBHQ = "lbhq";
4414 // static const char* VEO = "veo";
4415
4420 const char* featureName;
4421
4427 bool opened;
4428 };
4429
4433 enum CONNECTION_STATE_TYPE {
4441 CONNECTION_STATE_DISCONNECTED = 1,
4451 CONNECTION_STATE_CONNECTING = 2,
4459 CONNECTION_STATE_CONNECTED = 3,
4469 CONNECTION_STATE_RECONNECTING = 4,
4479 CONNECTION_STATE_FAILED = 5,
4480 };
4481
4485 struct TranscodingUser {
4489 uid_t uid;
4495 int x;
4501 int y;
4505 int width;
4509 int height;
4518 int zOrder;
4524 double alpha;
4544 int audioChannel;
4545
4546 TranscodingUser()
4547 : uid(0), x(0), y(0), width(0), height(0), zOrder(0), alpha(1.0), audioChannel(0) {}
4548 };
4549
4553 struct LiveTranscoding {
4561 int width;
4569 int height;
4576 int videoBitrate;
4582 int videoFramerate;
4583
4591 bool lowLatency;
4592
4596 int videoGop;
4602 VIDEO_CODEC_PROFILE_TYPE videoCodecProfile;
4607 unsigned int backgroundColor;
4611 VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType;
4615 unsigned int userCount;
4620 TranscodingUser* transcodingUsers;
4626 const char* transcodingExtraInfo;
4627
4633 const char* metadata;
4639 RtcImage* watermark;
4644 unsigned int watermarkCount;
4645
4652 RtcImage* backgroundImage;
4657 unsigned int backgroundImageCount;
4658
4662 AUDIO_SAMPLE_RATE_TYPE audioSampleRate;
4667 int audioBitrate;
4677 int audioChannels;
4681 AUDIO_CODEC_PROFILE_TYPE audioCodecProfile;
4685 LiveStreamAdvancedFeature* advancedFeatures;
4686
4690 unsigned int advancedFeatureCount;
4691
4692 LiveTranscoding()
4693 : width(360),
4694 height(640),
4695 videoBitrate(400),
4696 videoFramerate(15),
4697 lowLatency(false),
4698 videoGop(30),
4699 videoCodecProfile(VIDEO_CODEC_PROFILE_HIGH),
4700 backgroundColor(0x000000),
4701 videoCodecType(VIDEO_CODEC_H264_FOR_STREAM),
4702 userCount(0),
4703 transcodingUsers(OPTIONAL_NULLPTR),
4704 transcodingExtraInfo(OPTIONAL_NULLPTR),
4705 metadata(OPTIONAL_NULLPTR),
4706 watermark(OPTIONAL_NULLPTR),
4707 watermarkCount(0),
4708 backgroundImage(OPTIONAL_NULLPTR),
4709 backgroundImageCount(0),
4710 audioSampleRate(AUDIO_SAMPLE_RATE_48000),
4711 audioBitrate(48),
4712 audioChannels(1),
4713 audioCodecProfile(AUDIO_CODEC_PROFILE_LC_AAC),
4714 advancedFeatures(OPTIONAL_NULLPTR),
4715 advancedFeatureCount(0) {}
4716 };
4717
4721 struct TranscodingVideoStream {
4725 VIDEO_SOURCE_TYPE sourceType;
4731 uid_t remoteUserUid;
4738 const char* imageUrl;
4743 int mediaPlayerId;
4748 int x;
4753 int y;
4757 int width;
4761 int height;
4768 int zOrder;
4773 double alpha;
4780 bool mirror;
4781
4782 TranscodingVideoStream()
4783 : sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
4784 remoteUserUid(0),
4785 imageUrl(OPTIONAL_NULLPTR),
4786 x(0),
4787 y(0),
4788 width(0),
4789 height(0),
4790 zOrder(0),
4791 alpha(1.0),
4792 mirror(false) {}
4793 };
4794
4798 struct LocalTranscoderConfiguration {
4802 unsigned int streamCount;
4806 TranscodingVideoStream* videoInputStreams;
4811 VideoEncoderConfiguration videoOutputConfiguration;
4820 bool syncWithPrimaryCamera;
4821
4822 LocalTranscoderConfiguration()
4823 : streamCount(0),
4824 videoInputStreams(OPTIONAL_NULLPTR),
4825 videoOutputConfiguration(),
4826 syncWithPrimaryCamera(true) {}
4827 };
4828
4832 enum VIDEO_TRANSCODER_ERROR {
4837 VT_ERR_VIDEO_SOURCE_NOT_READY = 1,
4841 VT_ERR_INVALID_VIDEO_SOURCE_TYPE = 2,
4845 VT_ERR_INVALID_IMAGE_PATH = 3,
4849 VT_ERR_UNSUPPORT_IMAGE_FORMAT = 4,
4853 VT_ERR_INVALID_LAYOUT = 5,
4857 VT_ERR_INTERNAL = 20
4858 };
4859
4860
4864 struct MixedAudioStream {
4868 AUDIO_SOURCE_TYPE sourceType;
4874 uid_t remoteUserUid;
4888 const char* channelId;
4895 track_id_t trackId;
4896
4897 MixedAudioStream(AUDIO_SOURCE_TYPE source)
4898 : sourceType(source),
4899 remoteUserUid(0),
4900 channelId(NULL),
4901 trackId(-1) {}
4902
4903 MixedAudioStream(AUDIO_SOURCE_TYPE source, track_id_t track)
4904 : sourceType(source),
4905 trackId(track) {}
4906
4907 MixedAudioStream(AUDIO_SOURCE_TYPE source, uid_t uid, const char* channel)
4908 : sourceType(source),
4909 remoteUserUid(uid),
4910 channelId(channel) {}
4911
4912 MixedAudioStream(AUDIO_SOURCE_TYPE source, uid_t uid, const char* channel, track_id_t track)
4913 : sourceType(source),
4914 remoteUserUid(uid),
4915 channelId(channel),
4916 trackId(track) {}
4917
4918 };
4919
4923 struct LocalAudioMixerConfiguration {
4927 unsigned int streamCount;
4931 MixedAudioStream* audioInputStreams;
4932
4940 bool syncWithLocalMic;
4941
4942 LocalAudioMixerConfiguration() : streamCount(0), syncWithLocalMic(true) {}
4943 };
4944
4948 struct LastmileProbeConfig {
4955 bool probeUplink;
4961 bool probeDownlink;
4966 unsigned int expectedUplinkBitrate;
4971 unsigned int expectedDownlinkBitrate;
4972 };
4973
4977 enum LASTMILE_PROBE_RESULT_STATE {
4981 LASTMILE_PROBE_RESULT_COMPLETE = 1,
4987 LASTMILE_PROBE_RESULT_INCOMPLETE_NO_BWE = 2,
4991 LASTMILE_PROBE_RESULT_UNAVAILABLE = 3
4992 };
4993
4997 struct LastmileProbeOneWayResult {
5001 unsigned int packetLossRate;
5005 unsigned int jitter;
5009 unsigned int availableBandwidth;
5010
5011 LastmileProbeOneWayResult() : packetLossRate(0), jitter(0), availableBandwidth(0) {}
5012 };
5013
5017 struct LastmileProbeResult {
5021 LASTMILE_PROBE_RESULT_STATE state;
5025 LastmileProbeOneWayResult uplinkReport;
5029 LastmileProbeOneWayResult downlinkReport;
5033 unsigned int rtt;
5034
5035 LastmileProbeResult() : state(LASTMILE_PROBE_RESULT_UNAVAILABLE), rtt(0) {}
5036 };
5037
5041 enum CONNECTION_CHANGED_REASON_TYPE {
5045 CONNECTION_CHANGED_CONNECTING = 0,
5049 CONNECTION_CHANGED_JOIN_SUCCESS = 1,
5053 CONNECTION_CHANGED_INTERRUPTED = 2,
5058 CONNECTION_CHANGED_BANNED_BY_SERVER = 3,
5064 CONNECTION_CHANGED_JOIN_FAILED = 4,
5068 CONNECTION_CHANGED_LEAVE_CHANNEL = 5,
5073 CONNECTION_CHANGED_INVALID_APP_ID = 6,
5083 CONNECTION_CHANGED_INVALID_CHANNEL_NAME = 7,
5098 CONNECTION_CHANGED_INVALID_TOKEN = 8,
5103 CONNECTION_CHANGED_TOKEN_EXPIRED = 9,
5112 CONNECTION_CHANGED_REJECTED_BY_SERVER = 10,
5116 CONNECTION_CHANGED_SETTING_PROXY_SERVER = 11,
5120 CONNECTION_CHANGED_RENEW_TOKEN = 12,
5125 CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED = 13,
5130 CONNECTION_CHANGED_KEEP_ALIVE_TIMEOUT = 14,
5134 CONNECTION_CHANGED_REJOIN_SUCCESS = 15,
5138 CONNECTION_CHANGED_LOST = 16,
5142 CONNECTION_CHANGED_ECHO_TEST = 17,
5146 CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED_BY_USER = 18,
5150 CONNECTION_CHANGED_SAME_UID_LOGIN = 19,
5154 CONNECTION_CHANGED_TOO_MANY_BROADCASTERS = 20,
5155
5159 CONNECTION_CHANGED_LICENSE_VALIDATION_FAILURE = 21,
5160 /*
5161 * 22: The connection is failed due to certification verify failure.
5162 */
5163 CONNECTION_CHANGED_CERTIFICATION_VERYFY_FAILURE = 22,
5167 CONNECTION_CHANGED_STREAM_CHANNEL_NOT_AVAILABLE = 23,
5171 CONNECTION_CHANGED_INCONSISTENT_APPID = 24,
5172 };
5173
5177 enum CLIENT_ROLE_CHANGE_FAILED_REASON {
5184 CLIENT_ROLE_CHANGE_FAILED_TOO_MANY_BROADCASTERS = 1,
5189 CLIENT_ROLE_CHANGE_FAILED_NOT_AUTHORIZED = 2,
5195 CLIENT_ROLE_CHANGE_FAILED_REQUEST_TIME_OUT __deprecated = 3,
5201 CLIENT_ROLE_CHANGE_FAILED_CONNECTION_FAILED __deprecated = 4,
5202 };
5203
5207 enum NETWORK_TYPE {
5211 NETWORK_TYPE_UNKNOWN = -1,
5215 NETWORK_TYPE_DISCONNECTED = 0,
5219 NETWORK_TYPE_LAN = 1,
5223 NETWORK_TYPE_WIFI = 2,
5227 NETWORK_TYPE_MOBILE_2G = 3,
5231 NETWORK_TYPE_MOBILE_3G = 4,
5235 NETWORK_TYPE_MOBILE_4G = 5,
5239 NETWORK_TYPE_MOBILE_5G = 6,
5240 };
5241
5245 enum VIDEO_VIEW_SETUP_MODE {
5249 VIDEO_VIEW_SETUP_REPLACE = 0,
5253 VIDEO_VIEW_SETUP_ADD = 1,
5260 VIDEO_VIEW_SETUP_REMOVE = 2,
5261 };
5262
5266 struct VideoCanvas {
5270 uid_t uid;
5271
5275 uid_t subviewUid;
5281 view_t view;
5286 uint32_t backgroundColor;
5290 media::base::RENDER_MODE_TYPE renderMode;
5298 VIDEO_MIRROR_MODE_TYPE mirrorMode;
5302 VIDEO_VIEW_SETUP_MODE setupMode;
5306 VIDEO_SOURCE_TYPE sourceType;
5310 int mediaPlayerId;
5316 Rectangle cropArea;
5329 bool enableAlphaMask;
5333 media::base::VIDEO_MODULE_POSITION position;
5334
5335 VideoCanvas()
5336 : uid(0),
5337 subviewUid(0),
5338 view(NULL),
5339 backgroundColor(0x00000000),
5340 renderMode(media::base::RENDER_MODE_HIDDEN),
5341 mirrorMode(VIDEO_MIRROR_MODE_AUTO),
5342 setupMode(VIDEO_VIEW_SETUP_REPLACE),
5343 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
5344 mediaPlayerId(-ERR_NOT_READY),
5345 cropArea(0, 0, 0, 0),
5346 enableAlphaMask(false),
5347 position(media::base::POSITION_POST_CAPTURER) {}
5348
5349 VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt)
5350 : uid(0),
5351 subviewUid(0),
5352 view(v),
5353 backgroundColor(0x00000000),
5354 renderMode(m),
5355 mirrorMode(mt),
5356 setupMode(VIDEO_VIEW_SETUP_REPLACE),
5357 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
5358 mediaPlayerId(-ERR_NOT_READY),
5359 cropArea(0, 0, 0, 0),
5360 enableAlphaMask(false),
5361 position(media::base::POSITION_POST_CAPTURER) {}
5362
5363 VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u)
5364 : uid(u),
5365 subviewUid(0),
5366 view(v),
5367 backgroundColor(0x00000000),
5368 renderMode(m),
5369 mirrorMode(mt),
5370 setupMode(VIDEO_VIEW_SETUP_REPLACE),
5371 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
5372 mediaPlayerId(-ERR_NOT_READY),
5373 cropArea(0, 0, 0, 0),
5374 enableAlphaMask(false),
5375 position(media::base::POSITION_POST_CAPTURER) {}
5376
5377 VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u,
5378 uid_t subu)
5379 : uid(u),
5380 subviewUid(subu),
5381 view(v),
5382 backgroundColor(0x00000000),
5383 renderMode(m),
5384 mirrorMode(mt),
5385 setupMode(VIDEO_VIEW_SETUP_REPLACE),
5386 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
5387 mediaPlayerId(-ERR_NOT_READY),
5388 cropArea(0, 0, 0, 0),
5389 enableAlphaMask(false),
5390 position(media::base::POSITION_POST_CAPTURER) {}
5391 };
5392
5396 struct BeautyOptions {
5400 enum LIGHTENING_CONTRAST_LEVEL {
5404 LIGHTENING_CONTRAST_LOW = 0,
5408 LIGHTENING_CONTRAST_NORMAL = 1,
5412 LIGHTENING_CONTRAST_HIGH = 2,
5413 };
5414
5419 LIGHTENING_CONTRAST_LEVEL lighteningContrastLevel;
5420
5425 float lighteningLevel;
5426
5431 float smoothnessLevel;
5432
5437 float rednessLevel;
5438
5443 float sharpnessLevel;
5444
5445 BeautyOptions(LIGHTENING_CONTRAST_LEVEL contrastLevel, float lightening, float smoothness,
5446 float redness, float sharpness)
5447 : lighteningContrastLevel(contrastLevel),
5448 lighteningLevel(lightening),
5449 smoothnessLevel(smoothness),
5450 rednessLevel(redness),
5451 sharpnessLevel(sharpness) {}
5452
5453 BeautyOptions()
5454 : lighteningContrastLevel(LIGHTENING_CONTRAST_NORMAL),
5455 lighteningLevel(0),
5456 smoothnessLevel(0),
5457 rednessLevel(0),
5458 sharpnessLevel(0) {}
5459 };
5460
5466 struct FaceShapeAreaOptions {
5472 enum FACE_SHAPE_AREA {
5476 FACE_SHAPE_AREA_NONE = -1,
5481 FACE_SHAPE_AREA_HEADSCALE = 100,
5486 FACE_SHAPE_AREA_FOREHEAD = 101,
5491 FACE_SHAPE_AREA_FACECONTOUR = 102,
5497 FACE_SHAPE_AREA_FACELENGTH = 103,
5502 FACE_SHAPE_AREA_FACEWIDTH = 104,
5508 FACE_SHAPE_AREA_CHEEKBONE = 105,
5513 FACE_SHAPE_AREA_CHEEK = 106,
5519 FACE_SHAPE_AREA_MANDIBLE = 107,
5525 FACE_SHAPE_AREA_CHIN = 108,
5530 FACE_SHAPE_AREA_EYESCALE = 200,
5537 FACE_SHAPE_AREA_EYEDISTANCE = 201,
5544 FACE_SHAPE_AREA_EYEPOSITION = 202,
5550 FACE_SHAPE_AREA_LOWEREYELID = 203,
5556 FACE_SHAPE_AREA_EYEPUPILS = 204,
5563 FACE_SHAPE_AREA_EYEINNERCORNER = 205,
5570 FACE_SHAPE_AREA_EYEOUTERCORNER = 206,
5575 FACE_SHAPE_AREA_NOSELENGTH = 300,
5581 FACE_SHAPE_AREA_NOSEWIDTH = 301,
5587 FACE_SHAPE_AREA_NOSEWING = 302,
5593 FACE_SHAPE_AREA_NOSEROOT = 303,
5599 FACE_SHAPE_AREA_NOSEBRIDGE = 304,
5605 FACE_SHAPE_AREA_NOSETIP = 305,
5612 FACE_SHAPE_AREA_NOSEGENERAL = 306,
5619 FACE_SHAPE_AREA_MOUTHSCALE = 400,
5625 FACE_SHAPE_AREA_MOUTHPOSITION = 401,
5631 FACE_SHAPE_AREA_MOUTHSMILE = 402,
5638 FACE_SHAPE_AREA_MOUTHLIP = 403,
5645 FACE_SHAPE_AREA_EYEBROWPOSITION = 500,
5651 FACE_SHAPE_AREA_EYEBROWTHICKNESS = 501,
5652 };
5653
5657 FACE_SHAPE_AREA shapeArea;
5658
5663 int shapeIntensity;
5664
5665 FaceShapeAreaOptions(FACE_SHAPE_AREA shapeArea, int areaIntensity) : shapeArea(shapeArea), shapeIntensity(areaIntensity) {}
5666
5667 FaceShapeAreaOptions() : shapeArea(FACE_SHAPE_AREA_NONE), shapeIntensity(0) {}
5668 };
5669
5675 struct FaceShapeBeautyOptions {
5681 enum FACE_SHAPE_BEAUTY_STYLE {
5685 FACE_SHAPE_BEAUTY_STYLE_FEMALE = 0,
5689 FACE_SHAPE_BEAUTY_STYLE_MALE = 1,
5694 FACE_SHAPE_BEAUTY_STYLE_NATURAL = 2,
5695 };
5696
5700 FACE_SHAPE_BEAUTY_STYLE shapeStyle;
5701
5707 int styleIntensity;
5708
5709 FaceShapeBeautyOptions(FACE_SHAPE_BEAUTY_STYLE shapeStyle, int styleIntensity) : shapeStyle(shapeStyle), styleIntensity(styleIntensity) {}
5710
5711 FaceShapeBeautyOptions() : shapeStyle(FACE_SHAPE_BEAUTY_STYLE_FEMALE), styleIntensity(50) {}
5712 };
5713
5719 struct FilterEffectOptions {
5737 const char * path;
5738
5743 float strength;
5744
5745 FilterEffectOptions(const char * lut3dPath, float filterStrength) : path(lut3dPath), strength(filterStrength) {}
5746
5747 FilterEffectOptions() : path(OPTIONAL_NULLPTR), strength(0.5) {}
5748 };
5749
5753 struct LowlightEnhanceOptions {
5757 enum LOW_LIGHT_ENHANCE_MODE {
5763 LOW_LIGHT_ENHANCE_AUTO = 0,
5767 LOW_LIGHT_ENHANCE_MANUAL = 1,
5768 };
5772 enum LOW_LIGHT_ENHANCE_LEVEL {
5778 LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY = 0,
5783 LOW_LIGHT_ENHANCE_LEVEL_FAST = 1,
5784 };
5785
5789 LOW_LIGHT_ENHANCE_MODE mode;
5790
5794 LOW_LIGHT_ENHANCE_LEVEL level;
5795
5796 LowlightEnhanceOptions(LOW_LIGHT_ENHANCE_MODE lowlightMode, LOW_LIGHT_ENHANCE_LEVEL lowlightLevel)
5797 : mode(lowlightMode), level(lowlightLevel) {}
5798
5799 LowlightEnhanceOptions()
5800 : mode(LOW_LIGHT_ENHANCE_AUTO), level(LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY) {}
5801 };
5807 struct VideoDenoiserOptions {
5811 enum VIDEO_DENOISER_MODE {
5816 VIDEO_DENOISER_AUTO = 0,
5820 VIDEO_DENOISER_MANUAL = 1,
5821 };
5825 enum VIDEO_DENOISER_LEVEL {
5831 VIDEO_DENOISER_LEVEL_HIGH_QUALITY = 0,
5839 VIDEO_DENOISER_LEVEL_FAST = 1,
5840 };
5844 VIDEO_DENOISER_MODE mode;
5845
5849 VIDEO_DENOISER_LEVEL level;
5850
5851 VideoDenoiserOptions(VIDEO_DENOISER_MODE denoiserMode, VIDEO_DENOISER_LEVEL denoiserLevel)
5852 : mode(denoiserMode), level(denoiserLevel) {}
5853
5854 VideoDenoiserOptions() : mode(VIDEO_DENOISER_AUTO), level(VIDEO_DENOISER_LEVEL_HIGH_QUALITY) {}
5855 };
5856
5862 struct ColorEnhanceOptions {
5868 float strengthLevel;
5869
5881 float skinProtectLevel;
5882
5883 ColorEnhanceOptions(float stength, float skinProtect)
5884 : strengthLevel(stength), skinProtectLevel(skinProtect) {}
5885
5886 ColorEnhanceOptions() : strengthLevel(0), skinProtectLevel(1) {}
5887 };
5888
5892 struct VirtualBackgroundSource {
5896 enum BACKGROUND_SOURCE_TYPE {
5902 BACKGROUND_NONE = 0,
5906 BACKGROUND_COLOR = 1,
5910 BACKGROUND_IMG = 2,
5914 BACKGROUND_BLUR = 3,
5918 BACKGROUND_VIDEO = 4,
5919 };
5920
5924 enum BACKGROUND_BLUR_DEGREE {
5929 BLUR_DEGREE_LOW = 1,
5934 BLUR_DEGREE_MEDIUM = 2,
5939 BLUR_DEGREE_HIGH = 3,
5940 };
5941
5945 BACKGROUND_SOURCE_TYPE background_source_type;
5946
5959 unsigned int color;
5960
5968 const char* source;
5969
5975 BACKGROUND_BLUR_DEGREE blur_degree;
5976
5977 VirtualBackgroundSource()
5978 : background_source_type(BACKGROUND_COLOR),
5979 color(0xffffff),
5980 source(OPTIONAL_NULLPTR),
5981 blur_degree(BLUR_DEGREE_HIGH) {}
5982 };
5983
5987 struct SegmentationProperty {
5991 enum SEG_MODEL_TYPE {
5995 SEG_MODEL_AI = 1,
5999 SEG_MODEL_GREEN = 2
6000 };
6001
6005 enum SCREEN_COLOR_TYPE {
6009 SCREEN_COLOR_AUTO = 0,
6013 SCREEN_COLOR_GREEN = 1,
6017 SCREEN_COLOR_BLUE = 2
6018 };
6019
6023 SEG_MODEL_TYPE modelType;
6024
6033 float greenCapacity;
6034
6038 SCREEN_COLOR_TYPE screenColorType;
6039
6040 SegmentationProperty() : modelType(SEG_MODEL_AI), greenCapacity(0.5), screenColorType(SCREEN_COLOR_AUTO) {}
6041 };
6042
6046 enum AUDIO_TRACK_TYPE {
6050 AUDIO_TRACK_INVALID = -1,
6056 AUDIO_TRACK_MIXABLE = 0,
6066 AUDIO_TRACK_DIRECT = 1,
6067 };
6068
6072 struct AudioTrackConfig {
6078 bool enableLocalPlayback;
6086 bool enableAudioProcessing;
6087
6088 AudioTrackConfig() : enableLocalPlayback(true),enableAudioProcessing(false) {}
6089 };
6090
6112 enum VOICE_BEAUTIFIER_PRESET {
6116 VOICE_BEAUTIFIER_OFF = 0x00000000,
6122 CHAT_BEAUTIFIER_MAGNETIC = 0x01010100,
6128 CHAT_BEAUTIFIER_FRESH = 0x01010200,
6134 CHAT_BEAUTIFIER_VITALITY = 0x01010300,
6144 SINGING_BEAUTIFIER = 0x01020100,
6148 TIMBRE_TRANSFORMATION_VIGOROUS = 0x01030100,
6152 TIMBRE_TRANSFORMATION_DEEP = 0x01030200,
6156 TIMBRE_TRANSFORMATION_MELLOW = 0x01030300,
6160 TIMBRE_TRANSFORMATION_FALSETTO = 0x01030400,
6164 TIMBRE_TRANSFORMATION_FULL = 0x01030500,
6168 TIMBRE_TRANSFORMATION_CLEAR = 0x01030600,
6172 TIMBRE_TRANSFORMATION_RESOUNDING = 0x01030700,
6176 TIMBRE_TRANSFORMATION_RINGING = 0x01030800,
6187 ULTRA_HIGH_QUALITY_VOICE = 0x01040100
6188 };
6189
6201 enum AUDIO_EFFECT_PRESET {
6205 AUDIO_EFFECT_OFF = 0x00000000,
6209 ROOM_ACOUSTICS_KTV = 0x02010100,
6213 ROOM_ACOUSTICS_VOCAL_CONCERT = 0x02010200,
6217 ROOM_ACOUSTICS_STUDIO = 0x02010300,
6221 ROOM_ACOUSTICS_PHONOGRAPH = 0x02010400,
6225 ROOM_ACOUSTICS_VIRTUAL_STEREO = 0x02010500,
6229 ROOM_ACOUSTICS_SPACIAL = 0x02010600,
6233 ROOM_ACOUSTICS_ETHEREAL = 0x02010700,
6241 ROOM_ACOUSTICS_3D_VOICE = 0x02010800,
6248 ROOM_ACOUSTICS_VIRTUAL_SURROUND_SOUND = 0x02010900,
6253 ROOM_ACOUSTICS_CHORUS = 0x02010D00,
6259 VOICE_CHANGER_EFFECT_UNCLE = 0x02020100,
6265 VOICE_CHANGER_EFFECT_OLDMAN = 0x02020200,
6271 VOICE_CHANGER_EFFECT_BOY = 0x02020300,
6277 VOICE_CHANGER_EFFECT_SISTER = 0x02020400,
6283 VOICE_CHANGER_EFFECT_GIRL = 0x02020500,
6287 VOICE_CHANGER_EFFECT_PIGKING = 0x02020600,
6291 VOICE_CHANGER_EFFECT_HULK = 0x02020700,
6295 STYLE_TRANSFORMATION_RNB = 0x02030100,
6299 STYLE_TRANSFORMATION_POPULAR = 0x02030200,
6305 PITCH_CORRECTION = 0x02040100,
6306
6310 };
6311
6315 enum VOICE_CONVERSION_PRESET {
6319 VOICE_CONVERSION_OFF = 0x00000000,
6324 VOICE_CHANGER_NEUTRAL = 0x03010100,
6329 VOICE_CHANGER_SWEET = 0x03010200,
6334 VOICE_CHANGER_SOLID = 0x03010300,
6339 VOICE_CHANGER_BASS = 0x03010400,
6342 VOICE_CHANGER_CARTOON = 0x03010500,
6345 VOICE_CHANGER_CHILDLIKE = 0x03010600,
6348 VOICE_CHANGER_PHONE_OPERATOR = 0x03010700,
6351 VOICE_CHANGER_MONSTER = 0x03010800,
6354 VOICE_CHANGER_TRANSFORMERS = 0x03010900,
6357 VOICE_CHANGER_GROOT = 0x03010A00,
6360 VOICE_CHANGER_DARTH_VADER = 0x03010B00,
6363 VOICE_CHANGER_IRON_LADY = 0x03010C00,
6366 VOICE_CHANGER_SHIN_CHAN = 0x03010D00,
6369 VOICE_CHANGER_GIRLISH_MAN = 0x03010E00,
6372 VOICE_CHANGER_CHIPMUNK = 0x03010F00,
6373
6374 };
6375
6379 enum HEADPHONE_EQUALIZER_PRESET {
6383 HEADPHONE_EQUALIZER_OFF = 0x00000000,
6387 HEADPHONE_EQUALIZER_OVEREAR = 0x04000001,
6391 HEADPHONE_EQUALIZER_INEAR = 0x04000002
6392 };
6393
6397 enum VOICE_AI_TUNER_TYPE {
6401 VOICE_AI_TUNER_MATURE_MALE,
6405 VOICE_AI_TUNER_FRESH_MALE,
6409 VOICE_AI_TUNER_ELEGANT_FEMALE,
6413 VOICE_AI_TUNER_SWEET_FEMALE,
6417 VOICE_AI_TUNER_WARM_MALE_SINGING,
6421 VOICE_AI_TUNER_GENTLE_FEMALE_SINGING,
6425 VOICE_AI_TUNER_HUSKY_MALE_SINGING,
6429 VOICE_AI_TUNER_WARM_ELEGANT_FEMALE_SINGING,
6433 VOICE_AI_TUNER_POWERFUL_MALE_SINGING,
6437 VOICE_AI_TUNER_DREAMY_FEMALE_SINGING,
6438 };
6439
6447 struct ScreenAudioParameters {
6451 int sampleRate;
6455 int channels;
6459 int captureSignalVolume;
6460
6461 #if defined(__APPLE__) && !TARGET_OS_IOS
6462
6465 bool excludeCurrentProcessAudio = true;
6466 ScreenAudioParameters(): sampleRate(48000), channels(2), captureSignalVolume(100) {}
6467 #else
6468 ScreenAudioParameters(): sampleRate(16000), channels(2), captureSignalVolume(100) {}
6469 #endif
6470 };
6471
6475 struct ScreenCaptureParameters {
6476
6486 bool captureAudio;
6492 ScreenAudioParameters audioParams;
6493
6517 VideoDimensions dimensions;
6523 int frameRate;
6529 int bitrate;
6537 bool captureMouseCursor;
6546 bool windowFocus;
6553 view_t* excludeWindowList;
6559 int excludeWindowCount;
6560
6566 int highLightWidth;
6572 unsigned int highLightColor;
6580 bool enableHighLight;
6581
6582 ScreenCaptureParameters()
6583 : captureAudio(false),
6584 dimensions(1920, 1080),
6585 frameRate(5),
6586 bitrate(STANDARD_BITRATE),
6587 captureMouseCursor(true),
6588 windowFocus(false),
6589 excludeWindowList(OPTIONAL_NULLPTR),
6590 excludeWindowCount(0),
6591 highLightWidth(0),
6592 highLightColor(0),
6593 enableHighLight(false) {}
6594 ScreenCaptureParameters(const VideoDimensions& d, int f, int b)
6595 : captureAudio(false),dimensions(d),
6596 frameRate(f),
6597 bitrate(b),
6598 captureMouseCursor(true),
6599 windowFocus(false),
6600 excludeWindowList(OPTIONAL_NULLPTR),
6601 excludeWindowCount(0),
6602 highLightWidth(0),
6603 highLightColor(0),
6604 enableHighLight(false) {}
6605 ScreenCaptureParameters(int width, int height, int f, int b)
6606 : captureAudio(false),
6607 dimensions(width, height),
6608 frameRate(f),
6609 bitrate(b),
6610 captureMouseCursor(true),
6611 windowFocus(false),
6612 excludeWindowList(OPTIONAL_NULLPTR),
6613 excludeWindowCount(0),
6614 highLightWidth(0),
6615 highLightColor(0),
6616 enableHighLight(false) {}
6617 ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs)
6618 : captureAudio(false),
6619 dimensions(width, height),
6620 frameRate(f),
6621 bitrate(b),
6622 captureMouseCursor(cur),
6623 windowFocus(fcs),
6624 excludeWindowList(OPTIONAL_NULLPTR),
6625 excludeWindowCount(0),
6626 highLightWidth(0),
6627 highLightColor(0),
6628 enableHighLight(false) {}
6629 ScreenCaptureParameters(int width, int height, int f, int b, view_t* ex, int cnt)
6630 : captureAudio(false),
6631 dimensions(width, height),
6632 frameRate(f),
6633 bitrate(b),
6634 captureMouseCursor(true),
6635 windowFocus(false),
6636 excludeWindowList(ex),
6637 excludeWindowCount(cnt),
6638 highLightWidth(0),
6639 highLightColor(0),
6640 enableHighLight(false) {}
6641 ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs, view_t* ex,
6642 int cnt)
6643 : captureAudio(false),
6644 dimensions(width, height),
6645 frameRate(f),
6646 bitrate(b),
6647 captureMouseCursor(cur),
6648 windowFocus(fcs),
6649 excludeWindowList(ex),
6650 excludeWindowCount(cnt),
6651 highLightWidth(0),
6652 highLightColor(0),
6653 enableHighLight(false) {}
6654 };
6655
6659 enum AUDIO_RECORDING_QUALITY_TYPE {
6664 AUDIO_RECORDING_QUALITY_LOW = 0,
6669 AUDIO_RECORDING_QUALITY_MEDIUM = 1,
6674 AUDIO_RECORDING_QUALITY_HIGH = 2,
6679 AUDIO_RECORDING_QUALITY_ULTRA_HIGH = 3,
6680 };
6681
6685 enum AUDIO_FILE_RECORDING_TYPE {
6689 AUDIO_FILE_RECORDING_MIC = 1,
6693 AUDIO_FILE_RECORDING_PLAYBACK = 2,
6697 AUDIO_FILE_RECORDING_MIXED = 3,
6698 };
6699
6703 enum AUDIO_ENCODED_FRAME_OBSERVER_POSITION {
6707 AUDIO_ENCODED_FRAME_OBSERVER_POSITION_RECORD = 1,
6711 AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK = 2,
6715 AUDIO_ENCODED_FRAME_OBSERVER_POSITION_MIXED = 3,
6716 };
6717
6721 struct AudioRecordingConfiguration {
6727 const char* filePath;
6733 bool encode;
6744 int sampleRate;
6748 AUDIO_FILE_RECORDING_TYPE fileRecordingType;
6753 AUDIO_RECORDING_QUALITY_TYPE quality;
6754
6768 int recordingChannel;
6769
6770 AudioRecordingConfiguration()
6771 : filePath(OPTIONAL_NULLPTR),
6772 encode(false),
6773 sampleRate(32000),
6774 fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
6775 quality(AUDIO_RECORDING_QUALITY_LOW),
6776 recordingChannel(1) {}
6777
6778 AudioRecordingConfiguration(const char* file_path, int sample_rate,
6779 AUDIO_RECORDING_QUALITY_TYPE quality_type, int channel)
6780 : filePath(file_path),
6781 encode(false),
6782 sampleRate(sample_rate),
6783 fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
6784 quality(quality_type),
6785 recordingChannel(channel) {}
6786
6787 AudioRecordingConfiguration(const char* file_path, bool enc, int sample_rate,
6788 AUDIO_FILE_RECORDING_TYPE type,
6789 AUDIO_RECORDING_QUALITY_TYPE quality_type, int channel)
6790 : filePath(file_path),
6791 encode(enc),
6792 sampleRate(sample_rate),
6793 fileRecordingType(type),
6794 quality(quality_type),
6795 recordingChannel(channel) {}
6796
6797 AudioRecordingConfiguration(const AudioRecordingConfiguration& rhs)
6798 : filePath(rhs.filePath),
6799 encode(rhs.encode),
6800 sampleRate(rhs.sampleRate),
6801 fileRecordingType(rhs.fileRecordingType),
6802 quality(rhs.quality),
6803 recordingChannel(rhs.recordingChannel) {}
6804 };
6805
6809 struct AudioEncodedFrameObserverConfig {
6813 AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType;
6817 AUDIO_ENCODING_TYPE encodingType;
6818
6819 AudioEncodedFrameObserverConfig()
6820 : postionType(AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK),
6821 encodingType(AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM) {}
6822 };
6826 class IAudioEncodedFrameObserver {
6827 public:
6841 virtual void onRecordAudioEncodedFrame(const uint8_t* frameBuffer, int length,
6842 const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
6843
6857 virtual void onPlaybackAudioEncodedFrame(const uint8_t* frameBuffer, int length,
6858 const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
6859
6873 virtual void onMixedAudioEncodedFrame(const uint8_t* frameBuffer, int length,
6874 const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
6875
6876 virtual ~IAudioEncodedFrameObserver() {}
6877 };
6878
6883 enum AREA_CODE {
6887 AREA_CODE_CN = 0x00000001,
6891 AREA_CODE_NA = 0x00000002,
6895 AREA_CODE_EU = 0x00000004,
6899 AREA_CODE_AS = 0x00000008,
6903 AREA_CODE_JP = 0x00000010,
6907 AREA_CODE_IN = 0x00000020,
6911 AREA_CODE_GLOB = (0xFFFFFFFF)
6912 };
6913
6918 enum AREA_CODE_EX {
6922 AREA_CODE_OC = 0x00000040,
6926 AREA_CODE_SA = 0x00000080,
6930 AREA_CODE_AF = 0x00000100,
6934 AREA_CODE_KR = 0x00000200,
6938 AREA_CODE_HKMC = 0x00000400,
6942 AREA_CODE_US = 0x00000800,
6946 AREA_CODE_RU = 0x00001000,
6950 AREA_CODE_OVS = 0xFFFFFFFE
6951 };
6952
6956 enum CHANNEL_MEDIA_RELAY_ERROR {
6960 RELAY_OK = 0,
6964 RELAY_ERROR_SERVER_ERROR_RESPONSE = 1,
6973 RELAY_ERROR_SERVER_NO_RESPONSE = 2,
6977 RELAY_ERROR_NO_RESOURCE_AVAILABLE = 3,
6981 RELAY_ERROR_FAILED_JOIN_SRC = 4,
6985 RELAY_ERROR_FAILED_JOIN_DEST = 5,
6989 RELAY_ERROR_FAILED_PACKET_RECEIVED_FROM_SRC = 6,
6993 RELAY_ERROR_FAILED_PACKET_SENT_TO_DEST = 7,
6998 RELAY_ERROR_SERVER_CONNECTION_LOST = 8,
7002 RELAY_ERROR_INTERNAL_ERROR = 9,
7006 RELAY_ERROR_SRC_TOKEN_EXPIRED = 10,
7010 RELAY_ERROR_DEST_TOKEN_EXPIRED = 11,
7011 };
7012
7016 enum CHANNEL_MEDIA_RELAY_STATE {
7021 RELAY_STATE_IDLE = 0,
7025 RELAY_STATE_CONNECTING = 1,
7029 RELAY_STATE_RUNNING = 2,
7033 RELAY_STATE_FAILURE = 3,
7034 };
7035
7039 struct ChannelMediaInfo {
7043 uid_t uid;
7047 const char* channelName;
7051 const char* token;
7052
7053 ChannelMediaInfo() : uid(0), channelName(NULL), token(NULL) {}
7054 ChannelMediaInfo(const char* c, const char* t, uid_t u) : uid(u), channelName(c), token(t) {}
7055 };
7056
7060 struct ChannelMediaRelayConfiguration {
7074 ChannelMediaInfo* srcInfo;
7091 ChannelMediaInfo* destInfos;
7097 int destCount;
7098
7099 ChannelMediaRelayConfiguration()
7100 : srcInfo(OPTIONAL_NULLPTR), destInfos(OPTIONAL_NULLPTR), destCount(0) {}
7101 };
7102
7106 struct UplinkNetworkInfo {
7110 int video_encoder_target_bitrate_bps;
7111
7112 UplinkNetworkInfo() : video_encoder_target_bitrate_bps(0) {}
7113
7114 bool operator==(const UplinkNetworkInfo& rhs) const {
7115 return (video_encoder_target_bitrate_bps == rhs.video_encoder_target_bitrate_bps);
7116 }
7117 };
7118
7119 struct DownlinkNetworkInfo {
7120 struct PeerDownlinkInfo {
7124 const char* userId;
7128 VIDEO_STREAM_TYPE stream_type;
7132 REMOTE_VIDEO_DOWNSCALE_LEVEL current_downscale_level;
7136 int expected_bitrate_bps;
7137
7138 PeerDownlinkInfo()
7139 : userId(OPTIONAL_NULLPTR),
7140 stream_type(VIDEO_STREAM_HIGH),
7141 current_downscale_level(REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE),
7142 expected_bitrate_bps(-1) {}
7143
7144 PeerDownlinkInfo(const PeerDownlinkInfo& rhs)
7145 : stream_type(rhs.stream_type),
7146 current_downscale_level(rhs.current_downscale_level),
7147 expected_bitrate_bps(rhs.expected_bitrate_bps) {
7148 if (rhs.userId != OPTIONAL_NULLPTR) {
7149 const size_t len = std::strlen(rhs.userId);
7150 char* buf = new char[len + 1];
7151 std::memcpy(buf, rhs.userId, len);
7152 buf[len] = '\0';
7153 userId = buf;
7154 }
7155 }
7156
7157 PeerDownlinkInfo& operator=(const PeerDownlinkInfo& rhs) {
7158 if (this == &rhs) return *this;
7159 userId = OPTIONAL_NULLPTR;
7160 stream_type = rhs.stream_type;
7161 current_downscale_level = rhs.current_downscale_level;
7162 expected_bitrate_bps = rhs.expected_bitrate_bps;
7163 if (rhs.userId != OPTIONAL_NULLPTR) {
7164 const size_t len = std::strlen(rhs.userId);
7165 char* buf = new char[len + 1];
7166 std::memcpy(buf, rhs.userId, len);
7167 buf[len] = '\0';
7168 userId = buf;
7169 }
7170 return *this;
7171 }
7172
7173 ~PeerDownlinkInfo() { delete[] userId; }
7174 };
7175
7179 int lastmile_buffer_delay_time_ms;
7183 int bandwidth_estimation_bps;
7187 int total_downscale_level_count;
7191 PeerDownlinkInfo* peer_downlink_info;
7195 int total_received_video_count;
7196
7197 DownlinkNetworkInfo()
7198 : lastmile_buffer_delay_time_ms(-1),
7199 bandwidth_estimation_bps(-1),
7200 total_downscale_level_count(-1),
7201 peer_downlink_info(OPTIONAL_NULLPTR),
7202 total_received_video_count(-1) {}
7203
7204 DownlinkNetworkInfo(const DownlinkNetworkInfo& info)
7205 : lastmile_buffer_delay_time_ms(info.lastmile_buffer_delay_time_ms),
7206 bandwidth_estimation_bps(info.bandwidth_estimation_bps),
7207 total_downscale_level_count(info.total_downscale_level_count),
7208 peer_downlink_info(OPTIONAL_NULLPTR),
7209 total_received_video_count(info.total_received_video_count) {
7210 if (total_received_video_count <= 0) return;
7211 peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
7212 for (int i = 0; i < total_received_video_count; ++i)
7213 peer_downlink_info[i] = info.peer_downlink_info[i];
7214 }
7215
7216 DownlinkNetworkInfo& operator=(const DownlinkNetworkInfo& rhs) {
7217 if (this == &rhs) return *this;
7218 lastmile_buffer_delay_time_ms = rhs.lastmile_buffer_delay_time_ms;
7219 bandwidth_estimation_bps = rhs.bandwidth_estimation_bps;
7220 total_downscale_level_count = rhs.total_downscale_level_count;
7221 peer_downlink_info = OPTIONAL_NULLPTR;
7222 total_received_video_count = rhs.total_received_video_count;
7223 if (total_received_video_count > 0) {
7224 peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
7225 for (int i = 0; i < total_received_video_count; ++i)
7226 peer_downlink_info[i] = rhs.peer_downlink_info[i];
7227 }
7228 return *this;
7229 }
7230
7231 ~DownlinkNetworkInfo() { delete[] peer_downlink_info; }
7232 };
7233
7242 enum ENCRYPTION_MODE {
7246 AES_128_XTS = 1,
7250 AES_128_ECB = 2,
7254 AES_256_XTS = 3,
7258 SM4_128_ECB = 4,
7262 AES_128_GCM = 5,
7266 AES_256_GCM = 6,
7271 AES_128_GCM2 = 7,
7276 AES_256_GCM2 = 8,
7280 MODE_END,
7281 };
7282
7286 struct EncryptionConfig {
7291 ENCRYPTION_MODE encryptionMode;
7297 const char* encryptionKey;
7304 uint8_t encryptionKdfSalt[32];
7305
7311 bool datastreamEncryptionEnabled;
7312
7313 EncryptionConfig()
7314 : encryptionMode(AES_128_GCM2),
7315 encryptionKey(OPTIONAL_NULLPTR),
7316 datastreamEncryptionEnabled(false) {
7317 memset(encryptionKdfSalt, 0, sizeof(encryptionKdfSalt));
7318 }
7319
7321 const char* getEncryptionString() const {
7322 switch (encryptionMode) {
7323 case AES_128_XTS:
7324 return "aes-128-xts";
7325 case AES_128_ECB:
7326 return "aes-128-ecb";
7327 case AES_256_XTS:
7328 return "aes-256-xts";
7329 case SM4_128_ECB:
7330 return "sm4-128-ecb";
7331 case AES_128_GCM:
7332 return "aes-128-gcm";
7333 case AES_256_GCM:
7334 return "aes-256-gcm";
7335 case AES_128_GCM2:
7336 return "aes-128-gcm-2";
7337 case AES_256_GCM2:
7338 return "aes-256-gcm-2";
7339 default:
7340 return "aes-128-gcm-2";
7341 }
7342 return "aes-128-gcm-2";
7343 }
7345 };
7346
7350 enum ENCRYPTION_ERROR_TYPE {
7354 ENCRYPTION_ERROR_INTERNAL_FAILURE = 0,
7359 ENCRYPTION_ERROR_DECRYPTION_FAILURE = 1,
7363 ENCRYPTION_ERROR_ENCRYPTION_FAILURE = 2,
7368 ENCRYPTION_ERROR_DATASTREAM_DECRYPTION_FAILURE = 3,
7372 ENCRYPTION_ERROR_DATASTREAM_ENCRYPTION_FAILURE = 4,
7373 };
7374
7375 enum UPLOAD_ERROR_REASON {
7376 UPLOAD_SUCCESS = 0,
7377 UPLOAD_NET_ERROR = 1,
7378 UPLOAD_SERVER_ERROR = 2,
7379 };
7380
7386 enum RENEW_TOKEN_ERROR_CODE {
7390 RENEW_TOKEN_SUCCESS = 0,
7395 RENEW_TOKEN_FAILURE = 1,
7400 RENEW_TOKEN_TOKEN_EXPIRED = 2,
7409 RENEW_TOKEN_INVALID_TOKEN = 3,
7415 RENEW_TOKEN_INVALID_CHANNEL_NAME = 4,
7420 RENEW_TOKEN_INCONSISTENT_APPID = 5,
7424 RENEW_TOKEN_CANCELED_BY_NEW_REQUEST = 6,
7425 };
7426
7430 enum PERMISSION_TYPE {
7434 RECORD_AUDIO = 0,
7438 CAMERA = 1,
7439
7443 SCREEN_CAPTURE = 2,
7444 };
7445
7449 enum STREAM_SUBSCRIBE_STATE {
7453 SUB_STATE_IDLE = 0,
7469 SUB_STATE_NO_SUBSCRIBED = 1,
7473 SUB_STATE_SUBSCRIBING = 2,
7477 SUB_STATE_SUBSCRIBED = 3
7478 };
7479
7483 enum STREAM_PUBLISH_STATE {
7487 PUB_STATE_IDLE = 0,
7498 PUB_STATE_NO_PUBLISHED = 1,
7502 PUB_STATE_PUBLISHING = 2,
7506 PUB_STATE_PUBLISHED = 3
7507 };
7508
7512 struct EchoTestConfiguration {
7517 view_t view;
7524 bool enableAudio;
7531 bool enableVideo;
7539 const char* token;
7545 const char* channelId;
7553 int intervalInSeconds;
7554
7555 EchoTestConfiguration(view_t v, bool ea, bool ev, const char* t, const char* c, const int is)
7556 : view(v), enableAudio(ea), enableVideo(ev), token(t), channelId(c), intervalInSeconds(is) {}
7557
7558 EchoTestConfiguration()
7559 : view(OPTIONAL_NULLPTR),
7560 enableAudio(true),
7561 enableVideo(true),
7562 token(OPTIONAL_NULLPTR),
7563 channelId(OPTIONAL_NULLPTR),
7564 intervalInSeconds(2) {}
7565 };
7566
7570 struct UserInfo {
7574 uid_t uid;
7578 char userAccount[MAX_USER_ACCOUNT_LENGTH];
7579
7580 UserInfo() : uid(0) { userAccount[0] = '\0'; }
7581 };
7582
7586 enum EAR_MONITORING_FILTER_TYPE {
7590 EAR_MONITORING_FILTER_NONE = (1 << 0),
7595 EAR_MONITORING_FILTER_BUILT_IN_AUDIO_FILTERS = (1 << 1),
7599 EAR_MONITORING_FILTER_NOISE_SUPPRESSION = (1 << 2),
7605 EAR_MONITORING_FILTER_REUSE_POST_PROCESSING_FILTER = (1 << 15),
7606 };
7607
7611 enum THREAD_PRIORITY_TYPE {
7615 LOWEST = 0,
7619 LOW = 1,
7623 NORMAL = 2,
7627 HIGH = 3,
7631 HIGHEST = 4,
7635 CRITICAL = 5,
7636 };
7637
7638 #if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS) || defined(__OHOS__)
7639
7643 struct ScreenVideoParameters {
7647 VideoDimensions dimensions;
7651 int frameRate = 15;
7655 int bitrate;
7659 VIDEO_CONTENT_HINT contentHint = VIDEO_CONTENT_HINT::CONTENT_HINT_MOTION;
7660
7661 ScreenVideoParameters() : dimensions(1280, 720) {}
7662 };
7663
7667 struct ScreenCaptureParameters2 {
7679 bool captureAudio = false;
7684 ScreenAudioParameters audioParams;
7692 bool captureVideo = true;
7697 ScreenVideoParameters videoParams;
7698 };
7699 #endif
7700
7704 enum MEDIA_TRACE_EVENT {
7708 MEDIA_TRACE_EVENT_VIDEO_RENDERED = 0,
7712 MEDIA_TRACE_EVENT_VIDEO_DECODED,
7713 };
7714
7718 struct VideoRenderingTracingInfo {
7724 int elapsedTime;
7733 int start2JoinChannel;
7740 int join2JoinSuccess;
7755 int joinSuccess2RemoteJoined;
7770 int remoteJoined2SetView;
7785 int remoteJoined2UnmuteVideo;
7800 int remoteJoined2PacketReceived;
7801 };
7802
7803 enum CONFIG_FETCH_TYPE {
7807 CONFIG_FETCH_TYPE_INITIALIZE = 1,
7811 CONFIG_FETCH_TYPE_JOIN_CHANNEL = 2,
7812 };
7813
7817 enum LOCAL_PROXY_MODE {
7822 ConnectivityFirst = 0,
7826 LocalOnly = 1,
7827 };
7828
7832 struct LogUploadServerInfo {
7836 const char* serverDomain;
7840 const char* serverPath;
7844 int serverPort;
7850 bool serverHttps;
7851
7852 LogUploadServerInfo() : serverDomain(NULL), serverPath(NULL), serverPort(0), serverHttps(true) {}
7853
7854 LogUploadServerInfo(const char* domain, const char* path, int port, bool https)
7855 : serverDomain(domain), serverPath(path), serverPort(port), serverHttps(https) {}
7856 };
7857
7861 struct AdvancedConfigInfo {
7866 LogUploadServerInfo logUploadServer;
7867 };
7868
7872 struct LocalAccessPointConfiguration {
7877 const char** ipList;
7882 int ipListSize;
7890 const char** domainList;
7895 int domainListSize;
7900 const char* verifyDomainName;
7904 LOCAL_PROXY_MODE mode;
7908 AdvancedConfigInfo advancedConfig;
7914 bool disableAut;
7915 LocalAccessPointConfiguration()
7916 : ipList(NULL),
7917 ipListSize(0),
7918 domainList(NULL),
7919 domainListSize(0),
7920 verifyDomainName(NULL),
7921 mode(ConnectivityFirst),
7922 disableAut(true) {}
7923 };
7924
7928 enum RecorderStreamType {
7932 RTC,
7936 PREVIEW,
7937 };
7938
7942 struct RecorderStreamInfo {
7946 const char* channelId;
7950 uid_t uid;
7954 RecorderStreamType type;
7955 RecorderStreamInfo() : channelId(NULL), uid(0), type(RTC) {}
7956 RecorderStreamInfo(const char* channelId, uid_t uid)
7957 : channelId(channelId), uid(uid), type(RTC) {}
7958 RecorderStreamInfo(const char* channelId, uid_t uid, RecorderStreamType type)
7959 : channelId(channelId), uid(uid), type(type) {}
7960 };
7961
7967 enum RdtStreamType {
7973 RDT_STREAM_CMD,
7979 RDT_STREAM_DATA,
7983 RDT_STREAM_COUNT,
7984 };
7985
7991 enum RdtState {
7995 RDT_STATE_CLOSED,
7999 RDT_STATE_OPENED,
8004 RDT_STATE_BLOCKED,
8009 RDT_STATE_PENDING,
8016 RDT_STATE_BROKEN,
8017 };
8018 } // namespace rtc
8019
8020 namespace base {
8021
8022 class IEngineBase {
8023 public:
8024 virtual int queryInterface(rtc::INTERFACE_ID_TYPE iid, void** inter) = 0;
8025 virtual ~IEngineBase() {}
8026 };
8027
8028 class AParameter : public agora::util::AutoPtr<IAgoraParameter> {
8029 public:
8030 AParameter(IEngineBase& engine) { initialize(&engine); }
8031 AParameter(IEngineBase* engine) { initialize(engine); }
8032 AParameter(IAgoraParameter* p) : agora::util::AutoPtr<IAgoraParameter>(p) {}
8033
8034 private:
8035 bool initialize(IEngineBase* engine) {
8036 IAgoraParameter* p = OPTIONAL_NULLPTR;
8037 if (engine && !engine->queryInterface(rtc::AGORA_IID_PARAMETER_ENGINE, (void**)&p)) reset(p);
8038 return p != OPTIONAL_NULLPTR;
8039 }
8040 };
8041
8042 class LicenseCallback {
8043 public:
8044 virtual ~LicenseCallback() {}
8045 virtual void onCertificateRequired() = 0;
8046 virtual void onLicenseRequest() = 0;
8047 virtual void onLicenseValidated() = 0;
8048 virtual void onLicenseError(int result) = 0;
8049 };
8050
8051 } // namespace base
8052
8056 struct SpatialAudioParams {
8066 Optional<double> speaker_azimuth;
8074 Optional<double> speaker_elevation;
8079 Optional<double> speaker_distance;
8086 Optional<int> speaker_orientation;
8092 Optional<bool> enable_blur;
8101 Optional<bool> enable_air_absorb;
8115 Optional<double> speaker_attenuation;
8132 Optional<bool> enable_doppler;
8133 };
8137 struct VideoLayout {
8141 const char* channelId;
8145 rtc::uid_t uid;
8149 user_id_t strUid;
8155 uint32_t x;
8161 uint32_t y;
8165 uint32_t width;
8169 uint32_t height;
8177 uint32_t videoState;
8178
8179 VideoLayout()
8180 : channelId(OPTIONAL_NULLPTR),
8181 uid(0),
8182 strUid(OPTIONAL_NULLPTR),
8183 x(0),
8184 y(0),
8185 width(0),
8186 height(0),
8187 videoState(0) {}
8188 };
8189 } // namespace agora
8190
8196 AGORA_API const char* AGORA_CALL getAgoraSdkVersion(int* build);
8197
8203 AGORA_API const char* AGORA_CALL getAgoraSdkErrorDescription(int err);
8204
8205 AGORA_API int AGORA_CALL setAgoraSdkExternalSymbolLoader(void* (*func)(const char* symname));
8206
8214 AGORA_API int AGORA_CALL createAgoraCredential(agora::util::AString& credential);
8215
8229 AGORA_API int AGORA_CALL getAgoraCertificateVerifyResult(const char* credential_buf,
8230 int credential_len,
8231 const char* certificate_buf,
8232 int certificate_len);
8233
8241 AGORA_API void setAgoraLicenseCallback(agora::base::LicenseCallback* callback);
8242
8250 AGORA_API agora::base::LicenseCallback* getAgoraLicenseCallback();
8251
8252 /*
8253 * Get monotonic time in ms which can be used by capture time,
8254 * typical scenario is as follows:
8255 *
8256 * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8257 * | // custom audio/video base capture time, e.g. the first audio/video capture time. | | int64_t
8258 * custom_capture_time_base; | | | |
8259 * int64_t agora_monotonic_time = getAgoraCurrentMonotonicTimeInMs(); |
8260 * | | | // offset is fixed once calculated in the begining. | | const int64_t offset =
8261 * agora_monotonic_time - custom_capture_time_base; | | | | //
8262 * realtime_custom_audio/video_capture_time is the origin capture time that customer provided.| | //
8263 * actual_audio/video_capture_time is the actual capture time transfered to sdk. | |
8264 * int64_t actual_audio_capture_time = realtime_custom_audio_capture_time + offset; |
8265 * | int64_t actual_video_capture_time = realtime_custom_video_capture_time + offset; |
8266 * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8267 *
8268 * @return
8269 * - >= 0: Success.
8270 * - < 0: Failure.
8271 */
8272 AGORA_API int64_t AGORA_CALL getAgoraCurrentMonotonicTimeInMs();
agora::rtc::LiveTranscoding::transcodingUsers
TranscodingUser * transcodingUsers
Definition: AgoraBase.h:4620
agora::rtc::LogUploadServerInfo::serverDomain
const char * serverDomain
Definition: AgoraBase.h:7836
agora::rtc::IPacketObserver::onReceiveVideoPacket
virtual bool onReceiveVideoPacket(Packet &packet)=0
Occurs when the local user receives a video packet.
agora::rtc::VideoCanvas::mediaPlayerId
int mediaPlayerId
Definition: AgoraBase.h:5310
agora::rtc::RtcImage::width
int width
Definition: AgoraBase.h:4377
agora::rtc::TranscodingVideoStream::zOrder
int zOrder
Definition: AgoraBase.h:4768
agora::rtc::RtcStats::firstAudioPacketDuration
int firstAudioPacketDuration
Definition: AgoraBase.h:2853
agora::rtc::ScreenAudioParameters::captureSignalVolume
int captureSignalVolume
Definition: AgoraBase.h:6459
agora::VideoLayout
Layout information of a specific sub-video stream within the mixed stream.
Definition: AgoraBase.h:8137
agora::rtc::FilterEffectOptions::strength
float strength
Definition: AgoraBase.h:5743
agora::rtc::SimulcastConfig::STREAM_LAYER_1
@ STREAM_LAYER_1
Definition: AgoraBase.h:2266
agora::VideoLayout::channelId
const char * channelId
Definition: AgoraBase.h:8141
agora::rtc::UserInfo
The information of the user.
Definition: AgoraBase.h:7570
agora::rtc::FilterEffectOptions
Filter effect options.
Definition: AgoraBase.h:5719
agora::rtc::TranscodingVideoStream::alpha
double alpha
Definition: AgoraBase.h:4773
agora::rtc::EncodedAudioFrameInfo::captureTimeMs
int64_t captureTimeMs
Definition: AgoraBase.h:1606
agora::rtc::VideoEncoderConfiguration::degradationPreference
DEGRADATION_PREFERENCE degradationPreference
Definition: AgoraBase.h:2102
agora::rtc::LastmileProbeResult
Results of the uplink and downlink last-mile network tests.
Definition: AgoraBase.h:5017
agora::rtc::RtcStats::lanAccelerateState
int lanAccelerateState
Definition: AgoraBase.h:2909
agora::rtc::AudioEncodedFrameObserverConfig
Observer settings for the encoded audio.
Definition: AgoraBase.h:6809
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo::userId
const char * userId
Definition: AgoraBase.h:7124
agora::rtc::ScreenCaptureParameters
Screen sharing configurations.
Definition: AgoraBase.h:6475
agora::VideoLayout::x
uint32_t x
Definition: AgoraBase.h:8155
agora::rtc::WatermarkRatio
The position and size of the watermark on the screen.
Definition: AgoraBase.h:2376
agora::rtc::AudioVolumeInfo
The volume information of users.
Definition: AgoraBase.h:3974
agora::rtc::VirtualBackgroundSource::BACKGROUND_BLUR_DEGREE
BACKGROUND_BLUR_DEGREE
The degree of blurring applied to the custom background image.
Definition: AgoraBase.h:5924
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo::current_downscale_level
REMOTE_VIDEO_DOWNSCALE_LEVEL current_downscale_level
Definition: AgoraBase.h:7132
agora::rtc::LastmileProbeResult::uplinkReport
LastmileProbeOneWayResult uplinkReport
Definition: AgoraBase.h:5025
agora::rtc::EncodedVideoFrameInfo::rotation
VIDEO_ORIENTATION rotation
Definition: AgoraBase.h:1804
agora::rtc::AdvancedConfigInfo::logUploadServer
LogUploadServerInfo logUploadServer
Definition: AgoraBase.h:7866
agora::rtc::BeautyOptions
Image enhancement options.
Definition: AgoraBase.h:5396
agora::rtc::SenderOptions
Definition: AgoraBase.h:1342
agora::rtc::WatermarkBuffer::height
int height
Definition: AgoraBase.h:2561
agora::rtc::ScreenCaptureParameters::bitrate
int bitrate
Definition: AgoraBase.h:6529
agora::rtc::EchoTestConfiguration::channelId
const char * channelId
Definition: AgoraBase.h:7545
agora::rtc::BeautyOptions::lighteningLevel
float lighteningLevel
Definition: AgoraBase.h:5425
agora::rtc::RtcStats::txVideoBytes
unsigned int txVideoBytes
Definition: AgoraBase.h:2762
agora::rtc::VirtualBackgroundSource::BACKGROUND_BLUR
@ BACKGROUND_BLUR
Definition: AgoraBase.h:5914
agora::rtc::LiveTranscoding::backgroundColor
unsigned int backgroundColor
Definition: AgoraBase.h:4607
agora::base::IAgoraParameter
The interface class of Agora RTC SDK, which provides JSON configuration information of the SDK.
Definition: IAgoraParameter.h:151
agora::rtc::DownlinkNetworkInfo::peer_downlink_info
PeerDownlinkInfo * peer_downlink_info
Definition: AgoraBase.h:7191
agora::rtc::AudioVolumeInfo::voicePitch
double voicePitch
Definition: AgoraBase.h:4007
agora::rtc::LastmileProbeConfig
Configurations of the last-mile network test.
Definition: AgoraBase.h:4948
agora::rtc::TranscodingUser::y
int y
Definition: AgoraBase.h:4501
agora::rtc::ScreenCaptureParameters::highLightWidth
int highLightWidth
Definition: AgoraBase.h:6566
agora::rtc::RtcStats::rxKBitRate
unsigned short rxKBitRate
Definition: AgoraBase.h:2778
agora::rtc::RtcStats::memoryTotalUsageRatio
double memoryTotalUsageRatio
Definition: AgoraBase.h:2838
agora::rtc::LocalAudioStats::txPacketLossRate
unsigned short txPacketLossRate
Definition: AgoraBase.h:4187
agora::rtc::VideoFormat::fps
int fps
Definition: AgoraBase.h:3188
agora::SpatialAudioParams::speaker_elevation
Optional< double > speaker_elevation
Definition: AgoraBase.h:8074
agora::rtc::VideoEncoderConfiguration::minBitrate
int minBitrate
Definition: AgoraBase.h:2091
agora::rtc::WatermarkConfig::buffer
WatermarkBuffer buffer
Definition: AgoraBase.h:2599
agora::rtc::ScreenCaptureParameters::enableHighLight
bool enableHighLight
Definition: AgoraBase.h:6580
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_AUTO
@ VIDEO_DENOISER_AUTO
Definition: AgoraBase.h:5816
agora::rtc::VideoCanvas::setupMode
VIDEO_VIEW_SETUP_MODE setupMode
Definition: AgoraBase.h:5302
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY
@ LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY
Definition: AgoraBase.h:5778
agora::rtc::WatermarkConfig::literal
WatermarkLiteral literal
Definition: AgoraBase.h:2611
agora::rtc::TranscodingUser::audioChannel
int audioChannel
Definition: AgoraBase.h:4544
agora::rtc::SimulcastConfig::StreamLayerIndex
StreamLayerIndex
Index of video streams of different quality levels.
Definition: AgoraBase.h:2262
agora::rtc::RtcStats::firstAudioPacketDurationAfterUnmute
int firstAudioPacketDurationAfterUnmute
Definition: AgoraBase.h:2873
agora::rtc::SimulcastConfig::STREAM_LAYER_2
@ STREAM_LAYER_2
Definition: AgoraBase.h:2270
agora::rtc::VideoFormat::width
int width
Definition: AgoraBase.h:3180
agora::rtc::ScreenCaptureParameters::windowFocus
bool windowFocus
Definition: AgoraBase.h:6546
agora::rtc::AudioEncodedFrameObserverConfig::encodingType
AUDIO_ENCODING_TYPE encodingType
Definition: AgoraBase.h:6817
agora::rtc::SenderOptions::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1351
agora::rtc::EncodedAudioFrameInfo::codec
AUDIO_CODEC_TYPE codec
Definition: AgoraBase.h:1585
agora::rtc::LiveTranscoding::videoGop
int videoGop
Definition: AgoraBase.h:4596
agora::rtc::ChannelMediaRelayConfiguration::destCount
int destCount
Definition: AgoraBase.h:7097
agora::rtc::LocalAudioStats::audioDeviceDelay
int audioDeviceDelay
Definition: AgoraBase.h:4191
agora::rtc::LastmileProbeOneWayResult::jitter
unsigned int jitter
Definition: AgoraBase.h:5005
agora::rtc::BeautyOptions::smoothnessLevel
float smoothnessLevel
Definition: AgoraBase.h:5431
agora::rtc::VideoDenoiserOptions::level
VIDEO_DENOISER_LEVEL level
Definition: AgoraBase.h:5849
agora::rtc::VideoCanvas::mirrorMode
VIDEO_MIRROR_MODE_TYPE mirrorMode
Definition: AgoraBase.h:5298
agora::rtc::RtcStats::duration
unsigned int duration
Definition: AgoraBase.h:2746
agora::rtc::SimulcastStreamConfig::framerate
int framerate
Definition: AgoraBase.h:2245
agora::rtc::SegmentationProperty::SEG_MODEL_GREEN
@ SEG_MODEL_GREEN
Definition: AgoraBase.h:5999
agora::rtc::VideoDimensions::height
int height
Definition: AgoraBase.h:1174
agora::rtc::LocalAccessPointConfiguration::mode
LOCAL_PROXY_MODE mode
Definition: AgoraBase.h:7904
agora::rtc::LastmileProbeConfig::probeUplink
bool probeUplink
Definition: AgoraBase.h:4955
agora::rtc::RecorderStreamInfo::channelId
const char * channelId
Definition: AgoraBase.h:7946
agora::rtc::LocalAccessPointConfiguration
Configuration for the Local Access Point.
Definition: AgoraBase.h:7872
agora::rtc::FilterEffectOptions::path
const char * path
Definition: AgoraBase.h:5737
agora::rtc::SegmentationProperty::SCREEN_COLOR_TYPE
SCREEN_COLOR_TYPE
Screen color type.
Definition: AgoraBase.h:6005
agora::rtc::LiveTranscoding::videoCodecType
VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType
Definition: AgoraBase.h:4611
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_MODE
VIDEO_DENOISER_MODE
Video noise reduction mode.
Definition: AgoraBase.h:5811
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEWIDTH
@ FACE_SHAPE_AREA_NOSEWIDTH
Definition: AgoraBase.h:5581
agora::rtc::LiveTranscoding
Transcoding configurations for Media Push.
Definition: AgoraBase.h:4553
agora::rtc::RtcStats::txBytes
unsigned int txBytes
Definition: AgoraBase.h:2750
agora::rtc::VideoFormat::height
int height
Definition: AgoraBase.h:3184
agora::rtc::Rectangle
The location of the target area relative to the screen or window. If you do not set this parameter,...
Definition: AgoraBase.h:2342
agora::rtc::LocalAccessPointConfiguration::ipList
const char ** ipList
Definition: AgoraBase.h:7877
agora::rtc::VideoCanvas::uid
uid_t uid
Definition: AgoraBase.h:5270
agora::rtc::RtcStats::firstVideoPacketDuration
int firstVideoPacketDuration
Definition: AgoraBase.h:2858
agora::rtc::AudioRecordingConfiguration::filePath
const char * filePath
Definition: AgoraBase.h:6727
agora::rtc::EncodedVideoFrameInfo
Information about externally encoded video frames.
Definition: AgoraBase.h:1735
agora::rtc::ColorEnhanceOptions::strengthLevel
float strengthLevel
Definition: AgoraBase.h:5868
agora::rtc::MultipathStats::activePathNum
int activePathNum
Definition: AgoraBase.h:2723
agora::SpatialAudioParams::speaker_distance
Optional< double > speaker_distance
Definition: AgoraBase.h:8079
agora::rtc::VirtualBackgroundSource::BACKGROUND_NONE
@ BACKGROUND_NONE
Definition: AgoraBase.h:5902
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MOUTHSMILE
@ FACE_SHAPE_AREA_MOUTHSMILE
Definition: AgoraBase.h:5631
agora::rtc::FaceShapeBeautyOptions::shapeStyle
FACE_SHAPE_BEAUTY_STYLE shapeStyle
Definition: AgoraBase.h:5700
agora::rtc::BeautyOptions::rednessLevel
float rednessLevel
Definition: AgoraBase.h:5437
agora::rtc::RtcStats::rxVideoBytes
unsigned int rxVideoBytes
Definition: AgoraBase.h:2770
agora::rtc::TranscodingVideoStream::remoteUserUid
uid_t remoteUserUid
Definition: AgoraBase.h:4731
agora::rtc::WatermarkOptions::zOrder
int zOrder
Definition: AgoraBase.h:2437
agora::rtc::VideoEncoderConfiguration::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:2067
agora::rtc::EncodedAudioFrameInfo
Audio information after encoding.
Definition: AgoraBase.h:1567
agora::util::AutoPtr
Definition: AgoraBase.h:100
agora::rtc::LastmileProbeOneWayResult::packetLossRate
unsigned int packetLossRate
Definition: AgoraBase.h:5001
agora::UserInfo::hasAudio
bool hasAudio
Definition: AgoraBase.h:865
agora::rtc::ScreenCaptureParameters::excludeWindowCount
int excludeWindowCount
Definition: AgoraBase.h:6559
agora::rtc::IPacketObserver::Packet
Configurations for the Packet instance.
Definition: AgoraBase.h:4038
agora::rtc::AudioTrackConfig::enableLocalPlayback
bool enableLocalPlayback
Definition: AgoraBase.h:6078
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSELENGTH
@ FACE_SHAPE_AREA_NOSELENGTH
Definition: AgoraBase.h:5575
agora::rtc::LiveTranscoding::audioCodecProfile
AUDIO_CODEC_PROFILE_TYPE audioCodecProfile
Definition: AgoraBase.h:4681
agora::rtc::RecorderStreamInfo::uid
uid_t uid
Definition: AgoraBase.h:7950
agora::rtc::VideoEncoderConfiguration
Video encoder configurations.
Definition: AgoraBase.h:2057
agora::rtc::Rectangle::width
int width
Definition: AgoraBase.h:2354
agora::rtc::SimulcastConfig::StreamLayerConfig::framerate
int framerate
Definition: AgoraBase.h:2312
agora::rtc::VideoEncoderConfiguration::bitrate
int bitrate
Definition: AgoraBase.h:2081
agora::rtc::VideoRenderingTracingInfo::remoteJoined2UnmuteVideo
int remoteJoined2UnmuteVideo
Definition: AgoraBase.h:7785
agora::util::AList
Definition: AgoraBase.h:233
agora::rtc::RtcStats::firstVideoKeyFrameDecodedDurationAfterUnmute
int firstVideoKeyFrameDecodedDurationAfterUnmute
Definition: AgoraBase.h:2888
agora::rtc::VideoSubscriptionOptions
Video subscription options.
Definition: AgoraBase.h:1705
agora::rtc::TranscodingUser
Transcoding configurations of each host.
Definition: AgoraBase.h:4485
agora::rtc::WatermarkConfig::id
const char * id
Definition: AgoraBase.h:2590
agora::rtc::PathStats
Statistical information about a specific network path.
Definition: AgoraBase.h:2673
agora::rtc::EchoTestConfiguration
The configuration of the audio and video call loop test.
Definition: AgoraBase.h:7512
agora::rtc::RtcImage
Image properties.
Definition: AgoraBase.h:4358
agora::rtc::TranscodingUser::x
int x
Definition: AgoraBase.h:4495
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo::stream_type
VIDEO_STREAM_TYPE stream_type
Definition: AgoraBase.h:7128
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_FACECONTOUR
@ FACE_SHAPE_AREA_FACECONTOUR
Definition: AgoraBase.h:5491
agora::rtc::ChannelMediaInfo::token
const char * token
Definition: AgoraBase.h:7051
agora::rtc::VideoRenderingTracingInfo::remoteJoined2PacketReceived
int remoteJoined2PacketReceived
Definition: AgoraBase.h:7800
agora::rtc::AudioRecordingConfiguration::encode
bool encode
Definition: AgoraBase.h:6733
agora::rtc::BeautyOptions::lighteningContrastLevel
LIGHTENING_CONTRAST_LEVEL lighteningContrastLevel
Definition: AgoraBase.h:5419
agora::rtc::WatermarkRatio::yRatio
float yRatio
Definition: AgoraBase.h:2388
agora::SpatialAudioParams::enable_blur
Optional< bool > enable_blur
Definition: AgoraBase.h:8092
agora::rtc::SimulcastStreamConfig
The configuration of the low-quality video stream.
Definition: AgoraBase.h:2230
agora::rtc::LiveTranscoding::audioBitrate
int audioBitrate
Definition: AgoraBase.h:4667
agora::rtc::WatermarkBuffer::buffer
const uint8_t * buffer
Definition: AgoraBase.h:2576
agora::rtc::FaceShapeAreaOptions::shapeArea
FACE_SHAPE_AREA shapeArea
Definition: AgoraBase.h:5657
agora::rtc::ChannelMediaRelayConfiguration::destInfos
ChannelMediaInfo * destInfos
Definition: AgoraBase.h:7091
agora::rtc::RtcImage::x
int x
Definition: AgoraBase.h:4368
agora::rtc::VirtualBackgroundSource::background_source_type
BACKGROUND_SOURCE_TYPE background_source_type
Definition: AgoraBase.h:5945
agora::rtc::FaceShapeBeautyOptions
The facial enhancement style options.
Definition: AgoraBase.h:5675
agora::rtc::TranscodingVideoStream::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:4725
agora::rtc::LocalTranscoderConfiguration::syncWithPrimaryCamera
bool syncWithPrimaryCamera
Definition: AgoraBase.h:4820
agora::rtc::RtcImage::zOrder
int zOrder
Definition: AgoraBase.h:4389
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_FACELENGTH
@ FACE_SHAPE_AREA_FACELENGTH
Definition: AgoraBase.h:5497
agora::rtc::WatermarkTimestamp::format
const char * format
Definition: AgoraBase.h:2504
agora::rtc::MixedAudioStream
The source of the audio streams that are mixed locally.
Definition: AgoraBase.h:4864
agora::rtc::ClientRoleOptions::audienceLatencyLevel
AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel
Definition: AgoraBase.h:3004
agora::rtc::AudioVolumeInfo::volume
unsigned int volume
Definition: AgoraBase.h:3990
agora::rtc::TranscodingUser::uid
uid_t uid
Definition: AgoraBase.h:4489
agora::rtc::VideoCanvas::enableAlphaMask
bool enableAlphaMask
Definition: AgoraBase.h:5329
agora::rtc::VideoRenderingTracingInfo::elapsedTime
int elapsedTime
Definition: AgoraBase.h:7724
agora::rtc::LiveStreamAdvancedFeature::featureName
const char * featureName
Definition: AgoraBase.h:4420
agora::rtc::AdvancedConfigInfo
Advanced options for the Local Access Point.
Definition: AgoraBase.h:7861
agora::rtc::ScreenAudioParameters::channels
int channels
Definition: AgoraBase.h:6455
agora::rtc::Rectangle::y
int y
Definition: AgoraBase.h:2350
agora::rtc::SimulcastConfig::publish_fallback_enable
bool publish_fallback_enable
Definition: AgoraBase.h:2334
agora::rtc::MultipathStats::wifiRxBytes
uint32_t wifiRxBytes
Definition: AgoraBase.h:2711
agora::rtc::LocalAudioStats::sentBitrate
int sentBitrate
Definition: AgoraBase.h:4178
agora::rtc::RtcImage::url
const char * url
Definition: AgoraBase.h:4363
agora::rtc::IPacketObserver::Packet::buffer
const unsigned char * buffer
Definition: AgoraBase.h:4044
agora::rtc::EncodedVideoFrameInfo::decodeTimeMs
int64_t decodeTimeMs
Definition: AgoraBase.h:1817
agora::rtc::RtcStats::firstVideoKeyFrameRenderedDurationAfterUnmute
int firstVideoKeyFrameRenderedDurationAfterUnmute
Definition: AgoraBase.h:2893
agora::rtc::SimulcastConfig::configs
StreamLayerConfig configs[STREAM_LAYER_COUNT_MAX]
Definition: AgoraBase.h:2325
agora::rtc::WatermarkConfig::imageUrl
const char * imageUrl
Definition: AgoraBase.h:2615
agora::rtc::ColorEnhanceOptions
The color enhancement options.
Definition: AgoraBase.h:5862
agora::rtc::MultipathStats::wifiTxBytes
uint32_t wifiTxBytes
Definition: AgoraBase.h:2707
agora::rtc::AudioRecordingConfiguration::sampleRate
int sampleRate
Definition: AgoraBase.h:6744
agora::UserInfo::userId
util::AString userId
Definition: AgoraBase.h:859
agora::rtc::UplinkNetworkInfo
The uplink network information.
Definition: AgoraBase.h:7106
agora::rtc::WatermarkOptions::positionInPortraitMode
Rectangle positionInPortraitMode
Definition: AgoraBase.h:2424
agora::rtc::LocalAccessPointConfiguration::advancedConfig
AdvancedConfigInfo advancedConfig
Definition: AgoraBase.h:7908
agora::rtc::LastmileProbeResult::downlinkReport
LastmileProbeOneWayResult downlinkReport
Definition: AgoraBase.h:5029
agora::rtc::LiveTranscoding::watermarkCount
unsigned int watermarkCount
Definition: AgoraBase.h:4644
agora::rtc::Rectangle::x
int x
Definition: AgoraBase.h:2346
agora::rtc::LocalTranscoderConfiguration::videoInputStreams
TranscodingVideoStream * videoInputStreams
Definition: AgoraBase.h:4806
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEDISTANCE
@ FACE_SHAPE_AREA_EYEDISTANCE
Definition: AgoraBase.h:5537
agora::rtc::WatermarkConfig::timestamp
WatermarkTimestamp timestamp
Definition: AgoraBase.h:2605
agora::util::IString
Definition: AgoraBase.h:172
agora::rtc::LocalAccessPointConfiguration::verifyDomainName
const char * verifyDomainName
Definition: AgoraBase.h:7900
agora::SpatialAudioParams::enable_air_absorb
Optional< bool > enable_air_absorb
Definition: AgoraBase.h:8101
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_LEVEL
LOW_LIGHT_ENHANCE_LEVEL
The low-light enhancement level.
Definition: AgoraBase.h:5772
agora::rtc::SegmentationProperty::SEG_MODEL_TYPE
SEG_MODEL_TYPE
The type of algorithms to user for background processing.
Definition: AgoraBase.h:5991
agora::rtc::EncodedAudioFrameInfo::advancedSettings
EncodedAudioFrameAdvancedSettings advancedSettings
Definition: AgoraBase.h:1601
agora::rtc::LocalTranscoderConfiguration
The configuration of the video mixing on the local client.
Definition: AgoraBase.h:4798
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_LEVEL
LIGHTENING_CONTRAST_LEVEL
The contrast level.
Definition: AgoraBase.h:5400
agora::rtc::WatermarkRatio::xRatio
float xRatio
Definition: AgoraBase.h:2382
agora::rtc::LocalAudioStats::sentSampleRate
int sentSampleRate
Definition: AgoraBase.h:4174
agora::rtc::VideoSubscriptionOptions::type
Optional< VIDEO_STREAM_TYPE > type
Definition: AgoraBase.h:1710
agora::rtc::RecorderStreamInfo::type
RecorderStreamType type
Definition: AgoraBase.h:7954
agora::rtc::LocalAudioMixerConfiguration::audioInputStreams
MixedAudioStream * audioInputStreams
Definition: AgoraBase.h:4931
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MOUTHPOSITION
@ FACE_SHAPE_AREA_MOUTHPOSITION
Definition: AgoraBase.h:5625
agora::rtc::WatermarkConfig::options
WatermarkOptions options
Definition: AgoraBase.h:2621
agora::rtc::LastmileProbeConfig::expectedDownlinkBitrate
unsigned int expectedDownlinkBitrate
Definition: AgoraBase.h:4971
agora::rtc::RtcStats::cpuTotalUsage
double cpuTotalUsage
Definition: AgoraBase.h:2818
agora::rtc::IPacketObserver::Packet::size
unsigned int size
Definition: AgoraBase.h:4048
agora::rtc::LiveTranscoding::advancedFeatures
LiveStreamAdvancedFeature * advancedFeatures
Definition: AgoraBase.h:4685
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEWING
@ FACE_SHAPE_AREA_NOSEWING
Definition: AgoraBase.h:5587
agora::rtc::LiveTranscoding::backgroundImageCount
unsigned int backgroundImageCount
Definition: AgoraBase.h:4657
agora::rtc::IPacketObserver
Definition: AgoraBase.h:4032
agora::rtc::LiveTranscoding::backgroundImage
RtcImage * backgroundImage
Definition: AgoraBase.h:4652
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_CHIN
@ FACE_SHAPE_AREA_CHIN
Definition: AgoraBase.h:5525
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEBROWTHICKNESS
@ FACE_SHAPE_AREA_EYEBROWTHICKNESS
Definition: AgoraBase.h:5651
agora::rtc::RtcStats::cpuAppUsage
double cpuAppUsage
Definition: AgoraBase.h:2809
agora::VideoLayout::width
uint32_t width
Definition: AgoraBase.h:8165
agora::rtc::VideoFormat
The format of the video frame.
Definition: AgoraBase.h:3167
agora::rtc::AdvanceOptions
Advanced options for video encoding.
Definition: AgoraBase.h:1873
agora::rtc::TranscodingUser::alpha
double alpha
Definition: AgoraBase.h:4524
agora::rtc::MixedAudioStream::trackId
track_id_t trackId
Definition: AgoraBase.h:4895
agora::rtc::WatermarkOptions::watermarkRatio
WatermarkRatio watermarkRatio
Definition: AgoraBase.h:2429
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_CHEEKBONE
@ FACE_SHAPE_AREA_CHEEKBONE
Definition: AgoraBase.h:5508
agora::rtc::DataStreamConfig
The configurations for the data stream.
Definition: AgoraBase.h:2185
agora::rtc::AdvanceOptions::compressionPreference
COMPRESSION_PREFERENCE compressionPreference
Definition: AgoraBase.h:1882
agora::rtc::LocalAudioMixerConfiguration::streamCount
unsigned int streamCount
Definition: AgoraBase.h:4927
agora::rtc::RtcStats::txAudioBytes
unsigned int txAudioBytes
Definition: AgoraBase.h:2758
agora::rtc::RtcStats::connectTimeMs
int connectTimeMs
Definition: AgoraBase.h:2848
agora::rtc::LastmileProbeResult::state
LASTMILE_PROBE_RESULT_STATE state
Definition: AgoraBase.h:5021
agora::rtc::VideoEncoderConfiguration::advanceOptions
AdvanceOptions advanceOptions
Definition: AgoraBase.h:2114
agora::rtc::VideoCanvas::position
media::base::VIDEO_MODULE_POSITION position
Definition: AgoraBase.h:5333
agora::rtc::ChannelMediaInfo::channelName
const char * channelName
Definition: AgoraBase.h:7047
agora::rtc::LiveTranscoding::height
int height
Definition: AgoraBase.h:4569
agora::rtc::EncodedAudioFrameAdvancedSettings::speech
bool speech
Definition: AgoraBase.h:1555
agora::rtc::LocalAudioMixerConfiguration
The configurations for mixing the lcoal audio.
Definition: AgoraBase.h:4923
agora::rtc::EncodedVideoFrameInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1782
agora::rtc::DownlinkNetworkInfo
Definition: AgoraBase.h:7119
agora::rtc::RtcStats::txVideoKBitRate
unsigned short txVideoKBitRate
Definition: AgoraBase.h:2794
agora::rtc::RtcStats::rxAudioBytes
unsigned int rxAudioBytes
Definition: AgoraBase.h:2766
agora::rtc::EncodedAudioFrameAdvancedSettings::sendEvenIfEmpty
bool sendEvenIfEmpty
Definition: AgoraBase.h:1561
agora::SpatialAudioParams::enable_doppler
Optional< bool > enable_doppler
Definition: AgoraBase.h:8132
agora::rtc::CodecCapLevels::hwDecodingLevel
VIDEO_CODEC_CAPABILITY_LEVEL hwDecodingLevel
Definition: AgoraBase.h:2004
agora::rtc::RtcStats::txAudioKBitRate
unsigned short txAudioKBitRate
Definition: AgoraBase.h:2786
agora::VideoLayout::height
uint32_t height
Definition: AgoraBase.h:8169
agora::rtc::AudioVolumeInfo::uid
uid_t uid
Definition: AgoraBase.h:3981
agora::rtc::WatermarkLiteral
The definition of the WatermarkLiteral struct.
Definition: AgoraBase.h:2515
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_LOW
@ LIGHTENING_CONTRAST_LOW
Definition: AgoraBase.h:5404
agora::rtc::DownlinkNetworkInfo::lastmile_buffer_delay_time_ms
int lastmile_buffer_delay_time_ms
Definition: AgoraBase.h:7179
agora::rtc::LiveTranscoding::videoBitrate
int videoBitrate
Definition: AgoraBase.h:4576
agora::rtc::FaceShapeBeautyOptions::FACE_SHAPE_BEAUTY_STYLE_FEMALE
@ FACE_SHAPE_BEAUTY_STYLE_FEMALE
Definition: AgoraBase.h:5685
agora::rtc::VideoTrackInfo::trackId
track_id_t trackId
Definition: AgoraBase.h:3919
agora::rtc::VideoTrackInfo::encodedFrameOnly
bool encodedFrameOnly
Definition: AgoraBase.h:3933
agora::rtc::FaceShapeBeautyOptions::FACE_SHAPE_BEAUTY_STYLE
FACE_SHAPE_BEAUTY_STYLE
The facial enhancement style options.
Definition: AgoraBase.h:5681
agora::rtc::SegmentationProperty::SCREEN_COLOR_BLUE
@ SCREEN_COLOR_BLUE
Definition: AgoraBase.h:6017
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_CHEEK
@ FACE_SHAPE_AREA_CHEEK
Definition: AgoraBase.h:5513
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MOUTHSCALE
@ FACE_SHAPE_AREA_MOUTHSCALE
Definition: AgoraBase.h:5619
agora::rtc::TranscodingUser::width
int width
Definition: AgoraBase.h:4505
agora::rtc::FaceShapeBeautyOptions::FACE_SHAPE_BEAUTY_STYLE_MALE
@ FACE_SHAPE_BEAUTY_STYLE_MALE
Definition: AgoraBase.h:5689
agora::rtc::ScreenCaptureParameters::highLightColor
unsigned int highLightColor
Definition: AgoraBase.h:6572
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_FACEWIDTH
@ FACE_SHAPE_AREA_FACEWIDTH
Definition: AgoraBase.h:5502
agora::base::AParameter
Definition: AgoraBase.h:8028
agora::rtc::BeautyOptions::sharpnessLevel
float sharpnessLevel
Definition: AgoraBase.h:5443
agora::rtc::MultipathStats::lanTxBytes
uint32_t lanTxBytes
Definition: AgoraBase.h:2699
agora::rtc::EncryptionConfig::encryptionMode
ENCRYPTION_MODE encryptionMode
Definition: AgoraBase.h:7291
agora::util::AOutputIterator
Definition: AgoraBase.h:202
agora::rtc::WatermarkOptions::positionInLandscapeMode
Rectangle positionInLandscapeMode
Definition: AgoraBase.h:2419
agora::rtc::IAudioEncodedFrameObserver
Definition: AgoraBase.h:6826
agora::rtc::WatermarkBuffer::length
int length
Definition: AgoraBase.h:2565
agora::rtc::EncodedVideoFrameInfo::width
int width
Definition: AgoraBase.h:1786
agora::rtc::WatermarkTimestamp::fontSize
int fontSize
Definition: AgoraBase.h:2485
agora::rtc::ScreenAudioParameters
The audio configuration for the shared screen stream.
Definition: AgoraBase.h:6447
agora::rtc::VideoTrackInfo::ownerUid
uid_t ownerUid
Definition: AgoraBase.h:3915
agora::rtc::VideoRenderingTracingInfo::join2JoinSuccess
int join2JoinSuccess
Definition: AgoraBase.h:7740
agora::rtc::LastmileProbeOneWayResult::availableBandwidth
unsigned int availableBandwidth
Definition: AgoraBase.h:5009
agora::rtc::EncodedVideoFrameInfo::captureTimeMs
int64_t captureTimeMs
Definition: AgoraBase.h:1813
agora::rtc::EncodedVideoFrameInfo::framesPerSecond
int framesPerSecond
Definition: AgoraBase.h:1796
agora::rtc::LiveTranscoding::transcodingExtraInfo
const char * transcodingExtraInfo
Definition: AgoraBase.h:4626
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo
Definition: AgoraBase.h:7120
agora::rtc::SimulcastConfig::StreamLayerConfig
Configures the parameters of a specific layer in multi-quality video streams.
Definition: AgoraBase.h:2304
agora::rtc::VideoTrackInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:3927
agora::rtc::DeviceInfo::isLowLatencyAudioSupported
bool isLowLatencyAudioSupported
Definition: AgoraBase.h:4024
agora::rtc::LiveTranscoding::metadata
const char * metadata
Definition: AgoraBase.h:4633
agora::rtc::LiveTranscoding::audioSampleRate
AUDIO_SAMPLE_RATE_TYPE audioSampleRate
Definition: AgoraBase.h:4662
agora::rtc::ChannelMediaRelayConfiguration
Configuration of cross channel media relay.
Definition: AgoraBase.h:7060
agora::rtc::VirtualBackgroundSource::blur_degree
BACKGROUND_BLUR_DEGREE blur_degree
Definition: AgoraBase.h:5975
agora::rtc::MultipathStats::pathStats
const PathStats * pathStats
Definition: AgoraBase.h:2727
agora::rtc::UserInfo::uid
uid_t uid
Definition: AgoraBase.h:7574
agora::rtc::DataStreamConfig::ordered
bool ordered
Definition: AgoraBase.h:2204
agora::rtc::LiveStreamAdvancedFeature
The configuration for advanced features of the RTMP or RTMPS streaming with transcoding.
Definition: AgoraBase.h:4407
agora::rtc::VirtualBackgroundSource::color
unsigned int color
Definition: AgoraBase.h:5959
agora::rtc::LastmileProbeOneWayResult
Results of the uplink or downlink last-mile network test.
Definition: AgoraBase.h:4997
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEGENERAL
@ FACE_SHAPE_AREA_NOSEGENERAL
Definition: AgoraBase.h:5612
agora::rtc::VideoDenoiserOptions
Video noise reduction options.
Definition: AgoraBase.h:5807
agora::rtc::WatermarkRatio::widthRatio
float widthRatio
Definition: AgoraBase.h:2395
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL_HIGH_QUALITY
@ VIDEO_DENOISER_LEVEL_HIGH_QUALITY
Definition: AgoraBase.h:5831
agora::rtc::VideoCanvas::cropArea
Rectangle cropArea
Definition: AgoraBase.h:5316
agora::rtc::AudioPcmDataInfo::samplesOut
size_t samplesOut
Definition: AgoraBase.h:1633
agora::rtc::VideoEncoderConfiguration::frameRate
int frameRate
Definition: AgoraBase.h:2071
agora::rtc::Rectangle::height
int height
Definition: AgoraBase.h:2358
agora::rtc::AudioPcmDataInfo::elapsedTimeMs
int64_t elapsedTimeMs
Definition: AgoraBase.h:1637
agora::rtc::WatermarkOptions::mode
WATERMARK_FIT_MODE mode
Definition: AgoraBase.h:2433
agora::rtc::MixedAudioStream::channelId
const char * channelId
Definition: AgoraBase.h:4888
agora::rtc::EncodedAudioFrameInfo::sampleRateHz
int sampleRateHz
Definition: AgoraBase.h:1589
agora::UserInfo
The information of the user.
Definition: AgoraBase.h:855
agora::rtc::RtcStats::txPacketLossRate
int txPacketLossRate
Definition: AgoraBase.h:2898
agora::rtc::VirtualBackgroundSource
The custom background.
Definition: AgoraBase.h:5892
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEPUPILS
@ FACE_SHAPE_AREA_EYEPUPILS
Definition: AgoraBase.h:5556
agora::rtc::LowlightEnhanceOptions::level
LOW_LIGHT_ENHANCE_LEVEL level
Definition: AgoraBase.h:5794
agora::rtc::VideoCanvas::view
view_t view
Definition: AgoraBase.h:5281
agora::rtc::TranscodingVideoStream::imageUrl
const char * imageUrl
Definition: AgoraBase.h:4738
agora::rtc::ScreenCaptureParameters::audioParams
ScreenAudioParameters audioParams
Definition: AgoraBase.h:6492
agora::rtc::AudioEncodedFrameObserverConfig::postionType
AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType
Definition: AgoraBase.h:6813
agora::rtc::IPacketObserver::onSendAudioPacket
virtual bool onSendAudioPacket(Packet &packet)=0
Occurs when the local user sends an audio packet.
agora::rtc::EncryptionConfig::encryptionKdfSalt
uint8_t encryptionKdfSalt[32]
Definition: AgoraBase.h:7304
agora::rtc::ScreenCaptureParameters::captureAudio
bool captureAudio
Definition: AgoraBase.h:6486
agora::rtc::VirtualBackgroundSource::BACKGROUND_IMG
@ BACKGROUND_IMG
Definition: AgoraBase.h:5910
agora::rtc::LiveTranscoding::watermark
RtcImage * watermark
Definition: AgoraBase.h:4639
agora::rtc::AudioVolumeInfo::vad
unsigned int vad
Definition: AgoraBase.h:4001
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSETIP
@ FACE_SHAPE_AREA_NOSETIP
Definition: AgoraBase.h:5605
agora::rtc::ChannelMediaInfo
Channel media information.
Definition: AgoraBase.h:7039
agora::rtc::WatermarkLiteral::wmLiteral
const char * wmLiteral
Definition: AgoraBase.h:2530
agora::UserInfo::hasVideo
bool hasVideo
Definition: AgoraBase.h:871
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_MANUAL
@ LOW_LIGHT_ENHANCE_MANUAL
Definition: AgoraBase.h:5767
agora::rtc::DownlinkNetworkInfo::total_downscale_level_count
int total_downscale_level_count
Definition: AgoraBase.h:7187
agora::VideoLayout::y
uint32_t y
Definition: AgoraBase.h:8161
agora::rtc::WatermarkLiteral::fontSize
int fontSize
Definition: AgoraBase.h:2520
agora::rtc::DownlinkNetworkInfo::bandwidth_estimation_bps
int bandwidth_estimation_bps
Definition: AgoraBase.h:7183
agora::rtc::LocalAudioStats::aecEstimatedDelay
int aecEstimatedDelay
Definition: AgoraBase.h:4204
agora::rtc::VideoCanvas::renderMode
media::base::RENDER_MODE_TYPE renderMode
Definition: AgoraBase.h:5290
agora::SpatialAudioParams::speaker_orientation
Optional< int > speaker_orientation
Definition: AgoraBase.h:8086
agora::rtc::LocalAudioStats::earMonitorDelay
int earMonitorDelay
Definition: AgoraBase.h:4199
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA
FACE_SHAPE_AREA
Chooses the specific facial areas that need to be adjusted.
Definition: AgoraBase.h:5472
agora::rtc::MultipathStats::lanRxBytes
uint32_t lanRxBytes
Definition: AgoraBase.h:2703
agora::rtc::VideoTrackInfo::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:3937
agora::rtc::RtcStats::txKBitRate
unsigned short txKBitRate
Definition: AgoraBase.h:2774
agora::rtc::EncodedAudioFrameInfo::numberOfChannels
int numberOfChannels
Definition: AgoraBase.h:1597
agora::rtc::EncodedVideoFrameInfo::streamType
VIDEO_STREAM_TYPE streamType
Definition: AgoraBase.h:1821
agora::rtc::SimulcastConfig::STREAM_LAYER_6
@ STREAM_LAYER_6
Definition: AgoraBase.h:2286
agora::rtc::MultipathStats::mobileRxBytes
uint32_t mobileRxBytes
Definition: AgoraBase.h:2719
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEINNERCORNER
@ FACE_SHAPE_AREA_EYEINNERCORNER
Definition: AgoraBase.h:5563
agora::rtc::LocalAudioStats::audioPlayoutDelay
int audioPlayoutDelay
Definition: AgoraBase.h:4195
agora::SpatialAudioParams::speaker_attenuation
Optional< double > speaker_attenuation
Definition: AgoraBase.h:8115
agora::rtc::VideoTrackInfo::observationPosition
uint32_t observationPosition
Definition: AgoraBase.h:3941
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_LOWEREYELID
@ FACE_SHAPE_AREA_LOWEREYELID
Definition: AgoraBase.h:5550
agora::rtc::AdvanceOptions::encodeAlpha
bool encodeAlpha
Definition: AgoraBase.h:1889
agora::VideoLayout::strUid
user_id_t strUid
Definition: AgoraBase.h:8149
agora::rtc::LogUploadServerInfo
Configuration information for the log server.
Definition: AgoraBase.h:7832
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL
VIDEO_DENOISER_LEVEL
Video noise reduction level.
Definition: AgoraBase.h:5825
agora::rtc::AudioTrackConfig::enableAudioProcessing
bool enableAudioProcessing
Definition: AgoraBase.h:6086
agora::rtc::VideoCanvas::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:5306
agora::rtc::CodecCapInfo
The codec capability of the SDK.
Definition: AgoraBase.h:2019
agora::rtc::ScreenCaptureParameters::frameRate
int frameRate
Definition: AgoraBase.h:6523
agora::rtc::AudioRecordingConfiguration::recordingChannel
int recordingChannel
Definition: AgoraBase.h:6768
agora::rtc::RtcStats::firstVideoKeyFramePacketDurationAfterUnmute
int firstVideoKeyFramePacketDurationAfterUnmute
Definition: AgoraBase.h:2883
agora::rtc::LiveTranscoding::audioChannels
int audioChannels
Definition: AgoraBase.h:4677
agora::rtc::RtcImage::height
int height
Definition: AgoraBase.h:4381
agora::rtc::SimulcastStreamConfig::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:2235
agora::rtc::EncodedVideoFrameInfo::frameType
VIDEO_FRAME_TYPE frameType
Definition: AgoraBase.h:1800
agora::rtc::LastmileProbeConfig::probeDownlink
bool probeDownlink
Definition: AgoraBase.h:4961
agora::rtc::SegmentationProperty::modelType
SEG_MODEL_TYPE modelType
Definition: AgoraBase.h:6023
agora::rtc::MultipathStats
Aggregates statistics of each network path in multipath transmission.
Definition: AgoraBase.h:2695
agora::rtc::RtcStats::userCount
unsigned int userCount
Definition: AgoraBase.h:2802
agora::rtc::EchoTestConfiguration::intervalInSeconds
int intervalInSeconds
Definition: AgoraBase.h:7553
agora::rtc::LocalTranscoderConfiguration::streamCount
unsigned int streamCount
Definition: AgoraBase.h:4802
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_HIGH
@ LIGHTENING_CONTRAST_HIGH
Definition: AgoraBase.h:5412
agora::base::LicenseCallback
Definition: AgoraBase.h:8042
agora::rtc::EncryptionConfig
Built-in encryption configurations.
Definition: AgoraBase.h:7286
agora::rtc::LiveTranscoding::videoCodecProfile
VIDEO_CODEC_PROFILE_TYPE videoCodecProfile
Definition: AgoraBase.h:4602
agora::rtc::SimulcastConfig::STREAM_LOW
@ STREAM_LOW
Definition: AgoraBase.h:2290
agora::rtc::VirtualBackgroundSource::BACKGROUND_SOURCE_TYPE
BACKGROUND_SOURCE_TYPE
The custom background.
Definition: AgoraBase.h:5896
agora::rtc::VideoRenderingTracingInfo::start2JoinChannel
int start2JoinChannel
Definition: AgoraBase.h:7733
agora::rtc::VideoCanvas::backgroundColor
uint32_t backgroundColor
Definition: AgoraBase.h:5286
agora::rtc::LocalAccessPointConfiguration::disableAut
bool disableAut
Definition: AgoraBase.h:7914
agora::rtc::ScreenAudioParameters::sampleRate
int sampleRate
Definition: AgoraBase.h:6451
agora::rtc::ScreenCaptureParameters::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:6517
agora::rtc::VideoDimensions::width
int width
Definition: AgoraBase.h:1170
agora::rtc::TranscodingVideoStream::x
int x
Definition: AgoraBase.h:4748
agora::rtc::LiveTranscoding::lowLatency
bool lowLatency
Definition: AgoraBase.h:4591
agora::rtc::TranscodingVideoStream
The video streams for local video mixing.
Definition: AgoraBase.h:4721
agora::rtc::VirtualBackgroundSource::source
const char * source
Definition: AgoraBase.h:5968
agora::rtc::LogUploadServerInfo::serverPath
const char * serverPath
Definition: AgoraBase.h:7840
agora::rtc::EncryptionConfig::datastreamEncryptionEnabled
bool datastreamEncryptionEnabled
Definition: AgoraBase.h:7311
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYESCALE
@ FACE_SHAPE_AREA_EYESCALE
Definition: AgoraBase.h:5530
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MOUTHLIP
@ FACE_SHAPE_AREA_MOUTHLIP
Definition: AgoraBase.h:5638
agora::rtc::SimulcastConfig::STREAM_LAYER_5
@ STREAM_LAYER_5
Definition: AgoraBase.h:2282
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEBRIDGE
@ FACE_SHAPE_AREA_NOSEBRIDGE
Definition: AgoraBase.h:5599
agora::rtc::SegmentationProperty::SCREEN_COLOR_AUTO
@ SCREEN_COLOR_AUTO
Definition: AgoraBase.h:6009
agora::VideoLayout::videoState
uint32_t videoState
Definition: AgoraBase.h:8177
agora::rtc::MixedAudioStream::sourceType
AUDIO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:4868
agora::rtc::WatermarkConfig
Used to configure watermark-related information.
Definition: AgoraBase.h:2586
agora::rtc::EchoTestConfiguration::view
view_t view
Definition: AgoraBase.h:7517
agora::rtc::RtcStats
Statistics of a call session.
Definition: AgoraBase.h:2742
agora::rtc::VideoSubscriptionOptions::encodedFrameOnly
Optional< bool > encodedFrameOnly
Definition: AgoraBase.h:1717
agora::rtc::IAudioEncodedFrameObserver::onRecordAudioEncodedFrame
virtual void onRecordAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
Gets the encoded audio data of the local user.
agora::rtc::VirtualBackgroundSource::BACKGROUND_VIDEO
@ BACKGROUND_VIDEO
Definition: AgoraBase.h:5918
agora::rtc::WatermarkOptions::visibleInPreview
bool visibleInPreview
Definition: AgoraBase.h:2414
agora::rtc::LowlightEnhanceOptions
The low-light enhancement options.
Definition: AgoraBase.h:5753
agora::rtc::TranscodingUser::zOrder
int zOrder
Definition: AgoraBase.h:4518
agora::rtc::UplinkNetworkInfo::video_encoder_target_bitrate_bps
int video_encoder_target_bitrate_bps
Definition: AgoraBase.h:7110
agora::rtc::LiveTranscoding::width
int width
Definition: AgoraBase.h:4561
agora::rtc::AudioPcmDataInfo
Definition: AgoraBase.h:1611
agora::rtc::RtcStats::rxBytes
unsigned int rxBytes
Definition: AgoraBase.h:2754
agora::rtc::RtcStats::rxVideoKBitRate
unsigned short rxVideoKBitRate
Definition: AgoraBase.h:2790
agora::rtc::VideoDenoiserOptions::mode
VIDEO_DENOISER_MODE mode
Definition: AgoraBase.h:5844
agora::rtc::RtcStats::rxAudioKBitRate
unsigned short rxAudioKBitRate
Definition: AgoraBase.h:2782
agora::rtc::SegmentationProperty::greenCapacity
float greenCapacity
Definition: AgoraBase.h:6033
agora::rtc::LocalAudioStats::numChannels
int numChannels
Definition: AgoraBase.h:4170
agora::rtc::VideoRenderingTracingInfo::remoteJoined2SetView
int remoteJoined2SetView
Definition: AgoraBase.h:7770
agora::rtc::SimulcastConfig::STREAM_LAYER_COUNT_MAX
@ STREAM_LAYER_COUNT_MAX
Definition: AgoraBase.h:2294
agora::rtc::WatermarkOptions
Watermark image configurations.
Definition: AgoraBase.h:2408
agora::rtc::VideoEncoderConfiguration::mirrorMode
VIDEO_MIRROR_MODE_TYPE mirrorMode
Definition: AgoraBase.h:2109
agora::rtc::LocalAudioStats
Local audio statistics.
Definition: AgoraBase.h:4166
agora::rtc::RecorderStreamInfo
The information about the media streams to be recorded.
Definition: AgoraBase.h:7942
agora::rtc::LogUploadServerInfo::serverPort
int serverPort
Definition: AgoraBase.h:7844
agora::rtc::SimulcastConfig
Configure video streams of different quality levels.
Definition: AgoraBase.h:2258
agora::rtc::ScreenCaptureParameters::captureMouseCursor
bool captureMouseCursor
Definition: AgoraBase.h:6537
agora::rtc::DownlinkNetworkInfo::total_received_video_count
int total_received_video_count
Definition: AgoraBase.h:7195
agora::rtc::MixedAudioStream::remoteUserUid
uid_t remoteUserUid
Definition: AgoraBase.h:4874
agora::rtc::WatermarkBuffer::width
int width
Definition: AgoraBase.h:2557
agora::rtc::RtcImage::y
int y
Definition: AgoraBase.h:4373
agora::rtc::FocalLengthInfo::focalLengthType
CAMERA_FOCAL_LENGTH_TYPE focalLengthType
Definition: AgoraBase.h:2051
agora::rtc::EncodedAudioFrameAdvancedSettings
Definition: AgoraBase.h:1547
agora::rtc::RtcStats::memoryAppUsageRatio
double memoryAppUsageRatio
Definition: AgoraBase.h:2833
agora::rtc::EchoTestConfiguration::enableVideo
bool enableVideo
Definition: AgoraBase.h:7531
agora::rtc::RtcStats::gatewayRtt
int gatewayRtt
Definition: AgoraBase.h:2828
agora::rtc::LastmileProbeConfig::expectedUplinkBitrate
unsigned int expectedUplinkBitrate
Definition: AgoraBase.h:4966
agora::rtc::VideoTrackInfo::isLocal
bool isLocal
Definition: AgoraBase.h:3911
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEPOSITION
@ FACE_SHAPE_AREA_EYEPOSITION
Definition: AgoraBase.h:5544
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo::expected_bitrate_bps
int expected_bitrate_bps
Definition: AgoraBase.h:7136
agora::rtc::IAudioEncodedFrameObserver::onPlaybackAudioEncodedFrame
virtual void onPlaybackAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
Gets the encoded audio data of all remote users.
agora::rtc::AdvanceOptions::encodingPreference
ENCODING_PREFERENCE encodingPreference
Definition: AgoraBase.h:1877
agora::rtc::SegmentationProperty::screenColorType
SCREEN_COLOR_TYPE screenColorType
Definition: AgoraBase.h:6038
agora::rtc::VideoTrackInfo::channelId
const char * channelId
Definition: AgoraBase.h:3923
agora::rtc::IAudioEncodedFrameObserver::onMixedAudioEncodedFrame
virtual void onMixedAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo)=0
Gets the mixed and encoded audio data of the local and all remote users.
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_LEVEL_FAST
@ LOW_LIGHT_ENHANCE_LEVEL_FAST
Definition: AgoraBase.h:5783
agora::rtc::RtcStats::firstVideoKeyFramePacketDuration
int firstVideoKeyFramePacketDuration
Definition: AgoraBase.h:2863
agora::rtc::CodecCapInfo::codecLevels
CodecCapLevels codecLevels
Definition: AgoraBase.h:2031
agora::rtc::LiveTranscoding::advancedFeatureCount
unsigned int advancedFeatureCount
Definition: AgoraBase.h:4690
agora::rtc::CodecCapInfo::codecCapMask
int codecCapMask
Definition: AgoraBase.h:2027
agora::rtc::AudioRecordingConfiguration
Recording configurations.
Definition: AgoraBase.h:6721
agora::SpatialAudioParams::speaker_azimuth
Optional< double > speaker_azimuth
Definition: AgoraBase.h:8066
agora::rtc::WatermarkTimestamp::strokeWidth
int strokeWidth
Definition: AgoraBase.h:2496
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_MODE
LOW_LIGHT_ENHANCE_MODE
The low-light enhancement mode.
Definition: AgoraBase.h:5757
agora::util::IContainer
Definition: AgoraBase.h:193
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_HIGH
@ BLUR_DEGREE_HIGH
Definition: AgoraBase.h:5939
agora::rtc::LocalAudioMixerConfiguration::syncWithLocalMic
bool syncWithLocalMic
Definition: AgoraBase.h:4940
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MANDIBLE
@ FACE_SHAPE_AREA_MANDIBLE
Definition: AgoraBase.h:5519
agora::rtc::VideoDimensions
The video dimension.
Definition: AgoraBase.h:1166
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_LOW
@ BLUR_DEGREE_LOW
Definition: AgoraBase.h:5929
agora::rtc::SegmentationProperty::SEG_MODEL_AI
@ SEG_MODEL_AI
Definition: AgoraBase.h:5995
agora::rtc::FaceShapeBeautyOptions::FACE_SHAPE_BEAUTY_STYLE_NATURAL
@ FACE_SHAPE_BEAUTY_STYLE_NATURAL
Definition: AgoraBase.h:5694
agora::rtc::VideoRenderingTracingInfo::joinSuccess2RemoteJoined
int joinSuccess2RemoteJoined
Definition: AgoraBase.h:7755
agora::rtc::FaceShapeAreaOptions::shapeIntensity
int shapeIntensity
Definition: AgoraBase.h:5663
agora::rtc::TranscodingVideoStream::height
int height
Definition: AgoraBase.h:4761
agora::rtc::DataStreamConfig::syncWithAudio
bool syncWithAudio
Definition: AgoraBase.h:2196
agora::rtc::LowlightEnhanceOptions::mode
LOW_LIGHT_ENHANCE_MODE mode
Definition: AgoraBase.h:5789
agora::rtc::LiveTranscoding::userCount
unsigned int userCount
Definition: AgoraBase.h:4615
agora::rtc::WatermarkBuffer
Configures the format, size, and pixel buffer of the watermark image.
Definition: AgoraBase.h:2552
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_FOREHEAD
@ FACE_SHAPE_AREA_FOREHEAD
Definition: AgoraBase.h:5486
agora::util::CopyableAutoPtr
Definition: AgoraBase.h:156
agora::rtc::WatermarkTimestamp
The definition of the WatermarkTimestamp struct.
Definition: AgoraBase.h:2481
agora::rtc::CodecCapInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:2023
agora::rtc::AudioTrackConfig
The configuration of custom audio tracks.
Definition: AgoraBase.h:6072
agora::rtc::FocalLengthInfo::cameraDirection
int cameraDirection
Definition: AgoraBase.h:2047
agora::rtc::LocalAccessPointConfiguration::ipListSize
int ipListSize
Definition: AgoraBase.h:7882
agora::rtc::SimulcastConfig::STREAM_LAYER_4
@ STREAM_LAYER_4
Definition: AgoraBase.h:2278
agora::rtc::TranscodingVideoStream::width
int width
Definition: AgoraBase.h:4757
agora::rtc::TranscodingVideoStream::mirror
bool mirror
Definition: AgoraBase.h:4780
agora::rtc::SimulcastStreamConfig::kBitrate
int kBitrate
Definition: AgoraBase.h:2241
agora::rtc::RtcImage::alpha
double alpha
Definition: AgoraBase.h:4395
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEOUTERCORNER
@ FACE_SHAPE_AREA_EYEOUTERCORNER
Definition: AgoraBase.h:5570
agora::rtc::TranscodingVideoStream::mediaPlayerId
int mediaPlayerId
Definition: AgoraBase.h:4743
agora::rtc::VideoCanvas::subviewUid
uid_t subviewUid
Definition: AgoraBase.h:5275
agora::rtc::EncryptionConfig::encryptionKey
const char * encryptionKey
Definition: AgoraBase.h:7297
agora::rtc::MultipathStats::mobileTxBytes
uint32_t mobileTxBytes
Definition: AgoraBase.h:2715
agora::rtc::EncodedVideoFrameInfo::trackId
int trackId
Definition: AgoraBase.h:1808
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_MEDIUM
@ BLUR_DEGREE_MEDIUM
Definition: AgoraBase.h:5934
agora::rtc::ScreenCaptureParameters::excludeWindowList
view_t * excludeWindowList
Definition: AgoraBase.h:6553
agora::rtc::LocalAccessPointConfiguration::domainList
const char ** domainList
Definition: AgoraBase.h:7890
agora::rtc::SimulcastConfig::STREAM_LAYER_3
@ STREAM_LAYER_3
Definition: AgoraBase.h:2274
agora::rtc::IPacketObserver::onSendVideoPacket
virtual bool onSendVideoPacket(Packet &packet)=0
Occurs when the local user sends a video packet.
agora::rtc::AudioPcmDataInfo::samplesPerChannel
size_t samplesPerChannel
Definition: AgoraBase.h:1625
agora::rtc::VideoTrackInfo
Definition: AgoraBase.h:3896
agora::rtc::LocalTranscoderConfiguration::videoOutputConfiguration
VideoEncoderConfiguration videoOutputConfiguration
Definition: AgoraBase.h:4811
agora::rtc::EchoTestConfiguration::enableAudio
bool enableAudio
Definition: AgoraBase.h:7524
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_HEADSCALE
@ FACE_SHAPE_AREA_HEADSCALE
Definition: AgoraBase.h:5481
agora::rtc::SenderOptions::ccMode
TCcMode ccMode
Definition: AgoraBase.h:1346
agora::rtc::SimulcastConfig::StreamLayerConfig::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:2308
agora::rtc::VirtualBackgroundSource::BACKGROUND_COLOR
@ BACKGROUND_COLOR
Definition: AgoraBase.h:5906
agora::rtc::CodecCapLevels::swDecodingLevel
VIDEO_CODEC_CAPABILITY_LEVEL swDecodingLevel
Definition: AgoraBase.h:2009
agora::rtc::AudioPcmDataInfo::ntpTimeMs
int64_t ntpTimeMs
Definition: AgoraBase.h:1641
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_AUTO
@ LOW_LIGHT_ENHANCE_AUTO
Definition: AgoraBase.h:5763
agora::rtc::RtcStats::firstVideoPacketDurationAfterUnmute
int firstVideoPacketDurationAfterUnmute
Definition: AgoraBase.h:2878
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NONE
@ FACE_SHAPE_AREA_NONE
Definition: AgoraBase.h:5476
agora::rtc::LiveTranscoding::videoFramerate
int videoFramerate
Definition: AgoraBase.h:4582
agora::rtc::RtcStats::rxPacketLossRate
int rxPacketLossRate
Definition: AgoraBase.h:2903
agora::rtc::RtcStats::lastmileDelay
unsigned short lastmileDelay
Definition: AgoraBase.h:2798
agora::rtc::FaceShapeAreaOptions
Filter effect options.
Definition: AgoraBase.h:5466
agora::rtc::CodecCapLevels
The level of the codec capability.
Definition: AgoraBase.h:1999
agora::SpatialAudioParams
The spatial audio parameters.
Definition: AgoraBase.h:8056
agora::rtc::ColorEnhanceOptions::skinProtectLevel
float skinProtectLevel
Definition: AgoraBase.h:5881
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL_FAST
@ VIDEO_DENOISER_LEVEL_FAST
Definition: AgoraBase.h:5839
agora::rtc::SegmentationProperty::SCREEN_COLOR_GREEN
@ SCREEN_COLOR_GREEN
Definition: AgoraBase.h:6013
agora::rtc::VideoEncoderConfiguration::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:2061
agora::rtc::LastmileProbeResult::rtt
unsigned int rtt
Definition: AgoraBase.h:5033
agora::rtc::TranscodingVideoStream::y
int y
Definition: AgoraBase.h:4753
agora::rtc::PathStats::rxKBitRate
int rxKBitRate
Definition: AgoraBase.h:2685
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEROOT
@ FACE_SHAPE_AREA_NOSEROOT
Definition: AgoraBase.h:5593
agora::rtc::RtcStats::packetsBeforeFirstKeyFramePacket
int packetsBeforeFirstKeyFramePacket
Definition: AgoraBase.h:2868
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_NORMAL
@ LIGHTENING_CONTRAST_NORMAL
Definition: AgoraBase.h:5408
agora::rtc::ChannelMediaRelayConfiguration::srcInfo
ChannelMediaInfo * srcInfo
Definition: AgoraBase.h:7074
agora::rtc::VideoEncoderConfiguration::orientationMode
ORIENTATION_MODE orientationMode
Definition: AgoraBase.h:2095
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEBROWPOSITION
@ FACE_SHAPE_AREA_EYEBROWPOSITION
Definition: AgoraBase.h:5645
agora::rtc::LiveStreamAdvancedFeature::opened
bool opened
Definition: AgoraBase.h:4427
agora::rtc::WatermarkBuffer::format
media::base::VIDEO_PIXEL_FORMAT format
Definition: AgoraBase.h:2571
agora::rtc::FocalLengthInfo
Focal length information supported by the camera, including the camera direction and focal length typ...
Definition: AgoraBase.h:2043
agora::rtc::EchoTestConfiguration::token
const char * token
Definition: AgoraBase.h:7539
agora::rtc::DeviceInfo
The audio device information.
Definition: AgoraBase.h:4018
agora::base::IEngineBase
Definition: AgoraBase.h:8022
agora::rtc::SenderOptions::targetBitrate
int targetBitrate
Definition: AgoraBase.h:1412
agora::rtc::AudioRecordingConfiguration::quality
AUDIO_RECORDING_QUALITY_TYPE quality
Definition: AgoraBase.h:6753
agora::util::IIterator
Definition: AgoraBase.h:184
agora::rtc::UserInfo::userAccount
char userAccount[MAX_USER_ACCOUNT_LENGTH]
Definition: AgoraBase.h:7578
agora::rtc::VideoRenderingTracingInfo
Indicators during video frame rendering progress.
Definition: AgoraBase.h:7718
agora::rtc::LogUploadServerInfo::serverHttps
bool serverHttps
Definition: AgoraBase.h:7850
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_MANUAL
@ VIDEO_DENOISER_MANUAL
Definition: AgoraBase.h:5820
agora::rtc::WatermarkTimestamp::fontFilePath
const char * fontFilePath
Definition: AgoraBase.h:2492
agora::rtc::EncodedAudioFrameInfo::samplesPerChannel
int samplesPerChannel
Definition: AgoraBase.h:1593
agora::rtc::EncodedVideoFrameInfo::height
int height
Definition: AgoraBase.h:1790
agora::rtc::RtcStats::memoryAppUsageInKbytes
int memoryAppUsageInKbytes
Definition: AgoraBase.h:2843
agora::rtc::FaceShapeBeautyOptions::styleIntensity
int styleIntensity
Definition: AgoraBase.h:5707
agora::rtc::WatermarkLiteral::fontFilePath
const char * fontFilePath
Definition: AgoraBase.h:2537
agora::VideoLayout::uid
rtc::uid_t uid
Definition: AgoraBase.h:8145
agora::rtc::WatermarkConfig::type
WATERMARK_SOURCE_TYPE type
Definition: AgoraBase.h:2594
agora::rtc::PathStats::txKBitRate
int txKBitRate
Definition: AgoraBase.h:2681
agora::Optional< VIDEO_STREAM_TYPE >
agora::rtc::LocalAccessPointConfiguration::domainListSize
int domainListSize
Definition: AgoraBase.h:7895
agora::rtc::PathStats::type
MultipathType type
Definition: AgoraBase.h:2677
agora::rtc::ClientRoleOptions
Setting of user role properties.
Definition: AgoraBase.h:2999
agora::rtc::WatermarkLiteral::strokeWidth
int strokeWidth
Definition: AgoraBase.h:2524
agora::rtc::TranscodingUser::height
int height
Definition: AgoraBase.h:4509
agora::rtc::IPacketObserver::onReceiveAudioPacket
virtual bool onReceiveAudioPacket(Packet &packet)=0
Occurs when the local user receives an audio packet.
agora::rtc::VideoCanvas
Attributes of the video canvas object.
Definition: AgoraBase.h:5266
agora::rtc::LocalAudioStats::internalCodec
int internalCodec
Definition: AgoraBase.h:4182
agora::rtc::AudioRecordingConfiguration::fileRecordingType
AUDIO_FILE_RECORDING_TYPE fileRecordingType
Definition: AgoraBase.h:6748
agora::rtc::SegmentationProperty
Processing properties for background images.
Definition: AgoraBase.h:5987
agora::rtc::SimulcastConfig::StreamLayerConfig::enable
bool enable
Definition: AgoraBase.h:2318
agora::rtc::ChannelMediaInfo::uid
uid_t uid
Definition: AgoraBase.h:7043