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,
3533 LOCAL_VIDEO_EVENT_TYPE_CAMERA_FOCAL_LENGTH_APPLIED = 5,
3538 LOCAL_VIDEO_EVENT_TYPE_CAMERA_FOCAL_LENGTH_FALLBACK_TO_DEFAULT = 6,
3539 };
3540
3544 enum LOCAL_VIDEO_STREAM_REASON {
3548 LOCAL_VIDEO_STREAM_REASON_OK = 0,
3552 LOCAL_VIDEO_STREAM_REASON_FAILURE = 1,
3557 LOCAL_VIDEO_STREAM_REASON_DEVICE_NO_PERMISSION = 2,
3562 LOCAL_VIDEO_STREAM_REASON_DEVICE_BUSY = 3,
3567 LOCAL_VIDEO_STREAM_REASON_CAPTURE_FAILURE = 4,
3571 LOCAL_VIDEO_STREAM_REASON_CODEC_NOT_SUPPORT = 5,
3576 LOCAL_VIDEO_STREAM_REASON_CAPTURE_INBACKGROUND = 6,
3583 LOCAL_VIDEO_STREAM_REASON_CAPTURE_MULTIPLE_FOREGROUND_APPS = 7,
3589 LOCAL_VIDEO_STREAM_REASON_DEVICE_NOT_FOUND = 8,
3594 LOCAL_VIDEO_STREAM_REASON_DEVICE_DISCONNECTED = 9,
3599 LOCAL_VIDEO_STREAM_REASON_DEVICE_INVALID_ID = 10,
3608 LOCAL_VIDEO_STREAM_REASON_DEVICE_INTERRUPT = 14,
3614 LOCAL_VIDEO_STREAM_REASON_DEVICE_FATAL_ERROR = 15,
3618 LOCAL_VIDEO_STREAM_REASON_DEVICE_SYSTEM_PRESSURE = 101,
3624 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_MINIMIZED = 11,
3638 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_CLOSED = 12,
3643 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_OCCLUDED = 13,
3645 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_NOT_SUPPORTED = 20,
3649 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_FAILURE = 21,
3653 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_NO_PERMISSION = 22,
3663 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_AUTO_FALLBACK = 24,
3668 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_HIDDEN = 25,
3672 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_HIDDEN = 26,
3677 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_MINIMIZED = 27,
3683 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_PAUSED = 28,
3687 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_RESUMED = 29,
3692 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_DISPLAY_DISCONNECTED = 30,
3693 /* 30: (HMOS only) ScreenCapture stopped by user */
3694 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_STOPPED_BY_USER = 31,
3695 /* 31: (HMOS only) ScreenCapture interrupted by other screen capture */
3696 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_INTERRUPTED_BY_OTHER = 32,
3697 /* 32: (HMOS only) ScreenCapture stopped by SIM call */
3698 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_STOPPED_BY_CALL = 33,
3700 LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_EXCLUDE_WINDOW_FAILED = 34,
3701 };
3702
3706 enum REMOTE_AUDIO_STATE {
3712 REMOTE_AUDIO_STATE_STOPPED =
3713 0, // Default state, audio is started or remote user disabled/muted audio stream
3717 REMOTE_AUDIO_STATE_STARTING = 1, // The first audio frame packet has been received
3723 REMOTE_AUDIO_STATE_DECODING =
3724 2, // The first remote audio frame has been decoded or fronzen state ends
3729 REMOTE_AUDIO_STATE_FROZEN = 3, // Remote audio is frozen, probably due to network issue
3734 REMOTE_AUDIO_STATE_FAILED = 4, // Remote audio play failed
3735 };
3736
3740 enum REMOTE_AUDIO_STATE_REASON {
3744 REMOTE_AUDIO_REASON_INTERNAL = 0,
3748 REMOTE_AUDIO_REASON_NETWORK_CONGESTION = 1,
3752 REMOTE_AUDIO_REASON_NETWORK_RECOVERY = 2,
3756 REMOTE_AUDIO_REASON_LOCAL_MUTED = 3,
3760 REMOTE_AUDIO_REASON_LOCAL_UNMUTED = 4,
3764 REMOTE_AUDIO_REASON_REMOTE_MUTED = 5,
3768 REMOTE_AUDIO_REASON_REMOTE_UNMUTED = 6,
3772 REMOTE_AUDIO_REASON_REMOTE_OFFLINE = 7,
3776 REMOTE_AUDIO_REASON_NO_PACKET_RECEIVE = 8,
3780 REMOTE_AUDIO_REASON_LOCAL_PLAY_FAILED = 9,
3781 };
3782
3786 enum REMOTE_VIDEO_STATE {
3792 REMOTE_VIDEO_STATE_STOPPED = 0,
3796 REMOTE_VIDEO_STATE_STARTING = 1,
3803 REMOTE_VIDEO_STATE_DECODING = 2,
3808 REMOTE_VIDEO_STATE_FROZEN = 3,
3813 REMOTE_VIDEO_STATE_FAILED = 4,
3814 };
3818 enum REMOTE_VIDEO_STATE_REASON {
3822 REMOTE_VIDEO_STATE_REASON_INTERNAL = 0,
3826 REMOTE_VIDEO_STATE_REASON_NETWORK_CONGESTION = 1,
3830 REMOTE_VIDEO_STATE_REASON_NETWORK_RECOVERY = 2,
3834 REMOTE_VIDEO_STATE_REASON_LOCAL_MUTED = 3,
3838 REMOTE_VIDEO_STATE_REASON_LOCAL_UNMUTED = 4,
3842 REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED = 5,
3846 REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED = 6,
3850 REMOTE_VIDEO_STATE_REASON_REMOTE_OFFLINE = 7,
3855 REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK = 8,
3860 REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK_RECOVERY = 9,
3863 REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_LOW = 10,
3866 REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_HIGH = 11,
3870 REMOTE_VIDEO_STATE_REASON_SDK_IN_BACKGROUND = 12,
3871
3875 REMOTE_VIDEO_STATE_REASON_CODEC_NOT_SUPPORT = 13,
3876
3877 };
3878
3882 enum REMOTE_USER_STATE {
3886 USER_STATE_MUTE_AUDIO = (1 << 0),
3890 USER_STATE_MUTE_VIDEO = (1 << 1),
3894 USER_STATE_ENABLE_VIDEO = (1 << 4),
3898 USER_STATE_ENABLE_LOCAL_VIDEO = (1 << 8),
3899 };
3900
3905 struct VideoTrackInfo {
3906 VideoTrackInfo()
3907 : isLocal(false),
3908 ownerUid(0),
3909 trackId(0),
3910 channelId(OPTIONAL_NULLPTR),
3911 codecType(VIDEO_CODEC_H265),
3912 encodedFrameOnly(false),
3913 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
3914 observationPosition(agora::media::base::POSITION_POST_CAPTURER) {}
3920 bool isLocal;
3924 uid_t ownerUid;
3928 track_id_t trackId;
3932 const char* channelId;
3936 VIDEO_CODEC_TYPE codecType;
3942 bool encodedFrameOnly;
3946 VIDEO_SOURCE_TYPE sourceType;
3950 uint32_t observationPosition;
3951 };
3952
3957 enum REMOTE_VIDEO_DOWNSCALE_LEVEL {
3961 REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE,
3965 REMOTE_VIDEO_DOWNSCALE_LEVEL_1,
3969 REMOTE_VIDEO_DOWNSCALE_LEVEL_2,
3973 REMOTE_VIDEO_DOWNSCALE_LEVEL_3,
3977 REMOTE_VIDEO_DOWNSCALE_LEVEL_4,
3978 };
3979
3983 struct AudioVolumeInfo {
3990 uid_t uid;
3999 unsigned int volume; // [0,255]
4010 unsigned int vad;
4016 double voicePitch;
4017
4018 AudioVolumeInfo() : uid(0), volume(0), vad(0), voicePitch(0.0) {}
4019 };
4020
4027 struct DeviceInfo {
4033 bool isLowLatencyAudioSupported;
4034
4035 DeviceInfo() : isLowLatencyAudioSupported(false) {}
4036 };
4037
4041 class IPacketObserver {
4042 public:
4043 virtual ~IPacketObserver() {}
4047 struct Packet {
4053 const unsigned char* buffer;
4057 unsigned int size;
4058
4059 Packet() : buffer(OPTIONAL_NULLPTR), size(0) {}
4060 };
4070 virtual bool onSendAudioPacket(Packet& packet) = 0;
4080 virtual bool onSendVideoPacket(Packet& packet) = 0;
4090 virtual bool onReceiveAudioPacket(Packet& packet) = 0;
4100 virtual bool onReceiveVideoPacket(Packet& packet) = 0;
4101 };
4102
4106 enum AUDIO_SAMPLE_RATE_TYPE {
4110 AUDIO_SAMPLE_RATE_32000 = 32000,
4114 AUDIO_SAMPLE_RATE_44100 = 44100,
4118 AUDIO_SAMPLE_RATE_48000 = 48000,
4119 };
4123 enum VIDEO_CODEC_TYPE_FOR_STREAM {
4127 VIDEO_CODEC_H264_FOR_STREAM = 1,
4131 VIDEO_CODEC_H265_FOR_STREAM = 2,
4132 };
4133
4137 enum VIDEO_CODEC_PROFILE_TYPE {
4141 VIDEO_CODEC_PROFILE_BASELINE = 66,
4146 VIDEO_CODEC_PROFILE_MAIN = 77,
4151 VIDEO_CODEC_PROFILE_HIGH = 100,
4152 };
4153
4157 enum AUDIO_CODEC_PROFILE_TYPE {
4161 AUDIO_CODEC_PROFILE_LC_AAC = 0,
4165 AUDIO_CODEC_PROFILE_HE_AAC = 1,
4169 AUDIO_CODEC_PROFILE_HE_AAC_V2 = 2,
4170 };
4171
4175 struct LocalAudioStats {
4179 int numChannels;
4183 int sentSampleRate;
4187 int sentBitrate;
4191 int internalCodec;
4196 unsigned short txPacketLossRate;
4200 int audioDeviceDelay;
4204 int audioPlayoutDelay;
4208 int earMonitorDelay;
4213 int aecEstimatedDelay;
4214 };
4215
4219 enum RTMP_STREAM_PUBLISH_STATE {
4223 RTMP_STREAM_PUBLISH_STATE_IDLE = 0,
4227 RTMP_STREAM_PUBLISH_STATE_CONNECTING = 1,
4232 RTMP_STREAM_PUBLISH_STATE_RUNNING = 2,
4241 RTMP_STREAM_PUBLISH_STATE_RECOVERING = 3,
4246 RTMP_STREAM_PUBLISH_STATE_FAILURE = 4,
4252 RTMP_STREAM_PUBLISH_STATE_DISCONNECTING = 5,
4253 };
4254
4258 enum RTMP_STREAM_PUBLISH_REASON {
4262 RTMP_STREAM_PUBLISH_REASON_OK = 0,
4266 RTMP_STREAM_PUBLISH_REASON_INVALID_ARGUMENT = 1,
4270 RTMP_STREAM_PUBLISH_REASON_ENCRYPTED_STREAM_NOT_ALLOWED = 2,
4274 RTMP_STREAM_PUBLISH_REASON_CONNECTION_TIMEOUT = 3,
4278 RTMP_STREAM_PUBLISH_REASON_INTERNAL_SERVER_ERROR = 4,
4282 RTMP_STREAM_PUBLISH_REASON_RTMP_SERVER_ERROR = 5,
4286 RTMP_STREAM_PUBLISH_REASON_TOO_OFTEN = 6,
4290 RTMP_STREAM_PUBLISH_REASON_REACH_LIMIT = 7,
4295 RTMP_STREAM_PUBLISH_REASON_NOT_AUTHORIZED = 8,
4299 RTMP_STREAM_PUBLISH_REASON_STREAM_NOT_FOUND = 9,
4304 RTMP_STREAM_PUBLISH_REASON_FORMAT_NOT_SUPPORTED = 10,
4309 RTMP_STREAM_PUBLISH_REASON_NOT_BROADCASTER =
4310 11, // Note: match to ERR_PUBLISH_STREAM_NOT_BROADCASTER in AgoraBase.h
4315 RTMP_STREAM_PUBLISH_REASON_TRANSCODING_NO_MIX_STREAM =
4316 13, // Note: match to ERR_PUBLISH_STREAM_TRANSCODING_NO_MIX_STREAM in AgoraBase.h
4320 RTMP_STREAM_PUBLISH_REASON_NET_DOWN = 14, // Note: match to ERR_NET_DOWN in AgoraBase.h
4324 RTMP_STREAM_PUBLISH_REASON_INVALID_APPID =
4325 15, // Note: match to ERR_PUBLISH_STREAM_APPID_INVALID in AgoraBase.h
4329 RTMP_STREAM_PUBLISH_REASON_INVALID_PRIVILEGE = 16,
4334 RTMP_STREAM_UNPUBLISH_REASON_OK = 100,
4335 };
4336
4340 enum RTMP_STREAMING_EVENT {
4344 RTMP_STREAMING_EVENT_FAILED_LOAD_IMAGE = 1,
4349 RTMP_STREAMING_EVENT_URL_ALREADY_IN_USE = 2,
4353 RTMP_STREAMING_EVENT_ADVANCED_FEATURE_NOT_SUPPORT = 3,
4357 RTMP_STREAMING_EVENT_REQUEST_TOO_OFTEN = 4,
4358 };
4359
4367 typedef struct RtcImage {
4372 const char* url;
4377 int x;
4382 int y;
4386 int width;
4390 int height;
4398 int zOrder;
4404 double alpha;
4405
4406 RtcImage() : url(OPTIONAL_NULLPTR), x(0), y(0), width(0), height(0), zOrder(0), alpha(1.0) {}
4407 } RtcImage;
4416 struct LiveStreamAdvancedFeature {
4417 LiveStreamAdvancedFeature() : featureName(OPTIONAL_NULLPTR), opened(false) {}
4418 LiveStreamAdvancedFeature(const char* feat_name, bool open)
4419 : featureName(feat_name), opened(open) {}
4421 // static const char* LBHQ = "lbhq";
4423 // static const char* VEO = "veo";
4424
4429 const char* featureName;
4430
4436 bool opened;
4437 };
4438
4442 enum CONNECTION_STATE_TYPE {
4450 CONNECTION_STATE_DISCONNECTED = 1,
4460 CONNECTION_STATE_CONNECTING = 2,
4468 CONNECTION_STATE_CONNECTED = 3,
4478 CONNECTION_STATE_RECONNECTING = 4,
4488 CONNECTION_STATE_FAILED = 5,
4489 };
4490
4494 struct TranscodingUser {
4498 uid_t uid;
4504 int x;
4510 int y;
4514 int width;
4518 int height;
4527 int zOrder;
4533 double alpha;
4553 int audioChannel;
4554
4555 TranscodingUser()
4556 : uid(0), x(0), y(0), width(0), height(0), zOrder(0), alpha(1.0), audioChannel(0) {}
4557 };
4558
4562 struct LiveTranscoding {
4570 int width;
4578 int height;
4585 int videoBitrate;
4591 int videoFramerate;
4592
4600 bool lowLatency;
4601
4605 int videoGop;
4611 VIDEO_CODEC_PROFILE_TYPE videoCodecProfile;
4616 unsigned int backgroundColor;
4620 VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType;
4624 unsigned int userCount;
4629 TranscodingUser* transcodingUsers;
4635 const char* transcodingExtraInfo;
4636
4642 const char* metadata;
4648 RtcImage* watermark;
4653 unsigned int watermarkCount;
4654
4661 RtcImage* backgroundImage;
4666 unsigned int backgroundImageCount;
4667
4671 AUDIO_SAMPLE_RATE_TYPE audioSampleRate;
4676 int audioBitrate;
4686 int audioChannels;
4690 AUDIO_CODEC_PROFILE_TYPE audioCodecProfile;
4694 LiveStreamAdvancedFeature* advancedFeatures;
4695
4699 unsigned int advancedFeatureCount;
4700
4701 LiveTranscoding()
4702 : width(360),
4703 height(640),
4704 videoBitrate(400),
4705 videoFramerate(15),
4706 lowLatency(false),
4707 videoGop(30),
4708 videoCodecProfile(VIDEO_CODEC_PROFILE_HIGH),
4709 backgroundColor(0x000000),
4710 videoCodecType(VIDEO_CODEC_H264_FOR_STREAM),
4711 userCount(0),
4712 transcodingUsers(OPTIONAL_NULLPTR),
4713 transcodingExtraInfo(OPTIONAL_NULLPTR),
4714 metadata(OPTIONAL_NULLPTR),
4715 watermark(OPTIONAL_NULLPTR),
4716 watermarkCount(0),
4717 backgroundImage(OPTIONAL_NULLPTR),
4718 backgroundImageCount(0),
4719 audioSampleRate(AUDIO_SAMPLE_RATE_48000),
4720 audioBitrate(48),
4721 audioChannels(1),
4722 audioCodecProfile(AUDIO_CODEC_PROFILE_LC_AAC),
4723 advancedFeatures(OPTIONAL_NULLPTR),
4724 advancedFeatureCount(0) {}
4725 };
4726
4730 struct TranscodingVideoStream {
4734 VIDEO_SOURCE_TYPE sourceType;
4740 uid_t remoteUserUid;
4747 const char* imageUrl;
4752 int mediaPlayerId;
4757 int x;
4762 int y;
4766 int width;
4770 int height;
4777 int zOrder;
4782 double alpha;
4789 bool mirror;
4790
4791 TranscodingVideoStream()
4792 : sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
4793 remoteUserUid(0),
4794 imageUrl(OPTIONAL_NULLPTR),
4795 x(0),
4796 y(0),
4797 width(0),
4798 height(0),
4799 zOrder(0),
4800 alpha(1.0),
4801 mirror(false) {}
4802 };
4803
4807 struct LocalTranscoderConfiguration {
4811 unsigned int streamCount;
4815 TranscodingVideoStream* videoInputStreams;
4820 VideoEncoderConfiguration videoOutputConfiguration;
4829 bool syncWithPrimaryCamera;
4830
4831 LocalTranscoderConfiguration()
4832 : streamCount(0),
4833 videoInputStreams(OPTIONAL_NULLPTR),
4834 videoOutputConfiguration(),
4835 syncWithPrimaryCamera(true) {}
4836 };
4837
4841 enum VIDEO_TRANSCODER_ERROR {
4846 VT_ERR_VIDEO_SOURCE_NOT_READY = 1,
4850 VT_ERR_INVALID_VIDEO_SOURCE_TYPE = 2,
4854 VT_ERR_INVALID_IMAGE_PATH = 3,
4858 VT_ERR_UNSUPPORT_IMAGE_FORMAT = 4,
4862 VT_ERR_INVALID_LAYOUT = 5,
4866 VT_ERR_INTERNAL = 20
4867 };
4868
4869
4873 struct MixedAudioStream {
4877 AUDIO_SOURCE_TYPE sourceType;
4883 uid_t remoteUserUid;
4897 const char* channelId;
4904 track_id_t trackId;
4905
4906 MixedAudioStream(AUDIO_SOURCE_TYPE source)
4907 : sourceType(source),
4908 remoteUserUid(0),
4909 channelId(NULL),
4910 trackId(-1) {}
4911
4912 MixedAudioStream(AUDIO_SOURCE_TYPE source, track_id_t track)
4913 : sourceType(source),
4914 trackId(track) {}
4915
4916 MixedAudioStream(AUDIO_SOURCE_TYPE source, uid_t uid, const char* channel)
4917 : sourceType(source),
4918 remoteUserUid(uid),
4919 channelId(channel) {}
4920
4921 MixedAudioStream(AUDIO_SOURCE_TYPE source, uid_t uid, const char* channel, track_id_t track)
4922 : sourceType(source),
4923 remoteUserUid(uid),
4924 channelId(channel),
4925 trackId(track) {}
4926
4927 };
4928
4932 struct LocalAudioMixerConfiguration {
4936 unsigned int streamCount;
4940 MixedAudioStream* audioInputStreams;
4941
4949 bool syncWithLocalMic;
4950
4951 LocalAudioMixerConfiguration() : streamCount(0), syncWithLocalMic(true) {}
4952 };
4953
4957 struct LastmileProbeConfig {
4964 bool probeUplink;
4970 bool probeDownlink;
4975 unsigned int expectedUplinkBitrate;
4980 unsigned int expectedDownlinkBitrate;
4981 };
4982
4986 enum LASTMILE_PROBE_RESULT_STATE {
4990 LASTMILE_PROBE_RESULT_COMPLETE = 1,
4996 LASTMILE_PROBE_RESULT_INCOMPLETE_NO_BWE = 2,
5000 LASTMILE_PROBE_RESULT_UNAVAILABLE = 3
5001 };
5002
5006 struct LastmileProbeOneWayResult {
5010 unsigned int packetLossRate;
5014 unsigned int jitter;
5018 unsigned int availableBandwidth;
5019
5020 LastmileProbeOneWayResult() : packetLossRate(0), jitter(0), availableBandwidth(0) {}
5021 };
5022
5026 struct LastmileProbeResult {
5030 LASTMILE_PROBE_RESULT_STATE state;
5034 LastmileProbeOneWayResult uplinkReport;
5038 LastmileProbeOneWayResult downlinkReport;
5042 unsigned int rtt;
5043
5044 LastmileProbeResult() : state(LASTMILE_PROBE_RESULT_UNAVAILABLE), rtt(0) {}
5045 };
5046
5050 enum CONNECTION_CHANGED_REASON_TYPE {
5054 CONNECTION_CHANGED_CONNECTING = 0,
5058 CONNECTION_CHANGED_JOIN_SUCCESS = 1,
5062 CONNECTION_CHANGED_INTERRUPTED = 2,
5067 CONNECTION_CHANGED_BANNED_BY_SERVER = 3,
5073 CONNECTION_CHANGED_JOIN_FAILED = 4,
5077 CONNECTION_CHANGED_LEAVE_CHANNEL = 5,
5082 CONNECTION_CHANGED_INVALID_APP_ID = 6,
5092 CONNECTION_CHANGED_INVALID_CHANNEL_NAME = 7,
5107 CONNECTION_CHANGED_INVALID_TOKEN = 8,
5112 CONNECTION_CHANGED_TOKEN_EXPIRED = 9,
5121 CONNECTION_CHANGED_REJECTED_BY_SERVER = 10,
5125 CONNECTION_CHANGED_SETTING_PROXY_SERVER = 11,
5129 CONNECTION_CHANGED_RENEW_TOKEN = 12,
5134 CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED = 13,
5139 CONNECTION_CHANGED_KEEP_ALIVE_TIMEOUT = 14,
5143 CONNECTION_CHANGED_REJOIN_SUCCESS = 15,
5147 CONNECTION_CHANGED_LOST = 16,
5151 CONNECTION_CHANGED_ECHO_TEST = 17,
5155 CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED_BY_USER = 18,
5159 CONNECTION_CHANGED_SAME_UID_LOGIN = 19,
5163 CONNECTION_CHANGED_TOO_MANY_BROADCASTERS = 20,
5164
5168 CONNECTION_CHANGED_LICENSE_VALIDATION_FAILURE = 21,
5169 /*
5170 * 22: The connection is failed due to certification verify failure.
5171 */
5172 CONNECTION_CHANGED_CERTIFICATION_VERYFY_FAILURE = 22,
5176 CONNECTION_CHANGED_STREAM_CHANNEL_NOT_AVAILABLE = 23,
5180 CONNECTION_CHANGED_INCONSISTENT_APPID = 24,
5181 };
5182
5186 enum CLIENT_ROLE_CHANGE_FAILED_REASON {
5193 CLIENT_ROLE_CHANGE_FAILED_TOO_MANY_BROADCASTERS = 1,
5198 CLIENT_ROLE_CHANGE_FAILED_NOT_AUTHORIZED = 2,
5204 CLIENT_ROLE_CHANGE_FAILED_REQUEST_TIME_OUT __deprecated = 3,
5210 CLIENT_ROLE_CHANGE_FAILED_CONNECTION_FAILED __deprecated = 4,
5211 };
5212
5216 enum NETWORK_TYPE {
5220 NETWORK_TYPE_UNKNOWN = -1,
5224 NETWORK_TYPE_DISCONNECTED = 0,
5228 NETWORK_TYPE_LAN = 1,
5232 NETWORK_TYPE_WIFI = 2,
5236 NETWORK_TYPE_MOBILE_2G = 3,
5240 NETWORK_TYPE_MOBILE_3G = 4,
5244 NETWORK_TYPE_MOBILE_4G = 5,
5248 NETWORK_TYPE_MOBILE_5G = 6,
5249 };
5250
5254 enum VIDEO_VIEW_SETUP_MODE {
5258 VIDEO_VIEW_SETUP_REPLACE = 0,
5262 VIDEO_VIEW_SETUP_ADD = 1,
5269 VIDEO_VIEW_SETUP_REMOVE = 2,
5270 };
5271
5275 struct VideoCanvas {
5279 uid_t uid;
5280
5284 uid_t subviewUid;
5290 view_t view;
5295 uint32_t backgroundColor;
5299 media::base::RENDER_MODE_TYPE renderMode;
5307 VIDEO_MIRROR_MODE_TYPE mirrorMode;
5311 VIDEO_VIEW_SETUP_MODE setupMode;
5315 VIDEO_SOURCE_TYPE sourceType;
5319 int mediaPlayerId;
5325 Rectangle cropArea;
5338 bool enableAlphaMask;
5342 media::base::VIDEO_MODULE_POSITION position;
5343
5344 VideoCanvas()
5345 : uid(0),
5346 subviewUid(0),
5347 view(NULL),
5348 backgroundColor(0x00000000),
5349 renderMode(media::base::RENDER_MODE_HIDDEN),
5350 mirrorMode(VIDEO_MIRROR_MODE_AUTO),
5351 setupMode(VIDEO_VIEW_SETUP_REPLACE),
5352 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
5353 mediaPlayerId(-ERR_NOT_READY),
5354 cropArea(0, 0, 0, 0),
5355 enableAlphaMask(false),
5356 position(media::base::POSITION_POST_CAPTURER) {}
5357
5358 VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt)
5359 : uid(0),
5360 subviewUid(0),
5361 view(v),
5362 backgroundColor(0x00000000),
5363 renderMode(m),
5364 mirrorMode(mt),
5365 setupMode(VIDEO_VIEW_SETUP_REPLACE),
5366 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
5367 mediaPlayerId(-ERR_NOT_READY),
5368 cropArea(0, 0, 0, 0),
5369 enableAlphaMask(false),
5370 position(media::base::POSITION_POST_CAPTURER) {}
5371
5372 VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u)
5373 : uid(u),
5374 subviewUid(0),
5375 view(v),
5376 backgroundColor(0x00000000),
5377 renderMode(m),
5378 mirrorMode(mt),
5379 setupMode(VIDEO_VIEW_SETUP_REPLACE),
5380 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
5381 mediaPlayerId(-ERR_NOT_READY),
5382 cropArea(0, 0, 0, 0),
5383 enableAlphaMask(false),
5384 position(media::base::POSITION_POST_CAPTURER) {}
5385
5386 VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u,
5387 uid_t subu)
5388 : uid(u),
5389 subviewUid(subu),
5390 view(v),
5391 backgroundColor(0x00000000),
5392 renderMode(m),
5393 mirrorMode(mt),
5394 setupMode(VIDEO_VIEW_SETUP_REPLACE),
5395 sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
5396 mediaPlayerId(-ERR_NOT_READY),
5397 cropArea(0, 0, 0, 0),
5398 enableAlphaMask(false),
5399 position(media::base::POSITION_POST_CAPTURER) {}
5400 };
5401
5405 struct BeautyOptions {
5409 enum LIGHTENING_CONTRAST_LEVEL {
5413 LIGHTENING_CONTRAST_LOW = 0,
5417 LIGHTENING_CONTRAST_NORMAL = 1,
5421 LIGHTENING_CONTRAST_HIGH = 2,
5422 };
5423
5428 LIGHTENING_CONTRAST_LEVEL lighteningContrastLevel;
5429
5434 float lighteningLevel;
5435
5440 float smoothnessLevel;
5441
5446 float rednessLevel;
5447
5452 float sharpnessLevel;
5453
5454 BeautyOptions(LIGHTENING_CONTRAST_LEVEL contrastLevel, float lightening, float smoothness,
5455 float redness, float sharpness)
5456 : lighteningContrastLevel(contrastLevel),
5457 lighteningLevel(lightening),
5458 smoothnessLevel(smoothness),
5459 rednessLevel(redness),
5460 sharpnessLevel(sharpness) {}
5461
5462 BeautyOptions()
5463 : lighteningContrastLevel(LIGHTENING_CONTRAST_NORMAL),
5464 lighteningLevel(0),
5465 smoothnessLevel(0),
5466 rednessLevel(0),
5467 sharpnessLevel(0) {}
5468 };
5469
5475 struct FaceShapeAreaOptions {
5481 enum FACE_SHAPE_AREA {
5485 FACE_SHAPE_AREA_NONE = -1,
5490 FACE_SHAPE_AREA_HEADSCALE = 100,
5495 FACE_SHAPE_AREA_FOREHEAD = 101,
5500 FACE_SHAPE_AREA_FACECONTOUR = 102,
5506 FACE_SHAPE_AREA_FACELENGTH = 103,
5511 FACE_SHAPE_AREA_FACEWIDTH = 104,
5517 FACE_SHAPE_AREA_CHEEKBONE = 105,
5522 FACE_SHAPE_AREA_CHEEK = 106,
5528 FACE_SHAPE_AREA_MANDIBLE = 107,
5534 FACE_SHAPE_AREA_CHIN = 108,
5539 FACE_SHAPE_AREA_EYESCALE = 200,
5546 FACE_SHAPE_AREA_EYEDISTANCE = 201,
5553 FACE_SHAPE_AREA_EYEPOSITION = 202,
5559 FACE_SHAPE_AREA_LOWEREYELID = 203,
5565 FACE_SHAPE_AREA_EYEPUPILS = 204,
5572 FACE_SHAPE_AREA_EYEINNERCORNER = 205,
5579 FACE_SHAPE_AREA_EYEOUTERCORNER = 206,
5584 FACE_SHAPE_AREA_NOSELENGTH = 300,
5590 FACE_SHAPE_AREA_NOSEWIDTH = 301,
5596 FACE_SHAPE_AREA_NOSEWING = 302,
5602 FACE_SHAPE_AREA_NOSEROOT = 303,
5608 FACE_SHAPE_AREA_NOSEBRIDGE = 304,
5614 FACE_SHAPE_AREA_NOSETIP = 305,
5621 FACE_SHAPE_AREA_NOSEGENERAL = 306,
5628 FACE_SHAPE_AREA_MOUTHSCALE = 400,
5634 FACE_SHAPE_AREA_MOUTHPOSITION = 401,
5640 FACE_SHAPE_AREA_MOUTHSMILE = 402,
5647 FACE_SHAPE_AREA_MOUTHLIP = 403,
5654 FACE_SHAPE_AREA_EYEBROWPOSITION = 500,
5660 FACE_SHAPE_AREA_EYEBROWTHICKNESS = 501,
5661 };
5662
5666 FACE_SHAPE_AREA shapeArea;
5667
5672 int shapeIntensity;
5673
5674 FaceShapeAreaOptions(FACE_SHAPE_AREA shapeArea, int areaIntensity) : shapeArea(shapeArea), shapeIntensity(areaIntensity) {}
5675
5676 FaceShapeAreaOptions() : shapeArea(FACE_SHAPE_AREA_NONE), shapeIntensity(0) {}
5677 };
5678
5684 struct FaceShapeBeautyOptions {
5690 enum FACE_SHAPE_BEAUTY_STYLE {
5694 FACE_SHAPE_BEAUTY_STYLE_FEMALE = 0,
5698 FACE_SHAPE_BEAUTY_STYLE_MALE = 1,
5703 FACE_SHAPE_BEAUTY_STYLE_NATURAL = 2,
5704 };
5705
5709 FACE_SHAPE_BEAUTY_STYLE shapeStyle;
5710
5716 int styleIntensity;
5717
5718 FaceShapeBeautyOptions(FACE_SHAPE_BEAUTY_STYLE shapeStyle, int styleIntensity) : shapeStyle(shapeStyle), styleIntensity(styleIntensity) {}
5719
5720 FaceShapeBeautyOptions() : shapeStyle(FACE_SHAPE_BEAUTY_STYLE_FEMALE), styleIntensity(50) {}
5721 };
5722
5728 struct FilterEffectOptions {
5746 const char * path;
5747
5752 float strength;
5753
5754 FilterEffectOptions(const char * lut3dPath, float filterStrength) : path(lut3dPath), strength(filterStrength) {}
5755
5756 FilterEffectOptions() : path(OPTIONAL_NULLPTR), strength(0.5) {}
5757 };
5758
5762 struct LowlightEnhanceOptions {
5766 enum LOW_LIGHT_ENHANCE_MODE {
5772 LOW_LIGHT_ENHANCE_AUTO = 0,
5776 LOW_LIGHT_ENHANCE_MANUAL = 1,
5777 };
5781 enum LOW_LIGHT_ENHANCE_LEVEL {
5787 LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY = 0,
5792 LOW_LIGHT_ENHANCE_LEVEL_FAST = 1,
5793 };
5794
5798 LOW_LIGHT_ENHANCE_MODE mode;
5799
5803 LOW_LIGHT_ENHANCE_LEVEL level;
5804
5805 LowlightEnhanceOptions(LOW_LIGHT_ENHANCE_MODE lowlightMode, LOW_LIGHT_ENHANCE_LEVEL lowlightLevel)
5806 : mode(lowlightMode), level(lowlightLevel) {}
5807
5808 LowlightEnhanceOptions()
5809 : mode(LOW_LIGHT_ENHANCE_AUTO), level(LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY) {}
5810 };
5816 struct VideoDenoiserOptions {
5820 enum VIDEO_DENOISER_MODE {
5825 VIDEO_DENOISER_AUTO = 0,
5829 VIDEO_DENOISER_MANUAL = 1,
5830 };
5834 enum VIDEO_DENOISER_LEVEL {
5840 VIDEO_DENOISER_LEVEL_HIGH_QUALITY = 0,
5848 VIDEO_DENOISER_LEVEL_FAST = 1,
5849 };
5853 VIDEO_DENOISER_MODE mode;
5854
5858 VIDEO_DENOISER_LEVEL level;
5859
5860 VideoDenoiserOptions(VIDEO_DENOISER_MODE denoiserMode, VIDEO_DENOISER_LEVEL denoiserLevel)
5861 : mode(denoiserMode), level(denoiserLevel) {}
5862
5863 VideoDenoiserOptions() : mode(VIDEO_DENOISER_AUTO), level(VIDEO_DENOISER_LEVEL_HIGH_QUALITY) {}
5864 };
5865
5871 struct ColorEnhanceOptions {
5877 float strengthLevel;
5878
5890 float skinProtectLevel;
5891
5892 ColorEnhanceOptions(float stength, float skinProtect)
5893 : strengthLevel(stength), skinProtectLevel(skinProtect) {}
5894
5895 ColorEnhanceOptions() : strengthLevel(0), skinProtectLevel(1) {}
5896 };
5897
5901 struct VirtualBackgroundSource {
5905 enum BACKGROUND_SOURCE_TYPE {
5911 BACKGROUND_NONE = 0,
5915 BACKGROUND_COLOR = 1,
5919 BACKGROUND_IMG = 2,
5923 BACKGROUND_BLUR = 3,
5927 BACKGROUND_VIDEO = 4,
5928 };
5929
5933 enum BACKGROUND_BLUR_DEGREE {
5938 BLUR_DEGREE_LOW = 1,
5943 BLUR_DEGREE_MEDIUM = 2,
5948 BLUR_DEGREE_HIGH = 3,
5949 };
5950
5954 BACKGROUND_SOURCE_TYPE background_source_type;
5955
5968 unsigned int color;
5969
5977 const char* source;
5978
5984 BACKGROUND_BLUR_DEGREE blur_degree;
5985
5986 VirtualBackgroundSource()
5987 : background_source_type(BACKGROUND_COLOR),
5988 color(0xffffff),
5989 source(OPTIONAL_NULLPTR),
5990 blur_degree(BLUR_DEGREE_HIGH) {}
5991 };
5992
5996 struct SegmentationProperty {
6000 enum SEG_MODEL_TYPE {
6004 SEG_MODEL_AI = 1,
6008 SEG_MODEL_GREEN = 2
6009 };
6010
6014 enum SCREEN_COLOR_TYPE {
6018 SCREEN_COLOR_AUTO = 0,
6022 SCREEN_COLOR_GREEN = 1,
6026 SCREEN_COLOR_BLUE = 2
6027 };
6028
6032 SEG_MODEL_TYPE modelType;
6033
6042 float greenCapacity;
6043
6047 SCREEN_COLOR_TYPE screenColorType;
6048
6049 SegmentationProperty() : modelType(SEG_MODEL_AI), greenCapacity(0.5), screenColorType(SCREEN_COLOR_AUTO) {}
6050 };
6051
6055 enum AUDIO_TRACK_TYPE {
6059 AUDIO_TRACK_INVALID = -1,
6065 AUDIO_TRACK_MIXABLE = 0,
6075 AUDIO_TRACK_DIRECT = 1,
6076 };
6077
6081 struct AudioTrackConfig {
6087 bool enableLocalPlayback;
6095 bool enableAudioProcessing;
6096
6097 AudioTrackConfig() : enableLocalPlayback(true),enableAudioProcessing(false) {}
6098 };
6099
6121 enum VOICE_BEAUTIFIER_PRESET {
6125 VOICE_BEAUTIFIER_OFF = 0x00000000,
6131 CHAT_BEAUTIFIER_MAGNETIC = 0x01010100,
6137 CHAT_BEAUTIFIER_FRESH = 0x01010200,
6143 CHAT_BEAUTIFIER_VITALITY = 0x01010300,
6153 SINGING_BEAUTIFIER = 0x01020100,
6157 TIMBRE_TRANSFORMATION_VIGOROUS = 0x01030100,
6161 TIMBRE_TRANSFORMATION_DEEP = 0x01030200,
6165 TIMBRE_TRANSFORMATION_MELLOW = 0x01030300,
6169 TIMBRE_TRANSFORMATION_FALSETTO = 0x01030400,
6173 TIMBRE_TRANSFORMATION_FULL = 0x01030500,
6177 TIMBRE_TRANSFORMATION_CLEAR = 0x01030600,
6181 TIMBRE_TRANSFORMATION_RESOUNDING = 0x01030700,
6185 TIMBRE_TRANSFORMATION_RINGING = 0x01030800,
6196 ULTRA_HIGH_QUALITY_VOICE = 0x01040100
6197 };
6198
6210 enum AUDIO_EFFECT_PRESET {
6214 AUDIO_EFFECT_OFF = 0x00000000,
6218 ROOM_ACOUSTICS_KTV = 0x02010100,
6222 ROOM_ACOUSTICS_VOCAL_CONCERT = 0x02010200,
6226 ROOM_ACOUSTICS_STUDIO = 0x02010300,
6230 ROOM_ACOUSTICS_PHONOGRAPH = 0x02010400,
6234 ROOM_ACOUSTICS_VIRTUAL_STEREO = 0x02010500,
6238 ROOM_ACOUSTICS_SPACIAL = 0x02010600,
6242 ROOM_ACOUSTICS_ETHEREAL = 0x02010700,
6250 ROOM_ACOUSTICS_3D_VOICE = 0x02010800,
6257 ROOM_ACOUSTICS_VIRTUAL_SURROUND_SOUND = 0x02010900,
6262 ROOM_ACOUSTICS_CHORUS = 0x02010D00,
6268 VOICE_CHANGER_EFFECT_UNCLE = 0x02020100,
6274 VOICE_CHANGER_EFFECT_OLDMAN = 0x02020200,
6280 VOICE_CHANGER_EFFECT_BOY = 0x02020300,
6286 VOICE_CHANGER_EFFECT_SISTER = 0x02020400,
6292 VOICE_CHANGER_EFFECT_GIRL = 0x02020500,
6296 VOICE_CHANGER_EFFECT_PIGKING = 0x02020600,
6300 VOICE_CHANGER_EFFECT_HULK = 0x02020700,
6304 STYLE_TRANSFORMATION_RNB = 0x02030100,
6308 STYLE_TRANSFORMATION_POPULAR = 0x02030200,
6314 PITCH_CORRECTION = 0x02040100,
6315
6319 };
6320
6324 enum VOICE_CONVERSION_PRESET {
6328 VOICE_CONVERSION_OFF = 0x00000000,
6333 VOICE_CHANGER_NEUTRAL = 0x03010100,
6338 VOICE_CHANGER_SWEET = 0x03010200,
6343 VOICE_CHANGER_SOLID = 0x03010300,
6348 VOICE_CHANGER_BASS = 0x03010400,
6351 VOICE_CHANGER_CARTOON = 0x03010500,
6354 VOICE_CHANGER_CHILDLIKE = 0x03010600,
6357 VOICE_CHANGER_PHONE_OPERATOR = 0x03010700,
6360 VOICE_CHANGER_MONSTER = 0x03010800,
6363 VOICE_CHANGER_TRANSFORMERS = 0x03010900,
6366 VOICE_CHANGER_GROOT = 0x03010A00,
6369 VOICE_CHANGER_DARTH_VADER = 0x03010B00,
6372 VOICE_CHANGER_IRON_LADY = 0x03010C00,
6375 VOICE_CHANGER_SHIN_CHAN = 0x03010D00,
6378 VOICE_CHANGER_GIRLISH_MAN = 0x03010E00,
6381 VOICE_CHANGER_CHIPMUNK = 0x03010F00,
6382
6383 };
6384
6388 enum HEADPHONE_EQUALIZER_PRESET {
6392 HEADPHONE_EQUALIZER_OFF = 0x00000000,
6396 HEADPHONE_EQUALIZER_OVEREAR = 0x04000001,
6400 HEADPHONE_EQUALIZER_INEAR = 0x04000002
6401 };
6402
6406 enum VOICE_AI_TUNER_TYPE {
6410 VOICE_AI_TUNER_MATURE_MALE,
6414 VOICE_AI_TUNER_FRESH_MALE,
6418 VOICE_AI_TUNER_ELEGANT_FEMALE,
6422 VOICE_AI_TUNER_SWEET_FEMALE,
6426 VOICE_AI_TUNER_WARM_MALE_SINGING,
6430 VOICE_AI_TUNER_GENTLE_FEMALE_SINGING,
6434 VOICE_AI_TUNER_HUSKY_MALE_SINGING,
6438 VOICE_AI_TUNER_WARM_ELEGANT_FEMALE_SINGING,
6442 VOICE_AI_TUNER_POWERFUL_MALE_SINGING,
6446 VOICE_AI_TUNER_DREAMY_FEMALE_SINGING,
6447 };
6448
6456 struct ScreenAudioParameters {
6460 int sampleRate;
6464 int channels;
6468 int captureSignalVolume;
6469
6470 #if defined(__APPLE__) && !TARGET_OS_IOS
6471
6474 bool excludeCurrentProcessAudio = true;
6475 ScreenAudioParameters(): sampleRate(48000), channels(2), captureSignalVolume(100) {}
6476 #else
6477 ScreenAudioParameters(): sampleRate(16000), channels(2), captureSignalVolume(100) {}
6478 #endif
6479 };
6480
6484 struct ScreenCaptureParameters {
6485
6495 bool captureAudio;
6501 ScreenAudioParameters audioParams;
6502
6526 VideoDimensions dimensions;
6532 int frameRate;
6538 int bitrate;
6546 bool captureMouseCursor;
6555 bool windowFocus;
6562 view_t* excludeWindowList;
6568 int excludeWindowCount;
6569
6575 int highLightWidth;
6581 unsigned int highLightColor;
6589 bool enableHighLight;
6590
6591 ScreenCaptureParameters()
6592 : captureAudio(false),
6593 dimensions(1920, 1080),
6594 frameRate(5),
6595 bitrate(STANDARD_BITRATE),
6596 captureMouseCursor(true),
6597 windowFocus(false),
6598 excludeWindowList(OPTIONAL_NULLPTR),
6599 excludeWindowCount(0),
6600 highLightWidth(0),
6601 highLightColor(0),
6602 enableHighLight(false) {}
6603 ScreenCaptureParameters(const VideoDimensions& d, int f, int b)
6604 : captureAudio(false),dimensions(d),
6605 frameRate(f),
6606 bitrate(b),
6607 captureMouseCursor(true),
6608 windowFocus(false),
6609 excludeWindowList(OPTIONAL_NULLPTR),
6610 excludeWindowCount(0),
6611 highLightWidth(0),
6612 highLightColor(0),
6613 enableHighLight(false) {}
6614 ScreenCaptureParameters(int width, int height, int f, int b)
6615 : captureAudio(false),
6616 dimensions(width, height),
6617 frameRate(f),
6618 bitrate(b),
6619 captureMouseCursor(true),
6620 windowFocus(false),
6621 excludeWindowList(OPTIONAL_NULLPTR),
6622 excludeWindowCount(0),
6623 highLightWidth(0),
6624 highLightColor(0),
6625 enableHighLight(false) {}
6626 ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs)
6627 : captureAudio(false),
6628 dimensions(width, height),
6629 frameRate(f),
6630 bitrate(b),
6631 captureMouseCursor(cur),
6632 windowFocus(fcs),
6633 excludeWindowList(OPTIONAL_NULLPTR),
6634 excludeWindowCount(0),
6635 highLightWidth(0),
6636 highLightColor(0),
6637 enableHighLight(false) {}
6638 ScreenCaptureParameters(int width, int height, int f, int b, view_t* ex, int cnt)
6639 : captureAudio(false),
6640 dimensions(width, height),
6641 frameRate(f),
6642 bitrate(b),
6643 captureMouseCursor(true),
6644 windowFocus(false),
6645 excludeWindowList(ex),
6646 excludeWindowCount(cnt),
6647 highLightWidth(0),
6648 highLightColor(0),
6649 enableHighLight(false) {}
6650 ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs, view_t* ex,
6651 int cnt)
6652 : captureAudio(false),
6653 dimensions(width, height),
6654 frameRate(f),
6655 bitrate(b),
6656 captureMouseCursor(cur),
6657 windowFocus(fcs),
6658 excludeWindowList(ex),
6659 excludeWindowCount(cnt),
6660 highLightWidth(0),
6661 highLightColor(0),
6662 enableHighLight(false) {}
6663 };
6664
6668 enum AUDIO_RECORDING_QUALITY_TYPE {
6673 AUDIO_RECORDING_QUALITY_LOW = 0,
6678 AUDIO_RECORDING_QUALITY_MEDIUM = 1,
6683 AUDIO_RECORDING_QUALITY_HIGH = 2,
6688 AUDIO_RECORDING_QUALITY_ULTRA_HIGH = 3,
6689 };
6690
6694 enum AUDIO_FILE_RECORDING_TYPE {
6698 AUDIO_FILE_RECORDING_MIC = 1,
6702 AUDIO_FILE_RECORDING_PLAYBACK = 2,
6706 AUDIO_FILE_RECORDING_MIXED = 3,
6707 };
6708
6712 enum AUDIO_ENCODED_FRAME_OBSERVER_POSITION {
6716 AUDIO_ENCODED_FRAME_OBSERVER_POSITION_RECORD = 1,
6720 AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK = 2,
6724 AUDIO_ENCODED_FRAME_OBSERVER_POSITION_MIXED = 3,
6725 };
6726
6730 struct AudioRecordingConfiguration {
6736 const char* filePath;
6742 bool encode;
6753 int sampleRate;
6757 AUDIO_FILE_RECORDING_TYPE fileRecordingType;
6762 AUDIO_RECORDING_QUALITY_TYPE quality;
6763
6777 int recordingChannel;
6778
6779 AudioRecordingConfiguration()
6780 : filePath(OPTIONAL_NULLPTR),
6781 encode(false),
6782 sampleRate(32000),
6783 fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
6784 quality(AUDIO_RECORDING_QUALITY_LOW),
6785 recordingChannel(1) {}
6786
6787 AudioRecordingConfiguration(const char* file_path, int sample_rate,
6788 AUDIO_RECORDING_QUALITY_TYPE quality_type, int channel)
6789 : filePath(file_path),
6790 encode(false),
6791 sampleRate(sample_rate),
6792 fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
6793 quality(quality_type),
6794 recordingChannel(channel) {}
6795
6796 AudioRecordingConfiguration(const char* file_path, bool enc, int sample_rate,
6797 AUDIO_FILE_RECORDING_TYPE type,
6798 AUDIO_RECORDING_QUALITY_TYPE quality_type, int channel)
6799 : filePath(file_path),
6800 encode(enc),
6801 sampleRate(sample_rate),
6802 fileRecordingType(type),
6803 quality(quality_type),
6804 recordingChannel(channel) {}
6805
6806 AudioRecordingConfiguration(const AudioRecordingConfiguration& rhs)
6807 : filePath(rhs.filePath),
6808 encode(rhs.encode),
6809 sampleRate(rhs.sampleRate),
6810 fileRecordingType(rhs.fileRecordingType),
6811 quality(rhs.quality),
6812 recordingChannel(rhs.recordingChannel) {}
6813 };
6814
6818 struct AudioEncodedFrameObserverConfig {
6822 AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType;
6826 AUDIO_ENCODING_TYPE encodingType;
6827
6828 AudioEncodedFrameObserverConfig()
6829 : postionType(AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK),
6830 encodingType(AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM) {}
6831 };
6835 class IAudioEncodedFrameObserver {
6836 public:
6850 virtual void onRecordAudioEncodedFrame(const uint8_t* frameBuffer, int length,
6851 const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
6852
6866 virtual void onPlaybackAudioEncodedFrame(const uint8_t* frameBuffer, int length,
6867 const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
6868
6882 virtual void onMixedAudioEncodedFrame(const uint8_t* frameBuffer, int length,
6883 const EncodedAudioFrameInfo& audioEncodedFrameInfo) = 0;
6884
6885 virtual ~IAudioEncodedFrameObserver() {}
6886 };
6887
6892 enum AREA_CODE {
6896 AREA_CODE_CN = 0x00000001,
6900 AREA_CODE_NA = 0x00000002,
6904 AREA_CODE_EU = 0x00000004,
6908 AREA_CODE_AS = 0x00000008,
6912 AREA_CODE_JP = 0x00000010,
6916 AREA_CODE_IN = 0x00000020,
6920 AREA_CODE_GLOB = (0xFFFFFFFF)
6921 };
6922
6927 enum AREA_CODE_EX {
6931 AREA_CODE_OC = 0x00000040,
6935 AREA_CODE_SA = 0x00000080,
6939 AREA_CODE_AF = 0x00000100,
6943 AREA_CODE_KR = 0x00000200,
6947 AREA_CODE_HKMC = 0x00000400,
6951 AREA_CODE_US = 0x00000800,
6955 AREA_CODE_RU = 0x00001000,
6959 AREA_CODE_OVS = 0xFFFFFFFE
6960 };
6961
6965 enum CHANNEL_MEDIA_RELAY_ERROR {
6969 RELAY_OK = 0,
6973 RELAY_ERROR_SERVER_ERROR_RESPONSE = 1,
6982 RELAY_ERROR_SERVER_NO_RESPONSE = 2,
6986 RELAY_ERROR_NO_RESOURCE_AVAILABLE = 3,
6990 RELAY_ERROR_FAILED_JOIN_SRC = 4,
6994 RELAY_ERROR_FAILED_JOIN_DEST = 5,
6998 RELAY_ERROR_FAILED_PACKET_RECEIVED_FROM_SRC = 6,
7002 RELAY_ERROR_FAILED_PACKET_SENT_TO_DEST = 7,
7007 RELAY_ERROR_SERVER_CONNECTION_LOST = 8,
7011 RELAY_ERROR_INTERNAL_ERROR = 9,
7015 RELAY_ERROR_SRC_TOKEN_EXPIRED = 10,
7019 RELAY_ERROR_DEST_TOKEN_EXPIRED = 11,
7020 };
7021
7025 enum CHANNEL_MEDIA_RELAY_STATE {
7030 RELAY_STATE_IDLE = 0,
7034 RELAY_STATE_CONNECTING = 1,
7038 RELAY_STATE_RUNNING = 2,
7042 RELAY_STATE_FAILURE = 3,
7043 };
7044
7048 struct ChannelMediaInfo {
7052 uid_t uid;
7056 const char* channelName;
7060 const char* token;
7061
7062 ChannelMediaInfo() : uid(0), channelName(NULL), token(NULL) {}
7063 ChannelMediaInfo(const char* c, const char* t, uid_t u) : uid(u), channelName(c), token(t) {}
7064 };
7065
7069 struct ChannelMediaRelayConfiguration {
7083 ChannelMediaInfo* srcInfo;
7100 ChannelMediaInfo* destInfos;
7106 int destCount;
7107
7108 ChannelMediaRelayConfiguration()
7109 : srcInfo(OPTIONAL_NULLPTR), destInfos(OPTIONAL_NULLPTR), destCount(0) {}
7110 };
7111
7115 struct UplinkNetworkInfo {
7119 int video_encoder_target_bitrate_bps;
7120
7121 UplinkNetworkInfo() : video_encoder_target_bitrate_bps(0) {}
7122
7123 bool operator==(const UplinkNetworkInfo& rhs) const {
7124 return (video_encoder_target_bitrate_bps == rhs.video_encoder_target_bitrate_bps);
7125 }
7126 };
7127
7128 struct DownlinkNetworkInfo {
7129 struct PeerDownlinkInfo {
7133 const char* userId;
7137 VIDEO_STREAM_TYPE stream_type;
7141 REMOTE_VIDEO_DOWNSCALE_LEVEL current_downscale_level;
7145 int expected_bitrate_bps;
7146
7147 PeerDownlinkInfo()
7148 : userId(OPTIONAL_NULLPTR),
7149 stream_type(VIDEO_STREAM_HIGH),
7150 current_downscale_level(REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE),
7151 expected_bitrate_bps(-1) {}
7152
7153 PeerDownlinkInfo(const PeerDownlinkInfo& rhs)
7154 : stream_type(rhs.stream_type),
7155 current_downscale_level(rhs.current_downscale_level),
7156 expected_bitrate_bps(rhs.expected_bitrate_bps) {
7157 if (rhs.userId != OPTIONAL_NULLPTR) {
7158 const size_t len = std::strlen(rhs.userId);
7159 char* buf = new char[len + 1];
7160 std::memcpy(buf, rhs.userId, len);
7161 buf[len] = '\0';
7162 userId = buf;
7163 }
7164 }
7165
7166 PeerDownlinkInfo& operator=(const PeerDownlinkInfo& rhs) {
7167 if (this == &rhs) return *this;
7168 userId = OPTIONAL_NULLPTR;
7169 stream_type = rhs.stream_type;
7170 current_downscale_level = rhs.current_downscale_level;
7171 expected_bitrate_bps = rhs.expected_bitrate_bps;
7172 if (rhs.userId != OPTIONAL_NULLPTR) {
7173 const size_t len = std::strlen(rhs.userId);
7174 char* buf = new char[len + 1];
7175 std::memcpy(buf, rhs.userId, len);
7176 buf[len] = '\0';
7177 userId = buf;
7178 }
7179 return *this;
7180 }
7181
7182 ~PeerDownlinkInfo() { delete[] userId; }
7183 };
7184
7188 int lastmile_buffer_delay_time_ms;
7192 int bandwidth_estimation_bps;
7196 int total_downscale_level_count;
7200 PeerDownlinkInfo* peer_downlink_info;
7204 int total_received_video_count;
7205
7206 DownlinkNetworkInfo()
7207 : lastmile_buffer_delay_time_ms(-1),
7208 bandwidth_estimation_bps(-1),
7209 total_downscale_level_count(-1),
7210 peer_downlink_info(OPTIONAL_NULLPTR),
7211 total_received_video_count(-1) {}
7212
7213 DownlinkNetworkInfo(const DownlinkNetworkInfo& info)
7214 : lastmile_buffer_delay_time_ms(info.lastmile_buffer_delay_time_ms),
7215 bandwidth_estimation_bps(info.bandwidth_estimation_bps),
7216 total_downscale_level_count(info.total_downscale_level_count),
7217 peer_downlink_info(OPTIONAL_NULLPTR),
7218 total_received_video_count(info.total_received_video_count) {
7219 if (total_received_video_count <= 0) return;
7220 peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
7221 for (int i = 0; i < total_received_video_count; ++i)
7222 peer_downlink_info[i] = info.peer_downlink_info[i];
7223 }
7224
7225 DownlinkNetworkInfo& operator=(const DownlinkNetworkInfo& rhs) {
7226 if (this == &rhs) return *this;
7227 lastmile_buffer_delay_time_ms = rhs.lastmile_buffer_delay_time_ms;
7228 bandwidth_estimation_bps = rhs.bandwidth_estimation_bps;
7229 total_downscale_level_count = rhs.total_downscale_level_count;
7230 peer_downlink_info = OPTIONAL_NULLPTR;
7231 total_received_video_count = rhs.total_received_video_count;
7232 if (total_received_video_count > 0) {
7233 peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
7234 for (int i = 0; i < total_received_video_count; ++i)
7235 peer_downlink_info[i] = rhs.peer_downlink_info[i];
7236 }
7237 return *this;
7238 }
7239
7240 ~DownlinkNetworkInfo() { delete[] peer_downlink_info; }
7241 };
7242
7251 enum ENCRYPTION_MODE {
7255 AES_128_XTS = 1,
7259 AES_128_ECB = 2,
7263 AES_256_XTS = 3,
7267 SM4_128_ECB = 4,
7271 AES_128_GCM = 5,
7275 AES_256_GCM = 6,
7280 AES_128_GCM2 = 7,
7285 AES_256_GCM2 = 8,
7289 MODE_END,
7290 };
7291
7295 struct EncryptionConfig {
7300 ENCRYPTION_MODE encryptionMode;
7306 const char* encryptionKey;
7313 uint8_t encryptionKdfSalt[32];
7314
7320 bool datastreamEncryptionEnabled;
7321
7322 EncryptionConfig()
7323 : encryptionMode(AES_128_GCM2),
7324 encryptionKey(OPTIONAL_NULLPTR),
7325 datastreamEncryptionEnabled(false) {
7326 memset(encryptionKdfSalt, 0, sizeof(encryptionKdfSalt));
7327 }
7328
7330 const char* getEncryptionString() const {
7331 switch (encryptionMode) {
7332 case AES_128_XTS:
7333 return "aes-128-xts";
7334 case AES_128_ECB:
7335 return "aes-128-ecb";
7336 case AES_256_XTS:
7337 return "aes-256-xts";
7338 case SM4_128_ECB:
7339 return "sm4-128-ecb";
7340 case AES_128_GCM:
7341 return "aes-128-gcm";
7342 case AES_256_GCM:
7343 return "aes-256-gcm";
7344 case AES_128_GCM2:
7345 return "aes-128-gcm-2";
7346 case AES_256_GCM2:
7347 return "aes-256-gcm-2";
7348 default:
7349 return "aes-128-gcm-2";
7350 }
7351 return "aes-128-gcm-2";
7352 }
7354 };
7355
7359 enum ENCRYPTION_ERROR_TYPE {
7363 ENCRYPTION_ERROR_INTERNAL_FAILURE = 0,
7368 ENCRYPTION_ERROR_DECRYPTION_FAILURE = 1,
7372 ENCRYPTION_ERROR_ENCRYPTION_FAILURE = 2,
7377 ENCRYPTION_ERROR_DATASTREAM_DECRYPTION_FAILURE = 3,
7381 ENCRYPTION_ERROR_DATASTREAM_ENCRYPTION_FAILURE = 4,
7382 };
7383
7384 enum UPLOAD_ERROR_REASON {
7385 UPLOAD_SUCCESS = 0,
7386 UPLOAD_NET_ERROR = 1,
7387 UPLOAD_SERVER_ERROR = 2,
7388 };
7389
7395 enum RENEW_TOKEN_ERROR_CODE {
7399 RENEW_TOKEN_SUCCESS = 0,
7404 RENEW_TOKEN_FAILURE = 1,
7409 RENEW_TOKEN_TOKEN_EXPIRED = 2,
7418 RENEW_TOKEN_INVALID_TOKEN = 3,
7424 RENEW_TOKEN_INVALID_CHANNEL_NAME = 4,
7429 RENEW_TOKEN_INCONSISTENT_APPID = 5,
7433 RENEW_TOKEN_CANCELED_BY_NEW_REQUEST = 6,
7434 };
7435
7439 enum PERMISSION_TYPE {
7443 RECORD_AUDIO = 0,
7447 CAMERA = 1,
7448
7452 SCREEN_CAPTURE = 2,
7453 };
7454
7458 enum STREAM_SUBSCRIBE_STATE {
7462 SUB_STATE_IDLE = 0,
7478 SUB_STATE_NO_SUBSCRIBED = 1,
7482 SUB_STATE_SUBSCRIBING = 2,
7486 SUB_STATE_SUBSCRIBED = 3
7487 };
7488
7492 enum STREAM_PUBLISH_STATE {
7496 PUB_STATE_IDLE = 0,
7507 PUB_STATE_NO_PUBLISHED = 1,
7511 PUB_STATE_PUBLISHING = 2,
7515 PUB_STATE_PUBLISHED = 3
7516 };
7517
7521 struct EchoTestConfiguration {
7526 view_t view;
7533 bool enableAudio;
7540 bool enableVideo;
7548 const char* token;
7554 const char* channelId;
7562 int intervalInSeconds;
7563
7564 EchoTestConfiguration(view_t v, bool ea, bool ev, const char* t, const char* c, const int is)
7565 : view(v), enableAudio(ea), enableVideo(ev), token(t), channelId(c), intervalInSeconds(is) {}
7566
7567 EchoTestConfiguration()
7568 : view(OPTIONAL_NULLPTR),
7569 enableAudio(true),
7570 enableVideo(true),
7571 token(OPTIONAL_NULLPTR),
7572 channelId(OPTIONAL_NULLPTR),
7573 intervalInSeconds(2) {}
7574 };
7575
7579 struct UserInfo {
7583 uid_t uid;
7587 char userAccount[MAX_USER_ACCOUNT_LENGTH];
7588
7589 UserInfo() : uid(0) { userAccount[0] = '\0'; }
7590 };
7591
7595 enum EAR_MONITORING_FILTER_TYPE {
7599 EAR_MONITORING_FILTER_NONE = (1 << 0),
7604 EAR_MONITORING_FILTER_BUILT_IN_AUDIO_FILTERS = (1 << 1),
7608 EAR_MONITORING_FILTER_NOISE_SUPPRESSION = (1 << 2),
7614 EAR_MONITORING_FILTER_REUSE_POST_PROCESSING_FILTER = (1 << 15),
7615 };
7616
7620 enum THREAD_PRIORITY_TYPE {
7624 LOWEST = 0,
7628 LOW = 1,
7632 NORMAL = 2,
7636 HIGH = 3,
7640 HIGHEST = 4,
7644 CRITICAL = 5,
7645 };
7646
7647 #if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS) || defined(__OHOS__)
7648
7652 struct ScreenVideoParameters {
7656 VideoDimensions dimensions;
7660 int frameRate = 15;
7664 int bitrate;
7668 VIDEO_CONTENT_HINT contentHint = VIDEO_CONTENT_HINT::CONTENT_HINT_MOTION;
7669
7670 ScreenVideoParameters() : dimensions(1280, 720) {}
7671 };
7672
7676 struct ScreenCaptureParameters2 {
7688 bool captureAudio = false;
7693 ScreenAudioParameters audioParams;
7701 bool captureVideo = true;
7706 ScreenVideoParameters videoParams;
7707 };
7708 #endif
7709
7713 enum MEDIA_TRACE_EVENT {
7717 MEDIA_TRACE_EVENT_VIDEO_RENDERED = 0,
7721 MEDIA_TRACE_EVENT_VIDEO_DECODED,
7722 };
7723
7727 struct VideoRenderingTracingInfo {
7733 int elapsedTime;
7742 int start2JoinChannel;
7749 int join2JoinSuccess;
7764 int joinSuccess2RemoteJoined;
7779 int remoteJoined2SetView;
7794 int remoteJoined2UnmuteVideo;
7809 int remoteJoined2PacketReceived;
7810 };
7811
7812 enum CONFIG_FETCH_TYPE {
7816 CONFIG_FETCH_TYPE_INITIALIZE = 1,
7820 CONFIG_FETCH_TYPE_JOIN_CHANNEL = 2,
7821 };
7822
7826 enum LOCAL_PROXY_MODE {
7831 ConnectivityFirst = 0,
7835 LocalOnly = 1,
7836 };
7837
7841 struct LogUploadServerInfo {
7845 const char* serverDomain;
7849 const char* serverPath;
7853 int serverPort;
7859 bool serverHttps;
7860
7861 LogUploadServerInfo() : serverDomain(NULL), serverPath(NULL), serverPort(0), serverHttps(true) {}
7862
7863 LogUploadServerInfo(const char* domain, const char* path, int port, bool https)
7864 : serverDomain(domain), serverPath(path), serverPort(port), serverHttps(https) {}
7865 };
7866
7870 struct AdvancedConfigInfo {
7875 LogUploadServerInfo logUploadServer;
7876 };
7877
7881 struct LocalAccessPointConfiguration {
7886 const char** ipList;
7891 int ipListSize;
7899 const char** domainList;
7904 int domainListSize;
7909 const char* verifyDomainName;
7913 LOCAL_PROXY_MODE mode;
7917 AdvancedConfigInfo advancedConfig;
7923 bool disableAut;
7924 LocalAccessPointConfiguration()
7925 : ipList(NULL),
7926 ipListSize(0),
7927 domainList(NULL),
7928 domainListSize(0),
7929 verifyDomainName(NULL),
7930 mode(ConnectivityFirst),
7931 disableAut(true) {}
7932 };
7933
7937 enum RecorderStreamType {
7941 RTC,
7945 PREVIEW,
7946 };
7947
7951 struct RecorderStreamInfo {
7955 const char* channelId;
7959 uid_t uid;
7963 RecorderStreamType type;
7964 RecorderStreamInfo() : channelId(NULL), uid(0), type(RTC) {}
7965 RecorderStreamInfo(const char* channelId, uid_t uid)
7966 : channelId(channelId), uid(uid), type(RTC) {}
7967 RecorderStreamInfo(const char* channelId, uid_t uid, RecorderStreamType type)
7968 : channelId(channelId), uid(uid), type(type) {}
7969 };
7970
7976 enum RdtStreamType {
7982 RDT_STREAM_CMD,
7988 RDT_STREAM_DATA,
7992 RDT_STREAM_COUNT,
7993 };
7994
8000 enum RdtState {
8004 RDT_STATE_CLOSED,
8008 RDT_STATE_OPENED,
8013 RDT_STATE_BLOCKED,
8018 RDT_STATE_PENDING,
8025 RDT_STATE_BROKEN,
8026 };
8027 } // namespace rtc
8028
8029 namespace base {
8030
8031 class IEngineBase {
8032 public:
8033 virtual int queryInterface(rtc::INTERFACE_ID_TYPE iid, void** inter) = 0;
8034 virtual ~IEngineBase() {}
8035 };
8036
8037 class AParameter : public agora::util::AutoPtr<IAgoraParameter> {
8038 public:
8039 AParameter(IEngineBase& engine) { initialize(&engine); }
8040 AParameter(IEngineBase* engine) { initialize(engine); }
8041 AParameter(IAgoraParameter* p) : agora::util::AutoPtr<IAgoraParameter>(p) {}
8042
8043 private:
8044 bool initialize(IEngineBase* engine) {
8045 IAgoraParameter* p = OPTIONAL_NULLPTR;
8046 if (engine && !engine->queryInterface(rtc::AGORA_IID_PARAMETER_ENGINE, (void**)&p)) reset(p);
8047 return p != OPTIONAL_NULLPTR;
8048 }
8049 };
8050
8051 class LicenseCallback {
8052 public:
8053 virtual ~LicenseCallback() {}
8054 virtual void onCertificateRequired() = 0;
8055 virtual void onLicenseRequest() = 0;
8056 virtual void onLicenseValidated() = 0;
8057 virtual void onLicenseError(int result) = 0;
8058 };
8059
8060 } // namespace base
8061
8065 struct SpatialAudioParams {
8075 Optional<double> speaker_azimuth;
8083 Optional<double> speaker_elevation;
8088 Optional<double> speaker_distance;
8095 Optional<int> speaker_orientation;
8101 Optional<bool> enable_blur;
8110 Optional<bool> enable_air_absorb;
8124 Optional<double> speaker_attenuation;
8141 Optional<bool> enable_doppler;
8142 };
8146 struct VideoLayout {
8150 const char* channelId;
8154 rtc::uid_t uid;
8158 user_id_t strUid;
8164 uint32_t x;
8170 uint32_t y;
8174 uint32_t width;
8178 uint32_t height;
8186 uint32_t videoState;
8187
8188 VideoLayout()
8189 : channelId(OPTIONAL_NULLPTR),
8190 uid(0),
8191 strUid(OPTIONAL_NULLPTR),
8192 x(0),
8193 y(0),
8194 width(0),
8195 height(0),
8196 videoState(0) {}
8197 };
8198 } // namespace agora
8199
8205 AGORA_API const char* AGORA_CALL getAgoraSdkVersion(int* build);
8206
8212 AGORA_API const char* AGORA_CALL getAgoraSdkErrorDescription(int err);
8213
8214 AGORA_API int AGORA_CALL setAgoraSdkExternalSymbolLoader(void* (*func)(const char* symname));
8215
8223 AGORA_API int AGORA_CALL createAgoraCredential(agora::util::AString& credential);
8224
8238 AGORA_API int AGORA_CALL getAgoraCertificateVerifyResult(const char* credential_buf,
8239 int credential_len,
8240 const char* certificate_buf,
8241 int certificate_len);
8242
8250 AGORA_API void setAgoraLicenseCallback(agora::base::LicenseCallback* callback);
8251
8259 AGORA_API agora::base::LicenseCallback* getAgoraLicenseCallback();
8260
8261 /*
8262 * Get monotonic time in ms which can be used by capture time,
8263 * typical scenario is as follows:
8264 *
8265 * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8266 * | // custom audio/video base capture time, e.g. the first audio/video capture time. | | int64_t
8267 * custom_capture_time_base; | | | |
8268 * int64_t agora_monotonic_time = getAgoraCurrentMonotonicTimeInMs(); |
8269 * | | | // offset is fixed once calculated in the begining. | | const int64_t offset =
8270 * agora_monotonic_time - custom_capture_time_base; | | | | //
8271 * realtime_custom_audio/video_capture_time is the origin capture time that customer provided.| | //
8272 * actual_audio/video_capture_time is the actual capture time transfered to sdk. | |
8273 * int64_t actual_audio_capture_time = realtime_custom_audio_capture_time + offset; |
8274 * | int64_t actual_video_capture_time = realtime_custom_video_capture_time + offset; |
8275 * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8276 *
8277 * @return
8278 * - >= 0: Success.
8279 * - < 0: Failure.
8280 */
8281 AGORA_API int64_t AGORA_CALL getAgoraCurrentMonotonicTimeInMs();
agora::rtc::LiveTranscoding::transcodingUsers
TranscodingUser * transcodingUsers
Definition: AgoraBase.h:4629
agora::rtc::LogUploadServerInfo::serverDomain
const char * serverDomain
Definition: AgoraBase.h:7845
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:5319
agora::rtc::RtcImage::width
int width
Definition: AgoraBase.h:4386
agora::rtc::TranscodingVideoStream::zOrder
int zOrder
Definition: AgoraBase.h:4777
agora::rtc::RtcStats::firstAudioPacketDuration
int firstAudioPacketDuration
Definition: AgoraBase.h:2853
agora::rtc::ScreenAudioParameters::captureSignalVolume
int captureSignalVolume
Definition: AgoraBase.h:6468
agora::VideoLayout
Layout information of a specific sub-video stream within the mixed stream.
Definition: AgoraBase.h:8146
agora::rtc::FilterEffectOptions::strength
float strength
Definition: AgoraBase.h:5752
agora::rtc::SimulcastConfig::STREAM_LAYER_1
@ STREAM_LAYER_1
Definition: AgoraBase.h:2266
agora::VideoLayout::channelId
const char * channelId
Definition: AgoraBase.h:8150
agora::rtc::UserInfo
The information of the user.
Definition: AgoraBase.h:7579
agora::rtc::FilterEffectOptions
Filter effect options.
Definition: AgoraBase.h:5728
agora::rtc::TranscodingVideoStream::alpha
double alpha
Definition: AgoraBase.h:4782
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:5026
agora::rtc::RtcStats::lanAccelerateState
int lanAccelerateState
Definition: AgoraBase.h:2909
agora::rtc::AudioEncodedFrameObserverConfig
Observer settings for the encoded audio.
Definition: AgoraBase.h:6818
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo::userId
const char * userId
Definition: AgoraBase.h:7133
agora::rtc::ScreenCaptureParameters
Screen sharing configurations.
Definition: AgoraBase.h:6484
agora::VideoLayout::x
uint32_t x
Definition: AgoraBase.h:8164
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:3983
agora::rtc::VirtualBackgroundSource::BACKGROUND_BLUR_DEGREE
BACKGROUND_BLUR_DEGREE
The degree of blurring applied to the custom background image.
Definition: AgoraBase.h:5933
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo::current_downscale_level
REMOTE_VIDEO_DOWNSCALE_LEVEL current_downscale_level
Definition: AgoraBase.h:7141
agora::rtc::LastmileProbeResult::uplinkReport
LastmileProbeOneWayResult uplinkReport
Definition: AgoraBase.h:5034
agora::rtc::EncodedVideoFrameInfo::rotation
VIDEO_ORIENTATION rotation
Definition: AgoraBase.h:1804
agora::rtc::AdvancedConfigInfo::logUploadServer
LogUploadServerInfo logUploadServer
Definition: AgoraBase.h:7875
agora::rtc::BeautyOptions
Image enhancement options.
Definition: AgoraBase.h:5405
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:6538
agora::rtc::EchoTestConfiguration::channelId
const char * channelId
Definition: AgoraBase.h:7554
agora::rtc::BeautyOptions::lighteningLevel
float lighteningLevel
Definition: AgoraBase.h:5434
agora::rtc::RtcStats::txVideoBytes
unsigned int txVideoBytes
Definition: AgoraBase.h:2762
agora::rtc::VirtualBackgroundSource::BACKGROUND_BLUR
@ BACKGROUND_BLUR
Definition: AgoraBase.h:5923
agora::rtc::LiveTranscoding::backgroundColor
unsigned int backgroundColor
Definition: AgoraBase.h:4616
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:7200
agora::rtc::AudioVolumeInfo::voicePitch
double voicePitch
Definition: AgoraBase.h:4016
agora::rtc::LastmileProbeConfig
Configurations of the last-mile network test.
Definition: AgoraBase.h:4957
agora::rtc::TranscodingUser::y
int y
Definition: AgoraBase.h:4510
agora::rtc::ScreenCaptureParameters::highLightWidth
int highLightWidth
Definition: AgoraBase.h:6575
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:4196
agora::rtc::VideoFormat::fps
int fps
Definition: AgoraBase.h:3188
agora::SpatialAudioParams::speaker_elevation
Optional< double > speaker_elevation
Definition: AgoraBase.h:8083
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:6589
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_AUTO
@ VIDEO_DENOISER_AUTO
Definition: AgoraBase.h:5825
agora::rtc::VideoCanvas::setupMode
VIDEO_VIEW_SETUP_MODE setupMode
Definition: AgoraBase.h:5311
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY
@ LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY
Definition: AgoraBase.h:5787
agora::rtc::WatermarkConfig::literal
WatermarkLiteral literal
Definition: AgoraBase.h:2611
agora::rtc::TranscodingUser::audioChannel
int audioChannel
Definition: AgoraBase.h:4553
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:6555
agora::rtc::AudioEncodedFrameObserverConfig::encodingType
AUDIO_ENCODING_TYPE encodingType
Definition: AgoraBase.h:6826
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:4605
agora::rtc::ChannelMediaRelayConfiguration::destCount
int destCount
Definition: AgoraBase.h:7106
agora::rtc::LocalAudioStats::audioDeviceDelay
int audioDeviceDelay
Definition: AgoraBase.h:4200
agora::rtc::LastmileProbeOneWayResult::jitter
unsigned int jitter
Definition: AgoraBase.h:5014
agora::rtc::BeautyOptions::smoothnessLevel
float smoothnessLevel
Definition: AgoraBase.h:5440
agora::rtc::VideoDenoiserOptions::level
VIDEO_DENOISER_LEVEL level
Definition: AgoraBase.h:5858
agora::rtc::VideoCanvas::mirrorMode
VIDEO_MIRROR_MODE_TYPE mirrorMode
Definition: AgoraBase.h:5307
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:6008
agora::rtc::VideoDimensions::height
int height
Definition: AgoraBase.h:1174
agora::rtc::LocalAccessPointConfiguration::mode
LOCAL_PROXY_MODE mode
Definition: AgoraBase.h:7913
agora::rtc::LastmileProbeConfig::probeUplink
bool probeUplink
Definition: AgoraBase.h:4964
agora::rtc::RecorderStreamInfo::channelId
const char * channelId
Definition: AgoraBase.h:7955
agora::rtc::LocalAccessPointConfiguration
Configuration for the Local Access Point.
Definition: AgoraBase.h:7881
agora::rtc::FilterEffectOptions::path
const char * path
Definition: AgoraBase.h:5746
agora::rtc::SegmentationProperty::SCREEN_COLOR_TYPE
SCREEN_COLOR_TYPE
Screen color type.
Definition: AgoraBase.h:6014
agora::rtc::LiveTranscoding::videoCodecType
VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType
Definition: AgoraBase.h:4620
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_MODE
VIDEO_DENOISER_MODE
Video noise reduction mode.
Definition: AgoraBase.h:5820
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEWIDTH
@ FACE_SHAPE_AREA_NOSEWIDTH
Definition: AgoraBase.h:5590
agora::rtc::LiveTranscoding
Transcoding configurations for Media Push.
Definition: AgoraBase.h:4562
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:7886
agora::rtc::VideoCanvas::uid
uid_t uid
Definition: AgoraBase.h:5279
agora::rtc::RtcStats::firstVideoPacketDuration
int firstVideoPacketDuration
Definition: AgoraBase.h:2858
agora::rtc::AudioRecordingConfiguration::filePath
const char * filePath
Definition: AgoraBase.h:6736
agora::rtc::EncodedVideoFrameInfo
Information about externally encoded video frames.
Definition: AgoraBase.h:1735
agora::rtc::ColorEnhanceOptions::strengthLevel
float strengthLevel
Definition: AgoraBase.h:5877
agora::rtc::MultipathStats::activePathNum
int activePathNum
Definition: AgoraBase.h:2723
agora::SpatialAudioParams::speaker_distance
Optional< double > speaker_distance
Definition: AgoraBase.h:8088
agora::rtc::VirtualBackgroundSource::BACKGROUND_NONE
@ BACKGROUND_NONE
Definition: AgoraBase.h:5911
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MOUTHSMILE
@ FACE_SHAPE_AREA_MOUTHSMILE
Definition: AgoraBase.h:5640
agora::rtc::FaceShapeBeautyOptions::shapeStyle
FACE_SHAPE_BEAUTY_STYLE shapeStyle
Definition: AgoraBase.h:5709
agora::rtc::BeautyOptions::rednessLevel
float rednessLevel
Definition: AgoraBase.h:5446
agora::rtc::RtcStats::rxVideoBytes
unsigned int rxVideoBytes
Definition: AgoraBase.h:2770
agora::rtc::TranscodingVideoStream::remoteUserUid
uid_t remoteUserUid
Definition: AgoraBase.h:4740
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:5010
agora::UserInfo::hasAudio
bool hasAudio
Definition: AgoraBase.h:865
agora::rtc::ScreenCaptureParameters::excludeWindowCount
int excludeWindowCount
Definition: AgoraBase.h:6568
agora::rtc::IPacketObserver::Packet
Configurations for the Packet instance.
Definition: AgoraBase.h:4047
agora::rtc::AudioTrackConfig::enableLocalPlayback
bool enableLocalPlayback
Definition: AgoraBase.h:6087
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSELENGTH
@ FACE_SHAPE_AREA_NOSELENGTH
Definition: AgoraBase.h:5584
agora::rtc::LiveTranscoding::audioCodecProfile
AUDIO_CODEC_PROFILE_TYPE audioCodecProfile
Definition: AgoraBase.h:4690
agora::rtc::RecorderStreamInfo::uid
uid_t uid
Definition: AgoraBase.h:7959
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:7794
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:4494
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:7521
agora::rtc::RtcImage
Image properties.
Definition: AgoraBase.h:4367
agora::rtc::TranscodingUser::x
int x
Definition: AgoraBase.h:4504
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo::stream_type
VIDEO_STREAM_TYPE stream_type
Definition: AgoraBase.h:7137
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_FACECONTOUR
@ FACE_SHAPE_AREA_FACECONTOUR
Definition: AgoraBase.h:5500
agora::rtc::ChannelMediaInfo::token
const char * token
Definition: AgoraBase.h:7060
agora::rtc::VideoRenderingTracingInfo::remoteJoined2PacketReceived
int remoteJoined2PacketReceived
Definition: AgoraBase.h:7809
agora::rtc::AudioRecordingConfiguration::encode
bool encode
Definition: AgoraBase.h:6742
agora::rtc::BeautyOptions::lighteningContrastLevel
LIGHTENING_CONTRAST_LEVEL lighteningContrastLevel
Definition: AgoraBase.h:5428
agora::rtc::WatermarkRatio::yRatio
float yRatio
Definition: AgoraBase.h:2388
agora::SpatialAudioParams::enable_blur
Optional< bool > enable_blur
Definition: AgoraBase.h:8101
agora::rtc::SimulcastStreamConfig
The configuration of the low-quality video stream.
Definition: AgoraBase.h:2230
agora::rtc::LiveTranscoding::audioBitrate
int audioBitrate
Definition: AgoraBase.h:4676
agora::rtc::WatermarkBuffer::buffer
const uint8_t * buffer
Definition: AgoraBase.h:2576
agora::rtc::FaceShapeAreaOptions::shapeArea
FACE_SHAPE_AREA shapeArea
Definition: AgoraBase.h:5666
agora::rtc::ChannelMediaRelayConfiguration::destInfos
ChannelMediaInfo * destInfos
Definition: AgoraBase.h:7100
agora::rtc::RtcImage::x
int x
Definition: AgoraBase.h:4377
agora::rtc::VirtualBackgroundSource::background_source_type
BACKGROUND_SOURCE_TYPE background_source_type
Definition: AgoraBase.h:5954
agora::rtc::FaceShapeBeautyOptions
The facial enhancement style options.
Definition: AgoraBase.h:5684
agora::rtc::TranscodingVideoStream::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:4734
agora::rtc::LocalTranscoderConfiguration::syncWithPrimaryCamera
bool syncWithPrimaryCamera
Definition: AgoraBase.h:4829
agora::rtc::RtcImage::zOrder
int zOrder
Definition: AgoraBase.h:4398
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_FACELENGTH
@ FACE_SHAPE_AREA_FACELENGTH
Definition: AgoraBase.h:5506
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:4873
agora::rtc::ClientRoleOptions::audienceLatencyLevel
AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel
Definition: AgoraBase.h:3004
agora::rtc::AudioVolumeInfo::volume
unsigned int volume
Definition: AgoraBase.h:3999
agora::rtc::TranscodingUser::uid
uid_t uid
Definition: AgoraBase.h:4498
agora::rtc::VideoCanvas::enableAlphaMask
bool enableAlphaMask
Definition: AgoraBase.h:5338
agora::rtc::VideoRenderingTracingInfo::elapsedTime
int elapsedTime
Definition: AgoraBase.h:7733
agora::rtc::LiveStreamAdvancedFeature::featureName
const char * featureName
Definition: AgoraBase.h:4429
agora::rtc::AdvancedConfigInfo
Advanced options for the Local Access Point.
Definition: AgoraBase.h:7870
agora::rtc::ScreenAudioParameters::channels
int channels
Definition: AgoraBase.h:6464
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:4187
agora::rtc::RtcImage::url
const char * url
Definition: AgoraBase.h:4372
agora::rtc::IPacketObserver::Packet::buffer
const unsigned char * buffer
Definition: AgoraBase.h:4053
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:5871
agora::rtc::MultipathStats::wifiTxBytes
uint32_t wifiTxBytes
Definition: AgoraBase.h:2707
agora::rtc::AudioRecordingConfiguration::sampleRate
int sampleRate
Definition: AgoraBase.h:6753
agora::UserInfo::userId
util::AString userId
Definition: AgoraBase.h:859
agora::rtc::UplinkNetworkInfo
The uplink network information.
Definition: AgoraBase.h:7115
agora::rtc::WatermarkOptions::positionInPortraitMode
Rectangle positionInPortraitMode
Definition: AgoraBase.h:2424
agora::rtc::LocalAccessPointConfiguration::advancedConfig
AdvancedConfigInfo advancedConfig
Definition: AgoraBase.h:7917
agora::rtc::LastmileProbeResult::downlinkReport
LastmileProbeOneWayResult downlinkReport
Definition: AgoraBase.h:5038
agora::rtc::LiveTranscoding::watermarkCount
unsigned int watermarkCount
Definition: AgoraBase.h:4653
agora::rtc::Rectangle::x
int x
Definition: AgoraBase.h:2346
agora::rtc::LocalTranscoderConfiguration::videoInputStreams
TranscodingVideoStream * videoInputStreams
Definition: AgoraBase.h:4815
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEDISTANCE
@ FACE_SHAPE_AREA_EYEDISTANCE
Definition: AgoraBase.h:5546
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:7909
agora::SpatialAudioParams::enable_air_absorb
Optional< bool > enable_air_absorb
Definition: AgoraBase.h:8110
agora::rtc::LowlightEnhanceOptions::LOW_LIGHT_ENHANCE_LEVEL
LOW_LIGHT_ENHANCE_LEVEL
The low-light enhancement level.
Definition: AgoraBase.h:5781
agora::rtc::SegmentationProperty::SEG_MODEL_TYPE
SEG_MODEL_TYPE
The type of algorithms to user for background processing.
Definition: AgoraBase.h:6000
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:4807
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_LEVEL
LIGHTENING_CONTRAST_LEVEL
The contrast level.
Definition: AgoraBase.h:5409
agora::rtc::WatermarkRatio::xRatio
float xRatio
Definition: AgoraBase.h:2382
agora::rtc::LocalAudioStats::sentSampleRate
int sentSampleRate
Definition: AgoraBase.h:4183
agora::rtc::VideoSubscriptionOptions::type
Optional< VIDEO_STREAM_TYPE > type
Definition: AgoraBase.h:1710
agora::rtc::RecorderStreamInfo::type
RecorderStreamType type
Definition: AgoraBase.h:7963
agora::rtc::LocalAudioMixerConfiguration::audioInputStreams
MixedAudioStream * audioInputStreams
Definition: AgoraBase.h:4940
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MOUTHPOSITION
@ FACE_SHAPE_AREA_MOUTHPOSITION
Definition: AgoraBase.h:5634
agora::rtc::WatermarkConfig::options
WatermarkOptions options
Definition: AgoraBase.h:2621
agora::rtc::LastmileProbeConfig::expectedDownlinkBitrate
unsigned int expectedDownlinkBitrate
Definition: AgoraBase.h:4980
agora::rtc::RtcStats::cpuTotalUsage
double cpuTotalUsage
Definition: AgoraBase.h:2818
agora::rtc::IPacketObserver::Packet::size
unsigned int size
Definition: AgoraBase.h:4057
agora::rtc::LiveTranscoding::advancedFeatures
LiveStreamAdvancedFeature * advancedFeatures
Definition: AgoraBase.h:4694
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEWING
@ FACE_SHAPE_AREA_NOSEWING
Definition: AgoraBase.h:5596
agora::rtc::LiveTranscoding::backgroundImageCount
unsigned int backgroundImageCount
Definition: AgoraBase.h:4666
agora::rtc::IPacketObserver
Definition: AgoraBase.h:4041
agora::rtc::LiveTranscoding::backgroundImage
RtcImage * backgroundImage
Definition: AgoraBase.h:4661
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_CHIN
@ FACE_SHAPE_AREA_CHIN
Definition: AgoraBase.h:5534
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEBROWTHICKNESS
@ FACE_SHAPE_AREA_EYEBROWTHICKNESS
Definition: AgoraBase.h:5660
agora::rtc::RtcStats::cpuAppUsage
double cpuAppUsage
Definition: AgoraBase.h:2809
agora::VideoLayout::width
uint32_t width
Definition: AgoraBase.h:8174
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:4533
agora::rtc::MixedAudioStream::trackId
track_id_t trackId
Definition: AgoraBase.h:4904
agora::rtc::WatermarkOptions::watermarkRatio
WatermarkRatio watermarkRatio
Definition: AgoraBase.h:2429
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_CHEEKBONE
@ FACE_SHAPE_AREA_CHEEKBONE
Definition: AgoraBase.h:5517
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:4936
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:5030
agora::rtc::VideoEncoderConfiguration::advanceOptions
AdvanceOptions advanceOptions
Definition: AgoraBase.h:2114
agora::rtc::VideoCanvas::position
media::base::VIDEO_MODULE_POSITION position
Definition: AgoraBase.h:5342
agora::rtc::ChannelMediaInfo::channelName
const char * channelName
Definition: AgoraBase.h:7056
agora::rtc::LiveTranscoding::height
int height
Definition: AgoraBase.h:4578
agora::rtc::EncodedAudioFrameAdvancedSettings::speech
bool speech
Definition: AgoraBase.h:1555
agora::rtc::LocalAudioMixerConfiguration
The configurations for mixing the lcoal audio.
Definition: AgoraBase.h:4932
agora::rtc::EncodedVideoFrameInfo::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:1782
agora::rtc::DownlinkNetworkInfo
Definition: AgoraBase.h:7128
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:8141
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:8178
agora::rtc::AudioVolumeInfo::uid
uid_t uid
Definition: AgoraBase.h:3990
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:5413
agora::rtc::DownlinkNetworkInfo::lastmile_buffer_delay_time_ms
int lastmile_buffer_delay_time_ms
Definition: AgoraBase.h:7188
agora::rtc::LiveTranscoding::videoBitrate
int videoBitrate
Definition: AgoraBase.h:4585
agora::rtc::FaceShapeBeautyOptions::FACE_SHAPE_BEAUTY_STYLE_FEMALE
@ FACE_SHAPE_BEAUTY_STYLE_FEMALE
Definition: AgoraBase.h:5694
agora::rtc::VideoTrackInfo::trackId
track_id_t trackId
Definition: AgoraBase.h:3928
agora::rtc::VideoTrackInfo::encodedFrameOnly
bool encodedFrameOnly
Definition: AgoraBase.h:3942
agora::rtc::FaceShapeBeautyOptions::FACE_SHAPE_BEAUTY_STYLE
FACE_SHAPE_BEAUTY_STYLE
The facial enhancement style options.
Definition: AgoraBase.h:5690
agora::rtc::SegmentationProperty::SCREEN_COLOR_BLUE
@ SCREEN_COLOR_BLUE
Definition: AgoraBase.h:6026
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_CHEEK
@ FACE_SHAPE_AREA_CHEEK
Definition: AgoraBase.h:5522
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MOUTHSCALE
@ FACE_SHAPE_AREA_MOUTHSCALE
Definition: AgoraBase.h:5628
agora::rtc::TranscodingUser::width
int width
Definition: AgoraBase.h:4514
agora::rtc::FaceShapeBeautyOptions::FACE_SHAPE_BEAUTY_STYLE_MALE
@ FACE_SHAPE_BEAUTY_STYLE_MALE
Definition: AgoraBase.h:5698
agora::rtc::ScreenCaptureParameters::highLightColor
unsigned int highLightColor
Definition: AgoraBase.h:6581
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_FACEWIDTH
@ FACE_SHAPE_AREA_FACEWIDTH
Definition: AgoraBase.h:5511
agora::base::AParameter
Definition: AgoraBase.h:8037
agora::rtc::BeautyOptions::sharpnessLevel
float sharpnessLevel
Definition: AgoraBase.h:5452
agora::rtc::MultipathStats::lanTxBytes
uint32_t lanTxBytes
Definition: AgoraBase.h:2699
agora::rtc::EncryptionConfig::encryptionMode
ENCRYPTION_MODE encryptionMode
Definition: AgoraBase.h:7300
agora::util::AOutputIterator
Definition: AgoraBase.h:202
agora::rtc::WatermarkOptions::positionInLandscapeMode
Rectangle positionInLandscapeMode
Definition: AgoraBase.h:2419
agora::rtc::IAudioEncodedFrameObserver
Definition: AgoraBase.h:6835
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:6456
agora::rtc::VideoTrackInfo::ownerUid
uid_t ownerUid
Definition: AgoraBase.h:3924
agora::rtc::VideoRenderingTracingInfo::join2JoinSuccess
int join2JoinSuccess
Definition: AgoraBase.h:7749
agora::rtc::LastmileProbeOneWayResult::availableBandwidth
unsigned int availableBandwidth
Definition: AgoraBase.h:5018
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:4635
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo
Definition: AgoraBase.h:7129
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:3936
agora::rtc::DeviceInfo::isLowLatencyAudioSupported
bool isLowLatencyAudioSupported
Definition: AgoraBase.h:4033
agora::rtc::LiveTranscoding::metadata
const char * metadata
Definition: AgoraBase.h:4642
agora::rtc::LiveTranscoding::audioSampleRate
AUDIO_SAMPLE_RATE_TYPE audioSampleRate
Definition: AgoraBase.h:4671
agora::rtc::ChannelMediaRelayConfiguration
Configuration of cross channel media relay.
Definition: AgoraBase.h:7069
agora::rtc::VirtualBackgroundSource::blur_degree
BACKGROUND_BLUR_DEGREE blur_degree
Definition: AgoraBase.h:5984
agora::rtc::MultipathStats::pathStats
const PathStats * pathStats
Definition: AgoraBase.h:2727
agora::rtc::UserInfo::uid
uid_t uid
Definition: AgoraBase.h:7583
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:4416
agora::rtc::VirtualBackgroundSource::color
unsigned int color
Definition: AgoraBase.h:5968
agora::rtc::LastmileProbeOneWayResult
Results of the uplink or downlink last-mile network test.
Definition: AgoraBase.h:5006
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEGENERAL
@ FACE_SHAPE_AREA_NOSEGENERAL
Definition: AgoraBase.h:5621
agora::rtc::VideoDenoiserOptions
Video noise reduction options.
Definition: AgoraBase.h:5816
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:5840
agora::rtc::VideoCanvas::cropArea
Rectangle cropArea
Definition: AgoraBase.h:5325
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:4897
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:5901
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEPUPILS
@ FACE_SHAPE_AREA_EYEPUPILS
Definition: AgoraBase.h:5565
agora::rtc::LowlightEnhanceOptions::level
LOW_LIGHT_ENHANCE_LEVEL level
Definition: AgoraBase.h:5803
agora::rtc::VideoCanvas::view
view_t view
Definition: AgoraBase.h:5290
agora::rtc::TranscodingVideoStream::imageUrl
const char * imageUrl
Definition: AgoraBase.h:4747
agora::rtc::ScreenCaptureParameters::audioParams
ScreenAudioParameters audioParams
Definition: AgoraBase.h:6501
agora::rtc::AudioEncodedFrameObserverConfig::postionType
AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType
Definition: AgoraBase.h:6822
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:7313
agora::rtc::ScreenCaptureParameters::captureAudio
bool captureAudio
Definition: AgoraBase.h:6495
agora::rtc::VirtualBackgroundSource::BACKGROUND_IMG
@ BACKGROUND_IMG
Definition: AgoraBase.h:5919
agora::rtc::LiveTranscoding::watermark
RtcImage * watermark
Definition: AgoraBase.h:4648
agora::rtc::AudioVolumeInfo::vad
unsigned int vad
Definition: AgoraBase.h:4010
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSETIP
@ FACE_SHAPE_AREA_NOSETIP
Definition: AgoraBase.h:5614
agora::rtc::ChannelMediaInfo
Channel media information.
Definition: AgoraBase.h:7048
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:5776
agora::rtc::DownlinkNetworkInfo::total_downscale_level_count
int total_downscale_level_count
Definition: AgoraBase.h:7196
agora::VideoLayout::y
uint32_t y
Definition: AgoraBase.h:8170
agora::rtc::WatermarkLiteral::fontSize
int fontSize
Definition: AgoraBase.h:2520
agora::rtc::DownlinkNetworkInfo::bandwidth_estimation_bps
int bandwidth_estimation_bps
Definition: AgoraBase.h:7192
agora::rtc::LocalAudioStats::aecEstimatedDelay
int aecEstimatedDelay
Definition: AgoraBase.h:4213
agora::rtc::VideoCanvas::renderMode
media::base::RENDER_MODE_TYPE renderMode
Definition: AgoraBase.h:5299
agora::SpatialAudioParams::speaker_orientation
Optional< int > speaker_orientation
Definition: AgoraBase.h:8095
agora::rtc::LocalAudioStats::earMonitorDelay
int earMonitorDelay
Definition: AgoraBase.h:4208
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA
FACE_SHAPE_AREA
Chooses the specific facial areas that need to be adjusted.
Definition: AgoraBase.h:5481
agora::rtc::MultipathStats::lanRxBytes
uint32_t lanRxBytes
Definition: AgoraBase.h:2703
agora::rtc::VideoTrackInfo::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:3946
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:5572
agora::rtc::LocalAudioStats::audioPlayoutDelay
int audioPlayoutDelay
Definition: AgoraBase.h:4204
agora::SpatialAudioParams::speaker_attenuation
Optional< double > speaker_attenuation
Definition: AgoraBase.h:8124
agora::rtc::VideoTrackInfo::observationPosition
uint32_t observationPosition
Definition: AgoraBase.h:3950
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_LOWEREYELID
@ FACE_SHAPE_AREA_LOWEREYELID
Definition: AgoraBase.h:5559
agora::rtc::AdvanceOptions::encodeAlpha
bool encodeAlpha
Definition: AgoraBase.h:1889
agora::VideoLayout::strUid
user_id_t strUid
Definition: AgoraBase.h:8158
agora::rtc::LogUploadServerInfo
Configuration information for the log server.
Definition: AgoraBase.h:7841
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL
VIDEO_DENOISER_LEVEL
Video noise reduction level.
Definition: AgoraBase.h:5834
agora::rtc::AudioTrackConfig::enableAudioProcessing
bool enableAudioProcessing
Definition: AgoraBase.h:6095
agora::rtc::VideoCanvas::sourceType
VIDEO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:5315
agora::rtc::CodecCapInfo
The codec capability of the SDK.
Definition: AgoraBase.h:2019
agora::rtc::ScreenCaptureParameters::frameRate
int frameRate
Definition: AgoraBase.h:6532
agora::rtc::AudioRecordingConfiguration::recordingChannel
int recordingChannel
Definition: AgoraBase.h:6777
agora::rtc::RtcStats::firstVideoKeyFramePacketDurationAfterUnmute
int firstVideoKeyFramePacketDurationAfterUnmute
Definition: AgoraBase.h:2883
agora::rtc::LiveTranscoding::audioChannels
int audioChannels
Definition: AgoraBase.h:4686
agora::rtc::RtcImage::height
int height
Definition: AgoraBase.h:4390
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:4970
agora::rtc::SegmentationProperty::modelType
SEG_MODEL_TYPE modelType
Definition: AgoraBase.h:6032
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:7562
agora::rtc::LocalTranscoderConfiguration::streamCount
unsigned int streamCount
Definition: AgoraBase.h:4811
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_HIGH
@ LIGHTENING_CONTRAST_HIGH
Definition: AgoraBase.h:5421
agora::base::LicenseCallback
Definition: AgoraBase.h:8051
agora::rtc::EncryptionConfig
Built-in encryption configurations.
Definition: AgoraBase.h:7295
agora::rtc::LiveTranscoding::videoCodecProfile
VIDEO_CODEC_PROFILE_TYPE videoCodecProfile
Definition: AgoraBase.h:4611
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:5905
agora::rtc::VideoRenderingTracingInfo::start2JoinChannel
int start2JoinChannel
Definition: AgoraBase.h:7742
agora::rtc::VideoCanvas::backgroundColor
uint32_t backgroundColor
Definition: AgoraBase.h:5295
agora::rtc::LocalAccessPointConfiguration::disableAut
bool disableAut
Definition: AgoraBase.h:7923
agora::rtc::ScreenAudioParameters::sampleRate
int sampleRate
Definition: AgoraBase.h:6460
agora::rtc::ScreenCaptureParameters::dimensions
VideoDimensions dimensions
Definition: AgoraBase.h:6526
agora::rtc::VideoDimensions::width
int width
Definition: AgoraBase.h:1170
agora::rtc::TranscodingVideoStream::x
int x
Definition: AgoraBase.h:4757
agora::rtc::LiveTranscoding::lowLatency
bool lowLatency
Definition: AgoraBase.h:4600
agora::rtc::TranscodingVideoStream
The video streams for local video mixing.
Definition: AgoraBase.h:4730
agora::rtc::VirtualBackgroundSource::source
const char * source
Definition: AgoraBase.h:5977
agora::rtc::LogUploadServerInfo::serverPath
const char * serverPath
Definition: AgoraBase.h:7849
agora::rtc::EncryptionConfig::datastreamEncryptionEnabled
bool datastreamEncryptionEnabled
Definition: AgoraBase.h:7320
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYESCALE
@ FACE_SHAPE_AREA_EYESCALE
Definition: AgoraBase.h:5539
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MOUTHLIP
@ FACE_SHAPE_AREA_MOUTHLIP
Definition: AgoraBase.h:5647
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:5608
agora::rtc::SegmentationProperty::SCREEN_COLOR_AUTO
@ SCREEN_COLOR_AUTO
Definition: AgoraBase.h:6018
agora::VideoLayout::videoState
uint32_t videoState
Definition: AgoraBase.h:8186
agora::rtc::MixedAudioStream::sourceType
AUDIO_SOURCE_TYPE sourceType
Definition: AgoraBase.h:4877
agora::rtc::WatermarkConfig
Used to configure watermark-related information.
Definition: AgoraBase.h:2586
agora::rtc::EchoTestConfiguration::view
view_t view
Definition: AgoraBase.h:7526
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:5927
agora::rtc::WatermarkOptions::visibleInPreview
bool visibleInPreview
Definition: AgoraBase.h:2414
agora::rtc::LowlightEnhanceOptions
The low-light enhancement options.
Definition: AgoraBase.h:5762
agora::rtc::TranscodingUser::zOrder
int zOrder
Definition: AgoraBase.h:4527
agora::rtc::UplinkNetworkInfo::video_encoder_target_bitrate_bps
int video_encoder_target_bitrate_bps
Definition: AgoraBase.h:7119
agora::rtc::LiveTranscoding::width
int width
Definition: AgoraBase.h:4570
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:5853
agora::rtc::RtcStats::rxAudioKBitRate
unsigned short rxAudioKBitRate
Definition: AgoraBase.h:2782
agora::rtc::SegmentationProperty::greenCapacity
float greenCapacity
Definition: AgoraBase.h:6042
agora::rtc::LocalAudioStats::numChannels
int numChannels
Definition: AgoraBase.h:4179
agora::rtc::VideoRenderingTracingInfo::remoteJoined2SetView
int remoteJoined2SetView
Definition: AgoraBase.h:7779
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:4175
agora::rtc::RecorderStreamInfo
The information about the media streams to be recorded.
Definition: AgoraBase.h:7951
agora::rtc::LogUploadServerInfo::serverPort
int serverPort
Definition: AgoraBase.h:7853
agora::rtc::SimulcastConfig
Configure video streams of different quality levels.
Definition: AgoraBase.h:2258
agora::rtc::ScreenCaptureParameters::captureMouseCursor
bool captureMouseCursor
Definition: AgoraBase.h:6546
agora::rtc::DownlinkNetworkInfo::total_received_video_count
int total_received_video_count
Definition: AgoraBase.h:7204
agora::rtc::MixedAudioStream::remoteUserUid
uid_t remoteUserUid
Definition: AgoraBase.h:4883
agora::rtc::WatermarkBuffer::width
int width
Definition: AgoraBase.h:2557
agora::rtc::RtcImage::y
int y
Definition: AgoraBase.h:4382
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:7540
agora::rtc::RtcStats::gatewayRtt
int gatewayRtt
Definition: AgoraBase.h:2828
agora::rtc::LastmileProbeConfig::expectedUplinkBitrate
unsigned int expectedUplinkBitrate
Definition: AgoraBase.h:4975
agora::rtc::VideoTrackInfo::isLocal
bool isLocal
Definition: AgoraBase.h:3920
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEPOSITION
@ FACE_SHAPE_AREA_EYEPOSITION
Definition: AgoraBase.h:5553
agora::rtc::DownlinkNetworkInfo::PeerDownlinkInfo::expected_bitrate_bps
int expected_bitrate_bps
Definition: AgoraBase.h:7145
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:6047
agora::rtc::VideoTrackInfo::channelId
const char * channelId
Definition: AgoraBase.h:3932
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:5792
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:4699
agora::rtc::CodecCapInfo::codecCapMask
int codecCapMask
Definition: AgoraBase.h:2027
agora::rtc::AudioRecordingConfiguration
Recording configurations.
Definition: AgoraBase.h:6730
agora::SpatialAudioParams::speaker_azimuth
Optional< double > speaker_azimuth
Definition: AgoraBase.h:8075
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:5766
agora::util::IContainer
Definition: AgoraBase.h:193
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_HIGH
@ BLUR_DEGREE_HIGH
Definition: AgoraBase.h:5948
agora::rtc::LocalAudioMixerConfiguration::syncWithLocalMic
bool syncWithLocalMic
Definition: AgoraBase.h:4949
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_MANDIBLE
@ FACE_SHAPE_AREA_MANDIBLE
Definition: AgoraBase.h:5528
agora::rtc::VideoDimensions
The video dimension.
Definition: AgoraBase.h:1166
agora::rtc::VirtualBackgroundSource::BLUR_DEGREE_LOW
@ BLUR_DEGREE_LOW
Definition: AgoraBase.h:5938
agora::rtc::SegmentationProperty::SEG_MODEL_AI
@ SEG_MODEL_AI
Definition: AgoraBase.h:6004
agora::rtc::FaceShapeBeautyOptions::FACE_SHAPE_BEAUTY_STYLE_NATURAL
@ FACE_SHAPE_BEAUTY_STYLE_NATURAL
Definition: AgoraBase.h:5703
agora::rtc::VideoRenderingTracingInfo::joinSuccess2RemoteJoined
int joinSuccess2RemoteJoined
Definition: AgoraBase.h:7764
agora::rtc::FaceShapeAreaOptions::shapeIntensity
int shapeIntensity
Definition: AgoraBase.h:5672
agora::rtc::TranscodingVideoStream::height
int height
Definition: AgoraBase.h:4770
agora::rtc::DataStreamConfig::syncWithAudio
bool syncWithAudio
Definition: AgoraBase.h:2196
agora::rtc::LowlightEnhanceOptions::mode
LOW_LIGHT_ENHANCE_MODE mode
Definition: AgoraBase.h:5798
agora::rtc::LiveTranscoding::userCount
unsigned int userCount
Definition: AgoraBase.h:4624
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:5495
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:6081
agora::rtc::FocalLengthInfo::cameraDirection
int cameraDirection
Definition: AgoraBase.h:2047
agora::rtc::LocalAccessPointConfiguration::ipListSize
int ipListSize
Definition: AgoraBase.h:7891
agora::rtc::SimulcastConfig::STREAM_LAYER_4
@ STREAM_LAYER_4
Definition: AgoraBase.h:2278
agora::rtc::TranscodingVideoStream::width
int width
Definition: AgoraBase.h:4766
agora::rtc::TranscodingVideoStream::mirror
bool mirror
Definition: AgoraBase.h:4789
agora::rtc::SimulcastStreamConfig::kBitrate
int kBitrate
Definition: AgoraBase.h:2241
agora::rtc::RtcImage::alpha
double alpha
Definition: AgoraBase.h:4404
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_EYEOUTERCORNER
@ FACE_SHAPE_AREA_EYEOUTERCORNER
Definition: AgoraBase.h:5579
agora::rtc::TranscodingVideoStream::mediaPlayerId
int mediaPlayerId
Definition: AgoraBase.h:4752
agora::rtc::VideoCanvas::subviewUid
uid_t subviewUid
Definition: AgoraBase.h:5284
agora::rtc::EncryptionConfig::encryptionKey
const char * encryptionKey
Definition: AgoraBase.h:7306
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:5943
agora::rtc::ScreenCaptureParameters::excludeWindowList
view_t * excludeWindowList
Definition: AgoraBase.h:6562
agora::rtc::LocalAccessPointConfiguration::domainList
const char ** domainList
Definition: AgoraBase.h:7899
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:3905
agora::rtc::LocalTranscoderConfiguration::videoOutputConfiguration
VideoEncoderConfiguration videoOutputConfiguration
Definition: AgoraBase.h:4820
agora::rtc::EchoTestConfiguration::enableAudio
bool enableAudio
Definition: AgoraBase.h:7533
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_HEADSCALE
@ FACE_SHAPE_AREA_HEADSCALE
Definition: AgoraBase.h:5490
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:5915
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:5772
agora::rtc::RtcStats::firstVideoPacketDurationAfterUnmute
int firstVideoPacketDurationAfterUnmute
Definition: AgoraBase.h:2878
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NONE
@ FACE_SHAPE_AREA_NONE
Definition: AgoraBase.h:5485
agora::rtc::LiveTranscoding::videoFramerate
int videoFramerate
Definition: AgoraBase.h:4591
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:5475
agora::rtc::CodecCapLevels
The level of the codec capability.
Definition: AgoraBase.h:1999
agora::SpatialAudioParams
The spatial audio parameters.
Definition: AgoraBase.h:8065
agora::rtc::ColorEnhanceOptions::skinProtectLevel
float skinProtectLevel
Definition: AgoraBase.h:5890
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_LEVEL_FAST
@ VIDEO_DENOISER_LEVEL_FAST
Definition: AgoraBase.h:5848
agora::rtc::SegmentationProperty::SCREEN_COLOR_GREEN
@ SCREEN_COLOR_GREEN
Definition: AgoraBase.h:6022
agora::rtc::VideoEncoderConfiguration::codecType
VIDEO_CODEC_TYPE codecType
Definition: AgoraBase.h:2061
agora::rtc::LastmileProbeResult::rtt
unsigned int rtt
Definition: AgoraBase.h:5042
agora::rtc::TranscodingVideoStream::y
int y
Definition: AgoraBase.h:4762
agora::rtc::PathStats::rxKBitRate
int rxKBitRate
Definition: AgoraBase.h:2685
agora::rtc::FaceShapeAreaOptions::FACE_SHAPE_AREA_NOSEROOT
@ FACE_SHAPE_AREA_NOSEROOT
Definition: AgoraBase.h:5602
agora::rtc::RtcStats::packetsBeforeFirstKeyFramePacket
int packetsBeforeFirstKeyFramePacket
Definition: AgoraBase.h:2868
agora::rtc::BeautyOptions::LIGHTENING_CONTRAST_NORMAL
@ LIGHTENING_CONTRAST_NORMAL
Definition: AgoraBase.h:5417
agora::rtc::ChannelMediaRelayConfiguration::srcInfo
ChannelMediaInfo * srcInfo
Definition: AgoraBase.h:7083
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:5654
agora::rtc::LiveStreamAdvancedFeature::opened
bool opened
Definition: AgoraBase.h:4436
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:7548
agora::rtc::DeviceInfo
The audio device information.
Definition: AgoraBase.h:4027
agora::base::IEngineBase
Definition: AgoraBase.h:8031
agora::rtc::SenderOptions::targetBitrate
int targetBitrate
Definition: AgoraBase.h:1412
agora::rtc::AudioRecordingConfiguration::quality
AUDIO_RECORDING_QUALITY_TYPE quality
Definition: AgoraBase.h:6762
agora::util::IIterator
Definition: AgoraBase.h:184
agora::rtc::UserInfo::userAccount
char userAccount[MAX_USER_ACCOUNT_LENGTH]
Definition: AgoraBase.h:7587
agora::rtc::VideoRenderingTracingInfo
Indicators during video frame rendering progress.
Definition: AgoraBase.h:7727
agora::rtc::LogUploadServerInfo::serverHttps
bool serverHttps
Definition: AgoraBase.h:7859
agora::rtc::VideoDenoiserOptions::VIDEO_DENOISER_MANUAL
@ VIDEO_DENOISER_MANUAL
Definition: AgoraBase.h:5829
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:5716
agora::rtc::WatermarkLiteral::fontFilePath
const char * fontFilePath
Definition: AgoraBase.h:2537
agora::VideoLayout::uid
rtc::uid_t uid
Definition: AgoraBase.h:8154
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:7904
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:4518
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:5275
agora::rtc::LocalAudioStats::internalCodec
int internalCodec
Definition: AgoraBase.h:4191
agora::rtc::AudioRecordingConfiguration::fileRecordingType
AUDIO_FILE_RECORDING_TYPE fileRecordingType
Definition: AgoraBase.h:6757
agora::rtc::SegmentationProperty
Processing properties for background images.
Definition: AgoraBase.h:5996
agora::rtc::SimulcastConfig::StreamLayerConfig::enable
bool enable
Definition: AgoraBase.h:2318
agora::rtc::ChannelMediaInfo::uid
uid_t uid
Definition: AgoraBase.h:7052