CameraHal.cpp revision 97db71f3a06c88c16f46fea8189f542dcde28f7f
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#define LOG_TAG "CameraHAL" 25 26#include "CameraHal.h" 27#include "ANativeWindowDisplayAdapter.h" 28#include "TICameraParameters.h" 29#include "CameraProperties.h" 30#include <cutils/properties.h> 31 32#include <poll.h> 33#include <math.h> 34 35namespace android { 36 37extern "C" CameraAdapter* CameraAdapter_Factory(); 38 39/*****************************************************************************/ 40 41////Constant definitions and declarations 42////@todo Have a CameraProperties class to store these parameters as constants for every camera 43//// Currently, they are hard-coded 44 45const int CameraHal::NO_BUFFERS_PREVIEW = MAX_CAMERA_BUFFERS; 46const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE = 2; 47 48const uint32_t MessageNotifier::EVENT_BIT_FIELD_POSITION = 0; 49const uint32_t MessageNotifier::FRAME_BIT_FIELD_POSITION = 0; 50 51/******************************************************************************/ 52 53#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 54 55struct timeval CameraHal::mStartPreview; 56struct timeval CameraHal::mStartFocus; 57struct timeval CameraHal::mStartCapture; 58 59#endif 60 61static void orientation_cb(uint32_t orientation, uint32_t tilt, void* cookie) { 62 CameraHal *camera = NULL; 63 64 if (cookie) { 65 camera = (CameraHal*) cookie; 66 camera->onOrientationEvent(orientation, tilt); 67 } 68 69} 70/*-------------Camera Hal Interface Method definitions STARTS here--------------------*/ 71 72/** 73 Callback function to receive orientation events from SensorListener 74 */ 75void CameraHal::onOrientationEvent(uint32_t orientation, uint32_t tilt) { 76 LOG_FUNCTION_NAME; 77 78 if ( NULL != mCameraAdapter ) { 79 mCameraAdapter->onOrientationEvent(orientation, tilt); 80 } 81 82 LOG_FUNCTION_NAME_EXIT; 83} 84 85/** 86 @brief Set the notification and data callbacks 87 88 @param[in] notify_cb Notify callback for notifying the app about events and errors 89 @param[in] data_cb Buffer callback for sending the preview/raw frames to the app 90 @param[in] data_cb_timestamp Buffer callback for sending the video frames w/ timestamp 91 @param[in] user Callback cookie 92 @return none 93 94 */ 95void CameraHal::setCallbacks(camera_notify_callback notify_cb, 96 camera_data_callback data_cb, 97 camera_data_timestamp_callback data_cb_timestamp, 98 camera_request_memory get_memory, 99 void *user) 100{ 101 LOG_FUNCTION_NAME; 102 103 if ( NULL != mAppCallbackNotifier.get() ) 104 { 105 mAppCallbackNotifier->setCallbacks(this, 106 notify_cb, 107 data_cb, 108 data_cb_timestamp, 109 get_memory, 110 user); 111 } 112 113 LOG_FUNCTION_NAME_EXIT; 114} 115 116/** 117 @brief Enable a message, or set of messages. 118 119 @param[in] msgtype Bitmask of the messages to enable (defined in include/ui/Camera.h) 120 @return none 121 122 */ 123void CameraHal::enableMsgType(int32_t msgType) 124{ 125 LOG_FUNCTION_NAME; 126 127 if ( ( msgType & CAMERA_MSG_SHUTTER ) && ( !mShutterEnabled ) ) 128 { 129 msgType &= ~CAMERA_MSG_SHUTTER; 130 } 131 132 { 133 Mutex::Autolock lock(mLock); 134 mMsgEnabled |= msgType; 135 } 136 137 if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) 138 { 139 if(mDisplayPaused) 140 { 141 CAMHAL_LOGDA("Preview currently paused...will enable preview callback when restarted"); 142 msgType &= ~CAMERA_MSG_PREVIEW_FRAME; 143 }else 144 { 145 CAMHAL_LOGDA("Enabling Preview Callback"); 146 } 147 } 148 else 149 { 150 CAMHAL_LOGDB("Preview callback not enabled %x", msgType); 151 } 152 153 154 ///Configure app callback notifier with the message callback required 155 mAppCallbackNotifier->enableMsgType (msgType); 156 157 LOG_FUNCTION_NAME_EXIT; 158} 159 160/** 161 @brief Disable a message, or set of messages. 162 163 @param[in] msgtype Bitmask of the messages to disable (defined in include/ui/Camera.h) 164 @return none 165 166 */ 167void CameraHal::disableMsgType(int32_t msgType) 168{ 169 LOG_FUNCTION_NAME; 170 171 { 172 Mutex::Autolock lock(mLock); 173 mMsgEnabled &= ~msgType; 174 } 175 176 if( msgType & CAMERA_MSG_PREVIEW_FRAME) 177 { 178 CAMHAL_LOGDA("Disabling Preview Callback"); 179 } 180 181 ///Configure app callback notifier 182 mAppCallbackNotifier->disableMsgType (msgType); 183 184 LOG_FUNCTION_NAME_EXIT; 185} 186 187/** 188 @brief Query whether a message, or a set of messages, is enabled. 189 190 Note that this is operates as an AND, if any of the messages queried are off, this will 191 return false. 192 193 @param[in] msgtype Bitmask of the messages to query (defined in include/ui/Camera.h) 194 @return true If all message types are enabled 195 false If any message type 196 197 */ 198int CameraHal::msgTypeEnabled(int32_t msgType) 199{ 200 LOG_FUNCTION_NAME; 201 Mutex::Autolock lock(mLock); 202 LOG_FUNCTION_NAME_EXIT; 203 return (mMsgEnabled & msgType); 204} 205 206/** 207 @brief Set the camera parameters. 208 209 @param[in] params Camera parameters to configure the camera 210 @return NO_ERROR 211 @todo Define error codes 212 213 */ 214int CameraHal::setParameters(const char* parameters) 215{ 216 217 LOG_FUNCTION_NAME; 218 219 CameraParameters params; 220 221 String8 str_params(parameters); 222 params.unflatten(str_params); 223 224 LOG_FUNCTION_NAME_EXIT; 225 226 return setParameters(params); 227} 228 229/** 230 @brief Set the camera parameters. 231 232 @param[in] params Camera parameters to configure the camera 233 @return NO_ERROR 234 @todo Define error codes 235 236 */ 237int CameraHal::setParameters(const CameraParameters& params) 238{ 239 240 LOG_FUNCTION_NAME; 241 242 int w, h; 243 int w_orig, h_orig; 244 int framerate,minframerate; 245 int maxFPS, minFPS; 246 int error; 247 int base; 248 const char *valstr = NULL; 249 const char *prevFormat; 250 char *af_coord; 251 TIUTILS::Message msg; 252 status_t ret = NO_ERROR; 253 // Needed for KEY_RECORDING_HINT 254 bool restartPreviewRequired = false; 255 CameraParameters oldParams(mParameters.flatten()); 256 257 { 258 Mutex::Autolock lock(mLock); 259 260 ///Ensure that preview is not enabled when the below parameters are changed. 261 if(!previewEnabled()) 262 { 263 264 CAMHAL_LOGDB("PreviewFormat %s", params.getPreviewFormat()); 265 266 if ((valstr = params.getPreviewFormat()) != NULL) { 267 if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS))) { 268 mParameters.setPreviewFormat(valstr); 269 } else { 270 CAMHAL_LOGEB("Invalid preview format.Supported: %s", mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); 271 return -EINVAL; 272 } 273 } 274 275 params.getPreviewSize(&w, &h); 276 if (w == -1 && h == -1) { 277 CAMHAL_LOGEA("Unable to get preview size"); 278 return -EINVAL; 279 } 280 281 int orientation =0; 282 if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL) 283 { 284 CAMHAL_LOGDB("Sensor Orientation is set to %s", params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)); 285 mParameters.set(TICameraParameters::KEY_SENSOR_ORIENTATION, valstr); 286 orientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION); 287 } 288 289 if(orientation ==90 || orientation ==270) 290 { 291 if ( !isResolutionValid(h,w, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) 292 { 293 CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h); 294 return -EINVAL; 295 } 296 else 297 { 298 mParameters.setPreviewSize(w, h); 299 } 300 } 301 else 302 { 303 if ( !isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) 304 { 305 CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h); 306 return -EINVAL; 307 } 308 else 309 { 310 mParameters.setPreviewSize(w, h); 311 } 312 } 313 314 CAMHAL_LOGDB("PreviewResolution by App %d x %d", w, h); 315 316 if ((valstr = params.get(TICameraParameters::KEY_VNF)) != NULL) { 317 if ( (params.getInt(TICameraParameters::KEY_VNF)==0) || (params.getInt(TICameraParameters::KEY_VNF)==1) ) { 318 CAMHAL_LOGDB("VNF set %s", params.get(TICameraParameters::KEY_VNF)); 319 mParameters.set(TICameraParameters::KEY_VNF, valstr); 320 } else { 321 CAMHAL_LOGEB("ERROR: Invalid VNF: %s", valstr); 322 ret = -EINVAL; 323 } 324 } 325 326 if ((valstr = params.get(TICameraParameters::KEY_VSTAB)) != NULL) { 327 if ((params.getInt(TICameraParameters::KEY_VSTAB)==0) || (params.getInt(TICameraParameters::KEY_VSTAB)==1)) { 328 CAMHAL_LOGDB("VSTAB set %s", params.get(TICameraParameters::KEY_VSTAB)); 329 mParameters.set(TICameraParameters::KEY_VSTAB, valstr); 330 } else { 331 CAMHAL_LOGEB("ERROR: Invalid VSTAB: %s", valstr); 332 ret = -EINVAL; 333 } 334 } 335 336 if( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL) 337 { 338 CAMHAL_LOGDB("Capture mode set %s", params.get(TICameraParameters::KEY_CAP_MODE)); 339 mParameters.set(TICameraParameters::KEY_CAP_MODE, valstr); 340 } 341 342 if ((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL) { 343 if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES))) { 344 CAMHAL_LOGDB("IPP mode set %s", params.get(TICameraParameters::KEY_IPP)); 345 mParameters.set(TICameraParameters::KEY_IPP, valstr); 346 } else { 347 CAMHAL_LOGEB("ERROR: Invalid IPP mode: %s", valstr); 348 ret = -EINVAL; 349 } 350 } 351 352 if((valstr = params.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) 353 { 354 CAMHAL_LOGDB("Stereo 3D->2D Preview mode is %s", params.get(TICameraParameters::KEY_S3D2D_PREVIEW)); 355 mParameters.set(TICameraParameters::KEY_S3D2D_PREVIEW, valstr); 356 } 357 358 if((valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL) 359 { 360 CAMHAL_LOGDB("AutoConvergence mode is %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE)); 361 mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr); 362 } 363 364 } 365 366 // Handle RECORDING_HINT to Set/Reset Video Mode Parameters 367 valstr = params.get(CameraParameters::KEY_RECORDING_HINT); 368 if(valstr != NULL) 369 { 370 if(strcmp(valstr, CameraParameters::TRUE) == 0) 371 { 372 CAMHAL_LOGDB("Recording Hint is set to %s", valstr); 373 mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr); 374 restartPreviewRequired = setVideoModeParameters(); 375 } 376 else if(strcmp(valstr, CameraParameters::FALSE) == 0) 377 { 378 CAMHAL_LOGDB("Recording Hint is set to %s", valstr); 379 mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr); 380 restartPreviewRequired = resetVideoModeParameters(); 381 } 382 else 383 { 384 CAMHAL_LOGEA("Invalid RECORDING_HINT"); 385 return -EINVAL; 386 } 387 } 388 else 389 { 390 // This check is required in following case. 391 // If VideoRecording activity sets KEY_RECORDING_HINT to TRUE and 392 // ImageCapture activity doesnot set KEY_RECORDING_HINT to FALSE (i.e. simply NULL), 393 // then Video Mode parameters may remain present in ImageCapture activity as well. 394 CAMHAL_LOGDA("Recording Hint is set to NULL"); 395 mParameters.set(CameraParameters::KEY_RECORDING_HINT, ""); 396 restartPreviewRequired = resetVideoModeParameters(); 397 } 398 399 ///Below parameters can be changed when the preview is running 400 if ( (valstr = params.getPictureFormat()) != NULL ) { 401 if (isParameterValid(params.getPictureFormat(),mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS))) { 402 mParameters.setPictureFormat(valstr); 403 } else { 404 CAMHAL_LOGEB("ERROR: Invalid picture format: %s",valstr); 405 ret = -EINVAL; 406 } 407 } 408 409 params.getPictureSize(&w, &h); 410 if ( isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES))) { 411 mParameters.setPictureSize(w, h); 412 } else { 413 CAMHAL_LOGEB("ERROR: Invalid picture resolution %dx%d", w, h); 414 ret = -EINVAL; 415 } 416 417 CAMHAL_LOGDB("Picture Size by App %d x %d", w, h); 418 419 if ((valstr = params.get(TICameraParameters::KEY_BURST)) != NULL) { 420 if (params.getInt(TICameraParameters::KEY_BURST) >=0) { 421 CAMHAL_LOGDB("Burst set %s", params.get(TICameraParameters::KEY_BURST)); 422 mParameters.set(TICameraParameters::KEY_BURST, valstr); 423 } else { 424 CAMHAL_LOGEB("ERROR: Invalid Burst value: %s",valstr); 425 ret = -EINVAL; 426 } 427 } 428 429 framerate = params.getPreviewFrameRate(); 430 CAMHAL_LOGDB("FRAMERATE %d", framerate); 431 432 // Variable framerate ranges have higher priority over 433 // deprecated constant FPS. "KEY_PREVIEW_FPS_RANGE" should 434 // be cleared by the client in order for constant FPS to get 435 // applied. 436 if ( ( valstr = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE) ) != NULL ) 437 { 438 CAMHAL_LOGDB("FPS Range = %s", valstr); 439 params.getPreviewFpsRange(&minFPS, &maxFPS); 440 441 if ( ( 0 > minFPS ) || ( 0 > maxFPS ) ) 442 { 443 CAMHAL_LOGEA("ERROR: FPS Range is negative!"); 444 ret = -EINVAL; 445 } 446 447 minFPS /= CameraHal::VFR_SCALE; 448 maxFPS /= CameraHal::VFR_SCALE; 449 450 if ( ( 0 == minFPS ) || ( 0 == maxFPS ) ) 451 { 452 CAMHAL_LOGEA("ERROR: FPS Range is invalid!"); 453 ret = -EINVAL; 454 } 455 456 if ( maxFPS < minFPS ) 457 { 458 CAMHAL_LOGEA("ERROR: Max FPS is smaller than Min FPS!"); 459 ret = -EINVAL; 460 } 461 462 if ( maxFPS > framerate ) 463 { 464 framerate = maxFPS; 465 mParameters.setPreviewFrameRate(framerate); 466 } 467 468 CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS); 469 mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS); 470 mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS); 471 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr); 472 } 473 else if ( isParameterValid(framerate, 474 mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)) ) 475 { 476 minFPS = framerate; 477 maxFPS = framerate; 478 mParameters.setPreviewFrameRate(framerate); 479 480 CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS); 481 mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS); 482 mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS); 483 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 484 params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE)); 485 } 486 else 487 { 488 return -EINVAL; 489 } 490 491 if( ( valstr = params.get(TICameraParameters::KEY_GBCE) ) != NULL ) 492 { 493 CAMHAL_LOGDB("GBCE Value = %s", valstr); 494 mParameters.set(TICameraParameters::KEY_GBCE, valstr); 495 } 496 497 if( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL ) 498 { 499 CAMHAL_LOGDB("GLBCE Value = %s", valstr); 500 mParameters.set(TICameraParameters::KEY_GLBCE, valstr); 501 } 502 503 ///Update the current parameter set 504 if( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL) 505 { 506 CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE)); 507 mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr); 508 } 509 510 // if(params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE)!=NULL) 511 // { 512 // CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE)); 513 // mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE)); 514 // } 515 516 if( (valstr = params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES)) !=NULL ) 517 { 518 CAMHAL_LOGDB("ManualConvergence Value = %s", params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES)); 519 mParameters.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, valstr); 520 } 521 522 if ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL) { 523 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES))) { 524 CAMHAL_LOGDB("Exposure set = %s", valstr); 525 mParameters.set(TICameraParameters::KEY_EXPOSURE_MODE, valstr); 526 } else { 527 CAMHAL_LOGEB("ERROR: Invalid Exposure = %s", valstr); 528 ret = -EINVAL; 529 } 530 } 531 532 if ((valstr = params.get(CameraParameters::KEY_WHITE_BALANCE)) != NULL) { 533 if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE))) { 534 CAMHAL_LOGDB("White balance set %s", valstr); 535 mParameters.set(CameraParameters::KEY_WHITE_BALANCE, valstr); 536 } else { 537 CAMHAL_LOGEB("ERROR: Invalid white balance = %s", valstr); 538 ret = -EINVAL; 539 } 540 } 541 542 if ((valstr = params.get(TICameraParameters::KEY_CONTRAST)) != NULL) { 543 if (params.getInt(TICameraParameters::KEY_CONTRAST) >= 0 ) { 544 CAMHAL_LOGDB("Contrast set %s", valstr); 545 mParameters.set(TICameraParameters::KEY_CONTRAST, valstr); 546 } else { 547 CAMHAL_LOGEB("ERROR: Invalid Contrast = %s", valstr); 548 ret = -EINVAL; 549 } 550 } 551 552 if ((valstr =params.get(TICameraParameters::KEY_SHARPNESS)) != NULL) { 553 if (params.getInt(TICameraParameters::KEY_SHARPNESS) >= 0 ) { 554 CAMHAL_LOGDB("Sharpness set %s", valstr); 555 mParameters.set(TICameraParameters::KEY_SHARPNESS, valstr); 556 } else { 557 CAMHAL_LOGEB("ERROR: Invalid Sharpness = %s", valstr); 558 ret = -EINVAL; 559 } 560 } 561 562 if ((valstr = params.get(TICameraParameters::KEY_SATURATION)) != NULL) { 563 if (params.getInt(TICameraParameters::KEY_SATURATION) >= 0 ) { 564 CAMHAL_LOGDB("Saturation set %s", valstr); 565 mParameters.set(TICameraParameters::KEY_SATURATION, valstr); 566 } else { 567 CAMHAL_LOGEB("ERROR: Invalid Saturation = %s", valstr); 568 ret = -EINVAL; 569 } 570 } 571 572 if ((valstr = params.get(TICameraParameters::KEY_BRIGHTNESS)) != NULL) { 573 if (params.getInt(TICameraParameters::KEY_BRIGHTNESS) >= 0 ) { 574 CAMHAL_LOGDB("Brightness set %s", valstr); 575 mParameters.set(TICameraParameters::KEY_BRIGHTNESS, valstr); 576 } else { 577 CAMHAL_LOGEB("ERROR: Invalid Brightness = %s", valstr); 578 ret = -EINVAL; 579 } 580 } 581 582 if ((valstr = params.get(CameraParameters::KEY_ANTIBANDING)) != NULL) { 583 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING))) { 584 CAMHAL_LOGDB("Antibanding set %s", valstr); 585 mParameters.set(CameraParameters::KEY_ANTIBANDING, valstr); 586 } else { 587 CAMHAL_LOGEB("ERROR: Invalid Antibanding = %s", valstr); 588 ret = -EINVAL; 589 } 590 } 591 592 if ((valstr = params.get(TICameraParameters::KEY_ISO)) != NULL) { 593 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES))) { 594 CAMHAL_LOGDB("ISO set %s", valstr); 595 mParameters.set(TICameraParameters::KEY_ISO, valstr); 596 } else { 597 CAMHAL_LOGEB("ERROR: Invalid ISO = %s", valstr); 598 ret = -EINVAL; 599 } 600 } 601 602 if ((valstr = params.get(CameraParameters::KEY_FOCUS_MODE)) != NULL) { 603 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES))) { 604 CAMHAL_LOGDB("Focus mode set %s", params.get(CameraParameters::KEY_FOCUS_MODE)); 605 mParameters.set(CameraParameters::KEY_FOCUS_MODE, valstr); 606 } else { 607 CAMHAL_LOGEB("ERROR: Invalid FOCUS mode = %s", valstr); 608 ret = -EINVAL; 609 } 610 } 611 612 if( (valstr = params.get(CameraParameters::KEY_FOCUS_AREAS)) != NULL ) 613 { 614 CAMHAL_LOGEB("Focus areas position set %s", params.get(CameraParameters::KEY_FOCUS_AREAS)); 615 mParameters.set(CameraParameters::KEY_FOCUS_AREAS, valstr); 616 } 617 618 if( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL ) 619 { 620 CAMHAL_LOGDB("Measurements set to %s", params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)); 621 mParameters.set(TICameraParameters::KEY_MEASUREMENT_ENABLE, valstr); 622 623 if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0) 624 { 625 mMeasurementEnabled = true; 626 } 627 else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0) 628 { 629 mMeasurementEnabled = false; 630 } 631 else 632 { 633 mMeasurementEnabled = false; 634 } 635 636 } 637 638 if( (valstr = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL) 639 { 640 CAMHAL_LOGDB("Exposure compensation set %s", params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION)); 641 mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, valstr); 642 } 643 644 if ((valstr = params.get(CameraParameters::KEY_SCENE_MODE)) != NULL) { 645 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES))) { 646 CAMHAL_LOGDB("Scene mode set %s", valstr); 647 mParameters.set(CameraParameters::KEY_SCENE_MODE, valstr); 648 } else { 649 CAMHAL_LOGEB("ERROR: Invalid Scene mode = %s", valstr); 650 ret = -EINVAL; 651 } 652 } 653 654 if ((valstr = params.get(CameraParameters::KEY_FLASH_MODE)) != NULL) { 655 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES))) { 656 CAMHAL_LOGDB("Flash mode set %s", valstr); 657 mParameters.set(CameraParameters::KEY_FLASH_MODE, valstr); 658 } else { 659 CAMHAL_LOGEB("ERROR: Invalid Flash mode = %s", valstr); 660 ret = -EINVAL; 661 } 662 } 663 664 if ((valstr = params.get(CameraParameters::KEY_EFFECT)) != NULL) { 665 if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS))) { 666 CAMHAL_LOGDB("Effect set %s", valstr); 667 mParameters.set(CameraParameters::KEY_EFFECT, valstr); 668 } else { 669 CAMHAL_LOGEB("ERROR: Invalid Effect = %s", valstr); 670 ret = -EINVAL; 671 } 672 } 673 674 if(( (valstr = params.get(CameraParameters::KEY_ROTATION)) != NULL) 675 && (params.getInt(CameraParameters::KEY_ROTATION) >=0)) 676 { 677 CAMHAL_LOGDB("Rotation set %s", params.get(CameraParameters::KEY_ROTATION)); 678 mParameters.set(CameraParameters::KEY_ROTATION, valstr); 679 } 680 681 if(( (valstr = params.get(CameraParameters::KEY_JPEG_QUALITY)) != NULL) 682 && (params.getInt(CameraParameters::KEY_JPEG_QUALITY) >=0)) 683 { 684 CAMHAL_LOGDB("Jpeg quality set %s", params.get(CameraParameters::KEY_JPEG_QUALITY)); 685 mParameters.set(CameraParameters::KEY_JPEG_QUALITY, valstr); 686 } 687 688 if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH)) != NULL) 689 && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH) >=0)) 690 { 691 CAMHAL_LOGDB("Thumbnail width set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH)); 692 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, valstr); 693 } 694 695 if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT)) != NULL) 696 && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT) >=0)) 697 { 698 CAMHAL_LOGDB("Thumbnail width set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT)); 699 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, valstr); 700 } 701 702 if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)) != NULL ) 703 && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY) >=0)) 704 { 705 CAMHAL_LOGDB("Thumbnail quality set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)); 706 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, valstr); 707 } 708 709 if( (valstr = params.get(CameraParameters::KEY_GPS_LATITUDE)) != NULL ) 710 { 711 CAMHAL_LOGDB("GPS latitude set %s", params.get(CameraParameters::KEY_GPS_LATITUDE)); 712 mParameters.set(CameraParameters::KEY_GPS_LATITUDE, valstr); 713 }else{ 714 mParameters.remove(CameraParameters::KEY_GPS_LATITUDE); 715 } 716 717 if( (valstr = params.get(CameraParameters::KEY_GPS_LONGITUDE)) != NULL ) 718 { 719 CAMHAL_LOGDB("GPS longitude set %s", params.get(CameraParameters::KEY_GPS_LONGITUDE)); 720 mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, valstr); 721 }else{ 722 mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE); 723 } 724 725 if( (valstr = params.get(CameraParameters::KEY_GPS_ALTITUDE)) != NULL ) 726 { 727 CAMHAL_LOGDB("GPS altitude set %s", params.get(CameraParameters::KEY_GPS_ALTITUDE)); 728 mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, valstr); 729 }else{ 730 mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE); 731 } 732 733 if( (valstr = params.get(CameraParameters::KEY_GPS_TIMESTAMP)) != NULL ) 734 { 735 CAMHAL_LOGDB("GPS timestamp set %s", params.get(CameraParameters::KEY_GPS_TIMESTAMP)); 736 mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, valstr); 737 }else{ 738 mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP); 739 } 740 741 if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL ) 742 { 743 CAMHAL_LOGDB("GPS datestamp set %s", params.get(TICameraParameters::KEY_GPS_DATESTAMP)); 744 mParameters.set(TICameraParameters::KEY_GPS_DATESTAMP, valstr); 745 }else{ 746 mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP); 747 } 748 749 if( (valstr = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL ) 750 { 751 CAMHAL_LOGDB("GPS processing method set %s", params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD)); 752 mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, valstr); 753 }else{ 754 mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD); 755 } 756 757 if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL ) 758 { 759 CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_MAPDATUM)); 760 mParameters.set(TICameraParameters::KEY_GPS_MAPDATUM, valstr); 761 }else{ 762 mParameters.remove(TICameraParameters::KEY_GPS_MAPDATUM); 763 } 764 765 if( (valstr = params.get(TICameraParameters::KEY_GPS_VERSION)) != NULL ) 766 { 767 CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_VERSION)); 768 mParameters.set(TICameraParameters::KEY_GPS_VERSION, valstr); 769 }else{ 770 mParameters.remove(TICameraParameters::KEY_GPS_VERSION); 771 } 772 773 if( (valstr = params.get(TICameraParameters::KEY_EXIF_MODEL)) != NULL ) 774 { 775 CAMHAL_LOGDB("EXIF Model set %s", params.get(TICameraParameters::KEY_EXIF_MODEL)); 776 mParameters.set(TICameraParameters::KEY_EXIF_MODEL, valstr); 777 } 778 779 if( (valstr = params.get(TICameraParameters::KEY_EXIF_MAKE)) != NULL ) 780 { 781 CAMHAL_LOGDB("EXIF Make set %s", params.get(TICameraParameters::KEY_EXIF_MAKE)); 782 mParameters.set(TICameraParameters::KEY_EXIF_MAKE, valstr); 783 } 784 785 if( (valstr = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL ) 786 { 787 CAMHAL_LOGDB("Exposure Bracketing set %s", params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)); 788 mParameters.set(TICameraParameters::KEY_EXP_BRACKETING_RANGE, valstr); 789 } 790 else 791 { 792 mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE); 793 } 794 795 if ((valstr = params.get(CameraParameters::KEY_ZOOM)) != NULL ) { 796 if ((params.getInt(CameraParameters::KEY_ZOOM) >= 0 ) && 797 (params.getInt(CameraParameters::KEY_ZOOM) <= mMaxZoomSupported )) { 798 CAMHAL_LOGDB("Zoom set %s", valstr); 799 mParameters.set(CameraParameters::KEY_ZOOM, valstr); 800 } else { 801 CAMHAL_LOGEB("ERROR: Invalid Zoom: %s", valstr); 802 ret = -EINVAL; 803 } 804 } 805 806 if( (valstr = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL ) 807 { 808 CAMHAL_LOGDB("Auto Exposure Lock set %s", params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 809 mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr); 810 } 811 812 if( (valstr = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL ) 813 { 814 CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 815 mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr); 816 } 817 818 CameraParameters adapterParams = mParameters; 819 820 // Only send parameters to adapter if preview is already 821 // enabled. Initial setParameters to camera adapter, will 822 // be called in startPreview() 823 if ( NULL != mCameraAdapter && mPreviewEnabled ) { 824 ret |= mCameraAdapter->setParameters(adapterParams); 825 } 826 827 if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS) ) 828 { 829 int posBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS); 830 if ( 0 < posBracketRange ) 831 { 832 mBracketRangePositive = posBracketRange; 833 } 834 } 835 CAMHAL_LOGDB("Positive bracketing range %d", mBracketRangePositive); 836 837 838 if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG) ) 839 { 840 int negBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG); 841 if ( 0 < negBracketRange ) 842 { 843 mBracketRangeNegative = negBracketRange; 844 } 845 } 846 CAMHAL_LOGDB("Negative bracketing range %d", mBracketRangeNegative); 847 848 if( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL) && 849 ( strcmp(valstr, TICameraParameters::BRACKET_ENABLE) == 0 )) 850 { 851 if ( !mBracketingEnabled ) 852 { 853 CAMHAL_LOGDA("Enabling bracketing"); 854 mBracketingEnabled = true; 855 856 //Wait for AF events to enable bracketing 857 if ( NULL != mCameraAdapter ) 858 { 859 setEventProvider( CameraHalEvent::ALL_EVENTS, mCameraAdapter ); 860 } 861 } 862 else 863 { 864 CAMHAL_LOGDA("Bracketing already enabled"); 865 } 866 } 867 else if ( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL ) && 868 ( strcmp(valstr, TICameraParameters::BRACKET_DISABLE) == 0 )) 869 { 870 CAMHAL_LOGDA("Disabling bracketing"); 871 872 mBracketingEnabled = false; 873 stopImageBracketing(); 874 875 //Remove AF events subscription 876 if ( NULL != mEventProvider ) 877 { 878 mEventProvider->disableEventNotification( CameraHalEvent::ALL_EVENTS ); 879 delete mEventProvider; 880 mEventProvider = NULL; 881 } 882 883 } 884 885 if( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) && 886 ( strcmp(valstr, TICameraParameters::SHUTTER_ENABLE) == 0 )) 887 { 888 CAMHAL_LOGDA("Enabling shutter sound"); 889 890 mShutterEnabled = true; 891 mMsgEnabled |= CAMERA_MSG_SHUTTER; 892 mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr); 893 } 894 else if ( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) && 895 ( strcmp(valstr, TICameraParameters::SHUTTER_DISABLE) == 0 )) 896 { 897 CAMHAL_LOGDA("Disabling shutter sound"); 898 899 mShutterEnabled = false; 900 mMsgEnabled &= ~CAMERA_MSG_SHUTTER; 901 mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr); 902 } 903 904 } 905 906 //On fail restore old parameters 907 if ( NO_ERROR != ret ) { 908 mParameters.unflatten(oldParams.flatten()); 909 } 910 911 // Restart Preview if needed by KEY_RECODING_HINT only if preview is already running. 912 // If preview is not started yet, Video Mode parameters will take effect on next startPreview() 913 if(restartPreviewRequired && previewEnabled()) 914 { 915 CAMHAL_LOGDA("Restarting Preview as needed by KEY_RECODING_HINT"); 916 ret = restartPreview(); 917 } 918 if (ret != NO_ERROR) 919 { 920 CAMHAL_LOGEA("Failed to restart Preview"); 921 return ret; 922 } 923 924 LOG_FUNCTION_NAME_EXIT; 925 926 return ret; 927} 928 929status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewFormat, 930 unsigned int buffercount, unsigned int &max_queueable) 931{ 932 status_t ret = NO_ERROR; 933 934 LOG_FUNCTION_NAME; 935 936 if(mDisplayAdapter.get() == NULL) 937 { 938 // Memory allocation of preview buffers is now placed in gralloc 939 // CameraHal should not allocate preview buffers without DisplayAdapter 940 return NO_MEMORY; 941 } 942 943 if(!mPreviewBufs) 944 { 945 ///@todo Pluralise the name of this method to allocateBuffers 946 mPreviewLength = 0; 947 mPreviewBufs = (int32_t *) mDisplayAdapter->allocateBuffer(width, height, 948 previewFormat, 949 mPreviewLength, 950 buffercount); 951 952 if (NULL == mPreviewBufs ) { 953 CAMHAL_LOGEA("Couldn't allocate preview buffers"); 954 return NO_MEMORY; 955 } 956 957 mPreviewOffsets = (uint32_t *) mDisplayAdapter->getOffsets(); 958 if ( NULL == mPreviewOffsets ) { 959 CAMHAL_LOGEA("Buffer mapping failed"); 960 return BAD_VALUE; 961 } 962 963 mPreviewFd = mDisplayAdapter->getFd(); 964 if ( -1 == mPreviewFd ) { 965 CAMHAL_LOGEA("Invalid handle"); 966 return BAD_VALUE; 967 } 968 969 mBufProvider = (BufferProvider*) mDisplayAdapter.get(); 970 971 ret = mDisplayAdapter->maxQueueableBuffers(max_queueable); 972 if (ret != NO_ERROR) { 973 return ret; 974 } 975 976 } 977 978 LOG_FUNCTION_NAME_EXIT; 979 980 return ret; 981 982} 983 984status_t CameraHal::freePreviewBufs() 985{ 986 status_t ret = NO_ERROR; 987 LOG_FUNCTION_NAME; 988 989 CAMHAL_LOGDB("mPreviewBufs = 0x%x", (unsigned int)mPreviewBufs); 990 if(mPreviewBufs) 991 { 992 ///@todo Pluralise the name of this method to freeBuffers 993 ret = mBufProvider->freeBuffer(mPreviewBufs); 994 mPreviewBufs = NULL; 995 LOG_FUNCTION_NAME_EXIT; 996 return ret; 997 } 998 LOG_FUNCTION_NAME_EXIT; 999 return ret; 1000} 1001 1002 1003status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount) 1004{ 1005 status_t ret = NO_ERROR; 1006 int bytes; 1007 1008 LOG_FUNCTION_NAME; 1009 1010 bytes = size; 1011 1012 if ( NO_ERROR == ret ) 1013 { 1014 if( NULL != mPreviewDataBufs ) 1015 { 1016 ret = freePreviewDataBufs(); 1017 } 1018 } 1019 1020 if ( NO_ERROR == ret ) 1021 { 1022 mPreviewDataBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, NULL, bytes, bufferCount); 1023 1024 CAMHAL_LOGDB("Size of Preview data buffer = %d", bytes); 1025 if( NULL == mPreviewDataBufs ) 1026 { 1027 CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager"); 1028 ret = -NO_MEMORY; 1029 } 1030 else 1031 { 1032 bytes = size; 1033 } 1034 } 1035 1036 if ( NO_ERROR == ret ) 1037 { 1038 mPreviewDataFd = mMemoryManager->getFd(); 1039 mPreviewDataLength = bytes; 1040 mPreviewDataOffsets = mMemoryManager->getOffsets(); 1041 } 1042 else 1043 { 1044 mPreviewDataFd = -1; 1045 mPreviewDataLength = 0; 1046 mPreviewDataOffsets = NULL; 1047 } 1048 1049 LOG_FUNCTION_NAME; 1050 1051 return ret; 1052} 1053 1054status_t CameraHal::freePreviewDataBufs() 1055{ 1056 status_t ret = NO_ERROR; 1057 1058 LOG_FUNCTION_NAME; 1059 1060 if ( NO_ERROR == ret ) 1061 { 1062 1063 if( NULL != mPreviewDataBufs ) 1064 { 1065 1066 ///@todo Pluralise the name of this method to freeBuffers 1067 ret = mMemoryManager->freeBuffer(mPreviewDataBufs); 1068 mPreviewDataBufs = NULL; 1069 1070 } 1071 else 1072 { 1073 CAMHAL_LOGEA("Couldn't free PreviewDataBufs allocated by memory manager"); 1074 ret = -EINVAL; 1075 } 1076 1077 } 1078 1079 LOG_FUNCTION_NAME_EXIT; 1080 1081 return ret; 1082} 1083 1084status_t CameraHal::allocImageBufs(unsigned int width, unsigned int height, size_t size, const char* previewFormat, unsigned int bufferCount) 1085{ 1086 status_t ret = NO_ERROR; 1087 int bytes; 1088 1089 LOG_FUNCTION_NAME; 1090 1091 bytes = size; 1092 1093 ///Always allocate the buffers for image capture using MemoryManager 1094 if ( NO_ERROR == ret ) 1095 { 1096 if( ( NULL != mImageBufs ) ) 1097 { 1098 ret = freeImageBufs(); 1099 } 1100 } 1101 1102 if ( NO_ERROR == ret ) 1103 { 1104 mImageBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, previewFormat, bytes, bufferCount); 1105 1106 CAMHAL_LOGDB("Size of Image cap buffer = %d", bytes); 1107 if( NULL == mImageBufs ) 1108 { 1109 CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager"); 1110 ret = -NO_MEMORY; 1111 } 1112 else 1113 { 1114 bytes = size; 1115 } 1116 } 1117 1118 if ( NO_ERROR == ret ) 1119 { 1120 mImageFd = mMemoryManager->getFd(); 1121 mImageLength = bytes; 1122 mImageOffsets = mMemoryManager->getOffsets(); 1123 } 1124 else 1125 { 1126 mImageFd = -1; 1127 mImageLength = 0; 1128 mImageOffsets = NULL; 1129 } 1130 1131 LOG_FUNCTION_NAME; 1132 1133 return ret; 1134} 1135 1136void endImageCapture( void *userData) 1137{ 1138 LOG_FUNCTION_NAME; 1139 1140 if ( NULL != userData ) 1141 { 1142 CameraHal *c = reinterpret_cast<CameraHal *>(userData); 1143 c->signalEndImageCapture(); 1144 } 1145 1146 LOG_FUNCTION_NAME_EXIT; 1147} 1148 1149void releaseImageBuffers(void *userData) 1150{ 1151 LOG_FUNCTION_NAME; 1152 1153 if ( NULL != userData ) 1154 { 1155 CameraHal *c = reinterpret_cast<CameraHal *>(userData); 1156 c->freeImageBufs(); 1157 } 1158 1159 LOG_FUNCTION_NAME_EXIT; 1160} 1161 1162status_t CameraHal::signalEndImageCapture() 1163{ 1164 status_t ret = NO_ERROR; 1165 int w,h; 1166 CameraParameters adapterParams = mParameters; 1167 Mutex::Autolock lock(mLock); 1168 1169 LOG_FUNCTION_NAME; 1170 1171 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE); 1172 1173 LOG_FUNCTION_NAME_EXIT; 1174 1175 return ret; 1176} 1177 1178status_t CameraHal::freeImageBufs() 1179{ 1180 status_t ret = NO_ERROR; 1181 1182 LOG_FUNCTION_NAME; 1183 1184 if ( NO_ERROR == ret ) 1185 { 1186 1187 if( NULL != mImageBufs ) 1188 { 1189 1190 ///@todo Pluralise the name of this method to freeBuffers 1191 ret = mMemoryManager->freeBuffer(mImageBufs); 1192 mImageBufs = NULL; 1193 1194 } 1195 else 1196 { 1197 ret = -EINVAL; 1198 } 1199 1200 } 1201 1202 LOG_FUNCTION_NAME_EXIT; 1203 1204 return ret; 1205} 1206 1207 1208 1209/** 1210 @brief Start preview mode. 1211 1212 @param none 1213 @return NO_ERROR Camera switched to VF mode 1214 @todo Update function header with the different errors that are possible 1215 1216 */ 1217status_t CameraHal::startPreview() 1218{ 1219 1220 status_t ret = NO_ERROR; 1221 CameraAdapter::BuffersDescriptor desc; 1222 CameraFrame frame; 1223 const char *valstr = NULL; 1224 unsigned int required_buffer_count; 1225 unsigned int max_queueble_buffers; 1226 1227#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1228 1229 gettimeofday(&mStartPreview, NULL); 1230 1231#endif 1232 1233 LOG_FUNCTION_NAME; 1234 1235 if ( mPreviewEnabled ) 1236 { 1237 CAMHAL_LOGDA("Preview already running"); 1238 1239 LOG_FUNCTION_NAME_EXIT; 1240 1241 return ALREADY_EXISTS; 1242 } 1243 1244 if ( NULL != mCameraAdapter ) { 1245 1246 ret = mCameraAdapter->setParameters(mParameters); 1247 } 1248 1249 ///If we don't have the preview callback enabled and display adapter, 1250 if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)) 1251 { 1252 CAMHAL_LOGEA("Preview not started. Preview in progress flag set"); 1253 mPreviewStartInProgress = true; 1254 return NO_ERROR; 1255 } 1256 1257 if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) ) 1258 { 1259 CAMHAL_LOGDA("Preview is in paused state"); 1260 1261 mDisplayPaused = false; 1262 mPreviewEnabled = true; 1263 if ( NO_ERROR == ret ) 1264 { 1265 ret = mDisplayAdapter->pauseDisplay(mDisplayPaused); 1266 1267 if ( NO_ERROR != ret ) 1268 { 1269 CAMHAL_LOGEB("Display adapter resume failed %x", ret); 1270 } 1271 } 1272 //restart preview callbacks 1273 if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) 1274 { 1275 mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME); 1276 } 1277 return ret; 1278 1279 } 1280 1281 /// Ensure that buffers for preview are allocated before we start the camera 1282 ///Get the updated size from Camera Adapter, to account for padding etc 1283 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW, 1284 ( int ) &frame); 1285 if ( NO_ERROR != ret ) 1286 { 1287 return ret; 1288 } 1289 1290 ///Update the current preview width and height 1291 mPreviewWidth = frame.mWidth; 1292 mPreviewHeight = frame.mHeight; 1293 1294 //Update the padded width and height - required for VNF and VSTAB 1295 mParameters.set(TICameraParameters::KEY_PADDED_WIDTH, mPreviewWidth); 1296 mParameters.set(TICameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight); 1297 1298 required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); 1299 1300 ///Allocate the preview buffers 1301 ret = allocPreviewBufs(frame.mWidth, frame.mHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers); 1302 1303 if ( NO_ERROR != ret ) 1304 { 1305 CAMHAL_LOGEA("Couldn't allocate buffers for Preview"); 1306 goto error; 1307 } 1308 1309 if ( mMeasurementEnabled ) 1310 { 1311 1312 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA, 1313 ( int ) &frame, 1314 required_buffer_count); 1315 if ( NO_ERROR != ret ) 1316 { 1317 return ret; 1318 } 1319 1320 ///Allocate the preview data buffers 1321 ret = allocPreviewDataBufs(frame.mLength, required_buffer_count); 1322 if ( NO_ERROR != ret ) { 1323 CAMHAL_LOGEA("Couldn't allocate preview data buffers"); 1324 goto error; 1325 } 1326 1327 if ( NO_ERROR == ret ) 1328 { 1329 desc.mBuffers = mPreviewDataBufs; 1330 desc.mOffsets = mPreviewDataOffsets; 1331 desc.mFd = mPreviewDataFd; 1332 desc.mLength = mPreviewDataLength; 1333 desc.mCount = ( size_t ) required_buffer_count; 1334 desc.mMaxQueueable = (size_t) required_buffer_count; 1335 1336 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA, 1337 ( int ) &desc); 1338 } 1339 1340 } 1341 1342 ///Pass the buffers to Camera Adapter 1343 desc.mBuffers = mPreviewBufs; 1344 desc.mOffsets = mPreviewOffsets; 1345 desc.mFd = mPreviewFd; 1346 desc.mLength = mPreviewLength; 1347 desc.mCount = ( size_t ) required_buffer_count; 1348 desc.mMaxQueueable = (size_t) max_queueble_buffers; 1349 1350 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW, 1351 ( int ) &desc); 1352 1353 mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count); 1354 1355 ///Start the callback notifier 1356 ret = mAppCallbackNotifier->start(); 1357 1358 if( ALREADY_EXISTS == ret ) 1359 { 1360 //Already running, do nothing 1361 CAMHAL_LOGDA("AppCallbackNotifier already running"); 1362 ret = NO_ERROR; 1363 } 1364 else if ( NO_ERROR == ret ) { 1365 CAMHAL_LOGDA("Started AppCallbackNotifier.."); 1366 mAppCallbackNotifier->setMeasurements(mMeasurementEnabled); 1367 } 1368 else 1369 { 1370 CAMHAL_LOGDA("Couldn't start AppCallbackNotifier"); 1371 goto error; 1372 } 1373 1374 ///Enable the display adapter if present, actual overlay enable happens when we post the buffer 1375 if(mDisplayAdapter.get() != NULL) 1376 { 1377 CAMHAL_LOGDA("Enabling display"); 1378 bool isS3d = false; 1379 DisplayAdapter::S3DParameters s3dParams; 1380 int width, height; 1381 mParameters.getPreviewSize(&width, &height); 1382#if 0 //TODO: s3d is not part of bringup...will reenable 1383 if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_SUPPORTED)) != NULL) { 1384 isS3d = (strcmp(valstr, "true") == 0); 1385 } 1386 if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) { 1387 if (strcmp(valstr, "off") == 0) 1388 { 1389 CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS OFF"); 1390 //TODO: obtain the frame packing configuration from camera or user settings 1391 //once side by side configuration is supported 1392 s3dParams.mode = OVERLAY_S3D_MODE_ON; 1393 s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER; 1394 s3dParams.order = OVERLAY_S3D_ORDER_LF; 1395 s3dParams.subSampling = OVERLAY_S3D_SS_NONE; 1396 } 1397 else 1398 { 1399 CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS ON"); 1400 s3dParams.mode = OVERLAY_S3D_MODE_OFF; 1401 s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER; 1402 s3dParams.order = OVERLAY_S3D_ORDER_LF; 1403 s3dParams.subSampling = OVERLAY_S3D_SS_NONE; 1404 } 1405 } 1406#endif //if 0 1407 1408#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1409 1410 ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview, isS3d ? &s3dParams : NULL); 1411 1412#else 1413 1414 ret = mDisplayAdapter->enableDisplay(width, height, NULL, isS3d ? &s3dParams : NULL); 1415 1416#endif 1417 1418 if ( ret != NO_ERROR ) 1419 { 1420 CAMHAL_LOGEA("Couldn't enable display"); 1421 goto error; 1422 } 1423 1424 } 1425 1426 ///Send START_PREVIEW command to adapter 1427 CAMHAL_LOGDA("Starting CameraAdapter preview mode"); 1428 1429 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW); 1430 1431 if(ret!=NO_ERROR) 1432 { 1433 CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter"); 1434 goto error; 1435 } 1436 CAMHAL_LOGDA("Started preview"); 1437 1438 mPreviewEnabled = true; 1439 mPreviewStartInProgress = false; 1440 return ret; 1441 1442 error: 1443 1444 CAMHAL_LOGEA("Performing cleanup after error"); 1445 1446 //Do all the cleanup 1447 freePreviewBufs(); 1448 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW); 1449 if(mDisplayAdapter.get() != NULL) 1450 { 1451 mDisplayAdapter->disableDisplay(); 1452 } 1453 mAppCallbackNotifier->stop(); 1454 mPreviewStartInProgress = false; 1455 mPreviewEnabled = false; 1456 LOG_FUNCTION_NAME_EXIT; 1457 1458 return ret; 1459} 1460 1461/** 1462 @brief Sets ANativeWindow object. 1463 1464 Preview buffers provided to CameraHal via this object. DisplayAdapter will be interfacing with it 1465 to render buffers to display. 1466 1467 @param[in] window The ANativeWindow object created by Surface flinger 1468 @return NO_ERROR If the ANativeWindow object passes validation criteria 1469 @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios 1470 1471 */ 1472status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window) 1473{ 1474 status_t ret = NO_ERROR; 1475 CameraAdapter::BuffersDescriptor desc; 1476 1477 LOG_FUNCTION_NAME; 1478 mSetPreviewWindowCalled = true; 1479 1480 ///If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter 1481 if(!window) 1482 { 1483 if(mDisplayAdapter.get() != NULL) 1484 { 1485 ///NULL window passed, destroy the display adapter if present 1486 CAMHAL_LOGEA("NULL window passed, destroying display adapter"); 1487 mDisplayAdapter.clear(); 1488 ///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client 1489 ///@remarks so, we will wait until it passes a valid window to begin the preview again 1490 mSetPreviewWindowCalled = false; 1491 } 1492 CAMHAL_LOGEA("NULL ANativeWindow passed to setPreviewWindow"); 1493 return NO_ERROR; 1494 }else if(mDisplayAdapter.get() == NULL) 1495 { 1496 // Need to create the display adapter since it has not been created 1497 // Create display adapter 1498 mDisplayAdapter = new ANativeWindowDisplayAdapter(); 1499 ret = NO_ERROR; 1500 if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR)) 1501 { 1502 if(ret!=NO_ERROR) 1503 { 1504 mDisplayAdapter.clear(); 1505 CAMHAL_LOGEA("DisplayAdapter initialize failed"); 1506 LOG_FUNCTION_NAME_EXIT; 1507 return ret; 1508 } 1509 else 1510 { 1511 CAMHAL_LOGEA("Couldn't create DisplayAdapter"); 1512 LOG_FUNCTION_NAME_EXIT; 1513 return NO_MEMORY; 1514 } 1515 } 1516 1517 // DisplayAdapter needs to know where to get the CameraFrames from inorder to display 1518 // Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter 1519 mDisplayAdapter->setFrameProvider(mCameraAdapter); 1520 1521 // Any dynamic errors that happen during the camera use case has to be propagated back to the application 1522 // via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application 1523 // Set it as the error handler for the DisplayAdapter 1524 mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get()); 1525 1526 // Update the display adapter with the new window that is passed from CameraService 1527 ret = mDisplayAdapter->setPreviewWindow(window); 1528 if(ret!=NO_ERROR) 1529 { 1530 CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret); 1531 } 1532 1533 if(mPreviewStartInProgress) 1534 { 1535 CAMHAL_LOGDA("setPreviewWindow called when preview running"); 1536 // Start the preview since the window is now available 1537 ret = startPreview(); 1538 } 1539 }else 1540 { 1541 /* If mDisplayAdpater is already created. No need to do anything. 1542 * We get a surface handle directly now, so we can reconfigure surface 1543 * itself in DisplayAdapter if dimensions have changed 1544 */ 1545 } 1546 LOG_FUNCTION_NAME_EXIT; 1547 1548 return ret; 1549 1550} 1551 1552 1553/** 1554 @brief Stop a previously started preview. 1555 1556 @param none 1557 @return none 1558 1559 */ 1560void CameraHal::stopPreview() 1561{ 1562 LOG_FUNCTION_NAME; 1563 1564 if(!previewEnabled() && !mDisplayPaused) 1565 { 1566 LOG_FUNCTION_NAME_EXIT; 1567 return; 1568 } 1569 1570 if(mDisplayPaused) 1571 { 1572 // Display is paused, which essentially means there is no preview active. 1573 // Note: this is done so that when stopPreview is called by client after 1574 // an image capture, we do not de-initialize the camera adapter and 1575 // restart over again. 1576 1577 // Since we are not calling CameraAdapter->stopPreview, we need to 1578 // explicitly release the 3A locks in this first level stopPreview call 1579 // before returning 1580 if ( NULL != mCameraAdapter ) { 1581 CameraParameters adapterParams = mParameters; 1582 1583 adapterParams.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, CameraParameters::FALSE); 1584 adapterParams.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, CameraParameters::FALSE); 1585 mCameraAdapter->setParameters(adapterParams); 1586 } 1587 1588 return; 1589 } 1590 1591 forceStopPreview(); 1592 1593 // Reset Capture-Mode to default, so that when we switch from VideoRecording 1594 // to ImageCapture, CAPTURE_MODE is not left to VIDEO_MODE. 1595 CAMHAL_LOGDA("Resetting Capture-Mode to default"); 1596 mParameters.set(TICameraParameters::KEY_CAP_MODE, ""); 1597 1598 LOG_FUNCTION_NAME_EXIT; 1599} 1600 1601/** 1602 @brief Returns true if preview is enabled 1603 1604 @param none 1605 @return true If preview is running currently 1606 false If preview has been stopped 1607 1608 */ 1609bool CameraHal::previewEnabled() 1610{ 1611 LOG_FUNCTION_NAME; 1612 1613 return (mPreviewEnabled || mPreviewStartInProgress); 1614} 1615 1616/** 1617 @brief Start record mode. 1618 1619 When a record image is available a CAMERA_MSG_VIDEO_FRAME message is sent with 1620 the corresponding frame. Every record frame must be released by calling 1621 releaseRecordingFrame(). 1622 1623 @param none 1624 @return NO_ERROR If recording could be started without any issues 1625 @todo Update the header with possible error values in failure scenarios 1626 1627 */ 1628status_t CameraHal::startRecording( ) 1629{ 1630 int w, h; 1631 const char *valstr = NULL; 1632 bool restartPreviewRequired = false; 1633 status_t ret = NO_ERROR; 1634 1635 LOG_FUNCTION_NAME; 1636 1637 1638#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1639 1640 gettimeofday(&mStartPreview, NULL); 1641 1642#endif 1643 1644 if(!previewEnabled()) 1645 { 1646 return NO_INIT; 1647 } 1648 1649 valstr = mParameters.get(CameraParameters::KEY_RECORDING_HINT); 1650 if ( (valstr == NULL) || 1651 ( (valstr != NULL) && (strcmp(valstr, CameraParameters::TRUE) != 0) ) ) 1652 { 1653 restartPreviewRequired = setVideoModeParameters(); 1654 1655 if(restartPreviewRequired) 1656 { 1657 ret = restartPreview(); 1658 } 1659 } 1660 1661 if ( NO_ERROR == ret ) 1662 { 1663 ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS))); 1664 } 1665 1666 if ( NO_ERROR == ret ) 1667 { 1668 ret = mAppCallbackNotifier->startRecording(); 1669 } 1670 1671 if ( NO_ERROR == ret ) 1672 { 1673 ///Buffers for video capture (if different from preview) are expected to be allocated within CameraAdapter 1674 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_VIDEO); 1675 } 1676 1677 if ( NO_ERROR == ret ) 1678 { 1679 mRecordingEnabled = true; 1680 } 1681 1682 LOG_FUNCTION_NAME_EXIT; 1683 1684 return ret; 1685} 1686 1687/** 1688 @brief Set the camera parameters specific to Video Recording. 1689 1690 This function checks for the camera parameters which have to be set for recording. 1691 Video Recording needs CAPTURE_MODE to be VIDEO_MODE. This function sets it. 1692 This function also enables Video Recording specific functions like VSTAB & VNF. 1693 1694 @param none 1695 @return true if preview needs to be restarted for VIDEO_MODE parameters to take effect. 1696 @todo Modify the policies for enabling VSTAB & VNF usecase based later. 1697 1698 */ 1699bool CameraHal::setVideoModeParameters() 1700{ 1701 const char *valstr = NULL; 1702 bool restartPreviewRequired = false; 1703 status_t ret = NO_ERROR; 1704 1705 LOG_FUNCTION_NAME; 1706 1707 // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview 1708 valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); 1709 if ( (valstr == NULL) || 1710 ( (valstr != NULL) && (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) != 0) ) ) 1711 { 1712 CAMHAL_LOGDA("Set CAPTURE_MODE to VIDEO_MODE"); 1713 mParameters.set(TICameraParameters::KEY_CAP_MODE, (const char *) TICameraParameters::VIDEO_MODE); 1714 restartPreviewRequired = true; 1715 } 1716 1717 // Check if CAPTURE_MODE is VIDEO_MODE, since VSTAB & VNF work only in VIDEO_MODE. 1718 valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); 1719 if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0) 1720 { 1721 // Enable VSTAB, if not enabled already 1722 valstr = mParameters.get(TICameraParameters::KEY_VSTAB); 1723 if ( (valstr == NULL) || 1724 ( (valstr != NULL) && (strcmp(valstr, "1") != 0) ) ) 1725 { 1726 CAMHAL_LOGDA("Enable VSTAB"); 1727 mParameters.set(TICameraParameters::KEY_VSTAB, "1"); 1728 restartPreviewRequired = true; 1729 } 1730 1731 // Enable VNF, if not enabled already 1732 valstr = mParameters.get(TICameraParameters::KEY_VNF); 1733 if ( (valstr == NULL) || 1734 ( (valstr != NULL) && (strcmp(valstr, "1") != 0) ) ) 1735 { 1736 CAMHAL_LOGDA("Enable VNF"); 1737 mParameters.set(TICameraParameters::KEY_VNF, "1"); 1738 restartPreviewRequired = true; 1739 } 1740 1741 // For VSTAB alone for 1080p resolution, padded width goes > 2048, which cannot be rendered by GPU. 1742 // In such case, there is support in Ducati for combination of VSTAB & VNF requiring padded width < 2048. 1743 // So we are forcefully enabling VNF, if VSTAB is enabled for 1080p resolution. 1744 valstr = mParameters.get(TICameraParameters::KEY_VSTAB); 1745 if ((valstr != NULL) && (strcmp(valstr, "1") == 0) && (mPreviewWidth == 1920)) 1746 { 1747 CAMHAL_LOGDA("Force Enable VNF for 1080p"); 1748 mParameters.set(TICameraParameters::KEY_VNF, "1"); 1749 restartPreviewRequired = true; 1750 } 1751 } 1752 1753 LOG_FUNCTION_NAME_EXIT; 1754 1755 return restartPreviewRequired; 1756} 1757 1758/** 1759 @brief Reset the camera parameters specific to Video Recording. 1760 1761 This function resets CAPTURE_MODE and disables Recording specific functions like VSTAB & VNF. 1762 1763 @param none 1764 @return true if preview needs to be restarted for VIDEO_MODE parameters to take effect. 1765 1766 */ 1767bool CameraHal::resetVideoModeParameters() 1768{ 1769 const char *valstr = NULL; 1770 bool restartPreviewRequired = false; 1771 status_t ret = NO_ERROR; 1772 1773 LOG_FUNCTION_NAME; 1774 1775 // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview 1776 valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); 1777 if ( (valstr != NULL) && (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0) ) 1778 { 1779 CAMHAL_LOGDA("Reset Capture-Mode to default"); 1780 mParameters.set(TICameraParameters::KEY_CAP_MODE, ""); 1781 restartPreviewRequired = true; 1782 } 1783 1784 // Enable VSTAB, if not enabled already 1785 valstr = mParameters.get(TICameraParameters::KEY_VSTAB); 1786 if ( (valstr != NULL) && (strcmp(valstr, "1") == 0) ) 1787 { 1788 CAMHAL_LOGDA("Disable VSTAB"); 1789 mParameters.set(TICameraParameters::KEY_VSTAB, "0"); 1790 restartPreviewRequired = true; 1791 } 1792 1793 // Enable VNF, if not enabled already 1794 valstr = mParameters.get(TICameraParameters::KEY_VNF); 1795 if ( (valstr != NULL) && (strcmp(valstr, "1") == 0) ) 1796 { 1797 CAMHAL_LOGDA("Disable VNF"); 1798 mParameters.set(TICameraParameters::KEY_VNF, "0"); 1799 restartPreviewRequired = true; 1800 } 1801 1802 LOG_FUNCTION_NAME_EXIT; 1803 1804 return restartPreviewRequired; 1805} 1806 1807/** 1808 @brief Restart the preview with setParameter. 1809 1810 This function restarts preview, for some VIDEO_MODE parameters to take effect. 1811 1812 @param none 1813 @return NO_ERROR If recording parameters could be set without any issues 1814 1815 */ 1816status_t CameraHal::restartPreview() 1817{ 1818 const char *valstr = NULL; 1819 char tmpvalstr[30]; 1820 status_t ret = NO_ERROR; 1821 1822 LOG_FUNCTION_NAME; 1823 1824 // Retain CAPTURE_MODE before calling stopPreview(), since it is reset in stopPreview(). 1825 tmpvalstr[0] = 0; 1826 valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); 1827 if(valstr != NULL) 1828 { 1829 if(sizeof(tmpvalstr) < (strlen(valstr)+1)) 1830 { 1831 return -EINVAL; 1832 } 1833 1834 strncpy(tmpvalstr, valstr, sizeof(tmpvalstr)); 1835 tmpvalstr[sizeof(tmpvalstr)-1] = 0; 1836 } 1837 1838 stopPreview(); 1839 1840 { 1841 Mutex::Autolock lock(mLock); 1842 mParameters.set(TICameraParameters::KEY_CAP_MODE, tmpvalstr); 1843 mCameraAdapter->setParameters(mParameters); 1844 } 1845 1846 ret = startPreview(); 1847 1848 LOG_FUNCTION_NAME_EXIT; 1849 1850 return ret; 1851} 1852 1853/** 1854 @brief Stop a previously started recording. 1855 1856 @param none 1857 @return none 1858 1859 */ 1860void CameraHal::stopRecording() 1861{ 1862 LOG_FUNCTION_NAME; 1863 1864 if (!mRecordingEnabled ) 1865 { 1866 return; 1867 } 1868 1869 mAppCallbackNotifier->stopRecording(); 1870 1871 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_VIDEO); 1872 1873 mRecordingEnabled = false; 1874 1875 LOG_FUNCTION_NAME_EXIT; 1876} 1877 1878/** 1879 @brief Returns true if recording is enabled. 1880 1881 @param none 1882 @return true If recording is currently running 1883 false If recording has been stopped 1884 1885 */ 1886int CameraHal::recordingEnabled() 1887{ 1888 LOG_FUNCTION_NAME; 1889 1890 LOG_FUNCTION_NAME_EXIT; 1891 1892 return mRecordingEnabled; 1893} 1894 1895/** 1896 @brief Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME. 1897 1898 @param[in] mem MemoryBase pointer to the frame being released. Must be one of the buffers 1899 previously given by CameraHal 1900 @return none 1901 1902 */ 1903void CameraHal::releaseRecordingFrame(const void* mem) 1904{ 1905 LOG_FUNCTION_NAME; 1906 1907 //CAMHAL_LOGDB(" 0x%x", mem->pointer()); 1908 1909 if ( ( mRecordingEnabled ) && mem != NULL) 1910 { 1911 mAppCallbackNotifier->releaseRecordingFrame(mem); 1912 } 1913 1914 LOG_FUNCTION_NAME_EXIT; 1915 1916 return; 1917} 1918 1919/** 1920 @brief Start auto focus 1921 1922 This call asynchronous. 1923 The notification callback routine is called with CAMERA_MSG_FOCUS once when 1924 focusing is complete. autoFocus() will be called again if another auto focus is 1925 needed. 1926 1927 @param none 1928 @return NO_ERROR 1929 @todo Define the error codes if the focus is not locked 1930 1931 */ 1932status_t CameraHal::autoFocus() 1933{ 1934 status_t ret = NO_ERROR; 1935 1936#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1937 1938 gettimeofday(&mStartFocus, NULL); 1939 1940#endif 1941 1942 1943 LOG_FUNCTION_NAME; 1944 1945 if ( NULL != mCameraAdapter ) 1946 { 1947 1948#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1949 1950 //pass the autoFocus timestamp along with the command to camera adapter 1951 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS, ( int ) &mStartFocus); 1952 1953#else 1954 1955 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS); 1956 1957#endif 1958 1959 } 1960 else 1961 { 1962 ret = -1; 1963 } 1964 1965 LOG_FUNCTION_NAME_EXIT; 1966 1967 return ret; 1968} 1969 1970/** 1971 @brief Cancels auto-focus function. 1972 1973 If the auto-focus is still in progress, this function will cancel it. 1974 Whether the auto-focus is in progress or not, this function will return the 1975 focus position to the default. If the camera does not support auto-focus, this is a no-op. 1976 1977 1978 @param none 1979 @return NO_ERROR If the cancel succeeded 1980 @todo Define error codes if cancel didnt succeed 1981 1982 */ 1983status_t CameraHal::cancelAutoFocus() 1984{ 1985 LOG_FUNCTION_NAME; 1986 if( NULL != mCameraAdapter ) 1987 { 1988 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS); 1989 } 1990 LOG_FUNCTION_NAME_EXIT; 1991 return NO_ERROR; 1992} 1993 1994void CameraHal::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier) 1995{ 1996 1997 LOG_FUNCTION_NAME; 1998 1999 if ( NULL != mEventProvider ) 2000 { 2001 mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS); 2002 delete mEventProvider; 2003 mEventProvider = NULL; 2004 } 2005 2006 mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay); 2007 if ( NULL == mEventProvider ) 2008 { 2009 CAMHAL_LOGEA("Error in creating EventProvider"); 2010 } 2011 else 2012 { 2013 mEventProvider->enableEventNotification(eventMask); 2014 } 2015 2016 LOG_FUNCTION_NAME_EXIT; 2017} 2018 2019void CameraHal::eventCallbackRelay(CameraHalEvent* event) 2020{ 2021 LOG_FUNCTION_NAME; 2022 2023 CameraHal *appcbn = ( CameraHal * ) (event->mCookie); 2024 appcbn->eventCallback(event ); 2025 2026 LOG_FUNCTION_NAME_EXIT; 2027} 2028 2029void CameraHal::eventCallback(CameraHalEvent* event) 2030{ 2031 LOG_FUNCTION_NAME; 2032 2033 if ( NULL != event ) 2034 { 2035 switch( event->mEventType ) 2036 { 2037 case CameraHalEvent::EVENT_FOCUS_LOCKED: 2038 case CameraHalEvent::EVENT_FOCUS_ERROR: 2039 { 2040 if ( mBracketingEnabled ) 2041 { 2042 startImageBracketing(); 2043 } 2044 break; 2045 } 2046 default: 2047 { 2048 break; 2049 } 2050 }; 2051 } 2052 2053 LOG_FUNCTION_NAME_EXIT; 2054} 2055 2056status_t CameraHal::startImageBracketing() 2057{ 2058 status_t ret = NO_ERROR; 2059 CameraFrame frame; 2060 CameraAdapter::BuffersDescriptor desc; 2061 2062#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2063 2064 gettimeofday(&mStartCapture, NULL); 2065 2066#endif 2067 2068 LOG_FUNCTION_NAME; 2069 2070 if(!previewEnabled() && !mDisplayPaused) 2071 { 2072 LOG_FUNCTION_NAME_EXIT; 2073 return NO_INIT; 2074 } 2075 2076 if ( !mBracketingEnabled ) 2077 { 2078 return ret; 2079 } 2080 2081 if ( NO_ERROR == ret ) 2082 { 2083 mBracketingRunning = true; 2084 } 2085 2086 if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) 2087 { 2088 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE, 2089 ( int ) &frame, 2090 ( mBracketRangeNegative + 1 )); 2091 2092 if ( NO_ERROR != ret ) 2093 { 2094 CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret); 2095 } 2096 } 2097 2098 if ( NO_ERROR == ret ) 2099 { 2100 if ( NULL != mAppCallbackNotifier.get() ) 2101 { 2102 mAppCallbackNotifier->setBurst(true); 2103 } 2104 } 2105 2106 if ( NO_ERROR == ret ) 2107 { 2108 mParameters.getPictureSize(( int * ) &frame.mWidth, 2109 ( int * ) &frame.mHeight); 2110 2111 ret = allocImageBufs(frame.mWidth, 2112 frame.mHeight, 2113 frame.mLength, 2114 mParameters.getPictureFormat(), 2115 ( mBracketRangeNegative + 1 )); 2116 if ( NO_ERROR != ret ) 2117 { 2118 CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); 2119 } 2120 } 2121 2122 if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) 2123 { 2124 2125 desc.mBuffers = mImageBufs; 2126 desc.mOffsets = mImageOffsets; 2127 desc.mFd = mImageFd; 2128 desc.mLength = mImageLength; 2129 desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 ); 2130 desc.mMaxQueueable = ( size_t ) ( mBracketRangeNegative + 1 ); 2131 2132 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, 2133 ( int ) &desc); 2134 2135 if ( NO_ERROR == ret ) 2136 { 2137 2138#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2139 2140 //pass capture timestamp along with the camera adapter command 2141 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ), (int) &mStartCapture); 2142 2143#else 2144 2145 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 )); 2146 2147#endif 2148 2149 } 2150 } 2151 2152 return ret; 2153} 2154 2155status_t CameraHal::stopImageBracketing() 2156{ 2157 status_t ret = NO_ERROR; 2158 2159 LOG_FUNCTION_NAME; 2160 2161 if ( !mBracketingRunning ) 2162 { 2163 return ret; 2164 } 2165 2166 if ( NO_ERROR == ret ) 2167 { 2168 mBracketingRunning = false; 2169 } 2170 2171 if(!previewEnabled() && !mDisplayPaused) 2172 { 2173 return NO_INIT; 2174 } 2175 2176 if ( NO_ERROR == ret ) 2177 { 2178 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE); 2179 } 2180 2181 LOG_FUNCTION_NAME_EXIT; 2182 2183 return ret; 2184} 2185 2186/** 2187 @brief Take a picture. 2188 2189 @param none 2190 @return NO_ERROR If able to switch to image capture 2191 @todo Define error codes if unable to switch to image capture 2192 2193 */ 2194status_t CameraHal::takePicture( ) 2195{ 2196 status_t ret = NO_ERROR; 2197 CameraFrame frame; 2198 CameraAdapter::BuffersDescriptor desc; 2199 int burst; 2200 unsigned int bufferCount = 1; 2201 2202 Mutex::Autolock lock(mLock); 2203 2204#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2205 2206 gettimeofday(&mStartCapture, NULL); 2207 2208#endif 2209 2210 LOG_FUNCTION_NAME; 2211 2212 if(!previewEnabled() && !mDisplayPaused) 2213 { 2214 LOG_FUNCTION_NAME_EXIT; 2215 return NO_INIT; 2216 } 2217 2218 //If capture has already started, then queue this call for later execution 2219 if ( mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE && 2220 mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) { 2221 return NO_INIT; 2222 } 2223 2224 if ( !mBracketingRunning ) 2225 { 2226 2227 if ( NO_ERROR == ret ) 2228 { 2229 burst = mParameters.getInt(TICameraParameters::KEY_BURST); 2230 } 2231 2232 //Allocate all buffers only in burst capture case 2233 if ( burst > 1 ) 2234 { 2235 bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE; 2236 if ( NULL != mAppCallbackNotifier.get() ) 2237 { 2238 mAppCallbackNotifier->setBurst(true); 2239 } 2240 } 2241 else 2242 { 2243 if ( NULL != mAppCallbackNotifier.get() ) 2244 { 2245 mAppCallbackNotifier->setBurst(false); 2246 } 2247 } 2248 2249 //Pause Preview during capture 2250 if ( (NO_ERROR == ret) && ( NULL != mDisplayAdapter.get() ) && ( burst < 1 ) ) 2251 { 2252 mDisplayPaused = true; 2253 mPreviewEnabled = false; 2254 ret = mDisplayAdapter->pauseDisplay(mDisplayPaused); 2255 2256#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2257 2258 mDisplayAdapter->setSnapshotTimeRef(&mStartCapture); 2259 2260#endif 2261 // since preview is paused we should stop sending preview frames too 2262 if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) 2263 { 2264 mAppCallbackNotifier->disableMsgType (CAMERA_MSG_PREVIEW_FRAME); 2265 } 2266 } 2267 2268 if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) 2269 { 2270 if ( NO_ERROR == ret ) 2271 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE, 2272 ( int ) &frame, 2273 bufferCount); 2274 2275 if ( NO_ERROR != ret ) 2276 { 2277 CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret); 2278 } 2279 } 2280 2281 if ( NO_ERROR == ret ) 2282 { 2283 mParameters.getPictureSize(( int * ) &frame.mWidth, 2284 ( int * ) &frame.mHeight); 2285 2286 ret = allocImageBufs(frame.mWidth, 2287 frame.mHeight, 2288 frame.mLength, 2289 mParameters.getPictureFormat(), 2290 bufferCount); 2291 if ( NO_ERROR != ret ) 2292 { 2293 CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); 2294 } 2295 } 2296 2297 if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) 2298 { 2299 desc.mBuffers = mImageBufs; 2300 desc.mOffsets = mImageOffsets; 2301 desc.mFd = mImageFd; 2302 desc.mLength = mImageLength; 2303 desc.mCount = ( size_t ) bufferCount; 2304 desc.mMaxQueueable = ( size_t ) bufferCount; 2305 2306 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, 2307 ( int ) &desc); 2308 } 2309 } 2310 else 2311 { 2312 mBracketingRunning = false; 2313 } 2314 2315 if ( ( NO_ERROR == ret ) && ( NULL != mCameraAdapter ) ) 2316 { 2317 2318#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2319 2320 //pass capture timestamp along with the camera adapter command 2321 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE, (int) &mStartCapture); 2322 2323#else 2324 2325 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE); 2326 2327#endif 2328 2329 } 2330 2331 return ret; 2332} 2333 2334/** 2335 @brief Cancel a picture that was started with takePicture. 2336 2337 Calling this method when no picture is being taken is a no-op. 2338 2339 @param none 2340 @return NO_ERROR If cancel succeeded. Cancel can succeed if image callback is not sent 2341 @todo Define error codes 2342 2343 */ 2344status_t CameraHal::cancelPicture( ) 2345{ 2346 LOG_FUNCTION_NAME; 2347 2348 Mutex::Autolock lock(mLock); 2349 2350 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE); 2351 2352 return NO_ERROR; 2353} 2354 2355/** 2356 @brief Return the camera parameters. 2357 2358 @param none 2359 @return Currently configured camera parameters 2360 2361 */ 2362char* CameraHal::getParameters() 2363{ 2364 CameraParameters params; 2365 String8 params_str8; 2366 char* params_string; 2367 2368 LOG_FUNCTION_NAME; 2369 2370 params = mParameters; 2371 if( NULL != mCameraAdapter ) 2372 { 2373 mCameraAdapter->getParameters(params); 2374 } 2375 2376 params_str8 = params.flatten(); 2377 // camera service frees this string... 2378 params_string = (char*) malloc(sizeof(char) * (params_str8.length()+1)); 2379 strcpy(params_string, params_str8.string()); 2380 2381 LOG_FUNCTION_NAME_EXIT; 2382 2383 ///Return the current set of parameters 2384 2385 return params_string; 2386} 2387 2388void CameraHal::putParameters(char *parms) 2389{ 2390 free(parms); 2391} 2392 2393/** 2394 @brief Send command to camera driver. 2395 2396 @param none 2397 @return NO_ERROR If the command succeeds 2398 @todo Define the error codes that this function can return 2399 2400 */ 2401status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) 2402{ 2403 status_t ret = NO_ERROR; 2404 2405 LOG_FUNCTION_NAME; 2406 2407 2408 if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) ) 2409 { 2410 CAMHAL_LOGEA("No CameraAdapter instance"); 2411 ret = -EINVAL; 2412 } 2413 2414 if ( ( NO_ERROR == ret ) && ( !previewEnabled() )) 2415 { 2416 CAMHAL_LOGEA("Preview is not running"); 2417 ret = -EINVAL; 2418 } 2419 2420 if ( NO_ERROR == ret ) 2421 { 2422 switch(cmd) 2423 { 2424 case CAMERA_CMD_START_SMOOTH_ZOOM: 2425 2426 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_SMOOTH_ZOOM, arg1); 2427 2428 break; 2429 case CAMERA_CMD_STOP_SMOOTH_ZOOM: 2430 2431 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM); 2432 2433 case CAMERA_CMD_START_FACE_DETECTION: 2434 2435 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD); 2436 2437 break; 2438 2439 case CAMERA_CMD_STOP_FACE_DETECTION: 2440 2441 ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD); 2442 2443 break; 2444 2445 default: 2446 break; 2447 }; 2448 } 2449 2450 LOG_FUNCTION_NAME_EXIT; 2451 2452 return ret; 2453} 2454 2455/** 2456 @brief Release the hardware resources owned by this object. 2457 2458 Note that this is *not* done in the destructor. 2459 2460 @param none 2461 @return none 2462 2463 */ 2464void CameraHal::release() 2465{ 2466 LOG_FUNCTION_NAME; 2467 ///@todo Investigate on how release is used by CameraService. Vaguely remember that this is called 2468 ///just before CameraHal object destruction 2469 deinitialize(); 2470 LOG_FUNCTION_NAME_EXIT; 2471} 2472 2473 2474/** 2475 @brief Dump state of the camera hardware 2476 2477 @param[in] fd File descriptor 2478 @param[in] args Arguments 2479 @return NO_ERROR Dump succeeded 2480 @todo Error codes for dump fail 2481 2482 */ 2483status_t CameraHal::dump(int fd) const 2484{ 2485 LOG_FUNCTION_NAME; 2486 ///Implement this method when the h/w dump function is supported on Ducati side 2487 return NO_ERROR; 2488} 2489 2490/*-------------Camera Hal Interface Method definitions ENDS here--------------------*/ 2491 2492 2493 2494 2495/*-------------Camera Hal Internal Method definitions STARTS here--------------------*/ 2496 2497/** 2498 @brief Constructor of CameraHal 2499 2500 Member variables are initialized here. No allocations should be done here as we 2501 don't use c++ exceptions in the code. 2502 2503 */ 2504CameraHal::CameraHal(int cameraId) 2505{ 2506 LOG_FUNCTION_NAME; 2507 2508 ///Initialize all the member variables to their defaults 2509 mPreviewEnabled = false; 2510 mPreviewBufs = NULL; 2511 mImageBufs = NULL; 2512 mBufProvider = NULL; 2513 mPreviewStartInProgress = false; 2514 mVideoBufs = NULL; 2515 mVideoBufProvider = NULL; 2516 mRecordingEnabled = false; 2517 mDisplayPaused = false; 2518 mSetPreviewWindowCalled = false; 2519 mMsgEnabled = 0; 2520 mAppCallbackNotifier = NULL; 2521 mMemoryManager = NULL; 2522 mCameraAdapter = NULL; 2523 mBracketingEnabled = false; 2524 mBracketingRunning = false; 2525 mEventProvider = NULL; 2526 mBracketRangePositive = 1; 2527 mBracketRangeNegative = 1; 2528 mMaxZoomSupported = 0; 2529 mShutterEnabled = true; 2530 mMeasurementEnabled = false; 2531 mPreviewDataBufs = NULL; 2532 mCameraProperties = NULL; 2533 mCurrentTime = 0; 2534 mFalsePreview = 0; 2535 mImageOffsets = NULL; 2536 mImageLength = 0; 2537 mImageFd = 0; 2538 mVideoOffsets = NULL; 2539 mVideoFd = 0; 2540 mVideoLength = 0; 2541 mPreviewDataOffsets = NULL; 2542 mPreviewDataFd = 0; 2543 mPreviewDataLength = 0; 2544 mPreviewFd = 0; 2545 mPreviewWidth = 0; 2546 mPreviewHeight = 0; 2547 mPreviewLength = 0; 2548 mPreviewOffsets = NULL; 2549 mPreviewRunning = 0; 2550 mPreviewStateOld = 0; 2551 mRecordingEnabled = 0; 2552 mRecordEnabled = 0; 2553 mSensorListener = NULL; 2554 2555#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 2556 2557 //Initialize the CameraHAL constructor timestamp, which is used in the 2558 // PPM() method as time reference if the user does not supply one. 2559 gettimeofday(&ppm_start, NULL); 2560 2561#endif 2562 2563 mCameraIndex = cameraId; 2564 2565 LOG_FUNCTION_NAME_EXIT; 2566} 2567 2568/** 2569 @brief Destructor of CameraHal 2570 2571 This function simply calls deinitialize() to free up memory allocate during construct 2572 phase 2573 */ 2574CameraHal::~CameraHal() 2575{ 2576 LOG_FUNCTION_NAME; 2577 2578 ///Call de-initialize here once more - it is the last chance for us to relinquish all the h/w and s/w resources 2579 deinitialize(); 2580 2581 if ( NULL != mEventProvider ) 2582 { 2583 mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS); 2584 delete mEventProvider; 2585 mEventProvider = NULL; 2586 } 2587 2588 /// Free the callback notifier 2589 mAppCallbackNotifier.clear(); 2590 2591 /// Free the memory manager 2592 mMemoryManager.clear(); 2593 2594 /// Free the display adapter 2595 mDisplayAdapter.clear(); 2596 2597 if ( NULL != mCameraAdapter ) { 2598 int strongCount = mCameraAdapter->getStrongCount(); 2599 2600 mCameraAdapter->decStrong(mCameraAdapter); 2601 2602 mCameraAdapter = NULL; 2603 } 2604 2605 LOG_FUNCTION_NAME_EXIT; 2606} 2607 2608/** 2609 @brief Initialize the Camera HAL 2610 2611 Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager 2612 2613 @param None 2614 @return NO_ERROR - On success 2615 NO_MEMORY - On failure to allocate memory for any of the objects 2616 @remarks Camera Hal internal function 2617 2618 */ 2619 2620status_t CameraHal::initialize(CameraProperties::Properties* properties) 2621{ 2622 LOG_FUNCTION_NAME; 2623 2624 int sensor_index = 0; 2625 2626 ///Initialize the event mask used for registering an event provider for AppCallbackNotifier 2627 ///Currently, registering all events as to be coming from CameraAdapter 2628 int32_t eventMask = CameraHalEvent::ALL_EVENTS; 2629 2630 // Get my camera properties 2631 mCameraProperties = properties; 2632 2633 if(!mCameraProperties) 2634 { 2635 goto fail_loop; 2636 } 2637 2638 // Dump the properties of this Camera 2639 // will only print if DEBUG macro is defined 2640 mCameraProperties->dump(); 2641 2642 if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 ) 2643 { 2644 sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)); 2645 } 2646 2647 CAMHAL_LOGDB("Sensor index %d", sensor_index); 2648 2649 mCameraAdapter = CameraAdapter_Factory(); 2650 if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties, sensor_index)!=NO_ERROR)) 2651 { 2652 CAMHAL_LOGEA("Unable to create or initialize CameraAdapter"); 2653 mCameraAdapter = NULL; 2654 goto fail_loop; 2655 } 2656 2657 mCameraAdapter->incStrong(mCameraAdapter); 2658 mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this); 2659 mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this); 2660 2661 if(!mAppCallbackNotifier.get()) 2662 { 2663 /// Create the callback notifier 2664 mAppCallbackNotifier = new AppCallbackNotifier(); 2665 if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR)) 2666 { 2667 CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier"); 2668 goto fail_loop; 2669 } 2670 } 2671 2672 if(!mMemoryManager.get()) 2673 { 2674 /// Create Memory Manager 2675 mMemoryManager = new MemoryManager(); 2676 if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR)) 2677 { 2678 CAMHAL_LOGEA("Unable to create or initialize MemoryManager"); 2679 goto fail_loop; 2680 } 2681 } 2682 2683 ///Setup the class dependencies... 2684 2685 ///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from. 2686 ///CameraAdapter is the one which provides those events 2687 ///Set it as the frame and event providers for AppCallbackNotifier 2688 ///@remarks setEventProvider API takes in a bit mask of events for registering a provider for the different events 2689 /// That way, if events can come from DisplayAdapter in future, we will be able to add it as provider 2690 /// for any event 2691 mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter); 2692 mAppCallbackNotifier->setFrameProvider(mCameraAdapter); 2693 2694 ///Any dynamic errors that happen during the camera use case has to be propagated back to the application 2695 ///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application 2696 ///Set it as the error handler for CameraAdapter 2697 mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get()); 2698 2699 ///Start the callback notifier 2700 if(mAppCallbackNotifier->start() != NO_ERROR) 2701 { 2702 CAMHAL_LOGEA("Couldn't start AppCallbackNotifier"); 2703 goto fail_loop; 2704 } 2705 2706 CAMHAL_LOGDA("Started AppCallbackNotifier.."); 2707 mAppCallbackNotifier->setMeasurements(mMeasurementEnabled); 2708 2709 ///Initialize default parameters 2710 initDefaultParameters(); 2711 2712 2713 if ( setParameters(mParameters) != NO_ERROR ) 2714 { 2715 CAMHAL_LOGEA("Failed to set default parameters?!"); 2716 } 2717 2718 // register for sensor events 2719 mSensorListener = new SensorListener(); 2720 if (mSensorListener.get()) { 2721 if (mSensorListener->initialize() == NO_ERROR) { 2722 mSensorListener->setCallbacks(orientation_cb, this); 2723 mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION); 2724 } else { 2725 CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing"); 2726 mSensorListener.clear(); 2727 mSensorListener = NULL; 2728 } 2729 } 2730 2731 LOG_FUNCTION_NAME_EXIT; 2732 2733 return NO_ERROR; 2734 2735 fail_loop: 2736 2737 ///Free up the resources because we failed somewhere up 2738 deinitialize(); 2739 LOG_FUNCTION_NAME_EXIT; 2740 2741 return NO_MEMORY; 2742 2743} 2744 2745bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions) 2746{ 2747 bool ret = true; 2748 status_t status = NO_ERROR; 2749 char tmpBuffer[PARAM_BUFFER + 1]; 2750 char *pos = NULL; 2751 2752 LOG_FUNCTION_NAME; 2753 2754 if ( NULL == supportedResolutions ) 2755 { 2756 CAMHAL_LOGEA("Invalid supported resolutions string"); 2757 ret = false; 2758 goto exit; 2759 } 2760 2761 status = snprintf(tmpBuffer, PARAM_BUFFER, "%dx%d", width, height); 2762 if ( 0 > status ) 2763 { 2764 CAMHAL_LOGEA("Error encountered while generating validation string"); 2765 ret = false; 2766 goto exit; 2767 } 2768 2769 pos = strstr(supportedResolutions, tmpBuffer); 2770 if ( NULL == pos ) 2771 { 2772 ret = false; 2773 } 2774 else 2775 { 2776 ret = true; 2777 } 2778 2779exit: 2780 2781 LOG_FUNCTION_NAME_EXIT; 2782 2783 return ret; 2784} 2785 2786bool CameraHal::isParameterValid(const char *param, const char *supportedParams) 2787{ 2788 bool ret = true; 2789 char *pos = NULL; 2790 2791 LOG_FUNCTION_NAME; 2792 2793 if ( NULL == supportedParams ) 2794 { 2795 CAMHAL_LOGEA("Invalid supported parameters string"); 2796 ret = false; 2797 goto exit; 2798 } 2799 2800 if ( NULL == param ) 2801 { 2802 CAMHAL_LOGEA("Invalid parameter string"); 2803 ret = false; 2804 goto exit; 2805 } 2806 2807 pos = strstr(supportedParams, param); 2808 if ( NULL == pos ) 2809 { 2810 ret = false; 2811 } 2812 else 2813 { 2814 ret = true; 2815 } 2816 2817exit: 2818 2819 LOG_FUNCTION_NAME_EXIT; 2820 2821 return ret; 2822} 2823 2824bool CameraHal::isParameterValid(int param, const char *supportedParams) 2825{ 2826 bool ret = true; 2827 char *pos = NULL; 2828 status_t status; 2829 char tmpBuffer[PARAM_BUFFER + 1]; 2830 2831 LOG_FUNCTION_NAME; 2832 2833 if ( NULL == supportedParams ) 2834 { 2835 CAMHAL_LOGEA("Invalid supported parameters string"); 2836 ret = false; 2837 goto exit; 2838 } 2839 2840 status = snprintf(tmpBuffer, PARAM_BUFFER, "%d", param); 2841 if ( 0 > status ) 2842 { 2843 CAMHAL_LOGEA("Error encountered while generating validation string"); 2844 ret = false; 2845 goto exit; 2846 } 2847 2848 pos = strstr(supportedParams, tmpBuffer); 2849 if ( NULL == pos ) 2850 { 2851 ret = false; 2852 } 2853 else 2854 { 2855 ret = true; 2856 } 2857 2858exit: 2859 2860 LOG_FUNCTION_NAME_EXIT; 2861 2862 return ret; 2863} 2864 2865status_t CameraHal::parseResolution(const char *resStr, int &width, int &height) 2866{ 2867 status_t ret = NO_ERROR; 2868 char *ctx, *pWidth, *pHeight; 2869 const char *sep = "x"; 2870 char *tmp = NULL; 2871 2872 LOG_FUNCTION_NAME; 2873 2874 if ( NULL == resStr ) 2875 { 2876 return -EINVAL; 2877 } 2878 2879 //This fixes "Invalid input resolution" 2880 char *resStr_copy = (char *)malloc(strlen(resStr) + 1); 2881 if ( NULL!=resStr_copy ) { 2882 if ( NO_ERROR == ret ) 2883 { 2884 strcpy(resStr_copy, resStr); 2885 pWidth = strtok_r( (char *) resStr_copy, sep, &ctx); 2886 2887 if ( NULL != pWidth ) 2888 { 2889 width = atoi(pWidth); 2890 } 2891 else 2892 { 2893 CAMHAL_LOGEB("Invalid input resolution %s", resStr); 2894 ret = -EINVAL; 2895 } 2896 } 2897 2898 if ( NO_ERROR == ret ) 2899 { 2900 pHeight = strtok_r(NULL, sep, &ctx); 2901 2902 if ( NULL != pHeight ) 2903 { 2904 height = atoi(pHeight); 2905 } 2906 else 2907 { 2908 CAMHAL_LOGEB("Invalid input resolution %s", resStr); 2909 ret = -EINVAL; 2910 } 2911 } 2912 2913 free(resStr_copy); 2914 resStr_copy = NULL; 2915 } 2916 LOG_FUNCTION_NAME_EXIT; 2917 2918 return ret; 2919} 2920 2921void CameraHal::insertSupportedParams() 2922{ 2923 char tmpBuffer[PARAM_BUFFER + 1]; 2924 2925 LOG_FUNCTION_NAME; 2926 2927 CameraParameters &p = mParameters; 2928 2929 ///Set the name of the camera 2930 p.set(TICameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME)); 2931 2932 mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES)); 2933 2934 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES)); 2935 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS)); 2936 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)); 2937 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); 2938 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)); 2939 p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES)); 2940 p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE)); 2941 p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS)); 2942 p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES)); 2943 p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES)); 2944 p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES)); 2945 p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING)); 2946 p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX)); 2947 p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN)); 2948 p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP)); 2949 p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES)); 2950 p.set(TICameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES)); 2951 p.set(TICameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES)); 2952 p.set(CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS)); 2953 p.set(CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES)); 2954 p.set(CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED)); 2955 p.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED)); 2956 p.set(TICameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES)); 2957 p.set(TICameraParameters::KEY_S3D_SUPPORTED,mCameraProperties->get(CameraProperties::S3D_SUPPORTED)); 2958 p.set(TICameraParameters::KEY_S3D2D_PREVIEW_MODE,mCameraProperties->get(CameraProperties::S3D2D_PREVIEW_MODES)); 2959 p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE)); 2960 p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES)); 2961 p.set(TICameraParameters::KEY_VSTAB,mCameraProperties->get(CameraProperties::VSTAB)); 2962 p.set(TICameraParameters::KEY_VSTAB_VALUES,mCameraProperties->get(CameraProperties::VSTAB_VALUES)); 2963 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED)); 2964 p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION)); 2965 p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES)); 2966 p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED)); 2967 p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED)); 2968 2969 LOG_FUNCTION_NAME_EXIT; 2970 2971} 2972 2973void CameraHal::initDefaultParameters() 2974{ 2975 //Purpose of this function is to initialize the default current and supported parameters for the currently 2976 //selected camera. 2977 2978 CameraParameters &p = mParameters; 2979 int currentRevision, adapterRevision; 2980 status_t ret = NO_ERROR; 2981 int width, height; 2982 2983 LOG_FUNCTION_NAME; 2984 2985 ret = parseResolution(mCameraProperties->get(CameraProperties::PREVIEW_SIZE), width, height); 2986 2987 if ( NO_ERROR == ret ) 2988 { 2989 p.setPreviewSize(width, height); 2990 } 2991 else 2992 { 2993 p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT); 2994 } 2995 2996 ret = parseResolution(mCameraProperties->get(CameraProperties::PICTURE_SIZE), width, height); 2997 2998 if ( NO_ERROR == ret ) 2999 { 3000 p.setPictureSize(width, height); 3001 } 3002 else 3003 { 3004 p.setPictureSize(PICTURE_WIDTH, PICTURE_HEIGHT); 3005 } 3006 3007 ret = parseResolution(mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_SIZE), width, height); 3008 3009 if ( NO_ERROR == ret ) 3010 { 3011 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); 3012 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); 3013 } 3014 else 3015 { 3016 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH); 3017 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT); 3018 } 3019 3020 insertSupportedParams(); 3021 3022 //Insert default values 3023 p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE))); 3024 p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT)); 3025 p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT)); 3026 p.set(CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY)); 3027 p.set(CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE)); 3028 p.set(CameraParameters::KEY_EFFECT, mCameraProperties->get(CameraProperties::EFFECT)); 3029 p.set(CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING)); 3030 p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE)); 3031 p.set(CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE)); 3032 p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION)); 3033 p.set(CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE)); 3034 p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE)); 3035 p.set(CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM)); 3036 p.set(TICameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST)); 3037 p.set(TICameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION)); 3038 p.set(TICameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS)); 3039 p.set(TICameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS)); 3040 p.set(TICameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE)); 3041 p.set(TICameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE)); 3042 p.set(TICameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP)); 3043 p.set(TICameraParameters::KEY_S3D2D_PREVIEW, mCameraProperties->get(CameraProperties::S3D2D_PREVIEW)); 3044 p.set(TICameraParameters::KEY_AUTOCONVERGENCE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE)); 3045 p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES)); 3046 p.set(TICameraParameters::KEY_VSTAB,mCameraProperties->get(CameraProperties::VSTAB)); 3047 p.set(TICameraParameters::KEY_VSTAB_VALUES,mCameraProperties->get(CameraProperties::VSTAB_VALUES)); 3048 p.set(CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH)); 3049 p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE)); 3050 p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE)); 3051 p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,mCameraProperties->get(CameraProperties::FRAMERATE_RANGE)); 3052 p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION)); 3053 p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES)); 3054 p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE)); 3055 p.set(TICameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL)); 3056 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY)); 3057 p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar"); 3058 p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES)); 3059 p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES)); 3060 3061 // Only one area a.k.a Touch AF for now. 3062 // TODO: Add support for multiple focus areas. 3063 p.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS)); 3064 p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK)); 3065 p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK)); 3066 p.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS)); 3067 3068 LOG_FUNCTION_NAME_EXIT; 3069} 3070 3071/** 3072 @brief Stop a previously started preview. 3073 @param none 3074 @return none 3075 3076 */ 3077void CameraHal::forceStopPreview() 3078{ 3079 LOG_FUNCTION_NAME; 3080 3081 // stop bracketing if it is running 3082 stopImageBracketing(); 3083 3084 if(mDisplayAdapter.get() != NULL) { 3085 ///Stop the buffer display first 3086 mDisplayAdapter->disableDisplay(); 3087 } 3088 3089 if(mAppCallbackNotifier.get() != NULL) { 3090 //Stop the callback sending 3091 mAppCallbackNotifier->stop(); 3092 mAppCallbackNotifier->stopPreviewCallbacks(); 3093 } 3094 3095 // since prerequisite for capturing is for camera system 3096 // to be previewing...cancel all captures before stopping 3097 // preview 3098 if ( mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE && 3099 mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) { 3100 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE); 3101 } 3102 3103 if ( NULL != mCameraAdapter ) { 3104 // according to javadoc...FD should be stopped in stopPreview 3105 // and application needs to call startFaceDection again 3106 // to restart FD 3107 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD); 3108 3109 cancelAutoFocus(); 3110 3111 //Stop the source of frames 3112 mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW); 3113 } 3114 3115 freePreviewBufs(); 3116 freePreviewDataBufs(); 3117 3118 mPreviewEnabled = false; 3119 mDisplayPaused = false; 3120 3121 LOG_FUNCTION_NAME_EXIT; 3122} 3123 3124/** 3125 @brief Deallocates memory for all the resources held by Camera HAL. 3126 3127 Frees the following objects- CameraAdapter, AppCallbackNotifier, DisplayAdapter, 3128 and Memory Manager 3129 3130 @param none 3131 @return none 3132 3133 */ 3134void CameraHal::deinitialize() 3135{ 3136 LOG_FUNCTION_NAME; 3137 3138 if ( mPreviewEnabled || mDisplayPaused ) { 3139 forceStopPreview(); 3140 } 3141 3142 freeImageBufs(); 3143 3144 mSetPreviewWindowCalled = false; 3145 3146 if (mSensorListener.get()) { 3147 mSensorListener->disableSensor(SensorListener::SENSOR_ORIENTATION); 3148 mSensorListener.clear(); 3149 mSensorListener = NULL; 3150 } 3151 3152 LOG_FUNCTION_NAME_EXIT; 3153 3154} 3155 3156status_t CameraHal::storeMetaDataInBuffers(bool enable) 3157{ 3158 LOG_FUNCTION_NAME; 3159 3160 return mAppCallbackNotifier->useMetaDataBufferMode(enable); 3161 3162 LOG_FUNCTION_NAME_EXIT; 3163} 3164 3165}; 3166 3167 3168