LiveRoomDefines.h

Go to the documentation of this file.

//
//  ZegoLiveRoomDefines.h
//  zegoliveroom
//
//  Copyright © 2017年 ZEGO. All rights reserved.
//
 
#ifndef ZegoLiveRoomDefines_h
#define ZegoLiveRoomDefines_h
 
#include "./AVDefines.h"
#include "./RoomDefines.h"
 
 
 
namespace ZEGO
{
    namespace LIVEROOM
    {
        using namespace COMMON;
        using COMMON::ZEGONetType;
        
        using COMMON::ZegoRoomRole;
        
        using COMMON::ZegoStreamInfo;
        
        using COMMON::ZegoStreamUpdateType;
        
        const int kInvalidSeq = -1;
        
        enum ZegoVideoViewMode
        {
            ZegoVideoViewModeScaleAspectFit = 0,    
            ZegoVideoViewModeScaleAspectFill = 1,   
            ZegoVideoViewModeScaleToFill = 2,       
        };
        
        struct ZegoPublishQuality
        {
            double cfps;            
            double vencFps;         
            double fps;             
            double kbps;            
            
            double acapFps;         
            double afps;            
            double akbps;           
        
            int rtt;                
            int pktLostRate;        
            int quality;            
            
            bool isHardwareVenc;    
            int videoCodecId;       
            int width;              
            int height;             
 
            double totalBytes; 
            double audioBytes; 
            double videoBytes; 
            
            double cpuAppUsage;    
            double cpuTotalUsage;  
            
            double memoryAppUsage;         
            double memoryTotalUsage;       
            double memoryAppUsed;          
 
            int vTrafficControlRate;       
            int aTrafficControlRate;       
 
            ZegoPublishQuality()
            {
                cfps = 0;   
                vencFps = 0;
                fps = 0;    
                kbps = 0;   
                    
                acapFps = 0;
                afps = 0;   
                akbps = 0;  
                rtt = 0;     
                pktLostRate = 0;  
                quality = 0;      
                        
                isHardwareVenc = false;
                videoCodecId = 0;
                width = 0;            
                height = 0;           
                totalBytes = 0;  
                audioBytes = 0;  
                videoBytes = 0;  
                    
                cpuAppUsage = 0;    
                cpuTotalUsage = 0;  
                    
                memoryAppUsage = 0;  
                memoryTotalUsage = 0;
                memoryAppUsed = 0;   
                
                vTrafficControlRate = 0;
                aTrafficControlRate = 0;
            }
        };
        
        struct ZegoPlayQuality
        {
            double fps;              
            double vdjFps;           
            double vdecFps;          
            double vrndFps;          
            double kbps;             
            
            double afps;             
            double adjFps;           
            double adecFps;          
            double arndFps;          
            double akbps;            
            
            double audioBreakRate;   
            double videoBreakRate;   
            int rtt;                 
            int pktLostRate;         
            int peerToPeerDelay;     
            int peerToPeerPktLostRate; 
            int quality;             
            int delay;               
            double mos;              
            
            bool isHardwareVdec;     
            int videoCodecId;        
            int width;               
            int height;              
 
            double totalBytes; 
            double audioBytes; 
            double videoBytes; 
            
            double cpuAppUsage;        
            double cpuTotalUsage;      
            
            double memoryAppUsage;         
            double memoryTotalUsage;       
            double memoryAppUsed;          
 
            int avTimestampDiff;       
 
            unsigned int audioCumulativeBreakCount; 
            unsigned int audioCumulativeBreakTime;  
            unsigned int audioCumulativeDecodeTime; 
            double       audioCumulativeBreakRate;  
            unsigned int videoCumulativeBreakCount; 
            unsigned int videoCumulativeBreakTime;  
            unsigned int videoCumulativeDecodeTime; 
            double       videoCumulativeBreakRate;  
            int muteVideo;
            int muteAudio;
 
            ZegoPlayQuality()
            {
                fps = 0;           
                vdjFps = 0;        
                vdecFps = 0;       
                vrndFps = 0;       
                kbps = 0;          
                    
                afps = 0;          
                adjFps = 0;        
                adecFps = 0;       
                arndFps = 0;       
                akbps = 0;         
                    
                audioBreakRate = 0;
                videoBreakRate = 0;
                rtt = 0;              
                pktLostRate = 0;      
                peerToPeerDelay = 0;  
                peerToPeerPktLostRate = 0;
                quality = 0;          
                delay = 0;        
                mos = -1;
                        
                isHardwareVdec = false;  
                videoCodecId = 0;
                width = 0;            
                height = 0;           
                totalBytes = 0;
                audioBytes = 0;
                videoBytes = 0;
                    
                cpuAppUsage = 0;
                cpuTotalUsage = 0;
                    
                memoryAppUsage = 0;
                memoryTotalUsage = 0;
                memoryAppUsed = 0;
 
                avTimestampDiff = 0;
 
                audioCumulativeBreakCount = 0;
                audioCumulativeBreakTime = 0;
                audioCumulativeDecodeTime = 0;
                audioCumulativeBreakRate = 0;
                videoCumulativeBreakCount = 0;
                videoCumulativeBreakTime = 0;
                videoCumulativeDecodeTime = 0;
                videoCumulativeBreakRate = 0;
 
                muteVideo = 0;
                muteAudio = 0;
            }
        };
 
        enum ZegoMixSysPlayoutPropertyMask
        {
            MIX_PROP_NONE = 0,
            MIX_PROP_ENABLE_AGC_FOR_SYS_PLAYOUT = 1, //当开启采集系统声卡声音时，传递此参数启用自动增益(仅支持win) 
        };
        struct ZegoPublishStreamParams
        {
            // 流 ID
            const char* streamID;
            // 直播名称
            const char* streamTitle;
            // 直播属性，参考 ZegoPublishFlag
            int publishFlag;
            // 推流参数
            const char* publishParams;
            // 推流 channel Index. 默认为主Channel
            AV::PublishChannelIndex channelIndex;
            // 关联的房间 ID，为 NULL 时，表示关联默认房间
            const char* roomID;
            // 关联的范围场景实例对象句柄。当为-1时，表示没有关联场景；当不为-1时，表示关联到场景。
            int rangeSceneHandle;
            //推流是否同步网络时间,仅RTC流有效，与SetStreamAlignmentProperty 接口配合使用, 用于混流时各路流的对齐, 常用于KTV场景。
            int forceSynchronousNetworkTime;
 
            //推流时指定该流的审查模式，常用与对音视频鉴黄的场景，需要此功能需要联系ZEGO技术支持，后台开通。
            AV::ZegoStreamCensorshipMode streamCensorshipMode;
            //审查标记，与即构的审查SDK配合使用，使用此功能需要联系ZEGO技术支持
            int censorFlag;
            
 
            // 推流编码参考的能力协商类型
            AV::ZegoCapabilityNegotiationType codecNegotiationType;
            //int codecNegotiationType;
 
            ZegoPublishStreamParams()
            {
                streamID = NULL;
                streamTitle = NULL;
                publishFlag = 0;
                publishParams = NULL;
                channelIndex = AV::PUBLISH_CHN_MAIN;
                roomID = NULL;
                rangeSceneHandle = -1;
                forceSynchronousNetworkTime = 0;
                streamCensorshipMode        = AV::ZegoStreamCensorshipMode::CENSORSHIP_NONE;
                censorFlag = 0;
                codecNegotiationType =  AV::ZegoCapabilityNegotiationType::ZEGO_CAPABILITY_NEGOTIATION_TYPE_NONE;
            }
        };
    
        struct ZegoPlayStreamParams
        {
            // 流 ID
            const char* streamID;
            // 用于拉流播放的 view
            void* displayView;
            // view 是否支持 alpha 混合图层渲染
            bool viewAlphaBlend;
            // 可选，额外的信息
            ZegoStreamExtraPlayInfo* extraInfo;
            // 房间 ID
            const char* roomID;
            // 关联的范围场景实例对象句柄。当为-1时，表示没有关联场景；当不为-1时，表示关联到场景。
            int rangeSceneHandle;
            
            ZegoPlayStreamParams()
            {
                streamID = NULL;
                displayView = NULL;
                viewAlphaBlend = false;
                extraInfo = NULL;
                roomID = NULL;
                rangeSceneHandle = -1;
            }
        };
 
        struct ZegoSwitchStreamParams
        {
            // 源流ID
            const char* fromStreamID;
            // 目标流ID
            const char* toStreamID;
            // 可选，额外的信息
            ZegoStreamExtraPlayInfo* extraInfo;
 
            AV::ZegoSwitchPlayingStreamType switchPlayingType;
            
            // 切流超时时间，单位秒
            int switchTimeout;
            
            ZegoSwitchStreamParams()
            {
                fromStreamID = NULL;
                toStreamID = NULL;
                extraInfo = NULL;
                switchPlayingType = AV::ZegoSwitchPlayingStreamTypeDefault;
                switchTimeout = 30;
            }
        };
        
        enum ZegoRoomMode 
        {
            // 单房间模式
            ZegoRoomModeSingleRoom = 0, 
            // 多房间模式
            ZegoRoomModeMultiRoom = 1,
        };
 
        enum ZegoRangeAudioMode
        {
            //面向所有人
            ZegoRangeAudioModeWorld = 1, 
            //仅小队
            ZegoRangeAudioModeTeam = 2,
            //隐秘小队，可以接收到世界范围内的声音
            ZegoRangeAudioModeSecreteTeam = 3
        };
 
        enum ZegoRangeAudioMicrophoneState
        {
            //正在打开中
            Opening = 1, 
            //打开成功
            Success   = 2,
            //临时中断，正在重试中
            TempBroken    = 3, 
            // 打开失败
            Failed      = 4, 
        };
    
        enum ZegoRangeAudioSpeakMode
        {
            //发声到所有场景
            SpeakToAll = 0,
            //仅发声到世界
            SpeakToWorld = 1,
            //仅发声到小队
            SpeakToTeam = 2
        };
    
        enum ZegoRangeAudioListenMode
        {
            //收听所有场景
            ListenFromAll = 0,
            //仅收听世界
            ListenFromWorld = 1,
            //仅收听小队
            ListenFromTeam = 2
        };
 
        struct ZegoReceiveRangeParam
        {
            // 3D 音效具有衰减效果的最小距离值，该值需 >= 0 且 <= max, 默认值为 0
            float min;
            // 接收的最大范围，该值需 >= min, 默认值为 0
            float max;
 
            ZegoReceiveRangeParam()
            {
                min = 0.0;
                max = 0.0;
            }
        };
 
        struct ZegoVocalRangeParam
        {
            // 3D 音效具有衰减效果的最小距离值，该值需 >= 0 且 <= max, 默认值为 0
            float min;
            // 发声的最大范围，该值需 >= min, 默认值为 0
            float max;
 
            ZegoVocalRangeParam()
            {
                min = 0.0;
                max = 0.0;
            }
        };
 
        struct ZegoSnapshotPreviewConfig
        {
            // position 截图位置, VCAP_SNAPSHOT_AFTER_FILTER = 0, VCAP_SNAPSHOT_CAPTURE_ORIGIN = 1, 只有 harmonyos 支持 VCAP_SNAPSHOT_PREVIEW = 2
            int position;
 
            ZegoSnapshotPreviewConfig()
            {
                position = 0;
            }
        };
    }
}
 
#endif /* ZegoLiveRoomDefines_h */