zego-api-mediaplayer-defines.h

Go to the documentation of this file.

//
//  zego-api-mediaplayer-defines.h
//  ZegoLiveRoom
//
//  Copyright © 2018年 Zego. All rights reserved.
//
 
#ifndef zego_api_mediaplayer_defines_h
#define zego_api_mediaplayer_defines_h
 
#include "zego-api-defines.h"
 
namespace ZEGO
{
namespace MEDIAPLAYER
{
        
    enum ZegoMediaPlayerType
    {
        ZegoMediaPlayerTypePlayer   = 0,
        ZegoMediaPlayerTypeAux      = 1
    };
    
    enum ZegoMediaPlayerVideoPixelFormat
    {
        ZegoMediaPlayerVideoPixelFormatUnknown  = 0,
        ZegoMediaPlayerVideoPixelFormatI420     = 1,
        ZegoMediaPlayerVideoPixelFormatNV12     = 2,
        ZegoMediaPlayerVideoPixelFormatNV21     = 3,
        ZegoMediaPlayerVideoPixelFormatBGRA32   = 4,
        ZegoMediaPlayerVideoPixelFormatRGBA32   = 5,
        ZegoMediaPlayerVideoPixelFormatARGB32   = 6,
        ZegoMediaPlayerVideoPixelFormatABGR32   = 7,
    };
    
    enum ZegoMediaPlayerIndex
    {
        ZegoMediaPlayerIndexFirst   = 0,
        ZegoMediaPlayerIndexSecond  = 1,
        ZegoMediaPlayerIndexThird   = 2,
        ZegoMediaPlayerIndexFourth  = 3,
    };
    
    enum ZegoMediaPlayerAudioChannel
    {
        ZegoMediaPlayerAudioChannelLeft  = 1,
        ZegoMediaPlayerAudioChannelRight = 2,
        ZegoMediaPlayerAudioChannelAll   = 3
    };
 
    enum ZegoMediaPlayerAudioTrackMode
    {
        ZegoMediaPlayerAudioTrackModeNormal = 0,  // 普通模式
        ZegoMediaPlayerAudioTrackModeMultiple = 1 // 多音轨模式
    };
 
    enum ZegoMediaPlayerError
    {
        ZegoMediaPlayerErrorOK = 0,
        ZegoMediaPlayerErrorFile = -1,
        ZegoMediaPlayerErrorPath = -2,
        ZegoMediaPlayerErrorCodec = -3,
        ZegoMediaPlayerErrorNoSupportStream = -4,
        ZegoMediaPlayerErrorDemux = -5,
        ZegoMediaPlayerErrorFrameDrop = -6,
        ZegoMediaPlayerErrorLoadTimeout = -7,
        ZegoMediaPlayerErrorExpired = -8,
        ZegoMediaPlayerErrorResourceIDExpired = -9,
        ZegoMediaPlayerErrorPermissionDenied = -13
    };
 
    enum ZegoMultimediaLoadType {
        ZEGO_MULTIMEDIA_LOAD_TYPE_FILE_PATH = 0,
 
        ZEGO_MULTIMEDIA_LOAD_TYPE_MEMORY = 1,
 
        ZEGO_MULTIMEDIA_LOAD_TYPE_RESOURCE_ID = 2
    };
 
    enum ZegoLiveAudioEffectMode {
        ZEGO_LIVE_AUDIO_EFFECT_MODE_NONE = 0,
 
        ZEGO_LIVE_AUDIO_EFFECT_MODE_LOCAL = 1,
 
        ZEGO_LIVE_AUDIO_EFFECT_MODE_PUBLISH = 2,
 
        ZEGO_LIVE_AUDIO_EFFECT_MODE_ALL = 3
    };
 
    enum ZegoMediaStreamType {
        ZEGO_MEDIA_STREAM_TYPE_AUDIO = 0,
 
        ZEGO_MEDIA_STREAM_TYPE_VIDEO = 1,
 
        ZEGO_MEDIA_STREAM_TYPE_AV = 2
    };
 
    enum ZegoMediaPlayerExceptionEvent{
        ZEGO_MEDIA_PLAYER_EXCEPTION_EVENT_LOAD_TIMEOUT = -1,
 
        ZEGO_MEDIA_PLAYER_EXCEPTION_EVENT_SEEK_TIMEOUT = -2,
 
        ZEGO_MEDIA_PLAYER_EXCEPTION_EVENT_SEEK_FAILED = -3,
 
        ZEGO_MEDIA_PLAYER_EXCEPTION_EVENT_AUDIORND_ERROR = -4,
 
        ZEGO_MEDIA_PLAYER_EXCEPTION_EVENT_DECODE_FAILED = -5,
 
        ZEGO_MEDIA_PLAYER_EXCEPTION_EVENT_SYNC_ERROR = -6,
 
        ZEGO_MEDIA_PLAYER_EXCEPTION_EVENT_FLOW_ERROR = -7
    };
    
    struct ZegoMediaPlayerVideoDataFormat
    {
        int width;
        int height;
        int strides[4];
        int rotation;
        long pts;
        ZegoMediaPlayerVideoPixelFormat pixelFormat;
        
        ZegoMediaPlayerVideoDataFormat()
        {
            width = 0;
            height = 0;
            strides[0] = strides[1] = strides[2] = strides[3] = 0;
            rotation = 0;
            pixelFormat = ZegoMediaPlayerVideoPixelFormatUnknown;
        }
        
        ZegoMediaPlayerVideoDataFormat(int width, int height, ZegoMediaPlayerVideoPixelFormat pixelFormat)
        {
            this->width = width;
            this->height = height;
            this->pixelFormat = pixelFormat;
            this->strides[0] = this->strides[1] = this->strides[2] = this->strides[3] = 0;
            this->rotation = 0;
        }
    };
 
    struct ZegoMediaPlayerHttpHeader
    {
        char szKey[512];
        char szValue[512];
 
        ZegoMediaPlayerHttpHeader()
        {
            szKey[0] = '\0';
            szValue[0] = '\0';
        }
    };
 
    struct ZegoMediaPlayerResource
    {
        /* 加载资源类型 */
        ZegoMultimediaLoadType loadType;
        /* 开始播放位置 */
        long startPosition;
        /* 开始播放位置 */
        AV::ZegoAlphaLayoutType alphaLayout;
        /* 普通资源路径 */
        char filePath[2048];
        /* 二进制数据缓存 */
        unsigned char *memory;
        /* 二进制数据缓存长度 */
        int memoryLength;
        /* 版权音乐资源ID */
        char resourceID[512];
        /* 是否立即开始播放 */
        bool instantPlay;
        /* 在线资源缓存路径，utf8 编码格式。使用限制：不能与 SetMediaPlayerFileReader 一起使用，仅支持 http/htpps 协议 */
        char onlineResourceCachePath[2048];
        /* 在线资源最大的缓存待使用长度，单位 byte，最小设置 10M(10 * 1024 * 1024)，默认0-不做限制，尝试缓存整个文件 */
        long long maxCachePendingLength;
 
        ZegoMediaPlayerResource()
        {
            loadType = ZEGO_MULTIMEDIA_LOAD_TYPE_FILE_PATH;
            startPosition = 0;
            alphaLayout = AV::ZEGO_ALPHA_LAYOUT_TYPE_NONE;
            filePath[0] = '\0';
            memory = nullptr;
            memoryLength = 0;
            resourceID[0] = '\0';
            instantPlay = false;
            onlineResourceCachePath[0] = '\0';
            maxCachePendingLength = 0;
        }
    };
 
    struct ZegoMediaPlayerMediaInfo
    {
        int width;
        int height;
        int frameRate;
 
        ZegoMediaPlayerMediaInfo()
        {
            width = 0;
            height = 0;
            frameRate = 0;
        }
    };
 
    struct ZegoMediaPlayerStatisticsInfo{
        double videoSourceFps;
        
        double videoDecodeFps;
 
        double videoRenderFps;
 
        double audioSourceFps;
 
        double audioDecodeFps;
 
        double audioRenderFps;
 
        ZegoMediaPlayerStatisticsInfo(){
            videoSourceFps = 0;
            videoDecodeFps = 0;
            videoRenderFps = 0;
            audioSourceFps = 0;
            audioDecodeFps = 0;
            audioRenderFps = 0;
        }
    };
    
    class IZegoMediaPlayerEventWithIndexCallback
    {
    public:
        virtual void OnPlayStart(ZegoMediaPlayerIndex index) = 0;
        virtual void OnPlayError(const int errCode, ZegoMediaPlayerIndex index) = 0;
        virtual void OnVideoBegin(ZegoMediaPlayerIndex index) {}
        virtual void OnAudioBegin(ZegoMediaPlayerIndex index) {}
        virtual void OnPlayEnd(ZegoMediaPlayerIndex index) = 0;
        virtual void OnSeekComplete(const int state, const long duration, ZegoMediaPlayerIndex index) {}
        virtual void OnPlayPause(ZegoMediaPlayerIndex index) {}
        virtual void OnPlayResume(ZegoMediaPlayerIndex index) {}
        virtual void OnPlayStop(ZegoMediaPlayerIndex index) {}
        virtual void OnBufferBegin(ZegoMediaPlayerIndex index) {}
        virtual void OnBufferEnd(ZegoMediaPlayerIndex index) {}
        
        virtual void OnSnapshot(void *image, ZegoMediaPlayerIndex index) {}
        
        virtual void OnLoadComplete(ZegoMediaPlayerIndex index) {}
        
        virtual void OnProcessInterval(long timestamp, ZegoMediaPlayerIndex index) {}
 
        virtual void OnRenderingProcessInterval(long timestamp, ZegoMediaPlayerIndex index) {}
 
        virtual void OnReadEOF(ZegoMediaPlayerIndex index) {}
        
        virtual void OnMediaPlayerVideoSizeChanged(int width, int height, ZegoMediaPlayerIndex index) {}
        
        virtual void OnLocalCache(int error, const char *resource, const char *cached_file, ZegoMediaPlayerIndex index) {}
 
        virtual void OnMonitorEvent(ZegoMediaPlayerExceptionEvent event, ZegoMediaPlayerIndex index) {};
    };
    
    class IZegoMediaPlayerVideoDataWithIndexCallback
    {
    public:
        virtual void OnPlayVideoData(const char* data, int len, ZegoMediaPlayerVideoDataFormat& format, ZegoMediaPlayerIndex index) {}
        
        virtual void OnPlayVideoData2(const char **pData, int* len, ZegoMediaPlayerVideoDataFormat& format, ZegoMediaPlayerIndex index) {}
    };
 
    class IZegoMediaPlayerAudioDataCallback
    {
    public:
        virtual void OnPlayAudioData(unsigned char *const data, int length, int sample_rate, int channels, int bit_depth, ZegoMediaPlayerIndex index) = 0;
    };
 
    class IZegoMediaPlayerMediaSideInfoCallback
    {
    public:
        virtual void OnMediaSideInfo(const unsigned char *data, int length, ZegoMediaPlayerIndex index) = 0;
    };
 
    class IZegoMediaPlayerSoundInfoCallback
    {
    public:
 
        virtual void OnPlayerSoundLevelUpdate(float soundLevel, ZegoMediaPlayerIndex index) = 0;
 
        virtual void OnPlayerFrequencySpectrumUpdate(float *spectrumList, unsigned spectrumCount, ZegoMediaPlayerIndex index) = 0;
    };
 
    class ZegoMediaPlayerFileReader
    {
    public:
        virtual int Open(const char *path, ZegoMediaPlayerIndex index) = 0;
 
        virtual void Close(ZegoMediaPlayerIndex index) = 0;
 
        virtual int Read(unsigned char *buf, int size, ZegoMediaPlayerIndex index) = 0;
 
        virtual long long Seek(long long pos, int seekMode, ZegoMediaPlayerIndex index) = 0;
 
        virtual long long GetSize(ZegoMediaPlayerIndex index) = 0;  //返回文件的大小
    };
 
    class IZegoMediaPlayerBlockDataCallback
    {
    public:
 
        virtual void OnBlockBegin(const char *path, ZegoMediaPlayerIndex index) = 0;
 
        virtual int OnBlockData(unsigned char *const buf, int size, ZegoMediaPlayerIndex index) = 0;
    };
    
}   // MEDIAPLAYER
}   // ZEGO
 
 
#endif /* zego_api_mediaplayer_defines_h */