LiveRoom.h

Go to the documentation of this file.

//
//  LiveRoom.h
//  zegoliveroom
//
//  Copyright © 2017年 Zego. All rights reserved.
//

#ifndef LiveRoom_h
#define LiveRoom_h

#ifndef ZEGO_API
#ifdef WIN32
#ifdef ZEGO_EXPORTS
#define ZEGO_API __declspec(dllexport)
#else
#define ZEGO_API __declspec(dllimport)
#endif
#else
#define ZEGO_API __attribute__((visibility("default")))
#endif
#endif // !ZEGO_API


#define ZEGO_MAX_COMMON_LEN         (512)
#define ZEGO_MAX_USERID_LEN         (64)
#define ZEGO_MAX_USERNAME_LEN       (256)

namespace ZEGO
{
    namespace LIVEROOM
    {
        struct ZegoStreamInfo
        {
            ZegoStreamInfo()
            {
                szUserId[0] = '\0';
                szUserName[0] = '\0';
                szStreamId[0] = '\0';
                szExtraInfo[0] = '\0';
                uStreamCreateTime = 0;
            }
            
            char szUserId[ZEGO_MAX_USERID_LEN];        
            char szUserName[ZEGO_MAX_USERNAME_LEN];    
            char szStreamId[ZEGO_MAX_COMMON_LEN];      
            char szExtraInfo[ZEGO_MAX_COMMON_LEN];     
            unsigned long uStreamCreateTime;           
        };
        
        enum ZegoStreamUpdateType
        {
            StreamAdded     = 2001,     
            StreamDeleted   = 2002,     
        };
        
        enum MuxerStreamType
        {
            MuxerStreamTypeAudio = 1, 
            MuxerStreamTypeVideo = 2, 
            MuxerStreamTypeBoth  = 3, 
        };
        
        enum MuxerOutType
        {
            MuxerOutTypeOnlyWriteFile = 1, 
            MuxerOutTypeOnlyCallback  = 2, 
        };
        
        enum ZegoVideoStreamLayerType
        {
            ZegoVideoStreamLayerAuto = -1,  
            ZegoVideoStreamLayerBase = 0,   
            ZegoVideoStreamLayerExtend = 1, 
        };
    
        enum ZegoFillMode
        {
            ZEGO_FILL_MODE_CROP = 0,      
            ZEGO_FILL_MODE_BLACKBAR = 1,  
        };
        
        enum ZegoFrameFillMode
        {
            ZEGO_MODE_LAST_FRAME = 0,   
            ZEGO_MODE_FILL_FRAME = 1,   
            ZEGO_MODE_HIDE_FRAME = 2,   
        };
        
        struct ZegoRecordStatus
        {
            char filePath[ZEGO_MAX_COMMON_LEN];
            unsigned int recordDuration;
            unsigned int fileSize;
        };
        
        struct ZegoRecordSingleStreamConfig
        {
            bool videoAndAudioSeperate = false;  
            ZegoVideoStreamLayerType streamLayerType = ZegoVideoStreamLayerAuto; 
            bool isExternalVideoDataSource = false;  
            int externalVideoBitrate = 600000;       
        };
        
        struct ZegoWaterMarkConfig
        {
            const char *info = nullptr;                
            int xPosition = -1;                        
            int yPosition = -1;                        
            int nWidth = 0;                            
            int nHeight = 0;                           
            int fontColor = 0xFFFFFF00;                
            int backgroundColor = 0x3F3F3FFF;          
        };
        
        struct ZegoStreamConfig
        {
            char szStreamID[ZEGO_MAX_COMMON_LEN];   
            struct
            {
                int top;
                int left;
                int bottom;
                int right;
            } layout;
            int layer;
            
            ZegoWaterMarkConfig waterMark;          
            bool isExternalVideoDataSource = false;  
            ZegoFillMode fillMode = ZEGO_FILL_MODE_CROP;
            ZegoFrameFillMode frameFillMode = ZEGO_MODE_LAST_FRAME; 
            int frameFillColor = 0x00000000;        
            const char* pBackgroundImagePath = nullptr; 
            ZegoStreamConfig ()
            {
                szStreamID[0] = '\0';
            }
        };
        
        enum ZegoTimestampPosition
        {
            ZegoTimestampUpperRight = 0,  
            ZegoTimestampUpperLeft  = 1,  
            ZegoTimestampBottomRight = 2, 
            ZegoTimestampBottomLeft = 3,  
        };
        
        struct ZegoTimestampConfig
        {
            ZegoTimestampPosition position = ZegoTimestampUpperRight;
            int width = 0;
            int height = 0;
        };

        enum ZegoImageWaterMarkFillMode
        {
            MODE_SCALE_CENTER, 
            MODE_STRETCH_FILL, 
        };

        struct ZegoImageWaterMarkConfig
        {
            const char *imagePath = nullptr;           
            int xPosition = -1;                        
            int yPosition = -1;                        
            int nWidth = 0;                            
            int nHeight = 0;                           
            ZegoImageWaterMarkFillMode fillMode = MODE_SCALE_CENTER; 
        };
        
        struct AudioFrame
        {
            AudioFrame()
            {
                frameType = 0;
                samples = 0;
                bytesPerSample = 0;
                channels = 0;
                sampleRate = 0;
                timeStamp = 0.0;
                configLen = 0;
                bufLen = 0;
                buffer = 0;
            }
            
            int frameType;              //refer to enum FrameType
            int samples;                //PCM:capture pcm samples at this input.  AAC:aac encode one frame need samples
            int bytesPerSample;         //bytes per sample = 2 * channels, current bit depth only support 16bit(2 bytes).
            int channels;               //channels, 1 or 2.
            int sampleRate;             //PCM: capture sample rate; AAC: encode sample rate. supported [16k/32k/44.1k/48k]
            double timeStamp;            //time stamp, PCM: 0; AAC: 0 or encode timeStamp, if buffer data only contain special config fill 0.
            int configLen;              //aac special config Len, PCM: 0; AAC: range [0-64]. 0 indicate this frame not contain spcial config.
            int bufLen;                 /*buffer Length, PCM bufLen = 2 * samples * channels(only need correct fill samples and channels,
                                         not use filed bufLen). AAC encode data len = bufLen - configLen.*/
            unsigned char* buffer;      //data buffer, the caller is responsible for bufer allocate and release
        };

        struct ZegoMixStreamRecordConfig
        {
            char szPathAndName[ZEGO_MAX_COMMON_LEN];     
            bool bGenerateMp3;                          
            MuxerStreamType nMuxerStreamType;           
            int nFragmentSeconds;                       
            int nOutputFps;                             
            int nOutputBitrate;                         
            int nOutputWidth;                           
            int nOutputHeight;                          
            int nOutputAudioBitrate;                    
            ZegoStreamConfig* pInputStream;             
            int nInputStreamCount;                      
            int nOutputBackgroundColor;                 
            const char* pOutputBackgroundImage;         
            ZegoTimestampConfig *pTimestampConfig;       
            bool videoAudioSeperateFile;                 
            ZegoVideoStreamLayerType streamLayerType;    
            ZegoImageWaterMarkConfig *pImageWaterMark;   
            bool bRecordSoundLevel;                      
            ZegoMixStreamRecordConfig ()
            : bGenerateMp3(false)
            , nMuxerStreamType(MuxerStreamTypeBoth)
            , nFragmentSeconds(2)
            , nOutputFps(0)
            , nOutputBitrate(0)
            , nOutputWidth(0)
            , nOutputHeight(0)
            , nOutputAudioBitrate(80*1000)
            , pInputStream(0)
            , nInputStreamCount(0)
            , nOutputBackgroundColor(0x00000000)
            , pOutputBackgroundImage(0)
            , pTimestampConfig(nullptr)
            , videoAudioSeperateFile(false)
            , streamLayerType(ZegoVideoStreamLayerAuto)
            , pImageWaterMark(nullptr)
            , bRecordSoundLevel(false)
            {
                szPathAndName[0] = '\0';
            }
        };
        
        enum RecordEndReason
        {
            RecordEndReasonNormalEnd = 0,           
            RecordEndReasonUnknowError = 1,         
            RecordEndReasonPathNameTooLong = 2,     
            RecordEndReasonOpenFileError = 3,       
            RecordEndReasonNoSpaceLeft = 4,         
            RecordEndReasonInitError = 5,           
            RecordEndReasonWriteHeaderError = 6,    
            RecordEndReasonBadFd = 7,               
            RecordEndReasonErrorIo = 8,             
            RecordEndReasonChnError = 9,            
            RecordEndReasonFormatNotSupport = 10,   
            RecordEndReasonIllegalState = 11,       
            RecordEndReasonCreateDirError = 1000,   
            RecordEndReasonMixStreamTaskLimit = 1001, 
            RecordEndReasonPlayErrorBase = 100000,  
            RecordEndReasonNoStreamError = 100006   
        };
        
        enum RecordEvent
        {
            RecordEventPause,   
            RecordEventResume   
        };
        
        enum VideoPixelFormat
        {
            PIXEL_FORMAT_UNKNOWN = 0,
            PIXEL_FORMAT_I420 = 1,
            PIXEL_FORMAT_BGRA32 = 4,
            PIXEL_FORMAT_RGBA32 = 5,
            PIXEL_FORMAT_ARGB32 = 6,
            PIXEL_FORMAT_ABGR32 = 7,
        };
        
        class IExternalVideoDataSource
        {
        public:
            virtual int OnIncomingVideoData(const unsigned char *pData[4],
                                            int dataLen[4],
                                            int width,
                                            int height,
                                            int strides[4],
                                            VideoPixelFormat format,
                                            unsigned long long referenceTime,
                                            unsigned int referenceTimeScale) = 0;
        };

        class IExternalMediaDataSource : public IExternalVideoDataSource
        {
        public:
            virtual int OnRecordAudioFrame(const AudioFrame& audioFrame) = 0;
        };
        
        class ICallback
        {
        public:
            virtual void OnInitSDK(int errorCode) {}
            
            virtual void OnLoginRoom(int errorCode, const char *pszRoomID) = 0;
            
            virtual void OnLogoutRoom(int errorCode, const char *pszRoomID) {}
            
            virtual void OnDisconnect(int errorCode, const char *pszRoomID) = 0;
            
            virtual void OnStreamUpdate(ZegoStreamUpdateType type, ZegoStreamInfo *pStreamInfo, unsigned int streamCount, const char *pszRoomID) = 0;

            virtual void OnPlayQualityUpdate(const char* pszStreamID, int quality, double videoFPS, double videoKBPS) {};

            virtual void OnPlayQualityUpdate(const char* pszStreamID, int quality, double videoFPS, double videoKBPS, double audioKBPS) {};
            
            virtual void OnStreamRecordBegin(const char* pszStreamID, const char *pszPathAndName) = 0;
            
            virtual void OnStreamRecordEnd(const char* pszStreamID, const char *pszPathAndName, RecordEndReason reason) = 0;

            virtual void OnStreamRecordVideoSizeChanged(const char* pszStreamID, int width, int height) {};

            virtual void OnStreamRecordRemoteMicOperation(const char* pszStreamID, int operation, int reason) {};
            
            virtual void OnStreamRecordEvent(const char* pszStreamID, RecordEvent event) {};
            
            virtual void OnStreamRecordData(const char* pszStreamID, const char *data, int len) {};
            
            virtual void OnSeek(const char* pszStreamID, long long offset, int whence) {};
            
            virtual void OnVideoDataCallback(const unsigned char **pData, int* dataLen, const char* pszStreamID, int width, int height, int strides[4], VideoPixelFormat pixel_format) {}
            
            virtual void OnAudioDataCallback(const char* pszStreamID, const AudioFrame &frame) {};

            virtual void OnMixStreamRecordUpdate(const char** ppszStreamID, int nStreamCount) = 0;
            
            virtual void OnRecordFilePath(const char *pszStreamID, const char *filePath, MuxerStreamType muxerType, unsigned int startTimeStamp, unsigned int stopTimeStamp) {};
            
            virtual void OnExternalVideoDataSource(const char *pszStreamID, IExternalVideoDataSource *source) {};

            virtual void OnExternalMediaDataSource(const char *pszStreamID, IExternalMediaDataSource *source) {};

            virtual void OnStreamSnapshotFilePath(int nErrorCode, const char* pszStreamID, const char* pszFilePath) {};
            
            virtual ~ICallback() {}
        };
        
        class IMediaSideCallback
        {
        public:
            virtual void OnRecvMediaSideInfo(const char * pszStreamID, const unsigned char *buf, int dataLen) = 0;
            
            virtual ~IMediaSideCallback() {}
        };
        
        ZEGO_API const char* GetSDKVersion();
        
        ZEGO_API bool SetLogDirAndSize(const char* pszLogDir, unsigned long long lLogFileSize = 5 * 1024 * 1024);
        
        ZEGO_API void UploadLog();

        ZEGO_API void SetUseTestEnv(bool bTestEnv);
        
        ZEGO_API void SetConfig(const char *config);
        
        ZEGO_API bool InitSDK(unsigned int uiAppID, unsigned char* pBufAppSignature, int nSignatureSize);

        ZEGO_API bool InitSDK(unsigned int uiAppID);
        
        ZEGO_API bool UnInitSDK();
        
        ZEGO_API bool SetCallback(ICallback* pCB);
       
        ZEGO_API bool LoginRoom(const char* pszRoomID);

        
        ZEGO_API bool SetUser(const char* pszUserID, const char* pszUserName);
        
        ZEGO_API void SetCustomToken(const char *thirdPartyToken);
        
        ZEGO_API bool LogoutRoom();
        
        ZEGO_API int GetMaxRecordCount();
        
        ZEGO_API void SetMuxerOutType(MuxerOutType type);
        
        ZEGO_API void SetMuxerCacheSize(int size);
        
        ZEGO_API void EnableSingleAndMixRecordMode(bool enable);
        
        ZEGO_API void EnableExternalRender(bool bEnable);
        
        ZEGO_API bool SetFontFile(const char *pszPathAndName);
        
        ZEGO_API void EnableExternalAudioData(bool bEnable, int sampleRate, int channels);

        ZEGO_API bool StartRecordSingleStream(const char* pszStreamID, const char *pszPathAndName, MuxerStreamType nMuxerStreamType = MuxerStreamTypeBoth, int nFragmentSeconds = 2, ZegoRecordSingleStreamConfig *config = nullptr);
        
        ZEGO_API bool StopRecordSingleStream(const char* pszStreamID);
        
        ZEGO_API bool StartRecordMixStream(ZegoMixStreamRecordConfig* pConfig);
        
        ZEGO_API bool UpdateInputStreamConfig(ZegoStreamConfig* pInputStream, int nInputStreamCount);

        ZEGO_API bool UpdateImageWaterMarkConfig(ZegoImageWaterMarkConfig* pConfig);
        
        ZEGO_API bool StopRecordMixStream();

        ZEGO_API bool PauseRecordMixStream();

        ZEGO_API bool ResumeRecordMixStream();
        
        ZEGO_API bool GetRecordStatus(const char* streamID, ZegoRecordStatus& status);
        
        ZEGO_API unsigned int GetRecordLastMediaSideTime(const char* streamID);
        
        ZEGO_API bool SetMediaSideCallback(IMediaSideCallback *pCB);

        ZEGO_API bool TakeStreamSnapshot(const char* pszStreamID, const char* pszPathAndName);
        
    }
}

#endif /* LiveRoom.h */