IAgoraLinuxSdkCommon.h

Go to the documentation of this file.

           #ifndef _IAGORA_LINUXSDKCOMMON_H_
        

           #define _IAGORA_LINUXSDKCOMMON_H_
        


           #include <cstdint>
        

           #include <string>
        

           #include <string.h>
        


           namespace agora {
        

           namespace linuxsdk {
        


           class IEngine{
        

           
          virtual ~IEngine() {};
        

};


           class IEngineConfig
          {
        

           
          virtual ~IEngineConfig() {};
        
};


           typedef unsigned
          char
          uchar_t;
        

           typedef unsigned
          int
          uint_t;
        

           typedef unsigned
          int
          uid_t;
        

           typedef uint64_t
          u64_t;
        


           enum
          ERROR_CODE_TYPE
          {
        


           
          ERR_OK
          = 0,
        

           
          //1~1000
        

           
          ERR_FAILED
          = 1,
        

           
          ERR_INVALID_ARGUMENT
          = 2,
        

           
          ERR_INTERNAL_FAILED
          = 3,
        
};


           enum
          STAT_CODE_TYPE
          {
        

           
          STAT_OK
          = 0,
        

           
          STAT_ERR_FROM_ENGINE
          = 1,
        

           
          STAT_ERR_ARS_JOIN_CHANNEL
          = 2,
        

           
          STAT_ERR_CREATE_PROCESS
          = 3,
        

           
          STAT_ERR_MIXED_INVALID_VIDEO_PARAM
          = 4,
        

           
          STAT_ERR_NULL_POINTER
          = 5,
        

           
          STAT_ERR_PROXY_SERVER_INVALID_PARAM
          = 6,
        


           
          STAT_POLL_ERR
          = 0x8,
        

           
          STAT_POLL_HANG_UP
          = 0x10,
        

           
          STAT_POLL_NVAL
          = 0x20,
        
};


           enum
          LEAVE_PATH_CODE
          {
        

           
          LEAVE_CODE_INIT
          = 0,
        

           
          LEAVE_CODE_SIG
          = 1<<1,
        

           
          LEAVE_CODE_NO_USERS
          = 1<<2,
        

           
          LEAVE_CODE_TIMER_CATCH
          = 1<<3,
        

           
          LEAVE_CODE_CLIENT_LEAVE
          = 1 << 4,
        
};


           enum
          WARN_CODE_TYPE
          {
        

           
          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,
        

           
          WARN_RECOVERY_CORE_SERVICE_FAILURE
          = 108,
        

           
          WARN_DECRYPTION_FAILED
          = 120,
        
};


           enum
          CHANNEL_PROFILE_TYPE
        
{

           
          CHANNEL_PROFILE_COMMUNICATION
          = 0,
        

           
          CHANNEL_PROFILE_LIVE_BROADCASTING
          = 1,
        
};


           enum
          USER_OFFLINE_REASON_TYPE
        
{

           
          USER_OFFLINE_QUIT
          = 0,
        

           
          USER_OFFLINE_DROPPED
          = 1,
        

           
          USER_OFFLINE_BECOME_AUDIENCE
          = 2,
        
};


           enum
          REMOTE_VIDEO_STREAM_TYPE
        
{

           
          REMOTE_VIDEO_STREAM_HIGH
          = 0,
        

           
          REMOTE_VIDEO_STREAM_LOW
          = 1,
        
};


           enum
          VIDEO_FORMAT_TYPE
          {
        

           
          VIDEO_FORMAT_DEFAULT_TYPE
          = 0,
        

           
          VIDEO_FORMAT_H264_FRAME_TYPE
          = 1,
        

           
          VIDEO_FORMAT_ENCODED_FRAME_TYPE
          =
          VIDEO_FORMAT_H264_FRAME_TYPE,
        

           
          VIDEO_FORMAT_YUV_FRAME_TYPE
          = 2,
        

           
          VIDEO_FORMAT_JPG_FRAME_TYPE
          = 3,
        

           
          VIDEO_FORMAT_JPG_FILE_TYPE
          = 4,
        

           
          VIDEO_FORMAT_JPG_VIDEO_FILE_TYPE
          = 5,
        
};


           enum
          AUDIO_FORMAT_TYPE
          {
        

           
          AUDIO_FORMAT_DEFAULT_TYPE
          = 0,
        

           
          AUDIO_FORMAT_AAC_FRAME_TYPE
          = 1,
        

           
          AUDIO_FORMAT_PCM_FRAME_TYPE
          = 2,
        

           
          AUDIO_FORMAT_MIXED_PCM_FRAME_TYPE
          = 3,
        
};


           enum
          AUDIO_FRAME_TYPE
          {
        

           
          AUDIO_FRAME_RAW_PCM
          = 0,
        

           
          AUDIO_FRAME_AAC
          = 1
        

           };
        


           enum
          MEMORY_TYPE
          {
        

           
          STACK_MEM_TYPE
          = 0,
        

           
          HEAP_MEM_TYPE
          = 1
        

           };
        


           enum
          VIDEO_FRAME_TYPE
          {
        

           
          VIDEO_FRAME_RAW_YUV
          = 0,
        

           
          VIDEO_FRAME_H264
          = 1,
        

           
          VIDEO_FRAME_JPG
          = 2,
        

           
          VIDEO_FRAME_H265
          = 3,
        

           
          VIDEO_JPG_FILE
          = 4,
        
};


           enum
          SERVICE_MODE
          {
        

           
          RECORDING_MODE
          = 0,//down stream
        

           
          SERVER_MODE
          = 1,//up-down stream
        

           
          IOT_MODE
          = 2,//up-down stream
        
};


           enum
          TRIGGER_MODE_TYPE
          {
        

           
          AUTOMATICALLY_MODE
          = 0,
        

           
          MANUALLY_MODE
          = 1
        

           };
        


           enum
          LANGUAGE_TYPE
          {
        

           
          CPP_LANG
          = 0,
        

           
          JAVA_LANG
          = 1
        

           };
        


           enum
          AUDIO_PROFILE_TYPE
          {
        

           
          AUDIO_PROFILE_DEFAULT
          = 0, //use default settings.
        

           
          AUDIO_PROFILE_HIGH_QUALITY
          = 1, //48khz, 128kbps, mono, music
        

           
          AUDIO_PROFILE_HIGH_QUALITY_STEREO
          = 2, //48khz, 192kbps, stereo, music
        
};


           enum
          agora_log_level
          {
        

           
          AGORA_LOG_LEVEL_FATAL
          = 1,
        

           
          AGORA_LOG_LEVEL_ERROR
          = 2,
        

           
          AGORA_LOG_LEVEL_WARN
          = 3,
        

           
          AGORA_LOG_LEVEL_NOTICE
          = 4,
        

           
          AGORA_LOG_LEVEL_INFO
          = 5,
        

           
          AGORA_LOG_LEVEL_DEBUG
          = 6,
        
};


           enum
          RemoteStreamStateChangedReason
          {
        

           
          REASON_REMOTE_STREAM_STARTED,
        

           
          REASON_REMOTE_STREAM_STOPPED
        

           };
        


           enum
          RemoteStreamState
          {
        

           
          REMOTE_STREAM_STATE_RUNNING,
        

           
          REMOTE_STREAM_STATE_STOPPED
        

           };
        


           enum
          MIXED_AV_CODEC_TYPE
          {
        

           
          MIXED_AV_DEFAULT
          = 0,
        

           
          MIXED_AV_CODEC_V1
          = 1,
        

           
          MIXED_AV_CODEC_V2
          = 2,
        

           
          AV_CODEC_INDIVIDUAL_TS_ONLY
          = 4,
        

           
          AV_CODEC_INDIVIDUAL_TS_AND_MP4
          = 5,
        

           
          AV_CODEC_MIXED_TS_ONLY
          = 6,
        

           
          AV_CODEC_MIXED_TS_AND_MP4
          = 7
        

           };
        


           enum
          ClientRoleType
          {
        

           
          CLIENT_ROLE_BROADCASTER
          = 1,
        

           
          CLIENT_ROLE_AUDIENCE
          =2,
        
};


           enum
          ConnectionStateType
        
{

           
          CONNECTION_STATE_DISCONNECTED
          = 1,
        

           
          CONNECTION_STATE_CONNECTING
          = 2,
        

           
          CONNECTION_STATE_CONNECTED
          = 3,
        

           
          CONNECTION_STATE_RECONNECTING
          = 4,
        

           
          CONNECTION_STATE_FAILED
          = 5,
        
};



           enum
          ConnectionChangedReasonType
        
{

           
          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,
        
};


           enum
          MAX_USER_ACCOUNT_LENGTH_TYPE
        
{

           
          MAX_USER_ACCOUNT_LENGTH
          = 256
        

           };
        


           struct UserInfo {
        

           
          uid_t
          uid;
        

            char
          userAccount[MAX_USER_ACCOUNT_LENGTH];
        

           
          UserInfo()
        

            :
          uid(0) {
        

           
          userAccount[0] = '\0';
        
 }
};


           /* Properties of the audio volume information. An array containing the user ID and
            volume information for each speaker. */
        

           struct AudioVolumeInfo
          {
        

           
          /* The user ID of the speaker. The uid of the local user is 0. */
        

           
          uid_t
          uid;
        

           
          /*The volume of the speaker. The value ranges between 0 (lowest volume) and 255
            (highest volume).*/
        

            uint32_t
          volume;
        


           
          AudioVolumeInfo()
        

            :
          uid(0),
          volume(0) { }
        
};


           struct RemoteVideoStats
          {
        

            int
          delay;
        

            int
          width;
        

            int
          height;
        

            int
          receivedBitrate;
        

            int
          decoderOutputFrameRate;
        

           
          REMOTE_VIDEO_STREAM_TYPE
          rxStreamType;
        


           
          RemoteVideoStats()
        

            :
          delay(0),
        

           
          width(0),
        

           
          height(0),
        

           
          receivedBitrate(0),
        

           
          decoderOutputFrameRate(0),
        

           
          rxStreamType(REMOTE_VIDEO_STREAM_HIGH) {}
        
};


           struct RemoteAudioStats
          {
        

            int
          quality;
        

            int
          networkTransportDelay;
        

            int
          jitterBufferDelay;
        

            int
          audioLossRate;
        


           
          RemoteAudioStats()
        

            :
          quality(0),
        

           
          networkTransportDelay(0),
        

           
          jitterBufferDelay(0),
        

           
          audioLossRate(0) {}
        
};


           struct RecordingStats
        
{

            uint32_t
          duration;
        

            uint32_t
          rxBytes;
        

            uint32_t
          rxKBitRate;
        

            uint32_t
          rxAudioKBitRate;
        

            uint32_t
          rxVideoKBitRate;
        

            uint32_t
          lastmileDelay;
        

            uint32_t
          userCount;
        

            double
          cpuAppUsage;
        

            double
          cpuTotalUsage;
        

           
          RecordingStats()
        

            :
          duration(0)
        

            ,
          rxBytes(0)
        

            ,
          rxKBitRate(0)
        

            ,
          rxAudioKBitRate(0)
        

            ,
          rxVideoKBitRate(0)
        

            ,
          lastmileDelay(0)
        

            ,
          userCount(0)
        

            ,
          cpuAppUsage(0)
        

            ,
          cpuTotalUsage(0) {}
        
};


           class AudioPcmFrame
          {
        

           
          public:
        

           
          AudioPcmFrame(u64_t
          frame_ms,
          uint_t
          sample_rates,
          uint_t
          samples);
        

           
          ~AudioPcmFrame();
        

           
          public:
        

           
          u64_t
          frame_ms_;
        

           
          uint_t
          channels_; // 1
        

           
          uint_t
          sample_bits_; // 16
        

           
          uint_t
          sample_rates_; // 8k, 16k, 32k
        

           
          uint_t
          samples_;
        


            const
          uchar_t
          *pcmBuf_;
        

           
          uint_t
          pcmBufSize_;
        
};


           class AudioAacFrame
          {
        

           
          public:
        

            explicit
          AudioAacFrame(u64_t
          frame_ms);
        

           
          ~AudioAacFrame();
        


            const
          uchar_t
          *aacBuf_;
        

           
          u64_t
          frame_ms_;
        

           
          uint_t
          aacBufSize_;
        

           
          uint_t
          channels_;
        

           
          uint_t
          bitrate_;
        
};


           struct AudioFrame {
        

           
          AUDIO_FRAME_TYPE
          type;
        

           
          union {
        

           
          AudioPcmFrame
          *pcm;
        

           
          AudioAacFrame
          *aac;
        

            }
          frame;
        


           
          AudioFrame();
        

           
          ~AudioFrame();
        

           
          MEMORY_TYPE
          mType;
        
};


           class VideoYuvFrame
          {
        

           
          public:
        

           
          VideoYuvFrame(u64_t
          frame_ms,
          uint_t
          width,
          uint_t
          height,
          uint_t
          ystride,
        

           
          uint_t
          ustride,
          uint_t
          vstride);
        

           
          ~VideoYuvFrame();
        


           
          u64_t
          frame_ms_;
        


            const
          uchar_t
          *ybuf_;
        

            const
          uchar_t
          *ubuf_;
        

            const
          uchar_t
          *vbuf_;
        


           
          uint_t
          width_;
        

           
          uint_t
          height_;
        


           
          uint_t
          ystride_;
        

           
          uint_t
          ustride_;
        

           
          uint_t
          vstride_;
        


           
          //all
        

            const
          uchar_t
          *buf_;
        

           
          uint_t
          bufSize_;
        
};


           struct VideoH264Frame
          {
        

           
          public:
        

           
          VideoH264Frame():
        

           
          frame_ms_(0),
        

           
          frame_num_(0),
        

           
          buf_(NULL),
        

           
          bufSize_(0)
        
 {}


           
          ~VideoH264Frame(){}
        

           
          u64_t
          frame_ms_;
        

           
          uint_t
          frame_num_;
        


           
          //all
        

            const
          uchar_t
          *buf_;
        

           
          uint_t
          bufSize_;
        
};


           struct VideoH265Frame
          {
        

           
          public:
        

           
          VideoH265Frame():
        

           
          frame_ms_(0),
        

           
          frame_num_(0),
        

           
          buf_(NULL),
        

           
          bufSize_(0)
        
 {}


           
          ~VideoH265Frame(){}
        

           
          u64_t
          frame_ms_;
        

           
          uint_t
          frame_num_;
        


           
          //all
        

            const
          uchar_t
          *buf_;
        

           
          uint_t
          bufSize_;
        
};


           struct VideoJpgFrame
          {
        

           
          public:
        

           
          VideoJpgFrame():
        

           
          frame_ms_(0),
        

           
          buf_(NULL),
        

           
          bufSize_(0){}
        


           
          ~VideoJpgFrame() {}
        

           
          u64_t
          frame_ms_;
        


           
          //all
        

            const
          uchar_t
          *buf_;
        

           
          uint_t
          bufSize_;
        
};


           struct VideoJpgFile {
        

           
          public:
        

           
          VideoJpgFile():
        

           
          frame_ms_(0),
        

           
          file_name_(NULL) {}
        


           
          ~VideoJpgFile() {}
        

           
          u64_t
          frame_ms_;
        


           
          //all
        

            const
          char *file_name_;
        
};


           struct VideoFrame {
        

           
          VIDEO_FRAME_TYPE
          type;
        

           
          union {
        

           
          VideoYuvFrame
          *yuv;
        

           
          VideoH264Frame
          *h264;
        

           
          VideoJpgFrame
          *jpg;
        

           
          VideoH265Frame
          *h265;
        

           
          VideoJpgFile
          *jpg_file;
        

            }
          frame;
        


            int
          rotation_; // 0, 90, 180, 270
        

           
          VideoFrame();
        

           
          ~VideoFrame();
        


           
          MEMORY_TYPE
          mType;
        
};


           enum
          WatermarkType
          {
        

           
          WATERMARK_TYPE_LITERA,
        


           
          WATERMARK_TYPE_TIMESTAMP,
        


           
          WATERMARK_TYPE_IMAGE
        

           };
        


           struct LiteraWatermarkConfig
          {
        

            const char*
          wm_litera;
        

            const char*
          font_file_path;
        

            uint32_t
          font_size;
        

            uint32_t
          offset_x;
        

            uint32_t
          offset_y;
        

            uint32_t
          wm_width;
        

            uint32_t
          wm_height;
        
};


           struct TimestampWatermarkConfig
          {
        

            uint32_t
          font_size;
        

            uint32_t
          offset_x;
        

            uint32_t
          offset_y;
        

            uint32_t
          wm_width;
        

            uint32_t
          wm_height;
        
};


           struct ImageWatermarkConfig
          {
        

            const char*
          image_path;
        

            uint32_t
          offset_x;
        

            uint32_t
          offset_y;
        

            uint32_t
          wm_width;
        

            uint32_t
          wm_height;
        
};



           struct WatermarkConfig
          {
        

            union WatermarkConfigUnion{
        

           
          LiteraWatermarkConfig
          litera;
        

           
          TimestampWatermarkConfig
          timestamp;
        

           
          ImageWatermarkConfig
          image;
        


           
          WatermarkConfigUnion() {
        

            memset(this, 0, sizeof(*this));
        
 }
 };


           
          WatermarkType
          type;
        

           
          WatermarkConfigUnion
          config;
        
};


           typedef struct VideoMixingLayout
        
{

            struct Region
          {
        

           
          uid_t
          uid;
        

            double
          x;//[0,1]
        

            double
          y;//[0,1]
        

            double
          width;//[0,1]
        

            double
          height;//[0,1]
        

           
          // Optional
        

           
          // [0, 1.0] where 0 denotes throughly transparent, 1.0 opaque
        

            double
          alpha;
        


            int
          renderMode;//RENDER_MODE_HIDDEN: Crop, RENDER_MODE_FIT: Zoom to fit
        

           
          Region()
        

            :uid(0)
        

            ,
          x(0)
        

            ,
          y(0)
        

            ,
          width(0)
        

            ,
          height(0)
        

            ,
          alpha(1.0)
        

            ,
          renderMode(1)
        
 {}

 };

            int
          canvasWidth;
        

            int
          canvasHeight;
        

            const char*
          backgroundColor;//e.g. "#C0C0C0" in RGB
        

            uint32_t
          regionCount;
        

            const
          Region*
          regions;
        

            const char*
          appData;
        

            int
          appDataLength;
        

            bool
          keepLastFrame;
        

            uint32_t
          wm_num;
        

           
          WatermarkConfig
          *
          wm_configs;
        

           
          VideoMixingLayout()
        

            :canvasWidth(0)
        

            ,
          canvasHeight(0)
        

            ,
          backgroundColor(NULL)
        

            ,
          regionCount(0)
        

            ,
          regions(NULL)
        

            ,
          appData(NULL)
        

            ,
          appDataLength(0)
        

            ,
          keepLastFrame(false)
        

            ,
          wm_num(0)
        

            ,
          wm_configs(NULL)
        
 {}

           }
          VideoMixingLayout;
        


           typedef struct UserJoinInfos
          {
        

            const char*
          storageDir;
        

           
          //new attached info add below
        


           
          UserJoinInfos():
        

           
          storageDir(NULL)
        
 {}

           }UserJoinInfos;
        


           enum
          UID_LIST_TYPE
          {
        

           
          UID_SUBSCRIBE_WHITE_LIST
          = 0,
        

           
          UID_SUBSCRIBE_BLACK_LIST,
        
};

}
}


           #endif