API Reference

Documentation


Video Call
Agora.io Community


Agora C++ API Reference for All Platforms
Index IRtcEngine RtcEngineParameters IRtcEngineEventHandler Warning Codes Error Codes
 //
 //  Agora Rtc Engine SDK
 //
 //  Copyright (c) 2018 Agora.io. All rights reserved.
 //
 
 #ifndef AGORA_RTC_ENGINE_H
 #define AGORA_RTC_ENGINE_H
 #include "AgoraBase.h"
 #include "IAgoraService.h"
 
 namespace agora {
 namespace rtc {
     typedef unsigned int uid_t;
     typedef void* view_t;
 enum MAX_DEVICE_ID_LENGTH_TYPE
 {
     MAX_DEVICE_ID_LENGTH = 512
 };
 enum QUALITY_REPORT_FORMAT_TYPE
 {
     QUALITY_REPORT_JSON = 0,
     QUALITY_REPORT_HTML = 1,
 };
 
 enum MEDIA_ENGINE_EVENT_CODE_TYPE
 {
     MEDIA_ENGINE_RECORDING_ERROR = 0,
     MEDIA_ENGINE_PLAYOUT_ERROR = 1,
     MEDIA_ENGINE_RECORDING_WARNING = 2,
     MEDIA_ENGINE_PLAYOUT_WARNING = 3,
     MEDIA_ENGINE_AUDIO_FILE_MIX_FINISH = 10,
     MEDIA_ENGINE_AUDIO_FAREND_MUSIC_BEGINS = 12,
     MEDIA_ENGINE_AUDIO_FAREND_MUSIC_ENDS = 13,
     MEDIA_ENGINE_LOCAL_AUDIO_RECORD_ENABLED = 14,
     MEDIA_ENGINE_LOCAL_AUDIO_RECORD_DISABLED = 15,
     // media engine role changed
     MEDIA_ENGINE_ROLE_BROADCASTER_SOLO = 20,
     MEDIA_ENGINE_ROLE_BROADCASTER_INTERACTIVE = 21,
     MEDIA_ENGINE_ROLE_AUDIENCE = 22,
     MEDIA_ENGINE_ROLE_COMM_PEER = 23,
     MEDIA_ENGINE_ROLE_GAME_PEER = 24,
     // iOS adm sample rate changed
     MEDIA_ENGINE_AUDIO_ADM_REQUIRE_RESTART = 110,
     MEDIA_ENGINE_AUDIO_ADM_SPECIAL_RESTART = 111,
 };
 enum MEDIA_DEVICE_STATE_TYPE
 {
     MEDIA_DEVICE_STATE_ACTIVE = 1,
     MEDIA_DEVICE_STATE_DISABLED = 2,
     MEDIA_DEVICE_STATE_NOT_PRESENT = 4,
     MEDIA_DEVICE_STATE_UNPLUGGED = 8
 };
 
 enum MEDIA_DEVICE_TYPE
 {
     UNKNOWN_AUDIO_DEVICE = -1,
     AUDIO_PLAYOUT_DEVICE = 0,
     AUDIO_RECORDING_DEVICE = 1,
     VIDEO_RENDER_DEVICE = 2,
     VIDEO_CAPTURE_DEVICE = 3,
     AUDIO_APPLICATION_PLAYOUT_DEVICE = 4,
 };
 
 enum AUDIO_RECORDING_QUALITY_TYPE
 {
     AUDIO_RECORDING_QUALITY_LOW = 0,
     AUDIO_RECORDING_QUALITY_MEDIUM = 1,
     AUDIO_RECORDING_QUALITY_HIGH = 2,
 };
 
 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,
 };
 
 enum RENDER_MODE_TYPE
 {
     RENDER_MODE_HIDDEN = 1,
     RENDER_MODE_FIT = 2,
     RENDER_MODE_ADAPTIVE = 3,
 };
 
 enum VIDEO_MIRROR_MODE_TYPE
 {
     VIDEO_MIRROR_MODE_AUTO = 0,//determined by SDK
     VIDEO_MIRROR_MODE_ENABLED = 1,//enabled mirror
     VIDEO_MIRROR_MODE_DISABLED = 2,//disable mirror
 };
 
 enum VIDEO_PROFILE_TYPE
 {
     VIDEO_PROFILE_LANDSCAPE_120P = 0,
     VIDEO_PROFILE_LANDSCAPE_120P_3 = 2,
     VIDEO_PROFILE_LANDSCAPE_180P = 10,
     VIDEO_PROFILE_LANDSCAPE_180P_3 = 12,
     VIDEO_PROFILE_LANDSCAPE_180P_4 = 13,
     VIDEO_PROFILE_LANDSCAPE_240P = 20,
     VIDEO_PROFILE_LANDSCAPE_240P_3 = 22,
     VIDEO_PROFILE_LANDSCAPE_240P_4 = 23,
     VIDEO_PROFILE_LANDSCAPE_360P = 30,
     VIDEO_PROFILE_LANDSCAPE_360P_3 = 32,
     VIDEO_PROFILE_LANDSCAPE_360P_4 = 33,
     VIDEO_PROFILE_LANDSCAPE_360P_6 = 35,
     VIDEO_PROFILE_LANDSCAPE_360P_7 = 36,
     VIDEO_PROFILE_LANDSCAPE_360P_8 = 37,
     VIDEO_PROFILE_LANDSCAPE_360P_9 = 38,
     VIDEO_PROFILE_LANDSCAPE_360P_10 = 39,
     VIDEO_PROFILE_LANDSCAPE_360P_11 = 100,
     VIDEO_PROFILE_LANDSCAPE_480P = 40,
     VIDEO_PROFILE_LANDSCAPE_480P_3 = 42,
     VIDEO_PROFILE_LANDSCAPE_480P_4 = 43,
     VIDEO_PROFILE_LANDSCAPE_480P_6 = 45,
     VIDEO_PROFILE_LANDSCAPE_480P_8 = 47,
     VIDEO_PROFILE_LANDSCAPE_480P_9 = 48,
     VIDEO_PROFILE_LANDSCAPE_480P_10 = 49,
     VIDEO_PROFILE_LANDSCAPE_720P = 50,
     VIDEO_PROFILE_LANDSCAPE_720P_3 = 52,
     VIDEO_PROFILE_LANDSCAPE_720P_5 = 54,
     VIDEO_PROFILE_LANDSCAPE_720P_6 = 55,
     VIDEO_PROFILE_LANDSCAPE_1080P = 60,
     VIDEO_PROFILE_LANDSCAPE_1080P_3 = 62,
     VIDEO_PROFILE_LANDSCAPE_1080P_5 = 64,
     VIDEO_PROFILE_LANDSCAPE_1440P = 66,
     VIDEO_PROFILE_LANDSCAPE_1440P_2 = 67,
     VIDEO_PROFILE_LANDSCAPE_4K = 70,
     VIDEO_PROFILE_LANDSCAPE_4K_3 = 72,
     VIDEO_PROFILE_PORTRAIT_120P = 1000,
     VIDEO_PROFILE_PORTRAIT_120P_3 = 1002,
     VIDEO_PROFILE_PORTRAIT_180P = 1010,
     VIDEO_PROFILE_PORTRAIT_180P_3 = 1012,
     VIDEO_PROFILE_PORTRAIT_180P_4 = 1013,
     VIDEO_PROFILE_PORTRAIT_240P = 1020,
     VIDEO_PROFILE_PORTRAIT_240P_3 = 1022,
     VIDEO_PROFILE_PORTRAIT_240P_4 = 1023,
     VIDEO_PROFILE_PORTRAIT_360P = 1030,
     VIDEO_PROFILE_PORTRAIT_360P_3 = 1032,
     VIDEO_PROFILE_PORTRAIT_360P_4 = 1033,
     VIDEO_PROFILE_PORTRAIT_360P_6 = 1035,
     VIDEO_PROFILE_PORTRAIT_360P_7 = 1036,
     VIDEO_PROFILE_PORTRAIT_360P_8 = 1037,
     VIDEO_PROFILE_PORTRAIT_360P_9 = 1038,
     VIDEO_PROFILE_PORTRAIT_360P_10 = 1039,
     VIDEO_PROFILE_PORTRAIT_360P_11 = 1100,
     VIDEO_PROFILE_PORTRAIT_480P = 1040,
     VIDEO_PROFILE_PORTRAIT_480P_3 = 1042,
     VIDEO_PROFILE_PORTRAIT_480P_4 = 1043,
     VIDEO_PROFILE_PORTRAIT_480P_6 = 1045,
     VIDEO_PROFILE_PORTRAIT_480P_8 = 1047,
     VIDEO_PROFILE_PORTRAIT_480P_9 = 1048,
     VIDEO_PROFILE_PORTRAIT_480P_10 = 1049,
     VIDEO_PROFILE_PORTRAIT_720P = 1050,
     VIDEO_PROFILE_PORTRAIT_720P_3 = 1052,
     VIDEO_PROFILE_PORTRAIT_720P_5 = 1054,
     VIDEO_PROFILE_PORTRAIT_720P_6 = 1055,
     VIDEO_PROFILE_PORTRAIT_1080P = 1060,
     VIDEO_PROFILE_PORTRAIT_1080P_3 = 1062,
     VIDEO_PROFILE_PORTRAIT_1080P_5 = 1064,
     VIDEO_PROFILE_PORTRAIT_1440P = 1066,
     VIDEO_PROFILE_PORTRAIT_1440P_2 = 1067,
     VIDEO_PROFILE_PORTRAIT_4K = 1070,
     VIDEO_PROFILE_PORTRAIT_4K_3 = 1072,
     VIDEO_PROFILE_DEFAULT = VIDEO_PROFILE_LANDSCAPE_360P,
 };
 
 enum AUDIO_PROFILE_TYPE // sample rate, bit rate, mono/stereo, speech/music codec
 {
     AUDIO_PROFILE_DEFAULT = 0, // use default settings
     AUDIO_PROFILE_SPEECH_STANDARD = 1, // 32Khz, 18Kbps, mono, speech
     AUDIO_PROFILE_MUSIC_STANDARD = 2, // 48Khz, 48Kbps, mono, music
     AUDIO_PROFILE_MUSIC_STANDARD_STEREO = 3, // 48Khz, 56Kbps, stereo, music
     AUDIO_PROFILE_MUSIC_HIGH_QUALITY = 4, // 48Khz, 128Kbps, mono, music
     AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO = 5, // 48Khz, 192Kbps, stereo, music
     AUDIO_PROFILE_IOT                       = 6,
     AUDIO_PROFILE_NUM = 7,
 };
 
 enum AUDIO_SCENARIO_TYPE // set a suitable scenario for your app type
 {
     AUDIO_SCENARIO_DEFAULT = 0,
     AUDIO_SCENARIO_CHATROOM_ENTERTAINMENT = 1,
     AUDIO_SCENARIO_EDUCATION = 2,
     AUDIO_SCENARIO_GAME_STREAMING = 3,
     AUDIO_SCENARIO_SHOWROOM = 4,
     AUDIO_SCENARIO_CHATROOM_GAMING = 5,
     AUDIO_SCENARIO_IOT = 6,
     AUDIO_SCENARIO_NUM = 7,
 };
 
 enum CHANNEL_PROFILE_TYPE
 {
     CHANNEL_PROFILE_COMMUNICATION = 0,
     CHANNEL_PROFILE_LIVE_BROADCASTING = 1,
     CHANNEL_PROFILE_GAME = 2,
 };
 
 enum CLIENT_ROLE_TYPE
 {
     CLIENT_ROLE_BROADCASTER = 1,
     CLIENT_ROLE_AUDIENCE = 2,
 };
 
 enum USER_OFFLINE_REASON_TYPE
 {
     USER_OFFLINE_QUIT = 0,
     USER_OFFLINE_DROPPED = 1,
     USER_OFFLINE_BECOME_AUDIENCE = 2,
 };
 
 enum INJECT_STREAM_STATUS
 {
     INJECT_STREAM_STATUS_START_SUCCESS = 0,
     INJECT_STREAM_STATUS_START_ALREADY_EXISTS = 1,
     INJECT_STREAM_STATUS_START_UNAUTHORIZED = 2,
     INJECT_STREAM_STATUS_START_TIMEDOUT = 3,
     INJECT_STREAM_STATUS_START_FAILED = 4,
     INJECT_STREAM_STATUS_STOP_SUCCESS = 5,
     INJECT_STREAM_STATUS_STOP_NOT_FOUND = 6,
     INJECT_STREAM_STATUS_STOP_UNAUTHORIZED = 7,
     INJECT_STREAM_STATUS_STOP_TIMEDOUT = 8,
     INJECT_STREAM_STATUS_STOP_FAILED = 9,
     INJECT_STREAM_STATUS_BROKEN = 10,
 };
 enum REMOTE_VIDEO_STREAM_TYPE
 {
     REMOTE_VIDEO_STREAM_HIGH = 0,
     REMOTE_VIDEO_STREAM_LOW = 1,
 };
 
 enum RAW_AUDIO_FRAME_OP_MODE_TYPE
 {
     RAW_AUDIO_FRAME_OP_MODE_READ_ONLY = 0,
     RAW_AUDIO_FRAME_OP_MODE_WRITE_ONLY = 1,
     RAW_AUDIO_FRAME_OP_MODE_READ_WRITE = 2,
 };
 
 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_EQUALIZATION_BAND_FREQUENCY
 {
     AUDIO_EQUALIZATION_BAND_31 = 0,
     AUDIO_EQUALIZATION_BAND_62 = 1,
     AUDIO_EQUALIZATION_BAND_125 = 2,
     AUDIO_EQUALIZATION_BAND_250 = 3,
     AUDIO_EQUALIZATION_BAND_500 = 4,
     AUDIO_EQUALIZATION_BAND_1K = 5,
     AUDIO_EQUALIZATION_BAND_2K = 6,
     AUDIO_EQUALIZATION_BAND_4K = 7,
     AUDIO_EQUALIZATION_BAND_8K = 8,
     AUDIO_EQUALIZATION_BAND_16K = 9,
 };
 
 enum AUDIO_REVERB_TYPE
 {
     AUDIO_REVERB_DRY_LEVEL = 0, // (dB, [-20,10]), the level of the dry signal
     AUDIO_REVERB_WET_LEVEL = 1, // (dB, [-20,10]), the level of the early reflection signal (wet signal)
     AUDIO_REVERB_ROOM_SIZE = 2, // ([0,100]), the room size of the reflection
     AUDIO_REVERB_WET_DELAY = 3, // (ms, [0,200]), the length of the initial delay of the wet signal in ms
     AUDIO_REVERB_STRENGTH = 4, // ([0,100]), the strength of the reverberation
 };
 
 enum REMOTE_VIDEO_STATE
 {
     // REMOTE_VIDEO_STATE_STOPPED is not used at this version. Ignore this value.
     // REMOTE_VIDEO_STATE_STOPPED = 0,  // Default state, video is started or remote user disabled/muted video stream
       REMOTE_VIDEO_STATE_RUNNING = 1,  // Running state, remote video can be displayed normally
       REMOTE_VIDEO_STATE_FROZEN = 2,    // Remote video is frozen, probably due to network issue.
 };
 
 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 ORIENTATION_MODE {
     ORIENTATION_MODE_ADAPTIVE = 0,
     ORIENTATION_MODE_FIXED_LANDSCAPE = 1,
     ORIENTATION_MODE_FIXED_PORTRAIT = 2,
 };
 
 enum STREAM_FALLBACK_OPTIONS
 {
     STREAM_FALLBACK_OPTION_DISABLED = 0,
     STREAM_FALLBACK_OPTION_VIDEO_STREAM_LOW = 1,
     STREAM_FALLBACK_OPTION_AUDIO_ONLY = 2,
 };
 
 struct AudioVolumeInfo
 {
     uid_t uid;
     unsigned int volume;
 };
 
 struct RtcStats
 {
     unsigned int duration;
     unsigned int txBytes;
     unsigned int rxBytes;
     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;
 };
 
 struct LocalVideoStats
 {
     int sentBitrate;
     int sentFrameRate;
 };
 struct RemoteVideoStats
 {
     uid_t uid;
     int delay;
     int width;
     int height;
     int receivedBitrate;
     int receivedFrameRate;
     REMOTE_VIDEO_STREAM_TYPE rxStreamType;
 };
 
 struct VideoCompositingLayout
 {
     struct Region {
         uid_t uid;
         double x;//[0,1]
         double y;//[0,1]
         double width;//[0,1]
         double height;//[0,1]
         int zOrder; //optional, [0, 100] //0 (default): bottom most, 100: top most
 
         double alpha;
         RENDER_MODE_TYPE renderMode;
         Region()
             :uid(0)
             , x(0)
             , y(0)
             , width(0)
             , height(0)
             , zOrder(0)
             , alpha(1.0)
             , renderMode(RENDER_MODE_HIDDEN)
         {}
 
     };
     int canvasWidth;
     int canvasHeight;
     const char* backgroundColor;
     const Region* regions;
     int regionCount;
     const char* appData;
     int appDataLength;
     VideoCompositingLayout()
         :canvasWidth(0)
         ,canvasHeight(0)
         ,backgroundColor(NULL)
         ,regions(NULL)
         , regionCount(0)
         , appData(NULL)
         , appDataLength(0)
     {}
 };
 
 struct VideoDimensions {
     int width;
     int height;
     VideoDimensions()
         : width(0), height(0)
     {}
     VideoDimensions(int w, int h)
         : width(w), height(h)
     {}
 };
 
 const int STANDARD_BITRATE = 0;
 
 const int COMPATIBLE_BITRATE = -1;
 struct VideoEncoderConfiguration {
     VideoDimensions dimensions;
     FRAME_RATE frameRate;
     int bitrate;
     ORIENTATION_MODE orientationMode;
     VideoEncoderConfiguration(
         const VideoDimensions& d, FRAME_RATE f,
         int b, ORIENTATION_MODE m)
         : dimensions(d), frameRate(f), bitrate(b), orientationMode(m)
     {}
     VideoEncoderConfiguration(
         int width, int height, FRAME_RATE f,
         int b, ORIENTATION_MODE m)
         : dimensions(width, height), frameRate(f), bitrate(b), orientationMode(m)
     {}
     VideoEncoderConfiguration()
         : frameRate(FRAME_RATE_FPS_30)
         , bitrate(0)
         , orientationMode(ORIENTATION_MODE_ADAPTIVE)
     {}
 };
 typedef struct Rect {
     int top;
     int left;
     int bottom;
     int right;
 
     Rect(): top(0), left(0), bottom(0), right(0) {}
     Rect(int t, int l, int b, int r): top(t), left(l), bottom(b), right(r) {}
 } Rect;
 
 typedef 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)
     {}
 
 } TranscodingUser;
 
 typedef struct RtcImage {
     RtcImage() :
        url(NULL),
        x(0),
        y(0),
        width(0),
        height(0)
     {}
     const char* url;
     int x;
     int y;
     int width;
     int height;
 } RtcImage;
 
 typedef struct LiveTranscoding {
     int width;
     int height;
     int videoBitrate;
     int videoFramerate;
 
     bool lowLatency;
 
     int videoGop;
     VIDEO_CODEC_PROFILE_TYPE videoCodecProfile;
     unsigned int backgroundColor;
     unsigned int userCount;
     TranscodingUser *transcodingUsers;
     const char *transcodingExtraInfo;
 
     const char *metadata;
     RtcImage* watermark;
     RtcImage* backgroundImage;
     AUDIO_SAMPLE_RATE_TYPE audioSampleRate;
     int audioBitrate;
     int audioChannels;
 
     LiveTranscoding()
         : width(360)
         , height(640)
         , videoBitrate(400)
         , videoFramerate(15)
         , lowLatency(false)
         , videoGop(30)
         , videoCodecProfile(VIDEO_CODEC_PROFILE_HIGH)
         , backgroundColor(0x000000)
         , userCount(0)
         , transcodingUsers(NULL)
         , transcodingExtraInfo(NULL)
         , watermark(NULL)
         , audioSampleRate(AUDIO_SAMPLE_RATE_48000)
         , audioBitrate(48)
         , audioChannels(1)
     {}
 } LiveTranscoding;
 
 struct InjectStreamConfig {
     int width;
     int height;
     int videoGop;
     int videoFramerate;
     int videoBitrate;
     AUDIO_SAMPLE_RATE_TYPE audioSampleRate;
     int audioBitrate;
     int audioChannels;
 
     // width / height default set to 0 means pull the stream with its original resolution
     InjectStreamConfig()
         : width(0)
         , height(0)
         , videoGop(30)
         , videoFramerate(15)
         , videoBitrate(400)
         , audioSampleRate(AUDIO_SAMPLE_RATE_48000)
         , audioBitrate(48)
         , audioChannels(1)
     {}
 };
 
 enum RTMP_STREAM_LIFE_CYCLE_TYPE
 {
     RTMP_STREAM_LIFE_CYCLE_BIND2CHANNEL = 1,
     RTMP_STREAM_LIFE_CYCLE_BIND2OWNER = 2,
 };
 
 struct PublisherConfiguration {
     int width;
     int height;
     int framerate;
     int bitrate;
     int defaultLayout;
     int lifecycle;
     bool owner;
     int injectStreamWidth;
     int injectStreamHeight;
     const char* injectStreamUrl;
     const char* publishUrl;
     const char* rawStreamUrl;
     const char* extraInfo;
 
 
     PublisherConfiguration()
         : width(640)
         , height(360)
         , framerate(15)
         , bitrate(500)
         , defaultLayout(1)
         , lifecycle(RTMP_STREAM_LIFE_CYCLE_BIND2CHANNEL)
         , owner(true)
         , injectStreamWidth(0)
         , injectStreamHeight(0)
         , injectStreamUrl(NULL)
         , publishUrl(NULL)
         , rawStreamUrl(NULL)
         , extraInfo(NULL)
     {}
 
 };
 
 #if !defined(__ANDROID__)
 
 struct VideoCanvas
 {
     view_t view;
     int renderMode;
     uid_t uid;
     void *priv; // private data (underlying video engine denotes it)
 
     VideoCanvas()
         : view(NULL)
         , renderMode(RENDER_MODE_HIDDEN)
         , uid(0)
         , priv(NULL)
     {}
     VideoCanvas(view_t v, int m, uid_t u)
         : view(v)
         , renderMode(m)
         , uid(u)
         , priv(NULL)
     {}
 };
 #else
 struct VideoCanvas;
 #endif
 
 class IPacketObserver
 {
 public:
     struct Packet
     {
         const unsigned char* buffer;
         unsigned int size;
     };
     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 IRtcEngineEventHandler
 {
 public:
     virtual ~IRtcEngineEventHandler() {}
 
     virtual void onWarning(int warn, const char* msg) {
         (void)warn;
         (void)msg;
     }
 
     virtual void onError(int err, const char* msg) {
         (void)err;
         (void)msg;
     }
 
     virtual void onJoinChannelSuccess(const char* channel, uid_t uid, int elapsed) {
         (void)channel;
         (void)uid;
         (void)elapsed;
     }
 
     virtual void onRejoinChannelSuccess(const char* channel, uid_t uid, int elapsed) {
         (void)channel;
         (void)uid;
         (void)elapsed;
     }
 
     virtual void onLeaveChannel(const RtcStats& stats) {
         (void)stats;
     }
 
     virtual void onClientRoleChanged(CLIENT_ROLE_TYPE oldRole, CLIENT_ROLE_TYPE newRole) {
     }
 
     virtual void onUserJoined(uid_t uid, int elapsed) {
         (void)uid;
         (void)elapsed;
     }
 
     virtual void onUserOffline(uid_t uid, USER_OFFLINE_REASON_TYPE reason) {
         (void)uid;
         (void)reason;
     }
 
     virtual void onLastmileQuality(int quality) {
         (void)quality;
     }
 
     virtual void onConnectionInterrupted() {}
 
     virtual void onConnectionLost() {}
 
     virtual void onConnectionBanned() {}
 
     virtual void onApiCallExecuted(int err, const char* api, const char* result) {
         (void)err;
         (void)api;
         (void)result;
     }
 
     virtual void onRequestToken() {
     }
 
     virtual void onTokenPrivilegeWillExpire(const char* token) {
         (void)token;
     }
 
     virtual void onAudioQuality(uid_t uid, int quality, unsigned short delay, unsigned short lost) {
         (void)uid;
         (void)quality;
         (void)delay;
         (void)lost;
     }
 
     virtual void onRtcStats(const RtcStats& stats) {
         (void)stats;
     }
 
     virtual void onNetworkQuality(uid_t uid, int txQuality, int rxQuality) {
     (void)uid;
     (void)txQuality;
     (void)rxQuality;
     }
 
   virtual void onLocalVideoStats(const LocalVideoStats& stats) {
     (void)stats;
     }
 
   virtual void onRemoteVideoStats(const RemoteVideoStats& stats) {
     (void)stats;
     }
 
     virtual void onAudioVolumeIndication(const AudioVolumeInfo* speakers, unsigned int speakerNumber, int totalVolume) {
         (void)speakers;
         (void)speakerNumber;
         (void)totalVolume;
     }
 
     virtual void onActiveSpeaker(uid_t uid) {
         (void)uid;
     }
 
     virtual void onVideoStopped() {}
 
     virtual void onFirstLocalVideoFrame(int width, int height, int elapsed) {
         (void)width;
         (void)height;
         (void)elapsed;
     }
 
     virtual void onFirstRemoteVideoDecoded(uid_t uid, int width, int height, int elapsed) {
         (void)uid;
         (void)width;
         (void)height;
         (void)elapsed;
     }
 
     virtual void onFirstRemoteVideoFrame(uid_t uid, int width, int height, int elapsed) {
         (void)uid;
         (void)width;
         (void)height;
         (void)elapsed;
     }
 
     virtual void onUserMuteAudio(uid_t uid, bool muted) {
         (void)uid;
         (void)muted;
     }
 
     virtual void onUserMuteVideo(uid_t uid, bool muted) {
         (void)uid;
         (void)muted;
     }
 
 
         virtual void onUserEnableVideo(uid_t uid, bool enabled) {
             (void)uid;
             (void)enabled;
         }
 
     virtual void onAudioDeviceStateChanged(const char* deviceId, int deviceType, int deviceState) {
         (void)deviceId;
         (void)deviceType;
         (void)deviceState;
     }
 
     virtual void onAudioDeviceVolumeChanged(MEDIA_DEVICE_TYPE deviceType, int volume, bool muted) {
         (void)deviceType;
         (void)volume;
         (void)muted;
     }
 
     virtual void onCameraReady() {}
 
     virtual void onCameraFocusAreaChanged(int x, int y, int width, int height) {
         (void)x;
         (void)y;
         (void)width;
         (void)height;
     }
 
     virtual void onAudioMixingFinished() {
     }
 
     virtual void onRemoteAudioMixingBegin() {
     }
     virtual void onRemoteAudioMixingEnd() {
     }
 
     virtual void onAudioEffectFinished(int soundId) {
     }
 
     virtual void onVideoDeviceStateChanged(const char* deviceId, int deviceType, int deviceState) {
         (void)deviceId;
         (void)deviceType;
         (void)deviceState;
     }
 
     virtual void onVideoSizeChanged(uid_t uid, int width, int height, int rotation) {
         (void)uid;
         (void)width;
         (void)height;
         (void)rotation;
     }
     virtual void onRemoteVideoStateChanged(uid_t uid, REMOTE_VIDEO_STATE state) {
         (void)uid;
         (void)state;
     }
 
     virtual void onUserEnableLocalVideo(uid_t uid, bool enabled) {
         (void)uid;
         (void)enabled;
     }
 
 //    virtual void onStreamError(int streamId, int code, int parameter, const char* message, size_t length) {}
     virtual void onStreamMessage(uid_t uid, int streamId, const char* data, size_t length) {
         (void)uid;
         (void)streamId;
         (void)data;
         (void)length;
     }
 
     virtual void onStreamMessageError(uid_t uid, int streamId, int code, int missed, int cached) {
         (void)uid;
         (void)streamId;
         (void)code;
         (void)missed;
         (void)cached;
     }
 
     virtual void onMediaEngineLoadSuccess() {
     }
     virtual void onMediaEngineStartCallSuccess() {
     }
 
     virtual void onFirstLocalAudioFrame(int elapsed) {
         (void)elapsed;
     }
 
     virtual void onFirstRemoteAudioFrame(uid_t uid, int elapsed) {
         (void)uid;
         (void)elapsed;
     }
 
     virtual void onStreamPublished(const char *url, int error) {
         (void)url;
         (void)error;
     }
     virtual void onStreamUnpublished(const char *url) {
         (void)url;
     }
     virtual void onTranscodingUpdated() {
     }
     virtual void onStreamInjectedStatus(const char* url, uid_t uid, int status) {
         (void)url;
         (void)uid;
         (void)status;
     }
 
     virtual void onLocalPublishFallbackToAudioOnly(bool isFallbackOrRecover) {
         (void)isFallbackOrRecover;
     }
 
     virtual void onRemoteSubscribeFallbackToAudioOnly(uid_t uid, bool isFallbackOrRecover) {
         (void)uid;
         (void)isFallbackOrRecover;
     }
 
     virtual void onRemoteAudioTransportStats(
         uid_t uid, unsigned short delay, unsigned short lost,
         unsigned short rxKBitRate) {
         (void)uid;
         (void)delay;
         (void)lost;
         (void)rxKBitRate;
     }
 
     virtual void onRemoteVideoTransportStats(
         uid_t uid, unsigned short delay, unsigned short lost,
         unsigned short rxKBitRate) {
         (void)uid;
         (void)delay;
         (void)lost;
         (void)rxKBitRate;
     }
 
     virtual void onMicrophoneEnabled(bool enabled) {
         (void)enabled;
     }
 };
 
 class IVideoDeviceCollection
 {
 public:
     virtual int getCount() = 0;
 
     virtual int getDevice(int index, char deviceName[MAX_DEVICE_ID_LENGTH], char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual int setDevice(const char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual void release() = 0;
 };
 
 class IVideoDeviceManager
 {
 public:
 
     virtual IVideoDeviceCollection* enumerateVideoDevices() = 0;
 
     virtual int startDeviceTest(view_t hwnd) = 0;
 
     virtual int stopDeviceTest() = 0;
 
     virtual int setDevice(const char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual int getDevice(char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual void release() = 0;
 };
 
 class IAudioDeviceCollection
 {
 public:
 
     virtual int getCount() = 0;
 
     virtual int getDevice(int index, char deviceName[MAX_DEVICE_ID_LENGTH], char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual int setDevice(const char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual int setApplicationVolume(int volume) = 0;
 
     virtual int getApplicationVolume(int& volume) = 0;
 
     virtual int setApplicationMute(bool mute) = 0;
     virtual int isApplicationMute(bool& mute) = 0;
     virtual void release() = 0;
 };
 class IAudioDeviceManager
 {
 public:
 
     virtual IAudioDeviceCollection* enumeratePlaybackDevices() = 0;
 
     virtual IAudioDeviceCollection* enumerateRecordingDevices() = 0;
 
     virtual int setPlaybackDevice(const char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual int setRecordingDevice(const char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual int startPlaybackDeviceTest(const char* testAudioFilePath) = 0;
 
     virtual int stopPlaybackDeviceTest() = 0;
 
     virtual int setPlaybackDeviceVolume(int volume) = 0;
 
     virtual int getPlaybackDeviceVolume(int *volume) = 0;
 
     virtual int setRecordingDeviceVolume(int volume) = 0;
 
     virtual int getRecordingDeviceVolume(int *volume) = 0;
 
     virtual int setPlaybackDeviceMute(bool mute) = 0;
     virtual int getPlaybackDeviceMute(bool *mute) = 0;
     virtual int setRecordingDeviceMute(bool mute) = 0;
 
     virtual int getRecordingDeviceMute(bool *mute) = 0;
 
     virtual int startRecordingDeviceTest(int indicationInterval) = 0;
 
     virtual int stopRecordingDeviceTest() = 0;
 
     virtual int getPlaybackDevice(char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual int getPlaybackDeviceInfo(char deviceId[MAX_DEVICE_ID_LENGTH], char deviceName[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual int getRecordingDevice(char deviceId[MAX_DEVICE_ID_LENGTH]) = 0;
 
    virtual int getRecordingDeviceInfo(char deviceId[MAX_DEVICE_ID_LENGTH], char deviceName[MAX_DEVICE_ID_LENGTH]) = 0;
 
     virtual void release() = 0;
 };
 
 struct RtcEngineContext
 {
     IRtcEngineEventHandler* eventHandler;
     const char* appId;
     RtcEngineContext()
     :eventHandler(NULL)
     ,appId(NULL)
     {}
 };
 
 class IRtcEngine
 {
 
 public:
 
     virtual int initialize(const RtcEngineContext& context) = 0;
 
     virtual void release(bool sync=false) = 0;
 
     virtual int setChannelProfile(CHANNEL_PROFILE_TYPE profile) = 0;
 
     virtual int setClientRole(CLIENT_ROLE_TYPE role) = 0;
 
     virtual int joinChannel(const char* token, const char* channelId, const char* info, uid_t uid) = 0;
 
     virtual int leaveChannel() = 0;
 
     virtual int renewToken(const char* token) = 0;
 
     virtual int queryInterface(INTERFACE_ID_TYPE iid, void** inter) = 0;
 
     virtual int startEchoTest() = 0;
 
     virtual int stopEchoTest() = 0;
 
     virtual int enableVideo() = 0;
 
     virtual int disableVideo() = 0;
 
     virtual int setVideoProfile(VIDEO_PROFILE_TYPE profile, bool swapWidthAndHeight) = 0;
 
     virtual int setVideoEncoderConfiguration(const VideoEncoderConfiguration& config) = 0;
 
     virtual int setupLocalVideo(const VideoCanvas& canvas) = 0;
 
     virtual int setupRemoteVideo(const VideoCanvas& canvas) = 0;
 
     virtual int startPreview() = 0;
 
     virtual int stopPreview() = 0;
 
     virtual int enableAudio() = 0;
 
     virtual int enableLocalAudio(bool enabled) = 0;
 
     virtual int disableAudio() = 0;
 
     virtual int setAudioProfile(AUDIO_PROFILE_TYPE profile, AUDIO_SCENARIO_TYPE scenario) = 0;
 
 #if defined(__APPLE__) || defined(_WIN32)
 #if defined(__APPLE__)
   typedef unsigned int WindowIDType;
 #elif defined(_WIN32)
   typedef HWND WindowIDType;
 #endif
 
   virtual int startScreenCapture(WindowIDType windowId, int captureFreq, const Rect *rect, int bitrate) = 0;
 
   virtual int stopScreenCapture() = 0;
 
   virtual int updateScreenCaptureRegion(const Rect *rect) = 0;
 #endif
 
     virtual int getCallId(agora::util::AString& callId) = 0;
 
     virtual int rate(const char* callId, int rating, const char* description) = 0;
 
     virtual int complain(const char* callId, const char* description) = 0;
 
     virtual const char* getVersion(int* build) = 0;
 
     virtual int enableLastmileTest() = 0;
 
     virtual int disableLastmileTest() = 0;
 
     virtual const char* getErrorDescription(int code) = 0;
 
     virtual int setEncryptionSecret(const char* secret) = 0;
 
     virtual int setEncryptionMode(const char* encryptionMode) = 0;
 
     virtual int registerPacketObserver(IPacketObserver* observer) = 0;
 
     virtual int createDataStream(int* streamId, bool reliable, bool ordered) = 0;
 
     virtual int sendStreamMessage(int streamId, const char* data, size_t length) = 0;
 
     virtual int addPublishStreamUrl(const char *url, bool transcodingEnabled) = 0;
 
     virtual int removePublishStreamUrl(const char *url) = 0;
 
     virtual int setLiveTranscoding(const LiveTranscoding &transcoding) = 0;
 
     virtual int configPublisher(const PublisherConfiguration& config) = 0;
 
     virtual int setVideoCompositingLayout(const VideoCompositingLayout& sei) = 0;
 
     virtual int clearVideoCompositingLayout() = 0;
 
     virtual int addVideoWatermark(const RtcImage& watermark) = 0;
 
     virtual int clearVideoWatermarks() = 0;
 
     virtual int addInjectStreamUrl(const char* url, const InjectStreamConfig& config) = 0;
 
     virtual int removeInjectStreamUrl(const char* url) = 0;
     virtual bool registerEventHandler(IRtcEngineEventHandler *eventHandler) = 0;
     virtual bool unregisterEventHandler(IRtcEngineEventHandler *eventHandler) = 0;
 };
 
 
 class IRtcEngineParameter
 {
 public:
     virtual void release() = 0;
 
     virtual int setBool(const char* key, bool value) = 0;
 
     virtual int setInt(const char* key, int value) = 0;
 
     virtual int setUInt(const char* key, unsigned int value) = 0;
 
     virtual int setNumber(const char* key, double value) = 0;
 
     virtual int setString(const char* key, const char* value) = 0;
 
     virtual int setObject(const char* key, const char* value) = 0;
 
     virtual int getBool(const char* key, bool& value) = 0;
 
     virtual int getInt(const char* key, int& value) = 0;
 
     virtual int getUInt(const char* key, unsigned int& value) = 0;
 
     virtual int getNumber(const char* key, double& value) = 0;
 
     virtual int getString(const char* key, agora::util::AString& value) = 0;
 
     virtual int getObject(const char* key, agora::util::AString& value) = 0;
 
     virtual int getArray(const char* key, agora::util::AString& value) = 0;
 
     virtual int setParameters(const char* parameters) = 0;
 
     virtual int setProfile(const char* profile, bool merge) = 0;
 
     virtual int convertPath(const char* filePath, agora::util::AString& value) = 0;
 };
 
 class AAudioDeviceManager : public agora::util::AutoPtr<IAudioDeviceManager>
 {
 public:
     AAudioDeviceManager(IRtcEngine* engine)
     {
         queryInterface(engine, AGORA_IID_AUDIO_DEVICE_MANAGER);
     }
 };
 
 class AVideoDeviceManager : public agora::util::AutoPtr<IVideoDeviceManager>
 {
 public:
     AVideoDeviceManager(IRtcEngine* engine)
     {
         queryInterface(engine, AGORA_IID_VIDEO_DEVICE_MANAGER);
     }
 };
 
 class AParameter : public agora::util::AutoPtr<IRtcEngineParameter>
 {
 public:
     AParameter(IRtcEngine& engine) { initialize(&engine); }
     AParameter(IRtcEngine* engine) { initialize(engine); }
     AParameter(IRtcEngineParameter* p) :agora::util::AutoPtr<IRtcEngineParameter>(p) {}
 private:
     bool initialize(IRtcEngine* engine)
     {
         IRtcEngineParameter* p = NULL;
         if (engine && !engine->queryInterface(AGORA_IID_RTC_ENGINE_PARAMETER, (void**)&p))
             reset(p);
         return p != NULL;
     }
 };
 class RtcEngineParameters
 {
 public:
     RtcEngineParameters(IRtcEngine& engine)
         :m_parameter(&engine){}
     RtcEngineParameters(IRtcEngine* engine)
         :m_parameter(engine){}
 
     int enableLocalVideo(bool enabled) {
         return setParameters("{\"rtc.video.capture\":%s,\"che.video.local.capture\":%s,\"che.video.local.render\":%s,\"che.video.local.send\":%s}", enabled ? "true" : "false", enabled ? "true" : "false", enabled ? "true" : "false", enabled ? "true" : "false");
     }
 
 
     int muteLocalVideoStream(bool mute) {
         return setParameters("{\"rtc.video.mute_me\":%s,\"che.video.local.send\":%s}", mute ? "true" : "false", mute ? "false" : "true");
     }
 
     int muteAllRemoteVideoStreams(bool mute) {
         return m_parameter ? m_parameter->setBool("rtc.video.mute_peers", mute) : -ERR_NOT_INITIALIZED;
     }
 
 
     int setDefaultMuteAllRemoteVideoStreams(bool mute) {
         return m_parameter ? m_parameter->setBool("rtc.video.set_default_mute_peers", mute) : -ERR_NOT_INITIALIZED;
     }
 
     int muteRemoteVideoStream(uid_t uid, bool mute) {
         return setObject("rtc.video.mute_peer", "{\"uid\":%u,\"mute\":%s}", uid, mute ? "true" : "false");
     }
 
     int setPlaybackDeviceVolume(int volume) {// [0,255]
         return m_parameter ? m_parameter->setInt("che.audio.output.volume", volume) : -ERR_NOT_INITIALIZED;
     }
 
     int startAudioRecording(const char* filePath, AUDIO_RECORDING_QUALITY_TYPE quality) {
         if (!m_parameter) return -ERR_NOT_INITIALIZED;
 #if defined(_WIN32)
         util::AString path;
         if (!m_parameter->convertPath(filePath, path))
             filePath = path->c_str();
         else
             return -ERR_INVALID_ARGUMENT;
 #endif
         return setObject("che.audio.start_recording", "{\"filePath\":\"%s\",\"quality\":%d}", filePath, quality);
     }
 
     int stopAudioRecording() {
         return m_parameter ? m_parameter->setBool("che.audio.stop_recording", true) : -ERR_NOT_INITIALIZED;
     }
 
     int startAudioMixing(const char* filePath, bool loopback, bool replace, int cycle) {
         if (!m_parameter) return -ERR_NOT_INITIALIZED;
 #if defined(_WIN32)
         util::AString path;
         if (!m_parameter->convertPath(filePath, path))
             filePath = path->c_str();
         else
             return -ERR_INVALID_ARGUMENT;
 #endif
         return setObject("che.audio.start_file_as_playout", "{\"filePath\":\"%s\",\"loopback\":%s,\"replace\":%s,\"cycle\":%d}",
                          filePath,
                          loopback?"true":"false",
                          replace?"true":"false",
                          cycle);
     }
 
     int stopAudioMixing() {
         return m_parameter ? m_parameter->setBool("che.audio.stop_file_as_playout", true) : -ERR_NOT_INITIALIZED;
     }
 
     int pauseAudioMixing() {
         return m_parameter ? m_parameter->setBool("che.audio.pause_file_as_playout", true) : -ERR_NOT_INITIALIZED;
     }
 
     int resumeAudioMixing() {
         return m_parameter ? m_parameter->setBool("che.audio.pause_file_as_playout", false) : -ERR_NOT_INITIALIZED;
     }
 
     int adjustAudioMixingVolume(int volume) {
         return m_parameter ? m_parameter->setInt("che.audio.set_file_as_playout_volume", volume) : -ERR_NOT_INITIALIZED;
     }
 
     int getAudioMixingDuration() {
         int duration = 0;
         int r = m_parameter ? m_parameter->getInt("che.audio.get_mixing_file_length_ms", duration) : -ERR_NOT_INITIALIZED;
         if (r == 0)
             r = duration;
         return r;
     }
 
     int getAudioMixingCurrentPosition() {
         if (!m_parameter) return -ERR_NOT_INITIALIZED;
         int pos = 0;
         int r = m_parameter->getInt("che.audio.get_mixing_file_played_ms", pos);
         if (r == 0)
             r = pos;
         return r;
     }
     int setAudioMixingPosition(int pos /*in ms*/) {
         return m_parameter ? m_parameter->setInt("che.audio.mixing.file.position", pos) : -ERR_NOT_INITIALIZED;
     }
 
     int getEffectsVolume() {
         if (!m_parameter) return -ERR_NOT_INITIALIZED;
         int volume = 0;
         int r = m_parameter->getInt("che.audio.game_get_effects_volume", volume);
         if (r == 0)
             r = volume;
         return r;
     }
 
     int setEffectsVolume(int volume) {
         return m_parameter ? m_parameter->setInt("che.audio.game_set_effects_volume", volume) : -ERR_NOT_INITIALIZED;
     }
 
     int setVolumeOfEffect(int soundId, int volume) {
         return setObject(
                          "che.audio.game_adjust_effect_volume",
                          "{\"soundId\":%d,\"gain\":%d}",
                          soundId, volume);
     }
 
     int playEffect(int soundId, const char* filePath, int loopCount, double pitch, double pan, int gain, bool publish = false) {
 #if defined(_WIN32)
         util::AString path;
         if (!m_parameter->convertPath(filePath, path))
             filePath = path->c_str();
         else if (!filePath)
             filePath = "";
 #endif
         return setObject(
                          "che.audio.game_play_effect",
                          "{\"soundId\":%d,\"filePath\":\"%s\",\"loopCount\":%d, \"pitch\":%lf,\"pan\":%lf,\"gain\":%d, \"send2far\":%d}",
                          soundId, filePath, loopCount, pitch, pan, gain, publish);
     }
 
     int stopEffect(int soundId) {
         return m_parameter ? m_parameter->setInt(
                                                  "che.audio.game_stop_effect", soundId) : -ERR_NOT_INITIALIZED;
     }
 
     int stopAllEffects() {
         return m_parameter ? m_parameter->setBool(
                                                   "che.audio.game_stop_all_effects", true) : -ERR_NOT_INITIALIZED;
     }
 
     int preloadEffect(int soundId, char* filePath) {
         return setObject(
                          "che.audio.game_preload_effect",
                          "{\"soundId\":%d,\"filePath\":\"%s\"}",
                          soundId, filePath);
     }
 
     int unloadEffect(int soundId) {
         return m_parameter ? m_parameter->setInt(
                                                  "che.audio.game_unload_effect", soundId) : -ERR_NOT_INITIALIZED;
     }
 
     int pauseEffect(int soundId) {
         return m_parameter ? m_parameter->setInt(
                                                  "che.audio.game_pause_effect", soundId) : -ERR_NOT_INITIALIZED;
     }
 
     int pauseAllEffects() {
         return m_parameter ? m_parameter->setBool(
                                                   "che.audio.game_pause_all_effects", true) : -ERR_NOT_INITIALIZED;
     }
 
     int resumeEffect(int soundId) {
         return m_parameter ? m_parameter->setInt(
                                                  "che.audio.game_resume_effect", soundId) : -ERR_NOT_INITIALIZED;
     }
 
     int resumeAllEffects() {
         return m_parameter ? m_parameter->setBool(
                                                   "che.audio.game_resume_all_effects", true) : -ERR_NOT_INITIALIZED;
     }
 
     int setLocalVoicePitch(double pitch) {
         return m_parameter ? m_parameter->setInt(
                                                  "che.audio.morph.pitch_shift",
                                                  static_cast<int>(pitch * 100)) : -ERR_NOT_INITIALIZED;
     }
     int setLocalVoiceEqualization(AUDIO_EQUALIZATION_BAND_FREQUENCY bandFrequency, int bandGain) {
         return setObject(
                          "che.audio.morph.equalization",
                          "{\"index\":%d,\"gain\":%d}",
                          static_cast<int>(bandFrequency), bandGain);
     }
     int setLocalVoiceReverb(AUDIO_REVERB_TYPE reverbKey, int value) {
         return setObject(
                          "che.audio.morph.reverb",
                          "{\"key\":%d,\"value\":%d}",
                          static_cast<int>(reverbKey), value);
     }
 
     int pauseAudio() {
         return m_parameter ? m_parameter->setBool("che.pause.audio", true) : -ERR_NOT_INITIALIZED;
     }
 
     int resumeAudio() {
         return m_parameter ? m_parameter->setBool("che.pause.audio", false) : -ERR_NOT_INITIALIZED;
     }
 
     int setHighQualityAudioParameters(bool fullband, bool stereo, bool fullBitrate) {
         return setObject("che.audio.codec.hq", "{\"fullband\":%s,\"stereo\":%s,\"fullBitrate\":%s}", fullband ? "true" : "false", stereo ? "true" : "false", fullBitrate ? "true" : "false");
     }
 
     int adjustRecordingSignalVolume(int volume) {//[0, 400]: e.g. 50~0.5x 100~1x 400~4x
         if (volume < 0)
             volume = 0;
         else if (volume > 400)
             volume = 400;
         return m_parameter ? m_parameter->setInt("che.audio.record.signal.volume", volume) : -ERR_NOT_INITIALIZED;
     }
 
     int adjustPlaybackSignalVolume(int volume) {//[0, 400]
         if (volume < 0)
             volume = 0;
         else if (volume > 400)
             volume = 400;
         return m_parameter ? m_parameter->setInt("che.audio.playout.signal.volume", volume) : -ERR_NOT_INITIALIZED;
     }
 
     int enableAudioVolumeIndication(int interval, int smooth) { // in ms: <= 0: disable, > 0: enable, interval in ms
         if (interval < 0)
             interval = 0;
         return setObject("che.audio.volume_indication", "{\"interval\":%d,\"smooth\":%d}", interval, smooth);
     }
 
     int muteLocalAudioStream(bool mute) {
         return setParameters("{\"rtc.audio.mute_me\":%s,\"che.audio.mute_me\":%s}", mute ? "true" : "false", mute ? "true" : "false");
     }
     // mute/unmute all peers. unmute will clear all muted peers specified mutePeer() interface
 
     int muteRemoteAudioStream(uid_t uid, bool mute) {
         return setObject("rtc.audio.mute_peer", "{\"uid\":%u,\"mute\":%s}", uid, mute?"true":"false");
     }
 
     int muteAllRemoteAudioStreams(bool mute) {
         return m_parameter ? m_parameter->setBool("rtc.audio.mute_peers", mute) : -ERR_NOT_INITIALIZED;
     }
 
     int setDefaultMuteAllRemoteAudioStreams(bool mute) {
         return m_parameter ? m_parameter->setBool("rtc.audio.set_default_mute_peers", mute) : -ERR_NOT_INITIALIZED;
     }
 
     int setExternalAudioSource(bool enabled, int sampleRate, int channels) {
         if (enabled)
             return setParameters("{\"che.audio.external_capture\":true,\"che.audio.external_capture.push\":true,\"che.audio.set_capture_raw_audio_format\":{\"sampleRate\":%d,\"channelCnt\":%d,\"mode\":%d}}", sampleRate, channels, RAW_AUDIO_FRAME_OP_MODE_TYPE::RAW_AUDIO_FRAME_OP_MODE_READ_WRITE);
         else
             return setParameters("{\"che.audio.external_capture\":false,\"che.audio.external_capture.push\":false}");
     }
 
     int setLogFile(const char* filePath) {
         if (!m_parameter) return -ERR_NOT_INITIALIZED;
 #if defined(_WIN32)
         util::AString path;
         if (!m_parameter->convertPath(filePath, path))
             filePath = path->c_str();
         else if (!filePath)
             filePath = "";
 #endif
         return m_parameter->setString("rtc.log_file", filePath);
     }
 
     int setLogFilter(unsigned int filter) {
         return m_parameter ? m_parameter->setUInt("rtc.log_filter", filter&LOG_FILTER_MASK) : -ERR_NOT_INITIALIZED;
     }
 
     int setLocalRenderMode(RENDER_MODE_TYPE renderMode) {
         return setRemoteRenderMode(0, renderMode);
     }
 
     int setRemoteRenderMode(uid_t uid, RENDER_MODE_TYPE renderMode) {
         return setObject("che.video.render_mode", "{\"uid\":%u,\"mode\":%d}", uid, renderMode);
     }
 
 
     int enableDualStreamMode(bool enabled) {
         return setParameters("{\"rtc.dual_stream_mode\":%s,\"che.video.enableLowBitRateStream\":%d}", enabled ? "true" : "false", enabled ? 1 : 0);
     }
 
     int setRemoteVideoStreamType(uid_t uid, REMOTE_VIDEO_STREAM_TYPE streamType) {
         return setParameters("{\"rtc.video.set_remote_video_stream\":{\"uid\":%u,\"stream\":%d}, \"che.video.setstream\":{\"uid\":%u,\"stream\":%d}}", uid, streamType, uid, streamType);
 //        return setObject("rtc.video.set_remote_video_stream", "{\"uid\":%u,\"stream\":%d}", uid, streamType);
     }
 
     int setRemoteDefaultVideoStreamType(REMOTE_VIDEO_STREAM_TYPE streamType) {
         return m_parameter ? m_parameter->setInt("rtc.video.set_remote_default_video_stream_type", streamType) : -ERR_NOT_INITIALIZED;
     }
 
     int setRecordingAudioFrameParameters(int sampleRate, int channel, RAW_AUDIO_FRAME_OP_MODE_TYPE mode, int samplesPerCall) {
         return setObject("che.audio.set_capture_raw_audio_format", "{\"sampleRate\":%d,\"channelCnt\":%d,\"mode\":%d,\"samplesPerCall\":%d}", sampleRate, channel, mode, samplesPerCall);
     }
     int setPlaybackAudioFrameParameters(int sampleRate, int channel, RAW_AUDIO_FRAME_OP_MODE_TYPE mode, int samplesPerCall) {
         return setObject("che.audio.set_render_raw_audio_format", "{\"sampleRate\":%d,\"channelCnt\":%d,\"mode\":%d,\"samplesPerCall\":%d}", sampleRate, channel, mode, samplesPerCall);
     }
     int setMixedAudioFrameParameters(int sampleRate, int samplesPerCall) {
         return setObject("che.audio.set_mixed_raw_audio_format", "{\"sampleRate\":%d,\"samplesPerCall\":%d}", sampleRate, samplesPerCall);
     }
 
     int enableWebSdkInteroperability(bool enabled) {//enable interoperability with zero-plugin web sdk
         return setParameters("{\"rtc.video.web_h264_interop_enable\":%s,\"che.video.web_h264_interop_enable\":%s}", enabled ? "true" : "false", enabled ? "true" : "false");
     }
 
     //only for live broadcast
     int setVideoQualityParameters(bool preferFrameRateOverImageQuality) {
         return setParameters("{\"rtc.video.prefer_frame_rate\":%s,\"che.video.prefer_frame_rate\":%s}", preferFrameRateOverImageQuality ? "true" : "false", preferFrameRateOverImageQuality ? "true" : "false");
     }
 
     int setLocalVideoMirrorMode(VIDEO_MIRROR_MODE_TYPE mirrorMode) {
         if (!m_parameter) return -ERR_NOT_INITIALIZED;
         const char *value;
         switch (mirrorMode) {
             case VIDEO_MIRROR_MODE_AUTO:
                 value = "default";
                 break;
             case VIDEO_MIRROR_MODE_ENABLED:
                 value = "forceMirror";
                 break;
             case VIDEO_MIRROR_MODE_DISABLED:
                 value = "disableMirror";
                 break;
             default:
                 return -ERR_INVALID_ARGUMENT;
         }
         return m_parameter->setString("che.video.localViewMirrorSetting", value);
     }
 
     int setLocalPublishFallbackOption(STREAM_FALLBACK_OPTIONS option) {
         return m_parameter ? m_parameter->setInt("rtc.local_publish_fallback_option", option) : -ERR_NOT_INITIALIZED;
     }
 
     int setRemoteSubscribeFallbackOption(STREAM_FALLBACK_OPTIONS option) {
         return m_parameter ? m_parameter->setInt("rtc.remote_subscribe_fallback_option", option) : -ERR_NOT_INITIALIZED;
     }
 
     int enableLoopbackRecording(bool enabled, const char* deviceName = NULL) {
         if (!deviceName) {
             return setParameters("{\"che.audio.loopback.recording\":%s}", enabled ? "true" : "false");
         }
         else {
             return setParameters("{\"che.audio.loopback.deviceName\":\"%s\",\"che.audio.loopback.recording\":%s}", deviceName, enabled ? "true" : "false");
         }
     }
 
     int setInEarMonitoringVolume(int volume) {
         return m_parameter ? m_parameter->setInt("che.audio.headset.monitoring.parameter", volume) : -ERR_NOT_INITIALIZED;
     }
 
 protected:
     AParameter& parameter() {
         return m_parameter;
     }
     int setParameters(const char* format, ...) {
         char buf[512];
         va_list args;
         va_start(args, format);
         vsnprintf(buf, sizeof(buf)-1, format, args);
         va_end(args);
         return m_parameter ? m_parameter->setParameters(buf) : -ERR_NOT_INITIALIZED;
     }
     int setObject(const char* key, const char* format, ...) {
         char buf[512];
         va_list args;
         va_start(args, format);
         vsnprintf(buf, sizeof(buf)-1, format, args);
         va_end(args);
         return m_parameter ? m_parameter->setObject(key, buf) : -ERR_NOT_INITIALIZED;
     }
     int stopAllRemoteVideo() {
         return m_parameter ? m_parameter->setBool("che.video.peer.stop_render", true) : -ERR_NOT_INITIALIZED;
     }
 private:
     AParameter m_parameter;
 };
 
 } //namespace rtc
 } // namespace agora
 
 #define getAgoraRtcEngineVersion getAgoraSdkVersion
 
 
 
 AGORA_API agora::rtc::IRtcEngine* AGORA_CALL createAgoraRtcEngine();
 
 
 
 #define getAgoraRtcEngineErrorDescription getAgoraSdkErrorDescription
 #define setAgoraRtcEngineExternalSymbolLoader setAgoraSdkExternalSymbolLoader
 
 #endif