NGIAgoraCameraCapturer.h

//
//  Agora SDK
//
//  Copyright (c) 2019 Agora.io. All rights reserved.
//
 
#pragma once  // NOLINT(build/header_guard)
 
#include "AgoraBase.h"
#include "AgoraRefPtr.h"
 
namespace agora {
namespace rtc {
class IVideoSinkBase;
class ICameraCaptureObserver;
class ICameraCapturer : public RefCountInterface {
 
 public:
  enum CAMERA_SOURCE {
    CAMERA_BACK,
    CAMERA_FRONT,
    CAMERA_EXTRA,
  };
 
  enum CAMERA_STATE {
    CAMERA_STARTED,
    CAMERA_STOPPED,
  };
 
  // Interface for receiving information about available camera devices.
  class IDeviceInfo {
   public:
    virtual ~IDeviceInfo() {}
 
    virtual void release() = 0;
 
    virtual uint32_t NumberOfDevices() = 0;
 
    virtual int32_t GetDeviceName(uint32_t deviceNumber, char* deviceNameUTF8,
                                  uint32_t deviceNameLength, char* deviceUniqueIdUTF8,
                                  uint32_t deviceUniqueIdLength, char* productUniqueIdUTF8 = 0,
                                  uint32_t productUniqueIdLength = 0,
                                  char* deviceTypeUTF8 = 0, uint32_t deviceTypeLength = 0) = 0;
 
    virtual int32_t NumberOfCapabilities(const char* deviceUniqueIdUTF8) = 0;
 
    virtual int32_t GetCapability(const char* deviceUniqueIdUTF8,
                                  const uint32_t deviceCapabilityNumber,
                                  VideoFormat& capability) = 0;
  };
 
 public:
#if defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IPHONE)
 
  virtual int setCameraSource(CAMERA_SOURCE source) = 0;
  virtual CAMERA_SOURCE getCameraSource() = 0;
  virtual void switchCamera() = 0;
  virtual bool isZoomSupported() = 0;
  virtual int32_t setCameraZoom(float zoomValue) = 0;
  virtual float getCameraMaxZoom() = 0;
  virtual bool isFocusSupported() = 0;
  virtual int32_t setCameraFocus(float x, float y) = 0;
  virtual bool isAutoFaceFocusSupported() = 0;
  virtual int32_t setCameraAutoFaceFocus(bool enable) = 0;
  virtual int32_t enableFaceDetection(bool enable) = 0;
 
  virtual bool isCameraFaceDetectSupported() = 0;
 
  virtual bool isCameraTorchSupported() = 0;
 
  virtual int setCameraTorchOn(bool isOn) = 0;
 
  virtual bool isCameraExposurePositionSupported() = 0;
 
  virtual int setCameraExposurePosition(float positionXinView, float positionYinView) = 0;
  
  virtual bool isCameraExposureSupported() = 0;
 
  virtual int setCameraExposureFactor(float value) = 0;
 
#if (defined(__APPLE__) && TARGET_OS_IOS)
 
  virtual bool enableMultiCamera(bool enable) = 0;
  virtual bool isCameraAutoExposureFaceModeSupported() = 0;
 
 
  virtual int setCameraAutoExposureFaceModeEnabled(bool enabled) = 0;
 
  virtual int setCameraStabilizationMode(CAMERA_STABILIZATION_MODE mode) = 0;
#endif
  
#elif defined(_WIN32) || (defined(__linux__) && !defined(__ANDROID__)) || \
    (defined(__APPLE__) && TARGET_OS_MAC && !TARGET_OS_IPHONE)
 
  virtual IDeviceInfo* createDeviceInfo() = 0;
  virtual int initWithDeviceId(const char* deviceId) = 0;
  virtual int initWithDeviceName(const char* deviceName) = 0;
#endif
 
#if defined(__APPLE__)
 
  virtual bool isSupportCenterStage() = 0;
  
  virtual int enableCenterStage(bool enabled) = 0;
#endif
 
  virtual void setDeviceOrientation(VIDEO_ORIENTATION orientation) = 0;
 
  virtual void setCaptureFormat(const VideoFormat& capture_format) = 0;
  virtual VideoFormat getCaptureFormat() = 0;
  virtual int registerCameraObserver(ICameraCaptureObserver* observer) = 0;
  virtual int unregisterCameraObserver(ICameraCaptureObserver* observer) = 0;
 
 protected:
  ~ICameraCapturer() {}
};
class ICameraCaptureObserver {
 public:
  virtual void onCameraFocusAreaChanged(int imageWidth, int imageHeight, int x, int y) {
    (void) imageWidth;
    (void) imageHeight;
    (void) x;
    (void) y;
 
  }
  virtual void onFacePositionChanged(
      int imageWidth, int imageHeight, const Rectangle* vecRectangle, const int* vecDistance, int numFaces) {
    (void) imageWidth;
    (void) imageHeight;
    (void) vecRectangle;
    (void) vecDistance;
    (void) numFaces;
  }
 
  virtual void onCameraExposureAreaChanged(int x, int y, int width, int height) {
    (void)x;
    (void)y;
    (void)width;
    (void)height;
  }
 
  virtual void onCameraStateChanged(ICameraCapturer::CAMERA_STATE state, ICameraCapturer::CAMERA_SOURCE source) {
    (void) state;
    (void) source;
  }
 
 protected:
  virtual ~ICameraCaptureObserver() {}
};
 
}  // namespace rtc
}  // namespace agora