CameraHal.cpp revision f7a4d11e9f710e2cd0592310ac1baecccb85f1d1
1/* 2 * Copyright (C) Texas Instruments - http://www.ti.com/ 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/** 18* @file CameraHal.cpp 19* 20* This file maps the Camera Hardware Interface to V4L2. 21* 22*/ 23 24#include "CameraHal.h" 25#include "ANativeWindowDisplayAdapter.h" 26#include "BufferSourceAdapter.h" 27#include "TICameraParameters.h" 28#include "CameraProperties.h" 29#include <cutils/properties.h> 30 31#include <poll.h> 32#include <math.h> 33 34namespace Ti { 35namespace Camera { 36 37extern "C" CameraAdapter* OMXCameraAdapter_Factory(size_t); 38extern "C" CameraAdapter* V4LCameraAdapter_Factory(size_t); 39 40/*****************************************************************************/ 41 42////Constant definitions and declarations 43////@todo Have a CameraProperties class to store these parameters as constants for every camera 44//// Currently, they are hard-coded 45 46const int CameraHal::NO_BUFFERS_PREVIEW = MAX_CAMERA_BUFFERS; 47const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE = 5; 48const int CameraHal::SW_SCALING_FPS_LIMIT = 15; 49 50const uint32_t MessageNotifier::EVENT_BIT_FIELD_POSITION = 16; 51 52const uint32_t MessageNotifier::FRAME_BIT_FIELD_POSITION = 0; 53 54// TODO(XXX): Temporarily increase number of buffers we can allocate from ANW 55// until faux-NPA mode is implemented 56const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE_SYSTEM_HEAP = 15; 57 58#ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING 59// HACK: Default path to directory where RAW images coming from video port will be saved to. 60// If directory not exists the saving is skipped and video port frame is ignored. 61// The directory name is choosed in so weird way to enable RAW images saving only when 62// directory has been created explicitly by user. 63extern const char * const kRawImagesOutputDirPath = "/data/misc/camera/RaW_PiCtUrEs"; 64extern const char * const kYuvImagesOutputDirPath = "/data/misc/camera/YuV_PiCtUrEs"; 65#endif 66 67/******************************************************************************/ 68 69 70#ifdef OMAP_ENHANCEMENT_CPCAM 71static int dummy_update_and_get_buffer(preview_stream_ops_t*, buffer_handle_t**, int*) { 72 return INVALID_OPERATION; 73} 74 75static int dummy_get_buffer_dimension(preview_stream_ops_t*, int*, int*) { 76 return INVALID_OPERATION; 77} 78 79static int dummy_get_buffer_format(preview_stream_ops_t*, int*) { 80 return INVALID_OPERATION; 81} 82 83static int dummy_set_metadata(preview_stream_ops_t*, const camera_memory_t*) { 84 return INVALID_OPERATION; 85} 86 87static int dummy_get_id(preview_stream_ops_t*, char *data, unsigned int dataSize) { 88 return INVALID_OPERATION; 89} 90#endif 91 92#ifdef OMAP_ENHANCEMENT 93static preview_stream_extended_ops_t dummyPreviewStreamExtendedOps = { 94#ifdef OMAP_ENHANCEMENT_CPCAM 95 dummy_update_and_get_buffer, 96 dummy_get_buffer_dimension, 97 dummy_get_buffer_format, 98 dummy_set_metadata, 99 dummy_get_id, 100#endif 101}; 102#endif 103 104 105DisplayAdapter::DisplayAdapter() 106{ 107#ifdef OMAP_ENHANCEMENT 108 mExtendedOps = &dummyPreviewStreamExtendedOps; 109#endif 110} 111 112#ifdef OMAP_ENHANCEMENT 113void DisplayAdapter::setExtendedOps(preview_stream_extended_ops_t * extendedOps) { 114 mExtendedOps = extendedOps ? extendedOps : &dummyPreviewStreamExtendedOps; 115} 116#endif 117 118 119 120#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 121 122struct timeval CameraHal::mStartPreview; 123struct timeval CameraHal::mStartFocus; 124struct timeval CameraHal::mStartCapture; 125 126#endif 127 128static void orientation_cb(uint32_t orientation, uint32_t tilt, void* cookie) { 129 CameraHal *camera = NULL; 130 131 if (cookie) { 132 camera = (CameraHal*) cookie; 133 camera->onOrientationEvent(orientation, tilt); 134 } 135 136} 137 138/*-------------Camera Hal Interface Method definitions STARTS here--------------------*/ 139 140/** 141 Callback function to receive orientation events from SensorListener 142 */ 143void CameraHal::onOrientationEvent(uint32_t orientation, uint32_t tilt) { 144 LOG_FUNCTION_NAME; 145 146 if ( NULL != mCameraAdapter ) { 147 mCameraAdapter->onOrientationEvent(orientation, tilt); 148 } 149 150 LOG_FUNCTION_NAME_EXIT; 151} 152 153/** 154 @brief Set the notification and data callbacks 155 156 @param[in] notify_cb Notify callback for notifying the app about events and errors 157 @param[in] data_cb Buffer callback for sending the preview/raw frames to the app 158 @param[in] data_cb_timestamp Buffer callback for sending the video frames w/ timestamp 159 @param[in] user Callback cookie 160 @return none 161 162 */ 163void CameraHal::setCallbacks(camera_notify_callback notify_cb, 164 camera_data_callback data_cb, 165 camera_data_timestamp_callback data_cb_timestamp, 166 camera_request_memory get_memory, 167 void *user) 168{ 169 LOG_FUNCTION_NAME; 170 171 if ( NULL != mAppCallbackNotifier.get() ) 172 { 173 mAppCallbackNotifier->setCallbacks(this, 174 notify_cb, 175 data_cb, 176 data_cb_timestamp, 177 get_memory, 178 user); 179 } 180 181 if ( NULL != mCameraAdapter ) { 182 mCameraAdapter->setSharedAllocator(get_memory); 183 } 184 185 LOG_FUNCTION_NAME_EXIT; 186} 187 188/** 189 @brief Enable a message, or set of messages. 190 191 @param[in] msgtype Bitmask of the messages to enable (defined in include/ui/Camera.h) 192 @return none 193 194 */ 195void CameraHal::enableMsgType(int32_t msgType) 196{ 197 LOG_FUNCTION_NAME; 198 199 if ( ( msgType & CAMERA_MSG_SHUTTER ) && ( !mShutterEnabled ) ) 200 { 201 msgType &= ~CAMERA_MSG_SHUTTER; 202 } 203 204 // ignoring enable focus message from camera service 205 // we will enable internally in autoFocus call 206 msgType &= ~CAMERA_MSG_FOCUS; 207#ifdef ANDROID_API_JB_OR_LATER 208 msgType &= ~CAMERA_MSG_FOCUS_MOVE; 209#endif 210 211 { 212 android::AutoMutex lock(mLock); 213 mMsgEnabled |= msgType; 214 } 215 216 if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) 217 { 218 if(mDisplayPaused) 219 { 220 CAMHAL_LOGDA("Preview currently paused...will enable preview callback when restarted"); 221 msgType &= ~CAMERA_MSG_PREVIEW_FRAME; 222 }else 223 { 224 CAMHAL_LOGDA("Enabling Preview Callback"); 225 } 226 } 227 else 228 { 229 CAMHAL_LOGDB("Preview callback not enabled %x", msgType); 230 } 231 232 233 ///Configure app callback notifier with the message callback required 234 mAppCallbackNotifier->enableMsgType (msgType); 235 236 LOG_FUNCTION_NAME_EXIT; 237} 238 239/** 240 @brief Disable a message, or set of messages. 241 242 @param[in] msgtype Bitmask of the messages to disable (defined in include/ui/Camera.h) 243 @return none 244 245 */ 246void CameraHal::disableMsgType(int32_t msgType) 247{ 248 LOG_FUNCTION_NAME; 249 250 { 251 android::AutoMutex lock(mLock); 252 mMsgEnabled &= ~msgType; 253 } 254 255 if( msgType & CAMERA_MSG_PREVIEW_FRAME) 256 { 257 CAMHAL_LOGDA("Disabling Preview Callback"); 258 } 259 260 ///Configure app callback notifier 261 mAppCallbackNotifier->disableMsgType (msgType); 262 263 LOG_FUNCTION_NAME_EXIT; 264} 265 266/** 267 @brief Query whether a message, or a set of messages, is enabled. 268 269 Note that this is operates as an AND, if any of the messages queried are off, this will 270 return false. 271 272 @param[in] msgtype Bitmask of the messages to query (defined in include/ui/Camera.h) 273 @return true If all message types are enabled 274 false If any message type 275 276 */ 277int CameraHal::msgTypeEnabled(int32_t msgType) 278{ 279 int32_t msgEnabled = 0; 280 281 LOG_FUNCTION_NAME; 282 android::AutoMutex lock(mLock); 283 284 msgEnabled = mMsgEnabled; 285 if (!previewEnabled() && !mPreviewInitializationDone) { 286 msgEnabled &= ~(CAMERA_MSG_PREVIEW_FRAME | CAMERA_MSG_PREVIEW_METADATA); 287 } 288 289 LOG_FUNCTION_NAME_EXIT; 290 return (msgEnabled & msgType); 291} 292 293/** 294 @brief Set the camera parameters. 295 296 @param[in] params Camera parameters to configure the camera 297 @return NO_ERROR 298 @todo Define error codes 299 300 */ 301int CameraHal::setParameters(const char* parameters) 302{ 303 304 LOG_FUNCTION_NAME; 305 306 android::CameraParameters params; 307 308 android::String8 str_params(parameters); 309 params.unflatten(str_params); 310 311 LOG_FUNCTION_NAME_EXIT; 312 313 return setParameters(params); 314} 315 316/** 317 @brief Set the camera parameters. 318 319 @param[in] params Camera parameters to configure the camera 320 @return NO_ERROR 321 @todo Define error codes 322 323 */ 324int CameraHal::setParameters(const android::CameraParameters& params) 325{ 326 327 LOG_FUNCTION_NAME; 328 329 int w, h; 330 int framerate; 331 int maxFPS, minFPS; 332 const char *valstr = NULL; 333 int varint = 0; 334 status_t ret = NO_ERROR; 335 // Needed for KEY_RECORDING_HINT 336 bool restartPreviewRequired = false; 337 bool updateRequired = false; 338 android::CameraParameters oldParams = mParameters; 339 340#ifdef V4L_CAMERA_ADAPTER 341 if (strcmp (V4L_CAMERA_NAME_USB, mCameraProperties->get(CameraProperties::CAMERA_NAME)) == 0 ) { 342 updateRequired = true; 343 } 344#endif 345 346 { 347 android::AutoMutex lock(mLock); 348 349 ///Ensure that preview is not enabled when the below parameters are changed. 350 if(!previewEnabled()) 351 { 352 if ((valstr = params.getPreviewFormat()) != NULL) { 353 if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS))) { 354 mParameters.setPreviewFormat(valstr); 355 CAMHAL_LOGDB("PreviewFormat set %s", valstr); 356 } else { 357 CAMHAL_LOGEB("Invalid preview format: %s. Supported: %s", valstr, 358 mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); 359 return BAD_VALUE; 360 } 361 } 362 363 if ((valstr = params.get(TICameraParameters::KEY_VNF)) != NULL) { 364 if (strcmp(mCameraProperties->get(CameraProperties::VNF_SUPPORTED), 365 android::CameraParameters::TRUE) == 0) { 366 CAMHAL_LOGDB("VNF %s", valstr); 367 mParameters.set(TICameraParameters::KEY_VNF, valstr); 368 } else if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { 369 CAMHAL_LOGEB("ERROR: Invalid VNF: %s", valstr); 370 return BAD_VALUE; 371 } else { 372 mParameters.set(TICameraParameters::KEY_VNF, 373 android::CameraParameters::FALSE); 374 } 375 } 376 377 if ((valstr = params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION)) != NULL) { 378 // make sure we support vstab...if we don't and application is trying to set 379 // vstab then return an error 380 if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED), 381 android::CameraParameters::TRUE) == 0) { 382 CAMHAL_LOGDB("VSTAB %s", valstr); 383 mParameters.set(android::CameraParameters::KEY_VIDEO_STABILIZATION, valstr); 384 } else if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { 385 CAMHAL_LOGEB("ERROR: Invalid VSTAB: %s", valstr); 386 return BAD_VALUE; 387 } else { 388 mParameters.set(android::CameraParameters::KEY_VIDEO_STABILIZATION, 389 android::CameraParameters::FALSE); 390 } 391 } 392 393 if( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL) { 394 395 if (strcmp(TICameraParameters::VIDEO_MODE, valstr)) { 396 mCapModeBackup = valstr; 397 } 398 399 CAMHAL_LOGDB("Capture mode set %s", valstr); 400 401 const char *currentMode = mParameters.get(TICameraParameters::KEY_CAP_MODE); 402 if ( NULL != currentMode ) { 403 if ( strcmp(currentMode, valstr) != 0 ) { 404 updateRequired = true; 405 } 406 } else { 407 updateRequired = true; 408 } 409 410 mParameters.set(TICameraParameters::KEY_CAP_MODE, valstr); 411 } else if (!mCapModeBackup.isEmpty()) { 412 // Restore previous capture mode after stopPreview() 413 mParameters.set(TICameraParameters::KEY_CAP_MODE, 414 mCapModeBackup.string()); 415 updateRequired = true; 416 } 417 418#ifdef OMAP_ENHANCEMENT_VTC 419 if ((valstr = params.get(TICameraParameters::KEY_VTC_HINT)) != NULL ) { 420 mParameters.set(TICameraParameters::KEY_VTC_HINT, valstr); 421 if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { 422 mVTCUseCase = true; 423 } else { 424 mVTCUseCase = false; 425 } 426 CAMHAL_LOGDB("VTC Hint = %d", mVTCUseCase); 427 } 428 429 if (mVTCUseCase) { 430 if ((valstr = params.get(TICameraParameters::KEY_VIDEO_ENCODER_HANDLE)) != NULL ) { 431 mParameters.set(TICameraParameters::KEY_VIDEO_ENCODER_HANDLE, valstr); 432 } 433 434 if ((valstr = params.get(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT)) != NULL ) { 435 mParameters.set(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT, valstr); 436 } 437 } 438#endif 439 } 440 441 if ((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL) { 442 if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES))) { 443 if (strcmp(valstr, mParameters.get(TICameraParameters::KEY_IPP))) { 444 CAMHAL_LOGDB("IPP mode set %s", params.get(TICameraParameters::KEY_IPP)); 445 mParameters.set(TICameraParameters::KEY_IPP, valstr); 446 restartPreviewRequired = true; 447 } 448 } else { 449 CAMHAL_LOGEB("ERROR: Invalid IPP mode: %s", valstr); 450 return BAD_VALUE; 451 } 452 } 453 454 if ( (valstr = params.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT)) != NULL ) 455 { 456 if (strcmp(valstr, mParameters.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT))) 457 { 458 CAMHAL_LOGDB("Stereo 3D preview image layout is %s", valstr); 459 mParameters.set(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT, valstr); 460 restartPreviewRequired = true; 461 } 462 } 463 464#ifdef OMAP_ENHANCEMENT 465 int orientation =0; 466 if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL) 467 { 468 doesSetParameterNeedUpdate(valstr, 469 mParameters.get(TICameraParameters::KEY_SENSOR_ORIENTATION), 470 updateRequired); 471 472 orientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION); 473 if ( orientation < 0 || orientation >= 360 || (orientation%90) != 0 ) { 474 CAMHAL_LOGE("Invalid sensor orientation: %s. Value must be one of: [0, 90, 180, 270]", valstr); 475 return BAD_VALUE; 476 } 477 478 CAMHAL_LOGD("Sensor Orientation is set to %d", orientation); 479 mParameters.set(TICameraParameters::KEY_SENSOR_ORIENTATION, valstr); 480 } 481#endif 482 483 params.getPreviewSize(&w, &h); 484 if (w == -1 && h == -1) { 485 CAMHAL_LOGEA("Unable to get preview size"); 486 return BAD_VALUE; 487 } 488 489 mVideoWidth = w; 490 mVideoHeight = h; 491 492 // Handle RECORDING_HINT to Set/Reset Video Mode Parameters 493 valstr = params.get(android::CameraParameters::KEY_RECORDING_HINT); 494 if(valstr != NULL) 495 { 496 CAMHAL_LOGDB("Recording Hint is set to %s", valstr); 497 if(strcmp(valstr, android::CameraParameters::TRUE) == 0) 498 { 499 CAMHAL_LOGVB("Video Resolution: %d x %d", mVideoWidth, mVideoHeight); 500#ifdef OMAP_ENHANCEMENT_VTC 501 if (!mVTCUseCase) 502#endif 503 { 504 int maxFPS, minFPS; 505 506 params.getPreviewFpsRange(&minFPS, &maxFPS); 507 maxFPS /= CameraHal::VFR_SCALE; 508 if ( ( maxFPS <= SW_SCALING_FPS_LIMIT ) ) { 509 getPreferredPreviewRes(&w, &h); 510 } 511 } 512 mParameters.set(android::CameraParameters::KEY_RECORDING_HINT, valstr); 513 restartPreviewRequired |= setVideoModeParameters(params); 514 } 515 else if(strcmp(valstr, android::CameraParameters::FALSE) == 0) 516 { 517 mParameters.set(android::CameraParameters::KEY_RECORDING_HINT, valstr); 518 restartPreviewRequired |= resetVideoModeParameters(); 519 } 520 else 521 { 522 CAMHAL_LOGEA("Invalid RECORDING_HINT"); 523 return BAD_VALUE; 524 } 525 } 526 else 527 { 528 // This check is required in following case. 529 // If VideoRecording activity sets KEY_RECORDING_HINT to TRUE and 530 // ImageCapture activity doesnot set KEY_RECORDING_HINT to FALSE (i.e. simply NULL), 531 // then Video Mode parameters may remain present in ImageCapture activity as well. 532 CAMHAL_LOGDA("Recording Hint is set to NULL"); 533 mParameters.set(android::CameraParameters::KEY_RECORDING_HINT, ""); 534 restartPreviewRequired |= resetVideoModeParameters(); 535 } 536 537 if ( (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) 538 && (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SUBSAMPLED_SIZES))) 539 && (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES))) 540 && (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_TOPBOTTOM_SIZES))) ) { 541 CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h); 542 return BAD_VALUE; 543 } 544 545 int oldWidth, oldHeight; 546 mParameters.getPreviewSize(&oldWidth, &oldHeight); 547 if ( ( oldWidth != w ) || ( oldHeight != h ) ) 548 { 549 mParameters.setPreviewSize(w, h); 550 restartPreviewRequired = true; 551 } 552 553 CAMHAL_LOGDB("Preview Resolution: %d x %d", w, h); 554 555 if ((valstr = params.get(android::CameraParameters::KEY_FOCUS_MODE)) != NULL) { 556 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES))) { 557 CAMHAL_LOGDB("Focus mode set %s", valstr); 558 559 // we need to take a decision on the capture mode based on whether CAF picture or 560 // video is chosen so the behavior of each is consistent to the application 561 if(strcmp(valstr, android::CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0){ 562 restartPreviewRequired |= resetVideoModeParameters(); 563 } else if (strcmp(valstr, android::CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) == 0){ 564 restartPreviewRequired |= setVideoModeParameters(params); 565 } 566 567 mParameters.set(android::CameraParameters::KEY_FOCUS_MODE, valstr); 568 } else { 569 CAMHAL_LOGEB("ERROR: Invalid FOCUS mode = %s", valstr); 570 return BAD_VALUE; 571 } 572 } 573 574 mRawCapture = false; 575 576#ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING 577 valstr = params.get(TICameraParameters::KEY_CAP_MODE); 578 if ( (!valstr || strcmp(valstr, TICameraParameters::HIGH_QUALITY_MODE) == 0) && 579 access(kRawImagesOutputDirPath, F_OK) != -1 ) { 580 mRawCapture = true; 581 } 582#endif 583 584 if ( (valstr = params.get(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT)) != NULL ) 585 { 586 CAMHAL_LOGDB("Stereo 3D capture image layout is %s", valstr); 587 mParameters.set(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT, valstr); 588 } 589 590 params.getPictureSize(&w, &h); 591 if ( (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES))) 592 || (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SUBSAMPLED_SIZES))) 593 || (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_TOPBOTTOM_SIZES))) 594 || (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIDEBYSIDE_SIZES))) ) { 595 mParameters.setPictureSize(w, h); 596 } else { 597 CAMHAL_LOGEB("ERROR: Invalid picture resolution %d x %d", w, h); 598 return BAD_VALUE; 599 } 600 601 CAMHAL_LOGDB("Picture Size by App %d x %d", w, h); 602 603 if ( (valstr = params.getPictureFormat()) != NULL ) { 604 if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS))) { 605 if ((strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_BAYER_RGGB) == 0) && 606 mCameraProperties->get(CameraProperties::MAX_PICTURE_WIDTH) && 607 mCameraProperties->get(CameraProperties::MAX_PICTURE_HEIGHT)) { 608 unsigned int width = 0, height = 0; 609 // Set picture size to full frame for raw bayer capture 610 width = atoi(mCameraProperties->get(CameraProperties::MAX_PICTURE_WIDTH)); 611 height = atoi(mCameraProperties->get(CameraProperties::MAX_PICTURE_HEIGHT)); 612 mParameters.setPictureSize(width,height); 613 } 614 mParameters.setPictureFormat(valstr); 615 } else { 616 CAMHAL_LOGEB("ERROR: Invalid picture format: %s",valstr); 617 ret = BAD_VALUE; 618 } 619 } 620 621#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE 622 if ((valstr = params.get(TICameraParameters::KEY_BURST)) != NULL) { 623 if (params.getInt(TICameraParameters::KEY_BURST) >=0) { 624 CAMHAL_LOGDB("Burst set %s", valstr); 625 mParameters.set(TICameraParameters::KEY_BURST, valstr); 626 } else { 627 CAMHAL_LOGEB("ERROR: Invalid Burst value: %s",valstr); 628 return BAD_VALUE; 629 } 630 } 631#endif 632 633 // Variable framerate ranges have higher priority over 634 // deprecated constant FPS. "KEY_PREVIEW_FPS_RANGE" should 635 // be cleared by the client in order for constant FPS to get 636 // applied. 637 // If Port FPS needs to be used for configuring, then FPS RANGE should not be set by the APP. 638 valstr = params.get(android::CameraParameters::KEY_PREVIEW_FPS_RANGE); 639 if (valstr != NULL && strlen(valstr)) { 640 int curMaxFPS = 0; 641 int curMinFPS = 0; 642 643 // APP wants to set FPS range 644 // Set framerate = MAXFPS 645 CAMHAL_LOGDA("APP IS CHANGING FRAME RATE RANGE"); 646 647 mParameters.getPreviewFpsRange(&curMinFPS, &curMaxFPS); 648 CAMHAL_LOGDB("## current minFPS = %d; maxFPS=%d",curMinFPS, curMaxFPS); 649 650 params.getPreviewFpsRange(&minFPS, &maxFPS); 651 CAMHAL_LOGDB("## requested minFPS = %d; maxFPS=%d",minFPS, maxFPS); 652 // Validate VFR 653 if (!isFpsRangeValid(minFPS, maxFPS, params.get(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE)) && 654 !isFpsRangeValid(minFPS, maxFPS, params.get(TICameraParameters::KEY_FRAMERATE_RANGES_EXT_SUPPORTED))) { 655 CAMHAL_LOGEA("Invalid FPS Range"); 656 return BAD_VALUE; 657 } else { 658 framerate = maxFPS / CameraHal::VFR_SCALE; 659 mParameters.setPreviewFrameRate(framerate); 660 CAMHAL_LOGDB("SET FRAMERATE %d", framerate); 661 mParameters.set(android::CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr); 662 CAMHAL_LOGDB("FPS Range = %s", valstr); 663 if ( curMaxFPS == (FRAME_RATE_HIGH_HD * CameraHal::VFR_SCALE) && 664 maxFPS < (FRAME_RATE_HIGH_HD * CameraHal::VFR_SCALE) ) { 665 restartPreviewRequired = true; 666 } 667 } 668 } else { 669 framerate = params.getPreviewFrameRate(); 670 if (!isParameterValid(framerate, params.get(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES)) && 671 !isParameterValid(framerate, params.get(TICameraParameters::KEY_FRAMERATES_EXT_SUPPORTED))) { 672 CAMHAL_LOGEA("Invalid frame rate"); 673 return BAD_VALUE; 674 } 675 char tmpBuffer[MAX_PROP_VALUE_LENGTH]; 676 677 sprintf(tmpBuffer, "%d,%d", framerate * CameraHal::VFR_SCALE, framerate * CameraHal::VFR_SCALE); 678 mParameters.setPreviewFrameRate(framerate); 679 CAMHAL_LOGDB("SET FRAMERATE %d", framerate); 680 mParameters.set(android::CameraParameters::KEY_PREVIEW_FPS_RANGE, tmpBuffer); 681 CAMHAL_LOGDB("FPS Range = %s", tmpBuffer); 682 } 683 684 if ((valstr = params.get(TICameraParameters::KEY_GBCE)) != NULL) { 685 if (strcmp(mCameraProperties->get(CameraProperties::SUPPORTED_GBCE), 686 android::CameraParameters::TRUE) == 0) { 687 CAMHAL_LOGDB("GBCE %s", valstr); 688 mParameters.set(TICameraParameters::KEY_GBCE, valstr); 689 } else if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { 690 CAMHAL_LOGEB("ERROR: Invalid GBCE: %s", valstr); 691 return BAD_VALUE; 692 } else { 693 mParameters.set(TICameraParameters::KEY_GBCE, android::CameraParameters::FALSE); 694 } 695 } else { 696 mParameters.set(TICameraParameters::KEY_GBCE, android::CameraParameters::FALSE); 697 } 698 699 if ((valstr = params.get(TICameraParameters::KEY_GLBCE)) != NULL) { 700 if (strcmp(mCameraProperties->get(CameraProperties::SUPPORTED_GLBCE), 701 android::CameraParameters::TRUE) == 0) { 702 CAMHAL_LOGDB("GLBCE %s", valstr); 703 mParameters.set(TICameraParameters::KEY_GLBCE, valstr); 704 } else if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { 705 CAMHAL_LOGEB("ERROR: Invalid GLBCE: %s", valstr); 706 return BAD_VALUE; 707 } else { 708 mParameters.set(TICameraParameters::KEY_GLBCE, android::CameraParameters::FALSE); 709 } 710 } else { 711 mParameters.set(TICameraParameters::KEY_GLBCE, android::CameraParameters::FALSE); 712 } 713 714#ifdef OMAP_ENHANCEMENT_S3D 715 ///Update the current parameter set 716 if ( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE)) != NULL ) { 717 CAMHAL_LOGDB("AutoConvergence mode set = %s", valstr); 718 mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, valstr); 719 } 720 721 if ( (valstr = params.get(TICameraParameters::KEY_MANUAL_CONVERGENCE)) != NULL ) { 722 int manualConvergence = (int)strtol(valstr, 0, 0); 723 724 if ( ( manualConvergence < strtol(mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_MIN), 0, 0) ) || 725 ( manualConvergence > strtol(mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_MAX), 0, 0) ) ) { 726 CAMHAL_LOGEB("ERROR: Invalid Manual Convergence = %d", manualConvergence); 727 return BAD_VALUE; 728 } else { 729 CAMHAL_LOGDB("ManualConvergence Value = %d", manualConvergence); 730 mParameters.set(TICameraParameters::KEY_MANUAL_CONVERGENCE, valstr); 731 } 732 } 733 734 if((valstr = params.get(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION)) != NULL) { 735 if ( strcmp(mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED), 736 android::CameraParameters::TRUE) == 0 ) { 737 CAMHAL_LOGDB("Mechanical Mialignment Correction is %s", valstr); 738 mParameters.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION, valstr); 739 } else { 740 mParameters.remove(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION); 741 } 742 } 743 744 if ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL) { 745 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES))) { 746 CAMHAL_LOGDB("Exposure mode set = %s", valstr); 747 mParameters.set(TICameraParameters::KEY_EXPOSURE_MODE, valstr); 748 if (!strcmp(valstr, TICameraParameters::EXPOSURE_MODE_MANUAL)) { 749 int manualVal; 750 if ((valstr = params.get(TICameraParameters::KEY_MANUAL_EXPOSURE)) != NULL) { 751 manualVal = params.getInt(TICameraParameters::KEY_MANUAL_EXPOSURE); 752 if (manualVal < mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN) || 753 manualVal > mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MAX)) { 754 CAMHAL_LOGEB("ERROR: Manual Exposure = %s is out of range - " 755 "setting minimum supported value", valstr); 756 valstr = mParameters.get(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN); 757 } 758 CAMHAL_LOGDB("Manual Exposure = %s", valstr); 759 mParameters.set(TICameraParameters::KEY_MANUAL_EXPOSURE, valstr); 760 } 761 if ((valstr = params.get(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT)) != NULL) { 762 manualVal = params.getInt(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT); 763 if (manualVal < mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN) || 764 manualVal > mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MAX)) { 765 CAMHAL_LOGEB("ERROR: Manual Exposure right = %s is out of range - " 766 "setting minimum supported value", valstr); 767 valstr = mParameters.get(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN); 768 } 769 CAMHAL_LOGDB("Manual Exposure right = %s", valstr); 770 mParameters.set(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT, valstr); 771 } 772 if ((valstr = params.get(TICameraParameters::KEY_MANUAL_GAIN_ISO)) != NULL) { 773 manualVal = params.getInt(TICameraParameters::KEY_MANUAL_GAIN_ISO); 774 if (manualVal < mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN) || 775 manualVal > mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX)) { 776 CAMHAL_LOGEB("ERROR: Manual Gain = %s is out of range - " 777 "setting minimum supported value", valstr); 778 valstr = mParameters.get(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN); 779 } 780 CAMHAL_LOGDB("Manual Gain = %s", valstr); 781 mParameters.set(TICameraParameters::KEY_MANUAL_GAIN_ISO, valstr); 782 } 783 if ((valstr = params.get(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT)) != NULL) { 784 manualVal = params.getInt(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT); 785 if (manualVal < mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN) || 786 manualVal > mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX)) { 787 CAMHAL_LOGEB("ERROR: Manual Gain right = %s is out of range - " 788 "setting minimum supported value", valstr); 789 valstr = mParameters.get(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN); 790 } 791 CAMHAL_LOGDB("Manual Gain right = %s", valstr); 792 mParameters.set(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT, valstr); 793 } 794 } 795 } else { 796 CAMHAL_LOGEB("ERROR: Invalid Exposure mode = %s", valstr); 797 return BAD_VALUE; 798 } 799 } 800#endif 801 802 if ((valstr = params.get(android::CameraParameters::KEY_WHITE_BALANCE)) != NULL) { 803 if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE))) { 804 CAMHAL_LOGDB("White balance set %s", valstr); 805 mParameters.set(android::CameraParameters::KEY_WHITE_BALANCE, valstr); 806 } else { 807 CAMHAL_LOGEB("ERROR: Invalid white balance = %s", valstr); 808 return BAD_VALUE; 809 } 810 } 811 812#ifdef OMAP_ENHANCEMENT 813 if ((valstr = params.get(TICameraParameters::KEY_CONTRAST)) != NULL) { 814 if (params.getInt(TICameraParameters::KEY_CONTRAST) >= 0 ) { 815 CAMHAL_LOGDB("Contrast set %s", valstr); 816 mParameters.set(TICameraParameters::KEY_CONTRAST, valstr); 817 } else { 818 CAMHAL_LOGEB("ERROR: Invalid Contrast = %s", valstr); 819 return BAD_VALUE; 820 } 821 } 822 823 if ((valstr =params.get(TICameraParameters::KEY_SHARPNESS)) != NULL) { 824 if (params.getInt(TICameraParameters::KEY_SHARPNESS) >= 0 ) { 825 CAMHAL_LOGDB("Sharpness set %s", valstr); 826 mParameters.set(TICameraParameters::KEY_SHARPNESS, valstr); 827 } else { 828 CAMHAL_LOGEB("ERROR: Invalid Sharpness = %s", valstr); 829 return BAD_VALUE; 830 } 831 } 832 833 if ((valstr = params.get(TICameraParameters::KEY_SATURATION)) != NULL) { 834 if (params.getInt(TICameraParameters::KEY_SATURATION) >= 0 ) { 835 CAMHAL_LOGDB("Saturation set %s", valstr); 836 mParameters.set(TICameraParameters::KEY_SATURATION, valstr); 837 } else { 838 CAMHAL_LOGEB("ERROR: Invalid Saturation = %s", valstr); 839 return BAD_VALUE; 840 } 841 } 842 843 if ((valstr = params.get(TICameraParameters::KEY_BRIGHTNESS)) != NULL) { 844 if (params.getInt(TICameraParameters::KEY_BRIGHTNESS) >= 0 ) { 845 CAMHAL_LOGDB("Brightness set %s", valstr); 846 mParameters.set(TICameraParameters::KEY_BRIGHTNESS, valstr); 847 } else { 848 CAMHAL_LOGEB("ERROR: Invalid Brightness = %s", valstr); 849 return BAD_VALUE; 850 } 851 } 852#endif 853 854 if ((valstr = params.get(android::CameraParameters::KEY_ANTIBANDING)) != NULL) { 855 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING))) { 856 CAMHAL_LOGDB("Antibanding set %s", valstr); 857 mParameters.set(android::CameraParameters::KEY_ANTIBANDING, valstr); 858 } else { 859 CAMHAL_LOGEB("ERROR: Invalid Antibanding = %s", valstr); 860 return BAD_VALUE; 861 } 862 } 863 864#ifdef OMAP_ENHANCEMENT 865 if ((valstr = params.get(TICameraParameters::KEY_ISO)) != NULL) { 866 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES))) { 867 CAMHAL_LOGDB("ISO set %s", valstr); 868 mParameters.set(TICameraParameters::KEY_ISO, valstr); 869 } else { 870 CAMHAL_LOGEB("ERROR: Invalid ISO = %s", valstr); 871 return BAD_VALUE; 872 } 873 } 874#endif 875 876 if( (valstr = params.get(android::CameraParameters::KEY_FOCUS_AREAS)) != NULL ) 877 { 878 CAMHAL_LOGDB("Focus areas position set %s", params.get(android::CameraParameters::KEY_FOCUS_AREAS)); 879 mParameters.set(android::CameraParameters::KEY_FOCUS_AREAS, valstr); 880 } 881 882#ifdef OMAP_ENHANCEMENT 883 if( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL ) 884 { 885 CAMHAL_LOGDB("Measurements set to %s", valstr); 886 mParameters.set(TICameraParameters::KEY_MEASUREMENT_ENABLE, valstr); 887 888 if (strcmp(valstr, android::CameraParameters::TRUE) == 0) 889 { 890 mMeasurementEnabled = true; 891 } 892 else if (strcmp(valstr, android::CameraParameters::FALSE) == 0) 893 { 894 mMeasurementEnabled = false; 895 } 896 else 897 { 898 mMeasurementEnabled = false; 899 } 900 901 } 902#endif 903 904 if( (valstr = params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL) 905 { 906 CAMHAL_LOGDB("Exposure compensation set %s", params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION)); 907 mParameters.set(android::CameraParameters::KEY_EXPOSURE_COMPENSATION, valstr); 908 } 909 910 if ((valstr = params.get(android::CameraParameters::KEY_SCENE_MODE)) != NULL) { 911 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES))) { 912 CAMHAL_LOGDB("Scene mode set %s", valstr); 913 doesSetParameterNeedUpdate(valstr, 914 mParameters.get(android::CameraParameters::KEY_SCENE_MODE), 915 updateRequired); 916 mParameters.set(android::CameraParameters::KEY_SCENE_MODE, valstr); 917 } else { 918 CAMHAL_LOGEB("ERROR: Invalid Scene mode = %s", valstr); 919 return BAD_VALUE; 920 } 921 } 922 923 if ((valstr = params.get(android::CameraParameters::KEY_FLASH_MODE)) != NULL) { 924 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES))) { 925 CAMHAL_LOGDB("Flash mode set %s", valstr); 926 mParameters.set(android::CameraParameters::KEY_FLASH_MODE, valstr); 927 } else { 928 CAMHAL_LOGEB("ERROR: Invalid Flash mode = %s", valstr); 929 return BAD_VALUE; 930 } 931 } 932 933 if ((valstr = params.get(android::CameraParameters::KEY_EFFECT)) != NULL) { 934 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS))) { 935 CAMHAL_LOGDB("Effect set %s", valstr); 936 mParameters.set(android::CameraParameters::KEY_EFFECT, valstr); 937 } else { 938 CAMHAL_LOGEB("ERROR: Invalid Effect = %s", valstr); 939 return BAD_VALUE; 940 } 941 } 942 943 varint = params.getInt(android::CameraParameters::KEY_ROTATION); 944 if ( varint >= 0 ) { 945 CAMHAL_LOGDB("Rotation set %d", varint); 946 mParameters.set(android::CameraParameters::KEY_ROTATION, varint); 947 } 948 949 varint = params.getInt(android::CameraParameters::KEY_JPEG_QUALITY); 950 if ( varint >= 0 ) { 951 CAMHAL_LOGDB("Jpeg quality set %d", varint); 952 mParameters.set(android::CameraParameters::KEY_JPEG_QUALITY, varint); 953 } 954 955 varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 956 if ( varint >= 0 ) { 957 CAMHAL_LOGDB("Thumbnail width set %d", varint); 958 mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, varint); 959 } 960 961 varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 962 if ( varint >= 0 ) { 963 CAMHAL_LOGDB("Thumbnail width set %d", varint); 964 mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, varint); 965 } 966 967 varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 968 if ( varint >= 0 ) { 969 CAMHAL_LOGDB("Thumbnail quality set %d", varint); 970 mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, varint); 971 } 972 973 if( (valstr = params.get(android::CameraParameters::KEY_GPS_LATITUDE)) != NULL ) 974 { 975 CAMHAL_LOGDB("GPS latitude set %s", params.get(android::CameraParameters::KEY_GPS_LATITUDE)); 976 mParameters.set(android::CameraParameters::KEY_GPS_LATITUDE, valstr); 977 }else{ 978 mParameters.remove(android::CameraParameters::KEY_GPS_LATITUDE); 979 } 980 981 if( (valstr = params.get(android::CameraParameters::KEY_GPS_LONGITUDE)) != NULL ) 982 { 983 CAMHAL_LOGDB("GPS longitude set %s", params.get(android::CameraParameters::KEY_GPS_LONGITUDE)); 984 mParameters.set(android::CameraParameters::KEY_GPS_LONGITUDE, valstr); 985 }else{ 986 mParameters.remove(android::CameraParameters::KEY_GPS_LONGITUDE); 987 } 988 989 if( (valstr = params.get(android::CameraParameters::KEY_GPS_ALTITUDE)) != NULL ) 990 { 991 CAMHAL_LOGDB("GPS altitude set %s", params.get(android::CameraParameters::KEY_GPS_ALTITUDE)); 992 mParameters.set(android::CameraParameters::KEY_GPS_ALTITUDE, valstr); 993 }else{ 994 mParameters.remove(android::CameraParameters::KEY_GPS_ALTITUDE); 995 } 996 997 if( (valstr = params.get(android::CameraParameters::KEY_GPS_TIMESTAMP)) != NULL ) 998 { 999 CAMHAL_LOGDB("GPS timestamp set %s", params.get(android::CameraParameters::KEY_GPS_TIMESTAMP)); 1000 mParameters.set(android::CameraParameters::KEY_GPS_TIMESTAMP, valstr); 1001 }else{ 1002 mParameters.remove(android::CameraParameters::KEY_GPS_TIMESTAMP); 1003 } 1004 1005 if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL ) 1006 { 1007 CAMHAL_LOGDB("GPS datestamp set %s", valstr); 1008 mParameters.set(TICameraParameters::KEY_GPS_DATESTAMP, valstr); 1009 }else{ 1010 mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP); 1011 } 1012 1013 if( (valstr = params.get(android::CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL ) 1014 { 1015 CAMHAL_LOGDB("GPS processing method set %s", params.get(android::CameraParameters::KEY_GPS_PROCESSING_METHOD)); 1016 mParameters.set(android::CameraParameters::KEY_GPS_PROCESSING_METHOD, valstr); 1017 }else{ 1018 mParameters.remove(android::CameraParameters::KEY_GPS_PROCESSING_METHOD); 1019 } 1020 1021 if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL ) 1022 { 1023 CAMHAL_LOGDB("GPS MAPDATUM set %s", valstr); 1024 mParameters.set(TICameraParameters::KEY_GPS_MAPDATUM, valstr); 1025 }else{ 1026 mParameters.remove(TICameraParameters::KEY_GPS_MAPDATUM); 1027 } 1028 1029 if( (valstr = params.get(TICameraParameters::KEY_GPS_VERSION)) != NULL ) 1030 { 1031 CAMHAL_LOGDB("GPS MAPDATUM set %s", valstr); 1032 mParameters.set(TICameraParameters::KEY_GPS_VERSION, valstr); 1033 }else{ 1034 mParameters.remove(TICameraParameters::KEY_GPS_VERSION); 1035 } 1036 1037 if( (valstr = params.get(TICameraParameters::KEY_EXIF_MODEL)) != NULL ) 1038 { 1039 CAMHAL_LOGDB("EXIF Model set %s", valstr); 1040 mParameters.set(TICameraParameters::KEY_EXIF_MODEL, valstr); 1041 } 1042 1043 if( (valstr = params.get(TICameraParameters::KEY_EXIF_MAKE)) != NULL ) 1044 { 1045 CAMHAL_LOGDB("EXIF Make set %s", valstr); 1046 mParameters.set(TICameraParameters::KEY_EXIF_MAKE, valstr); 1047 } 1048 1049#ifdef OMAP_ENHANCEMENT 1050 if( (valstr = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL ) 1051 { 1052 CAMHAL_LOGDB("Exposure Bracketing set %s", params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)); 1053 mParameters.set(TICameraParameters::KEY_EXP_BRACKETING_RANGE, valstr); 1054 mParameters.remove(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE); 1055 } 1056 else if ((valstr = params.get(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE)) != NULL) { 1057 CAMHAL_LOGDB("ABS Exposure+Gain Bracketing set %s", params.get(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE)); 1058 mParameters.set(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE, valstr); 1059 mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE); 1060 } else 1061 { 1062 mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE); 1063 } 1064 1065 if( (valstr = params.get(TICameraParameters::KEY_ZOOM_BRACKETING_RANGE)) != NULL ) { 1066 CAMHAL_LOGDB("Zoom Bracketing range %s", valstr); 1067 mParameters.set(TICameraParameters::KEY_ZOOM_BRACKETING_RANGE, valstr); 1068 } else { 1069 mParameters.remove(TICameraParameters::KEY_ZOOM_BRACKETING_RANGE); 1070 } 1071#endif 1072 1073 if ((valstr = params.get(android::CameraParameters::KEY_ZOOM)) != NULL ) { 1074 varint = atoi(valstr); 1075 if ( varint >= 0 && varint <= mMaxZoomSupported ) { 1076 CAMHAL_LOGDB("Zoom set %d", varint); 1077 doesSetParameterNeedUpdate(valstr, 1078 mParameters.get(android::CameraParameters::KEY_ZOOM), 1079 updateRequired); 1080 mParameters.set(android::CameraParameters::KEY_ZOOM, valstr); 1081 } else { 1082 CAMHAL_LOGEB("ERROR: Invalid Zoom: %s", valstr); 1083 return BAD_VALUE; 1084 } 1085 } 1086 1087 if( (valstr = params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL ) 1088 { 1089 CAMHAL_LOGDB("Auto Exposure Lock set %s", valstr); 1090 doesSetParameterNeedUpdate(valstr, 1091 mParameters.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK), 1092 updateRequired); 1093 mParameters.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr); 1094 } 1095 1096 if( (valstr = params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL ) 1097 { 1098 CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", valstr); 1099 doesSetParameterNeedUpdate(valstr, 1100 mParameters.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK), 1101 updateRequired); 1102 mParameters.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr); 1103 } 1104 if( (valstr = params.get(android::CameraParameters::KEY_METERING_AREAS)) != NULL ) 1105 { 1106 CAMHAL_LOGDB("Metering areas position set %s", params.get(android::CameraParameters::KEY_METERING_AREAS)); 1107 mParameters.set(android::CameraParameters::KEY_METERING_AREAS, valstr); 1108 } 1109 1110 if( (valstr = params.get(TICameraParameters::RAW_WIDTH)) != NULL ) { 1111 CAMHAL_LOGDB("Raw image width set %s", params.get(TICameraParameters::RAW_WIDTH)); 1112 mParameters.set(TICameraParameters::RAW_WIDTH, valstr); 1113 } 1114 1115 if( (valstr = params.get(TICameraParameters::RAW_HEIGHT)) != NULL ) { 1116 CAMHAL_LOGDB("Raw image height set %s", params.get(TICameraParameters::RAW_HEIGHT)); 1117 mParameters.set(TICameraParameters::RAW_HEIGHT, valstr); 1118 } 1119 1120 //TI extensions for enable/disable algos 1121 if( (valstr = params.get(TICameraParameters::KEY_ALGO_FIXED_GAMMA)) != NULL ) 1122 { 1123 CAMHAL_LOGDB("Fixed Gamma set %s", valstr); 1124 mParameters.set(TICameraParameters::KEY_ALGO_FIXED_GAMMA, valstr); 1125 } 1126 1127 if( (valstr = params.get(TICameraParameters::KEY_ALGO_NSF1)) != NULL ) 1128 { 1129 CAMHAL_LOGDB("NSF1 set %s", valstr); 1130 mParameters.set(TICameraParameters::KEY_ALGO_NSF1, valstr); 1131 } 1132 1133 if( (valstr = params.get(TICameraParameters::KEY_ALGO_NSF2)) != NULL ) 1134 { 1135 CAMHAL_LOGDB("NSF2 set %s", valstr); 1136 mParameters.set(TICameraParameters::KEY_ALGO_NSF2, valstr); 1137 } 1138 1139 if( (valstr = params.get(TICameraParameters::KEY_ALGO_SHARPENING)) != NULL ) 1140 { 1141 CAMHAL_LOGDB("Sharpening set %s", valstr); 1142 mParameters.set(TICameraParameters::KEY_ALGO_SHARPENING, valstr); 1143 } 1144 1145 if( (valstr = params.get(TICameraParameters::KEY_ALGO_THREELINCOLORMAP)) != NULL ) 1146 { 1147 CAMHAL_LOGDB("Color Conversion set %s", valstr); 1148 mParameters.set(TICameraParameters::KEY_ALGO_THREELINCOLORMAP, valstr); 1149 } 1150 1151 if( (valstr = params.get(TICameraParameters::KEY_ALGO_GIC)) != NULL ) 1152 { 1153 CAMHAL_LOGDB("Green Inballance Correction set %s", valstr); 1154 mParameters.set(TICameraParameters::KEY_ALGO_GIC, valstr); 1155 } 1156 1157 android::CameraParameters adapterParams = mParameters; 1158 1159#ifdef OMAP_ENHANCEMENT 1160 if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS) ) 1161 { 1162 int posBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS); 1163 if ( 0 < posBracketRange ) 1164 { 1165 mBracketRangePositive = posBracketRange; 1166 } 1167 } 1168 CAMHAL_LOGDB("Positive bracketing range %d", mBracketRangePositive); 1169 1170 1171 if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG) ) 1172 { 1173 int negBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG); 1174 if ( 0 < negBracketRange ) 1175 { 1176 mBracketRangeNegative = negBracketRange; 1177 } 1178 } 1179 CAMHAL_LOGDB("Negative bracketing range %d", mBracketRangeNegative); 1180 1181 if( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL) && 1182 ( strcmp(valstr, android::CameraParameters::TRUE) == 0 )) { 1183 if ( !mBracketingEnabled ) { 1184 CAMHAL_LOGDA("Enabling bracketing"); 1185 mBracketingEnabled = true; 1186 } else { 1187 CAMHAL_LOGDA("Bracketing already enabled"); 1188 } 1189 adapterParams.set(TICameraParameters::KEY_TEMP_BRACKETING, valstr); 1190 mParameters.set(TICameraParameters::KEY_TEMP_BRACKETING, valstr); 1191 } else if ( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL ) && 1192 ( strcmp(valstr, android::CameraParameters::FALSE) == 0 )) { 1193 CAMHAL_LOGDA("Disabling bracketing"); 1194 1195 adapterParams.set(TICameraParameters::KEY_TEMP_BRACKETING, valstr); 1196 mParameters.set(TICameraParameters::KEY_TEMP_BRACKETING, valstr); 1197 mBracketingEnabled = false; 1198 if ( mBracketingRunning ) { 1199 stopImageBracketing(); 1200 } 1201 1202 } else { 1203 adapterParams.remove(TICameraParameters::KEY_TEMP_BRACKETING); 1204 mParameters.remove(TICameraParameters::KEY_TEMP_BRACKETING); 1205 } 1206#endif 1207 1208#ifdef OMAP_ENHANCEMENT_VTC 1209 if (mVTCUseCase && !mTunnelSetup && (mCameraAdapter != NULL) && 1210 ((mParameters.get(TICameraParameters::KEY_VIDEO_ENCODER_HANDLE)) != NULL )&& 1211 ((mParameters.get(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT)) != NULL )) { 1212 1213 uint32_t sliceHeight = mParameters.getInt(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT); 1214 uint32_t encoderHandle = mParameters.getInt(TICameraParameters::KEY_VIDEO_ENCODER_HANDLE); 1215 int w, h; 1216 mParameters.getPreviewSize(&w, &h); 1217 status_t done = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SETUP_TUNNEL, sliceHeight, encoderHandle, w, h); 1218 if (done == NO_ERROR) mTunnelSetup = true; 1219 ret |= done; 1220 } 1221#endif 1222 1223 // Only send parameters to adapter if preview is already 1224 // enabled or doesSetParameterNeedUpdate says so. Initial setParameters to camera adapter, 1225 // will be called in startPreview() 1226 // TODO(XXX): Need to identify other parameters that need update from camera adapter 1227 if ( (NULL != mCameraAdapter) && 1228 (mPreviewEnabled || updateRequired) && 1229 (!(mPreviewEnabled && restartPreviewRequired)) ) { 1230 ret |= mCameraAdapter->setParameters(adapterParams); 1231 } 1232 1233#ifdef OMAP_ENHANCEMENT 1234 if( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) && 1235 ( strcmp(valstr, android::CameraParameters::TRUE) == 0 )) 1236 { 1237 CAMHAL_LOGDA("Enabling shutter sound"); 1238 1239 mShutterEnabled = true; 1240 mMsgEnabled |= CAMERA_MSG_SHUTTER; 1241 mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr); 1242 } 1243 else if ( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) && 1244 ( strcmp(valstr, android::CameraParameters::FALSE) == 0 )) 1245 { 1246 CAMHAL_LOGDA("Disabling shutter sound"); 1247 1248 mShutterEnabled = false; 1249 mMsgEnabled &= ~CAMERA_MSG_SHUTTER; 1250 mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr); 1251 } 1252#endif 1253 } 1254 1255 //On fail restore old parameters 1256 if ( NO_ERROR != ret ) { 1257 mParameters = oldParams; 1258 } 1259 1260 // Restart Preview if needed by KEY_RECODING_HINT only if preview is already running. 1261 // If preview is not started yet, Video Mode parameters will take effect on next startPreview() 1262 if (restartPreviewRequired && previewEnabled() && !mRecordingEnabled) { 1263 CAMHAL_LOGDA("Restarting Preview"); 1264 ret = restartPreview(); 1265 } else if (restartPreviewRequired && !previewEnabled() && 1266 mDisplayPaused && !mRecordingEnabled) { 1267 CAMHAL_LOGDA("Restarting preview in paused mode"); 1268 ret = restartPreview(); 1269 1270 // TODO(XXX): If there is some delay between the restartPreview call and the code 1271 // below, then the user could see some preview frames and callbacks. Let's find 1272 // a better place to put this later... 1273 if (ret == NO_ERROR) { 1274 mDisplayPaused = true; 1275 mPreviewEnabled = false; 1276 ret = mDisplayAdapter->pauseDisplay(mDisplayPaused); 1277 } 1278 } 1279 1280 if ( !mBracketingRunning && mBracketingEnabled ) { 1281 startImageBracketing(); 1282 } 1283 1284 if (ret != NO_ERROR) 1285 { 1286 CAMHAL_LOGEA("Failed to restart Preview"); 1287 return ret; 1288 } 1289 1290 LOG_FUNCTION_NAME_EXIT; 1291 1292 return ret; 1293} 1294 1295status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewFormat, 1296 unsigned int buffercount, unsigned int &max_queueable) 1297{ 1298 status_t ret = NO_ERROR; 1299 1300 LOG_FUNCTION_NAME; 1301 1302 if(mDisplayAdapter.get() == NULL) 1303 { 1304 // Memory allocation of preview buffers is now placed in gralloc 1305 // CameraHal should not allocate preview buffers without DisplayAdapter 1306 return NO_MEMORY; 1307 } 1308 1309 if(!mPreviewBuffers) 1310 { 1311 mPreviewLength = 0; 1312 mPreviewBuffers = mDisplayAdapter->allocateBufferList(width, height, 1313 previewFormat, 1314 mPreviewLength, 1315 buffercount); 1316 if (NULL == mPreviewBuffers ) { 1317 CAMHAL_LOGEA("Couldn't allocate preview buffers"); 1318 return NO_MEMORY; 1319 } 1320 1321 mPreviewOffsets = (uint32_t *) mDisplayAdapter->getOffsets(); 1322 if ( NULL == mPreviewOffsets ) { 1323 CAMHAL_LOGEA("Buffer mapping failed"); 1324 return BAD_VALUE; 1325 } 1326 1327 mBufProvider = (BufferProvider*) mDisplayAdapter.get(); 1328 1329 ret = mDisplayAdapter->maxQueueableBuffers(max_queueable); 1330 if (ret != NO_ERROR) { 1331 return ret; 1332 } 1333 } 1334 1335 LOG_FUNCTION_NAME_EXIT; 1336 1337 return ret; 1338} 1339 1340status_t CameraHal::freePreviewBufs() 1341{ 1342 status_t ret = NO_ERROR; 1343 LOG_FUNCTION_NAME; 1344 1345 CAMHAL_LOGDB("mPreviewBuffers = %p", mPreviewBuffers); 1346 if(mPreviewBuffers) 1347 { 1348 ret = mBufProvider->freeBufferList(mPreviewBuffers); 1349 mPreviewBuffers = NULL; 1350 LOG_FUNCTION_NAME_EXIT; 1351 return ret; 1352 } 1353 LOG_FUNCTION_NAME_EXIT; 1354 return ret; 1355} 1356 1357 1358status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount) 1359{ 1360 status_t ret = NO_ERROR; 1361 int bytes; 1362 1363 LOG_FUNCTION_NAME; 1364 1365 bytes = size; 1366 1367 if ( NO_ERROR == ret ) 1368 { 1369 if( NULL != mPreviewDataBuffers ) 1370 { 1371 ret = freePreviewDataBufs(); 1372 } 1373 } 1374 1375 if ( NO_ERROR == ret ) 1376 { 1377 bytes = ((bytes+4095)/4096)*4096; 1378 mPreviewDataBuffers = mMemoryManager->allocateBufferList(0, 0, NULL, bytes, bufferCount); 1379 1380 CAMHAL_LOGDB("Size of Preview data buffer = %d", bytes); 1381 if( NULL == mPreviewDataBuffers ) 1382 { 1383 CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager"); 1384 ret = -NO_MEMORY; 1385 } 1386 else 1387 { 1388 bytes = size; 1389 } 1390 } 1391 1392 if ( NO_ERROR == ret ) 1393 { 1394 mPreviewDataFd = mMemoryManager->getFd(); 1395 mPreviewDataLength = bytes; 1396 mPreviewDataOffsets = mMemoryManager->getOffsets(); 1397 } 1398 else 1399 { 1400 mPreviewDataFd = -1; 1401 mPreviewDataLength = 0; 1402 mPreviewDataOffsets = NULL; 1403 } 1404 1405 LOG_FUNCTION_NAME_EXIT; 1406 1407 return ret; 1408} 1409 1410status_t CameraHal::freePreviewDataBufs() 1411{ 1412 status_t ret = NO_ERROR; 1413 1414 LOG_FUNCTION_NAME; 1415 1416 if ( NO_ERROR == ret ) 1417 { 1418 1419 if( NULL != mPreviewDataBuffers ) 1420 { 1421 1422 ret = mMemoryManager->freeBufferList(mPreviewDataBuffers); 1423 mPreviewDataBuffers = NULL; 1424 1425 } 1426 } 1427 1428 LOG_FUNCTION_NAME_EXIT; 1429 1430 return ret; 1431} 1432 1433status_t CameraHal::allocImageBufs(unsigned int width, unsigned int height, size_t size, 1434 const char* previewFormat, unsigned int bufferCount, 1435 unsigned int *max_queueable) 1436{ 1437 status_t ret = NO_ERROR; 1438 int bytes; 1439 1440 LOG_FUNCTION_NAME; 1441 1442 bytes = size; 1443 1444 // allocate image buffers only if not already allocated 1445 if(NULL != mImageBuffers) { 1446 if (mBufferSourceAdapter_Out.get()) { 1447 mBufferSourceAdapter_Out->maxQueueableBuffers(*max_queueable); 1448 } else { 1449 *max_queueable = bufferCount; 1450 } 1451 return NO_ERROR; 1452 } 1453 1454 if (mBufferSourceAdapter_Out.get()) { 1455 mImageBuffers = mBufferSourceAdapter_Out->allocateBufferList(width, height, previewFormat, 1456 bytes, bufferCount); 1457 mBufferSourceAdapter_Out->maxQueueableBuffers(*max_queueable); 1458 } else { 1459 bytes = ((bytes + 4095) / 4096) * 4096; 1460 mImageBuffers = mMemoryManager->allocateBufferList(0, 0, previewFormat, bytes, bufferCount); 1461 *max_queueable = bufferCount; 1462 } 1463 1464 CAMHAL_LOGDB("Size of Image cap buffer = %d", bytes); 1465 if ( NULL == mImageBuffers ) { 1466 CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager"); 1467 ret = -NO_MEMORY; 1468 } else { 1469 bytes = size; 1470 } 1471 1472 if ( NO_ERROR == ret ) { 1473 mImageFd = mMemoryManager->getFd(); 1474 mImageLength = bytes; 1475 mImageOffsets = mMemoryManager->getOffsets(); 1476 } else { 1477 mImageFd = -1; 1478 mImageLength = 0; 1479 mImageOffsets = NULL; 1480 } 1481 1482 LOG_FUNCTION_NAME_EXIT; 1483 1484 return ret; 1485} 1486 1487status_t CameraHal::allocVideoBufs(uint32_t width, uint32_t height, uint32_t bufferCount) 1488{ 1489 status_t ret = NO_ERROR; 1490 LOG_FUNCTION_NAME; 1491 1492 if( NULL != mVideoBuffers ){ 1493 ret = freeVideoBufs(mVideoBuffers); 1494 mVideoBuffers = NULL; 1495 } 1496 1497 if ( NO_ERROR == ret ){ 1498 int32_t stride; 1499 CameraBuffer *buffers = new CameraBuffer [bufferCount]; 1500 1501 memset (buffers, 0, sizeof(CameraBuffer) * bufferCount); 1502 1503 if (buffers != NULL){ 1504 for (unsigned int i = 0; i< bufferCount; i++){ 1505 android::GraphicBufferAllocator &GrallocAlloc = android::GraphicBufferAllocator::get(); 1506 buffer_handle_t handle; 1507 ret = GrallocAlloc.alloc(width, height, HAL_PIXEL_FORMAT_NV12, CAMHAL_GRALLOC_USAGE, &handle, &stride); 1508 if (ret != NO_ERROR){ 1509 CAMHAL_LOGEA("Couldn't allocate video buffers using Gralloc"); 1510 ret = -NO_MEMORY; 1511 for (unsigned int j=0; j< i; j++){ 1512 CAMHAL_LOGEB("Freeing Gralloc Buffer %p", buffers[i].opaque); 1513 GrallocAlloc.free((buffer_handle_t)buffers[i].opaque); 1514 } 1515 delete [] buffers; 1516 goto exit; 1517 } 1518 buffers[i].type = CAMERA_BUFFER_GRALLOC; 1519 buffers[i].opaque = (void *)handle; 1520 CAMHAL_LOGVB("*** Gralloc Handle =0x%x ***", handle); 1521 } 1522 1523 mVideoBuffers = buffers; 1524 } 1525 else{ 1526 CAMHAL_LOGEA("Couldn't allocate video buffers "); 1527 ret = -NO_MEMORY; 1528 } 1529 } 1530 1531 exit: 1532 LOG_FUNCTION_NAME_EXIT; 1533 1534 return ret; 1535} 1536 1537status_t CameraHal::allocRawBufs(int width, int height, const char* previewFormat, int bufferCount) 1538{ 1539 status_t ret = NO_ERROR; 1540 1541 LOG_FUNCTION_NAME 1542 1543 1544 ///@todo Enhance this method allocImageBufs() to take in a flag for burst capture 1545 ///Always allocate the buffers for image capture using MemoryManager 1546 if (NO_ERROR == ret) { 1547 if(( NULL != mVideoBuffers )) { 1548 // Re-use the buffer for raw capture. 1549 return ret; 1550 } 1551 } 1552 1553 if ( NO_ERROR == ret ) { 1554 mVideoLength = 0; 1555 mVideoLength = (((width * height * 2) + 4095)/4096)*4096; 1556 mVideoBuffers = mMemoryManager->allocateBufferList(width, height, previewFormat, 1557 mVideoLength, bufferCount); 1558 1559 CAMHAL_LOGDB("Size of Video cap buffer (used for RAW capture) %d", mVideoLength); 1560 if( NULL == mVideoBuffers ) { 1561 CAMHAL_LOGEA("Couldn't allocate Video buffers using memory manager"); 1562 ret = -NO_MEMORY; 1563 } 1564 } 1565 1566 if ( NO_ERROR == ret ) { 1567 mVideoFd = mMemoryManager->getFd(); 1568 mVideoOffsets = mMemoryManager->getOffsets(); 1569 } else { 1570 mVideoFd = -1; 1571 mVideoOffsets = NULL; 1572 } 1573 1574 LOG_FUNCTION_NAME_EXIT; 1575 1576 return ret; 1577} 1578 1579void endImageCapture( void *userData) 1580{ 1581 LOG_FUNCTION_NAME; 1582 1583 if ( NULL != userData ) 1584 { 1585 CameraHal *c = reinterpret_cast<CameraHal *>(userData); 1586 c->signalEndImageCapture(); 1587 } 1588 1589 LOG_FUNCTION_NAME_EXIT; 1590} 1591 1592void releaseImageBuffers(void *userData) 1593{ 1594 LOG_FUNCTION_NAME; 1595 1596 if (NULL != userData) { 1597 CameraHal *c = reinterpret_cast<CameraHal *>(userData); 1598 c->freeImageBufs(); 1599 } 1600 1601 LOG_FUNCTION_NAME_EXIT; 1602} 1603 1604status_t CameraHal::signalEndImageCapture() 1605{ 1606 status_t ret = NO_ERROR; 1607 int w,h; 1608 android::AutoMutex lock(mLock); 1609 1610 LOG_FUNCTION_NAME; 1611 1612 if (mBufferSourceAdapter_Out.get()) { 1613 mBufferSourceAdapter_Out->disableDisplay(); 1614 } 1615 1616 if (mBufferSourceAdapter_In.get()) { 1617 mBufferSourceAdapter_In->disableDisplay(); 1618 } 1619 1620 if ( mBracketingRunning ) { 1621 stopImageBracketing(); 1622 } else { 1623 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE); 1624 } 1625 1626 LOG_FUNCTION_NAME_EXIT; 1627 1628 return ret; 1629} 1630 1631status_t CameraHal::freeImageBufs() 1632{ 1633 status_t ret = NO_ERROR; 1634 1635 LOG_FUNCTION_NAME; 1636 1637 if (NULL == mImageBuffers) { 1638 return -EINVAL; 1639 } 1640 1641 if (mBufferSourceAdapter_Out.get()) { 1642 ret = mBufferSourceAdapter_Out->freeBufferList(mImageBuffers); 1643 } else { 1644 ret = mMemoryManager->freeBufferList(mImageBuffers); 1645 } 1646 1647 if (ret == NO_ERROR) { 1648 mImageBuffers = NULL; 1649 } 1650 1651 LOG_FUNCTION_NAME_EXIT; 1652 1653 return ret; 1654} 1655 1656status_t CameraHal::freeVideoBufs(CameraBuffer *bufs) 1657{ 1658 status_t ret = NO_ERROR; 1659 1660 LOG_FUNCTION_NAME; 1661 1662 int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); 1663 if(bufs == NULL) 1664 { 1665 CAMHAL_LOGEA("NULL pointer passed to freeVideoBuffer"); 1666 LOG_FUNCTION_NAME_EXIT; 1667 return BAD_VALUE; 1668 } 1669 1670 android::GraphicBufferAllocator &GrallocAlloc = android::GraphicBufferAllocator::get(); 1671 1672 for(int i = 0; i < count; i++){ 1673 CAMHAL_LOGVB("Free Video Gralloc Handle 0x%x", bufs[i].opaque); 1674 GrallocAlloc.free((buffer_handle_t)bufs[i].opaque); 1675 } 1676 1677 LOG_FUNCTION_NAME_EXIT; 1678 1679 return ret; 1680} 1681 1682status_t CameraHal::freeRawBufs() 1683{ 1684 status_t ret = NO_ERROR; 1685 1686 LOG_FUNCTION_NAME 1687 1688 if ( NO_ERROR == ret ) { 1689 if( NULL != mVideoBuffers ) { 1690 ///@todo Pluralise the name of this method to freeBuffers 1691 ret = mMemoryManager->freeBufferList(mVideoBuffers); 1692 mVideoBuffers = NULL; 1693 } else { 1694 ret = -EINVAL; 1695 } 1696 } 1697 1698 LOG_FUNCTION_NAME_EXIT 1699 1700 return ret; 1701} 1702 1703/** 1704 @brief Start preview mode. 1705 1706 @param none 1707 @return NO_ERROR Camera switched to VF mode 1708 @todo Update function header with the different errors that are possible 1709 1710 */ 1711status_t CameraHal::startPreview() { 1712 LOG_FUNCTION_NAME; 1713 1714 // When tunneling is enabled during VTC, startPreview happens in 2 steps: 1715 // When the application sends the command CAMERA_CMD_PREVIEW_INITIALIZATION, 1716 // cameraPreviewInitialization() is called, which in turn causes the CameraAdapter 1717 // to move from loaded to idle state. And when the application calls startPreview, 1718 // the CameraAdapter moves from idle to executing state. 1719 // 1720 // If the application calls startPreview() without sending the command 1721 // CAMERA_CMD_PREVIEW_INITIALIZATION, then the function cameraPreviewInitialization() 1722 // AND startPreview() are executed. In other words, if the application calls 1723 // startPreview() without sending the command CAMERA_CMD_PREVIEW_INITIALIZATION, 1724 // then the CameraAdapter moves from loaded to idle to executing state in one shot. 1725 status_t ret = cameraPreviewInitialization(); 1726 1727 // The flag mPreviewInitializationDone is set to true at the end of the function 1728 // cameraPreviewInitialization(). Therefore, if everything goes alright, then the 1729 // flag will be set. Sometimes, the function cameraPreviewInitialization() may 1730 // return prematurely if all the resources are not available for starting preview. 1731 // For example, if the preview window is not set, then it would return NO_ERROR. 1732 // Under such circumstances, one should return from startPreview as well and should 1733 // not continue execution. That is why, we check the flag and not the return value. 1734 if (!mPreviewInitializationDone) return ret; 1735 1736 // Once startPreview is called, there is no need to continue to remember whether 1737 // the function cameraPreviewInitialization() was called earlier or not. And so 1738 // the flag mPreviewInitializationDone is reset here. Plus, this preserves the 1739 // current behavior of startPreview under the circumstances where the application 1740 // calls startPreview twice or more. 1741 mPreviewInitializationDone = false; 1742 1743 ///Enable the display adapter if present, actual overlay enable happens when we post the buffer 1744 if(mDisplayAdapter.get() != NULL) { 1745 CAMHAL_LOGDA("Enabling display"); 1746 int width, height; 1747 mParameters.getPreviewSize(&width, &height); 1748 1749#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1750 ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview); 1751#else 1752 ret = mDisplayAdapter->enableDisplay(width, height, NULL); 1753#endif 1754 1755 if ( ret != NO_ERROR ) { 1756 CAMHAL_LOGEA("Couldn't enable display"); 1757 1758 // FIXME: At this stage mStateSwitchLock is locked and unlock is supposed to be called 1759 // only from mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW) 1760 // below. But this will never happen because of goto error. Thus at next 1761 // startPreview() call CameraHAL will be deadlocked. 1762 // Need to revisit mStateSwitch lock, for now just abort the process. 1763 CAMHAL_ASSERT_X(false, 1764 "At this stage mCameraAdapter->mStateSwitchLock is still locked, " 1765 "deadlock is guaranteed"); 1766 1767 goto error; 1768 } 1769 1770 } 1771 1772 ///Send START_PREVIEW command to adapter 1773 CAMHAL_LOGDA("Starting CameraAdapter preview mode"); 1774 1775 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW); 1776 1777 if(ret!=NO_ERROR) { 1778 CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter"); 1779 goto error; 1780 } 1781 CAMHAL_LOGDA("Started preview"); 1782 1783 mPreviewEnabled = true; 1784 mPreviewStartInProgress = false; 1785 return ret; 1786 1787 error: 1788 1789 CAMHAL_LOGEA("Performing cleanup after error"); 1790 1791 //Do all the cleanup 1792 freePreviewBufs(); 1793 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW); 1794 if(mDisplayAdapter.get() != NULL) { 1795 mDisplayAdapter->disableDisplay(false); 1796 } 1797 mAppCallbackNotifier->stop(); 1798 mPreviewStartInProgress = false; 1799 mPreviewEnabled = false; 1800 LOG_FUNCTION_NAME_EXIT; 1801 1802 return ret; 1803} 1804 1805//////////// 1806/** 1807 @brief Set preview mode related initialization 1808 -> Camera Adapter set params 1809 -> Allocate buffers 1810 -> Set use buffers for preview 1811 @param none 1812 @return NO_ERROR 1813 @todo Update function header with the different errors that are possible 1814 1815 */ 1816status_t CameraHal::cameraPreviewInitialization() 1817{ 1818 1819 status_t ret = NO_ERROR; 1820 CameraAdapter::BuffersDescriptor desc; 1821 CameraFrame frame; 1822 unsigned int required_buffer_count; 1823 unsigned int max_queueble_buffers; 1824 1825#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1826 gettimeofday(&mStartPreview, NULL); 1827#endif 1828 1829 LOG_FUNCTION_NAME; 1830 1831 if (mPreviewInitializationDone) { 1832 return NO_ERROR; 1833 } 1834 1835 if ( mPreviewEnabled ){ 1836 CAMHAL_LOGDA("Preview already running"); 1837 LOG_FUNCTION_NAME_EXIT; 1838 return ALREADY_EXISTS; 1839 } 1840 1841 if ( NULL != mCameraAdapter ) { 1842 ret = mCameraAdapter->setParameters(mParameters); 1843 } 1844 1845 if ((mPreviewStartInProgress == false) && (mDisplayPaused == false)){ 1846 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,( int ) &frame); 1847 if ( NO_ERROR != ret ){ 1848 CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d", ret); 1849 return ret; 1850 } 1851 1852 ///Update the current preview width and height 1853 mPreviewWidth = frame.mWidth; 1854 mPreviewHeight = frame.mHeight; 1855 } 1856 1857 ///If we don't have the preview callback enabled and display adapter, 1858 if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)){ 1859 CAMHAL_LOGD("Preview not started. Preview in progress flag set"); 1860 mPreviewStartInProgress = true; 1861 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING); 1862 if ( NO_ERROR != ret ){ 1863 CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d", ret); 1864 return ret; 1865 } 1866 return NO_ERROR; 1867 } 1868 1869 if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) ) 1870 { 1871 CAMHAL_LOGDA("Preview is in paused state"); 1872 1873 mDisplayPaused = false; 1874 mPreviewEnabled = true; 1875 if ( NO_ERROR == ret ) 1876 { 1877 ret = mDisplayAdapter->pauseDisplay(mDisplayPaused); 1878 1879 if ( NO_ERROR != ret ) 1880 { 1881 CAMHAL_LOGEB("Display adapter resume failed %x", ret); 1882 } 1883 } 1884 //restart preview callbacks 1885 if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) 1886 { 1887 mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME); 1888 } 1889 1890 signalEndImageCapture(); 1891 return ret; 1892 } 1893 1894 required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); 1895 1896 ///Allocate the preview buffers 1897 ret = allocPreviewBufs(mPreviewWidth, mPreviewHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers); 1898 1899 if ( NO_ERROR != ret ) 1900 { 1901 CAMHAL_LOGEA("Couldn't allocate buffers for Preview"); 1902 goto error; 1903 } 1904 1905 if ( mMeasurementEnabled ) 1906 { 1907 1908 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA, 1909 ( int ) &frame, 1910 required_buffer_count); 1911 if ( NO_ERROR != ret ) 1912 { 1913 return ret; 1914 } 1915 1916 ///Allocate the preview data buffers 1917 ret = allocPreviewDataBufs(frame.mLength, required_buffer_count); 1918 if ( NO_ERROR != ret ) { 1919 CAMHAL_LOGEA("Couldn't allocate preview data buffers"); 1920 goto error; 1921 } 1922 1923 if ( NO_ERROR == ret ) 1924 { 1925 desc.mBuffers = mPreviewDataBuffers; 1926 desc.mOffsets = mPreviewDataOffsets; 1927 desc.mFd = mPreviewDataFd; 1928 desc.mLength = mPreviewDataLength; 1929 desc.mCount = ( size_t ) required_buffer_count; 1930 desc.mMaxQueueable = (size_t) required_buffer_count; 1931 1932 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA, 1933 ( int ) &desc); 1934 } 1935 1936 } 1937 1938 ///Pass the buffers to Camera Adapter 1939 desc.mBuffers = mPreviewBuffers; 1940 desc.mOffsets = mPreviewOffsets; 1941 desc.mFd = mPreviewFd; 1942 desc.mLength = mPreviewLength; 1943 desc.mCount = ( size_t ) required_buffer_count; 1944 desc.mMaxQueueable = (size_t) max_queueble_buffers; 1945 1946 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW, 1947 ( int ) &desc); 1948 1949 if ( NO_ERROR != ret ) 1950 { 1951 CAMHAL_LOGEB("Failed to register preview buffers: 0x%x", ret); 1952 freePreviewBufs(); 1953 return ret; 1954 } 1955 1956 ///Start the callback notifier 1957 ret = mAppCallbackNotifier->start(); 1958 1959 if( ALREADY_EXISTS == ret ) 1960 { 1961 //Already running, do nothing 1962 CAMHAL_LOGDA("AppCallbackNotifier already running"); 1963 ret = NO_ERROR; 1964 } 1965 else if ( NO_ERROR == ret ) { 1966 CAMHAL_LOGDA("Started AppCallbackNotifier.."); 1967 mAppCallbackNotifier->setMeasurements(mMeasurementEnabled); 1968 } 1969 else 1970 { 1971 CAMHAL_LOGDA("Couldn't start AppCallbackNotifier"); 1972 goto error; 1973 } 1974 1975 if (ret == NO_ERROR) mPreviewInitializationDone = true; 1976 1977 mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count); 1978 1979 return ret; 1980 1981 error: 1982 1983 CAMHAL_LOGEA("Performing cleanup after error"); 1984 1985 //Do all the cleanup 1986 freePreviewBufs(); 1987 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW); 1988 if(mDisplayAdapter.get() != NULL) 1989 { 1990 mDisplayAdapter->disableDisplay(false); 1991 } 1992 mAppCallbackNotifier->stop(); 1993 mPreviewStartInProgress = false; 1994 mPreviewEnabled = false; 1995 LOG_FUNCTION_NAME_EXIT; 1996 1997 return ret; 1998} 1999 2000/** 2001 @brief Sets ANativeWindow object. 2002 2003 Preview buffers provided to CameraHal via this object. DisplayAdapter will be interfacing with it 2004 to render buffers to display. 2005 2006 @param[in] window The ANativeWindow object created by Surface flinger 2007 @return NO_ERROR If the ANativeWindow object passes validation criteria 2008 @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios 2009 2010 */ 2011status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window) 2012{ 2013 status_t ret = NO_ERROR; 2014 CameraAdapter::BuffersDescriptor desc; 2015 2016 LOG_FUNCTION_NAME; 2017 mSetPreviewWindowCalled = true; 2018 2019 ///If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter 2020 if(!window) 2021 { 2022 if(mDisplayAdapter.get() != NULL) 2023 { 2024 ///NULL window passed, destroy the display adapter if present 2025 CAMHAL_LOGD("NULL window passed, destroying display adapter"); 2026 mDisplayAdapter.clear(); 2027 ///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client 2028 ///@remarks so, we will wait until it passes a valid window to begin the preview again 2029 mSetPreviewWindowCalled = false; 2030 } 2031 CAMHAL_LOGD("NULL ANativeWindow passed to setPreviewWindow"); 2032 return NO_ERROR; 2033 }else if(mDisplayAdapter.get() == NULL) 2034 { 2035 // Need to create the display adapter since it has not been created 2036 // Create display adapter 2037 mDisplayAdapter = new ANativeWindowDisplayAdapter(); 2038#ifdef OMAP_ENHANCEMENT 2039 mDisplayAdapter->setExtendedOps(mExtendedPreviewStreamOps); 2040#endif 2041 ret = NO_ERROR; 2042 if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR)) 2043 { 2044 if(ret!=NO_ERROR) 2045 { 2046 mDisplayAdapter.clear(); 2047 CAMHAL_LOGEA("DisplayAdapter initialize failed"); 2048 LOG_FUNCTION_NAME_EXIT; 2049 return ret; 2050 } 2051 else 2052 { 2053 CAMHAL_LOGEA("Couldn't create DisplayAdapter"); 2054 LOG_FUNCTION_NAME_EXIT; 2055 return NO_MEMORY; 2056 } 2057 } 2058 2059 // DisplayAdapter needs to know where to get the CameraFrames from inorder to display 2060 // Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter 2061 mDisplayAdapter->setFrameProvider(mCameraAdapter); 2062 2063 // Any dynamic errors that happen during the camera use case has to be propagated back to the application 2064 // via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application 2065 // Set it as the error handler for the DisplayAdapter 2066 mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get()); 2067 2068 // Update the display adapter with the new window that is passed from CameraService 2069 ret = mDisplayAdapter->setPreviewWindow(window); 2070 if(ret!=NO_ERROR) 2071 { 2072 CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret); 2073 } 2074 2075 if(mPreviewStartInProgress) 2076 { 2077 CAMHAL_LOGDA("setPreviewWindow called when preview running"); 2078 // Start the preview since the window is now available 2079 ret = startPreview(); 2080 } 2081 } else { 2082 // Update the display adapter with the new window that is passed from CameraService 2083 ret = mDisplayAdapter->setPreviewWindow(window); 2084 if ( (NO_ERROR == ret) && previewEnabled() ) { 2085 restartPreview(); 2086 } else if (ret == ALREADY_EXISTS) { 2087 // ALREADY_EXISTS should be treated as a noop in this case 2088 ret = NO_ERROR; 2089 } 2090 } 2091 LOG_FUNCTION_NAME_EXIT; 2092 2093 return ret; 2094 2095} 2096 2097 2098#ifdef OMAP_ENHANCEMENT_CPCAM 2099void CameraHal::setExtendedPreviewStreamOps(preview_stream_extended_ops_t *ops) 2100{ 2101 mExtendedPreviewStreamOps = ops; 2102} 2103 2104/** 2105 @brief Sets Tapout Surfaces. 2106 2107 Buffers provided to CameraHal via this object for tap-out 2108 functionality. 2109 2110 @param[in] window The ANativeWindow object created by Surface flinger 2111 @return NO_ERROR If the ANativeWindow object passes validation criteria 2112 @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios 2113 2114 */ 2115status_t CameraHal::setTapoutLocked(struct preview_stream_ops *tapout) 2116{ 2117 status_t ret = NO_ERROR; 2118 int index = -1; 2119 2120 LOG_FUNCTION_NAME; 2121 2122 if (!tapout) { 2123 CAMHAL_LOGD("Missing argument"); 2124 LOG_FUNCTION_NAME_EXIT; 2125 return NO_ERROR; 2126 } 2127 2128 // Set tapout point 2129 // 1. Check name of tap-out 2130 // 2. If not already set, then create a new one 2131 // 3. Allocate buffers. If user is re-setting the surface, free buffers first and re-allocate 2132 // in case dimensions have changed 2133 2134 for (unsigned int i = 0; i < mOutAdapters.size(); i++) { 2135 android::sp<DisplayAdapter> out; 2136 out = mOutAdapters.itemAt(i); 2137 ret = out->setPreviewWindow(tapout); 2138 if (ret == ALREADY_EXISTS) { 2139 CAMHAL_LOGD("Tap Out already set at index = %d", i); 2140 index = i; 2141 ret = NO_ERROR; 2142 } 2143 } 2144 2145 if (index < 0) { 2146 android::sp<DisplayAdapter> out = new BufferSourceAdapter(); 2147 2148 ret = out->initialize(); 2149 if (ret != NO_ERROR) { 2150 out.clear(); 2151 CAMHAL_LOGEA("DisplayAdapter initialize failed"); 2152 goto exit; 2153 } 2154 2155 // BufferSourceAdapter will be handler of the extended OPS 2156 out->setExtendedOps(mExtendedPreviewStreamOps); 2157 2158 // CameraAdapter will be the frame provider for BufferSourceAdapter 2159 out->setFrameProvider(mCameraAdapter); 2160 2161 // BufferSourceAdapter will use ErrorHandler to send errors back to 2162 // the application 2163 out->setErrorHandler(mAppCallbackNotifier.get()); 2164 2165 // Update the display adapter with the new window that is passed from CameraService 2166 ret = out->setPreviewWindow(tapout); 2167 if(ret != NO_ERROR) { 2168 CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret); 2169 goto exit; 2170 } 2171 2172 mOutAdapters.add(out); 2173 } 2174 2175exit: 2176 2177 LOG_FUNCTION_NAME_EXIT; 2178 2179 return ret; 2180} 2181 2182/** 2183 @brief Releases Tapout Surfaces. 2184 2185 @param[in] window The ANativeWindow object created by Surface flinger 2186 @return NO_ERROR If the ANativeWindow object passes validation criteria 2187 @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios 2188 2189 */ 2190status_t CameraHal::releaseTapoutLocked(struct preview_stream_ops *tapout) 2191{ 2192 status_t ret = NO_ERROR; 2193 char id[OP_STR_SIZE]; 2194 2195 LOG_FUNCTION_NAME; 2196 2197 if (!tapout) { 2198 CAMHAL_LOGD("Missing argument"); 2199 LOG_FUNCTION_NAME_EXIT; 2200 return NO_ERROR; 2201 } 2202 2203 // Get the name of tapout 2204 ret = mExtendedPreviewStreamOps->get_id(tapout, id, sizeof(id)); 2205 if (NO_ERROR != ret) { 2206 CAMHAL_LOGEB("get_id OPS returned error %d", ret); 2207 return ret; 2208 } 2209 2210 // 1. Check name of tap-out 2211 // 2. If exist, then free buffers and then remove it 2212 if (mBufferSourceAdapter_Out.get() && mBufferSourceAdapter_Out->match(id)) { 2213 CAMHAL_LOGD("REMOVE tap out %p previously set as current", tapout); 2214 mBufferSourceAdapter_Out.clear(); 2215 } 2216 for (unsigned int i = 0; i < mOutAdapters.size(); i++) { 2217 android::sp<DisplayAdapter> out; 2218 out = mOutAdapters.itemAt(i); 2219 if (out->match(id)) { 2220 CAMHAL_LOGD("REMOVE tap out %p \"%s\" at position %d", tapout, id, i); 2221 out->freeBufferList(out->getBuffers()); 2222 mOutAdapters.removeAt(i); 2223 break; 2224 } 2225 } 2226 2227 LOG_FUNCTION_NAME_EXIT; 2228 2229 return ret; 2230} 2231 2232/** 2233 @brief Sets Tapin Surfaces. 2234 2235 Buffers provided to CameraHal via this object for tap-in 2236 functionality. 2237 2238 @param[in] window The ANativeWindow object created by Surface flinger 2239 @return NO_ERROR If the ANativeWindow object passes validation criteria 2240 @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios 2241 2242 */ 2243status_t CameraHal::setTapinLocked(struct preview_stream_ops *tapin) 2244{ 2245 status_t ret = NO_ERROR; 2246 int index = -1; 2247 2248 LOG_FUNCTION_NAME; 2249 2250 if (!tapin) { 2251 CAMHAL_LOGD("Missing argument"); 2252 LOG_FUNCTION_NAME_EXIT; 2253 return NO_ERROR; 2254 } 2255 2256 // 1. Set tapin point 2257 // 1. Check name of tap-in 2258 // 2. If not already set, then create a new one 2259 // 3. Allocate buffers. If user is re-setting the surface, free buffers first and re-allocate 2260 // in case dimensions have changed 2261 for (unsigned int i = 0; i < mInAdapters.size(); i++) { 2262 android::sp<DisplayAdapter> in; 2263 in = mInAdapters.itemAt(i); 2264 ret = in->setPreviewWindow(tapin); 2265 if (ret == ALREADY_EXISTS) { 2266 CAMHAL_LOGD("Tap In already set at index = %d", i); 2267 index = i; 2268 ret = NO_ERROR; 2269 } 2270 } 2271 2272 if (index < 0) { 2273 android::sp<DisplayAdapter> in = new BufferSourceAdapter(); 2274 2275 ret = in->initialize(); 2276 if (ret != NO_ERROR) { 2277 in.clear(); 2278 CAMHAL_LOGEA("DisplayAdapter initialize failed"); 2279 goto exit; 2280 } 2281 2282 // BufferSourceAdapter will be handler of the extended OPS 2283 in->setExtendedOps(mExtendedPreviewStreamOps); 2284 2285 // CameraAdapter will be the frame provider for BufferSourceAdapter 2286 in->setFrameProvider(mCameraAdapter); 2287 2288 // BufferSourceAdapter will use ErrorHandler to send errors back to 2289 // the application 2290 in->setErrorHandler(mAppCallbackNotifier.get()); 2291 2292 // Update the display adapter with the new window that is passed from CameraService 2293 ret = in->setPreviewWindow(tapin); 2294 if(ret != NO_ERROR) { 2295 CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret); 2296 goto exit; 2297 } 2298 2299 mInAdapters.add(in); 2300 } 2301 2302exit: 2303 2304 LOG_FUNCTION_NAME_EXIT; 2305 2306 return ret; 2307} 2308 2309 2310/** 2311 @brief Releases Tapin Surfaces. 2312 2313 @param[in] window The ANativeWindow object created by Surface flinger 2314 @return NO_ERROR If the ANativeWindow object passes validation criteria 2315 @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios 2316 2317 */ 2318status_t CameraHal::releaseTapinLocked(struct preview_stream_ops *tapin) 2319{ 2320 status_t ret = NO_ERROR; 2321 char id[OP_STR_SIZE]; 2322 2323 LOG_FUNCTION_NAME; 2324 2325 if (!tapin) { 2326 CAMHAL_LOGD("Missing argument"); 2327 LOG_FUNCTION_NAME_EXIT; 2328 return NO_ERROR; 2329 } 2330 2331 // Get the name of tapin 2332 ret = mExtendedPreviewStreamOps->get_id(tapin, id, sizeof(id)); 2333 if (NO_ERROR != ret) { 2334 CAMHAL_LOGEB("get_id OPS returned error %d", ret); 2335 return ret; 2336 } 2337 2338 // 1. Check name of tap-in 2339 // 2. If exist, then free buffers and then remove it 2340 if (mBufferSourceAdapter_In.get() && mBufferSourceAdapter_In->match(id)) { 2341 CAMHAL_LOGD("REMOVE tap in %p previously set as current", tapin); 2342 mBufferSourceAdapter_In.clear(); 2343 } 2344 for (unsigned int i = 0; i < mInAdapters.size(); i++) { 2345 android::sp<DisplayAdapter> in; 2346 in = mInAdapters.itemAt(i); 2347 if (in->match(id)) { 2348 CAMHAL_LOGD("REMOVE tap in %p \"%s\" at position %d", tapin, id, i); 2349 in->freeBufferList(in->getBuffers()); 2350 mInAdapters.removeAt(i); 2351 break; 2352 } 2353 } 2354 2355 LOG_FUNCTION_NAME_EXIT; 2356 2357 return ret; 2358} 2359 2360 2361/** 2362 @brief Sets ANativeWindow object. 2363 2364 Buffers provided to CameraHal via this object for tap-in/tap-out 2365 functionality. 2366 2367 TODO(XXX): this is just going to use preview_stream_ops for now, but we 2368 most likely need to extend it when we want more functionality 2369 2370 @param[in] window The ANativeWindow object created by Surface flinger 2371 @return NO_ERROR If the ANativeWindow object passes validation criteria 2372 @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios 2373 2374 */ 2375status_t CameraHal::setBufferSource(struct preview_stream_ops *tapin, struct preview_stream_ops *tapout) 2376{ 2377 status_t ret = NO_ERROR; 2378 int index = -1; 2379 2380 LOG_FUNCTION_NAME; 2381 2382 android::AutoMutex lock(mLock); 2383 2384 CAMHAL_LOGD ("setBufferSource(%p, %p)", tapin, tapout); 2385 2386 ret = setTapoutLocked(tapout); 2387 if (ret != NO_ERROR) { 2388 CAMHAL_LOGE("setTapoutLocked returned error 0x%x", ret); 2389 goto exit; 2390 } 2391 2392 ret = setTapinLocked(tapin); 2393 if (ret != NO_ERROR) { 2394 CAMHAL_LOGE("setTapinLocked returned error 0x%x", ret); 2395 goto exit; 2396 } 2397 2398exit: 2399 LOG_FUNCTION_NAME_EXIT; 2400 2401 return ret; 2402} 2403 2404 2405/** 2406 @brief Releases ANativeWindow object. 2407 2408 Release Buffers previously released with setBufferSource() 2409 2410 TODO(XXX): this is just going to use preview_stream_ops for now, but we 2411 most likely need to extend it when we want more functionality 2412 2413 @param[in] window The ANativeWindow object created by Surface flinger 2414 @return NO_ERROR If the ANativeWindow object passes validation criteria 2415 @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios 2416 2417 */ 2418status_t CameraHal::releaseBufferSource(struct preview_stream_ops *tapin, struct preview_stream_ops *tapout) 2419{ 2420 status_t ret = NO_ERROR; 2421 int index = -1; 2422 2423 LOG_FUNCTION_NAME; 2424 2425 android::AutoMutex lock(mLock); 2426 CAMHAL_LOGD ("releaseBufferSource(%p, %p)", tapin, tapout); 2427 if (tapout) { 2428 ret |= releaseTapoutLocked(tapout); 2429 if (ret != NO_ERROR) { 2430 CAMHAL_LOGE("Error %d to release tap out", ret); 2431 } 2432 } 2433 2434 if (tapin) { 2435 ret |= releaseTapinLocked(tapin); 2436 if (ret != NO_ERROR) { 2437 CAMHAL_LOGE("Error %d to release tap in", ret); 2438 } 2439 } 2440 2441exit: 2442 2443 LOG_FUNCTION_NAME_EXIT; 2444 2445 return ret; 2446} 2447#endif 2448 2449 2450/** 2451 @brief Stop a previously started preview. 2452 2453 @param none 2454 @return none 2455 2456 */ 2457void CameraHal::stopPreview() 2458{ 2459 LOG_FUNCTION_NAME; 2460 2461 if( (!previewEnabled() && !mDisplayPaused) || mRecordingEnabled) 2462 { 2463 LOG_FUNCTION_NAME_EXIT; 2464 return; 2465 } 2466 2467 bool imageCaptureRunning = (mCameraAdapter->getState() & CameraAdapter::CAPTURE_STATE) && 2468 (mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE); 2469 if(mDisplayPaused && !imageCaptureRunning) 2470 { 2471 // Display is paused, which essentially means there is no preview active. 2472 // Note: this is done so that when stopPreview is called by client after 2473 // an image capture, we do not de-initialize the camera adapter and 2474 // restart over again. 2475 2476 return; 2477 } 2478 2479 forceStopPreview(); 2480 2481 // Reset Capture-Mode to default, so that when we switch from VideoRecording 2482 // to ImageCapture, CAPTURE_MODE is not left to VIDEO_MODE. 2483 CAMHAL_LOGDA("Resetting Capture-Mode to default"); 2484 mParameters.set(TICameraParameters::KEY_CAP_MODE, ""); 2485 2486 LOG_FUNCTION_NAME_EXIT; 2487} 2488 2489/** 2490 @brief Returns true if preview is enabled 2491 2492 @param none 2493 @return true If preview is running currently 2494 false If preview has been stopped 2495 2496 */ 2497bool CameraHal::previewEnabled() 2498{ 2499 LOG_FUNCTION_NAME; 2500 2501 return (mPreviewEnabled || mPreviewStartInProgress); 2502} 2503 2504/** 2505 @brief Start record mode. 2506 2507 When a record image is available a CAMERA_MSG_VIDEO_FRAME message is sent with 2508 the corresponding frame. Every record frame must be released by calling 2509 releaseRecordingFrame(). 2510 2511 @param none 2512 @return NO_ERROR If recording could be started without any issues 2513 @todo Update the header with possible error values in failure scenarios 2514 2515 */ 2516status_t CameraHal::startRecording( ) 2517{ 2518 int w, h; 2519 const char *valstr = NULL; 2520 bool restartPreviewRequired = false; 2521 status_t ret = NO_ERROR; 2522 2523 LOG_FUNCTION_NAME; 2524 2525 2526#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2527 2528 gettimeofday(&mStartPreview, NULL); 2529 2530#endif 2531 2532 if(!previewEnabled()) 2533 { 2534 return NO_INIT; 2535 } 2536 2537 // set internal recording hint in case camera adapter needs to make some 2538 // decisions....(will only be sent to camera adapter if camera restart is required) 2539 mParameters.set(TICameraParameters::KEY_RECORDING_HINT, android::CameraParameters::TRUE); 2540 2541 // if application starts recording in continuous focus picture mode... 2542 // then we need to force default capture mode (as opposed to video mode) 2543 if ( ((valstr = mParameters.get(android::CameraParameters::KEY_FOCUS_MODE)) != NULL) && 2544 (strcmp(valstr, android::CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0) ){ 2545 restartPreviewRequired = resetVideoModeParameters(); 2546 } 2547 2548 // only need to check recording hint if preview restart is not already needed 2549 valstr = mParameters.get(android::CameraParameters::KEY_RECORDING_HINT); 2550 if ( !restartPreviewRequired && 2551 (!valstr || (valstr && (strcmp(valstr, android::CameraParameters::TRUE) != 0))) ) { 2552 restartPreviewRequired = setVideoModeParameters(mParameters); 2553 } 2554 2555 if (restartPreviewRequired) { 2556 { 2557 android::AutoMutex lock(mLock); 2558 mCapModeBackup = mParameters.get(TICameraParameters::KEY_CAP_MODE); 2559 } 2560 ret = restartPreview(); 2561 } 2562 2563 if ( NO_ERROR == ret ) 2564 { 2565 int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); 2566 mParameters.getPreviewSize(&w, &h); 2567 CAMHAL_LOGDB("%s Video Width=%d Height=%d", __FUNCTION__, mVideoWidth, mVideoHeight); 2568 2569 if ((w != mVideoWidth) && (h != mVideoHeight)) 2570 { 2571 ret = allocVideoBufs(mVideoWidth, mVideoHeight, count); 2572 if ( NO_ERROR != ret ) 2573 { 2574 CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); 2575 mParameters.remove(TICameraParameters::KEY_RECORDING_HINT); 2576 return ret; 2577 } 2578 2579 mAppCallbackNotifier->useVideoBuffers(true); 2580 mAppCallbackNotifier->setVideoRes(mVideoWidth, mVideoHeight); 2581 ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, count, mVideoBuffers); 2582 } 2583 else 2584 { 2585 mAppCallbackNotifier->useVideoBuffers(false); 2586 mAppCallbackNotifier->setVideoRes(mPreviewWidth, mPreviewHeight); 2587 ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, count, NULL); 2588 } 2589 } 2590 2591 if ( NO_ERROR == ret ) 2592 { 2593 ret = mAppCallbackNotifier->startRecording(); 2594 } 2595 2596 if ( NO_ERROR == ret ) 2597 { 2598 ///Buffers for video capture (if different from preview) are expected to be allocated within CameraAdapter 2599 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_VIDEO); 2600 } 2601 2602 if ( NO_ERROR == ret ) 2603 { 2604 mRecordingEnabled = true; 2605 } 2606 2607 LOG_FUNCTION_NAME_EXIT; 2608 2609 return ret; 2610} 2611 2612/** 2613 @brief Set the camera parameters specific to Video Recording. 2614 2615 This function checks for the camera parameters which have to be set for recording. 2616 Video Recording needs CAPTURE_MODE to be VIDEO_MODE. This function sets it. 2617 This function also enables Video Recording specific functions like VSTAB & VNF. 2618 2619 @param none 2620 @return true if preview needs to be restarted for VIDEO_MODE parameters to take effect. 2621 @todo Modify the policies for enabling VSTAB & VNF usecase based later. 2622 2623 */ 2624bool CameraHal::setVideoModeParameters(const android::CameraParameters& params) 2625{ 2626 const char *valstr = NULL; 2627 const char *valstrRemote = NULL; 2628 bool restartPreviewRequired = false; 2629 2630 LOG_FUNCTION_NAME; 2631 2632 // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview 2633 valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); 2634 if ( (valstr == NULL) || 2635 ( (valstr != NULL) && ( (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) != 0) && 2636 (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE_HQ ) != 0) ) ) ) { 2637 CAMHAL_LOGDA("Set CAPTURE_MODE to VIDEO_MODE"); 2638 mParameters.set(TICameraParameters::KEY_CAP_MODE, (const char *) TICameraParameters::VIDEO_MODE); 2639 restartPreviewRequired = true; 2640 } 2641 2642 // set VSTAB. restart is required if vstab value has changed 2643 if ( (valstrRemote = params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION)) != NULL ) { 2644 // make sure we support vstab 2645 if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED), 2646 android::CameraParameters::TRUE) == 0) { 2647 valstr = mParameters.get(android::CameraParameters::KEY_VIDEO_STABILIZATION); 2648 // vstab value has changed 2649 if ((valstr != NULL) && 2650 strcmp(valstr, valstrRemote) != 0) { 2651 restartPreviewRequired = true; 2652 } 2653 mParameters.set(android::CameraParameters::KEY_VIDEO_STABILIZATION, 2654 valstrRemote); 2655 } 2656 } else if (mParameters.get(android::CameraParameters::KEY_VIDEO_STABILIZATION)) { 2657 // vstab was configured but now unset 2658 restartPreviewRequired = true; 2659 mParameters.remove(android::CameraParameters::KEY_VIDEO_STABILIZATION); 2660 } 2661 2662 // Set VNF 2663 if ((valstrRemote = params.get(TICameraParameters::KEY_VNF)) == NULL) { 2664 CAMHAL_LOGDA("Enable VNF"); 2665 mParameters.set(TICameraParameters::KEY_VNF, android::CameraParameters::TRUE); 2666 restartPreviewRequired = true; 2667 } else { 2668 valstr = mParameters.get(TICameraParameters::KEY_VNF); 2669 if (valstr && strcmp(valstr, valstrRemote) != 0) { 2670 restartPreviewRequired = true; 2671 } 2672 mParameters.set(TICameraParameters::KEY_VNF, valstrRemote); 2673 } 2674 2675#if !defined(OMAP_ENHANCEMENT) && !defined(ENHANCED_DOMX) 2676 // For VSTAB alone for 1080p resolution, padded width goes > 2048, which cannot be rendered by GPU. 2677 // In such case, there is support in Ducati for combination of VSTAB & VNF requiring padded width < 2048. 2678 // So we are forcefully enabling VNF, if VSTAB is enabled for 1080p resolution. 2679 int w, h; 2680 params.getPreviewSize(&w, &h); 2681 valstr = mParameters.get(android::CameraParameters::KEY_VIDEO_STABILIZATION); 2682 if (valstr && (strcmp(valstr, android::CameraParameters::TRUE) == 0) && (w == 1920)) { 2683 CAMHAL_LOGDA("Force Enable VNF for 1080p"); 2684 const char *valKeyVnf = mParameters.get(TICameraParameters::KEY_VNF); 2685 if(!valKeyVnf || (strcmp(valKeyVnf, android::CameraParameters::TRUE) != 0)) { 2686 mParameters.set(TICameraParameters::KEY_VNF, android::CameraParameters::TRUE); 2687 restartPreviewRequired = true; 2688 } 2689 } 2690#endif 2691 2692 LOG_FUNCTION_NAME_EXIT; 2693 2694 return restartPreviewRequired; 2695} 2696 2697/** 2698 @brief Reset the camera parameters specific to Video Recording. 2699 2700 This function resets CAPTURE_MODE and disables Recording specific functions like VSTAB & VNF. 2701 2702 @param none 2703 @return true if preview needs to be restarted for VIDEO_MODE parameters to take effect. 2704 2705 */ 2706bool CameraHal::resetVideoModeParameters() 2707{ 2708 const char *valstr = NULL; 2709 bool restartPreviewRequired = false; 2710 status_t ret = NO_ERROR; 2711 2712 LOG_FUNCTION_NAME; 2713 2714 // ignore this if we are already recording 2715 if (mRecordingEnabled) { 2716 return false; 2717 } 2718 2719 // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview 2720 valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); 2721 if ((valstr != NULL) && (strcmp(valstr, TICameraParameters::VIDEO_MODE) == 0)) { 2722 CAMHAL_LOGDA("Reset Capture-Mode to default"); 2723 mParameters.set(TICameraParameters::KEY_CAP_MODE, ""); 2724 restartPreviewRequired = true; 2725 } 2726 2727 LOG_FUNCTION_NAME_EXIT; 2728 2729 return restartPreviewRequired; 2730} 2731 2732/** 2733 @brief Restart the preview with setParameter. 2734 2735 This function restarts preview, for some VIDEO_MODE parameters to take effect. 2736 2737 @param none 2738 @return NO_ERROR If recording parameters could be set without any issues 2739 2740 */ 2741status_t CameraHal::restartPreview() 2742{ 2743 status_t ret = NO_ERROR; 2744 2745 LOG_FUNCTION_NAME; 2746 2747 // Retain CAPTURE_MODE before calling stopPreview(), since it is reset in stopPreview(). 2748 2749 forceStopPreview(); 2750 2751 { 2752 android::AutoMutex lock(mLock); 2753 if (!mCapModeBackup.isEmpty()) { 2754 mParameters.set(TICameraParameters::KEY_CAP_MODE, mCapModeBackup.string()); 2755 mCapModeBackup = ""; 2756 } else { 2757 mParameters.set(TICameraParameters::KEY_CAP_MODE, ""); 2758 } 2759 mCameraAdapter->setParameters(mParameters); 2760 } 2761 2762 ret = startPreview(); 2763 2764 LOG_FUNCTION_NAME_EXIT; 2765 2766 return ret; 2767} 2768 2769/** 2770 @brief Stop a previously started recording. 2771 2772 @param none 2773 @return none 2774 2775 */ 2776void CameraHal::stopRecording() 2777{ 2778 CameraAdapter::AdapterState currentState; 2779 2780 LOG_FUNCTION_NAME; 2781 2782 android::AutoMutex lock(mLock); 2783 2784 if (!mRecordingEnabled ) 2785 { 2786 return; 2787 } 2788 2789 currentState = mCameraAdapter->getState(); 2790 if (currentState == CameraAdapter::VIDEO_CAPTURE_STATE) { 2791 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE); 2792 } 2793 2794 mAppCallbackNotifier->stopRecording(); 2795 2796 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_VIDEO); 2797 2798 mRecordingEnabled = false; 2799 2800 if ( mAppCallbackNotifier->getUesVideoBuffers() ){ 2801 freeVideoBufs(mVideoBuffers); 2802 if (mVideoBuffers){ 2803 CAMHAL_LOGVB(" FREEING mVideoBuffers %p", mVideoBuffers); 2804 delete [] mVideoBuffers; 2805 } 2806 mVideoBuffers = NULL; 2807 } 2808 2809 // reset internal recording hint in case camera adapter needs to make some 2810 // decisions....(will only be sent to camera adapter if camera restart is required) 2811 mParameters.remove(TICameraParameters::KEY_RECORDING_HINT); 2812 2813 LOG_FUNCTION_NAME_EXIT; 2814} 2815 2816/** 2817 @brief Returns true if recording is enabled. 2818 2819 @param none 2820 @return true If recording is currently running 2821 false If recording has been stopped 2822 2823 */ 2824int CameraHal::recordingEnabled() 2825{ 2826 LOG_FUNCTION_NAME; 2827 2828 LOG_FUNCTION_NAME_EXIT; 2829 2830 return mRecordingEnabled; 2831} 2832 2833/** 2834 @brief Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME. 2835 2836 @param[in] mem MemoryBase pointer to the frame being released. Must be one of the buffers 2837 previously given by CameraHal 2838 @return none 2839 2840 */ 2841void CameraHal::releaseRecordingFrame(const void* mem) 2842{ 2843 LOG_FUNCTION_NAME; 2844 2845 //CAMHAL_LOGDB(" 0x%x", mem->pointer()); 2846 2847 if ( ( mRecordingEnabled ) && mem != NULL) 2848 { 2849 mAppCallbackNotifier->releaseRecordingFrame(mem); 2850 } 2851 2852 LOG_FUNCTION_NAME_EXIT; 2853 2854 return; 2855} 2856 2857/** 2858 @brief Start auto focus 2859 2860 This call asynchronous. 2861 The notification callback routine is called with CAMERA_MSG_FOCUS once when 2862 focusing is complete. autoFocus() will be called again if another auto focus is 2863 needed. 2864 2865 @param none 2866 @return NO_ERROR 2867 @todo Define the error codes if the focus is not locked 2868 2869 */ 2870status_t CameraHal::autoFocus() 2871{ 2872 status_t ret = NO_ERROR; 2873 2874#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2875 2876 gettimeofday(&mStartFocus, NULL); 2877 2878#endif 2879 2880 LOG_FUNCTION_NAME; 2881 2882 android::AutoMutex lock(mLock); 2883 2884 mMsgEnabled |= CAMERA_MSG_FOCUS; 2885 2886 if ( NULL == mCameraAdapter ) 2887 { 2888 ret = -1; 2889 goto EXIT; 2890 } 2891 2892 CameraAdapter::AdapterState state; 2893 ret = mCameraAdapter->getState(state); 2894 if (ret != NO_ERROR) 2895 { 2896 goto EXIT; 2897 } 2898 2899 if (state == CameraAdapter::AF_STATE) 2900 { 2901 CAMHAL_LOGI("Ignoring start-AF (already in progress)"); 2902 goto EXIT; 2903 } 2904 2905#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2906 2907 //pass the autoFocus timestamp along with the command to camera adapter 2908 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS, ( int ) &mStartFocus); 2909 2910#else 2911 2912 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS); 2913 2914#endif 2915 2916EXIT: 2917 LOG_FUNCTION_NAME_EXIT; 2918 2919 return ret; 2920} 2921 2922/** 2923 @brief Cancels auto-focus function. 2924 2925 If the auto-focus is still in progress, this function will cancel it. 2926 Whether the auto-focus is in progress or not, this function will return the 2927 focus position to the default. If the camera does not support auto-focus, this is a no-op. 2928 2929 2930 @param none 2931 @return NO_ERROR If the cancel succeeded 2932 @todo Define error codes if cancel didnt succeed 2933 2934 */ 2935status_t CameraHal::cancelAutoFocus() 2936{ 2937 LOG_FUNCTION_NAME; 2938 2939 android::AutoMutex lock(mLock); 2940 android::CameraParameters adapterParams = mParameters; 2941 mMsgEnabled &= ~CAMERA_MSG_FOCUS; 2942 2943 if( NULL != mCameraAdapter ) 2944 { 2945 adapterParams.set(TICameraParameters::KEY_AUTO_FOCUS_LOCK, android::CameraParameters::FALSE); 2946 mCameraAdapter->setParameters(adapterParams); 2947 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS); 2948 mAppCallbackNotifier->flushEventQueue(); 2949 } 2950 2951 LOG_FUNCTION_NAME_EXIT; 2952 return NO_ERROR; 2953} 2954 2955void CameraHal::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier) 2956{ 2957 2958 LOG_FUNCTION_NAME; 2959 2960 if ( NULL != mEventProvider ) 2961 { 2962 mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS); 2963 delete mEventProvider; 2964 mEventProvider = NULL; 2965 } 2966 2967 mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay); 2968 if ( NULL == mEventProvider ) 2969 { 2970 CAMHAL_LOGEA("Error in creating EventProvider"); 2971 } 2972 else 2973 { 2974 mEventProvider->enableEventNotification(eventMask); 2975 } 2976 2977 LOG_FUNCTION_NAME_EXIT; 2978} 2979 2980void CameraHal::eventCallbackRelay(CameraHalEvent* event) 2981{ 2982 LOG_FUNCTION_NAME; 2983 2984 CameraHal *appcbn = ( CameraHal * ) (event->mCookie); 2985 appcbn->eventCallback(event ); 2986 2987 LOG_FUNCTION_NAME_EXIT; 2988} 2989 2990void CameraHal::eventCallback(CameraHalEvent* event) 2991{ 2992 LOG_FUNCTION_NAME; 2993 2994 LOG_FUNCTION_NAME_EXIT; 2995} 2996 2997status_t CameraHal::startImageBracketing() 2998{ 2999 status_t ret = NO_ERROR; 3000 CameraFrame frame; 3001 CameraAdapter::BuffersDescriptor desc; 3002 unsigned int max_queueable = 0; 3003 3004 3005 3006#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 3007 3008 gettimeofday(&mStartCapture, NULL); 3009 3010#endif 3011 3012 LOG_FUNCTION_NAME; 3013 3014 if(!previewEnabled() && !mDisplayPaused) 3015 { 3016 LOG_FUNCTION_NAME_EXIT; 3017 return NO_INIT; 3018 } 3019 3020 if ( !mBracketingEnabled ) 3021 { 3022 return ret; 3023 } 3024 3025 if ( NO_ERROR == ret ) 3026 { 3027 mBracketingRunning = true; 3028 } 3029 3030 if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) 3031 { 3032 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE, 3033 ( int ) &frame, 3034 ( mBracketRangeNegative + 1 )); 3035 3036 if ( NO_ERROR != ret ) 3037 { 3038 CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret); 3039 } 3040 } 3041 3042 if ( NO_ERROR == ret ) 3043 { 3044 if ( NULL != mAppCallbackNotifier.get() ) 3045 { 3046 mAppCallbackNotifier->setBurst(true); 3047 } 3048 } 3049 3050 if ( NO_ERROR == ret ) 3051 { 3052 unsigned int bufferCount = mBracketRangeNegative + 1; 3053 mParameters.getPictureSize(( int * ) &frame.mWidth, 3054 ( int * ) &frame.mHeight); 3055 3056 ret = allocImageBufs(frame.mWidth, 3057 frame.mHeight, 3058 frame.mLength, 3059 mParameters.getPictureFormat(), 3060 bufferCount, 3061 &max_queueable); 3062 mBracketRangeNegative = bufferCount - 1; 3063 if ( NO_ERROR != ret ) 3064 { 3065 CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); 3066 } 3067 } 3068 3069 if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) 3070 { 3071 3072 desc.mBuffers = mImageBuffers; 3073 desc.mOffsets = mImageOffsets; 3074 desc.mFd = mImageFd; 3075 desc.mLength = mImageLength; 3076 desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 ); 3077 desc.mMaxQueueable = ( size_t) max_queueable; 3078 3079 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, 3080 ( int ) &desc); 3081 3082 if ( NO_ERROR == ret ) 3083 { 3084 3085#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 3086 3087 //pass capture timestamp along with the camera adapter command 3088 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ), (int) &mStartCapture); 3089 3090#else 3091 3092 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 )); 3093 3094#endif 3095 3096 } 3097 } 3098 3099 return ret; 3100} 3101 3102status_t CameraHal::stopImageBracketing() 3103{ 3104 status_t ret = NO_ERROR; 3105 3106 LOG_FUNCTION_NAME; 3107 3108 if( !previewEnabled() ) 3109 { 3110 return NO_INIT; 3111 } 3112 3113 mBracketingRunning = false; 3114 3115 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE); 3116 3117 LOG_FUNCTION_NAME_EXIT; 3118 3119 return ret; 3120} 3121 3122/** 3123 @brief Take a picture. 3124 3125 @param none 3126 @return NO_ERROR If able to switch to image capture 3127 @todo Define error codes if unable to switch to image capture 3128 3129 */ 3130status_t CameraHal::takePicture(const char *params) 3131{ 3132 android::AutoMutex lock(mLock); 3133 return __takePicture(params); 3134} 3135 3136/** 3137 @brief Internal function for getting a captured image. 3138 shared by takePicture and reprocess. 3139 @param none 3140 @return NO_ERROR If able to switch to image capture 3141 @todo Define error codes if unable to switch to image capture 3142 3143 */ 3144status_t CameraHal::__takePicture(const char *params) 3145{ 3146 // cancel AF state if needed (before any operation and mutex lock) 3147 if (mCameraAdapter->getState() == CameraAdapter::AF_STATE) { 3148 cancelAutoFocus(); 3149 } 3150 3151 status_t ret = NO_ERROR; 3152 CameraFrame frame; 3153 CameraAdapter::BuffersDescriptor desc; 3154 int burst = -1; 3155 const char *valstr = NULL; 3156 unsigned int bufferCount = 1; 3157 unsigned int max_queueable = 0; 3158 unsigned int rawBufferCount = 1; 3159 bool isCPCamMode = false; 3160 3161#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 3162 3163 gettimeofday(&mStartCapture, NULL); 3164 3165#endif 3166 3167 LOG_FUNCTION_NAME; 3168 3169 if(!previewEnabled() && !mDisplayPaused) 3170 { 3171 LOG_FUNCTION_NAME_EXIT; 3172 CAMHAL_LOGEA("Preview not started..."); 3173 return NO_INIT; 3174 } 3175 3176 valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); 3177 3178 isCPCamMode = valstr && !strcmp(valstr, TICameraParameters::CP_CAM_MODE); 3179 3180 // return error if we are already capturing 3181 // however, we can queue a capture when in cpcam mode 3182 if ( ((mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE && 3183 mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) || 3184 (mCameraAdapter->getState() == CameraAdapter::VIDEO_CAPTURE_STATE && 3185 mCameraAdapter->getNextState() != CameraAdapter::VIDEO_STATE)) && 3186 !isCPCamMode) { 3187 CAMHAL_LOGEA("Already capturing an image..."); 3188 return NO_INIT; 3189 } 3190 3191 // we only support video snapshot if we are in video mode (recording hint is set) 3192 if ( (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE) && 3193 (valstr && ( strcmp(valstr, TICameraParameters::VIDEO_MODE) && 3194 strcmp(valstr, TICameraParameters::VIDEO_MODE_HQ ) ) ) ) { 3195 CAMHAL_LOGEA("Trying to capture while recording without recording hint set..."); 3196 return INVALID_OPERATION; 3197 } 3198 3199#ifdef OMAP_ENHANCEMENT_CPCAM 3200 // check if camera application is using shots parameters 3201 // api. parameters set here override anything set using setParameters 3202 // TODO(XXX): Just going to use legacy TI parameters for now. Need 3203 // add new APIs in CameraHal to utilize android::ShotParameters later, so 3204 // we don't have to parse through the whole set of parameters 3205 // in camera adapter 3206 if (strlen(params) > 0) { 3207 android::ShotParameters shotParams; 3208 const char *valStr; 3209 const char *valExpComp, *valExpGain; 3210 int valNum; 3211 3212 android::String8 shotParams8(params); 3213 3214 shotParams.unflatten(shotParams8); 3215 mParameters.remove(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE); 3216 mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE); 3217 3218 valExpGain = shotParams.get(android::ShotParameters::KEY_EXP_GAIN_PAIRS); 3219 valExpComp = shotParams.get(android::ShotParameters::KEY_EXP_COMPENSATION); 3220 if (NULL != valExpComp) { 3221 mParameters.set(TICameraParameters::KEY_EXP_BRACKETING_RANGE, valExpComp); 3222 } else if (NULL != valExpGain) { 3223 mParameters.set(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE, valExpGain); 3224 } 3225 3226 valNum = shotParams.getInt(android::ShotParameters::KEY_BURST); 3227 if (valNum >= 0) { 3228 mParameters.set(TICameraParameters::KEY_BURST, valNum); 3229 burst = valNum; 3230 } 3231 3232 valStr = shotParams.get(android::ShotParameters::KEY_FLUSH_CONFIG); 3233 if (valStr!= NULL) { 3234 if ( 0 == strcmp(valStr, android::ShotParameters::TRUE) ) { 3235 mParameters.set(TICameraParameters::KEY_FLUSH_SHOT_CONFIG_QUEUE, 3236 android::CameraParameters::TRUE); 3237 } else if ( 0 == strcmp(valStr, android::ShotParameters::FALSE) ) { 3238 mParameters.set(TICameraParameters::KEY_FLUSH_SHOT_CONFIG_QUEUE, 3239 android::CameraParameters::FALSE); 3240 } 3241 } 3242 3243 valStr = shotParams.get(android::ShotParameters::KEY_CURRENT_TAP_OUT); 3244 if (valStr != NULL) { 3245 int index = -1; 3246 for (unsigned int i = 0; i < mOutAdapters.size(); i++) { 3247 if(mOutAdapters.itemAt(i)->match(valStr)) { 3248 index = i; 3249 break; 3250 } 3251 } 3252 if (index < 0) { 3253 CAMHAL_LOGE("Invalid tap out surface passed to camerahal"); 3254 return BAD_VALUE; 3255 } 3256 CAMHAL_LOGD("Found matching out adapter at %d", index); 3257 mBufferSourceAdapter_Out = mOutAdapters.itemAt(index); 3258 } else { 3259 mBufferSourceAdapter_Out.clear(); 3260 } 3261 3262 mCameraAdapter->setParameters(mParameters); 3263 } else 3264#endif 3265 { 3266 // TODO(XXX): Should probably reset burst and bracketing params 3267 // when we remove legacy TI parameters implementation 3268 } 3269 3270 // if we are already in the middle of a capture...then we just need 3271 // setParameters and start image capture to queue more shots 3272 if (((mCameraAdapter->getState() & CameraAdapter::CAPTURE_STATE) == 3273 CameraAdapter::CAPTURE_STATE) && 3274 (mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE)) { 3275#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 3276 //pass capture timestamp along with the camera adapter command 3277 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE, 3278 (int) &mStartCapture); 3279#else 3280 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE); 3281#endif 3282 return ret; 3283 } 3284 3285 if ( !mBracketingRunning ) 3286 { 3287 // if application didn't set burst through android::ShotParameters 3288 // then query from TICameraParameters 3289 if ((burst == -1) && (NO_ERROR == ret)) { 3290 burst = mParameters.getInt(TICameraParameters::KEY_BURST); 3291 } 3292 3293 //Allocate all buffers only in burst capture case 3294 if ( burst > 0 ) { 3295 // For CPCam mode...allocate for worst case burst 3296 bufferCount = isCPCamMode || (burst > CameraHal::NO_BUFFERS_IMAGE_CAPTURE) ? 3297 CameraHal::NO_BUFFERS_IMAGE_CAPTURE : burst; 3298 3299 if (mBufferSourceAdapter_Out.get()) { 3300 // TODO(XXX): Temporarily increase number of buffers we can allocate from ANW 3301 // until faux-NPA mode is implemented 3302 bufferCount = NO_BUFFERS_IMAGE_CAPTURE_SYSTEM_HEAP; 3303 } 3304 3305 if ( NULL != mAppCallbackNotifier.get() ) { 3306 mAppCallbackNotifier->setBurst(true); 3307 } 3308 } else if ( mBracketingEnabled ) { 3309 bufferCount = mBracketRangeNegative + 1; 3310 if ( NULL != mAppCallbackNotifier.get() ) { 3311 mAppCallbackNotifier->setBurst(false); 3312 } 3313 } else { 3314 if ( NULL != mAppCallbackNotifier.get() ) { 3315 mAppCallbackNotifier->setBurst(false); 3316 } 3317 } 3318 3319 // pause preview during normal image capture 3320 // do not pause preview if recording (video state) 3321 if ( (NO_ERROR == ret) && (NULL != mDisplayAdapter.get()) ) { 3322 if (mCameraAdapter->getState() != CameraAdapter::VIDEO_STATE) { 3323 mDisplayPaused = true; 3324 mPreviewEnabled = false; 3325 ret = mDisplayAdapter->pauseDisplay(mDisplayPaused); 3326 // since preview is paused we should stop sending preview frames too 3327 if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) { 3328 mAppCallbackNotifier->disableMsgType (CAMERA_MSG_PREVIEW_FRAME); 3329 } 3330 } 3331 3332#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 3333 mDisplayAdapter->setSnapshotTimeRef(&mStartCapture); 3334#endif 3335 } 3336 3337 // if we taking video snapshot... 3338 if ((NO_ERROR == ret) && (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE)) { 3339 // enable post view frames if not already enabled so we can internally 3340 // save snapshot frames for generating thumbnail 3341 if((mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) == 0) { 3342 mAppCallbackNotifier->enableMsgType(CAMERA_MSG_POSTVIEW_FRAME); 3343 } 3344 } 3345 3346 if ( (NO_ERROR == ret) && (NULL != mCameraAdapter) ) 3347 { 3348 if ( NO_ERROR == ret ) 3349 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE, 3350 ( int ) &frame, 3351 bufferCount); 3352 3353 if ( NO_ERROR != ret ) 3354 { 3355 CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret); 3356 } 3357 } 3358 3359 if ( NO_ERROR == ret ) 3360 { 3361 ret = allocImageBufs(frame.mAlignment / getBPP(mParameters.getPictureFormat()), 3362 frame.mHeight, 3363 frame.mLength, 3364 mParameters.getPictureFormat(), 3365 bufferCount, 3366 &max_queueable); 3367 if ( NO_ERROR != ret ) 3368 { 3369 CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); 3370 } 3371 } 3372 3373 if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) 3374 { 3375 desc.mBuffers = mImageBuffers; 3376 desc.mOffsets = mImageOffsets; 3377 desc.mFd = mImageFd; 3378 desc.mLength = mImageLength; 3379 desc.mCount = ( size_t ) bufferCount; 3380 desc.mMaxQueueable = ( size_t ) max_queueable; 3381 3382 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, 3383 ( int ) &desc); 3384 } 3385 if (mRawCapture) { 3386 if ( NO_ERROR == ret ) { 3387 CAMHAL_LOGDB("Raw capture buffers setup - %s", mParameters.getPictureFormat()); 3388 ret = allocRawBufs(mParameters.getInt(TICameraParameters::RAW_WIDTH), 3389 mParameters.getInt(TICameraParameters::RAW_HEIGHT), 3390 android::CameraParameters::PIXEL_FORMAT_BAYER_RGGB, 3391 rawBufferCount); 3392 3393 if ( NO_ERROR != ret ) { 3394 CAMHAL_LOGEB("allocRawBufs (for RAW capture) returned error 0x%x", ret); 3395 } 3396 } 3397 3398 if ((NO_ERROR == ret) && ( NULL != mCameraAdapter )) { 3399 desc.mBuffers = mVideoBuffers; 3400 desc.mOffsets = mVideoOffsets; 3401 desc.mFd = mVideoFd; 3402 desc.mLength = mVideoLength; 3403 desc.mCount = ( size_t ) rawBufferCount; 3404 desc.mMaxQueueable = ( size_t ) rawBufferCount; 3405 3406 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_VIDEO_CAPTURE, 3407 ( int ) &desc); 3408 } 3409 } 3410 } 3411 3412 if ((ret == NO_ERROR) && mBufferSourceAdapter_Out.get()) { 3413 mBufferSourceAdapter_Out->enableDisplay(0, 0, NULL); 3414 } 3415 3416 if ((NO_ERROR == ret) && (NULL != mCameraAdapter)) { 3417 3418#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 3419 3420 //pass capture timestamp along with the camera adapter command 3421 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE, (int) &mStartCapture); 3422 3423#else 3424 3425 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE); 3426 3427#endif 3428 3429 } 3430 3431 return ret; 3432} 3433 3434/** 3435 @brief Cancel a picture that was started with takePicture. 3436 3437 Calling this method when no picture is being taken is a no-op. 3438 3439 @param none 3440 @return NO_ERROR If cancel succeeded. Cancel can succeed if image callback is not sent 3441 @todo Define error codes 3442 3443 */ 3444status_t CameraHal::cancelPicture( ) 3445{ 3446 LOG_FUNCTION_NAME; 3447 status_t ret = NO_ERROR; 3448 3449 ret = signalEndImageCapture(); 3450 return NO_ERROR; 3451} 3452 3453/** 3454 @brief Return the camera parameters. 3455 3456 @param none 3457 @return Currently configured camera parameters 3458 3459 */ 3460char* CameraHal::getParameters() 3461{ 3462 android::String8 params_str8; 3463 char* params_string; 3464 const char * valstr = NULL; 3465 3466 LOG_FUNCTION_NAME; 3467 3468 if( NULL != mCameraAdapter ) 3469 { 3470 mCameraAdapter->getParameters(mParameters); 3471 } 3472 3473 if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT)) != NULL ) { 3474 if (!strcmp(TICameraParameters::S3D_TB_FULL, valstr)) { 3475 mParameters.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES)); 3476 } else if (!strcmp(TICameraParameters::S3D_SS_FULL, valstr)) { 3477 mParameters.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES)); 3478 } else if ((!strcmp(TICameraParameters::S3D_TB_SUBSAMPLED, valstr)) 3479 || (!strcmp(TICameraParameters::S3D_SS_SUBSAMPLED, valstr))) { 3480 mParameters.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PICTURE_SUBSAMPLED_SIZES)); 3481 } 3482 } 3483 3484 if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT)) != NULL ) { 3485 if (!strcmp(TICameraParameters::S3D_TB_FULL, valstr)) { 3486 mParameters.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES)); 3487 } else if (!strcmp(TICameraParameters::S3D_SS_FULL, valstr)) { 3488 mParameters.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES)); 3489 } else if ((!strcmp(TICameraParameters::S3D_TB_SUBSAMPLED, valstr)) 3490 || (!strcmp(TICameraParameters::S3D_SS_SUBSAMPLED, valstr))) { 3491 mParameters.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES)); 3492 } 3493 } 3494 3495 android::CameraParameters mParams = mParameters; 3496 3497 // Handle RECORDING_HINT to Set/Reset Video Mode Parameters 3498 valstr = mParameters.get(android::CameraParameters::KEY_RECORDING_HINT); 3499 if(valstr != NULL) 3500 { 3501 if(strcmp(valstr, android::CameraParameters::TRUE) == 0) 3502 { 3503 //HACK FOR MMS MODE 3504 resetPreviewRes(&mParams); 3505 } 3506 } 3507 3508 // do not send internal parameters to upper layers 3509 mParams.remove(TICameraParameters::KEY_RECORDING_HINT); 3510 mParams.remove(TICameraParameters::KEY_AUTO_FOCUS_LOCK); 3511 3512 params_str8 = mParams.flatten(); 3513 3514 // camera service frees this string... 3515 params_string = (char*) malloc(sizeof(char) * (params_str8.length()+1)); 3516 strcpy(params_string, params_str8.string()); 3517 3518 LOG_FUNCTION_NAME_EXIT; 3519 3520 ///Return the current set of parameters 3521 3522 return params_string; 3523} 3524 3525 3526#ifdef OMAP_ENHANCEMENT_CPCAM 3527/** 3528 @brief Starts reprocessing operation. 3529 */ 3530status_t CameraHal::reprocess(const char *params) 3531{ 3532 status_t ret = NO_ERROR; 3533 int bufferCount = 0; 3534 CameraAdapter::BuffersDescriptor desc; 3535 CameraBuffer *reprocBuffers = NULL; 3536 android::ShotParameters shotParams; 3537 const char *valStr = NULL; 3538 3539 android::AutoMutex lock(mLock); 3540 3541 LOG_FUNCTION_NAME; 3542 3543 // 0. Get tap in surface 3544 if (strlen(params) > 0) { 3545 android::String8 shotParams8(params); 3546 shotParams.unflatten(shotParams8); 3547 } 3548 3549 valStr = shotParams.get(android::ShotParameters::KEY_CURRENT_TAP_IN); 3550 if (valStr != NULL) { 3551 int index = -1; 3552 for (unsigned int i = 0; i < mInAdapters.size(); i++) { 3553 if(mInAdapters.itemAt(i)->match(valStr)) { 3554 index = i; 3555 break; 3556 } 3557 } 3558 if (index < 0) { 3559 CAMHAL_LOGE("Invalid tap in surface passed to camerahal"); 3560 return BAD_VALUE; 3561 } 3562 CAMHAL_LOGD("Found matching in adapter at %d", index); 3563 mBufferSourceAdapter_In = mInAdapters.itemAt(index); 3564 } else { 3565 CAMHAL_LOGE("No tap in surface sent with shot config!"); 3566 return BAD_VALUE; 3567 } 3568 3569 // 1. Get buffers 3570 if (mBufferSourceAdapter_In.get()) { 3571 reprocBuffers = mBufferSourceAdapter_In->getBufferList(&bufferCount); 3572 } 3573 3574 if (!reprocBuffers) { 3575 CAMHAL_LOGE("Error: couldn't get input buffers for reprocess()"); 3576 goto exit; 3577 } 3578 3579 // 2. Get buffer information and parse parameters 3580 { 3581 shotParams.setBurst(bufferCount); 3582 } 3583 3584 // 3. Give buffer to camera adapter 3585 desc.mBuffers = reprocBuffers; 3586 desc.mOffsets = 0; 3587 desc.mFd = 0; 3588 desc.mLength = 0; 3589 desc.mCount = (size_t) bufferCount; 3590 desc.mMaxQueueable = (size_t) bufferCount; 3591 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_REPROCESS, (int) &desc); 3592 if (ret != NO_ERROR) { 3593 CAMHAL_LOGE("Error calling camera use buffers"); 3594 goto exit; 3595 } 3596 3597 // 4. Start reprocessing 3598 ret = mBufferSourceAdapter_In->enableDisplay(0, 0, NULL); 3599 if (ret != NO_ERROR) { 3600 CAMHAL_LOGE("Error enabling tap in point"); 3601 goto exit; 3602 } 3603 3604 // 5. Start capturing 3605 ret = __takePicture(shotParams.flatten().string()); 3606 3607 exit: 3608 return ret; 3609} 3610 3611/** 3612 @brief Cancels current reprocessing operation 3613 3614 */ 3615status_t CameraHal::cancel_reprocess( ) 3616{ 3617 LOG_FUNCTION_NAME; 3618 status_t ret = NO_ERROR; 3619 3620 ret = signalEndImageCapture(); 3621 return NO_ERROR; 3622} 3623#endif 3624 3625 3626void CameraHal::putParameters(char *parms) 3627{ 3628 free(parms); 3629} 3630 3631/** 3632 @brief Send command to camera driver. 3633 3634 @param none 3635 @return NO_ERROR If the command succeeds 3636 @todo Define the error codes that this function can return 3637 3638 */ 3639status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) 3640{ 3641 status_t ret = NO_ERROR; 3642 3643 LOG_FUNCTION_NAME; 3644 3645 if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) ) 3646 { 3647 CAMHAL_LOGEA("No CameraAdapter instance"); 3648 return -EINVAL; 3649 } 3650 3651 /////////////////////////////////////////////////////// 3652 // Following commands do NOT need preview to be started 3653 /////////////////////////////////////////////////////// 3654 3655 switch ( cmd ) { 3656#ifdef ANDROID_API_JB_OR_LATER 3657 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG: 3658 { 3659 const bool enable = static_cast<bool>(arg1); 3660 android::AutoMutex lock(mLock); 3661 if ( enable ) { 3662 mMsgEnabled |= CAMERA_MSG_FOCUS_MOVE; 3663 } else { 3664 mMsgEnabled &= ~CAMERA_MSG_FOCUS_MOVE; 3665 } 3666 } 3667 return OK; 3668#endif 3669 } 3670 3671 if ( ret == OK && !previewEnabled() 3672#ifdef OMAP_ENHANCEMENT_VTC 3673 && (cmd != CAMERA_CMD_PREVIEW_INITIALIZATION) 3674#endif 3675 ) { 3676 CAMHAL_LOGEA("Preview is not running"); 3677 ret = -EINVAL; 3678 } 3679 3680 /////////////////////////////////////////////////////// 3681 // Following commands NEED preview to be started 3682 /////////////////////////////////////////////////////// 3683 3684 if ( NO_ERROR == ret ) 3685 { 3686 switch(cmd) 3687 { 3688 case CAMERA_CMD_START_SMOOTH_ZOOM: 3689 3690 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_SMOOTH_ZOOM, arg1); 3691 3692 break; 3693 case CAMERA_CMD_STOP_SMOOTH_ZOOM: 3694 3695 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM); 3696 break; 3697 3698 case CAMERA_CMD_START_FACE_DETECTION: 3699 3700 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD); 3701 3702 break; 3703 3704 case CAMERA_CMD_STOP_FACE_DETECTION: 3705 3706 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD); 3707 3708 break; 3709 3710#ifdef OMAP_ENHANCEMENT_VTC 3711 case CAMERA_CMD_PREVIEW_DEINITIALIZATION: 3712 if(mDisplayAdapter.get() != NULL) { 3713 ///Stop the buffer display first 3714 mDisplayAdapter->disableDisplay(); 3715 } 3716 3717 if(mAppCallbackNotifier.get() != NULL) { 3718 //Stop the callback sending 3719 mAppCallbackNotifier->stop(); 3720 mAppCallbackNotifier->flushAndReturnFrames(); 3721 mAppCallbackNotifier->stopPreviewCallbacks(); 3722 } 3723 3724 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_DESTROY_TUNNEL); 3725 mTunnelSetup = false; 3726 3727 break; 3728 3729 case CAMERA_CMD_PREVIEW_INITIALIZATION: 3730 ret = cameraPreviewInitialization(); 3731 3732 break; 3733#endif 3734 3735 default: 3736 break; 3737 }; 3738 } 3739 3740 LOG_FUNCTION_NAME_EXIT; 3741 3742 return ret; 3743} 3744 3745/** 3746 @brief Release the hardware resources owned by this object. 3747 3748 Note that this is *not* done in the destructor. 3749 3750 @param none 3751 @return none 3752 3753 */ 3754void CameraHal::release() 3755{ 3756 LOG_FUNCTION_NAME; 3757 ///@todo Investigate on how release is used by CameraService. Vaguely remember that this is called 3758 ///just before CameraHal object destruction 3759 deinitialize(); 3760 LOG_FUNCTION_NAME_EXIT; 3761} 3762 3763 3764/** 3765 @brief Dump state of the camera hardware 3766 3767 @param[in] fd File descriptor 3768 @param[in] args Arguments 3769 @return NO_ERROR Dump succeeded 3770 @todo Error codes for dump fail 3771 3772 */ 3773status_t CameraHal::dump(int fd) const 3774{ 3775 LOG_FUNCTION_NAME; 3776 ///Implement this method when the h/w dump function is supported on Ducati side 3777 return NO_ERROR; 3778} 3779 3780/*-------------Camera Hal Interface Method definitions ENDS here--------------------*/ 3781 3782 3783 3784 3785/*-------------Camera Hal Internal Method definitions STARTS here--------------------*/ 3786 3787/** 3788 @brief Constructor of CameraHal 3789 3790 Member variables are initialized here. No allocations should be done here as we 3791 don't use c++ exceptions in the code. 3792 3793 */ 3794CameraHal::CameraHal(int cameraId) 3795{ 3796 LOG_FUNCTION_NAME; 3797 3798 ///Initialize all the member variables to their defaults 3799 mPreviewEnabled = false; 3800 mPreviewBuffers = NULL; 3801 mImageBuffers = NULL; 3802 mBufProvider = NULL; 3803 mPreviewStartInProgress = false; 3804 mVideoBuffers = NULL; 3805 mVideoBufProvider = NULL; 3806 mRecordingEnabled = false; 3807 mDisplayPaused = false; 3808 mSetPreviewWindowCalled = false; 3809 mMsgEnabled = 0; 3810 mAppCallbackNotifier = NULL; 3811 mMemoryManager = NULL; 3812 mCameraAdapter = NULL; 3813 mBracketingEnabled = false; 3814 mBracketingRunning = false; 3815 mEventProvider = NULL; 3816 mBracketRangePositive = 1; 3817 mBracketRangeNegative = 1; 3818 mMaxZoomSupported = 0; 3819 mShutterEnabled = true; 3820 mMeasurementEnabled = false; 3821 mPreviewDataBuffers = NULL; 3822 mCameraProperties = NULL; 3823 mCurrentTime = 0; 3824 mFalsePreview = 0; 3825 mImageOffsets = NULL; 3826 mImageLength = 0; 3827 mImageFd = 0; 3828 mVideoOffsets = NULL; 3829 mVideoFd = 0; 3830 mVideoLength = 0; 3831 mPreviewDataOffsets = NULL; 3832 mPreviewDataFd = 0; 3833 mPreviewDataLength = 0; 3834 mPreviewFd = 0; 3835 mPreviewWidth = 0; 3836 mPreviewHeight = 0; 3837 mPreviewLength = 0; 3838 mPreviewOffsets = NULL; 3839 mPreviewRunning = 0; 3840 mPreviewStateOld = 0; 3841 mRecordingEnabled = 0; 3842 mRecordEnabled = 0; 3843 mSensorListener = NULL; 3844 mVideoWidth = 0; 3845 mVideoHeight = 0; 3846#ifdef OMAP_ENHANCEMENT_VTC 3847 mVTCUseCase = false; 3848 mTunnelSetup = false; 3849#endif 3850 mPreviewInitializationDone = false; 3851 3852#ifdef OMAP_ENHANCEMENT_CPCAM 3853 mExtendedPreviewStreamOps = 0; 3854#endif 3855 3856 //These values depends on the sensor characteristics 3857 3858 mRawCapture = false; 3859 3860#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 3861 3862 //Initialize the CameraHAL constructor timestamp, which is used in the 3863 // PPM() method as time reference if the user does not supply one. 3864 gettimeofday(&ppm_start, NULL); 3865 3866#endif 3867 3868 mCameraIndex = cameraId; 3869 3870 LOG_FUNCTION_NAME_EXIT; 3871} 3872 3873/** 3874 @brief Destructor of CameraHal 3875 3876 This function simply calls deinitialize() to free up memory allocate during construct 3877 phase 3878 */ 3879CameraHal::~CameraHal() 3880{ 3881 LOG_FUNCTION_NAME; 3882 3883 ///Call de-initialize here once more - it is the last chance for us to relinquish all the h/w and s/w resources 3884 deinitialize(); 3885 3886 if ( NULL != mEventProvider ) 3887 { 3888 mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS); 3889 delete mEventProvider; 3890 mEventProvider = NULL; 3891 } 3892 3893 /// Free the callback notifier 3894 mAppCallbackNotifier.clear(); 3895 3896 /// Free the display adapter 3897 mDisplayAdapter.clear(); 3898 3899 if ( NULL != mCameraAdapter ) { 3900 int strongCount = mCameraAdapter->getStrongCount(); 3901 3902 mCameraAdapter->decStrong(mCameraAdapter); 3903 3904 mCameraAdapter = NULL; 3905 } 3906 3907 freeImageBufs(); 3908 freeRawBufs(); 3909 3910 /// Free the memory manager 3911 mMemoryManager.clear(); 3912 3913 LOG_FUNCTION_NAME_EXIT; 3914} 3915 3916/** 3917 @brief Initialize the Camera HAL 3918 3919 Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager 3920 3921 @param None 3922 @return NO_ERROR - On success 3923 NO_MEMORY - On failure to allocate memory for any of the objects 3924 @remarks Camera Hal internal function 3925 3926 */ 3927 3928status_t CameraHal::initialize(CameraProperties::Properties* properties) 3929{ 3930 LOG_FUNCTION_NAME; 3931 3932 int sensor_index = 0; 3933 const char* sensor_name = NULL; 3934 3935 ///Initialize the event mask used for registering an event provider for AppCallbackNotifier 3936 ///Currently, registering all events as to be coming from CameraAdapter 3937 int32_t eventMask = CameraHalEvent::ALL_EVENTS; 3938 3939 // Get my camera properties 3940 mCameraProperties = properties; 3941 3942 if(!mCameraProperties) 3943 { 3944 goto fail_loop; 3945 } 3946 3947 // Dump the properties of this Camera 3948 // will only print if DEBUG macro is defined 3949 mCameraProperties->dump(); 3950 3951 if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 ) 3952 { 3953 sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)); 3954 } 3955 3956 if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_NAME)) != 0 ) { 3957 sensor_name = mCameraProperties->get(CameraProperties::CAMERA_NAME); 3958 } 3959 CAMHAL_LOGDB("Sensor index= %d; Sensor name= %s", sensor_index, sensor_name); 3960 3961 if (strcmp(sensor_name, V4L_CAMERA_NAME_USB) == 0) { 3962#ifdef V4L_CAMERA_ADAPTER 3963 mCameraAdapter = V4LCameraAdapter_Factory(sensor_index); 3964#endif 3965 } 3966 else { 3967#ifdef OMX_CAMERA_ADAPTER 3968 mCameraAdapter = OMXCameraAdapter_Factory(sensor_index); 3969#endif 3970 } 3971 3972 if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties)!=NO_ERROR)) 3973 { 3974 CAMHAL_LOGEA("Unable to create or initialize CameraAdapter"); 3975 mCameraAdapter = NULL; 3976 goto fail_loop; 3977 } 3978 3979 mCameraAdapter->incStrong(mCameraAdapter); 3980 mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this); 3981 mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this); 3982 3983 if(!mAppCallbackNotifier.get()) 3984 { 3985 /// Create the callback notifier 3986 mAppCallbackNotifier = new AppCallbackNotifier(); 3987 if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR)) 3988 { 3989 CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier"); 3990 goto fail_loop; 3991 } 3992 } 3993 3994 if(!mMemoryManager.get()) 3995 { 3996 /// Create Memory Manager 3997 mMemoryManager = new MemoryManager(); 3998 if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR)) 3999 { 4000 CAMHAL_LOGEA("Unable to create or initialize MemoryManager"); 4001 goto fail_loop; 4002 } 4003 } 4004 4005 ///Setup the class dependencies... 4006 4007 ///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from. 4008 ///CameraAdapter is the one which provides those events 4009 ///Set it as the frame and event providers for AppCallbackNotifier 4010 ///@remarks setEventProvider API takes in a bit mask of events for registering a provider for the different events 4011 /// That way, if events can come from DisplayAdapter in future, we will be able to add it as provider 4012 /// for any event 4013 mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter); 4014 mAppCallbackNotifier->setFrameProvider(mCameraAdapter); 4015 4016 ///Any dynamic errors that happen during the camera use case has to be propagated back to the application 4017 ///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application 4018 ///Set it as the error handler for CameraAdapter 4019 mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get()); 4020 4021 ///Start the callback notifier 4022 if(mAppCallbackNotifier->start() != NO_ERROR) 4023 { 4024 CAMHAL_LOGEA("Couldn't start AppCallbackNotifier"); 4025 goto fail_loop; 4026 } 4027 4028 CAMHAL_LOGDA("Started AppCallbackNotifier.."); 4029 mAppCallbackNotifier->setMeasurements(mMeasurementEnabled); 4030 4031 ///Initialize default parameters 4032 initDefaultParameters(); 4033 4034 4035 if ( setParameters(mParameters) != NO_ERROR ) 4036 { 4037 CAMHAL_LOGEA("Failed to set default parameters?!"); 4038 } 4039 4040 // register for sensor events 4041 mSensorListener = new SensorListener(); 4042 if (mSensorListener.get()) { 4043 if (mSensorListener->initialize() == NO_ERROR) { 4044 mSensorListener->setCallbacks(orientation_cb, this); 4045 mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION); 4046 } else { 4047 CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing"); 4048 mSensorListener.clear(); 4049 mSensorListener = NULL; 4050 } 4051 } 4052 4053 LOG_FUNCTION_NAME_EXIT; 4054 4055 return NO_ERROR; 4056 4057 fail_loop: 4058 4059 ///Free up the resources because we failed somewhere up 4060 deinitialize(); 4061 LOG_FUNCTION_NAME_EXIT; 4062 4063 return NO_MEMORY; 4064 4065} 4066 4067bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions) 4068{ 4069 bool ret = false; 4070 status_t status = NO_ERROR; 4071 char tmpBuffer[MAX_PROP_VALUE_LENGTH]; 4072 char *pos = NULL; 4073 4074 LOG_FUNCTION_NAME; 4075 4076 if (NULL == supportedResolutions) { 4077 CAMHAL_LOGEA("Invalid supported resolutions string"); 4078 goto exit; 4079 } 4080 4081 status = snprintf(tmpBuffer, MAX_PROP_VALUE_LENGTH - 1, "%dx%d", width, height); 4082 if (0 > status) { 4083 CAMHAL_LOGEA("Error encountered while generating validation string"); 4084 goto exit; 4085 } 4086 4087 ret = isParameterValid(tmpBuffer, supportedResolutions); 4088 4089exit: 4090 LOG_FUNCTION_NAME_EXIT; 4091 4092 return ret; 4093} 4094 4095bool CameraHal::isFpsRangeValid(int fpsMin, int fpsMax, const char *supportedFpsRanges) 4096{ 4097 bool ret = false; 4098 char supported[MAX_PROP_VALUE_LENGTH]; 4099 char *pos; 4100 int suppFpsRangeArray[2]; 4101 int i = 0; 4102 4103 LOG_FUNCTION_NAME; 4104 4105 if ( NULL == supportedFpsRanges ) { 4106 CAMHAL_LOGEA("Invalid supported FPS ranges string"); 4107 return false; 4108 } 4109 4110 if (fpsMin <= 0 || fpsMax <= 0 || fpsMin > fpsMax) { 4111 return false; 4112 } 4113 4114 strncpy(supported, supportedFpsRanges, MAX_PROP_VALUE_LENGTH); 4115 pos = strtok(supported, " (,)"); 4116 while (pos != NULL) { 4117 suppFpsRangeArray[i] = atoi(pos); 4118 if (i++) { 4119 if (fpsMin >= suppFpsRangeArray[0] && fpsMax <= suppFpsRangeArray[1]) { 4120 ret = true; 4121 break; 4122 } 4123 i = 0; 4124 } 4125 pos = strtok(NULL, " (,)"); 4126 } 4127 4128 LOG_FUNCTION_NAME_EXIT; 4129 4130 return ret; 4131} 4132 4133bool CameraHal::isParameterValid(const char *param, const char *supportedParams) 4134{ 4135 bool ret = false; 4136 char *pos; 4137 char supported[MAX_PROP_VALUE_LENGTH]; 4138 4139 LOG_FUNCTION_NAME; 4140 4141 if (NULL == supportedParams) { 4142 CAMHAL_LOGEA("Invalid supported parameters string"); 4143 goto exit; 4144 } 4145 4146 if (NULL == param) { 4147 CAMHAL_LOGEA("Invalid parameter string"); 4148 goto exit; 4149 } 4150 4151 strncpy(supported, supportedParams, MAX_PROP_VALUE_LENGTH - 1); 4152 4153 pos = strtok(supported, ","); 4154 while (pos != NULL) { 4155 if (!strcmp(pos, param)) { 4156 ret = true; 4157 break; 4158 } 4159 pos = strtok(NULL, ","); 4160 } 4161 4162exit: 4163 LOG_FUNCTION_NAME_EXIT; 4164 4165 return ret; 4166} 4167 4168bool CameraHal::isParameterValid(int param, const char *supportedParams) 4169{ 4170 bool ret = false; 4171 status_t status; 4172 char tmpBuffer[MAX_PROP_VALUE_LENGTH]; 4173 4174 LOG_FUNCTION_NAME; 4175 4176 if (NULL == supportedParams) { 4177 CAMHAL_LOGEA("Invalid supported parameters string"); 4178 goto exit; 4179 } 4180 4181 status = snprintf(tmpBuffer, MAX_PROP_VALUE_LENGTH - 1, "%d", param); 4182 if (0 > status) { 4183 CAMHAL_LOGEA("Error encountered while generating validation string"); 4184 goto exit; 4185 } 4186 4187 ret = isParameterValid(tmpBuffer, supportedParams); 4188 4189exit: 4190 LOG_FUNCTION_NAME_EXIT; 4191 4192 return ret; 4193} 4194 4195status_t CameraHal::doesSetParameterNeedUpdate(const char* new_param, const char* old_param, bool& update) { 4196 if (!new_param || !old_param) { 4197 return -EINVAL; 4198 } 4199 4200 // if params mismatch we should update parameters for camera adapter 4201 if ((strcmp(new_param, old_param) != 0)) { 4202 update = true; 4203 } 4204 4205 return NO_ERROR; 4206} 4207 4208status_t CameraHal::parseResolution(const char *resStr, int &width, int &height) 4209{ 4210 status_t ret = NO_ERROR; 4211 char *ctx, *pWidth, *pHeight; 4212 const char *sep = "x"; 4213 4214 LOG_FUNCTION_NAME; 4215 4216 if ( NULL == resStr ) 4217 { 4218 return -EINVAL; 4219 } 4220 4221 //This fixes "Invalid input resolution" 4222 char *resStr_copy = (char *)malloc(strlen(resStr) + 1); 4223 if ( NULL != resStr_copy ) 4224 { 4225 strcpy(resStr_copy, resStr); 4226 pWidth = strtok_r(resStr_copy, sep, &ctx); 4227 4228 if ( NULL != pWidth ) 4229 { 4230 width = atoi(pWidth); 4231 } 4232 else 4233 { 4234 CAMHAL_LOGEB("Invalid input resolution %s", resStr); 4235 ret = -EINVAL; 4236 } 4237 } 4238 4239 if ( NO_ERROR == ret ) 4240 { 4241 pHeight = strtok_r(NULL, sep, &ctx); 4242 4243 if ( NULL != pHeight ) 4244 { 4245 height = atoi(pHeight); 4246 } 4247 else 4248 { 4249 CAMHAL_LOGEB("Invalid input resolution %s", resStr); 4250 ret = -EINVAL; 4251 } 4252 } 4253 4254 free(resStr_copy); 4255 resStr_copy = NULL; 4256 4257 LOG_FUNCTION_NAME_EXIT; 4258 4259 return ret; 4260} 4261 4262void CameraHal::insertSupportedParams() 4263{ 4264 LOG_FUNCTION_NAME; 4265 4266 android::CameraParameters &p = mParameters; 4267 4268 ///Set the name of the camera 4269 p.set(TICameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME)); 4270 4271 mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES)); 4272 4273 p.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES)); 4274 p.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS)); 4275 p.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)); 4276 p.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); 4277 p.set(TICameraParameters::KEY_SUPPORTED_PICTURE_SUBSAMPLED_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SUBSAMPLED_SIZES)); 4278 p.set(TICameraParameters::KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIDEBYSIDE_SIZES)); 4279 p.set(TICameraParameters::KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_TOPBOTTOM_SIZES)); 4280 p.set(TICameraParameters::KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SUBSAMPLED_SIZES)); 4281 p.set(TICameraParameters::KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES)); 4282 p.set(TICameraParameters::KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_TOPBOTTOM_SIZES)); 4283 p.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)); 4284 p.set(TICameraParameters::KEY_FRAMERATES_EXT_SUPPORTED, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES_EXT)); 4285 p.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED)); 4286 p.set(TICameraParameters::KEY_FRAMERATE_RANGES_EXT_SUPPORTED, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_EXT_SUPPORTED)); 4287 p.set(android::CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES)); 4288 p.set(android::CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE)); 4289 p.set(android::CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS)); 4290 p.set(android::CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES)); 4291 p.set(android::CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES)); 4292 p.set(android::CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES)); 4293 p.set(android::CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING)); 4294 p.set(android::CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX)); 4295 p.set(android::CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN)); 4296 p.set(android::CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP)); 4297 p.set(TICameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES)); 4298 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_MIN)); 4299 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MAX, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_MAX)); 4300 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_STEP)); 4301 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_MIN)); 4302 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_MAX)); 4303 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_STEP)); 4304 p.set(TICameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES)); 4305 p.set(android::CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS)); 4306 p.set(android::CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES)); 4307 p.set(android::CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED)); 4308 p.set(android::CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED)); 4309 p.set(TICameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES)); 4310 p.set(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT_VALUES, mCameraProperties->get(CameraProperties::S3D_PRV_FRAME_LAYOUT_VALUES)); 4311 p.set(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT_VALUES, mCameraProperties->get(CameraProperties::S3D_CAP_FRAME_LAYOUT_VALUES)); 4312 p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE_VALUES, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE_VALUES)); 4313 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_MIN)); 4314 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_MAX)); 4315 p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_STEP)); 4316 p.set(android::CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED)); 4317 p.set(TICameraParameters::KEY_VNF_SUPPORTED, mCameraProperties->get(CameraProperties::VNF_SUPPORTED)); 4318 p.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED)); 4319 p.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED)); 4320 p.set(android::CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED)); 4321 p.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED, mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED)); 4322 p.set(TICameraParameters::KEY_CAP_MODE_VALUES, mCameraProperties->get(CameraProperties::CAP_MODE_VALUES)); 4323 4324 LOG_FUNCTION_NAME_EXIT; 4325 4326} 4327 4328void CameraHal::initDefaultParameters() 4329{ 4330 //Purpose of this function is to initialize the default current and supported parameters for the currently 4331 //selected camera. 4332 4333 android::CameraParameters &p = mParameters; 4334 int currentRevision, adapterRevision; 4335 status_t ret = NO_ERROR; 4336 int width, height; 4337 const char *valstr; 4338 4339 LOG_FUNCTION_NAME; 4340 4341 insertSupportedParams(); 4342 4343 ret = parseResolution(mCameraProperties->get(CameraProperties::PREVIEW_SIZE), width, height); 4344 4345 if ( NO_ERROR == ret ) 4346 { 4347 p.setPreviewSize(width, height); 4348 } 4349 else 4350 { 4351 p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT); 4352 } 4353 4354 ret = parseResolution(mCameraProperties->get(CameraProperties::PICTURE_SIZE), width, height); 4355 4356 if ( NO_ERROR == ret ) 4357 { 4358 p.setPictureSize(width, height); 4359 } 4360 else 4361 { 4362 p.setPictureSize(PICTURE_WIDTH, PICTURE_HEIGHT); 4363 } 4364 4365 ret = parseResolution(mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_SIZE), width, height); 4366 4367 if ( NO_ERROR == ret ) 4368 { 4369 p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); 4370 p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); 4371 } 4372 else 4373 { 4374 p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH); 4375 p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT); 4376 } 4377 4378 //Insert default values 4379 p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE))); 4380 p.set(android::CameraParameters::KEY_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE)); 4381 p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT)); 4382 p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT)); 4383 p.set(android::CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY)); 4384 p.set(android::CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE)); 4385 p.set(android::CameraParameters::KEY_EFFECT, mCameraProperties->get(CameraProperties::EFFECT)); 4386 p.set(android::CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING)); 4387 p.set(android::CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE)); 4388 p.set(android::CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE)); 4389 p.set(android::CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION)); 4390 p.set(android::CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE)); 4391 p.set(android::CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM)); 4392 p.set(TICameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST)); 4393 p.set(TICameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION)); 4394 p.set(TICameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS)); 4395 p.set(TICameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS)); 4396 p.set(TICameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE)); 4397 p.set(TICameraParameters::KEY_MANUAL_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_MIN)); 4398 p.set(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_MIN)); 4399 p.set(TICameraParameters::KEY_MANUAL_GAIN_ISO, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_MIN)); 4400 p.set(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_MIN)); 4401 p.set(TICameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE)); 4402 p.set(TICameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP)); 4403 p.set(TICameraParameters::KEY_GBCE, mCameraProperties->get(CameraProperties::GBCE)); 4404 p.set(TICameraParameters::KEY_GBCE_SUPPORTED, mCameraProperties->get(CameraProperties::SUPPORTED_GBCE)); 4405 p.set(TICameraParameters::KEY_GLBCE, mCameraProperties->get(CameraProperties::GLBCE)); 4406 p.set(TICameraParameters::KEY_GLBCE_SUPPORTED, mCameraProperties->get(CameraProperties::SUPPORTED_GLBCE)); 4407 p.set(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT, mCameraProperties->get(CameraProperties::S3D_PRV_FRAME_LAYOUT)); 4408 p.set(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT, mCameraProperties->get(CameraProperties::S3D_CAP_FRAME_LAYOUT)); 4409 p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE)); 4410 p.set(TICameraParameters::KEY_MANUAL_CONVERGENCE, mCameraProperties->get(CameraProperties::MANUAL_CONVERGENCE)); 4411 p.set(android::CameraParameters::KEY_VIDEO_STABILIZATION, mCameraProperties->get(CameraProperties::VSTAB)); 4412 p.set(TICameraParameters::KEY_VNF, mCameraProperties->get(CameraProperties::VNF)); 4413 p.set(android::CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH)); 4414 p.set(android::CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE)); 4415 p.set(android::CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE)); 4416 p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION)); 4417 p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE)); 4418 p.set(TICameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL)); 4419 p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY)); 4420 p.set(android::CameraParameters::KEY_VIDEO_FRAME_FORMAT, "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar"); 4421 p.set(android::CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES)); 4422 p.set(android::CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES)); 4423 p.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION, mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION)); 4424 // Only one area a.k.a Touch AF for now. 4425 // TODO: Add support for multiple focus areas. 4426 p.set(android::CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS)); 4427 p.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK)); 4428 p.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK)); 4429 p.set(android::CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS)); 4430 p.set(TICameraParameters::RAW_WIDTH, mCameraProperties->get(CameraProperties::RAW_WIDTH)); 4431 p.set(TICameraParameters::RAW_HEIGHT,mCameraProperties->get(CameraProperties::RAW_HEIGHT)); 4432 4433 // TI extensions for enable/disable algos 4434 // Hadcoded for now 4435 p.set(TICameraParameters::KEY_ALGO_FIXED_GAMMA, android::CameraParameters::TRUE); 4436 p.set(TICameraParameters::KEY_ALGO_NSF1, android::CameraParameters::TRUE); 4437 p.set(TICameraParameters::KEY_ALGO_NSF2, android::CameraParameters::TRUE); 4438 p.set(TICameraParameters::KEY_ALGO_SHARPENING, android::CameraParameters::TRUE); 4439 p.set(TICameraParameters::KEY_ALGO_THREELINCOLORMAP, android::CameraParameters::TRUE); 4440 p.set(TICameraParameters::KEY_ALGO_GIC, android::CameraParameters::TRUE); 4441 4442 LOG_FUNCTION_NAME_EXIT; 4443} 4444 4445/** 4446 @brief Stop a previously started preview. 4447 @param none 4448 @return none 4449 4450 */ 4451void CameraHal::forceStopPreview() 4452{ 4453 LOG_FUNCTION_NAME; 4454 4455 // stop bracketing if it is running 4456 if ( mBracketingRunning ) { 4457 stopImageBracketing(); 4458 } 4459 4460 if(mDisplayAdapter.get() != NULL) { 4461 ///Stop the buffer display first 4462 mDisplayAdapter->disableDisplay(); 4463 } 4464 4465 if(mAppCallbackNotifier.get() != NULL) { 4466 //Stop the callback sending 4467 mAppCallbackNotifier->stop(); 4468 mAppCallbackNotifier->flushAndReturnFrames(); 4469 mAppCallbackNotifier->stopPreviewCallbacks(); 4470 } 4471 4472 if ( NULL != mCameraAdapter ) { 4473 // only need to send these control commands to state machine if we are 4474 // passed the LOADED_PREVIEW_STATE 4475 if (mCameraAdapter->getState() > CameraAdapter::LOADED_PREVIEW_STATE) { 4476 // according to javadoc...FD should be stopped in stopPreview 4477 // and application needs to call startFaceDection again 4478 // to restart FD 4479 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD); 4480 } 4481 4482 mCameraAdapter->rollbackToInitializedState(); 4483 4484 } 4485 4486 freePreviewBufs(); 4487 freePreviewDataBufs(); 4488 4489 mPreviewEnabled = false; 4490 mDisplayPaused = false; 4491 mPreviewStartInProgress = false; 4492 4493 LOG_FUNCTION_NAME_EXIT; 4494} 4495 4496/** 4497 @brief Deallocates memory for all the resources held by Camera HAL. 4498 4499 Frees the following objects- CameraAdapter, AppCallbackNotifier, DisplayAdapter, 4500 and Memory Manager 4501 4502 @param none 4503 @return none 4504 4505 */ 4506void CameraHal::deinitialize() 4507{ 4508 LOG_FUNCTION_NAME; 4509 4510 if ( mPreviewEnabled || mDisplayPaused ) { 4511 forceStopPreview(); 4512 } 4513 4514 mSetPreviewWindowCalled = false; 4515 4516 if (mSensorListener.get()) { 4517 mSensorListener->disableSensor(SensorListener::SENSOR_ORIENTATION); 4518 mSensorListener.clear(); 4519 mSensorListener = NULL; 4520 } 4521 4522 mBufferSourceAdapter_Out.clear(); 4523 mBufferSourceAdapter_In.clear(); 4524 mOutAdapters.clear(); 4525 mInAdapters.clear(); 4526 4527 LOG_FUNCTION_NAME_EXIT; 4528 4529} 4530 4531status_t CameraHal::storeMetaDataInBuffers(bool enable) 4532{ 4533 LOG_FUNCTION_NAME; 4534 4535 return mAppCallbackNotifier->useMetaDataBufferMode(enable); 4536 4537 LOG_FUNCTION_NAME_EXIT; 4538} 4539 4540void CameraHal::getPreferredPreviewRes(int *width, int *height) 4541{ 4542 LOG_FUNCTION_NAME; 4543 4544 // We request Ducati for a higher resolution so preview looks better and then downscale the frame before the callback. 4545 // TODO: This should be moved to configuration constants and boolean flag whether to provide such optimization 4546 // Also consider providing this configurability of the desired display resolution from the application 4547 if ( ( *width == 320 ) && ( *height == 240 ) ) { 4548 *width = 640; 4549 *height = 480; 4550 } else if ( ( *width == 176 ) && ( *height == 144 ) ) { 4551 *width = 704; 4552 *height = 576; 4553 } 4554 4555 LOG_FUNCTION_NAME_EXIT; 4556} 4557 4558void CameraHal::resetPreviewRes(android::CameraParameters *params) 4559{ 4560 LOG_FUNCTION_NAME; 4561 4562 if ( (mVideoWidth <= 320) && (mVideoHeight <= 240)){ 4563 params->setPreviewSize(mVideoWidth, mVideoHeight); 4564 } 4565 4566 LOG_FUNCTION_NAME_EXIT; 4567} 4568 4569void * 4570camera_buffer_get_omx_ptr (CameraBuffer *buffer) 4571{ 4572 CAMHAL_LOGV("buffer_type %d opaque %p", buffer->type, buffer->opaque); 4573 4574 if (buffer->type == CAMERA_BUFFER_ANW) { 4575 buffer_handle_t *handle = (buffer_handle_t *)buffer->opaque; 4576 CAMHAL_LOGV("anw %08x", *handle); 4577 return (void *)*handle; 4578 } else if (buffer->type == CAMERA_BUFFER_ION) { 4579 return (void *)buffer->fd; 4580 } else { 4581 CAMHAL_LOGV("other %08x", buffer->opaque); 4582 return (void *)buffer->opaque; 4583 } 4584} 4585 4586} // namespace Camera 4587} // namespace Ti 4588