media_player.h

Go to the documentation of this file.

#ifndef ZEGOMediaPlayer_h
#define ZEGOMediaPlayer_h
#include "video_format.h"
 
namespace AVE
{
    class IMediaPlayer
    {
    public:
        enum PlayerType
        {
            TYPE_PLAYER = 0,    //only play
            TYPE_AUX            //play and mix into publish stream.
        };
        
        enum AudioChannel
        {
            LEFT_CHANNEL = 0x01,
            RIGHT_CHANNEL = 0x02,
            ALL_CHANNEL = LEFT_CHANNEL | RIGHT_CHANNEL
        };
        
        class EventCallback
        {
        public:
            virtual void OnPlayStart() = 0;
            virtual void OnPlayError(int code) = 0;
            virtual void OnVideoBegin() = 0;
            virtual void OnAudioBegin() = 0;
            virtual void OnPlayEnd() = 0;
            virtual void OnLoadComplete() = 0;
            virtual void OnSeekComplete(int code, long timestamp_ms) = 0;    //Units in millisecond
            virtual void OnPlayPause() = 0;
            virtual void OnPlayResume() = 0;
            virtual void OnPlayStop() = 0;
            virtual void OnBufferBegin() = 0;
            virtual void OnBufferEnd() = 0;
            virtual void OnSnapshot(void *image) = 0;
            virtual void OnProcessInterval(long timestamp_ms) = 0;
            virtual void OnReadEOF() = 0;
            virtual void OnVideoSizeChanged(int width, int height) = 0;
            virtual void OnLocalCache(int err, const char *url, const char *local_path) = 0;
            virtual void OnDecodeError() = 0;
            virtual void OnMonitorEvent(int event) = 0;
        };
        
        class VideoPlayCallback
        {
        public:
            virtual void OnPlayVideoData(const char* data, int len, const VideoDataFormat& format, int timestamp_ms) = 0;
            virtual void OnPlayVideoData2(const char **pData, int* len, const VideoDataFormat& format, int timestamp_ms) = 0;
        };
        
        class VideoCryptoCallback
        {
        public:
            virtual int OnVideoDecryptContextCallback(const unsigned char* data, int length) = 0;
            virtual int OnVideoDecryptCallback(unsigned char* in_data, int in_length,
                                               unsigned char** out_data, int* out_length, VideoCodecType codec_type) = 0;
        };
        
        class AudioPlayCallback
        {
        public:    //only pcm data  
            virtual void OnPlayAudioData(unsigned char *const data, int len, int sample_rate, int num_channels, int bit_depth) = 0;
        };
 
        class VideoSourceCallback
        {
        public: 
            virtual int Open(const char *path) = 0;
            virtual void Close() = 0;
            virtual int Read(unsigned char *buf, int size) = 0;
            virtual long long Seek(long long pos, int seekMode) = 0;
            virtual long long GetSize() = 0;
        };
        
        class BlockDataCallback
        {
        public:
            virtual void OnBlockBegin(const char *path) = 0;
            virtual int OnBlockData(unsigned char *buf, int size) = 0;
        };
        
        typedef enum
        {
            MSG_TYPE_UNKNOWN = 0x3E0,
            MSG_TYPE_USER_PACKETED = 0x3E8,             //User packeted message
            MSG_TYPE_USER_DEFINED = 0x3E9,              //User input message other than SEI(payload type = 5)
            MSG_TYPE_MIXER_VOLUME = 0x3EA,              //music wave
            MSG_TYPE_LAYOUT_SETTING = 0x3EB,            //layout information
            MSG_TYPE_USER_DEFINED_NEED_FILTER  = 0x3EC, //SEI(payload type = 5), uuid filter is required or all message(payload type = 5) will be thrown.
        }SideInfoMsgType;
        
        class MediaSideCallback
        {
            public:
                virtual void OnMediaSideInfo(const unsigned char* buf, int bufLen, int msgType) = 0; //msgType SideInfoMsgType
        };
        
        enum Alpha_Layout_Mode
        {
            ALPHA_LAYOUT_NULL = 0,
            ALPHA_LAYOUT_DOWN,
            ALPHA_LAYOUT_LEFT,
            ALPHA_LAYOUT_RIGHT,
            ALPHA_LAYOUT_RIGHT_TOP,
        };
        struct LoadParam {
            const char* path = 0;
            long start_ms = 0;
            int loop_count = 0;
            unsigned char* mem = 0;
            int mem_len = 0;
            unsigned char alpha_layout = ALPHA_LAYOUT_NULL;
            unsigned char instant_play = 0;
            const char* iplist = 0; 
        };
        struct MediaInfo {
            int width = 0;
            int height = 0;
            int frame_rate = 0;
        };
        struct PlayStat {
            double vsrc_fps;
            double vdec_fps;
            double vrnd_fps;
            double asrc_fps;
            double adec_fps;
            double arnd_fps;
        };
        enum StreamType
        {
            STREAM_NONE = 0,
            STREAM_AUDIO = 1,
            STREAM_VIDEO = 2,
        };
        
        typedef enum
        {
            PROP_EFFECT_NONE = 0,
            PROP_EFFECT_LOCAL = 1,
            PROP_EFFECT_PUBLISH = PROP_EFFECT_LOCAL << 1,
        } EffectPropertyMask;
        virtual int  EnableLiveEffect(bool bEnable, int properties, int level) = 0;
        //EffectPropertyMask properties = PROP_EFFECT_LOCAL | PROP_EFFECT_PUBLISH
        //level = 0; not use now
 
        virtual void SetEventCallback(EventCallback* callback) = 0;
        virtual void SetVideoSourceCallback(VideoSourceCallback* callback) = 0;
        virtual void SetBlockDataCallback(BlockDataCallback *callback, int block_size) = 0;
        virtual void SetPlayerType(PlayerType type) = 0;
        virtual float GetMediaPlayerSoundLevel() = 0;
        virtual int  GetMediaPlayerFreqSpectrum(float *spectrum_buf, int buf_size, int *spectrum_size) = 0;
        virtual void SetVolume(int volume) = 0;  // local volume: 0 ~ 200, default volume is 60
        virtual void SetPublishVolume(int volume) = 0; // publish volume: 0 ~ 200, default volume is 60
        virtual int  GetVolume() = 0;        // local volume
        virtual int  GetPublishVolume() = 0; // publish volume
        virtual void MuteLocal(bool bMute) = 0;
        virtual void Load(const char* path, long start_ms = 0, int loop_count = 0) = 0; //loop_count: -1 = infinite loop
        virtual void Load(unsigned char* mem, int mem_len, long start_ms = 0, int loop_count = 0) = 0;
        virtual void Start(const char* path, long start_ms = 0, int loop_count = 0) = 0;
        // repeat_play: play repeat or not;
        virtual void Start(const char* path, bool repeat_play = false, long start_ms = 0) = 0;
        virtual void Start(unsigned char* mem, int mem_len, long start_ms = 0, int loop_count = 0) = 0;
        virtual void Load(LoadParam param) = 0;
        virtual void Stop() = 0;
        virtual void Pause() = 0;
        virtual void Resume() = 0;
        virtual void SeekTo(long timestamp_ms) = 0;                          //Units in millisecond
        virtual long GetDuration() = 0;
        virtual long GetCurrentDuration() = 0;
        virtual long SetProcessInterval(long interval_ms) = 0;
        
        virtual void SetView(void *view, bool enable_alpha_blend) = 0;
        virtual void SetViewMode(int nMode) = 0;
        virtual void ClearView() = 0;
        virtual void EnableViewMirror(bool enable) = 0;
 
        //format support:ARGB32/ABGR32/RGBA32/BGRA32/I420/NV12/NV21
        virtual void SetVideoPlayCallback(VideoPlayCallback *callback, VideoPixelFormat format) = 0;
        virtual void SetVideoCryptoCallback(VideoCryptoCallback* callback) = 0;
        virtual void SetAudioPlayCallback(AudioPlayCallback *callback) = 0;
        virtual void SetMediaSideCallback(MediaSideCallback *callback) = 0;
        virtual long SetAudioStream(long streamidx) = 0;
        virtual long SetAudioPublishStream(long streamidx) = 0;
        virtual long GetAudioStreamCount() = 0;
        virtual void SetRepeatMode(bool repeat_play) = 0;
        virtual void SetLoopCount(int loop_count) = 0;
        virtual long TakeSnapshot() = 0;
        virtual long RequireHWDecoder() = 0;
        virtual void SetBackgroundColor(int color) = 0;   //0x00RRGGBB
        virtual void EnableAccurateSeek(bool bAccurate = false) = 0;
        virtual void SetAccurateSeekTimeout(long timeout_ms = 5000) = 0;
        virtual void SetActiveAudioChannel(AudioChannel channel) = 0;
        // key_shift_value can set any value between -8.0 ~ 8.0
        virtual int  SetAudioChannelKeyShift(AudioChannel channel, float key_shift_value) = 0;
        virtual int  EnableAudioChannelKeyShift(AudioChannel channel, bool enable, float key_shift_value) = 0;
        virtual void SetNetSourceCache(int max_cache_ms, int max_cache_size) = 0;
        virtual int  GetNetSourceCacheStat(int *cache_ms, int *cache_size) = 0;
        virtual void SetBufferThreshold(int buffer_end_threshold_ms) = 0;
        virtual void SetLoadResourceTimeout(int timeout_ms) = 0;
        // header format : "Host: xxx\r\nUser-Agent: xxx\r\n"
        virtual void SetHttpHeaders(const char *header) = 0;
        // speed between 0.5 ~ 2.0
        virtual int  SetPlaySpeed(float speed) = 0; 
        virtual void EnableMultiAudioTrackDecode(bool bEnable = false) = 0;
        virtual char* GetMetaDataValue(const char *key) = 0;
        virtual int  GetMediaInfo(MediaInfo *info) = 0;
        virtual bool IsActive() = 0;
        virtual int SetVirtualStereoGain(float gain) = 0;
        virtual int  EnableVirtualStereo(bool bEnable, int hAngle) = 0;
        virtual void DisableStream(StreamType type) = 0;
        virtual void EnableLocalCache(bool enable, const char *local_dir) = 0;
        virtual int  GetPlayStat(PlayStat *stat) = 0;
        virtual void EnableStatusMonitor(bool enable) = 0;
    };
    
    class IAudioEffectPlayer {
    public:
        class EffectEventCallback
        {
        public:
            virtual void OnPreloadComplete(unsigned int sound_id) = 0;
            virtual void OnPlayEnd(unsigned int sound_id) = 0;
        };
 
        class AudioSourceCallback
        {
        public: 
            virtual int Open(unsigned int sound_id, const char *path) = 0;
            virtual void Close(unsigned int sound_id) = 0;
            virtual int Read(unsigned int sound_id, unsigned char *buf, int size) = 0;
            virtual long long Seek(unsigned int sound_id, long long pos, int seekMode) = 0;
            virtual long long GetSize(unsigned int sound_id) = 0;
        };
        
        virtual void SetEventCallback(EffectEventCallback* callback) = 0;
        virtual void SetAudioSourceCallback(AudioSourceCallback* callback) = 0;
        virtual int PlayEffect(const char *path, unsigned int sound_id, int loop_count = 0, bool publish_out = false) = 0;
        virtual int StopEffect(unsigned int sound_id) = 0;
        virtual void PauseEffect(unsigned int sound_id) = 0;
        virtual void ResumeEffect(unsigned int sound_id) = 0;
        virtual void SetVolume(unsigned int sound_id, int volume) = 0;
        virtual void SetPublishVolume(unsigned int sound_id, int volume) = 0;
        virtual int  SeekTo(unsigned int sound_id, long timestamp_ms) = 0;                          //Units in millisecond
        virtual void SetPlaySpeed(unsigned int sound_id, float speed) = 0;
        virtual long GetDuration(unsigned int sound_id) = 0;
        virtual long GetCurrentDuration(unsigned int sound_id) = 0;
        virtual void SetVolumeAll(int volume) = 0;
        virtual void SetPublishVolumeAll(int volume) = 0;
        virtual void PauseAll() = 0;
        virtual void ResumeAll() = 0;
        virtual void StopAll() = 0;
        virtual int  PreloadEffect(const char *path, unsigned int sound_id) = 0;
        virtual void UnloadEffect(unsigned int sound_id) = 0;
        
        virtual bool IsActive(int sound_id) = 0;
        virtual void ResetVirtualStereo(bool bEnable, float gain, int hAngle) = 0;
        virtual int SetVirtualStereoGain(float gain, int sound_id) = 0;
        virtual int  EnableVirtualStereo(bool bEnable, int hAngle, int sound_id) = 0;
    };
}
 
#endif /* ZEGOMediaPlayer_h */