| /* |
| ** |
| ** Copyright 2017, 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_PARAMETERS_H |
| #define EXYNOS_CAMERA_PARAMETERS_H |
| |
| #include <utils/threads.h> |
| #include <utils/RefBase.h> |
| #include <utils/String8.h> |
| #include <cutils/properties.h> |
| #include <CameraParameters.h> |
| |
| #include <videodev2.h> |
| #include <videodev2_exynos_media.h> |
| #include <videodev2_exynos_camera.h> |
| #include <map> |
| |
| #ifdef USE_CSC_FEATURE |
| #include <SecNativeFeature.h> |
| #endif |
| |
| #include "ExynosCameraObject.h" |
| #include "ExynosCameraConfig.h" |
| #include "ExynosCameraSensorInfoBase.h" |
| #include "ExynosCameraCounter.h" |
| #include "fimc-is-metadata.h" |
| #include "ExynosRect.h" |
| #include "exynos_format.h" |
| #include "ExynosExif.h" |
| #include "ExynosCameraUtils.h" |
| #include "ExynosCameraActivityControl.h" |
| #include "ExynosCameraAutoTimer.h" |
| |
| #ifdef SAMSUNG_TN_FEATURE |
| #include "SecCameraParameters.h" |
| #endif |
| #ifdef SAMSUNG_HYPER_MOTION |
| #include "SecCameraHyperMotion.h" |
| #endif /*SAMSUNG_HYPER_MOTION*/ |
| #ifdef SAMSUNG_OIS |
| #include "ExynosCameraNode.h" |
| #endif |
| #ifdef SAMSUNG_DNG |
| #include "SecCameraDng.h" |
| #include "SecCameraDngThumbnail.h" |
| #endif |
| |
| #include "ExynosCameraSensorInfo.h" |
| #include "SecCameraUtil.h" |
| |
| #ifdef SAMSUNG_UNI_API |
| #include "uni_api_wrapper.h" |
| #endif |
| |
| #define FW_CUSTOM_OFFSET (1) |
| #define V4L2_FOURCC_LENGTH 5 |
| #define IS_WBLEVEL_DEFAULT (4) |
| |
| #define GPS_PROCESSING_METHOD_SIZE 32 |
| |
| #define EXYNOS_CONFIG_DEFINED (-1) |
| #define EXYNOS_CONFIG_NOTDEFINED (-2) |
| |
| #define STATE_REG_BINNING_MODE (1<<28) |
| #define STATE_REG_MANUAL_ISO (1<<26) |
| #define STATE_REG_LONG_CAPTURE (1<<24) |
| #define STATE_REG_SHARPEN_SINGLE (1<<22) |
| #define STATE_REG_RTHDR_AUTO (1<<20) |
| #define STATE_REG_NEED_LLS (1<<18) |
| #define STATE_REG_ZOOM_INDOOR (1<<16) |
| #define STATE_REG_ZOOM_OUTDOOR (1<<14) |
| #define STATE_REG_ZOOM (1<<12) |
| #define STATE_REG_RTHDR_ON (1<<10) |
| #define STATE_REG_RECORDINGHINT (1<<8) |
| #define STATE_REG_DUAL_RECORDINGHINT (1<<6) |
| #define STATE_REG_UHD_RECORDING (1<<4) |
| #define STATE_REG_DUAL_MODE (1<<2) |
| #define STATE_REG_FLAG_REPROCESSING (1) |
| |
| #define STATE_STILL_PREVIEW (0) |
| #define STATE_STILL_PREVIEW_WDR_ON (STATE_REG_RTHDR_ON) |
| #define STATE_STILL_PREVIEW_WDR_AUTO (STATE_REG_RTHDR_AUTO) |
| |
| #define STATE_STILL_CAPTURE (STATE_REG_FLAG_REPROCESSING) |
| #define STATE_STILL_CAPTURE_ZOOM (STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM) |
| #define STATE_STILL_CAPTURE_ZOOM_OUTDOOR (STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM_OUTDOOR) |
| #define STATE_STILL_CAPTURE_ZOOM_INDOOR (STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM_INDOOR) |
| #define STATE_VIDEO_CAPTURE (STATE_REG_FLAG_REPROCESSING|STATE_REG_RECORDINGHINT) |
| #define STATE_STILL_CAPTURE_LLS (STATE_REG_FLAG_REPROCESSING|STATE_REG_NEED_LLS) |
| #define STATE_STILL_CAPTURE_LONG (STATE_REG_FLAG_REPROCESSING|STATE_REG_LONG_CAPTURE) |
| #define STATE_STILL_CAPTURE_MANUAL_ISO (STATE_REG_FLAG_REPROCESSING|STATE_REG_MANUAL_ISO) |
| #define STATE_STILL_CAPTURE_LLS_ZOOM (STATE_REG_FLAG_REPROCESSING|STATE_REG_NEED_LLS|STATE_REG_ZOOM) |
| |
| #define STATE_STILL_CAPTURE_WDR_ON (STATE_REG_RTHDR_ON|STATE_REG_FLAG_REPROCESSING) |
| #define STATE_STILL_CAPTURE_WDR_ON_ZOOM (STATE_REG_RTHDR_ON|STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM) |
| #define STATE_STILL_CAPTURE_WDR_ON_ZOOM_OUTDOOR (STATE_REG_RTHDR_ON|STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM_OUTDOOR) |
| #define STATE_STILL_CAPTURE_WDR_ON_ZOOM_INDOOR (STATE_REG_RTHDR_ON|STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM_INDOOR) |
| #define STATE_STILL_CAPTURE_WDR_ON_LLS_ZOOM (STATE_REG_RTHDR_ON|STATE_REG_FLAG_REPROCESSING|STATE_REG_NEED_LLS|STATE_REG_ZOOM) |
| #define STATE_VIDEO_CAPTURE_WDR_ON (STATE_REG_RTHDR_ON|STATE_REG_FLAG_REPROCESSING|STATE_REG_RECORDINGHINT) |
| #define STATE_VIDEO_CAPTURE_WDR_ON_LLS (STATE_REG_RTHDR_ON|STATE_REG_FLAG_REPROCESSING|STATE_REG_NEED_LLS) |
| |
| #define STATE_STILL_CAPTURE_WDR_AUTO (STATE_REG_RTHDR_AUTO|STATE_REG_FLAG_REPROCESSING) |
| #define STATE_STILL_CAPTURE_WDR_AUTO_ZOOM (STATE_REG_RTHDR_AUTO|STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM) |
| #define STATE_STILL_CAPTURE_WDR_AUTO_ZOOM_OUTDOOR (STATE_REG_RTHDR_AUTO|STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM_OUTDOOR) |
| #define STATE_STILL_CAPTURE_WDR_AUTO_ZOOM_INDOOR (STATE_REG_RTHDR_AUTO|STATE_REG_FLAG_REPROCESSING|STATE_REG_ZOOM_INDOOR) |
| #define STATE_VIDEO_CAPTURE_WDR_AUTO (STATE_REG_RTHDR_AUTO|STATE_REG_FLAG_REPROCESSING|STATE_REG_RECORDINGHINT) |
| #define STATE_STILL_CAPTURE_WDR_AUTO_LLS (STATE_REG_RTHDR_AUTO|STATE_REG_FLAG_REPROCESSING|STATE_REG_NEED_LLS) |
| #define STATE_STILL_CAPTURE_WDR_AUTO_LLS_ZOOM (STATE_REG_RTHDR_AUTO|STATE_REG_FLAG_REPROCESSING|STATE_REG_NEED_LLS|STATE_REG_ZOOM) |
| #define STATE_STILL_CAPTURE_WDR_AUTO_SHARPEN (STATE_REG_RTHDR_AUTO|STATE_REG_FLAG_REPROCESSING|STATE_REG_SHARPEN_SINGLE) |
| |
| #define STATE_VIDEO (STATE_REG_RECORDINGHINT) |
| #define STATE_VIDEO_WDR_ON (STATE_REG_RECORDINGHINT|STATE_REG_RTHDR_ON) |
| #define STATE_VIDEO_WDR_AUTO (STATE_REG_RECORDINGHINT|STATE_REG_RTHDR_AUTO) |
| |
| #define STATE_DUAL_VIDEO (STATE_REG_DUAL_RECORDINGHINT|STATE_REG_DUAL_MODE) |
| #define STATE_DUAL_VIDEO_CAPTURE (STATE_REG_DUAL_RECORDINGHINT|STATE_REG_DUAL_MODE|STATE_REG_FLAG_REPROCESSING) |
| #define STATE_DUAL_STILL_PREVIEW (STATE_REG_DUAL_MODE) |
| #define STATE_DUAL_STILL_CAPTURE (STATE_REG_DUAL_MODE|STATE_REG_FLAG_REPROCESSING) |
| |
| #define STATE_UHD_PREVIEW (STATE_REG_UHD_RECORDING) |
| #define STATE_UHD_PREVIEW_WDR_ON (STATE_REG_UHD_RECORDING|STATE_REG_RTHDR_ON) |
| #define STATE_UHD_PREVIEW_WDR_AUTO (STATE_REG_UHD_RECORDING|STATE_REG_RTHDR_AUTO) |
| #define STATE_UHD_VIDEO (STATE_REG_UHD_RECORDING|STATE_REG_RECORDINGHINT) |
| #define STATE_UHD_VIDEO_WDR_ON (STATE_REG_UHD_RECORDING|STATE_REG_RECORDINGHINT|STATE_REG_RTHDR_ON) |
| #define STATE_UHD_VIDEO_WDR_AUTO (STATE_REG_UHD_RECORDING|STATE_REG_RECORDINGHINT|STATE_REG_RTHDR_AUTO) |
| |
| #define STATE_UHD_PREVIEW_CAPTURE (STATE_REG_UHD_RECORDING|STATE_REG_FLAG_REPROCESSING) |
| #define STATE_UHD_PREVIEW_CAPTURE_WDR_ON (STATE_REG_UHD_RECORDING|STATE_REG_FLAG_REPROCESSING|STATE_REG_RTHDR_ON) |
| #define STATE_UHD_PREVIEW_CAPTURE_WDR_AUTO (STATE_REG_UHD_RECORDING|STATE_REG_FLAG_REPROCESSING|STATE_REG_RTHDR_AUTO) |
| #define STATE_UHD_VIDEO_CAPTURE (STATE_REG_UHD_RECORDING|STATE_REG_RECORDINGHINT|STATE_REG_FLAG_REPROCESSING) |
| #define STATE_UHD_VIDEO_CAPTURE_WDR_ON (STATE_REG_UHD_RECORDING|STATE_REG_RECORDINGHINT|STATE_REG_FLAG_REPROCESSING|STATE_REG_RTHDR_ON) |
| #define STATE_UHD_VIDEO_CAPTURE_WDR_AUTO (STATE_REG_UHD_RECORDING|STATE_REG_RECORDINGHINT|STATE_REG_FLAG_REPROCESSING|STATE_REG_RTHDR_AUTO) |
| |
| #define STATE_STILL_BINNING_PREVIEW (STATE_REG_BINNING_MODE) |
| #define STATE_VIDEO_BINNING (STATE_REG_RECORDINGHINT|STATE_REG_BINNING_MODE) |
| #define STATE_DUAL_STILL_BINING_PREVIEW (STATE_REG_DUAL_MODE|STATE_REG_BINNING_MODE) |
| #define STATE_DUAL_VIDEO_BINNING (STATE_REG_DUAL_RECORDINGHINT|STATE_REG_DUAL_MODE|STATE_REG_BINNING_MODE) |
| |
| namespace android { |
| |
| using namespace std; |
| using ::android::hardware::camera::common::V1_0::helper::CameraParameters; |
| using ::android::hardware::camera::common::V1_0::helper::CameraMetadata; |
| |
| namespace CONFIG_MODE { |
| enum MODE { |
| NORMAL = 0x00, |
| HIGHSPEED_60, |
| HIGHSPEED_120, |
| HIGHSPEED_240, |
| MAX |
| }; |
| }; |
| |
| enum YuvStallUsage { |
| YUV_STALL_USAGE_DSCALED = 0, |
| YUV_STALL_USAGE_PICTURE = 1 |
| }; |
| |
| struct CONFIG_PIPE { |
| uint32_t prepare[MAX_PIPE_NUM_REPROCESSING]; |
| }; |
| |
| struct CONFIG_BUFFER { |
| uint32_t num_sensor_buffers; |
| uint32_t num_bayer_buffers; |
| uint32_t num_3aa_buffers; |
| uint32_t num_hwdis_buffers; |
| uint32_t num_preview_buffers; |
| uint32_t num_preview_cb_buffers; |
| uint32_t num_picture_buffers; |
| uint32_t num_nv21_picture_buffers; |
| uint32_t num_reprocessing_buffers; |
| uint32_t num_recording_buffers; |
| uint32_t num_fastaestable_buffer; |
| uint32_t num_vra_buffers; |
| uint32_t reprocessing_bayer_hold_count; |
| uint32_t num_request_raw_buffers; |
| uint32_t num_request_preview_buffers; |
| uint32_t num_request_callback_buffers; |
| uint32_t num_request_video_buffers; |
| uint32_t num_request_jpeg_buffers; |
| uint32_t num_batch_buffers; |
| }; |
| |
| struct CONFIG_BUFFER_PIPE { |
| struct CONFIG_PIPE pipeInfo; |
| struct CONFIG_BUFFER bufInfo; |
| }; |
| |
| struct ExynosConfigInfo { |
| struct CONFIG_BUFFER_PIPE *current; |
| struct CONFIG_BUFFER_PIPE info[CONFIG_MODE::MAX]; |
| uint32_t mode; |
| }; |
| |
| struct CameraMetaParameters { |
| int m_flashMode; |
| float m_zoomRatio; |
| #ifdef SAMSUNG_OT |
| bool m_startObjectTracking; |
| #endif |
| }; |
| |
| #ifdef USE_DUAL_CAMERA |
| enum DUAL_PREVIEW_MODE { |
| DUAL_PREVIEW_MODE_OFF, |
| DUAL_PREVIEW_MODE_HW, |
| DUAL_PREVIEW_MODE_SW, |
| DUAL_PREVIEW_MODE_MAX, |
| }; |
| |
| enum DUAL_REPROCESSING_MODE { |
| DUAL_REPROCESSING_MODE_OFF, |
| DUAL_REPROCESSING_MODE_HW, |
| DUAL_REPROCESSING_MODE_SW, |
| DUAL_REPROCESSING_MODE_MAX, |
| }; |
| |
| enum DUAL_OPERATION_MODE { |
| DUAL_OPERATION_MODE_NONE, |
| DUAL_OPERATION_MODE_MASTER, |
| DUAL_OPERATION_MODE_SLAVE, |
| DUAL_OPERATION_MODE_SYNC, |
| DUAL_OPERATION_MODE_MAX, |
| }; |
| #endif |
| |
| class ExynosCameraParameters : public ExynosCameraObject { |
| public: |
| /* Enumerator */ |
| enum yuv_output_port_id { |
| YUV_0, |
| YUV_1, |
| YUV_2, |
| YUV_MAX, //3 |
| |
| YUV_STALL_0 = YUV_MAX, |
| YUV_STALL_1, |
| YUV_STALL_2, |
| YUV_STALL_MAX, //6 |
| YUV_OUTPUT_PORT_ID_MAX = YUV_STALL_MAX, |
| }; |
| |
| enum critical_section_type { |
| /* Order is VERY important. |
| It indicates the order of entering critical section on run-time. |
| */ |
| CRITICAL_SECTION_TYPE_START, |
| CRITICAL_SECTION_TYPE_HWFC = CRITICAL_SECTION_TYPE_START, |
| CRITICAL_SECTION_TYPE_VOTF, |
| CRITICAL_SECTION_TYPE_END, |
| }; |
| |
| /* Constructor */ |
| ExynosCameraParameters(int cameraId); |
| |
| /* Destructor */ |
| virtual ~ExynosCameraParameters(); |
| |
| void setDefaultCameraInfo(void); |
| |
| public: |
| status_t checkPictureSize(int pictureW, int pctureH); |
| status_t checkJpegQuality(int quality); |
| status_t checkThumbnailSize(int thumbnailW, int thumbnailH); |
| status_t checkThumbnailQuality(int quality); |
| status_t checkPreviewFpsRange(uint32_t minFps, uint32_t maxFps); |
| |
| status_t resetYuvSizeRatioId(void); |
| status_t checkYuvSize(const int width, const int height, const int outputPortId, bool reprocessing = false); |
| status_t checkHwYuvSize(const int width, const int height, const int outputPortId, bool reprocessing = false); |
| status_t checkYuvFormat(const int format, const int outputPortId); |
| #ifdef HAL3_YUVSIZE_BASED_BDS |
| status_t initYuvSizes(); |
| #endif |
| void resetMinYuvSize(); |
| void resetMaxYuvSize(); |
| status_t getMinYuvSize(int* w, int* h) const; |
| status_t getMaxYuvSize(int* w, int* h) const; |
| |
| void resetMaxHwYuvSize(); |
| status_t getMaxHwYuvSize(int* w, int* h) const; |
| |
| void getYuvSize(int *width, int *height, int outputPortId); |
| int getYuvFormat(const int outputPortId); |
| void resetYuvSize(void); |
| |
| void getHwYuvSize(int *width, int *height, int outputPortId); |
| void resetHwYuvSize(void); |
| |
| void setPreviewPortId(int outputPortId); |
| bool isPreviewPortId(int outputPortId); |
| int getPreviewPortId(void); |
| |
| void setRecordingPortId(int outputPortId); |
| bool isRecordingPortId(int outputPortId); |
| int getRecordingPortId(void); |
| |
| void setYuvOutPortId(enum pipeline pipeId, int outputPortId); |
| int getYuvOutPortId(enum pipeline pipeId); |
| |
| void setThumbnailCbSize(int w, int h); |
| void getThumbnailCbSize(int *w, int *h); |
| void resetThumbnailCbSize(); |
| |
| void getDScaledYuvStallSize(int *w, int *h); |
| |
| 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 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); |
| |
| void setRestartStream(bool restart); |
| bool getRestartStream(void); |
| |
| private: |
| /* Sets the dimensions for pictures. */ |
| void m_setPictureSize(int w, int h); |
| /* Sets the image format for picture-related HW. */ |
| void m_setHwPictureFormat(int colorFormat); |
| /* Sets the image pixel size for picture-related HW. */ |
| void m_setHwPicturePixelSize(camera_pixel_size pixelSize); |
| void m_setYuvSize(const int width, const int height, const int index); |
| void m_setYuvFormat(const int format, const int index); |
| void m_setHwYuvSize(const int width, const int height, const int index); |
| |
| /* Sets the dimensions for Sesnor-related HW. */ |
| void m_setHwSensorSize(int w, int h); |
| /* 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 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 the frame rate range for preview. */ |
| void m_setPreviewFpsRange(uint32_t min, uint32_t max); |
| /* Sets Bayer Crop Region */ |
| status_t m_setParamCropRegion(int srcW, int srcH, int dstW, int dstH); |
| |
| /* |
| * Additional API. |
| */ |
| /* Sets ODC */ |
| void m_setOdcMode(bool toggle); |
| /* |
| * Vendor specific APIs |
| */ |
| /* Sets Intelligent mode */ |
| void m_setIntelligentMode(int intelligentMode); |
| void m_setVisionMode(bool vision); |
| void m_setVisionModeFps(int fps); |
| void m_setVisionModeAeTarget(int ae); |
| |
| /* Sets VT mode */ |
| void m_setVtMode(int vtMode); |
| |
| void m_setHighSpeedRecording(bool highSpeed); |
| status_t m_setImageUniqueId(const char *uniqueId); |
| |
| /* |
| * Others |
| */ |
| void m_setExifFixedAttribute(void); |
| status_t m_adjustPreviewFpsRange(uint32_t &newMinFps, uint32_t &newMaxFps); |
| |
| public: |
| #ifdef SAMSUNG_DOF |
| /* Sets Lens Position */ |
| void m_setLensPos(int pos); |
| #endif |
| #ifdef SAMSUNG_HRM |
| void m_setHRM(int ir_data, int flicker_data, int status); |
| void m_setHRM_Hint(bool flag); |
| bool m_getHRM_Hint(void); |
| #endif |
| #ifdef SAMSUNG_LIGHT_IR |
| void m_setLight_IR(SensorListenerEvent_t data); |
| void m_setLight_IR_Hint(bool flag); |
| bool m_getLight_IR_Hint(void); |
| #endif |
| #ifdef SAMSUNG_GYRO |
| void m_setGyro(SensorListenerEvent_t data); |
| void m_setGyroHint(bool flag); |
| bool m_getGyroHint(void); |
| SensorListenerEvent_t *getGyroData(void); |
| #endif |
| #ifdef SAMSUNG_ACCELEROMETER |
| void m_setAccelerometer(SensorListenerEvent_t data); |
| void m_setAccelerometerHint(bool flag); |
| bool m_getAccelerometerHint(void); |
| #endif |
| #ifdef SAMSUNG_ROTATION |
| void m_setRotationHint(bool flag); |
| bool m_getRotationHint(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 dimension setting for pictures. */ |
| void getPictureSize(int *w, int *h); |
| /* Returns the image format for picture-related HW. */ |
| int getHwPictureFormat(void); |
| /* Returns the image pixel size for picture-related HW. */ |
| camera_pixel_size getHwPicturePixelSize(void); |
| /* Sets video's width, height */ |
| void setVideoSize(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); |
| |
| /* 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); |
| /* 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); |
| /* Returns the current minimum and maximum preview fps. */ |
| void getPreviewFpsRange(uint32_t *min, uint32_t *max); |
| /* Gets the current state of video stabilization. */ |
| bool getVideoStabilization(void); |
| /* Set the current crop region info */ |
| status_t setCropRegion(int x, int y, int w, int h); |
| /* Returns the recording mode hint. */ |
| bool getRecordingHint(void); |
| /* Sets recording mode hint. */ |
| void setRecordingHint(bool hint); |
| /* Sets the YSUM recording mode */ |
| void setYsumRecordingMode(bool); |
| /* Returns the YSUM recording mode */ |
| bool getYsumRecordingMode(void); |
| |
| void getHwVraInputSize(int *w, int *h, int dsInputPortId); |
| int getHwVraInputFormat(void); |
| |
| void setDsInputPortId(int dsInputPortId, bool isReprocessing); |
| int getDsInputPortId(bool isReprocessing); |
| |
| void updateYsumPordId(struct camera2_shot_ext *shot_ext); |
| status_t updateYsumBuffer(struct ysum_data *ysumdata, ExynosCameraBuffer *dstBuf); |
| |
| /* |
| * Additional API. |
| */ |
| |
| /* Sets ExposureTime for capture */ |
| void setCaptureExposureTime(uint64_t exposureTime); |
| /* 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 WDR */ |
| bool getHdrMode(void); |
| /* Gets ODC */ |
| bool getOdcMode(void); |
| /* Gets Shot mode */ |
| int getShotMode(void); |
| /* Gets GDC enable case or not */ |
| bool getGDCEnabledMode(void); |
| /* Get sensor control frame delay count */ |
| int getSensorControlDelay(void); |
| |
| #ifdef SAMSUNG_PAF |
| /* Gets PAF */ |
| enum companion_paf_mode getPaf(void); |
| #endif |
| #ifdef SAMSUNG_RTHDR |
| /* Gets RT HDR */ |
| enum companion_wdr_mode getRTHdr(void); |
| void setRTHdr(enum companion_wdr_mode rtHdrMode); |
| #endif |
| |
| /* |
| * Vendor specific APIs |
| */ |
| |
| /* Gets Intelligent mode */ |
| int getIntelligentMode(void); |
| bool getVisionMode(void); |
| int getVisionModeFps(void); |
| int getVisionModeAeTarget(void); |
| |
| bool getHWVdisMode(void); |
| int getHWVdisFormat(void); |
| |
| void getYuvVendorSize(int *width, int *height, int outputPortId, ExynosRect ispSize); |
| |
| /* Gets VT mode */ |
| int getVtMode(void); |
| |
| /* Set/Get Dual mode */ |
| void setPIPMode(bool toggle); |
| bool getPIPMode(void); |
| |
| #ifdef USE_DUAL_CAMERA |
| void setDualMode(bool enabled); |
| bool getDualMode(void); |
| enum DUAL_PREVIEW_MODE getDualPreviewMode(void); |
| enum DUAL_REPROCESSING_MODE getDualReprocessingMode(void); |
| void setDualOperationMode(enum DUAL_OPERATION_MODE mode); |
| enum DUAL_OPERATION_MODE getDualOperationMode(void); |
| bool isSupportMasterSensorStandby(void); |
| bool isSupportSlaveSensorStandby(void); |
| #endif |
| uint32_t getSensorStandbyDelay(void); |
| |
| void setProMode(bool proMode); |
| |
| /* Returns the dual recording mode hint. */ |
| bool getPIPRecordingHint(void); |
| |
| bool getHighSpeedRecording(void); |
| #ifdef USE_BINNING_MODE |
| int * getBinningSizeTable(void); |
| #endif |
| /* Gets ImageUniqueId */ |
| const char *getImageUniqueId(void); |
| #ifdef SAMSUNG_TN_FEATURE |
| void setImageUniqueId(char *uniqueId); |
| #endif |
| |
| void setFlipHorizontal(int val); |
| int getFlipHorizontal(void); |
| void setFlipVertical(int val); |
| int getFlipVertical(void); |
| |
| /* Gets Burst mode */ |
| int getSeriesShotCount(void); |
| /* Gets Low Light Shot */ |
| int getLLS(struct camera2_shot_ext *shot); |
| /* Gets Low Light A */ |
| /* 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); |
| |
| /* |
| * Static info |
| */ |
| /* Gets max zoom ratio */ |
| float getMaxZoomRatio(void); |
| /* Gets current zoom ratio */ |
| float getZoomRatio(void); |
| /* Sets current zoom ratio */ |
| void setZoomRatio(float zoomRatio); |
| |
| /* Gets FocalLengthIn35mmFilm */ |
| int getFocalLengthIn35mmFilm(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); |
| |
| debug_attribute_t *getDebugAttribute(void); |
| debug_attribute_t *getDebug2Attribute(void); |
| |
| #ifdef DEBUG_RAWDUMP |
| bool checkBayerDumpEnable(void); |
| #endif/* DEBUG_RAWDUMP */ |
| #ifdef USE_BINNING_MODE |
| int getBinningMode(void); |
| #endif /* USE_BINNING_MODE */ |
| |
| public: |
| /* For Vendor */ |
| bool getSamsungCamera(void); |
| void setSamsungCamera(bool flag); |
| status_t checkSamsungCamera(const CameraParameters& params); |
| int getRecordingFps(void); |
| void setRecordingFps(int fps); |
| status_t checkRecordingFps(const CameraParameters& params); |
| status_t setParameters(const CameraParameters& params); |
| status_t checkDualMode(const CameraParameters& params); |
| status_t checkIntelligentMode(const CameraParameters& params); |
| status_t checkVtMode(const CameraParameters& params); |
| status_t checkFactorytest(const CameraParameters& params); |
| bool getFactorytest(void); |
| |
| void updateHwSensorSize(void); |
| void updateBinningScaleRatio(void); |
| |
| status_t duplicateCtrlMetadata(void *buf); |
| |
| bool getUHDRecordingMode(void); |
| status_t init(void); |
| void vendorSpecificConstructor(int cameraId); |
| bool getSWVdisMode(void); |
| bool getHyperMotionMode(void); |
| #ifdef SAMSUNG_STR_PREVIEW |
| bool getSTRPreviewEnable(void); |
| #endif |
| |
| #ifdef SAMSUNG_SW_VDIS |
| void getSWVdisYuvSize(int w, int h, int *newW, int *newH); |
| void getSWVdisAdjustYuvSize(int *width, int *height); |
| void setSWVdisPreviewOffset(int left, int top); |
| void getSWVdisPreviewOffset(int *left, int *top); |
| bool isSWVdisOnPreview(void); |
| void setSWVdisVideoIndex(int index); |
| int getSWVdisVideoIndex(void); |
| #endif |
| |
| private: |
| bool m_isSupportedYuvSize(const int width, const int height, const int outputPortId, int *ratio); |
| bool m_isSupportedPictureSize(const int width, const int height); |
| status_t m_getSizeListIndex(int (*sizelist)[SIZE_OF_LUT], int listMaxSize, int ratio, int *index); |
| status_t m_getPictureSizeList(int *sizeList); |
| status_t m_getPreviewSizeList(int *sizeList); |
| bool m_isSupportedFullSizePicture(void); |
| void m_getSWVdisPreviewSize(int w, int h, int *newW, int *newH); |
| |
| void m_initMetadata(void); |
| bool m_isUHDRecordingMode(void); |
| |
| status_t checkSWVdisMode(const CameraParameters& params); |
| status_t checkHyperMotionMode(const CameraParameters& params); |
| /* |
| * Vendor specific adjust function |
| */ |
| status_t m_vendorInit(void); |
| void m_vendorSpecificDestructor(void); |
| status_t m_getPreviewBdsSize(ExynosRect *dstRect); |
| status_t m_adjustPictureSize(int *newPictureW, int *newPictureH, |
| int *newHwPictureW, int *newHwPictureH); |
| void m_adjustSensorMargin(int *sensorMarginW, int *sensorMarginH); |
| void m_getSetfileYuvRange(bool flagReprocessing, int *setfile, int *yuvRange); |
| void m_getCropRegion(int *x, int *y, int *w, int *h); |
| #ifdef USE_CSC_FEATURE |
| bool m_isLatinOpenCSC(); |
| int m_getAntiBandingFromLatinMCC(); |
| #endif |
| |
| status_t m_setBinningScaleRatio(int ratio); |
| void m_setExifChangedAttribute(exif_attribute_t *exifInfo, |
| ExynosRect *PictureRect, |
| ExynosRect *thumbnailRect, |
| camera2_shot_t *shot, |
| bool useDebugInfo2 = false); |
| |
| void m_getV4l2Name(char* colorName, size_t length, int colorFormat); |
| bool m_getUseFullSizeLUT(void); |
| |
| /* H/W Chain Scenario Infos */ |
| enum HW_CONNECTION_MODE m_getFlite3aaOtf(void); |
| enum HW_CONNECTION_MODE m_get3aaIspOtf(void); |
| enum HW_CONNECTION_MODE m_getIspMcscOtf(void); |
| enum HW_CONNECTION_MODE m_getMcscVraOtf(void); |
| enum HW_CONNECTION_MODE m_getReprocessing3aaIspOtf(void); |
| enum HW_CONNECTION_MODE m_getReprocessingIspMcscOtf(void); |
| enum HW_CONNECTION_MODE m_getReprocessingMcscVraOtf(void); |
| #ifdef USE_DUAL_CAMERA |
| enum HW_CONNECTION_MODE m_getIspDcpOtf(void); |
| enum HW_CONNECTION_MODE m_getDcpMcscOtf(void); |
| enum HW_CONNECTION_MODE m_getReprocessingIspDcpOtf(void); |
| enum HW_CONNECTION_MODE m_getReprocessingDcpMcscOtf(void); |
| #endif |
| |
| public: |
| void setBurstShotFps(int value); |
| int getBurstShotFps(void); |
| void setBurstShotTargetFps(int value); |
| int getBurstShotTargetFps(void); |
| int getLightCondition(void); |
| |
| ExynosCameraActivityControl *getActivityControl(void); |
| |
| void getSetfileYuvRange(bool flagReprocessing, int *setfile, int *yuvRange); |
| void setSetfileYuvRange(void); |
| void setSetfileYuvRange(bool flagReprocessing, int setfile, int yuvRange); |
| status_t checkSetfileYuvRange(void); |
| |
| void setUseSensorPackedBayer(bool enable); |
| bool getUsePureBayerReprocessing(void); |
| int32_t getReprocessingBayerMode(void); |
| void setUseDynamicBayer(bool enable); |
| bool getUseDynamicBayer(void); |
| bool getUseDynamicBayer60FpsVideoSnapShot(void); |
| bool getUseDynamicBayer120FpsVideoSnapShot(void); |
| bool getUseDynamicBayer240FpsVideoSnapShot(void); |
| |
| void setUseFastenAeStable(bool enable); |
| bool getUseFastenAeStable(void); |
| bool isFastenAeStableEnable(void); |
| |
| uint32_t getBinningScaleRatio(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); |
| /* Gets BatchSize for HFR */ |
| int getBatchSize(enum pipeline pipeId); |
| /* Check to use Service Batch Mode */ |
| bool useServiceBatchMode(void); |
| /* Decide to enter critical section */ |
| bool isCriticalSection(enum pipeline pipeId, |
| enum critical_section_type type); |
| |
| struct ExynosCameraSensorInfoBase *getSensorStaticInfo(); |
| |
| int32_t getYuvStreamMaxNum(void); |
| int32_t getInputStreamMaxNum(void); |
| |
| #ifdef SAMSUNG_DOF |
| int getFocusLensPos(void); |
| void setFocusLensPos(int pos); |
| #endif |
| |
| int getSeriesShotMode(void); |
| |
| int getMultiCaptureMode(void); |
| void setMultiCaptureMode(int captureMode); |
| |
| void setExposureTime(int64_t shutterSpeed); |
| int64_t getExposureTime(void); |
| void setGain(int gain); |
| int getGain(void); |
| void setLedPulseWidth(int64_t ledPulseWidth); |
| int64_t getLedPulseWidth(void); |
| void setLedPulseDelay(int64_t ledPulseDelay); |
| int64_t getLedPulseDelay(void); |
| void setLedCurrent(int ledCurrent); |
| int getLedCurrent(void); |
| void setLedMaxTime(int ledMaxTime); |
| int getLedMaxTime(void); |
| |
| void setDvfsLock(bool lock); |
| bool getDvfsLock(void); |
| |
| bool getSensorOTFSupported(void); |
| bool isReprocessing(void); |
| bool isSccCapture(void); |
| |
| /* True if private reprocessing or YUV reprocessing is supported */ |
| bool isSupportZSLInput(void); |
| |
| enum HW_CONNECTION_MODE getHwConnectionMode( |
| enum pipeline srcPipeId, |
| enum pipeline dstPipeId); |
| |
| 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 isUseThumbnailHWFC(void) {return true;}; |
| bool isHWFCOnDemand(void); |
| |
| bool setConfig(struct ExynosConfigInfo* config); |
| struct ExynosConfigInfo* getConfig(); |
| |
| bool setConfigMode(uint32_t mode); |
| int getConfigMode(); |
| /* Sets Shot mode */ |
| void setShotMode(int shotMode); |
| #ifdef LLS_CAPTURE |
| void setLLSOn(uint32_t enable); |
| bool getLLSOn(void); |
| void setLLSValue(int value); |
| int getLLSValue(void); |
| #ifdef SET_LLS_CAPTURE_SETFILE |
| void setLLSCaptureOn(bool enable); |
| int getLLSCaptureOn(); |
| #endif |
| #endif |
| #ifdef SAMSUNG_HIFI_CAPTURE |
| bool getHiFiCatureEnable(void); |
| #endif |
| void setManualAeControl(bool isManualAeControl); |
| bool getManualAeControl(void); |
| void setFlashMode(int flashMode); |
| int getFlashMode(void); |
| void updateMetaParameter(struct CameraMetaParameters *metaParameters); |
| #ifdef OIS_CAPTURE |
| void checkOISCaptureMode(int multiCaptureMode); |
| void setOISCaptureModeOn(bool enable); |
| bool getOISCaptureModeOn(void); |
| #endif |
| void setDynamicPickCaptureModeOn(bool enable); |
| bool getDynamicPickCaptureModeOn(void); |
| #ifdef RAWDUMP_CAPTURE |
| void setRawCaptureModeOn(bool enable); |
| bool getRawCaptureModeOn(void); |
| #endif |
| status_t setMarkingOfExifFlash(int flag); |
| int getMarkingOfExifFlash(void); |
| |
| status_t setYuvBufferCount(const int count, const int outputPortId); |
| int getYuvBufferCount(const int outputPortId); |
| void resetYuvBufferCount(void); |
| |
| void setHighSpeedMode(uint32_t mode); |
| int getMaxHighSpeedFps(void); |
| |
| //Added |
| int getHDRDelay(void) { return HDR_DELAY; } |
| int getReprocessingBayerHoldCount(void) { return REPROCESSING_BAYER_HOLD_COUNT; } |
| 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 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;} |
| |
| bool needGSCForCapture(int camId) { return (camId == CAMERA_ID_BACK) ? USE_GSC_FOR_CAPTURE_BACK : USE_GSC_FOR_CAPTURE_FRONT; } |
| bool getSetFileCtlMode(void); |
| bool getSetFileCtl3AA(void); |
| bool getSetFileCtlISP(void); |
| void setYuvStallPortUsage(int usage); |
| int getYuvStallPortUsage(void); |
| void resetYuvStallPort(void); |
| void setYuvStallPort(int port); |
| int getYuvStallPort(void); |
| |
| #ifdef SUPPORT_DEPTH_MAP |
| status_t getDepthMapSize(int *depthMapW, int *depthMapH); |
| void setDepthMapSize(int depthMapW, int depthMapH); |
| bool getUseDepthMap(void); |
| void setUseDepthMap(bool useDepthMap); |
| bool getDepthCallbackOnPreview(void) {return 0;}; |
| bool getDepthCallbackOnCapture(void) {return 0;}; |
| bool isDepthMapSupported(void); |
| #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 setLDCaptureMode(int LDMode); |
| int getLDCaptureMode(void); |
| int getLDCaptureCount(void); |
| void setLDCaptureCount(int count); |
| void checkLDCaptureMode(void); |
| void setLDCaptureLLSValue(uint32_t lls); |
| int getLDCaptureLLSValue(void); |
| void setLLSdebugInfo(unsigned char *data, unsigned int size); |
| #endif |
| |
| #ifdef SAMSUNG_LENS_DC |
| bool getLensDCEnable(void); |
| #endif |
| |
| #ifdef SAMSUNG_STR_CAPTURE |
| void checkSTRCaptureMode(bool hasCaptureStream); |
| void setSTRCaptureEnable(bool enable); |
| bool getSTRCaptureEnable(void); |
| void setSTRdebugInfo(unsigned char *data, unsigned int size); |
| #endif |
| |
| int getAntibanding(); |
| void setUseFullSizeLUT(bool enable); |
| |
| bool checkFaceDetectMeta(struct camera2_shot_ext *shot_ext); |
| |
| #ifdef SAMSUNG_OT |
| void setObjectTrackingEnable(bool startObjectTracking); |
| bool getObjectTrackingEnable(void); |
| void setObjectTrackingAreas(int validFocusArea, ExynosRect2 area, int weight); |
| int getObjectTrackingAreas(int* validFocusArea, ExynosRect2* areas, int* weights); |
| #endif |
| |
| #ifdef SAMSUNG_HLV |
| bool getHLVEnable(bool recordingEnabled); |
| #endif |
| #ifdef SAMSUNG_IDDQD |
| bool getIDDQDEnable(void); |
| void setIDDQDresult(bool isdetected); |
| bool getIDDQDresult(void); |
| #endif |
| void m_setSWVdisMode(bool swVdis); |
| void m_setHyperMotionMode(bool enable); |
| |
| void setTransientActionMode(int transientAction); |
| int getTransientActionMode(); |
| |
| bool getHfdMode(void); |
| #ifdef SAMSUNG_SSRM |
| struct ssrmCameraInfo* getSsrmCameraInfo(void) {return &m_ssrmCameraInfo; } |
| #endif |
| |
| private: |
| int m_scenario; |
| struct camera2_shot_ext m_metadata; |
| struct exynos_camera_info m_cameraInfo; |
| struct ExynosCameraSensorInfoBase *m_staticInfo; |
| struct ExynosConfigInfo *m_exynosconfig; |
| struct CameraMetaParameters m_metaParameters; |
| |
| exif_attribute_t m_exifInfo; |
| debug_attribute_t mDebugInfo; |
| debug_attribute_t mDebugInfo2; |
| |
| mutable Mutex m_parameterLock; |
| mutable Mutex m_staticInfoExifLock; |
| mutable Mutex m_faceDetectMetaLock; |
| |
| ExynosCameraActivityControl *m_activityControl; |
| |
| /* Flags for camera status */ |
| bool m_flagCheckPIPMode; |
| bool m_flagRestartStream; |
| |
| bool m_flagCheckProMode; |
| #ifdef USE_DUAL_CAMERA |
| bool m_flagCheckDualMode; |
| enum DUAL_OPERATION_MODE m_dualOperationMode; |
| #endif |
| int m_burstShotFps; |
| int m_burstShotTargetFps; |
| #ifdef LLS_CAPTURE |
| bool m_flagLLSOn; |
| int m_LLSValue; |
| int m_LLSCaptureOn; |
| #endif |
| #ifdef OIS_CAPTURE |
| bool m_flagOISCaptureOn; |
| #endif |
| #ifdef RAWDUMP_CAPTURE |
| bool m_flagRawCaptureOn; |
| #endif |
| bool m_flagDynamicPickCaptureOn; |
| bool m_flagCheckRecordingHint; |
| |
| 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_useSensorPackedBayer; |
| bool m_useDynamicBayer; |
| bool m_useDynamicBayer60Fps; |
| bool m_useDynamicBayer120Fps; |
| bool m_useDynamicBayer240Fps; |
| bool m_usePureBayerReprocessing; |
| bool m_useFastenAeStable; |
| bool m_dvfsLock; |
| |
| #ifdef SAMSUNG_SSRM |
| struct ssrmCameraInfo m_ssrmCameraInfo; |
| #endif |
| |
| #ifdef SAMSUNG_DOF |
| int m_focusLensPos; |
| #endif |
| |
| int m_firing_flash_marking; |
| uint64_t m_exposureTimeCapture; |
| |
| #ifdef SUPPORT_DEPTH_MAP |
| bool m_flagUseDepthMap; |
| int m_depthMapW; |
| int m_depthMapH; |
| #endif |
| |
| int m_yuvBufferCount[YUV_OUTPUT_PORT_ID_MAX]; |
| int m_previewPortId; |
| int m_recordingPortId; |
| int m_yuvOutPortId[MAX_PIPE_NUM]; |
| |
| #ifdef SAMSUNG_LLS_DEBLUR |
| int m_flagLDCaptureMode; |
| uint32_t m_flagLDCaptureLLSValue; |
| int m_LDCaptureCount; |
| #endif |
| int m_yuvStallPort; |
| int m_flagYuvStallPortUsage; |
| #ifdef SAMSUNG_LENS_DC |
| bool m_flagLensDCEnable; |
| bool m_flagLensDCMode; |
| #endif |
| #ifdef SAMSUNG_STR_CAPTURE |
| bool m_flagSTRCaptureEnable; |
| #endif |
| bool m_isManualAeControl; |
| #ifdef SAMSUNG_HRM |
| bool m_flagSensorHRM_Hint; |
| #endif |
| #ifdef SAMSUNG_LIGHT_IR |
| bool m_flagSensorLight_IR_Hint; |
| #endif |
| #ifdef SAMSUNG_GYRO |
| bool m_flagSensorGyroHint; |
| SensorListenerEvent_t m_gyroListenerData; |
| #endif |
| #ifdef SAMSUNG_ACCELEROMETER |
| bool m_flagSensorAccelerationHint; |
| #endif |
| #ifdef SAMSUNG_ROTATION |
| bool m_flagSensorRotationHint; |
| #endif |
| bool m_isUniqueIdRead; |
| |
| bool m_isFactoryBin; |
| int64_t m_exposureTime; |
| int m_gain; |
| int64_t m_ledPulseWidth; |
| int64_t m_ledPulseDelay; |
| int m_ledCurrent; |
| int m_ledMaxTime; |
| |
| bool m_isFullSizeLut; |
| int m_thumbnailCbW; |
| int m_thumbnailCbH; |
| |
| int m_previewDsInputPortId; |
| int m_captureDsInputPortId; |
| |
| #ifdef SAMSUNG_OT |
| ExynosRect2 m_objectTrackingArea; |
| int m_objectTrackingWeight; |
| #endif |
| int m_flagtransientAction; |
| #ifdef SAMSUNG_IDDQD |
| bool m_lensDirtyDetected; |
| #endif |
| #ifdef SAMSUNG_SW_VDIS |
| int m_previewOffsetLeft; |
| int m_previewOffsetTop; |
| int m_videoOutIndex; |
| #endif |
| }; |
| |
| }; /* namespace android */ |
| |
| #endif |