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