diff options
Diffstat (limited to 'camera/CameraHal.cpp')
| -rw-r--r-- | camera/CameraHal.cpp | 4333 |
1 files changed, 0 insertions, 4333 deletions
diff --git a/camera/CameraHal.cpp b/camera/CameraHal.cpp deleted file mode 100644 index a1920c5..0000000 --- a/camera/CameraHal.cpp +++ /dev/null @@ -1,4333 +0,0 @@ -/* - * Copyright (C) Texas Instruments - http://www.ti.com/ - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** -* @file CameraHal.cpp -* -* This file maps the Camera Hardware Interface to V4L2. -* -*/ - -#include "CameraHal.h" -#include "ANativeWindowDisplayAdapter.h" -#include "BufferSourceAdapter.h" -#include "TICameraParameters.h" -#include "CameraProperties.h" -#include <cutils/properties.h> - -#include <poll.h> -#include <math.h> - -namespace Ti { -namespace Camera { - -extern "C" CameraAdapter* OMXCameraAdapter_Factory(size_t); -extern "C" CameraAdapter* V4LCameraAdapter_Factory(size_t); - -/*****************************************************************************/ - -////Constant definitions and declarations -////@todo Have a CameraProperties class to store these parameters as constants for every camera -//// Currently, they are hard-coded - -const int CameraHal::NO_BUFFERS_PREVIEW = MAX_CAMERA_BUFFERS; -const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE = 5; -const int CameraHal::SW_SCALING_FPS_LIMIT = 15; - -const uint32_t MessageNotifier::EVENT_BIT_FIELD_POSITION = 16; - -const uint32_t MessageNotifier::FRAME_BIT_FIELD_POSITION = 0; - -// TODO(XXX): Temporarily increase number of buffers we can allocate from ANW -// until faux-NPA mode is implemented -const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE_SYSTEM_HEAP = 15; - -#ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING -// HACK: Default path to directory where RAW images coming from video port will be saved to. -// If directory not exists the saving is skipped and video port frame is ignored. -// The directory name is choosed in so weird way to enable RAW images saving only when -// directory has been created explicitly by user. -extern const char * const kRawImagesOutputDirPath = "/data/misc/camera/RaW_PiCtUrEs"; -extern const char * const kYuvImagesOutputDirPath = "/data/misc/camera/YuV_PiCtUrEs"; -#endif - -/******************************************************************************/ - - -#ifdef OMAP_ENHANCEMENT_CPCAM -static int dummy_update_and_get_buffer(preview_stream_ops_t*, buffer_handle_t**, int*) { - return INVALID_OPERATION; -} - -static int dummy_get_buffer_dimension(preview_stream_ops_t*, int*, int*) { - return INVALID_OPERATION; -} - -static int dummy_get_buffer_format(preview_stream_ops_t*, int*) { - return INVALID_OPERATION; -} - -static int dummy_set_metadata(preview_stream_ops_t*, const camera_memory_t*) { - return INVALID_OPERATION; -} -#endif - -#ifdef OMAP_ENHANCEMENT -static preview_stream_extended_ops_t dummyPreviewStreamExtendedOps = { -#ifdef OMAP_ENHANCEMENT_CPCAM - dummy_update_and_get_buffer, - dummy_get_buffer_dimension, - dummy_get_buffer_format, - dummy_set_metadata, -#endif -}; -#endif - - -DisplayAdapter::DisplayAdapter() -{ -#ifdef OMAP_ENHANCEMENT - mExtendedOps = &dummyPreviewStreamExtendedOps; -#endif -} - -#ifdef OMAP_ENHANCEMENT -void DisplayAdapter::setExtendedOps(preview_stream_extended_ops_t * extendedOps) { - mExtendedOps = extendedOps ? extendedOps : &dummyPreviewStreamExtendedOps; -} -#endif - - - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - -struct timeval CameraHal::mStartPreview; -struct timeval CameraHal::mStartFocus; -struct timeval CameraHal::mStartCapture; - -#endif - -static void orientation_cb(uint32_t orientation, uint32_t tilt, void* cookie) { - CameraHal *camera = NULL; - - if (cookie) { - camera = (CameraHal*) cookie; - camera->onOrientationEvent(orientation, tilt); - } - -} -/*-------------Camera Hal Interface Method definitions STARTS here--------------------*/ - -/** - Callback function to receive orientation events from SensorListener - */ -void CameraHal::onOrientationEvent(uint32_t orientation, uint32_t tilt) { - LOG_FUNCTION_NAME; - - if ( NULL != mCameraAdapter ) { - mCameraAdapter->onOrientationEvent(orientation, tilt); - } - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Set the notification and data callbacks - - @param[in] notify_cb Notify callback for notifying the app about events and errors - @param[in] data_cb Buffer callback for sending the preview/raw frames to the app - @param[in] data_cb_timestamp Buffer callback for sending the video frames w/ timestamp - @param[in] user Callback cookie - @return none - - */ -void CameraHal::setCallbacks(camera_notify_callback notify_cb, - camera_data_callback data_cb, - camera_data_timestamp_callback data_cb_timestamp, - camera_request_memory get_memory, - void *user) -{ - LOG_FUNCTION_NAME; - - if ( NULL != mAppCallbackNotifier.get() ) - { - mAppCallbackNotifier->setCallbacks(this, - notify_cb, - data_cb, - data_cb_timestamp, - get_memory, - user); - } - - if ( NULL != mCameraAdapter ) { - mCameraAdapter->setSharedAllocator(get_memory); - } - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Enable a message, or set of messages. - - @param[in] msgtype Bitmask of the messages to enable (defined in include/ui/Camera.h) - @return none - - */ -void CameraHal::enableMsgType(int32_t msgType) -{ - LOG_FUNCTION_NAME; - - if ( ( msgType & CAMERA_MSG_SHUTTER ) && ( !mShutterEnabled ) ) - { - msgType &= ~CAMERA_MSG_SHUTTER; - } - - // ignoring enable focus message from camera service - // we will enable internally in autoFocus call - msgType &= ~CAMERA_MSG_FOCUS; -#ifdef ANDROID_API_JB_OR_LATER - msgType &= ~CAMERA_MSG_FOCUS_MOVE; -#endif - - { - android::AutoMutex lock(mLock); - mMsgEnabled |= msgType; - } - - if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) - { - if(mDisplayPaused) - { - CAMHAL_LOGDA("Preview currently paused...will enable preview callback when restarted"); - msgType &= ~CAMERA_MSG_PREVIEW_FRAME; - }else - { - CAMHAL_LOGDA("Enabling Preview Callback"); - } - } - else - { - CAMHAL_LOGDB("Preview callback not enabled %x", msgType); - } - - - ///Configure app callback notifier with the message callback required - mAppCallbackNotifier->enableMsgType (msgType); - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Disable a message, or set of messages. - - @param[in] msgtype Bitmask of the messages to disable (defined in include/ui/Camera.h) - @return none - - */ -void CameraHal::disableMsgType(int32_t msgType) -{ - LOG_FUNCTION_NAME; - - { - android::AutoMutex lock(mLock); - mMsgEnabled &= ~msgType; - } - - if( msgType & CAMERA_MSG_PREVIEW_FRAME) - { - CAMHAL_LOGDA("Disabling Preview Callback"); - } - - ///Configure app callback notifier - mAppCallbackNotifier->disableMsgType (msgType); - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Query whether a message, or a set of messages, is enabled. - - Note that this is operates as an AND, if any of the messages queried are off, this will - return false. - - @param[in] msgtype Bitmask of the messages to query (defined in include/ui/Camera.h) - @return true If all message types are enabled - false If any message type - - */ -int CameraHal::msgTypeEnabled(int32_t msgType) -{ - int32_t msgEnabled = 0; - - LOG_FUNCTION_NAME; - android::AutoMutex lock(mLock); - - msgEnabled = mMsgEnabled; - if (!previewEnabled() && !mPreviewInitializationDone) { - msgEnabled &= ~(CAMERA_MSG_PREVIEW_FRAME | CAMERA_MSG_PREVIEW_METADATA); - } - - LOG_FUNCTION_NAME_EXIT; - return (msgEnabled & msgType); -} - -/** - @brief Set the camera parameters. - - @param[in] params Camera parameters to configure the camera - @return NO_ERROR - @todo Define error codes - - */ -int CameraHal::setParameters(const char* parameters) -{ - - LOG_FUNCTION_NAME; - - android::CameraParameters params; - - android::String8 str_params(parameters); - params.unflatten(str_params); - - LOG_FUNCTION_NAME_EXIT; - - return setParameters(params); -} - -/** - @brief Set the camera parameters. - - @param[in] params Camera parameters to configure the camera - @return NO_ERROR - @todo Define error codes - - */ -int CameraHal::setParameters(const android::CameraParameters& params) -{ - - LOG_FUNCTION_NAME; - - int w, h; - int framerate; - int maxFPS, minFPS; - const char *valstr = NULL; - int varint = 0; - status_t ret = NO_ERROR; - // Needed for KEY_RECORDING_HINT - bool restartPreviewRequired = false; - bool updateRequired = false; - android::CameraParameters oldParams = mParameters; - -#ifdef V4L_CAMERA_ADAPTER - if (strcmp (V4L_CAMERA_NAME_USB, mCameraProperties->get(CameraProperties::CAMERA_NAME)) == 0 ) { - updateRequired = true; - } -#endif - - { - android::AutoMutex lock(mLock); - - ///Ensure that preview is not enabled when the below parameters are changed. - if(!previewEnabled()) - { - if ((valstr = params.getPreviewFormat()) != NULL) { - if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS))) { - mParameters.setPreviewFormat(valstr); - CAMHAL_LOGDB("PreviewFormat set %s", valstr); - } else { - CAMHAL_LOGEB("Invalid preview format: %s. Supported: %s", valstr, - mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); - return BAD_VALUE; - } - } - - if ((valstr = params.get(TICameraParameters::KEY_VNF)) != NULL) { - if (strcmp(mCameraProperties->get(CameraProperties::VNF_SUPPORTED), - android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGDB("VNF %s", valstr); - mParameters.set(TICameraParameters::KEY_VNF, valstr); - } else if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGEB("ERROR: Invalid VNF: %s", valstr); - return BAD_VALUE; - } else { - mParameters.set(TICameraParameters::KEY_VNF, - android::CameraParameters::FALSE); - } - } - - if ((valstr = params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION)) != NULL) { - // make sure we support vstab...if we don't and application is trying to set - // vstab then return an error - if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED), - android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGDB("VSTAB %s", valstr); - mParameters.set(android::CameraParameters::KEY_VIDEO_STABILIZATION, valstr); - } else if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGEB("ERROR: Invalid VSTAB: %s", valstr); - return BAD_VALUE; - } else { - mParameters.set(android::CameraParameters::KEY_VIDEO_STABILIZATION, - android::CameraParameters::FALSE); - } - } - - if( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL) { - - if (strcmp(TICameraParameters::VIDEO_MODE, valstr)) { - mCapModeBackup = valstr; - } - - CAMHAL_LOGDB("Capture mode set %s", valstr); - - const char *currentMode = mParameters.get(TICameraParameters::KEY_CAP_MODE); - if ( NULL != currentMode ) { - if ( strcmp(currentMode, valstr) != 0 ) { - updateRequired = true; - } - } else { - updateRequired = true; - } - - mParameters.set(TICameraParameters::KEY_CAP_MODE, valstr); - } else if (!mCapModeBackup.isEmpty()) { - // Restore previous capture mode after stopPreview() - mParameters.set(TICameraParameters::KEY_CAP_MODE, - mCapModeBackup.string()); - updateRequired = true; - } - - if ((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL) { - if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES))) { - CAMHAL_LOGDB("IPP mode set %s", valstr); - mParameters.set(TICameraParameters::KEY_IPP, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid IPP mode: %s", valstr); - return BAD_VALUE; - } - } - -#ifdef OMAP_ENHANCEMENT_VTC - if ((valstr = params.get(TICameraParameters::KEY_VTC_HINT)) != NULL ) { - mParameters.set(TICameraParameters::KEY_VTC_HINT, valstr); - if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { - mVTCUseCase = true; - } else { - mVTCUseCase = false; - } - CAMHAL_LOGDB("VTC Hint = %d", mVTCUseCase); - } - - if (mVTCUseCase) { - if ((valstr = params.get(TICameraParameters::KEY_VIDEO_ENCODER_HANDLE)) != NULL ) { - mParameters.set(TICameraParameters::KEY_VIDEO_ENCODER_HANDLE, valstr); - } - - if ((valstr = params.get(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT)) != NULL ) { - mParameters.set(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT, valstr); - } - } -#endif - } - -#ifndef OMAP_TUNA - if ( (valstr = params.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT)) != NULL ) - { - if (strcmp(valstr, mParameters.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT))) - { - CAMHAL_LOGDB("Stereo 3D preview image layout is %s", valstr); - mParameters.set(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT, valstr); - restartPreviewRequired = true; - } - } -#endif - -#ifdef OMAP_ENHANCEMENT - int orientation =0; - if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL) - { - doesSetParameterNeedUpdate(valstr, - mParameters.get(TICameraParameters::KEY_SENSOR_ORIENTATION), - updateRequired); - - orientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION); - if ( orientation < 0 || orientation >= 360 || (orientation%90) != 0 ) { - CAMHAL_LOGE("Invalid sensor orientation: %s. Value must be one of: [0, 90, 180, 270]", valstr); - return BAD_VALUE; - } - - CAMHAL_LOGD("Sensor Orientation is set to %d", orientation); - mParameters.set(TICameraParameters::KEY_SENSOR_ORIENTATION, valstr); - } -#endif - - params.getPreviewSize(&w, &h); - if (w == -1 && h == -1) { - CAMHAL_LOGEA("Unable to get preview size"); - return BAD_VALUE; - } - - mVideoWidth = w; - mVideoHeight = h; - - // Handle RECORDING_HINT to Set/Reset Video Mode Parameters - valstr = params.get(android::CameraParameters::KEY_RECORDING_HINT); - if(valstr != NULL) - { - CAMHAL_LOGDB("Recording Hint is set to %s", valstr); - if(strcmp(valstr, android::CameraParameters::TRUE) == 0) - { - CAMHAL_LOGVB("Video Resolution: %d x %d", mVideoWidth, mVideoHeight); -#ifdef OMAP_ENHANCEMENT_VTC - if (!mVTCUseCase) -#endif - { - int maxFPS, minFPS; - - params.getPreviewFpsRange(&minFPS, &maxFPS); - maxFPS /= CameraHal::VFR_SCALE; - if ( ( maxFPS <= SW_SCALING_FPS_LIMIT ) ) { - getPreferredPreviewRes(&w, &h); - } - } - mParameters.set(android::CameraParameters::KEY_RECORDING_HINT, valstr); - restartPreviewRequired |= setVideoModeParameters(params); - } - else if(strcmp(valstr, android::CameraParameters::FALSE) == 0) - { - mParameters.set(android::CameraParameters::KEY_RECORDING_HINT, valstr); - restartPreviewRequired |= resetVideoModeParameters(); - } - else - { - CAMHAL_LOGEA("Invalid RECORDING_HINT"); - return BAD_VALUE; - } - } - else - { - // This check is required in following case. - // If VideoRecording activity sets KEY_RECORDING_HINT to TRUE and - // ImageCapture activity doesnot set KEY_RECORDING_HINT to FALSE (i.e. simply NULL), - // then Video Mode parameters may remain present in ImageCapture activity as well. - CAMHAL_LOGDA("Recording Hint is set to NULL"); - mParameters.set(android::CameraParameters::KEY_RECORDING_HINT, ""); - restartPreviewRequired |= resetVideoModeParameters(); - } - - if ( (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) -#ifndef OMAP_TUNA - && (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SUBSAMPLED_SIZES))) - && (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES))) - && (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_TOPBOTTOM_SIZES))) -#endif - ) { - CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h); - return BAD_VALUE; - } - - int oldWidth, oldHeight; - mParameters.getPreviewSize(&oldWidth, &oldHeight); - if ( ( oldWidth != w ) || ( oldHeight != h ) ) - { - mParameters.setPreviewSize(w, h); - restartPreviewRequired = true; - } - - CAMHAL_LOGDB("Preview Resolution: %d x %d", w, h); - - if ((valstr = params.get(android::CameraParameters::KEY_FOCUS_MODE)) != NULL) { - if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES))) { - CAMHAL_LOGDB("Focus mode set %s", valstr); - - // we need to take a decision on the capture mode based on whether CAF picture or - // video is chosen so the behavior of each is consistent to the application - if(strcmp(valstr, android::CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0){ - restartPreviewRequired |= resetVideoModeParameters(); - } else if (strcmp(valstr, android::CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) == 0){ - restartPreviewRequired |= setVideoModeParameters(params); - } - - mParameters.set(android::CameraParameters::KEY_FOCUS_MODE, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid FOCUS mode = %s", valstr); - return BAD_VALUE; - } - } - - mRawCapture = false; - -#ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING - valstr = params.get(TICameraParameters::KEY_CAP_MODE); - if ( (!valstr || strcmp(valstr, TICameraParameters::HIGH_QUALITY_MODE) == 0) && - access(kRawImagesOutputDirPath, F_OK) != -1 ) { - mRawCapture = true; - } -#endif - -#ifndef OMAP_TUNA - if ( (valstr = params.get(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT)) != NULL ) - { - CAMHAL_LOGDB("Stereo 3D capture image layout is %s", valstr); - mParameters.set(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT, valstr); - } -#endif - - params.getPictureSize(&w, &h); - if ( (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES))) -#ifndef OMAP_TUNA - || (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SUBSAMPLED_SIZES))) - || (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_TOPBOTTOM_SIZES))) - || (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIDEBYSIDE_SIZES))) -#endif - ) { - mParameters.setPictureSize(w, h); - } else { - CAMHAL_LOGEB("ERROR: Invalid picture resolution %d x %d", w, h); - return BAD_VALUE; - } - - CAMHAL_LOGDB("Picture Size by App %d x %d", w, h); - - if ( (valstr = params.getPictureFormat()) != NULL ) { - if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS))) { - if ((strcmp(valstr, android::CameraParameters::PIXEL_FORMAT_BAYER_RGGB) == 0) && - mCameraProperties->get(CameraProperties::MAX_PICTURE_WIDTH) && - mCameraProperties->get(CameraProperties::MAX_PICTURE_HEIGHT)) { - unsigned int width = 0, height = 0; - // Set picture size to full frame for raw bayer capture - width = atoi(mCameraProperties->get(CameraProperties::MAX_PICTURE_WIDTH)); - height = atoi(mCameraProperties->get(CameraProperties::MAX_PICTURE_HEIGHT)); - mParameters.setPictureSize(width,height); - } - mParameters.setPictureFormat(valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid picture format: %s",valstr); - ret = BAD_VALUE; - } - } - -#ifdef OMAP_ENHANCEMENT_BURST_CAPTURE - if ((valstr = params.get(TICameraParameters::KEY_BURST)) != NULL) { - if (params.getInt(TICameraParameters::KEY_BURST) >=0) { - CAMHAL_LOGDB("Burst set %s", valstr); - mParameters.set(TICameraParameters::KEY_BURST, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Burst value: %s",valstr); - return BAD_VALUE; - } - } -#endif - - // Variable framerate ranges have higher priority over - // deprecated constant FPS. "KEY_PREVIEW_FPS_RANGE" should - // be cleared by the client in order for constant FPS to get - // applied. - // If Port FPS needs to be used for configuring, then FPS RANGE should not be set by the APP. - valstr = params.get(android::CameraParameters::KEY_PREVIEW_FPS_RANGE); - if (valstr != NULL && strlen(valstr)) { - int curMaxFPS = 0; - int curMinFPS = 0; - - // APP wants to set FPS range - // Set framerate = MAXFPS - CAMHAL_LOGDA("APP IS CHANGING FRAME RATE RANGE"); - - mParameters.getPreviewFpsRange(&curMinFPS, &curMaxFPS); - CAMHAL_LOGDB("## current minFPS = %d; maxFPS=%d",curMinFPS, curMaxFPS); - - params.getPreviewFpsRange(&minFPS, &maxFPS); - CAMHAL_LOGDB("## requested minFPS = %d; maxFPS=%d",minFPS, maxFPS); - // Validate VFR - if (!isFpsRangeValid(minFPS, maxFPS, params.get(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE)) && - !isFpsRangeValid(minFPS, maxFPS, params.get(TICameraParameters::KEY_FRAMERATE_RANGES_EXT_SUPPORTED))) { - CAMHAL_LOGEA("Invalid FPS Range"); - return BAD_VALUE; - } else { - framerate = maxFPS / CameraHal::VFR_SCALE; - mParameters.setPreviewFrameRate(framerate); - CAMHAL_LOGDB("SET FRAMERATE %d", framerate); - mParameters.set(android::CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr); - CAMHAL_LOGDB("FPS Range = %s", valstr); - if ( curMaxFPS == (FRAME_RATE_HIGH_HD * CameraHal::VFR_SCALE) && - (unsigned int)maxFPS < (FRAME_RATE_HIGH_HD * CameraHal::VFR_SCALE) ) { - restartPreviewRequired = true; - } - } - } else { - framerate = params.getPreviewFrameRate(); - if (!isParameterValid(framerate, params.get(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES)) && - !isParameterValid(framerate, params.get(TICameraParameters::KEY_FRAMERATES_EXT_SUPPORTED))) { - CAMHAL_LOGEA("Invalid frame rate"); - return BAD_VALUE; - } - char tmpBuffer[MAX_PROP_VALUE_LENGTH]; - - sprintf(tmpBuffer, "%d,%d", framerate * CameraHal::VFR_SCALE, framerate * CameraHal::VFR_SCALE); - mParameters.setPreviewFrameRate(framerate); - CAMHAL_LOGDB("SET FRAMERATE %d", framerate); - mParameters.set(android::CameraParameters::KEY_PREVIEW_FPS_RANGE, tmpBuffer); - CAMHAL_LOGDB("FPS Range = %s", tmpBuffer); - } - - if ((valstr = params.get(TICameraParameters::KEY_GBCE)) != NULL) { - if (strcmp(mCameraProperties->get(CameraProperties::SUPPORTED_GBCE), - android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGDB("GBCE %s", valstr); - mParameters.set(TICameraParameters::KEY_GBCE, valstr); - } else if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGEB("ERROR: Invalid GBCE: %s", valstr); - return BAD_VALUE; - } else { - mParameters.set(TICameraParameters::KEY_GBCE, android::CameraParameters::FALSE); - } - } else { - mParameters.set(TICameraParameters::KEY_GBCE, android::CameraParameters::FALSE); - } - - if ((valstr = params.get(TICameraParameters::KEY_GLBCE)) != NULL) { - if (strcmp(mCameraProperties->get(CameraProperties::SUPPORTED_GLBCE), - android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGDB("GLBCE %s", valstr); - mParameters.set(TICameraParameters::KEY_GLBCE, valstr); - } else if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGEB("ERROR: Invalid GLBCE: %s", valstr); - return BAD_VALUE; - } else { - mParameters.set(TICameraParameters::KEY_GLBCE, android::CameraParameters::FALSE); - } - } else { - mParameters.set(TICameraParameters::KEY_GLBCE, android::CameraParameters::FALSE); - } - -#ifdef OMAP_ENHANCEMENT_S3D - ///Update the current parameter set - if ( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE)) != NULL ) { - CAMHAL_LOGDB("AutoConvergence mode set = %s", valstr); - mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, valstr); - } - - if ( (valstr = params.get(TICameraParameters::KEY_MANUAL_CONVERGENCE)) != NULL ) { - int manualConvergence = (int)strtol(valstr, 0, 0); - - if ( ( manualConvergence < strtol(mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_MIN), 0, 0) ) || - ( manualConvergence > strtol(mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_MAX), 0, 0) ) ) { - CAMHAL_LOGEB("ERROR: Invalid Manual Convergence = %d", manualConvergence); - return BAD_VALUE; - } else { - CAMHAL_LOGDB("ManualConvergence Value = %d", manualConvergence); - mParameters.set(TICameraParameters::KEY_MANUAL_CONVERGENCE, valstr); - } - } - -#ifndef OMAP_TUNA - if((valstr = params.get(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION)) != NULL) { - if ( strcmp(mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED), - android::CameraParameters::TRUE) == 0 ) { - CAMHAL_LOGDB("Mechanical Mialignment Correction is %s", valstr); - mParameters.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION, valstr); - } else { - mParameters.remove(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION); - } - } -#endif - - if ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL) { - if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES))) { - CAMHAL_LOGDB("Exposure mode set = %s", valstr); - mParameters.set(TICameraParameters::KEY_EXPOSURE_MODE, valstr); - if (!strcmp(valstr, TICameraParameters::EXPOSURE_MODE_MANUAL)) { - int manualVal; - if ((valstr = params.get(TICameraParameters::KEY_MANUAL_EXPOSURE)) != NULL) { - manualVal = params.getInt(TICameraParameters::KEY_MANUAL_EXPOSURE); - if (manualVal < mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN) || - manualVal > mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MAX)) { - CAMHAL_LOGEB("ERROR: Manual Exposure = %s is out of range - " - "setting minimum supported value", valstr); - valstr = mParameters.get(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN); - } - CAMHAL_LOGDB("Manual Exposure = %s", valstr); - mParameters.set(TICameraParameters::KEY_MANUAL_EXPOSURE, valstr); - } - if ((valstr = params.get(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT)) != NULL) { - manualVal = params.getInt(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT); - if (manualVal < mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN) || - manualVal > mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MAX)) { - CAMHAL_LOGEB("ERROR: Manual Exposure right = %s is out of range - " - "setting minimum supported value", valstr); - valstr = mParameters.get(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN); - } - CAMHAL_LOGDB("Manual Exposure right = %s", valstr); - mParameters.set(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT, valstr); - } - if ((valstr = params.get(TICameraParameters::KEY_MANUAL_GAIN_ISO)) != NULL) { - manualVal = params.getInt(TICameraParameters::KEY_MANUAL_GAIN_ISO); - if (manualVal < mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN) || - manualVal > mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX)) { - CAMHAL_LOGEB("ERROR: Manual Gain = %s is out of range - " - "setting minimum supported value", valstr); - valstr = mParameters.get(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN); - } - CAMHAL_LOGDB("Manual Gain = %s", valstr); - mParameters.set(TICameraParameters::KEY_MANUAL_GAIN_ISO, valstr); - } - if ((valstr = params.get(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT)) != NULL) { - manualVal = params.getInt(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT); - if (manualVal < mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN) || - manualVal > mParameters.getInt(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX)) { - CAMHAL_LOGEB("ERROR: Manual Gain right = %s is out of range - " - "setting minimum supported value", valstr); - valstr = mParameters.get(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN); - } - CAMHAL_LOGDB("Manual Gain right = %s", valstr); - mParameters.set(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT, valstr); - } - } - } else { - CAMHAL_LOGEB("ERROR: Invalid Exposure mode = %s", valstr); - return BAD_VALUE; - } - } -#endif - - if ((valstr = params.get(android::CameraParameters::KEY_WHITE_BALANCE)) != NULL) { - if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE))) { - CAMHAL_LOGDB("White balance set %s", valstr); - mParameters.set(android::CameraParameters::KEY_WHITE_BALANCE, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid white balance = %s", valstr); - return BAD_VALUE; - } - } - -#ifdef OMAP_ENHANCEMENT - if ((valstr = params.get(TICameraParameters::KEY_CONTRAST)) != NULL) { - if (params.getInt(TICameraParameters::KEY_CONTRAST) >= 0 ) { - CAMHAL_LOGDB("Contrast set %s", valstr); - mParameters.set(TICameraParameters::KEY_CONTRAST, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Contrast = %s", valstr); - return BAD_VALUE; - } - } - - if ((valstr =params.get(TICameraParameters::KEY_SHARPNESS)) != NULL) { - if (params.getInt(TICameraParameters::KEY_SHARPNESS) >= 0 ) { - CAMHAL_LOGDB("Sharpness set %s", valstr); - mParameters.set(TICameraParameters::KEY_SHARPNESS, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Sharpness = %s", valstr); - return BAD_VALUE; - } - } - - if ((valstr = params.get(TICameraParameters::KEY_SATURATION)) != NULL) { - if (params.getInt(TICameraParameters::KEY_SATURATION) >= 0 ) { - CAMHAL_LOGDB("Saturation set %s", valstr); - mParameters.set(TICameraParameters::KEY_SATURATION, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Saturation = %s", valstr); - return BAD_VALUE; - } - } - - if ((valstr = params.get(TICameraParameters::KEY_BRIGHTNESS)) != NULL) { - if (params.getInt(TICameraParameters::KEY_BRIGHTNESS) >= 0 ) { - CAMHAL_LOGDB("Brightness set %s", valstr); - mParameters.set(TICameraParameters::KEY_BRIGHTNESS, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Brightness = %s", valstr); - return BAD_VALUE; - } - } -#endif - - if ((valstr = params.get(android::CameraParameters::KEY_ANTIBANDING)) != NULL) { - if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING))) { - CAMHAL_LOGDB("Antibanding set %s", valstr); - mParameters.set(android::CameraParameters::KEY_ANTIBANDING, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Antibanding = %s", valstr); - return BAD_VALUE; - } - } - -#ifdef OMAP_ENHANCEMENT - if ((valstr = params.get(TICameraParameters::KEY_ISO)) != NULL) { - if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES))) { - CAMHAL_LOGDB("ISO set %s", valstr); - mParameters.set(TICameraParameters::KEY_ISO, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid ISO = %s", valstr); - return BAD_VALUE; - } - } -#endif - - if( (valstr = params.get(android::CameraParameters::KEY_FOCUS_AREAS)) != NULL ) - { - CAMHAL_LOGDB("Focus areas position set %s", params.get(android::CameraParameters::KEY_FOCUS_AREAS)); - mParameters.set(android::CameraParameters::KEY_FOCUS_AREAS, valstr); - } - -#ifdef OMAP_ENHANCEMENT - if( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL ) - { - CAMHAL_LOGDB("Measurements set to %s", valstr); - mParameters.set(TICameraParameters::KEY_MEASUREMENT_ENABLE, valstr); - - if (strcmp(valstr, android::CameraParameters::TRUE) == 0) - { - mMeasurementEnabled = true; - } - else if (strcmp(valstr, android::CameraParameters::FALSE) == 0) - { - mMeasurementEnabled = false; - } - else - { - mMeasurementEnabled = false; - } - - } -#endif - - if( (valstr = params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL) - { - CAMHAL_LOGDB("Exposure compensation set %s", params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION)); - mParameters.set(android::CameraParameters::KEY_EXPOSURE_COMPENSATION, valstr); - } - - if ((valstr = params.get(android::CameraParameters::KEY_SCENE_MODE)) != NULL) { - if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES))) { - CAMHAL_LOGDB("Scene mode set %s", valstr); - doesSetParameterNeedUpdate(valstr, - mParameters.get(android::CameraParameters::KEY_SCENE_MODE), - updateRequired); - mParameters.set(android::CameraParameters::KEY_SCENE_MODE, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Scene mode = %s", valstr); - return BAD_VALUE; - } - } - - if ((valstr = params.get(android::CameraParameters::KEY_FLASH_MODE)) != NULL) { - if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES))) { - CAMHAL_LOGDB("Flash mode set %s", valstr); - mParameters.set(android::CameraParameters::KEY_FLASH_MODE, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Flash mode = %s", valstr); - return BAD_VALUE; - } - } - - if ((valstr = params.get(android::CameraParameters::KEY_EFFECT)) != NULL) { - if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS))) { - CAMHAL_LOGDB("Effect set %s", valstr); - mParameters.set(android::CameraParameters::KEY_EFFECT, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Effect = %s", valstr); - return BAD_VALUE; - } - } - - varint = params.getInt(android::CameraParameters::KEY_ROTATION); - if ( varint >= 0 ) { - CAMHAL_LOGDB("Rotation set %d", varint); - mParameters.set(android::CameraParameters::KEY_ROTATION, varint); - } - - varint = params.getInt(android::CameraParameters::KEY_JPEG_QUALITY); - if ( varint >= 0 ) { - CAMHAL_LOGDB("Jpeg quality set %d", varint); - mParameters.set(android::CameraParameters::KEY_JPEG_QUALITY, varint); - } - - varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); - if ( varint >= 0 ) { - CAMHAL_LOGDB("Thumbnail width set %d", varint); - mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, varint); - } - - varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); - if ( varint >= 0 ) { - CAMHAL_LOGDB("Thumbnail width set %d", varint); - mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, varint); - } - - varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); - if ( varint >= 0 ) { - CAMHAL_LOGDB("Thumbnail quality set %d", varint); - mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, varint); - } - - if( (valstr = params.get(android::CameraParameters::KEY_GPS_LATITUDE)) != NULL ) - { - CAMHAL_LOGDB("GPS latitude set %s", params.get(android::CameraParameters::KEY_GPS_LATITUDE)); - mParameters.set(android::CameraParameters::KEY_GPS_LATITUDE, valstr); - }else{ - mParameters.remove(android::CameraParameters::KEY_GPS_LATITUDE); - } - - if( (valstr = params.get(android::CameraParameters::KEY_GPS_LONGITUDE)) != NULL ) - { - CAMHAL_LOGDB("GPS longitude set %s", params.get(android::CameraParameters::KEY_GPS_LONGITUDE)); - mParameters.set(android::CameraParameters::KEY_GPS_LONGITUDE, valstr); - }else{ - mParameters.remove(android::CameraParameters::KEY_GPS_LONGITUDE); - } - - if( (valstr = params.get(android::CameraParameters::KEY_GPS_ALTITUDE)) != NULL ) - { - CAMHAL_LOGDB("GPS altitude set %s", params.get(android::CameraParameters::KEY_GPS_ALTITUDE)); - mParameters.set(android::CameraParameters::KEY_GPS_ALTITUDE, valstr); - }else{ - mParameters.remove(android::CameraParameters::KEY_GPS_ALTITUDE); - } - - if( (valstr = params.get(android::CameraParameters::KEY_GPS_TIMESTAMP)) != NULL ) - { - CAMHAL_LOGDB("GPS timestamp set %s", params.get(android::CameraParameters::KEY_GPS_TIMESTAMP)); - mParameters.set(android::CameraParameters::KEY_GPS_TIMESTAMP, valstr); - }else{ - mParameters.remove(android::CameraParameters::KEY_GPS_TIMESTAMP); - } - - if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL ) - { - CAMHAL_LOGDB("GPS datestamp set %s", valstr); - mParameters.set(TICameraParameters::KEY_GPS_DATESTAMP, valstr); - }else{ - mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP); - } - - if( (valstr = params.get(android::CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL ) - { - CAMHAL_LOGDB("GPS processing method set %s", params.get(android::CameraParameters::KEY_GPS_PROCESSING_METHOD)); - mParameters.set(android::CameraParameters::KEY_GPS_PROCESSING_METHOD, valstr); - }else{ - mParameters.remove(android::CameraParameters::KEY_GPS_PROCESSING_METHOD); - } - - if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL ) - { - CAMHAL_LOGDB("GPS MAPDATUM set %s", valstr); - mParameters.set(TICameraParameters::KEY_GPS_MAPDATUM, valstr); - }else{ - mParameters.remove(TICameraParameters::KEY_GPS_MAPDATUM); - } - - if( (valstr = params.get(TICameraParameters::KEY_GPS_VERSION)) != NULL ) - { - CAMHAL_LOGDB("GPS MAPDATUM set %s", valstr); - mParameters.set(TICameraParameters::KEY_GPS_VERSION, valstr); - }else{ - mParameters.remove(TICameraParameters::KEY_GPS_VERSION); - } - - if( (valstr = params.get(TICameraParameters::KEY_EXIF_MODEL)) != NULL ) - { - CAMHAL_LOGDB("EXIF Model set %s", valstr); - mParameters.set(TICameraParameters::KEY_EXIF_MODEL, valstr); - } - - if( (valstr = params.get(TICameraParameters::KEY_EXIF_MAKE)) != NULL ) - { - CAMHAL_LOGDB("EXIF Make set %s", valstr); - mParameters.set(TICameraParameters::KEY_EXIF_MAKE, valstr); - } - -#ifdef OMAP_ENHANCEMENT - if( (valstr = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL ) - { - CAMHAL_LOGDB("Exposure Bracketing set %s", params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)); - mParameters.set(TICameraParameters::KEY_EXP_BRACKETING_RANGE, valstr); - mParameters.remove(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE); - } - else if ((valstr = params.get(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE)) != NULL) { - CAMHAL_LOGDB("ABS Exposure+Gain Bracketing set %s", params.get(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE)); - mParameters.set(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE, valstr); - mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE); - } else - { - mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE); - } - - if( (valstr = params.get(TICameraParameters::KEY_ZOOM_BRACKETING_RANGE)) != NULL ) { - CAMHAL_LOGDB("Zoom Bracketing range %s", valstr); - mParameters.set(TICameraParameters::KEY_ZOOM_BRACKETING_RANGE, valstr); - } else { - mParameters.remove(TICameraParameters::KEY_ZOOM_BRACKETING_RANGE); - } -#endif - - if ((valstr = params.get(android::CameraParameters::KEY_ZOOM)) != NULL ) { - varint = atoi(valstr); - if ( varint >= 0 && varint <= mMaxZoomSupported ) { - CAMHAL_LOGDB("Zoom set %d", varint); - doesSetParameterNeedUpdate(valstr, - mParameters.get(android::CameraParameters::KEY_ZOOM), - updateRequired); - mParameters.set(android::CameraParameters::KEY_ZOOM, valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid Zoom: %s", valstr); - return BAD_VALUE; - } - } - - if( (valstr = params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL ) - { - CAMHAL_LOGDB("Auto Exposure Lock set %s", valstr); - doesSetParameterNeedUpdate(valstr, - mParameters.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK), - updateRequired); - mParameters.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr); - } - - if( (valstr = params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL ) - { - CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", valstr); - doesSetParameterNeedUpdate(valstr, - mParameters.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK), - updateRequired); - mParameters.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr); - } - if( (valstr = params.get(android::CameraParameters::KEY_METERING_AREAS)) != NULL ) - { - CAMHAL_LOGDB("Metering areas position set %s", params.get(android::CameraParameters::KEY_METERING_AREAS)); - mParameters.set(android::CameraParameters::KEY_METERING_AREAS, valstr); - } - - if( (valstr = params.get(TICameraParameters::RAW_WIDTH)) != NULL ) { - CAMHAL_LOGDB("Raw image width set %s", params.get(TICameraParameters::RAW_WIDTH)); - mParameters.set(TICameraParameters::RAW_WIDTH, valstr); - } - - if( (valstr = params.get(TICameraParameters::RAW_HEIGHT)) != NULL ) { - CAMHAL_LOGDB("Raw image height set %s", params.get(TICameraParameters::RAW_HEIGHT)); - mParameters.set(TICameraParameters::RAW_HEIGHT, valstr); - } - -#ifndef OMAP_TUNA - //TI extensions for enable/disable algos - if( (valstr = params.get(TICameraParameters::KEY_ALGO_FIXED_GAMMA)) != NULL ) - { - CAMHAL_LOGDB("Fixed Gamma set %s", valstr); - mParameters.set(TICameraParameters::KEY_ALGO_FIXED_GAMMA, valstr); - } - - if( (valstr = params.get(TICameraParameters::KEY_ALGO_NSF1)) != NULL ) - { - CAMHAL_LOGDB("NSF1 set %s", valstr); - mParameters.set(TICameraParameters::KEY_ALGO_NSF1, valstr); - } - - if( (valstr = params.get(TICameraParameters::KEY_ALGO_NSF2)) != NULL ) - { - CAMHAL_LOGDB("NSF2 set %s", valstr); - mParameters.set(TICameraParameters::KEY_ALGO_NSF2, valstr); - } - - if( (valstr = params.get(TICameraParameters::KEY_ALGO_SHARPENING)) != NULL ) - { - CAMHAL_LOGDB("Sharpening set %s", valstr); - mParameters.set(TICameraParameters::KEY_ALGO_SHARPENING, valstr); - } - - if( (valstr = params.get(TICameraParameters::KEY_ALGO_THREELINCOLORMAP)) != NULL ) - { - CAMHAL_LOGDB("Color Conversion set %s", valstr); - mParameters.set(TICameraParameters::KEY_ALGO_THREELINCOLORMAP, valstr); - } - - if( (valstr = params.get(TICameraParameters::KEY_ALGO_GIC)) != NULL ) - { - CAMHAL_LOGDB("Green Inballance Correction set %s", valstr); - mParameters.set(TICameraParameters::KEY_ALGO_GIC, valstr); - } -#endif - - android::CameraParameters adapterParams = mParameters; - -#ifdef OMAP_ENHANCEMENT - if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS) ) - { - int posBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS); - if ( 0 < posBracketRange ) - { - mBracketRangePositive = posBracketRange; - } - } - CAMHAL_LOGDB("Positive bracketing range %d", mBracketRangePositive); - - - if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG) ) - { - int negBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG); - if ( 0 < negBracketRange ) - { - mBracketRangeNegative = negBracketRange; - } - } - CAMHAL_LOGDB("Negative bracketing range %d", mBracketRangeNegative); - - if( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL) && - ( strcmp(valstr, android::CameraParameters::TRUE) == 0 )) { - if ( !mBracketingEnabled ) { - CAMHAL_LOGDA("Enabling bracketing"); - mBracketingEnabled = true; - } else { - CAMHAL_LOGDA("Bracketing already enabled"); - } - adapterParams.set(TICameraParameters::KEY_TEMP_BRACKETING, valstr); - mParameters.set(TICameraParameters::KEY_TEMP_BRACKETING, valstr); - } else if ( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL ) && - ( strcmp(valstr, android::CameraParameters::FALSE) == 0 )) { - CAMHAL_LOGDA("Disabling bracketing"); - - adapterParams.set(TICameraParameters::KEY_TEMP_BRACKETING, valstr); - mParameters.set(TICameraParameters::KEY_TEMP_BRACKETING, valstr); - mBracketingEnabled = false; - if ( mBracketingRunning ) { - stopImageBracketing(); - } - - } else { - adapterParams.remove(TICameraParameters::KEY_TEMP_BRACKETING); - mParameters.remove(TICameraParameters::KEY_TEMP_BRACKETING); - } -#endif - -#ifdef OMAP_ENHANCEMENT_VTC - if (mVTCUseCase && !mTunnelSetup && (mCameraAdapter != NULL) && - ((mParameters.get(TICameraParameters::KEY_VIDEO_ENCODER_HANDLE)) != NULL )&& - ((mParameters.get(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT)) != NULL )) { - - uint32_t sliceHeight = mParameters.getInt(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT); - uint32_t encoderHandle = mParameters.getInt(TICameraParameters::KEY_VIDEO_ENCODER_HANDLE); - int w, h; - mParameters.getPreviewSize(&w, &h); - status_t done = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SETUP_TUNNEL, sliceHeight, encoderHandle, w, h); - if (done == NO_ERROR) mTunnelSetup = true; - ret |= done; - } -#endif - - // Only send parameters to adapter if preview is already - // enabled or doesSetParameterNeedUpdate says so. Initial setParameters to camera adapter, - // will be called in startPreview() - // TODO(XXX): Need to identify other parameters that need update from camera adapter - if ( (NULL != mCameraAdapter) && (mPreviewEnabled || updateRequired) && !restartPreviewRequired ) { - ret |= mCameraAdapter->setParameters(adapterParams); - } - -#ifdef OMAP_ENHANCEMENT - if( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) && - ( strcmp(valstr, android::CameraParameters::TRUE) == 0 )) - { - CAMHAL_LOGDA("Enabling shutter sound"); - - mShutterEnabled = true; - mMsgEnabled |= CAMERA_MSG_SHUTTER; - mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr); - } - else if ( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) && - ( strcmp(valstr, android::CameraParameters::FALSE) == 0 )) - { - CAMHAL_LOGDA("Disabling shutter sound"); - - mShutterEnabled = false; - mMsgEnabled &= ~CAMERA_MSG_SHUTTER; - mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr); - } -#endif - } - - //On fail restore old parameters - if ( NO_ERROR != ret ) { - mParameters = oldParams; - } - - // Restart Preview if needed by KEY_RECODING_HINT only if preview is already running. - // If preview is not started yet, Video Mode parameters will take effect on next startPreview() - if (restartPreviewRequired && previewEnabled() && !mRecordingEnabled) { - CAMHAL_LOGDA("Restarting Preview"); - ret = restartPreview(); - } else if (restartPreviewRequired && !previewEnabled() && - mDisplayPaused && !mRecordingEnabled) { - CAMHAL_LOGDA("Stopping Preview"); - forceStopPreview(); - } - - if ( !mBracketingRunning && mBracketingEnabled ) { - startImageBracketing(); - } - - if (ret != NO_ERROR) - { - CAMHAL_LOGEA("Failed to restart Preview"); - return ret; - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewFormat, - unsigned int buffercount, unsigned int &max_queueable) -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - if(mDisplayAdapter.get() == NULL) - { - // Memory allocation of preview buffers is now placed in gralloc - // CameraHal should not allocate preview buffers without DisplayAdapter - return NO_MEMORY; - } - - if(!mPreviewBuffers) - { - mPreviewLength = 0; - mPreviewBuffers = mDisplayAdapter->allocateBufferList(width, height, - previewFormat, - mPreviewLength, - buffercount); - if (NULL == mPreviewBuffers ) { - CAMHAL_LOGEA("Couldn't allocate preview buffers"); - return NO_MEMORY; - } - - mPreviewOffsets = (uint32_t *) mDisplayAdapter->getOffsets(); - if ( NULL == mPreviewOffsets ) { - CAMHAL_LOGEA("Buffer mapping failed"); - return BAD_VALUE; - } - - mBufProvider = (BufferProvider*) mDisplayAdapter.get(); - - ret = mDisplayAdapter->maxQueueableBuffers(max_queueable); - if (ret != NO_ERROR) { - return ret; - } - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::freePreviewBufs() -{ - status_t ret = NO_ERROR; - LOG_FUNCTION_NAME; - - CAMHAL_LOGDB("mPreviewBuffers = %p", mPreviewBuffers); - if(mPreviewBuffers) - { - ret = mBufProvider->freeBufferList(mPreviewBuffers); - mPreviewBuffers = NULL; - LOG_FUNCTION_NAME_EXIT; - return ret; - } - LOG_FUNCTION_NAME_EXIT; - return ret; -} - - -status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount) -{ - status_t ret = NO_ERROR; - int bytes; - - LOG_FUNCTION_NAME; - - bytes = size; - - if ( NO_ERROR == ret ) - { - if( NULL != mPreviewDataBuffers ) - { - ret = freePreviewDataBufs(); - } - } - - if ( NO_ERROR == ret ) - { - bytes = ((bytes+4095)/4096)*4096; - mPreviewDataBuffers = mMemoryManager->allocateBufferList(0, 0, NULL, bytes, bufferCount); - - CAMHAL_LOGDB("Size of Preview data buffer = %d", bytes); - if( NULL == mPreviewDataBuffers ) - { - CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager"); - ret = -NO_MEMORY; - } - else - { - bytes = size; - } - } - - if ( NO_ERROR == ret ) - { - mPreviewDataFd = mMemoryManager->getFd(); - mPreviewDataLength = bytes; - mPreviewDataOffsets = mMemoryManager->getOffsets(); - } - else - { - mPreviewDataFd = -1; - mPreviewDataLength = 0; - mPreviewDataOffsets = NULL; - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::freePreviewDataBufs() -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - if ( NO_ERROR == ret ) - { - - if( NULL != mPreviewDataBuffers ) - { - - ret = mMemoryManager->freeBufferList(mPreviewDataBuffers); - mPreviewDataBuffers = NULL; - - } - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::allocImageBufs(unsigned int width, unsigned int height, size_t size, - const char* previewFormat, unsigned int bufferCount, - unsigned int *max_queueable) -{ - status_t ret = NO_ERROR; - int bytes; - - LOG_FUNCTION_NAME; - - bytes = size; - - // allocate image buffers only if not already allocated - if(NULL != mImageBuffers) { - if (mBufferSourceAdapter_Out.get()) { - mBufferSourceAdapter_Out->maxQueueableBuffers(*max_queueable); - } else { - *max_queueable = bufferCount; - } - return NO_ERROR; - } - - if (mBufferSourceAdapter_Out.get()) { - mImageBuffers = mBufferSourceAdapter_Out->allocateBufferList(width, height, previewFormat, - bytes, bufferCount); - mBufferSourceAdapter_Out->maxQueueableBuffers(*max_queueable); - } else { - bytes = ((bytes + 4095) / 4096) * 4096; - mImageBuffers = mMemoryManager->allocateBufferList(0, 0, previewFormat, bytes, bufferCount); - *max_queueable = bufferCount; - } - - CAMHAL_LOGDB("Size of Image cap buffer = %d", bytes); - if ( NULL == mImageBuffers ) { - CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager"); - ret = -NO_MEMORY; - } else { - bytes = size; - } - - if ( NO_ERROR == ret ) { - mImageFd = mMemoryManager->getFd(); - mImageLength = bytes; - mImageOffsets = mMemoryManager->getOffsets(); - } else { - mImageFd = -1; - mImageLength = 0; - mImageOffsets = NULL; - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::allocVideoBufs(uint32_t width, uint32_t height, uint32_t bufferCount) -{ - status_t ret = NO_ERROR; - LOG_FUNCTION_NAME; - - if( NULL != mVideoBuffers ){ - ret = freeVideoBufs(mVideoBuffers); - mVideoBuffers = NULL; - } - - if ( NO_ERROR == ret ){ - int32_t stride; - CameraBuffer *buffers = new CameraBuffer [bufferCount]; - - memset (buffers, 0, sizeof(CameraBuffer) * bufferCount); - - if (buffers != NULL){ - for (unsigned int i = 0; i< bufferCount; i++){ - android::GraphicBufferAllocator &GrallocAlloc = android::GraphicBufferAllocator::get(); - buffer_handle_t handle; - ret = GrallocAlloc.alloc(width, height, HAL_PIXEL_FORMAT_NV12, CAMHAL_GRALLOC_USAGE, &handle, &stride); - if (ret != NO_ERROR){ - CAMHAL_LOGEA("Couldn't allocate video buffers using Gralloc"); - ret = -NO_MEMORY; - for (unsigned int j=0; j< i; j++){ - CAMHAL_LOGEB("Freeing Gralloc Buffer %p", buffers[i].opaque); - GrallocAlloc.free((buffer_handle_t)buffers[i].opaque); - } - delete [] buffers; - goto exit; - } - buffers[i].type = CAMERA_BUFFER_GRALLOC; - buffers[i].opaque = (void *)handle; - CAMHAL_LOGVB("*** Gralloc Handle =0x%x ***", handle); - } - - mVideoBuffers = buffers; - } - else{ - CAMHAL_LOGEA("Couldn't allocate video buffers "); - ret = -NO_MEMORY; - } - } - - exit: - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::allocRawBufs(int width, int height, const char* previewFormat, int bufferCount) -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME - - - ///@todo Enhance this method allocImageBufs() to take in a flag for burst capture - ///Always allocate the buffers for image capture using MemoryManager - if (NO_ERROR == ret) { - if(( NULL != mVideoBuffers )) { - // Re-use the buffer for raw capture. - return ret; - } - } - - if ( NO_ERROR == ret ) { - mVideoLength = 0; - mVideoLength = (((width * height * 2) + 4095)/4096)*4096; - mVideoBuffers = mMemoryManager->allocateBufferList(width, height, previewFormat, - mVideoLength, bufferCount); - - CAMHAL_LOGDB("Size of Video cap buffer (used for RAW capture) %d", mVideoLength); - if( NULL == mVideoBuffers ) { - CAMHAL_LOGEA("Couldn't allocate Video buffers using memory manager"); - ret = -NO_MEMORY; - } - } - - if ( NO_ERROR == ret ) { - mVideoFd = mMemoryManager->getFd(); - mVideoOffsets = mMemoryManager->getOffsets(); - } else { - mVideoFd = -1; - mVideoOffsets = NULL; - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -void endImageCapture( void *userData) -{ - LOG_FUNCTION_NAME; - - if ( NULL != userData ) - { - CameraHal *c = reinterpret_cast<CameraHal *>(userData); - c->signalEndImageCapture(); - } - - LOG_FUNCTION_NAME_EXIT; -} - -void releaseImageBuffers(void *userData) -{ - LOG_FUNCTION_NAME; - - if (NULL != userData) { - CameraHal *c = reinterpret_cast<CameraHal *>(userData); - c->freeImageBufs(); - } - - LOG_FUNCTION_NAME_EXIT; -} - -status_t CameraHal::signalEndImageCapture() -{ - status_t ret = NO_ERROR; - int w,h; - android::AutoMutex lock(mLock); - - LOG_FUNCTION_NAME; - - if (mBufferSourceAdapter_Out.get()) { - mBufferSourceAdapter_Out->disableDisplay(); - } - - if (mBufferSourceAdapter_In.get()) { - mBufferSourceAdapter_In->disableDisplay(); - } - - if ( mBracketingRunning ) { - stopImageBracketing(); - } else { - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE); - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::freeImageBufs() -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - if (NULL == mImageBuffers) { - return -EINVAL; - } - - if (mBufferSourceAdapter_Out.get()) { - ret = mBufferSourceAdapter_Out->freeBufferList(mImageBuffers); - } else { - ret = mMemoryManager->freeBufferList(mImageBuffers); - } - - if (ret == NO_ERROR) { - mImageBuffers = NULL; - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::freeVideoBufs(CameraBuffer *bufs) -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); - if(bufs == NULL) - { - CAMHAL_LOGEA("NULL pointer passed to freeVideoBuffer"); - LOG_FUNCTION_NAME_EXIT; - return BAD_VALUE; - } - - android::GraphicBufferAllocator &GrallocAlloc = android::GraphicBufferAllocator::get(); - - for(int i = 0; i < count; i++){ - CAMHAL_LOGVB("Free Video Gralloc Handle 0x%x", bufs[i].opaque); - GrallocAlloc.free((buffer_handle_t)bufs[i].opaque); - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::freeRawBufs() -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME - - if ( NO_ERROR == ret ) { - if( NULL != mVideoBuffers ) { - ///@todo Pluralise the name of this method to freeBuffers - ret = mMemoryManager->freeBufferList(mVideoBuffers); - mVideoBuffers = NULL; - } else { - ret = -EINVAL; - } - } - - LOG_FUNCTION_NAME_EXIT - - return ret; -} - -/** - @brief Start preview mode. - - @param none - @return NO_ERROR Camera switched to VF mode - @todo Update function header with the different errors that are possible - - */ -status_t CameraHal::startPreview() { - LOG_FUNCTION_NAME; - - // When tunneling is enabled during VTC, startPreview happens in 2 steps: - // When the application sends the command CAMERA_CMD_PREVIEW_INITIALIZATION, - // cameraPreviewInitialization() is called, which in turn causes the CameraAdapter - // to move from loaded to idle state. And when the application calls startPreview, - // the CameraAdapter moves from idle to executing state. - // - // If the application calls startPreview() without sending the command - // CAMERA_CMD_PREVIEW_INITIALIZATION, then the function cameraPreviewInitialization() - // AND startPreview() are executed. In other words, if the application calls - // startPreview() without sending the command CAMERA_CMD_PREVIEW_INITIALIZATION, - // then the CameraAdapter moves from loaded to idle to executing state in one shot. - status_t ret = cameraPreviewInitialization(); - - // The flag mPreviewInitializationDone is set to true at the end of the function - // cameraPreviewInitialization(). Therefore, if everything goes alright, then the - // flag will be set. Sometimes, the function cameraPreviewInitialization() may - // return prematurely if all the resources are not available for starting preview. - // For example, if the preview window is not set, then it would return NO_ERROR. - // Under such circumstances, one should return from startPreview as well and should - // not continue execution. That is why, we check the flag and not the return value. - if (!mPreviewInitializationDone) return ret; - - // Once startPreview is called, there is no need to continue to remember whether - // the function cameraPreviewInitialization() was called earlier or not. And so - // the flag mPreviewInitializationDone is reset here. Plus, this preserves the - // current behavior of startPreview under the circumstances where the application - // calls startPreview twice or more. - mPreviewInitializationDone = false; - - ///Enable the display adapter if present, actual overlay enable happens when we post the buffer - if(mDisplayAdapter.get() != NULL) { - CAMHAL_LOGDA("Enabling display"); - int width, height; - mParameters.getPreviewSize(&width, &height); - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview); -#else - ret = mDisplayAdapter->enableDisplay(width, height, NULL); -#endif - - if ( ret != NO_ERROR ) { - CAMHAL_LOGEA("Couldn't enable display"); - - // FIXME: At this stage mStateSwitchLock is locked and unlock is supposed to be called - // only from mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW) - // below. But this will never happen because of goto error. Thus at next - // startPreview() call CameraHAL will be deadlocked. - // Need to revisit mStateSwitch lock, for now just abort the process. - CAMHAL_ASSERT_X(false, - "At this stage mCameraAdapter->mStateSwitchLock is still locked, " - "deadlock is guaranteed"); - - goto error; - } - - } - - ///Send START_PREVIEW command to adapter - CAMHAL_LOGDA("Starting CameraAdapter preview mode"); - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW); - - if(ret!=NO_ERROR) { - CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter"); - goto error; - } - CAMHAL_LOGDA("Started preview"); - - mPreviewEnabled = true; - mPreviewStartInProgress = false; - return ret; - - error: - - CAMHAL_LOGEA("Performing cleanup after error"); - - //Do all the cleanup - freePreviewBufs(); - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW); - if(mDisplayAdapter.get() != NULL) { - mDisplayAdapter->disableDisplay(false); - } - mAppCallbackNotifier->stop(); - mPreviewStartInProgress = false; - mPreviewEnabled = false; - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -//////////// -/** - @brief Set preview mode related initialization - -> Camera Adapter set params - -> Allocate buffers - -> Set use buffers for preview - @param none - @return NO_ERROR - @todo Update function header with the different errors that are possible - - */ -status_t CameraHal::cameraPreviewInitialization() -{ - - status_t ret = NO_ERROR; - CameraAdapter::BuffersDescriptor desc; - CameraFrame frame; - unsigned int required_buffer_count; - unsigned int max_queueble_buffers; - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - gettimeofday(&mStartPreview, NULL); -#endif - - LOG_FUNCTION_NAME; - - if (mPreviewInitializationDone) { - return NO_ERROR; - } - - if ( mPreviewEnabled ){ - CAMHAL_LOGDA("Preview already running"); - LOG_FUNCTION_NAME_EXIT; - return ALREADY_EXISTS; - } - - if ( NULL != mCameraAdapter ) { - ret = mCameraAdapter->setParameters(mParameters); - } - - if ((mPreviewStartInProgress == false) && (mDisplayPaused == false)){ - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,( int ) &frame); - if ( NO_ERROR != ret ){ - CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d", ret); - return ret; - } - - ///Update the current preview width and height - mPreviewWidth = frame.mWidth; - mPreviewHeight = frame.mHeight; - } - - ///If we don't have the preview callback enabled and display adapter, - if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)){ - CAMHAL_LOGD("Preview not started. Preview in progress flag set"); - mPreviewStartInProgress = true; - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING); - if ( NO_ERROR != ret ){ - CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d", ret); - return ret; - } - return NO_ERROR; - } - - if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) ) - { - CAMHAL_LOGDA("Preview is in paused state"); - - mDisplayPaused = false; - mPreviewEnabled = true; - if ( NO_ERROR == ret ) - { - ret = mDisplayAdapter->pauseDisplay(mDisplayPaused); - - if ( NO_ERROR != ret ) - { - CAMHAL_LOGEB("Display adapter resume failed %x", ret); - } - } - //restart preview callbacks - if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) - { - mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME); - } - - signalEndImageCapture(); - return ret; - } - - required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); - - ///Allocate the preview buffers - ret = allocPreviewBufs(mPreviewWidth, mPreviewHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers); - - if ( NO_ERROR != ret ) - { - CAMHAL_LOGEA("Couldn't allocate buffers for Preview"); - goto error; - } - - if ( mMeasurementEnabled ) - { - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA, - ( int ) &frame, - required_buffer_count); - if ( NO_ERROR != ret ) - { - return ret; - } - - ///Allocate the preview data buffers - ret = allocPreviewDataBufs(frame.mLength, required_buffer_count); - if ( NO_ERROR != ret ) { - CAMHAL_LOGEA("Couldn't allocate preview data buffers"); - goto error; - } - - if ( NO_ERROR == ret ) - { - desc.mBuffers = mPreviewDataBuffers; - desc.mOffsets = mPreviewDataOffsets; - desc.mFd = mPreviewDataFd; - desc.mLength = mPreviewDataLength; - desc.mCount = ( size_t ) required_buffer_count; - desc.mMaxQueueable = (size_t) required_buffer_count; - - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA, - ( int ) &desc); - } - - } - - ///Pass the buffers to Camera Adapter - desc.mBuffers = mPreviewBuffers; - desc.mOffsets = mPreviewOffsets; - desc.mFd = mPreviewFd; - desc.mLength = mPreviewLength; - desc.mCount = ( size_t ) required_buffer_count; - desc.mMaxQueueable = (size_t) max_queueble_buffers; - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW, - ( int ) &desc); - - if ( NO_ERROR != ret ) - { - CAMHAL_LOGEB("Failed to register preview buffers: 0x%x", ret); - freePreviewBufs(); - return ret; - } - - ///Start the callback notifier - ret = mAppCallbackNotifier->start(); - - if( ALREADY_EXISTS == ret ) - { - //Already running, do nothing - CAMHAL_LOGDA("AppCallbackNotifier already running"); - ret = NO_ERROR; - } - else if ( NO_ERROR == ret ) { - CAMHAL_LOGDA("Started AppCallbackNotifier.."); - mAppCallbackNotifier->setMeasurements(mMeasurementEnabled); - } - else - { - CAMHAL_LOGDA("Couldn't start AppCallbackNotifier"); - goto error; - } - - if (ret == NO_ERROR) mPreviewInitializationDone = true; - - mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count); - - return ret; - - error: - - CAMHAL_LOGEA("Performing cleanup after error"); - - //Do all the cleanup - freePreviewBufs(); - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW); - if(mDisplayAdapter.get() != NULL) - { - mDisplayAdapter->disableDisplay(false); - } - mAppCallbackNotifier->stop(); - mPreviewStartInProgress = false; - mPreviewEnabled = false; - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -/** - @brief Sets ANativeWindow object. - - Preview buffers provided to CameraHal via this object. DisplayAdapter will be interfacing with it - to render buffers to display. - - @param[in] window The ANativeWindow object created by Surface flinger - @return NO_ERROR If the ANativeWindow object passes validation criteria - @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios - - */ -status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window) -{ - status_t ret = NO_ERROR; - CameraAdapter::BuffersDescriptor desc; - - LOG_FUNCTION_NAME; - mSetPreviewWindowCalled = true; - - ///If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter - if(!window) - { - if(mDisplayAdapter.get() != NULL) - { - ///NULL window passed, destroy the display adapter if present - CAMHAL_LOGD("NULL window passed, destroying display adapter"); - mDisplayAdapter.clear(); - ///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client - ///@remarks so, we will wait until it passes a valid window to begin the preview again - mSetPreviewWindowCalled = false; - } - CAMHAL_LOGD("NULL ANativeWindow passed to setPreviewWindow"); - return NO_ERROR; - }else if(mDisplayAdapter.get() == NULL) - { - // Need to create the display adapter since it has not been created - // Create display adapter - mDisplayAdapter = new ANativeWindowDisplayAdapter(); -#ifdef OMAP_ENHANCEMENT - mDisplayAdapter->setExtendedOps(mExtendedPreviewStreamOps); -#endif - ret = NO_ERROR; - if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR)) - { - if(ret!=NO_ERROR) - { - mDisplayAdapter.clear(); - CAMHAL_LOGEA("DisplayAdapter initialize failed"); - LOG_FUNCTION_NAME_EXIT; - return ret; - } - else - { - CAMHAL_LOGEA("Couldn't create DisplayAdapter"); - LOG_FUNCTION_NAME_EXIT; - return NO_MEMORY; - } - } - - // DisplayAdapter needs to know where to get the CameraFrames from inorder to display - // Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter - mDisplayAdapter->setFrameProvider(mCameraAdapter); - - // Any dynamic errors that happen during the camera use case has to be propagated back to the application - // via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application - // Set it as the error handler for the DisplayAdapter - mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get()); - - // Update the display adapter with the new window that is passed from CameraService - ret = mDisplayAdapter->setPreviewWindow(window); - if(ret!=NO_ERROR) - { - CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret); - } - - if(mPreviewStartInProgress) - { - CAMHAL_LOGDA("setPreviewWindow called when preview running"); - // Start the preview since the window is now available - ret = startPreview(); - } - } else { - // Update the display adapter with the new window that is passed from CameraService - ret = mDisplayAdapter->setPreviewWindow(window); - if ( (NO_ERROR == ret) && previewEnabled() ) { - restartPreview(); - } else if (ret == ALREADY_EXISTS) { - // ALREADY_EXISTS should be treated as a noop in this case - ret = NO_ERROR; - } - } - LOG_FUNCTION_NAME_EXIT; - - return ret; - -} - - -#ifdef OMAP_ENHANCEMENT_CPCAM -void CameraHal::setExtendedPreviewStreamOps(preview_stream_extended_ops_t *ops) -{ - mExtendedPreviewStreamOps = ops; -} - -/** - @brief Sets ANativeWindow object. - - Buffers provided to CameraHal via this object for tap-in/tap-out - functionality. - - TODO(XXX): this is just going to use preview_stream_ops for now, but we - most likely need to extend it when we want more functionality - - @param[in] window The ANativeWindow object created by Surface flinger - @return NO_ERROR If the ANativeWindow object passes validation criteria - @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios - - */ -status_t CameraHal::setBufferSource(struct preview_stream_ops *tapin, struct preview_stream_ops *tapout) -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - // If either a tapin or tapout was previously set - // we need to clean up and clear capturing - if ((!tapout && mBufferSourceAdapter_Out.get()) || - (!tapin && mBufferSourceAdapter_In.get())) { - signalEndImageCapture(); - } - - // Set tapout point - // destroy current buffer tapout if NULL tapout is passed - if (!tapout) { - if (mBufferSourceAdapter_Out.get() != NULL) { - CAMHAL_LOGD("NULL tapout passed, destroying buffer tapout adapter"); - mBufferSourceAdapter_Out.clear(); - mBufferSourceAdapter_Out = 0; - } - ret = NO_ERROR; - } else if (mBufferSourceAdapter_Out.get() == NULL) { - mBufferSourceAdapter_Out = new BufferSourceAdapter(); - mBufferSourceAdapter_Out->setExtendedOps(mExtendedPreviewStreamOps); - if(!mBufferSourceAdapter_Out.get()) { - CAMHAL_LOGEA("Couldn't create DisplayAdapter"); - ret = NO_MEMORY; - goto exit; - } - - ret = mBufferSourceAdapter_Out->initialize(); - if (ret != NO_ERROR) - { - mBufferSourceAdapter_Out.clear(); - mBufferSourceAdapter_Out = 0; - CAMHAL_LOGEA("DisplayAdapter initialize failed"); - goto exit; - } - - // CameraAdapter will be the frame provider for BufferSourceAdapter - mBufferSourceAdapter_Out->setFrameProvider(mCameraAdapter); - - // BufferSourceAdapter will use ErrorHandler to send errors back to - // the application - mBufferSourceAdapter_Out->setErrorHandler(mAppCallbackNotifier.get()); - - // Update the display adapter with the new window that is passed from CameraService - ret = mBufferSourceAdapter_Out->setPreviewWindow(tapout); - if(ret != NO_ERROR) { - CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret); - goto exit; - } - } else { - // Update the display adapter with the new window that is passed from CameraService - freeImageBufs(); - ret = mBufferSourceAdapter_Out->setPreviewWindow(tapout); - if (ret == ALREADY_EXISTS) { - // ALREADY_EXISTS should be treated as a noop in this case - ret = NO_ERROR; - } - } - - if (ret != NO_ERROR) { - CAMHAL_LOGE("Error while trying to set tapout point"); - goto exit; - } - - // 1. Set tapin point - if (!tapin) { - if (mBufferSourceAdapter_In.get() != NULL) { - CAMHAL_LOGD("NULL tapin passed, destroying buffer tapin adapter"); - mBufferSourceAdapter_In.clear(); - mBufferSourceAdapter_In = 0; - } - ret = NO_ERROR; - } else if (mBufferSourceAdapter_In.get() == NULL) { - mBufferSourceAdapter_In = new BufferSourceAdapter(); - mBufferSourceAdapter_In->setExtendedOps(mExtendedPreviewStreamOps); - if(!mBufferSourceAdapter_In.get()) { - CAMHAL_LOGEA("Couldn't create DisplayAdapter"); - ret = NO_MEMORY; - goto exit; - } - - ret = mBufferSourceAdapter_In->initialize(); - if (ret != NO_ERROR) - { - mBufferSourceAdapter_In.clear(); - mBufferSourceAdapter_In = 0; - CAMHAL_LOGEA("DisplayAdapter initialize failed"); - goto exit; - } - - // We need to set a frame provider so camera adapter can return the frame back to us - mBufferSourceAdapter_In->setFrameProvider(mCameraAdapter); - - // BufferSourceAdapter will use ErrorHandler to send errors back to - // the application - mBufferSourceAdapter_In->setErrorHandler(mAppCallbackNotifier.get()); - - // Update the display adapter with the new window that is passed from CameraService - ret = mBufferSourceAdapter_In->setPreviewWindow(tapin); - if(ret != NO_ERROR) { - CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret); - goto exit; - } - } else { - // Update the display adapter with the new window that is passed from CameraService - ret = mBufferSourceAdapter_In->setPreviewWindow(tapin); - if (ret == ALREADY_EXISTS) { - // ALREADY_EXISTS should be treated as a noop in this case - ret = NO_ERROR; - } - } - - exit: - return ret; -} -#endif - - -/** - @brief Stop a previously started preview. - - @param none - @return none - - */ -void CameraHal::stopPreview() -{ - LOG_FUNCTION_NAME; - - if( (!previewEnabled() && !mDisplayPaused) || mRecordingEnabled) - { - LOG_FUNCTION_NAME_EXIT; - return; - } - - bool imageCaptureRunning = (mCameraAdapter->getState() & CameraAdapter::CAPTURE_STATE) && - (mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE); - if(mDisplayPaused && !imageCaptureRunning) - { - // Display is paused, which essentially means there is no preview active. - // Note: this is done so that when stopPreview is called by client after - // an image capture, we do not de-initialize the camera adapter and - // restart over again. - - return; - } - - forceStopPreview(); - - // Reset Capture-Mode to default, so that when we switch from VideoRecording - // to ImageCapture, CAPTURE_MODE is not left to VIDEO_MODE. - CAMHAL_LOGDA("Resetting Capture-Mode to default"); - mParameters.set(TICameraParameters::KEY_CAP_MODE, ""); - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Returns true if preview is enabled - - @param none - @return true If preview is running currently - false If preview has been stopped - - */ -bool CameraHal::previewEnabled() -{ - LOG_FUNCTION_NAME; - - return (mPreviewEnabled || mPreviewStartInProgress); -} - -/** - @brief Start record mode. - - When a record image is available a CAMERA_MSG_VIDEO_FRAME message is sent with - the corresponding frame. Every record frame must be released by calling - releaseRecordingFrame(). - - @param none - @return NO_ERROR If recording could be started without any issues - @todo Update the header with possible error values in failure scenarios - - */ -status_t CameraHal::startRecording( ) -{ - int w, h; - const char *valstr = NULL; - bool restartPreviewRequired = false; - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - - gettimeofday(&mStartPreview, NULL); - -#endif - - if(!previewEnabled()) - { - return NO_INIT; - } - - // set internal recording hint in case camera adapter needs to make some - // decisions....(will only be sent to camera adapter if camera restart is required) - mParameters.set(TICameraParameters::KEY_RECORDING_HINT, android::CameraParameters::TRUE); - - // if application starts recording in continuous focus picture mode... - // then we need to force default capture mode (as opposed to video mode) - if ( ((valstr = mParameters.get(android::CameraParameters::KEY_FOCUS_MODE)) != NULL) && - (strcmp(valstr, android::CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0) ){ - restartPreviewRequired = resetVideoModeParameters(); - } - - // only need to check recording hint if preview restart is not already needed - valstr = mParameters.get(android::CameraParameters::KEY_RECORDING_HINT); - if ( !restartPreviewRequired && - (!valstr || (valstr && (strcmp(valstr, android::CameraParameters::TRUE) != 0))) ) { - restartPreviewRequired = setVideoModeParameters(mParameters); - } - - if (restartPreviewRequired) { - { - android::AutoMutex lock(mLock); - mCapModeBackup = mParameters.get(TICameraParameters::KEY_CAP_MODE); - } - ret = restartPreview(); - } - - if ( NO_ERROR == ret ) - { - int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); - mParameters.getPreviewSize(&w, &h); - CAMHAL_LOGDB("%s Video Width=%d Height=%d", __FUNCTION__, mVideoWidth, mVideoHeight); - - if ((w != mVideoWidth) && (h != mVideoHeight)) - { - ret = allocVideoBufs(mVideoWidth, mVideoHeight, count); - if ( NO_ERROR != ret ) - { - CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); - mParameters.remove(TICameraParameters::KEY_RECORDING_HINT); - return ret; - } - - mAppCallbackNotifier->useVideoBuffers(true); - mAppCallbackNotifier->setVideoRes(mVideoWidth, mVideoHeight); - ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, count, mVideoBuffers); - } - else - { - mAppCallbackNotifier->useVideoBuffers(false); - mAppCallbackNotifier->setVideoRes(mPreviewWidth, mPreviewHeight); - ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, count, NULL); - } - } - - if ( NO_ERROR == ret ) - { - ret = mAppCallbackNotifier->startRecording(); - } - - if ( NO_ERROR == ret ) - { - ///Buffers for video capture (if different from preview) are expected to be allocated within CameraAdapter - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_VIDEO); - } - - if ( NO_ERROR == ret ) - { - mRecordingEnabled = true; - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -/** - @brief Set the camera parameters specific to Video Recording. - - This function checks for the camera parameters which have to be set for recording. - Video Recording needs CAPTURE_MODE to be VIDEO_MODE. This function sets it. - This function also enables Video Recording specific functions like VSTAB & VNF. - - @param none - @return true if preview needs to be restarted for VIDEO_MODE parameters to take effect. - @todo Modify the policies for enabling VSTAB & VNF usecase based later. - - */ -bool CameraHal::setVideoModeParameters(const android::CameraParameters& params) -{ - const char *valstr = NULL; - const char *valstrRemote = NULL; - bool restartPreviewRequired = false; - - LOG_FUNCTION_NAME; - - // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview - valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); - if ( (valstr == NULL) || - ( (valstr != NULL) && (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) != 0) ) ) - { - CAMHAL_LOGDA("Set CAPTURE_MODE to VIDEO_MODE"); - mParameters.set(TICameraParameters::KEY_CAP_MODE, (const char *) TICameraParameters::VIDEO_MODE); - restartPreviewRequired = true; - } - - // set VSTAB. restart is required if vstab value has changed - if ( (valstrRemote = params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION)) != NULL ) { - // make sure we support vstab - if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED), - android::CameraParameters::TRUE) == 0) { - valstr = mParameters.get(android::CameraParameters::KEY_VIDEO_STABILIZATION); - // vstab value has changed - if ((valstr != NULL) && - strcmp(valstr, valstrRemote) != 0) { - restartPreviewRequired = true; - } - mParameters.set(android::CameraParameters::KEY_VIDEO_STABILIZATION, - valstrRemote); - } - } else if (mParameters.get(android::CameraParameters::KEY_VIDEO_STABILIZATION)) { - // vstab was configured but now unset - restartPreviewRequired = true; - mParameters.remove(android::CameraParameters::KEY_VIDEO_STABILIZATION); - } - - // Set VNF - if ((valstrRemote = params.get(TICameraParameters::KEY_VNF)) == NULL) { - CAMHAL_LOGDA("Enable VNF"); - mParameters.set(TICameraParameters::KEY_VNF, android::CameraParameters::TRUE); - restartPreviewRequired = true; - } else { - valstr = mParameters.get(TICameraParameters::KEY_VNF); - if (valstr && strcmp(valstr, valstrRemote) != 0) { - restartPreviewRequired = true; - } - mParameters.set(TICameraParameters::KEY_VNF, valstrRemote); - } - -#if !defined(OMAP_ENHANCEMENT) && !defined(ENHANCED_DOMX) - // For VSTAB alone for 1080p resolution, padded width goes > 2048, which cannot be rendered by GPU. - // In such case, there is support in Ducati for combination of VSTAB & VNF requiring padded width < 2048. - // So we are forcefully enabling VNF, if VSTAB is enabled for 1080p resolution. - int w, h; - params.getPreviewSize(&w, &h); - valstr = mParameters.get(android::CameraParameters::KEY_VIDEO_STABILIZATION); - if (valstr && (strcmp(valstr, android::CameraParameters::TRUE) == 0) && (w == 1920)) { - CAMHAL_LOGDA("Force Enable VNF for 1080p"); - const char *valKeyVnf = mParameters.get(TICameraParameters::KEY_VNF); - if(!valKeyVnf || (strcmp(valKeyVnf, android::CameraParameters::TRUE) != 0)) { - mParameters.set(TICameraParameters::KEY_VNF, android::CameraParameters::TRUE); - restartPreviewRequired = true; - } - } -#endif - - LOG_FUNCTION_NAME_EXIT; - - return restartPreviewRequired; -} - -/** - @brief Reset the camera parameters specific to Video Recording. - - This function resets CAPTURE_MODE and disables Recording specific functions like VSTAB & VNF. - - @param none - @return true if preview needs to be restarted for VIDEO_MODE parameters to take effect. - - */ -bool CameraHal::resetVideoModeParameters() -{ - const char *valstr = NULL; - bool restartPreviewRequired = false; - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - // ignore this if we are already recording - if (mRecordingEnabled) { - return false; - } - - // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview - valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); - if ((valstr != NULL) && (strcmp(valstr, TICameraParameters::VIDEO_MODE) == 0)) { - CAMHAL_LOGDA("Reset Capture-Mode to default"); - mParameters.set(TICameraParameters::KEY_CAP_MODE, ""); - restartPreviewRequired = true; - } - - LOG_FUNCTION_NAME_EXIT; - - return restartPreviewRequired; -} - -/** - @brief Restart the preview with setParameter. - - This function restarts preview, for some VIDEO_MODE parameters to take effect. - - @param none - @return NO_ERROR If recording parameters could be set without any issues - - */ -status_t CameraHal::restartPreview() -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - // Retain CAPTURE_MODE before calling stopPreview(), since it is reset in stopPreview(). - - forceStopPreview(); - - { - android::AutoMutex lock(mLock); - if (!mCapModeBackup.isEmpty()) { - mParameters.set(TICameraParameters::KEY_CAP_MODE, mCapModeBackup.string()); - mCapModeBackup = ""; - } else { - mParameters.set(TICameraParameters::KEY_CAP_MODE, ""); - } - mCameraAdapter->setParameters(mParameters); - } - - ret = startPreview(); - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -/** - @brief Stop a previously started recording. - - @param none - @return none - - */ -void CameraHal::stopRecording() -{ - CameraAdapter::AdapterState currentState; - - LOG_FUNCTION_NAME; - - android::AutoMutex lock(mLock); - - if (!mRecordingEnabled ) - { - return; - } - - currentState = mCameraAdapter->getState(); - if (currentState == CameraAdapter::VIDEO_CAPTURE_STATE) { - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE); - } - - mAppCallbackNotifier->stopRecording(); - - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_VIDEO); - - mRecordingEnabled = false; - - if ( mAppCallbackNotifier->getUesVideoBuffers() ){ - freeVideoBufs(mVideoBuffers); - if (mVideoBuffers){ - CAMHAL_LOGVB(" FREEING mVideoBuffers %p", mVideoBuffers); - delete [] mVideoBuffers; - } - mVideoBuffers = NULL; - } - - // reset internal recording hint in case camera adapter needs to make some - // decisions....(will only be sent to camera adapter if camera restart is required) - mParameters.remove(TICameraParameters::KEY_RECORDING_HINT); - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Returns true if recording is enabled. - - @param none - @return true If recording is currently running - false If recording has been stopped - - */ -int CameraHal::recordingEnabled() -{ - LOG_FUNCTION_NAME; - - LOG_FUNCTION_NAME_EXIT; - - return mRecordingEnabled; -} - -/** - @brief Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME. - - @param[in] mem MemoryBase pointer to the frame being released. Must be one of the buffers - previously given by CameraHal - @return none - - */ -void CameraHal::releaseRecordingFrame(const void* mem) -{ - LOG_FUNCTION_NAME; - - //CAMHAL_LOGDB(" 0x%x", mem->pointer()); - - if ( ( mRecordingEnabled ) && mem != NULL) - { - mAppCallbackNotifier->releaseRecordingFrame(mem); - } - - LOG_FUNCTION_NAME_EXIT; - - return; -} - -/** - @brief Start auto focus - - This call asynchronous. - The notification callback routine is called with CAMERA_MSG_FOCUS once when - focusing is complete. autoFocus() will be called again if another auto focus is - needed. - - @param none - @return NO_ERROR - @todo Define the error codes if the focus is not locked - - */ -status_t CameraHal::autoFocus() -{ - status_t ret = NO_ERROR; - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - - gettimeofday(&mStartFocus, NULL); - -#endif - - LOG_FUNCTION_NAME; - - android::AutoMutex lock(mLock); - - mMsgEnabled |= CAMERA_MSG_FOCUS; - - if ( NULL == mCameraAdapter ) - { - ret = -1; - goto EXIT; - } - - CameraAdapter::AdapterState state; - ret = mCameraAdapter->getState(state); - if (ret != NO_ERROR) - { - goto EXIT; - } - - if (state == CameraAdapter::AF_STATE) - { - CAMHAL_LOGI("Ignoring start-AF (already in progress)"); - goto EXIT; - } - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - - //pass the autoFocus timestamp along with the command to camera adapter - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS, ( int ) &mStartFocus); - -#else - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS); - -#endif - -EXIT: - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -/** - @brief Cancels auto-focus function. - - If the auto-focus is still in progress, this function will cancel it. - Whether the auto-focus is in progress or not, this function will return the - focus position to the default. If the camera does not support auto-focus, this is a no-op. - - - @param none - @return NO_ERROR If the cancel succeeded - @todo Define error codes if cancel didnt succeed - - */ -status_t CameraHal::cancelAutoFocus() -{ - LOG_FUNCTION_NAME; - - android::AutoMutex lock(mLock); - android::CameraParameters adapterParams = mParameters; - mMsgEnabled &= ~CAMERA_MSG_FOCUS; - - if( NULL != mCameraAdapter ) - { - adapterParams.set(TICameraParameters::KEY_AUTO_FOCUS_LOCK, android::CameraParameters::FALSE); - mCameraAdapter->setParameters(adapterParams); - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS); - mAppCallbackNotifier->flushEventQueue(); - } - - LOG_FUNCTION_NAME_EXIT; - return NO_ERROR; -} - -void CameraHal::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier) -{ - - LOG_FUNCTION_NAME; - - if ( NULL != mEventProvider ) - { - mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS); - delete mEventProvider; - mEventProvider = NULL; - } - - mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay); - if ( NULL == mEventProvider ) - { - CAMHAL_LOGEA("Error in creating EventProvider"); - } - else - { - mEventProvider->enableEventNotification(eventMask); - } - - LOG_FUNCTION_NAME_EXIT; -} - -void CameraHal::eventCallbackRelay(CameraHalEvent* event) -{ - LOG_FUNCTION_NAME; - - CameraHal *appcbn = ( CameraHal * ) (event->mCookie); - appcbn->eventCallback(event ); - - LOG_FUNCTION_NAME_EXIT; -} - -void CameraHal::eventCallback(CameraHalEvent* event) -{ - LOG_FUNCTION_NAME; - - LOG_FUNCTION_NAME_EXIT; -} - -status_t CameraHal::startImageBracketing() -{ - status_t ret = NO_ERROR; - CameraFrame frame; - CameraAdapter::BuffersDescriptor desc; - unsigned int max_queueable = 0; - - - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - - gettimeofday(&mStartCapture, NULL); - -#endif - - LOG_FUNCTION_NAME; - - if(!previewEnabled() && !mDisplayPaused) - { - LOG_FUNCTION_NAME_EXIT; - return NO_INIT; - } - - if ( !mBracketingEnabled ) - { - return ret; - } - - if ( NO_ERROR == ret ) - { - mBracketingRunning = true; - } - - if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) - { - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE, - ( int ) &frame, - ( mBracketRangeNegative + 1 )); - - if ( NO_ERROR != ret ) - { - CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret); - } - } - - if ( NO_ERROR == ret ) - { - if ( NULL != mAppCallbackNotifier.get() ) - { - mAppCallbackNotifier->setBurst(true); - } - } - - if ( NO_ERROR == ret ) - { - unsigned int bufferCount = mBracketRangeNegative + 1; - mParameters.getPictureSize(( int * ) &frame.mWidth, - ( int * ) &frame.mHeight); - - ret = allocImageBufs(frame.mWidth, - frame.mHeight, - frame.mLength, - mParameters.getPictureFormat(), - bufferCount, - &max_queueable); - mBracketRangeNegative = bufferCount - 1; - if ( NO_ERROR != ret ) - { - CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); - } - } - - if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) - { - - desc.mBuffers = mImageBuffers; - desc.mOffsets = mImageOffsets; - desc.mFd = mImageFd; - desc.mLength = mImageLength; - desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 ); - desc.mMaxQueueable = ( size_t) max_queueable; - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, - ( int ) &desc); - - if ( NO_ERROR == ret ) - { - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - - //pass capture timestamp along with the camera adapter command - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ), (int) &mStartCapture); - -#else - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 )); - -#endif - - } - } - - return ret; -} - -status_t CameraHal::stopImageBracketing() -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - if( !previewEnabled() ) - { - return NO_INIT; - } - - mBracketingRunning = false; - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE); - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -/** - @brief Take a picture. - - @param none - @return NO_ERROR If able to switch to image capture - @todo Define error codes if unable to switch to image capture - - */ -status_t CameraHal::takePicture(const char *params) -{ - android::AutoMutex lock(mLock); - return __takePicture(params); -} - -/** - @brief Internal function for getting a captured image. - shared by takePicture and reprocess. - @param none - @return NO_ERROR If able to switch to image capture - @todo Define error codes if unable to switch to image capture - - */ -status_t CameraHal::__takePicture(const char *params) -{ - // cancel AF state if needed (before any operation and mutex lock) - if (mCameraAdapter->getState() == CameraAdapter::AF_STATE) { - cancelAutoFocus(); - } - - status_t ret = NO_ERROR; - CameraFrame frame; - CameraAdapter::BuffersDescriptor desc; - int burst = -1; - const char *valstr = NULL; - unsigned int bufferCount = 1; - unsigned int max_queueable = 0; - unsigned int rawBufferCount = 1; - bool isCPCamMode = false; - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - - gettimeofday(&mStartCapture, NULL); - -#endif - - LOG_FUNCTION_NAME; - - if(!previewEnabled() && !mDisplayPaused) - { - LOG_FUNCTION_NAME_EXIT; - CAMHAL_LOGEA("Preview not started..."); - return NO_INIT; - } - - valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); - - isCPCamMode = valstr && !strcmp(valstr, TICameraParameters::CP_CAM_MODE); - - // return error if we are already capturing - // however, we can queue a capture when in cpcam mode - if ( ((mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE && - mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) || - (mCameraAdapter->getState() == CameraAdapter::VIDEO_CAPTURE_STATE && - mCameraAdapter->getNextState() != CameraAdapter::VIDEO_STATE)) && - !isCPCamMode) { - CAMHAL_LOGEA("Already capturing an image..."); - return NO_INIT; - } - - // we only support video snapshot if we are in video mode (recording hint is set) - if ( (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE) && - (valstr && strcmp(valstr, TICameraParameters::VIDEO_MODE)) ) { - CAMHAL_LOGEA("Trying to capture while recording without recording hint set..."); - return INVALID_OPERATION; - } - -#ifdef OMAP_ENHANCEMENT_CPCAM - // check if camera application is using shots parameters - // api. parameters set here override anything set using setParameters - // TODO(XXX): Just going to use legacy TI parameters for now. Need - // add new APIs in CameraHal to utilize ShotParameters later, so - // we don't have to parse through the whole set of parameters - // in camera adapter - if (strlen(params) > 0) { - android::ShotParameters shotParams; - const char *valStr; - const char *valExpComp, *valExpGain; - int valNum; - - android::String8 shotParams8(params); - - shotParams.unflatten(shotParams8); - mParameters.remove(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE); - mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE); - - valExpGain = shotParams.get(android::ShotParameters::KEY_EXP_GAIN_PAIRS); - valExpComp = shotParams.get(android::ShotParameters::KEY_EXP_COMPENSATION); - if (NULL != valExpComp) { - mParameters.set(TICameraParameters::KEY_EXP_BRACKETING_RANGE, valExpComp); - } else if (NULL != valExpGain) { - mParameters.set(TICameraParameters::KEY_EXP_GAIN_BRACKETING_RANGE, valExpGain); - } - - valNum = shotParams.getInt(android::ShotParameters::KEY_BURST); - if (valNum >= 0) { - mParameters.set(TICameraParameters::KEY_BURST, valNum); - burst = valNum; - } - - valStr = shotParams.get(android::ShotParameters::KEY_FLUSH_CONFIG); - if (valStr!= NULL) { - if ( 0 == strcmp(valStr, android::ShotParameters::TRUE) ) { - mParameters.set(TICameraParameters::KEY_FLUSH_SHOT_CONFIG_QUEUE, - android::CameraParameters::TRUE); - } else if ( 0 == strcmp(valStr, android::ShotParameters::FALSE) ) { - mParameters.set(TICameraParameters::KEY_FLUSH_SHOT_CONFIG_QUEUE, - android::CameraParameters::FALSE); - } - } - - mCameraAdapter->setParameters(mParameters); - } else -#endif - { - // TODO(XXX): Should probably reset burst and bracketing params - // when we remove legacy TI parameters implementation - } - - // if we are already in the middle of a capture...then we just need - // setParameters and start image capture to queue more shots - if (((mCameraAdapter->getState() & CameraAdapter::CAPTURE_STATE) == - CameraAdapter::CAPTURE_STATE) && - (mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE)) { -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - //pass capture timestamp along with the camera adapter command - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE, - (int) &mStartCapture); -#else - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE); -#endif - return ret; - } - - if ( !mBracketingRunning ) - { - // if application didn't set burst through ShotParameters - // then query from TICameraParameters - if ((burst == -1) && (NO_ERROR == ret)) { - burst = mParameters.getInt(TICameraParameters::KEY_BURST); - } - - //Allocate all buffers only in burst capture case - if ( burst > 0 ) { - // For CPCam mode...allocate for worst case burst - bufferCount = isCPCamMode || (burst > CameraHal::NO_BUFFERS_IMAGE_CAPTURE) ? - CameraHal::NO_BUFFERS_IMAGE_CAPTURE : burst; - - if (mBufferSourceAdapter_Out.get()) { - // TODO(XXX): Temporarily increase number of buffers we can allocate from ANW - // until faux-NPA mode is implemented - bufferCount = NO_BUFFERS_IMAGE_CAPTURE_SYSTEM_HEAP; - } - - if ( NULL != mAppCallbackNotifier.get() ) { - mAppCallbackNotifier->setBurst(true); - } - } else if ( mBracketingEnabled ) { - bufferCount = mBracketRangeNegative + 1; - if ( NULL != mAppCallbackNotifier.get() ) { - mAppCallbackNotifier->setBurst(false); - } - } else { - if ( NULL != mAppCallbackNotifier.get() ) { - mAppCallbackNotifier->setBurst(false); - } - } - - // pause preview during normal image capture - // do not pause preview if recording (video state) - if ( (NO_ERROR == ret) && (NULL != mDisplayAdapter.get()) ) { - if (mCameraAdapter->getState() != CameraAdapter::VIDEO_STATE) { - mDisplayPaused = true; - mPreviewEnabled = false; - ret = mDisplayAdapter->pauseDisplay(mDisplayPaused); - // since preview is paused we should stop sending preview frames too - if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) { - mAppCallbackNotifier->disableMsgType (CAMERA_MSG_PREVIEW_FRAME); - } - } - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - mDisplayAdapter->setSnapshotTimeRef(&mStartCapture); -#endif - } - - // if we taking video snapshot... - if ((NO_ERROR == ret) && (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE)) { - // enable post view frames if not already enabled so we can internally - // save snapshot frames for generating thumbnail - if((mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) == 0) { - mAppCallbackNotifier->enableMsgType(CAMERA_MSG_POSTVIEW_FRAME); - } - } - - if ( (NO_ERROR == ret) && (NULL != mCameraAdapter) ) - { - if ( NO_ERROR == ret ) - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE, - ( int ) &frame, - bufferCount); - - if ( NO_ERROR != ret ) - { - CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret); - } - } - - if ( NO_ERROR == ret ) - { - ret = allocImageBufs(frame.mAlignment, - frame.mHeight, - frame.mLength, - mParameters.getPictureFormat(), - bufferCount, - &max_queueable); - if ( NO_ERROR != ret ) - { - CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); - } - } - - if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) - { - desc.mBuffers = mImageBuffers; - desc.mOffsets = mImageOffsets; - desc.mFd = mImageFd; - desc.mLength = mImageLength; - desc.mCount = ( size_t ) bufferCount; - desc.mMaxQueueable = ( size_t ) max_queueable; - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, - ( int ) &desc); - } - if (mRawCapture) { - if ( NO_ERROR == ret ) { - CAMHAL_LOGDB("Raw capture buffers setup - %s", mParameters.getPictureFormat()); - ret = allocRawBufs(mParameters.getInt(TICameraParameters::RAW_WIDTH), - mParameters.getInt(TICameraParameters::RAW_HEIGHT), - android::CameraParameters::PIXEL_FORMAT_BAYER_RGGB, - rawBufferCount); - - if ( NO_ERROR != ret ) { - CAMHAL_LOGEB("allocRawBufs (for RAW capture) returned error 0x%x", ret); - } - } - - if ((NO_ERROR == ret) && ( NULL != mCameraAdapter )) { - desc.mBuffers = mVideoBuffers; - desc.mOffsets = mVideoOffsets; - desc.mFd = mVideoFd; - desc.mLength = mVideoLength; - desc.mCount = ( size_t ) rawBufferCount; - desc.mMaxQueueable = ( size_t ) rawBufferCount; - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_VIDEO_CAPTURE, - ( int ) &desc); - } - } - } - - if ((ret == NO_ERROR) && mBufferSourceAdapter_Out.get()) { - mBufferSourceAdapter_Out->enableDisplay(0, 0, NULL); - } - - if ((NO_ERROR == ret) && (NULL != mCameraAdapter)) { - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - - //pass capture timestamp along with the camera adapter command - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE, (int) &mStartCapture); - -#else - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE); - -#endif - - } - - return ret; -} - -/** - @brief Cancel a picture that was started with takePicture. - - Calling this method when no picture is being taken is a no-op. - - @param none - @return NO_ERROR If cancel succeeded. Cancel can succeed if image callback is not sent - @todo Define error codes - - */ -status_t CameraHal::cancelPicture( ) -{ - LOG_FUNCTION_NAME; - status_t ret = NO_ERROR; - - ret = signalEndImageCapture(); - return NO_ERROR; -} - -/** - @brief Return the camera parameters. - - @param none - @return Currently configured camera parameters - - */ -char* CameraHal::getParameters() -{ - android::String8 params_str8; - char* params_string; - const char * valstr = NULL; - - LOG_FUNCTION_NAME; - - if( NULL != mCameraAdapter ) - { - mCameraAdapter->getParameters(mParameters); - } - -#ifndef OMAP_TUNA - if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT)) != NULL ) { - if (!strcmp(TICameraParameters::S3D_TB_FULL, valstr)) { - mParameters.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES)); - } else if (!strcmp(TICameraParameters::S3D_SS_FULL, valstr)) { - mParameters.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES)); - } else if ((!strcmp(TICameraParameters::S3D_TB_SUBSAMPLED, valstr)) - || (!strcmp(TICameraParameters::S3D_SS_SUBSAMPLED, valstr))) { - mParameters.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PICTURE_SUBSAMPLED_SIZES)); - } - } - - if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT)) != NULL ) { - if (!strcmp(TICameraParameters::S3D_TB_FULL, valstr)) { - mParameters.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES)); - } else if (!strcmp(TICameraParameters::S3D_SS_FULL, valstr)) { - mParameters.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES)); - } else if ((!strcmp(TICameraParameters::S3D_TB_SUBSAMPLED, valstr)) - || (!strcmp(TICameraParameters::S3D_SS_SUBSAMPLED, valstr))) { - mParameters.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mParameters.get(TICameraParameters::KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES)); - } - } -#endif - - android::CameraParameters mParams = mParameters; - - // Handle RECORDING_HINT to Set/Reset Video Mode Parameters - valstr = mParameters.get(android::CameraParameters::KEY_RECORDING_HINT); - if(valstr != NULL) - { - if(strcmp(valstr, android::CameraParameters::TRUE) == 0) - { - //HACK FOR MMS MODE - resetPreviewRes(&mParams); - } - } - - // do not send internal parameters to upper layers - mParams.remove(TICameraParameters::KEY_RECORDING_HINT); - mParams.remove(TICameraParameters::KEY_AUTO_FOCUS_LOCK); - - params_str8 = mParams.flatten(); - - // camera service frees this string... - params_string = (char*) malloc(sizeof(char) * (params_str8.length()+1)); - strcpy(params_string, params_str8.string()); - - LOG_FUNCTION_NAME_EXIT; - - ///Return the current set of parameters - - return params_string; -} - - -#ifdef OMAP_ENHANCEMENT_CPCAM -/** - @brief Starts reprocessing operation. - */ -status_t CameraHal::reprocess(const char *params) -{ - status_t ret = NO_ERROR; - int bufferCount = 0; - CameraAdapter::BuffersDescriptor desc; - CameraBuffer *reprocBuffers = NULL; - android::ShotParameters shotParams; - - android::AutoMutex lock(mLock); - - LOG_FUNCTION_NAME; - - // 1. Get buffers - if (mBufferSourceAdapter_In.get()) { - reprocBuffers = mBufferSourceAdapter_In->getBufferList(&bufferCount); - } - - if (!reprocBuffers) { - CAMHAL_LOGE("Error: couldn't get input buffers for reprocess()"); - goto exit; - } - - // 2. Get buffer information and parse parameters - { - shotParams.setBurst(bufferCount); - } - - // 3. Give buffer to camera adapter - desc.mBuffers = reprocBuffers; - desc.mOffsets = 0; - desc.mFd = 0; - desc.mLength = 0; - desc.mCount = (size_t) bufferCount; - desc.mMaxQueueable = (size_t) bufferCount; - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_REPROCESS, (int) &desc); - if (ret != NO_ERROR) { - CAMHAL_LOGE("Error calling camera use buffers"); - goto exit; - } - - // 4. Start reprocessing - ret = mBufferSourceAdapter_In->enableDisplay(0, 0, NULL); - if (ret != NO_ERROR) { - CAMHAL_LOGE("Error enabling tap in point"); - goto exit; - } - - // 5. Start capturing - ret = __takePicture(shotParams.flatten().string()); - - exit: - return ret; -} - -/** - @brief Cancels current reprocessing operation - - */ -status_t CameraHal::cancel_reprocess( ) -{ - LOG_FUNCTION_NAME; - status_t ret = NO_ERROR; - - ret = signalEndImageCapture(); - return NO_ERROR; -} -#endif - - -void CameraHal::putParameters(char *parms) -{ - free(parms); -} - -/** - @brief Send command to camera driver. - - @param none - @return NO_ERROR If the command succeeds - @todo Define the error codes that this function can return - - */ -status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) -{ - status_t ret = NO_ERROR; - - LOG_FUNCTION_NAME; - - if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) ) - { - CAMHAL_LOGEA("No CameraAdapter instance"); - return -EINVAL; - } - - /////////////////////////////////////////////////////// - // Following commands do NOT need preview to be started - /////////////////////////////////////////////////////// - - switch ( cmd ) { -#ifdef ANDROID_API_JB_OR_LATER - case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG: - { - const bool enable = static_cast<bool>(arg1); - android::AutoMutex lock(mLock); - if ( enable ) { - mMsgEnabled |= CAMERA_MSG_FOCUS_MOVE; - } else { - mMsgEnabled &= ~CAMERA_MSG_FOCUS_MOVE; - } - } - return OK; -#endif - } - - if ( ret == OK && !previewEnabled() -#ifdef OMAP_ENHANCEMENT_VTC - && (cmd != CAMERA_CMD_PREVIEW_INITIALIZATION) -#endif - ) { - CAMHAL_LOGEA("Preview is not running"); - ret = -EINVAL; - } - - /////////////////////////////////////////////////////// - // Following commands NEED preview to be started - /////////////////////////////////////////////////////// - - if ( NO_ERROR == ret ) - { - switch(cmd) - { - case CAMERA_CMD_START_SMOOTH_ZOOM: - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_SMOOTH_ZOOM, arg1); - - break; - case CAMERA_CMD_STOP_SMOOTH_ZOOM: - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM); - break; - - case CAMERA_CMD_START_FACE_DETECTION: - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD); - - break; - - case CAMERA_CMD_STOP_FACE_DETECTION: - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD); - - break; - -#ifdef OMAP_ENHANCEMENT_VTC - case CAMERA_CMD_PREVIEW_DEINITIALIZATION: - if(mDisplayAdapter.get() != NULL) { - ///Stop the buffer display first - mDisplayAdapter->disableDisplay(); - } - - if(mAppCallbackNotifier.get() != NULL) { - //Stop the callback sending - mAppCallbackNotifier->stop(); - mAppCallbackNotifier->flushAndReturnFrames(); - mAppCallbackNotifier->stopPreviewCallbacks(); - } - - ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_DESTROY_TUNNEL); - mTunnelSetup = false; - - break; - - case CAMERA_CMD_PREVIEW_INITIALIZATION: - ret = cameraPreviewInitialization(); - - break; -#endif - - default: - break; - }; - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -/** - @brief Release the hardware resources owned by this object. - - Note that this is *not* done in the destructor. - - @param none - @return none - - */ -void CameraHal::release() -{ - LOG_FUNCTION_NAME; - ///@todo Investigate on how release is used by CameraService. Vaguely remember that this is called - ///just before CameraHal object destruction - deinitialize(); - LOG_FUNCTION_NAME_EXIT; -} - - -/** - @brief Dump state of the camera hardware - - @param[in] fd File descriptor - @param[in] args Arguments - @return NO_ERROR Dump succeeded - @todo Error codes for dump fail - - */ -status_t CameraHal::dump(int fd) const -{ - LOG_FUNCTION_NAME; - ///Implement this method when the h/w dump function is supported on Ducati side - return NO_ERROR; -} - -/*-------------Camera Hal Interface Method definitions ENDS here--------------------*/ - - - - -/*-------------Camera Hal Internal Method definitions STARTS here--------------------*/ - -/** - @brief Constructor of CameraHal - - Member variables are initialized here. No allocations should be done here as we - don't use c++ exceptions in the code. - - */ -CameraHal::CameraHal(int cameraId) -{ - LOG_FUNCTION_NAME; - - ///Initialize all the member variables to their defaults - mPreviewEnabled = false; - mPreviewBuffers = NULL; - mImageBuffers = NULL; - mBufProvider = NULL; - mPreviewStartInProgress = false; - mVideoBuffers = NULL; - mVideoBufProvider = NULL; - mRecordingEnabled = false; - mDisplayPaused = false; - mSetPreviewWindowCalled = false; - mMsgEnabled = 0; - mAppCallbackNotifier = NULL; - mMemoryManager = NULL; - mCameraAdapter = NULL; - mBracketingEnabled = false; - mBracketingRunning = false; - mEventProvider = NULL; - mBracketRangePositive = 1; - mBracketRangeNegative = 1; - mMaxZoomSupported = 0; - mShutterEnabled = true; - mMeasurementEnabled = false; - mPreviewDataBuffers = NULL; - mCameraProperties = NULL; - mCurrentTime = 0; - mFalsePreview = 0; - mImageOffsets = NULL; - mImageLength = 0; - mImageFd = 0; - mVideoOffsets = NULL; - mVideoFd = 0; - mVideoLength = 0; - mPreviewDataOffsets = NULL; - mPreviewDataFd = 0; - mPreviewDataLength = 0; - mPreviewFd = 0; - mPreviewWidth = 0; - mPreviewHeight = 0; - mPreviewLength = 0; - mPreviewOffsets = NULL; - mPreviewRunning = 0; - mPreviewStateOld = 0; - mRecordingEnabled = 0; - mRecordEnabled = 0; - mSensorListener = NULL; - mVideoWidth = 0; - mVideoHeight = 0; -#ifdef OMAP_ENHANCEMENT_VTC - mVTCUseCase = false; - mTunnelSetup = false; -#endif - mPreviewInitializationDone = false; - -#ifdef OMAP_ENHANCEMENT_CPCAM - mExtendedPreviewStreamOps = 0; -#endif - - //These values depends on the sensor characteristics - - mRawCapture = false; - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS - - //Initialize the CameraHAL constructor timestamp, which is used in the - // PPM() method as time reference if the user does not supply one. - gettimeofday(&ppm_start, NULL); - -#endif - - mCameraIndex = cameraId; - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Destructor of CameraHal - - This function simply calls deinitialize() to free up memory allocate during construct - phase - */ -CameraHal::~CameraHal() -{ - LOG_FUNCTION_NAME; - - ///Call de-initialize here once more - it is the last chance for us to relinquish all the h/w and s/w resources - deinitialize(); - - if ( NULL != mEventProvider ) - { - mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS); - delete mEventProvider; - mEventProvider = NULL; - } - - /// Free the callback notifier - mAppCallbackNotifier.clear(); - - /// Free the display adapter - mDisplayAdapter.clear(); - - if ( NULL != mCameraAdapter ) { - int strongCount = mCameraAdapter->getStrongCount(); - - mCameraAdapter->decStrong(mCameraAdapter); - - mCameraAdapter = NULL; - } - - freeImageBufs(); - freeRawBufs(); - - /// Free the memory manager - mMemoryManager.clear(); - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Initialize the Camera HAL - - Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager - - @param None - @return NO_ERROR - On success - NO_MEMORY - On failure to allocate memory for any of the objects - @remarks Camera Hal internal function - - */ - -status_t CameraHal::initialize(CameraProperties::Properties* properties) -{ - LOG_FUNCTION_NAME; - - int sensor_index = 0; - const char* sensor_name = NULL; - - ///Initialize the event mask used for registering an event provider for AppCallbackNotifier - ///Currently, registering all events as to be coming from CameraAdapter - int32_t eventMask = CameraHalEvent::ALL_EVENTS; - - // Get my camera properties - mCameraProperties = properties; - - if(!mCameraProperties) - { - goto fail_loop; - } - - // Dump the properties of this Camera - // will only print if DEBUG macro is defined - mCameraProperties->dump(); - - if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 ) - { - sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)); - } - - if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_NAME)) != 0 ) { - sensor_name = mCameraProperties->get(CameraProperties::CAMERA_NAME); - } - CAMHAL_LOGDB("Sensor index= %d; Sensor name= %s", sensor_index, sensor_name); - - if (strcmp(sensor_name, V4L_CAMERA_NAME_USB) == 0) { -#ifdef V4L_CAMERA_ADAPTER - mCameraAdapter = V4LCameraAdapter_Factory(sensor_index); -#endif - } - else { -#ifdef OMX_CAMERA_ADAPTER - mCameraAdapter = OMXCameraAdapter_Factory(sensor_index); -#endif - } - - if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties)!=NO_ERROR)) - { - CAMHAL_LOGEA("Unable to create or initialize CameraAdapter"); - mCameraAdapter = NULL; - goto fail_loop; - } - - mCameraAdapter->incStrong(mCameraAdapter); - mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this); - mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this); - - if(!mAppCallbackNotifier.get()) - { - /// Create the callback notifier - mAppCallbackNotifier = new AppCallbackNotifier(); - if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR)) - { - CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier"); - goto fail_loop; - } - } - - if(!mMemoryManager.get()) - { - /// Create Memory Manager - mMemoryManager = new MemoryManager(); - if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR)) - { - CAMHAL_LOGEA("Unable to create or initialize MemoryManager"); - goto fail_loop; - } - } - - ///Setup the class dependencies... - - ///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from. - ///CameraAdapter is the one which provides those events - ///Set it as the frame and event providers for AppCallbackNotifier - ///@remarks setEventProvider API takes in a bit mask of events for registering a provider for the different events - /// That way, if events can come from DisplayAdapter in future, we will be able to add it as provider - /// for any event - mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter); - mAppCallbackNotifier->setFrameProvider(mCameraAdapter); - - ///Any dynamic errors that happen during the camera use case has to be propagated back to the application - ///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application - ///Set it as the error handler for CameraAdapter - mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get()); - - ///Start the callback notifier - if(mAppCallbackNotifier->start() != NO_ERROR) - { - CAMHAL_LOGEA("Couldn't start AppCallbackNotifier"); - goto fail_loop; - } - - CAMHAL_LOGDA("Started AppCallbackNotifier.."); - mAppCallbackNotifier->setMeasurements(mMeasurementEnabled); - - ///Initialize default parameters - initDefaultParameters(); - - - if ( setParameters(mParameters) != NO_ERROR ) - { - CAMHAL_LOGEA("Failed to set default parameters?!"); - } - - // register for sensor events - mSensorListener = new SensorListener(); - if (mSensorListener.get()) { - if (mSensorListener->initialize() == NO_ERROR) { - mSensorListener->setCallbacks(orientation_cb, this); - mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION); - } else { - CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing"); - mSensorListener.clear(); - mSensorListener = NULL; - } - } - - LOG_FUNCTION_NAME_EXIT; - - return NO_ERROR; - - fail_loop: - - ///Free up the resources because we failed somewhere up - deinitialize(); - LOG_FUNCTION_NAME_EXIT; - - return NO_MEMORY; - -} - -bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions) -{ - bool ret = false; - status_t status = NO_ERROR; - char tmpBuffer[MAX_PROP_VALUE_LENGTH]; - char *pos = NULL; - - LOG_FUNCTION_NAME; - - if (NULL == supportedResolutions) { - CAMHAL_LOGEA("Invalid supported resolutions string"); - goto exit; - } - - status = snprintf(tmpBuffer, MAX_PROP_VALUE_LENGTH - 1, "%dx%d", width, height); - if (0 > status) { - CAMHAL_LOGEA("Error encountered while generating validation string"); - goto exit; - } - - ret = isParameterValid(tmpBuffer, supportedResolutions); - -exit: - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -bool CameraHal::isFpsRangeValid(int fpsMin, int fpsMax, const char *supportedFpsRanges) -{ - bool ret = false; - char supported[MAX_PROP_VALUE_LENGTH]; - char *pos; - int suppFpsRangeArray[2]; - int i = 0; - - LOG_FUNCTION_NAME; - - if ( NULL == supportedFpsRanges ) { - CAMHAL_LOGEA("Invalid supported FPS ranges string"); - return false; - } - - if (fpsMin <= 0 || fpsMax <= 0 || fpsMin > fpsMax) { - return false; - } - - strncpy(supported, supportedFpsRanges, MAX_PROP_VALUE_LENGTH); - pos = strtok(supported, " (,)"); - while (pos != NULL) { - suppFpsRangeArray[i] = atoi(pos); - if (i++) { - if (fpsMin >= suppFpsRangeArray[0] && fpsMax <= suppFpsRangeArray[1]) { - ret = true; - break; - } - i = 0; - } - pos = strtok(NULL, " (,)"); - } - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -bool CameraHal::isParameterValid(const char *param, const char *supportedParams) -{ - bool ret = false; - char *pos; - char supported[MAX_PROP_VALUE_LENGTH]; - - LOG_FUNCTION_NAME; - - if (NULL == supportedParams) { - CAMHAL_LOGEA("Invalid supported parameters string"); - goto exit; - } - - if (NULL == param) { - CAMHAL_LOGEA("Invalid parameter string"); - goto exit; - } - - strncpy(supported, supportedParams, MAX_PROP_VALUE_LENGTH - 1); - - pos = strtok(supported, ","); - while (pos != NULL) { - if (!strcmp(pos, param)) { - ret = true; - break; - } - pos = strtok(NULL, ","); - } - -exit: - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -bool CameraHal::isParameterValid(int param, const char *supportedParams) -{ - bool ret = false; - status_t status; - char tmpBuffer[MAX_PROP_VALUE_LENGTH]; - - LOG_FUNCTION_NAME; - - if (NULL == supportedParams) { - CAMHAL_LOGEA("Invalid supported parameters string"); - goto exit; - } - - status = snprintf(tmpBuffer, MAX_PROP_VALUE_LENGTH - 1, "%d", param); - if (0 > status) { - CAMHAL_LOGEA("Error encountered while generating validation string"); - goto exit; - } - - ret = isParameterValid(tmpBuffer, supportedParams); - -exit: - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -status_t CameraHal::doesSetParameterNeedUpdate(const char* new_param, const char* old_param, bool& update) { - if (!new_param || !old_param) { - return -EINVAL; - } - - // if params mismatch we should update parameters for camera adapter - if ((strcmp(new_param, old_param) != 0)) { - update = true; - } - - return NO_ERROR; -} - -status_t CameraHal::parseResolution(const char *resStr, int &width, int &height) -{ - status_t ret = NO_ERROR; - char *ctx, *pWidth, *pHeight; - const char *sep = "x"; - - LOG_FUNCTION_NAME; - - if ( NULL == resStr ) - { - return -EINVAL; - } - - //This fixes "Invalid input resolution" - char *resStr_copy = (char *)malloc(strlen(resStr) + 1); - if ( NULL != resStr_copy ) - { - strcpy(resStr_copy, resStr); - pWidth = strtok_r(resStr_copy, sep, &ctx); - - if ( NULL != pWidth ) - { - width = atoi(pWidth); - } - else - { - CAMHAL_LOGEB("Invalid input resolution %s", resStr); - ret = -EINVAL; - } - } - - if ( NO_ERROR == ret ) - { - pHeight = strtok_r(NULL, sep, &ctx); - - if ( NULL != pHeight ) - { - height = atoi(pHeight); - } - else - { - CAMHAL_LOGEB("Invalid input resolution %s", resStr); - ret = -EINVAL; - } - } - - free(resStr_copy); - resStr_copy = NULL; - - LOG_FUNCTION_NAME_EXIT; - - return ret; -} - -void CameraHal::insertSupportedParams() -{ - LOG_FUNCTION_NAME; - - android::CameraParameters &p = mParameters; - - ///Set the name of the camera - p.set(TICameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME)); - - mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES)); - - p.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES)); - p.set(android::CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS)); - p.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)); - p.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); -#ifndef OMAP_TUNA - p.set(TICameraParameters::KEY_SUPPORTED_PICTURE_SUBSAMPLED_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SUBSAMPLED_SIZES)); - p.set(TICameraParameters::KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIDEBYSIDE_SIZES)); - p.set(TICameraParameters::KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_TOPBOTTOM_SIZES)); - p.set(TICameraParameters::KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SUBSAMPLED_SIZES)); - p.set(TICameraParameters::KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES)); - p.set(TICameraParameters::KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_TOPBOTTOM_SIZES)); -#endif - p.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)); - p.set(TICameraParameters::KEY_FRAMERATES_EXT_SUPPORTED, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES_EXT)); - p.set(android::CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED)); - p.set(TICameraParameters::KEY_FRAMERATE_RANGES_EXT_SUPPORTED, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_EXT_SUPPORTED)); - p.set(android::CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES)); - p.set(android::CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE)); - p.set(android::CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS)); - p.set(android::CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES)); - p.set(android::CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES)); - p.set(android::CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES)); - p.set(android::CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING)); - p.set(android::CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX)); - p.set(android::CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN)); - p.set(android::CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP)); - p.set(TICameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MIN, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_MIN)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_MAX, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_MAX)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_EXPOSURE_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_STEP)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_MIN)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_MAX)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_STEP)); - p.set(TICameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES)); - p.set(android::CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS)); - p.set(android::CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES)); - p.set(android::CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED)); - p.set(android::CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED)); - p.set(TICameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES)); -#ifndef OMAP_TUNA - p.set(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT_VALUES, mCameraProperties->get(CameraProperties::S3D_PRV_FRAME_LAYOUT_VALUES)); - p.set(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT_VALUES, mCameraProperties->get(CameraProperties::S3D_CAP_FRAME_LAYOUT_VALUES)); -#endif - p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE_VALUES, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE_VALUES)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_MIN)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_MAX)); - p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_STEP)); - p.set(android::CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED)); - p.set(TICameraParameters::KEY_VNF_SUPPORTED, mCameraProperties->get(CameraProperties::VNF_SUPPORTED)); - p.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED)); - p.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED)); - p.set(android::CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED)); -#ifndef OMAP_TUNA - p.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED, mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED)); -#endif - p.set(TICameraParameters::KEY_CAP_MODE_VALUES, mCameraProperties->get(CameraProperties::CAP_MODE_VALUES)); - - LOG_FUNCTION_NAME_EXIT; - -} - -void CameraHal::initDefaultParameters() -{ - //Purpose of this function is to initialize the default current and supported parameters for the currently - //selected camera. - - android::CameraParameters &p = mParameters; - int currentRevision, adapterRevision; - status_t ret = NO_ERROR; - int width, height; - const char *valstr; - - LOG_FUNCTION_NAME; - - insertSupportedParams(); - - ret = parseResolution(mCameraProperties->get(CameraProperties::PREVIEW_SIZE), width, height); - - if ( NO_ERROR == ret ) - { - p.setPreviewSize(width, height); - } - else - { - p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT); - } - - ret = parseResolution(mCameraProperties->get(CameraProperties::PICTURE_SIZE), width, height); - - if ( NO_ERROR == ret ) - { - p.setPictureSize(width, height); - } - else - { - p.setPictureSize(PICTURE_WIDTH, PICTURE_HEIGHT); - } - - ret = parseResolution(mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_SIZE), width, height); - - if ( NO_ERROR == ret ) - { - p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); - p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); - } - else - { - p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH); - p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT); - } - - //Insert default values - p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE))); - p.set(android::CameraParameters::KEY_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE)); - p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT)); - p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT)); - p.set(android::CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY)); - p.set(android::CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE)); - p.set(android::CameraParameters::KEY_EFFECT, mCameraProperties->get(CameraProperties::EFFECT)); - p.set(android::CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING)); - p.set(android::CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE)); - p.set(android::CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE)); - p.set(android::CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION)); - p.set(android::CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE)); - p.set(android::CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM)); - p.set(TICameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST)); - p.set(TICameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION)); - p.set(TICameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS)); - p.set(TICameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS)); - p.set(TICameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE)); - p.set(TICameraParameters::KEY_MANUAL_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_MIN)); - p.set(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_EXPOSURE_MIN)); - p.set(TICameraParameters::KEY_MANUAL_GAIN_ISO, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_MIN)); - p.set(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_GAIN_ISO_MIN)); - p.set(TICameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE)); - p.set(TICameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP)); - p.set(TICameraParameters::KEY_GBCE, mCameraProperties->get(CameraProperties::GBCE)); - p.set(TICameraParameters::KEY_GBCE_SUPPORTED, mCameraProperties->get(CameraProperties::SUPPORTED_GBCE)); - p.set(TICameraParameters::KEY_GLBCE, mCameraProperties->get(CameraProperties::GLBCE)); - p.set(TICameraParameters::KEY_GLBCE_SUPPORTED, mCameraProperties->get(CameraProperties::SUPPORTED_GLBCE)); -#ifndef OMAP_TUNA - p.set(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT, mCameraProperties->get(CameraProperties::S3D_PRV_FRAME_LAYOUT)); - p.set(TICameraParameters::KEY_S3D_CAP_FRAME_LAYOUT, mCameraProperties->get(CameraProperties::S3D_CAP_FRAME_LAYOUT)); -#endif - p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE)); - p.set(TICameraParameters::KEY_MANUAL_CONVERGENCE, mCameraProperties->get(CameraProperties::MANUAL_CONVERGENCE)); - p.set(android::CameraParameters::KEY_VIDEO_STABILIZATION, mCameraProperties->get(CameraProperties::VSTAB)); - p.set(TICameraParameters::KEY_VNF, mCameraProperties->get(CameraProperties::VNF)); - p.set(android::CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH)); - p.set(android::CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE)); - p.set(android::CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE)); - p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION)); - p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE)); - p.set(TICameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL)); - p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY)); - p.set(android::CameraParameters::KEY_VIDEO_FRAME_FORMAT, "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar"); - p.set(android::CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES)); - p.set(android::CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES)); -#ifndef OMAP_TUNA - p.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION, mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION)); -#endif - // Only one area a.k.a Touch AF for now. - // TODO: Add support for multiple focus areas. - p.set(android::CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS)); - p.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK)); - p.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK)); - p.set(android::CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS)); - p.set(TICameraParameters::RAW_WIDTH, mCameraProperties->get(CameraProperties::RAW_WIDTH)); - p.set(TICameraParameters::RAW_HEIGHT,mCameraProperties->get(CameraProperties::RAW_HEIGHT)); - -#ifndef OMAP_TUNA - // TI extensions for enable/disable algos - // Hadcoded for now - p.set(TICameraParameters::KEY_ALGO_FIXED_GAMMA, android::CameraParameters::TRUE); - p.set(TICameraParameters::KEY_ALGO_NSF1, android::CameraParameters::TRUE); - p.set(TICameraParameters::KEY_ALGO_NSF2, android::CameraParameters::TRUE); - p.set(TICameraParameters::KEY_ALGO_SHARPENING, android::CameraParameters::TRUE); - p.set(TICameraParameters::KEY_ALGO_THREELINCOLORMAP, android::CameraParameters::TRUE); - p.set(TICameraParameters::KEY_ALGO_GIC, android::CameraParameters::TRUE); -#endif - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Stop a previously started preview. - @param none - @return none - - */ -void CameraHal::forceStopPreview() -{ - LOG_FUNCTION_NAME; - - // stop bracketing if it is running - if ( mBracketingRunning ) { - stopImageBracketing(); - } - - if(mDisplayAdapter.get() != NULL) { - ///Stop the buffer display first - mDisplayAdapter->disableDisplay(); - } - - if(mAppCallbackNotifier.get() != NULL) { - //Stop the callback sending - mAppCallbackNotifier->stop(); - mAppCallbackNotifier->flushAndReturnFrames(); - mAppCallbackNotifier->stopPreviewCallbacks(); - } - - if ( NULL != mCameraAdapter ) { - // only need to send these control commands to state machine if we are - // passed the LOADED_PREVIEW_STATE - if (mCameraAdapter->getState() > CameraAdapter::LOADED_PREVIEW_STATE) { - // according to javadoc...FD should be stopped in stopPreview - // and application needs to call startFaceDection again - // to restart FD - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD); - } - - mCameraAdapter->rollbackToInitializedState(); - - } - - freePreviewBufs(); - freePreviewDataBufs(); - - mPreviewEnabled = false; - mDisplayPaused = false; - mPreviewStartInProgress = false; - - LOG_FUNCTION_NAME_EXIT; -} - -/** - @brief Deallocates memory for all the resources held by Camera HAL. - - Frees the following objects- CameraAdapter, AppCallbackNotifier, DisplayAdapter, - and Memory Manager - - @param none - @return none - - */ -void CameraHal::deinitialize() -{ - LOG_FUNCTION_NAME; - - if ( mPreviewEnabled || mDisplayPaused ) { - forceStopPreview(); - } - - mSetPreviewWindowCalled = false; - - if (mSensorListener.get()) { - mSensorListener->disableSensor(SensorListener::SENSOR_ORIENTATION); - mSensorListener.clear(); - mSensorListener = NULL; - } - - LOG_FUNCTION_NAME_EXIT; - -} - -status_t CameraHal::storeMetaDataInBuffers(bool enable) -{ - LOG_FUNCTION_NAME; - - return mAppCallbackNotifier->useMetaDataBufferMode(enable); - - LOG_FUNCTION_NAME_EXIT; -} - -void CameraHal::getPreferredPreviewRes(int *width, int *height) -{ - LOG_FUNCTION_NAME; - - // We request Ducati for a higher resolution so preview looks better and then downscale the frame before the callback. - // TODO: This should be moved to configuration constants and boolean flag whether to provide such optimization - // Also consider providing this configurability of the desired display resolution from the application - if ( ( *width == 320 ) && ( *height == 240 ) ) { - *width = 640; - *height = 480; - } else if ( ( *width == 176 ) && ( *height == 144 ) ) { - *width = 704; - *height = 576; - } - - LOG_FUNCTION_NAME_EXIT; -} - -void CameraHal::resetPreviewRes(android::CameraParameters *params) -{ - LOG_FUNCTION_NAME; - - if ( (mVideoWidth <= 320) && (mVideoHeight <= 240)){ - params->setPreviewSize(mVideoWidth, mVideoHeight); - } - - LOG_FUNCTION_NAME_EXIT; -} - -void * -camera_buffer_get_omx_ptr (CameraBuffer *buffer) -{ - CAMHAL_LOGSV("buffer_type %d opaque %p", buffer->type, buffer->opaque); - - if (buffer->type == CAMERA_BUFFER_ANW) { - buffer_handle_t *handle = (buffer_handle_t *)buffer->opaque; - CAMHAL_LOGSV("anw %08x", *handle); - return (void *)*handle; - } else if (buffer->type == CAMERA_BUFFER_ION) { - return (void *)buffer->fd; - } else { - CAMHAL_LOGSV("other %08x", buffer->opaque); - return (void *)buffer->opaque; - } -} - -} // namespace Camera -} // namespace Ti |