| /* |
| ** |
| ** Copyright 2013, Samsung Electronics Co. LTD |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #ifndef EXYNOS_CAMERA_1_PARAMETERS_H |
| #define EXYNOS_CAMERA_1_PARAMETERS_H |
| |
| #if 0 |
| #include <utils/threads.h> |
| #include <utils/RefBase.h> |
| #include <utils/String8.h> |
| #include <cutils/properties.h> |
| #include <camera/CameraParameters.h> |
| |
| #include <videodev2.h> |
| #include <videodev2_exynos_media.h> |
| #include <videodev2_exynos_camera.h> |
| |
| #ifdef USE_CSC_FEATURE |
| #include <SecNativeFeature.h> |
| #endif |
| |
| #include "ExynosCameraCommonDefine.h" |
| #include "ExynosCameraCommonEnum.h" |
| //#include "ExynosCameraConfig.h" |
| |
| #include "ExynosCameraSensorInfo.h" |
| #include "ExynosCameraCounter.h" |
| #include "fimc-is-metadata.h" |
| #include "ExynosRect.h" |
| #include "exynos_format.h" |
| #include "ExynosExif.h" |
| #include "ExynosCameraUtils.h" |
| #include "ExynosCameraUtilsModule.h" |
| #include "ExynosCameraActivityControl.h" |
| #include "ExynosCameraAutoTimer.h" |
| #ifdef SAMSUNG_TN_FEATURE |
| #include "SecCameraParameters.h" |
| #endif |
| #ifdef SUPPORT_SW_VDIS |
| #include "SecCameraSWVdis_3_0.h" |
| #endif /*SUPPORT_SW_VDIS*/ |
| #ifdef SAMSUNG_OIS |
| #include"ExynosCameraNode.h" |
| #endif |
| #endif |
| |
| #include "ExynosCameraConfig.h" |
| #include "ExynosCameraParameters.h" |
| |
| #include "ExynosCameraUtilsModule.h" |
| #include "ExynosCameraSensorInfo.h" |
| #include "ExynosCameraNode.h" |
| |
| #ifdef SAMSUNG_UNI_API |
| #include "uni_api_wrapper.h" |
| #endif |
| |
| #if defined(SAMSUNG_COMPANION) || defined(SAMSUNG_EEPROM) |
| #include "SecCameraUtil.h" |
| #endif |
| #ifdef SAMSUNG_DNG |
| #include "SecCameraDng.h" |
| #endif |
| |
| #define IS_WBLEVEL_DEFAULT (4) |
| #define FW_CUSTOM_OFFSET (1) |
| #define ZOOM_RATIO_3X (430) |
| |
| namespace android { |
| |
| #ifdef USE_DUAL_CAMERA |
| enum dual_camera_notify_type { |
| DUAL_CAMERA_NOTIFY_BASE, |
| DUAL_CAMERA_NOTIFY_WAKE_UP, |
| DUAL_CAMERA_NOTIFY_WAKE_UP_FINISH, |
| DUAL_CAMERA_NOTIFY_SET_OBJECT_TRACKING_FOCUS_AREA, |
| DUAL_CAMERA_NOTIFY_MAX, |
| }; |
| |
| class ExynosCamera; |
| typedef status_t (ExynosCamera::*dual_notify_func_t)(enum dual_camera_notify_type /* notifyType */, |
| int32_t /* arg1 */, int32_t /* arg2 */, void* /* arg3 */); |
| |
| /* singleton object */ |
| class ExynosCamera1DualParameters : public ExynosCameraSingleton<ExynosCamera1DualParameters> { |
| protected: |
| friend class ExynosCameraSingleton<ExynosCamera1DualParameters>; |
| |
| /* Constructor */ |
| ExynosCamera1DualParameters() { init(); }; |
| ~ExynosCamera1DualParameters() {}; |
| void init(); |
| |
| public: |
| typedef struct dual_camera_notify_parcel { |
| enum dual_camera_notify_type notifyType; |
| int32_t arg1; |
| int32_t arg2; |
| void* arg3; |
| } dual_camera_notify_parcel_t; |
| |
| /* type equals to sync_type_t in ExynosCameraFrame */ |
| void setDualCameraSyncType(int32_t cameraId, sync_type_t *type, sync_type_t *reprocessingType); |
| sync_type_t getDualCameraSyncType(int32_t cameraId); |
| sync_type_t getDualCameraReprocessingSyncType(int32_t cameraId); |
| void setZoom(int32_t cameraId, int zoom); |
| int getZoom(int32_t cameraId); |
| void setLLSValue(int32_t cameraId, int LLSValue); |
| int getLLSValue(int32_t cameraId); |
| void lockDualCameraSyncType(int32_t cameraId, bool lockFlag); |
| void clearDualCameraInformation(int32_t cameraId); |
| #ifdef DUAL_SMOOTH_TRANSITION_LAUNCH |
| void finishStartPreview(int32_t cameraId, int32_t targetCameraId); |
| bool getFlagFinishStartPreview(int32_t cameraId, int32_t targetCameraId); |
| #endif |
| void setForceSwitchingOnly(int32_t cameraId, bool forceSwitchingOnly); |
| int getFlagForceSwitchingOnly(int32_t cameraId); |
| #ifdef SAMSUNG_DUAL_SOLUTION |
| void setForceWide(int32_t cameraId, bool forceWide); |
| int getForceWide(int32_t cameraId); |
| int checkDualAfState(int cameraId, int focusState); |
| void setForceWideCond(int32_t cameraId, bool forceWideCond); |
| bool getForceWideCond(int32_t cameraId); |
| void checkFusionCaptureMode(int cameraId, |
| struct camera2_shot_ext *wideMeta, struct camera2_shot_ext *teleMeta); |
| bool getFusionCaptureMode(int cameraId, bool isLogPrint); |
| void setRecordingHint(int32_t cameraId, bool hint); |
| bool getRecordingHint(int32_t cameraId); |
| void setMasterCam(int32_t cameraId, int32_t curDispCamId); |
| int getMasterCam(int32_t cameraId); |
| #ifdef SAMSUNG_SENSOR_LISTENER |
| #ifdef SAMSUNG_GYRO |
| void setDualGyro(SensorListenerEvent_t data); |
| void setDualGyroHint(bool onOff); |
| bool getDualGyroHint(void); |
| #endif |
| #ifdef SAMSUNG_HRM |
| void setDualHRM(int ir_data, int flicker_data, int status); |
| void setDualHRMHint(bool onOff); |
| bool getDualHRMHint(void); |
| #endif |
| #ifdef SAMSUNG_ACCELEROMETER |
| void setDualAccelerometer(SensorListenerEvent_t data); |
| void setDualAccelerometerHint(bool onOff); |
| bool getDualAccelerometerHint(void); |
| #endif |
| #endif |
| camera2_shot_ext* getDualMetadata(void); |
| #endif |
| void setParamExifInfo(int32_t cameraId, uint32_t iso, uint32_t exposureTime); |
| void registerCameraParam(int32_t cameraId, CameraParameters* param); |
| /* to notify */ |
| void registerNotifyCallback(int32_t cameraId, ExynosCamera *camera, dual_notify_func_t notifyFunc); |
| void unregisterNotifyCallback(int32_t cameraId); |
| status_t notify(int32_t cameraId, |
| enum dual_camera_notify_type notifyType, |
| bool useThread, |
| int32_t arg1, |
| int32_t arg2, |
| void* arg3); |
| |
| private: |
| /* to notify specific camera from other camera */ |
| typedef ExynosCameraThread<ExynosCamera1DualParameters> DualNotifyThread; |
| ExynosCameraList<dual_camera_notify_parcel_t *> m_dualNotifyQ; |
| sp<DualNotifyThread> m_dualNotifyThread; |
| bool m_dualNotifyThreadFunc(void); |
| bool m_flagDualNotifyThreadStop; |
| ExynosCamera *m_camera[CAMERA_ID_MAX]; |
| CameraParameters *m_params[CAMERA_ID_MAX]; |
| dual_notify_func_t m_dualNotifyCallbackFunc[CAMERA_ID_MAX]; /* it will be registered by each ExynosCamera */ |
| |
| char m_name[EXYNOS_CAMERA_NAME_STR_SIZE]; |
| Mutex m_lock; |
| int m_zoom; |
| int m_LLSValue; |
| sync_type_t m_dualCameraSyncType; |
| sync_type_t m_dualCameraReprocessingSyncType; |
| bool m_lockDualCameraSyncType; |
| bool m_flagFinishStartPreview[CAMERA_ID_MAX]; |
| bool m_flagForceSwitchingOnly; |
| #ifdef SAMSUNG_DUAL_SOLUTION |
| bool m_forceWideCond; |
| bool m_forceWide; |
| int m_wideFocusState; |
| int m_teleFocusState; |
| bool m_wideFocusDone; |
| bool m_teleFocusDone; |
| int32_t m_dualLux; |
| int32_t m_dualFocusDistance; |
| int32_t m_forceWideOnDelay; |
| int32_t m_forceWideOffDelay; |
| int32_t m_checkForceWideCount; |
| int32_t m_checkForceWideCond; |
| bool m_isFusionCapture; |
| camera2_shot_ext m_dualmetadata; |
| bool m_dualGyroHint; |
| bool m_dualAccHint; |
| bool m_dualHrmHint; |
| bool m_recordingHint; |
| int32_t m_masterCam; |
| #endif |
| }; |
| #endif |
| |
| class ExynosCamera1Parameters : public ExynosCameraParameters { |
| public: |
| /* Constructor */ |
| ExynosCamera1Parameters(int cameraId, bool flagCompanion = false, int halVersion = IS_HAL_VER_1_0, bool flagDummy = false); |
| |
| /* Destructor */ |
| virtual ~ExynosCamera1Parameters(); |
| |
| /* Create the instance */ |
| bool create(int cameraId); |
| /* Destroy the instance */ |
| bool destroy(void); |
| /* Check if the instance was created */ |
| bool flagCreate(void); |
| |
| void setDefaultCameraInfo(void); |
| void setDefaultParameter(void); |
| status_t setRestartParameters(const CameraParameters& params); |
| bool checkRestartPreview(const CameraParameters& params); |
| |
| void operator=(const ExynosCamera1Parameters& params); |
| |
| public: |
| status_t checkVisionMode(const CameraParameters& params); |
| #ifdef USE_FW_OPMODE |
| status_t checkFactorytest(const CameraParameters& params); |
| #endif |
| status_t checkRecordingHint(const CameraParameters& params); |
| status_t checkDualMode(const CameraParameters& params); |
| status_t checkDualRecordingHint(const CameraParameters& params); |
| #ifdef USE_DUAL_CAMERA |
| status_t checkDualCameraMode(const CameraParameters& params); |
| #endif |
| status_t checkEffectHint(const CameraParameters& params); |
| status_t checkEffectRecordingHint(const CameraParameters& params); |
| /* |
| * Check preview frame rate |
| * both previewFpsRange(new API) and previewFrameRate(Old API) |
| */ |
| status_t checkPreviewFps(const CameraParameters& params); |
| status_t checkPreviewFpsRange(const CameraParameters& params); |
| status_t checkPreviewFrameRate(const CameraParameters& params); |
| status_t checkVideoSize(const CameraParameters& params); |
| status_t checkFastFpsMode(const CameraParameters& params); |
| status_t checkVideoStabilization(const CameraParameters& params); |
| status_t checkSWVdisMode(const CameraParameters& params); |
| status_t checkHWVdisMode(const CameraParameters& params); |
| status_t checkPreviewSize(const CameraParameters& params); |
| status_t checkPreviewFormat(const CameraParameters& params); |
| status_t checkPictureSize(const CameraParameters& params); |
| status_t checkPictureFormat(const CameraParameters& params); |
| status_t checkJpegQuality(const CameraParameters& params); |
| status_t checkThumbnailSize(const CameraParameters& params); |
| status_t checkThumbnailQuality(const CameraParameters& params); |
| status_t check3dnrMode(const CameraParameters& params); |
| status_t checkDrcMode(const CameraParameters& params); |
| status_t checkOdcMode(const CameraParameters& params); |
| status_t checkZoomLevel(const CameraParameters& params); |
| status_t checkRotation(const CameraParameters& params); |
| status_t checkAutoExposureLock(const CameraParameters& params); |
| status_t checkExposureCompensation(const CameraParameters& params); |
| status_t checkExposureTime(const CameraParameters& params); |
| status_t checkMeteringAreas(const CameraParameters& params); |
| status_t checkMeteringMode(const CameraParameters& params); |
| status_t checkAntibanding(const CameraParameters& params); |
| status_t checkSceneMode(const CameraParameters& params); |
| status_t checkFocusMode(const CameraParameters& params); |
| #ifdef SAMSUNG_MANUAL_FOCUS |
| status_t checkFocusDistance(const CameraParameters& params); |
| #endif |
| status_t checkFlashMode(const CameraParameters& params); |
| status_t checkWhiteBalanceMode(const CameraParameters& params); |
| status_t checkAutoWhiteBalanceLock(const CameraParameters& params); |
| #ifdef SAMSUNG_FOOD_MODE |
| status_t checkWbLevel(const CameraParameters& params); |
| void m_setWbLevel(int32_t value); |
| int32_t getWbLevel(void); |
| #endif |
| status_t checkWbKelvin(const CameraParameters& params); |
| void m_setWbKelvin(int32_t value); |
| int32_t getWbKelvin(void); |
| status_t checkFocusAreas(const CameraParameters& params); |
| status_t checkColorEffectMode(const CameraParameters& params); |
| status_t checkGpsAltitude(const CameraParameters& params); |
| status_t checkGpsLatitude(const CameraParameters& params); |
| status_t checkGpsLongitude(const CameraParameters& params); |
| status_t checkGpsProcessingMethod(const CameraParameters& params); |
| status_t checkGpsTimeStamp(const CameraParameters& params); |
| status_t checkCityId(const CameraParameters& params); |
| status_t checkWeatherId(const CameraParameters& params); |
| status_t checkBrightness(const CameraParameters& params); |
| status_t checkSaturation(const CameraParameters& params); |
| status_t checkSharpness(const CameraParameters& params); |
| status_t checkHue(const CameraParameters& params); |
| #ifdef SAMSUNG_COMPANION |
| status_t checkRTDrc(const CameraParameters& params); |
| status_t checkPaf(const CameraParameters& params); |
| status_t checkRTHdr(const CameraParameters& params); |
| status_t checkSceneRTHdr(bool onoff); |
| #endif |
| status_t checkIso(const CameraParameters& params); |
| status_t checkContrast(const CameraParameters& params); |
| status_t checkHdrMode(const CameraParameters& params); |
| status_t checkWdrMode(const CameraParameters& params); |
| status_t checkShotMode(const CameraParameters& params); |
| status_t checkAntiShake(const CameraParameters& params); |
| status_t checkVtMode(const CameraParameters& params); |
| status_t checkVRMode(const CameraParameters& params); |
| status_t checkGamma(const CameraParameters& params); |
| status_t checkSlowAe(const CameraParameters& params); |
| status_t checkScalableSensorMode(const CameraParameters& params); |
| status_t checkImageUniqueId(const CameraParameters& params); |
| status_t checkSeriesShotMode(const CameraParameters& params); |
| #ifdef BURST_CAPTURE |
| status_t checkSeriesShotFilePath(const CameraParameters& params); |
| #endif |
| |
| #ifdef SAMSUNG_LLV |
| status_t checkLLV(const CameraParameters& params); |
| #endif |
| |
| #ifdef SAMSUNG_DOF |
| status_t checkMoveLens(const CameraParameters& params); |
| #endif |
| #ifdef SUPPORT_DEPTH_MAP |
| status_t checkUseDepthMap(void); |
| #endif |
| #ifdef SAMSUNG_HYPER_MOTION |
| status_t checkHyperMotionSpeed(const CameraParameters& params); |
| #endif |
| #ifdef USE_MULTI_FACING_SINGLE_CAMERA |
| status_t checkCameraDirection(const CameraParameters& params); |
| #endif |
| #ifdef SAMSUNG_LENS_DC |
| status_t checkLensDCMode(const CameraParameters& params); |
| #endif |
| status_t checkShutterSpeed(const CameraParameters& params); |
| status_t checkGain(const CameraParameters& params); |
| status_t checkIrLedWidth(const CameraParameters& params); |
| status_t checkIrLedDelay(const CameraParameters& params); |
| status_t checkIrLedCurrent(const CameraParameters& params); |
| status_t checkIrLedOnTime(const CameraParameters& params); |
| status_t calcPreviewGSCRect(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t calcHighResolutionPreviewGSCRect(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t calcRecordingGSCRect(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t calcPictureRect(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t calcPictureRect(int originW, int originH, ExynosRect *srcRect, ExynosRect *dstRect); |
| |
| #ifdef SAMSUNG_DUAL_SOLUTION |
| void getPreviewStatsRoi(ExynosRect *dstRect, ExynosRect *statsRoi); |
| #endif |
| status_t getPreviewBayerCropSize(ExynosRect *srcRect, ExynosRect *dstRect, bool applyZoom = true); |
| status_t getPreviewBdsSize(ExynosRect *dstRect, bool applyZoom = true); |
| status_t getPictureBayerCropSize(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t getPictureBdsSize(ExynosRect *dstRect); |
| status_t getPreviewYuvCropSize(ExynosRect *yuvCropSize); |
| status_t getPictureYuvCropSize(ExynosRect *yuvCropSize); |
| status_t getFastenAeStableSensorSize(int *hwSensorW, int *hwSensorH, int index); |
| status_t getFastenAeStableBcropSize(int *hwBcropW, int *hwBcropH, int index); |
| status_t getFastenAeStableBdsSize(int *hwBdsW, int *hwBdsH, int index); |
| status_t getDepthMapSize(int *depthMapW, int *depthMapH); |
| int getActualPictureRatioIdx(int pictureRatioId); |
| #ifdef SUPPORT_DEPTH_MAP |
| bool getUseDepthMap(void); |
| bool getDepthCallbackOnPreview(void); |
| bool getDepthCallbackOnCapture(void); |
| void setDepthCallbackOnPreview(bool enable); |
| void setDepthCallbackOnCapture(bool enable); |
| void setDisparityMode(enum companion_disparity_mode disparity_mode); |
| #endif |
| bool checkFaceDetectMeta(struct camera2_shot_ext *shot_ext); |
| |
| status_t calcPreviewBayerCropSize(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t calcPictureBayerCropSize(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t calcPreviewBDSSize(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t calcPictureBDSSize(ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t calcNormalToTpuSize(int srcW, int srcH, int *dstW, int *dstH); |
| status_t calcTpuToNormalSize(int srcW, int srcH, int *dstW, int *dstH); |
| status_t calcPreviewDzoomCropSize(ExynosRect *srcRect, ExynosRect *dstRect); |
| /* Sets the auto-exposure lock state. */ |
| void m_setAutoExposureLock(bool lock); |
| /* Sets the auto-white balance lock state. */ |
| void m_setAutoWhiteBalanceLock(bool value); |
| |
| private: |
| #ifdef SUPPORT_DEPTH_MAP |
| void m_setUseDepthMap(bool useDepthMap); |
| #endif |
| /* Sets the dimensions for preview pictures. */ |
| void m_setPreviewSize(int w, int h); |
| /* Sets the image format for preview pictures. */ |
| void m_setPreviewFormat(int colorFormat); |
| /* Sets the dimensions for pictures. */ |
| void m_setPictureSize(int w, int h); |
| /* Sets the image format for pictures. */ |
| void m_setPictureFormat(int colorFormat); |
| /* Sets the image format for picture-related HW. */ |
| void m_setHwPictureFormat(int colorFormat); |
| /* Sets hw video's width, height */ |
| void m_setHwVideoSize(int w, int h); |
| /* Sets video's width, height */ |
| void m_setVideoSize(int w, int h); |
| /* Sets video's color format */ |
| void m_setVideoFormat(int colorFormat); |
| |
| /* Sets the dimensions for Sesnor-related HW. */ |
| void m_setHwSensorSize(int w, int h); |
| /* Sets the dimensions for preview-related HW. */ |
| void m_setHwPreviewSize(int w, int h); |
| /* Sets the image format for preview-related HW. */ |
| void m_setHwPreviewFormat(int colorFormat); |
| /* Sets the dimensions for picture-related HW. */ |
| void m_setHwPictureSize(int w, int h); |
| /* Sets HW Bayer Crop Size */ |
| void m_setHwBayerCropRegion(int w, int h, int x, int y); |
| /* Sets the antibanding. */ |
| void m_setAntibanding(int value); |
| |
| /* Sets the current color effect setting. */ |
| void m_setColorEffectMode(int effect); |
| |
| /* Sets the exposure compensation index. */ |
| void m_setExposureCompensation(int value); |
| /* Sets the flash mode. */ |
| void m_setFlashMode(int flashMode); |
| /* Sets focus areas. */ |
| void m_setFocusAreas(uint32_t numValid, ExynosRect* rects, int *weights); |
| /* Sets focus areas. (Using ExynosRect2) */ |
| void m_setFocusAreas(uint32_t numValid, ExynosRect2* rect2s, int *weights); |
| /* Sets the focus mode. */ |
| void m_setFocusMode(int focusMode); |
| #ifdef SAMSUNG_MANUAL_FOCUS |
| void m_setFocusDistance(int32_t distance); |
| #endif |
| /* Sets Jpeg quality of captured picture. */ |
| void m_setJpegQuality(int quality); |
| /* Sets the quality of the EXIF thumbnail in Jpeg picture. */ |
| void m_setThumbnailQuality(int quality); |
| /* Sets the dimensions for EXIF thumbnail in Jpeg picture. */ |
| void m_setThumbnailSize(int w, int h); |
| /* Sets ExposureTime for preview. */ |
| void m_setExposureTime(uint64_t exposureTime); |
| /* Sets metering areas. */ |
| void m_setMeteringAreas(uint32_t num, ExynosRect *rects, int *weights); |
| /* Sets metering areas.(Using ExynosRect2) */ |
| void m_setMeteringAreas(uint32_t num, ExynosRect2 *rect2s, int *weights); |
| /* Sets the frame rate range for preview. */ |
| void m_setPreviewFpsRange(uint32_t min, uint32_t max); |
| /* Sets the scene mode. */ |
| void m_setSceneMode(int sceneMode); |
| /* Enables and disables video stabilization. */ |
| void m_setVideoStabilization(bool stabilization); |
| /* Sets the white balance. */ |
| status_t m_setWhiteBalanceMode(int whiteBalance); |
| /* Sets Bayer Crop Region */ |
| status_t m_setParamCropRegion(int zoom, int srcW, int srcH, int dstW, int dstH); |
| /* Sets recording mode hint. */ |
| void m_setRecordingHint(bool hint); |
| /* Sets GPS altitude. */ |
| void m_setGpsAltitude(double altitude); |
| /* Sets GPS latitude coordinate. */ |
| void m_setGpsLatitude(double latitude); |
| /* Sets GPS longitude coordinate. */ |
| void m_setGpsLongitude(double longitude); |
| /* Sets GPS processing method. */ |
| void m_setGpsProcessingMethod(const char *gpsProcessingMethod); |
| /* Sets GPS timestamp. */ |
| void m_setGpsTimeStamp(long timeStamp); |
| /* Sets the rotation angle in degrees relative to the orientation of the camera. */ |
| void m_setRotation(int rotation); |
| |
| /* |
| * Additional API. |
| */ |
| /* Sets metering areas. */ |
| void m_setMeteringMode(int meteringMode); |
| /* Sets brightness */ |
| void m_setBrightness(int brightness); |
| #ifdef SAMSUNG_COMPANION |
| /* Sets RT DRC */ |
| void m_setRTDrc(enum companion_drc_mode rtdrc); |
| /* Sets PAF */ |
| void m_setPaf(enum companion_paf_mode paf); |
| /* Sets RT HDR */ |
| void m_setRTHdr(enum companion_wdr_mode rthdr); |
| #endif |
| /* Sets ISO */ |
| void m_setIso(uint32_t iso); |
| /* Sets Contrast */ |
| void m_setContrast(uint32_t contrast); |
| /* Sets Saturation */ |
| void m_setSaturation(int saturation); |
| /* Sets Sharpness */ |
| void m_setSharpness(int sharpness); |
| /* Sets Hue */ |
| void m_setHue(int hue); |
| /* Sets WDR */ |
| void m_setHdrMode(bool hdr); |
| /* Sets WDR */ |
| void m_setWdrMode(bool wdr); |
| /* Sets anti shake */ |
| void m_setAntiShake(bool toggle); |
| /* Sets gamma */ |
| void m_setGamma(bool gamma); |
| /* Sets ODC */ |
| void m_setOdcMode(bool toggle); |
| /* Sets Slow AE */ |
| void m_setSlowAe(bool slowAe); |
| /* Sets 3DNR */ |
| void m_set3dnrMode(bool toggle); |
| /* Sets DRC */ |
| void m_setDrcMode(bool toggle); |
| |
| /* |
| * Vendor specific APIs |
| */ |
| /* Sets Intelligent mode */ |
| status_t m_setIntelligentMode(int intelligentMode); |
| void m_setVisionMode(bool vision); |
| void m_setVisionModeFps(int fps); |
| void m_setVisionModeAeTarget(int ae); |
| |
| void m_setSWVdisMode(bool swVdis); |
| void m_setSWVdisUIMode(bool swVdisUI); |
| |
| /* Sets VT mode */ |
| void m_setVtMode(int vtMode); |
| |
| /* Sets VR mode */ |
| void m_setVRMode(int vrMode); |
| |
| /* Sets dual recording mode hint. */ |
| void m_setDualRecordingHint(bool hint); |
| /* Sets effect hint. */ |
| void m_setEffectHint(bool hint); |
| /* Sets effect recording mode hint. */ |
| void m_setEffectRecordingHint(bool hint); |
| |
| void m_setHighResolutionCallbackMode(bool enable); |
| void m_setHighSpeedRecording(bool highSpeed); |
| void m_setCityId(long long int cityId); |
| void m_setWeatherId(unsigned char cityId); |
| status_t m_setImageUniqueId(const char *uniqueId); |
| /* Sets camera angle */ |
| bool m_setAngle(int angle); |
| /* Sets Top-down mirror */ |
| bool m_setTopDownMirror(void); |
| /* Sets Left-right mirror */ |
| bool m_setLRMirror(void); |
| /* Sets Burst mode */ |
| void m_setSeriesShotCount(int seriesShotCount); |
| bool m_setAutoFocusMacroPosition(int autoFocusMacroPosition); |
| /* Sets Low Light A */ |
| bool m_setLLAMode(void); |
| |
| /* Sets object tracking */ |
| bool m_setObjectTracking(bool toggle); |
| /* Start or stop object tracking operation */ |
| bool m_setObjectTrackingStart(bool toggle); |
| /* Sets x, y position for object tracking operation */ |
| bool m_setObjectPosition(int x, int y); |
| /* Sets smart auto */ |
| bool m_setSmartAuto(bool toggle); |
| /* Sets beauty shot */ |
| bool m_setBeautyShot(bool toggle); |
| |
| /* |
| * Others |
| */ |
| void m_setRestartPreviewChecked(bool restart); |
| bool m_getRestartPreviewChecked(void); |
| void m_setRestartPreview(bool restart); |
| void m_setExifFixedAttribute(void); |
| int m_convertMetaCtlAwbMode(struct camera2_shot_ext *shot_ext); |
| |
| public: |
| |
| #ifdef SAMSUNG_DOF |
| /* Sets Lens Position */ |
| void m_setLensPosition(int step); |
| #endif |
| #ifdef SAMSUNG_HRM |
| void m_setHRM(int ir_data, int flicker_data, int status); |
| void m_setHRM_Hint(bool flag); |
| bool m_getHRMHint(void); |
| #endif |
| #ifdef SAMSUNG_LIGHT_IR |
| void m_setLight_IR(SensorListenerEvent_t data); |
| void m_setLight_IR_Hint(bool flag); |
| #endif |
| #ifdef SAMSUNG_GYRO |
| void m_setGyro(SensorListenerEvent_t data); |
| void m_setGyroHint(bool flag); |
| bool m_getGyroHint(void); |
| #endif |
| #ifdef SAMSUNG_ACCELEROMETER |
| void m_setAccelerometer(SensorListenerEvent_t data); |
| void m_setAccelerometerHint(bool flag); |
| bool m_getAccelerometerHint(void); |
| #endif |
| #ifdef USE_MULTI_FACING_SINGLE_CAMERA |
| void m_setCameraDirection(int cameraDirection); |
| #endif |
| void m_setShutterSpeed(int shutterSpeed); |
| void m_setGain(int gain); |
| void m_setIrLedWidth(int irLedWidth); |
| void m_setIrLedDelay(int irLedDelay); |
| void m_setIrLedCurrent(int irLedCurrent); |
| void m_setIrLedOnTime(int irLedOnTime); |
| |
| #ifdef SAMSUNG_HYPER_MOTION |
| virtual bool getHyperMotionMode(void); |
| virtual void getHyperMotionCropSize(int inputW, int inputH, int outputW, int outputH, |
| int *cropX, int *corpY, int *cropW, int *cropH); |
| int getHyperMotionSpeed(void); |
| #endif |
| /* Returns the image format for FLITE/3AC/3AP bayer */ |
| int getBayerFormat(int pipeId); |
| /* Returns the dimensions setting for preview pictures. */ |
| void getPreviewSize(int *w, int *h); |
| /* Returns the image format for preview frames got from Camera.PreviewCallback. */ |
| int getPreviewFormat(void); |
| /* Returns the dimension setting for pictures. */ |
| void getPictureSize(int *w, int *h); |
| /* Returns the image format for pictures. */ |
| int getPictureFormat(void); |
| /* Returns the image format for picture-related HW. */ |
| int getHwPictureFormat(void); |
| /* Gets video's width, height */ |
| void getHwVideoSize(int *w, int *h); |
| /* Gets video's width, height */ |
| void getVideoSize(int *w, int *h); |
| /* Gets video's color format */ |
| int getVideoFormat(void); |
| /* Gets the supported sensor sizes. */ |
| void getMaxSensorSize(int *w, int *h); |
| /* Gets the supported sensor margin. */ |
| void getSensorMargin(int *w, int *h); |
| /* Gets the supported preview sizes. */ |
| void getMaxPreviewSize(int *w, int *h); |
| /* Gets the supported picture sizes. */ |
| void getMaxPictureSize(int *w, int *h); |
| /* Gets the supported video frame sizes that can be used by MediaRecorder. */ |
| void getMaxVideoSize(int *w, int *h); |
| /* Gets the supported jpeg thumbnail sizes. */ |
| bool getSupportedJpegThumbnailSizes(int *w, int *h); |
| |
| /* Returns the dimensions setting for preview-related HW. */ |
| void getHwSensorSize(int *w, int *h); |
| /* Returns the dimensions setting for preview-related HW. */ |
| void getHwPreviewSize(int *w, int *h); |
| /* Returns the image format for preview-related HW. */ |
| int getHwPreviewFormat(void); |
| /* Returns the dimension setting for picture-related HW. */ |
| void getHwPictureSize(int *w, int *h); |
| /* Returns HW Bayer Crop Size */ |
| void getHwBayerCropRegion(int *w, int *h, int *x, int *y); |
| |
| /* Gets the current antibanding setting. */ |
| int getAntibanding(void); |
| /* Gets the state of the auto-exposure lock. */ |
| bool getAutoExposureLock(void); |
| /* Gets the state of the auto-white balance lock. */ |
| bool getAutoWhiteBalanceLock(void); |
| |
| /* Gets the current color effect setting. */ |
| int getColorEffectMode(void); |
| |
| /* Gets the current exposure compensation index. */ |
| int getExposureCompensation(void); |
| /* Gets the current flash mode setting. */ |
| int getFlashMode(void); |
| /* Gets the current focus areas. */ |
| void getFocusAreas(int *validFocusArea, ExynosRect2 *rect2s, int *weights); |
| /* Gets the current focus mode setting. */ |
| int getFocusMode(void); |
| #ifdef SAMSUNG_MANUAL_FOCUS |
| int32_t getFocusDistance(void); |
| #endif |
| /* Returns the quality setting for the JPEG picture. */ |
| int getJpegQuality(void); |
| /* Returns the quality setting for the EXIF thumbnail in Jpeg picture. */ |
| int getThumbnailQuality(void); |
| /* Returns the dimensions for EXIF thumbnail in Jpeg picture. */ |
| void getThumbnailSize(int *w, int *h); |
| /* Returns the max size for EXIF thumbnail in Jpeg picture. */ |
| void getMaxThumbnailSize(int *w, int *h); |
| /* Gets the current metering areas. */ |
| void getMeteringAreas(ExynosRect *rects); |
| /* Gets the current metering areas.(Using ExynosRect2) */ |
| void getMeteringAreas(ExynosRect2 *rect2s); |
| /* Returns the current minimum and maximum preview fps. */ |
| void getPreviewFpsRange(uint32_t *min, uint32_t *max); |
| /* Gets scene mode */ |
| int getSceneMode(void); |
| /* Gets the current state of video stabilization. */ |
| bool getVideoStabilization(void); |
| /* Gets the current white balance setting. */ |
| int getWhiteBalanceMode(void); |
| /* Sets current zoom value. */ |
| status_t setZoomLevel(int value); |
| /* Gets current zoom value. */ |
| int getZoomLevel(void); |
| /* Returns the recording mode hint. */ |
| bool getRecordingHint(void); |
| /* Gets GPS altitude. */ |
| double getGpsAltitude(void); |
| /* Gets GPS latitude coordinate. */ |
| double getGpsLatitude(void); |
| /* Gets GPS longitude coordinate. */ |
| double getGpsLongitude(void); |
| /* Gets GPS processing method. */ |
| const char * getGpsProcessingMethod(void); |
| /* Gets GPS timestamp. */ |
| long getGpsTimeStamp(void); |
| /* Gets the rotation angle in degrees relative to the orientation of the camera. */ |
| int getRotation(void); |
| |
| /* |
| * Additional API. |
| */ |
| |
| /* Set IonClient */ |
| void setIonClient(int ionClient); |
| int getIonClient(void); |
| |
| /* Gets metering */ |
| int getMeteringMode(void); |
| /* Gets metering List */ |
| int getSupportedMeteringMode(void); |
| /* Gets brightness */ |
| int getBrightness(void); |
| /* Gets ISO */ |
| uint32_t getIso(void); |
| /* Set ExposureTime */ |
| void setExposureTime(void); |
| void setPreviewExposureTime(void); |
| /* Gets ExposureTime for preview */ |
| uint64_t getPreviewExposureTime(void); |
| /* Gets ExposureTime for capture */ |
| uint64_t getCaptureExposureTime(void); |
| /* Gets LongExposureTime for capture */ |
| uint64_t getLongExposureTime(void); |
| /* Gets LongExposureShotCount for capture */ |
| int32_t getLongExposureShotCount(void); |
| /* Gets BatchSize for HFR */ |
| int getBatchSize(enum pipeline pipeId); |
| |
| #ifdef SAMSUNG_TN_FEATURE |
| /* Export iso, exposureTime info to camera parameters */ |
| void setParamExifInfo(camera2_udm *udm); |
| #endif |
| |
| /* Gets Contrast */ |
| uint32_t getContrast(void); |
| /* Gets Saturation */ |
| int getSaturation(void); |
| /* Gets Sharpness */ |
| int getSharpness(void); |
| /* Gets Hue */ |
| int getHue(void); |
| /* Gets WDR */ |
| bool getHdrMode(void); |
| /* Gets WDR */ |
| bool getWdrMode(void); |
| /* Gets anti shake */ |
| bool getAntiShake(void); |
| /* Gets gamma */ |
| bool getGamma(void); |
| /* Gets ODC */ |
| bool getOdcMode(void); |
| /* Gets Slow AE */ |
| bool getSlowAe(void); |
| /* Gets Shot mode */ |
| int getShotMode(void); |
| /* Gets Preview Buffer Count */ |
| int getPreviewBufferCount(void); |
| /* Sets Preview Buffer Count */ |
| void setPreviewBufferCount(int previewBufferCount); |
| |
| /* Gets 3DNR */ |
| bool get3dnrMode(void); |
| /* Gets DRC */ |
| bool getDrcMode(void); |
| /* Gets TPU enable case or not */ |
| bool getTpuEnabledMode(void); |
| void getHwVraInputSize(int *w, int *h); |
| int getHwVraInputFormat(void); |
| |
| #ifdef USE_VRA_GROUP |
| void setDsInputPortId(int dsInputPortId); |
| int getDsInputPortId(void); |
| #endif |
| |
| #ifdef SAMSUNG_COMPANION |
| /* Gets RT DRC */ |
| enum companion_drc_mode getRTDrc(void); |
| /* Gets PAF */ |
| enum companion_paf_mode getPaf(void); |
| /* Gets RT HDR */ |
| enum companion_wdr_mode getRTHdr(void); |
| bool getFlagChangedRtHdr(void); |
| void setFlagChangedRtHdr(bool state); |
| #endif |
| |
| /* |
| * Vendor specific APIs |
| */ |
| |
| /* Gets Intelligent mode */ |
| int getIntelligentMode(void); |
| bool getVisionMode(void); |
| int getVisionModeFps(void); |
| int getVisionModeAeTarget(void); |
| |
| bool isSWVdisMode(void); /* need to change name */ |
| bool isSWVdisModeWithParam(int nPreviewW, int nPreviewH); |
| bool isSWVdisOnPreview(void); |
| bool getSWVdisMode(void); |
| bool getSWVdisUIMode(void); |
| |
| bool getHWVdisMode(void); |
| int getHWVdisFormat(void); |
| |
| /* Gets VT mode */ |
| int getVtMode(void); |
| |
| /* Gets VR mode */ |
| int getVRMode(void); |
| |
| /* Set/Get Dual mode */ |
| void setDualMode(bool toggle); |
| bool getDualMode(void); |
| /* Returns the dual recording mode hint. */ |
| bool getDualRecordingHint(void); |
| /* Returns the effect hint. */ |
| bool getEffectHint(void); |
| /* Returns the effect recording mode hint. */ |
| bool getEffectRecordingHint(void); |
| |
| void setFastFpsMode(int fpsMode); |
| int getFastFpsMode(void); |
| |
| bool getHighResolutionCallbackMode(void); |
| bool getSamsungCamera(void); |
| void setSamsungCamera(bool value); |
| bool getHighSpeedRecording(void); |
| int * getHighSpeedSizeTable(int fpsMode); |
| int * getBinningSizeTable(void); |
| int * getBnsRecordingSizeTable(void); |
| int * getNormalRecordingSizeTable(void); |
| int * getDualModeSizeTable(void); |
| bool getScalableSensorMode(void); |
| void setScalableSensorMode(bool scaleMode); |
| long long int getCityId(void); |
| unsigned char getWeatherId(void); |
| /* Gets ImageUniqueId */ |
| const char *getImageUniqueId(void); |
| #ifdef SAMSUNG_TN_FEATURE |
| void setImageUniqueId(char *uniqueId); |
| #endif |
| /* Gets camera angle */ |
| int getAngle(void); |
| |
| void setFlipHorizontal(int val); |
| int getFlipHorizontal(void); |
| void setFlipVertical(int val); |
| int getFlipVertical(void); |
| |
| /* Gets Burst mode */ |
| int getSeriesShotCount(void); |
| /* Return callback need CSC */ |
| bool getCallbackNeedCSC(void); |
| /* Return callback need copy to rendering */ |
| bool getCallbackNeedCopy2Rendering(void); |
| |
| /* Gets Illumination */ |
| int getIllumination(void); |
| /* Gets Low Light Shot */ |
| int getLLS(struct camera2_shot_ext *shot); |
| /* Gets Low Light A */ |
| bool getLLAMode(void); |
| /* Sets the device orientation angle in degrees to camera FW for FD scanning property. */ |
| bool setDeviceOrientation(int orientation); |
| /* Gets the device orientation angle in degrees . */ |
| int getDeviceOrientation(void); |
| /* Gets the FD orientation angle in degrees . */ |
| int getFdOrientation(void); |
| /* Gets object tracking */ |
| bool getObjectTracking(void); |
| /* Gets status of object tracking operation */ |
| int getObjectTrackingStatus(void); |
| /* Gets smart auto */ |
| bool getSmartAuto(void); |
| /* Gets the status of smart auto operation */ |
| int getSmartAutoStatus(void); |
| /* Gets beauty shot */ |
| bool getBeautyShot(void); |
| |
| /* |
| * Static info |
| */ |
| /* Gets the exposure compensation step. */ |
| float getExposureCompensationStep(void); |
| |
| /* Gets the focal length (in millimeter) of the camera. */ |
| void getFocalLength(int *num, int *den); |
| |
| /* Gets the distances from the camera to where an object appears to be in focus. */ |
| void getFocusDistances(int *num, int *den);; |
| |
| /* Gets the minimum exposure compensation index. */ |
| int getMinExposureCompensation(void); |
| |
| /* Gets the maximum exposure compensation index. */ |
| int getMaxExposureCompensation(void); |
| |
| /* Gets the minimum exposure Time. */ |
| int getMinExposureTime(void); |
| |
| /* Gets the maximum exposure Time. */ |
| int getMaxExposureTime(void); |
| |
| /* Gets the possible minimum exposure Time of the Sensor. */ |
| int64_t getSensorMinExposureTime(void); |
| |
| /* Gets the possible maximum exposure Time of the Sensor. */ |
| int64_t getSensorMaxExposureTime(void); |
| |
| /* Gets the minimum WB Kelvin value. */ |
| int getMinWBK(void); |
| |
| /* Gets the maximum WB Kelvin value. */ |
| int getMaxWBK(void); |
| |
| /* Gets the maximum number of detected faces supported. */ |
| int getMaxNumDetectedFaces(void); |
| |
| /* Gets the maximum number of focus areas supported. */ |
| uint32_t getMaxNumFocusAreas(void); |
| |
| /* Gets the maximum number of metering areas supported. */ |
| uint32_t getMaxNumMeteringAreas(void); |
| |
| /* Gets the maximum zoom value allowed for snapshot. */ |
| int getMaxZoomLevel(void); |
| |
| /* Gets the supported antibanding values. */ |
| int getSupportedAntibanding(void); |
| |
| |
| /* Gets the supported color effects. */ |
| int getSupportedColorEffects(void); |
| /* Gets the supported color effects & hidden color effect. */ |
| bool isSupportedColorEffects(int effectMode); |
| |
| /* Check whether the target support Flash */ |
| int getSupportedFlashModes(void); |
| |
| /* Gets the supported focus modes. */ |
| int getSupportedFocusModes(void); |
| |
| /* Gets the supported preview fps range. */ |
| bool getMaxPreviewFpsRange(int *min, int *max); |
| |
| /* Gets the supported scene modes. */ |
| int getSupportedSceneModes(void); |
| |
| /* Gets the supported white balance. */ |
| int getSupportedWhiteBalance(void); |
| |
| /* Gets the supported Iso values. */ |
| int getSupportedISO(void); |
| |
| /* Gets max zoom ratio */ |
| float getMaxZoomRatio(void); |
| /* Gets zoom ratio */ |
| float getZoomRatio(int zoom); |
| /* Gets current zoom ratio */ |
| float getZoomRatio(void); |
| #ifdef SAMSUNG_DUAL_SOLUTION |
| float getZoomRatio(int cameraId, int zoomLevel); |
| float getZoomOrgRatio(int zoomLevel); |
| void getZoomList(int** list, int *size); |
| void setPreviewNeedMargin(int zoomLevel); |
| int getPreviewNeedMargin(void) { return m_needPreviewMargin; }; |
| status_t adjustDualSolutionSize(int targetWidth, int targetHeight); |
| void getDualSolutionSize(int *dstW, int *dstH, int *wideW, int *wideH, int *teleW, int *teleH); |
| void setForceWide(bool forceWide); |
| bool getForceWide(void); |
| void setForceWideCond(bool flagValidFrame, struct camera2_shot_ext *meta); |
| bool getForceWideCond(void); |
| void setFusionParam(UniPlugin_DCVOZ_CAMERAPARAM_t *cameraParam); |
| int getFusionParamIndex(void); |
| UniPlugin_DCVOZ_CAMERAPARAM_t* getFusionParam(void); |
| int checkDualAfState(int cameraId, int focusState); |
| void checkFusionCaptureMode(int cameraId, |
| struct camera2_shot_ext *wideMeta, struct camera2_shot_ext *teleMeta); |
| bool getFusionCaptureMode(int cameraId, bool isLogPrint); |
| bool isUseNewCropRect(void); |
| void getDualCropRect(ExynosRect *dualRect); |
| int getMasterCam(void); |
| #endif |
| /* Set displayed camera information */ |
| void setMasterCamera(int curDispCamId); |
| /* Returns true if auto-exposure locking is supported. */ |
| bool getAutoExposureLockSupported(void); |
| |
| /* Returns true if auto-white balance locking is supported. */ |
| bool getAutoWhiteBalanceLockSupported(void); |
| |
| /* Returns true if smooth zoom is supported. */ |
| bool getSmoothZoomSupported(void); |
| |
| /* Returns true if video snapshot is supported. */ |
| bool getVideoSnapshotSupported(void); |
| |
| /* Returns true if video stabilization is supported. */ |
| bool getVideoStabilizationSupported(void); |
| |
| /* Returns true if zoom is supported. */ |
| bool getZoomSupported(void); |
| |
| /* Gets the horizontal angle of view in degrees. */ |
| void checkHorizontalViewAngle(void); |
| float getHorizontalViewAngle(void); |
| |
| /* Sets the horizontal angle of view in degrees. */ |
| void setHorizontalViewAngle(int pictureW, int pictureH); |
| |
| /* Gets the vertical angle of view in degrees. */ |
| float getVerticalViewAngle(void); |
| |
| /* Gets Fnumber */ |
| void getFnumber(int *num, int *den); |
| |
| /* Gets Aperture value */ |
| void getApertureValue(int *num, int *den); |
| |
| /* Gets FocalLengthIn35mmFilm */ |
| int getFocalLengthIn35mmFilm(void); |
| |
| bool isScalableSensorSupported(void); |
| |
| status_t getFixedExifInfo(exif_attribute_t *exifInfo); |
| void setExifChangedAttribute(exif_attribute_t *exifInfo, |
| ExynosRect *PictureRect, |
| ExynosRect *thumbnailRect, |
| camera2_shot_t *shot, |
| bool useDebugInfo2 = false |
| #ifdef SAMSUNG_DUAL_CAPTURE_SOLUTION |
| , camera2_shot_t *shot2 = NULL |
| #endif |
| ); |
| |
| debug_attribute_t *getDebugAttribute(void); |
| debug_attribute_t *getDebug2Attribute(void); |
| #ifdef USE_MULTI_FACING_SINGLE_CAMERA |
| int getCameraDirection(void); |
| #endif |
| |
| #ifdef DEBUG_RAWDUMP |
| bool checkBayerDumpEnable(void); |
| #endif/* DEBUG_RAWDUMP */ |
| #ifdef SAMSUNG_LBP |
| int32_t getHoldFrameCount(void); |
| #endif |
| #ifdef USE_BINNING_MODE |
| int getBinningMode(void); |
| #endif /* USE_BINNING_MODE */ |
| |
| bool getSwitchSensor(void); |
| |
| int getShutterSpeed(void); |
| int getGain(void); |
| int getIrLedWidth(void); |
| int getIrLedDelay(void); |
| int getIrLedCurrent(void); |
| int getIrLedOnTime(void); |
| #ifdef USE_REMOSAIC_CAPTURE |
| enum remosaic_capture_mode { |
| REMOSAIC_CAPTURE_MODE_NOT_SUPPORTED, |
| REMOSAIC_CAPTURE_MODE_NONE, |
| REMOSAIC_CAPTURE_MODE_PURE_BAYER, |
| REMOSAIC_CAPTURE_MODE_PROCESSED_BAYER, |
| }; |
| int getAvailableRemosaicCapture(void); |
| void setRemosaicCaptureMode(enum remosaic_capture_mode remosaic_mode); |
| int getRemosaicCaptureMode(); |
| bool isUseRemosaicCapture(); |
| enum remosaic_capture_mode m_flagRemosaicCaptureMode; |
| #endif |
| |
| public: |
| bool DvfsLock(); |
| bool DvfsUnLock(); |
| |
| void updatePreviewFpsRange(void); |
| void updateHwSensorSize(void); |
| void updateBinningScaleRatio(void); |
| void updateBnsScaleRatio(void); |
| |
| void setHwPreviewStride(int stride); |
| int getHwPreviewStride(void); |
| |
| status_t duplicateCtrlMetadata(void *buf); |
| |
| status_t setRequestDis(int value); |
| |
| status_t setDisEnable(bool enable); |
| status_t setDrcEnable(bool enable); |
| status_t setDnrEnable(bool enable); |
| status_t setFdEnable(bool enable); |
| |
| bool getDisEnable(void); |
| bool getDrcEnable(void); |
| bool getDnrEnable(void); |
| bool getFdEnable(void); |
| |
| status_t check3dnrBypass(bool is3dnrMode, bool *flagBypass); |
| |
| status_t setFdMode(enum facedetect_mode mode); |
| status_t getFdMeta(bool reprocessing, void *buf); |
| bool getUHDRecordingMode(void); |
| bool getFaceDetectionMode(bool flagCheckingRecording = true); |
| |
| void vendorSpecificConstructor(int cameraId, bool flagCompanion = false); |
| |
| private: |
| bool m_isSupportedPreviewSize(const int width, const int height); |
| bool m_isSupportedPictureSize(const int width, const int height); |
| bool m_isSupportedVideoSize(const int width, const int height); |
| bool m_isHighResolutionCallbackSize(const int width, const int height); |
| void m_isHighResolutionMode(const CameraParameters& params); |
| #ifdef SAMSUNG_HYPER_MOTION |
| void m_isHyperMotionMode(const CameraParameters& params); |
| void m_setHyperMotionMode(bool enable); |
| void m_setHyperMotionSpeed(int motionSpeed); |
| void m_getHyperMotionPreviewSize(int w, int h, int *newW, int *newH); |
| #endif |
| |
| bool m_getSupportedVariableFpsList(int min, int max, |
| int *newMin, int *newMax); |
| |
| status_t m_getPreviewSizeList(int *sizeList); |
| |
| void m_getSWVdisPreviewSize(int w, int h, int *newW, int *newH); |
| void m_getSWVdisVideoSize(int w, int h, int *newW, int *newH); |
| void m_getScalableSensorSize(int *newSensorW, int *newSensorH); |
| |
| void m_initMetadata(void); |
| |
| bool m_isUHDRecordingMode(void); |
| |
| /* |
| * Vendor specific adjust function |
| */ |
| private: |
| status_t m_adjustPreviewFpsRange(int &newMinFps, int &newMaxFps); |
| status_t m_getPreviewBdsSize(ExynosRect *dstRect); |
| status_t m_adjustPreviewSize(const CameraParameters ¶ms, |
| int previewW, int previewH, |
| int *newPreviewW, int *newPreviewH, |
| int *newCalPreviewW, int *newCalPreviewH); |
| status_t m_adjustPreviewFormat(int &previewFormat, int &hwPreviewFormatH); |
| status_t m_adjustPictureSize(int *newPictureW, int *newPictureH, |
| int *newHwPictureW, int *newHwPictureH); |
| bool m_adjustHighSpeedRecording(int curMinFps, int curMaxFps, int newMinFps, int newMaxFps); |
| const char * m_adjustAntibanding(const char *strAntibanding); |
| const char * m_adjustFocusMode(const char *focusMode); |
| const char * m_adjustFlashMode(const char *flashMode); |
| const char * m_adjustWhiteBalanceMode(const char *whiteBalance); |
| bool m_adjustScalableSensorMode(const int scaleMode); |
| void m_adjustAeMode(enum aa_aemode curAeMode, enum aa_aemode *newAeMode); |
| void m_adjustSensorMargin(int *sensorMarginW, int *sensorMarginH); |
| void m_getSetfileYuvRange(bool flagReprocessing, int *setfile, int *yuvRange); |
| |
| #ifdef USE_CSC_FEATURE |
| void m_getAntiBandingFromLatinMCC(char *temp_str); |
| int m_IsLatinOpenCSC(); |
| void m_chooseAntiBandingFrequency(); |
| #endif |
| /* for initial 120fps start due to quick launch */ |
| /* |
| void set120FpsState(enum INIT_120FPS_STATE state); |
| void clear120FpsState(enum INIT_120FPS_STATE state); |
| bool flag120FpsStart(void); |
| bool setSensorFpsAfter120fps(void); |
| void setInitValueAfter120fps(bool isAfter); |
| */ |
| |
| status_t m_setBinningScaleRatio(int ratio); |
| status_t m_setBnsScaleRatio(uint32_t ratio); |
| status_t m_addHiddenResolutionList(String8 &string8Buf, struct ExynosSensorInfoBase *sensorInfo, |
| int w, int h, enum MODE mode, int cameraId); |
| /* 1.0 Function */ |
| void m_setExifChangedAttribute(exif_attribute_t *exifInfo, |
| ExynosRect *PictureRect, |
| ExynosRect *thumbnailRect, |
| camera2_dm *dm, |
| camera2_udm *udm, |
| #ifdef SAMSUNG_DUAL_CAPTURE_SOLUTION |
| camera2_dm *dm2 = NULL, |
| camera2_udm *udm2 = NULL, |
| #endif |
| bool useDebugInfo2 = false); |
| |
| #ifdef USE_DUAL_CAMERA |
| status_t m_getFusionSize(int w, int h, ExynosRect *rect, bool flagSrc); |
| |
| bool m_updateTpuParameters(void); |
| #endif |
| |
| #ifdef USE_MCSC_FOR_FD |
| bool m_setFDConfig(CONFIG_FD::TAG tag, ExynosFDConfig_t *config); |
| ExynosFDConfig_t *m_getFDConfig(); |
| bool m_updateVRAParameters(void); |
| #endif |
| |
| public: |
| status_t setParameters(const CameraParameters& params); |
| CameraParameters getParameters() const; |
| int getCameraId(void); |
| /* Gets the detected faces areas. */ |
| int getDetectedFacesAreas(int num, int *id, |
| int *score, ExynosRect *face, |
| ExynosRect *leftEye, ExynosRect *rightEye, |
| ExynosRect *mouth); |
| /* Gets the detected faces areas. (Using ExynosRect2) */ |
| int getDetectedFacesAreas(int num, int *id, |
| int *score, ExynosRect2 *face, |
| ExynosRect2 *leftEye, ExynosRect2 *rightEye, |
| ExynosRect2 *mouth); |
| |
| void enableMsgType(int32_t msgType); |
| void disableMsgType(int32_t msgType); |
| bool msgTypeEnabled(int32_t msgType); |
| |
| status_t setFrameSkipCount(int count); |
| status_t getFrameSkipCount(int *count); |
| int getFrameSkipCount(void); |
| |
| void setIsFirstStartFlag(bool flag); |
| int getIsFirstStartFlag(void); |
| |
| void setPreviewRunning(bool enable); |
| void setPictureRunning(bool enable); |
| void setRecordingRunning(bool enable); |
| #if defined(SAMSUNG_COMPANION) || defined(SAMSUNG_EEPROM) |
| void setRomReadThreadDone(bool enable); |
| #endif |
| bool getPreviewRunning(void); |
| bool getPictureRunning(void); |
| bool getRecordingRunning(void); |
| bool getRestartPreview(void); |
| |
| ExynosCameraActivityControl *getActivityControl(void); |
| status_t setAutoFocusMacroPosition(int autoFocusMacroPosition); |
| |
| void getSetfileYuvRange(bool flagReprocessing, int *setfile, int *yuvRange); |
| void setSetfileYuvRange(void); |
| status_t checkSetfileYuvRange(void); |
| |
| void setUseDynamicBayer(bool enable); |
| bool getUseDynamicBayer(void); |
| void setUseDynamicBayerVideoSnapShot(bool enable); |
| bool getUseDynamicBayerVideoSnapShot(void); |
| void setUseDynamicScc(bool enable); |
| bool getUseDynamicScc(void); |
| |
| void setUseFastenAeStable(bool enable); |
| bool getUseFastenAeStable(void); |
| |
| void setFastenAeStableOn(bool enable); |
| bool getFastenAeStableOn(void); |
| bool isFastenAeStableEnable(void); |
| |
| void setUsePureBayerReprocessing(bool enable); |
| bool getUsePureBayerReprocessing(void); |
| #ifdef SAMSUNG_LBP |
| bool getUseBestPic(void); |
| #endif |
| |
| int32_t updateReprocessingBayerMode(void); |
| int32_t getReprocessingBayerMode(void); |
| |
| void setAdaptiveCSCRecording(bool enable); |
| bool getAdaptiveCSCRecording(void); |
| bool doCscRecording(void); |
| |
| uint32_t getBinningScaleRatio(void); |
| uint32_t getBnsScaleRatio(void); |
| /* Sets the dimensions for Sesnor-related BNS. */ |
| void setBnsSize(int w, int h); |
| /* Gets the dimensions for Sesnor-related BNS. */ |
| void getBnsSize(int *w, int *h); |
| |
| /* |
| * This must call before startPreview(), |
| * this update h/w setting at once. |
| */ |
| bool updateParameters(void); |
| int getHalVersion(void); |
| void setHalVersion(int halVersion); |
| struct ExynosSensorInfoBase *getSensorStaticInfo(); |
| |
| #ifdef SAMSUNG_DOF |
| int getMoveLensTotal(void); |
| void setMoveLensCount(int count); |
| void setMoveLensTotal(int count); |
| #endif |
| #ifdef SUPPORT_MULTI_AF |
| status_t checkMultiAf(const CameraParameters& params); |
| #endif |
| bool checkEnablePicture(void); |
| #ifdef SAMSUNG_OIS_VDIS |
| void setOISCoef(uint32_t coef); |
| void setSWVdisOISInit(); |
| uint32_t getOISGain(); |
| void setOISFadeVal(int oisFadeVal); |
| void setSWVdisPreviewFrameExposureTime(int exposureTime); |
| #endif |
| |
| #ifdef BURST_CAPTURE |
| int getSeriesShotSaveLocation(void); |
| void setSeriesShotSaveLocation(int ssaveLocation); |
| char *getSeriesShotFilePath(void); |
| #ifdef VARIABLE_BURST_FPS |
| void setBurstShotDuration(int fps); |
| int getBurstShotDuration(void); |
| int m_burstShotDuration; |
| #endif |
| int m_seriesShotSaveLocation; |
| char m_seriesShotFilePath[CAMERA_FILE_PATH_SIZE]; |
| #endif |
| int getSeriesShotDuration(void); |
| int getSeriesShotMode(void); |
| void setSeriesShotMode(int sshotMode, int count = 0); |
| |
| int getHalPixelFormat(void); |
| int convertingHalPreviewFormat(int previewFormat, int yuvRange); |
| |
| void setDvfsLock(bool lock); |
| bool getDvfsLock(void); |
| |
| #ifdef SAMSUNG_LLV |
| void setLLV(bool enable); |
| bool getLLV(void); |
| #endif |
| void setFocusModeSetting(bool enable); |
| int getFocusModeSetting(void); |
| bool getSensorOTFSupported(void); |
| bool isReprocessing(void); |
| bool isSccCapture(void); |
| |
| /* H/W Chain Scenario Infos */ |
| bool isFlite3aaOtf(void); |
| bool is3aaIspOtf(void); |
| bool isIspTpuOtf(void); |
| bool isIspMcscOtf(void); |
| bool isTpuMcscOtf(void); |
| bool isMcscVraOtf(void); |
| |
| bool isReprocessing3aaIspOTF(void); |
| bool isReprocessingIspTpuOtf(void); |
| bool isReprocessingIspMcscOtf(void); |
| bool isReprocessingTpuMcscOtf(void); |
| |
| bool isSingleChain(void); |
| |
| bool isUse3aaInputCrop(void); |
| bool isUseIspInputCrop(void); |
| bool isUseMcscInputCrop(void); |
| bool isUseReprocessing3aaInputCrop(void); |
| bool isUseReprocessingIspInputCrop(void); |
| bool isUseReprocessingMcscInputCrop(void); |
| bool isUseEarlyFrameReturn(void); |
| bool isUseHWFC(void); |
| bool isHWFCOnDemand(void); |
| void setHWFCEnable(bool enable); |
| bool getHWFCEnable(void); |
| bool getSupportedZoomPreviewWIthScaler(void); |
| void setZoomPreviewWIthScaler(bool enable); |
| bool getZoomPreviewWIthScaler(void); |
| |
| bool getReallocBuffer(); |
| bool setReallocBuffer(bool enable); |
| |
| bool setConfig(struct ExynosConfigInfo* config); |
| struct ExynosConfigInfo* getConfig(); |
| |
| bool setConfigMode(uint32_t mode); |
| int getConfigMode(); |
| /* Sets Shot mode */ |
| void m_setShotMode(int shotMode); |
| void m_setDualShotMode(const CameraParameters& params); |
| #ifdef LLS_CAPTURE |
| void setLLSOn(uint32_t enable); |
| bool getLLSOn(void); |
| void setLLSValue(int value); |
| int getLLSValue(void); |
| void m_setLLSShotMode(void); |
| void m_setLLSShotMode(const CameraParameters& params); |
| #ifdef SET_LLS_CAPTURE_SETFILE |
| void setLLSCaptureOn(bool enable); |
| int getLLSCaptureOn(); |
| #endif |
| #endif |
| #ifdef LLS_REPROCESSING |
| void setLLSCaptureCount(int count); |
| int getLLSCaptureCount(); |
| #endif |
| #ifdef SR_CAPTURE |
| void setSROn(uint32_t enable); |
| bool getSROn(void); |
| #endif |
| #if defined(SR_CAPTURE) || defined(SAMSUNG_HIFI_LLS) |
| void setNoBayerCrop(bool enable); |
| bool getNoBayerCrop(void); |
| #endif |
| #ifdef SAMSUNG_HIFI_LLS |
| bool checkHiFiLLSEnable(void); |
| #endif |
| #ifdef OIS_CAPTURE |
| void setOISCaptureModeOn(bool enable); |
| void checkOISCaptureMode(void); |
| bool getOISCaptureModeOn(void); |
| #endif |
| #ifdef SAMSUNG_DNG |
| void setDNGCaptureModeOn(bool enable); |
| bool getDNGCaptureModeOn(void); |
| void setUseDNGCapture(bool enable); |
| bool getUseDNGCapture(void); |
| void setCheckMultiFrame(bool enable); |
| bool getCheckMultiFrame(void); |
| void m_setDngFixedAttribute(void); |
| dng_attribute_t *getDngInfo(); |
| void setDngChangedAttribute(struct camera2_dm *dm, struct camera2_udm *udm); |
| void setIsUsefulDngInfo(bool enable); |
| bool getIsUsefulDngInfo(); |
| status_t checkDngFilePath(const CameraParameters& params); |
| char *getDngFilePath(void); |
| int getDngSaveLocation(void); |
| void setDngSaveLocation(int saveLocation); |
| dng_thumbnail_t *createDngThumbnailBuffer(int size); |
| dng_thumbnail_t *putDngThumbnailBuffer(dng_thumbnail_t *buf); |
| dng_thumbnail_t *getDngThumbnailBuffer(unsigned int frameCount); |
| void deleteDngThumbnailBuffer(dng_thumbnail_t *curNode); |
| void cleanDngThumbnailBuffer(); |
| #endif |
| #ifdef SAMSUNG_QUICKSHOT |
| status_t checkQuickShot(const CameraParameters& params); |
| int getQuickShot(void); |
| #endif |
| #ifdef SAMSUNG_OIS |
| status_t checkOIS(const CameraParameters& params); |
| void m_setOIS(enum optical_stabilization_mode ois); |
| enum optical_stabilization_mode getOIS(void); |
| void setOISNode(ExynosCameraNode *node); |
| void setOISMode(void); |
| void setOISModeSetting(bool enable); |
| int getOISModeSetting(void); |
| #endif |
| #ifdef RAWDUMP_CAPTURE |
| void setRawCaptureModeOn(bool enable); |
| bool getRawCaptureModeOn(void); |
| #endif |
| void setMotionPhotoOn(bool enable); |
| bool getMotionPhotoOn(void); |
| #ifdef SAMSUNG_LLS_DEBLUR |
| void checkLDCaptureMode(void); |
| void setLDCaptureMode(int LDMode); |
| int getLDCaptureMode(void); |
| void setLDCaptureLLSValue(uint32_t lls); |
| int getLDCaptureLLSValue(void); |
| void setLDCaptureCount(int count); |
| int getLDCaptureCount(void); |
| #ifdef SUPPORT_ZSL_MULTIFRAME |
| void checkZslMultiframeMode(void); |
| void setZslMultiframeModeOn(bool enable); |
| bool getZslMultiframeModeOn(void); |
| #endif |
| #endif |
| #ifdef LLS_STUNR |
| void checkLLSStunrMode(void); |
| void setLLSStunrMode(bool enable); |
| bool getLLSStunrMode(void); |
| int getLLSStunrCount(void); |
| #endif |
| #ifdef USE_ODC_CAPTURE |
| status_t checkODCCaptureMode(); |
| void setODCCaptureMode(bool enable); |
| bool getODCCaptureMode(void); |
| void setODCCaptureEnable(bool enable); |
| bool getODCCaptureEnable(void); |
| #endif |
| void setOutPutFormatNV21Enable(bool enable); |
| bool getOutPutFormatNV21Enable(void); |
| #ifdef SAMSUNG_LENS_DC |
| void setLensDCMode(bool enable); |
| bool getLensDCMode(void); |
| void setLensDCEnable(bool enable); |
| bool getLensDCEnable(void); |
| #endif |
| #ifdef SAMSUNG_STR_CAPTURE |
| bool checkSTRCaptureMode(void); |
| void setSTRCaptureEnable(bool enable); |
| bool getSTRCaptureEnable(void); |
| #endif |
| #ifdef SAMSUNG_STR_PREVIEW |
| bool checkSTRPreviewMode(void); |
| #endif |
| #ifdef SAMSUNG_FOCUS_PEAKING |
| void m_setFocusPeakingMode(bool enable); |
| bool m_getFocusPeakingMode(void); |
| #endif |
| #ifdef SAMSUNG_IDDQD |
| bool checkIDDQDMode(void); |
| #endif |
| void setZoomActiveOn(bool enable); |
| bool getZoomActiveOn(void); |
| void setFocusModeLock(bool enable); |
| status_t setMarkingOfExifFlash(int flag); |
| int getMarkingOfExifFlash(void); |
| bool increaseMaxBufferOfPreview(void); |
| |
| |
| |
| |
| |
| |
| //Added |
| int getHDRDelay(void) { return HDR_DELAY; } |
| int getReprocessingBayerHoldCount(void) { return REPROCESSING_BAYER_HOLD_COUNT; } |
| int getFastenAeFps(void) { return FASTEN_AE_FPS; } |
| int getPerFrameControlPipe(void) {return PERFRAME_CONTROL_PIPE; } |
| int getPerFrameControlReprocessingPipe(void) {return PERFRAME_CONTROL_REPROCESSING_PIPE; } |
| int getPerFrameInfo3AA(void) { return PERFRAME_INFO_3AA; }; |
| int getPerFrameInfoIsp(void) { return PERFRAME_INFO_ISP; }; |
| int getPerFrameInfoDis(void) { return PERFRAME_INFO_DIS; }; |
| int getPerFrameInfoReprocessingPure3AA(void) { return PERFRAME_INFO_PURE_REPROCESSING_3AA; } |
| int getPerFrameInfoReprocessingPureIsp(void) { return PERFRAME_INFO_PURE_REPROCESSING_ISP; } |
| int getScalerNodeNumPicture(void) { return PICTURE_GSC_NODE_NUM;} |
| int getScalerNodeNumPreview(void) { return PREVIEW_GSC_NODE_NUM;} |
| int getScalerNodeNumVideo(void) { return VIDEO_GSC_NODE_NUM;} |
| bool isOwnScc(int cameraId); |
| bool needGSCForCapture(int camId) { return (camId == CAMERA_ID_BACK) ? USE_GSC_FOR_CAPTURE_BACK : USE_GSC_FOR_CAPTURE_FRONT; } |
| bool getSetFileCtlMode(void); |
| bool getSetFileCtl3AA_ISP(void); |
| bool getSetFileCtl3AA(void); |
| bool getSetFileCtlISP(void); |
| bool getSetFileCtlSCP(void); |
| |
| #ifdef SAMSUNG_OT |
| bool getObjectTrackingEnable(void); |
| void setObjectTrackingChanged(bool newValue); |
| bool getObjectTrackingChanged(void); |
| int getObjectTrackingAreas(int* validFocusArea, ExynosRect2* areas, int* weights); |
| void setObjectTrackingGet(bool newValue); |
| bool getObjectTrackingGet(void); |
| #endif |
| #ifdef SAMSUNG_LBP |
| void setNormalBestFrameCount(uint32_t count); |
| uint32_t getNormalBestFrameCount(void); |
| void resetNormalBestFrameCount(void); |
| void setSCPFrameCount(uint32_t count); |
| uint32_t getSCPFrameCount(void); |
| void resetSCPFrameCount(void); |
| void setBayerFrameCount(uint32_t count); |
| uint32_t getBayerFrameCount(void); |
| void resetBayerFrameCount(void); |
| #endif |
| #ifdef SAMSUNG_JQ |
| void setJpegQtableStatus(int state); |
| int getJpegQtableStatus(void); |
| void setJpegQtableOn(bool isOn); |
| bool getJpegQtableOn(void); |
| void setJpegQtable(unsigned char* qtable); |
| void getJpegQtable(unsigned char* qtable); |
| #endif |
| #ifdef SAMSUNG_BD |
| void setBlurInfo(unsigned char *data, unsigned int size); |
| #endif |
| #ifdef SAMSUNG_UTC_TS |
| void setUTCInfo(); |
| #endif |
| #ifdef SAMSUNG_LLS_DEBLUR |
| void setLLSdebugInfo(unsigned char *data, unsigned int size); |
| #endif |
| #ifdef SAMSUNG_LENS_DC |
| void setLensDCdebugInfo(unsigned char *data, unsigned int size); |
| #endif |
| #ifdef SAMSUNG_STR_CAPTURE |
| void setSTRdebugInfo(unsigned char *data, unsigned int size); |
| #endif |
| #ifdef SENSOR_FW_GET_FROM_FILE |
| bool m_checkCalibrationDataValid(char *sensor_fw); |
| #endif |
| void setUseCompanion(bool use); |
| bool getUseCompanion(); |
| void setIsThumbnailCallbackOn(bool enable); |
| bool getIsThumbnailCallbackOn(); |
| bool getDualCameraMode(void); |
| #ifdef USE_DUAL_CAMERA |
| /* Set/Get Dual camera mode */ |
| void setDualCameraMode(bool toggle); |
| bool isFusionEnabled(void); |
| void updateDualCameraFusionMode(); |
| bool getDualCameraPreviewFusionMode(void); |
| bool getDualCameraCaptureFusionMode(void); |
| status_t getFusionSize(int w, int h, ExynosRect *srcRect, ExynosRect *dstRect); |
| status_t setFusionInfo(camera2_shot_ext *shot_ext); |
| DOF *getDOF(void); |
| dual_standby_mode_t getDualStandbyMode(void); |
| void setDualStandbyMode(dual_standby_mode_t dualStandbyMode); |
| /* type equals to sync_type_t in ExynosCameraFrame */ |
| void updateDualCameraSyncType(int zoom, sync_type_t *syncType, sync_type_t *reprocessingSyncType); |
| sync_type_t getDualCameraSyncType(void); |
| sync_type_t getDualCameraReprocessingSyncType(void); |
| void lockDualCameraSyncType(bool lockFlag); |
| /* for transition/smoothTransition */ |
| int setDualTransitionCount(int count); |
| int getDualTransitionCount(void); |
| int decreaseDualTransitionCount(void); |
| int setDualSmoothTransitionCount(int count); |
| int getDualSmoothTransitionCount(void); |
| int decreaseDualSmoothTransitionCount(void); |
| int setDualWakeupFinishCount(int count); |
| int getDualWakeupFinishCount(void); |
| int decreaseDualWakeupFinishCount(void); |
| void clearDualCameraInformation(void); |
| void getDualBackupPostStandbyFps(uint32_t *min, uint32_t *max); |
| #ifdef DUAL_SMOOTH_TRANSITION_LAUNCH |
| void finishStartPreview(int32_t targetCameraId); |
| bool getFlagFinishStartPreview(int32_t targetCameraId); |
| #endif |
| void setForceSwitchingOnly(bool forceSwitchingOnly); |
| bool getFlagForceSwitchingOnly(void); |
| void setDualStableFromStandby(bool stable); |
| bool getDualStableFromStandby(void); |
| |
| /* to notify */ |
| void registerDualNotifyCallback(ExynosCamera *camera, dual_notify_func_t notifyFunc); |
| void unregisterDualNotifyCallback(void); |
| status_t dualNotify(enum dual_camera_notify_type notifyType, |
| bool useThread, |
| int32_t arg1, |
| int32_t arg2, |
| void* arg3); |
| #ifdef USE_CP_FUSION_LIB |
| char *readFusionCalData(int *readSize); |
| void setFusionCalData(char *addr, int size); |
| char *getFusionCalData(int *size); |
| #endif // USE_CP_FUSION_LIB |
| #endif // USE_DUAL_CAMERA |
| |
| #ifdef USE_MCSC_FOR_FD |
| ExynosFDConfig_t *getFDConfig(); |
| #endif // USE_MCSC_FOR_FD |
| |
| #ifdef USE_FADE_IN_ENTRANCE |
| status_t checkFirstEntrance(const CameraParameters& params); |
| void setFirstEntrance(bool value); |
| bool getFirstEntrance(void); |
| #endif |
| #ifdef USE_LIVE_BROADCAST /* PLB mode */ |
| void setPLBMode(bool plbMode); |
| bool getPLBMode(void); |
| #endif |
| #ifdef FLASHED_LLS_CAPTURE |
| void setFlashedLLSCapture(bool isLLSCapture); |
| bool getFlashedLLSCapture(); |
| #endif |
| void getYuvSize(__unused int *width, __unused int *height, __unused const int index) {}; |
| #ifdef SAMSUNG_QUICK_SWITCH |
| void checkQuickSwitchProp(); |
| void setQuickSwitchFlag(bool isQuickSwitch); |
| bool getQuickSwitchFlag(); |
| |
| void setQuickSwitchCmd(int cmd); |
| int getQuickSwitchCmd(); |
| #endif |
| void switchSensorMode(); |
| |
| private: |
| int m_cameraId; |
| int m_scenario; |
| char m_name[EXYNOS_CAMERA_NAME_STR_SIZE]; |
| |
| CameraParameters m_params; |
| struct camera2_shot_ext m_metadata; |
| |
| struct exynos_camera_info m_cameraInfo; |
| struct ExynosSensorInfoBase *m_staticInfo; |
| |
| int m_ionClient; |
| exif_attribute_t m_exifInfo; |
| debug_attribute_t mDebugInfo; |
| debug_attribute_t mDebugInfo2; |
| |
| int32_t m_enabledMsgType; |
| mutable Mutex m_msgLock; |
| float m_calculatedHorizontalViewAngle; |
| /* frame skips */ |
| ExynosCameraCounter m_frameSkipCounter; |
| |
| mutable Mutex m_parameterLock; |
| mutable Mutex m_staticInfoExifLock; |
| mutable Mutex m_faceDetectMetaLock; |
| |
| ExynosCameraActivityControl *m_activityControl; |
| |
| /* Flags for camera status */ |
| bool m_previewRunning; |
| bool m_previewSizeChanged; |
| bool m_pictureRunning; |
| bool m_recordingRunning; |
| bool m_flagCheckDualMode; |
| #ifdef USE_DUAL_CAMERA |
| bool m_flagCheckDualCameraMode; |
| bool m_flagDualCameraPreviewFusionMode; |
| bool m_flagDualCameraCaptureFusionMode; |
| uint32_t m_backupDualPostStandbyMinFps; |
| uint32_t m_backupDualPostStandbyMaxFps; |
| mutable Mutex m_transitionLock; |
| int m_transitionCount; |
| int m_smoothTransitionCount; |
| /* count to indicate whether this camera finishs wakeup from standby or not */ |
| int m_wakeupFinishCount; |
| ExynosCameraParameters::dual_standby_mode_t m_dualStandbyMode; |
| ExynosCamera1DualParameters *m_dualParameters; |
| bool m_dualStableFromStandby; |
| #endif |
| bool m_romReadThreadDone; |
| bool m_use_companion; |
| bool m_IsThumbnailCallbackOn; |
| bool m_flagRestartPreviewChecked; |
| bool m_flagRestartPreview; |
| int m_fastFpsMode; |
| bool m_flagFirstStart; |
| bool m_flagMeteringRegionChanged; |
| bool m_flagHWVDisMode; |
| |
| bool m_flagVideoStabilization; |
| bool m_flag3dnrMode; |
| |
| int32_t m_reprocessingBayerMode; |
| |
| #ifdef USE_MCSC_FOR_FD |
| struct ExynosFDConfig m_fdConfig; |
| mutable Mutex m_fdConfigLock; |
| #endif |
| |
| #ifdef SAMSUNG_DUAL_SOLUTION |
| int m_orgZoomLevel; |
| ExynosCameraFusionWrapper *m_fusionPreviewWrapper; |
| ExynosCameraFusionWrapper *m_fusionCaptureWrapper; |
| int m_dualDstWidth; |
| int m_dualDstHeight; |
| int m_dualSrcWideWidth; |
| int m_dualSrcWideHeight; |
| int m_dualSrcTeleWidth; |
| int m_dualSrcTeleHeight; |
| int m_needPreviewMargin; |
| UniPlugin_DCVOZ_CAMERAPARAM_t* m_fusionParam; |
| #endif |
| |
| #ifdef LLS_CAPTURE |
| bool m_flagLLSOn; |
| int m_LLSValue; |
| int m_LLSCaptureOn; |
| #endif |
| #ifdef LLS_REPROCESSING |
| int m_LLSCaptureCount; |
| #endif |
| |
| #ifdef SR_CAPTURE |
| bool m_flagSRSOn; |
| #endif |
| #if defined(SR_CAPTURE) || defined(SAMSUNG_HIFI_LLS) |
| bool m_flagNoBayerCrop; |
| #endif |
| #ifdef OIS_CAPTURE |
| bool m_flagOISCaptureOn; |
| int m_llsValue; |
| #endif |
| #ifdef SAMSUNG_DNG |
| bool m_flagDNGCaptureOn; |
| bool m_use_DNGCapture; |
| bool m_flagMultiFrame; |
| bool m_isUsefulDngInfo; |
| dng_attribute_t m_dngInfo; |
| int m_dngSaveLocation; |
| char m_dngFilePath[CAMERA_FILE_PATH_SIZE]; |
| SecCameraDngThumbnail m_dngThumbnail; |
| #endif |
| #ifdef RAWDUMP_CAPTURE |
| bool m_flagRawCaptureOn; |
| #endif |
| bool m_flagMotionPhotoOn; |
| #ifdef SAMSUNG_LLS_DEBLUR |
| int m_flagLDCaptureMode; |
| uint32_t m_flagLDCaptureLLSValue; |
| int m_LDCaptureCount; |
| #ifdef SUPPORT_ZSL_MULTIFRAME |
| bool m_flagZslMultiframeOn; |
| #endif |
| #endif |
| bool m_flagOutPutFormatNV21Enable; |
| bool m_flagCheckRecordingHint; |
| #ifdef SAMSUNG_LENS_DC |
| bool m_flagLensDCEnable; |
| bool m_flagLensDCMode; |
| #endif |
| #ifdef SAMSUNG_STR_CAPTURE |
| bool m_flagSTRCaptureEnable; |
| #endif |
| #ifdef SAMSUNG_STR_PREVIEW |
| bool m_flagSTRPreviewMode; |
| #endif |
| |
| #ifdef SAMSUNG_HRM |
| bool m_flagSensorHRM_Hint; |
| #endif |
| #ifdef SAMSUNG_LIGHT_IR |
| bool m_flagSensorLight_IR_Hint; |
| #endif |
| #ifdef SAMSUNG_GYRO |
| bool m_flagSensorGyroHint; |
| #endif |
| #ifdef SAMSUNG_ACCELEROMETER |
| bool m_flagSensorAccelerationHint; |
| #endif |
| #ifdef SAMSUNG_FOCUS_PEAKING |
| bool m_flagFocusPeakingMode; |
| #endif |
| int m_setfile; |
| int m_yuvRange; |
| int m_setfileReprocessing; |
| int m_yuvRangeReprocessing; |
| #ifdef USE_BINNING_MODE |
| int m_binningProperty; |
| #endif |
| #ifdef USE_LIMITATION_FOR_THIRD_PARTY |
| int m_fpsProperty; |
| #endif |
| bool m_useSizeTable; |
| bool m_useDynamicBayer; |
| bool m_useDynamicBayerVideoSnapShot; |
| bool m_useDynamicScc; |
| bool m_useFastenAeStable; |
| bool m_fastenAeStableOn; |
| bool m_usePureBayerReprocessing; |
| #ifdef SAMSUNG_LBP |
| bool m_useBestPic; |
| #endif |
| bool m_useAdaptiveCSCRecording; |
| bool m_dvfsLock; |
| int m_previewBufferCount; |
| |
| bool m_reallocBuffer; |
| mutable Mutex m_reallocLock; |
| #ifdef USE_FADE_IN_ENTRANCE |
| bool m_flagFirstEntrance; |
| #endif |
| struct ExynosConfigInfo *m_exynosconfig; |
| |
| #ifdef SAMSUNG_LLV |
| bool m_isLLVOn; |
| #endif |
| |
| #ifdef SAMSUNG_DOF |
| int m_curLensStep; |
| int m_curLensCount; |
| #endif |
| bool m_setFocusmodeSetting; |
| #ifdef USE_CSC_FEATURE |
| char m_antiBanding[10]; |
| #endif |
| #ifdef SAMSUNG_OIS |
| ExynosCameraNode *m_oisNode; |
| bool m_setOISmodeSetting; |
| #endif |
| #ifdef SAMSUNG_OIS_VDIS |
| int m_oisFadeVal; |
| int m_SWVdisOisGainFrameCount[2]; |
| int m_SWVdisPreviewFrameExposureTime; |
| #endif |
| bool m_zoom_activated; |
| int m_firing_flash_marking; |
| |
| #ifdef SAMSUNG_OT |
| bool m_startObjectTracking; |
| bool m_objectTrackingAreaChanged; |
| bool m_objectTrackingGet; |
| ExynosRect2 *m_objectTrackingArea; |
| int *m_objectTrackingWeight; |
| #endif |
| #ifdef SAMSUNG_LBP |
| uint32_t m_normal_best_frame_count; |
| uint32_t m_scp_frame_count; |
| uint32_t m_bayer_frame_count; |
| #endif |
| #ifdef SAMSUNG_JQ |
| unsigned char m_jpegQtable[128]; |
| int m_jpegQtableStatus; |
| bool m_isJpegQtableOn; |
| mutable Mutex m_JpegQtableLock; |
| #endif |
| #ifdef FORCE_CAL_RELOAD |
| bool m_calValid; |
| #endif |
| |
| #ifdef USE_CP_FUSION_LIB |
| char *m_fusionCalData; |
| int m_fusionCalDataSize; |
| #endif |
| |
| uint64_t m_exposureTimeCapture; |
| |
| bool m_zoomWithScaler; |
| float m_currentZoomRatio; |
| |
| int m_halVersion; |
| ExynosCamera1Parameters *m_dummyParameters; |
| bool m_flagDummy; |
| #ifdef SUPPORT_DEPTH_MAP |
| bool m_flaguseDepthMap; |
| bool m_flagDepthCallbackOnPreview; |
| bool m_flagDepthCallbackOnCapture; |
| #endif |
| bool m_flagHWFCEnable; |
| #ifdef FLASHED_LLS_CAPTURE |
| bool m_isFlashedLLSCapture; |
| #endif |
| #ifdef USE_MULTI_FACING_SINGLE_CAMERA |
| int m_cameraDirection; |
| #endif |
| #ifdef SAMSUNG_QUICK_SWITCH |
| bool m_isQuickSwitch; |
| int m_quickSwitchCmd; |
| #endif |
| #ifdef SAMSUNG_COMPANION |
| bool m_flagChangedRtHdr; |
| #endif |
| int m_shutterSpeed; |
| int m_gain; |
| int m_irLedWidth; |
| int m_irLedDelay; |
| int m_irLedCurrent; |
| int m_irLedOnTime; |
| #ifdef LLS_STUNR |
| bool m_flagLLSStunrMode; |
| int m_LLSStunrCaptureCount; |
| #endif |
| #ifdef USE_ODC_CAPTURE |
| bool m_flagODCCaptureMode; |
| bool m_flagODCCaptureEnable; |
| #endif |
| #ifdef USE_VRA_GROUP |
| int m_dsInputPortId; |
| #endif |
| bool m_isSwitchSensor; |
| }; |
| |
| |
| }; /* namespace android */ |
| |
| #endif |