video_capture.h

Go to the documentation of this file.

#ifndef ZEGOVideoCapture_h
#define ZEGOVideoCapture_h
#include "video_format.h"
namespace AVE {  
    enum {
        VCAP_ERROR_NOERROR = 0,
        VCAP_ERROR_GENERIC_ERROR = -1,
        VCAP_ERROR_NOMEMORY = -2,
 
        VCAP_ERROR_INVALID_ACTIVE_D3D11_DEVICE = -1024,
    };
 
    typedef VideoDataFormat VideoCaptureFormat;
    
    class SupportsVideoCapture {
    public:
        virtual int SetFrameRate(int framerate) = 0;
        
        virtual int SetResolution(int width, int height) = 0;
        
        virtual int SetFrontCam(int bFront) = 0;
        
        virtual int SetView(void *view) = 0;
        
        virtual int SetViewMode(int nMode) = 0;
        
        virtual int SetViewRotation(int nRotation) = 0;
        
        virtual int SetCaptureRotation(int nRotation) = 0;
        
        virtual int StartPreview() = 0;
        
        virtual int StopPreview() = 0;
        
        virtual int EnableTorch(bool bEnable) = 0;
        
        virtual int TakeSnapshot() = 0;
        
        virtual int SetPowerlineFreq(unsigned int nFreq) { return 0; }
    };
    
    enum VideoFillMode {
        FILL_MODE_BLACKBAR,         // * maintain aspect ratio, adds black bars if needed
        FILL_MODE_CROP,             // * crop video to fit view
        FILL_MODE_STRETCH           // * stretch video to fit view
    };
    
    enum VideoFlipMode {
        FLIP_MODE_NONE = 0,
        FLIP_MODE_X = 1 << 0,       // * 水平翻转，镜像
        FLIP_MODE_Y = 1 << 1,       // * 垂直翻转
    };
 
    // [top, left](bottom, right)
    struct ROIRect {
        ROIRect() {
            top = left = bottom = right = 0;
            level = 2;
        }
        
        int top;
        int left;
        int bottom;
        int right;
        int level; // [0~10]
    };
    
    class VideoCaptureCallback {
    public:
        virtual void OnIncomingCapturedData(const char* data,
                                            int length,
                                            const VideoCaptureFormat& frame_format,
                                            unsigned long long reference_time,
                                            unsigned int reference_time_scale) = 0;
 
        virtual void OnIncomingCapturedData2(unsigned char **ptrs, 
                                             int *lens,
                                             const VideoCaptureFormat& frame_format,
                                             unsigned long long reference_time,
                                             unsigned int reference_time_scale) = 0;
 
#if defined(_WIN32) || defined(WIN32) || defined(_MSC_VER)
        virtual int OnIncomingD3DTexture(void* videoTex,
            unsigned int rotate,
            unsigned long long reference_time,
            unsigned int reference_time_scale) {
            return 0;
        };
 
        virtual int OnIncomingD3DTextureWithHandle(void* texture, void* shared_handle,
            unsigned long long reference_time,
            unsigned int reference_time_scale) {
            return 0;
        };
 
        virtual void ResetTextureContext() {};
#endif
 
        virtual void OnTakeSnapshot(void* image) = 0;
        
        virtual void SetFillMode(int mode) = 0;
 
        virtual int SetROI(ROIRect* rects, int count) = 0;
    };
    
    class VideoCaptureCVPixelBufferCallback {
    public:
        virtual void OnIncomingCapturedData(void* buffer,
                                            double reference_time_ms) = 0;
        
        virtual void SetFillMode(int mode) = 0;
        virtual void SetRotation(int rotation) = 0;
 
        virtual int SetROI(ROIRect* rects, int count) = 0;
    };
    
    class VideoCaptureSurfaceTextureCallback {
    public:
        virtual void* GetSurfaceTexture() = 0;
 
        virtual int SetROI(ROIRect* rects, int count, unsigned long long timestamp_ns) = 0;
        virtual void SetFillMode(int mode) = 0;
        virtual void SetTextureResolution(int width, int height) = 0;
    };
    
    class VideoCaptureTextureCallback {
    public:
        virtual void OnIncomingCapturedData(int texture_id, int width, int height, double reference_time_ms) = 0;
        
        virtual void SetFillMode(int mode) = 0;
        
        virtual void SetFlipMode(int mode) = 0;
        
        virtual void SetTransformMatrix(float matrix[16]) = 0;
        
        virtual void SetRotation(int rotation) = 0;
 
        virtual int SetROI(ROIRect* rects, int count) = 0;
        
        virtual void ResetTextureContext() = 0;
    };
        
    struct VideoCodecConfig {
        VideoCodecConfig() : width(0), height(0), codec_type(CODEC_TYPE_AVC_AVCC), media_side_info(0), media_side_info_size(0), is_external_clock(false), rotation(0), stream_layer(2) {
        }
        
        int width;
        int height;
        VideoCodecType codec_type;
        const char* media_side_info; // deprecated, use CEngine::SendMediaSideInfo instead
        int media_side_info_size; // deprecated, use CEngine::SendMediaSideInfo instead
 
        bool is_external_clock;
        int rotation; // counterclockwise degree
 
        int stream_layer; // stream layer, @see CEngine::VideoStreamLayer_t
    };
    
    class VideoCaptureEncodedFrameCallback {
    public:
        virtual void OnEncodedFrame(const char* data, int length,
                                    const VideoCodecConfig& codec_config,
                                    bool b_keyframe, double reference_time_ms) = 0;
 
        virtual bool ConvertTimestamp(unsigned long long reference_time_ms, unsigned long long *adjusted_time_ms) = 0;
        
        typedef void(*OnRequestIDRCallback)(void *callback_context);
        virtual void RegisterRequestIDRCallback(OnRequestIDRCallback callback, void *callback_context) = 0;
    };
    
    enum VideoPixelBufferType {
        PIXEL_BUFFER_TYPE_UNKNOWN = 0,
        PIXEL_BUFFER_TYPE_MEM = 1 << 0,
        PIXEL_BUFFER_TYPE_CV_PIXEL_BUFFER = 1 << 1,
        PIXEL_BUFFER_TYPE_SURFACE_TEXTURE = 1 << 2,
        PIXEL_BUFFER_TYPE_GL_TEXTURE_2D = 1 << 3,
        PIXEL_BUFFER_TYPE_ENCODED_FRAME = 1 << 4,
        PIXEL_BUFFER_TYPE_I422_MEM_FOR_HIGH422 = 1 << 5,
        PIXEL_BUFFER_TYPE_GL_TEXTURE_EXTERNAL_OES = 1 << 6,
        PIXEL_BUFFER_TYPE_D3D9_TEXTURE = 1 << 7,
        PIXEL_BUFFER_TYPE_D3D11_TEXTURE = 1 << 8,
        PIXEL_BUFFER_TYPE_D3D12_TEXTURE = 1 << 9,
    };
    
    class VideoCaptureDeviceBase {
    public:
        class Client {
        public:
            virtual ~Client() {}
            
            virtual void Destroy() = 0;
            
            virtual void SetStatusReason(bool is_closed, int reason) = 0;
            
            virtual void* GetInterface() = 0;
        };
        
    public:       
        virtual void AllocateAndStart(Client* client) = 0;
        
        virtual void StopAndDeAllocate() = 0;
        
        virtual int StartCapture() = 0;
 
        virtual int StopCapture() = 0;
        
        virtual VideoPixelBufferType SupportBufferType() = 0;
        
        virtual void* GetInterface() = 0;
    };
    
    class VideoCaptureDevice : public VideoCaptureDeviceBase, public SupportsVideoCapture {
    public:
        class Client : public VideoCaptureDeviceBase::Client, public VideoCaptureCallback {
        public:
            virtual ~Client() {}
            virtual void* GetInterface() {
                return (VideoCaptureCallback*)this;
            }
        };
    
    public :
        virtual void AllocateAndStart(Client* client) = 0;
        
        virtual void AllocateAndStart(VideoCaptureDeviceBase::Client* client) override {
            this->AllocateAndStart((Client*)client);
        }
        
        virtual VideoPixelBufferType SupportBufferType() override {
            return VideoPixelBufferType::PIXEL_BUFFER_TYPE_MEM;
        }
        
        virtual void* GetInterface() override {
            return (SupportsVideoCapture*)this;
        }
    };
    
    class VideoCaptureFactory {
    public:
        virtual ~VideoCaptureFactory() {}
        virtual VideoCaptureDeviceBase* Create(const char* device_id) = 0;
 
        virtual void Destroy(VideoCaptureDeviceBase *vc) = 0;
    };
    
    enum VideoBufferType {
        BUFFER_TYPE_UNKNOWN = 0,
        BUFFER_TYPE_MEM = 1 << 0,
        BUFFER_TYPE_ASYNC_PIXEL_BUFFER = 1 << 1,
        BUFFER_TYPE_SYNC_PIXEL_BUFFER = 1 << 2,
        BUFFER_TYPE_SURFACE_TEXTURE = 1 << 3,
        BUFFER_TYPE_HYBRID_MEM_GL_TEXTURE_2D = 1 << 4,
        BUFFER_TYPE_SYNC_GL_TEXTURE_2D = 1 << 5,
        BUFFER_TYPE_ASYNC_I420_MEM = 1 << 6,
        BUFFER_TYPE_ASYNC_I420_PIXEL_BUFFER = 1 << 7,
        BUFFER_TYPE_ASYNC_NV12_PIXEL_BUFFER = 1 << 8,
        BUFFER_TYPE_ASYNC_CM_SAMPLE_BUFFER = 1 << 9,
        BUFFER_TYPE_SYNC_CM_SAMPLE_BUFFER = 1 << 10,
        BUFFER_TYPE_SYNC_BGRA32_MEM = 1 << 11,
        BUFFER_TYPE_SYNC_I420_MEM = 1 << 12,
        BUFFER_TYPE_SYNC_NV12_PIXEL_BUFFER = 1 << 13,
    };
 
    enum VideoBufferDestination {
        BUFFER_TO_PREVIEW = 0,
        BUFFER_TO_ENCODE = 1,
        BUFFER_TO_BOTH = 2,
    };
 
    class VideoBufferPool {
    public:
        virtual int DequeueInputBuffer(int width, int height, int stride) = 0;
        virtual void* GetInputBuffer(int index) = 0;
        virtual void QueueInputBuffer(int index, int width, int height, int stride, unsigned long long timestamp_100n) = 0;
        virtual void QueueInputBufferWithDest(int index, int width, int height, int stride, 
                                              unsigned long long timestamp_100n, VideoBufferDestination dest) {
        }
    };
    
    class VideoFilterCallback {
    public:
        virtual void OnProcess(void* buffer, int size, int width, int height, int stride, unsigned long long timestamp_100n) = 0;
        virtual void OnProcessWithDest(void* buffer, int size, int width, int height, int stride, 
                                       unsigned long long timestamp_100n, VideoBufferDestination dest) {
        }
    };
 
    class VideoFilterMemCallback {
    public:
        virtual void OnProcessMem(unsigned char **pData, int* dataLen, int width, int height, int stride[4], unsigned long long timestamp_100n) = 0;
        virtual void OnProcessMemWithDest(unsigned char **pData, int* dataLen, int width, int height, int stride[4], 
                                          unsigned long long timestamp_100n, VideoBufferDestination dest) {
        }
    };
    
    class VideoFilter {
    public:
        class Client {
        public:
            virtual ~Client() {}
            virtual void Destroy() = 0;
            
            virtual void* GetInterface() = 0;
        };
        
    public:
        virtual void AllocateAndStart(Client* client) = 0;
        
        virtual void StopAndDeAllocate() = 0;
        
        virtual VideoBufferType SupportBufferType() = 0;
        
        virtual void* GetInterface(VideoBufferType buffer_type = BUFFER_TYPE_UNKNOWN) = 0;
    };
    
    class VideoFilterFactory {
    public:
        virtual ~VideoFilterFactory() {}
        
        virtual VideoFilter* Create() = 0;
        
        virtual void Destroy(VideoFilter *vf) = 0;
    };
    
    class Camera : public VideoCaptureDeviceBase, public SupportsVideoCapture {
    public:
        static Camera* Create();
        static void Destroy(Camera* camera);
        
        virtual void SetDeviceId(const char* device_id) = 0;
    };
 
    class PictureCaptureDevice :  public VideoCaptureDeviceBase {
    public:
        static PictureCaptureDevice* Create(unsigned int instance_id);
        static void Destroy(PictureCaptureDevice* camera);
 
        virtual void SetPath(const char* path) = 0;
    };
}
#endif /* ZEGOVideoCapture_h */