| /* |
| * Copyright 2008, The Android Open Source Project |
| * 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. |
| */ |
| |
| /*! |
| * \file ISecCameraHardware.h |
| * \brief source file for Android Camera Ext HAL |
| * \author teahyung kim (tkon.kim@samsung.com) |
| * \date 2013/04/30 |
| * |
| */ |
| |
| #ifndef ANDROID_HARDWARE_ISECCAMERAHARDWARE_H |
| #define ANDROID_HARDWARE_ISECCAMERAHARDWARE_H |
| |
| /* |
| * Common Header file |
| */ |
| #include <utils/List.h> |
| #include <utils/threads.h> |
| #include <utils/RefBase.h> |
| #include <cutils/compiler.h> |
| #include <binder/MemoryBase.h> |
| #include <binder/MemoryHeapBase.h> |
| #include <ui/GraphicBufferMapper.h> |
| #include <hardware/camera.h> |
| #include <hardware/gralloc.h> |
| #include <camera/CameraParameters.h> |
| #include <cutils/properties.h> |
| #include <utils/Log.h> |
| |
| #ifndef HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_FULL |
| #define HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_FULL (HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL) /* 0x11E, */ |
| #endif |
| |
| #ifndef HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP |
| #define HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP (HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M) /* 0x11D, */ |
| #endif |
| |
| /* use exynos feature */ |
| #include <ion.h> |
| #include "ExynosBuffer.h" |
| #include "exynos_v4l2.h" |
| #include "exynos_format.h" |
| #include "csc.h" |
| #include "gralloc_priv.h" |
| |
| /* |
| * Model-specific Header file |
| */ |
| #include "model/include/SecCameraHardware-model.h" |
| |
| #include "ExynosCameraConfig.h" |
| |
| #include "SecCameraParameters.h" |
| |
| /* |
| * Define debug feature |
| */ |
| #ifdef CAMERA_DEBUG_ALL |
| #define DEBUG_THREAD_EXIT_WAIT |
| #define DEBUG_PREVIEW_CALLBACK |
| #define DEBUG_CAPTURE_RETRY |
| #endif |
| |
| //#define SAVE_DUMP |
| |
| /* FIMC IS debug */ |
| #if IS_FW_DEBUG |
| #define FIMC_IS_FW_DEBUG_REGION_SIZE 512000 |
| #define FIMC_IS_FW_MMAP_REGION_SIZE (512 * 1024) |
| #define FIMC_IS_FW_DEBUG_REGION_ADDR 0x84B000 |
| #define LOGD_IS(...) ((void)ALOG(LOG_DEBUG, "IS_FW_DEBUG", __VA_ARGS__)) |
| #endif |
| |
| #define SPARE_SIZE (EXYNOS_CAMERA_META_PLANE_SIZE) |
| #define SPARE_PLANE (1) |
| |
| #define FD_SERVICE_CAMERA_ID 2 |
| |
| #define DUMP_FIRST_PREVIEW_FRAME |
| |
| #define USE_USERPTR |
| #define USE_CAPTURE_MODE |
| //#define USE_VIDIOC_ENUM_FORMAT |
| //#define USE_VIDIOC_QUERY_CAP |
| #define NUM_FLITE_BUF_PLANE (1) |
| #define FLITE_BUF_CNT (8) |
| #define PREVIEW_BUF_CNT (8) |
| #define REC_BUF_CNT (8) |
| #define REC_PLANE_CNT (2) |
| #define SKIP_CAPTURE_CNT (1) |
| #define NUM_OF_DETECTED_FACES (16) |
| |
| #define NUM_OF_AE_WINDOW_ROW (17) |
| #define NUM_OF_AE_WINDOW_COLUMN (13) |
| #define SIZE_OF_AE_WINDOW_ROW (1) |
| #define SIZE_OF_AE_WINDOW_COLUMN (1) |
| |
| #define APPLY_ESD |
| #if !defined(LOG_NFPS) || LOG_NFPS |
| #define LOG_FPS(...) ((void)0) |
| #else |
| #define LOG_FPS(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) |
| #endif |
| |
| #if !defined(LOG_NPERFORMANCE) || LOG_NPERFORMANCE |
| #define LOG_PERFORMANCE_START(n) ((void)0) |
| #define LOG_PERFORMANCE_END(n, tag) ((void)0) |
| #else |
| #define LOG_PERFORMANCE_START(n) \ |
| struct timeval time_start_##n, time_stop_##n; \ |
| gettimeofday(&time_start_##n, NULL) |
| |
| #define LOG_PERFORMANCE_END(n, tag) \ |
| gettimeofday(&time_stop_##n, NULL); \ |
| ALOGD("%s: %s %ld us", __FUNCTION__, tag, \ |
| (time_stop_##n.tv_sec * 1000000 + time_stop_##n.tv_usec) \ |
| - (time_start_##n.tv_sec * 1000000 + time_start_##n.tv_usec)) |
| #endif |
| |
| #define LOG_RECORD_TRACE(fmt, ...) \ |
| if (CC_UNLIKELY(mRecordingTrace)) { \ |
| ALOGI("%s: " fmt, __FUNCTION__, ##__VA_ARGS__); \ |
| } |
| |
| #define HDR_BUF_CNT 3 |
| #define CAP_CNT_MAGIC 32 |
| |
| #define HWC_ON |
| |
| #if VENDOR_FEATURE |
| #define BURST_SHOT_SUPPORT |
| #define BURST_STRING_CB_SUPPORT |
| #define CHANGED_PREVIEW_SUPPORT |
| #define USE_CONTEXTUAL_FILE_NAME |
| #endif |
| |
| //#define ZOOM_CTRL_THREAD |
| |
| //#define ALLOCATION_REC_BUF_BY_MEM_CB |
| |
| #define CLEAR(x) memset(&(x), 0, sizeof(x)) |
| |
| namespace android { |
| |
| /* cmdType in sendCommand functions */ |
| enum { |
| CAMERA_CMD_SET_TOUCH_AF_POSITION = 1503, // CAMERA_CMD_SET_TOUCH_AF_POSITION = 1103, |
| HAL_OBJECT_TRACKING_STARTSTOP = 1504, |
| CAMERA_CMD_START_STOP_TOUCH_AF = 1505, |
| CAMERA_CMD_SET_SAMSUNG_APP = 1508, |
| CAMERA_CMD_DISABLE_POSTVIEW = 1109, |
| CAMERA_CMD_SET_FLIP = 1510, |
| CAMERA_CMD_SET_AEAWB_LOCk = 1111, |
| RECORDING_TAKE_PICTURE = 1201, |
| |
| #ifndef FCJUNG |
| CAMERA_CMD_ISP_DEBUG = 9000, |
| CAMERA_CMD_ISP_LOG = 9001, |
| CAMERA_CMD_FACTORY_SEND_VALUE = 9002, |
| CAMERA_CMD_FACTORY_SEND_WORD_VALUE = 9003, |
| CAMERA_CMD_FACTORY_SEND_LONG_VALUE = 9004, |
| CAMERA_CMD_FACTORY_SYS_MODE = 9005, |
| #endif |
| #ifdef BURST_SHOT_SUPPORT |
| CAMERA_CMD_RUN_BURST_TAKE = 1571, |
| CAMERA_CMD_STOP_BURST_TAKE = 1572, |
| CAMERA_CMD_DELETE_BURST_TAKE = 1573, |
| CAMERA_CMD_FLUSH_ION_MEMORY = 1561, |
| #endif |
| |
| HAL_START_CONTINUOUS_AF = 1551, |
| HAL_STOP_CONTINUOUS_AF = 1552, |
| HAL_AF_LAMP_CONTROL = 1555, |
| |
| CAMERA_CMD_SMART_AUTO_S1_RELEASE = 1252, |
| CAMERA_CMD_SETZOOM = 1557, |
| |
| CAMERA_CMD_SET_AFAE_DIVISION_AE_POSITION = 1631, /* AE Position for Galaxy-Camera SF2 AF/AE Division function */ |
| CAMERA_CMD_SET_AFAE_DIVISION_WINDOW_SIZE = 1632, /* AE Window size for Galaxy-Camera SF2 AF/AE Division function */ |
| CAMERA_CMD_SET_AFAE_DIVISION_PREVIEW_TOUCH_CTRL = 1633, /* PREVIEW_TOUCH control for Galaxy-Camera SF2 AF/AE Division function */ |
| |
| CAMERA_CMD_GET_WB_CUSTOM_VALUE = 1231, |
| }; |
| |
| enum { |
| CAMERA_BURST_MEMORY_NONE= 0, |
| CAMERA_BURST_MEMORY_ION = 1, |
| CAMERA_BURST_MEMORY_HEAP = 2, |
| }; |
| |
| enum { |
| CAMERA_BURST_STOP_NONE=0, |
| CAMERA_BURST_STOP_REQ, |
| CAMERA_BURST_STOP_PROC, |
| CAMERA_BURST_STOP_END, |
| }; |
| |
| enum { |
| CAMERA_HEAP_PREVIEW = 0, |
| CAMERA_HEAP_POSTVIEW, |
| }; |
| |
| enum { |
| PREVIEW_THREAD_NONE = 0, |
| PREVIEW_THREAD_NORMAL, |
| PREVIEW_THREAD_CHANGED, |
| }; |
| |
| typedef struct _burst_item { |
| int ix; |
| int size; |
| int type; |
| int frame_num; |
| int group; |
| |
| ion_client ion; |
| int fd; |
| |
| ExynosBuffer *buf; |
| uint8_t *virt; |
| } burst_item; |
| |
| #ifdef BURST_SHOT_SUPPORT |
| enum { |
| BURST_ATTRIB_WRITE_STOP = 0x1, |
| BURST_ATTRIB_NOTUSING_POSTVIEW = 0x10, |
| |
| BURST_ATTRIB_BURST_MODE = 0x01000000, |
| BURST_ATTRIB_BEST_MODE = 0x02000000, |
| BURST_ATTRIB_IMAGE_CB_MODE = 0x10000000, |
| BURST_ATTRIB_STRING_CB_MODE = 0x20000000, |
| }; |
| #endif |
| |
| /* Structure for Focus Area */ |
| typedef struct FocusArea { |
| int top; |
| int left; |
| int bottom; |
| int right; |
| int weight; |
| } FocusArea; |
| |
| typedef struct FocusPoint { |
| int x; |
| int y; |
| } FocusPoint; |
| |
| typedef struct node_info { |
| int fd; |
| int width; |
| int height; |
| int format; |
| int planes; |
| int buffers; |
| enum v4l2_memory memory; |
| enum v4l2_buf_type type; |
| ion_client ionClient; |
| ExynosBuffer buffer[VIDEO_MAX_FRAME]; |
| bool flagStart; |
| } node_info_t; |
| |
| /* for recording */ |
| typedef struct rec_src_buf { |
| ExynosBuffer *buf; |
| nsecs_t timestamp; |
| } rec_src_buf_t; |
| |
| /* for MC */ |
| enum { |
| CAMERA_EXT_PREVIEW, |
| CAMERA_EXT_CAPTURE_YUV, |
| CAMERA_EXT_CAPTURE_JPEG |
| }; |
| |
| struct addrs { |
| /* make sure that this is 4 byte. */ |
| uint32_t type; |
| unsigned int fd_y; |
| unsigned int fd_cbcr; |
| unsigned int buf_index; |
| unsigned int reserved; |
| }; |
| |
| struct addrs_cap { |
| unsigned int addr_y; |
| unsigned int width; |
| unsigned int height; |
| }; |
| |
| class ISecCameraHardware : public virtual RefBase { |
| public: |
| virtual status_t setPreviewWindow(preview_stream_ops *w); |
| |
| virtual void setCallbacks(camera_notify_callback notify_cb, |
| camera_data_callback data_cb, |
| camera_data_timestamp_callback data_cb_timestamp, |
| camera_request_memory get_memory, |
| void* user) { |
| Mutex::Autolock lock(mLock); |
| mNotifyCb = notify_cb; |
| mDataCb = data_cb; |
| mDataCbTimestamp = data_cb_timestamp; |
| mGetMemoryCb = get_memory; |
| mCallbackCookie = user; |
| } |
| |
| virtual void enableMsgType(int32_t msgType) { |
| /* ALOGV("%s: msg=0x%X, ++msg=0x%X", __FUNCTION__, mMsgEnabled, msgType); */ |
| Mutex::Autolock lock(mLock); |
| mMsgEnabled |= msgType; |
| } |
| virtual void disableMsgType(int32_t msgType) { |
| /* ALOGV("%s: msg=0x%X, --msg=0x%X", __FUNCTION__, mMsgEnabled, msgType); */ |
| Mutex::Autolock lock(mLock); |
| #ifdef DEBUG_PREVIEW_CALLBACK |
| if (msgType & CAMERA_MSG_PREVIEW_FRAME) { |
| if (true == mPreviewCbStarted) { |
| ALOGD("disable ongoing preview callbacks"); |
| } |
| mPreviewCbStarted = false; |
| } |
| #endif |
| mMsgEnabled &= ~msgType; |
| } |
| virtual bool msgTypeEnabled(int32_t msgType) { |
| Mutex::Autolock lock(mLock); |
| return (mMsgEnabled & msgType); |
| } |
| |
| /* Preview */ |
| virtual status_t startPreview(); |
| virtual void stopPreview(); |
| virtual bool previewEnabled() { |
| Mutex::Autolock lock(mLock); |
| return mPreviewRunning; |
| } |
| |
| virtual status_t storeMetaDataInBuffers (bool enable); |
| |
| /* Recording */ |
| virtual status_t startRecording(); |
| virtual void stopRecording(); |
| virtual bool recordingEnabled() { |
| Mutex::Autolock lock(mLock); |
| return mRecordingRunning; |
| } |
| |
| virtual void releaseRecordingFrame(const void *opaque); |
| |
| /* Auto Focus*/ |
| virtual status_t autoFocus(); |
| virtual status_t cancelAutoFocus(); |
| |
| /* Picture */ |
| virtual status_t takePicture(); |
| virtual status_t cancelPicture(); |
| |
| /* Raw Capture */ |
| virtual status_t pictureThread_RAW(); |
| |
| virtual status_t Factory_pictureThread_Resolution(); |
| |
| /* Parameter */ |
| virtual status_t setParameters(const CameraParameters& params); |
| virtual CameraParameters getParameters() const { |
| Mutex::Autolock lock(mLock); |
| return mParameters; |
| } |
| virtual status_t sendCommand(int32_t command, int32_t arg1, int32_t arg2); |
| |
| virtual void release(); |
| virtual status_t dump(int fd) const; |
| virtual int getCameraId() const; |
| void Fimc_stream_true_part2(); |
| bool IsSamsungApp() { return mSamsungApp; }; |
| |
| protected: |
| int mCameraId; |
| CameraParameters mParameters; |
| |
| bool mFlagANWindowRegister; |
| bool mPreviewInitialized; |
| #ifdef DEBUG_PREVIEW_CALLBACK |
| bool mPreviewCbStarted; /* for debugging */ |
| #endif |
| |
| camera_memory_t *mPreviewHeap; |
| int mPreviewHeapFd; |
| camera_memory_t *mPostviewHeap; |
| int mPostviewHeapFd; |
| camera_memory_t *mPostviewHeapTmp; |
| int mPostviewHeapTmpFd; |
| |
| camera_memory_t *mRawHeap; |
| camera_memory_t *mRecordingHeap; |
| int mRecordHeapFd; |
| camera_memory_t *mJpegHeap; |
| ExynosBuffer mPictureBuf; |
| ExynosBuffer mPictureBufDummy[SKIP_CAPTURE_CNT]; |
| camera_frame_metadata_t mFrameMetadata; |
| camera_face_t mFaces[NUM_OF_DETECTED_FACES]; |
| int mJpegHeapFd; |
| int mRawHeapFd; |
| int mHDRHeapFd; |
| |
| #if FRONT_ZSL |
| camera_memory_t *mFullPreviewHeap; |
| int mZSLindex; |
| sp<MemoryHeapBase> rawImageMem; |
| #endif |
| bool mFullPreviewRunning; /* for FRONT_ZSL */ |
| |
| uint32_t mPreviewFrameSize; |
| uint32_t mRecordingFrameSize; |
| uint32_t mRawFrameSize; |
| uint32_t mPostviewFrameSize; |
| uint32_t mPictureFrameSize; |
| uint32_t mRawThumbnailSize; |
| #ifdef RECORDING_CAPTURE |
| uint32_t mRecordingPictureFrameSize; |
| uint32_t mPreviewFrameOffset; |
| #endif |
| #if FRONT_ZSL |
| uint32_t mFullPreviewFrameSize; |
| #endif |
| camera_memory_t *mHDRHeap; |
| #ifndef RCJUNG |
| camera_memory_t *mYUVHeap; |
| #endif |
| uint32_t mHDRFrameSize; |
| |
| image_rect_type mPreviewSize; |
| image_rect_type mOrgPreviewSize; |
| image_rect_type mPreviewWindowSize; |
| image_rect_type mRawSize; |
| image_rect_type mPictureSize; |
| image_rect_type mThumbnailSize; |
| image_rect_type mVideoSize; |
| image_rect_type mSensorSize; |
| image_rect_type mFLiteSize; /* for FLite */ |
| image_rect_type mFLiteCaptureSize; /* for FLite during capture */ |
| image_rect_type mPostviewSize; |
| |
| #ifndef FCJUNG |
| uint32_t mFactoryTestNum; |
| uint32_t mFactoryNumCnt; |
| uint32_t mBFactoryStopSmartThread; |
| |
| factory_punt_range_data_sturct mFactoryPuntRangeData; |
| factory_vib_range_data_struct mFactoryVibRangeData; |
| factory_gyro_range_data_struct mFactoryGyroRangeData; |
| factory_OIS_range_data_sturct mFactoryOISRangeData; |
| factory_AFLED_range_data_sturct mFactoryAFLEDRangeData; |
| factory_WB_range_data_sturct mFactoryWBRangeData; |
| |
| factory_Min_Max_range_sturct mFactoryZoomRangeCheckData; |
| factory_Min_Max_range_sturct mFactoryZoomSlopeCheckData; |
| factory_Min_Max_range_sturct mFactoryAFScanLimit; |
| factory_Min_Max_range_sturct mFactoryAFScanRange; |
| factory_Min_Max_range_sturct mFactoryIRISRange; |
| factory_Min_Max_range_sturct mFactoryGainLiveViewRange; |
| factory_Min_Max_range_sturct mFactoryCaptureGainRange; |
| factory_Min_Max_range_sturct mFactoryAFDiffCheck; |
| factory_Min_Max_range_sturct mFactoryAFLEDlvlimit; |
| factory_Min_Max_range_sturct mFactoryTiltScanLimitData; |
| factory_Min_Max_range_sturct mFactoryTiltAFRangeData; |
| factory_Min_Max_range_sturct mFactoryTiltDiffRangeData; |
| factory_Min_Max_range_sturct mFactoryIRCheckRGainData; |
| factory_Min_Max_range_sturct mFactoryIRCheckBGainData; |
| |
| factory_xy_range_sturct mFactoryShCloseSpeedTime; |
| factory_xy_range_sturct mFactoryFlashRange; |
| int mFactorySysMode; |
| |
| int mFactoryExifFnum; |
| int mFactoryExifShutterSpeed; |
| int mFactoryExifISO; |
| #endif |
| |
| factory_xy_range_sturct mWBcustomValue; |
| |
| cam_pixel_format mPreviewFormat; |
| cam_pixel_format mPictureFormat; |
| cam_pixel_format mFliteFormat; |
| |
| int mJpegQuality; |
| int mFrameRate; |
| int mFps; |
| int mMirror; |
| cam_scene_mode mSceneMode; |
| cam_flash_mode mFlashMode; |
| cam_focus_mode mFocusMode; |
| cam_focus_area mFocusArea; |
| int mFocusRange; |
| int mFirmwareResult; |
| cam_fw_mode mFirmwareMode; |
| cam_vt_mode mVtMode; |
| bool mMovieMode; |
| #ifdef DEBUG_PREVIEW_NO_FRAME |
| bool mFactoryMode; |
| #endif |
| bool mDtpMode; |
| bool mZoomSupport; |
| bool mEnableDZoom; |
| bool mFastCaptureSupport; |
| |
| bool mNeedSizeChange; |
| bool mFastCaptureCalled; |
| |
| bool mDualCapture; |
| int mMultiFullCaptureNum; |
| |
| int mPASMMode; |
| int mCaptureMode; |
| int mFirstStart; |
| int mTimerSet; |
| int mExifFnum; |
| int mExifShutterSpeed; |
| int mExifLightSource; |
| int mWeather; |
| long long int mCityId; |
| |
| int mZoomParamSet; |
| int mZoomSetVal; |
| int mZoomActionMethod; |
| int mZoomCurrLevel; |
| int mZoomStatus; |
| int mZoomStatusBak; |
| int mLensStatus; |
| int mLensChecked; |
| |
| bool mCameraPower; |
| #ifdef APPLY_ESD |
| bool isResetedByESD; |
| #endif |
| |
| char mAntiBanding[10]; |
| ion_client mIonCameraClient; |
| #ifdef ZOOM_CTRL_THREAD |
| int zoom_cmd; |
| int old_zoom_cmd; |
| #endif |
| ISecCameraHardware(int cameraId, camera_device_t *dev); |
| virtual ~ISecCameraHardware(); |
| |
| bool initialized(sp<MemoryHeapBase> heap) const { |
| return heap != NULL && heap->base() != MAP_FAILED; |
| } |
| |
| virtual bool init(); |
| virtual void initDefaultParameters(); |
| |
| virtual status_t nativeSetParameters(cam_control_id id, int value, bool recordingMode = false) = 0; |
| virtual status_t nativeGetParameters(cam_control_id id, int *value, bool recordingMode = false) = 0; |
| virtual status_t nativeGetNotiParameters(cam_control_id, int *read_val) = 0; |
| |
| #ifndef FCJUNG |
| virtual status_t nativeGetExtParameters(cam_control_id id, char *value, int size, bool recordingMode = false) = 0; |
| virtual status_t nativeSetExtParameters(cam_control_id id, char *value, int size, bool recordingMode = false) = 0; |
| #endif |
| |
| #if defined(SEC_USES_TVOUT) && defined(SUSPEND_ENABLE) |
| virtual void nativeTvoutSuspendCall() = 0; |
| #endif |
| |
| virtual image_rect_type nativeGetWindowSize() = 0; |
| |
| virtual status_t nativeStartPreview() = 0; |
| virtual status_t nativeStartPreviewZoom() = 0; |
| virtual int nativeGetPreview() = 0; |
| virtual int nativeReleasePreviewFrame(int index) = 0; |
| virtual void nativeStopPreview() = 0; |
| #if FRONT_ZSL |
| virtual status_t nativeStartFullPreview() = 0; |
| virtual int nativeGetFullPreview() = 0; |
| virtual int nativeReleaseFullPreviewFrame(int index) = 0; |
| virtual void nativeStopFullPreview() = 0; |
| virtual void nativeForceStopFullPreview() = 0; |
| #endif |
| |
| #ifndef FCJUNG |
| virtual int nativeGetFactoryOISDecenter() = 0; |
| |
| virtual int nativeGetFactoryDownResult() = 0; |
| virtual int nativeGetFactoryEndResult() = 0; |
| virtual int nativeGetFactoryIspFwVerData() = 0; |
| virtual int nativeGetFactoryOisVerData() = 0; |
| virtual int nativeGetFactoryAFIntResult() = 0; |
| virtual int nativeGetFactoryFlashCharge() = 0; |
| #endif |
| |
| #if IS_FW_DEBUG |
| virtual int nativeGetDebugAddr(unsigned int *vaddr) = 0; |
| virtual void dump_is_fw_log(const char *fname, uint8_t *buf, uint32_t size) = 0; |
| virtual void printDebugFirmware(); |
| #endif |
| virtual status_t nativeSetZoomRatio(int value) = 0; |
| virtual status_t nativePreviewCallback(int index, ExynosBuffer *grallocBuf) = 0; |
| virtual status_t nativeCSCPreview(int index, int type) = 0; |
| virtual status_t nativeStartRecording() = 0; |
| virtual status_t nativeCSCRecording(rec_src_buf_t *srcBuf, int dstIndex) = 0; |
| virtual status_t nativeStartRecordingZoom() = 0; |
| virtual void nativeStopRecording() = 0; |
| |
| virtual bool nativeGetRecordingJpeg(ExynosBuffer *yuvBuf, uint32_t width, uint32_t height) = 0; |
| |
| virtual bool nativeSetAutoFocus() = 0; |
| virtual int nativeGetPreAutoFocus() = 0; |
| virtual int nativeGetAutoFocus() = 0; |
| virtual status_t nativeCancelAutoFocus() = 0; |
| |
| #ifdef BURST_SHOT_SUPPORT |
| virtual bool nativeSaveJpegPicture(const char *fname, burst_item* item) = 0; |
| #endif |
| virtual bool nativePrepareYUVSnapshot() = 0; |
| virtual bool nativeStartYUVSnapshot() = 0; |
| virtual bool nativeGetYUVSnapshot(int numF, int *postviewOffset) = 0; |
| #ifndef RCJUNG |
| virtual bool nativeDumpYUV() = 0; |
| virtual bool nativeGetSnapshotMainSeq(uint32_t mode, int numf) = 0; |
| virtual bool nativeGetOneYUVSnapshot() = 0; |
| #endif |
| virtual bool nativeStartSnapshot() = 0; |
| #ifndef FCJUNG |
| virtual int nativeSetStream(bool flag) = 0; |
| #endif |
| virtual bool nativeStartPostview() = 0; |
| virtual void nativeMakeJpegDump() = 0; |
| virtual bool nativeGetSnapshot(int numF, int *postviewOffset) = 0; |
| virtual bool nativeGetPostview(int numF) = 0; |
| virtual void nativeStopSnapshot() = 0; |
| virtual bool nativeStartDualCapture(int numF) = 0; |
| virtual status_t nativeCSCCapture(ExynosBuffer *srcBuf, ExynosBuffer *dstBuf) = 0; |
| virtual status_t nativeCSCRecordingCapture(ExynosBuffer *srcBuf, ExynosBuffer *dstBuf) = 0; |
| |
| virtual int nativegetWBcustomX() = 0; |
| virtual int nativegetWBcustomY() = 0; |
| |
| |
| #ifndef FCJUNG |
| virtual int nativeSetFactoryTestNum(uint32_t mFactoryTestNum) = 0; |
| |
| // ISP Debug Code start |
| int intpow(int n,int m); |
| int find_seperator(char *buf, int size); |
| int CharToByte(char *buf, int size); |
| int CharToNumber(char *buf, int size); |
| void upper(char *buf, int size); |
| |
| bool ISP_DBG_ouput_state(char* state); |
| bool ISP_DBG_input(void); |
| bool ISP_DBG_proc(char *buffer, int size); |
| bool ISP_DBG_ouput(char *buffer, int size); |
| bool ISP_DBG_logwrite(void); |
| // ISP Debug Code end |
| #endif |
| |
| virtual int nativeSetFastCapture(bool onOff) = 0; |
| |
| virtual bool nativeCreateSurface(uint32_t width, uint32_t height, uint32_t halPixelFormat) = 0; |
| virtual bool nativeDestroySurface(void) = 0; |
| virtual bool nativeFlushSurfaceYUV420(uint32_t width, uint32_t height, uint32_t size, uint32_t index, int type = CAMERA_HEAP_POSTVIEW) = 0; |
| virtual bool nativeFlushSurface(uint32_t width, uint32_t height, uint32_t size, uint32_t index, int type=CAMERA_HEAP_PREVIEW) = 0; |
| virtual bool beautyLiveFlushSurface(uint32_t width, uint32_t height, uint32_t size, uint32_t index, int type=CAMERA_HEAP_PREVIEW) = 0; |
| |
| virtual bool nativeIsInternalISP() { return false; }; |
| |
| #ifdef RECORDING_CAPTURE |
| virtual bool conversion420to422(uint8_t *src, uint8_t *dest, int width, int height) = 0; |
| virtual bool conversion420Tto422(uint8_t *src, uint8_t *dest, int width, int height) = 0; |
| #endif |
| |
| virtual int dumpToFile(void *buf, uint32_t size, char *filePath) { |
| FILE *fd = NULL; |
| fd = fopen(filePath, "wb"); |
| if (!fd) { |
| ALOGE("dumpToFile: error, fail to open %s", filePath); |
| return -1; |
| } |
| size_t nwrite = fwrite(buf, sizeof(char), size, fd); |
| fclose(fd); |
| ALOGD("dumped: %s (size=%dbytes)", filePath, nwrite); |
| |
| return 0; |
| } |
| |
| public: |
| #ifdef BURST_SHOT_SUPPORT |
| bool mBurstWriteRunning; |
| int mBurstSoundMaxCount; |
| int mBurstSoundCount; |
| int mBurstStopReq; |
| bool mEnableStrCb; |
| |
| class BurstShot { |
| public: |
| BurstShot(); |
| virtual ~BurstShot(); |
| |
| private: |
| mutable Mutex mBurstLock; |
| bool mInitialize; |
| char mPath[128]; |
| |
| int mLimitByte; |
| int mUsedByte; |
| int mTotalIndex; |
| |
| int mCountMax; |
| int mHead; |
| int mTail; |
| int mAttrib; |
| int mRandNum; |
| |
| static const int MAX_BURST_COUNT= 512; |
| burst_item mItem[MAX_BURST_COUNT]; |
| burst_item mJpegION; |
| #ifdef USE_CONTEXTUAL_FILE_NAME |
| char mContextualFilename[128]; |
| bool mContextualstate; |
| #endif |
| |
| public: |
| bool init(); |
| void release(); |
| |
| char* getPath() { return mPath; } |
| void setPath(char *p) { strncpy(mPath, p, sizeof(mPath)-1); } |
| void getFileName(char* buffer, int i, int group_num); |
| |
| int getCountMax() { return mCountMax; } |
| void setCountMax(int i) { mCountMax=i; } |
| int getIndexHead() { return mHead; } |
| int getIndexTail() { return mTail; } |
| |
| int getAttrib() { return mAttrib; } |
| int getMode() { return mAttrib & 0xFF000000; } |
| void setAttrib(int a) { mAttrib = a; } |
| uint8_t* getAddress(burst_item* item); |
| |
| //int getRandNum() { return mRandNum; } |
| //void setRandNum(int r) { mRandNum=r; } |
| |
| bool isEmpty(); |
| bool isLimit(int size=7000000); |
| bool isStartLimit(); |
| bool isInit(void) { return mInitialize; } |
| |
| uint8_t* malloc(int size, bool cached=true); |
| bool free(burst_item *item); |
| |
| bool push(int cnt); |
| bool pop(burst_item *item); |
| |
| void DumpState(void); |
| #ifdef USE_CONTEXTUAL_FILE_NAME |
| char* getContextualFileName(void); |
| void setContextualFileName(char* strName); |
| void freeContextualFileName() { memset(mContextualFilename, 0, 128);} |
| bool getContextualState() { return mContextualstate;} |
| void setContextualState(bool val) { mContextualstate = val;} |
| #endif |
| bool allocMemBurst(ion_client ionClient, ExynosBuffer *buf, int index, bool flagCache = true); |
| void freeMemBurst(ExynosBuffer *buf, int index); |
| }; |
| BurstShot mBurstShot; |
| #endif |
| |
| private: |
| typedef bool (ISecCameraHardware::*thread_loop)(void); |
| class CameraThread : public Thread { |
| ISecCameraHardware *mHardware; |
| thread_loop mThreadLoop; |
| char mName[32]; |
| #ifdef DEBUG_THREAD_EXIT_WAIT |
| pid_t threadId; |
| #endif |
| bool mExitRequested; |
| struct timeval mTimeStart; |
| struct timeval mTimeStop; |
| public: |
| CameraThread(ISecCameraHardware *hw, thread_loop loop, const char *name = "camera:unamed_thread") : |
| #ifdef SINGLE_PROCESS |
| /* In single process mode this thread needs to be a java thread, |
| since we won't be calling through the binder. |
| */ |
| Thread(true), |
| #else |
| Thread(false), |
| #endif |
| mHardware(hw), |
| mThreadLoop(loop), |
| #ifdef DEBUG_THREAD_EXIT_WAIT |
| threadId(-1), |
| #endif |
| mExitRequested(false) { |
| memset(&mTimeStart, 0, sizeof(mTimeStart)); |
| memset(&mTimeStop, 0, sizeof(mTimeStop)); |
| CLEAR(mName); |
| if (name) |
| strncpy(mName, name, sizeof(mName) - 1); |
| } |
| |
| virtual status_t run(const char *name = 0, |
| int32_t priority = PRIORITY_DEFAULT, |
| size_t stack = 0) { |
| memset(&mTimeStart, 0, sizeof(mTimeStart)); |
| memset(&mTimeStop, 0, sizeof(mTimeStop)); |
| mExitRequested = false; |
| |
| status_t err = Thread::run(mName, priority, stack); |
| if (CC_UNLIKELY(err)) { |
| mExitRequested = true; |
| } |
| #if defined(DEBUG_THREAD_EXIT_WAIT) && defined(HAVE_ANDROID_OS) |
| else { |
| threadId = getTid(); |
| ALOGV("Thread started (%s %d)", mName, threadId); |
| } |
| #endif |
| |
| return err; |
| } |
| |
| virtual void requestExit() { |
| mExitRequested = true; |
| Thread::requestExit(); |
| } |
| |
| status_t requestExitAndWait() { |
| #if defined(DEBUG_THREAD_EXIT_WAIT) && defined(HAVE_ANDROID_OS) |
| const int waitSliceTime = 5; /* 5ms */ |
| int timeOutMsec = 200; /* 200ms */ |
| |
| if (timeOutMsec < waitSliceTime) |
| timeOutMsec = waitSliceTime; |
| |
| int waitCnt = timeOutMsec / waitSliceTime; |
| if (timeOutMsec % waitSliceTime) |
| waitCnt++; |
| |
| requestExit(); |
| ALOGD("request thread exit (%s)", mName); |
| |
| pid_t tid = -1; |
| int cnt; |
| |
| for (cnt = 0; cnt <= waitCnt; cnt++) { |
| tid = getTid(); |
| if (-1 == tid) |
| break; |
| |
| if (!((cnt + 1) % 4)) { |
| ALOGV("wait for thread to be finished (%s). %d %d (%d)", mName, threadId, tid, cnt + 1); |
| } |
| usleep(waitSliceTime * 1000); |
| } |
| |
| if (-1 == tid) |
| ALOGD("thread exit %s (%s)", !cnt ? "already" : "", mName); |
| else |
| ALOGD("request thread exit again, blocked (%s)", mName); |
| #else |
| mExitRequested = true; |
| #endif |
| return Thread::requestExitAndWait(); |
| } |
| |
| bool exitRequested() { |
| return mExitRequested; |
| } |
| void calcFrameWaitTime(int maxFps) { |
| /* Calculate how long to wait between frames */ |
| if (mTimeStart.tv_sec == 0 && mTimeStart.tv_usec == 0) { |
| gettimeofday(&mTimeStart, NULL); |
| } else { |
| gettimeofday(&mTimeStop, NULL); |
| unsigned long timeUs = (mTimeStop.tv_sec * 1000000 + mTimeStop.tv_usec) |
| - (mTimeStart.tv_sec*1000000 + mTimeStart.tv_usec); |
| gettimeofday(&mTimeStart, NULL); |
| unsigned long framerateUs = 1000.0 / maxFps * 1000000; |
| unsigned long delay = framerateUs > timeUs ? framerateUs - timeUs : 0; |
| LOG_FPS("%s: time %ld us, delay %ld us", mName, timeUs, delay); |
| usleep(delay); |
| } |
| } |
| |
| private: |
| virtual bool threadLoop() { |
| /* loop until we need to quit */ |
| return (mHardware->*mThreadLoop)(); |
| } |
| }; |
| |
| #if IS_FW_DEBUG |
| #if IS_FW_DEBUG_THREAD |
| class DebugThread : public Thread { |
| ISecCameraHardware *mHardware; |
| public: |
| DebugThread(ISecCameraHardware *hw): |
| Thread(false), |
| mHardware(hw) { } |
| virtual bool threadLoop() { |
| return mHardware->debugThread(); |
| } |
| }; |
| |
| sp<DebugThread> mDebugThread; |
| bool debugThread(); |
| #endif |
| |
| protected: |
| int mPrevOffset; |
| int mCurrOffset; |
| int mPrevWp; |
| int mCurrWp; |
| |
| unsigned int mDebugVaddr; |
| bool mPrintDebugEnabled; |
| |
| private: |
| #if IS_FW_DEBUG_THREAD |
| bool mStopDebugging; |
| mutable Mutex mDebugLock; |
| mutable Condition mDebugCondition; |
| #endif |
| |
| struct is_debug_control { |
| unsigned int write_point; /* 0 ~ 500KB boundary */ |
| unsigned int assert_flag; /* 0: Not invoked, 1: Invoked */ |
| unsigned int pabort_flag; /* 0: Not invoked, 1: Invoked */ |
| unsigned int dabort_flag; /* 0: Not invoked, 1: Invoked */ |
| }; |
| struct is_debug_control mIs_debug_ctrl; |
| #endif |
| |
| mutable Mutex mLock; |
| mutable Mutex mPictureLock; |
| mutable Mutex mBurstThreadLock; |
| |
| mutable Mutex mAutoFocusLock; |
| mutable Condition mAutoFocusCondition; |
| bool mAutoFocusExit; |
| |
| mutable Mutex mBurstShotLock; |
| mutable Condition mBurstShotCondition; |
| bool mBurstShotExit; |
| |
| bool mPreviewRunning; |
| int mPreviewThreadType; |
| bool mRecordingRunning; |
| bool mAutoFocusRunning; |
| bool mSelfShotFDReading; |
| bool mPictureRunning; |
| bool mRecordingTrace; |
| bool mPictureStart; |
| bool mCaptureStarted; |
| bool mCancelCapture; |
| |
| int roi_x_pos; |
| int roi_y_pos; |
| int roi_width; |
| int roi_height; |
| |
| /* protected by mLock */ |
| sp<CameraThread> mPreviewThread; |
| sp<CameraThread> mRecordingThread; |
| sp<CameraThread> mAutoFocusThread; |
| sp<CameraThread> mPictureThread; |
| |
| #ifdef BURST_SHOT_SUPPORT |
| sp<CameraThread> mBurstPictureThread; |
| sp<CameraThread> mBurstWriteThread; |
| #endif |
| sp<CameraThread> mHDRPictureThread; |
| sp<CameraThread> mAEBPictureThread; |
| sp<CameraThread> mBlinkPictureThread; |
| sp<CameraThread> mRecordingPictureThread; |
| sp<CameraThread> mDumpPictureThread; |
| |
| #if FRONT_ZSL |
| sp<CameraThread> mZSLPictureThread; |
| #endif |
| sp<CameraThread> mZoomCtrlThread; |
| sp<CameraThread> mSmartThread; |
| |
| /* Thread for zoom */ |
| sp<CameraThread> mPostRecordThread; |
| sp<CameraThread> mPreviewZoomThread; |
| #ifdef CHANGED_PREVIEW_SUPPORT |
| sp<CameraThread> mChangedPreviewThread; |
| #endif |
| |
| sp<CameraThread> mShutterThread; |
| |
| protected: |
| int32_t mMsgEnabled; |
| camera_request_memory mGetMemoryCb; |
| preview_stream_ops *mPreviewWindow; |
| camera_notify_callback mNotifyCb; |
| camera_data_callback mDataCb; |
| camera_data_timestamp_callback mDataCbTimestamp; |
| void *mCallbackCookie; |
| node_info_t mFliteNode; |
| |
| /* for recording */ |
| mutable Mutex mRecordSrcLock; |
| List<rec_src_buf_t*> mRecordSrcQ; |
| int mRecordSrcIndex; |
| rec_src_buf_t mRecordSrcSlot[FLITE_BUF_CNT]; |
| mutable Mutex mRecordDstLock; |
| int mRecordDstIndex; |
| camera_memory_t *mRecordDstHeap[REC_BUF_CNT][REC_PLANE_CNT]; |
| ExynosBuffer mRecordingDstBuf[REC_BUF_CNT]; |
| int mRecordDstHeapFd[REC_BUF_CNT][REC_PLANE_CNT]; |
| bool mRecordFrameAvailable[REC_BUF_CNT]; |
| int mRecordFrameAvailableCnt; |
| |
| /* Focus Areas values */ |
| static const ssize_t FOCUS_AREA_TOP = -1000; |
| static const ssize_t FOCUS_AREA_LEFT = -1000; |
| static const ssize_t FOCUS_AREA_BOTTOM = 1000; |
| static const ssize_t FOCUS_AREA_RIGHT = 1000; |
| static const ssize_t FOCUS_AREA_WEIGHT_MIN = 1; |
| static const ssize_t FOCUS_AREA_WEIGHT_MAX = 1000; |
| bool allocMemSinglePlane(ion_client ionClient, ExynosBuffer *buf, int index, bool flagCache = true); |
| void freeMemSinglePlane(ExynosBuffer *buf, int index); |
| bool allocMem(ion_client ionClient, ExynosBuffer *buf, int cacheIndex = 0xff); |
| void freeMem(ExynosBuffer *buf); |
| |
| /* for recording */ |
| void mInitRecSrcQ(void); |
| void mInitRecDstBuf(void); |
| int getRecSrcBufSlotIndex(void); |
| void mPushRecSrcQ(rec_src_buf_t *buf); |
| bool mPopRecSrcQ(rec_src_buf_t *buf); |
| int mSizeOfRecSrcQ(void); |
| int getRecDstBufIndex(void); |
| void setAvailDstBufIndex(int index); |
| int getAlignedYUVSize(int colorFormat, int w, int h, ExynosBuffer *buf, bool flagAndroidColorFormat = false); |
| |
| private: |
| |
| int mDropFrameCount; |
| bool mbFirst_preview_started; |
| int mMaxFrameRate; |
| |
| bool mDisablePostview; |
| int mLastIndex; |
| #ifdef DUMP_FIRST_PREVIEW_FRAME |
| int mFlagFirstFrameDump; |
| #endif |
| bool mSamsungApp; |
| int mAntibanding60Hz; |
| int mFaceDetectionStatus; |
| |
| /* for NSM Mode */ |
| bool mbGetFDinfo; |
| /* end NSM Mode */ |
| |
| void setDropFrame(int count); |
| #ifdef PX_COMMON_CAMERA |
| void setDropUnstableInitFrames(); |
| #endif |
| |
| bool autoFocusCheckAndWaitPreview() { |
| for (int i = 0; i < 50; i++) { |
| if (mPreviewInitialized) |
| return true; |
| |
| usleep(10000); /* 10ms*/ |
| } |
| |
| return false; |
| } |
| |
| status_t setAELock(const CameraParameters& params); |
| status_t setAWBLock(const CameraParameters& params); |
| status_t setFirmwareMode(const CameraParameters& params); |
| status_t setDtpMode(const CameraParameters& params); |
| status_t setVtMode(const CameraParameters& params); |
| status_t setMovieMode(const CameraParameters& params); |
| status_t setRecordingMode(const CameraParameters& params); |
| |
| status_t setPreviewSize(const CameraParameters& params); |
| status_t setPreviewFormat(const CameraParameters& params); |
| status_t setPictureSize(const CameraParameters& params); |
| status_t setPictureFormat(const CameraParameters& params); |
| status_t setThumbnailSize(const CameraParameters& params); |
| status_t setJpegThumbnailQuality(const CameraParameters& params); |
| status_t setJpegQuality(const CameraParameters& params); |
| status_t setFrameRate(const CameraParameters& params); |
| status_t setRotation(const CameraParameters& params); |
| status_t setVideoSize(const CameraParameters& params); |
| status_t setPreviewFrameRate(const CameraParameters& params); |
| |
| status_t setSceneMode(const CameraParameters& params); |
| |
| /* Focus Area start */ |
| status_t findCenter(struct FocusArea *focusArea, |
| struct FocusPoint *center); |
| status_t normalizeArea(struct FocusPoint *center); |
| status_t checkArea(ssize_t top, ssize_t left, ssize_t bottom, |
| ssize_t right, ssize_t weight); |
| status_t parseAreas(const char *area, size_t areaLength, |
| struct FocusArea *focusArea, int *num_areas); |
| status_t setFocusAreas(const CameraParameters& params); |
| /* Focus Area end */ |
| |
| status_t setCapturemode(const CameraParameters& params); |
| status_t setWeather(const CameraParameters& params); |
| status_t setCityId(const CameraParameters& params); |
| status_t setBracketAEBvalue(const CameraParameters& params); |
| status_t setIso(const CameraParameters& params); |
| status_t setBrightness(const CameraParameters& params); |
| status_t setWhiteBalance(const CameraParameters& params); |
| status_t setFlash(const CameraParameters& params); |
| status_t setMetering(const CameraParameters& params); |
| status_t setMeteringAreas(const CameraParameters& params); |
| status_t setFocusMode(const CameraParameters& params); |
| status_t setEffect(const CameraParameters& params); |
| status_t setZoom(const CameraParameters& params); |
| status_t setAutoContrast(const CameraParameters& params); |
| status_t setSharpness(const CameraParameters& params); |
| status_t setSaturation(const CameraParameters& params); |
| status_t setContrast(const CameraParameters& params); |
| status_t setColorAdjust(const CameraParameters& params); |
| status_t setAntiShake(const CameraParameters& params); |
| status_t setFaceBeauty(const CameraParameters& params); |
| status_t setBlur(const CameraParameters& params); |
| status_t setAntiBanding(); |
| status_t setAntiBanding(const CameraParameters& params); |
| #ifdef BURST_SHOT_SUPPORT |
| status_t setBurstSavePath(const CameraParameters& params); |
| #endif |
| status_t setPASMmode(const CameraParameters& params); |
| status_t setImageStabilizermode(const CameraParameters& params); |
| void chooseAntiBandingFrequency(); |
| |
| status_t setGps(const CameraParameters& params); |
| status_t setFocusAreaModes(const CameraParameters& params); |
| status_t setFaceDetection(const CameraParameters& params); |
| int getFaceDetection(void); |
| status_t setROIBox(const CameraParameters& params); |
| |
| status_t setKvalue(const CameraParameters& params); |
| |
| status_t setFNumber(const CameraParameters& params); |
| status_t setShutterSpeed(const CameraParameters& params); |
| status_t setAFLED(const CameraParameters& params); |
| status_t setTimerMode(const CameraParameters& params); |
| |
| /* for NSM Mode */ |
| status_t setNsmSystem(const CameraParameters ¶ms); |
| status_t setNsmState(const CameraParameters ¶ms); |
| |
| status_t setNsmRGB(const CameraParameters ¶ms); |
| status_t setNsmContSharp(const CameraParameters ¶ms); |
| |
| status_t setNsmHueAllRedOrange(const CameraParameters ¶ms); |
| status_t setNsmHueYellowGreenCyan(const CameraParameters ¶ms); |
| status_t setNsmHueBlueVioletPurple(const CameraParameters ¶ms); |
| status_t setNsmSatAllRedOrange(const CameraParameters ¶ms); |
| status_t setNsmSatYellowGreenCyan(const CameraParameters ¶ms); |
| status_t setNsmSatBlueVioletPurple(const CameraParameters ¶ms); |
| |
| status_t setNsmR(const CameraParameters ¶ms); |
| status_t setNsmG(const CameraParameters ¶ms); |
| status_t setNsmB(const CameraParameters ¶ms); |
| status_t setNsmGlobalContrast(const CameraParameters ¶ms); |
| status_t setNsmGlobalSharpness(const CameraParameters ¶ms); |
| |
| status_t setNsmHueAll(const CameraParameters ¶ms); |
| status_t setNsmHueRed(const CameraParameters ¶ms); |
| status_t setNsmHueOrange(const CameraParameters ¶ms); |
| status_t setNsmHueYellow(const CameraParameters ¶ms); |
| status_t setNsmHueGreen(const CameraParameters ¶ms); |
| status_t setNsmHueCyan(const CameraParameters ¶ms); |
| status_t setNsmHueBlue(const CameraParameters ¶ms); |
| status_t setNsmHueViolet(const CameraParameters ¶ms); |
| status_t setNsmHuePurple(const CameraParameters ¶ms); |
| |
| status_t setNsmSatAll(const CameraParameters ¶ms); |
| status_t setNsmSatRed(const CameraParameters ¶ms); |
| status_t setNsmSatOrange(const CameraParameters ¶ms); |
| status_t setNsmSatYellow(const CameraParameters ¶ms); |
| status_t setNsmSatGreen(const CameraParameters ¶ms); |
| status_t setNsmSatCyan(const CameraParameters ¶ms); |
| status_t setNsmSatBlue(const CameraParameters ¶ms); |
| status_t setNsmSatViolet(const CameraParameters ¶ms); |
| status_t setNsmSatPurple(const CameraParameters ¶ms); |
| /* end NSM Mode */ |
| |
| int checkFnumber(int f_val, int zoomLevel); |
| |
| #ifndef FCJUNG |
| status_t setFactoryTestNumber(const CameraParameters& params); |
| status_t setLDC(const CameraParameters& params); |
| status_t setLSC(const CameraParameters& params); |
| status_t setApertureCmd(const CameraParameters& params); |
| status_t setApertureStep(const CameraParameters& params); |
| status_t setApertureStepPreview(const CameraParameters& params); |
| status_t setApertureStepCapture(const CameraParameters& params); |
| status_t setFactoryPunt(const CameraParameters& params); |
| status_t setFactoryPuntShortScanData(const CameraParameters& params); |
| status_t setFactoryPuntLongScanData(const CameraParameters & params); |
| status_t setFactoryPuntRangeData(const CameraParameters& params); |
| status_t setFactoryPuntInterpolation(const CameraParameters & params); |
| status_t setFactoryOIS(const CameraParameters& params); |
| status_t setFactoryOISDecenter(const CameraParameters& params); |
| status_t setFactoryOISMoveShift(const CameraParameters& params); |
| status_t setFactoryOISCenteringRangeData(const CameraParameters& params); |
| status_t setFactoryZoom(const CameraParameters& params); |
| status_t setFactoryZoomStep(const CameraParameters& params); |
| status_t setFactoryZoomRangeCheckData(const CameraParameters& params); |
| status_t setFactoryZoomSlopeCheckData(const CameraParameters& params); |
| status_t setFactoryFailStop(const CameraParameters& params); |
| status_t setFactoryNoDeFocus(const CameraParameters& params); |
| status_t setFactoryInterPolation(const CameraParameters& params); |
| status_t setFactoryCommon(const CameraParameters& params); |
| status_t setFactoryVib(const CameraParameters& params); |
| status_t setFactoryVibRangeData(const CameraParameters& params); |
| status_t setFactoryGyro(const CameraParameters& params); |
| status_t setFactoryGyroRangeData(const CameraParameters& params); |
| status_t setFactoryBacklash(const CameraParameters& params); |
| status_t setFactoryBacklashCount(const CameraParameters& params); |
| status_t setFactoryBacklashMaxThreshold(const CameraParameters& params); |
| status_t setFactoryAF(const CameraParameters& params); |
| status_t setFactoryAFLens(const CameraParameters& params); |
| status_t setFactoryAFZone(const CameraParameters& params); |
| status_t setFactoryAFStepSet(const CameraParameters& params); |
| status_t setFactoryAFPosition(const CameraParameters& params); |
| status_t setFactoryDeFocus(const CameraParameters& params); |
| status_t setFactoryDeFocusWide(const CameraParameters& params); |
| status_t setFactoryDeFocusTele(const CameraParameters& params); |
| status_t setFactoryResol(const CameraParameters& params); |
| #endif |
| |
| #ifndef FCJUNG |
| status_t setFactoryLVTarget(const CameraParameters& params); |
| status_t setFactoryAdjIRIS(const CameraParameters& params); |
| status_t setFactoryLiveViewGain(const CameraParameters& params); |
| status_t setFactoryLiveViewGainOffsetSign(const CameraParameters& params); |
| status_t setFactoryLiveViewGainOffsetVal(const CameraParameters& params); |
| status_t setFactoryShClose(const CameraParameters& params); |
| status_t setFactoryShCloseIRISNum(const CameraParameters& params); |
| status_t setFactoryShCloseSetIRIS(const CameraParameters& params); |
| status_t setFactoryShCloseIso(const CameraParameters& params); |
| status_t setFactoryShCloseRange(const CameraParameters& params); |
| status_t setFactoryCaptureGain(const CameraParameters& params); |
| status_t setFactoryCaptureGainOffsetSign(const CameraParameters& params); |
| status_t setFactoryCaptureGainOffsetVal(const CameraParameters& params); |
| status_t setFactoryLscFshdTable(const CameraParameters& params); |
| status_t setFactoryLscFshdReference(const CameraParameters& params); |
| status_t setFactoryIRISRange(const CameraParameters& params); |
| status_t setFactoryGainLiveViewRange(const CameraParameters& params); |
| status_t setFactoryShCloseSpeedTime(const CameraParameters& params); |
| status_t setFactoryCameraMode(const CameraParameters& params); |
| status_t setFactoryFlash(const CameraParameters& params); |
| status_t setFactoryFlashChgChkTime(const CameraParameters& params); |
| status_t setFactoryAFScanLimit(const CameraParameters& params); |
| status_t setFactoryAFScanRange(const CameraParameters& params); |
| status_t setFactoryFlashRange(const CameraParameters& params); |
| status_t setFactoryWB(const CameraParameters& params); |
| status_t setFactoryWBRange(const CameraParameters& params); |
| status_t setFactoryFlicker(const CameraParameters& params); |
| status_t setFactoryAETarget(const CameraParameters& params); |
| status_t setFactoryAFLEDtime(const CameraParameters& params); |
| status_t setFactoryCamSysMode(const CameraParameters& params); |
| status_t setFactoryCaptureGainRange(const CameraParameters& params); |
| status_t setFactoryCaptureCtrl(const CameraParameters& params); |
| status_t setFactoryWBvalue(const CameraParameters& params); |
| status_t setFactoryAFLEDRangeData(const CameraParameters& params); |
| status_t setFactoryAFDiffCheck(const CameraParameters& params); |
| status_t setFactoryDefectNoiseLevel(const CameraParameters& params); |
| status_t setFactoryDefectPixel(const CameraParameters& params); |
| status_t setFactoryDFPXWriteADJData(const CameraParameters& params, int select); |
| status_t setFactoryDFPXNLVCAP(const CameraParameters& params); |
| status_t setFactoryDFPXNLVDR1HD(const CameraParameters& params); |
| status_t setFactoryDFPXNLVDR0(const CameraParameters& params); |
| status_t setFactoryDFPXNLVDR1(const CameraParameters& params); |
| status_t setFactoryDFPXNLVDR2(const CameraParameters& params); |
| status_t setFactoryDFPXNLVDRHS(const CameraParameters& params); |
| status_t setTurnOnOffAFLED(const CameraParameters& params); |
| status_t setFactoryAFLEDlevel(const CameraParameters& params); |
| status_t setFactoryIspFwVerCheck(const CameraParameters& params); |
| status_t setFactoryOisVerCheck(const CameraParameters& params); |
| status_t setFactoryTiltScanLimitData(const CameraParameters& params); |
| status_t setFactoryTiltAFRangeData(const CameraParameters& params); |
| status_t setFactoryTiltAFScanLimitData(const CameraParameters& params); |
| status_t setFactoryTiltDiffRangeData(const CameraParameters& params); |
| status_t setFactoryIRCheckRGainData(const CameraParameters& params); |
| status_t setFactoryIRCheckBGainData(const CameraParameters& params); |
| status_t setFactoryTiltField(const CameraParameters& params); |
| status_t setFactoryFlashManCharge(const CameraParameters& params); |
| status_t setFactoryFlashManEn(const CameraParameters& params); |
| status_t setFactoryTilt(const CameraParameters& params); |
| status_t setFactoryIRCheck(const CameraParameters& params); |
| status_t setFactoryFlashCharge(const CameraParameters& params); |
| status_t setFactoryMemCopy(const CameraParameters& params); |
| status_t setFactoryMemMode(const CameraParameters& params); |
| status_t setFactoryEEPWrite(const CameraParameters& params); |
| status_t setFactoryLensCap(const CameraParameters& params); |
| status_t setFactoryCheckSum(const CameraParameters& params); |
| status_t setFactoryLogWriteAll(const CameraParameters& params); |
| status_t setFactoryDataErase(const CameraParameters& params); |
| status_t setFactoryNoLensOff(const CameraParameters& params); |
| status_t setFactoryFocusCloseOpenCheck(const CameraParameters& params); |
| status_t setFactoryResolutionLog(const CameraParameters& params); |
| status_t setFactoryShadingLog(const CameraParameters& params); |
| status_t setFactoryTiltCoordinate(const CameraParameters& params); |
| status_t setFactoryComapareMemory(const CameraParameters& params); |
| #endif |
| |
| #ifdef BURST_SHOT_SUPPORT |
| char *getBurstSavePath(void); |
| #endif |
| |
| status_t setZoomActionMethod(const CameraParameters& params); |
| status_t setDzoom(const CameraParameters& params); |
| status_t setZoomSpeed(const CameraParameters& params); |
| status_t setOpticalZoomCtrl(const CameraParameters& params); |
| status_t setSmartZoommode(const CameraParameters& params); |
| #if defined(KOR_CAMERA) |
| status_t setSelfTestMode(const CameraParameters& params); |
| #endif |
| |
| status_t doCameraCapture(); |
| status_t doRecordingCapture(); |
| |
| bool previewThread(); |
| bool recordingThread(); |
| bool autoFocusThread(); |
| bool pictureThread(); |
| |
| #ifdef BURST_SHOT_SUPPORT |
| bool burstPictureThread_postview(int ncnt); |
| bool burstPictureThread(); |
| bool burstFrontPictureThread(); |
| bool burstWriteThread(); |
| #endif |
| bool HDRPictureThread(); |
| bool AEBPictureThread(); |
| bool BlinkPictureThread(); |
| bool RecordingPictureThread(); |
| bool dumpPictureThread(); |
| |
| #if FRONT_ZSL |
| bool zslpictureThread(); |
| #endif |
| bool ZoomCtrlThread(); |
| /* smart thread */ |
| bool smartThread(); |
| |
| bool shutterThread(); |
| |
| camera_device_t *mHalDevice; |
| |
| public: |
| int mPostRecordIndex; |
| nsecs_t mRecordTimestamp; |
| nsecs_t mLastRecordTimestamp; |
| |
| bool mPostRecordExit; |
| mutable Mutex mPostRecordLock; |
| mutable Condition mPostRecordCondition; |
| bool postRecordThread(); |
| bool previewZoomThread(); |
| #ifdef CHANGED_PREVIEW_SUPPORT |
| bool changedPreviewThread(); |
| #endif |
| }; |
| }; /* namespace android */ |
| |
| #endif /* ANDROID_HARDWARE_ISECCAMERAHARDWARE_H */ |