| /* |
| ** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved. |
| ** |
| ** 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. |
| */ |
| |
| //#define ALOG_NDEBUG 0 |
| #define ALOG_NIDEBUG 0 |
| #define LOG_TAG "QCameraHWI_Parm" |
| #include <utils/Log.h> |
| |
| #include <utils/Errors.h> |
| #include <utils/threads.h> |
| //#include <binder/MemoryHeapPmem.h> |
| #include <utils/String16.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <cutils/properties.h> |
| #include <math.h> |
| #if HAVE_ANDROID_OS |
| #include <linux/android_pmem.h> |
| #endif |
| #include <linux/ioctl.h> |
| #include "QCameraParameters.h" |
| #include <media/mediarecorder.h> |
| #include <gralloc_priv.h> |
| |
| #include "linux/msm_mdp.h" |
| #include <linux/fb.h> |
| #include <limits.h> |
| |
| extern "C" { |
| #include <fcntl.h> |
| #include <time.h> |
| #include <pthread.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <termios.h> |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <ctype.h> |
| #include <signal.h> |
| #include <errno.h> |
| #include <sys/mman.h> |
| #include <sys/system_properties.h> |
| #include <sys/time.h> |
| #include <stdlib.h> |
| #include <linux/msm_ion.h> |
| |
| } // extern "C" |
| |
| #include "QCameraHWI.h" |
| #include "QCameraStream.h" |
| |
| /* QCameraHardwareInterface class implementation goes here*/ |
| /* following code implements the parameter logic of this class*/ |
| #define EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR 12 |
| #define EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR -12 |
| #define EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR 0 |
| #define EXPOSURE_COMPENSATION_DENOMINATOR 6 |
| #define EXPOSURE_COMPENSATION_STEP ((float (1))/EXPOSURE_COMPENSATION_DENOMINATOR) |
| #define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)" |
| |
| #define HDR_HAL_FRAME 2 |
| |
| #define BURST_INTREVAL_MIN 1 |
| #define BURST_INTREVAL_MAX 10 |
| #define BURST_INTREVAL_DEFAULT 1 |
| |
| //Default FPS |
| #define MINIMUM_FPS 5 |
| #define MAXIMUM_FPS 120 |
| #define DEFAULT_FIXED_FPS 30 |
| #define DEFAULT_FPS 30 |
| |
| //Default Picture Width |
| #define DEFAULT_PICTURE_WIDTH 640 |
| #define DEFAULT_PICTURE_HEIGHT 480 |
| |
| //Default Video Width |
| #define DEFAULT_VIDEO_WIDTH 1920 |
| #define DEFAULT_VIDEO_HEIGHT 1088 |
| |
| #define THUMBNAIL_SIZE_COUNT (sizeof(thumbnail_sizes)/sizeof(thumbnail_size_type)) |
| #define DEFAULT_THUMBNAIL_SETTING 4 |
| #define THUMBNAIL_WIDTH_STR "512" |
| #define THUMBNAIL_HEIGHT_STR "384" |
| #define THUMBNAIL_SMALL_HEIGHT 144 |
| |
| #define DONT_CARE_COORDINATE -1 |
| |
| //for histogram stats |
| #define HISTOGRAM_STATS_SIZE 257 |
| |
| //Supported preview fps ranges should be added to this array in the form (minFps,maxFps) |
| static android::FPSRange FpsRangesSupported[] = { |
| android::FPSRange(MINIMUM_FPS*1000,MAXIMUM_FPS*1000) |
| }; |
| #define FPS_RANGES_SUPPORTED_COUNT (sizeof(FpsRangesSupported)/sizeof(FpsRangesSupported[0])) |
| |
| |
| typedef struct { |
| uint32_t aspect_ratio; |
| uint32_t width; |
| uint32_t height; |
| } thumbnail_size_type; |
| |
| static thumbnail_size_type thumbnail_sizes[] = { |
| { 7281, 512, 288 }, //1.777778 |
| { 6826, 480, 288 }, //1.666667 |
| { 6808, 256, 154 }, //1.66233 |
| { 6144, 432, 288 }, //1.5 |
| { 5461, 512, 384 }, //1.333333 |
| { 5006, 352, 288 }, //1.222222 |
| { 5461, 320, 240 }, //1.33333 |
| { 5006, 176, 144 }, //1.222222 |
| |
| }; |
| |
| static struct camera_size_type zsl_picture_sizes[] = { |
| { 1280, 960}, // 1.3MP |
| { 800, 600}, //SVGA |
| { 800, 480}, // WVGA |
| { 640, 480}, // VGA |
| { 352, 288}, //CIF |
| { 320, 240}, // QVGA |
| { 176, 144} // QCIF |
| }; |
| |
| static camera_size_type default_picture_sizes[] = { |
| { 4000, 3000}, // 12MP |
| { 3264, 2448}, // 8MP |
| { 3264, 1836}, // Picture Size to match 1080p,720p AR |
| { 3264, 2176}, // Picture Size to match 480p AR |
| { 2592, 1944}, // 5MP |
| { 2048, 1536}, // 3MP QXGA |
| { 1920, 1080}, // HD1080 |
| { 1600, 1200}, // 2MP UXGA |
| { 1280, 960}, // 1.3MP |
| { 1280, 720}, |
| { 720, 480}, |
| { 800, 480}, // WVGA |
| { 640, 480}, // VGA |
| { 352, 288}, // CIF |
| { 320, 240}, // QVGA |
| { 176, 144} // QCIF |
| }; |
| |
| static int iso_speed_values[] = { |
| 0, 1, 100, 200, 400, 800, 1600 |
| }; |
| |
| extern int HAL_numOfCameras; |
| extern qcamera_info_t HAL_cameraInfo[MSM_MAX_CAMERA_SENSORS]; |
| extern mm_camera_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS]; |
| |
| namespace android { |
| |
| static uint32_t HFR_SIZE_COUNT=2; |
| static const int PICTURE_FORMAT_JPEG = 1; |
| static const int PICTURE_FORMAT_RAW = 2; |
| |
| /********************************************************************/ |
| static const str_map effects[] = { |
| { QCameraParameters::EFFECT_NONE, CAMERA_EFFECT_OFF }, |
| { QCameraParameters::EFFECT_MONO, CAMERA_EFFECT_MONO }, |
| { QCameraParameters::EFFECT_NEGATIVE, CAMERA_EFFECT_NEGATIVE }, |
| { QCameraParameters::EFFECT_SOLARIZE, CAMERA_EFFECT_SOLARIZE }, |
| { QCameraParameters::EFFECT_SEPIA, CAMERA_EFFECT_SEPIA }, |
| { QCameraParameters::EFFECT_POSTERIZE, CAMERA_EFFECT_POSTERIZE }, |
| { QCameraParameters::EFFECT_WHITEBOARD, CAMERA_EFFECT_WHITEBOARD }, |
| { QCameraParameters::EFFECT_BLACKBOARD, CAMERA_EFFECT_BLACKBOARD }, |
| { QCameraParameters::EFFECT_AQUA, CAMERA_EFFECT_AQUA }, |
| { QCameraParameters::EFFECT_EMBOSS, CAMERA_EFFECT_EMBOSS }, |
| { QCameraParameters::EFFECT_SKETCH, CAMERA_EFFECT_SKETCH }, |
| { QCameraParameters::EFFECT_NEON, CAMERA_EFFECT_NEON } |
| }; |
| |
| static const str_map iso[] = { |
| { QCameraParameters::ISO_AUTO, CAMERA_ISO_AUTO}, |
| { QCameraParameters::ISO_HJR, CAMERA_ISO_DEBLUR}, |
| { QCameraParameters::ISO_100, CAMERA_ISO_100}, |
| { QCameraParameters::ISO_200, CAMERA_ISO_200}, |
| { QCameraParameters::ISO_400, CAMERA_ISO_400}, |
| { QCameraParameters::ISO_800, CAMERA_ISO_800 }, |
| { QCameraParameters::ISO_1600, CAMERA_ISO_1600 } |
| }; |
| |
| static const str_map scenemode[] = { |
| { QCameraParameters::SCENE_MODE_AUTO, CAMERA_BESTSHOT_OFF }, |
| { QCameraParameters::SCENE_MODE_ASD, CAMERA_BESTSHOT_AUTO }, |
| { QCameraParameters::SCENE_MODE_ACTION, CAMERA_BESTSHOT_ACTION }, |
| { QCameraParameters::SCENE_MODE_PORTRAIT, CAMERA_BESTSHOT_PORTRAIT }, |
| { QCameraParameters::SCENE_MODE_LANDSCAPE, CAMERA_BESTSHOT_LANDSCAPE }, |
| { QCameraParameters::SCENE_MODE_NIGHT, CAMERA_BESTSHOT_NIGHT }, |
| { QCameraParameters::SCENE_MODE_NIGHT_PORTRAIT, CAMERA_BESTSHOT_NIGHT_PORTRAIT }, |
| { QCameraParameters::SCENE_MODE_THEATRE, CAMERA_BESTSHOT_THEATRE }, |
| { QCameraParameters::SCENE_MODE_BEACH, CAMERA_BESTSHOT_BEACH }, |
| { QCameraParameters::SCENE_MODE_SNOW, CAMERA_BESTSHOT_SNOW }, |
| { QCameraParameters::SCENE_MODE_SUNSET, CAMERA_BESTSHOT_SUNSET }, |
| { QCameraParameters::SCENE_MODE_STEADYPHOTO, CAMERA_BESTSHOT_ANTISHAKE }, |
| { QCameraParameters::SCENE_MODE_FIREWORKS , CAMERA_BESTSHOT_FIREWORKS }, |
| { QCameraParameters::SCENE_MODE_SPORTS , CAMERA_BESTSHOT_SPORTS }, |
| { QCameraParameters::SCENE_MODE_PARTY, CAMERA_BESTSHOT_PARTY }, |
| { QCameraParameters::SCENE_MODE_CANDLELIGHT, CAMERA_BESTSHOT_CANDLELIGHT }, |
| { QCameraParameters::SCENE_MODE_BACKLIGHT, CAMERA_BESTSHOT_BACKLIGHT }, |
| { QCameraParameters::SCENE_MODE_FLOWERS, CAMERA_BESTSHOT_FLOWERS }, |
| { QCameraParameters::SCENE_MODE_AR, CAMERA_BESTSHOT_AR }, |
| { QCameraParameters::SCENE_MODE_HDR, CAMERA_BESTSHOT_AUTO }, |
| }; |
| |
| static const str_map scenedetect[] = { |
| { QCameraParameters::SCENE_DETECT_OFF, false }, |
| { QCameraParameters::SCENE_DETECT_ON, true }, |
| }; |
| |
| #define DONT_CARE AF_MODE_MAX |
| static const str_map focus_modes[] = { |
| { QCameraParameters::FOCUS_MODE_AUTO, AF_MODE_AUTO}, |
| { QCameraParameters::FOCUS_MODE_INFINITY, AF_MODE_INFINITY }, |
| { QCameraParameters::FOCUS_MODE_NORMAL, AF_MODE_NORMAL }, |
| { QCameraParameters::FOCUS_MODE_MACRO, AF_MODE_MACRO }, |
| { QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE, AF_MODE_CAF}, |
| { QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO, AF_MODE_CAF } |
| }; |
| |
| static const str_map selectable_zone_af[] = { |
| { QCameraParameters::SELECTABLE_ZONE_AF_AUTO, AUTO }, |
| { QCameraParameters::SELECTABLE_ZONE_AF_SPOT_METERING, SPOT }, |
| { QCameraParameters::SELECTABLE_ZONE_AF_CENTER_WEIGHTED, CENTER_WEIGHTED }, |
| { QCameraParameters::SELECTABLE_ZONE_AF_FRAME_AVERAGE, AVERAGE } |
| }; |
| |
| static const str_map autoexposure[] = { |
| { QCameraParameters::AUTO_EXPOSURE_FRAME_AVG, CAMERA_AEC_FRAME_AVERAGE }, |
| { QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED, CAMERA_AEC_CENTER_WEIGHTED }, |
| { QCameraParameters::AUTO_EXPOSURE_SPOT_METERING, CAMERA_AEC_SPOT_METERING } |
| }; |
| |
| // from aeecamera.h |
| static const str_map whitebalance[] = { |
| { QCameraParameters::WHITE_BALANCE_AUTO, CAMERA_WB_AUTO }, |
| { QCameraParameters::WHITE_BALANCE_INCANDESCENT, CAMERA_WB_INCANDESCENT }, |
| { QCameraParameters::WHITE_BALANCE_FLUORESCENT, CAMERA_WB_FLUORESCENT }, |
| { QCameraParameters::WHITE_BALANCE_DAYLIGHT, CAMERA_WB_DAYLIGHT }, |
| { QCameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT, CAMERA_WB_CLOUDY_DAYLIGHT } |
| }; |
| |
| static const str_map antibanding[] = { |
| { QCameraParameters::ANTIBANDING_OFF, CAMERA_ANTIBANDING_OFF }, |
| { QCameraParameters::ANTIBANDING_50HZ, CAMERA_ANTIBANDING_50HZ }, |
| { QCameraParameters::ANTIBANDING_60HZ, CAMERA_ANTIBANDING_60HZ }, |
| { QCameraParameters::ANTIBANDING_AUTO, CAMERA_ANTIBANDING_AUTO } |
| }; |
| |
| static const str_map frame_rate_modes[] = { |
| {QCameraParameters::KEY_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO}, |
| {QCameraParameters::KEY_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED} |
| }; |
| |
| static const str_map touchafaec[] = { |
| { QCameraParameters::TOUCH_AF_AEC_OFF, false }, |
| { QCameraParameters::TOUCH_AF_AEC_ON, true } |
| }; |
| |
| static const str_map hfr[] = { |
| { QCameraParameters::VIDEO_HFR_OFF, CAMERA_HFR_MODE_OFF }, |
| { QCameraParameters::VIDEO_HFR_2X, CAMERA_HFR_MODE_60FPS }, |
| { QCameraParameters::VIDEO_HFR_3X, CAMERA_HFR_MODE_90FPS }, |
| { QCameraParameters::VIDEO_HFR_4X, CAMERA_HFR_MODE_120FPS }, |
| }; |
| static const int HFR_VALUES_COUNT = (sizeof(hfr)/sizeof(str_map)); |
| |
| static const str_map flash[] = { |
| { QCameraParameters::FLASH_MODE_OFF, LED_MODE_OFF }, |
| { QCameraParameters::FLASH_MODE_AUTO, LED_MODE_AUTO }, |
| { QCameraParameters::FLASH_MODE_ON, LED_MODE_ON }, |
| { QCameraParameters::FLASH_MODE_TORCH, LED_MODE_TORCH} |
| }; |
| |
| static const str_map lensshade[] = { |
| { QCameraParameters::LENSSHADE_ENABLE, true }, |
| { QCameraParameters::LENSSHADE_DISABLE, false } |
| }; |
| |
| static const str_map mce[] = { |
| { QCameraParameters::MCE_ENABLE, true }, |
| { QCameraParameters::MCE_DISABLE, false } |
| }; |
| |
| static const str_map histogram[] = { |
| { QCameraParameters::HISTOGRAM_ENABLE, true }, |
| { QCameraParameters::HISTOGRAM_DISABLE, false } |
| }; |
| |
| static const str_map skinToneEnhancement[] = { |
| { QCameraParameters::SKIN_TONE_ENHANCEMENT_ENABLE, true }, |
| { QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE, false } |
| }; |
| |
| static const str_map denoise[] = { |
| { QCameraParameters::DENOISE_OFF, false }, |
| { QCameraParameters::DENOISE_ON, true } |
| }; |
| |
| static const str_map facedetection[] = { |
| { QCameraParameters::FACE_DETECTION_OFF, false }, |
| { QCameraParameters::FACE_DETECTION_ON, true } |
| }; |
| |
| static const str_map redeye_reduction[] = { |
| { QCameraParameters::REDEYE_REDUCTION_ENABLE, true }, |
| { QCameraParameters::REDEYE_REDUCTION_DISABLE, false } |
| }; |
| |
| static const str_map picture_formats[] = { |
| {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG}, |
| {QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW} |
| }; |
| |
| static const str_map recording_Hints[] = { |
| {"false", false}, |
| {"true", true} |
| }; |
| |
| static const str_map preview_formats[] = { |
| {QCameraParameters::PIXEL_FORMAT_YUV420SP, HAL_PIXEL_FORMAT_YCrCb_420_SP}, |
| {QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO, HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO}, |
| {QCameraParameters::PIXEL_FORMAT_YV12, HAL_PIXEL_FORMAT_YV12}, |
| {QCameraParameters::PIXEL_FORMAT_YUV420P,HAL_PIXEL_FORMAT_YV12}, |
| {QCameraParameters::PIXEL_FORMAT_NV12, HAL_PIXEL_FORMAT_YCbCr_420_SP} |
| }; |
| |
| static const preview_format_info_t preview_format_info_list[] = { |
| {HAL_PIXEL_FORMAT_YCrCb_420_SP, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_WORD, 2}, |
| {HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_4K, 2}, |
| {HAL_PIXEL_FORMAT_YCbCr_420_SP, CAMERA_YUV_420_NV12, CAMERA_PAD_TO_WORD, 2}, |
| {HAL_PIXEL_FORMAT_YV12, CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3} |
| }; |
| |
| static const str_map zsl_modes[] = { |
| { QCameraParameters::ZSL_OFF, false }, |
| { QCameraParameters::ZSL_ON, true }, |
| }; |
| |
| |
| static const str_map hdr_bracket[] = { |
| { QCameraParameters::AE_BRACKET_HDR_OFF,HDR_BRACKETING_OFF}, |
| { QCameraParameters::AE_BRACKET_HDR,HDR_MODE }, |
| }; |
| |
| typedef enum { |
| NORMAL_POWER, |
| LOW_POWER |
| } power_mode; |
| |
| static const str_map power_modes[] = { |
| { QCameraParameters::NORMAL_POWER,NORMAL_POWER }, |
| { QCameraParameters::LOW_POWER,LOW_POWER } |
| }; |
| |
| /**************************************************************************/ |
| static int attr_lookup(const str_map arr[], int len, const char *name) |
| { |
| if (name) { |
| for (int i = 0; i < len; i++) { |
| if (!strcmp(arr[i].desc, name)) |
| return arr[i].val; |
| } |
| } |
| return NOT_FOUND; |
| } |
| |
| bool QCameraHardwareInterface::native_set_parms( |
| mm_camera_parm_type_t type, uint16_t length, void *value) |
| { |
| ALOGV("%s : type : %d Value : %d",__func__,type,*((int *)value)); |
| if(MM_CAMERA_OK != cam_config_set_parm(mCameraId, type,value )) { |
| ALOGE("native_set_parms failed: type %d length %d error %s", |
| type, length, strerror(errno)); |
| return false; |
| } |
| |
| return true; |
| |
| } |
| |
| bool QCameraHardwareInterface::native_set_parms( |
| mm_camera_parm_type_t type, uint16_t length, void *value, int *result) |
| { |
| *result= cam_config_set_parm(mCameraId, type,value ); |
| if(MM_CAMERA_OK == *result) { |
| ALOGV("native_set_parms: succeeded : %d", *result); |
| return true; |
| } |
| |
| ALOGE("native_set_parms failed: type %d length %d error str %s error# %d", |
| type, length, strerror(errno), errno); |
| return false; |
| } |
| |
| //Filter Picture sizes based on max width and height |
| /* TBD: do we still need this - except for ZSL? */ |
| void QCameraHardwareInterface::filterPictureSizes(){ |
| unsigned int i; |
| if(mPictureSizeCount <= 0) |
| return; |
| maxSnapshotWidth = mPictureSizes[0].width; |
| maxSnapshotHeight = mPictureSizes[0].height; |
| // Iterate through all the width and height to find the max value |
| for(i =0; i<mPictureSizeCount;i++){ |
| if(((maxSnapshotWidth < mPictureSizes[i].width) && |
| (maxSnapshotHeight <= mPictureSizes[i].height))){ |
| maxSnapshotWidth = mPictureSizes[i].width; |
| maxSnapshotHeight = mPictureSizes[i].height; |
| } |
| } |
| if(myMode & CAMERA_ZSL_MODE){ |
| // due to lack of PMEM we restrict to lower resolution |
| mPictureSizesPtr = zsl_picture_sizes; |
| mSupportedPictureSizesCount = 7; |
| }else{ |
| mPictureSizesPtr = mPictureSizes; |
| mSupportedPictureSizesCount = mPictureSizeCount; |
| } |
| } |
| |
| static String8 create_sizes_str(const camera_size_type *sizes, int len) { |
| String8 str; |
| char buffer[32]; |
| |
| if (len > 0) { |
| snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height); |
| str.append(buffer); |
| } |
| for (int i = 1; i < len; i++) { |
| snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height); |
| str.append(buffer); |
| } |
| return str; |
| } |
| |
| String8 QCameraHardwareInterface::create_values_str(const str_map *values, int len) { |
| String8 str; |
| |
| if (len > 0) { |
| str.append(values[0].desc); |
| } |
| for (int i = 1; i < len; i++) { |
| str.append(","); |
| str.append(values[i].desc); |
| } |
| return str; |
| } |
| |
| static String8 create_fps_str(const android:: FPSRange* fps, int len) { |
| String8 str; |
| char buffer[32]; |
| |
| if (len > 0) { |
| snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS); |
| str.append(buffer); |
| } |
| for (int i = 1; i < len; i++) { |
| snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS); |
| str.append(buffer); |
| } |
| return str; |
| } |
| |
| static String8 create_values_range_str(int min, int max){ |
| String8 str; |
| char buffer[32]; |
| |
| if(min <= max){ |
| snprintf(buffer, sizeof(buffer), "%d", min); |
| str.append(buffer); |
| |
| for (int i = min + 1; i <= max; i++) { |
| snprintf(buffer, sizeof(buffer), ",%d", i); |
| str.append(buffer); |
| } |
| } |
| return str; |
| } |
| |
| static int parse_size(const char *str, int &width, int &height) |
| { |
| // Find the width. |
| char *end; |
| int w = (int)strtol(str, &end, 10); |
| // If an 'x' or 'X' does not immediately follow, give up. |
| if ( (*end != 'x') && (*end != 'X') ) |
| return -1; |
| |
| // Find the height, immediately after the 'x'. |
| int h = (int)strtol(end+1, 0, 10); |
| |
| width = w; |
| height = h; |
| |
| return 0; |
| } |
| |
| bool QCameraHardwareInterface::isValidDimension(int width, int height) { |
| bool retVal = false; |
| /* This function checks if a given resolution is valid or not. |
| * A particular resolution is considered valid if it satisfies |
| * the following conditions: |
| * 1. width & height should be multiple of 16. |
| * 2. width & height should be less than/equal to the dimensions |
| * supported by the camera sensor. |
| * 3. the aspect ratio is a valid aspect ratio and is among the |
| * commonly used aspect ratio as determined by the thumbnail_sizes |
| * data structure. |
| */ |
| |
| if( (width == CEILING16(width)) && (height == CEILING16(height)) |
| && (width <= maxSnapshotWidth) |
| && (height <= maxSnapshotHeight) ) |
| { |
| uint32_t pictureAspectRatio = (uint32_t)((width * Q12)/height); |
| for(uint32_t i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ) { |
| if(thumbnail_sizes[i].aspect_ratio == pictureAspectRatio) { |
| retVal = true; |
| break; |
| } |
| } |
| } |
| return retVal; |
| } |
| |
| void QCameraHardwareInterface::hasAutoFocusSupport(){ |
| |
| ALOGV("%s",__func__); |
| |
| if(isZSLMode()){ |
| mHasAutoFocusSupport = false; |
| return; |
| } |
| |
| if(cam_ops_is_op_supported (mCameraId, MM_CAMERA_OPS_FOCUS )) { |
| mHasAutoFocusSupport = true; |
| } |
| else { |
| ALOGV("AutoFocus is not supported"); |
| mHasAutoFocusSupport = false; |
| } |
| |
| ALOGV("%s:rc= %d",__func__, mHasAutoFocusSupport); |
| |
| } |
| |
| bool QCameraHardwareInterface::supportsSceneDetection() { |
| bool rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_ASD_ENABLE); |
| return rc; |
| } |
| |
| bool QCameraHardwareInterface::supportsFaceDetection() { |
| bool rc; |
| |
| status_t ret = NO_ERROR; |
| mm_camera_op_mode_type_t op_mode; |
| |
| ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_OP_MODE, &op_mode); |
| if(ret != NO_ERROR){ |
| ALOGE("%s: Failed to get Op Mode", __func__); |
| } |
| |
| ALOGV("%s: OP_Mode is %d, ret=%d, mHdrMode=%d",__func__,op_mode,ret,mHdrMode); |
| if ((ret == NO_ERROR) && (op_mode == MM_CAMERA_OP_MODE_VIDEO) && (mHdrMode != HDR_MODE)) |
| { |
| ALOGV("%s: Video mode : FD not supported",__func__); |
| return false; |
| } |
| else{ |
| rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_FD); |
| ALOGV("%s: Still mode : FD supported : %d",__func__,rc); |
| return rc; |
| } |
| } |
| |
| bool QCameraHardwareInterface::supportsSelectableZoneAf() { |
| bool rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_FOCUS_RECT); |
| return rc; |
| } |
| |
| bool QCameraHardwareInterface::supportsRedEyeReduction() { |
| bool rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_REDEYE_REDUCTION); |
| return rc; |
| } |
| |
| static String8 create_str(int16_t *arr, int length){ |
| String8 str; |
| char buffer[32] = {0}; |
| |
| if(length > 0){ |
| snprintf(buffer, sizeof(buffer), "%d", arr[0]); |
| str.append(buffer); |
| } |
| |
| for (int i =1;i<length;i++){ |
| snprintf(buffer, sizeof(buffer), ",%d",arr[i]); |
| str.append(buffer); |
| } |
| return str; |
| } |
| |
| bool QCameraHardwareInterface::getMaxPictureDimension(mm_camera_dimension_t *maxDim) |
| { |
| bool ret = NO_ERROR; |
| mm_camera_dimension_t dim; |
| |
| ret = cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim); |
| if (ret != NO_ERROR) |
| return ret; |
| |
| /* Find the first dimension in the mPictureSizes |
| * array which is smaller than the max dimension. |
| * This will be the valid max picture resolution */ |
| for (unsigned int i = 0; i < mPictureSizeCount; i++) { |
| if ((mPictureSizes[i].width <= dim.width) && |
| (mPictureSizes[i].height <= dim.height)) { |
| maxDim->height = mPictureSizes[i].height; |
| maxDim->width = mPictureSizes[i].width; |
| break; |
| } |
| } |
| ALOGV("%s: Found Max Picture dimension: %d x %d", __func__, |
| maxDim->width, maxDim->height); |
| return ret; |
| } |
| void QCameraHardwareInterface::loadTables() |
| { |
| |
| bool ret = NO_ERROR; |
| ALOGV("%s: E", __func__); |
| |
| ret = cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_PREVIEW_SIZES_CNT, &preview_sizes_count); |
| |
| default_sizes_tbl_t preview_sizes_tbl; |
| preview_sizes_tbl.tbl_size=preview_sizes_count; |
| preview_sizes_tbl.sizes_tbl=&default_preview_sizes[0]; |
| if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_DEF_PREVIEW_SIZES, &preview_sizes_tbl)){ |
| ALOGE("%s:Failed to get default preview sizes",__func__); |
| } |
| ret = cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_VIDEO_SIZES_CNT, &video_sizes_count); |
| |
| default_sizes_tbl_t video_sizes_tbl; |
| video_sizes_tbl.tbl_size=video_sizes_count; |
| video_sizes_tbl.sizes_tbl=&default_video_sizes[0]; |
| if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_DEF_VIDEO_SIZES, &video_sizes_tbl)){ |
| ALOGE("%s:Failed to get default video sizes",__func__); |
| } |
| |
| ret = cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_THUMB_SIZES_CNT, &thumbnail_sizes_count); |
| |
| default_sizes_tbl_t thumbnail_sizes_tbl; |
| thumbnail_sizes_tbl.tbl_size=thumbnail_sizes_count; |
| thumbnail_sizes_tbl.sizes_tbl=&default_thumbnail_sizes[0]; |
| if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_DEF_THUMB_SIZES, &thumbnail_sizes_tbl)){ |
| ALOGE("%s:Failed to get default thumbnail sizes",__func__); |
| } |
| |
| ret = cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_HFR_SIZES_CNT, &hfr_sizes_count); |
| |
| default_sizes_tbl_t hfr_sizes_tbl; |
| hfr_sizes_tbl.tbl_size=hfr_sizes_count; |
| hfr_sizes_tbl.sizes_tbl=&default_hfr_sizes[0]; |
| if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_DEF_HFR_SIZES, &hfr_sizes_tbl)){ |
| ALOGE("%s:Failed to get default HFR sizes",__func__); |
| } |
| ALOGV("%s: X", __func__); |
| } |
| void QCameraHardwareInterface::initDefaultParameters() |
| { |
| bool ret; |
| char prop[PROPERTY_VALUE_MAX]; |
| mm_camera_dimension_t maxDim; |
| int rc = MM_CAMERA_OK; |
| ALOGV("%s: E", __func__); |
| |
| memset(&maxDim, 0, sizeof(mm_camera_dimension_t)); |
| ret = getMaxPictureDimension(&maxDim); |
| |
| if (ret != NO_ERROR) { |
| ALOGE("%s: Cannot get Max picture size supported", __func__); |
| return; |
| } |
| if (!maxDim.width || !maxDim.height) { |
| maxDim.width = DEFAULT_LIVESHOT_WIDTH; |
| maxDim.height = DEFAULT_LIVESHOT_HEIGHT; |
| } |
| |
| memset(prop, 0, sizeof(prop)); |
| property_get("persist.camera.snap.format", prop, "0"); |
| mSnapshotFormat = atoi(prop); |
| ALOGV("%s: prop =(%s), snap_format=%d", __func__, prop, mSnapshotFormat); |
| |
| //cam_ctrl_dimension_t dim; |
| mHFRLevel = 0; |
| memset(&mDimension, 0, sizeof(cam_ctrl_dimension_t)); |
| memset(&mPreviewFormatInfo, 0, sizeof(preview_format_info_t)); |
| mDimension.video_width = DEFAULT_VIDEO_WIDTH; |
| mDimension.video_height = DEFAULT_VIDEO_HEIGHT; |
| // mzhu mDimension.picture_width = DEFAULT_STREAM_WIDTH; |
| // mzhu mDimension.picture_height = DEFAULT_STREAM_HEIGHT; |
| mDimension.picture_width = maxDim.width; |
| mDimension.picture_height = maxDim.height; |
| mDimension.display_width = DEFAULT_STREAM_WIDTH; |
| mDimension.display_height = DEFAULT_STREAM_HEIGHT; |
| mDimension.orig_picture_dx = mDimension.picture_width; |
| mDimension.orig_picture_dy = mDimension.picture_height; |
| mDimension.ui_thumbnail_width = DEFAULT_STREAM_WIDTH; |
| mDimension.ui_thumbnail_height = DEFAULT_STREAM_HEIGHT; |
| mDimension.orig_video_width = DEFAULT_STREAM_WIDTH; |
| mDimension.orig_video_height = DEFAULT_STREAM_HEIGHT; |
| |
| mDimension.prev_format = CAMERA_YUV_420_NV21; |
| mDimension.enc_format = CAMERA_YUV_420_NV12; |
| if (mSnapshotFormat == 1) { |
| mDimension.main_img_format = CAMERA_YUV_422_NV61; |
| } else { |
| mDimension.main_img_format = CAMERA_YUV_420_NV21; |
| } |
| mDimension.thumb_format = CAMERA_YUV_420_NV21; |
| ALOGV("%s: main_img_format =%d, thumb_format=%d", __func__, |
| mDimension.main_img_format, mDimension.thumb_format); |
| mDimension.prev_padding_format = CAMERA_PAD_TO_WORD; |
| |
| ret = native_set_parms(MM_CAMERA_PARM_DIMENSION, |
| sizeof(cam_ctrl_dimension_t), (void *) &mDimension); |
| if(!ret) { |
| ALOGE("MM_CAMERA_PARM_DIMENSION Failed."); |
| return; |
| } |
| |
| hasAutoFocusSupport(); |
| |
| // Initialize constant parameter strings. This will happen only once in the |
| // lifetime of the mediaserver process. |
| if (true/*!mParamStringInitialized*/) { |
| //filter picture sizes |
| filterPictureSizes(); |
| mPictureSizeValues = create_sizes_str( |
| mPictureSizesPtr, mSupportedPictureSizesCount); |
| mPreviewSizeValues = create_sizes_str( |
| mPreviewSizes, mPreviewSizeCount); |
| mVideoSizeValues = create_sizes_str( |
| mVideoSizes, mVideoSizeCount); |
| |
| //Query for max HFR value |
| camera_hfr_mode_t maxHFR; |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_MAX_HFR_MODE, (void *)&maxHFR); |
| //Filter HFR values and build parameter string |
| String8 str; |
| for(int i=0; i<HFR_VALUES_COUNT; i++){ |
| if(hfr[i].val <= maxHFR){ |
| if(i>0) str.append(","); |
| str.append(hfr[i].desc); |
| } |
| } |
| mHfrValues = str; |
| mHfrSizeValues = create_sizes_str( |
| default_hfr_sizes, hfr_sizes_count); |
| mFpsRangesSupportedValues = create_fps_str( |
| FpsRangesSupported,FPS_RANGES_SUPPORTED_COUNT ); |
| mParameters.set( |
| QCameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, |
| mFpsRangesSupportedValues); |
| mParameters.setPreviewFpsRange(MINIMUM_FPS*1000,MAXIMUM_FPS*1000); |
| mFlashValues = create_values_str( |
| flash, sizeof(flash) / sizeof(str_map)); |
| mLensShadeValues = create_values_str( |
| lensshade,sizeof(lensshade)/sizeof(str_map)); |
| mMceValues = create_values_str( |
| mce,sizeof(mce)/sizeof(str_map)); |
| mEffectValues = create_values_str(effects, sizeof(effects) / sizeof(str_map)); |
| mAntibandingValues = create_values_str( |
| antibanding, sizeof(antibanding) / sizeof(str_map)); |
| mIsoValues = create_values_str(iso,sizeof(iso)/sizeof(str_map)); |
| mAutoExposureValues = create_values_str( |
| autoexposure, sizeof(autoexposure) / sizeof(str_map)); |
| mWhitebalanceValues = create_values_str( |
| whitebalance, sizeof(whitebalance) / sizeof(str_map)); |
| |
| if(mHasAutoFocusSupport){ |
| mFocusModeValues = create_values_str( |
| focus_modes, sizeof(focus_modes) / sizeof(str_map)); |
| } |
| |
| mSceneModeValues = create_values_str(scenemode, sizeof(scenemode) / sizeof(str_map)); |
| |
| if(mHasAutoFocusSupport){ |
| mTouchAfAecValues = create_values_str( |
| touchafaec,sizeof(touchafaec)/sizeof(str_map)); |
| } |
| //Currently Enabling Histogram for 8x60 |
| mHistogramValues = create_values_str( |
| histogram,sizeof(histogram)/sizeof(str_map)); |
| |
| mSkinToneEnhancementValues = create_values_str( |
| skinToneEnhancement,sizeof(skinToneEnhancement)/sizeof(str_map)); |
| |
| mPictureFormatValues = create_values_str( |
| picture_formats, sizeof(picture_formats)/sizeof(str_map)); |
| |
| mZoomSupported=false; |
| mMaxZoom=0; |
| mm_camera_zoom_tbl_t zmt; |
| if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_MAXZOOM, &mMaxZoom)){ |
| ALOGE("%s:Failed to get max zoom",__func__); |
| }else{ |
| |
| ALOGV("Max Zoom:%d",mMaxZoom); |
| /* Kernel driver limits the max amount of data that can be retreived through a control |
| command to 260 bytes hence we conservatively limit to 110 zoom ratios */ |
| if(mMaxZoom>MAX_ZOOM_RATIOS) { |
| ALOGV("%s:max zoom is larger than sizeof zoomRatios table",__func__); |
| mMaxZoom=MAX_ZOOM_RATIOS-1; |
| } |
| zmt.size=mMaxZoom; |
| zmt.zoom_ratio_tbl=&zoomRatios[0]; |
| if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_ZOOM_RATIO, &zmt)){ |
| ALOGE("%s:Failed to get max zoom ratios",__func__); |
| }else{ |
| mZoomSupported=true; |
| mZoomRatioValues = create_str(zoomRatios, mMaxZoom); |
| } |
| } |
| |
| ALOGV("Zoom supported:%d",mZoomSupported); |
| |
| denoise_value = create_values_str( |
| denoise, sizeof(denoise) / sizeof(str_map)); |
| |
| if(supportsFaceDetection()) { |
| mFaceDetectionValues = create_values_str( |
| facedetection, sizeof(facedetection) / sizeof(str_map)); |
| } |
| |
| if(mHasAutoFocusSupport){ |
| mSelectableZoneAfValues = create_values_str( |
| selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map)); |
| } |
| |
| mSceneDetectValues = create_values_str(scenedetect, sizeof(scenedetect) / sizeof(str_map)); |
| |
| mRedeyeReductionValues = create_values_str( |
| redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map)); |
| |
| mZslValues = create_values_str( |
| zsl_modes,sizeof(zsl_modes)/sizeof(str_map)); |
| |
| mParamStringInitialized = true; |
| } |
| |
| //set supported video sizes |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_VIDEO_SIZES, mVideoSizeValues.string()); |
| |
| //set default video size to first one in supported table |
| String8 vSize = create_sizes_str(&mVideoSizes[0], 1); |
| mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, vSize.string()); |
| |
| //Set Preview size |
| int default_preview_width, default_preview_height; |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH, |
| &default_preview_width); |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT, |
| &default_preview_height); |
| mParameters.setPreviewSize(default_preview_width, default_preview_height); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, |
| mPreviewSizeValues.string()); |
| mDimension.display_width = default_preview_width; |
| mDimension.display_height = default_preview_height; |
| |
| //Set Preview Frame Rate |
| if(mFps >= MINIMUM_FPS && mFps <= MAXIMUM_FPS) { |
| mPreviewFrameRateValues = create_values_range_str( |
| MINIMUM_FPS, mFps); |
| }else{ |
| mPreviewFrameRateValues = create_values_range_str( |
| MINIMUM_FPS, MAXIMUM_FPS); |
| } |
| |
| |
| if (cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS)) { |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, |
| mPreviewFrameRateValues.string()); |
| } else { |
| mParameters.set( |
| QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, |
| DEFAULT_FIXED_FPS); |
| } |
| |
| //Set Preview Frame Rate Modes |
| mParameters.setPreviewFrameRateMode("frame-rate-auto"); |
| mFrameRateModeValues = create_values_str( |
| frame_rate_modes, sizeof(frame_rate_modes) / sizeof(str_map)); |
| if(cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS_MODE)){ |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATE_MODES, |
| mFrameRateModeValues.string()); |
| } |
| |
| //Set Preview Format |
| //mParameters.setPreviewFormat("yuv420sp"); // informative |
| mParameters.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP); |
| |
| mPreviewFormatValues = create_values_str( |
| preview_formats, sizeof(preview_formats) / sizeof(str_map)); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, |
| mPreviewFormatValues.string()); |
| |
| //Set Overlay Format |
| mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP); |
| mParameters.set("max-num-detected-faces-hw", "2"); |
| |
| // Set supported max faces |
| int maxNumFaces = 0; |
| if (supportsFaceDetection()) { |
| //Query the maximum number of faces supported by hardware. |
| if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_MAX_NUM_FACES_DECT, &maxNumFaces)){ |
| ALOGE("%s:Failed to get max number of faces supported",__func__); |
| } |
| } |
| mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, maxNumFaces); |
| //This paramtere is set to default here. This will be changed by application |
| //if it needs to support specific number of faces. See also setParameters. |
| mParameters.set(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES, 2); |
| |
| // Set camera features supported flag |
| int32_t featureFlag = 0; |
| if (supportsFaceDetection()) { |
| featureFlag |= 0x00000001; // bit 0 indicate faciral feature |
| } |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_CAMERA_FEATURES, featureFlag); |
| |
| //Set Picture Size |
| mParameters.setPictureSize(DEFAULT_PICTURE_WIDTH, DEFAULT_PICTURE_HEIGHT); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES, |
| mPictureSizeValues.string()); |
| |
| //Set Preview Frame Rate |
| if(mFps >= MINIMUM_FPS && mFps <= MAXIMUM_FPS) { |
| mParameters.setPreviewFrameRate(mFps); |
| }else{ |
| mParameters.setPreviewFrameRate(DEFAULT_FPS); |
| } |
| |
| //Set Picture Format |
| mParameters.setPictureFormat("jpeg"); // informative |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, |
| mPictureFormatValues); |
| |
| mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, "90"); // max quality |
| mJpegQuality = 90; |
| //Set Video Format |
| mParameters.set(QCameraParameters::KEY_VIDEO_FRAME_FORMAT, "yuv420sp"); |
| |
| //Set Thumbnail parameters |
| mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, |
| THUMBNAIL_WIDTH_STR); // informative |
| mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, |
| THUMBNAIL_HEIGHT_STR); // informative |
| mDimension.ui_thumbnail_width = |
| thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].width; |
| mDimension.ui_thumbnail_height = |
| thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].height; |
| mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "90"); |
| String8 valuesStr = create_sizes_str(default_thumbnail_sizes, thumbnail_sizes_count); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, |
| valuesStr.string()); |
| // Define CAMERA_SMOOTH_ZOOM in Android.mk file , to enable smoothzoom |
| #ifdef CAMERA_SMOOTH_ZOOM |
| mParameters.set(QCameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, "true"); |
| #endif |
| if(mZoomSupported){ |
| mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "true"); |
| ALOGV("max zoom is %d", mMaxZoom-1); |
| /* mMaxZoom value that the query interface returns is the size |
| ALOGV("max zoom is %d", mMaxZoom-1); |
| * mMaxZoom value that the query interface returns is the size |
| * of zoom table. So the actual max zoom value will be one |
| * less than that value. */ |
| |
| mParameters.set("max-zoom",mMaxZoom-1); |
| mParameters.set(QCameraParameters::KEY_ZOOM_RATIOS, |
| mZoomRatioValues); |
| } else |
| { |
| mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "false"); |
| } |
| |
| /* Enable zoom support for video application if VPE enabled */ |
| if(mZoomSupported) { |
| mParameters.set("video-zoom-support", "true"); |
| } else { |
| mParameters.set("video-zoom-support", "false"); |
| } |
| |
| //8960 supports Power modes : Low power, Normal Power. |
| mParameters.set("power-mode-supported", "true"); |
| |
| //Set Live shot support |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_LIVESHOT_MAIN); |
| if(!rc) { |
| ALOGV("%s:LIVESHOT is not supported", __func__); |
| mParameters.set("video-snapshot-supported", "false"); |
| } else { |
| mParameters.set("video-snapshot-supported", "true"); |
| } |
| |
| |
| //Set default power mode |
| mParameters.set(QCameraParameters::KEY_POWER_MODE,"Low_Power"); |
| //Set Wnr on |
| mParameters.set(QCameraParameters::KEY_DENOISE,true); |
| //Set Camera Mode |
| mParameters.set(QCameraParameters::KEY_CAMERA_MODE,1); |
| mParameters.set(QCameraParameters::KEY_AE_BRACKET_HDR,"Off"); |
| |
| //Set Antibanding |
| mParameters.set(QCameraParameters::KEY_ANTIBANDING, |
| QCameraParameters::ANTIBANDING_AUTO); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_ANTIBANDING, |
| mAntibandingValues); |
| |
| //Set Effect |
| mParameters.set(QCameraParameters::KEY_EFFECT, |
| QCameraParameters::EFFECT_NONE); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_EFFECTS, mEffectValues); |
| |
| //Set Auto Exposure |
| mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE, |
| QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_AUTO_EXPOSURE, mAutoExposureValues); |
| |
| //Set WhiteBalance |
| mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, |
| QCameraParameters::WHITE_BALANCE_AUTO); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_WHITE_BALANCE,mWhitebalanceValues); |
| |
| //Set AEC_LOCK |
| mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK, "false"); |
| if(cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_AEC_LOCK)){ |
| mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true"); |
| } else { |
| mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "false"); |
| } |
| //Set AWB_LOCK |
| mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, "false"); |
| if(cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_AWB_LOCK)) |
| mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true"); |
| else |
| mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "false"); |
| |
| //Set Focus Mode |
| if(mHasAutoFocusSupport){ |
| mParameters.set(QCameraParameters::KEY_FOCUS_MODE, |
| QCameraParameters::FOCUS_MODE_AUTO); |
| mFocusMode = AF_MODE_AUTO; |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES, |
| mFocusModeValues); |
| mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "1"); |
| mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "1"); |
| } else { |
| mParameters.set(QCameraParameters::KEY_FOCUS_MODE, |
| QCameraParameters::FOCUS_MODE_INFINITY); |
| mFocusMode = DONT_CARE; |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES, |
| QCameraParameters::FOCUS_MODE_INFINITY); |
| mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "0"); |
| mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "0"); |
| } |
| |
| mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, DEFAULT_CAMERA_AREA); |
| mParameters.set(QCameraParameters::KEY_METERING_AREAS, DEFAULT_CAMERA_AREA); |
| |
| //Set Flash |
| if (cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_LED_MODE)) { |
| mParameters.set(QCameraParameters::KEY_FLASH_MODE, |
| QCameraParameters::FLASH_MODE_OFF); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_FLASH_MODES, |
| mFlashValues); |
| } |
| |
| //Set Sharpness |
| mParameters.set(QCameraParameters::KEY_MAX_SHARPNESS, |
| CAMERA_MAX_SHARPNESS); |
| mParameters.set(QCameraParameters::KEY_SHARPNESS, |
| CAMERA_DEF_SHARPNESS); |
| |
| //Set Contrast |
| mParameters.set(QCameraParameters::KEY_MAX_CONTRAST, |
| CAMERA_MAX_CONTRAST); |
| mParameters.set(QCameraParameters::KEY_CONTRAST, |
| CAMERA_DEF_CONTRAST); |
| |
| //Set Saturation |
| mParameters.set(QCameraParameters::KEY_MAX_SATURATION, |
| CAMERA_MAX_SATURATION); |
| mParameters.set(QCameraParameters::KEY_SATURATION, |
| CAMERA_DEF_SATURATION); |
| |
| //Set Brightness/luma-adaptaion |
| mParameters.set("luma-adaptation", "3"); |
| |
| mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, |
| QCameraParameters::PIXEL_FORMAT_JPEG); |
| |
| //Set Lensshading |
| mParameters.set(QCameraParameters::KEY_LENSSHADE, |
| QCameraParameters::LENSSHADE_ENABLE); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_LENSSHADE_MODES, |
| mLensShadeValues); |
| |
| //Set ISO Mode |
| mParameters.set(QCameraParameters::KEY_ISO_MODE, |
| QCameraParameters::ISO_AUTO); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_ISO_MODES, |
| mIsoValues); |
| |
| //Set MCE |
| mParameters.set(QCameraParameters::KEY_MEMORY_COLOR_ENHANCEMENT, |
| QCameraParameters::MCE_ENABLE); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_MEM_COLOR_ENHANCE_MODES, |
| mMceValues); |
| //Set HFR |
| if (cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_HFR)) { |
| mParameters.set(QCameraParameters::KEY_VIDEO_HIGH_FRAME_RATE, |
| QCameraParameters::VIDEO_HFR_OFF); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_HFR_SIZES, |
| mHfrSizeValues.string()); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES, |
| mHfrValues); |
| } else{ |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_HFR_SIZES,""); |
| } |
| |
| //Set Histogram |
| mParameters.set(QCameraParameters::KEY_HISTOGRAM, |
| QCameraParameters::HISTOGRAM_DISABLE); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_HISTOGRAM_MODES, |
| mHistogramValues); |
| |
| //Set SkinTone Enhancement |
| mParameters.set(QCameraParameters::KEY_SKIN_TONE_ENHANCEMENT, |
| QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE); |
| mParameters.set("skinToneEnhancement", "0"); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES, |
| mSkinToneEnhancementValues); |
| |
| //Set Scene Mode |
| mParameters.set(QCameraParameters::KEY_SCENE_MODE, |
| QCameraParameters::SCENE_MODE_AUTO); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_SCENE_MODES, |
| mSceneModeValues); |
| |
| //Set Streaming Textures |
| mParameters.set("strtextures", "OFF"); |
| |
| //Set Denoise |
| mParameters.set(QCameraParameters::KEY_DENOISE, |
| QCameraParameters::DENOISE_ON); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_DENOISE, |
| denoise_value); |
| //Set Touch AF/AEC |
| mParameters.set(QCameraParameters::KEY_TOUCH_AF_AEC, |
| QCameraParameters::TOUCH_AF_AEC_OFF); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_TOUCH_AF_AEC, |
| mTouchAfAecValues); |
| /* touch-AF ROI for reducing af fail case */ |
| mParameters.set("touchAfAec-dx","200"); |
| mParameters.set("touchAfAec-dy","200"); |
| |
| //Set Scene Detection |
| mParameters.set(QCameraParameters::KEY_SCENE_DETECT, |
| QCameraParameters::SCENE_DETECT_OFF); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_SCENE_DETECT, |
| mSceneDetectValues); |
| |
| //Set Selectable Zone AF |
| mParameters.set(QCameraParameters::KEY_SELECTABLE_ZONE_AF, |
| QCameraParameters::SELECTABLE_ZONE_AF_AUTO); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_SELECTABLE_ZONE_AF, |
| mSelectableZoneAfValues); |
| |
| //Set Face Detection |
| if(supportsFaceDetection()){ |
| mParameters.set(QCameraParameters::KEY_FACE_DETECTION, |
| QCameraParameters::FACE_DETECTION_OFF); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_FACE_DETECTION, |
| mFaceDetectionValues); |
| } |
| |
| //Set Red Eye Reduction |
| mParameters.set(QCameraParameters::KEY_REDEYE_REDUCTION, |
| QCameraParameters::REDEYE_REDUCTION_DISABLE); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_REDEYE_REDUCTION, |
| mRedeyeReductionValues); |
| |
| //Set ZSL |
| mParameters.set(QCameraParameters::KEY_ZSL, |
| QCameraParameters::ZSL_OFF); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_ZSL_MODES, |
| mZslValues); |
| |
| //Set Focal length, horizontal and vertical view angles |
| focus_distances_info_t focalLength; |
| float horizontalViewAngle = 0.0f; |
| float verticalViewAngle = 0.0f; |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_FOCAL_LENGTH, |
| (void *)&focalLength); |
| mParameters.setFloat(QCameraParameters::KEY_FOCAL_LENGTH, |
| focalLength.focus_distance[0]); |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE, |
| (void *)&horizontalViewAngle); |
| mParameters.setFloat(QCameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, |
| horizontalViewAngle); |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE, |
| (void *)&verticalViewAngle); |
| mParameters.setFloat(QCameraParameters::KEY_VERTICAL_VIEW_ANGLE, |
| verticalViewAngle); |
| |
| //Set Exposure Compensation |
| mParameters.set( |
| QCameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, |
| EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR); |
| mParameters.set( |
| QCameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, |
| EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR); |
| mParameters.set( |
| QCameraParameters::KEY_EXPOSURE_COMPENSATION, |
| EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR); |
| mParameters.setFloat( |
| QCameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, |
| EXPOSURE_COMPENSATION_STEP); |
| |
| mParameters.set("num-snaps-per-shutter", 1); |
| |
| mParameters.set("capture-burst-captures-values", getZSLQueueDepth()); |
| mParameters.set("capture-burst-interval-supported", "true"); |
| mParameters.set("capture-burst-interval-max", BURST_INTREVAL_MAX); /*skip frames*/ |
| mParameters.set("capture-burst-interval-min", BURST_INTREVAL_MIN); /*skip frames*/ |
| mParameters.set("capture-burst-interval", BURST_INTREVAL_DEFAULT); /*skip frames*/ |
| mParameters.set("capture-burst-retroactive", 0); |
| mParameters.set("capture-burst-retroactive-max", getZSLQueueDepth()); |
| mParameters.set("capture-burst-exposures", ""); |
| mParameters.set("capture-burst-exposures-values", |
| "-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12"); |
| { |
| String8 CamModeStr; |
| char buffer[32]; |
| int flag = 0; |
| |
| for (int i = 0; i < HAL_CAM_MODE_MAX; i++) { |
| if ( 0 ) { /*exclude some conflicting case*/ |
| } else { |
| if (flag == 0) { /*first item*/ |
| snprintf(buffer, sizeof(buffer), "%d", i); |
| } else { |
| snprintf(buffer, sizeof(buffer), ",%d", i); |
| } |
| flag = 1; |
| CamModeStr.append(buffer); |
| } |
| } |
| mParameters.set("camera-mode-values", CamModeStr); |
| } |
| |
| mParameters.set("ae-bracket-hdr-values", |
| create_values_str(hdr_bracket, sizeof(hdr_bracket)/sizeof(str_map) )); |
| |
| // if(mIs3DModeOn) |
| // mParameters.set("3d-frame-format", "left-right"); |
| mParameters.set("no-display-mode", 0); |
| //mUseOverlay = useOverlay(); |
| mParameters.set("zoom", 0); |
| |
| int mNuberOfVFEOutputs; |
| ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, &mNuberOfVFEOutputs); |
| if(ret != MM_CAMERA_OK) { |
| ALOGE("get parm MM_CAMERA_PARM_VFE_OUTPUT_ENABLE failed"); |
| ret = BAD_VALUE; |
| } |
| if(mNuberOfVFEOutputs == 1) |
| { |
| mParameters.set(QCameraParameters::KEY_SINGLE_ISP_OUTPUT_ENABLED, "true"); |
| } else { |
| mParameters.set(QCameraParameters::KEY_SINGLE_ISP_OUTPUT_ENABLED, "false"); |
| } |
| |
| if (setParameters(mParameters) != NO_ERROR) { |
| ALOGE("Failed to set default parameters?!"); |
| } |
| |
| mNoDisplayMode = 0; |
| mLedStatusForZsl = LED_MODE_OFF; |
| |
| mInitialized = true; |
| strTexturesOn = false; |
| |
| ALOGV("%s: X", __func__); |
| return; |
| } |
| |
| /** |
| * Set the camera parameters. This returns BAD_VALUE if any parameter is |
| * invalid or not supported. |
| */ |
| |
| int QCameraHardwareInterface::setParameters(const char *parms) |
| { |
| QCameraParameters param; |
| String8 str = String8(parms); |
| param.unflatten(str); |
| status_t ret = setParameters(param); |
| if(ret == NO_ERROR) |
| return 0; |
| else |
| return -1; |
| } |
| |
| /** |
| * Set the camera parameters. This returns BAD_VALUE if any parameter is |
| * invalid or not supported. */ |
| status_t QCameraHardwareInterface::setParameters(const QCameraParameters& params) |
| { |
| status_t ret = NO_ERROR; |
| |
| ALOGV("%s: E", __func__); |
| // Mutex::Autolock l(&mLock); |
| status_t rc, final_rc = NO_ERROR; |
| |
| if ((rc = setPowerMode(params))) final_rc = rc; |
| if ((rc = setPreviewSize(params))) final_rc = rc; |
| if ((rc = setVideoSize(params))) final_rc = rc; |
| if ((rc = setPictureSize(params))) final_rc = rc; |
| if ((rc = setJpegThumbnailSize(params))) final_rc = rc; |
| if ((rc = setJpegQuality(params))) final_rc = rc; |
| if ((rc = setEffect(params))) final_rc = rc; |
| if ((rc = setGpsLocation(params))) final_rc = rc; |
| if ((rc = setRotation(params))) final_rc = rc; |
| if ((rc = setZoom(params))) final_rc = rc; |
| if ((rc = setOrientation(params))) final_rc = rc; |
| if ((rc = setLensshadeValue(params))) final_rc = rc; |
| if ((rc = setMCEValue(params))) final_rc = rc; |
| if ((rc = setPictureFormat(params))) final_rc = rc; |
| if ((rc = setSharpness(params))) final_rc = rc; |
| if ((rc = setSaturation(params))) final_rc = rc; |
| if ((rc = setSceneMode(params))) final_rc = rc; |
| if ((rc = setContrast(params))) final_rc = rc; |
| // if ((rc = setFaceDetect(params))) final_rc = rc; |
| if ((rc = setStrTextures(params))) final_rc = rc; |
| if ((rc = setPreviewFormat(params))) final_rc = rc; |
| if ((rc = setSkinToneEnhancement(params))) final_rc = rc; |
| if ((rc = setWaveletDenoise(params))) final_rc = rc; |
| if ((rc = setAntibanding(params))) final_rc = rc; |
| // if ((rc = setOverlayFormats(params))) final_rc = rc; |
| if ((rc = setRedeyeReduction(params))) final_rc = rc; |
| if ((rc = setCaptureBurstExp())) final_rc = rc; |
| |
| const char *str_val = params.get("capture-burst-exposures"); |
| if ( str_val == NULL || strlen(str_val)==0 ) { |
| char burst_exp[PROPERTY_VALUE_MAX]; |
| memset(burst_exp, 0, sizeof(burst_exp)); |
| property_get("persist.capture.burst.exposures", burst_exp, ""); |
| if ( strlen(burst_exp)>0 ) { |
| mParameters.set("capture-burst-exposures", burst_exp); |
| } |
| } else { |
| mParameters.set("capture-burst-exposures", str_val); |
| } |
| mParameters.set("num-snaps-per-shutter", params.get("num-snaps-per-shutter")); |
| |
| if ((rc = setAEBracket(params))) final_rc = rc; |
| // if ((rc = setDenoise(params))) final_rc = rc; |
| if ((rc = setPreviewFpsRange(params))) final_rc = rc; |
| if((rc = setRecordingHint(params))) final_rc = rc; |
| if ((rc = setNumOfSnapshot(params))) final_rc = rc; |
| if ((rc = setAecAwbLock(params))) final_rc = rc; |
| if ((rc = setWhiteBalance(params))) final_rc = rc; |
| const char *str = params.get(QCameraParameters::KEY_SCENE_MODE); |
| int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str); |
| |
| if((value != NOT_FOUND) && (value == CAMERA_BESTSHOT_OFF )) { |
| //if ((rc = setPreviewFrameRateMode(params))) final_rc = rc; |
| if ((rc = setPreviewFrameRate(params))) final_rc = rc; |
| if ((rc = setBrightness(params))) final_rc = rc; |
| if ((rc = setISOValue(params))) final_rc = rc; |
| if ((rc = setFocusAreas(params))) final_rc = rc; |
| if ((rc = setMeteringAreas(params))) final_rc = rc; |
| } |
| if ((rc = setFocusMode(params))) final_rc = rc; |
| if ((rc = setAutoExposure(params))) final_rc = rc; |
| if ((rc = setExposureCompensation(params))) final_rc = rc; |
| if ((rc = setFlash(params))) final_rc = rc; |
| //selectableZoneAF needs to be invoked after continuous AF |
| if ((rc = setSelectableZoneAf(params))) final_rc = rc; |
| // setHighFrameRate needs to be done at end, as there can |
| // be a preview restart, and need to use the updated parameters |
| if ((rc = setHighFrameRate(params))) final_rc = rc; |
| if ((rc = setZSLBurstLookBack(params))) final_rc = rc; |
| if ((rc = setZSLBurstInterval(params))) final_rc = rc; |
| if ((rc = setNoDisplayMode(params))) final_rc = rc; |
| |
| //Update Exiftag values. |
| setExifTags(); |
| |
| ALOGV("%s: X", __func__); |
| return final_rc; |
| } |
| |
| /** Retrieve the camera parameters. The buffer returned by the camera HAL |
| must be returned back to it with put_parameters, if put_parameters |
| is not NULL. |
| */ |
| int QCameraHardwareInterface::getParameters(char **parms) |
| { |
| char* rc = NULL; |
| String8 str; |
| QCameraParameters param = getParameters(); |
| //param.dump(); |
| str = param.flatten( ); |
| rc = (char *)malloc(sizeof(char)*(str.length()+1)); |
| if(rc != NULL){ |
| memset(rc, 0, sizeof(char)*(str.length()+1)); |
| strncpy(rc, str.string(), str.length()); |
| rc[str.length()] = 0; |
| *parms = rc; |
| } |
| return 0; |
| } |
| |
| /** The camera HAL uses its own memory to pass us the parameters when we |
| call get_parameters. Use this function to return the memory back to |
| the camera HAL, if put_parameters is not NULL. If put_parameters |
| is NULL, then you have to use free() to release the memory. |
| */ |
| void QCameraHardwareInterface::putParameters(char *rc) |
| { |
| free(rc); |
| rc = NULL; |
| } |
| |
| QCameraParameters& QCameraHardwareInterface::getParameters() |
| { |
| Mutex::Autolock lock(mLock); |
| mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string()); |
| const char *str = mParameters.get(QCameraParameters::KEY_SCENE_MODE); |
| if (mHasAutoFocusSupport && strcmp(str, "auto")) { |
| mParameters.set(QCameraParameters::KEY_FOCUS_MODE, |
| QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE); |
| } |
| return mParameters; |
| } |
| |
| status_t QCameraHardwareInterface::runFaceDetection() |
| { |
| bool ret = true; |
| |
| const char *str = mParameters.get(QCameraParameters::KEY_FACE_DETECTION); |
| if (str != NULL) { |
| int value = attr_lookup(facedetection, |
| sizeof(facedetection) / sizeof(str_map), str); |
| fd_set_parm_t fd_set_parm; |
| int requested_faces = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES); |
| fd_set_parm.fd_mode = value; |
| fd_set_parm.num_fd = requested_faces; |
| ret = native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setSharpness(const QCameraParameters& params) |
| { |
| bool ret = false; |
| int rc = MM_CAMERA_OK; |
| ALOGV("%s",__func__); |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_SHARPNESS); |
| if(!rc) { |
| ALOGV("%s:CONTRAST not supported", __func__); |
| return NO_ERROR; |
| } |
| int sharpness = params.getInt(QCameraParameters::KEY_SHARPNESS); |
| if((sharpness < CAMERA_MIN_SHARPNESS |
| || sharpness > CAMERA_MAX_SHARPNESS)) |
| return UNKNOWN_ERROR; |
| |
| ALOGV("setting sharpness %d", sharpness); |
| mParameters.set(QCameraParameters::KEY_SHARPNESS, sharpness); |
| ret = native_set_parms(MM_CAMERA_PARM_SHARPNESS, sizeof(sharpness), |
| (void *)&sharpness); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setSaturation(const QCameraParameters& params) |
| { |
| bool ret = false; |
| int rc = MM_CAMERA_OK; |
| ALOGV("%s",__func__); |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_SATURATION); |
| if(!rc) { |
| ALOGV("%s:MM_CAMERA_PARM_SATURATION not supported", __func__); |
| return NO_ERROR; |
| } |
| int result; |
| int saturation = params.getInt(QCameraParameters::KEY_SATURATION); |
| |
| if((saturation < CAMERA_MIN_SATURATION) |
| || (saturation > CAMERA_MAX_SATURATION)) |
| return UNKNOWN_ERROR; |
| |
| ALOGV("Setting saturation %d", saturation); |
| mParameters.set(QCameraParameters::KEY_SATURATION, saturation); |
| ret = native_set_parms(MM_CAMERA_PARM_SATURATION, sizeof(saturation), |
| (void *)&saturation, (int *)&result); |
| if(result != MM_CAMERA_OK) |
| ALOGV("Saturation Value: %d is not set as the selected value is not supported", saturation); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setContrast(const QCameraParameters& params) |
| { |
| ALOGV("%s E", __func__ ); |
| int rc = MM_CAMERA_OK; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_CONTRAST); |
| if(!rc) { |
| ALOGV("%s:CONTRAST not supported", __func__); |
| return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_SCENE_MODE); |
| ALOGV("Contrast : %s",str); |
| int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str); |
| if(value == CAMERA_BESTSHOT_OFF) { |
| int contrast = params.getInt(QCameraParameters::KEY_CONTRAST); |
| if((contrast < CAMERA_MIN_CONTRAST) |
| || (contrast > CAMERA_MAX_CONTRAST)) |
| { |
| ALOGV("Contrast Value not matching"); |
| return UNKNOWN_ERROR; |
| } |
| ALOGV("setting contrast %d", contrast); |
| mParameters.set(QCameraParameters::KEY_CONTRAST, contrast); |
| ALOGV("Calling Contrast set on Lower layer"); |
| bool ret = native_set_parms(MM_CAMERA_PARM_CONTRAST, sizeof(contrast), |
| (void *)&contrast); |
| ALOGV("Lower layer returned %d", ret); |
| int bestshot_reconfigure; |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_BESTSHOT_RECONFIGURE, |
| &bestshot_reconfigure); |
| if(bestshot_reconfigure) { |
| if (mContrast != contrast) { |
| mContrast = contrast; |
| if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) { |
| mRestartPreview = 1; |
| pausePreviewForZSL(); |
| } |
| } |
| } |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } else { |
| ALOGV(" Contrast value will not be set " \ |
| "when the scenemode selected is %s", str); |
| return NO_ERROR; |
| } |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setSceneDetect(const QCameraParameters& params) |
| { |
| ALOGV("%s",__func__); |
| bool retParm; |
| int rc = MM_CAMERA_OK; |
| |
| rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_ASD_ENABLE); |
| if(!rc) { |
| ALOGV("%s:MM_CAMERA_PARM_ASD_ENABLE not supported", __func__); |
| return NO_ERROR; |
| } |
| |
| const char *str = params.get(QCameraParameters::KEY_SCENE_DETECT); |
| ALOGV("Scene Detect string : %s",str); |
| if (str != NULL) { |
| int32_t value = attr_lookup(scenedetect, sizeof(scenedetect) / sizeof(str_map), str); |
| ALOGV("Scenedetect Value : %d",value); |
| if (value != NOT_FOUND) { |
| mParameters.set(QCameraParameters::KEY_SCENE_DETECT, str); |
| |
| retParm = native_set_parms(MM_CAMERA_PARM_ASD_ENABLE, sizeof(value), |
| (void *)&value); |
| |
| return retParm ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| } |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setZoom(const QCameraParameters& params) |
| { |
| status_t rc = NO_ERROR; |
| |
| ALOGV("%s: E",__func__); |
| |
| |
| if( !( cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_ZOOM))) { |
| ALOGV("%s:MM_CAMERA_PARM_ZOOM not supported", __func__); |
| return NO_ERROR; |
| } |
| // No matter how many different zoom values the driver can provide, HAL |
| // provides applictations the same number of zoom levels. The maximum driver |
| // zoom value depends on sensor output (VFE input) and preview size (VFE |
| // output) because VFE can only crop and cannot upscale. If the preview size |
| // is bigger, the maximum zoom ratio is smaller. However, we want the |
| // zoom ratio of each zoom level is always the same whatever the preview |
| // size is. Ex: zoom level 1 is always 1.2x, zoom level 2 is 1.44x, etc. So, |
| // we need to have a fixed maximum zoom value and do read it from the |
| // driver. |
| static const int ZOOM_STEP = 1; |
| int32_t zoom_level = params.getInt("zoom"); |
| if(zoom_level >= 0 && zoom_level <= mMaxZoom-1) { |
| mParameters.set("zoom", zoom_level); |
| int32_t zoom_value = ZOOM_STEP * zoom_level; |
| bool ret = native_set_parms(MM_CAMERA_PARM_ZOOM, |
| sizeof(zoom_value), (void *)&zoom_value); |
| if(ret) { |
| mCurrentZoom=zoom_level; |
| } |
| rc = ret ? NO_ERROR : UNKNOWN_ERROR; |
| } else { |
| rc = BAD_VALUE; |
| } |
| ALOGV("%s X",__func__); |
| return rc; |
| |
| } |
| |
| status_t QCameraHardwareInterface::setISOValue(const QCameraParameters& params) { |
| |
| status_t rc = NO_ERROR; |
| ALOGV("%s",__func__); |
| |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_ISO); |
| if(!rc) { |
| ALOGV("%s:MM_CAMERA_PARM_ISO not supported", __func__); |
| return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_ISO_MODE); |
| ALOGV("ISO string : %s", str); |
| int8_t temp_hjr; |
| if (str != NULL) { |
| int value = (camera_iso_mode_type)attr_lookup( |
| iso, sizeof(iso) / sizeof(str_map), str); |
| ALOGV("ISO string : %s", str); |
| if (value != NOT_FOUND) { |
| camera_iso_mode_type temp = (camera_iso_mode_type) value; |
| if (value == CAMERA_ISO_DEBLUR) { |
| temp_hjr = true; |
| native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr); |
| mHJR = value; |
| } |
| else { |
| if (mHJR == CAMERA_ISO_DEBLUR) { |
| temp_hjr = false; |
| native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr); |
| mHJR = value; |
| } |
| } |
| |
| mParameters.set(QCameraParameters::KEY_ISO_MODE, str); |
| native_set_parms(MM_CAMERA_PARM_ISO, sizeof(camera_iso_mode_type), (void *)&temp); |
| mIsoValue = (int)temp; |
| return NO_ERROR; |
| } |
| } |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::updateFocusDistances() |
| { |
| ALOGV("%s: IN", __FUNCTION__); |
| focus_distances_info_t focusDistances; |
| if(cam_config_get_parm(mCameraId, MM_CAMERA_PARM_FOCUS_DISTANCES, |
| &focusDistances) == MM_CAMERA_OK) { |
| String8 str; |
| char buffer[32] = {0}; |
| //set all distances to infinity if focus mode is infinity |
| if(mFocusMode == AF_MODE_INFINITY) { |
| snprintf(buffer, sizeof(buffer), "Infinity,"); |
| str.append(buffer); |
| snprintf(buffer, sizeof(buffer), "Infinity,"); |
| str.append(buffer); |
| snprintf(buffer, sizeof(buffer), "Infinity"); |
| str.append(buffer); |
| } else { |
| snprintf(buffer, sizeof(buffer), "%f", focusDistances.focus_distance[0]); |
| str.append(buffer); |
| snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[1]); |
| str.append(buffer); |
| snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[2]); |
| str.append(buffer); |
| } |
| ALOGV("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string()); |
| mFocusDistance = str; |
| return NO_ERROR; |
| } |
| ALOGE("%s: get CAMERA_PARM_FOCUS_DISTANCES failed!!!", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| |
| // Parse string like "(1, 2, 3, 4, ..., N)" |
| // num is pointer to an allocated array of size N |
| static int parseNDimVector(const char *str, int *num, int N, char delim = ',') |
| { |
| char *start, *end; |
| if(num == NULL) { |
| ALOGE("Invalid output array (num == NULL)"); |
| return -1; |
| } |
| //check if string starts and ends with parantheses |
| if(str[0] != '(' || str[strlen(str)-1] != ')') { |
| ALOGE("Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", str); |
| return -1; |
| } |
| start = (char*) str; |
| start++; |
| for(int i=0; i<N; i++) { |
| *(num+i) = (int) strtol(start, &end, 10); |
| if(*end != delim && i < N-1) { |
| ALOGE("Cannot find delimeter '%c' in string \"%s\". end = %c", delim, str, *end); |
| return -1; |
| } |
| start = end+1; |
| } |
| return 0; |
| } |
| |
| // parse string like "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..." |
| static int parseCameraAreaString(const char* str, int max_num_areas, |
| camera_area_t *pAreas, int *num_areas_found) |
| { |
| char area_str[32]; |
| const char *start, *end, *p; |
| start = str; end = NULL; |
| int values[5], index=0; |
| *num_areas_found = 0; |
| |
| while(start != NULL) { |
| if(*start != '(') { |
| ALOGE("%s: error: Ill formatted area string: %s", __func__, str); |
| return -1; |
| } |
| end = strchr(start, ')'); |
| if(end == NULL) { |
| ALOGE("%s: error: Ill formatted area string: %s", __func__, str); |
| return -1; |
| } |
| int i; |
| for (i=0,p=start; p<=end; p++, i++) { |
| area_str[i] = *p; |
| } |
| area_str[i] = '\0'; |
| if(parseNDimVector(area_str, values, 5) < 0){ |
| ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str); |
| return -1; |
| } |
| // no more areas than max_num_areas are accepted. |
| if(index >= max_num_areas) { |
| ALOGE("%s: error: too many areas specified %s", __func__, str); |
| return -1; |
| } |
| pAreas[index].x1 = values[0]; |
| pAreas[index].y1 = values[1]; |
| pAreas[index].x2 = values[2]; |
| pAreas[index].y2 = values[3]; |
| pAreas[index].weight = values[4]; |
| |
| index++; |
| start = strchr(end, '('); // serach for next '(' |
| } |
| (*num_areas_found) = index; |
| return 0; |
| } |
| static bool validateCameraAreas(camera_area_t *areas, int num_areas) |
| { |
| for(int i=0; i<num_areas; i++) { |
| |
| // handle special case (0, 0, 0, 0, 0) |
| if((areas[i].x1 == 0) && (areas[i].y1 == 0) |
| && (areas[i].x2 == 0) && (areas[i].y2 == 0) && (areas[i].weight == 0)) { |
| continue; |
| } |
| if(areas[i].x1 < -1000) return false; // left should be >= -1000 |
| if(areas[i].y1 < -1000) return false; // top should be >= -1000 |
| if(areas[i].x2 > 1000) return false; // right should be <= 1000 |
| if(areas[i].y2 > 1000) return false; // bottom should be <= 1000 |
| if(areas[i].weight <= 0 || areas[i].weight > 1000) // weight should be in [1, 1000] |
| return false; |
| if(areas[i].x1 >= areas[i].x2) { // left should be < right |
| return false; |
| } |
| if(areas[i].y1 >= areas[i].y2) // top should be < bottom |
| return false; |
| } |
| return true; |
| } |
| |
| status_t QCameraHardwareInterface::setFocusAreas(const QCameraParameters& params) |
| { |
| ALOGV("%s: E", __func__); |
| status_t rc; |
| int max_num_af_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS); |
| if(max_num_af_areas == 0) { |
| return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_FOCUS_AREAS); |
| if (str == NULL) { |
| ALOGE("%s: Parameter string is null", __func__); |
| rc = NO_ERROR; |
| } else { |
| camera_area_t *areas = new camera_area_t[max_num_af_areas]; |
| int num_areas_found=0; |
| if(parseCameraAreaString(str, max_num_af_areas, areas, &num_areas_found) < 0) { |
| ALOGE("%s: Failed to parse the string: %s", __func__, str); |
| delete areas; |
| return BAD_VALUE; |
| } |
| for(int i=0; i<num_areas_found; i++) { |
| ALOGV("FocusArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1), |
| (areas[i].x2), (areas[i].y2), (areas[i].weight)); |
| } |
| if(validateCameraAreas(areas, num_areas_found) == false) { |
| ALOGE("%s: invalid areas specified : %s", __func__, str); |
| delete areas; |
| return BAD_VALUE; |
| } |
| mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, str); |
| num_areas_found = 1; //temp; need to change after the multi-roi is enabled |
| |
| //if the native_set_parms is called when preview is not started, it |
| //crashes in lower layer, so return of preview is not started |
| if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) { |
| delete areas; |
| return NO_ERROR; |
| } |
| |
| //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0, |
| //so no action is takenby the lower layer |
| if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0) |
| && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) { |
| num_areas_found = 0; |
| } |
| #if 1 //temp solution |
| |
| roi_info_t af_roi_value; |
| memset(&af_roi_value, 0, sizeof(roi_info_t)); |
| uint16_t x1, x2, y1, y2, dx, dy; |
| int previewWidth, previewHeight; |
| this->getPreviewSize(&previewWidth, &previewHeight); |
| //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) |
| x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f)); |
| y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f)); |
| x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f)); |
| y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f)); |
| dx = x2 - x1; |
| dy = y2 - y1; |
| |
| af_roi_value.num_roi = num_areas_found; |
| af_roi_value.roi[0].x = x1; |
| af_roi_value.roi[0].y = y1; |
| af_roi_value.roi[0].dx = dx; |
| af_roi_value.roi[0].dy = dy; |
| af_roi_value.is_multiwindow = 0; |
| if (native_set_parms(MM_CAMERA_PARM_AF_ROI, sizeof(roi_info_t), (void*)&af_roi_value)) |
| rc = NO_ERROR; |
| else |
| rc = BAD_VALUE; |
| delete areas; |
| #endif |
| #if 0 //better solution with multi-roi, to be enabled later |
| af_mtr_area_t afArea; |
| afArea.num_area = num_areas_found; |
| |
| uint16_t x1, x2, y1, y2, dx, dy; |
| int previewWidth, previewHeight; |
| this->getPreviewSize(&previewWidth, &previewHeight); |
| |
| for(int i=0; i<num_areas_found; i++) { |
| //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) |
| x1 = (uint16_t)((areas[i].x1 + 1000.0f)*(previewWidth/2000.0f)); |
| y1 = (uint16_t)((areas[i].y1 + 1000.0f)*(previewHeight/2000.0f)); |
| x2 = (uint16_t)((areas[i].x2 + 1000.0f)*(previewWidth/2000.0f)); |
| y2 = (uint16_t)((areas[i].y2 + 1000.0f)*(previewHeight/2000.0f)); |
| dx = x2 - x1; |
| dy = y2 - y1; |
| afArea.mtr_area[i].x = x1; |
| afArea.mtr_area[i].y = y1; |
| afArea.mtr_area[i].dx = dx; |
| afArea.mtr_area[i].dy = dy; |
| afArea.weight[i] = areas[i].weight; |
| } |
| |
| if(native_set_parms(MM_CAMERA_PARM_AF_MTR_AREA, sizeof(af_mtr_area_t), (void*)&afArea)) |
| rc = NO_ERROR; |
| else |
| rc = BAD_VALUE;*/ |
| #endif |
| } |
| ALOGV("%s: X", __func__); |
| return rc; |
| } |
| |
| status_t QCameraHardwareInterface::setMeteringAreas(const QCameraParameters& params) |
| { |
| ALOGV("%s: E", __func__); |
| status_t rc; |
| int max_num_mtr_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_METERING_AREAS); |
| if(max_num_mtr_areas == 0) { |
| return NO_ERROR; |
| } |
| |
| const char *str = params.get(QCameraParameters::KEY_METERING_AREAS); |
| if (str == NULL) { |
| ALOGE("%s: Parameter string is null", __func__); |
| rc = NO_ERROR; |
| } else { |
| camera_area_t *areas = new camera_area_t[max_num_mtr_areas]; |
| int num_areas_found=0; |
| if(parseCameraAreaString(str, max_num_mtr_areas, areas, &num_areas_found) < 0) { |
| ALOGE("%s: Failed to parse the string: %s", __func__, str); |
| delete areas; |
| return BAD_VALUE; |
| } |
| for(int i=0; i<num_areas_found; i++) { |
| ALOGV("MeteringArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1), |
| (areas[i].x2), (areas[i].y2), (areas[i].weight)); |
| } |
| if(validateCameraAreas(areas, num_areas_found) == false) { |
| ALOGE("%s: invalid areas specified : %s", __func__, str); |
| delete areas; |
| return BAD_VALUE; |
| } |
| mParameters.set(QCameraParameters::KEY_METERING_AREAS, str); |
| |
| //if the native_set_parms is called when preview is not started, it |
| //crashes in lower layer, so return of preview is not started |
| if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) { |
| delete areas; |
| return NO_ERROR; |
| } |
| |
| num_areas_found = 1; //temp; need to change after the multi-roi is enabled |
| |
| //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0, |
| //so no action is takenby the lower layer |
| if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0) |
| && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) { |
| num_areas_found = 0; |
| } |
| #if 1 |
| cam_set_aec_roi_t aec_roi_value; |
| uint16_t x1, x2, y1, y2; |
| int previewWidth, previewHeight; |
| this->getPreviewSize(&previewWidth, &previewHeight); |
| //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) |
| x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f)); |
| y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f)); |
| x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f)); |
| y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f)); |
| delete areas; |
| |
| if(num_areas_found == 1) { |
| aec_roi_value.aec_roi_enable = AEC_ROI_ON; |
| aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE; |
| aec_roi_value.aec_roi_position.coordinate.x = (x1+x2)/2; |
| aec_roi_value.aec_roi_position.coordinate.y = (y1+y2)/2; |
| } else { |
| aec_roi_value.aec_roi_enable = AEC_ROI_OFF; |
| aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE; |
| aec_roi_value.aec_roi_position.coordinate.x = DONT_CARE_COORDINATE; |
| aec_roi_value.aec_roi_position.coordinate.y = DONT_CARE_COORDINATE; |
| } |
| |
| if(native_set_parms(MM_CAMERA_PARM_AEC_ROI, sizeof(cam_set_aec_roi_t), (void *)&aec_roi_value)) |
| rc = NO_ERROR; |
| else |
| rc = BAD_VALUE; |
| #endif |
| #if 0 //solution including multi-roi, to be enabled later |
| aec_mtr_area_t aecArea; |
| aecArea.num_area = num_areas_found; |
| |
| uint16_t x1, x2, y1, y2, dx, dy; |
| int previewWidth, previewHeight; |
| this->getPreviewSize(&previewWidth, &previewHeight); |
| |
| for(int i=0; i<num_areas_found; i++) { |
| //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) |
| x1 = (uint16_t)((areas[i].x1 + 1000.0f)*(previewWidth/2000.0f)); |
| y1 = (uint16_t)((areas[i].y1 + 1000.0f)*(previewHeight/2000.0f)); |
| x2 = (uint16_t)((areas[i].x2 + 1000.0f)*(previewWidth/2000.0f)); |
| y2 = (uint16_t)((areas[i].y2 + 1000.0f)*(previewHeight/2000.0f)); |
| dx = x2 - x1; |
| dy = y2 - y1; |
| aecArea.mtr_area[i].x = x1; |
| aecArea.mtr_area[i].y = y1; |
| aecArea.mtr_area[i].dx = dx; |
| aecArea.mtr_area[i].dy = dy; |
| aecArea.weight[i] = areas[i].weight; |
| } |
| delete areas; |
| |
| if(native_set_parms(MM_CAMERA_PARM_AEC_MTR_AREA, sizeof(aec_mtr_area_t), (void*)&aecArea)) |
| rc = NO_ERROR; |
| else |
| rc = BAD_VALUE; |
| #endif |
| } |
| ALOGV("%s: X", __func__); |
| return rc; |
| } |
| |
| status_t QCameraHardwareInterface::setFocusMode(const QCameraParameters& params) |
| { |
| const char *str = params.get(QCameraParameters::KEY_FOCUS_MODE); |
| const char *prev_str = mParameters.get(QCameraParameters::KEY_FOCUS_MODE); |
| ALOGV("%s",__func__); |
| if (str != NULL) { |
| ALOGV("Focus mode %s",str); |
| int32_t value = attr_lookup(focus_modes, |
| sizeof(focus_modes) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| mParameters.set(QCameraParameters::KEY_FOCUS_MODE, str); |
| mFocusMode = value; |
| |
| if(updateFocusDistances() != NO_ERROR) { |
| ALOGE("%s: updateFocusDistances failed for %s", __FUNCTION__, str); |
| return UNKNOWN_ERROR; |
| } |
| mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string()); |
| if(mHasAutoFocusSupport){ |
| bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_MODE, |
| sizeof(value), |
| (void *)&value); |
| |
| int cafSupport = false; |
| int caf_type=0; |
| const char *str_hdr = mParameters.get(QCameraParameters::KEY_SCENE_MODE); |
| if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) || |
| !strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)){ |
| cafSupport = true; |
| bool rc = false; |
| if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO)) |
| { |
| caf_type = 1; |
| rc = native_set_parms(MM_CAMERA_PARM_CAF_TYPE, sizeof(caf_type), (void *)&caf_type); |
| } |
| else if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)) |
| { |
| caf_type = 2; |
| rc = native_set_parms(MM_CAMERA_PARM_CAF_TYPE, sizeof(caf_type), (void *)&caf_type); |
| } |
| ALOGV("caf_type %d rc %d", caf_type, rc); |
| } |
| ALOGV("Continuous Auto Focus %d", cafSupport); |
| if(mAutoFocusRunning && cafSupport){ |
| mAutoFocusRunning = false; |
| if(MM_CAMERA_OK!=cam_ops_action(mCameraId,false,MM_CAMERA_OPS_FOCUS,NULL )) { |
| ALOGE("%s: AF command failed err:%d error %s",__func__, errno,strerror(errno)); |
| } |
| } |
| ret = native_set_parms(MM_CAMERA_PARM_CONTINUOUS_AF, sizeof(cafSupport), |
| (void *)&cafSupport); |
| } |
| |
| return NO_ERROR; |
| } |
| ALOGV("%s:Could not look up str value",__func__); |
| } |
| ALOGE("Invalid focus mode value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setSceneMode(const QCameraParameters& params) |
| { |
| status_t rc = NO_ERROR; |
| ALOGV("%s",__func__); |
| |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_BESTSHOT_MODE); |
| if(!rc) { |
| ALOGV("%s:Parameter Scenemode is not supported for this sensor", __func__); |
| return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_SCENE_MODE); |
| const char *oldstr = mParameters.get(QCameraParameters::KEY_SCENE_MODE); |
| |
| if (str != NULL && oldstr != NULL) { |
| int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| /* Check to see if there was a change of scene mode */ |
| if(strcmp(str,oldstr)) { |
| ALOGV("%s: valued changed from %s to %s",__func__,oldstr, str); |
| |
| /* Check if we are either transitioning to/from HDR state |
| if yes preview needs restart*/ |
| if(!strcmp(str, "hdr") || !strcmp(oldstr, "hdr") ) { |
| ALOGV("Changed between HDR/non-HDR states"); |
| |
| /* Restart only if preview already running*/ |
| if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED) { |
| ALOGV("Preview in progress,restarting for HDR transition"); |
| mParameters.set(QCameraParameters::KEY_SCENE_MODE, str); |
| mRestartPreview = 1; |
| pausePreviewForZSL(); |
| } |
| } |
| } |
| |
| mParameters.set(QCameraParameters::KEY_SCENE_MODE, str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_BESTSHOT_MODE, sizeof(value), |
| (void *)&value); |
| int bestshot_reconfigure; |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_BESTSHOT_RECONFIGURE, |
| &bestshot_reconfigure); |
| if(bestshot_reconfigure) { |
| if (mBestShotMode != value) { |
| mBestShotMode = value; |
| if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) { |
| ALOGV("%s:Bestshot trigerring restart",__func__); |
| mRestartPreview = 1; |
| pausePreviewForZSL(); |
| } |
| } |
| } |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| } |
| ALOGE("Invalid scenemode value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setSelectableZoneAf(const QCameraParameters& params) |
| { |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| if(mHasAutoFocusSupport) { |
| const char *str = params.get(QCameraParameters::KEY_SELECTABLE_ZONE_AF); |
| if (str != NULL) { |
| int32_t value = attr_lookup(selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FOCUS_RECT); |
| if(!rc) { |
| ALOGV("SelectableZoneAF is not supported for this sensor"); |
| return NO_ERROR; |
| }else { |
| mParameters.set(QCameraParameters::KEY_SELECTABLE_ZONE_AF, str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_RECT, sizeof(value), |
| (void *)&value); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| } |
| } |
| ALOGE("Invalid selectable zone af value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setEffect(const QCameraParameters& params) |
| { |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| const char *str = params.get(QCameraParameters::KEY_EFFECT); |
| int result; |
| if (str != NULL) { |
| ALOGV("Setting effect %s",str); |
| int32_t value = attr_lookup(effects, sizeof(effects) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_EFFECT); |
| if(!rc) { |
| ALOGV("Camera Effect - %s mode is not supported for this sensor",str); |
| return NO_ERROR; |
| }else { |
| mParameters.set(QCameraParameters::KEY_EFFECT, str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_EFFECT, sizeof(value), |
| (void *)&value,(int *)&result); |
| if(result != MM_CAMERA_OK) { |
| ALOGE("Camera Effect: %s is not set as the selected value is not supported ", str); |
| } |
| int bestshot_reconfigure; |
| cam_config_get_parm(mCameraId, MM_CAMERA_PARM_BESTSHOT_RECONFIGURE, |
| &bestshot_reconfigure); |
| if(bestshot_reconfigure) { |
| if (mEffects != value) { |
| mEffects = value; |
| if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) { |
| mRestartPreview = 1; |
| pausePreviewForZSL(); |
| } |
| } |
| } |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| } |
| } |
| ALOGE("Invalid effect value: %s", (str == NULL) ? "NULL" : str); |
| ALOGV("setEffect X"); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setBrightness(const QCameraParameters& params) { |
| |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_BRIGHTNESS); |
| if(!rc) { |
| ALOGV("MM_CAMERA_PARM_BRIGHTNESS mode is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| int brightness = params.getInt("luma-adaptation"); |
| if (mBrightness != brightness) { |
| ALOGV(" new brightness value : %d ", brightness); |
| mBrightness = brightness; |
| mParameters.set("luma-adaptation", brightness); |
| bool ret = native_set_parms(MM_CAMERA_PARM_BRIGHTNESS, sizeof(mBrightness), |
| (void *)&mBrightness); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setAutoExposure(const QCameraParameters& params) |
| { |
| |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_EXPOSURE); |
| if(!rc) { |
| ALOGV("MM_CAMERA_PARM_EXPOSURE mode is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_AUTO_EXPOSURE); |
| if (str != NULL) { |
| int32_t value = attr_lookup(autoexposure, sizeof(autoexposure) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE, str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE, sizeof(value), |
| (void *)&value); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| } |
| ALOGE("Invalid auto exposure value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setExposureCompensation( |
| const QCameraParameters & params){ |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_EXPOSURE_COMPENSATION); |
| if(!rc) { |
| ALOGV("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| int numerator = params.getInt(QCameraParameters::KEY_EXPOSURE_COMPENSATION); |
| if(EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR <= numerator && |
| numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){ |
| int16_t numerator16 = (int16_t)(numerator & 0x0000ffff); |
| uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR; |
| uint32_t value = 0; |
| value = numerator16 << 16 | denominator16; |
| |
| const char *sce_str = params.get(QCameraParameters::KEY_SCENE_MODE); |
| if (sce_str != NULL) { |
| if(!strcmp(sce_str, "sunset")){ |
| //Exposure comp value in sunset scene mode |
| mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION, |
| -6); |
| }else{ |
| //Exposure comp value for other |
| mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION, |
| numerator); |
| } |
| }else { |
| mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION, |
| numerator); |
| } |
| bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE_COMPENSATION, |
| sizeof(value), (void *)&value); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| ALOGE("Invalid Exposure Compensation"); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setWhiteBalance(const QCameraParameters& params) |
| { |
| |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| int result; |
| const char *str = NULL; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_WHITE_BALANCE); |
| if(!rc) { |
| ALOGV("MM_CAMERA_PARM_WHITE_BALANCE mode is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| |
| const char *sce_str = params.get(QCameraParameters::KEY_SCENE_MODE); |
| if (sce_str != NULL) { |
| if(!strcmp(sce_str, "sunset")){ |
| //AWB value in sunset scene mode |
| str = QCameraParameters::WHITE_BALANCE_DAYLIGHT; |
| mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str); |
| }else if(!strcmp(sce_str, "auto")){ |
| str = params.get(QCameraParameters::KEY_WHITE_BALANCE); |
| }else{ |
| //AWB in other scene Mode |
| str = QCameraParameters::WHITE_BALANCE_AUTO; |
| mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str); |
| } |
| }else { |
| str = params.get(QCameraParameters::KEY_WHITE_BALANCE); |
| } |
| |
| if (str != NULL) { |
| int32_t value = attr_lookup(whitebalance, sizeof(whitebalance) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_WHITE_BALANCE, sizeof(value), |
| (void *)&value, (int *)&result); |
| if(result != MM_CAMERA_OK) { |
| ALOGE("WhiteBalance Value: %s is not set as the selected value is not supported ", str); |
| } |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| } |
| ALOGE("Invalid whitebalance value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setAntibanding(const QCameraParameters& params) |
| { |
| int result; |
| |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_ANTIBANDING); |
| if(!rc) { |
| ALOGV("ANTIBANDING mode is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_ANTIBANDING); |
| if (str != NULL) { |
| int value = (camera_antibanding_type)attr_lookup( |
| antibanding, sizeof(antibanding) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| camera_antibanding_type temp = (camera_antibanding_type) value; |
| ALOGV("Antibanding Value : %d",value); |
| mParameters.set(QCameraParameters::KEY_ANTIBANDING, str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_ANTIBANDING, |
| sizeof(camera_antibanding_type), (void *)&value ,(int *)&result); |
| if(result != MM_CAMERA_OK) { |
| ALOGE("AntiBanding Value: %s is not supported for the given BestShot Mode", str); |
| } |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| } |
| ALOGE("Invalid antibanding value: %s", (str == NULL) ? "NULL" : str); |
| |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setPreviewFrameRate(const QCameraParameters& params) |
| { |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS); |
| if(!rc) { |
| ALOGV("MM_CAMERA_PARM_FPS is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| uint16_t previousFps = (uint16_t)mParameters.getPreviewFrameRate(); |
| uint16_t fps = (uint16_t)params.getPreviewFrameRate(); |
| ALOGV("requested preview frame rate is %u", fps); |
| |
| if(mInitialized && (fps == previousFps)){ |
| ALOGV("No change is FPS Value %d",fps ); |
| return NO_ERROR; |
| } |
| |
| if(MINIMUM_FPS <= fps && fps <=MAXIMUM_FPS){ |
| mParameters.setPreviewFrameRate(fps); |
| bool ret = native_set_parms(MM_CAMERA_PARM_FPS, |
| sizeof(fps), (void *)&fps); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setPreviewFrameRateMode(const QCameraParameters& params) { |
| |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS); |
| if(!rc) { |
| ALOGV(" CAMERA FPS mode is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS_MODE); |
| if(!rc) { |
| ALOGV("CAMERA FPS MODE mode is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| |
| const char *previousMode = mParameters.getPreviewFrameRateMode(); |
| const char *str = params.getPreviewFrameRateMode(); |
| if (NULL == previousMode) { |
| ALOGV("Preview Frame Rate Mode is NULL\n"); |
| return NO_ERROR; |
| } |
| if (NULL == str) { |
| ALOGV("Preview Frame Rate Mode is NULL\n"); |
| return NO_ERROR; |
| } |
| int32_t frameRateMode = attr_lookup(frame_rate_modes, sizeof(frame_rate_modes) / sizeof(str_map),str); |
| if(frameRateMode != NOT_FOUND) { |
| ALOGV("setPreviewFrameRateMode: %s ", str); |
| mParameters.setPreviewFrameRateMode(str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(frameRateMode), (void *)&frameRateMode); |
| if(!ret) return ret; |
| //set the fps value when chaging modes |
| int16_t fps = (uint16_t)params.getPreviewFrameRate(); |
| if(MINIMUM_FPS <= fps && fps <=MAXIMUM_FPS){ |
| mParameters.setPreviewFrameRate(fps); |
| ret = native_set_parms(MM_CAMERA_PARM_FPS, |
| sizeof(fps), (void *)&fps); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| ALOGE("Invalid preview frame rate value: %d", fps); |
| return BAD_VALUE; |
| } |
| ALOGE("Invalid preview frame rate mode value: %s", (str == NULL) ? "NULL" : str); |
| |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setSkinToneEnhancement(const QCameraParameters& params) { |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_SCE_FACTOR); |
| if(!rc) { |
| ALOGV("SkinToneEnhancement is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| int skinToneValue = params.getInt("skinToneEnhancement"); |
| if (mSkinToneEnhancement != skinToneValue) { |
| ALOGV(" new skinTone correction value : %d ", skinToneValue); |
| mSkinToneEnhancement = skinToneValue; |
| mParameters.set("skinToneEnhancement", skinToneValue); |
| bool ret = native_set_parms(MM_CAMERA_PARM_SCE_FACTOR, sizeof(mSkinToneEnhancement), |
| (void *)&mSkinToneEnhancement); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setWaveletDenoise(const QCameraParameters& params) { |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_WAVELET_DENOISE); |
| if(rc != MM_CAMERA_PARM_SUPPORT_SET) { |
| ALOGV("Wavelet Denoise is not supported for this sensor"); |
| /* TO DO */ |
| // return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_DENOISE); |
| if (str != NULL) { |
| int value = attr_lookup(denoise, |
| sizeof(denoise) / sizeof(str_map), str); |
| if ((value != NOT_FOUND) && (mDenoiseValue != value)) { |
| mDenoiseValue = value; |
| mParameters.set(QCameraParameters::KEY_DENOISE, str); |
| |
| char prop[PROPERTY_VALUE_MAX]; |
| memset(prop, 0, sizeof(prop)); |
| property_get("persist.denoise.process.plates", prop, "1"); |
| |
| denoise_param_t temp; |
| memset(&temp, 0, sizeof(denoise_param_t)); |
| temp.denoise_enable = value; |
| temp.process_plates = atoi(prop); |
| ALOGV("Denoise enable=%d, plates=%d", temp.denoise_enable, temp.process_plates); |
| bool ret = native_set_parms(MM_CAMERA_PARM_WAVELET_DENOISE, sizeof(temp), |
| (void *)&temp); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| return NO_ERROR; |
| } |
| ALOGE("Invalid Denoise value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setVideoSize(const QCameraParameters& params) |
| { |
| const char *str= NULL; |
| const char *str_t= NULL; |
| int old_vid_w = 0, old_vid_h = 0; |
| ALOGV("%s: E", __func__); |
| str = params.get(QCameraParameters::KEY_VIDEO_SIZE); |
| str_t = mParameters.get(CameraParameters::KEY_VIDEO_SIZE); |
| if(!str) { |
| mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, ""); |
| //If application didn't set this parameter string, use the values from |
| //getPreviewSize() as video dimensions. |
| ALOGV("No Record Size requested, use the preview dimensions"); |
| mVideoWidth = mPreviewWidth; |
| mVideoHeight = mPreviewHeight; |
| } else { |
| //Extract the record witdh and height that application requested. |
| ALOGV("%s: requested record size %s", __func__, str); |
| if(!parse_size(str, mVideoWidth, mVideoHeight)) { |
| parse_size(str_t, old_vid_w, old_vid_h); |
| if(old_vid_w != mVideoWidth || old_vid_h != mVideoHeight) { |
| mRestartPreview = true; |
| ALOGV("%s: Video sizes changes, Restart preview...", __func__); |
| } |
| mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, str); |
| } else { |
| mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, ""); |
| ALOGE("%s: error :failed to parse parameter record-size (%s)", __func__, str); |
| return BAD_VALUE; |
| } |
| } |
| ALOGV("%s: preview dimensions: %dx%d", __func__, mPreviewWidth, mPreviewHeight); |
| ALOGV("%s: video dimensions: %dx%d", __func__, mVideoWidth, mVideoHeight); |
| |
| ALOGV("%s: X", __func__); |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setCameraMode(const QCameraParameters& params) { |
| int32_t value = params.getInt(QCameraParameters::KEY_CAMERA_MODE); |
| mParameters.set(QCameraParameters::KEY_CAMERA_MODE,value); |
| |
| ALOGV("ZSL is enabled %d", value); |
| if (value == 1) { |
| myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE); |
| } else { |
| myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setPowerMode(const QCameraParameters& params) { |
| uint32_t value = NORMAL_POWER; |
| const char *powermode = NULL; |
| |
| powermode = params.get(QCameraParameters::KEY_POWER_MODE); |
| if (powermode != NULL) { |
| value = attr_lookup(power_modes, |
| sizeof(power_modes) / sizeof(str_map), powermode); |
| if((value == LOW_POWER) || mHFRLevel > 1) { |
| ALOGV("Enable Low Power Mode"); |
| value = LOW_POWER; |
| mPowerMode = value; |
| mParameters.set(QCameraParameters::KEY_POWER_MODE,"Low_Power"); |
| } else { |
| ALOGV("Enable Normal Power Mode"); |
| mPowerMode = value; |
| mParameters.set(QCameraParameters::KEY_POWER_MODE,"Normal_Power"); |
| } |
| } |
| |
| ALOGV("%s Low power mode %s value = %d", __func__, |
| value ? "Enabled" : "Disabled", value); |
| native_set_parms(MM_CAMERA_PARM_LOW_POWER_MODE, sizeof(value), |
| (void *)&value); |
| return NO_ERROR; |
| } |
| |
| |
| status_t QCameraHardwareInterface::setPreviewSize(const QCameraParameters& params) |
| { |
| int width, height; |
| params.getPreviewSize(&width, &height); |
| ALOGV("################requested preview size %d x %d", width, height); |
| |
| // Validate the preview size |
| for (size_t i = 0; i < mPreviewSizeCount; ++i) { |
| if (width == mPreviewSizes[i].width |
| && height == mPreviewSizes[i].height) { |
| int old_width, old_height; |
| mParameters.getPreviewSize(&old_width,&old_height); |
| if(width != old_width || height != old_height) { |
| mRestartPreview = true; |
| } |
| mParameters.setPreviewSize(width, height); |
| ALOGV("setPreviewSize: width: %d heigh: %d", width, height); |
| mPreviewWidth = width; |
| mPreviewHeight = height; |
| |
| mDimension.display_width = mPreviewWidth; |
| mDimension.display_height= mPreviewHeight; |
| mDimension.orig_video_width = mPreviewWidth; |
| mDimension.orig_video_height = mPreviewHeight; |
| mDimension.video_width = mPreviewWidth; |
| mDimension.video_height = mPreviewHeight; |
| |
| return NO_ERROR; |
| } |
| } |
| ALOGE("Invalid preview size requested: %dx%d", width, height); |
| return BAD_VALUE; |
| } |
| status_t QCameraHardwareInterface::setPreviewFpsRange(const QCameraParameters& params) |
| { |
| ALOGV("%s: E", __func__); |
| int minFps,maxFps; |
| int prevMinFps, prevMaxFps; |
| int rc = NO_ERROR; |
| bool found = false; |
| |
| mParameters.getPreviewFpsRange(&prevMinFps, &prevMaxFps); |
| ALOGV("%s: Existing FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps); |
| params.getPreviewFpsRange(&minFps,&maxFps); |
| ALOGV("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps); |
| |
| if(mInitialized && (minFps == prevMinFps && maxFps == prevMaxFps)) { |
| ALOGV("%s: No change in FpsRange", __func__); |
| rc = NO_ERROR; |
| goto end; |
| } |
| for(size_t i=0; i<FPS_RANGES_SUPPORTED_COUNT; i++) { |
| // if the value is in the supported list |
| if(minFps==FpsRangesSupported[i].minFPS && maxFps == FpsRangesSupported[i].maxFPS){ |
| found = true; |
| ALOGV("FPS: i=%d : minFps = %d, maxFps = %d ",i,FpsRangesSupported[i].minFPS,FpsRangesSupported[i].maxFPS ); |
| mParameters.setPreviewFpsRange(minFps,maxFps); |
| // validate the values |
| bool valid = true; |
| // FPS can not be negative |
| if(minFps < 0 || maxFps < 0) valid = false; |
| // minFps must be >= maxFps |
| if(minFps > maxFps) valid = false; |
| |
| if(valid) { |
| //Set the FPS mode |
| const char *str = (minFps == maxFps) ? |
| QCameraParameters::KEY_PREVIEW_FRAME_RATE_FIXED_MODE: |
| QCameraParameters::KEY_PREVIEW_FRAME_RATE_AUTO_MODE; |
| ALOGV("%s FPS_MODE = %s", __func__, str); |
| int32_t frameRateMode = attr_lookup(frame_rate_modes, |
| sizeof(frame_rate_modes) / sizeof(str_map),str); |
| bool ret; |
| ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(int32_t), |
| (void *)&frameRateMode); |
| |
| //set FPS values |
| uint32_t fps; //lower 2 bytes specify maxFps and higher 2 bytes specify minFps |
| fps = ((uint32_t)(minFps/1000) << 16) + ((uint16_t)(maxFps/1000)); |
| ret = native_set_parms(MM_CAMERA_PARM_FPS, sizeof(uint32_t), (void *)&fps); |
| mParameters.setPreviewFpsRange(minFps, maxFps); |
| if(ret) |
| rc = NO_ERROR; |
| else { |
| rc = BAD_VALUE; |
| ALOGE("%s: error: native_set_params failed", __func__); |
| } |
| } else { |
| ALOGE("%s: error: invalid FPS range value", __func__); |
| rc = BAD_VALUE; |
| } |
| } |
| } |
| if(found == false){ |
| ALOGE("%s: error: FPS range value not supported", __func__); |
| rc = BAD_VALUE; |
| } |
| end: |
| ALOGV("%s: X", __func__); |
| return rc; |
| } |
| |
| status_t QCameraHardwareInterface::setJpegThumbnailSize(const QCameraParameters& params){ |
| int width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); |
| int height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); |
| |
| ALOGV("requested jpeg thumbnail size %d x %d", width, height); |
| |
| // Validate the picture size |
| for (unsigned int i = 0; i < thumbnail_sizes_count; ++i) { |
| if (width == default_thumbnail_sizes[i].width |
| && height == default_thumbnail_sizes[i].height) { |
| thumbnailWidth = width; |
| thumbnailHeight = height; |
| mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); |
| mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); |
| return NO_ERROR; |
| } |
| } |
| ALOGE("error: setting jpeg thumbnail size"); |
| return BAD_VALUE; |
| } |
| status_t QCameraHardwareInterface::setPictureSize(const QCameraParameters& params) |
| { |
| int width, height; |
| ALOGV("QualcommCameraHardware::setPictureSize E"); |
| params.getPictureSize(&width, &height); |
| ALOGV("requested picture size %d x %d", width, height); |
| |
| // Validate the picture size |
| for (int i = 0; i < mSupportedPictureSizesCount; ++i) { |
| if (width == mPictureSizesPtr[i].width |
| && height == mPictureSizesPtr[i].height) { |
| int old_width, old_height; |
| mParameters.getPictureSize(&old_width,&old_height); |
| if(width != old_width || height != old_height) { |
| mRestartPreview = true; |
| } |
| mParameters.setPictureSize(width, height); |
| mDimension.picture_width = width; |
| mDimension.picture_height = height; |
| return NO_ERROR; |
| } |
| } |
| /* Dimension not among the ones in the list. Check if |
| * its a valid dimension, if it is, then configure the |
| * camera accordingly. else reject it. |
| */ |
| if( isValidDimension(width, height) ) { |
| mParameters.setPictureSize(width, height); |
| mDimension.picture_width = width; |
| mDimension.picture_height = height; |
| return NO_ERROR; |
| } else |
| ALOGE("Invalid picture size requested: %dx%d", width, height); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setJpegRotation(int isZsl) { |
| return mm_jpeg_encoder_setRotation(mRotation, isZsl); |
| } |
| |
| int QCameraHardwareInterface::getJpegRotation(void) { |
| return mRotation; |
| } |
| |
| int QCameraHardwareInterface::getISOSpeedValue() |
| { |
| const char *iso_str = mParameters.get(QCameraParameters::KEY_ISO_MODE); |
| int iso_index = attr_lookup(iso, sizeof(iso) / sizeof(str_map), iso_str); |
| int iso_value = iso_speed_values[iso_index]; |
| return iso_value; |
| } |
| |
| |
| status_t QCameraHardwareInterface::setJpegQuality(const QCameraParameters& params) { |
| status_t rc = NO_ERROR; |
| int quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY); |
| ALOGV("setJpegQuality E"); |
| if (quality >= 0 && quality <= 100) { |
| mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, quality); |
| mJpegQuality = quality; |
| } else { |
| ALOGE("Invalid jpeg quality=%d", quality); |
| rc = BAD_VALUE; |
| } |
| |
| quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); |
| if (quality >= 0 && quality <= 100) { |
| mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, quality); |
| } else { |
| ALOGE("Invalid jpeg thumbnail quality=%d", quality); |
| rc = BAD_VALUE; |
| } |
| ALOGV("setJpegQuality X"); |
| return rc; |
| } |
| |
| status_t QCameraHardwareInterface:: |
| setNumOfSnapshot(const QCameraParameters& params) { |
| status_t rc = NO_ERROR; |
| |
| int num_of_snapshot = getNumOfSnapshots(params); |
| |
| if (num_of_snapshot <= 0) { |
| num_of_snapshot = 1; |
| } |
| ALOGV("number of snapshots = %d", num_of_snapshot); |
| mParameters.set("num-snaps-per-shutter", num_of_snapshot); |
| |
| bool result = native_set_parms(MM_CAMERA_PARM_SNAPSHOT_BURST_NUM, |
| sizeof(int), |
| (void *)&num_of_snapshot); |
| if(!result) |
| ALOGE("%s:Failure setting number of snapshots!!!", __func__); |
| return rc; |
| } |
| |
| status_t QCameraHardwareInterface::setPreviewFormat(const QCameraParameters& params) { |
| const char *str = params.getPreviewFormat(); |
| int32_t previewFormat = attr_lookup(preview_formats, sizeof(preview_formats) / sizeof(str_map), str); |
| if(previewFormat != NOT_FOUND) { |
| int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t); |
| int i; |
| |
| for (i = 0; i < num; i++) { |
| if (preview_format_info_list[i].Hal_format == previewFormat) { |
| mPreviewFormatInfo = preview_format_info_list[i]; |
| break; |
| } |
| } |
| |
| if (i == num) { |
| mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21; |
| mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD; |
| return BAD_VALUE; |
| } |
| bool ret = native_set_parms(MM_CAMERA_PARM_PREVIEW_FORMAT, sizeof(cam_format_t), |
| (void *)&mPreviewFormatInfo.mm_cam_format); |
| mParameters.set(QCameraParameters::KEY_PREVIEW_FORMAT, str); |
| mPreviewFormat = mPreviewFormatInfo.mm_cam_format; |
| ALOGV("Setting preview format to %d, i =%d, num=%d, hal_format=%d", |
| mPreviewFormat, i, num, mPreviewFormatInfo.Hal_format); |
| return NO_ERROR; |
| } else if ( strTexturesOn ) { |
| mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21; |
| mPreviewFormatInfo.padding = CAMERA_PAD_TO_4K; |
| } else { |
| mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21; |
| mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD; |
| } |
| ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setStrTextures(const QCameraParameters& params) { |
| const char *str = params.get("strtextures"); |
| const char *prev_str = mParameters.get("strtextures"); |
| |
| if(str != NULL) { |
| if(!strcmp(str,prev_str)) { |
| return NO_ERROR; |
| } |
| int str_size = strlen(str); |
| mParameters.set("strtextures", str); |
| if(str_size == 2) { |
| if(!strncmp(str, "on", str_size) || !strncmp(str, "ON", str_size)){ |
| ALOGV("Resetting mUseOverlay to false"); |
| strTexturesOn = true; |
| mUseOverlay = false; |
| } |
| }else if(str_size == 3){ |
| if (!strncmp(str, "off", str_size) || !strncmp(str, "OFF", str_size)) { |
| strTexturesOn = false; |
| mUseOverlay = true; |
| } |
| } |
| |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setFlash(const QCameraParameters& params) |
| { |
| const char *str = NULL; |
| |
| ALOGV("%s: E",__func__); |
| int rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_LED_MODE); |
| if(!rc) { |
| ALOGV("%s:LED FLASH not supported", __func__); |
| return NO_ERROR; |
| } |
| |
| const char *sce_str = params.get(QCameraParameters::KEY_SCENE_MODE); |
| if (sce_str != NULL) { |
| if (!strcmp(sce_str, "hdr")) { |
| //Flash In HDR |
| str = QCameraParameters::FLASH_MODE_OFF; |
| mParameters.set(QCameraParameters::KEY_FLASH_MODE, str); |
| }else if(!strcmp(sce_str, "auto")){ |
| //Flash Mode in auto scene mode |
| str = params.get(QCameraParameters::KEY_FLASH_MODE); |
| }else{ |
| //FLASH in scene Mode except auto, hdr |
| str = QCameraParameters::FLASH_MODE_AUTO; |
| mParameters.set(QCameraParameters::KEY_FLASH_MODE, str); |
| } |
| }else { |
| str = params.get(QCameraParameters::KEY_FLASH_MODE); |
| } |
| |
| if (str != NULL) { |
| int32_t value = attr_lookup(flash, sizeof(flash) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| mParameters.set(QCameraParameters::KEY_FLASH_MODE, str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_LED_MODE, |
| sizeof(value), (void *)&value); |
| mLedStatusForZsl = (led_mode_t)value; |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| } |
| ALOGE("Invalid flash mode value: %s", (str == NULL) ? "NULL" : str); |
| |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setAecAwbLock(const QCameraParameters & params) |
| { |
| ALOGV("%s : E", __func__); |
| status_t rc = NO_ERROR; |
| int32_t value; |
| const char* str; |
| |
| //for AEC lock |
| str = params.get(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK); |
| value = (strcmp(str, "true") == 0)? 1 : 0; |
| mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK, str); |
| rc = (native_set_parms(MM_CAMERA_PARM_AEC_LOCK, sizeof(int32_t), (void *)(&value))) ? |
| NO_ERROR : UNKNOWN_ERROR; |
| |
| //for AWB lock |
| str = params.get(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK); |
| value = (strcmp(str, "true") == 0)? 1 : 0; |
| mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, str); |
| rc = (native_set_parms(MM_CAMERA_PARM_AWB_LOCK, sizeof(int32_t), (void *)(&value))) ? |
| NO_ERROR : UNKNOWN_ERROR; |
| ALOGV("%s : X", __func__); |
| return rc; |
| } |
| |
| status_t QCameraHardwareInterface::setOverlayFormats(const QCameraParameters& params) |
| { |
| mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP); |
| if(mIs3DModeOn == true) { |
| int ovFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP|HAL_3D_IN_SIDE_BY_SIDE_L_R|HAL_3D_OUT_SIDE_BY_SIDE; |
| mParameters.set("overlay-format", ovFormat); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setMCEValue(const QCameraParameters& params) |
| { |
| ALOGV("%s",__func__); |
| status_t rc = NO_ERROR; |
| rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_MCE); |
| if(!rc) { |
| ALOGV("MM_CAMERA_PARM_MCE mode is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_MEMORY_COLOR_ENHANCEMENT); |
| if (str != NULL) { |
| int value = attr_lookup(mce, sizeof(mce) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| int temp = (int8_t)value; |
| ALOGV("%s: setting MCE value of %s", __FUNCTION__, str); |
| mParameters.set(QCameraParameters::KEY_MEMORY_COLOR_ENHANCEMENT, str); |
| |
| native_set_parms(MM_CAMERA_PARM_MCE, sizeof(int8_t), (void *)&temp); |
| return NO_ERROR; |
| } |
| } |
| ALOGE("Invalid MCE value: %s", (str == NULL) ? "NULL" : str); |
| |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setHighFrameRate(const QCameraParameters& params) |
| { |
| |
| bool mCameraRunning; |
| |
| int rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_HFR); |
| if(!rc) { |
| ALOGV("%s: MM_CAMERA_PARM_HFR not supported", __func__); |
| return NO_ERROR; |
| } |
| |
| const char *str = params.get(QCameraParameters::KEY_VIDEO_HIGH_FRAME_RATE); |
| if (str != NULL) { |
| int value = attr_lookup(hfr, sizeof(hfr) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| mHFRLevel = (int32_t)value; |
| //Check for change in HFR value |
| const char *oldHfr = mParameters.get(QCameraParameters::KEY_VIDEO_HIGH_FRAME_RATE); |
| if(strcmp(oldHfr, str)){ |
| mParameters.set(QCameraParameters::KEY_VIDEO_HIGH_FRAME_RATE, str); |
| // mHFRMode = true; |
| mCameraRunning=isPreviewRunning(); |
| if(mCameraRunning == true) { |
| // mHFRThreadWaitLock.lock(); |
| // pthread_attr_t pattr; |
| // pthread_attr_init(&pattr); |
| // pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_DETACHED); |
| // mHFRThreadRunning = !pthread_create(&mHFRThread, |
| // &pattr, |
| // hfr_thread, |
| // (void*)NULL); |
| // mHFRThreadWaitLock.unlock(); |
| stopPreviewInternal(); |
| mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; |
| native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel); |
| mPreviewState = QCAMERA_HAL_PREVIEW_START; |
| if (startPreview2() == NO_ERROR) |
| mPreviewState = QCAMERA_HAL_PREVIEW_STARTED; |
| return NO_ERROR; |
| } |
| } |
| native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel); |
| return NO_ERROR; |
| } |
| } |
| ALOGE("Invalid HFR value: %s", (str == NULL) ? "NULL" : str); |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setLensshadeValue(const QCameraParameters& params) |
| { |
| |
| int rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_ROLLOFF); |
| if(!rc) { |
| ALOGV("%s:LENS SHADING not supported", __func__); |
| return NO_ERROR; |
| } |
| |
| const char *str = params.get(QCameraParameters::KEY_LENSSHADE); |
| if (str != NULL) { |
| int value = attr_lookup(lensshade, |
| sizeof(lensshade) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| int8_t temp = (int8_t)value; |
| mParameters.set(QCameraParameters::KEY_LENSSHADE, str); |
| native_set_parms(MM_CAMERA_PARM_ROLLOFF, sizeof(int8_t), (void *)&temp); |
| return NO_ERROR; |
| } |
| } |
| ALOGE("Invalid lensShade value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setFaceDetect(const QCameraParameters& params) |
| { |
| if(supportsFaceDetection() == false){ |
| ALOGI("setFaceDetect support is not available"); |
| return NO_ERROR; |
| } |
| |
| int requested_faces = params.getInt(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES); |
| int hardware_supported_faces = mParameters.getInt(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW); |
| if (requested_faces > hardware_supported_faces) { |
| requested_faces = hardware_supported_faces; |
| } |
| mParameters.set(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES, requested_faces); |
| const char *str = params.get(QCameraParameters::KEY_FACE_DETECTION); |
| ALOGV("setFaceDetect: %s", str); |
| if (str != NULL) { |
| fd_set_parm_t fd_set_parm; |
| int value = attr_lookup(facedetection, |
| sizeof(facedetection) / sizeof(str_map), str); |
| mFaceDetectOn = value; |
| fd_set_parm.fd_mode = value; |
| fd_set_parm.num_fd = requested_faces; |
| ALOGV("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces); |
| native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm); |
| mParameters.set(QCameraParameters::KEY_FACE_DETECTION, str); |
| return NO_ERROR; |
| } |
| ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| status_t QCameraHardwareInterface::setFaceDetection(const char *str) |
| { |
| if(supportsFaceDetection() == false){ |
| ALOGV("Face detection is not enabled"); |
| return NO_ERROR; |
| } |
| if (str != NULL) { |
| int requested_faces = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES); |
| int value = attr_lookup(facedetection, |
| sizeof(facedetection) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| fd_set_parm_t fd_set_parm; |
| mMetaDataWaitLock.lock(); |
| mFaceDetectOn = value; |
| mMetaDataWaitLock.unlock(); |
| fd_set_parm.fd_mode = value; |
| fd_set_parm.num_fd = requested_faces; |
| ALOGV("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces); |
| native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm); |
| mParameters.set(QCameraParameters::KEY_FACE_DETECTION, str); |
| return NO_ERROR; |
| } |
| } |
| ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setAEBracket(const QCameraParameters& params) |
| { |
| const char *str; |
| if(!cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_HDR) || (myMode & CAMERA_ZSL_MODE)) { |
| ALOGV("Parameter HDR is not supported for this sensor/ ZSL mode"); |
| |
| if (myMode & CAMERA_ZSL_MODE) { |
| ALOGV("In ZSL mode, reset AEBBracket to HDR_OFF mode"); |
| exp_bracketing_t temp; |
| memset(&temp, 0, sizeof(temp)); |
| mHdrMode = HDR_BRACKETING_OFF; |
| temp.hdr_enable= false; |
| temp.mode = HDR_BRACKETING_OFF; |
| native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); |
| } |
| return NO_ERROR; |
| } |
| |
| const char *str2 = params.get(QCameraParameters::KEY_SCENE_MODE); |
| if(!strcmp(str2, "hdr")) { |
| str="HDR"; |
| } else { |
| str = params.get(QCameraParameters::KEY_AE_BRACKET_HDR); |
| } |
| |
| if (str != NULL) { |
| int value = attr_lookup(hdr_bracket, |
| sizeof(hdr_bracket) / sizeof(str_map), str); |
| exp_bracketing_t temp; |
| memset(&temp, 0, sizeof(temp)); |
| switch (value) { |
| case HDR_MODE: |
| { |
| mHdrMode = HDR_MODE; |
| } |
| break; |
| case EXP_BRACKETING_MODE: |
| { |
| int numFrames = getNumOfSnapshots(); |
| const char *str_val = params.get("capture-burst-exposures"); |
| if ((str_val != NULL) && (strlen(str_val)>0)) { |
| ALOGV("%s: capture-burst-exposures %s", __FUNCTION__, str_val); |
| |
| mHdrMode = EXP_BRACKETING_MODE; |
| temp.hdr_enable = false; |
| temp.mode = EXP_BRACKETING_MODE; |
| temp.total_frames = (numFrames > MAX_SNAPSHOT_BUFFERS -2) ? MAX_SNAPSHOT_BUFFERS -2 : numFrames; |
| temp.total_hal_frames = temp.total_frames; |
| strlcpy(temp.values, str_val, MAX_EXP_BRACKETING_LENGTH); |
| ALOGV("%s: setting Exposure Bracketing value of %s, frame (%d)", __FUNCTION__, temp.values, temp.total_hal_frames); |
| native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); |
| } |
| else { |
| /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */ |
| ALOGV("%s: capture-burst-exposures not set, back to HDR OFF mode", __FUNCTION__); |
| mHdrMode = HDR_BRACKETING_OFF; |
| temp.hdr_enable= false; |
| temp.mode = HDR_BRACKETING_OFF; |
| native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); |
| } |
| } |
| break; |
| case HDR_BRACKETING_OFF: |
| default: |
| { |
| mHdrMode = HDR_BRACKETING_OFF; |
| temp.hdr_enable= false; |
| temp.mode = HDR_BRACKETING_OFF; |
| native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); |
| } |
| break; |
| } |
| |
| /* save the value*/ |
| mParameters.set(QCameraParameters::KEY_AE_BRACKET_HDR, str); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setCaptureBurstExp() |
| { |
| char burst_exp[PROPERTY_VALUE_MAX]; |
| memset(burst_exp, 0, sizeof(burst_exp)); |
| property_get("persist.capture.burst.exposures", burst_exp, ""); |
| if (NULL != burst_exp) |
| mParameters.set("capture-burst-exposures", burst_exp); |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setRedeyeReduction(const QCameraParameters& params) |
| { |
| if(supportsRedEyeReduction() == false) { |
| ALOGV("Parameter Redeye Reduction is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| |
| const char *str = params.get(QCameraParameters::KEY_REDEYE_REDUCTION); |
| if (str != NULL) { |
| int value = attr_lookup(redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map), str); |
| if (value != NOT_FOUND) { |
| int8_t temp = (int8_t)value; |
| ALOGV("%s: setting Redeye Reduction value of %s", __FUNCTION__, str); |
| mParameters.set(QCameraParameters::KEY_REDEYE_REDUCTION, str); |
| |
| native_set_parms(MM_CAMERA_PARM_REDEYE_REDUCTION, sizeof(int8_t), (void *)&temp); |
| return NO_ERROR; |
| } |
| } |
| ALOGE("Invalid Redeye Reduction value: %s", (str == NULL) ? "NULL" : str); |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setGpsLocation(const QCameraParameters& params) |
| { |
| const char *method = params.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD); |
| if (method) { |
| mParameters.set(QCameraParameters::KEY_GPS_PROCESSING_METHOD, method); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_GPS_PROCESSING_METHOD); |
| } |
| |
| const char *latitude = params.get(QCameraParameters::KEY_GPS_LATITUDE); |
| if (latitude) { |
| mParameters.set(QCameraParameters::KEY_GPS_LATITUDE, latitude); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_GPS_LATITUDE); |
| } |
| |
| const char *latitudeRef = params.get(QCameraParameters::KEY_GPS_LATITUDE_REF); |
| if (latitudeRef) { |
| mParameters.set(QCameraParameters::KEY_GPS_LATITUDE_REF, latitudeRef); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_GPS_LATITUDE_REF); |
| } |
| |
| const char *longitude = params.get(QCameraParameters::KEY_GPS_LONGITUDE); |
| if (longitude) { |
| mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE, longitude); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_GPS_LONGITUDE); |
| } |
| |
| const char *longitudeRef = params.get(QCameraParameters::KEY_GPS_LONGITUDE_REF); |
| if (longitudeRef) { |
| mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE_REF, longitudeRef); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_GPS_LONGITUDE_REF); |
| } |
| |
| const char *altitudeRef = params.get(QCameraParameters::KEY_GPS_ALTITUDE_REF); |
| if (altitudeRef) { |
| mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE_REF, altitudeRef); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_GPS_ALTITUDE_REF); |
| } |
| |
| const char *altitude = params.get(QCameraParameters::KEY_GPS_ALTITUDE); |
| if (altitude) { |
| mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE, altitude); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_GPS_ALTITUDE); |
| } |
| |
| const char *status = params.get(QCameraParameters::KEY_GPS_STATUS); |
| if (status) { |
| mParameters.set(QCameraParameters::KEY_GPS_STATUS, status); |
| } |
| |
| const char *dateTime = params.get(QCameraParameters::KEY_EXIF_DATETIME); |
| if (dateTime) { |
| mParameters.set(QCameraParameters::KEY_EXIF_DATETIME, dateTime); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_EXIF_DATETIME); |
| } |
| |
| const char *timestamp = params.get(QCameraParameters::KEY_GPS_TIMESTAMP); |
| if (timestamp) { |
| mParameters.set(QCameraParameters::KEY_GPS_TIMESTAMP, timestamp); |
| }else { |
| mParameters.remove(QCameraParameters::KEY_GPS_TIMESTAMP); |
| } |
| ALOGV("setGpsLocation X"); |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setRotation(const QCameraParameters& params) |
| { |
| status_t rc = NO_ERROR; |
| int rotation = params.getInt(QCameraParameters::KEY_ROTATION); |
| if (rotation != NOT_FOUND) { |
| if (rotation == 0 || rotation == 90 || rotation == 180 |
| || rotation == 270) { |
| mParameters.set(QCameraParameters::KEY_ROTATION, rotation); |
| mRotation = rotation; |
| } else { |
| ALOGE("Invalid rotation value: %d", rotation); |
| rc = BAD_VALUE; |
| } |
| } |
| ALOGV("setRotation"); |
| return rc; |
| } |
| |
| status_t QCameraHardwareInterface::setDenoise(const QCameraParameters& params) |
| { |
| #if 0 |
| if(!mCfgControl.mm_camera_is_supported(MM_CAMERA_PARM_WAVELET_DENOISE)) { |
| ALOGE("Wavelet Denoise is not supported for this sensor"); |
| return NO_ERROR; |
| } |
| const char *str = params.get(QCameraParameters::KEY_DENOISE); |
| if (str != NULL) { |
| int value = attr_lookup(denoise, |
| sizeof(denoise) / sizeof(str_map), str); |
| if ((value != NOT_FOUND) && (mDenoiseValue != value)) { |
| mDenoiseValue = value; |
| mParameters.set(QCameraParameters::KEY_DENOISE, str); |
| bool ret = native_set_parms(MM_CAMERA_PARM_WAVELET_DENOISE, sizeof(value), |
| (void *)&value); |
| return ret ? NO_ERROR : UNKNOWN_ERROR; |
| } |
| return NO_ERROR; |
| } |
| ALOGE("Invalid Denoise value: %s", (str == NULL) ? "NULL" : str); |
| #endif |
| return BAD_VALUE; |
| } |
| |
| status_t QCameraHardwareInterface::setOrientation(const QCameraParameters& params) |
| { |
| const char *str = params.get("orientation"); |
| |
| if (str != NULL) { |
| if (strcmp(str, "portrait") == 0 || strcmp(str, "landscape") == 0) { |
| // Camera service needs this to decide if the preview frames and raw |
| // pictures should be rotated. |
| mParameters.set("orientation", str); |
| } else { |
| ALOGE("Invalid orientation value: %s", str); |
| return BAD_VALUE; |
| } |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setPictureFormat(const QCameraParameters& params) |
| { |
| const char * str = params.get(QCameraParameters::KEY_PICTURE_FORMAT); |
| |
| if(str != NULL){ |
| int32_t value = attr_lookup(picture_formats, |
| sizeof(picture_formats) / sizeof(str_map), str); |
| if(value != NOT_FOUND){ |
| mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, str); |
| } else { |
| ALOGE("Invalid Picture Format value: %s", str); |
| return BAD_VALUE; |
| } |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setRecordingHintValue(const int32_t value) |
| { |
| native_set_parms(MM_CAMERA_PARM_RECORDING_HINT, sizeof(value), |
| (void *)&value); |
| if (value == true){ |
| native_set_parms(MM_CAMERA_PARM_CAF_ENABLE, sizeof(value), |
| (void *)&value); |
| } |
| setDISMode(); |
| setFullLiveshot(); |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setRecordingHint(const QCameraParameters& params) |
| { |
| |
| const char * str = params.get(QCameraParameters::KEY_RECORDING_HINT); |
| |
| if(str != NULL){ |
| int32_t value = attr_lookup(recording_Hints, |
| sizeof(recording_Hints) / sizeof(str_map), str); |
| if(value != NOT_FOUND){ |
| mRecordingHint = value; |
| setRecordingHintValue(mRecordingHint); |
| mParameters.set(QCameraParameters::KEY_RECORDING_HINT, str); |
| return NO_ERROR; |
| } else { |
| ALOGE("Invalid Picture Format value: %s", str); |
| setDISMode(); |
| setFullLiveshot(); |
| return BAD_VALUE; |
| } |
| } |
| setDISMode(); |
| setFullLiveshot(); |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setDISMode() { |
| /* Enable DIS only if |
| * - Camcorder mode AND |
| * - DIS property is set AND |
| * - Not in Low power mode. */ |
| uint32_t value = mRecordingHint && mDisEnabled |
| && !isLowPowerCamcorder(); |
| |
| ALOGV("%s DIS is %s value = %d", __func__, |
| value ? "Enabled" : "Disabled", value); |
| native_set_parms(MM_CAMERA_PARM_DIS_ENABLE, sizeof(value), |
| (void *)&value); |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setFullLiveshot() |
| { |
| /* Enable full size liveshot only if |
| * - Camcorder mode AND |
| * - Full size liveshot is enabled. */ |
| uint32_t value = mRecordingHint && mFullLiveshotEnabled |
| && !isLowPowerCamcorder(); |
| |
| if (((mDimension.picture_width == mVideoWidth) && |
| (mDimension.picture_height == mVideoHeight))) { |
| /* If video size matches the live snapshot size |
| * turn off full size liveshot to get higher fps. */ |
| value = 0; |
| } |
| |
| ALOGV("%s Full size liveshot %s value = %d", __func__, |
| value ? "Enabled" : "Disabled", value); |
| native_set_parms(MM_CAMERA_PARM_FULL_LIVESHOT, sizeof(value), |
| (void *)&value); |
| return NO_ERROR; |
| } |
| |
| |
| isp3a_af_mode_t QCameraHardwareInterface::getAutoFocusMode( |
| const QCameraParameters& params) |
| { |
| isp3a_af_mode_t afMode = AF_MODE_MAX; |
| afMode = (isp3a_af_mode_t)mFocusMode; |
| return afMode; |
| } |
| |
| void QCameraHardwareInterface::getPictureSize(int *picture_width, |
| int *picture_height) const |
| { |
| mParameters.getPictureSize(picture_width, picture_height); |
| } |
| |
| void QCameraHardwareInterface::getPreviewSize(int *preview_width, |
| int *preview_height) const |
| { |
| mParameters.getPreviewSize(preview_width, preview_height); |
| } |
| |
| cam_format_t QCameraHardwareInterface::getPreviewFormat() const |
| { |
| cam_format_t foramt = CAMERA_YUV_420_NV21; |
| const char *str = mParameters.getPreviewFormat(); |
| int32_t value = attr_lookup(preview_formats, |
| sizeof(preview_formats)/sizeof(str_map), |
| str); |
| |
| if(value != NOT_FOUND) { |
| int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t); |
| int i; |
| for (i = 0; i < num; i++) { |
| if (preview_format_info_list[i].Hal_format == value) { |
| foramt = preview_format_info_list[i].mm_cam_format; |
| break; |
| } |
| } |
| } |
| |
| return foramt; |
| } |
| |
| cam_pad_format_t QCameraHardwareInterface::getPreviewPadding() const |
| { |
| return mPreviewFormatInfo.padding; |
| } |
| |
| int QCameraHardwareInterface::getJpegQuality() const |
| { |
| return mJpegQuality; |
| } |
| |
| int QCameraHardwareInterface::getNumOfSnapshots(void) const |
| { |
| char prop[PROPERTY_VALUE_MAX]; |
| memset(prop, 0, sizeof(prop)); |
| property_get("persist.camera.snapshot.number", prop, "0"); |
| ALOGV("%s: prop enable/disable = %d", __func__, atoi(prop)); |
| if (atoi(prop)) { |
| ALOGV("%s: Reading maximum no of snapshots = %d" |
| "from properties", __func__, atoi(prop)); |
| return atoi(prop); |
| } else { |
| return mParameters.getInt("num-snaps-per-shutter"); |
| } |
| } |
| |
| int QCameraHardwareInterface::getNumOfSnapshots(const QCameraParameters& params) |
| { |
| char prop[PROPERTY_VALUE_MAX]; |
| memset(prop, 0, sizeof(prop)); |
| property_get("persist.camera.snapshot.number", prop, "0"); |
| ALOGV("%s: prop enable/disable = %d", __func__, atoi(prop)); |
| if (atoi(prop)) { |
| ALOGV("%s: Reading maximum no of snapshots = %d" |
| "from properties", __func__, atoi(prop)); |
| return atoi(prop); |
| } else { |
| return params.getInt("num-snaps-per-shutter"); |
| } |
| |
| } |
| |
| int QCameraHardwareInterface:: |
| getThumbSizesFromAspectRatio(uint32_t aspect_ratio, |
| int *picture_width, |
| int *picture_height) |
| { |
| for(unsigned int i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ){ |
| if(thumbnail_sizes[i].aspect_ratio == aspect_ratio) |
| { |
| *picture_width = thumbnail_sizes[i].width; |
| *picture_height = thumbnail_sizes[i].height; |
| return NO_ERROR; |
| } |
| } |
| |
| return BAD_VALUE; |
| } |
| |
| bool QCameraHardwareInterface::isRawSnapshot() |
| { |
| const char *format = mParameters.getPictureFormat(); |
| if( format!= NULL && |
| !strcmp(format, QCameraParameters::PIXEL_FORMAT_RAW)){ |
| return true; |
| } |
| else{ |
| return false; |
| } |
| } |
| |
| status_t QCameraHardwareInterface::setPreviewSizeTable(void) |
| { |
| status_t ret = NO_ERROR; |
| mm_camera_dimension_t dim; |
| struct camera_size_type* preview_size_table; |
| int preview_table_size; |
| int i = 0; |
| char str[10] = {0}; |
| |
| /* Initialize table with default values */ |
| preview_size_table = default_preview_sizes; |
| preview_table_size = preview_sizes_count; |
| |
| |
| /* Get maximum preview size supported by sensor*/ |
| memset(&dim, 0, sizeof(mm_camera_dimension_t)); |
| ret = cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_MAX_PREVIEW_SIZE, &dim); |
| if (ret != NO_ERROR) { |
| ALOGE("%s: Failure getting Max Preview Size supported by camera", |
| __func__); |
| goto end; |
| } |
| |
| ALOGV("%s: Max Preview Sizes Supported: %d X %d", __func__, |
| dim.width, dim.height); |
| |
| for (i = 0; i < preview_table_size; i++) { |
| if ((preview_size_table->width <= dim.width) && |
| (preview_size_table->height <= dim.height)) { |
| ALOGV("%s: Camera Preview Size Table " |
| "Max width: %d height %d table_size: %d", |
| __func__, preview_size_table->width, |
| preview_size_table->height, preview_table_size - i); |
| break; |
| } |
| preview_size_table++; |
| } |
| //set preferred preview size to maximum preview size |
| sprintf(str, "%dx%d", preview_size_table->width, preview_size_table->height); |
| mParameters.set(QCameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, str); |
| ALOGV("KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO = %s", str); |
| |
| end: |
| /* Save the table in global member*/ |
| mPreviewSizes = preview_size_table; |
| mPreviewSizeCount = preview_table_size - i; |
| |
| return ret; |
| } |
| |
| status_t QCameraHardwareInterface::setPictureSizeTable(void) |
| { |
| status_t ret = NO_ERROR; |
| mm_camera_dimension_t dim; |
| struct camera_size_type* picture_size_table; |
| int picture_table_size; |
| int i = 0, count = 0; |
| |
| /* Initialize table with default values */ |
| picture_table_size = sizeof(default_picture_sizes)/ |
| sizeof(default_picture_sizes[0]); |
| picture_size_table = default_picture_sizes; |
| mPictureSizes = |
| ( struct camera_size_type *)malloc(picture_table_size * |
| sizeof(struct camera_size_type)); |
| if (mPictureSizes == NULL) { |
| ALOGE("%s: Failre allocating memory to store picture size table",__func__); |
| goto end; |
| } |
| |
| /* Get maximum picture size supported by sensor*/ |
| memset(&dim, 0, sizeof(mm_camera_dimension_t)); |
| ret = cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim); |
| if (ret != NO_ERROR) { |
| ALOGE("%s: Failure getting Max Picture Size supported by camera", |
| __func__); |
| ret = NO_MEMORY; |
| free(mPictureSizes); |
| mPictureSizes = NULL; |
| goto end; |
| } |
| |
| ALOGV("%s: Max Picture Sizes Supported: %d X %d", __func__, |
| dim.width, dim.height); |
| |
| for (i = 0; i < picture_table_size; i++) { |
| /* We'll store those dimensions whose width AND height |
| are less than or equal to maximum supported */ |
| if ((picture_size_table->width <= dim.width) && |
| (picture_size_table->height <= dim.height)) { |
| ALOGV("%s: Camera Picture Size Table " |
| "Max width: %d height %d table_size: %d", |
| __func__, picture_size_table->width, |
| picture_size_table->height, count+1); |
| mPictureSizes[count].height = picture_size_table->height; |
| mPictureSizes[count].width = picture_size_table->width; |
| count++; |
| } |
| picture_size_table++; |
| } |
| mPictureSizeCount = count; |
| |
| end: |
| /* In case of error, we use default picture sizes */ |
| if (ret != NO_ERROR) { |
| mPictureSizes = default_picture_sizes; |
| mPictureSizeCount = picture_table_size; |
| } |
| return ret; |
| } |
| |
| status_t QCameraHardwareInterface::setVideoSizeTable(void) |
| { |
| status_t ret = NO_ERROR; |
| mm_camera_dimension_t dim; |
| struct camera_size_type* video_size_table; |
| int video_table_size; |
| int i = 0, count = 0; |
| ALOGV("%s: E", __func__); |
| |
| /* Initialize table with default values */ |
| video_table_size = video_sizes_count; |
| video_size_table = default_video_sizes; |
| mVideoSizes = |
| (struct camera_size_type *)malloc(video_table_size * |
| sizeof(struct camera_size_type)); |
| if(mVideoSizes == NULL) { |
| ALOGE("%s: error allocating memory to store video size table",__func__); |
| ret = BAD_VALUE; |
| goto end; |
| } |
| |
| /* Get maximum video size supported by sensor*/ |
| memset(&dim, 0, sizeof(mm_camera_dimension_t)); |
| ret = cam_config_get_parm(mCameraId, |
| MM_CAMERA_PARM_MAX_VIDEO_SIZE, &dim); |
| if(ret != NO_ERROR) { |
| ALOGE("%s: error getting Max Video Size supported by camera", |
| __func__); |
| ret = NO_MEMORY; |
| free(mVideoSizes); |
| mVideoSizes = NULL; |
| ret = BAD_VALUE; |
| goto end; |
| } |
| |
| ALOGV("%s: Max Video Size Supported: %d X %d", __func__, |
| dim.width, dim.height); |
| |
| for(i=0; i < video_table_size; i++) { |
| /* We'll store those dimensions whose width AND height |
| are less than or equal to maximum supported */ |
| if((video_size_table->width <= dim.width) && |
| (video_size_table->height <= dim.height)) { |
| ALOGV("%s: Supported Video Size [%d] = %dx%d", __func__, count, video_size_table->width, |
| video_size_table->height); |
| mVideoSizes[count].height = video_size_table->height; |
| mVideoSizes[count].width = video_size_table->width; |
| count++; |
| } |
| video_size_table++; |
| } |
| mVideoSizeCount = count; |
| |
| end: |
| ALOGV("%s: X", __func__); |
| return ret; |
| } |
| |
| void QCameraHardwareInterface::freeVideoSizeTable(void) |
| { |
| if(mVideoSizes != NULL) |
| { |
| free(mVideoSizes); |
| } |
| mVideoSizeCount = 0; |
| } |
| |
| |
| void QCameraHardwareInterface::freePictureTable(void) |
| { |
| /* If we couldn't allocate memory to store picture table |
| we use the picture table pointer to point to default |
| picture table array. In that case we cannot free it.*/ |
| if ((mPictureSizes != default_picture_sizes) && mPictureSizes) { |
| free(mPictureSizes); |
| } |
| } |
| |
| status_t QCameraHardwareInterface::setHistogram(int histogram_en) |
| { |
| ALOGV("setHistogram: E"); |
| if(mStatsOn == histogram_en) { |
| return NO_ERROR; |
| } |
| |
| mSendData = histogram_en; |
| mStatsOn = histogram_en; |
| mCurrentHisto = -1; |
| mStatSize = sizeof(uint32_t)* HISTOGRAM_STATS_SIZE; |
| |
| if (histogram_en == QCAMERA_PARM_ENABLE) { |
| /*Currently the Ashmem is multiplying the buffer size with total number |
| of buffers and page aligning. This causes a crash in JNI as each buffer |
| individually expected to be page aligned */ |
| int page_size_minus_1 = getpagesize() - 1; |
| int statSize = sizeof (camera_preview_histogram_info ); |
| int32_t mAlignedStatSize = ((statSize + page_size_minus_1) & (~page_size_minus_1)); |
| #if 0 |
| mStatHeap = |
| new AshmemPool(mAlignedStatSize, 3, statSize, "stat"); |
| if (!mStatHeap->initialized()) { |
| ALOGE("Stat Heap X failed "); |
| mStatHeap.clear(); |
| mStatHeap = NULL; |
| return UNKNOWN_ERROR; |
| } |
| #endif |
| for(int cnt = 0; cnt<3; cnt++) { |
| mStatsMapped[cnt]=mGetMemory(-1, mStatSize, 1, mCallbackCookie); |
| if(mStatsMapped[cnt] == NULL) { |
| ALOGE("Failed to get camera memory for stats heap index: %d", cnt); |
| return(-1); |
| } else { |
| ALOGV("Received following info for stats mapped data:%p,handle:%p, size:%d,release:%p", |
| mStatsMapped[cnt]->data ,mStatsMapped[cnt]->handle, mStatsMapped[cnt]->size, mStatsMapped[cnt]->release); |
| } |
| mHistServer.size = sizeof(camera_preview_histogram_info); |
| #ifdef USE_ION |
| if(allocate_ion_memory(&mHistServer, cnt, ION_CP_MM_HEAP_ID) < 0) { |
| ALOGE("%s ION alloc failed\n", __func__); |
| return -1; |
| } |
| #else |
| mHistServer.fd[cnt] = open("/dev/pmem_adsp", O_RDWR|O_SYNC); |
| if(mHistServer.fd[cnt] <= 0) { |
| ALOGE("%s: no pmem for frame %d", __func__, cnt); |
| return -1; |
| } |
| #endif |
| mHistServer.camera_memory[cnt]=mGetMemory(mHistServer.fd[cnt],mHistServer.size, 1, mCallbackCookie); |
| if(mHistServer.camera_memory[cnt] == NULL) { |
| ALOGE("Failed to get camera memory for server side histogram index: %d", cnt); |
| return(-1); |
| } else { |
| ALOGV("Received following info for server side histogram data:%p,handle:%p, size:%d,release:%p", |
| mHistServer.camera_memory[cnt]->data ,mHistServer.camera_memory[cnt]->handle, |
| mHistServer.camera_memory[cnt]->size, mHistServer.camera_memory[cnt]->release); |
| } |
| /*Register buffer at back-end*/ |
| if (NO_ERROR != sendMappingBuf(0, cnt, mHistServer.fd[cnt], |
| mHistServer.size, mCameraId, |
| CAM_SOCK_MSG_TYPE_HIST_MAPPING)) { |
| ALOGE("%s could not send buffer to back-end\n", __func__); |
| } |
| } |
| } |
| ALOGV("Setting histogram = %d", histogram_en); |
| native_set_parms(MM_CAMERA_PARM_HISTOGRAM, sizeof(int), &histogram_en); |
| if(histogram_en == QCAMERA_PARM_DISABLE) |
| { |
| //release memory |
| for(int i=0; i<3; i++){ |
| if(mStatsMapped[i] != NULL) { |
| mStatsMapped[i]->release(mStatsMapped[i]); |
| } |
| /*Unregister buffer at back-end */ |
| if (NO_ERROR != sendUnMappingBuf(0, i, mCameraId, CAM_SOCK_MSG_TYPE_HIST_UNMAPPING)) { |
| ALOGE("%s could not unregister buffer from back-end\n", __func__); |
| } |
| if(mHistServer.camera_memory[i] != NULL) { |
| mHistServer.camera_memory[i]->release(mHistServer.camera_memory[i]); |
| } |
| close(mHistServer.fd[i]); |
| #ifdef USE_ION |
| deallocate_ion_memory(&mHistServer, i); |
| #endif |
| } |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setZSLBurstLookBack(const QCameraParameters& params) |
| { |
| const char *v = params.get("capture-burst-retroactive"); |
| if (v) { |
| int look_back = atoi(v); |
| ALOGV("%s: look_back =%d", __func__, look_back); |
| mParameters.set("capture-burst-retroactive", look_back); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setZSLBurstInterval(const QCameraParameters& params) |
| { |
| mZslInterval = BURST_INTREVAL_DEFAULT; |
| const char *v = params.get("capture-burst-interval"); |
| if (v) { |
| int interval = atoi(v); |
| ALOGV("%s: Interval =%d", __func__, interval); |
| if(interval < BURST_INTREVAL_MIN ||interval > BURST_INTREVAL_MAX ) { |
| return BAD_VALUE; |
| } |
| mZslInterval = interval; |
| } |
| return NO_ERROR; |
| } |
| |
| int QCameraHardwareInterface::getZSLBurstInterval( void ) |
| { |
| int val; |
| |
| if (mZslInterval == BURST_INTREVAL_DEFAULT) { |
| char prop[PROPERTY_VALUE_MAX]; |
| memset(prop, 0, sizeof(prop)); |
| property_get("persist.camera.zsl.interval", prop, "1"); |
| val = atoi(prop); |
| ALOGV("%s: prop interval = %d", __func__, val); |
| } else { |
| val = mZslInterval; |
| } |
| return val; |
| } |
| |
| |
| int QCameraHardwareInterface::getZSLQueueDepth(void) const |
| { |
| char prop[PROPERTY_VALUE_MAX]; |
| memset(prop, 0, sizeof(prop)); |
| property_get("persist.camera.zsl.queuedepth", prop, "2"); |
| ALOGV("%s: prop = %d", __func__, atoi(prop)); |
| return atoi(prop); |
| } |
| |
| int QCameraHardwareInterface::getZSLBackLookCount(void) const |
| { |
| int look_back; |
| char prop[PROPERTY_VALUE_MAX]; |
| memset(prop, 0, sizeof(prop)); |
| property_get("persist.camera.zsl.backlookcnt", prop, "0"); |
| ALOGV("%s: prop = %d", __func__, atoi(prop)); |
| look_back = atoi(prop); |
| if (look_back == 0 ) { |
| look_back = mParameters.getInt("capture-burst-retroactive"); |
| ALOGV("%s: look_back = %d", __func__, look_back); |
| } |
| return look_back; |
| } |
| |
| bool QCameraHardwareInterface::getFlashCondition(void) |
| { |
| int32_t rc = 0; |
| bool flash_cond = false; |
| aec_info_for_flash_t lowLightForZSL; |
| |
| lowLightForZSL.aec_index_for_zsl = 0; |
| lowLightForZSL.zsl_flash_enable = 0; |
| |
| if(myMode & CAMERA_ZSL_MODE){ |
| switch(mLedStatusForZsl) { |
| case LED_MODE_ON: |
| flash_cond = true; |
| break; |
| case LED_MODE_AUTO: |
| rc = cam_config_get_parm(mCameraId, |
| MM_CAMERA_GET_PARM_LOW_LIGHT_FOR_ZSL, &lowLightForZSL); |
| if(MM_CAMERA_OK == rc) { |
| if(lowLightForZSL.zsl_flash_enable != 0) |
| flash_cond = true; |
| else |
| flash_cond = false; |
| } |
| else |
| ALOGE("%s: Failed to get lowLightForZSL, rc %d", __func__, rc); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| ALOGV("%s: myMode %d, flash mode %d, flash condition %d", |
| __func__, myMode, mLedStatusForZsl, flash_cond); |
| return flash_cond; |
| } |
| |
| //EXIF functions |
| void QCameraHardwareInterface::deinitExifData() |
| { |
| ALOGV("Clearing EXIF data"); |
| for(int i=0; i<MAX_EXIF_TABLE_ENTRIES; i++) |
| { |
| //clear all data |
| memset(&mExifData[i], 0x00, sizeof(exif_tags_info_t)); |
| } |
| mExifTableNumEntries = 0; |
| } |
| |
| void QCameraHardwareInterface::addExifTag(exif_tag_id_t tagid, exif_tag_type_t type, |
| uint32_t count, uint8_t copy, void *data) { |
| |
| if(mExifTableNumEntries >= MAX_EXIF_TABLE_ENTRIES) { |
| ALOGE("%s: Number of entries exceeded limit", __func__); |
| return; |
| } |
| int index = mExifTableNumEntries; |
| mExifData[index].tag_id = tagid; |
| mExifData[index].tag_entry.type = type; |
| mExifData[index].tag_entry.count = count; |
| mExifData[index].tag_entry.copy = copy; |
| if((type == EXIF_RATIONAL) && (count > 1)) |
| mExifData[index].tag_entry.data._rats = (rat_t *)data; |
| if((type == EXIF_RATIONAL) && (count == 1)) |
| mExifData[index].tag_entry.data._rat = *(rat_t *)data; |
| else if(type == EXIF_ASCII) |
| mExifData[index].tag_entry.data._ascii = (char *)data; |
| else if(type == EXIF_BYTE) |
| mExifData[index].tag_entry.data._byte = *(uint8_t *)data; |
| else if((type == EXIF_SHORT) && (count > 1)) |
| mExifData[index].tag_entry.data._shorts = (uint16_t *)data; |
| else if((type == EXIF_SHORT) && (count == 1)) |
| mExifData[index].tag_entry.data._short = *(uint16_t *)data; |
| // Increase number of entries |
| mExifTableNumEntries++; |
| } |
| |
| rat_t getRational(int num, int denom) |
| { |
| rat_t temp = {num, denom}; |
| return temp; |
| } |
| |
| void QCameraHardwareInterface::initExifData(){ |
| if(mExifValues.dateTime) { |
| addExifTag(EXIFTAGID_EXIF_DATE_TIME_ORIGINAL, EXIF_ASCII, |
| 20, 1, (void *)mExifValues.dateTime); |
| addExifTag(EXIFTAGID_EXIF_DATE_TIME_DIGITIZED, EXIF_ASCII, |
| 20, 1, (void *)mExifValues.dateTime); |
| } |
| addExifTag(EXIFTAGID_FOCAL_LENGTH, EXIF_RATIONAL, 1, 1, (void *)&(mExifValues.focalLength)); |
| addExifTag(EXIFTAGID_ISO_SPEED_RATING,EXIF_SHORT,1,1,(void *)&(mExifValues.isoSpeed)); |
| |
| if(mExifValues.mGpsProcess) { |
| addExifTag(EXIFTAGID_GPS_PROCESSINGMETHOD, EXIF_ASCII, |
| EXIF_ASCII_PREFIX_SIZE + strlen(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE) + 1, |
| 1, (void *)mExifValues.gpsProcessingMethod); |
| } |
| |
| if(mExifValues.mLatitude) { |
| addExifTag(EXIFTAGID_GPS_LATITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.latitude); |
| |
| if(mExifValues.latRef) { |
| addExifTag(EXIFTAGID_GPS_LATITUDE_REF, EXIF_ASCII, 2, |
| 1, (void *)mExifValues.latRef); |
| } |
| } |
| |
| if(mExifValues.mLongitude) { |
| addExifTag(EXIFTAGID_GPS_LONGITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.longitude); |
| |
| if(mExifValues.lonRef) { |
| addExifTag(EXIFTAGID_GPS_LONGITUDE_REF, EXIF_ASCII, 2, |
| 1, (void *)mExifValues.lonRef); |
| } |
| } |
| |
| if(mExifValues.mAltitude) { |
| addExifTag(EXIFTAGID_GPS_ALTITUDE, EXIF_RATIONAL, 1, |
| 1, (void *)&(mExifValues.altitude)); |
| |
| addExifTag(EXIFTAGID_GPS_ALTITUDE_REF, EXIF_BYTE, 1, 1, (void *)&mExifValues.mAltitude_ref); |
| } |
| |
| if(mExifValues.mTimeStamp) { |
| time_t unixTime; |
| struct tm *UTCTimestamp; |
| |
| unixTime = (time_t)mExifValues.mGPSTimestamp; |
| UTCTimestamp = gmtime(&unixTime); |
| |
| strftime(mExifValues.gpsDateStamp, sizeof(mExifValues.gpsDateStamp), "%Y:%m:%d", UTCTimestamp); |
| addExifTag(EXIFTAGID_GPS_DATESTAMP, EXIF_ASCII, |
| strlen(mExifValues.gpsDateStamp)+1 , 1, (void *)mExifValues.gpsDateStamp); |
| |
| mExifValues.gpsTimeStamp[0] = getRational(UTCTimestamp->tm_hour, 1); |
| mExifValues.gpsTimeStamp[1] = getRational(UTCTimestamp->tm_min, 1); |
| mExifValues.gpsTimeStamp[2] = getRational(UTCTimestamp->tm_sec, 1); |
| |
| addExifTag(EXIFTAGID_GPS_TIMESTAMP, EXIF_RATIONAL, |
| 3, 1, (void *)mExifValues.gpsTimeStamp); |
| ALOGV("EXIFTAGID_GPS_TIMESTAMP set"); |
| } |
| if(mExifValues.exposure_time.num || mExifValues.exposure_time.denom) |
| addExifTag(EXIFTAGID_EXPOSURE_TIME, EXIF_RATIONAL, 1, 1, (void *)&mExifValues.exposure_time); |
| |
| } |
| |
| //Add all exif tags in this function |
| void QCameraHardwareInterface::setExifTags() |
| { |
| const char *str; |
| |
| //set TimeStamp |
| str = mParameters.get(QCameraParameters::KEY_EXIF_DATETIME); |
| if(str != NULL) { |
| strncpy(mExifValues.dateTime, str, 19); |
| mExifValues.dateTime[19] = '\0'; |
| } |
| |
| //Set focal length |
| int focalLengthValue = (int) (mParameters.getFloat( |
| QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION); |
| |
| mExifValues.focalLength = getRational(focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION); |
| |
| focus_distances_info_t focusDistances; |
| status_t rc = NO_ERROR; |
| rc = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_FOCAL_LENGTH,(void *)&focusDistances); |
| if (rc == MM_CAMERA_OK){ |
| uint16_t temp1; |
| rat_t temp; |
| if(mIsoValue == 0) // ISO is auto |
| { |
| temp1 = (uint16_t)(focusDistances.real_gain + 0.5)*100; |
| mExifValues.isoSpeed = temp1; |
| ALOGV("The new ISO value is %d", temp1); |
| } |
| else{ |
| temp1 = iso_speed_values[mIsoValue]; |
| mExifValues.isoSpeed = temp1; |
| ALOGV("else The new ISO value is %d", temp1); |
| } |
| |
| if(focusDistances.exp_time <= 0) // avoid zero-divide problem |
| focusDistances.exp_time = 0.01668; // expoure time will be 1/60 s |
| |
| uint16_t temp2 = (uint16_t)(focusDistances.exp_time * 100000); |
| temp2 = (uint16_t)(100000 / temp2); |
| temp.num = 1; |
| temp.denom = temp2; |
| memcpy(&mExifValues.exposure_time, &temp, sizeof(mExifValues.exposure_time)); |
| ALOGV(" The exposure value is %f", temp2); |
| } |
| //get time and date from system |
| time_t rawtime; |
| struct tm * timeinfo; |
| time(&rawtime); |
| timeinfo = localtime (&rawtime); |
| //Write datetime according to EXIF Spec |
| //"YYYY:MM:DD HH:MM:SS" (20 chars including \0) |
| snprintf(mExifValues.dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d", |
| timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, |
| timeinfo->tm_mday, timeinfo->tm_hour, |
| timeinfo->tm_min, timeinfo->tm_sec); |
| //set gps tags |
| setExifTagsGPS(); |
| } |
| |
| void QCameraHardwareInterface::setExifTagsGPS() |
| { |
| const char *str = NULL; |
| |
| //Set GPS processing method |
| str = mParameters.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD); |
| if(str != NULL) { |
| memcpy(mExifValues.gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE); |
| strncpy(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str, |
| GPS_PROCESSING_METHOD_SIZE - 1); |
| mExifValues.gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE + GPS_PROCESSING_METHOD_SIZE-1] = '\0'; |
| ALOGV("EXIFTAGID_GPS_PROCESSINGMETHOD = %s %s", mExifValues.gpsProcessingMethod, |
| mExifValues.gpsProcessingMethod+8); |
| mExifValues.mGpsProcess = true; |
| }else{ |
| mExifValues.mGpsProcess = false; |
| } |
| str = NULL; |
| |
| //Set Latitude |
| str = mParameters.get(QCameraParameters::KEY_GPS_LATITUDE); |
| if(str != NULL) { |
| parseGPSCoordinate(str, mExifValues.latitude); |
| ALOGV("EXIFTAGID_GPS_LATITUDE = %s", str); |
| |
| //set Latitude Ref |
| float latitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LATITUDE); |
| if(latitudeValue < 0.0f) { |
| mExifValues.latRef[0] = 'S'; |
| } else { |
| mExifValues.latRef[0] = 'N'; |
| } |
| mExifValues.latRef[1] = '\0'; |
| mExifValues.mLatitude = true; |
| mParameters.set(QCameraParameters::KEY_GPS_LATITUDE_REF,mExifValues.latRef); |
| ALOGV("EXIFTAGID_GPS_LATITUDE_REF = %s", mExifValues.latRef); |
| }else{ |
| mExifValues.mLatitude = false; |
| } |
| |
| //set Longitude |
| str = NULL; |
| str = mParameters.get(QCameraParameters::KEY_GPS_LONGITUDE); |
| if(str != NULL) { |
| parseGPSCoordinate(str, mExifValues.longitude); |
| ALOGV("EXIFTAGID_GPS_LONGITUDE = %s", str); |
| |
| //set Longitude Ref |
| float longitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LONGITUDE); |
| if(longitudeValue < 0.0f) { |
| mExifValues.lonRef[0] = 'W'; |
| } else { |
| mExifValues.lonRef[0] = 'E'; |
| } |
| mExifValues.lonRef[1] = '\0'; |
| mExifValues.mLongitude = true; |
| ALOGV("EXIFTAGID_GPS_LONGITUDE_REF = %s", mExifValues.lonRef); |
| mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE_REF, mExifValues.lonRef); |
| }else{ |
| mExifValues.mLongitude = false; |
| } |
| |
| //set Altitude |
| str = mParameters.get(QCameraParameters::KEY_GPS_ALTITUDE); |
| if(str != NULL) { |
| double value = atof(str); |
| mExifValues.mAltitude_ref = 0; |
| if(value < 0){ |
| mExifValues.mAltitude_ref = 1; |
| value = -value; |
| } |
| mExifValues.altitude = getRational(value*1000, 1000); |
| mExifValues.mAltitude = true; |
| //set AltitudeRef |
| mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE_REF, mExifValues.mAltitude_ref); |
| ALOGV("EXIFTAGID_GPS_ALTITUDE = %f", value); |
| }else{ |
| mExifValues.mAltitude = false; |
| } |
| |
| //set Gps TimeStamp |
| str = NULL; |
| str = mParameters.get(QCameraParameters::KEY_GPS_TIMESTAMP); |
| if(str != NULL) { |
| mExifValues.mTimeStamp = true; |
| mExifValues.mGPSTimestamp = atol(str); |
| }else{ |
| mExifValues.mTimeStamp = false; |
| } |
| } |
| |
| //latlonString is string formatted coordinate |
| //coord is rat_t[3] |
| void QCameraHardwareInterface::parseGPSCoordinate(const char *latlonString, rat_t* coord) |
| { |
| if(coord == NULL) { |
| ALOGE("%s: error, invalid argument coord == NULL", __func__); |
| return; |
| } |
| float degF = fabs(atof(latlonString)); |
| float minF = (degF- (int) degF) * 60; |
| float secF = (minF - (int) minF) * 60; |
| |
| coord[0] = getRational((int) degF, 1); |
| coord[1] = getRational((int) minF, 1); |
| coord[2] = getRational((int) (secF * 10000), 10000); |
| } |
| |
| bool QCameraHardwareInterface::isLowPowerCamcorder() { |
| |
| if (mPowerMode == LOW_POWER) |
| return true; |
| |
| if(mHFRLevel > 1) /* hard code the value now. Need to move tgtcommon to camear.h */ |
| return true; |
| |
| return false; |
| } |
| |
| status_t QCameraHardwareInterface::setNoDisplayMode(const QCameraParameters& params) |
| { |
| char prop[PROPERTY_VALUE_MAX]; |
| memset(prop, 0, sizeof(prop)); |
| property_get("persist.camera.nodisplay", prop, "0"); |
| int prop_val = atoi(prop); |
| |
| if (prop_val == 0) { |
| const char *str_val = params.get("no-display-mode"); |
| if(str_val && strlen(str_val) > 0) { |
| mNoDisplayMode = atoi(str_val); |
| } else { |
| mNoDisplayMode = 0; |
| } |
| ALOGV("Param mNoDisplayMode =%d", mNoDisplayMode); |
| } else { |
| mNoDisplayMode = prop_val; |
| ALOGV("prop mNoDisplayMode =%d", mNoDisplayMode); |
| } |
| return NO_ERROR; |
| } |
| |
| status_t QCameraHardwareInterface::setCAFLockCancel(void) |
| { |
| ALOGV("%s : E", __func__); |
| status_t rc = NO_ERROR; |
| int32_t value; |
| |
| //for CAF unlock |
| value = 1; |
| rc = (native_set_parms(MM_CAMERA_PARM_CAF_LOCK_CANCEL, sizeof(int32_t), (void *)(&value))) ? |
| NO_ERROR : UNKNOWN_ERROR; |
| ALOGV("%s : X", __func__); |
| return rc; |
| } |
| |
| void QCameraHardwareInterface::prepareVideoPicture(bool disable){ |
| String8 str; |
| char buffer[32]; |
| |
| if(disable) { |
| sprintf(buffer, "%dx%d", mDimension.video_width, mDimension.video_height); |
| str.append(buffer); |
| |
| mParameters.setPictureSize(mDimension.video_width, mDimension.video_height); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES, |
| str.string()); |
| ALOGV("%s: Video Picture size supported = %d X %d", |
| __func__,mDimension.video_width,mDimension.video_height); |
| }else{ |
| //Set Picture Size |
| mParameters.setPictureSize(mDimension.picture_width, mDimension.picture_height); |
| mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES, |
| mPictureSizeValues.string()); |
| } |
| } |
| |
| }; /*namespace android */ |