1 /* 2 ** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved. 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 //#define ALOG_NDEBUG 0 18 #define ALOG_NIDEBUG 0 19 #define LOG_TAG "QCameraHWI_Parm" 20 #include <utils/Log.h> 21 22 #include <utils/Errors.h> 23 #include <utils/threads.h> 24 //#include <binder/MemoryHeapPmem.h> 25 #include <utils/String16.h> 26 #include <sys/types.h> 27 #include <sys/stat.h> 28 #include <unistd.h> 29 #include <fcntl.h> 30 #include <cutils/properties.h> 31 #include <math.h> 32 #include <linux/ioctl.h> 33 #include "QCameraParameters.h" 34 #include <media/mediarecorder.h> 35 #include <gralloc_priv.h> 36 37 #include "linux/msm_mdp.h" 38 #include <linux/fb.h> 39 #include <limits.h> 40 41 extern "C" { 42 #include <fcntl.h> 43 #include <time.h> 44 #include <pthread.h> 45 #include <stdio.h> 46 #include <string.h> 47 #include <unistd.h> 48 #include <termios.h> 49 #include <assert.h> 50 #include <stdlib.h> 51 #include <ctype.h> 52 #include <signal.h> 53 #include <errno.h> 54 #include <sys/mman.h> 55 #include <sys/system_properties.h> 56 #include <sys/time.h> 57 #include <stdlib.h> 58 #include <linux/msm_ion.h> 59 60 } // extern "C" 61 62 #include "QCameraHWI.h" 63 #include "QCameraStream.h" 64 65 /* QCameraHardwareInterface class implementation goes here*/ 66 /* following code implements the parameter logic of this class*/ 67 #define EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR 12 68 #define EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR -12 69 #define EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR 0 70 #define EXPOSURE_COMPENSATION_DENOMINATOR 6 71 #define EXPOSURE_COMPENSATION_STEP ((float (1))/EXPOSURE_COMPENSATION_DENOMINATOR) 72 #define DEFAULT_CAMERA_AREA "(0,0,0,0,0)" // important: spaces not allowed 73 74 #define HDR_HAL_FRAME 2 75 76 #define BURST_INTREVAL_MIN 1 77 #define BURST_INTREVAL_MAX 10 78 #define BURST_INTREVAL_DEFAULT 1 79 80 //Default FPS 81 #define MINIMUM_FPS 5 82 #define MAXIMUM_FPS 30 83 #define DEFAULT_FIXED_FPS 30 84 #define DEFAULT_FPS 30 85 86 //Default Picture Width 87 #define DEFAULT_PICTURE_WIDTH 640 88 #define DEFAULT_PICTURE_HEIGHT 480 89 90 //Default Video Width 91 #define DEFAULT_VIDEO_WIDTH 1920 92 #define DEFAULT_VIDEO_HEIGHT 1088 93 94 #define THUMBNAIL_SIZE_COUNT (sizeof(thumbnail_sizes)/sizeof(thumbnail_size_type)) 95 #define DEFAULT_THUMBNAIL_SETTING 4 96 #define THUMBNAIL_WIDTH_STR "512" 97 #define THUMBNAIL_HEIGHT_STR "384" 98 #define THUMBNAIL_SMALL_HEIGHT 144 99 100 #define DONT_CARE_COORDINATE -1 101 102 //for histogram stats 103 #define HISTOGRAM_STATS_SIZE 257 104 105 //Supported preview fps ranges should be added to this array in the form (minFps,maxFps) 106 static android::FPSRange FpsRangesSupported[] = { 107 android::FPSRange(MINIMUM_FPS*1000,MAXIMUM_FPS*1000) 108 }; 109 #define FPS_RANGES_SUPPORTED_COUNT (sizeof(FpsRangesSupported)/sizeof(FpsRangesSupported[0])) 110 111 112 typedef struct { 113 uint32_t aspect_ratio; 114 uint32_t width; 115 uint32_t height; 116 } thumbnail_size_type; 117 118 static thumbnail_size_type thumbnail_sizes[] = { 119 { 7281, 512, 288 }, //1.777778 120 { 6826, 480, 288 }, //1.666667 121 { 6808, 256, 154 }, //1.66233 122 { 6144, 432, 288 }, //1.5 123 { 5461, 512, 384 }, //1.333333 124 { 5006, 352, 288 }, //1.222222 125 { 5461, 320, 240 }, //1.33333 126 { 5006, 176, 144 }, //1.222222 127 128 }; 129 130 static struct camera_size_type zsl_picture_sizes[] = { 131 { 1280, 960}, // 1.3MP 132 { 800, 600}, //SVGA 133 { 800, 480}, // WVGA 134 { 640, 480}, // VGA 135 { 352, 288}, //CIF 136 { 320, 240}, // QVGA 137 { 176, 144} // QCIF 138 }; 139 140 static camera_size_type default_picture_sizes[] = { 141 { 4000, 3000}, // 12MP 142 { 3264, 2448}, // 8MP 143 { 3264, 1836}, // Picture Size to match 1080p,720p AR 144 { 3264, 2176}, // Picture Size to match 480p AR 145 { 2592, 1944}, // 5MP 146 { 2048, 1536}, // 3MP QXGA 147 { 1920, 1080}, // HD1080 148 { 1600, 1200}, // 2MP UXGA 149 { 1280, 960}, // 1.3MP 150 { 1280, 720}, 151 { 720, 480}, 152 { 800, 480}, // WVGA 153 { 640, 480}, // VGA 154 { 352, 288}, // CIF 155 { 320, 240}, // QVGA 156 { 176, 144} // QCIF 157 }; 158 159 static int iso_speed_values[] = { 160 0, 1, 100, 200, 400, 800, 1600 161 }; 162 163 extern int HAL_numOfCameras; 164 extern qcamera_info_t HAL_cameraInfo[MSM_MAX_CAMERA_SENSORS]; 165 extern mm_camera_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS]; 166 167 namespace android { 168 169 static uint32_t HFR_SIZE_COUNT=2; 170 static const int PICTURE_FORMAT_JPEG = 1; 171 static const int PICTURE_FORMAT_RAW = 2; 172 173 /********************************************************************/ 174 static const str_map effects[] = { 175 { QCameraParameters::EFFECT_NONE, CAMERA_EFFECT_OFF }, 176 { QCameraParameters::EFFECT_MONO, CAMERA_EFFECT_MONO }, 177 { QCameraParameters::EFFECT_NEGATIVE, CAMERA_EFFECT_NEGATIVE }, 178 { QCameraParameters::EFFECT_SOLARIZE, CAMERA_EFFECT_SOLARIZE }, 179 { QCameraParameters::EFFECT_SEPIA, CAMERA_EFFECT_SEPIA }, 180 { QCameraParameters::EFFECT_POSTERIZE, CAMERA_EFFECT_POSTERIZE }, 181 { QCameraParameters::EFFECT_AQUA, CAMERA_EFFECT_AQUA }, 182 { QCameraParameters::EFFECT_EMBOSS, CAMERA_EFFECT_EMBOSS }, 183 { QCameraParameters::EFFECT_SKETCH, CAMERA_EFFECT_SKETCH }, 184 { QCameraParameters::EFFECT_NEON, CAMERA_EFFECT_NEON } 185 }; 186 187 static const str_map iso[] = { 188 { QCameraParameters::ISO_AUTO, CAMERA_ISO_AUTO}, 189 { QCameraParameters::ISO_HJR, CAMERA_ISO_DEBLUR}, 190 { QCameraParameters::ISO_100, CAMERA_ISO_100}, 191 { QCameraParameters::ISO_200, CAMERA_ISO_200}, 192 { QCameraParameters::ISO_400, CAMERA_ISO_400}, 193 { QCameraParameters::ISO_800, CAMERA_ISO_800 }, 194 { QCameraParameters::ISO_1600, CAMERA_ISO_1600 } 195 }; 196 197 static const str_map scenemode[] = { 198 { QCameraParameters::SCENE_MODE_AUTO, CAMERA_BESTSHOT_OFF }, 199 { QCameraParameters::SCENE_MODE_ASD, CAMERA_BESTSHOT_AUTO }, 200 { QCameraParameters::SCENE_MODE_ACTION, CAMERA_BESTSHOT_ACTION }, 201 { QCameraParameters::SCENE_MODE_PORTRAIT, CAMERA_BESTSHOT_PORTRAIT }, 202 { QCameraParameters::SCENE_MODE_LANDSCAPE, CAMERA_BESTSHOT_LANDSCAPE }, 203 { QCameraParameters::SCENE_MODE_NIGHT, CAMERA_BESTSHOT_NIGHT }, 204 { QCameraParameters::SCENE_MODE_NIGHT_PORTRAIT, CAMERA_BESTSHOT_NIGHT_PORTRAIT }, 205 { QCameraParameters::SCENE_MODE_THEATRE, CAMERA_BESTSHOT_THEATRE }, 206 { QCameraParameters::SCENE_MODE_BEACH, CAMERA_BESTSHOT_BEACH }, 207 { QCameraParameters::SCENE_MODE_SNOW, CAMERA_BESTSHOT_SNOW }, 208 { QCameraParameters::SCENE_MODE_SUNSET, CAMERA_BESTSHOT_SUNSET }, 209 { QCameraParameters::SCENE_MODE_STEADYPHOTO, CAMERA_BESTSHOT_ANTISHAKE }, 210 { QCameraParameters::SCENE_MODE_FIREWORKS , CAMERA_BESTSHOT_FIREWORKS }, 211 { QCameraParameters::SCENE_MODE_SPORTS , CAMERA_BESTSHOT_SPORTS }, 212 { QCameraParameters::SCENE_MODE_PARTY, CAMERA_BESTSHOT_PARTY }, 213 { QCameraParameters::SCENE_MODE_CANDLELIGHT, CAMERA_BESTSHOT_CANDLELIGHT }, 214 { QCameraParameters::SCENE_MODE_BACKLIGHT, CAMERA_BESTSHOT_BACKLIGHT }, 215 { QCameraParameters::SCENE_MODE_FLOWERS, CAMERA_BESTSHOT_FLOWERS }, 216 { QCameraParameters::SCENE_MODE_AR, CAMERA_BESTSHOT_AR }, 217 { QCameraParameters::SCENE_MODE_HDR, CAMERA_BESTSHOT_AUTO }, 218 }; 219 220 static const str_map scenedetect[] = { 221 { QCameraParameters::SCENE_DETECT_OFF, false }, 222 { QCameraParameters::SCENE_DETECT_ON, true }, 223 }; 224 225 #define DONT_CARE AF_MODE_MAX 226 // These are listed as the supported focus-modes for cameras with AF 227 static const str_map focus_modes_auto[] = { 228 { QCameraParameters::FOCUS_MODE_AUTO, AF_MODE_AUTO}, 229 { QCameraParameters::FOCUS_MODE_INFINITY, AF_MODE_INFINITY }, 230 { QCameraParameters::FOCUS_MODE_NORMAL, AF_MODE_NORMAL }, 231 { QCameraParameters::FOCUS_MODE_MACRO, AF_MODE_MACRO }, 232 { QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE, AF_MODE_CAF}, 233 { QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO, AF_MODE_CAF }, 234 // Note that "FIXED" is omitted 235 }; 236 237 // These are the supported focus-modes for cameras without AF 238 static const str_map focus_modes_fixed[] = { 239 { QCameraParameters::FOCUS_MODE_FIXED, AF_MODE_INFINITY }, 240 }; 241 242 static const str_map selectable_zone_af[] = { 243 { QCameraParameters::SELECTABLE_ZONE_AF_AUTO, AUTO }, 244 { QCameraParameters::SELECTABLE_ZONE_AF_SPOT_METERING, SPOT }, 245 { QCameraParameters::SELECTABLE_ZONE_AF_CENTER_WEIGHTED, CENTER_WEIGHTED }, 246 { QCameraParameters::SELECTABLE_ZONE_AF_FRAME_AVERAGE, AVERAGE } 247 }; 248 249 static const str_map autoexposure[] = { 250 { QCameraParameters::AUTO_EXPOSURE_FRAME_AVG, CAMERA_AEC_FRAME_AVERAGE }, 251 { QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED, CAMERA_AEC_CENTER_WEIGHTED }, 252 { QCameraParameters::AUTO_EXPOSURE_SPOT_METERING, CAMERA_AEC_SPOT_METERING } 253 }; 254 255 // from aeecamera.h 256 static const str_map whitebalance[] = { 257 { QCameraParameters::WHITE_BALANCE_AUTO, CAMERA_WB_AUTO }, 258 { QCameraParameters::WHITE_BALANCE_INCANDESCENT, CAMERA_WB_INCANDESCENT }, 259 { QCameraParameters::WHITE_BALANCE_FLUORESCENT, CAMERA_WB_FLUORESCENT }, 260 { QCameraParameters::WHITE_BALANCE_DAYLIGHT, CAMERA_WB_DAYLIGHT }, 261 { QCameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT, CAMERA_WB_CLOUDY_DAYLIGHT } 262 }; 263 264 static const str_map antibanding[] = { 265 { QCameraParameters::ANTIBANDING_OFF, CAMERA_ANTIBANDING_OFF }, 266 { QCameraParameters::ANTIBANDING_50HZ, CAMERA_ANTIBANDING_50HZ }, 267 { QCameraParameters::ANTIBANDING_60HZ, CAMERA_ANTIBANDING_60HZ }, 268 { QCameraParameters::ANTIBANDING_AUTO, CAMERA_ANTIBANDING_AUTO } 269 }; 270 271 static const str_map frame_rate_modes[] = { 272 {QCameraParameters::KEY_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO}, 273 {QCameraParameters::KEY_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED} 274 }; 275 276 static const str_map touchafaec[] = { 277 { QCameraParameters::TOUCH_AF_AEC_OFF, false }, 278 { QCameraParameters::TOUCH_AF_AEC_ON, true } 279 }; 280 281 static const str_map hfr[] = { 282 { QCameraParameters::VIDEO_HFR_OFF, CAMERA_HFR_MODE_OFF }, 283 { QCameraParameters::VIDEO_HFR_2X, CAMERA_HFR_MODE_60FPS }, 284 { QCameraParameters::VIDEO_HFR_3X, CAMERA_HFR_MODE_90FPS }, 285 { QCameraParameters::VIDEO_HFR_4X, CAMERA_HFR_MODE_120FPS }, 286 }; 287 static const int HFR_VALUES_COUNT = (sizeof(hfr)/sizeof(str_map)); 288 289 static const str_map flash[] = { 290 { QCameraParameters::FLASH_MODE_OFF, LED_MODE_OFF }, 291 { QCameraParameters::FLASH_MODE_AUTO, LED_MODE_AUTO }, 292 { QCameraParameters::FLASH_MODE_ON, LED_MODE_ON }, 293 { QCameraParameters::FLASH_MODE_TORCH, LED_MODE_TORCH} 294 }; 295 296 static const str_map lensshade[] = { 297 { QCameraParameters::LENSSHADE_ENABLE, true }, 298 { QCameraParameters::LENSSHADE_DISABLE, false } 299 }; 300 301 static const str_map mce[] = { 302 { QCameraParameters::MCE_ENABLE, true }, 303 { QCameraParameters::MCE_DISABLE, false } 304 }; 305 306 static const str_map histogram[] = { 307 { QCameraParameters::HISTOGRAM_ENABLE, true }, 308 { QCameraParameters::HISTOGRAM_DISABLE, false } 309 }; 310 311 static const str_map skinToneEnhancement[] = { 312 { QCameraParameters::SKIN_TONE_ENHANCEMENT_ENABLE, true }, 313 { QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE, false } 314 }; 315 316 static const str_map denoise[] = { 317 { QCameraParameters::DENOISE_OFF, false }, 318 { QCameraParameters::DENOISE_ON, true } 319 }; 320 321 static const str_map facedetection[] = { 322 { QCameraParameters::FACE_DETECTION_OFF, false }, 323 { QCameraParameters::FACE_DETECTION_ON, true } 324 }; 325 326 static const str_map redeye_reduction[] = { 327 { QCameraParameters::REDEYE_REDUCTION_ENABLE, true }, 328 { QCameraParameters::REDEYE_REDUCTION_DISABLE, false } 329 }; 330 331 static const str_map picture_formats[] = { 332 {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG}, 333 {QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW} 334 }; 335 336 static const str_map recording_Hints[] = { 337 {"false", false}, 338 {"true", true} 339 }; 340 341 static const str_map preview_formats[] = { 342 {QCameraParameters::PIXEL_FORMAT_YUV420SP, HAL_PIXEL_FORMAT_YCrCb_420_SP}, 343 {QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO, HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO}, 344 {QCameraParameters::PIXEL_FORMAT_YV12, HAL_PIXEL_FORMAT_YV12}, 345 {QCameraParameters::PIXEL_FORMAT_YUV420P,HAL_PIXEL_FORMAT_YV12}, 346 {QCameraParameters::PIXEL_FORMAT_NV12, HAL_PIXEL_FORMAT_YCbCr_420_SP} 347 }; 348 349 static const preview_format_info_t preview_format_info_list[] = { 350 {HAL_PIXEL_FORMAT_YCrCb_420_SP, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_WORD, 2}, 351 {HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_4K, 2}, 352 {HAL_PIXEL_FORMAT_YCbCr_420_SP, CAMERA_YUV_420_NV12, CAMERA_PAD_TO_WORD, 2}, 353 {HAL_PIXEL_FORMAT_YV12, CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3} 354 }; 355 356 static const str_map zsl_modes[] = { 357 { QCameraParameters::ZSL_OFF, false }, 358 { QCameraParameters::ZSL_ON, true }, 359 }; 360 361 362 static const str_map hdr_bracket[] = { 363 { QCameraParameters::AE_BRACKET_HDR_OFF,HDR_BRACKETING_OFF}, 364 { QCameraParameters::AE_BRACKET_HDR,HDR_MODE }, 365 }; 366 367 typedef enum { 368 NORMAL_POWER, 369 LOW_POWER 370 } power_mode; 371 372 static const str_map power_modes[] = { 373 { QCameraParameters::NORMAL_POWER,NORMAL_POWER }, 374 { QCameraParameters::LOW_POWER,LOW_POWER } 375 }; 376 377 /**************************************************************************/ 378 static int attr_lookup(const str_map arr[], int len, const char *name) 379 { 380 if (name) { 381 for (int i = 0; i < len; i++) { 382 if (!strcmp(arr[i].desc, name)) 383 return arr[i].val; 384 } 385 } 386 return NOT_FOUND; 387 } 388 389 bool QCameraHardwareInterface::native_set_parms( 390 mm_camera_parm_type_t type, uint16_t length, void *value) 391 { 392 ALOGV("%s : type : %d Value : %d",__func__,type,*((int *)value)); 393 if(MM_CAMERA_OK != cam_config_set_parm(mCameraId, type,value )) { 394 ALOGE("native_set_parms failed: type %d length %d error %s", 395 type, length, strerror(errno)); 396 return false; 397 } 398 399 return true; 400 401 } 402 403 bool QCameraHardwareInterface::native_set_parms( 404 mm_camera_parm_type_t type, uint16_t length, void *value, int *result) 405 { 406 *result= cam_config_set_parm(mCameraId, type,value ); 407 if(MM_CAMERA_OK == *result) { 408 ALOGV("native_set_parms: succeeded : %d", *result); 409 return true; 410 } 411 412 ALOGE("native_set_parms failed: type %d length %d error str %s error# %d", 413 type, length, strerror(errno), errno); 414 return false; 415 } 416 417 //Filter Picture sizes based on max width and height 418 /* TBD: do we still need this - except for ZSL? */ 419 void QCameraHardwareInterface::filterPictureSizes(){ 420 unsigned int i; 421 if(mPictureSizeCount <= 0) 422 return; 423 maxSnapshotWidth = mPictureSizes[0].width; 424 maxSnapshotHeight = mPictureSizes[0].height; 425 // Iterate through all the width and height to find the max value 426 for(i =0; i<mPictureSizeCount;i++){ 427 if(((maxSnapshotWidth < mPictureSizes[i].width) && 428 (maxSnapshotHeight <= mPictureSizes[i].height))){ 429 maxSnapshotWidth = mPictureSizes[i].width; 430 maxSnapshotHeight = mPictureSizes[i].height; 431 } 432 } 433 if(myMode & CAMERA_ZSL_MODE){ 434 // due to lack of PMEM we restrict to lower resolution 435 mPictureSizesPtr = zsl_picture_sizes; 436 mSupportedPictureSizesCount = 7; 437 }else{ 438 mPictureSizesPtr = mPictureSizes; 439 mSupportedPictureSizesCount = mPictureSizeCount; 440 } 441 } 442 443 static String8 create_sizes_str(const camera_size_type *sizes, int len) { 444 String8 str; 445 char buffer[32]; 446 447 if (len > 0) { 448 snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height); 449 str.append(buffer); 450 } 451 for (int i = 1; i < len; i++) { 452 snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height); 453 str.append(buffer); 454 } 455 return str; 456 } 457 458 String8 QCameraHardwareInterface::create_values_str(const str_map *values, int len) { 459 String8 str; 460 461 if (len > 0) { 462 str.append(values[0].desc); 463 } 464 for (int i = 1; i < len; i++) { 465 str.append(","); 466 str.append(values[i].desc); 467 } 468 return str; 469 } 470 471 static String8 create_fps_str(const android:: FPSRange* fps, int len) { 472 String8 str; 473 char buffer[32]; 474 475 if (len > 0) { 476 snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS); 477 str.append(buffer); 478 } 479 for (int i = 1; i < len; i++) { 480 snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS); 481 str.append(buffer); 482 } 483 return str; 484 } 485 486 static String8 create_values_range_str(int min, int max){ 487 String8 str; 488 char buffer[32]; 489 490 if(min <= max){ 491 snprintf(buffer, sizeof(buffer), "%d", min); 492 str.append(buffer); 493 494 for (int i = min + 1; i <= max; i++) { 495 snprintf(buffer, sizeof(buffer), ",%d", i); 496 str.append(buffer); 497 } 498 } 499 return str; 500 } 501 502 static int parse_size(const char *str, int &width, int &height) 503 { 504 // Find the width. 505 char *end; 506 int w = (int)strtol(str, &end, 10); 507 // If an 'x' or 'X' does not immediately follow, give up. 508 if ( (*end != 'x') && (*end != 'X') ) 509 return -1; 510 511 // Find the height, immediately after the 'x'. 512 int h = (int)strtol(end+1, 0, 10); 513 514 width = w; 515 height = h; 516 517 return 0; 518 } 519 520 bool QCameraHardwareInterface::isValidDimension(int width, int height) { 521 bool retVal = false; 522 /* This function checks if a given resolution is valid or not. 523 * A particular resolution is considered valid if it satisfies 524 * the following conditions: 525 * 1. width & height should be multiple of 16. 526 * 2. width & height should be less than/equal to the dimensions 527 * supported by the camera sensor. 528 * 3. the aspect ratio is a valid aspect ratio and is among the 529 * commonly used aspect ratio as determined by the thumbnail_sizes 530 * data structure. 531 */ 532 533 if( (width == CEILING16(width)) && (height == CEILING16(height)) 534 && (width <= maxSnapshotWidth) 535 && (height <= maxSnapshotHeight) ) 536 { 537 uint32_t pictureAspectRatio = (uint32_t)((width * Q12)/height); 538 for(uint32_t i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ) { 539 if(thumbnail_sizes[i].aspect_ratio == pictureAspectRatio) { 540 retVal = true; 541 break; 542 } 543 } 544 } 545 return retVal; 546 } 547 548 void QCameraHardwareInterface::hasAutoFocusSupport(){ 549 550 ALOGV("%s",__func__); 551 552 if(isZSLMode()){ 553 mHasAutoFocusSupport = false; 554 return; 555 } 556 557 if(cam_ops_is_op_supported (mCameraId, MM_CAMERA_OPS_FOCUS )) { 558 mHasAutoFocusSupport = true; 559 } 560 else { 561 ALOGV("AutoFocus is not supported"); 562 mHasAutoFocusSupport = false; 563 } 564 565 ALOGV("%s:rc= %d",__func__, mHasAutoFocusSupport); 566 567 } 568 569 bool QCameraHardwareInterface::supportsSceneDetection() { 570 bool rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_ASD_ENABLE); 571 return rc; 572 } 573 574 bool QCameraHardwareInterface::supportsFaceDetection() { 575 bool rc; 576 577 status_t ret = NO_ERROR; 578 mm_camera_op_mode_type_t op_mode; 579 580 ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_OP_MODE, &op_mode); 581 if(ret != NO_ERROR){ 582 ALOGE("%s: Failed to get Op Mode", __func__); 583 } 584 585 ALOGV("%s: OP_Mode is %d, ret=%d, mHdrMode=%d",__func__,op_mode,ret,mHdrMode); 586 if ((ret == NO_ERROR) && (op_mode == MM_CAMERA_OP_MODE_VIDEO) && (mHdrMode != HDR_MODE)) 587 { 588 ALOGV("%s: Video mode : FD not supported",__func__); 589 return false; 590 } 591 else{ 592 rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_FD); 593 ALOGV("%s: Still mode : FD supported : %d",__func__,rc); 594 return rc; 595 } 596 } 597 598 bool QCameraHardwareInterface::supportsSelectableZoneAf() { 599 bool rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_FOCUS_RECT); 600 return rc; 601 } 602 603 bool QCameraHardwareInterface::supportsRedEyeReduction() { 604 bool rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_REDEYE_REDUCTION); 605 return rc; 606 } 607 608 static String8 create_str(int16_t *arr, int length){ 609 String8 str; 610 char buffer[32] = {0}; 611 612 if(length > 0){ 613 snprintf(buffer, sizeof(buffer), "%d", arr[0]); 614 str.append(buffer); 615 } 616 617 for (int i =1;i<length;i++){ 618 snprintf(buffer, sizeof(buffer), ",%d",arr[i]); 619 str.append(buffer); 620 } 621 return str; 622 } 623 624 bool QCameraHardwareInterface::getMaxPictureDimension(mm_camera_dimension_t *maxDim) 625 { 626 bool ret = NO_ERROR; 627 mm_camera_dimension_t dim; 628 629 ret = cam_config_get_parm(mCameraId, 630 MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim); 631 if (ret != NO_ERROR) 632 return ret; 633 634 /* Find the first dimension in the mPictureSizes 635 * array which is smaller than the max dimension. 636 * This will be the valid max picture resolution */ 637 for (unsigned int i = 0; i < mPictureSizeCount; i++) { 638 if ((mPictureSizes[i].width <= dim.width) && 639 (mPictureSizes[i].height <= dim.height)) { 640 maxDim->height = mPictureSizes[i].height; 641 maxDim->width = mPictureSizes[i].width; 642 break; 643 } 644 } 645 ALOGV("%s: Found Max Picture dimension: %d x %d", __func__, 646 maxDim->width, maxDim->height); 647 return ret; 648 } 649 void QCameraHardwareInterface::loadTables() 650 { 651 652 bool ret = NO_ERROR; 653 ALOGV("%s: E", __func__); 654 655 ret = cam_config_get_parm(mCameraId, 656 MM_CAMERA_PARM_PREVIEW_SIZES_CNT, &preview_sizes_count); 657 658 default_sizes_tbl_t preview_sizes_tbl; 659 preview_sizes_tbl.tbl_size=preview_sizes_count; 660 preview_sizes_tbl.sizes_tbl=&default_preview_sizes[0]; 661 if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, 662 MM_CAMERA_PARM_DEF_PREVIEW_SIZES, &preview_sizes_tbl)){ 663 ALOGE("%s:Failed to get default preview sizes",__func__); 664 } 665 ret = cam_config_get_parm(mCameraId, 666 MM_CAMERA_PARM_VIDEO_SIZES_CNT, &video_sizes_count); 667 668 default_sizes_tbl_t video_sizes_tbl; 669 video_sizes_tbl.tbl_size=video_sizes_count; 670 video_sizes_tbl.sizes_tbl=&default_video_sizes[0]; 671 if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, 672 MM_CAMERA_PARM_DEF_VIDEO_SIZES, &video_sizes_tbl)){ 673 ALOGE("%s:Failed to get default video sizes",__func__); 674 } 675 676 ret = cam_config_get_parm(mCameraId, 677 MM_CAMERA_PARM_THUMB_SIZES_CNT, &thumbnail_sizes_count); 678 679 default_sizes_tbl_t thumbnail_sizes_tbl; 680 thumbnail_sizes_tbl.tbl_size=thumbnail_sizes_count; 681 thumbnail_sizes_tbl.sizes_tbl=&default_thumbnail_sizes[0]; 682 if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, 683 MM_CAMERA_PARM_DEF_THUMB_SIZES, &thumbnail_sizes_tbl)){ 684 ALOGE("%s:Failed to get default thumbnail sizes",__func__); 685 } 686 687 ret = cam_config_get_parm(mCameraId, 688 MM_CAMERA_PARM_HFR_SIZES_CNT, &hfr_sizes_count); 689 690 default_sizes_tbl_t hfr_sizes_tbl; 691 hfr_sizes_tbl.tbl_size=hfr_sizes_count; 692 hfr_sizes_tbl.sizes_tbl=&default_hfr_sizes[0]; 693 if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, 694 MM_CAMERA_PARM_DEF_HFR_SIZES, &hfr_sizes_tbl)){ 695 ALOGE("%s:Failed to get default HFR sizes",__func__); 696 } 697 ALOGV("%s: X", __func__); 698 } 699 700 rat_t getRational(int num, int denom) 701 { 702 rat_t temp = {num, denom}; 703 return temp; 704 } 705 706 void QCameraHardwareInterface::initDefaultParameters() 707 { 708 bool ret; 709 char prop[PROPERTY_VALUE_MAX]; 710 mm_camera_dimension_t maxDim; 711 int rc = MM_CAMERA_OK; 712 ALOGV("%s: E", __func__); 713 714 memset(&maxDim, 0, sizeof(mm_camera_dimension_t)); 715 ret = getMaxPictureDimension(&maxDim); 716 717 if (ret != NO_ERROR) { 718 ALOGE("%s: Cannot get Max picture size supported", __func__); 719 return; 720 } 721 if (!maxDim.width || !maxDim.height) { 722 maxDim.width = DEFAULT_LIVESHOT_WIDTH; 723 maxDim.height = DEFAULT_LIVESHOT_HEIGHT; 724 } 725 726 memset(prop, 0, sizeof(prop)); 727 property_get("persist.camera.snap.format", prop, "0"); 728 mSnapshotFormat = atoi(prop); 729 ALOGV("%s: prop =(%s), snap_format=%d", __func__, prop, mSnapshotFormat); 730 731 //cam_ctrl_dimension_t dim; 732 mHFRLevel = 0; 733 memset(&mDimension, 0, sizeof(cam_ctrl_dimension_t)); 734 memset(&mPreviewFormatInfo, 0, sizeof(preview_format_info_t)); 735 mDimension.video_width = DEFAULT_VIDEO_WIDTH; 736 mDimension.video_height = DEFAULT_VIDEO_HEIGHT; 737 // mzhu mDimension.picture_width = DEFAULT_STREAM_WIDTH; 738 // mzhu mDimension.picture_height = DEFAULT_STREAM_HEIGHT; 739 mDimension.picture_width = maxDim.width; 740 mDimension.picture_height = maxDim.height; 741 mDimension.display_width = DEFAULT_STREAM_WIDTH; 742 mDimension.display_height = DEFAULT_STREAM_HEIGHT; 743 mDimension.orig_picture_dx = mDimension.picture_width; 744 mDimension.orig_picture_dy = mDimension.picture_height; 745 mDimension.ui_thumbnail_width = DEFAULT_STREAM_WIDTH; 746 mDimension.ui_thumbnail_height = DEFAULT_STREAM_HEIGHT; 747 mDimension.orig_video_width = DEFAULT_STREAM_WIDTH; 748 mDimension.orig_video_height = DEFAULT_STREAM_HEIGHT; 749 750 mDimension.prev_format = CAMERA_YUV_420_NV21; 751 mDimension.enc_format = CAMERA_YUV_420_NV12; 752 if (mSnapshotFormat == 1) { 753 mDimension.main_img_format = CAMERA_YUV_422_NV61; 754 } else { 755 mDimension.main_img_format = CAMERA_YUV_420_NV21; 756 } 757 mDimension.thumb_format = CAMERA_YUV_420_NV21; 758 ALOGV("%s: main_img_format =%d, thumb_format=%d", __func__, 759 mDimension.main_img_format, mDimension.thumb_format); 760 mDimension.prev_padding_format = CAMERA_PAD_TO_WORD; 761 762 ret = native_set_parms(MM_CAMERA_PARM_DIMENSION, 763 sizeof(cam_ctrl_dimension_t), (void *) &mDimension); 764 if(!ret) { 765 ALOGE("MM_CAMERA_PARM_DIMENSION Failed."); 766 return; 767 } 768 769 hasAutoFocusSupport(); 770 771 // Initialize constant parameter strings. This will happen only once in the 772 // lifetime of the mediaserver process. 773 if (true/*!mParamStringInitialized*/) { 774 //filter picture sizes 775 filterPictureSizes(); 776 mPictureSizeValues = create_sizes_str( 777 mPictureSizesPtr, mSupportedPictureSizesCount); 778 mPreviewSizeValues = create_sizes_str( 779 mPreviewSizes, mPreviewSizeCount); 780 mVideoSizeValues = create_sizes_str( 781 mVideoSizes, mVideoSizeCount); 782 783 //Query for max HFR value 784 camera_hfr_mode_t maxHFR; 785 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_MAX_HFR_MODE, (void *)&maxHFR); 786 //Filter HFR values and build parameter string 787 String8 str; 788 for(int i=0; i<HFR_VALUES_COUNT; i++){ 789 if(hfr[i].val <= maxHFR){ 790 if(i>0) str.append(","); 791 str.append(hfr[i].desc); 792 } 793 } 794 mHfrValues = str; 795 mHfrSizeValues = create_sizes_str( 796 default_hfr_sizes, hfr_sizes_count); 797 mFpsRangesSupportedValues = create_fps_str( 798 FpsRangesSupported,FPS_RANGES_SUPPORTED_COUNT ); 799 mParameters.set( 800 QCameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 801 mFpsRangesSupportedValues); 802 mParameters.setPreviewFpsRange(MINIMUM_FPS*1000,MAXIMUM_FPS*1000); 803 mFlashValues = create_values_str( 804 flash, sizeof(flash) / sizeof(str_map)); 805 mLensShadeValues = create_values_str( 806 lensshade,sizeof(lensshade)/sizeof(str_map)); 807 mMceValues = create_values_str( 808 mce,sizeof(mce)/sizeof(str_map)); 809 mEffectValues = create_values_str(effects, sizeof(effects) / sizeof(str_map)); 810 mAntibandingValues = create_values_str( 811 antibanding, sizeof(antibanding) / sizeof(str_map)); 812 mIsoValues = create_values_str(iso,sizeof(iso)/sizeof(str_map)); 813 mAutoExposureValues = create_values_str( 814 autoexposure, sizeof(autoexposure) / sizeof(str_map)); 815 mWhitebalanceValues = create_values_str( 816 whitebalance, sizeof(whitebalance) / sizeof(str_map)); 817 818 if(mHasAutoFocusSupport){ 819 mFocusModeValues = create_values_str( 820 focus_modes_auto, sizeof(focus_modes_auto) / sizeof(str_map)); 821 } 822 823 mSceneModeValues = create_values_str(scenemode, sizeof(scenemode) / sizeof(str_map)); 824 825 if(mHasAutoFocusSupport){ 826 mTouchAfAecValues = create_values_str( 827 touchafaec,sizeof(touchafaec)/sizeof(str_map)); 828 } 829 //Currently Enabling Histogram for 8x60 830 mHistogramValues = create_values_str( 831 histogram,sizeof(histogram)/sizeof(str_map)); 832 833 mSkinToneEnhancementValues = create_values_str( 834 skinToneEnhancement,sizeof(skinToneEnhancement)/sizeof(str_map)); 835 836 mPictureFormatValues = create_values_str( 837 picture_formats, sizeof(picture_formats)/sizeof(str_map)); 838 839 mZoomSupported=false; 840 mMaxZoom=0; 841 mm_camera_zoom_tbl_t zmt; 842 if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, 843 MM_CAMERA_PARM_MAXZOOM, &mMaxZoom)){ 844 ALOGE("%s:Failed to get max zoom",__func__); 845 }else{ 846 847 ALOGV("Max Zoom:%d",mMaxZoom); 848 /* Kernel driver limits the max amount of data that can be retreived through a control 849 command to 260 bytes hence we conservatively limit to 110 zoom ratios */ 850 if(mMaxZoom>MAX_ZOOM_RATIOS) { 851 ALOGV("%s:max zoom is larger than sizeof zoomRatios table",__func__); 852 mMaxZoom=MAX_ZOOM_RATIOS-1; 853 } 854 zmt.size=mMaxZoom; 855 zmt.zoom_ratio_tbl=&zoomRatios[0]; 856 if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, 857 MM_CAMERA_PARM_ZOOM_RATIO, &zmt)){ 858 ALOGE("%s:Failed to get max zoom ratios",__func__); 859 }else{ 860 mZoomSupported=true; 861 mZoomRatioValues = create_str(zoomRatios, mMaxZoom); 862 } 863 } 864 865 ALOGV("Zoom supported:%d",mZoomSupported); 866 867 denoise_value = create_values_str( 868 denoise, sizeof(denoise) / sizeof(str_map)); 869 870 if(supportsFaceDetection()) { 871 mFaceDetectionValues = create_values_str( 872 facedetection, sizeof(facedetection) / sizeof(str_map)); 873 } 874 875 if(mHasAutoFocusSupport){ 876 mSelectableZoneAfValues = create_values_str( 877 selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map)); 878 } 879 880 mSceneDetectValues = create_values_str(scenedetect, sizeof(scenedetect) / sizeof(str_map)); 881 882 mRedeyeReductionValues = create_values_str( 883 redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map)); 884 885 mZslValues = create_values_str( 886 zsl_modes,sizeof(zsl_modes)/sizeof(str_map)); 887 888 mParamStringInitialized = true; 889 } 890 891 //set supported video sizes 892 mParameters.set(QCameraParameters::KEY_SUPPORTED_VIDEO_SIZES, mVideoSizeValues.string()); 893 894 //set default video size to first one in supported table 895 String8 vSize = create_sizes_str(&mVideoSizes[0], 1); 896 mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, vSize.string()); 897 898 //Set Preview size 899 int default_preview_width, default_preview_height; 900 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH, 901 &default_preview_width); 902 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT, 903 &default_preview_height); 904 mParameters.setPreviewSize(default_preview_width, default_preview_height); 905 mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 906 mPreviewSizeValues.string()); 907 mDimension.display_width = default_preview_width; 908 mDimension.display_height = default_preview_height; 909 910 //Set Preview Frame Rate 911 if(mFps >= MINIMUM_FPS && mFps <= MAXIMUM_FPS) { 912 mPreviewFrameRateValues = create_values_range_str( 913 MINIMUM_FPS, mFps); 914 }else{ 915 mPreviewFrameRateValues = create_values_range_str( 916 MINIMUM_FPS, MAXIMUM_FPS); 917 } 918 919 920 if (cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS)) { 921 mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 922 mPreviewFrameRateValues.string()); 923 } else { 924 mParameters.set( 925 QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 926 DEFAULT_FIXED_FPS); 927 } 928 929 //Set Preview Frame Rate Modes 930 mParameters.setPreviewFrameRateMode("frame-rate-auto"); 931 mFrameRateModeValues = create_values_str( 932 frame_rate_modes, sizeof(frame_rate_modes) / sizeof(str_map)); 933 if(cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS_MODE)){ 934 mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATE_MODES, 935 mFrameRateModeValues.string()); 936 } 937 938 //Set Preview Format 939 //mParameters.setPreviewFormat("yuv420sp"); // informative 940 mParameters.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP); 941 942 mPreviewFormatValues = create_values_str( 943 preview_formats, sizeof(preview_formats) / sizeof(str_map)); 944 mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 945 mPreviewFormatValues.string()); 946 947 //Set Overlay Format 948 mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP); 949 mParameters.set("max-num-detected-faces-hw", "2"); 950 951 // Set supported max faces 952 int maxNumFaces = 0; 953 if (supportsFaceDetection()) { 954 //Query the maximum number of faces supported by hardware. 955 if(MM_CAMERA_OK != cam_config_get_parm(mCameraId, 956 MM_CAMERA_PARM_MAX_NUM_FACES_DECT, &maxNumFaces)){ 957 ALOGE("%s:Failed to get max number of faces supported",__func__); 958 } 959 } 960 mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, maxNumFaces); 961 //This paramtere is set to default here. This will be changed by application 962 //if it needs to support specific number of faces. See also setParameters. 963 mParameters.set(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES, 2); 964 965 // Set camera features supported flag 966 int32_t featureFlag = 0; 967 if (supportsFaceDetection()) { 968 featureFlag |= 0x00000001; // bit 0 indicate faciral feature 969 } 970 mParameters.set(QCameraParameters::KEY_SUPPORTED_CAMERA_FEATURES, featureFlag); 971 972 //Set Picture Size 973 mParameters.setPictureSize(DEFAULT_PICTURE_WIDTH, DEFAULT_PICTURE_HEIGHT); 974 mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 975 mPictureSizeValues.string()); 976 977 //Set Preview Frame Rate 978 if(mFps >= MINIMUM_FPS && mFps <= MAXIMUM_FPS) { 979 mParameters.setPreviewFrameRate(mFps); 980 }else{ 981 mParameters.setPreviewFrameRate(DEFAULT_FPS); 982 } 983 984 //Set Picture Format 985 mParameters.setPictureFormat("jpeg"); // informative 986 mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 987 mPictureFormatValues); 988 989 mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, "90"); // max quality 990 mJpegQuality = 90; 991 //Set Video Format 992 mParameters.set(QCameraParameters::KEY_VIDEO_FRAME_FORMAT, "yuv420sp"); 993 994 //Set Thumbnail parameters 995 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 996 THUMBNAIL_WIDTH_STR); // informative 997 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 998 THUMBNAIL_HEIGHT_STR); // informative 999 mDimension.ui_thumbnail_width = 1000 thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].width; 1001 mDimension.ui_thumbnail_height = 1002 thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].height; 1003 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "90"); 1004 String8 valuesStr = create_sizes_str(default_thumbnail_sizes, thumbnail_sizes_count); 1005 mParameters.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 1006 valuesStr.string()); 1007 // Define CAMERA_SMOOTH_ZOOM in Android.mk file , to enable smoothzoom 1008 #ifdef CAMERA_SMOOTH_ZOOM 1009 mParameters.set(QCameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, "true"); 1010 #endif 1011 if(mZoomSupported){ 1012 mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "true"); 1013 ALOGV("max zoom is %d", mMaxZoom-1); 1014 /* mMaxZoom value that the query interface returns is the size 1015 ALOGV("max zoom is %d", mMaxZoom-1); 1016 * mMaxZoom value that the query interface returns is the size 1017 * of zoom table. So the actual max zoom value will be one 1018 * less than that value. */ 1019 1020 mParameters.set("max-zoom",mMaxZoom-1); 1021 mParameters.set(QCameraParameters::KEY_ZOOM_RATIOS, 1022 mZoomRatioValues); 1023 } else 1024 { 1025 mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "false"); 1026 } 1027 1028 /* Enable zoom support for video application if VPE enabled */ 1029 if(mZoomSupported) { 1030 mParameters.set("video-zoom-support", "true"); 1031 } else { 1032 mParameters.set("video-zoom-support", "false"); 1033 } 1034 1035 //8960 supports Power modes : Low power, Normal Power. 1036 mParameters.set("power-mode-supported", "true"); 1037 1038 //Set Live shot support 1039 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_LIVESHOT_MAIN); 1040 if(!rc) { 1041 ALOGV("%s:LIVESHOT is not supported", __func__); 1042 mParameters.set("video-snapshot-supported", "false"); 1043 } else { 1044 mParameters.set("video-snapshot-supported", "true"); 1045 } 1046 1047 1048 //Set default power mode 1049 mParameters.set(QCameraParameters::KEY_POWER_MODE,"Low_Power"); 1050 //Set Wnr on 1051 mParameters.set(QCameraParameters::KEY_DENOISE,true); 1052 //Set Camera Mode 1053 mParameters.set(QCameraParameters::KEY_CAMERA_MODE,1); 1054 mParameters.set(QCameraParameters::KEY_AE_BRACKET_HDR,"Off"); 1055 1056 //Set Antibanding 1057 mParameters.set(QCameraParameters::KEY_ANTIBANDING, 1058 QCameraParameters::ANTIBANDING_AUTO); 1059 mParameters.set(QCameraParameters::KEY_SUPPORTED_ANTIBANDING, 1060 mAntibandingValues); 1061 1062 //Set Effect 1063 mParameters.set(QCameraParameters::KEY_EFFECT, 1064 QCameraParameters::EFFECT_NONE); 1065 mParameters.set(QCameraParameters::KEY_SUPPORTED_EFFECTS, mEffectValues); 1066 1067 //Set Auto Exposure 1068 mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE, 1069 QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED); 1070 mParameters.set(QCameraParameters::KEY_SUPPORTED_AUTO_EXPOSURE, mAutoExposureValues); 1071 1072 //Set WhiteBalance 1073 mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, 1074 QCameraParameters::WHITE_BALANCE_AUTO); 1075 mParameters.set(QCameraParameters::KEY_SUPPORTED_WHITE_BALANCE,mWhitebalanceValues); 1076 1077 //Set AEC_LOCK 1078 mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK, "false"); 1079 if(cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_AEC_LOCK)){ 1080 mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true"); 1081 } else { 1082 mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "false"); 1083 } 1084 //Set AWB_LOCK 1085 mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, "false"); 1086 if(cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_AWB_LOCK)) 1087 mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true"); 1088 else 1089 mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "false"); 1090 1091 //Set Focus Mode 1092 if(mHasAutoFocusSupport){ 1093 mParameters.set(QCameraParameters::KEY_FOCUS_MODE, 1094 QCameraParameters::FOCUS_MODE_AUTO); 1095 mFocusMode = AF_MODE_AUTO; 1096 mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES, 1097 mFocusModeValues); 1098 mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "1"); 1099 mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "1"); 1100 } else { 1101 mParameters.set(QCameraParameters::KEY_FOCUS_MODE, 1102 QCameraParameters::FOCUS_MODE_FIXED); 1103 mFocusMode = DONT_CARE; 1104 mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES, 1105 QCameraParameters::FOCUS_MODE_FIXED); 1106 mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "0"); 1107 mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "0"); 1108 } 1109 1110 mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, DEFAULT_CAMERA_AREA); 1111 mParameters.set(QCameraParameters::KEY_METERING_AREAS, DEFAULT_CAMERA_AREA); 1112 1113 //Set Flash 1114 if (cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_LED_MODE)) { 1115 mParameters.set(QCameraParameters::KEY_FLASH_MODE, 1116 QCameraParameters::FLASH_MODE_OFF); 1117 mParameters.set(QCameraParameters::KEY_SUPPORTED_FLASH_MODES, 1118 mFlashValues); 1119 } 1120 1121 //Set Sharpness 1122 mParameters.set(QCameraParameters::KEY_MAX_SHARPNESS, 1123 CAMERA_MAX_SHARPNESS); 1124 mParameters.set(QCameraParameters::KEY_SHARPNESS, 1125 CAMERA_DEF_SHARPNESS); 1126 1127 //Set Contrast 1128 mParameters.set(QCameraParameters::KEY_MAX_CONTRAST, 1129 CAMERA_MAX_CONTRAST); 1130 mParameters.set(QCameraParameters::KEY_CONTRAST, 1131 CAMERA_DEF_CONTRAST); 1132 1133 //Set Saturation 1134 mParameters.set(QCameraParameters::KEY_MAX_SATURATION, 1135 CAMERA_MAX_SATURATION); 1136 mParameters.set(QCameraParameters::KEY_SATURATION, 1137 CAMERA_DEF_SATURATION); 1138 1139 //Set Brightness/luma-adaptaion 1140 mParameters.set("luma-adaptation", "3"); 1141 1142 mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, 1143 QCameraParameters::PIXEL_FORMAT_JPEG); 1144 1145 //Set Lensshading 1146 mParameters.set(QCameraParameters::KEY_LENSSHADE, 1147 QCameraParameters::LENSSHADE_ENABLE); 1148 mParameters.set(QCameraParameters::KEY_SUPPORTED_LENSSHADE_MODES, 1149 mLensShadeValues); 1150 1151 //Set ISO Mode 1152 mParameters.set(QCameraParameters::KEY_ISO_MODE, 1153 QCameraParameters::ISO_AUTO); 1154 mParameters.set(QCameraParameters::KEY_SUPPORTED_ISO_MODES, 1155 mIsoValues); 1156 1157 //Set MCE 1158 mParameters.set(QCameraParameters::KEY_MEMORY_COLOR_ENHANCEMENT, 1159 QCameraParameters::MCE_ENABLE); 1160 mParameters.set(QCameraParameters::KEY_SUPPORTED_MEM_COLOR_ENHANCE_MODES, 1161 mMceValues); 1162 //Set HFR 1163 if (cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_HFR)) { 1164 mParameters.set(QCameraParameters::KEY_VIDEO_HIGH_FRAME_RATE, 1165 QCameraParameters::VIDEO_HFR_OFF); 1166 mParameters.set(QCameraParameters::KEY_SUPPORTED_HFR_SIZES, 1167 mHfrSizeValues.string()); 1168 mParameters.set(QCameraParameters::KEY_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES, 1169 mHfrValues); 1170 } else{ 1171 mParameters.set(QCameraParameters::KEY_SUPPORTED_HFR_SIZES,""); 1172 } 1173 1174 //Set Histogram 1175 mParameters.set(QCameraParameters::KEY_HISTOGRAM, 1176 QCameraParameters::HISTOGRAM_DISABLE); 1177 mParameters.set(QCameraParameters::KEY_SUPPORTED_HISTOGRAM_MODES, 1178 mHistogramValues); 1179 1180 //Set SkinTone Enhancement 1181 mParameters.set(QCameraParameters::KEY_SKIN_TONE_ENHANCEMENT, 1182 QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE); 1183 mParameters.set("skinToneEnhancement", "0"); 1184 mParameters.set(QCameraParameters::KEY_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES, 1185 mSkinToneEnhancementValues); 1186 1187 //Set Scene Mode 1188 mParameters.set(QCameraParameters::KEY_SCENE_MODE, 1189 QCameraParameters::SCENE_MODE_AUTO); 1190 mParameters.set(QCameraParameters::KEY_SUPPORTED_SCENE_MODES, 1191 mSceneModeValues); 1192 1193 //Set Streaming Textures 1194 mParameters.set("strtextures", "OFF"); 1195 1196 //Set Denoise 1197 mParameters.set(QCameraParameters::KEY_DENOISE, 1198 QCameraParameters::DENOISE_ON); 1199 mParameters.set(QCameraParameters::KEY_SUPPORTED_DENOISE, 1200 denoise_value); 1201 //Set Touch AF/AEC 1202 mParameters.set(QCameraParameters::KEY_TOUCH_AF_AEC, 1203 QCameraParameters::TOUCH_AF_AEC_OFF); 1204 mParameters.set(QCameraParameters::KEY_SUPPORTED_TOUCH_AF_AEC, 1205 mTouchAfAecValues); 1206 /* touch-AF ROI for reducing af fail case */ 1207 mParameters.set("touchAfAec-dx","200"); 1208 mParameters.set("touchAfAec-dy","200"); 1209 1210 //Set Scene Detection 1211 mParameters.set(QCameraParameters::KEY_SCENE_DETECT, 1212 QCameraParameters::SCENE_DETECT_OFF); 1213 mParameters.set(QCameraParameters::KEY_SUPPORTED_SCENE_DETECT, 1214 mSceneDetectValues); 1215 1216 //Set Selectable Zone AF 1217 mParameters.set(QCameraParameters::KEY_SELECTABLE_ZONE_AF, 1218 QCameraParameters::SELECTABLE_ZONE_AF_AUTO); 1219 mParameters.set(QCameraParameters::KEY_SUPPORTED_SELECTABLE_ZONE_AF, 1220 mSelectableZoneAfValues); 1221 1222 //Set Face Detection 1223 if(supportsFaceDetection()){ 1224 mParameters.set(QCameraParameters::KEY_FACE_DETECTION, 1225 QCameraParameters::FACE_DETECTION_OFF); 1226 mParameters.set(QCameraParameters::KEY_SUPPORTED_FACE_DETECTION, 1227 mFaceDetectionValues); 1228 } 1229 1230 //Set Red Eye Reduction 1231 mParameters.set(QCameraParameters::KEY_REDEYE_REDUCTION, 1232 QCameraParameters::REDEYE_REDUCTION_DISABLE); 1233 mParameters.set(QCameraParameters::KEY_SUPPORTED_REDEYE_REDUCTION, 1234 mRedeyeReductionValues); 1235 1236 //Set ZSL 1237 mParameters.set(QCameraParameters::KEY_ZSL, 1238 QCameraParameters::ZSL_OFF); 1239 mParameters.set(QCameraParameters::KEY_SUPPORTED_ZSL_MODES, 1240 mZslValues); 1241 1242 //Set Focal length, horizontal and vertical view angles 1243 focus_distances_info_t focalLength; 1244 float horizontalViewAngle = 0.0f; 1245 float verticalViewAngle = 0.0f; 1246 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_FOCAL_LENGTH, 1247 (void *)&focalLength); 1248 mParameters.setFloat(QCameraParameters::KEY_FOCAL_LENGTH, 1249 focalLength.focus_distance[0]); 1250 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE, 1251 (void *)&horizontalViewAngle); 1252 mParameters.setFloat(QCameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, 1253 horizontalViewAngle); 1254 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE, 1255 (void *)&verticalViewAngle); 1256 mParameters.setFloat(QCameraParameters::KEY_VERTICAL_VIEW_ANGLE, 1257 verticalViewAngle); 1258 1259 //Set Aperture 1260 float f_number = 0.0f; 1261 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_F_NUMBER, 1262 (void *)&f_number); 1263 mExifValues.f_number = getRational(f_number*F_NUMBER_DECIMAL_PRECISION, F_NUMBER_DECIMAL_PRECISION); 1264 1265 //Set Exposure Compensation 1266 mParameters.set( 1267 QCameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 1268 EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR); 1269 mParameters.set( 1270 QCameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 1271 EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR); 1272 mParameters.set( 1273 QCameraParameters::KEY_EXPOSURE_COMPENSATION, 1274 EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR); 1275 mParameters.setFloat( 1276 QCameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 1277 EXPOSURE_COMPENSATION_STEP); 1278 1279 mParameters.set("num-snaps-per-shutter", 1); 1280 1281 mParameters.set("capture-burst-captures-values", getZSLQueueDepth()); 1282 mParameters.set("capture-burst-interval-supported", "true"); 1283 mParameters.set("capture-burst-interval-max", BURST_INTREVAL_MAX); /*skip frames*/ 1284 mParameters.set("capture-burst-interval-min", BURST_INTREVAL_MIN); /*skip frames*/ 1285 mParameters.set("capture-burst-interval", BURST_INTREVAL_DEFAULT); /*skip frames*/ 1286 mParameters.set("capture-burst-retroactive", 0); 1287 mParameters.set("capture-burst-retroactive-max", getZSLQueueDepth()); 1288 mParameters.set("capture-burst-exposures", ""); 1289 mParameters.set("capture-burst-exposures-values", 1290 "-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"); 1291 { 1292 String8 CamModeStr; 1293 char buffer[32]; 1294 int flag = 0; 1295 1296 for (int i = 0; i < HAL_CAM_MODE_MAX; i++) { 1297 if ( 0 ) { /*exclude some conflicting case*/ 1298 } else { 1299 if (flag == 0) { /*first item*/ 1300 snprintf(buffer, sizeof(buffer), "%d", i); 1301 } else { 1302 snprintf(buffer, sizeof(buffer), ",%d", i); 1303 } 1304 flag = 1; 1305 CamModeStr.append(buffer); 1306 } 1307 } 1308 mParameters.set("camera-mode-values", CamModeStr); 1309 } 1310 1311 mParameters.set("ae-bracket-hdr-values", 1312 create_values_str(hdr_bracket, sizeof(hdr_bracket)/sizeof(str_map) )); 1313 1314 // if(mIs3DModeOn) 1315 // mParameters.set("3d-frame-format", "left-right"); 1316 mParameters.set("no-display-mode", 0); 1317 //mUseOverlay = useOverlay(); 1318 mParameters.set("zoom", 0); 1319 1320 int mNuberOfVFEOutputs; 1321 ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, &mNuberOfVFEOutputs); 1322 if(ret != MM_CAMERA_OK) { 1323 ALOGE("get parm MM_CAMERA_PARM_VFE_OUTPUT_ENABLE failed"); 1324 ret = BAD_VALUE; 1325 } 1326 if(mNuberOfVFEOutputs == 1) 1327 { 1328 mParameters.set(QCameraParameters::KEY_SINGLE_ISP_OUTPUT_ENABLED, "true"); 1329 } else { 1330 mParameters.set(QCameraParameters::KEY_SINGLE_ISP_OUTPUT_ENABLED, "false"); 1331 } 1332 1333 if (setParameters(mParameters) != NO_ERROR) { 1334 ALOGE("Failed to set default parameters?!"); 1335 } 1336 1337 mNoDisplayMode = 0; 1338 mLedStatusForZsl = LED_MODE_OFF; 1339 1340 mInitialized = true; 1341 strTexturesOn = false; 1342 1343 ALOGV("%s: X", __func__); 1344 return; 1345 } 1346 1347 /** 1348 * Set the camera parameters. This returns BAD_VALUE if any parameter is 1349 * invalid or not supported. 1350 */ 1351 1352 int QCameraHardwareInterface::setParameters(const char *parms) 1353 { 1354 QCameraParameters param; 1355 String8 str = String8(parms); 1356 param.unflatten(str); 1357 status_t ret = setParameters(param); 1358 if(ret == NO_ERROR) 1359 return 0; 1360 else 1361 return -1; 1362 } 1363 1364 /** 1365 * Set the camera parameters. This returns BAD_VALUE if any parameter is 1366 * invalid or not supported. */ 1367 status_t QCameraHardwareInterface::setParameters(const QCameraParameters& params) 1368 { 1369 status_t ret = NO_ERROR; 1370 1371 ALOGV("%s: E", __func__); 1372 // Mutex::Autolock l(&mLock); 1373 status_t rc, final_rc = NO_ERROR; 1374 1375 if ((rc = setPowerMode(params))) final_rc = rc; 1376 if ((rc = setPreviewSize(params))) final_rc = rc; 1377 if ((rc = setVideoSize(params))) final_rc = rc; 1378 if ((rc = setPictureSize(params))) final_rc = rc; 1379 if ((rc = setJpegThumbnailSize(params))) final_rc = rc; 1380 if ((rc = setJpegQuality(params))) final_rc = rc; 1381 if ((rc = setEffect(params))) final_rc = rc; 1382 if ((rc = setGpsLocation(params))) final_rc = rc; 1383 if ((rc = setRotation(params))) final_rc = rc; 1384 if ((rc = setZoom(params))) final_rc = rc; 1385 if ((rc = setOrientation(params))) final_rc = rc; 1386 if ((rc = setLensshadeValue(params))) final_rc = rc; 1387 if ((rc = setMCEValue(params))) final_rc = rc; 1388 if ((rc = setPictureFormat(params))) final_rc = rc; 1389 if ((rc = setSharpness(params))) final_rc = rc; 1390 if ((rc = setSaturation(params))) final_rc = rc; 1391 if ((rc = setSceneMode(params))) final_rc = rc; 1392 if ((rc = setContrast(params))) final_rc = rc; 1393 // if ((rc = setFaceDetect(params))) final_rc = rc; 1394 if ((rc = setStrTextures(params))) final_rc = rc; 1395 if ((rc = setPreviewFormat(params))) final_rc = rc; 1396 if ((rc = setSkinToneEnhancement(params))) final_rc = rc; 1397 if ((rc = setWaveletDenoise(params))) final_rc = rc; 1398 if ((rc = setAntibanding(params))) final_rc = rc; 1399 // if ((rc = setOverlayFormats(params))) final_rc = rc; 1400 if ((rc = setRedeyeReduction(params))) final_rc = rc; 1401 if ((rc = setCaptureBurstExp())) final_rc = rc; 1402 1403 const char *str_val = params.get("capture-burst-exposures"); 1404 if ( str_val == NULL || strlen(str_val)==0 ) { 1405 char burst_exp[PROPERTY_VALUE_MAX]; 1406 memset(burst_exp, 0, sizeof(burst_exp)); 1407 property_get("persist.capture.burst.exposures", burst_exp, ""); 1408 if ( strlen(burst_exp)>0 ) { 1409 mParameters.set("capture-burst-exposures", burst_exp); 1410 } 1411 } else { 1412 mParameters.set("capture-burst-exposures", str_val); 1413 } 1414 mParameters.set("num-snaps-per-shutter", params.get("num-snaps-per-shutter")); 1415 1416 if ((rc = setAEBracket(params))) final_rc = rc; 1417 // if ((rc = setDenoise(params))) final_rc = rc; 1418 if ((rc = setPreviewFpsRange(params))) final_rc = rc; 1419 if((rc = setRecordingHint(params))) final_rc = rc; 1420 if ((rc = setNumOfSnapshot(params))) final_rc = rc; 1421 if ((rc = setAecAwbLock(params))) final_rc = rc; 1422 if ((rc = setWhiteBalance(params))) final_rc = rc; 1423 const char *str = params.get(QCameraParameters::KEY_SCENE_MODE); 1424 int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str); 1425 1426 if((value != NOT_FOUND) && (value == CAMERA_BESTSHOT_OFF )) { 1427 //if ((rc = setPreviewFrameRateMode(params))) final_rc = rc; 1428 if ((rc = setPreviewFrameRate(params))) final_rc = rc; 1429 if ((rc = setBrightness(params))) final_rc = rc; 1430 if ((rc = setISOValue(params))) final_rc = rc; 1431 if ((rc = setFocusAreas(params))) final_rc = rc; 1432 if ((rc = setMeteringAreas(params))) final_rc = rc; 1433 } 1434 if ((rc = setFocusMode(params))) final_rc = rc; 1435 if ((rc = setAutoExposure(params))) final_rc = rc; 1436 if ((rc = setExposureCompensation(params))) final_rc = rc; 1437 if ((rc = setFlash(params))) final_rc = rc; 1438 //selectableZoneAF needs to be invoked after continuous AF 1439 if ((rc = setSelectableZoneAf(params))) final_rc = rc; 1440 // setHighFrameRate needs to be done at end, as there can 1441 // be a preview restart, and need to use the updated parameters 1442 if ((rc = setHighFrameRate(params))) final_rc = rc; 1443 if ((rc = setZSLBurstLookBack(params))) final_rc = rc; 1444 if ((rc = setZSLBurstInterval(params))) final_rc = rc; 1445 if ((rc = setNoDisplayMode(params))) final_rc = rc; 1446 1447 //Update Exiftag values. 1448 setExifTags(); 1449 1450 ALOGV("%s: X", __func__); 1451 return final_rc; 1452 } 1453 1454 /** Retrieve the camera parameters. The buffer returned by the camera HAL 1455 must be returned back to it with put_parameters, if put_parameters 1456 is not NULL. 1457 */ 1458 int QCameraHardwareInterface::getParameters(char **parms) 1459 { 1460 char* rc = NULL; 1461 String8 str; 1462 QCameraParameters param = getParameters(); 1463 //param.dump(); 1464 str = param.flatten( ); 1465 rc = (char *)malloc(sizeof(char)*(str.length()+1)); 1466 if(rc != NULL){ 1467 memset(rc, 0, sizeof(char)*(str.length()+1)); 1468 strncpy(rc, str.string(), str.length()); 1469 rc[str.length()] = 0; 1470 *parms = rc; 1471 } 1472 return 0; 1473 } 1474 1475 /** The camera HAL uses its own memory to pass us the parameters when we 1476 call get_parameters. Use this function to return the memory back to 1477 the camera HAL, if put_parameters is not NULL. If put_parameters 1478 is NULL, then you have to use free() to release the memory. 1479 */ 1480 void QCameraHardwareInterface::putParameters(char *rc) 1481 { 1482 free(rc); 1483 rc = NULL; 1484 } 1485 1486 QCameraParameters& QCameraHardwareInterface::getParameters() 1487 { 1488 Mutex::Autolock lock(mLock); 1489 mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string()); 1490 const char *str = mParameters.get(QCameraParameters::KEY_SCENE_MODE); 1491 if (mHasAutoFocusSupport && strcmp(str, "auto")) { 1492 mParameters.set(QCameraParameters::KEY_FOCUS_MODE, 1493 QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE); 1494 } 1495 return mParameters; 1496 } 1497 1498 status_t QCameraHardwareInterface::runFaceDetection() 1499 { 1500 bool ret = true; 1501 1502 const char *str = mParameters.get(QCameraParameters::KEY_FACE_DETECTION); 1503 if (str != NULL) { 1504 int value = attr_lookup(facedetection, 1505 sizeof(facedetection) / sizeof(str_map), str); 1506 fd_set_parm_t fd_set_parm; 1507 int requested_faces = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES); 1508 fd_set_parm.fd_mode = value; 1509 fd_set_parm.num_fd = requested_faces; 1510 ret = native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm); 1511 return ret ? NO_ERROR : UNKNOWN_ERROR; 1512 } 1513 ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str); 1514 return BAD_VALUE; 1515 } 1516 1517 status_t QCameraHardwareInterface::setSharpness(const QCameraParameters& params) 1518 { 1519 bool ret = false; 1520 int rc = MM_CAMERA_OK; 1521 ALOGV("%s",__func__); 1522 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_SHARPNESS); 1523 if(!rc) { 1524 ALOGV("%s:CONTRAST not supported", __func__); 1525 return NO_ERROR; 1526 } 1527 int sharpness = params.getInt(QCameraParameters::KEY_SHARPNESS); 1528 if((sharpness < CAMERA_MIN_SHARPNESS 1529 || sharpness > CAMERA_MAX_SHARPNESS)) 1530 return UNKNOWN_ERROR; 1531 1532 ALOGV("setting sharpness %d", sharpness); 1533 mParameters.set(QCameraParameters::KEY_SHARPNESS, sharpness); 1534 ret = native_set_parms(MM_CAMERA_PARM_SHARPNESS, sizeof(sharpness), 1535 (void *)&sharpness); 1536 return ret ? NO_ERROR : UNKNOWN_ERROR; 1537 } 1538 1539 status_t QCameraHardwareInterface::setSaturation(const QCameraParameters& params) 1540 { 1541 bool ret = false; 1542 int rc = MM_CAMERA_OK; 1543 ALOGV("%s",__func__); 1544 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_SATURATION); 1545 if(!rc) { 1546 ALOGV("%s:MM_CAMERA_PARM_SATURATION not supported", __func__); 1547 return NO_ERROR; 1548 } 1549 int result; 1550 int saturation = params.getInt(QCameraParameters::KEY_SATURATION); 1551 1552 if((saturation < CAMERA_MIN_SATURATION) 1553 || (saturation > CAMERA_MAX_SATURATION)) 1554 return UNKNOWN_ERROR; 1555 1556 ALOGV("Setting saturation %d", saturation); 1557 mParameters.set(QCameraParameters::KEY_SATURATION, saturation); 1558 ret = native_set_parms(MM_CAMERA_PARM_SATURATION, sizeof(saturation), 1559 (void *)&saturation, (int *)&result); 1560 if(result != MM_CAMERA_OK) 1561 ALOGV("Saturation Value: %d is not set as the selected value is not supported", saturation); 1562 return ret ? NO_ERROR : UNKNOWN_ERROR; 1563 } 1564 1565 status_t QCameraHardwareInterface::setContrast(const QCameraParameters& params) 1566 { 1567 ALOGV("%s E", __func__ ); 1568 int rc = MM_CAMERA_OK; 1569 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_CONTRAST); 1570 if(!rc) { 1571 ALOGV("%s:CONTRAST not supported", __func__); 1572 return NO_ERROR; 1573 } 1574 const char *str = params.get(QCameraParameters::KEY_SCENE_MODE); 1575 ALOGV("Contrast : %s",str); 1576 int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str); 1577 if(value == CAMERA_BESTSHOT_OFF) { 1578 int contrast = params.getInt(QCameraParameters::KEY_CONTRAST); 1579 if((contrast < CAMERA_MIN_CONTRAST) 1580 || (contrast > CAMERA_MAX_CONTRAST)) 1581 { 1582 ALOGV("Contrast Value not matching"); 1583 return UNKNOWN_ERROR; 1584 } 1585 ALOGV("setting contrast %d", contrast); 1586 mParameters.set(QCameraParameters::KEY_CONTRAST, contrast); 1587 ALOGV("Calling Contrast set on Lower layer"); 1588 bool ret = native_set_parms(MM_CAMERA_PARM_CONTRAST, sizeof(contrast), 1589 (void *)&contrast); 1590 ALOGV("Lower layer returned %d", ret); 1591 int bestshot_reconfigure; 1592 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_BESTSHOT_RECONFIGURE, 1593 &bestshot_reconfigure); 1594 if(bestshot_reconfigure) { 1595 if (mContrast != contrast) { 1596 mContrast = contrast; 1597 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) { 1598 mRestartPreview = 1; 1599 pausePreviewForZSL(); 1600 } 1601 } 1602 } 1603 return ret ? NO_ERROR : UNKNOWN_ERROR; 1604 } else { 1605 ALOGV(" Contrast value will not be set " \ 1606 "when the scenemode selected is %s", str); 1607 return NO_ERROR; 1608 } 1609 return BAD_VALUE; 1610 } 1611 1612 status_t QCameraHardwareInterface::setSceneDetect(const QCameraParameters& params) 1613 { 1614 ALOGV("%s",__func__); 1615 bool retParm; 1616 int rc = MM_CAMERA_OK; 1617 1618 rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_ASD_ENABLE); 1619 if(!rc) { 1620 ALOGV("%s:MM_CAMERA_PARM_ASD_ENABLE not supported", __func__); 1621 return NO_ERROR; 1622 } 1623 1624 const char *str = params.get(QCameraParameters::KEY_SCENE_DETECT); 1625 ALOGV("Scene Detect string : %s",str); 1626 if (str != NULL) { 1627 int32_t value = attr_lookup(scenedetect, sizeof(scenedetect) / sizeof(str_map), str); 1628 ALOGV("Scenedetect Value : %d",value); 1629 if (value != NOT_FOUND) { 1630 mParameters.set(QCameraParameters::KEY_SCENE_DETECT, str); 1631 1632 retParm = native_set_parms(MM_CAMERA_PARM_ASD_ENABLE, sizeof(value), 1633 (void *)&value); 1634 1635 return retParm ? NO_ERROR : UNKNOWN_ERROR; 1636 } 1637 } 1638 return BAD_VALUE; 1639 } 1640 1641 status_t QCameraHardwareInterface::setZoom(const QCameraParameters& params) 1642 { 1643 status_t rc = NO_ERROR; 1644 1645 ALOGV("%s: E",__func__); 1646 1647 1648 if( !( cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_ZOOM))) { 1649 ALOGV("%s:MM_CAMERA_PARM_ZOOM not supported", __func__); 1650 return NO_ERROR; 1651 } 1652 // No matter how many different zoom values the driver can provide, HAL 1653 // provides applictations the same number of zoom levels. The maximum driver 1654 // zoom value depends on sensor output (VFE input) and preview size (VFE 1655 // output) because VFE can only crop and cannot upscale. If the preview size 1656 // is bigger, the maximum zoom ratio is smaller. However, we want the 1657 // zoom ratio of each zoom level is always the same whatever the preview 1658 // size is. Ex: zoom level 1 is always 1.2x, zoom level 2 is 1.44x, etc. So, 1659 // we need to have a fixed maximum zoom value and do read it from the 1660 // driver. 1661 static const int ZOOM_STEP = 1; 1662 int32_t zoom_level = params.getInt("zoom"); 1663 if(zoom_level >= 0 && zoom_level <= mMaxZoom-1) { 1664 mParameters.set("zoom", zoom_level); 1665 int32_t zoom_value = ZOOM_STEP * zoom_level; 1666 bool ret = native_set_parms(MM_CAMERA_PARM_ZOOM, 1667 sizeof(zoom_value), (void *)&zoom_value); 1668 if(ret) { 1669 mCurrentZoom=zoom_level; 1670 } 1671 rc = ret ? NO_ERROR : UNKNOWN_ERROR; 1672 } else { 1673 rc = BAD_VALUE; 1674 } 1675 ALOGV("%s X",__func__); 1676 return rc; 1677 1678 } 1679 1680 status_t QCameraHardwareInterface::setISOValue(const QCameraParameters& params) { 1681 1682 status_t rc = NO_ERROR; 1683 ALOGV("%s",__func__); 1684 1685 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_ISO); 1686 if(!rc) { 1687 ALOGV("%s:MM_CAMERA_PARM_ISO not supported", __func__); 1688 return NO_ERROR; 1689 } 1690 const char *str = params.get(QCameraParameters::KEY_ISO_MODE); 1691 ALOGV("ISO string : %s", str); 1692 int8_t temp_hjr; 1693 if (str != NULL) { 1694 int value = (camera_iso_mode_type)attr_lookup( 1695 iso, sizeof(iso) / sizeof(str_map), str); 1696 ALOGV("ISO string : %s", str); 1697 if (value != NOT_FOUND) { 1698 camera_iso_mode_type temp = (camera_iso_mode_type) value; 1699 if (value == CAMERA_ISO_DEBLUR) { 1700 temp_hjr = true; 1701 native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr); 1702 mHJR = value; 1703 } 1704 else { 1705 if (mHJR == CAMERA_ISO_DEBLUR) { 1706 temp_hjr = false; 1707 native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr); 1708 mHJR = value; 1709 } 1710 } 1711 1712 mParameters.set(QCameraParameters::KEY_ISO_MODE, str); 1713 native_set_parms(MM_CAMERA_PARM_ISO, sizeof(camera_iso_mode_type), (void *)&temp); 1714 mIsoValue = (int)temp; 1715 return NO_ERROR; 1716 } 1717 } 1718 return BAD_VALUE; 1719 } 1720 1721 status_t QCameraHardwareInterface::updateFocusDistances() 1722 { 1723 ALOGV("%s: IN", __FUNCTION__); 1724 focus_distances_info_t focusDistances; 1725 if(cam_config_get_parm(mCameraId, MM_CAMERA_PARM_FOCUS_DISTANCES, 1726 &focusDistances) == MM_CAMERA_OK) { 1727 String8 str; 1728 char buffer[32] = {0}; 1729 //set all distances to infinity if focus mode is infinity 1730 if(mFocusMode == AF_MODE_INFINITY) { 1731 snprintf(buffer, sizeof(buffer), "Infinity,"); 1732 str.append(buffer); 1733 snprintf(buffer, sizeof(buffer), "Infinity,"); 1734 str.append(buffer); 1735 snprintf(buffer, sizeof(buffer), "Infinity"); 1736 str.append(buffer); 1737 } else { 1738 snprintf(buffer, sizeof(buffer), "%f", focusDistances.focus_distance[0]); 1739 str.append(buffer); 1740 snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[1]); 1741 str.append(buffer); 1742 snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[2]); 1743 str.append(buffer); 1744 } 1745 ALOGV("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string()); 1746 mFocusDistance = str; 1747 return NO_ERROR; 1748 } 1749 ALOGE("%s: get CAMERA_PARM_FOCUS_DISTANCES failed!!!", __FUNCTION__); 1750 return BAD_VALUE; 1751 } 1752 1753 // Parse string like "(1, 2, 3, 4, ..., N)" 1754 // num is pointer to an allocated array of size N 1755 static int parseNDimVector(const char *str, int *num, int N, char delim = ',') 1756 { 1757 char *start, *end; 1758 if(num == NULL) { 1759 ALOGE("Invalid output array (num == NULL)"); 1760 return -1; 1761 } 1762 //check if string starts and ends with parantheses 1763 if(str[0] != '(' || str[strlen(str)-1] != ')') { 1764 ALOGE("Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", str); 1765 return -1; 1766 } 1767 start = (char*) str; 1768 start++; 1769 for(int i=0; i<N; i++) { 1770 *(num+i) = (int) strtol(start, &end, 10); 1771 if(*end != delim && i < N-1) { 1772 ALOGE("Cannot find delimeter '%c' in string \"%s\". end = %c", delim, str, *end); 1773 return -1; 1774 } 1775 start = end+1; 1776 } 1777 return 0; 1778 } 1779 1780 // parse string like "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..." 1781 static int parseCameraAreaString(const char* str, int max_num_areas, 1782 camera_area_t *pAreas, int *num_areas_found) 1783 { 1784 char area_str[32]; 1785 const char *start, *end, *p; 1786 start = str; end = NULL; 1787 int values[5], index=0; 1788 *num_areas_found = 0; 1789 1790 while(start != NULL) { 1791 if(*start != '(') { 1792 ALOGE("%s: error: Ill formatted area string: %s", __func__, str); 1793 return -1; 1794 } 1795 end = strchr(start, ')'); 1796 if(end == NULL) { 1797 ALOGE("%s: error: Ill formatted area string: %s", __func__, str); 1798 return -1; 1799 } 1800 int i; 1801 for (i=0,p=start; p<=end; p++, i++) { 1802 area_str[i] = *p; 1803 } 1804 area_str[i] = '\0'; 1805 if(parseNDimVector(area_str, values, 5) < 0){ 1806 ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str); 1807 return -1; 1808 } 1809 // no more areas than max_num_areas are accepted. 1810 if(index >= max_num_areas) { 1811 ALOGE("%s: error: too many areas specified %s", __func__, str); 1812 return -1; 1813 } 1814 pAreas[index].x1 = values[0]; 1815 pAreas[index].y1 = values[1]; 1816 pAreas[index].x2 = values[2]; 1817 pAreas[index].y2 = values[3]; 1818 pAreas[index].weight = values[4]; 1819 1820 index++; 1821 start = strchr(end, '('); // serach for next '(' 1822 } 1823 (*num_areas_found) = index; 1824 return 0; 1825 } 1826 static bool validateCameraAreas(camera_area_t *areas, int num_areas) 1827 { 1828 for(int i=0; i<num_areas; i++) { 1829 1830 // handle special case (0, 0, 0, 0, 0) 1831 if((areas[i].x1 == 0) && (areas[i].y1 == 0) 1832 && (areas[i].x2 == 0) && (areas[i].y2 == 0) && (areas[i].weight == 0)) { 1833 continue; 1834 } 1835 if(areas[i].x1 < -1000) return false; // left should be >= -1000 1836 if(areas[i].y1 < -1000) return false; // top should be >= -1000 1837 if(areas[i].x2 > 1000) return false; // right should be <= 1000 1838 if(areas[i].y2 > 1000) return false; // bottom should be <= 1000 1839 if(areas[i].weight <= 0 || areas[i].weight > 1000) // weight should be in [1, 1000] 1840 return false; 1841 if(areas[i].x1 >= areas[i].x2) { // left should be < right 1842 return false; 1843 } 1844 if(areas[i].y1 >= areas[i].y2) // top should be < bottom 1845 return false; 1846 } 1847 return true; 1848 } 1849 1850 status_t QCameraHardwareInterface::setFocusAreas(const QCameraParameters& params) 1851 { 1852 ALOGV("%s: E", __func__); 1853 status_t rc; 1854 int max_num_af_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS); 1855 if(max_num_af_areas == 0) { 1856 return NO_ERROR; 1857 } 1858 const char *str = params.get(QCameraParameters::KEY_FOCUS_AREAS); 1859 if (str == NULL) { 1860 ALOGE("%s: Parameter string is null", __func__); 1861 rc = NO_ERROR; 1862 } else { 1863 camera_area_t *areas = new camera_area_t[max_num_af_areas]; 1864 int num_areas_found=0; 1865 if(parseCameraAreaString(str, max_num_af_areas, areas, &num_areas_found) < 0) { 1866 ALOGE("%s: Failed to parse the string: %s", __func__, str); 1867 delete areas; 1868 return BAD_VALUE; 1869 } 1870 for(int i=0; i<num_areas_found; i++) { 1871 ALOGV("FocusArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1), 1872 (areas[i].x2), (areas[i].y2), (areas[i].weight)); 1873 } 1874 if(validateCameraAreas(areas, num_areas_found) == false) { 1875 ALOGE("%s: invalid areas specified : %s", __func__, str); 1876 delete areas; 1877 return BAD_VALUE; 1878 } 1879 mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, str); 1880 num_areas_found = 1; //temp; need to change after the multi-roi is enabled 1881 1882 //if the native_set_parms is called when preview is not started, it 1883 //crashes in lower layer, so return of preview is not started 1884 if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) { 1885 delete areas; 1886 return NO_ERROR; 1887 } 1888 1889 //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0, 1890 //so no action is takenby the lower layer 1891 if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0) 1892 && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) { 1893 num_areas_found = 0; 1894 } 1895 #if 1 //temp solution 1896 1897 roi_info_t af_roi_value; 1898 memset(&af_roi_value, 0, sizeof(roi_info_t)); 1899 uint16_t x1, x2, y1, y2, dx, dy; 1900 int previewWidth, previewHeight; 1901 this->getPreviewSize(&previewWidth, &previewHeight); 1902 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) 1903 x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f)); 1904 y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f)); 1905 x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f)); 1906 y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f)); 1907 dx = x2 - x1; 1908 dy = y2 - y1; 1909 1910 af_roi_value.num_roi = num_areas_found; 1911 af_roi_value.roi[0].x = x1; 1912 af_roi_value.roi[0].y = y1; 1913 af_roi_value.roi[0].dx = dx; 1914 af_roi_value.roi[0].dy = dy; 1915 af_roi_value.is_multiwindow = 0; 1916 if (native_set_parms(MM_CAMERA_PARM_AF_ROI, sizeof(roi_info_t), (void*)&af_roi_value)) 1917 rc = NO_ERROR; 1918 else 1919 rc = BAD_VALUE; 1920 delete areas; 1921 #endif 1922 #if 0 //better solution with multi-roi, to be enabled later 1923 af_mtr_area_t afArea; 1924 afArea.num_area = num_areas_found; 1925 1926 uint16_t x1, x2, y1, y2, dx, dy; 1927 int previewWidth, previewHeight; 1928 this->getPreviewSize(&previewWidth, &previewHeight); 1929 1930 for(int i=0; i<num_areas_found; i++) { 1931 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) 1932 x1 = (uint16_t)((areas[i].x1 + 1000.0f)*(previewWidth/2000.0f)); 1933 y1 = (uint16_t)((areas[i].y1 + 1000.0f)*(previewHeight/2000.0f)); 1934 x2 = (uint16_t)((areas[i].x2 + 1000.0f)*(previewWidth/2000.0f)); 1935 y2 = (uint16_t)((areas[i].y2 + 1000.0f)*(previewHeight/2000.0f)); 1936 dx = x2 - x1; 1937 dy = y2 - y1; 1938 afArea.mtr_area[i].x = x1; 1939 afArea.mtr_area[i].y = y1; 1940 afArea.mtr_area[i].dx = dx; 1941 afArea.mtr_area[i].dy = dy; 1942 afArea.weight[i] = areas[i].weight; 1943 } 1944 1945 if(native_set_parms(MM_CAMERA_PARM_AF_MTR_AREA, sizeof(af_mtr_area_t), (void*)&afArea)) 1946 rc = NO_ERROR; 1947 else 1948 rc = BAD_VALUE;*/ 1949 #endif 1950 } 1951 ALOGV("%s: X", __func__); 1952 return rc; 1953 } 1954 1955 status_t QCameraHardwareInterface::setMeteringAreas(const QCameraParameters& params) 1956 { 1957 ALOGV("%s: E", __func__); 1958 status_t rc; 1959 int max_num_mtr_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_METERING_AREAS); 1960 if(max_num_mtr_areas == 0) { 1961 return NO_ERROR; 1962 } 1963 1964 const char *str = params.get(QCameraParameters::KEY_METERING_AREAS); 1965 if (str == NULL) { 1966 ALOGE("%s: Parameter string is null", __func__); 1967 rc = NO_ERROR; 1968 } else { 1969 camera_area_t *areas = new camera_area_t[max_num_mtr_areas]; 1970 int num_areas_found=0; 1971 if(parseCameraAreaString(str, max_num_mtr_areas, areas, &num_areas_found) < 0) { 1972 ALOGE("%s: Failed to parse the string: %s", __func__, str); 1973 delete areas; 1974 return BAD_VALUE; 1975 } 1976 for(int i=0; i<num_areas_found; i++) { 1977 ALOGV("MeteringArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1), 1978 (areas[i].x2), (areas[i].y2), (areas[i].weight)); 1979 } 1980 if(validateCameraAreas(areas, num_areas_found) == false) { 1981 ALOGE("%s: invalid areas specified : %s", __func__, str); 1982 delete areas; 1983 return BAD_VALUE; 1984 } 1985 mParameters.set(QCameraParameters::KEY_METERING_AREAS, str); 1986 1987 //if the native_set_parms is called when preview is not started, it 1988 //crashes in lower layer, so return of preview is not started 1989 if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) { 1990 delete areas; 1991 return NO_ERROR; 1992 } 1993 1994 num_areas_found = 1; //temp; need to change after the multi-roi is enabled 1995 1996 //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0, 1997 //so no action is takenby the lower layer 1998 if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0) 1999 && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) { 2000 num_areas_found = 0; 2001 } 2002 #if 1 2003 cam_set_aec_roi_t aec_roi_value; 2004 uint16_t x1, x2, y1, y2; 2005 int previewWidth, previewHeight; 2006 this->getPreviewSize(&previewWidth, &previewHeight); 2007 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) 2008 x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f)); 2009 y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f)); 2010 x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f)); 2011 y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f)); 2012 delete areas; 2013 2014 if(num_areas_found == 1) { 2015 aec_roi_value.aec_roi_enable = AEC_ROI_ON; 2016 aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE; 2017 aec_roi_value.aec_roi_position.coordinate.x = (x1+x2)/2; 2018 aec_roi_value.aec_roi_position.coordinate.y = (y1+y2)/2; 2019 } else { 2020 aec_roi_value.aec_roi_enable = AEC_ROI_OFF; 2021 aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE; 2022 aec_roi_value.aec_roi_position.coordinate.x = DONT_CARE_COORDINATE; 2023 aec_roi_value.aec_roi_position.coordinate.y = DONT_CARE_COORDINATE; 2024 } 2025 2026 if(native_set_parms(MM_CAMERA_PARM_AEC_ROI, sizeof(cam_set_aec_roi_t), (void *)&aec_roi_value)) 2027 rc = NO_ERROR; 2028 else 2029 rc = BAD_VALUE; 2030 #endif 2031 #if 0 //solution including multi-roi, to be enabled later 2032 aec_mtr_area_t aecArea; 2033 aecArea.num_area = num_areas_found; 2034 2035 uint16_t x1, x2, y1, y2, dx, dy; 2036 int previewWidth, previewHeight; 2037 this->getPreviewSize(&previewWidth, &previewHeight); 2038 2039 for(int i=0; i<num_areas_found; i++) { 2040 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) 2041 x1 = (uint16_t)((areas[i].x1 + 1000.0f)*(previewWidth/2000.0f)); 2042 y1 = (uint16_t)((areas[i].y1 + 1000.0f)*(previewHeight/2000.0f)); 2043 x2 = (uint16_t)((areas[i].x2 + 1000.0f)*(previewWidth/2000.0f)); 2044 y2 = (uint16_t)((areas[i].y2 + 1000.0f)*(previewHeight/2000.0f)); 2045 dx = x2 - x1; 2046 dy = y2 - y1; 2047 aecArea.mtr_area[i].x = x1; 2048 aecArea.mtr_area[i].y = y1; 2049 aecArea.mtr_area[i].dx = dx; 2050 aecArea.mtr_area[i].dy = dy; 2051 aecArea.weight[i] = areas[i].weight; 2052 } 2053 delete areas; 2054 2055 if(native_set_parms(MM_CAMERA_PARM_AEC_MTR_AREA, sizeof(aec_mtr_area_t), (void*)&aecArea)) 2056 rc = NO_ERROR; 2057 else 2058 rc = BAD_VALUE; 2059 #endif 2060 } 2061 ALOGV("%s: X", __func__); 2062 return rc; 2063 } 2064 2065 status_t QCameraHardwareInterface::setFocusMode(const QCameraParameters& params) 2066 { 2067 const char *str = params.get(QCameraParameters::KEY_FOCUS_MODE); 2068 const char *prev_str = mParameters.get(QCameraParameters::KEY_FOCUS_MODE); 2069 bool modesAreSame = strcmp(str, prev_str) == 0; 2070 ALOGV("%s",__func__); 2071 if (str != NULL) { 2072 ALOGV("Focus mode '%s', previous focus mode '%s' (cmp %d)",str, prev_str, strcmp(str, prev_str)); 2073 2074 int32_t value; 2075 2076 if (mHasAutoFocusSupport){ 2077 value = attr_lookup(focus_modes_auto, 2078 sizeof(focus_modes_auto) / sizeof(str_map), str); 2079 } else { 2080 value = attr_lookup(focus_modes_fixed, 2081 sizeof(focus_modes_fixed) / sizeof(str_map), str); 2082 } 2083 2084 if (value != NOT_FOUND) { 2085 mParameters.set(QCameraParameters::KEY_FOCUS_MODE, str); 2086 mFocusMode = value; 2087 2088 if(updateFocusDistances() != NO_ERROR) { 2089 ALOGE("%s: updateFocusDistances failed for %s", __FUNCTION__, str); 2090 return UNKNOWN_ERROR; 2091 } 2092 mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string()); 2093 2094 // Do not set the AF state to 'not running'; 2095 // this prevents a bug where an autoFocus followed by a setParameters 2096 // with the same exact focus mode resulting in dropping the autoFocusEvent 2097 if(modesAreSame) { 2098 ALOGV("AF mode unchanged (still '%s'); don't touch CAF", str); 2099 return NO_ERROR; 2100 } else { 2101 ALOGV("AF made has changed to '%s'", str); 2102 } 2103 2104 if(mHasAutoFocusSupport){ 2105 bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_MODE, 2106 sizeof(value), 2107 (void *)&value); 2108 2109 int cafSupport = false; 2110 int caf_type=0; 2111 const char *str_hdr = mParameters.get(QCameraParameters::KEY_SCENE_MODE); 2112 if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) || 2113 !strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)){ 2114 cafSupport = true; 2115 bool rc = false; 2116 if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO)) 2117 { 2118 caf_type = 1; 2119 rc = native_set_parms(MM_CAMERA_PARM_CAF_TYPE, sizeof(caf_type), (void *)&caf_type); 2120 } 2121 else if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)) 2122 { 2123 caf_type = 2; 2124 rc = native_set_parms(MM_CAMERA_PARM_CAF_TYPE, sizeof(caf_type), (void *)&caf_type); 2125 } 2126 ALOGV("caf_type %d rc %d", caf_type, rc); 2127 } 2128 2129 2130 ALOGV("Continuous Auto Focus %d", cafSupport); 2131 if(mAutoFocusRunning && cafSupport){ 2132 ALOGV("Set auto focus running to false"); 2133 mAutoFocusRunning = false; 2134 if(MM_CAMERA_OK!=cam_ops_action(mCameraId,false,MM_CAMERA_OPS_FOCUS,NULL )) { 2135 ALOGE("%s: AF command failed err:%d error %s",__func__, errno,strerror(errno)); 2136 } 2137 } 2138 ret = native_set_parms(MM_CAMERA_PARM_CONTINUOUS_AF, sizeof(cafSupport), 2139 (void *)&cafSupport); 2140 } 2141 2142 return NO_ERROR; 2143 } 2144 ALOGV("%s:Could not look up str value",__func__); 2145 } 2146 ALOGE("Invalid focus mode value: %s", (str == NULL) ? "NULL" : str); 2147 return BAD_VALUE; 2148 } 2149 2150 status_t QCameraHardwareInterface::setSceneMode(const QCameraParameters& params) 2151 { 2152 status_t rc = NO_ERROR; 2153 ALOGV("%s",__func__); 2154 2155 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_BESTSHOT_MODE); 2156 if(!rc) { 2157 ALOGV("%s:Parameter Scenemode is not supported for this sensor", __func__); 2158 return NO_ERROR; 2159 } 2160 const char *str = params.get(QCameraParameters::KEY_SCENE_MODE); 2161 const char *oldstr = mParameters.get(QCameraParameters::KEY_SCENE_MODE); 2162 2163 if (str != NULL && oldstr != NULL) { 2164 int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str); 2165 if (value != NOT_FOUND) { 2166 /* Check to see if there was a change of scene mode */ 2167 if(strcmp(str,oldstr)) { 2168 ALOGV("%s: valued changed from %s to %s",__func__,oldstr, str); 2169 2170 /* Check if we are either transitioning to/from HDR state 2171 if yes preview needs restart*/ 2172 if(!strcmp(str, "hdr") || !strcmp(oldstr, "hdr") ) { 2173 ALOGV("Changed between HDR/non-HDR states"); 2174 2175 /* Restart only if preview already running*/ 2176 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED) { 2177 ALOGV("Preview in progress,restarting for HDR transition"); 2178 mParameters.set(QCameraParameters::KEY_SCENE_MODE, str); 2179 mRestartPreview = 1; 2180 pausePreviewForZSL(); 2181 } 2182 } 2183 } 2184 2185 mParameters.set(QCameraParameters::KEY_SCENE_MODE, str); 2186 bool ret = native_set_parms(MM_CAMERA_PARM_BESTSHOT_MODE, sizeof(value), 2187 (void *)&value); 2188 int bestshot_reconfigure; 2189 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_BESTSHOT_RECONFIGURE, 2190 &bestshot_reconfigure); 2191 if(bestshot_reconfigure) { 2192 if (mBestShotMode != value) { 2193 mBestShotMode = value; 2194 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) { 2195 ALOGV("%s:Bestshot trigerring restart",__func__); 2196 mRestartPreview = 1; 2197 pausePreviewForZSL(); 2198 } 2199 } 2200 } 2201 return ret ? NO_ERROR : UNKNOWN_ERROR; 2202 } 2203 } 2204 ALOGE("Invalid scenemode value: %s", (str == NULL) ? "NULL" : str); 2205 return BAD_VALUE; 2206 } 2207 2208 status_t QCameraHardwareInterface::setSelectableZoneAf(const QCameraParameters& params) 2209 { 2210 ALOGV("%s",__func__); 2211 status_t rc = NO_ERROR; 2212 if(mHasAutoFocusSupport) { 2213 const char *str = params.get(QCameraParameters::KEY_SELECTABLE_ZONE_AF); 2214 if (str != NULL) { 2215 int32_t value = attr_lookup(selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map), str); 2216 if (value != NOT_FOUND) { 2217 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FOCUS_RECT); 2218 if(!rc) { 2219 ALOGV("SelectableZoneAF is not supported for this sensor"); 2220 return NO_ERROR; 2221 }else { 2222 mParameters.set(QCameraParameters::KEY_SELECTABLE_ZONE_AF, str); 2223 bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_RECT, sizeof(value), 2224 (void *)&value); 2225 return ret ? NO_ERROR : UNKNOWN_ERROR; 2226 } 2227 } 2228 } 2229 ALOGE("Invalid selectable zone af value: %s", (str == NULL) ? "NULL" : str); 2230 return BAD_VALUE; 2231 2232 } 2233 return NO_ERROR; 2234 } 2235 2236 status_t QCameraHardwareInterface::setEffect(const QCameraParameters& params) 2237 { 2238 ALOGV("%s",__func__); 2239 status_t rc = NO_ERROR; 2240 const char *str = params.get(QCameraParameters::KEY_EFFECT); 2241 int result; 2242 if (str != NULL) { 2243 ALOGV("Setting effect %s",str); 2244 int32_t value = attr_lookup(effects, sizeof(effects) / sizeof(str_map), str); 2245 if (value != NOT_FOUND) { 2246 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_EFFECT); 2247 if(!rc) { 2248 ALOGV("Camera Effect - %s mode is not supported for this sensor",str); 2249 return NO_ERROR; 2250 }else { 2251 mParameters.set(QCameraParameters::KEY_EFFECT, str); 2252 bool ret = native_set_parms(MM_CAMERA_PARM_EFFECT, sizeof(value), 2253 (void *)&value,(int *)&result); 2254 if(result != MM_CAMERA_OK) { 2255 ALOGE("Camera Effect: %s is not set as the selected value is not supported ", str); 2256 } 2257 int bestshot_reconfigure; 2258 cam_config_get_parm(mCameraId, MM_CAMERA_PARM_BESTSHOT_RECONFIGURE, 2259 &bestshot_reconfigure); 2260 if(bestshot_reconfigure) { 2261 if (mEffects != value) { 2262 mEffects = value; 2263 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) { 2264 mRestartPreview = 1; 2265 pausePreviewForZSL(); 2266 } 2267 } 2268 } 2269 return ret ? NO_ERROR : UNKNOWN_ERROR; 2270 } 2271 } 2272 } 2273 ALOGE("Invalid effect value: %s", (str == NULL) ? "NULL" : str); 2274 ALOGV("setEffect X"); 2275 return BAD_VALUE; 2276 } 2277 2278 status_t QCameraHardwareInterface::setBrightness(const QCameraParameters& params) { 2279 2280 ALOGV("%s",__func__); 2281 status_t rc = NO_ERROR; 2282 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_BRIGHTNESS); 2283 if(!rc) { 2284 ALOGV("MM_CAMERA_PARM_BRIGHTNESS mode is not supported for this sensor"); 2285 return NO_ERROR; 2286 } 2287 int brightness = params.getInt("luma-adaptation"); 2288 if (mBrightness != brightness) { 2289 ALOGV(" new brightness value : %d ", brightness); 2290 mBrightness = brightness; 2291 mParameters.set("luma-adaptation", brightness); 2292 bool ret = native_set_parms(MM_CAMERA_PARM_BRIGHTNESS, sizeof(mBrightness), 2293 (void *)&mBrightness); 2294 return ret ? NO_ERROR : UNKNOWN_ERROR; 2295 } 2296 2297 return NO_ERROR; 2298 } 2299 2300 status_t QCameraHardwareInterface::setAutoExposure(const QCameraParameters& params) 2301 { 2302 2303 ALOGV("%s",__func__); 2304 status_t rc = NO_ERROR; 2305 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_EXPOSURE); 2306 if(!rc) { 2307 ALOGV("MM_CAMERA_PARM_EXPOSURE mode is not supported for this sensor"); 2308 return NO_ERROR; 2309 } 2310 const char *str = params.get(QCameraParameters::KEY_AUTO_EXPOSURE); 2311 if (str != NULL) { 2312 int32_t value = attr_lookup(autoexposure, sizeof(autoexposure) / sizeof(str_map), str); 2313 if (value != NOT_FOUND) { 2314 mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE, str); 2315 bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE, sizeof(value), 2316 (void *)&value); 2317 return ret ? NO_ERROR : UNKNOWN_ERROR; 2318 } 2319 } 2320 ALOGE("Invalid auto exposure value: %s", (str == NULL) ? "NULL" : str); 2321 return BAD_VALUE; 2322 } 2323 2324 status_t QCameraHardwareInterface::setExposureCompensation( 2325 const QCameraParameters & params){ 2326 ALOGV("%s",__func__); 2327 status_t rc = NO_ERROR; 2328 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_EXPOSURE_COMPENSATION); 2329 if(!rc) { 2330 ALOGV("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor"); 2331 return NO_ERROR; 2332 } 2333 int numerator = params.getInt(QCameraParameters::KEY_EXPOSURE_COMPENSATION); 2334 if(EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR <= numerator && 2335 numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){ 2336 int16_t numerator16 = (int16_t)(numerator & 0x0000ffff); 2337 uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR; 2338 uint32_t value = 0; 2339 value = numerator16 << 16 | denominator16; 2340 2341 const char *sce_str = params.get(QCameraParameters::KEY_SCENE_MODE); 2342 if (sce_str != NULL) { 2343 if(!strcmp(sce_str, "sunset")){ 2344 //Exposure comp value in sunset scene mode 2345 mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION, 2346 -6); 2347 }else{ 2348 //Exposure comp value for other 2349 mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION, 2350 numerator); 2351 } 2352 }else { 2353 mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION, 2354 numerator); 2355 } 2356 bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE_COMPENSATION, 2357 sizeof(value), (void *)&value); 2358 return ret ? NO_ERROR : UNKNOWN_ERROR; 2359 } 2360 ALOGE("Invalid Exposure Compensation"); 2361 return BAD_VALUE; 2362 } 2363 2364 status_t QCameraHardwareInterface::setWhiteBalance(const QCameraParameters& params) 2365 { 2366 2367 ALOGV("%s",__func__); 2368 status_t rc = NO_ERROR; 2369 int result; 2370 const char *str = NULL; 2371 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_WHITE_BALANCE); 2372 if(!rc) { 2373 ALOGV("MM_CAMERA_PARM_WHITE_BALANCE mode is not supported for this sensor"); 2374 return NO_ERROR; 2375 } 2376 2377 const char *sce_str = params.get(QCameraParameters::KEY_SCENE_MODE); 2378 if (sce_str != NULL) { 2379 if(!strcmp(sce_str, "sunset")){ 2380 //AWB value in sunset scene mode 2381 str = QCameraParameters::WHITE_BALANCE_DAYLIGHT; 2382 mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str); 2383 }else if(!strcmp(sce_str, "auto")){ 2384 str = params.get(QCameraParameters::KEY_WHITE_BALANCE); 2385 }else{ 2386 //AWB in other scene Mode 2387 str = QCameraParameters::WHITE_BALANCE_AUTO; 2388 mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str); 2389 } 2390 }else { 2391 str = params.get(QCameraParameters::KEY_WHITE_BALANCE); 2392 } 2393 2394 if (str != NULL) { 2395 int32_t value = attr_lookup(whitebalance, sizeof(whitebalance) / sizeof(str_map), str); 2396 if (value != NOT_FOUND) { 2397 mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str); 2398 bool ret = native_set_parms(MM_CAMERA_PARM_WHITE_BALANCE, sizeof(value), 2399 (void *)&value, (int *)&result); 2400 if(result != MM_CAMERA_OK) { 2401 ALOGE("WhiteBalance Value: %s is not set as the selected value is not supported ", str); 2402 } 2403 return ret ? NO_ERROR : UNKNOWN_ERROR; 2404 } 2405 } 2406 ALOGE("Invalid whitebalance value: %s", (str == NULL) ? "NULL" : str); 2407 return BAD_VALUE; 2408 } 2409 2410 status_t QCameraHardwareInterface::setAntibanding(const QCameraParameters& params) 2411 { 2412 int result; 2413 2414 ALOGV("%s",__func__); 2415 status_t rc = NO_ERROR; 2416 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_ANTIBANDING); 2417 if(!rc) { 2418 ALOGV("ANTIBANDING mode is not supported for this sensor"); 2419 return NO_ERROR; 2420 } 2421 const char *str = params.get(QCameraParameters::KEY_ANTIBANDING); 2422 if (str != NULL) { 2423 int value = (camera_antibanding_type)attr_lookup( 2424 antibanding, sizeof(antibanding) / sizeof(str_map), str); 2425 if (value != NOT_FOUND) { 2426 camera_antibanding_type temp = (camera_antibanding_type) value; 2427 ALOGV("Antibanding Value : %d",value); 2428 mParameters.set(QCameraParameters::KEY_ANTIBANDING, str); 2429 bool ret = native_set_parms(MM_CAMERA_PARM_ANTIBANDING, 2430 sizeof(camera_antibanding_type), (void *)&value ,(int *)&result); 2431 if(result != MM_CAMERA_OK) { 2432 ALOGE("AntiBanding Value: %s is not supported for the given BestShot Mode", str); 2433 } 2434 return ret ? NO_ERROR : UNKNOWN_ERROR; 2435 } 2436 } 2437 ALOGE("Invalid antibanding value: %s", (str == NULL) ? "NULL" : str); 2438 2439 return BAD_VALUE; 2440 } 2441 2442 status_t QCameraHardwareInterface::setPreviewFrameRate(const QCameraParameters& params) 2443 { 2444 ALOGV("%s",__func__); 2445 status_t rc = NO_ERROR; 2446 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS); 2447 if(!rc) { 2448 ALOGV("MM_CAMERA_PARM_FPS is not supported for this sensor"); 2449 return NO_ERROR; 2450 } 2451 uint16_t previousFps = (uint16_t)mParameters.getPreviewFrameRate(); 2452 uint16_t fps = (uint16_t)params.getPreviewFrameRate(); 2453 ALOGV("requested preview frame rate is %u", fps); 2454 2455 if(mInitialized && (fps == previousFps)){ 2456 ALOGV("No change is FPS Value %d",fps ); 2457 return NO_ERROR; 2458 } 2459 2460 if(MINIMUM_FPS <= fps && fps <=MAXIMUM_FPS){ 2461 mParameters.setPreviewFrameRate(fps); 2462 bool ret = native_set_parms(MM_CAMERA_PARM_FPS, 2463 sizeof(fps), (void *)&fps); 2464 return ret ? NO_ERROR : UNKNOWN_ERROR; 2465 } 2466 2467 return BAD_VALUE; 2468 } 2469 2470 status_t QCameraHardwareInterface::setPreviewFrameRateMode(const QCameraParameters& params) { 2471 2472 ALOGV("%s",__func__); 2473 status_t rc = NO_ERROR; 2474 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS); 2475 if(!rc) { 2476 ALOGV(" CAMERA FPS mode is not supported for this sensor"); 2477 return NO_ERROR; 2478 } 2479 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_FPS_MODE); 2480 if(!rc) { 2481 ALOGV("CAMERA FPS MODE mode is not supported for this sensor"); 2482 return NO_ERROR; 2483 } 2484 2485 const char *previousMode = mParameters.getPreviewFrameRateMode(); 2486 const char *str = params.getPreviewFrameRateMode(); 2487 if (NULL == previousMode) { 2488 ALOGV("Preview Frame Rate Mode is NULL\n"); 2489 return NO_ERROR; 2490 } 2491 if (NULL == str) { 2492 ALOGV("Preview Frame Rate Mode is NULL\n"); 2493 return NO_ERROR; 2494 } 2495 int32_t frameRateMode = attr_lookup(frame_rate_modes, sizeof(frame_rate_modes) / sizeof(str_map),str); 2496 if(frameRateMode != NOT_FOUND) { 2497 ALOGV("setPreviewFrameRateMode: %s ", str); 2498 mParameters.setPreviewFrameRateMode(str); 2499 bool ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(frameRateMode), (void *)&frameRateMode); 2500 if(!ret) return ret; 2501 //set the fps value when chaging modes 2502 int16_t fps = (uint16_t)params.getPreviewFrameRate(); 2503 if(MINIMUM_FPS <= fps && fps <=MAXIMUM_FPS){ 2504 mParameters.setPreviewFrameRate(fps); 2505 ret = native_set_parms(MM_CAMERA_PARM_FPS, 2506 sizeof(fps), (void *)&fps); 2507 return ret ? NO_ERROR : UNKNOWN_ERROR; 2508 } 2509 ALOGE("Invalid preview frame rate value: %d", fps); 2510 return BAD_VALUE; 2511 } 2512 ALOGE("Invalid preview frame rate mode value: %s", (str == NULL) ? "NULL" : str); 2513 2514 return BAD_VALUE; 2515 } 2516 2517 status_t QCameraHardwareInterface::setSkinToneEnhancement(const QCameraParameters& params) { 2518 ALOGV("%s",__func__); 2519 status_t rc = NO_ERROR; 2520 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_SCE_FACTOR); 2521 if(!rc) { 2522 ALOGV("SkinToneEnhancement is not supported for this sensor"); 2523 return NO_ERROR; 2524 } 2525 int skinToneValue = params.getInt("skinToneEnhancement"); 2526 if (mSkinToneEnhancement != skinToneValue) { 2527 ALOGV(" new skinTone correction value : %d ", skinToneValue); 2528 mSkinToneEnhancement = skinToneValue; 2529 mParameters.set("skinToneEnhancement", skinToneValue); 2530 bool ret = native_set_parms(MM_CAMERA_PARM_SCE_FACTOR, sizeof(mSkinToneEnhancement), 2531 (void *)&mSkinToneEnhancement); 2532 return ret ? NO_ERROR : UNKNOWN_ERROR; 2533 } 2534 return NO_ERROR; 2535 } 2536 2537 status_t QCameraHardwareInterface::setWaveletDenoise(const QCameraParameters& params) { 2538 ALOGV("%s",__func__); 2539 status_t rc = NO_ERROR; 2540 rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_WAVELET_DENOISE); 2541 if(rc != MM_CAMERA_PARM_SUPPORT_SET) { 2542 ALOGV("Wavelet Denoise is not supported for this sensor"); 2543 /* TO DO */ 2544 // return NO_ERROR; 2545 } 2546 const char *str = params.get(QCameraParameters::KEY_DENOISE); 2547 if (str != NULL) { 2548 int value = attr_lookup(denoise, 2549 sizeof(denoise) / sizeof(str_map), str); 2550 if ((value != NOT_FOUND) && (mDenoiseValue != value)) { 2551 mDenoiseValue = value; 2552 mParameters.set(QCameraParameters::KEY_DENOISE, str); 2553 2554 char prop[PROPERTY_VALUE_MAX]; 2555 memset(prop, 0, sizeof(prop)); 2556 property_get("persist.denoise.process.plates", prop, "1"); 2557 2558 denoise_param_t temp; 2559 memset(&temp, 0, sizeof(denoise_param_t)); 2560 temp.denoise_enable = value; 2561 temp.process_plates = atoi(prop); 2562 ALOGV("Denoise enable=%d, plates=%d", temp.denoise_enable, temp.process_plates); 2563 bool ret = native_set_parms(MM_CAMERA_PARM_WAVELET_DENOISE, sizeof(temp), 2564 (void *)&temp); 2565 return ret ? NO_ERROR : UNKNOWN_ERROR; 2566 } 2567 return NO_ERROR; 2568 } 2569 ALOGE("Invalid Denoise value: %s", (str == NULL) ? "NULL" : str); 2570 return BAD_VALUE; 2571 } 2572 2573 status_t QCameraHardwareInterface::setVideoSize(const QCameraParameters& params) 2574 { 2575 const char *str= NULL; 2576 const char *str_t= NULL; 2577 int old_vid_w = 0, old_vid_h = 0; 2578 ALOGV("%s: E", __func__); 2579 str = params.get(QCameraParameters::KEY_VIDEO_SIZE); 2580 str_t = mParameters.get(CameraParameters::KEY_VIDEO_SIZE); 2581 if(!str) { 2582 mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, ""); 2583 //If application didn't set this parameter string, use the values from 2584 //getPreviewSize() as video dimensions. 2585 ALOGV("No Record Size requested, use the preview dimensions"); 2586 mVideoWidth = mPreviewWidth; 2587 mVideoHeight = mPreviewHeight; 2588 } else { 2589 //Extract the record witdh and height that application requested. 2590 ALOGV("%s: requested record size %s", __func__, str); 2591 if(!parse_size(str, mVideoWidth, mVideoHeight)) { 2592 parse_size(str_t, old_vid_w, old_vid_h); 2593 if(old_vid_w != mVideoWidth || old_vid_h != mVideoHeight) { 2594 mRestartPreview = true; 2595 ALOGV("%s: Video sizes changes, Restart preview...", __func__); 2596 } 2597 mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, str); 2598 } else { 2599 mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, ""); 2600 ALOGE("%s: error :failed to parse parameter record-size (%s)", __func__, str); 2601 return BAD_VALUE; 2602 } 2603 } 2604 ALOGV("%s: preview dimensions: %dx%d", __func__, mPreviewWidth, mPreviewHeight); 2605 ALOGV("%s: video dimensions: %dx%d", __func__, mVideoWidth, mVideoHeight); 2606 2607 ALOGV("%s: X", __func__); 2608 return NO_ERROR; 2609 } 2610 2611 status_t QCameraHardwareInterface::setCameraMode(const QCameraParameters& params) { 2612 int32_t value = params.getInt(QCameraParameters::KEY_CAMERA_MODE); 2613 mParameters.set(QCameraParameters::KEY_CAMERA_MODE,value); 2614 2615 ALOGV("ZSL is enabled %d", value); 2616 if (value == 1) { 2617 myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE); 2618 } else { 2619 myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE); 2620 } 2621 2622 return NO_ERROR; 2623 } 2624 2625 status_t QCameraHardwareInterface::setPowerMode(const QCameraParameters& params) { 2626 uint32_t value = NORMAL_POWER; 2627 const char *powermode = NULL; 2628 2629 powermode = params.get(QCameraParameters::KEY_POWER_MODE); 2630 if (powermode != NULL) { 2631 value = attr_lookup(power_modes, 2632 sizeof(power_modes) / sizeof(str_map), powermode); 2633 if((value == LOW_POWER) || mHFRLevel > 1) { 2634 ALOGV("Enable Low Power Mode"); 2635 value = LOW_POWER; 2636 mPowerMode = value; 2637 mParameters.set(QCameraParameters::KEY_POWER_MODE,"Low_Power"); 2638 } else { 2639 ALOGV("Enable Normal Power Mode"); 2640 mPowerMode = value; 2641 mParameters.set(QCameraParameters::KEY_POWER_MODE,"Normal_Power"); 2642 } 2643 } 2644 2645 ALOGV("%s Low power mode %s value = %d", __func__, 2646 value ? "Enabled" : "Disabled", value); 2647 native_set_parms(MM_CAMERA_PARM_LOW_POWER_MODE, sizeof(value), 2648 (void *)&value); 2649 return NO_ERROR; 2650 } 2651 2652 2653 status_t QCameraHardwareInterface::setPreviewSize(const QCameraParameters& params) 2654 { 2655 int width, height; 2656 params.getPreviewSize(&width, &height); 2657 ALOGV("################requested preview size %d x %d", width, height); 2658 2659 // Validate the preview size 2660 for (size_t i = 0; i < mPreviewSizeCount; ++i) { 2661 if (width == mPreviewSizes[i].width 2662 && height == mPreviewSizes[i].height) { 2663 int old_width, old_height; 2664 mParameters.getPreviewSize(&old_width,&old_height); 2665 if(width != old_width || height != old_height) { 2666 mRestartPreview = true; 2667 } 2668 mParameters.setPreviewSize(width, height); 2669 ALOGV("setPreviewSize: width: %d heigh: %d", width, height); 2670 mPreviewWidth = width; 2671 mPreviewHeight = height; 2672 2673 mDimension.display_width = mPreviewWidth; 2674 mDimension.display_height= mPreviewHeight; 2675 mDimension.orig_video_width = mPreviewWidth; 2676 mDimension.orig_video_height = mPreviewHeight; 2677 mDimension.video_width = mPreviewWidth; 2678 mDimension.video_height = mPreviewHeight; 2679 2680 return NO_ERROR; 2681 } 2682 } 2683 ALOGE("Invalid preview size requested: %dx%d", width, height); 2684 return BAD_VALUE; 2685 } 2686 status_t QCameraHardwareInterface::setPreviewFpsRange(const QCameraParameters& params) 2687 { 2688 ALOGV("%s: E", __func__); 2689 int minFps,maxFps; 2690 int prevMinFps, prevMaxFps; 2691 int rc = NO_ERROR; 2692 bool found = false; 2693 2694 mParameters.getPreviewFpsRange(&prevMinFps, &prevMaxFps); 2695 ALOGV("%s: Existing FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps); 2696 params.getPreviewFpsRange(&minFps,&maxFps); 2697 ALOGV("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps); 2698 2699 if(mInitialized && (minFps == prevMinFps && maxFps == prevMaxFps)) { 2700 ALOGV("%s: No change in FpsRange", __func__); 2701 rc = NO_ERROR; 2702 goto end; 2703 } 2704 for(size_t i=0; i<FPS_RANGES_SUPPORTED_COUNT; i++) { 2705 // if the value is in the supported list 2706 if(minFps==FpsRangesSupported[i].minFPS && maxFps == FpsRangesSupported[i].maxFPS){ 2707 found = true; 2708 ALOGV("FPS: i=%d : minFps = %d, maxFps = %d ",i,FpsRangesSupported[i].minFPS,FpsRangesSupported[i].maxFPS ); 2709 mParameters.setPreviewFpsRange(minFps,maxFps); 2710 // validate the values 2711 bool valid = true; 2712 // FPS can not be negative 2713 if(minFps < 0 || maxFps < 0) valid = false; 2714 // minFps must be >= maxFps 2715 if(minFps > maxFps) valid = false; 2716 2717 if(valid) { 2718 //Set the FPS mode 2719 const char *str = (minFps == maxFps) ? 2720 QCameraParameters::KEY_PREVIEW_FRAME_RATE_FIXED_MODE: 2721 QCameraParameters::KEY_PREVIEW_FRAME_RATE_AUTO_MODE; 2722 ALOGV("%s FPS_MODE = %s", __func__, str); 2723 int32_t frameRateMode = attr_lookup(frame_rate_modes, 2724 sizeof(frame_rate_modes) / sizeof(str_map),str); 2725 bool ret; 2726 ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(int32_t), 2727 (void *)&frameRateMode); 2728 2729 //set FPS values 2730 uint32_t fps; //lower 2 bytes specify maxFps and higher 2 bytes specify minFps 2731 fps = ((uint32_t)(minFps/1000) << 16) + ((uint16_t)(maxFps/1000)); 2732 ret = native_set_parms(MM_CAMERA_PARM_FPS, sizeof(uint32_t), (void *)&fps); 2733 mParameters.setPreviewFpsRange(minFps, maxFps); 2734 if(ret) 2735 rc = NO_ERROR; 2736 else { 2737 rc = BAD_VALUE; 2738 ALOGE("%s: error: native_set_params failed", __func__); 2739 } 2740 } else { 2741 ALOGE("%s: error: invalid FPS range value", __func__); 2742 rc = BAD_VALUE; 2743 } 2744 } 2745 } 2746 if(found == false){ 2747 ALOGE("%s: error: FPS range value not supported", __func__); 2748 rc = BAD_VALUE; 2749 } 2750 end: 2751 ALOGV("%s: X", __func__); 2752 return rc; 2753 } 2754 2755 status_t QCameraHardwareInterface::setJpegThumbnailSize(const QCameraParameters& params){ 2756 int width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 2757 int height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 2758 2759 ALOGV("requested jpeg thumbnail size %d x %d", width, height); 2760 2761 // Validate the picture size 2762 for (unsigned int i = 0; i < thumbnail_sizes_count; ++i) { 2763 if (width == default_thumbnail_sizes[i].width 2764 && height == default_thumbnail_sizes[i].height) { 2765 thumbnailWidth = width; 2766 thumbnailHeight = height; 2767 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); 2768 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); 2769 return NO_ERROR; 2770 } 2771 } 2772 ALOGE("error: setting jpeg thumbnail size"); 2773 return BAD_VALUE; 2774 } 2775 status_t QCameraHardwareInterface::setPictureSize(const QCameraParameters& params) 2776 { 2777 int width, height; 2778 ALOGV("QualcommCameraHardware::setPictureSize E"); 2779 params.getPictureSize(&width, &height); 2780 ALOGV("requested picture size %d x %d", width, height); 2781 2782 // Validate the picture size 2783 for (int i = 0; i < mSupportedPictureSizesCount; ++i) { 2784 if (width == mPictureSizesPtr[i].width 2785 && height == mPictureSizesPtr[i].height) { 2786 int old_width, old_height; 2787 mParameters.getPictureSize(&old_width,&old_height); 2788 if(width != old_width || height != old_height) { 2789 mRestartPreview = true; 2790 } 2791 mParameters.setPictureSize(width, height); 2792 mDimension.picture_width = width; 2793 mDimension.picture_height = height; 2794 return NO_ERROR; 2795 } 2796 } 2797 /* Dimension not among the ones in the list. Check if 2798 * its a valid dimension, if it is, then configure the 2799 * camera accordingly. else reject it. 2800 */ 2801 if( isValidDimension(width, height) ) { 2802 mParameters.setPictureSize(width, height); 2803 mDimension.picture_width = width; 2804 mDimension.picture_height = height; 2805 return NO_ERROR; 2806 } else 2807 ALOGE("Invalid picture size requested: %dx%d", width, height); 2808 return BAD_VALUE; 2809 } 2810 2811 status_t QCameraHardwareInterface::setJpegRotation(int isZsl) { 2812 return mm_jpeg_encoder_setRotation(mRotation, isZsl); 2813 } 2814 2815 int QCameraHardwareInterface::getJpegRotation(void) { 2816 return mRotation; 2817 } 2818 2819 int QCameraHardwareInterface::getISOSpeedValue() 2820 { 2821 const char *iso_str = mParameters.get(QCameraParameters::KEY_ISO_MODE); 2822 int iso_index = attr_lookup(iso, sizeof(iso) / sizeof(str_map), iso_str); 2823 int iso_value = iso_speed_values[iso_index]; 2824 return iso_value; 2825 } 2826 2827 2828 status_t QCameraHardwareInterface::setJpegQuality(const QCameraParameters& params) { 2829 status_t rc = NO_ERROR; 2830 int quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY); 2831 ALOGV("setJpegQuality E"); 2832 if (quality >= 0 && quality <= 100) { 2833 mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, quality); 2834 mJpegQuality = quality; 2835 } else { 2836 ALOGE("Invalid jpeg quality=%d", quality); 2837 rc = BAD_VALUE; 2838 } 2839 2840 quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 2841 if (quality >= 0 && quality <= 100) { 2842 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, quality); 2843 } else { 2844 ALOGE("Invalid jpeg thumbnail quality=%d", quality); 2845 rc = BAD_VALUE; 2846 } 2847 ALOGV("setJpegQuality X"); 2848 return rc; 2849 } 2850 2851 status_t QCameraHardwareInterface:: 2852 setNumOfSnapshot(const QCameraParameters& params) { 2853 status_t rc = NO_ERROR; 2854 2855 int num_of_snapshot = getNumOfSnapshots(params); 2856 2857 if (num_of_snapshot <= 0) { 2858 num_of_snapshot = 1; 2859 } 2860 ALOGV("number of snapshots = %d", num_of_snapshot); 2861 mParameters.set("num-snaps-per-shutter", num_of_snapshot); 2862 2863 bool result = native_set_parms(MM_CAMERA_PARM_SNAPSHOT_BURST_NUM, 2864 sizeof(int), 2865 (void *)&num_of_snapshot); 2866 if(!result) 2867 ALOGE("%s:Failure setting number of snapshots!!!", __func__); 2868 return rc; 2869 } 2870 2871 status_t QCameraHardwareInterface::setPreviewFormat(const QCameraParameters& params) { 2872 const char *str = params.getPreviewFormat(); 2873 int32_t previewFormat = attr_lookup(preview_formats, sizeof(preview_formats) / sizeof(str_map), str); 2874 if(previewFormat != NOT_FOUND) { 2875 int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t); 2876 int i; 2877 2878 for (i = 0; i < num; i++) { 2879 if (preview_format_info_list[i].Hal_format == previewFormat) { 2880 mPreviewFormatInfo = preview_format_info_list[i]; 2881 break; 2882 } 2883 } 2884 2885 if (i == num) { 2886 mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21; 2887 mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD; 2888 return BAD_VALUE; 2889 } 2890 bool ret = native_set_parms(MM_CAMERA_PARM_PREVIEW_FORMAT, sizeof(cam_format_t), 2891 (void *)&mPreviewFormatInfo.mm_cam_format); 2892 mParameters.set(QCameraParameters::KEY_PREVIEW_FORMAT, str); 2893 mPreviewFormat = mPreviewFormatInfo.mm_cam_format; 2894 ALOGV("Setting preview format to %d, i =%d, num=%d, hal_format=%d", 2895 mPreviewFormat, i, num, mPreviewFormatInfo.Hal_format); 2896 return NO_ERROR; 2897 } else if ( strTexturesOn ) { 2898 mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21; 2899 mPreviewFormatInfo.padding = CAMERA_PAD_TO_4K; 2900 } else { 2901 mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21; 2902 mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD; 2903 } 2904 ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str); 2905 return BAD_VALUE; 2906 } 2907 2908 status_t QCameraHardwareInterface::setStrTextures(const QCameraParameters& params) { 2909 const char *str = params.get("strtextures"); 2910 const char *prev_str = mParameters.get("strtextures"); 2911 2912 if(str != NULL) { 2913 if(!strcmp(str,prev_str)) { 2914 return NO_ERROR; 2915 } 2916 int str_size = strlen(str); 2917 mParameters.set("strtextures", str); 2918 if(str_size == 2) { 2919 if(!strncmp(str, "on", str_size) || !strncmp(str, "ON", str_size)){ 2920 ALOGV("Resetting mUseOverlay to false"); 2921 strTexturesOn = true; 2922 mUseOverlay = false; 2923 } 2924 }else if(str_size == 3){ 2925 if (!strncmp(str, "off", str_size) || !strncmp(str, "OFF", str_size)) { 2926 strTexturesOn = false; 2927 mUseOverlay = true; 2928 } 2929 } 2930 2931 } 2932 return NO_ERROR; 2933 } 2934 2935 status_t QCameraHardwareInterface::setFlash(const QCameraParameters& params) 2936 { 2937 const char *str = NULL; 2938 2939 ALOGV("%s: E",__func__); 2940 int rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_LED_MODE); 2941 if(!rc) { 2942 ALOGV("%s:LED FLASH not supported", __func__); 2943 return NO_ERROR; 2944 } 2945 2946 const char *sce_str = params.get(QCameraParameters::KEY_SCENE_MODE); 2947 if (sce_str != NULL) { 2948 if (!strcmp(sce_str, "hdr")) { 2949 //Flash In HDR 2950 str = QCameraParameters::FLASH_MODE_OFF; 2951 mParameters.set(QCameraParameters::KEY_FLASH_MODE, str); 2952 }else if(!strcmp(sce_str, "auto")){ 2953 //Flash Mode in auto scene mode 2954 str = params.get(QCameraParameters::KEY_FLASH_MODE); 2955 }else{ 2956 //FLASH in scene Mode except auto, hdr 2957 str = QCameraParameters::FLASH_MODE_AUTO; 2958 mParameters.set(QCameraParameters::KEY_FLASH_MODE, str); 2959 } 2960 }else { 2961 str = params.get(QCameraParameters::KEY_FLASH_MODE); 2962 } 2963 2964 if (str != NULL) { 2965 int32_t value = attr_lookup(flash, sizeof(flash) / sizeof(str_map), str); 2966 if (value != NOT_FOUND) { 2967 mParameters.set(QCameraParameters::KEY_FLASH_MODE, str); 2968 bool ret = native_set_parms(MM_CAMERA_PARM_LED_MODE, 2969 sizeof(value), (void *)&value); 2970 mLedStatusForZsl = (led_mode_t)value; 2971 return ret ? NO_ERROR : UNKNOWN_ERROR; 2972 } 2973 } 2974 ALOGE("Invalid flash mode value: %s", (str == NULL) ? "NULL" : str); 2975 2976 return BAD_VALUE; 2977 } 2978 2979 status_t QCameraHardwareInterface::setAecAwbLock(const QCameraParameters & params) 2980 { 2981 ALOGV("%s : E", __func__); 2982 status_t rc = NO_ERROR; 2983 int32_t value; 2984 const char* str; 2985 2986 //for AEC lock 2987 str = params.get(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK); 2988 value = (strcmp(str, "true") == 0)? 1 : 0; 2989 mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK, str); 2990 rc = (native_set_parms(MM_CAMERA_PARM_AEC_LOCK, sizeof(int32_t), (void *)(&value))) ? 2991 NO_ERROR : UNKNOWN_ERROR; 2992 2993 //for AWB lock 2994 str = params.get(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK); 2995 value = (strcmp(str, "true") == 0)? 1 : 0; 2996 mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, str); 2997 rc = (native_set_parms(MM_CAMERA_PARM_AWB_LOCK, sizeof(int32_t), (void *)(&value))) ? 2998 NO_ERROR : UNKNOWN_ERROR; 2999 ALOGV("%s : X", __func__); 3000 return rc; 3001 } 3002 3003 status_t QCameraHardwareInterface::setOverlayFormats(const QCameraParameters& params) 3004 { 3005 mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP); 3006 if(mIs3DModeOn == true) { 3007 int ovFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP|HAL_3D_IN_SIDE_BY_SIDE_L_R|HAL_3D_OUT_SIDE_BY_SIDE; 3008 mParameters.set("overlay-format", ovFormat); 3009 } 3010 return NO_ERROR; 3011 } 3012 3013 status_t QCameraHardwareInterface::setMCEValue(const QCameraParameters& params) 3014 { 3015 ALOGV("%s",__func__); 3016 status_t rc = NO_ERROR; 3017 rc = cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_MCE); 3018 if(!rc) { 3019 ALOGV("MM_CAMERA_PARM_MCE mode is not supported for this sensor"); 3020 return NO_ERROR; 3021 } 3022 const char *str = params.get(QCameraParameters::KEY_MEMORY_COLOR_ENHANCEMENT); 3023 if (str != NULL) { 3024 int value = attr_lookup(mce, sizeof(mce) / sizeof(str_map), str); 3025 if (value != NOT_FOUND) { 3026 int temp = (int8_t)value; 3027 ALOGV("%s: setting MCE value of %s", __FUNCTION__, str); 3028 mParameters.set(QCameraParameters::KEY_MEMORY_COLOR_ENHANCEMENT, str); 3029 3030 native_set_parms(MM_CAMERA_PARM_MCE, sizeof(int8_t), (void *)&temp); 3031 return NO_ERROR; 3032 } 3033 } 3034 ALOGE("Invalid MCE value: %s", (str == NULL) ? "NULL" : str); 3035 3036 return NO_ERROR; 3037 } 3038 3039 status_t QCameraHardwareInterface::setHighFrameRate(const QCameraParameters& params) 3040 { 3041 3042 bool mCameraRunning; 3043 3044 int rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_HFR); 3045 if(!rc) { 3046 ALOGV("%s: MM_CAMERA_PARM_HFR not supported", __func__); 3047 return NO_ERROR; 3048 } 3049 3050 const char *str = params.get(QCameraParameters::KEY_VIDEO_HIGH_FRAME_RATE); 3051 if (str != NULL) { 3052 int value = attr_lookup(hfr, sizeof(hfr) / sizeof(str_map), str); 3053 if (value != NOT_FOUND) { 3054 mHFRLevel = (int32_t)value; 3055 //Check for change in HFR value 3056 const char *oldHfr = mParameters.get(QCameraParameters::KEY_VIDEO_HIGH_FRAME_RATE); 3057 if(strcmp(oldHfr, str)){ 3058 mParameters.set(QCameraParameters::KEY_VIDEO_HIGH_FRAME_RATE, str); 3059 // mHFRMode = true; 3060 mCameraRunning=isPreviewRunning(); 3061 if(mCameraRunning == true) { 3062 // mHFRThreadWaitLock.lock(); 3063 // pthread_attr_t pattr; 3064 // pthread_attr_init(&pattr); 3065 // pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_DETACHED); 3066 // mHFRThreadRunning = !pthread_create(&mHFRThread, 3067 // &pattr, 3068 // hfr_thread, 3069 // (void*)NULL); 3070 // mHFRThreadWaitLock.unlock(); 3071 stopPreviewInternal(); 3072 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 3073 native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel); 3074 mPreviewState = QCAMERA_HAL_PREVIEW_START; 3075 if (startPreview2() == NO_ERROR) 3076 mPreviewState = QCAMERA_HAL_PREVIEW_STARTED; 3077 return NO_ERROR; 3078 } 3079 } 3080 native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel); 3081 return NO_ERROR; 3082 } 3083 } 3084 ALOGE("Invalid HFR value: %s", (str == NULL) ? "NULL" : str); 3085 return NO_ERROR; 3086 } 3087 3088 status_t QCameraHardwareInterface::setLensshadeValue(const QCameraParameters& params) 3089 { 3090 3091 int rc = cam_config_is_parm_supported(mCameraId, MM_CAMERA_PARM_ROLLOFF); 3092 if(!rc) { 3093 ALOGV("%s:LENS SHADING not supported", __func__); 3094 return NO_ERROR; 3095 } 3096 3097 const char *str = params.get(QCameraParameters::KEY_LENSSHADE); 3098 if (str != NULL) { 3099 int value = attr_lookup(lensshade, 3100 sizeof(lensshade) / sizeof(str_map), str); 3101 if (value != NOT_FOUND) { 3102 int8_t temp = (int8_t)value; 3103 mParameters.set(QCameraParameters::KEY_LENSSHADE, str); 3104 native_set_parms(MM_CAMERA_PARM_ROLLOFF, sizeof(int8_t), (void *)&temp); 3105 return NO_ERROR; 3106 } 3107 } 3108 ALOGE("Invalid lensShade value: %s", (str == NULL) ? "NULL" : str); 3109 return BAD_VALUE; 3110 } 3111 3112 status_t QCameraHardwareInterface::setFaceDetect(const QCameraParameters& params) 3113 { 3114 if(supportsFaceDetection() == false){ 3115 ALOGI("setFaceDetect support is not available"); 3116 return NO_ERROR; 3117 } 3118 3119 int requested_faces = params.getInt(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES); 3120 int hardware_supported_faces = mParameters.getInt(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW); 3121 if (requested_faces > hardware_supported_faces) { 3122 requested_faces = hardware_supported_faces; 3123 } 3124 mParameters.set(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES, requested_faces); 3125 const char *str = params.get(QCameraParameters::KEY_FACE_DETECTION); 3126 ALOGV("setFaceDetect: %s", str); 3127 if (str != NULL) { 3128 fd_set_parm_t fd_set_parm; 3129 int value = attr_lookup(facedetection, 3130 sizeof(facedetection) / sizeof(str_map), str); 3131 mFaceDetectOn = value; 3132 fd_set_parm.fd_mode = value; 3133 fd_set_parm.num_fd = requested_faces; 3134 ALOGV("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces); 3135 native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm); 3136 mParameters.set(QCameraParameters::KEY_FACE_DETECTION, str); 3137 return NO_ERROR; 3138 } 3139 ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str); 3140 return BAD_VALUE; 3141 } 3142 status_t QCameraHardwareInterface::setFaceDetection(const char *str) 3143 { 3144 if(supportsFaceDetection() == false){ 3145 ALOGV("Face detection is not enabled"); 3146 return NO_ERROR; 3147 } 3148 if (str != NULL) { 3149 int requested_faces = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_REQUESTED_FACES); 3150 int value = attr_lookup(facedetection, 3151 sizeof(facedetection) / sizeof(str_map), str); 3152 if (value != NOT_FOUND) { 3153 fd_set_parm_t fd_set_parm; 3154 mMetaDataWaitLock.lock(); 3155 mFaceDetectOn = value; 3156 mMetaDataWaitLock.unlock(); 3157 fd_set_parm.fd_mode = value; 3158 fd_set_parm.num_fd = requested_faces; 3159 ALOGV("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces); 3160 native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm); 3161 mParameters.set(QCameraParameters::KEY_FACE_DETECTION, str); 3162 return NO_ERROR; 3163 } 3164 } 3165 ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str); 3166 return BAD_VALUE; 3167 } 3168 3169 status_t QCameraHardwareInterface::setAEBracket(const QCameraParameters& params) 3170 { 3171 const char *str; 3172 if(!cam_config_is_parm_supported(mCameraId,MM_CAMERA_PARM_HDR) || (myMode & CAMERA_ZSL_MODE)) { 3173 ALOGV("Parameter HDR is not supported for this sensor/ ZSL mode"); 3174 3175 if (myMode & CAMERA_ZSL_MODE) { 3176 ALOGV("In ZSL mode, reset AEBBracket to HDR_OFF mode"); 3177 exp_bracketing_t temp; 3178 memset(&temp, 0, sizeof(temp)); 3179 mHdrMode = HDR_BRACKETING_OFF; 3180 temp.hdr_enable= false; 3181 temp.mode = HDR_BRACKETING_OFF; 3182 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); 3183 } 3184 return NO_ERROR; 3185 } 3186 3187 const char *str2 = params.get(QCameraParameters::KEY_SCENE_MODE); 3188 if(!strcmp(str2, "hdr")) { 3189 str="HDR"; 3190 } else { 3191 str = params.get(QCameraParameters::KEY_AE_BRACKET_HDR); 3192 } 3193 3194 if (str != NULL) { 3195 int value = attr_lookup(hdr_bracket, 3196 sizeof(hdr_bracket) / sizeof(str_map), str); 3197 exp_bracketing_t temp; 3198 memset(&temp, 0, sizeof(temp)); 3199 switch (value) { 3200 case HDR_MODE: 3201 { 3202 mHdrMode = HDR_MODE; 3203 } 3204 break; 3205 case EXP_BRACKETING_MODE: 3206 { 3207 int numFrames = getNumOfSnapshots(); 3208 const char *str_val = params.get("capture-burst-exposures"); 3209 if ((str_val != NULL) && (strlen(str_val)>0)) { 3210 ALOGV("%s: capture-burst-exposures %s", __FUNCTION__, str_val); 3211 3212 mHdrMode = EXP_BRACKETING_MODE; 3213 temp.hdr_enable = false; 3214 temp.mode = EXP_BRACKETING_MODE; 3215 temp.total_frames = (numFrames > MAX_SNAPSHOT_BUFFERS -2) ? MAX_SNAPSHOT_BUFFERS -2 : numFrames; 3216 temp.total_hal_frames = temp.total_frames; 3217 strlcpy(temp.values, str_val, MAX_EXP_BRACKETING_LENGTH); 3218 ALOGV("%s: setting Exposure Bracketing value of %s, frame (%d)", __FUNCTION__, temp.values, temp.total_hal_frames); 3219 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); 3220 } 3221 else { 3222 /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */ 3223 ALOGV("%s: capture-burst-exposures not set, back to HDR OFF mode", __FUNCTION__); 3224 mHdrMode = HDR_BRACKETING_OFF; 3225 temp.hdr_enable= false; 3226 temp.mode = HDR_BRACKETING_OFF; 3227 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); 3228 } 3229 } 3230 break; 3231 case HDR_BRACKETING_OFF: 3232 default: 3233 { 3234 mHdrMode = HDR_BRACKETING_OFF; 3235 temp.hdr_enable= false; 3236 temp.mode = HDR_BRACKETING_OFF; 3237 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); 3238 } 3239 break; 3240 } 3241 3242 /* save the value*/ 3243 mParameters.set(QCameraParameters::KEY_AE_BRACKET_HDR, str); 3244 } 3245 return NO_ERROR; 3246 } 3247 3248 status_t QCameraHardwareInterface::setCaptureBurstExp() 3249 { 3250 char burst_exp[PROPERTY_VALUE_MAX]; 3251 memset(burst_exp, 0, sizeof(burst_exp)); 3252 property_get("persist.capture.burst.exposures", burst_exp, ""); 3253 if (NULL != burst_exp) 3254 mParameters.set("capture-burst-exposures", burst_exp); 3255 return NO_ERROR; 3256 } 3257 3258 status_t QCameraHardwareInterface::setRedeyeReduction(const QCameraParameters& params) 3259 { 3260 if(supportsRedEyeReduction() == false) { 3261 ALOGV("Parameter Redeye Reduction is not supported for this sensor"); 3262 return NO_ERROR; 3263 } 3264 3265 const char *str = params.get(QCameraParameters::KEY_REDEYE_REDUCTION); 3266 if (str != NULL) { 3267 int value = attr_lookup(redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map), str); 3268 if (value != NOT_FOUND) { 3269 int8_t temp = (int8_t)value; 3270 ALOGV("%s: setting Redeye Reduction value of %s", __FUNCTION__, str); 3271 mParameters.set(QCameraParameters::KEY_REDEYE_REDUCTION, str); 3272 3273 native_set_parms(MM_CAMERA_PARM_REDEYE_REDUCTION, sizeof(int8_t), (void *)&temp); 3274 return NO_ERROR; 3275 } 3276 } 3277 ALOGE("Invalid Redeye Reduction value: %s", (str == NULL) ? "NULL" : str); 3278 return BAD_VALUE; 3279 } 3280 3281 status_t QCameraHardwareInterface::setGpsLocation(const QCameraParameters& params) 3282 { 3283 const char *method = params.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD); 3284 if (method) { 3285 mParameters.set(QCameraParameters::KEY_GPS_PROCESSING_METHOD, method); 3286 }else { 3287 mParameters.remove(QCameraParameters::KEY_GPS_PROCESSING_METHOD); 3288 } 3289 3290 const char *latitude = params.get(QCameraParameters::KEY_GPS_LATITUDE); 3291 if (latitude) { 3292 mParameters.set(QCameraParameters::KEY_GPS_LATITUDE, latitude); 3293 }else { 3294 mParameters.remove(QCameraParameters::KEY_GPS_LATITUDE); 3295 } 3296 3297 const char *latitudeRef = params.get(QCameraParameters::KEY_GPS_LATITUDE_REF); 3298 if (latitudeRef) { 3299 mParameters.set(QCameraParameters::KEY_GPS_LATITUDE_REF, latitudeRef); 3300 }else { 3301 mParameters.remove(QCameraParameters::KEY_GPS_LATITUDE_REF); 3302 } 3303 3304 const char *longitude = params.get(QCameraParameters::KEY_GPS_LONGITUDE); 3305 if (longitude) { 3306 mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE, longitude); 3307 }else { 3308 mParameters.remove(QCameraParameters::KEY_GPS_LONGITUDE); 3309 } 3310 3311 const char *longitudeRef = params.get(QCameraParameters::KEY_GPS_LONGITUDE_REF); 3312 if (longitudeRef) { 3313 mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE_REF, longitudeRef); 3314 }else { 3315 mParameters.remove(QCameraParameters::KEY_GPS_LONGITUDE_REF); 3316 } 3317 3318 const char *altitudeRef = params.get(QCameraParameters::KEY_GPS_ALTITUDE_REF); 3319 if (altitudeRef) { 3320 mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE_REF, altitudeRef); 3321 }else { 3322 mParameters.remove(QCameraParameters::KEY_GPS_ALTITUDE_REF); 3323 } 3324 3325 const char *altitude = params.get(QCameraParameters::KEY_GPS_ALTITUDE); 3326 if (altitude) { 3327 mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE, altitude); 3328 }else { 3329 mParameters.remove(QCameraParameters::KEY_GPS_ALTITUDE); 3330 } 3331 3332 const char *status = params.get(QCameraParameters::KEY_GPS_STATUS); 3333 if (status) { 3334 mParameters.set(QCameraParameters::KEY_GPS_STATUS, status); 3335 } 3336 3337 const char *dateTime = params.get(QCameraParameters::KEY_EXIF_DATETIME); 3338 if (dateTime) { 3339 mParameters.set(QCameraParameters::KEY_EXIF_DATETIME, dateTime); 3340 }else { 3341 mParameters.remove(QCameraParameters::KEY_EXIF_DATETIME); 3342 } 3343 3344 const char *timestamp = params.get(QCameraParameters::KEY_GPS_TIMESTAMP); 3345 if (timestamp) { 3346 mParameters.set(QCameraParameters::KEY_GPS_TIMESTAMP, timestamp); 3347 }else { 3348 mParameters.remove(QCameraParameters::KEY_GPS_TIMESTAMP); 3349 } 3350 ALOGV("setGpsLocation X"); 3351 return NO_ERROR; 3352 } 3353 3354 status_t QCameraHardwareInterface::setRotation(const QCameraParameters& params) 3355 { 3356 status_t rc = NO_ERROR; 3357 int rotation = params.getInt(QCameraParameters::KEY_ROTATION); 3358 if (rotation != NOT_FOUND) { 3359 if (rotation == 0 || rotation == 90 || rotation == 180 3360 || rotation == 270) { 3361 mParameters.set(QCameraParameters::KEY_ROTATION, rotation); 3362 mRotation = rotation; 3363 } else { 3364 ALOGE("Invalid rotation value: %d", rotation); 3365 rc = BAD_VALUE; 3366 } 3367 } 3368 ALOGV("setRotation"); 3369 return rc; 3370 } 3371 3372 status_t QCameraHardwareInterface::setDenoise(const QCameraParameters& params) 3373 { 3374 #if 0 3375 if(!mCfgControl.mm_camera_is_supported(MM_CAMERA_PARM_WAVELET_DENOISE)) { 3376 ALOGE("Wavelet Denoise is not supported for this sensor"); 3377 return NO_ERROR; 3378 } 3379 const char *str = params.get(QCameraParameters::KEY_DENOISE); 3380 if (str != NULL) { 3381 int value = attr_lookup(denoise, 3382 sizeof(denoise) / sizeof(str_map), str); 3383 if ((value != NOT_FOUND) && (mDenoiseValue != value)) { 3384 mDenoiseValue = value; 3385 mParameters.set(QCameraParameters::KEY_DENOISE, str); 3386 bool ret = native_set_parms(MM_CAMERA_PARM_WAVELET_DENOISE, sizeof(value), 3387 (void *)&value); 3388 return ret ? NO_ERROR : UNKNOWN_ERROR; 3389 } 3390 return NO_ERROR; 3391 } 3392 ALOGE("Invalid Denoise value: %s", (str == NULL) ? "NULL" : str); 3393 #endif 3394 return BAD_VALUE; 3395 } 3396 3397 status_t QCameraHardwareInterface::setOrientation(const QCameraParameters& params) 3398 { 3399 const char *str = params.get("orientation"); 3400 3401 if (str != NULL) { 3402 if (strcmp(str, "portrait") == 0 || strcmp(str, "landscape") == 0) { 3403 // Camera service needs this to decide if the preview frames and raw 3404 // pictures should be rotated. 3405 mParameters.set("orientation", str); 3406 } else { 3407 ALOGE("Invalid orientation value: %s", str); 3408 return BAD_VALUE; 3409 } 3410 } 3411 return NO_ERROR; 3412 } 3413 3414 status_t QCameraHardwareInterface::setPictureFormat(const QCameraParameters& params) 3415 { 3416 const char * str = params.get(QCameraParameters::KEY_PICTURE_FORMAT); 3417 3418 if(str != NULL){ 3419 int32_t value = attr_lookup(picture_formats, 3420 sizeof(picture_formats) / sizeof(str_map), str); 3421 if(value != NOT_FOUND){ 3422 mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, str); 3423 } else { 3424 ALOGE("Invalid Picture Format value: %s", str); 3425 return BAD_VALUE; 3426 } 3427 } 3428 return NO_ERROR; 3429 } 3430 3431 status_t QCameraHardwareInterface::setRecordingHintValue(const int32_t value) 3432 { 3433 native_set_parms(MM_CAMERA_PARM_RECORDING_HINT, sizeof(value), 3434 (void *)&value); 3435 if (value == true){ 3436 native_set_parms(MM_CAMERA_PARM_CAF_ENABLE, sizeof(value), 3437 (void *)&value); 3438 } 3439 setDISMode(); 3440 setFullLiveshot(); 3441 return NO_ERROR; 3442 } 3443 3444 status_t QCameraHardwareInterface::setRecordingHint(const QCameraParameters& params) 3445 { 3446 3447 const char * str = params.get(QCameraParameters::KEY_RECORDING_HINT); 3448 3449 if(str != NULL){ 3450 int32_t value = attr_lookup(recording_Hints, 3451 sizeof(recording_Hints) / sizeof(str_map), str); 3452 if(value != NOT_FOUND){ 3453 mRecordingHint = value; 3454 setRecordingHintValue(mRecordingHint); 3455 mParameters.set(QCameraParameters::KEY_RECORDING_HINT, str); 3456 return NO_ERROR; 3457 } else { 3458 ALOGE("Invalid Picture Format value: %s", str); 3459 setDISMode(); 3460 setFullLiveshot(); 3461 return BAD_VALUE; 3462 } 3463 } 3464 setDISMode(); 3465 setFullLiveshot(); 3466 return NO_ERROR; 3467 } 3468 3469 status_t QCameraHardwareInterface::setDISMode() { 3470 /* Enable DIS only if 3471 * - Camcorder mode AND 3472 * - DIS property is set AND 3473 * - Not in Low power mode. */ 3474 uint32_t value = mRecordingHint && mDisEnabled 3475 && !isLowPowerCamcorder(); 3476 3477 ALOGV("%s DIS is %s value = %d", __func__, 3478 value ? "Enabled" : "Disabled", value); 3479 native_set_parms(MM_CAMERA_PARM_DIS_ENABLE, sizeof(value), 3480 (void *)&value); 3481 return NO_ERROR; 3482 } 3483 3484 status_t QCameraHardwareInterface::setFullLiveshot() 3485 { 3486 /* Enable full size liveshot only if 3487 * - Camcorder mode AND 3488 * - Full size liveshot is enabled. */ 3489 uint32_t value = mRecordingHint && mFullLiveshotEnabled 3490 && !isLowPowerCamcorder(); 3491 3492 if (((mDimension.picture_width == mVideoWidth) && 3493 (mDimension.picture_height == mVideoHeight))) { 3494 /* If video size matches the live snapshot size 3495 * turn off full size liveshot to get higher fps. */ 3496 value = 0; 3497 } 3498 3499 ALOGV("%s Full size liveshot %s value = %d", __func__, 3500 value ? "Enabled" : "Disabled", value); 3501 native_set_parms(MM_CAMERA_PARM_FULL_LIVESHOT, sizeof(value), 3502 (void *)&value); 3503 return NO_ERROR; 3504 } 3505 3506 3507 isp3a_af_mode_t QCameraHardwareInterface::getAutoFocusMode( 3508 const QCameraParameters& params) 3509 { 3510 isp3a_af_mode_t afMode = AF_MODE_MAX; 3511 afMode = (isp3a_af_mode_t)mFocusMode; 3512 return afMode; 3513 } 3514 3515 void QCameraHardwareInterface::getPictureSize(int *picture_width, 3516 int *picture_height) const 3517 { 3518 mParameters.getPictureSize(picture_width, picture_height); 3519 } 3520 3521 void QCameraHardwareInterface::getPreviewSize(int *preview_width, 3522 int *preview_height) const 3523 { 3524 mParameters.getPreviewSize(preview_width, preview_height); 3525 } 3526 3527 cam_format_t QCameraHardwareInterface::getPreviewFormat() const 3528 { 3529 cam_format_t foramt = CAMERA_YUV_420_NV21; 3530 const char *str = mParameters.getPreviewFormat(); 3531 int32_t value = attr_lookup(preview_formats, 3532 sizeof(preview_formats)/sizeof(str_map), 3533 str); 3534 3535 if(value != NOT_FOUND) { 3536 int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t); 3537 int i; 3538 for (i = 0; i < num; i++) { 3539 if (preview_format_info_list[i].Hal_format == value) { 3540 foramt = preview_format_info_list[i].mm_cam_format; 3541 break; 3542 } 3543 } 3544 } 3545 3546 return foramt; 3547 } 3548 3549 cam_pad_format_t QCameraHardwareInterface::getPreviewPadding() const 3550 { 3551 return mPreviewFormatInfo.padding; 3552 } 3553 3554 int QCameraHardwareInterface::getJpegQuality() const 3555 { 3556 return mJpegQuality; 3557 } 3558 3559 int QCameraHardwareInterface::getNumOfSnapshots(void) const 3560 { 3561 char prop[PROPERTY_VALUE_MAX]; 3562 memset(prop, 0, sizeof(prop)); 3563 property_get("persist.camera.snapshot.number", prop, "0"); 3564 ALOGV("%s: prop enable/disable = %d", __func__, atoi(prop)); 3565 if (atoi(prop)) { 3566 ALOGV("%s: Reading maximum no of snapshots = %d" 3567 "from properties", __func__, atoi(prop)); 3568 return atoi(prop); 3569 } else { 3570 return mParameters.getInt("num-snaps-per-shutter"); 3571 } 3572 } 3573 3574 int QCameraHardwareInterface::getNumOfSnapshots(const QCameraParameters& params) 3575 { 3576 char prop[PROPERTY_VALUE_MAX]; 3577 memset(prop, 0, sizeof(prop)); 3578 property_get("persist.camera.snapshot.number", prop, "0"); 3579 ALOGV("%s: prop enable/disable = %d", __func__, atoi(prop)); 3580 if (atoi(prop)) { 3581 ALOGV("%s: Reading maximum no of snapshots = %d" 3582 "from properties", __func__, atoi(prop)); 3583 return atoi(prop); 3584 } else { 3585 return params.getInt("num-snaps-per-shutter"); 3586 } 3587 3588 } 3589 3590 int QCameraHardwareInterface:: 3591 getThumbSizesFromAspectRatio(uint32_t aspect_ratio, 3592 int *picture_width, 3593 int *picture_height) 3594 { 3595 for(unsigned int i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ){ 3596 if(thumbnail_sizes[i].aspect_ratio == aspect_ratio) 3597 { 3598 *picture_width = thumbnail_sizes[i].width; 3599 *picture_height = thumbnail_sizes[i].height; 3600 return NO_ERROR; 3601 } 3602 } 3603 3604 return BAD_VALUE; 3605 } 3606 3607 bool QCameraHardwareInterface::isRawSnapshot() 3608 { 3609 const char *format = mParameters.getPictureFormat(); 3610 if( format!= NULL && 3611 !strcmp(format, QCameraParameters::PIXEL_FORMAT_RAW)){ 3612 return true; 3613 } 3614 else{ 3615 return false; 3616 } 3617 } 3618 3619 status_t QCameraHardwareInterface::setPreviewSizeTable(void) 3620 { 3621 status_t ret = NO_ERROR; 3622 mm_camera_dimension_t dim; 3623 struct camera_size_type* preview_size_table; 3624 int preview_table_size; 3625 int i = 0; 3626 char str[10] = {0}; 3627 3628 /* Initialize table with default values */ 3629 preview_size_table = default_preview_sizes; 3630 preview_table_size = preview_sizes_count; 3631 3632 3633 /* Get maximum preview size supported by sensor*/ 3634 memset(&dim, 0, sizeof(mm_camera_dimension_t)); 3635 ret = cam_config_get_parm(mCameraId, 3636 MM_CAMERA_PARM_MAX_PREVIEW_SIZE, &dim); 3637 if (ret != NO_ERROR) { 3638 ALOGE("%s: Failure getting Max Preview Size supported by camera", 3639 __func__); 3640 goto end; 3641 } 3642 3643 ALOGV("%s: Max Preview Sizes Supported: %d X %d", __func__, 3644 dim.width, dim.height); 3645 3646 for (i = 0; i < preview_table_size; i++) { 3647 if ((preview_size_table->width <= dim.width) && 3648 (preview_size_table->height <= dim.height)) { 3649 ALOGV("%s: Camera Preview Size Table " 3650 "Max width: %d height %d table_size: %d", 3651 __func__, preview_size_table->width, 3652 preview_size_table->height, preview_table_size - i); 3653 break; 3654 } 3655 preview_size_table++; 3656 } 3657 //set preferred preview size to maximum preview size 3658 sprintf(str, "%dx%d", preview_size_table->width, preview_size_table->height); 3659 mParameters.set(QCameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, str); 3660 ALOGV("KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO = %s", str); 3661 3662 end: 3663 /* Save the table in global member*/ 3664 mPreviewSizes = preview_size_table; 3665 mPreviewSizeCount = preview_table_size - i; 3666 3667 return ret; 3668 } 3669 3670 status_t QCameraHardwareInterface::setPictureSizeTable(void) 3671 { 3672 status_t ret = NO_ERROR; 3673 mm_camera_dimension_t dim; 3674 struct camera_size_type* picture_size_table; 3675 int picture_table_size; 3676 int i = 0, count = 0; 3677 3678 /* Initialize table with default values */ 3679 picture_table_size = sizeof(default_picture_sizes)/ 3680 sizeof(default_picture_sizes[0]); 3681 picture_size_table = default_picture_sizes; 3682 mPictureSizes = 3683 ( struct camera_size_type *)malloc(picture_table_size * 3684 sizeof(struct camera_size_type)); 3685 if (mPictureSizes == NULL) { 3686 ALOGE("%s: Failre allocating memory to store picture size table",__func__); 3687 goto end; 3688 } 3689 3690 /* Get maximum picture size supported by sensor*/ 3691 memset(&dim, 0, sizeof(mm_camera_dimension_t)); 3692 ret = cam_config_get_parm(mCameraId, 3693 MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim); 3694 if (ret != NO_ERROR) { 3695 ALOGE("%s: Failure getting Max Picture Size supported by camera", 3696 __func__); 3697 ret = NO_MEMORY; 3698 free(mPictureSizes); 3699 mPictureSizes = NULL; 3700 goto end; 3701 } 3702 3703 ALOGV("%s: Max Picture Sizes Supported: %d X %d", __func__, 3704 dim.width, dim.height); 3705 3706 for (i = 0; i < picture_table_size; i++) { 3707 /* We'll store those dimensions whose width AND height 3708 are less than or equal to maximum supported */ 3709 if ((picture_size_table->width <= dim.width) && 3710 (picture_size_table->height <= dim.height)) { 3711 ALOGV("%s: Camera Picture Size Table " 3712 "Max width: %d height %d table_size: %d", 3713 __func__, picture_size_table->width, 3714 picture_size_table->height, count+1); 3715 mPictureSizes[count].height = picture_size_table->height; 3716 mPictureSizes[count].width = picture_size_table->width; 3717 count++; 3718 } 3719 picture_size_table++; 3720 } 3721 mPictureSizeCount = count; 3722 3723 end: 3724 /* In case of error, we use default picture sizes */ 3725 if (ret != NO_ERROR) { 3726 mPictureSizes = default_picture_sizes; 3727 mPictureSizeCount = picture_table_size; 3728 } 3729 return ret; 3730 } 3731 3732 status_t QCameraHardwareInterface::setVideoSizeTable(void) 3733 { 3734 status_t ret = NO_ERROR; 3735 mm_camera_dimension_t dim; 3736 struct camera_size_type* video_size_table; 3737 int video_table_size; 3738 int i = 0, count = 0; 3739 ALOGV("%s: E", __func__); 3740 3741 /* Initialize table with default values */ 3742 video_table_size = video_sizes_count; 3743 video_size_table = default_video_sizes; 3744 mVideoSizes = 3745 (struct camera_size_type *)malloc(video_table_size * 3746 sizeof(struct camera_size_type)); 3747 if(mVideoSizes == NULL) { 3748 ALOGE("%s: error allocating memory to store video size table",__func__); 3749 ret = BAD_VALUE; 3750 goto end; 3751 } 3752 3753 /* Get maximum video size supported by sensor*/ 3754 memset(&dim, 0, sizeof(mm_camera_dimension_t)); 3755 ret = cam_config_get_parm(mCameraId, 3756 MM_CAMERA_PARM_MAX_VIDEO_SIZE, &dim); 3757 if(ret != NO_ERROR) { 3758 ALOGE("%s: error getting Max Video Size supported by camera", 3759 __func__); 3760 ret = NO_MEMORY; 3761 free(mVideoSizes); 3762 mVideoSizes = NULL; 3763 ret = BAD_VALUE; 3764 goto end; 3765 } 3766 3767 ALOGV("%s: Max Video Size Supported: %d X %d", __func__, 3768 dim.width, dim.height); 3769 3770 for(i=0; i < video_table_size; i++) { 3771 /* We'll store those dimensions whose width AND height 3772 are less than or equal to maximum supported */ 3773 if((video_size_table->width <= dim.width) && 3774 (video_size_table->height <= dim.height)) { 3775 ALOGV("%s: Supported Video Size [%d] = %dx%d", __func__, count, video_size_table->width, 3776 video_size_table->height); 3777 mVideoSizes[count].height = video_size_table->height; 3778 mVideoSizes[count].width = video_size_table->width; 3779 count++; 3780 } 3781 video_size_table++; 3782 } 3783 mVideoSizeCount = count; 3784 3785 end: 3786 ALOGV("%s: X", __func__); 3787 return ret; 3788 } 3789 3790 void QCameraHardwareInterface::freeVideoSizeTable(void) 3791 { 3792 if(mVideoSizes != NULL) 3793 { 3794 free(mVideoSizes); 3795 } 3796 mVideoSizeCount = 0; 3797 } 3798 3799 3800 void QCameraHardwareInterface::freePictureTable(void) 3801 { 3802 /* If we couldn't allocate memory to store picture table 3803 we use the picture table pointer to point to default 3804 picture table array. In that case we cannot free it.*/ 3805 if ((mPictureSizes != default_picture_sizes) && mPictureSizes) { 3806 free(mPictureSizes); 3807 } 3808 } 3809 3810 status_t QCameraHardwareInterface::setHistogram(int histogram_en) 3811 { 3812 ALOGV("setHistogram: E"); 3813 if(mStatsOn == histogram_en) { 3814 return NO_ERROR; 3815 } 3816 3817 mSendData = histogram_en; 3818 mStatsOn = histogram_en; 3819 mCurrentHisto = -1; 3820 mStatSize = sizeof(uint32_t)* HISTOGRAM_STATS_SIZE; 3821 3822 if (histogram_en == QCAMERA_PARM_ENABLE) { 3823 /*Currently the Ashmem is multiplying the buffer size with total number 3824 of buffers and page aligning. This causes a crash in JNI as each buffer 3825 individually expected to be page aligned */ 3826 int page_size_minus_1 = getpagesize() - 1; 3827 int statSize = sizeof (camera_preview_histogram_info ); 3828 int32_t mAlignedStatSize = ((statSize + page_size_minus_1) & (~page_size_minus_1)); 3829 #if 0 3830 mStatHeap = 3831 new AshmemPool(mAlignedStatSize, 3, statSize, "stat"); 3832 if (!mStatHeap->initialized()) { 3833 ALOGE("Stat Heap X failed "); 3834 mStatHeap.clear(); 3835 mStatHeap = NULL; 3836 return UNKNOWN_ERROR; 3837 } 3838 #endif 3839 for(int cnt = 0; cnt<3; cnt++) { 3840 mStatsMapped[cnt]=mGetMemory(-1, mStatSize, 1, mCallbackCookie); 3841 if(mStatsMapped[cnt] == NULL) { 3842 ALOGE("Failed to get camera memory for stats heap index: %d", cnt); 3843 return(-1); 3844 } else { 3845 ALOGV("Received following info for stats mapped data:%p,handle:%p, size:%d,release:%p", 3846 mStatsMapped[cnt]->data ,mStatsMapped[cnt]->handle, mStatsMapped[cnt]->size, mStatsMapped[cnt]->release); 3847 } 3848 mHistServer.size = sizeof(camera_preview_histogram_info); 3849 #ifdef USE_ION 3850 if(allocate_ion_memory(&mHistServer, cnt, ION_IOMMU_HEAP_ID) < 0) { 3851 ALOGE("%s ION alloc failed\n", __func__); 3852 return -1; 3853 } 3854 #else 3855 mHistServer.fd[cnt] = open("/dev/pmem_adsp", O_RDWR|O_SYNC); 3856 if(mHistServer.fd[cnt] <= 0) { 3857 ALOGE("%s: no pmem for frame %d", __func__, cnt); 3858 return -1; 3859 } 3860 #endif 3861 mHistServer.camera_memory[cnt]=mGetMemory(mHistServer.fd[cnt],mHistServer.size, 1, mCallbackCookie); 3862 if(mHistServer.camera_memory[cnt] == NULL) { 3863 ALOGE("Failed to get camera memory for server side histogram index: %d", cnt); 3864 return(-1); 3865 } else { 3866 ALOGV("Received following info for server side histogram data:%p,handle:%p, size:%d,release:%p", 3867 mHistServer.camera_memory[cnt]->data ,mHistServer.camera_memory[cnt]->handle, 3868 mHistServer.camera_memory[cnt]->size, mHistServer.camera_memory[cnt]->release); 3869 } 3870 /*Register buffer at back-end*/ 3871 if (NO_ERROR != sendMappingBuf(0, cnt, mHistServer.fd[cnt], 3872 mHistServer.size, mCameraId, 3873 CAM_SOCK_MSG_TYPE_HIST_MAPPING)) { 3874 ALOGE("%s could not send buffer to back-end\n", __func__); 3875 } 3876 } 3877 } 3878 ALOGV("Setting histogram = %d", histogram_en); 3879 native_set_parms(MM_CAMERA_PARM_HISTOGRAM, sizeof(int), &histogram_en); 3880 if(histogram_en == QCAMERA_PARM_DISABLE) 3881 { 3882 //release memory 3883 for(int i=0; i<3; i++){ 3884 if(mStatsMapped[i] != NULL) { 3885 mStatsMapped[i]->release(mStatsMapped[i]); 3886 } 3887 /*Unregister buffer at back-end */ 3888 if (NO_ERROR != sendUnMappingBuf(0, i, mCameraId, CAM_SOCK_MSG_TYPE_HIST_UNMAPPING)) { 3889 ALOGE("%s could not unregister buffer from back-end\n", __func__); 3890 } 3891 if(mHistServer.camera_memory[i] != NULL) { 3892 mHistServer.camera_memory[i]->release(mHistServer.camera_memory[i]); 3893 } 3894 close(mHistServer.fd[i]); 3895 #ifdef USE_ION 3896 deallocate_ion_memory(&mHistServer, i); 3897 #endif 3898 } 3899 } 3900 return NO_ERROR; 3901 } 3902 3903 status_t QCameraHardwareInterface::setZSLBurstLookBack(const QCameraParameters& params) 3904 { 3905 const char *v = params.get("capture-burst-retroactive"); 3906 if (v) { 3907 int look_back = atoi(v); 3908 ALOGV("%s: look_back =%d", __func__, look_back); 3909 mParameters.set("capture-burst-retroactive", look_back); 3910 } 3911 return NO_ERROR; 3912 } 3913 3914 status_t QCameraHardwareInterface::setZSLBurstInterval(const QCameraParameters& params) 3915 { 3916 mZslInterval = BURST_INTREVAL_DEFAULT; 3917 const char *v = params.get("capture-burst-interval"); 3918 if (v) { 3919 int interval = atoi(v); 3920 ALOGV("%s: Interval =%d", __func__, interval); 3921 if(interval < BURST_INTREVAL_MIN ||interval > BURST_INTREVAL_MAX ) { 3922 return BAD_VALUE; 3923 } 3924 mZslInterval = interval; 3925 } 3926 return NO_ERROR; 3927 } 3928 3929 int QCameraHardwareInterface::getZSLBurstInterval( void ) 3930 { 3931 int val; 3932 3933 if (mZslInterval == BURST_INTREVAL_DEFAULT) { 3934 char prop[PROPERTY_VALUE_MAX]; 3935 memset(prop, 0, sizeof(prop)); 3936 property_get("persist.camera.zsl.interval", prop, "1"); 3937 val = atoi(prop); 3938 ALOGV("%s: prop interval = %d", __func__, val); 3939 } else { 3940 val = mZslInterval; 3941 } 3942 return val; 3943 } 3944 3945 3946 int QCameraHardwareInterface::getZSLQueueDepth(void) const 3947 { 3948 char prop[PROPERTY_VALUE_MAX]; 3949 memset(prop, 0, sizeof(prop)); 3950 property_get("persist.camera.zsl.queuedepth", prop, "2"); 3951 ALOGV("%s: prop = %d", __func__, atoi(prop)); 3952 return atoi(prop); 3953 } 3954 3955 int QCameraHardwareInterface::getZSLBackLookCount(void) const 3956 { 3957 int look_back; 3958 char prop[PROPERTY_VALUE_MAX]; 3959 memset(prop, 0, sizeof(prop)); 3960 property_get("persist.camera.zsl.backlookcnt", prop, "0"); 3961 ALOGV("%s: prop = %d", __func__, atoi(prop)); 3962 look_back = atoi(prop); 3963 if (look_back == 0 ) { 3964 look_back = mParameters.getInt("capture-burst-retroactive"); 3965 ALOGV("%s: look_back = %d", __func__, look_back); 3966 } 3967 return look_back; 3968 } 3969 3970 bool QCameraHardwareInterface::getFlashCondition(void) 3971 { 3972 int32_t rc = 0; 3973 bool flash_cond = false; 3974 aec_info_for_flash_t lowLightForZSL; 3975 3976 lowLightForZSL.aec_index_for_zsl = 0; 3977 lowLightForZSL.zsl_flash_enable = 0; 3978 3979 if(myMode & CAMERA_ZSL_MODE){ 3980 switch(mLedStatusForZsl) { 3981 case LED_MODE_ON: 3982 flash_cond = true; 3983 break; 3984 case LED_MODE_AUTO: 3985 rc = cam_config_get_parm(mCameraId, 3986 MM_CAMERA_GET_PARM_LOW_LIGHT_FOR_ZSL, &lowLightForZSL); 3987 if(MM_CAMERA_OK == rc) { 3988 if(lowLightForZSL.zsl_flash_enable != 0) 3989 flash_cond = true; 3990 else 3991 flash_cond = false; 3992 } 3993 else 3994 ALOGE("%s: Failed to get lowLightForZSL, rc %d", __func__, rc); 3995 break; 3996 default: 3997 break; 3998 } 3999 } 4000 4001 ALOGV("%s: myMode %d, flash mode %d, flash condition %d", 4002 __func__, myMode, mLedStatusForZsl, flash_cond); 4003 return flash_cond; 4004 } 4005 4006 //EXIF functions 4007 void QCameraHardwareInterface::deinitExifData() 4008 { 4009 ALOGV("Clearing EXIF data"); 4010 for(int i=0; i<MAX_EXIF_TABLE_ENTRIES; i++) 4011 { 4012 //clear all data 4013 memset(&mExifData[i], 0x00, sizeof(exif_tags_info_t)); 4014 } 4015 mExifTableNumEntries = 0; 4016 } 4017 4018 void QCameraHardwareInterface::addExifTag(exif_tag_id_t tagid, exif_tag_type_t type, 4019 uint32_t count, uint8_t copy, void *data) { 4020 4021 if(mExifTableNumEntries >= MAX_EXIF_TABLE_ENTRIES) { 4022 ALOGE("%s: Number of entries exceeded limit", __func__); 4023 return; 4024 } 4025 int index = mExifTableNumEntries; 4026 mExifData[index].tag_id = tagid; 4027 mExifData[index].tag_entry.type = type; 4028 mExifData[index].tag_entry.count = count; 4029 mExifData[index].tag_entry.copy = copy; 4030 if((type == EXIF_RATIONAL) && (count > 1)) 4031 mExifData[index].tag_entry.data._rats = (rat_t *)data; 4032 if((type == EXIF_RATIONAL) && (count == 1)) 4033 mExifData[index].tag_entry.data._rat = *(rat_t *)data; 4034 else if(type == EXIF_ASCII) 4035 mExifData[index].tag_entry.data._ascii = (char *)data; 4036 else if(type == EXIF_BYTE) 4037 mExifData[index].tag_entry.data._byte = *(uint8_t *)data; 4038 else if((type == EXIF_SHORT) && (count > 1)) 4039 mExifData[index].tag_entry.data._shorts = (uint16_t *)data; 4040 else if((type == EXIF_SHORT) && (count == 1)) 4041 mExifData[index].tag_entry.data._short = *(uint16_t *)data; 4042 // Increase number of entries 4043 mExifTableNumEntries++; 4044 } 4045 4046 void QCameraHardwareInterface::initExifData(){ 4047 short val_short; 4048 char value[PROPERTY_VALUE_MAX]; 4049 if (property_get("ro.product.manufacturer", value, "QCOM-AA") > 0) { 4050 strncpy(mExifValues.make, value, 19); 4051 mExifValues.make[19] = '\0'; 4052 addExifTag(EXIFTAGID_MAKE, EXIF_ASCII, strlen(value) + 1, 1, (void *)mExifValues.make); 4053 } else { 4054 ALOGE("%s: getExifMaker failed", __func__); 4055 } 4056 4057 if (property_get("ro.product.model", value, "QCAM-AA") > 0) { 4058 strncpy(mExifValues.model, value, 19); 4059 mExifValues.model[19] = '\0'; 4060 addExifTag(EXIFTAGID_MODEL, EXIF_ASCII, strlen(value) + 1, 1, (void *)mExifValues.model); 4061 } else { 4062 ALOGE("%s: getExifModel failed", __func__); 4063 } 4064 4065 if(mExifValues.dateTime) { 4066 addExifTag(EXIFTAGID_EXIF_DATE_TIME_ORIGINAL, EXIF_ASCII, 4067 20, 1, (void *)mExifValues.dateTime); 4068 addExifTag(EXIFTAGID_EXIF_DATE_TIME_DIGITIZED, EXIF_ASCII, 4069 20, 1, (void *)mExifValues.dateTime); 4070 } 4071 addExifTag(EXIFTAGID_FOCAL_LENGTH, EXIF_RATIONAL, 1, 1, (void *)&(mExifValues.focalLength)); 4072 addExifTag(EXIFTAGID_ISO_SPEED_RATING,EXIF_SHORT,1,1,(void *)&(mExifValues.isoSpeed)); 4073 4074 // normal f_number is from 1.2 to 22, but I'd like to put some margin. 4075 if(mExifValues.f_number.num>0 && mExifValues.f_number.num<3200) { 4076 addExifTag(EXIFTAGID_F_NUMBER,EXIF_RATIONAL,1,1,(void *)&(mExifValues.f_number)); 4077 addExifTag(EXIFTAGID_APERTURE,EXIF_RATIONAL,1,1,(void *)&(mExifValues.f_number)); 4078 } 4079 4080 4081 if(mExifValues.mGpsProcess) { 4082 addExifTag(EXIFTAGID_GPS_PROCESSINGMETHOD, EXIF_ASCII, 4083 EXIF_ASCII_PREFIX_SIZE + strlen(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE) + 1, 4084 1, (void *)mExifValues.gpsProcessingMethod); 4085 } 4086 4087 if(mExifValues.mLatitude) { 4088 addExifTag(EXIFTAGID_GPS_LATITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.latitude); 4089 4090 if(mExifValues.latRef) { 4091 addExifTag(EXIFTAGID_GPS_LATITUDE_REF, EXIF_ASCII, 2, 4092 1, (void *)mExifValues.latRef); 4093 } 4094 } 4095 4096 if(mExifValues.mLongitude) { 4097 addExifTag(EXIFTAGID_GPS_LONGITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.longitude); 4098 4099 if(mExifValues.lonRef) { 4100 addExifTag(EXIFTAGID_GPS_LONGITUDE_REF, EXIF_ASCII, 2, 4101 1, (void *)mExifValues.lonRef); 4102 } 4103 } 4104 4105 if(mExifValues.mAltitude) { 4106 addExifTag(EXIFTAGID_GPS_ALTITUDE, EXIF_RATIONAL, 1, 4107 1, (void *)&(mExifValues.altitude)); 4108 4109 addExifTag(EXIFTAGID_GPS_ALTITUDE_REF, EXIF_BYTE, 1, 1, (void *)&mExifValues.mAltitude_ref); 4110 } 4111 4112 if(mExifValues.mTimeStamp) { 4113 time_t unixTime; 4114 struct tm *UTCTimestamp; 4115 4116 unixTime = (time_t)mExifValues.mGPSTimestamp; 4117 UTCTimestamp = gmtime(&unixTime); 4118 4119 strftime(mExifValues.gpsDateStamp, sizeof(mExifValues.gpsDateStamp), "%Y:%m:%d", UTCTimestamp); 4120 addExifTag(EXIFTAGID_GPS_DATESTAMP, EXIF_ASCII, 4121 strlen(mExifValues.gpsDateStamp)+1 , 1, (void *)mExifValues.gpsDateStamp); 4122 4123 mExifValues.gpsTimeStamp[0] = getRational(UTCTimestamp->tm_hour, 1); 4124 mExifValues.gpsTimeStamp[1] = getRational(UTCTimestamp->tm_min, 1); 4125 mExifValues.gpsTimeStamp[2] = getRational(UTCTimestamp->tm_sec, 1); 4126 4127 addExifTag(EXIFTAGID_GPS_TIMESTAMP, EXIF_RATIONAL, 4128 3, 1, (void *)mExifValues.gpsTimeStamp); 4129 ALOGV("EXIFTAGID_GPS_TIMESTAMP set"); 4130 } 4131 if(mExifValues.exposure_time.num || mExifValues.exposure_time.denom) 4132 addExifTag(EXIFTAGID_EXPOSURE_TIME, EXIF_RATIONAL, 1, 1, (void *)&mExifValues.exposure_time); 4133 4134 bool flashCondition = getFlashCondition(); 4135 addExifTag(EXIFTAGID_FLASH, EXIF_SHORT, 1, 1, &flashCondition); 4136 if (mExifValues.mWbMode == CAMERA_WB_AUTO) 4137 val_short = 0; 4138 else 4139 val_short = 1; 4140 addExifTag(EXIFTAGID_WHITE_BALANCE, EXIF_SHORT, 1, 1, &val_short); 4141 4142 addExifTag(EXIFTAGID_SUBSEC_TIME, EXIF_ASCII, 7, 1, (void *)mExifValues.subsecTime); 4143 4144 addExifTag(EXIFTAGID_SUBSEC_TIME_ORIGINAL, EXIF_ASCII, 7, 1, (void *)mExifValues.subsecTime); 4145 4146 addExifTag(EXIFTAGID_SUBSEC_TIME_DIGITIZED, EXIF_ASCII, 7, 1, (void *)mExifValues.subsecTime); 4147 } 4148 4149 //Add all exif tags in this function 4150 void QCameraHardwareInterface::setExifTags() 4151 { 4152 const char *str; 4153 4154 //set TimeStamp 4155 str = mParameters.get(QCameraParameters::KEY_EXIF_DATETIME); 4156 if(str != NULL) { 4157 strncpy(mExifValues.dateTime, str, 19); 4158 mExifValues.dateTime[19] = '\0'; 4159 } 4160 4161 //Set focal length 4162 int focalLengthValue = (int) (mParameters.getFloat( 4163 QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION); 4164 4165 mExifValues.focalLength = getRational(focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION); 4166 4167 focus_distances_info_t focusDistances; 4168 status_t rc = NO_ERROR; 4169 rc = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_FOCAL_LENGTH,(void *)&focusDistances); 4170 if (rc == MM_CAMERA_OK){ 4171 uint16_t temp1; 4172 rat_t temp; 4173 if(mIsoValue == 0) // ISO is auto 4174 { 4175 temp1 = (uint16_t)(focusDistances.real_gain + 0.5)*100; 4176 mExifValues.isoSpeed = temp1; 4177 ALOGV("The new ISO value is %d", temp1); 4178 } 4179 else{ 4180 temp1 = iso_speed_values[mIsoValue]; 4181 mExifValues.isoSpeed = temp1; 4182 ALOGV("else The new ISO value is %d", temp1); 4183 } 4184 4185 if(focusDistances.exp_time <= 0) // avoid zero-divide problem 4186 focusDistances.exp_time = 0.01668; // expoure time will be 1/60 s 4187 4188 uint16_t temp2 = (uint16_t)(focusDistances.exp_time * 100000); 4189 temp2 = (uint16_t)(100000 / temp2); 4190 temp.num = 1; 4191 temp.denom = temp2; 4192 memcpy(&mExifValues.exposure_time, &temp, sizeof(mExifValues.exposure_time)); 4193 ALOGV(" The exposure value is %f", temp2); 4194 } 4195 //get time and date from system 4196 time_t rawtime; 4197 struct tm * timeinfo; 4198 time(&rawtime); 4199 timeinfo = localtime (&rawtime); 4200 //Write datetime according to EXIF Spec 4201 //"YYYY:MM:DD HH:MM:SS" (20 chars including \0) 4202 snprintf(mExifValues.dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d", 4203 timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, 4204 timeinfo->tm_mday, timeinfo->tm_hour, 4205 timeinfo->tm_min, timeinfo->tm_sec); 4206 //set gps tags 4207 4208 struct timeval tv; 4209 gettimeofday(&tv, NULL); 4210 snprintf(mExifValues.subsecTime, 7, "%06ld", tv.tv_usec); 4211 4212 mExifValues.mWbMode = mParameters.getInt(QCameraParameters::KEY_WHITE_BALANCE); 4213 setExifTagsGPS(); 4214 } 4215 4216 void QCameraHardwareInterface::setExifTagsGPS() 4217 { 4218 const char *str = NULL; 4219 4220 //Set GPS processing method 4221 str = mParameters.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD); 4222 if(str != NULL) { 4223 memcpy(mExifValues.gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE); 4224 strncpy(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str, 4225 GPS_PROCESSING_METHOD_SIZE - 1); 4226 mExifValues.gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE + GPS_PROCESSING_METHOD_SIZE-1] = '\0'; 4227 ALOGV("EXIFTAGID_GPS_PROCESSINGMETHOD = %s %s", mExifValues.gpsProcessingMethod, 4228 mExifValues.gpsProcessingMethod+8); 4229 mExifValues.mGpsProcess = true; 4230 }else{ 4231 mExifValues.mGpsProcess = false; 4232 } 4233 str = NULL; 4234 4235 //Set Latitude 4236 str = mParameters.get(QCameraParameters::KEY_GPS_LATITUDE); 4237 if(str != NULL) { 4238 parseGPSCoordinate(str, mExifValues.latitude); 4239 ALOGV("EXIFTAGID_GPS_LATITUDE = %s", str); 4240 4241 //set Latitude Ref 4242 float latitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LATITUDE); 4243 if(latitudeValue < 0.0f) { 4244 mExifValues.latRef[0] = 'S'; 4245 } else { 4246 mExifValues.latRef[0] = 'N'; 4247 } 4248 mExifValues.latRef[1] = '\0'; 4249 mExifValues.mLatitude = true; 4250 mParameters.set(QCameraParameters::KEY_GPS_LATITUDE_REF,mExifValues.latRef); 4251 ALOGV("EXIFTAGID_GPS_LATITUDE_REF = %s", mExifValues.latRef); 4252 }else{ 4253 mExifValues.mLatitude = false; 4254 } 4255 4256 //set Longitude 4257 str = NULL; 4258 str = mParameters.get(QCameraParameters::KEY_GPS_LONGITUDE); 4259 if(str != NULL) { 4260 parseGPSCoordinate(str, mExifValues.longitude); 4261 ALOGV("EXIFTAGID_GPS_LONGITUDE = %s", str); 4262 4263 //set Longitude Ref 4264 float longitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LONGITUDE); 4265 if(longitudeValue < 0.0f) { 4266 mExifValues.lonRef[0] = 'W'; 4267 } else { 4268 mExifValues.lonRef[0] = 'E'; 4269 } 4270 mExifValues.lonRef[1] = '\0'; 4271 mExifValues.mLongitude = true; 4272 ALOGV("EXIFTAGID_GPS_LONGITUDE_REF = %s", mExifValues.lonRef); 4273 mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE_REF, mExifValues.lonRef); 4274 }else{ 4275 mExifValues.mLongitude = false; 4276 } 4277 4278 //set Altitude 4279 str = mParameters.get(QCameraParameters::KEY_GPS_ALTITUDE); 4280 if(str != NULL) { 4281 double value = atof(str); 4282 mExifValues.mAltitude_ref = 0; 4283 if(value < 0){ 4284 mExifValues.mAltitude_ref = 1; 4285 value = -value; 4286 } 4287 mExifValues.altitude = getRational(value*1000, 1000); 4288 mExifValues.mAltitude = true; 4289 //set AltitudeRef 4290 mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE_REF, mExifValues.mAltitude_ref); 4291 ALOGV("EXIFTAGID_GPS_ALTITUDE = %f", value); 4292 }else{ 4293 mExifValues.mAltitude = false; 4294 } 4295 4296 //set Gps TimeStamp 4297 str = NULL; 4298 str = mParameters.get(QCameraParameters::KEY_GPS_TIMESTAMP); 4299 if(str != NULL) { 4300 mExifValues.mTimeStamp = true; 4301 mExifValues.mGPSTimestamp = atol(str); 4302 }else{ 4303 mExifValues.mTimeStamp = false; 4304 } 4305 } 4306 4307 //latlonString is string formatted coordinate 4308 //coord is rat_t[3] 4309 void QCameraHardwareInterface::parseGPSCoordinate(const char *latlonString, rat_t* coord) 4310 { 4311 if(coord == NULL) { 4312 ALOGE("%s: error, invalid argument coord == NULL", __func__); 4313 return; 4314 } 4315 float degF = fabs(atof(latlonString)); 4316 float minF = (degF- (int) degF) * 60; 4317 float secF = (minF - (int) minF) * 60; 4318 4319 coord[0] = getRational((int) degF, 1); 4320 coord[1] = getRational((int) minF, 1); 4321 coord[2] = getRational((int) (secF * 10000), 10000); 4322 } 4323 4324 bool QCameraHardwareInterface::isLowPowerCamcorder() { 4325 4326 if (mPowerMode == LOW_POWER) 4327 return true; 4328 4329 if(mHFRLevel > 1) /* hard code the value now. Need to move tgtcommon to camear.h */ 4330 return true; 4331 4332 return false; 4333 } 4334 4335 status_t QCameraHardwareInterface::setNoDisplayMode(const QCameraParameters& params) 4336 { 4337 char prop[PROPERTY_VALUE_MAX]; 4338 memset(prop, 0, sizeof(prop)); 4339 property_get("persist.camera.nodisplay", prop, "0"); 4340 int prop_val = atoi(prop); 4341 4342 if (prop_val == 0) { 4343 const char *str_val = params.get("no-display-mode"); 4344 if(str_val && strlen(str_val) > 0) { 4345 mNoDisplayMode = atoi(str_val); 4346 } else { 4347 mNoDisplayMode = 0; 4348 } 4349 ALOGV("Param mNoDisplayMode =%d", mNoDisplayMode); 4350 } else { 4351 mNoDisplayMode = prop_val; 4352 ALOGV("prop mNoDisplayMode =%d", mNoDisplayMode); 4353 } 4354 return NO_ERROR; 4355 } 4356 4357 status_t QCameraHardwareInterface::setCAFLockCancel(void) 4358 { 4359 ALOGV("%s : E", __func__); 4360 4361 //for CAF unlock 4362 if(MM_CAMERA_OK!=cam_ops_action(mCameraId,false,MM_CAMERA_OPS_FOCUS,NULL )) { 4363 ALOGE("%s: AF command failed err:%d error %s",__func__, errno,strerror(errno)); 4364 return -1; 4365 } 4366 4367 ALOGV("%s : X", __func__); 4368 return NO_ERROR; 4369 } 4370 4371 void QCameraHardwareInterface::prepareVideoPicture(bool disable){ 4372 String8 str; 4373 char buffer[32]; 4374 4375 if(disable) { 4376 sprintf(buffer, "%dx%d", mDimension.video_width, mDimension.video_height); 4377 str.append(buffer); 4378 4379 mParameters.setPictureSize(mDimension.video_width, mDimension.video_height); 4380 mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 4381 str.string()); 4382 ALOGV("%s: Video Picture size supported = %d X %d", 4383 __func__,mDimension.video_width,mDimension.video_height); 4384 }else{ 4385 //Set Picture Size 4386 mParameters.setPictureSize(mDimension.picture_width, mDimension.picture_height); 4387 mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 4388 mPictureSizeValues.string()); 4389 } 4390 } 4391 4392 }; /*namespace android */ 4393
