zego-api-mix-stream-defines.h

Go to the documentation of this file.

//
//  zego-api-mix-stream-defines.h
//
//  Copyright © 2018年 Zego. All rights reserved.
//
 
#ifndef zego_api_mix_stream_defines_h
#define zego_api_mix_stream_defines_h
 
#include "zego-api-defines.h"
#include <cstddef>
 
namespace ZEGO
{
namespace MIXSTREAM
{
 
    struct ZegoMixStreamInput
    {
        char szStreamID[ZEGO_MAX_URL_LEN];
        struct
        {
            int top;
            int left;
            int bottom;
            int right;
        } layout;
        unsigned int uSoundLevelID;
        int nContentControl;
        int nVolume;
        bool bAudioFocus;
        int nAudioDirection;
        AV::ZegoLabelInfo label;
        int renderMode;
        AV::ZegoMixImageInfo imageInfo;
        unsigned int cornerRadius;
        char advancedConfig[ZEGO_MAX_COMMON_LEN];
 
        AV::ZegoMixBlurInfo blurInfo;
 
        ZegoMixStreamInput ()
        : uSoundLevelID(0)
        , nContentControl(0)
        , nVolume(100)
        , bAudioFocus(false)
        , nAudioDirection(-1)
        , label()
        , renderMode(0)
        , imageInfo()
        , cornerRadius(0)
        , blurInfo()
        {
            szStreamID[0] = '\0';
            layout.top = 0;
            layout.left = 0;
            layout.bottom = 0;
            layout.right = 0;
            advancedConfig[0] = '\0';
        }
    };
    
    struct ZegoMixStreamOutput
    {
        bool isUrl;
        char target[ZEGO_MAX_URL_LEN];
        int videoCodec;
        int videoBitrate;
        
        AV::ZegoEncodeProfile encodeProfile;
        
        int encodeLatency;
 
        bool enableLowBitrateHD;
 
        struct {
            char roomID[ZEGO_MAX_ROOMID_LEN];
            char userID[ZEGO_MAX_USERID_LEN];
        } targetRoom;
 
        ZegoMixStreamOutput()
        {
            isUrl = false;
            target[0] = '\0';
            videoCodec = 0;
            videoBitrate = 0;
            encodeProfile = AV::ZegoEncodeProfileMain;
            encodeLatency = 0;
            enableLowBitrateHD = false;
            targetRoom.roomID[0] = '\0';
            targetRoom.userID[0] = '\0';
        }
    };
    
    struct ZegoMixStreamWatermark
    {
        char image[ZEGO_MAX_COMMON_LEN];
        
        struct
        {
            int top;
            int left;
            int bottom;
            int right;
        } layout;
        ZegoMixStreamWatermark()
        {
            image[0] = '\0';
            layout.top = 0;
            layout.left = 0;
            layout.bottom = 0;
            layout.right = 0;
        }
    };
 
    struct ZegoMixStreamWhiteboard
    {
        unsigned long long whiteboardID;
 
        int horizontalRatio;
 
        int verticalRatio;
 
        bool isPPTAnimation;
        
        struct
        {
            int top;
            int left;
            int bottom;
            int right;
        } layout;
        int zOrder;
 
        int backgroundColor;
 
        ZegoMixStreamWhiteboard()
        {
            whiteboardID = 0;
            horizontalRatio = 16;
            verticalRatio = 9;
            isPPTAnimation = false;
            layout.top = 0;
            layout.left = 0;
            layout.bottom = 0;
            layout.right = 0;
            zOrder = 0;
            backgroundColor = 0xF1F3F400;
        }
    };
    
    struct ZegoMixStreamConfig
    {
        int nOutputFps;
        int nOutputRateControlMode;
        int nOutputBitrate;
        int nOutputQuality;
        int nOutputAudioBitrate;
        int nOutputWidth;
        int nOutputHeight;
        int nOutputAudioConfig;
        ZegoMixStreamInput* pInputStreamList;
        int nInputStreamCount;
        ZegoMixStreamOutput* pOutputList;
        int nOutputStreamCount;                     
        const unsigned char * pUserData;
        int nLenOfUserData;
        int nChannels;
        int nOutputBackgroundColor;
        const char* pOutputBackgroundImage;
        bool bWithSoundLevel;
        int nAudioMixMode;
        int nExtra;
        ZegoMixStreamWatermark *pOutputWatermark;
        ZegoMixStreamWhiteboard *pInputWhiteboard;
        bool bSingleStreamPassThrough;
        bool bStreamAlignment;
        int nStreamAlignmentType;
        const char *pAdvancedConfig; 
        int minPlayStreamBufferLength;
 
        int nMixImageCheckMode;
        
        ZegoMixStreamConfig ()
        : nOutputFps(0)
        , nOutputRateControlMode(0)
        , nOutputBitrate(0)
        , nOutputQuality(23)
        , nOutputAudioBitrate(0)
        , nOutputWidth(0)
        , nOutputHeight(0)
        , nOutputAudioConfig(0)
        , pInputStreamList(0)
        , nInputStreamCount(0)
        , pOutputList(0)
        , nOutputStreamCount(0)
        , pUserData(0)
        , nLenOfUserData(0)
        , nChannels(1)
        , nOutputBackgroundColor(0x00000000)
        , pOutputBackgroundImage(0)
        , bWithSoundLevel(false)
        , nAudioMixMode(0)
        , nExtra(0)
        , pOutputWatermark(0)
        , pInputWhiteboard(0)
        , bSingleStreamPassThrough(false)
        , bStreamAlignment(false)
        , nStreamAlignmentType(0)
        , pAdvancedConfig(NULL)
        , minPlayStreamBufferLength(-1)
        , nMixImageCheckMode(0) {}
    };
    
}
}
 
#endif /* zego_api_mix_stream_defines_h */