AgoraBase.h

//
//  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"
 
#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)
#define AGORA_CPP_API __declspec(dllexport)
#else
#define AGORA_API extern "C" __declspec(dllimport)
#define AGORA_CPP_API __declspec(dllimport)
#endif  // AGORARTC_EXPORT
 
#define AGORA_CALL __cdecl
 
#define __deprecated
 
#define AGORA_CPP_INTERNAL_API extern
 
#elif defined(__APPLE__)
 
#include <TargetConditionals.h>
 
#define AGORA_API extern "C" __attribute__((visibility("default")))
#define AGORA_CPP_API __attribute__((visibility("default")))
#define AGORA_CALL
 
#define AGORA_CPP_INTERNAL_API __attribute__((visibility("hidden")))
 
#elif defined(__ANDROID__) || defined(__linux__)
 
#define AGORA_API extern "C" __attribute__((visibility("default")))
#define AGORA_CPP_API __attribute__((visibility("default")))
#define AGORA_CALL
 
#define __deprecated
 
#define AGORA_CPP_INTERNAL_API __attribute__((visibility("hidden")))
 
#else  // !_WIN32 && !__APPLE__ && !(__ANDROID__ || __linux__)
 
#define AGORA_API extern "C"
#define AGORA_CPP_API
#define AGORA_CALL
 
#define __deprecated
 
#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
 
#define INVALID_DISPLAY_ID (-2)
 
namespace agora {
namespace util {
 
template <class T>
class AutoPtr {
 protected:
  typedef T value_type;
  typedef T* pointer_type;
 
 public:
  explicit AutoPtr(pointer_type p = OPTIONAL_NULLPTR) : ptr_(p) {}
 
  ~AutoPtr() {
    if (ptr_) {
      ptr_->release();
      ptr_ = OPTIONAL_NULLPTR;
    }
  }
 
  operator bool() const { return (ptr_ != OPTIONAL_NULLPTR); }
 
  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 = OPTIONAL_NULLPTR) {
    if (ptr != ptr_ && ptr_) {
      ptr_->release();
    }
 
    ptr_ = ptr;
  }
 
  template <class C1, class C2>
  bool queryInterface(C1* c, C2 iid) {
    pointer_type p = OPTIONAL_NULLPTR;
    if (c && !c->queryInterface(iid, reinterpret_cast<void**>(&p))) {
      reset(p);
    }
 
    return (p != OPTIONAL_NULLPTR);
  }
 
 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) {}
  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 OPTIONAL_NULLPTR;
    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 = OPTIONAL_NULLPTR) : 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() != OPTIONAL_NULLPTR; }
};
 
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(OPTIONAL_NULLPTR), owner(false) {}
  AList(IContainer* c, bool take_ownership) : container(c), owner(take_ownership) {}
  ~AList() { reset(); }
  void reset(IContainer* c = OPTIONAL_NULLPTR, bool take_ownership = false) {
    if (owner && container) container->release();
    container = c;
    owner = take_ownership;
  }
  iterator begin() { return container ? iterator(container->begin()) : iterator(OPTIONAL_NULLPTR); }
  iterator end() { return iterator(OPTIONAL_NULLPTR); }
  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 __deprecated = 2,
  CHANNEL_PROFILE_CLOUD_GAMING __deprecated = 3,
 
  CHANNEL_PROFILE_COMMUNICATION_1v1 __deprecated = 4,
};
 
enum CHANNEL_TYPE {
  CHANNEL_TYPE_STANDARD = 0,
  CHANNEL_TYPE_LARGE_SCALE = 1,
};
 
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_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_POP_STATE = 1055,
  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_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_FUNC_IS_PROHIBITED = 23,
  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_DATASTREAM_DECRYPTION_FAILED = 122,
  ERR_CLIENT_IS_BANNED_BY_SERVER = 123,
  ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH = 130,
 
  ERR_LICENSE_CREDENTIAL_INVALID = 131,
 
  ERR_INVALID_USER_ACCOUNT = 134,
 
  ERR_MODULE_NOT_FOUND = 157,
 
  // 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
 
  // RDT error code: 250~270
  ERR_RDT_USER_NOT_EXIST = 250,
  ERR_RDT_USER_NOT_READY = 251,
  ERR_RDT_DATA_BLOCKED = 252,
  ERR_RDT_CMD_EXCEED_LIMIT = 253,
  ERR_RDT_DATA_EXCEED_LIMIT = 254,
  ERR_RDT_ENCRYPTION = 255,
 
  // signaling: 400~600
  ERR_LOGIN_ALREADY_LOGIN = 428,
 
  // 1001~2000
  ERR_LOAD_MEDIA_ENGINE = 1001,
  ERR_ADM_GENERAL_ERROR = 1005,
  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_VDM_CAMERA_NOT_AUTHORIZED = 1501,
};
 
enum LICENSE_ERROR_TYPE {
  LICENSE_ERR_INVALID = 1,
  LICENSE_ERR_EXPIRE = 2,
  LICENSE_ERR_MINUTES_EXCEED = 3,
  LICENSE_ERR_LIMITED_PERIOD = 4,
  LICENSE_ERR_DIFF_DEVICES = 5,
  LICENSE_ERR_INTERNAL = 99,
};
 
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_LOCAL_SPATIAL_AUDIO = 11,
  AGORA_IID_STATE_SYNC = 13,
  AGORA_IID_META_SERVICE = 14,
  AGORA_IID_MUSIC_CONTENT_CENTER = 15,
  AGORA_IID_H265_TRANSCODER = 16,
};
 
enum QUALITY_TYPE {
  QUALITY_UNKNOWN __deprecated = 0,
  QUALITY_EXCELLENT = 1,
  QUALITY_GOOD = 2,
  QUALITY_POOR = 3,
  QUALITY_BAD = 4,
  QUALITY_VBAD = 5,
  QUALITY_DOWN = 6,
  QUALITY_UNSUPPORTED = 7,
  QUALITY_DETECTING = 8,
};
 
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_960 = 960,
};
 
enum FRAME_HEIGHT {
  FRAME_HEIGHT_540 = 540,
};
 
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_AUTO = -1,
  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 SCREEN_CAPTURE_FRAMERATE_CAPABILITY {
  SCREEN_CAPTURE_FRAMERATE_CAPABILITY_15_FPS = 0,
  SCREEN_CAPTURE_FRAMERATE_CAPABILITY_30_FPS = 1,
  SCREEN_CAPTURE_FRAMERATE_CAPABILITY_60_FPS = 2,
};
 
enum VIDEO_CODEC_CAPABILITY_LEVEL {
  CODEC_CAPABILITY_LEVEL_UNSPECIFIED = -1,
  CODEC_CAPABILITY_LEVEL_BASIC_SUPPORT = 5,
  CODEC_CAPABILITY_LEVEL_1080P30FPS = 10,
  CODEC_CAPABILITY_LEVEL_1080P60FPS = 20,
  CODEC_CAPABILITY_LEVEL_4K60FPS = 30,
};
 
enum VIDEO_CODEC_TYPE {
  VIDEO_CODEC_NONE = 0,
  VIDEO_CODEC_VP8 = 1,
  VIDEO_CODEC_H264 = 2,
  VIDEO_CODEC_H265 = 3,
  VIDEO_CODEC_GENERIC = 6,
  VIDEO_CODEC_GENERIC_H264 = 7,
  VIDEO_CODEC_AV1 = 12,
  VIDEO_CODEC_VP9 = 13,
  VIDEO_CODEC_GENERIC_JPEG = 20,
};
 
enum CAMERA_FOCAL_LENGTH_TYPE {
  CAMERA_FOCAL_LENGTH_DEFAULT = 0,
  CAMERA_FOCAL_LENGTH_WIDE_ANGLE = 1,
  CAMERA_FOCAL_LENGTH_ULTRA_WIDE = 2,
  CAMERA_FOCAL_LENGTH_TELEPHOTO = 3,
};
 
enum TCcMode {
  CC_ENABLED,
  CC_DISABLED,
};
 
struct SenderOptions {
  TCcMode ccMode;
  VIDEO_CODEC_TYPE codecType;
 
  int targetBitrate;
 
  SenderOptions() : ccMode(CC_ENABLED), codecType(VIDEO_CODEC_H265), targetBitrate(6500) {}
};
 
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,
  AUDIO_CODEC_OPUSMC = 13,
};
 
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 = 0,
  FIT_MODE_USE_IMAGE_RATIO = 1,
};
 
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,
  VIDEO_STREAM_LAYER_1 = 4,
  VIDEO_STREAM_LAYER_2 = 5,
  VIDEO_STREAM_LAYER_3 = 6,
  VIDEO_STREAM_LAYER_4 = 7,
  VIDEO_STREAM_LAYER_5 = 8,
  VIDEO_STREAM_LAYER_6 = 9,
 
};
 
struct VideoSubscriptionOptions {
  Optional<VIDEO_STREAM_TYPE> type;
  Optional<bool> encodedFrameOnly;
 
  VideoSubscriptionOptions() {}
};
 
enum MAX_USER_ACCOUNT_LENGTH_TYPE {
  MAX_USER_ACCOUNT_LENGTH = 256
};
 
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),
        streamType(VIDEO_STREAM_HIGH),
        presentationMs(-1) {}
 
  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),
        streamType(rhs.streamType),
        presentationMs(rhs.presentationMs) {}
 
  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;
    streamType = rhs.streamType;
    presentationMs = rhs.presentationMs;
    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;
  VIDEO_STREAM_TYPE streamType;
 
  // @technical preview
  int64_t presentationMs;
};
 
enum COMPRESSION_PREFERENCE {
  PREFER_COMPRESSION_AUTO = -1,
  PREFER_LOW_LATENCY = 0,
  PREFER_QUALITY = 1,
};
 
enum ENCODING_PREFERENCE {
  PREFER_AUTO = -1,
  PREFER_SOFTWARE = 0,
  PREFER_HARDWARE = 1,
};
 
struct AdvanceOptions {
  ENCODING_PREFERENCE encodingPreference;
 
  COMPRESSION_PREFERENCE compressionPreference;
 
  bool encodeAlpha;
 
  AdvanceOptions() : encodingPreference(PREFER_AUTO),
                     compressionPreference(PREFER_COMPRESSION_AUTO),
                     encodeAlpha(false) {}
 
  AdvanceOptions(ENCODING_PREFERENCE encoding_preference,
                 COMPRESSION_PREFERENCE compression_preference,
                 bool encode_alpha) :
                 encodingPreference(encoding_preference),
                 compressionPreference(compression_preference),
                 encodeAlpha(encode_alpha) {}
 
  bool operator==(const AdvanceOptions& rhs) const {
    return encodingPreference == rhs.encodingPreference &&
           compressionPreference == rhs.compressionPreference &&
           encodeAlpha == rhs.encodeAlpha;
  }
};
 
enum VIDEO_MIRROR_MODE_TYPE {
  VIDEO_MIRROR_MODE_AUTO = 0,
  VIDEO_MIRROR_MODE_ENABLED = 1,
  VIDEO_MIRROR_MODE_DISABLED = 2,
};
 
#if defined(__APPLE__) && TARGET_OS_IOS
 
enum CAMERA_FORMAT_TYPE {
  CAMERA_FORMAT_NV12,
  CAMERA_FORMAT_BGRA,
};
#endif
 
enum VIDEO_MODULE_TYPE {
  VIDEO_MODULE_CAPTURER = 0,
  VIDEO_MODULE_SOFTWARE_ENCODER = 1,
  VIDEO_MODULE_HARDWARE_ENCODER = 2,
  VIDEO_MODULE_SOFTWARE_DECODER = 3,
  VIDEO_MODULE_HARDWARE_DECODER = 4,
  VIDEO_MODULE_RENDERER = 5,
};
 
enum HDR_CAPABILITY {
  HDR_CAPABILITY_UNKNOWN = -1,
  HDR_CAPABILITY_UNSUPPORTED = 0,
  HDR_CAPABILITY_SUPPORTED = 1,
};
 
enum CODEC_CAP_MASK {
  CODEC_CAP_MASK_NONE = 0,
 
  CODEC_CAP_MASK_HW_DEC = 1 << 0,
 
  CODEC_CAP_MASK_HW_ENC = 1 << 1,
 
  CODEC_CAP_MASK_SW_DEC = 1 << 2,
 
  CODEC_CAP_MASK_SW_ENC = 1 << 3,
};
 
struct CodecCapLevels {
  VIDEO_CODEC_CAPABILITY_LEVEL hwDecodingLevel;
  VIDEO_CODEC_CAPABILITY_LEVEL swDecodingLevel;
 
  CodecCapLevels()
      : hwDecodingLevel(CODEC_CAPABILITY_LEVEL_UNSPECIFIED),
        swDecodingLevel(CODEC_CAPABILITY_LEVEL_UNSPECIFIED) {}
};
 
struct CodecCapInfo {
  VIDEO_CODEC_TYPE codecType;
  int codecCapMask;
  CodecCapLevels codecLevels;
 
  CodecCapInfo() : codecType(VIDEO_CODEC_NONE), codecCapMask(0) {}
};
 
struct FocalLengthInfo {
  int cameraDirection;
  CAMERA_FOCAL_LENGTH_TYPE focalLengthType;
};
 
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;
 
  AdvanceOptions advanceOptions;
 
  VideoEncoderConfiguration(const VideoDimensions& d, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
    : codecType(VIDEO_CODEC_NONE),
      dimensions(d),
      frameRate(f),
      bitrate(b),
      minBitrate(DEFAULT_MIN_BITRATE),
      orientationMode(m),
      degradationPreference(MAINTAIN_AUTO),
      mirrorMode(mirror),
      advanceOptions(PREFER_AUTO, PREFER_COMPRESSION_AUTO, false) {}
  VideoEncoderConfiguration(int width, int height, int f, int b, ORIENTATION_MODE m, VIDEO_MIRROR_MODE_TYPE mirror = VIDEO_MIRROR_MODE_DISABLED)
    : codecType(VIDEO_CODEC_NONE),
      dimensions(width, height),
      frameRate(f),
      bitrate(b),
      minBitrate(DEFAULT_MIN_BITRATE),
      orientationMode(m),
      degradationPreference(MAINTAIN_AUTO),
      mirrorMode(mirror),
      advanceOptions(PREFER_AUTO, PREFER_COMPRESSION_AUTO, false) {}
  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),
        advanceOptions(config.advanceOptions) {}
  VideoEncoderConfiguration()
    : codecType(VIDEO_CODEC_NONE),
      dimensions(FRAME_WIDTH_960, FRAME_HEIGHT_540),
      frameRate(FRAME_RATE_FPS_15),
      bitrate(STANDARD_BITRATE),
      minBitrate(DEFAULT_MIN_BITRATE),
      orientationMode(ORIENTATION_MODE_ADAPTIVE),
      degradationPreference(MAINTAIN_AUTO),
      mirrorMode(VIDEO_MIRROR_MODE_DISABLED),
      advanceOptions(PREFER_AUTO, PREFER_COMPRESSION_AUTO, false) {}
 
  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;
    advanceOptions = rhs.advanceOptions;
    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 kBitrate;
  int framerate;
  SimulcastStreamConfig() : dimensions(160, 120), kBitrate(65), framerate(5) {}
  SimulcastStreamConfig(const SimulcastStreamConfig& other) : dimensions(other.dimensions), kBitrate(other.kBitrate), framerate(other.framerate) {}
  bool operator==(const SimulcastStreamConfig& rhs) const {
    return dimensions == rhs.dimensions && kBitrate == rhs.kBitrate && framerate == rhs.framerate;
  }
};
 
struct SimulcastConfig {
  enum StreamLayerIndex {
   STREAM_LAYER_1 = 0,
   STREAM_LAYER_2 = 1,
   STREAM_LAYER_3 = 2,
   STREAM_LAYER_4 = 3,
   STREAM_LAYER_5 = 4,
   STREAM_LAYER_6 = 5,
   STREAM_LOW = 6,
   STREAM_LAYER_COUNT_MAX = 7
  };
  struct StreamLayerConfig {
    VideoDimensions dimensions;
    int framerate;
    bool enable;
    StreamLayerConfig() : dimensions(0, 0), framerate(0), enable(false) {}
  };
 
  StreamLayerConfig configs[STREAM_LAYER_COUNT_MAX];
  bool publish_fallback_enable;
 
  SimulcastConfig(): publish_fallback_enable(false) {}
};
struct Rectangle {
  int x;
  int y;
  int width;
  int height;
 
  Rectangle() : x(0), y(0), width(0), height(0) {}
  Rectangle(int xx, int yy, int ww, int hh) : x(xx), y(yy), width(ww), height(hh) {}
};
 
struct WatermarkRatio {
  float xRatio;
  float yRatio;
  float widthRatio;
 
  WatermarkRatio() : xRatio(0.0), yRatio(0.0), widthRatio(0.0) {}
  WatermarkRatio(float x, float y, float width) : xRatio(x), yRatio(y), widthRatio(width) {}
};
 
struct WatermarkOptions {
  bool visibleInPreview;
  Rectangle positionInLandscapeMode;
  Rectangle positionInPortraitMode;
  WatermarkRatio watermarkRatio;
  WATERMARK_FIT_MODE mode;
  int zOrder;
 
  WatermarkOptions()
      : visibleInPreview(true),
        positionInLandscapeMode(0, 0, 0, 0),
        positionInPortraitMode(0, 0, 0, 0),
        mode(FIT_MODE_COVER_POSITION),
        zOrder(0) {}
};
 
enum WATERMARK_SOURCE_TYPE {
  IMAGE = 0,
  BUFFER = 1,
  LITERAL = 2,
  TIMESTAMPS = 3,
};
 
struct WatermarkTimestamp{
  int fontSize;
  const char* fontFilePath;
  int strokeWidth;
  const char* format;
 
  WatermarkTimestamp() : fontSize(10), fontFilePath(NULL), strokeWidth(1), format(NULL) {}
};
 
struct WatermarkLiteral {
 
  int fontSize;
  int strokeWidth;
  const char* wmLiteral;
  const char* fontFilePath;
 
  WatermarkLiteral() : wmLiteral(NULL), fontFilePath(NULL), fontSize(10), strokeWidth(1) {}
};
 
struct WatermarkBuffer {
 
  int width;
  int height;
  int length;
  media::base::VIDEO_PIXEL_FORMAT format;
 
  const uint8_t* buffer;
 
  WatermarkBuffer() : buffer(NULL), width(0), height(0), length(0), format(media::base::VIDEO_PIXEL_I420) {}
};
 
struct WatermarkConfig {
  const char* id;
  WATERMARK_SOURCE_TYPE type;
  union {
    WatermarkBuffer buffer;
    WatermarkTimestamp timestamp;
    WatermarkLiteral literal;
    const char* imageUrl;
  };
 
  WatermarkOptions options;
 
  WatermarkConfig() : id(NULL), type(IMAGE), imageUrl(NULL) {}
};
 
enum MultipathMode {
  Duplicate= 0,
  Dynamic
};
 
enum MultipathType {
  LAN = 0,
  WIFI,
  Mobile,
  Unknown = 99
};
 
struct PathStats {
  MultipathType type;
  int txKBitRate;
  int rxKBitRate;
  PathStats() : type(Unknown), txKBitRate(0), rxKBitRate(0) {}
  PathStats(MultipathType t, int tx, int rx) : type(t), txKBitRate(tx), rxKBitRate(rx) {}
};
 
struct MultipathStats {
  uint32_t lanTxBytes;
  uint32_t lanRxBytes;
  uint32_t wifiTxBytes;
  uint32_t wifiRxBytes;
  uint32_t mobileTxBytes;
  uint32_t mobileRxBytes;
  int activePathNum;
  const PathStats* pathStats;
  MultipathStats()
      : lanTxBytes(0),
        lanRxBytes(0),
        wifiTxBytes(0),
        wifiRxBytes(0),
        mobileTxBytes(0),
        mobileRxBytes(0),
        activePathNum(0),
        pathStats(nullptr) {}
};
 
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;
  int lanAccelerateState;
 
  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),
        lanAccelerateState(0) {}
};
 
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 AUDIENCE_LATENCY_LEVEL_TYPE {
  AUDIENCE_LATENCY_LEVEL_LOW_LATENCY = 1,
  AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY = 2,
};
 
struct ClientRoleOptions {
  AUDIENCE_LATENCY_LEVEL_TYPE audienceLatencyLevel;
 
  ClientRoleOptions() : audienceLatencyLevel(AUDIENCE_LATENCY_LEVEL_ULTRA_LOW_LATENCY) {}
};
 
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 AUDIO_AINS_MODE {
  AINS_MODE_BALANCED = 0,
  AINS_MODE_AGGRESSIVE = 1,
  AINS_MODE_ULTRALOWLATENCY = 2
};
 
enum AUDIO_PROFILE_TYPE {
  AUDIO_PROFILE_DEFAULT = 0,
  AUDIO_PROFILE_SPEECH_STANDARD = 1,
  AUDIO_PROFILE_MUSIC_STANDARD = 2,
  AUDIO_PROFILE_MUSIC_STANDARD_STEREO = 3,
  AUDIO_PROFILE_MUSIC_HIGH_QUALITY = 4,
  AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO = 5,
  AUDIO_PROFILE_IOT = 6,
  AUDIO_PROFILE_NUM = 7
};
 
enum AUDIO_SCENARIO_TYPE {
  AUDIO_SCENARIO_DEFAULT = 0,
  AUDIO_SCENARIO_GAME_STREAMING = 3,
  AUDIO_SCENARIO_CHATROOM = 5,
  AUDIO_SCENARIO_CHORUS = 7,
  AUDIO_SCENARIO_MEETING = 8,
  AUDIO_SCENARIO_AI_SERVER = 9,
  AUDIO_SCENARIO_AI_CLIENT = 10,
  AUDIO_SCENARIO_NUM = 11,
};
 
struct VideoFormat {
  OPTIONAL_ENUM_SIZE_T{
      kMaxWidthInPixels = 3840,
      kMaxHeightInPixels = 2160,
      kMaxFps = 60,
  };
 
  int width;  // Number of pixels.
  int height;  // Number of pixels.
  int fps;
  VideoFormat() : width(FRAME_WIDTH_960), height(FRAME_HEIGHT_540), fps(FRAME_RATE_FPS_15) {}
  VideoFormat(int w, int h, int f) : width(w), height(h), fps(f) {}
 
  bool operator<(const VideoFormat& fmt) const {
    if (height != fmt.height) {
      return height < fmt.height;
    } else if (width != fmt.width) {
      return width < fmt.width;
    } else {
      return fps < fmt.fps;
    }
  }
  bool operator==(const VideoFormat& fmt) const {
    return width == fmt.width && height == fmt.height && fps == fmt.fps;
  }
  bool operator!=(const VideoFormat& fmt) const { return !operator==(fmt); }
};
 
enum VIDEO_CONTENT_HINT {
  CONTENT_HINT_NONE,
  CONTENT_HINT_MOTION,
  CONTENT_HINT_DETAILS
};
enum SCREEN_SCENARIO_TYPE {
  SCREEN_SCENARIO_DOCUMENT = 1,
  SCREEN_SCENARIO_GAMING = 2,
  SCREEN_SCENARIO_VIDEO = 3,
  SCREEN_SCENARIO_RDC = 4,
};
 
enum VIDEO_APPLICATION_SCENARIO_TYPE {
  APPLICATION_SCENARIO_GENERAL = 0,
  APPLICATION_SCENARIO_MEETING = 1,
  APPLICATION_SCENARIO_1V1 = 2,
  APPLICATION_SCENARIO_LIVESHOW = 3,
};
 
enum VIDEO_QOE_PREFERENCE_TYPE {
  VIDEO_QOE_PREFERENCE_BALANCE = 1,
  VIDEO_QOE_PREFERENCE_DELAY_FIRST = 2,
  VIDEO_QOE_PREFERENCE_PICTURE_QUALITY_FIRST = 3,
  VIDEO_QOE_PREFERENCE_FLUENCY_FIRST = 4,
 
};
 
enum CAPTURE_BRIGHTNESS_LEVEL_TYPE {
  CAPTURE_BRIGHTNESS_LEVEL_INVALID = -1,
  CAPTURE_BRIGHTNESS_LEVEL_NORMAL = 0,
  CAPTURE_BRIGHTNESS_LEVEL_BRIGHT = 1,
  CAPTURE_BRIGHTNESS_LEVEL_DARK = 2,
};
 
enum CAMERA_STABILIZATION_MODE {
  CAMERA_STABILIZATION_MODE_OFF = -1,
  CAMERA_STABILIZATION_MODE_AUTO = 0,
  CAMERA_STABILIZATION_MODE_LEVEL_1 = 1,
  CAMERA_STABILIZATION_MODE_LEVEL_2 = 2,
  CAMERA_STABILIZATION_MODE_LEVEL_3 = 3,
  CAMERA_STABILIZATION_MODE_MAX_LEVEL = CAMERA_STABILIZATION_MODE_LEVEL_3,
};
 
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_REASON {
  LOCAL_AUDIO_STREAM_REASON_OK = 0,
  LOCAL_AUDIO_STREAM_REASON_FAILURE = 1,
  LOCAL_AUDIO_STREAM_REASON_DEVICE_NO_PERMISSION = 2,
  LOCAL_AUDIO_STREAM_REASON_DEVICE_BUSY = 3,
  LOCAL_AUDIO_STREAM_REASON_RECORD_FAILURE = 4,
  LOCAL_AUDIO_STREAM_REASON_ENCODE_FAILURE = 5,
  LOCAL_AUDIO_STREAM_REASON_NO_RECORDING_DEVICE = 6,
  LOCAL_AUDIO_STREAM_REASON_NO_PLAYOUT_DEVICE = 7,
  LOCAL_AUDIO_STREAM_REASON_INTERRUPTED = 8,
  LOCAL_AUDIO_STREAM_REASON_RECORD_INVALID_ID = 9,
  LOCAL_AUDIO_STREAM_REASON_PLAYOUT_INVALID_ID = 10,
};
 
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_EVENT_TYPE {
  LOCAL_VIDEO_EVENT_TYPE_SCREEN_CAPTURE_WINDOW_HIDDEN = 1,
  LOCAL_VIDEO_EVENT_TYPE_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_HIDDEN = 2,
  LOCAL_VIDEO_EVENT_TYPE_SCREEN_CAPTURE_STOPPED_BY_USER = 3,
  LOCAL_VIDEO_EVENT_TYPE_SCREEN_CAPTURE_SYSTEM_INTERNAL_ERROR = 4,
};
 
enum LOCAL_VIDEO_STREAM_REASON {
  LOCAL_VIDEO_STREAM_REASON_OK = 0,
  LOCAL_VIDEO_STREAM_REASON_FAILURE = 1,
  LOCAL_VIDEO_STREAM_REASON_DEVICE_NO_PERMISSION = 2,
  LOCAL_VIDEO_STREAM_REASON_DEVICE_BUSY = 3,
  LOCAL_VIDEO_STREAM_REASON_CAPTURE_FAILURE = 4,
  LOCAL_VIDEO_STREAM_REASON_CODEC_NOT_SUPPORT = 5,
  LOCAL_VIDEO_STREAM_REASON_CAPTURE_INBACKGROUND = 6,
  LOCAL_VIDEO_STREAM_REASON_CAPTURE_MULTIPLE_FOREGROUND_APPS = 7,
  LOCAL_VIDEO_STREAM_REASON_DEVICE_NOT_FOUND = 8,
  LOCAL_VIDEO_STREAM_REASON_DEVICE_DISCONNECTED = 9,
  LOCAL_VIDEO_STREAM_REASON_DEVICE_INVALID_ID = 10,
  LOCAL_VIDEO_STREAM_REASON_DEVICE_INTERRUPT = 14,
  LOCAL_VIDEO_STREAM_REASON_DEVICE_FATAL_ERROR = 15,
  LOCAL_VIDEO_STREAM_REASON_DEVICE_SYSTEM_PRESSURE = 101,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_MINIMIZED = 11,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_CLOSED = 12,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_OCCLUDED = 13,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_NOT_SUPPORTED = 20,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_FAILURE = 21,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_NO_PERMISSION = 22,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_AUTO_FALLBACK = 24,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_HIDDEN = 25,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_HIDDEN = 26,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_WINDOW_RECOVER_FROM_MINIMIZED = 27,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_PAUSED = 28,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_RESUMED = 29,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_DISPLAY_DISCONNECTED = 30,
  /* 30: (HMOS only) ScreenCapture stopped by user */
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_STOPPED_BY_USER = 31,
  /* 31: (HMOS only) ScreenCapture interrupted by other screen capture */
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_INTERRUPTED_BY_OTHER = 32,
  /* 32: (HMOS only) ScreenCapture stopped by SIM call */
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_STOPPED_BY_CALL = 33,
  LOCAL_VIDEO_STREAM_REASON_SCREEN_CAPTURE_EXCLUDE_WINDOW_FAILED = 34,
};
 
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 fronzen 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,
  REMOTE_AUDIO_REASON_NO_PACKET_RECEIVE = 8,
  REMOTE_AUDIO_REASON_LOCAL_PLAY_FAILED = 9,
};
 
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,
  REMOTE_VIDEO_STATE_REASON_SDK_IN_BACKGROUND = 12,
 
  REMOTE_VIDEO_STATE_REASON_CODEC_NOT_SUPPORT = 13,
 
};
 
enum REMOTE_USER_STATE {
  USER_STATE_MUTE_AUDIO = (1 << 0),
  USER_STATE_MUTE_VIDEO = (1 << 1),
  USER_STATE_ENABLE_VIDEO = (1 << 4),
  USER_STATE_ENABLE_LOCAL_VIDEO = (1 << 8),
};
 
struct VideoTrackInfo {
  VideoTrackInfo()
      : isLocal(false),
        ownerUid(0),
        trackId(0),
        channelId(OPTIONAL_NULLPTR),
        codecType(VIDEO_CODEC_H265),
        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_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]
  unsigned int vad;
  double voicePitch;
 
  AudioVolumeInfo() : uid(0), volume(0), vad(0), voicePitch(0.0) {}
};
 
struct DeviceInfo {
  bool isLowLatencyAudioSupported;
 
  DeviceInfo() : isLowLatencyAudioSupported(false) {}
};
 
class IPacketObserver {
 public:
  virtual ~IPacketObserver() {}
  struct Packet {
    const unsigned char* buffer;
    unsigned int size;
 
    Packet() : buffer(OPTIONAL_NULLPTR), 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;
};
 
enum AUDIO_SAMPLE_RATE_TYPE {
  AUDIO_SAMPLE_RATE_32000 = 32000,
  AUDIO_SAMPLE_RATE_44100 = 44100,
  AUDIO_SAMPLE_RATE_48000 = 48000,
};
enum VIDEO_CODEC_TYPE_FOR_STREAM {
  VIDEO_CODEC_H264_FOR_STREAM = 1,
  VIDEO_CODEC_H265_FOR_STREAM = 2,
};
 
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,
  AUDIO_CODEC_PROFILE_HE_AAC_V2 = 2,
};
 
struct LocalAudioStats {
  int numChannels;
  int sentSampleRate;
  int sentBitrate;
  int internalCodec;
  unsigned short txPacketLossRate;
  int audioDeviceDelay;
  int audioPlayoutDelay;
  int earMonitorDelay;
  int aecEstimatedDelay;
};
 
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,
  RTMP_STREAM_PUBLISH_STATE_DISCONNECTING = 5,
};
 
enum RTMP_STREAM_PUBLISH_REASON {
  RTMP_STREAM_PUBLISH_REASON_OK = 0,
  RTMP_STREAM_PUBLISH_REASON_INVALID_ARGUMENT = 1,
  RTMP_STREAM_PUBLISH_REASON_ENCRYPTED_STREAM_NOT_ALLOWED = 2,
  RTMP_STREAM_PUBLISH_REASON_CONNECTION_TIMEOUT = 3,
  RTMP_STREAM_PUBLISH_REASON_INTERNAL_SERVER_ERROR = 4,
  RTMP_STREAM_PUBLISH_REASON_RTMP_SERVER_ERROR = 5,
  RTMP_STREAM_PUBLISH_REASON_TOO_OFTEN = 6,
  RTMP_STREAM_PUBLISH_REASON_REACH_LIMIT = 7,
  RTMP_STREAM_PUBLISH_REASON_NOT_AUTHORIZED = 8,
  RTMP_STREAM_PUBLISH_REASON_STREAM_NOT_FOUND = 9,
  RTMP_STREAM_PUBLISH_REASON_FORMAT_NOT_SUPPORTED = 10,
  RTMP_STREAM_PUBLISH_REASON_NOT_BROADCASTER =
      11,  // Note: match to ERR_PUBLISH_STREAM_NOT_BROADCASTER in AgoraBase.h
  RTMP_STREAM_PUBLISH_REASON_TRANSCODING_NO_MIX_STREAM =
      13,  // Note: match to ERR_PUBLISH_STREAM_TRANSCODING_NO_MIX_STREAM in AgoraBase.h
  RTMP_STREAM_PUBLISH_REASON_NET_DOWN = 14,  // Note: match to ERR_NET_DOWN in AgoraBase.h
  RTMP_STREAM_PUBLISH_REASON_INVALID_APPID =
      15,  // Note: match to ERR_PUBLISH_STREAM_APPID_INVALID in AgoraBase.h
  RTMP_STREAM_PUBLISH_REASON_INVALID_PRIVILEGE = 16,
  RTMP_STREAM_UNPUBLISH_REASON_OK = 100,
};
 
enum RTMP_STREAMING_EVENT {
  RTMP_STREAMING_EVENT_FAILED_LOAD_IMAGE = 1,
  RTMP_STREAMING_EVENT_URL_ALREADY_IN_USE = 2,
  RTMP_STREAMING_EVENT_ADVANCED_FEATURE_NOT_SUPPORT = 3,
  RTMP_STREAMING_EVENT_REQUEST_TOO_OFTEN = 4,
};
 
typedef struct RtcImage {
  const char* url;
  int x;
  int y;
  int width;
  int height;
  int zOrder;
  double alpha;
 
  RtcImage() : url(OPTIONAL_NULLPTR), x(0), y(0), width(0), height(0), zOrder(0), alpha(1.0) {}
} RtcImage;
struct LiveStreamAdvancedFeature {
  LiveStreamAdvancedFeature() : featureName(OPTIONAL_NULLPTR), opened(false) {}
  LiveStreamAdvancedFeature(const char* feat_name, bool open)
      : featureName(feat_name), opened(open) {}
  // static const char* LBHQ = "lbhq";
  // static const char* VEO = "veo";
 
  const char* featureName;
 
  bool opened;
};
 
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 TranscodingUser {
  uid_t uid;
  int x;
  int y;
  int width;
  int height;
  int zOrder;
  double alpha;
  int audioChannel;
 
  TranscodingUser()
      : uid(0), x(0), y(0), width(0), height(0), zOrder(0), alpha(1.0), audioChannel(0) {}
};
 
struct LiveTranscoding {
  int width;
  int height;
  int videoBitrate;
  int videoFramerate;
 
  bool lowLatency;
 
  int videoGop;
  VIDEO_CODEC_PROFILE_TYPE videoCodecProfile;
  unsigned int backgroundColor;
  VIDEO_CODEC_TYPE_FOR_STREAM videoCodecType;
  unsigned int userCount;
  TranscodingUser* transcodingUsers;
  const char* transcodingExtraInfo;
 
  const char* metadata;
  RtcImage* watermark;
  unsigned int watermarkCount;
 
  RtcImage* backgroundImage;
  unsigned int backgroundImageCount;
 
  AUDIO_SAMPLE_RATE_TYPE audioSampleRate;
  int audioBitrate;
  int audioChannels;
  AUDIO_CODEC_PROFILE_TYPE audioCodecProfile;
  LiveStreamAdvancedFeature* advancedFeatures;
 
  unsigned int advancedFeatureCount;
 
  LiveTranscoding()
      : width(360),
        height(640),
        videoBitrate(400),
        videoFramerate(15),
        lowLatency(false),
        videoGop(30),
        videoCodecProfile(VIDEO_CODEC_PROFILE_HIGH),
        backgroundColor(0x000000),
        videoCodecType(VIDEO_CODEC_H264_FOR_STREAM),
        userCount(0),
        transcodingUsers(OPTIONAL_NULLPTR),
        transcodingExtraInfo(OPTIONAL_NULLPTR),
        metadata(OPTIONAL_NULLPTR),
        watermark(OPTIONAL_NULLPTR),
        watermarkCount(0),
        backgroundImage(OPTIONAL_NULLPTR),
        backgroundImageCount(0),
        audioSampleRate(AUDIO_SAMPLE_RATE_48000),
        audioBitrate(48),
        audioChannels(1),
        audioCodecProfile(AUDIO_CODEC_PROFILE_LC_AAC),
        advancedFeatures(OPTIONAL_NULLPTR),
        advancedFeatureCount(0) {}
};
 
struct TranscodingVideoStream {
  VIDEO_SOURCE_TYPE sourceType;
  uid_t remoteUserUid;
  const char* imageUrl;
  int mediaPlayerId;
  int x;
  int y;
  int width;
  int height;
  int zOrder;
  double alpha;
  bool mirror;
 
  TranscodingVideoStream()
      : sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
        remoteUserUid(0),
        imageUrl(OPTIONAL_NULLPTR),
        x(0),
        y(0),
        width(0),
        height(0),
        zOrder(0),
        alpha(1.0),
        mirror(false) {}
};
 
struct LocalTranscoderConfiguration {
  unsigned int streamCount;
  TranscodingVideoStream* videoInputStreams;
  VideoEncoderConfiguration videoOutputConfiguration;
  bool syncWithPrimaryCamera;
 
  LocalTranscoderConfiguration()
      : streamCount(0),
        videoInputStreams(OPTIONAL_NULLPTR),
        videoOutputConfiguration(),
        syncWithPrimaryCamera(true) {}
};
 
enum VIDEO_TRANSCODER_ERROR {
  VT_ERR_VIDEO_SOURCE_NOT_READY = 1,
  VT_ERR_INVALID_VIDEO_SOURCE_TYPE = 2,
  VT_ERR_INVALID_IMAGE_PATH = 3,
  VT_ERR_UNSUPPORT_IMAGE_FORMAT = 4,
  VT_ERR_INVALID_LAYOUT = 5,
  VT_ERR_INTERNAL = 20
};
 
 
struct MixedAudioStream {
  AUDIO_SOURCE_TYPE sourceType;
  uid_t remoteUserUid;
  const char* channelId;
  track_id_t trackId;
 
  MixedAudioStream(AUDIO_SOURCE_TYPE source)
    : sourceType(source),
      remoteUserUid(0),
      channelId(NULL),
      trackId(-1) {}
 
  MixedAudioStream(AUDIO_SOURCE_TYPE source, track_id_t track)
    : sourceType(source),
      trackId(track) {}
 
  MixedAudioStream(AUDIO_SOURCE_TYPE source, uid_t uid, const char* channel)
    : sourceType(source),
      remoteUserUid(uid),
      channelId(channel) {}
 
  MixedAudioStream(AUDIO_SOURCE_TYPE source, uid_t uid, const char* channel, track_id_t track)
    : sourceType(source),
      remoteUserUid(uid),
      channelId(channel),
      trackId(track) {}
 
};
 
struct LocalAudioMixerConfiguration {
  unsigned int streamCount;
  MixedAudioStream* audioInputStreams;
 
  bool syncWithLocalMic;
 
  LocalAudioMixerConfiguration() : streamCount(0), syncWithLocalMic(true) {}
};
 
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,
  CONNECTION_CHANGED_SAME_UID_LOGIN = 19,
  CONNECTION_CHANGED_TOO_MANY_BROADCASTERS = 20,
 
  CONNECTION_CHANGED_LICENSE_VALIDATION_FAILURE = 21,
  /*
   * 22: The connection is failed due to certification verify failure.
   */
  CONNECTION_CHANGED_CERTIFICATION_VERYFY_FAILURE = 22,
  CONNECTION_CHANGED_STREAM_CHANNEL_NOT_AVAILABLE = 23,
  CONNECTION_CHANGED_INCONSISTENT_APPID = 24,
};
 
enum CLIENT_ROLE_CHANGE_FAILED_REASON {
  CLIENT_ROLE_CHANGE_FAILED_TOO_MANY_BROADCASTERS = 1,
  CLIENT_ROLE_CHANGE_FAILED_NOT_AUTHORIZED = 2,
  CLIENT_ROLE_CHANGE_FAILED_REQUEST_TIME_OUT __deprecated = 3,
  CLIENT_ROLE_CHANGE_FAILED_CONNECTION_FAILED __deprecated = 4,
};
 
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,
  NETWORK_TYPE_MOBILE_5G = 6,
};
 
enum VIDEO_VIEW_SETUP_MODE {
  VIDEO_VIEW_SETUP_REPLACE = 0,
  VIDEO_VIEW_SETUP_ADD = 1,
  VIDEO_VIEW_SETUP_REMOVE = 2,
};
 
struct VideoCanvas {
  uid_t uid;
 
  uid_t subviewUid;
  view_t view;
  uint32_t backgroundColor;
  media::base::RENDER_MODE_TYPE renderMode;
  VIDEO_MIRROR_MODE_TYPE mirrorMode;
  VIDEO_VIEW_SETUP_MODE setupMode;
  VIDEO_SOURCE_TYPE sourceType;
  int mediaPlayerId;
  Rectangle cropArea;
  bool enableAlphaMask;
  media::base::VIDEO_MODULE_POSITION position;
 
  VideoCanvas()
      : uid(0),
        subviewUid(0),
        view(NULL),
        backgroundColor(0x00000000),
        renderMode(media::base::RENDER_MODE_HIDDEN),
        mirrorMode(VIDEO_MIRROR_MODE_AUTO),
        setupMode(VIDEO_VIEW_SETUP_REPLACE),
        sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
        mediaPlayerId(-ERR_NOT_READY),
        cropArea(0, 0, 0, 0),
        enableAlphaMask(false),
        position(media::base::POSITION_POST_CAPTURER) {}
 
  VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt)
      : uid(0),
        subviewUid(0),
        view(v),
        backgroundColor(0x00000000),
        renderMode(m),
        mirrorMode(mt),
        setupMode(VIDEO_VIEW_SETUP_REPLACE),
        sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
        mediaPlayerId(-ERR_NOT_READY),
        cropArea(0, 0, 0, 0),
        enableAlphaMask(false),
        position(media::base::POSITION_POST_CAPTURER) {}
 
  VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u)
      : uid(u),
        subviewUid(0),
        view(v),
        backgroundColor(0x00000000),
        renderMode(m),
        mirrorMode(mt),
        setupMode(VIDEO_VIEW_SETUP_REPLACE),
        sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
        mediaPlayerId(-ERR_NOT_READY),
        cropArea(0, 0, 0, 0),
        enableAlphaMask(false),
        position(media::base::POSITION_POST_CAPTURER) {}
 
  VideoCanvas(view_t v, media::base::RENDER_MODE_TYPE m, VIDEO_MIRROR_MODE_TYPE mt, uid_t u,
              uid_t subu)
      : uid(u),
        subviewUid(subu),
        view(v),
        backgroundColor(0x00000000),
        renderMode(m),
        mirrorMode(mt),
        setupMode(VIDEO_VIEW_SETUP_REPLACE),
        sourceType(VIDEO_SOURCE_CAMERA_PRIMARY),
        mediaPlayerId(-ERR_NOT_READY),
        cropArea(0, 0, 0, 0),
        enableAlphaMask(false),
        position(media::base::POSITION_POST_CAPTURER) {}
};
 
struct BeautyOptions {
  enum LIGHTENING_CONTRAST_LEVEL {
    LIGHTENING_CONTRAST_LOW = 0,
    LIGHTENING_CONTRAST_NORMAL = 1,
    LIGHTENING_CONTRAST_HIGH = 2,
  };
 
  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 FaceShapeAreaOptions {
  enum FACE_SHAPE_AREA {
    FACE_SHAPE_AREA_NONE = -1,
    FACE_SHAPE_AREA_HEADSCALE = 100,
    FACE_SHAPE_AREA_FOREHEAD = 101,
    FACE_SHAPE_AREA_FACECONTOUR = 102,
    FACE_SHAPE_AREA_FACELENGTH = 103,
    FACE_SHAPE_AREA_FACEWIDTH = 104,
    FACE_SHAPE_AREA_CHEEKBONE = 105,
    FACE_SHAPE_AREA_CHEEK = 106,
    FACE_SHAPE_AREA_MANDIBLE = 107,
    FACE_SHAPE_AREA_CHIN = 108,
    FACE_SHAPE_AREA_EYESCALE = 200,
    FACE_SHAPE_AREA_EYEDISTANCE = 201,
    FACE_SHAPE_AREA_EYEPOSITION = 202,
    FACE_SHAPE_AREA_LOWEREYELID = 203,
    FACE_SHAPE_AREA_EYEPUPILS = 204,
    FACE_SHAPE_AREA_EYEINNERCORNER = 205,
    FACE_SHAPE_AREA_EYEOUTERCORNER = 206,
    FACE_SHAPE_AREA_NOSELENGTH = 300,
    FACE_SHAPE_AREA_NOSEWIDTH = 301,
    FACE_SHAPE_AREA_NOSEWING = 302,
    FACE_SHAPE_AREA_NOSEROOT = 303,
    FACE_SHAPE_AREA_NOSEBRIDGE = 304,
    FACE_SHAPE_AREA_NOSETIP = 305,
    FACE_SHAPE_AREA_NOSEGENERAL = 306,
    FACE_SHAPE_AREA_MOUTHSCALE = 400,
    FACE_SHAPE_AREA_MOUTHPOSITION = 401,
    FACE_SHAPE_AREA_MOUTHSMILE = 402,
    FACE_SHAPE_AREA_MOUTHLIP = 403,
    FACE_SHAPE_AREA_EYEBROWPOSITION = 500,
    FACE_SHAPE_AREA_EYEBROWTHICKNESS = 501,
  };
 
  FACE_SHAPE_AREA shapeArea;
 
  int shapeIntensity;
 
  FaceShapeAreaOptions(FACE_SHAPE_AREA shapeArea, int areaIntensity) : shapeArea(shapeArea), shapeIntensity(areaIntensity) {}
 
  FaceShapeAreaOptions() : shapeArea(FACE_SHAPE_AREA_NONE), shapeIntensity(0) {}
};
 
struct FaceShapeBeautyOptions {
  enum FACE_SHAPE_BEAUTY_STYLE {
  FACE_SHAPE_BEAUTY_STYLE_FEMALE = 0,
  FACE_SHAPE_BEAUTY_STYLE_MALE = 1,
  FACE_SHAPE_BEAUTY_STYLE_NATURAL = 2,
  };
 
  FACE_SHAPE_BEAUTY_STYLE shapeStyle;
 
  int styleIntensity;
 
  FaceShapeBeautyOptions(FACE_SHAPE_BEAUTY_STYLE shapeStyle, int styleIntensity) : shapeStyle(shapeStyle), styleIntensity(styleIntensity) {}
 
  FaceShapeBeautyOptions() : shapeStyle(FACE_SHAPE_BEAUTY_STYLE_FEMALE), styleIntensity(50) {}
};
 
struct FilterEffectOptions {
  const char * path;
 
  float strength;
 
  FilterEffectOptions(const char * lut3dPath, float filterStrength) : path(lut3dPath), strength(filterStrength) {}
 
  FilterEffectOptions() : path(OPTIONAL_NULLPTR), strength(0.5) {}
};
 
struct LowlightEnhanceOptions {
  enum LOW_LIGHT_ENHANCE_MODE {
    LOW_LIGHT_ENHANCE_AUTO = 0,
    LOW_LIGHT_ENHANCE_MANUAL = 1,
  };
  enum LOW_LIGHT_ENHANCE_LEVEL {
    LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY = 0,
    LOW_LIGHT_ENHANCE_LEVEL_FAST = 1,
  };
 
  LOW_LIGHT_ENHANCE_MODE mode;
 
  LOW_LIGHT_ENHANCE_LEVEL level;
 
  LowlightEnhanceOptions(LOW_LIGHT_ENHANCE_MODE lowlightMode, LOW_LIGHT_ENHANCE_LEVEL lowlightLevel)
      : mode(lowlightMode), level(lowlightLevel) {}
 
  LowlightEnhanceOptions()
      : mode(LOW_LIGHT_ENHANCE_AUTO), level(LOW_LIGHT_ENHANCE_LEVEL_HIGH_QUALITY) {}
};
struct VideoDenoiserOptions {
  enum VIDEO_DENOISER_MODE {
    VIDEO_DENOISER_AUTO = 0,
    VIDEO_DENOISER_MANUAL = 1,
  };
  enum VIDEO_DENOISER_LEVEL {
    VIDEO_DENOISER_LEVEL_HIGH_QUALITY = 0,
    VIDEO_DENOISER_LEVEL_FAST = 1,
  };
  VIDEO_DENOISER_MODE mode;
 
  VIDEO_DENOISER_LEVEL level;
 
  VideoDenoiserOptions(VIDEO_DENOISER_MODE denoiserMode, VIDEO_DENOISER_LEVEL denoiserLevel)
      : mode(denoiserMode), level(denoiserLevel) {}
 
  VideoDenoiserOptions() : mode(VIDEO_DENOISER_AUTO), level(VIDEO_DENOISER_LEVEL_HIGH_QUALITY) {}
};
 
struct ColorEnhanceOptions {
  float strengthLevel;
 
  float skinProtectLevel;
 
  ColorEnhanceOptions(float stength, float skinProtect)
      : strengthLevel(stength), skinProtectLevel(skinProtect) {}
 
  ColorEnhanceOptions() : strengthLevel(0), skinProtectLevel(1) {}
};
 
struct VirtualBackgroundSource {
  enum BACKGROUND_SOURCE_TYPE {
    BACKGROUND_NONE = 0,
    BACKGROUND_COLOR = 1,
    BACKGROUND_IMG = 2,
    BACKGROUND_BLUR = 3,
    BACKGROUND_VIDEO = 4,
  };
 
  enum BACKGROUND_BLUR_DEGREE {
    BLUR_DEGREE_LOW = 1,
    BLUR_DEGREE_MEDIUM = 2,
    BLUR_DEGREE_HIGH = 3,
  };
 
  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(OPTIONAL_NULLPTR),
        blur_degree(BLUR_DEGREE_HIGH) {}
};
 
struct SegmentationProperty {
  enum SEG_MODEL_TYPE {
    SEG_MODEL_AI = 1,
    SEG_MODEL_GREEN = 2
  };
 
  enum SCREEN_COLOR_TYPE {
    SCREEN_COLOR_AUTO = 0,
    SCREEN_COLOR_GREEN = 1,
    SCREEN_COLOR_BLUE = 2
  };
 
  SEG_MODEL_TYPE modelType;
 
  float greenCapacity;
 
  SCREEN_COLOR_TYPE screenColorType;
 
  SegmentationProperty() : modelType(SEG_MODEL_AI), greenCapacity(0.5), screenColorType(SCREEN_COLOR_AUTO) {}
};
 
enum AUDIO_TRACK_TYPE {
  AUDIO_TRACK_INVALID = -1,
  AUDIO_TRACK_MIXABLE = 0,
  AUDIO_TRACK_DIRECT = 1,
};
 
struct AudioTrackConfig {
  bool enableLocalPlayback;
  bool enableAudioProcessing;
 
  AudioTrackConfig() : enableLocalPlayback(true),enableAudioProcessing(false) {}
};
 
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_BATHROOM = 0x02010110,
  ROOM_ACOUSTICS_STAIRWELL = 0x02010120,
  ROOM_ACOUSTICS_NATURE = 0x02010130,
  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,
  ROOM_ACOUSTICS_VIRTUAL_SURROUND_SOUND = 0x02010900,
  ROOM_ACOUSTICS_CHORUS = 0x02010D00,
  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,
  VOICE_CHANGER_CARTOON = 0x03010500,
  VOICE_CHANGER_CHILDLIKE = 0x03010600,
  VOICE_CHANGER_PHONE_OPERATOR = 0x03010700,
  VOICE_CHANGER_MONSTER = 0x03010800,
  VOICE_CHANGER_TRANSFORMERS = 0x03010900,
  VOICE_CHANGER_GROOT = 0x03010A00,
  VOICE_CHANGER_DARTH_VADER = 0x03010B00,
  VOICE_CHANGER_IRON_LADY = 0x03010C00,
  VOICE_CHANGER_SHIN_CHAN = 0x03010D00,
  VOICE_CHANGER_GIRLISH_MAN = 0x03010E00,
  VOICE_CHANGER_CHIPMUNK = 0x03010F00,
 
};
 
enum HEADPHONE_EQUALIZER_PRESET {
  HEADPHONE_EQUALIZER_OFF = 0x00000000,
  HEADPHONE_EQUALIZER_OVEREAR = 0x04000001,
  HEADPHONE_EQUALIZER_INEAR = 0x04000002
};
 
enum VOICE_AI_TUNER_TYPE {
  VOICE_AI_TUNER_MATURE_MALE,
  VOICE_AI_TUNER_FRESH_MALE,
  VOICE_AI_TUNER_ELEGANT_FEMALE,
  VOICE_AI_TUNER_SWEET_FEMALE,
  VOICE_AI_TUNER_WARM_MALE_SINGING,
  VOICE_AI_TUNER_GENTLE_FEMALE_SINGING,
  VOICE_AI_TUNER_HUSKY_MALE_SINGING,
  VOICE_AI_TUNER_WARM_ELEGANT_FEMALE_SINGING,
  VOICE_AI_TUNER_POWERFUL_MALE_SINGING,
  VOICE_AI_TUNER_DREAMY_FEMALE_SINGING,
};
 
struct ScreenAudioParameters {
  int sampleRate;
  int channels;
  int captureSignalVolume;
 
#if defined(__APPLE__) && !TARGET_OS_IOS
 
  bool excludeCurrentProcessAudio = true;
  ScreenAudioParameters(): sampleRate(48000), channels(2), captureSignalVolume(100) {}
#else
  ScreenAudioParameters(): sampleRate(16000), channels(2), captureSignalVolume(100) {}
#endif
};
 
struct ScreenCaptureParameters {
 
  bool captureAudio;
  ScreenAudioParameters audioParams;
 
  VideoDimensions dimensions;
  int frameRate;
  int bitrate;
  bool captureMouseCursor;
  bool windowFocus;
  view_t* excludeWindowList;
  int excludeWindowCount;
 
  int highLightWidth;
  unsigned int highLightColor;
  bool enableHighLight;
 
  ScreenCaptureParameters()
      : captureAudio(false),
        dimensions(1920, 1080),
        frameRate(5),
        bitrate(STANDARD_BITRATE),
        captureMouseCursor(true),
        windowFocus(false),
        excludeWindowList(OPTIONAL_NULLPTR),
        excludeWindowCount(0),
        highLightWidth(0),
        highLightColor(0),
        enableHighLight(false) {}
  ScreenCaptureParameters(const VideoDimensions& d, int f, int b)
      : captureAudio(false),dimensions(d),
        frameRate(f),
        bitrate(b),
        captureMouseCursor(true),
        windowFocus(false),
        excludeWindowList(OPTIONAL_NULLPTR),
        excludeWindowCount(0),
        highLightWidth(0),
        highLightColor(0),
        enableHighLight(false) {}
  ScreenCaptureParameters(int width, int height, int f, int b)
      : captureAudio(false),
        dimensions(width, height),
        frameRate(f),
        bitrate(b),
        captureMouseCursor(true),
        windowFocus(false),
        excludeWindowList(OPTIONAL_NULLPTR),
        excludeWindowCount(0),
        highLightWidth(0),
        highLightColor(0),
        enableHighLight(false) {}
  ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs)
      : captureAudio(false),
        dimensions(width, height),
        frameRate(f),
        bitrate(b),
        captureMouseCursor(cur),
        windowFocus(fcs),
        excludeWindowList(OPTIONAL_NULLPTR),
        excludeWindowCount(0),
        highLightWidth(0),
        highLightColor(0),
        enableHighLight(false) {}
  ScreenCaptureParameters(int width, int height, int f, int b, view_t* ex, int cnt)
      : captureAudio(false),
        dimensions(width, height),
        frameRate(f),
        bitrate(b),
        captureMouseCursor(true),
        windowFocus(false),
        excludeWindowList(ex),
        excludeWindowCount(cnt),
        highLightWidth(0),
        highLightColor(0),
        enableHighLight(false) {}
  ScreenCaptureParameters(int width, int height, int f, int b, bool cur, bool fcs, view_t* ex,
                          int cnt)
      : captureAudio(false),
        dimensions(width, height),
        frameRate(f),
        bitrate(b),
        captureMouseCursor(cur),
        windowFocus(fcs),
        excludeWindowList(ex),
        excludeWindowCount(cnt),
        highLightWidth(0),
        highLightColor(0),
        enableHighLight(false) {}
};
 
enum AUDIO_RECORDING_QUALITY_TYPE {
  AUDIO_RECORDING_QUALITY_LOW = 0,
  AUDIO_RECORDING_QUALITY_MEDIUM = 1,
  AUDIO_RECORDING_QUALITY_HIGH = 2,
  AUDIO_RECORDING_QUALITY_ULTRA_HIGH = 3,
};
 
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;
 
  int recordingChannel;
 
  AudioRecordingConfiguration()
      : filePath(OPTIONAL_NULLPTR),
        encode(false),
        sampleRate(32000),
        fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
        quality(AUDIO_RECORDING_QUALITY_LOW),
        recordingChannel(1) {}
 
  AudioRecordingConfiguration(const char* file_path, int sample_rate,
                              AUDIO_RECORDING_QUALITY_TYPE quality_type, int channel)
      : filePath(file_path),
        encode(false),
        sampleRate(sample_rate),
        fileRecordingType(AUDIO_FILE_RECORDING_MIXED),
        quality(quality_type),
        recordingChannel(channel) {}
 
  AudioRecordingConfiguration(const char* file_path, bool enc, int sample_rate,
                              AUDIO_FILE_RECORDING_TYPE type,
                              AUDIO_RECORDING_QUALITY_TYPE quality_type, int channel)
      : filePath(file_path),
        encode(enc),
        sampleRate(sample_rate),
        fileRecordingType(type),
        quality(quality_type),
        recordingChannel(channel) {}
 
  AudioRecordingConfiguration(const AudioRecordingConfiguration& rhs)
      : filePath(rhs.filePath),
        encode(rhs.encode),
        sampleRate(rhs.sampleRate),
        fileRecordingType(rhs.fileRecordingType),
        quality(rhs.quality),
        recordingChannel(rhs.recordingChannel) {}
};
 
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 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_HKMC = 0x00000400,
    AREA_CODE_US = 0x00000800,
    AREA_CODE_RU = 0x00001000,
    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,
};
 
enum CHANNEL_MEDIA_RELAY_STATE {
  RELAY_STATE_IDLE = 0,
  RELAY_STATE_CONNECTING = 1,
  RELAY_STATE_RUNNING = 2,
  RELAY_STATE_FAILURE = 3,
};
 
struct ChannelMediaInfo {
  uid_t uid;
  const char* channelName;
  const char* token;
 
  ChannelMediaInfo() : uid(0), channelName(NULL), token(NULL) {}
  ChannelMediaInfo(const char* c, const char* t, uid_t u) : uid(u), channelName(c), token(t) {}
};
 
struct ChannelMediaRelayConfiguration {
  ChannelMediaInfo* srcInfo;
  ChannelMediaInfo* destInfos;
  int destCount;
 
  ChannelMediaRelayConfiguration()
      : srcInfo(OPTIONAL_NULLPTR), destInfos(OPTIONAL_NULLPTR), 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* userId;
    VIDEO_STREAM_TYPE stream_type;
    REMOTE_VIDEO_DOWNSCALE_LEVEL current_downscale_level;
    int expected_bitrate_bps;
 
    PeerDownlinkInfo()
        : userId(OPTIONAL_NULLPTR),
          stream_type(VIDEO_STREAM_HIGH),
          current_downscale_level(REMOTE_VIDEO_DOWNSCALE_LEVEL_NONE),
          expected_bitrate_bps(-1) {}
 
    PeerDownlinkInfo(const PeerDownlinkInfo& rhs)
        : stream_type(rhs.stream_type),
          current_downscale_level(rhs.current_downscale_level),
          expected_bitrate_bps(rhs.expected_bitrate_bps) {
      if (rhs.userId != OPTIONAL_NULLPTR) {
        const size_t len = std::strlen(rhs.userId);
        char* buf = new char[len + 1];
        std::memcpy(buf, rhs.userId, len);
        buf[len] = '\0';
        userId = buf;
      }
    }
 
    PeerDownlinkInfo& operator=(const PeerDownlinkInfo& rhs) {
      if (this == &rhs) return *this;
      userId = OPTIONAL_NULLPTR;
      stream_type = rhs.stream_type;
      current_downscale_level = rhs.current_downscale_level;
      expected_bitrate_bps = rhs.expected_bitrate_bps;
      if (rhs.userId != OPTIONAL_NULLPTR) {
        const size_t len = std::strlen(rhs.userId);
        char* buf = new char[len + 1];
        std::memcpy(buf, rhs.userId, len);
        buf[len] = '\0';
        userId = buf;
      }
      return *this;
    }
 
    ~PeerDownlinkInfo() { delete[] userId; }
  };
 
  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() { 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];
 
  bool datastreamEncryptionEnabled;
 
  EncryptionConfig()
      : encryptionMode(AES_128_GCM2),
        encryptionKey(OPTIONAL_NULLPTR),
        datastreamEncryptionEnabled(false) {
    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,
  ENCRYPTION_ERROR_DATASTREAM_DECRYPTION_FAILURE = 3,
  ENCRYPTION_ERROR_DATASTREAM_ENCRYPTION_FAILURE = 4,
};
 
enum UPLOAD_ERROR_REASON {
  UPLOAD_SUCCESS = 0,
  UPLOAD_NET_ERROR = 1,
  UPLOAD_SERVER_ERROR = 2,
};
 
enum RENEW_TOKEN_ERROR_CODE {
  RENEW_TOKEN_SUCCESS = 0,
  RENEW_TOKEN_FAILURE = 1,
  RENEW_TOKEN_TOKEN_EXPIRED = 2,
  RENEW_TOKEN_INVALID_TOKEN = 3,
  RENEW_TOKEN_INVALID_CHANNEL_NAME = 4,
  RENEW_TOKEN_INCONSISTENT_APPID = 5,
  RENEW_TOKEN_CANCELED_BY_NEW_REQUEST = 6,
};
 
enum PERMISSION_TYPE {
  RECORD_AUDIO = 0,
  CAMERA = 1,
 
  SCREEN_CAPTURE = 2,
};
 
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 EchoTestConfiguration {
  view_t view;
  bool enableAudio;
  bool enableVideo;
  const char* token;
  const char* channelId;
  int intervalInSeconds;
 
  EchoTestConfiguration(view_t v, bool ea, bool ev, const char* t, const char* c, const int is)
      : view(v), enableAudio(ea), enableVideo(ev), token(t), channelId(c), intervalInSeconds(is) {}
 
  EchoTestConfiguration()
      : view(OPTIONAL_NULLPTR),
        enableAudio(true),
        enableVideo(true),
        token(OPTIONAL_NULLPTR),
        channelId(OPTIONAL_NULLPTR),
        intervalInSeconds(2) {}
};
 
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),
  EAR_MONITORING_FILTER_REUSE_POST_PROCESSING_FILTER = (1 << 15),
};
 
enum THREAD_PRIORITY_TYPE {
  LOWEST = 0,
  LOW = 1,
  NORMAL = 2,
  HIGH = 3,
  HIGHEST = 4,
  CRITICAL = 5,
};
 
#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS) || defined(__OHOS__)
 
struct ScreenVideoParameters {
  VideoDimensions dimensions;
  int frameRate = 15;
  int bitrate;
  VIDEO_CONTENT_HINT contentHint = VIDEO_CONTENT_HINT::CONTENT_HINT_MOTION;
 
  ScreenVideoParameters() : dimensions(1280, 720) {}
};
 
struct ScreenCaptureParameters2 {
  bool captureAudio = false;
  ScreenAudioParameters audioParams;
  bool captureVideo = true;
  ScreenVideoParameters videoParams;
};
#endif
 
enum MEDIA_TRACE_EVENT {
  MEDIA_TRACE_EVENT_VIDEO_RENDERED = 0,
  MEDIA_TRACE_EVENT_VIDEO_DECODED,
};
 
struct VideoRenderingTracingInfo {
  int elapsedTime;
  int start2JoinChannel;
  int join2JoinSuccess;
  int joinSuccess2RemoteJoined;
  int remoteJoined2SetView;
  int remoteJoined2UnmuteVideo;
  int remoteJoined2PacketReceived;
};
 
enum CONFIG_FETCH_TYPE {
  CONFIG_FETCH_TYPE_INITIALIZE = 1,
  CONFIG_FETCH_TYPE_JOIN_CHANNEL = 2,
};
 
enum LOCAL_PROXY_MODE {
  ConnectivityFirst = 0,
  LocalOnly = 1,
};
 
struct LogUploadServerInfo {
  const char* serverDomain;
  const char* serverPath;
  int serverPort;
  bool serverHttps;
 
  LogUploadServerInfo() : serverDomain(NULL), serverPath(NULL), serverPort(0), serverHttps(true) {}
 
  LogUploadServerInfo(const char* domain, const char* path, int port, bool https)
      : serverDomain(domain), serverPath(path), serverPort(port), serverHttps(https) {}
};
 
struct AdvancedConfigInfo {
  LogUploadServerInfo logUploadServer;
};
 
struct LocalAccessPointConfiguration {
  const char** ipList;
  int ipListSize;
  const char** domainList;
  int domainListSize;
  const char* verifyDomainName;
  LOCAL_PROXY_MODE mode;
  AdvancedConfigInfo advancedConfig;
  bool disableAut;
  LocalAccessPointConfiguration()
      : ipList(NULL),
        ipListSize(0),
        domainList(NULL),
        domainListSize(0),
        verifyDomainName(NULL),
        mode(ConnectivityFirst),
        disableAut(true) {}
};
 
enum RecorderStreamType {
  RTC,
  PREVIEW,
};
 
struct RecorderStreamInfo {
  const char* channelId;
  uid_t uid;
  RecorderStreamType type;
  RecorderStreamInfo() : channelId(NULL), uid(0), type(RTC) {}
  RecorderStreamInfo(const char* channelId, uid_t uid)
      : channelId(channelId), uid(uid), type(RTC) {}
  RecorderStreamInfo(const char* channelId, uid_t uid, RecorderStreamType type)
      : channelId(channelId), uid(uid), type(type) {}
};
 
enum RdtStreamType {
  RDT_STREAM_CMD,
  RDT_STREAM_DATA,
  RDT_STREAM_COUNT,
};
 
enum RdtState {
  RDT_STATE_CLOSED,
  RDT_STATE_OPENED,
  RDT_STATE_BLOCKED,
  RDT_STATE_PENDING,
  RDT_STATE_BROKEN,
};
}  // 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 = OPTIONAL_NULLPTR;
    if (engine && !engine->queryInterface(rtc::AGORA_IID_PARAMETER_ENGINE, (void**)&p)) reset(p);
    return p != OPTIONAL_NULLPTR;
  }
};
 
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;
  Optional<double> speaker_attenuation;
  Optional<bool> enable_doppler;
};
struct VideoLayout {
  const char* channelId;
  rtc::uid_t uid;
  user_id_t strUid;
  uint32_t x;
  uint32_t y;
  uint32_t width;
  uint32_t height;
  uint32_t videoState;
 
  VideoLayout()
      : channelId(OPTIONAL_NULLPTR),
        uid(0),
        strUid(OPTIONAL_NULLPTR),
        x(0),
        y(0),
        width(0),
        height(0),
        videoState(0) {}
};
}  // 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();
 
/*
 * Get monotonic time in ms which can be used by capture time,
 * typical scenario is as follows:
 *
 *  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *  |  // custom audio/video base capture time, e.g. the first audio/video capture time. | | int64_t
 * custom_capture_time_base;                                                             | | | |
 * int64_t agora_monotonic_time = getAgoraCurrentMonotonicTimeInMs();                            |
 *  | | |  // offset is fixed once calculated in the begining. | |  const int64_t offset =
 * agora_monotonic_time - custom_capture_time_base;                       | | | |  //
 * realtime_custom_audio/video_capture_time is the origin capture time that customer provided.| | //
 * actual_audio/video_capture_time is the actual capture time transfered to sdk.              | |
 * int64_t actual_audio_capture_time = realtime_custom_audio_capture_time + offset;              |
 *  |  int64_t actual_video_capture_time = realtime_custom_video_capture_time + offset; |
 *  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *
 * @return
 * - >= 0: Success.
 * - < 0: Failure.
 */
AGORA_API int64_t AGORA_CALL getAgoraCurrentMonotonicTimeInMs();