AgoraBase.h

Go to the documentation of this file.

//
//  Agora Engine SDK
//
//  Created by Sting Feng in 2017-11.
//  Copyright (c) 2017 Agora.io. All rights reserved.
//
 
// This header file is included by both high level and low level APIs,
#pragma once // NOLINT(build/header_guard)
 
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <cassert>
 
#include "IAgoraParameter.h"
#include "AgoraMediaBase.h"
#include "AgoraRefPtr.h"
#include "AgoraOptional.h"
 
#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
#define AGORA_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define AGORA_DEPRECATED __declspec(deprecated)
#else
#define AGORA_DEPRECATED
#endif
 
#define MAX_PATH_260 (260)
 
#if defined(_WIN32)
 
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif // !WIN32_LEAN_AND_MEAN
#if defined(__aarch64__)
#include <arm64intr.h>
#endif
#include <Windows.h>
 
#if defined(AGORARTC_EXPORT)
#define AGORA_API extern "C" __declspec(dllexport)
#else
#define AGORA_API extern "C" __declspec(dllimport)
#endif // AGORARTC_EXPORT
 
#define AGORA_CALL __cdecl
 
#elif defined(__APPLE__)
 
#include <TargetConditionals.h>
 
#define AGORA_API extern "C" __attribute__((visibility("default")))
#define AGORA_CALL
 
#elif defined(__ANDROID__) || defined(__linux__)
 
#define AGORA_API extern "C" __attribute__((visibility("default")))
#define AGORA_CALL
 
#else // !_WIN32 && !__APPLE__ && !(__ANDROID__ || __linux__)
 
#define AGORA_API extern "C"
#define AGORA_CALL
 
#endif // _WIN32
 
#ifndef OPTIONAL_ENUM_SIZE_T
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
#define OPTIONAL_ENUM_SIZE_T enum : size_t
#else
#define OPTIONAL_ENUM_SIZE_T enum
#endif
#endif
 
#ifndef OPTIONAL_NULLPTR
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
#define OPTIONAL_NULLPTR nullptr
#else
#define OPTIONAL_NULLPTR NULL
#endif
#endif
 
namespace agora
{
  namespace commons
  {
    namespace cjson
    {
      class JsonWrapper;
    } // namespace cjson
  }   // namespace commons
 
  typedef commons::cjson::JsonWrapper any_document_t;
 
  namespace base
  {
    class IEngineBase;
 
    class IParameterEngine
    {
    public:
      virtual int setParameters(const char *parameters) = 0;
      virtual int getParameters(const char *key, any_document_t &result) = 0;
      virtual ~IParameterEngine() {}
    };
  } // namespace base
 
  namespace util
  {
 
    template <class T>
    class AutoPtr
    {
    protected:
      typedef T value_type;
      typedef T *pointer_type;
 
    public:
      explicit AutoPtr(pointer_type p = NULL) : ptr_(p) {}
 
      ~AutoPtr()
      {
        if (ptr_)
        {
          ptr_->release();
          ptr_ = NULL;
        }
      }
 
      operator bool() const { return (ptr_ != NULL); }
 
      value_type &operator*() const { return *get(); }
 
      pointer_type operator->() const { return get(); }
 
      pointer_type get() const { return ptr_; }
 
      pointer_type release()
      {
        pointer_type ret = ptr_;
        ptr_ = 0;
        return ret;
      }
 
      void reset(pointer_type ptr = NULL)
      {
        if (ptr != ptr_ && ptr_)
        {
          ptr_->release();
        }
 
        ptr_ = ptr;
      }
 
      template <class C1, class C2>
      bool queryInterface(C1 *c, C2 iid)
      {
        pointer_type p = NULL;
        if (c && !c->queryInterface(iid, reinterpret_cast<void **>(&p)))
        {
          reset(p);
        }
 
        return (p != NULL);
      }
 
    private:
      AutoPtr(const AutoPtr &);
      AutoPtr &operator=(const AutoPtr &);
 
    private:
      pointer_type ptr_;
    };
 
    template <class T>
    class CopyableAutoPtr : public AutoPtr<T>
    {
      typedef typename AutoPtr<T>::pointer_type pointer_type;
 
    public:
      explicit CopyableAutoPtr(pointer_type p = 0) : AutoPtr<T>(p) {}
      explicit CopyableAutoPtr(const CopyableAutoPtr &rhs) { this->reset(rhs.clone()); }
      CopyableAutoPtr &operator=(const CopyableAutoPtr &rhs)
      {
        if (this != &rhs)
          this->reset(rhs.clone());
        return *this;
      }
      pointer_type clone() const
      {
        if (!this->get())
          return NULL;
        return this->get()->clone();
      }
    };
 
    class IString
    {
    public:
      virtual bool empty() const = 0;
      virtual const char *c_str() = 0;
      virtual const char *data() = 0;
      virtual size_t length() = 0;
      virtual IString *clone() = 0;
      virtual void release() = 0;
      virtual ~IString() {}
    };
    typedef CopyableAutoPtr<IString> AString;
 
    class IIterator
    {
    public:
      virtual void *current() = 0;
      virtual const void *const_current() const = 0;
      virtual bool next() = 0;
      virtual void release() = 0;
      virtual ~IIterator() {}
    };
 
    class IContainer
    {
    public:
      virtual IIterator *begin() = 0;
      virtual size_t size() const = 0;
      virtual void release() = 0;
      virtual ~IContainer() {}
    };
 
    template <class T>
    class AOutputIterator
    {
      IIterator *p;
 
    public:
      typedef T value_type;
      typedef value_type &reference;
      typedef const value_type &const_reference;
      typedef value_type *pointer;
      typedef const value_type *const_pointer;
      explicit AOutputIterator(IIterator *it = NULL) : p(it) {}
      ~AOutputIterator()
      {
        if (p)
          p->release();
      }
      AOutputIterator(const AOutputIterator &rhs) : p(rhs.p) {}
      AOutputIterator &operator++()
      {
        p->next();
        return *this;
      }
      bool operator==(const AOutputIterator &rhs) const
      {
        if (p && rhs.p)
          return p->current() == rhs.p->current();
        else
          return valid() == rhs.valid();
      }
      bool operator!=(const AOutputIterator &rhs) const { return !this->operator==(rhs); }
      reference operator*() { return *reinterpret_cast<pointer>(p->current()); }
      const_reference operator*() const { return *reinterpret_cast<const_pointer>(p->const_current()); }
      bool valid() const { return p && p->current() != NULL; }
    };
 
    template <class T>
    class AList
    {
      IContainer *container;
      bool owner;
 
    public:
      typedef T value_type;
      typedef value_type &reference;
      typedef const value_type &const_reference;
      typedef value_type *pointer;
      typedef const value_type *const_pointer;
      typedef size_t size_type;
      typedef AOutputIterator<value_type> iterator;
      typedef const AOutputIterator<value_type> const_iterator;
 
    public:
      AList() : container(NULL), owner(false) {}
      AList(IContainer *c, bool take_ownership) : container(c), owner(take_ownership) {}
      ~AList() { reset(); }
      void reset(IContainer *c = NULL, bool take_ownership = false)
      {
        if (owner && container)
          container->release();
        container = c;
        owner = take_ownership;
      }
      iterator begin() { return container ? iterator(container->begin()) : iterator(NULL); }
      iterator end() { return iterator(NULL); }
      size_type size() const { return container ? container->size() : 0; }
      bool empty() const { return size() == 0; }
    };
 
  } // namespace util
 
  enum CHANNEL_PROFILE_TYPE
  {
    CHANNEL_PROFILE_COMMUNICATION = 0,
    CHANNEL_PROFILE_LIVE_BROADCASTING = 1,
    CHANNEL_PROFILE_GAME = 2,
    CHANNEL_PROFILE_CLOUD_GAMING __deprecated = 3,
 
 
    CHANNEL_PROFILE_COMMUNICATION_1v1 = 4,
 
    CHANNEL_PROFILE_LIVE_BROADCASTING_2 = 5,
  };
 
 
  enum WARN_CODE_TYPE
  {
    WARN_INVALID_VIEW = 8,
    WARN_INIT_VIDEO = 16,
    WARN_PENDING = 20,
    WARN_NO_AVAILABLE_CHANNEL = 103,
    WARN_LOOKUP_CHANNEL_TIMEOUT = 104,
    WARN_LOOKUP_CHANNEL_REJECTED = 105,
    WARN_OPEN_CHANNEL_TIMEOUT = 106,
    WARN_OPEN_CHANNEL_REJECTED = 107,
 
    // sdk: 100~1000
    WARN_SWITCH_LIVE_VIDEO_TIMEOUT = 111,
    WARN_SET_CLIENT_ROLE_TIMEOUT = 118,
    WARN_OPEN_CHANNEL_INVALID_TICKET = 121,
    WARN_OPEN_CHANNEL_TRY_NEXT_VOS = 122,
    WARN_CHANNEL_CONNECTION_UNRECOVERABLE = 131,
    WARN_CHANNEL_CONNECTION_IP_CHANGED = 132,
    WARN_CHANNEL_CONNECTION_PORT_CHANGED = 133,
    WARN_CHANNEL_SOCKET_ERROR = 134,
    WARN_AUDIO_MIXING_OPEN_ERROR = 701,
    WARN_ADM_RUNTIME_PLAYOUT_WARNING = 1014,
    WARN_ADM_RUNTIME_RECORDING_WARNING = 1016,
    WARN_ADM_RECORD_AUDIO_SILENCE = 1019,
    WARN_ADM_PLAYOUT_MALFUNCTION = 1020,
    WARN_ADM_RECORD_MALFUNCTION = 1021,
    WARN_ADM_IOS_CATEGORY_NOT_PLAYANDRECORD = 1029,
    WARN_ADM_IOS_SAMPLERATE_CHANGE = 1030,
    WARN_ADM_RECORD_AUDIO_LOWLEVEL = 1031,
    WARN_ADM_PLAYOUT_AUDIO_LOWLEVEL = 1032,
    WARN_ADM_WINDOWS_NO_DATA_READY_EVENT = 1040,
    WARN_APM_HOWLING = 1051,
    WARN_ADM_GLITCH_STATE = 1052,
    WARN_ADM_IMPROPER_SETTINGS = 1053,
    WARN_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
    WARN_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
    WARN_ADM_WIN_CORE_IMPROPER_CAPTURE_RELEASE = 1324,
  };
 
  enum ERROR_CODE_TYPE
  {
    ERR_OK = 0,
    // 1~1000
    ERR_FAILED = 1,
    ERR_INVALID_ARGUMENT = 2,
    ERR_NOT_READY = 3,
    ERR_NOT_SUPPORTED = 4,
    ERR_REFUSED = 5,
    ERR_BUFFER_TOO_SMALL = 6,
    ERR_NOT_INITIALIZED = 7,
    ERR_INVALID_STATE = 8,
    ERR_NO_PERMISSION = 9,
    ERR_TIMEDOUT = 10,
    ERR_CANCELED = 11,
    ERR_TOO_OFTEN = 12,
    ERR_BIND_SOCKET = 13,
    ERR_NET_DOWN = 14,
    ERR_NET_NOBUFS = 15,
    ERR_JOIN_CHANNEL_REJECTED = 17,
    ERR_LEAVE_CHANNEL_REJECTED = 18,
    ERR_ALREADY_IN_USE = 19,
    ERR_ABORTED = 20,
    ERR_INIT_NET_ENGINE = 21,
    ERR_RESOURCE_LIMITED = 22,
    ERR_INVALID_APP_ID = 101,
    ERR_INVALID_CHANNEL_NAME = 102,
    ERR_NO_SERVER_RESOURCES = 103,
    ERR_TOKEN_EXPIRED = 109,
    ERR_INVALID_TOKEN = 110,
    ERR_CONNECTION_INTERRUPTED = 111, // only used in web sdk
    ERR_CONNECTION_LOST = 112, // only used in web sdk
    ERR_NOT_IN_CHANNEL = 113,
    ERR_SIZE_TOO_LARGE = 114,
    ERR_BITRATE_LIMIT = 115,
    ERR_TOO_MANY_DATA_STREAMS = 116,
    ERR_STREAM_MESSAGE_TIMEOUT = 117,
    ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED = 119,
    ERR_DECRYPTION_FAILED = 120,
    ERR_INVALID_USER_ID = 121,
    ERR_CLIENT_IS_BANNED_BY_SERVER = 123,
    ERR_WATERMARK_PARAM = 124,
    ERR_WATERMARK_PATH = 125,
    ERR_WATERMARK_PNG = 126,
    ERR_WATERMARKR_INFO = 127,
    ERR_WATERMARK_ARGB = 128,
    ERR_WATERMARK_READ = 129,
    ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH = 130,
 
    ERR_LICENSE_CREDENTIAL_INVALID = 131,
 
    // Licensing, keep the license error code same as the main version
    ERR_CERT_RAW = 157,
    ERR_CERT_JSON_PART = 158,
    ERR_CERT_JSON_INVAL = 159,
    ERR_CERT_JSON_NOMEM = 160,
    ERR_CERT_CUSTOM = 161,
    ERR_CERT_CREDENTIAL = 162,
    ERR_CERT_SIGN = 163,
    ERR_CERT_FAIL = 164,
    ERR_CERT_BUF = 165,
    ERR_CERT_NULL = 166,
    ERR_CERT_DUEDATE = 167,
    ERR_CERT_REQUEST = 168,
 
    // PcmSend Error num
    ERR_PCMSEND_FORMAT = 200,         // unsupport pcm format
    ERR_PCMSEND_BUFFEROVERFLOW = 201, // buffer overflow, the pcm send rate too quickly
 
    // signaling: 400~600
    ERR_LOGOUT_OTHER = 400,         //
    ERR_LOGOUT_USER = 401,          // logout by user
    ERR_LOGOUT_NET = 402,           // network failure
    ERR_LOGOUT_KICKED = 403,        // login in other device
    ERR_LOGOUT_PACKET = 404,        //
    ERR_LOGOUT_TOKEN_EXPIRED = 405, // token expired
    ERR_LOGOUT_OLDVERSION = 406,    //
    ERR_LOGOUT_TOKEN_WRONG = 407,
    ERR_LOGOUT_ALREADY_LOGOUT = 408,
    ERR_LOGIN_OTHER = 420,
    ERR_LOGIN_NET = 421,
    ERR_LOGIN_FAILED = 422,
    ERR_LOGIN_CANCELED = 423,
    ERR_LOGIN_TOKEN_EXPIRED = 424,
    ERR_LOGIN_OLD_VERSION = 425,
    ERR_LOGIN_TOKEN_WRONG = 426,
    ERR_LOGIN_TOKEN_KICKED = 427,
    ERR_LOGIN_ALREADY_LOGIN = 428,
    ERR_JOIN_CHANNEL_OTHER = 440,
    ERR_SEND_MESSAGE_OTHER = 440,
    ERR_SEND_MESSAGE_TIMEOUT = 441,
    ERR_QUERY_USERNUM_OTHER = 450,
    ERR_QUERY_USERNUM_TIMEOUT = 451,
    ERR_QUERY_USERNUM_BYUSER = 452,
    ERR_LEAVE_CHANNEL_OTHER = 460,
    ERR_LEAVE_CHANNEL_KICKED = 461,
    ERR_LEAVE_CHANNEL_BYUSER = 462,
    ERR_LEAVE_CHANNEL_LOGOUT = 463,
    ERR_LEAVE_CHANNEL_DISCONNECTED = 464,
    ERR_INVITE_OTHER = 470,
    ERR_INVITE_REINVITE = 471,
    ERR_INVITE_NET = 472,
    ERR_INVITE_PEER_OFFLINE = 473,
    ERR_INVITE_TIMEOUT = 474,
    ERR_INVITE_CANT_RECV = 475,
 
    // 1001~2000
    ERR_LOAD_MEDIA_ENGINE = 1001,
    ERR_START_CALL = 1002,
    ERR_START_CAMERA = 1003,
    ERR_START_VIDEO_RENDER = 1004,
    ERR_ADM_GENERAL_ERROR = 1005,
    ERR_ADM_JAVA_RESOURCE = 1006,
    ERR_ADM_SAMPLE_RATE = 1007,
    ERR_ADM_INIT_PLAYOUT = 1008,
    ERR_ADM_START_PLAYOUT = 1009,
    ERR_ADM_STOP_PLAYOUT = 1010,
    ERR_ADM_INIT_RECORDING = 1011,
    ERR_ADM_START_RECORDING = 1012,
    ERR_ADM_STOP_RECORDING = 1013,
    ERR_ADM_RUNTIME_PLAYOUT_ERROR = 1015,
    ERR_ADM_RUNTIME_RECORDING_ERROR = 1017,
    ERR_ADM_RECORD_AUDIO_FAILED = 1018,
    ERR_ADM_INIT_LOOPBACK = 1022,
    ERR_ADM_START_LOOPBACK = 1023,
    ERR_ADM_NO_PERMISSION = 1027,
    ERR_ADM_RECORD_AUDIO_IS_ACTIVE = 1033,
    ERR_ADM_ANDROID_JNI_JAVA_RESOURCE = 1101,
    ERR_ADM_ANDROID_JNI_NO_RECORD_FREQUENCY = 1108,
    ERR_ADM_ANDROID_JNI_NO_PLAYBACK_FREQUENCY = 1109,
    ERR_ADM_ANDROID_JNI_JAVA_START_RECORD = 1111,
    ERR_ADM_ANDROID_JNI_JAVA_START_PLAYBACK = 1112,
    ERR_ADM_ANDROID_JNI_JAVA_RECORD_ERROR = 1115,
    ERR_ADM_ANDROID_OPENSL_CREATE_ENGINE = 1151,
    ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_RECORDER = 1153,
    ERR_ADM_ANDROID_OPENSL_START_RECORDER_THREAD = 1156,
    ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_PLAYER = 1157,
    ERR_ADM_ANDROID_OPENSL_START_PLAYER_THREAD = 1160,
    ERR_ADM_IOS_INPUT_NOT_AVAILABLE = 1201,
    ERR_ADM_IOS_ACTIVATE_SESSION_FAIL = 1206,
    ERR_ADM_IOS_VPIO_INIT_FAIL = 1210,
    ERR_ADM_IOS_VPIO_REINIT_FAIL = 1213,
    ERR_ADM_IOS_VPIO_RESTART_FAIL = 1214,
    ERR_ADM_IOS_SET_RENDER_CALLBACK_FAIL = 1219,
    ERR_ADM_IOS_SESSION_SAMPLERATR_ZERO = 1221,
    ERR_ADM_WIN_CORE_INIT = 1301,
    ERR_ADM_WIN_CORE_INIT_RECORDING = 1303,
    ERR_ADM_WIN_CORE_INIT_PLAYOUT = 1306,
    ERR_ADM_WIN_CORE_INIT_PLAYOUT_NULL = 1307,
    ERR_ADM_WIN_CORE_START_RECORDING = 1309,
    ERR_ADM_WIN_CORE_CREATE_REC_THREAD = 1311,
    ERR_ADM_WIN_CORE_CAPTURE_NOT_STARTUP = 1314,
    ERR_ADM_WIN_CORE_CREATE_RENDER_THREAD = 1319,
    ERR_ADM_WIN_CORE_RENDER_NOT_STARTUP = 1320,
    ERR_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
    ERR_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
    ERR_ADM_WIN_WAVE_INIT = 1351,
    ERR_ADM_WIN_WAVE_INIT_RECORDING = 1353,
    ERR_ADM_WIN_WAVE_INIT_MICROPHONE = 1354,
    ERR_ADM_WIN_WAVE_INIT_PLAYOUT = 1355,
    ERR_ADM_WIN_WAVE_INIT_SPEAKER = 1356,
    ERR_ADM_WIN_WAVE_START_RECORDING = 1357,
    ERR_ADM_WIN_WAVE_START_PLAYOUT = 1358,
    ERR_ADM_NO_RECORDING_DEVICE = 1359,
    ERR_ADM_NO_PLAYOUT_DEVICE = 1360,
 
    // VDM error code starts from 1500
    ERR_VDM_CAMERA_NOT_AUTHORIZED = 1501,
 
    // VDM error code starts from 1500
    ERR_VDM_WIN_DEVICE_IN_USE = 1502,
 
    // VCM error code starts from 1600
    ERR_VCM_UNKNOWN_ERROR = 1600,
    ERR_VCM_ENCODER_INIT_ERROR = 1601,
    ERR_VCM_ENCODER_ENCODE_ERROR = 1602,
    ERR_VCM_ENCODER_SET_ERROR = 1603,
  };
 
  enum AUDIO_SESSION_OPERATION_RESTRICTION
  {
    AUDIO_SESSION_OPERATION_RESTRICTION_NONE = 0,
    AUDIO_SESSION_OPERATION_RESTRICTION_SET_CATEGORY = 1,
    AUDIO_SESSION_OPERATION_RESTRICTION_CONFIGURE_SESSION = 1 << 1,
    AUDIO_SESSION_OPERATION_RESTRICTION_DEACTIVATE_SESSION = 1 << 2,
    AUDIO_SESSION_OPERATION_RESTRICTION_ALL = 1 << 7,
  };
  typedef const char *user_id_t;
  typedef void *view_t;
 
  struct UserInfo
  {
    util::AString userId;
    bool hasAudio;
    bool hasVideo;
 
    UserInfo() : hasAudio(false), hasVideo(false) {}
  };
 
  typedef util::AList<UserInfo> UserList;
 
  // Shared between Agora Service and Rtc Engine
  namespace rtc
  {
 
    enum USER_OFFLINE_REASON_TYPE
    {
      USER_OFFLINE_QUIT = 0,
      USER_OFFLINE_DROPPED = 1,
      USER_OFFLINE_BECOME_AUDIENCE = 2,
    };
 
    enum INTERFACE_ID_TYPE
    {
      AGORA_IID_AUDIO_DEVICE_MANAGER = 1,
      AGORA_IID_VIDEO_DEVICE_MANAGER = 2,
      AGORA_IID_PARAMETER_ENGINE = 3,
      AGORA_IID_MEDIA_ENGINE = 4,
      AGORA_IID_AUDIO_ENGINE = 5,
      AGORA_IID_VIDEO_ENGINE = 6,
      AGORA_IID_RTC_CONNECTION = 7,
      AGORA_IID_SIGNALING_ENGINE = 8,
      AGORA_IID_MEDIA_ENGINE_REGULATOR = 9,
      AGORA_IID_CLOUD_SPATIAL_AUDIO = 10,
      AGORA_IID_LOCAL_SPATIAL_AUDIO = 11,
    };
 
    enum QUALITY_TYPE
    {
      QUALITY_UNKNOWN = 0,
      QUALITY_EXCELLENT = 1,
      QUALITY_GOOD = 2,
      QUALITY_POOR = 3,
      QUALITY_BAD = 4,
      QUALITY_VBAD = 5,
      QUALITY_DOWN = 6,
 
      QUALITY_UNSUPPORTED = 7,
      QUALITY_DETECTING
    };
 
 
    enum FIT_MODE_TYPE
    {
      MODE_COVER = 1,
 
      MODE_CONTAIN = 2,
    };
 
    enum VIDEO_ORIENTATION
    {
      VIDEO_ORIENTATION_0 = 0,
      VIDEO_ORIENTATION_90 = 90,
      VIDEO_ORIENTATION_180 = 180,
      VIDEO_ORIENTATION_270 = 270
    };
 
    enum FRAME_RATE
    {
      FRAME_RATE_FPS_1 = 1,
      FRAME_RATE_FPS_7 = 7,
      FRAME_RATE_FPS_10 = 10,
      FRAME_RATE_FPS_15 = 15,
      FRAME_RATE_FPS_24 = 24,
      FRAME_RATE_FPS_30 = 30,
      FRAME_RATE_FPS_60 = 60,
    };
    enum FRAME_WIDTH
    {
      FRAME_WIDTH_640 = 640,
    };
    enum FRAME_HEIGHT
    {
      FRAME_HEIGHT_360 = 360,
    };
 
    enum VIDEO_FRAME_TYPE
    {
      VIDEO_FRAME_TYPE_BLANK_FRAME = 0,
      VIDEO_FRAME_TYPE_KEY_FRAME = 3,
      VIDEO_FRAME_TYPE_DELTA_FRAME = 4,
      VIDEO_FRAME_TYPE_B_FRAME = 5,
      VIDEO_FRAME_TYPE_DROPPABLE_FRAME = 6,
      VIDEO_FRAME_TYPE_UNKNOW
    };
 
    enum ORIENTATION_MODE
    {
      ORIENTATION_MODE_ADAPTIVE = 0,
      ORIENTATION_MODE_FIXED_LANDSCAPE = 1,
      ORIENTATION_MODE_FIXED_PORTRAIT = 2,
    };
 
    enum DEGRADATION_PREFERENCE
    {
      MAINTAIN_QUALITY = 0,
      MAINTAIN_FRAMERATE = 1,
      MAINTAIN_BALANCED = 2,
      MAINTAIN_RESOLUTION = 3,
 
      DISABLED = 100,
    };
 
    struct VideoDimensions
    {
      int width;
      int height;
      VideoDimensions() : width(640), height(480) {}
      VideoDimensions(int w, int h) : width(w), height(h) {}
      bool operator==(const VideoDimensions &rhs) const
      {
        return width == rhs.width && height == rhs.height;
      }
    };
 
    const int STANDARD_BITRATE = 0;
 
    const int COMPATIBLE_BITRATE = -1;
 
    const int DEFAULT_MIN_BITRATE = -1;
 
    const int DEFAULT_MIN_BITRATE_EQUAL_TO_TARGET_BITRATE = -2;
 
    enum VIDEO_CODEC_TYPE
    {
      VIDEO_CODEC_NONE = 0,
      VIDEO_CODEC_VP8 = 1,
      VIDEO_CODEC_H264 = 2,
      VIDEO_CODEC_H265 = 3,
      VIDEO_CODEC_VP9 = 5,
      VIDEO_CODEC_GENERIC = 6,
      VIDEO_CODEC_GENERIC_H264 = 7,
      VIDEO_CODEC_AV1 = 12,
      VIDEO_CODEC_GENERIC_JPEG = 20,
    };
 
    enum AUDIO_CODEC_TYPE
    {
      AUDIO_CODEC_OPUS = 1,
      // kIsac = 2,
      AUDIO_CODEC_PCMA = 3,
      AUDIO_CODEC_PCMU = 4,
      AUDIO_CODEC_G722 = 5,
      // kIlbc = 6,
      // AUDIO_CODEC_AAC = 7,
      AUDIO_CODEC_AACLC = 8,
      AUDIO_CODEC_HEAAC = 9,
 
      AUDIO_CODEC_JC1 = 10,
 
      AUDIO_CODEC_HEAAC2 = 11,
 
      AUDIO_CODEC_LPCNET = 12,
    };
 
 
    enum AUDIO_ENCODING_TYPE
    {
      AUDIO_ENCODING_TYPE_AAC_16000_LOW = 0x010101,
      AUDIO_ENCODING_TYPE_AAC_16000_MEDIUM = 0x010102,
      AUDIO_ENCODING_TYPE_AAC_32000_LOW = 0x010201,
      AUDIO_ENCODING_TYPE_AAC_32000_MEDIUM = 0x010202,
      AUDIO_ENCODING_TYPE_AAC_32000_HIGH = 0x010203,
      AUDIO_ENCODING_TYPE_AAC_48000_MEDIUM = 0x010302,
      AUDIO_ENCODING_TYPE_AAC_48000_HIGH = 0x010303,
 
      AUDIO_ENCODING_TYPE_OPUS_16000_LOW = 0x020101,
      AUDIO_ENCODING_TYPE_OPUS_16000_MEDIUM = 0x020102,
      AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM = 0x020302,
      AUDIO_ENCODING_TYPE_OPUS_48000_HIGH = 0x020303,
    };
 
    enum WATERMARK_FIT_MODE
    {
      FIT_MODE_COVER_POSITION,
      FIT_MODE_USE_IMAGE_RATIO
    };
 
    struct EncodedAudioFrameAdvancedSettings
    {
      EncodedAudioFrameAdvancedSettings()
          : speech(true),
            sendEvenIfEmpty(true) {}
 
      bool speech;
      bool sendEvenIfEmpty;
    };
 
    struct EncodedAudioFrameInfo
    {
      EncodedAudioFrameInfo()
          : codec(AUDIO_CODEC_AACLC),
            sampleRateHz(0),
            samplesPerChannel(0),
            numberOfChannels(0),
            captureTimeMs(0) {}
 
      EncodedAudioFrameInfo(const EncodedAudioFrameInfo &rhs)
          : codec(rhs.codec),
            sampleRateHz(rhs.sampleRateHz),
            samplesPerChannel(rhs.samplesPerChannel),
            numberOfChannels(rhs.numberOfChannels),
            advancedSettings(rhs.advancedSettings),
            captureTimeMs(rhs.captureTimeMs) {}
      AUDIO_CODEC_TYPE codec;
      int sampleRateHz;
      int samplesPerChannel;
      int numberOfChannels;
      EncodedAudioFrameAdvancedSettings advancedSettings;
      int64_t captureTimeMs;
    };
 
    struct AudioPcmDataInfo
    {
      AudioPcmDataInfo() : samplesPerChannel(0), channelNum(0), samplesOut(0), elapsedTimeMs(0), ntpTimeMs(0) {}
 
      AudioPcmDataInfo(const AudioPcmDataInfo &rhs)
          : samplesPerChannel(rhs.samplesPerChannel),
            channelNum(rhs.channelNum),
            samplesOut(rhs.samplesOut),
            elapsedTimeMs(rhs.elapsedTimeMs),
            ntpTimeMs(rhs.ntpTimeMs) {}
 
      size_t samplesPerChannel;
 
      int16_t channelNum;
 
      // Output
      size_t samplesOut;
      int64_t elapsedTimeMs;
      int64_t ntpTimeMs;
    };
    enum H264PacketizeMode
    {
      NonInterleaved = 0, // Mode 1 - STAP-A, FU-A is allowed
      SingleNalUnit, // Mode 0 - only single NALU allowed
    };
 
    enum VIDEO_STREAM_TYPE
    {
      VIDEO_STREAM_HIGH = 0,
      VIDEO_STREAM_LOW = 1,
    };
    struct VideoSubscriptionOptions
    {
      VIDEO_STREAM_TYPE type;
      bool encodedFrameOnly;
 
      VideoSubscriptionOptions() : type(VIDEO_STREAM_HIGH),
                                   encodedFrameOnly(false) {}
 
      explicit VideoSubscriptionOptions(VIDEO_STREAM_TYPE streamtype) : type(streamtype),
                                                                        encodedFrameOnly(false) {}
 
      VideoSubscriptionOptions(VIDEO_STREAM_TYPE streamtype, bool encoded_only) : type(streamtype),
                                                                                  encodedFrameOnly(encoded_only) {}
    };
 
    struct EncodedVideoFrameInfo
    {
      EncodedVideoFrameInfo()
          : codecType(VIDEO_CODEC_H264),
            width(0),
            height(0),
            framesPerSecond(0),
            frameType(VIDEO_FRAME_TYPE_BLANK_FRAME),
            rotation(VIDEO_ORIENTATION_0),
            trackId(0),
            captureTimeMs(0),
            decodeTimeMs(0),
            uid(0),
            streamType(VIDEO_STREAM_HIGH) {}
 
      EncodedVideoFrameInfo(const EncodedVideoFrameInfo &rhs)
          : codecType(rhs.codecType),
            width(rhs.width),
            height(rhs.height),
            framesPerSecond(rhs.framesPerSecond),
            frameType(rhs.frameType),
            rotation(rhs.rotation),
            trackId(rhs.trackId),
            captureTimeMs(rhs.captureTimeMs),
            decodeTimeMs(rhs.decodeTimeMs),
            uid(rhs.uid),
            streamType(rhs.streamType) {}
 
      EncodedVideoFrameInfo &operator=(const EncodedVideoFrameInfo &rhs)
      {
        if (this == &rhs)
          return *this;
        codecType = rhs.codecType;
        width = rhs.width;
        height = rhs.height;
        framesPerSecond = rhs.framesPerSecond;
        frameType = rhs.frameType;
        rotation = rhs.rotation;
        trackId = rhs.trackId;
        captureTimeMs = rhs.captureTimeMs;
        decodeTimeMs = rhs.decodeTimeMs;
        uid = rhs.uid;
        streamType = rhs.streamType;
        return *this;
      }
      VIDEO_CODEC_TYPE codecType;
      int width;
      int height;
      int framesPerSecond;
      VIDEO_FRAME_TYPE frameType;
      VIDEO_ORIENTATION rotation;
      int trackId; // This can be reserved for multiple video tracks, we need to create different ssrc
                   // and additional payload for later implementation.
 
      int64_t captureTimeMs;
      int64_t decodeTimeMs;
      uid_t uid;
      VIDEO_STREAM_TYPE streamType;
    };
 
    enum VIDEO_MIRROR_MODE_TYPE
    {
      VIDEO_MIRROR_MODE_AUTO = 0,
      VIDEO_MIRROR_MODE_ENABLED = 1,
      VIDEO_MIRROR_MODE_DISABLED = 2,
    };
 
    struct VideoEncoderConfiguration
    {
      VIDEO_CODEC_TYPE codecType;
      VideoDimensions dimensions;
      int frameRate;
      int bitrate;
 
      int minBitrate;
      ORIENTATION_MODE orientationMode;
      DEGRADATION_PREFERENCE degradationPreference;
 
      VIDEO_MIRROR_MODE_TYPE mirrorMode;
 
      VideoEncoderConfiguration(const VideoDimensions &d, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
          : codecType(VIDEO_CODEC_H264),
            dimensions(d),
            frameRate(f),
            bitrate(b),
            minBitrate(DEFAULT_MIN_BITRATE),
            orientationMode(m),
            degradationPreference(MAINTAIN_QUALITY),
            mirrorMode(mirror) {}
      VideoEncoderConfiguration(int width, int height, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
          : codecType(VIDEO_CODEC_H264),
            dimensions(width, height),
            frameRate(f),
            bitrate(b),
            minBitrate(DEFAULT_MIN_BITRATE),
            orientationMode(m),
            degradationPreference(MAINTAIN_QUALITY),
            mirrorMode(mirror) {}
      VideoEncoderConfiguration(const VideoEncoderConfiguration &config)
          : codecType(config.codecType),
            dimensions(config.dimensions),
            frameRate(config.frameRate),
            bitrate(config.bitrate),
            minBitrate(config.minBitrate),
            orientationMode(config.orientationMode),
            degradationPreference(config.degradationPreference),
            mirrorMode(config.mirrorMode) {}
      VideoEncoderConfiguration()
          : codecType(VIDEO_CODEC_H264),
            dimensions(FRAME_WIDTH_640, FRAME_HEIGHT_360),
            frameRate(FRAME_RATE_FPS_15),
            bitrate(STANDARD_BITRATE),
            minBitrate(DEFAULT_MIN_BITRATE),
            orientationMode(ORIENTATION_MODE_ADAPTIVE),
            degradationPreference(MAINTAIN_QUALITY),
            mirrorMode(VIDEO_MIRROR_MODE_DISABLED) {}
 
      VideoEncoderConfiguration &operator=(const VideoEncoderConfiguration &rhs)
      {
        if (this == &rhs)
          return *this;
        codecType = rhs.codecType;
        dimensions = rhs.dimensions;
        frameRate = rhs.frameRate;
        bitrate = rhs.bitrate;
        minBitrate = rhs.minBitrate;
        orientationMode = rhs.orientationMode;
        degradationPreference = rhs.degradationPreference;
        mirrorMode = rhs.mirrorMode;
        return *this;
      }
    };
 
    struct DataStreamConfig
    {
      bool syncWithAudio;
      bool ordered;
    };
 
    enum SIMULCAST_STREAM_MODE
    {
      AUTO_SIMULCAST_STREAM = -1,
      DISABLE_SIMULCAST_STREAM = 0,
      ENABLE_SIMULCAST_STREAM = 1,
    };
 
    struct SimulcastStreamConfig
    {
      VideoDimensions dimensions;
      int bitrate;
      int framerate;
      SimulcastStreamConfig() : dimensions(160, 120), bitrate(65), framerate(5) {}
      bool operator==(const SimulcastStreamConfig &rhs) const
      {
        return dimensions == rhs.dimensions && bitrate == rhs.bitrate && framerate == rhs.framerate;
      }
    };
 
    struct RtcStats
    {
      unsigned int duration;
      unsigned int txBytes;
      unsigned int rxBytes;
      unsigned int txAudioBytes;
      unsigned int txVideoBytes;
      unsigned int rxAudioBytes;
      unsigned int rxVideoBytes;
      unsigned short txKBitRate;
      unsigned short rxKBitRate;
      unsigned short rxAudioKBitRate;
      unsigned short txAudioKBitRate;
      unsigned short rxVideoKBitRate;
      unsigned short txVideoKBitRate;
      unsigned short lastmileDelay;
      unsigned int userCount;
      double cpuAppUsage;
      double cpuTotalUsage;
      int gatewayRtt;
      double memoryAppUsageRatio;
      double memoryTotalUsageRatio;
      int memoryAppUsageInKbytes;
      int connectTimeMs;
      int firstAudioPacketDuration;
      int firstVideoPacketDuration;
      int firstVideoKeyFramePacketDuration;
      int packetsBeforeFirstKeyFramePacket;
      int firstAudioPacketDurationAfterUnmute;
      int firstVideoPacketDurationAfterUnmute;
      int firstVideoKeyFramePacketDurationAfterUnmute;
      int firstVideoKeyFrameDecodedDurationAfterUnmute;
      int firstVideoKeyFrameRenderedDurationAfterUnmute;
      int txPacketLossRate;
      int rxPacketLossRate;
      RtcStats()
          : duration(0),
            txBytes(0),
            rxBytes(0),
            txAudioBytes(0),
            txVideoBytes(0),
            rxAudioBytes(0),
            rxVideoBytes(0),
            txKBitRate(0),
            rxKBitRate(0),
            rxAudioKBitRate(0),
            txAudioKBitRate(0),
            rxVideoKBitRate(0),
            txVideoKBitRate(0),
            lastmileDelay(0),
            userCount(0),
            cpuAppUsage(0.0),
            cpuTotalUsage(0.0),
            gatewayRtt(0),
            memoryAppUsageRatio(0.0),
            memoryTotalUsageRatio(0.0),
            memoryAppUsageInKbytes(0),
            connectTimeMs(0),
            firstAudioPacketDuration(0),
            firstVideoPacketDuration(0),
            firstVideoKeyFramePacketDuration(0),
            packetsBeforeFirstKeyFramePacket(0),
            firstAudioPacketDurationAfterUnmute(0),
            firstVideoPacketDurationAfterUnmute(0),
            firstVideoKeyFramePacketDurationAfterUnmute(0),
            firstVideoKeyFrameDecodedDurationAfterUnmute(0),
            firstVideoKeyFrameRenderedDurationAfterUnmute(0),
            txPacketLossRate(0),
            rxPacketLossRate(0) {}
    };
 
    enum VIDEO_SOURCE_TYPE
    {
      VIDEO_SOURCE_CAMERA_PRIMARY,
 
      VIDEO_SOURCE_CAMERA = VIDEO_SOURCE_CAMERA_PRIMARY,
      VIDEO_SOURCE_CAMERA_SECONDARY,
      VIDEO_SOURCE_SCREEN_PRIMARY,
      VIDEO_SOURCE_SCREEN = VIDEO_SOURCE_SCREEN_PRIMARY,
      VIDEO_SOURCE_SCREEN_SECONDARY,
      VIDEO_SOURCE_CUSTOM,
      VIDEO_SOURCE_MEDIA_PLAYER,
      VIDEO_SOURCE_RTC_IMAGE_PNG,
      VIDEO_SOURCE_RTC_IMAGE_JPEG,
      VIDEO_SOURCE_RTC_IMAGE_GIF,
      VIDEO_SOURCE_REMOTE,
      VIDEO_SOURCE_TRANSCODED,
      VIDEO_SOURCE_UNKNOWN = 100
    };
 
    enum CLIENT_ROLE_TYPE
    {
      CLIENT_ROLE_BROADCASTER = 1,
      CLIENT_ROLE_AUDIENCE = 2,
    };
 
    enum QUALITY_ADAPT_INDICATION
    {
      ADAPT_NONE = 0,
      ADAPT_UP_BANDWIDTH = 1,
      ADAPT_DOWN_BANDWIDTH = 2,
    };
 
    enum EXPERIENCE_QUALITY_TYPE
    {
      EXPERIENCE_QUALITY_GOOD = 0,
      EXPERIENCE_QUALITY_BAD = 1,
    };
 
    enum EXPERIENCE_POOR_REASON
    {
      EXPERIENCE_REASON_NONE = 0,
      REMOTE_NETWORK_QUALITY_POOR = 1,
      LOCAL_NETWORK_QUALITY_POOR = 2,
      WIRELESS_SIGNAL_POOR = 4,
      WIFI_BLUETOOTH_COEXIST = 8,
    };
 
 
    enum AUDIENCE_LATENCY_LEVEL_TYPE
    {
      AUDIENCE_LATENCY_LEVEL_LOW_LATENCY = 1,
      AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY = 2,
      AUDIENCE_LATENCY_LEVEL_HIGH_LATENCY = 3,
    };
 
    struct ClientRoleOptions
    {
      AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel;
      ClientRoleOptions()
          : audienceLatencyLevel(AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY) {}
    };
 
    struct RemoteAudioStats
    {
      uid_t uid;
      int quality;
      int networkTransportDelay;
      int jitterBufferDelay;
      int audioLossRate;
      int numChannels;
      int receivedSampleRate;
      int receivedBitrate;
      int totalFrozenTime;
      int frozenRate;
      int mosValue;
      int totalActiveTime;
      int publishDuration;
 
      RemoteAudioStats() : uid(0),
                           quality(0),
                           networkTransportDelay(0),
                           jitterBufferDelay(0),
                           audioLossRate(0),
                           numChannels(0),
                           receivedSampleRate(0),
                           receivedBitrate(0),
                           totalFrozenTime(0),
                           frozenRate(0),
                           mosValue(0),
                           totalActiveTime(0),
                           publishDuration(0) {}
    };
 
    enum AUDIO_PROFILE_TYPE
    {
      AUDIO_SCENARIO_DEFAULT = 0,
      AUDIO_SCENARIO_GAME_STREAMING = 3,
      AUDIO_SCENARIO_CHATROOM = 5,
      AUDIO_SCENARIO_CHORUS = 7,
      AUDIO_SCENARIO_MEETING = 8,
      AUDIO_SCENARIO_NUM = 9,
    };
 
    enum AUDIO_SCENARIO_TYPE
    {
      AUDIO_SCENARIO_DEFAULT = 0,
      AUDIO_SCENARIO_GAME_STREAMING = 3,
      AUDIO_SCENARIO_CHATROOM = 5,
      AUDIO_SCENARIO_HIGH_DEFINITION = 6,
      AUDIO_SCENARIO_CHORUS = 7,
      AUDIO_SCENARIO_NUM = 8,
    };
 
 
    struct VideoFormat
    {
      OPTIONAL_ENUM_SIZE_T{
          kMaxWidthInPixels = 3840,
          kMaxHeightInPixels = 2160,
          kMaxFps = 60,
      };
 
      int width; // Number of pixels.
      int height; // Number of pixels.
      int fps;
 
      uint32_t pixelFormat;
 
      VideoFormat() : width(FRAME_WIDTH_640), height(FRAME_HEIGHT_360), fps(FRAME_RATE_FPS_15), pixelFormat(0) {}
      VideoFormat(int w, int h, int f, uint32_t fmt = 0) : width(w), height(h), fps(f), pixelFormat(fmt) {}
    };
 
 
    enum VIDEO_CONTENT_HINT
    {
      CONTENT_HINT_NONE,
      CONTENT_HINT_MOTION,
      CONTENT_HINT_DETAILS
    };
 
    enum LOCAL_AUDIO_STREAM_STATE
    {
      LOCAL_AUDIO_STREAM_STATE_STOPPED = 0,
      LOCAL_AUDIO_STREAM_STATE_RECORDING = 1,
      LOCAL_AUDIO_STREAM_STATE_ENCODING = 2,
      LOCAL_AUDIO_STREAM_STATE_FAILED = 3
    };
 
    enum LOCAL_AUDIO_STREAM_ERROR
    {
      LOCAL_AUDIO_STREAM_ERROR_OK = 0,
      LOCAL_AUDIO_STREAM_ERROR_FAILURE = 1,
      LOCAL_AUDIO_STREAM_ERROR_DEVICE_NO_PERMISSION = 2,
      LOCAL_AUDIO_STREAM_ERROR_DEVICE_BUSY = 3,
      LOCAL_AUDIO_STREAM_ERROR_RECORD_FAILURE = 4,
      LOCAL_AUDIO_STREAM_ERROR_ENCODE_FAILURE = 5
    };
 
    enum LOCAL_VIDEO_STREAM_STATE
    {
      LOCAL_VIDEO_STREAM_STATE_STOPPED = 0,
      LOCAL_VIDEO_STREAM_STATE_CAPTURING = 1,
      LOCAL_VIDEO_STREAM_STATE_ENCODING = 2,
      LOCAL_VIDEO_STREAM_STATE_FAILED = 3
    };
 
    enum LOCAL_VIDEO_STREAM_ERROR
    {
      LOCAL_VIDEO_STREAM_ERROR_OK = 0,
      LOCAL_VIDEO_STREAM_ERROR_FAILURE = 1,
      LOCAL_VIDEO_STREAM_ERROR_DEVICE_NO_PERMISSION = 2,
      LOCAL_VIDEO_STREAM_ERROR_DEVICE_BUSY = 3,
      LOCAL_VIDEO_STREAM_ERROR_CAPTURE_FAILURE = 4,
      LOCAL_VIDEO_STREAM_ERROR_ENCODE_FAILURE = 5,
 
      LOCAL_VIDEO_STREAM_ERROR_BACKGROUD = 6,
      LOCAL_VIDEO_STREAM_ERROR_MULTIPLE_FOREGROUND_APPS = 7,
      LOCAL_VIDEO_STREAM_ERROR_SYSTEM_PRESSURE = 8,
      LOCAL_VIDEO_STREAM_ERROR_SCREEN_CAPTURE_WINDOW_MINIMIZED = 11,
      LOCAL_VIDEO_STREAM_ERROR_SCREEN_CAPTURE_WINDOW_CLOSED = 12
    };
 
    enum REMOTE_AUDIO_STATE
    {
      REMOTE_AUDIO_STATE_STOPPED = 0, // Default state, audio is started or remote user disabled/muted audio stream
      REMOTE_AUDIO_STATE_STARTING = 1, // The first audio frame packet has been received
      REMOTE_AUDIO_STATE_DECODING = 2, // The first remote audio frame has been decoded or frozen state ends
      REMOTE_AUDIO_STATE_FROZEN = 3, // Remote audio is frozen, probably due to network issue
      REMOTE_AUDIO_STATE_FAILED = 4, // Remote audio play failed
    };
 
    enum REMOTE_AUDIO_STATE_REASON
    {
      REMOTE_AUDIO_REASON_INTERNAL = 0,
      REMOTE_AUDIO_REASON_NETWORK_CONGESTION = 1,
      REMOTE_AUDIO_REASON_NETWORK_RECOVERY = 2,
      REMOTE_AUDIO_REASON_LOCAL_MUTED = 3,
      REMOTE_AUDIO_REASON_LOCAL_UNMUTED = 4,
      REMOTE_AUDIO_REASON_REMOTE_MUTED = 5,
      REMOTE_AUDIO_REASON_REMOTE_UNMUTED = 6,
      REMOTE_AUDIO_REASON_REMOTE_OFFLINE = 7,
    };
 
    enum REMOTE_VIDEO_STATE
    {
      REMOTE_VIDEO_STATE_STOPPED = 0,
      REMOTE_VIDEO_STATE_STARTING = 1,
      REMOTE_VIDEO_STATE_DECODING = 2,
      REMOTE_VIDEO_STATE_FROZEN = 3,
      REMOTE_VIDEO_STATE_FAILED = 4,
    };
    enum REMOTE_VIDEO_STATE_REASON
    {
      REMOTE_VIDEO_STATE_REASON_INTERNAL = 0,
 
      REMOTE_VIDEO_STATE_REASON_NETWORK_CONGESTION = 1,
 
      REMOTE_VIDEO_STATE_REASON_NETWORK_RECOVERY = 2,
 
      REMOTE_VIDEO_STATE_REASON_LOCAL_MUTED = 3,
 
      REMOTE_VIDEO_STATE_REASON_LOCAL_UNMUTED = 4,
 
      REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED = 5,
 
      REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED = 6,
 
      REMOTE_VIDEO_STATE_REASON_REMOTE_OFFLINE = 7,
 
      REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK = 8,
 
      REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK_RECOVERY = 9,
 
      REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_LOW = 10,
      REMOTE_VIDEO_STATE_REASON_VIDEO_STREAM_TYPE_CHANGE_TO_HIGH = 11,
    };
 
    struct VideoTrackInfo
    {
      VideoTrackInfo()
          : isLocal(false), ownerUid(0), trackId(0), channelId(OPTIONAL_NULLPTR), streamType(VIDEO_STREAM_HIGH), codecType(VIDEO_CODEC_H264), encodedFrameOnly(false), sourceType(VIDEO_SOURCE_CAMERA_PRIMARY), observationPosition(agora::media::base::POSITION_POST_CAPTURER) {}
      bool isLocal;
      uid_t ownerUid;
 
      track_id_t trackId;
      const char *channelId;
      VIDEO_STREAM_TYPE streamType;
      VIDEO_CODEC_TYPE codecType;
      bool encodedFrameOnly;
      VIDEO_SOURCE_TYPE sourceType;
 
      uint32_t observationPosition;
    };
 
    enum REMOTE_VIDEO_DOWNSCALE_LEVEL
    {
      REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE,
      REMOTE_VIDEO_DOWNSCALE_LEVEL_1,
      REMOTE_VIDEO_DOWNSCALE_LEVEL_2,
      REMOTE_VIDEO_DOWNSCALE_LEVEL_3,
      REMOTE_VIDEO_DOWNSCALE_LEVEL_4,
    };
 
    struct AudioVolumeInfo
    {
      uid_t uid;
 
      unsigned int volume; // [0,255]
 
      /*
       * The activity status of remote users
       */
      unsigned int vad;
 
      double voicePitch;
 
      AudioVolumeInfo() : uid(0), volume(0), vad(0), voicePitch(0.0) {}
    };
 
    class IPacketObserver
    {
    public:
      virtual ~IPacketObserver() {}
      struct Packet
      {
        const unsigned char *buffer;
        unsigned int size;
 
        Packet() : buffer(NULL), size(0) {}
      };
      virtual bool onSendAudioPacket(Packet &packet) = 0;
      virtual bool onSendVideoPacket(Packet &packet) = 0;
      virtual bool onReceiveAudioPacket(Packet &packet) = 0;
      virtual bool onReceiveVideoPacket(Packet &packet) = 0;
    };
 
    class IVideoEncodedImageReceiver
    {
    public:
      virtual bool OnEncodedVideoImageReceived(const uint8_t *imageBuffer, size_t length,
                                               const EncodedVideoFrameInfo &videoEncodedFrameInfo) = 0;
 
      virtual ~IVideoEncodedImageReceiver() {}
    };
 
    enum AUDIO_SAMPLE_RATE_TYPE
    {
      AUDIO_SAMPLE_RATE_32000 = 32000,
      AUDIO_SAMPLE_RATE_44100 = 44100,
      AUDIO_SAMPLE_RATE_48000 = 48000,
    };
    enum VIDEO_CODEC_PROFILE_TYPE
    {
      VIDEO_CODEC_PROFILE_BASELINE = 66,
      VIDEO_CODEC_PROFILE_MAIN = 77,
      VIDEO_CODEC_PROFILE_HIGH = 100,
    };
 
    enum AUDIO_CODEC_PROFILE_TYPE
    {
      AUDIO_CODEC_PROFILE_LC_AAC = 0,
      AUDIO_CODEC_PROFILE_HE_AAC = 1,
    };
 
    struct LocalAudioStats
    {
      int numChannels;
      int sentSampleRate;
      int sentBitrate;
 
      int internalCodec;
    };
 
 
    enum RTMP_STREAM_PUBLISH_STATE
    {
      RTMP_STREAM_PUBLISH_STATE_IDLE = 0,
      RTMP_STREAM_PUBLISH_STATE_CONNECTING = 1,
      RTMP_STREAM_PUBLISH_STATE_RUNNING = 2,
      RTMP_STREAM_PUBLISH_STATE_RECOVERING = 3,
      RTMP_STREAM_PUBLISH_STATE_FAILURE = 4,
    };
 
    enum RTMP_STREAM_PUBLISH_ERROR
    {
      RTMP_STREAM_PUBLISH_ERROR_FAILED = -1,
      RTMP_STREAM_PUBLISH_ERROR_OK = 0,
      RTMP_STREAM_PUBLISH_ERROR_INVALID_ARGUMENT = 1,
      RTMP_STREAM_PUBLISH_ERROR_ENCRYPTED_STREAM_NOT_ALLOWED = 2,
      RTMP_STREAM_PUBLISH_ERROR_CONNECTION_TIMEOUT = 3,
      RTMP_STREAM_PUBLISH_ERROR_INTERNAL_SERVER_ERROR = 4,
      RTMP_STREAM_PUBLISH_ERROR_RTMP_SERVER_ERROR = 5,
      RTMP_STREAM_PUBLISH_ERROR_TOO_OFTEN = 6,
      RTMP_STREAM_PUBLISH_ERROR_REACH_LIMIT = 7,
      RTMP_STREAM_PUBLISH_ERROR_NOT_AUTHORIZED = 8,
      RTMP_STREAM_PUBLISH_ERROR_STREAM_NOT_FOUND = 9,
      RTMP_STREAM_PUBLISH_ERROR_FORMAT_NOT_SUPPORTED = 10,
      RTMP_STREAM_PUBLISH_ERROR_CDN_ERROR = 11,
      RTMP_STREAM_PUBLISH_ERROR_ALREADY_IN_USE = 12,
      RTMP_STREAM_UNPUBLISH_ERROR_OK = 100,
    };
 
    enum CONNECTION_STATE_TYPE
    {
      CONNECTION_STATE_DISCONNECTED = 1,
      CONNECTION_STATE_CONNECTING = 2,
      CONNECTION_STATE_CONNECTED = 3,
      CONNECTION_STATE_RECONNECTING = 4,
      CONNECTION_STATE_FAILED = 5,
    };
 
    struct LastmileProbeConfig
    {
      bool probeUplink;
      bool probeDownlink;
      unsigned int expectedUplinkBitrate;
      unsigned int expectedDownlinkBitrate;
    };
 
    enum LASTMILE_PROBE_RESULT_STATE
    {
      LASTMILE_PROBE_RESULT_COMPLETE = 1,
      LASTMILE_PROBE_RESULT_INCOMPLETE_NO_BWE = 2,
      LASTMILE_PROBE_RESULT_UNAVAILABLE = 3
    };
 
    struct LastmileProbeOneWayResult
    {
      unsigned int packetLossRate;
      unsigned int jitter;
      unsigned int availableBandwidth;
 
      LastmileProbeOneWayResult() : packetLossRate(0),
                                    jitter(0),
                                    availableBandwidth(0) {}
    };
 
    struct LastmileProbeResult
    {
      LASTMILE_PROBE_RESULT_STATE state;
      LastmileProbeOneWayResult uplinkReport;
      LastmileProbeOneWayResult downlinkReport;
      unsigned int rtt;
 
      LastmileProbeResult()
          : state(LASTMILE_PROBE_RESULT_UNAVAILABLE),
            rtt(0) {}
    };
 
    enum CONNECTION_CHANGED_REASON_TYPE
    {
      CONNECTION_CHANGED_CONNECTING = 0,
      CONNECTION_CHANGED_JOIN_SUCCESS = 1,
      CONNECTION_CHANGED_INTERRUPTED = 2,
      CONNECTION_CHANGED_BANNED_BY_SERVER = 3,
      CONNECTION_CHANGED_JOIN_FAILED = 4,
      CONNECTION_CHANGED_LEAVE_CHANNEL = 5,
      CONNECTION_CHANGED_INVALID_APP_ID = 6,
      CONNECTION_CHANGED_INVALID_CHANNEL_NAME = 7,
      CONNECTION_CHANGED_INVALID_TOKEN = 8,
      CONNECTION_CHANGED_TOKEN_EXPIRED = 9,
      CONNECTION_CHANGED_REJECTED_BY_SERVER = 10,
      CONNECTION_CHANGED_SETTING_PROXY_SERVER = 11,
      CONNECTION_CHANGED_RENEW_TOKEN = 12,
      CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED = 13,
      CONNECTION_CHANGED_KEEP_ALIVE_TIMEOUT = 14,
      CONNECTION_CHANGED_REJOIN_SUCCESS = 15,
      CONNECTION_CHANGED_LOST = 16,
      CONNECTION_CHANGED_ECHO_TEST = 17,
      CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED_BY_USER = 18,
    };
 
    enum NETWORK_TYPE
    {
      NETWORK_TYPE_UNKNOWN = -1,
      NETWORK_TYPE_DISCONNECTED = 0,
      NETWORK_TYPE_LAN = 1,
      NETWORK_TYPE_WIFI = 2,
      NETWORK_TYPE_MOBILE_2G = 3,
      NETWORK_TYPE_MOBILE_3G = 4,
      NETWORK_TYPE_MOBILE_4G = 5,
    };
 
    struct BeautyOptions
    {
      enum LIGHTENING_CONTRAST_LEVEL
      {
        LIGHTENING_CONTRAST_LOW = 0,
        LIGHTENING_CONTRAST_NORMAL,
        LIGHTENING_CONTRAST_HIGH
      };
 
      LIGHTENING_CONTRAST_LEVEL lighteningContrastLevel;
 
      float lighteningLevel;
 
      float smoothnessLevel;
 
      float rednessLevel;
 
      float sharpnessLevel;
 
      BeautyOptions(LIGHTENING_CONTRAST_LEVEL contrastLevel, float lightening, float smoothness, float redness, float sharpness) : lighteningContrastLevel(contrastLevel), lighteningLevel(lightening), smoothnessLevel(smoothness), rednessLevel(redness), sharpnessLevel(sharpness) {}
 
      BeautyOptions() : lighteningContrastLevel(LIGHTENING_CONTRAST_NORMAL), lighteningLevel(0), smoothnessLevel(0), rednessLevel(0), sharpnessLevel(0) {}
    };
 
    struct VirtualBackgroundSource
    {
      enum BACKGROUND_SOURCE_TYPE
      {
        BACKGROUND_COLOR = 1,
        BACKGROUND_IMG,
        BACKGROUND_BLUR,
      };
 
      enum BACKGROUND_BLUR_DEGREE
      {
        BLUR_DEGREE_LOW = 1,
        BLUR_DEGREE_MEDIUM,
        BLUR_DEGREE_HIGH,
      };
 
      BACKGROUND_SOURCE_TYPE background_source_type;
 
      unsigned int color;
 
      const char *source;
 
      BACKGROUND_BLUR_DEGREE blur_degree;
 
      VirtualBackgroundSource() : background_source_type(BACKGROUND_COLOR), color(0xffffff), source(NULL), blur_degree(BLUR_DEGREE_HIGH) {}
    };
 
    struct SegmentationProperty
    {
 
      enum SEG_MODEL_TYPE
      {
 
        SEG_MODEL_AGORA_AI_ONE = 0,
        SEG_MODEL_AGORA_GREEN = 2
      };
 
      SEG_MODEL_TYPE modelType;
 
      int preferVelocity;
 
      float greenCapacity;
 
      SegmentationProperty() : modelType(SEG_MODEL_AGORA_AI_ONE), preferVelocity(1), greenCapacity(0.5) {}
    };
 
    enum VOICE_BEAUTIFIER_PRESET
    {
      VOICE_BEAUTIFIER_OFF = 0x00000000,
      CHAT_BEAUTIFIER_MAGNETIC = 0x01010100,
      CHAT_BEAUTIFIER_FRESH = 0x01010200,
      CHAT_BEAUTIFIER_VITALITY = 0x01010300,
      SINGING_BEAUTIFIER = 0x01020100,
      TIMBRE_TRANSFORMATION_VIGOROUS = 0x01030100,
      TIMBRE_TRANSFORMATION_DEEP = 0x01030200,
      TIMBRE_TRANSFORMATION_MELLOW = 0x01030300,
      TIMBRE_TRANSFORMATION_FALSETTO = 0x01030400,
      TIMBRE_TRANSFORMATION_FULL = 0x01030500,
      TIMBRE_TRANSFORMATION_CLEAR = 0x01030600,
      TIMBRE_TRANSFORMATION_RESOUNDING = 0x01030700,
      TIMBRE_TRANSFORMATION_RINGING = 0x01030800,
 
      ULTRA_HIGH_QUALITY_VOICE = 0x01040100
    };
 
    enum AUDIO_EFFECT_PRESET
    {
      AUDIO_EFFECT_OFF = 0x00000000,
      ROOM_ACOUSTICS_KTV = 0x02010100,
      ROOM_ACOUSTICS_VOCAL_CONCERT = 0x02010200,
      ROOM_ACOUSTICS_STUDIO = 0x02010300,
      ROOM_ACOUSTICS_PHONOGRAPH = 0x02010400,
      ROOM_ACOUSTICS_VIRTUAL_STEREO = 0x02010500,
      ROOM_ACOUSTICS_SPACIAL = 0x02010600,
      ROOM_ACOUSTICS_ETHEREAL = 0x02010700,
      ROOM_ACOUSTICS_3D_VOICE = 0x02010800,
      VOICE_CHANGER_EFFECT_UNCLE = 0x02020100,
      VOICE_CHANGER_EFFECT_OLDMAN = 0x02020200,
      VOICE_CHANGER_EFFECT_BOY = 0x02020300,
      VOICE_CHANGER_EFFECT_SISTER = 0x02020400,
      VOICE_CHANGER_EFFECT_GIRL = 0x02020500,
      VOICE_CHANGER_EFFECT_PIGKING = 0x02020600,
      VOICE_CHANGER_EFFECT_HULK = 0x02020700,
      STYLE_TRANSFORMATION_RNB = 0x02030100,
      STYLE_TRANSFORMATION_POPULAR = 0x02030200,
      PITCH_CORRECTION = 0x02040100
 
    };
 
    enum VOICE_CONVERSION_PRESET
    {
      VOICE_CONVERSION_OFF = 0x00000000,
      VOICE_CHANGER_NEUTRAL = 0x03010100,
      VOICE_CHANGER_SWEET = 0x03010200,
      VOICE_CHANGER_SOLID = 0x03010300,
      VOICE_CHANGER_BASS = 0x03010400
    };
 
    // TODO(ZYH), it will be deleted after the new interfaces have been implemented to replace it.
    enum AUDIO_REVERB_PRESET
    {
      AUDIO_REVERB_OFF = 0, // Turn off audio reverb
      AUDIO_REVERB_FX_KTV = 0x02010100,
      AUDIO_REVERB_FX_VOCAL_CONCERT = 0x02010200,
      AUDIO_REVERB_FX_UNCLE = 0x02020100,
      AUDIO_REVERB_FX_SISTER = 0x02020400,
      AUDIO_REVERB_FX_STUDIO = 0x02010300,
      AUDIO_REVERB_FX_POPULAR = 0x02030200,
      AUDIO_REVERB_FX_RNB = 0x02030100,
      AUDIO_REVERB_FX_PHONOGRAPH = 0x02010400
    };
 
    enum AUDIO_RECORDING_QUALITY_TYPE
    {
      AUDIO_RECORDING_QUALITY_LOW = 0,
      AUDIO_RECORDING_QUALITY_MEDIUM = 1,
      AUDIO_RECORDING_QUALITY_HIGH = 2,
    };
 
    enum AUDIO_FILE_RECORDING_TYPE
    {
      AUDIO_FILE_RECORDING_MIC = 1,
      AUDIO_FILE_RECORDING_PLAYBACK = 2,
      AUDIO_FILE_RECORDING_MIXED = 3,
    };
 
    enum AUDIO_ENCODED_FRAME_OBSERVER_POSITION
    {
      AUDIO_ENCODED_FRAME_OBSERVER_POSITION_RECORD = 1,
      AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK = 2,
      AUDIO_ENCODED_FRAME_OBSERVER_POSITION_MIXED = 3,
    };
 
    struct AudioRecordingConfiguration
    {
      const char *filePath;
      bool encode;
      int sampleRate;
      AUDIO_FILE_RECORDING_TYPE fileRecordingType;
      AUDIO_RECORDING_QUALITY_TYPE quality;
 
      AudioRecordingConfiguration()
          : filePath(NULL),
            encode(false),
            sampleRate(32000),
            fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
            quality(AUDIO_RECORDING_QUALITY_LOW) {}
 
      AudioRecordingConfiguration(const char *file_path, int sample_rate, AUDIO_RECORDING_QUALITY_TYPE quality_type)
          : filePath(file_path),
            encode(false),
            sampleRate(sample_rate),
            fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
            quality(quality_type) {}
 
      AudioRecordingConfiguration(const char *file_path, bool enc, int sample_rate, AUDIO_FILE_RECORDING_TYPE type, AUDIO_RECORDING_QUALITY_TYPE quality_type)
          : filePath(file_path),
            encode(enc),
            sampleRate(sample_rate),
            fileRecordingType(type),
            quality(quality_type) {}
 
      AudioRecordingConfiguration(const AudioRecordingConfiguration &rhs)
          : filePath(rhs.filePath),
            encode(rhs.encode),
            sampleRate(rhs.sampleRate),
            fileRecordingType(rhs.fileRecordingType),
            quality(rhs.quality) {}
    };
 
    struct AudioEncodedFrameObserverConfig
    {
      AUDIO_ENCODED_FRAME_OBSERVER_POSITION postionType;
      AUDIO_ENCODING_TYPE encodingType;
 
      AudioEncodedFrameObserverConfig()
          : postionType(AUDIO_ENCODED_FRAME_OBSERVER_POSITION_PLAYBACK),
            encodingType(AUDIO_ENCODING_TYPE_OPUS_48000_MEDIUM) {}
    };
 
    class IAudioEncodedFrameObserver
    {
    public:
      virtual void OnRecordAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo) = 0;
 
      virtual void OnPlaybackAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo) = 0;
 
      virtual void OnMixedAudioEncodedFrame(const uint8_t *frameBuffer, int length, const EncodedAudioFrameInfo &audioEncodedFrameInfo) = 0;
 
      virtual ~IAudioEncodedFrameObserver() {}
    };
 
    enum VOICE_CHANGER_PRESET
    {
      VOICE_CHANGER_OFF = 0, // Turn off the voice changer
      VOICE_CHANGER_OLDMAN = 0x02020200,
      VOICE_CHANGER_BABYBOY = 0x02020300,
      VOICE_CHANGER_BABYGIRL = 0x02020500,
      VOICE_CHANGER_ZHUBAJIE = 0x02020600,
      VOICE_CHANGER_ETHEREAL = 0x02010700,
      VOICE_CHANGER_HULK = 0x02020700,
      VOICE_BEAUTY_VIGOROUS = 0x01030100,
      VOICE_BEAUTY_DEEP = 0x01030200,
      VOICE_BEAUTY_MELLOW = 0x01030300,
      VOICE_BEAUTY_FALSETTO = 0x01030400,
      VOICE_BEAUTY_FULL = 0x01030500,
      VOICE_BEAUTY_CLEAR = 0x01030600,
      VOICE_BEAUTY_RESOUNDING = 0x01030700,
      VOICE_BEAUTY_RINGING = 0x01030800,
      VOICE_BEAUTY_SPACIAL = 0x02010600,
      GENERAL_BEAUTY_VOICE_MALE = 0x01010100,
      GENERAL_BEAUTY_VOICE_FEMALE_FRESH = 0x01010200,
      GENERAL_BEAUTY_VOICE_FEMALE_VITALITY = 0x01010300
    };
 
    enum AREA_CODE
    {
      AREA_CODE_CN = 0x00000001,
      AREA_CODE_NA = 0x00000002,
      AREA_CODE_EU = 0x00000004,
      AREA_CODE_AS = 0x00000008,
      AREA_CODE_JP = 0x00000010,
      AREA_CODE_IN = 0x00000020,
      AREA_CODE_GLOB = (0xFFFFFFFF)
    };
 
 
    enum AREA_CODE_EX
    {
      AREA_CODE_OC = 0x00000040,
      AREA_CODE_SA = 0x00000080,
      AREA_CODE_AF = 0x00000100,
      AREA_CODE_KR = 0x00000200,
      AREA_CODE_OVS = 0xFFFFFFFE
    };
 
    enum CHANNEL_MEDIA_RELAY_ERROR
    {
      RELAY_OK = 0,
      RELAY_ERROR_SERVER_ERROR_RESPONSE = 1,
      RELAY_ERROR_SERVER_NO_RESPONSE = 2,
      RELAY_ERROR_NO_RESOURCE_AVAILABLE = 3,
      RELAY_ERROR_FAILED_JOIN_SRC = 4,
      RELAY_ERROR_FAILED_JOIN_DEST = 5,
      RELAY_ERROR_FAILED_PACKET_RECEIVED_FROM_SRC = 6,
      RELAY_ERROR_FAILED_PACKET_SENT_TO_DEST = 7,
      RELAY_ERROR_SERVER_CONNECTION_LOST = 8,
      RELAY_ERROR_INTERNAL_ERROR = 9,
      RELAY_ERROR_SRC_TOKEN_EXPIRED = 10,
      RELAY_ERROR_DEST_TOKEN_EXPIRED = 11,
    };
 
    // callback event
    enum CHANNEL_MEDIA_RELAY_EVENT
    {
      RELAY_EVENT_NETWORK_DISCONNECTED = 0,
      RELAY_EVENT_NETWORK_CONNECTED = 1,
      RELAY_EVENT_PACKET_JOINED_SRC_CHANNEL = 2,
      RELAY_EVENT_PACKET_JOINED_DEST_CHANNEL = 3,
      RELAY_EVENT_PACKET_SENT_TO_DEST_CHANNEL = 4,
      RELAY_EVENT_PACKET_RECEIVED_VIDEO_FROM_SRC = 5,
      RELAY_EVENT_PACKET_RECEIVED_AUDIO_FROM_SRC = 6,
      RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL = 7,
      RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_REFUSED = 8,
      RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_NOT_CHANGE = 9,
      RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_IS_NULL = 10,
      RELAY_EVENT_VIDEO_PROFILE_UPDATE = 11,
      RELAY_EVENT_PAUSE_SEND_PACKET_TO_DEST_CHANNEL_SUCCESS = 12,
      RELAY_EVENT_PAUSE_SEND_PACKET_TO_DEST_CHANNEL_FAILED = 13,
      RELAY_EVENT_RESUME_SEND_PACKET_TO_DEST_CHANNEL_SUCCESS = 14,
      RELAY_EVENT_RESUME_SEND_PACKET_TO_DEST_CHANNEL_FAILED = 15,
    };
 
    enum CHANNEL_MEDIA_RELAY_STATE
    {
      RELAY_STATE_IDLE = 0,
      RELAY_STATE_CONNECTING = 1,
      RELAY_STATE_RUNNING = 2,
      RELAY_STATE_FAILURE = 3,
    };
 
    struct ChannelMediaInfo
    {
      const char *channelName;
      const char *token;
      uid_t uid;
    };
 
    struct ChannelMediaRelayConfiguration
    {
      ChannelMediaInfo *srcInfo;
      ChannelMediaInfo *destInfos;
      int destCount;
 
      ChannelMediaRelayConfiguration()
          : srcInfo(NULL),
            destInfos(NULL),
            destCount(0)
      {
      }
    };
 
    struct UplinkNetworkInfo
    {
      int video_encoder_target_bitrate_bps;
 
      UplinkNetworkInfo() : video_encoder_target_bitrate_bps(0) {}
 
      bool operator==(const UplinkNetworkInfo &rhs) const
      {
        return (video_encoder_target_bitrate_bps == rhs.video_encoder_target_bitrate_bps);
      }
    };
 
    struct DownlinkNetworkInfo
    {
      struct PeerDownlinkInfo
      {
        const char *uid;
        VIDEO_STREAM_TYPE stream_type;
        REMOTE_VIDEO_DOWNSCALE_LEVEL current_downscale_level;
        int expected_bitrate_bps;
 
        PeerDownlinkInfo()
            : uid(OPTIONAL_NULLPTR),
              stream_type(VIDEO_STREAM_HIGH),
              current_downscale_level(REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE),
              expected_bitrate_bps(-1) {}
 
        PeerDownlinkInfo &operator=(const PeerDownlinkInfo &rhs)
        {
          if (this == &rhs)
            return *this;
          uid = OPTIONAL_NULLPTR;
          stream_type = rhs.stream_type;
          current_downscale_level = rhs.current_downscale_level;
          expected_bitrate_bps = rhs.expected_bitrate_bps;
          if (rhs.uid != OPTIONAL_NULLPTR)
          {
            char *temp = new char[strlen(rhs.uid) + 1];
            strcpy(temp, rhs.uid);
            uid = temp;
          }
          return *this;
        }
 
        ~PeerDownlinkInfo()
        {
          if (uid)
          {
            delete[] uid;
          }
        }
      };
 
      int lastmile_buffer_delay_time_ms;
      int bandwidth_estimation_bps;
      int total_downscale_level_count;
      PeerDownlinkInfo *peer_downlink_info;
      int total_received_video_count;
 
      DownlinkNetworkInfo()
          : lastmile_buffer_delay_time_ms(-1),
            bandwidth_estimation_bps(-1),
            total_downscale_level_count(-1),
            peer_downlink_info(OPTIONAL_NULLPTR),
            total_received_video_count(-1) {}
 
      DownlinkNetworkInfo(const DownlinkNetworkInfo &info)
          : lastmile_buffer_delay_time_ms(info.lastmile_buffer_delay_time_ms),
            bandwidth_estimation_bps(info.bandwidth_estimation_bps),
            total_downscale_level_count(info.total_downscale_level_count),
            peer_downlink_info(OPTIONAL_NULLPTR),
            total_received_video_count(info.total_received_video_count)
      {
        if (total_received_video_count <= 0)
          return;
        peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
        for (int i = 0; i < total_received_video_count; ++i)
          peer_downlink_info[i] = info.peer_downlink_info[i];
      }
 
      DownlinkNetworkInfo &operator=(const DownlinkNetworkInfo &rhs)
      {
        if (this == &rhs)
          return *this;
        lastmile_buffer_delay_time_ms = rhs.lastmile_buffer_delay_time_ms;
        bandwidth_estimation_bps = rhs.bandwidth_estimation_bps;
        total_downscale_level_count = rhs.total_downscale_level_count;
        peer_downlink_info = OPTIONAL_NULLPTR;
        total_received_video_count = rhs.total_received_video_count;
        if (total_received_video_count > 0)
        {
          peer_downlink_info = new PeerDownlinkInfo[total_received_video_count];
          for (int i = 0; i < total_received_video_count; ++i)
            peer_downlink_info[i] = rhs.peer_downlink_info[i];
        }
        return *this;
      }
 
      ~DownlinkNetworkInfo()
      {
        if (peer_downlink_info)
          delete[] peer_downlink_info;
      }
    };
 
    enum ENCRYPTION_MODE
    {
 
      AES_128_XTS = 1,
      AES_128_ECB = 2,
      AES_256_XTS = 3,
 
      SM4_128_ECB = 4,
      AES_128_GCM = 5,
      AES_256_GCM = 6,
      AES_128_GCM2 = 7,
      AES_256_GCM2 = 8,
      MODE_END,
    };
 
    struct EncryptionConfig
    {
      ENCRYPTION_MODE encryptionMode;
      const char *encryptionKey;
      uint8_t encryptionKdfSalt[32];
 
      EncryptionConfig()
          : encryptionMode(AES_128_GCM2),
            encryptionKey(NULL)
      {
        memset(encryptionKdfSalt, 0, sizeof(encryptionKdfSalt));
      }
 
      const char *getEncryptionString() const
      {
        switch (encryptionMode)
        {
        case AES_128_XTS:
          return "aes-128-xts";
        case AES_128_ECB:
          return "aes-128-ecb";
        case AES_256_XTS:
          return "aes-256-xts";
        case SM4_128_ECB:
          return "sm4-128-ecb";
        case AES_128_GCM:
          return "aes-128-gcm";
        case AES_256_GCM:
          return "aes-256-gcm";
        case AES_128_GCM2:
          return "aes-128-gcm-2";
        case AES_256_GCM2:
          return "aes-256-gcm-2";
        default:
          return "aes-128-gcm-2";
        }
        return "aes-128-gcm-2";
      }
    };
 
    enum ENCRYPTION_ERROR_TYPE
    {
      ENCRYPTION_ERROR_INTERNAL_FAILURE = 0,
      ENCRYPTION_ERROR_DECRYPTION_FAILURE = 1,
      ENCRYPTION_ERROR_ENCRYPTION_FAILURE = 2,
    };
 
 
    enum UPLOAD_ERROR_REASON
    {
      UPLOAD_SUCCESS = 0,
      UPLOAD_NET_ERROR = 1,
      UPLOAD_SERVER_ERROR = 2,
    };
 
    enum PERMISSION_TYPE
    {
      RECORD_AUDIO = 0,
      CAMERA = 1,
    };
 
    enum MAX_USER_ACCOUNT_LENGTH_TYPE
    {
      MAX_USER_ACCOUNT_LENGTH = 256
    };
 
    enum STREAM_SUBSCRIBE_STATE
    {
      SUB_STATE_IDLE = 0,
      SUB_STATE_NO_SUBSCRIBED = 1,
      SUB_STATE_SUBSCRIBING = 2,
      SUB_STATE_SUBSCRIBED = 3
    };
 
    enum STREAM_PUBLISH_STATE
    {
      PUB_STATE_IDLE = 0,
      PUB_STATE_NO_PUBLISHED = 1,
      PUB_STATE_PUBLISHING = 2,
      PUB_STATE_PUBLISHED = 3
    };
 
    struct UserInfo
    {
      uid_t uid;
      char userAccount[MAX_USER_ACCOUNT_LENGTH];
      UserInfo()
          : uid(0)
      {
        userAccount[0] = '\0';
      }
    };
 
 
    enum EAR_MONITORING_FILTER_TYPE
    {
      EAR_MONITORING_FILTER_NONE = (1 << 0),
      EAR_MONITORING_FILTER_BUILT_IN_AUDIO_FILTERS = (1 << 1),
      EAR_MONITORING_FILTER_NOISE_SUPPRESSION = (1 << 2)
    };
 
 
    enum THREAD_PRIORITY_TYPE
    {
      LOWEST = 0,
      LOW = 1,
      NORMAL = 2,
      HIGH = 3,
      HIGHEST = 4,
      CRITICAL = 5,
    };
 
    enum TCcMode
    {
      CC_ENABLED,
      CC_DISABLED,
    };
  } // namespace rtc
 
  namespace base
  {
 
    class IEngineBase
    {
    public:
      virtual int queryInterface(rtc::INTERFACE_ID_TYPE iid, void **inter) = 0;
      virtual ~IEngineBase() {}
    };
 
    class AParameter : public agora::util::AutoPtr<IAgoraParameter>
    {
    public:
      AParameter(IEngineBase &engine) { initialize(&engine); }
      AParameter(IEngineBase *engine) { initialize(engine); }
      AParameter(IAgoraParameter *p) : agora::util::AutoPtr<IAgoraParameter>(p) {}
 
    private:
      bool initialize(IEngineBase *engine)
      {
        IAgoraParameter *p = NULL;
        if (engine && !engine->queryInterface(rtc::AGORA_IID_PARAMETER_ENGINE, (void **)&p))
          reset(p);
        return p != NULL;
      }
    };
 
    class LicenseCallback
    {
    public:
      virtual ~LicenseCallback() {}
      virtual void onCertificateRequired() = 0;
      virtual void onLicenseRequest() = 0;
      virtual void onLicenseValidated() = 0;
      virtual void onLicenseError(int result) = 0;
    };
 
  } // namespace base
 
  struct SpatialAudioParams
  {
    Optional<double> speaker_azimuth;
    Optional<double> speaker_elevation;
    Optional<double> speaker_distance;
    Optional<int> speaker_orientation;
    Optional<bool> enable_blur;
    Optional<bool> enable_air_absorb;
  };
} // namespace agora
 
AGORA_API const char *AGORA_CALL getAgoraSdkVersion(int *build);
 
AGORA_API const char *AGORA_CALL getAgoraSdkErrorDescription(int err);
AGORA_API int AGORA_CALL setAgoraSdkExternalSymbolLoader(void *(*func)(const char *symname));
 
AGORA_API int AGORA_CALL createAgoraCredential(agora::util::AString &credential);
 
AGORA_API int AGORA_CALL getAgoraCertificateVerifyResult(const char *credential_buf, int credential_len,
                                                         const char *certificate_buf, int certificate_len);
 
AGORA_API void setAgoraLicenseCallback(agora::base::LicenseCallback *callback);
 
AGORA_API agora::base::LicenseCallback *getAgoraLicenseCallback();