diff options
Diffstat (limited to 'camera/CameraHal.cpp')
| -rw-r--r-- | camera/CameraHal.cpp | 2542 |
1 files changed, 1639 insertions, 903 deletions
diff --git a/camera/CameraHal.cpp b/camera/CameraHal.cpp index 7a5fdc0..71ba1bb 100644 --- a/camera/CameraHal.cpp +++ b/camera/CameraHal.cpp @@ -21,10 +21,9 @@ * */ -#define LOG_TAG "CameraHAL" - #include "CameraHal.h" #include "ANativeWindowDisplayAdapter.h" +#include "BufferSourceAdapter.h" #include "TICameraParameters.h" #include "CameraProperties.h" #include <cutils/properties.h> @@ -32,9 +31,11 @@ #include <poll.h> #include <math.h> -namespace android { +namespace Ti { +namespace Camera { -extern "C" CameraAdapter* CameraAdapter_Factory(size_t); +extern "C" CameraAdapter* OMXCameraAdapter_Factory(size_t); +extern "C" CameraAdapter* V4LCameraAdapter_Factory(size_t); /*****************************************************************************/ @@ -43,13 +44,74 @@ extern "C" CameraAdapter* CameraAdapter_Factory(size_t); //// Currently, they are hard-coded const int CameraHal::NO_BUFFERS_PREVIEW = MAX_CAMERA_BUFFERS; -const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE = 2; +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::EVENT_BIT_FIELD_POSITION = 0; 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; @@ -110,6 +172,10 @@ void CameraHal::setCallbacks(camera_notify_callback notify_cb, user); } + if ( NULL != mCameraAdapter ) { + mCameraAdapter->setSharedAllocator(get_memory); + } + LOG_FUNCTION_NAME_EXIT; } @@ -131,10 +197,13 @@ void CameraHal::enableMsgType(int32_t msgType) // ignoring enable focus message from camera service // we will enable internally in autoFocus call - msgType &= ~(CAMERA_MSG_FOCUS | CAMERA_MSG_FOCUS_MOVE); + msgType &= ~CAMERA_MSG_FOCUS; +#ifdef ANDROID_API_JB_OR_LATER + msgType &= ~CAMERA_MSG_FOCUS_MOVE; +#endif { - Mutex::Autolock lock(mLock); + android::AutoMutex lock(mLock); mMsgEnabled |= msgType; } @@ -173,7 +242,7 @@ void CameraHal::disableMsgType(int32_t msgType) LOG_FUNCTION_NAME; { - Mutex::Autolock lock(mLock); + android::AutoMutex lock(mLock); mMsgEnabled &= ~msgType; } @@ -201,10 +270,18 @@ void CameraHal::disableMsgType(int32_t msgType) */ int CameraHal::msgTypeEnabled(int32_t msgType) { + int32_t msgEnabled = 0; + LOG_FUNCTION_NAME; - Mutex::Autolock lock(mLock); + android::AutoMutex lock(mLock); + + msgEnabled = mMsgEnabled; + if (!previewEnabled() && !mPreviewInitializationDone) { + msgEnabled &= ~(CAMERA_MSG_PREVIEW_FRAME | CAMERA_MSG_PREVIEW_METADATA); + } + LOG_FUNCTION_NAME_EXIT; - return (mMsgEnabled & msgType); + return (msgEnabled & msgType); } /** @@ -218,11 +295,11 @@ int CameraHal::msgTypeEnabled(int32_t msgType) int CameraHal::setParameters(const char* parameters) { - LOG_FUNCTION_NAME; + LOG_FUNCTION_NAME; - CameraParameters params; + android::CameraParameters params; - String8 str_params(parameters); + android::String8 str_params(parameters); params.unflatten(str_params); LOG_FUNCTION_NAME_EXIT; @@ -238,77 +315,99 @@ int CameraHal::setParameters(const char* parameters) @todo Define error codes */ -int CameraHal::setParameters(const CameraParameters& params) +int CameraHal::setParameters(const android::CameraParameters& params) { - LOG_FUNCTION_NAME; + LOG_FUNCTION_NAME; int w, h; - int w_orig, h_orig; - int framerate,minframerate; + int framerate; int maxFPS, minFPS; const char *valstr = NULL; int varint = 0; status_t ret = NO_ERROR; - CameraParameters oldParams = mParameters; // Needed for KEY_RECORDING_HINT bool restartPreviewRequired = false; bool updateRequired = false; - bool videoMode = false; + android::CameraParameters oldParams = mParameters; + +#ifdef V4L_CAMERA_ADAPTER + if (strcmp (V4L_CAMERA_NAME_USB, mCameraProperties->get(CameraProperties::CAMERA_NAME)) == 0 ) { + updateRequired = true; + } +#endif { - Mutex::Autolock lock(mLock); + android::AutoMutex lock(mLock); ///Ensure that preview is not enabled when the below parameters are changed. if(!previewEnabled()) { - - CAMHAL_LOGDB("PreviewFormat %s", params.getPreviewFormat()); - 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.Supported: %s", mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); + CAMHAL_LOGEB("Invalid preview format: %s. Supported: %s", valstr, + mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); return BAD_VALUE; } } - varint = params.getInt(TICameraParameters::KEY_VNF); - valstr = params.get(TICameraParameters::KEY_VNF); - if ( valstr != NULL ) { - if ( ( varint == 0 ) || ( varint == 1 ) ) { - CAMHAL_LOGDB("VNF set %s", valstr); - mParameters.set(TICameraParameters::KEY_VNF, varint); - } else { + 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(CameraParameters::KEY_VIDEO_STABILIZATION)) != NULL) { + 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), - CameraParameters::TRUE) == 0) { - CAMHAL_LOGDB("VSTAB %s",valstr); - mParameters.set(CameraParameters::KEY_VIDEO_STABILIZATION, valstr); - } else if (strcmp(valstr, CameraParameters::TRUE) == 0) { + 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(CameraParameters::KEY_VIDEO_STABILIZATION, - CameraParameters::FALSE); + 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; + } - if( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL) - { - CAMHAL_LOGDB("Capture mode set %s", valstr); - mParameters.set(TICameraParameters::KEY_CAP_MODE, 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))) { @@ -320,122 +419,94 @@ int CameraHal::setParameters(const CameraParameters& params) } } -#ifdef OMAP_ENHANCEMENT +#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((valstr = params.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) - { - CAMHAL_LOGDB("Stereo 3D->2D Preview mode is %s", params.get(TICameraParameters::KEY_S3D2D_PREVIEW)); - mParameters.set(TICameraParameters::KEY_S3D2D_PREVIEW, valstr); + 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_AUTOCONVERGENCE)) != NULL) - { - CAMHAL_LOGDB("AutoConvergence mode is %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE)); - mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr); + if ((valstr = params.get(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT)) != NULL ) { + mParameters.set(TICameraParameters::KEY_VIDEO_ENCODER_SLICE_HEIGHT, valstr); } + } #endif - } - params.getPreviewSize(&w, &h); - if (w == -1 && h == -1) { - CAMHAL_LOGEA("Unable to get preview size"); - return BAD_VALUE; - } - - int oldWidth, oldHeight; - mParameters.getPreviewSize(&oldWidth, &oldHeight); - -#ifdef OMAP_ENHANCEMENT - - int orientation =0; - if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL) - { - CAMHAL_LOGDB("Sensor Orientation is set to %s", params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)); - mParameters.set(TICameraParameters::KEY_SENSOR_ORIENTATION, valstr); - orientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION); - } - - if(orientation ==90 || orientation ==270) - { - if ( !isResolutionValid(h,w, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) - { - CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h); - return BAD_VALUE; - } - else - { - mParameters.setPreviewSize(w, h); - mVideoWidth = w; - mVideoHeight = h; - } - } - else - { - if ( !isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) - { - CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h); - return BAD_VALUE; - } - else + if ( (valstr = params.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT)) != NULL ) + { + if (strcmp(valstr, mParameters.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT))) { - mParameters.setPreviewSize(w, h); + CAMHAL_LOGDB("Stereo 3D preview image layout is %s", valstr); + mParameters.set(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT, valstr); + restartPreviewRequired = true; } - } - + } -#else +#ifdef OMAP_ENHANCEMENT + int orientation =0; + if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL) + { + doesSetParameterNeedUpdate(valstr, + mParameters.get(TICameraParameters::KEY_SENSOR_ORIENTATION), + updateRequired); - if ( !isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) { - CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h); - return BAD_VALUE; - } else { - mParameters.setPreviewSize(w, h); - } + 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 - if ( ( oldWidth != w ) || ( oldHeight != h ) ) { - restartPreviewRequired |= true; + params.getPreviewSize(&w, &h); + if (w == -1 && h == -1) { + CAMHAL_LOGEA("Unable to get preview size"); + return BAD_VALUE; } - CAMHAL_LOGDB("PreviewResolution by App %d x %d", w, h); + mVideoWidth = w; + mVideoHeight = h; // Handle RECORDING_HINT to Set/Reset Video Mode Parameters - valstr = params.get(CameraParameters::KEY_RECORDING_HINT); + valstr = params.get(android::CameraParameters::KEY_RECORDING_HINT); if(valstr != NULL) { - if(strcmp(valstr, CameraParameters::TRUE) == 0) + CAMHAL_LOGDB("Recording Hint is set to %s", valstr); + if(strcmp(valstr, android::CameraParameters::TRUE) == 0) { - CAMHAL_LOGDB("Recording Hint is set to %s", valstr); - mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr); - videoMode = true; - int w, h; - - params.getPreviewSize(&w, &h); - CAMHAL_LOGVB("%s Preview Width=%d Height=%d\n", __FUNCTION__, w, h); - //HACK FOR MMS - mVideoWidth = w; - mVideoHeight = h; - CAMHAL_LOGVB("%s Video Width=%d Height=%d\n", __FUNCTION__, mVideoWidth, mVideoHeight); - - setPreferredPreviewRes(w, h); - mParameters.getPreviewSize(&w, &h); - CAMHAL_LOGVB("%s Preview Width=%d Height=%d\n", __FUNCTION__, w, h); - //Avoid restarting preview for MMS HACK - if ((w != mVideoWidth) && (h != mVideoHeight)) - { - restartPreviewRequired = false; - } + 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, CameraParameters::FALSE) == 0) + else if(strcmp(valstr, android::CameraParameters::FALSE) == 0) { - CAMHAL_LOGDB("Recording Hint is set to %s", valstr); - mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr); + mParameters.set(android::CameraParameters::KEY_RECORDING_HINT, valstr); restartPreviewRequired |= resetVideoModeParameters(); - params.getPreviewSize(&mVideoWidth, &mVideoHeight); } else { @@ -450,52 +521,95 @@ int CameraHal::setParameters(const CameraParameters& params) // 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(CameraParameters::KEY_RECORDING_HINT, ""); + mParameters.set(android::CameraParameters::KEY_RECORDING_HINT, ""); restartPreviewRequired |= resetVideoModeParameters(); - params.getPreviewSize(&mVideoWidth, &mVideoHeight); } - if ((valstr = params.get(CameraParameters::KEY_FOCUS_MODE)) != NULL) { + if ( (!isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) + && (!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))) ) { + 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, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0){ + if(strcmp(valstr, android::CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0){ restartPreviewRequired |= resetVideoModeParameters(); - } else if (strcmp(valstr, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) == 0){ + } else if (strcmp(valstr, android::CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) == 0){ restartPreviewRequired |= setVideoModeParameters(params); } - mParameters.set(CameraParameters::KEY_FOCUS_MODE, valstr); + mParameters.set(android::CameraParameters::KEY_FOCUS_MODE, valstr); } else { CAMHAL_LOGEB("ERROR: Invalid FOCUS mode = %s", valstr); return BAD_VALUE; } } - ///Below parameters can be changed when the preview is running - if ( (valstr = params.getPictureFormat()) != NULL ) { - if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS))) { - mParameters.setPictureFormat(valstr); - } else { - CAMHAL_LOGEB("ERROR: Invalid picture format: %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 + + 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); + } params.getPictureSize(&w, &h); - if ( isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES))) { + if ( (isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES))) + || (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))) ) { mParameters.setPictureSize(w, h); } else { - CAMHAL_LOGEB("ERROR: Invalid picture resolution %dx%d", w, h); + 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); -#ifdef OMAP_ENHANCEMENT + 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); @@ -505,145 +619,181 @@ int CameraHal::setParameters(const CameraParameters& params) return BAD_VALUE; } } - #endif - framerate = params.getPreviewFrameRate(); - valstr = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE); - CAMHAL_LOGDB("FRAMERATE %d", framerate); - - CAMHAL_LOGVB("Passed FRR: %s, Supported FRR %s", valstr - , mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED)); - CAMHAL_LOGVB("Passed FR: %d, Supported FR %s", framerate - , mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)); - - - //Perform parameter validation - if(!isParameterValid(valstr - , mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED)) - || !isParameterValid(framerate, - mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES))) - { - CAMHAL_LOGEA("Invalid frame rate range or frame rate"); - return BAD_VALUE; - } - // 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 ( strcmp(valstr, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE)) != 0) - { + // 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 + // Set framerate = MAXFPS CAMHAL_LOGDA("APP IS CHANGING FRAME RATE RANGE"); - params.getPreviewFpsRange(&minFPS, &maxFPS); - if ( ( 0 > minFPS ) || ( 0 > maxFPS ) ) - { - CAMHAL_LOGEA("ERROR: FPS Range is negative!"); - return BAD_VALUE; - } + mParameters.getPreviewFpsRange(&curMinFPS, &curMaxFPS); + CAMHAL_LOGDB("## current minFPS = %d; maxFPS=%d",curMinFPS, curMaxFPS); - framerate = maxFPS /CameraHal::VFR_SCALE; - - } - else - { - if ( framerate != atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)) ) - { - - selectFPSRange(framerate, &minFPS, &maxFPS); - CAMHAL_LOGDB("Select FPS Range %d %d", minFPS, maxFPS); - } - else - { - if (videoMode) { - valstr = mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_VIDEO); - CameraParameters temp; - temp.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr); - temp.getPreviewFpsRange(&minFPS, &maxFPS); - } - else { - valstr = mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_IMAGE); - CameraParameters temp; - temp.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr); - temp.getPreviewFpsRange(&minFPS, &maxFPS); - } - - framerate = maxFPS / CameraHal::VFR_SCALE; + 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) && + 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]; - } - - CAMHAL_LOGDB("FPS Range = %s", valstr); - CAMHAL_LOGDB("DEFAULT FPS Range = %s", mCameraProperties->get(CameraProperties::FRAMERATE_RANGE)); - - minFPS /= CameraHal::VFR_SCALE; - maxFPS /= CameraHal::VFR_SCALE; - - if ( ( 0 == minFPS ) || ( 0 == maxFPS ) ) - { - CAMHAL_LOGEA("ERROR: FPS Range is invalid!"); - return BAD_VALUE; - } - - if ( maxFPS < minFPS ) - { - CAMHAL_LOGEA("ERROR: Max FPS is smaller than Min FPS!"); - return BAD_VALUE; - } - CAMHAL_LOGDB("SET FRAMERATE %d", framerate); - mParameters.setPreviewFrameRate(framerate); - mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE)); - - CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS); - mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS); - mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS); + 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 ) - { - CAMHAL_LOGDB("GBCE Value = %s", valstr); - mParameters.set(TICameraParameters::KEY_GBCE, valstr); + 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 ) - { - CAMHAL_LOGDB("GLBCE Value = %s", valstr); - mParameters.set(TICameraParameters::KEY_GLBCE, valstr); + 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 - +#ifdef OMAP_ENHANCEMENT_S3D ///Update the current parameter set - if( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL) - { - CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE)); - mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr); + 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); } + } - if( (valstr = params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES)) !=NULL ) - { - CAMHAL_LOGDB("ManualConvergence Value = %s", params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES)); - mParameters.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, valstr); + 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); } + } if ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL) { if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES))) { - CAMHAL_LOGDB("Exposure set = %s", valstr); + 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 = %s", valstr); + CAMHAL_LOGEB("ERROR: Invalid Exposure mode = %s", valstr); return BAD_VALUE; } } - #endif - if ((valstr = params.get(CameraParameters::KEY_WHITE_BALANCE)) != NULL) { + 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(CameraParameters::KEY_WHITE_BALANCE, valstr); + mParameters.set(android::CameraParameters::KEY_WHITE_BALANCE, valstr); } else { CAMHAL_LOGEB("ERROR: Invalid white balance = %s", valstr); return BAD_VALUE; @@ -651,7 +801,6 @@ int CameraHal::setParameters(const CameraParameters& params) } #ifdef OMAP_ENHANCEMENT - if ((valstr = params.get(TICameraParameters::KEY_CONTRAST)) != NULL) { if (params.getInt(TICameraParameters::KEY_CONTRAST) >= 0 ) { CAMHAL_LOGDB("Contrast set %s", valstr); @@ -691,13 +840,12 @@ int CameraHal::setParameters(const CameraParameters& params) return BAD_VALUE; } } - #endif - if ((valstr = params.get(CameraParameters::KEY_ANTIBANDING)) != NULL) { + 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(CameraParameters::KEY_ANTIBANDING, valstr); + mParameters.set(android::CameraParameters::KEY_ANTIBANDING, valstr); } else { CAMHAL_LOGEB("ERROR: Invalid Antibanding = %s", valstr); return BAD_VALUE; @@ -705,7 +853,6 @@ int CameraHal::setParameters(const CameraParameters& params) } #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); @@ -715,27 +862,25 @@ int CameraHal::setParameters(const CameraParameters& params) return BAD_VALUE; } } - #endif - if( (valstr = params.get(CameraParameters::KEY_FOCUS_AREAS)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_FOCUS_AREAS)) != NULL ) { - CAMHAL_LOGDB("Focus areas position set %s",valstr); - mParameters.set(CameraParameters::KEY_FOCUS_AREAS, valstr); + 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", params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)); + CAMHAL_LOGDB("Measurements set to %s", valstr); mParameters.set(TICameraParameters::KEY_MEASUREMENT_ENABLE, valstr); - if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0) + if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { mMeasurementEnabled = true; } - else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0) + else if (strcmp(valstr, android::CameraParameters::FALSE) == 0) { mMeasurementEnabled = false; } @@ -745,113 +890,107 @@ int CameraHal::setParameters(const CameraParameters& params) } } - #endif - if( (valstr = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL) + if( (valstr = params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL) { - CAMHAL_LOGDB("Exposure compensation set %s", valstr); - mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, valstr); + 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(CameraParameters::KEY_SCENE_MODE)) != NULL) { + 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(CameraParameters::KEY_SCENE_MODE), + mParameters.get(android::CameraParameters::KEY_SCENE_MODE), updateRequired); - mParameters.set(CameraParameters::KEY_SCENE_MODE, valstr); + mParameters.set(android::CameraParameters::KEY_SCENE_MODE, valstr); } else { CAMHAL_LOGEB("ERROR: Invalid Scene mode = %s", valstr); return BAD_VALUE; } } - if ((valstr = params.get(CameraParameters::KEY_FLASH_MODE)) != NULL) { + 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(CameraParameters::KEY_FLASH_MODE, 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(CameraParameters::KEY_EFFECT)) != NULL) { + 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(CameraParameters::KEY_EFFECT, valstr); + mParameters.set(android::CameraParameters::KEY_EFFECT, valstr); } else { CAMHAL_LOGEB("ERROR: Invalid Effect = %s", valstr); return BAD_VALUE; } } - varint = params.getInt(CameraParameters::KEY_ROTATION); - if( varint >=0 ) - { + varint = params.getInt(android::CameraParameters::KEY_ROTATION); + if ( varint >= 0 ) { CAMHAL_LOGDB("Rotation set %d", varint); - mParameters.set(CameraParameters::KEY_ROTATION, varint); - } + mParameters.set(android::CameraParameters::KEY_ROTATION, varint); + } - varint = params.getInt(CameraParameters::KEY_JPEG_QUALITY); - if( varint >= 0 ) - { + varint = params.getInt(android::CameraParameters::KEY_JPEG_QUALITY); + if ( varint >= 0 ) { CAMHAL_LOGDB("Jpeg quality set %d", varint); - mParameters.set(CameraParameters::KEY_JPEG_QUALITY, varint); - } + mParameters.set(android::CameraParameters::KEY_JPEG_QUALITY, varint); + } - varint = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); - if( varint >=0 ) - { + varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); + if ( varint >= 0 ) { CAMHAL_LOGDB("Thumbnail width set %d", varint); - mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, varint); - } + mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, varint); + } - varint = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); - if( varint >=0 ) - { + varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); + if ( varint >= 0 ) { CAMHAL_LOGDB("Thumbnail width set %d", varint); - mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, varint); - } + mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, varint); + } - varint = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); - if( varint >=0 ) - { + varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); + if ( varint >= 0 ) { CAMHAL_LOGDB("Thumbnail quality set %d", varint); - mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, varint); - } + mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, varint); + } - if( (valstr = params.get(CameraParameters::KEY_GPS_LATITUDE)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_GPS_LATITUDE)) != NULL ) { - CAMHAL_LOGDB("GPS latitude set %s", valstr); - mParameters.set(CameraParameters::KEY_GPS_LATITUDE, valstr); + CAMHAL_LOGDB("GPS latitude set %s", params.get(android::CameraParameters::KEY_GPS_LATITUDE)); + mParameters.set(android::CameraParameters::KEY_GPS_LATITUDE, valstr); }else{ - mParameters.remove(CameraParameters::KEY_GPS_LATITUDE); + mParameters.remove(android::CameraParameters::KEY_GPS_LATITUDE); } - if( (valstr = params.get(CameraParameters::KEY_GPS_LONGITUDE)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_GPS_LONGITUDE)) != NULL ) { - CAMHAL_LOGDB("GPS longitude set %s", valstr); - mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, valstr); + CAMHAL_LOGDB("GPS longitude set %s", params.get(android::CameraParameters::KEY_GPS_LONGITUDE)); + mParameters.set(android::CameraParameters::KEY_GPS_LONGITUDE, valstr); }else{ - mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE); + mParameters.remove(android::CameraParameters::KEY_GPS_LONGITUDE); } - if( (valstr = params.get(CameraParameters::KEY_GPS_ALTITUDE)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_GPS_ALTITUDE)) != NULL ) { - CAMHAL_LOGDB("GPS altitude set %s", valstr); - mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, valstr); + CAMHAL_LOGDB("GPS altitude set %s", params.get(android::CameraParameters::KEY_GPS_ALTITUDE)); + mParameters.set(android::CameraParameters::KEY_GPS_ALTITUDE, valstr); }else{ - mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE); + mParameters.remove(android::CameraParameters::KEY_GPS_ALTITUDE); } - if( (valstr = params.get(CameraParameters::KEY_GPS_TIMESTAMP)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_GPS_TIMESTAMP)) != NULL ) { - CAMHAL_LOGDB("GPS timestamp set %s", valstr); - mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, valstr); + CAMHAL_LOGDB("GPS timestamp set %s", params.get(android::CameraParameters::KEY_GPS_TIMESTAMP)); + mParameters.set(android::CameraParameters::KEY_GPS_TIMESTAMP, valstr); }else{ - mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP); + mParameters.remove(android::CameraParameters::KEY_GPS_TIMESTAMP); } if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL ) @@ -862,12 +1001,12 @@ int CameraHal::setParameters(const CameraParameters& params) mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP); } - if( (valstr = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL ) { - CAMHAL_LOGDB("GPS processing method set %s", valstr); - mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, valstr); + 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(CameraParameters::KEY_GPS_PROCESSING_METHOD); + mParameters.remove(android::CameraParameters::KEY_GPS_PROCESSING_METHOD); } if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL ) @@ -899,67 +1038,116 @@ int CameraHal::setParameters(const CameraParameters& params) } #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 + 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 - valstr = params.get(CameraParameters::KEY_ZOOM); - varint = params.getInt(CameraParameters::KEY_ZOOM); - if ( valstr != NULL ) { - if ( ( varint >= 0 ) && ( varint <= mMaxZoomSupported ) ) { - CAMHAL_LOGDB("Zoom set %s", valstr); + 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(CameraParameters::KEY_ZOOM), + mParameters.get(android::CameraParameters::KEY_ZOOM), updateRequired); - mParameters.set(CameraParameters::KEY_ZOOM, valstr); + mParameters.set(android::CameraParameters::KEY_ZOOM, valstr); } else { CAMHAL_LOGEB("ERROR: Invalid Zoom: %s", valstr); return BAD_VALUE; } } - if( (valstr = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL ) { CAMHAL_LOGDB("Auto Exposure Lock set %s", valstr); doesSetParameterNeedUpdate(valstr, - mParameters.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK), + mParameters.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK), updateRequired); - mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr); + mParameters.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr); } - if( (valstr = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL ) { CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", valstr); doesSetParameterNeedUpdate(valstr, - mParameters.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK), + mParameters.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK), updateRequired); - mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr); + mParameters.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr); } - if( (valstr = params.get(CameraParameters::KEY_METERING_AREAS)) != NULL ) + if( (valstr = params.get(android::CameraParameters::KEY_METERING_AREAS)) != NULL ) { - CAMHAL_LOGDB("Metering areas position set %s", valstr); - mParameters.set(CameraParameters::KEY_METERING_AREAS, valstr); + CAMHAL_LOGDB("Metering areas position set %s", params.get(android::CameraParameters::KEY_METERING_AREAS)); + mParameters.set(android::CameraParameters::KEY_METERING_AREAS, valstr); } - // 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) ) { - ret |= mCameraAdapter->setParameters(mParameters); + 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); } -#ifdef OMAP_ENHANCEMENT + 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); + } + + //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); + } + 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); @@ -982,44 +1170,58 @@ int CameraHal::setParameters(const CameraParameters& params) CAMHAL_LOGDB("Negative bracketing range %d", mBracketRangeNegative); if( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL) && - ( strcmp(valstr, TICameraParameters::BRACKET_ENABLE) == 0 )) - { - if ( !mBracketingEnabled ) - { + ( strcmp(valstr, android::CameraParameters::TRUE) == 0 )) { + if ( !mBracketingEnabled ) { CAMHAL_LOGDA("Enabling bracketing"); mBracketingEnabled = true; - - //Wait for AF events to enable bracketing - if ( NULL != mCameraAdapter ) - { - setEventProvider( CameraHalEvent::ALL_EVENTS, mCameraAdapter ); - } - } - else - { + } else { CAMHAL_LOGDA("Bracketing already enabled"); - } } - else if ( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL ) && - ( strcmp(valstr, TICameraParameters::BRACKET_DISABLE) == 0 )) - { + 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; - stopImageBracketing(); + if ( mBracketingRunning ) { + stopImageBracketing(); + } - //Remove AF events subscription - if ( NULL != mEventProvider ) - { - mEventProvider->disableEventNotification( CameraHalEvent::ALL_EVENTS ); - delete mEventProvider; - mEventProvider = NULL; - } + } 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, TICameraParameters::SHUTTER_ENABLE) == 0 )) + ( strcmp(valstr, android::CameraParameters::TRUE) == 0 )) { CAMHAL_LOGDA("Enabling shutter sound"); @@ -1028,7 +1230,7 @@ int CameraHal::setParameters(const CameraParameters& params) mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr); } else if ( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) && - ( strcmp(valstr, TICameraParameters::SHUTTER_DISABLE) == 0 )) + ( strcmp(valstr, android::CameraParameters::FALSE) == 0 )) { CAMHAL_LOGDA("Disabling shutter sound"); @@ -1036,9 +1238,7 @@ int CameraHal::setParameters(const CameraParameters& params) mMsgEnabled &= ~CAMERA_MSG_SHUTTER; mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr); } - #endif - } //On fail restore old parameters @@ -1057,6 +1257,10 @@ int CameraHal::setParameters(const CameraParameters& params) forceStopPreview(); } + if ( !mBracketingRunning && mBracketingEnabled ) { + startImageBracketing(); + } + if (ret != NO_ERROR) { CAMHAL_LOGEA("Failed to restart Preview"); @@ -1082,45 +1286,35 @@ status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewF return NO_MEMORY; } - if(!mPreviewBufs) + if(!mPreviewBuffers) { - ///@todo Pluralise the name of this method to allocateBuffers mPreviewLength = 0; - mPreviewBufs = (int32_t *) mDisplayAdapter->allocateBuffer(width, height, + mPreviewBuffers = mDisplayAdapter->allocateBufferList(width, height, previewFormat, mPreviewLength, buffercount); - - if (NULL == mPreviewBufs ) { + 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; - } - - mPreviewFd = mDisplayAdapter->getFd(); - if ( -1 == mPreviewFd ) { - CAMHAL_LOGEA("Invalid handle"); - 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() @@ -1128,12 +1322,11 @@ status_t CameraHal::freePreviewBufs() status_t ret = NO_ERROR; LOG_FUNCTION_NAME; - CAMHAL_LOGDB("mPreviewBufs = 0x%x", (unsigned int)mPreviewBufs); - if(mPreviewBufs) + CAMHAL_LOGDB("mPreviewBuffers = %p", mPreviewBuffers); + if(mPreviewBuffers) { - ///@todo Pluralise the name of this method to freeBuffers - ret = mBufProvider->freeBuffer(mPreviewBufs); - mPreviewBufs = NULL; + ret = mBufProvider->freeBufferList(mPreviewBuffers); + mPreviewBuffers = NULL; LOG_FUNCTION_NAME_EXIT; return ret; } @@ -1153,7 +1346,7 @@ status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount) if ( NO_ERROR == ret ) { - if( NULL != mPreviewDataBufs ) + if( NULL != mPreviewDataBuffers ) { ret = freePreviewDataBufs(); } @@ -1162,10 +1355,10 @@ status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount) if ( NO_ERROR == ret ) { bytes = ((bytes+4095)/4096)*4096; - mPreviewDataBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, NULL, bytes, bufferCount); + mPreviewDataBuffers = mMemoryManager->allocateBufferList(0, 0, NULL, bytes, bufferCount); CAMHAL_LOGDB("Size of Preview data buffer = %d", bytes); - if( NULL == mPreviewDataBufs ) + if( NULL == mPreviewDataBuffers ) { CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager"); ret = -NO_MEMORY; @@ -1189,7 +1382,7 @@ status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount) mPreviewDataOffsets = NULL; } - LOG_FUNCTION_NAME; + LOG_FUNCTION_NAME_EXIT; return ret; } @@ -1203,12 +1396,11 @@ status_t CameraHal::freePreviewDataBufs() if ( NO_ERROR == ret ) { - if( NULL != mPreviewDataBufs ) + if( NULL != mPreviewDataBuffers ) { - ///@todo Pluralise the name of this method to freeBuffers - ret = mMemoryManager->freeBuffer(mPreviewDataBufs); - mPreviewDataBufs = NULL; + ret = mMemoryManager->freeBufferList(mPreviewDataBuffers); + mPreviewDataBuffers = NULL; } } @@ -1218,7 +1410,9 @@ status_t CameraHal::freePreviewDataBufs() return ret; } -status_t CameraHal::allocImageBufs(unsigned int width, unsigned int height, size_t size, const char* previewFormat, unsigned int bufferCount) +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; @@ -1228,41 +1422,44 @@ status_t CameraHal::allocImageBufs(unsigned int width, unsigned int height, size bytes = size; // allocate image buffers only if not already allocated - if(NULL != mImageBufs) { + if(NULL != mImageBuffers) { + if (mBufferSourceAdapter_Out.get()) { + mBufferSourceAdapter_Out->maxQueueableBuffers(*max_queueable); + } else { + *max_queueable = bufferCount; + } return NO_ERROR; } - if ( NO_ERROR == ret ) - { - bytes = ((bytes+4095)/4096)*4096; - mImageBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, previewFormat, bytes, bufferCount); + 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 == mImageBufs ) - { - CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager"); - ret = -NO_MEMORY; - } - else - { - bytes = size; - } - } + 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 ) - { + if ( NO_ERROR == ret ) { mImageFd = mMemoryManager->getFd(); mImageLength = bytes; mImageOffsets = mMemoryManager->getOffsets(); - } - else - { + } else { mImageFd = -1; mImageLength = 0; mImageOffsets = NULL; - } + } - LOG_FUNCTION_NAME; + LOG_FUNCTION_NAME_EXIT; return ret; } @@ -1272,36 +1469,38 @@ status_t CameraHal::allocVideoBufs(uint32_t width, uint32_t height, uint32_t buf status_t ret = NO_ERROR; LOG_FUNCTION_NAME; - if( NULL != mVideoBufs ){ - ret = freeVideoBufs(mVideoBufs); - mVideoBufs = NULL; + if( NULL != mVideoBuffers ){ + ret = freeVideoBufs(mVideoBuffers); + mVideoBuffers = NULL; } if ( NO_ERROR == ret ){ int32_t stride; - buffer_handle_t *bufsArr = new buffer_handle_t [bufferCount]; + CameraBuffer *buffers = new CameraBuffer [bufferCount]; - if (bufsArr != NULL){ - for (int i = 0; i< bufferCount; i++){ - GraphicBufferAllocator &GrallocAlloc = GraphicBufferAllocator::get(); - buffer_handle_t buf; - ret = GrallocAlloc.alloc(width, height, HAL_PIXEL_FORMAT_NV12, CAMHAL_GRALLOC_USAGE, &buf, &stride); + 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 (int j=0; j< i; j++){ - buf = (buffer_handle_t)bufsArr[j]; - CAMHAL_LOGEB("Freeing Gralloc Buffer 0x%x", buf); - GrallocAlloc.free(buf); + 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 [] bufsArr; + delete [] buffers; goto exit; } - bufsArr[i] = buf; - CAMHAL_LOGVB("*** Gralloc Handle =0x%x ***", buf); + buffers[i].type = CAMERA_BUFFER_GRALLOC; + buffers[i].opaque = (void *)handle; + CAMHAL_LOGVB("*** Gralloc Handle =0x%x ***", handle); } - mVideoBufs = (int32_t *)bufsArr; + mVideoBuffers = buffers; } else{ CAMHAL_LOGEA("Couldn't allocate video buffers "); @@ -1310,11 +1509,53 @@ status_t CameraHal::allocVideoBufs(uint32_t width, uint32_t height, uint32_t buf } exit: - LOG_FUNCTION_NAME; + 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; @@ -1344,11 +1585,18 @@ status_t CameraHal::signalEndImageCapture() { status_t ret = NO_ERROR; int w,h; - CameraParameters adapterParams = mParameters; - Mutex::Autolock lock(mLock); + 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 { @@ -1366,50 +1614,44 @@ status_t CameraHal::freeImageBufs() LOG_FUNCTION_NAME; - if ( NO_ERROR == ret ) - { - - if( NULL != mImageBufs ) - { - - ///@todo Pluralise the name of this method to freeBuffers - ret = mMemoryManager->freeBuffer(mImageBufs); - mImageBufs = NULL; + if (NULL == mImageBuffers) { + return -EINVAL; + } - } - else - { - ret = -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(void *bufs) +status_t CameraHal::freeVideoBufs(CameraBuffer *bufs) { status_t ret = NO_ERROR; LOG_FUNCTION_NAME; - buffer_handle_t *pBuf = (buffer_handle_t*)bufs; int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); - if(pBuf == NULL) + if(bufs == NULL) { CAMHAL_LOGEA("NULL pointer passed to freeVideoBuffer"); LOG_FUNCTION_NAME_EXIT; return BAD_VALUE; } - GraphicBufferAllocator &GrallocAlloc = GraphicBufferAllocator::get(); + android::GraphicBufferAllocator &GrallocAlloc = android::GraphicBufferAllocator::get(); for(int i = 0; i < count; i++){ - buffer_handle_t ptr = *pBuf++; - CAMHAL_LOGVB("Free Video Gralloc Handle 0x%x", ptr); - GrallocAlloc.free(ptr); + CAMHAL_LOGVB("Free Video Gralloc Handle 0x%x", bufs[i].opaque); + GrallocAlloc.free((buffer_handle_t)bufs[i].opaque); } LOG_FUNCTION_NAME_EXIT; @@ -1417,6 +1659,27 @@ status_t CameraHal::freeVideoBufs(void *bufs) 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. @@ -1425,13 +1688,117 @@ status_t CameraHal::freeVideoBufs(void *bufs) @todo Update function header with the different errors that are possible */ -status_t CameraHal::startPreview() +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; - const char *valstr = NULL; unsigned int required_buffer_count; unsigned int max_queueble_buffers; @@ -1441,6 +1808,10 @@ status_t CameraHal::startPreview() LOG_FUNCTION_NAME; + if (mPreviewInitializationDone) { + return NO_ERROR; + } + if ( mPreviewEnabled ){ CAMHAL_LOGDA("Preview already running"); LOG_FUNCTION_NAME_EXIT; @@ -1461,15 +1832,11 @@ status_t CameraHal::startPreview() ///Update the current preview width and height mPreviewWidth = frame.mWidth; mPreviewHeight = frame.mHeight; - //Update the padded width and height - required for VNF and VSTAB - mParameters.set(TICameraParameters::KEY_PADDED_WIDTH, mPreviewWidth); - mParameters.set(TICameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight); - } ///If we don't have the preview callback enabled and display adapter, if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)){ - CAMHAL_LOGDA("Preview not started. Preview in progress flag set"); + CAMHAL_LOGD("Preview not started. Preview in progress flag set"); mPreviewStartInProgress = true; ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING); if ( NO_ERROR != ret ){ @@ -1499,10 +1866,11 @@ status_t CameraHal::startPreview() { mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME); } + + signalEndImageCapture(); return ret; } - required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)); ///Allocate the preview buffers @@ -1534,7 +1902,7 @@ status_t CameraHal::startPreview() if ( NO_ERROR == ret ) { - desc.mBuffers = mPreviewDataBufs; + desc.mBuffers = mPreviewDataBuffers; desc.mOffsets = mPreviewDataOffsets; desc.mFd = mPreviewDataFd; desc.mLength = mPreviewDataLength; @@ -1548,7 +1916,7 @@ status_t CameraHal::startPreview() } ///Pass the buffers to Camera Adapter - desc.mBuffers = mPreviewBufs; + desc.mBuffers = mPreviewBuffers; desc.mOffsets = mPreviewOffsets; desc.mFd = mPreviewFd; desc.mLength = mPreviewLength; @@ -1565,8 +1933,6 @@ status_t CameraHal::startPreview() return ret; } - mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count); - ///Start the callback notifier ret = mAppCallbackNotifier->start(); @@ -1586,72 +1952,10 @@ status_t CameraHal::startPreview() goto error; } - ///Enable the display adapter if present, actual overlay enable happens when we post the buffer - if(mDisplayAdapter.get() != NULL) - { - CAMHAL_LOGDA("Enabling display"); - bool isS3d = false; - DisplayAdapter::S3DParameters s3dParams; - int width, height; - mParameters.getPreviewSize(&width, &height); -#if 0 //TODO: s3d is not part of bringup...will reenable - if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_SUPPORTED)) != NULL) { - isS3d = (strcmp(valstr, "true") == 0); - } - if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) { - if (strcmp(valstr, "off") == 0) - { - CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS OFF"); - //TODO: obtain the frame packing configuration from camera or user settings - //once side by side configuration is supported - s3dParams.mode = OVERLAY_S3D_MODE_ON; - s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER; - s3dParams.order = OVERLAY_S3D_ORDER_LF; - s3dParams.subSampling = OVERLAY_S3D_SS_NONE; - } - else - { - CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS ON"); - s3dParams.mode = OVERLAY_S3D_MODE_OFF; - s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER; - s3dParams.order = OVERLAY_S3D_ORDER_LF; - s3dParams.subSampling = OVERLAY_S3D_SS_NONE; - } - } -#endif //if 0 - -#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS + if (ret == NO_ERROR) mPreviewInitializationDone = true; - ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview, isS3d ? &s3dParams : NULL); + mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count); -#else - - ret = mDisplayAdapter->enableDisplay(width, height, NULL, isS3d ? &s3dParams : NULL); - -#endif - - if ( ret != NO_ERROR ) - { - CAMHAL_LOGEA("Couldn't enable display"); - 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: @@ -1698,19 +2002,22 @@ status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window) if(mDisplayAdapter.get() != NULL) { ///NULL window passed, destroy the display adapter if present - CAMHAL_LOGDA("NULL window passed, destroying display adapter"); + 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_LOGDA("NULL ANativeWindow passed to setPreviewWindow"); + 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)) { @@ -1768,6 +2075,148 @@ status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window) } +#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. @@ -1785,7 +2234,7 @@ void CameraHal::stopPreview() return; } - bool imageCaptureRunning = (mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE) && + bool imageCaptureRunning = (mCameraAdapter->getState() & CameraAdapter::CAPTURE_STATE) && (mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE); if(mDisplayPaused && !imageCaptureRunning) { @@ -1857,23 +2306,27 @@ status_t CameraHal::startRecording( ) // 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, CameraParameters::TRUE); + 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(CameraParameters::KEY_FOCUS_MODE)) != NULL) && - (strcmp(valstr, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0) ){ + 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(CameraParameters::KEY_RECORDING_HINT); + valstr = mParameters.get(android::CameraParameters::KEY_RECORDING_HINT); if ( !restartPreviewRequired && - (!valstr || (valstr && (strcmp(valstr, CameraParameters::TRUE) != 0))) ) { + (!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(); } @@ -1895,13 +2348,13 @@ status_t CameraHal::startRecording( ) mAppCallbackNotifier->useVideoBuffers(true); mAppCallbackNotifier->setVideoRes(mVideoWidth, mVideoHeight); - ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, count, mVideoBufs); + ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, count, mVideoBuffers); } else { mAppCallbackNotifier->useVideoBuffers(false); mAppCallbackNotifier->setVideoRes(mPreviewWidth, mPreviewHeight); - ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, count, NULL); + ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, count, NULL); } } @@ -1938,12 +2391,11 @@ status_t CameraHal::startRecording( ) @todo Modify the policies for enabling VSTAB & VNF usecase based later. */ -bool CameraHal::setVideoModeParameters(const CameraParameters& params) +bool CameraHal::setVideoModeParameters(const android::CameraParameters& params) { const char *valstr = NULL; const char *valstrRemote = NULL; bool restartPreviewRequired = false; - status_t ret = NO_ERROR; LOG_FUNCTION_NAME; @@ -1957,53 +2409,56 @@ bool CameraHal::setVideoModeParameters(const CameraParameters& params) restartPreviewRequired = true; } - // Check if CAPTURE_MODE is VIDEO_MODE, since VSTAB & VNF work only in VIDEO_MODE. - valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); - if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0) { - valstrRemote = params.get(CameraParameters::KEY_VIDEO_STABILIZATION); - // set VSTAB. restart is required if vstab value has changed - if ( valstrRemote != NULL) { - // make sure we support vstab - if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED), - CameraParameters::TRUE) == 0) { - valstr = mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION); - // vstab value has changed - if ((valstr != NULL) && - strcmp(valstr, valstrRemote) != 0) { - restartPreviewRequired = true; - } - mParameters.set(CameraParameters::KEY_VIDEO_STABILIZATION, valstrRemote); + // 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; } - } else if (mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION)) { - // vstab was configured but now unset - restartPreviewRequired = true; - mParameters.remove(CameraParameters::KEY_VIDEO_STABILIZATION); + 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 - valstrRemote = params.get(TICameraParameters::KEY_VNF); - if ( valstrRemote == NULL) { - CAMHAL_LOGDA("Enable VNF"); - mParameters.set(TICameraParameters::KEY_VNF, "1"); + // 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; - } else { - valstr = mParameters.get(TICameraParameters::KEY_VNF); - if (valstr && strcmp(valstr, valstrRemote) != 0) { - restartPreviewRequired = true; - } - mParameters.set(TICameraParameters::KEY_VNF, valstrRemote); } + 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. - valstr = mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION); - if (valstr && (strcmp(valstr, CameraParameters::TRUE) == 0) && (mPreviewWidth == 1920)) { + 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"); - mParameters.set(TICameraParameters::KEY_VNF, "1"); - restartPreviewRequired = true; + 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; @@ -2055,31 +2510,22 @@ bool CameraHal::resetVideoModeParameters() */ status_t CameraHal::restartPreview() { - const char *valstr = NULL; - char tmpvalstr[30]; status_t ret = NO_ERROR; LOG_FUNCTION_NAME; // Retain CAPTURE_MODE before calling stopPreview(), since it is reset in stopPreview(). - tmpvalstr[0] = 0; - valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); - if(valstr != NULL) - { - if(sizeof(tmpvalstr) < (strlen(valstr)+1)) - { - return -EINVAL; - } - - strncpy(tmpvalstr, valstr, sizeof(tmpvalstr)); - tmpvalstr[sizeof(tmpvalstr)-1] = 0; - } forceStopPreview(); { - Mutex::Autolock lock(mLock); - mParameters.set(TICameraParameters::KEY_CAP_MODE, tmpvalstr); + 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); } @@ -2103,7 +2549,7 @@ void CameraHal::stopRecording() LOG_FUNCTION_NAME; - Mutex::Autolock lock(mLock); + android::AutoMutex lock(mLock); if (!mRecordingEnabled ) { @@ -2122,12 +2568,12 @@ void CameraHal::stopRecording() mRecordingEnabled = false; if ( mAppCallbackNotifier->getUesVideoBuffers() ){ - freeVideoBufs(mVideoBufs); - if (mVideoBufs){ - CAMHAL_LOGVB(" FREEING mVideoBufs 0x%x", mVideoBufs); - delete [] mVideoBufs; + freeVideoBufs(mVideoBuffers); + if (mVideoBuffers){ + CAMHAL_LOGVB(" FREEING mVideoBuffers %p", mVideoBuffers); + delete [] mVideoBuffers; } - mVideoBufs = NULL; + mVideoBuffers = NULL; } // reset internal recording hint in case camera adapter needs to make some @@ -2203,7 +2649,7 @@ status_t CameraHal::autoFocus() LOG_FUNCTION_NAME; - Mutex::Autolock lock(mLock); + android::AutoMutex lock(mLock); mMsgEnabled |= CAMERA_MSG_FOCUS; @@ -2260,13 +2706,13 @@ status_t CameraHal::cancelAutoFocus() { LOG_FUNCTION_NAME; - Mutex::Autolock lock(mLock); - CameraParameters adapterParams = mParameters; + android::AutoMutex lock(mLock); + android::CameraParameters adapterParams = mParameters; mMsgEnabled &= ~CAMERA_MSG_FOCUS; if( NULL != mCameraAdapter ) { - adapterParams.set(TICameraParameters::KEY_AUTO_FOCUS_LOCK, CameraParameters::FALSE); + adapterParams.set(TICameraParameters::KEY_AUTO_FOCUS_LOCK, android::CameraParameters::FALSE); mCameraAdapter->setParameters(adapterParams); mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS); mAppCallbackNotifier->flushEventQueue(); @@ -2315,34 +2761,17 @@ void CameraHal::eventCallback(CameraHalEvent* event) { LOG_FUNCTION_NAME; - if ( NULL != event ) - { - switch( event->mEventType ) - { - case CameraHalEvent::EVENT_FOCUS_LOCKED: - case CameraHalEvent::EVENT_FOCUS_ERROR: - { - if ( mBracketingEnabled ) - { - startImageBracketing(); - } - break; - } - default: - { - break; - } - }; - } - LOG_FUNCTION_NAME_EXIT; } status_t CameraHal::startImageBracketing() { - status_t ret = NO_ERROR; - CameraFrame frame; - CameraAdapter::BuffersDescriptor desc; + status_t ret = NO_ERROR; + CameraFrame frame; + CameraAdapter::BuffersDescriptor desc; + unsigned int max_queueable = 0; + + #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS @@ -2390,6 +2819,7 @@ status_t CameraHal::startImageBracketing() if ( NO_ERROR == ret ) { + unsigned int bufferCount = mBracketRangeNegative + 1; mParameters.getPictureSize(( int * ) &frame.mWidth, ( int * ) &frame.mHeight); @@ -2397,7 +2827,9 @@ status_t CameraHal::startImageBracketing() frame.mHeight, frame.mLength, mParameters.getPictureFormat(), - ( mBracketRangeNegative + 1 )); + bufferCount, + &max_queueable); + mBracketRangeNegative = bufferCount - 1; if ( NO_ERROR != ret ) { CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); @@ -2407,12 +2839,12 @@ status_t CameraHal::startImageBracketing() if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) { - desc.mBuffers = mImageBufs; + desc.mBuffers = mImageBuffers; desc.mOffsets = mImageOffsets; desc.mFd = mImageFd; desc.mLength = mImageLength; desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 ); - desc.mMaxQueueable = ( size_t ) ( mBracketRangeNegative + 1 ); + desc.mMaxQueueable = ( size_t) max_queueable; ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, ( int ) &desc); @@ -2465,16 +2897,36 @@ status_t CameraHal::stopImageBracketing() @todo Define error codes if unable to switch to image capture */ -status_t CameraHal::takePicture( ) +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; + int burst = -1; const char *valstr = NULL; unsigned int bufferCount = 1; - - Mutex::Autolock lock(mLock); + unsigned int max_queueable = 0; + unsigned int rawBufferCount = 1; + bool isCPCamMode = false; #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS @@ -2491,53 +2943,132 @@ status_t CameraHal::takePicture( ) 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 - if ( (mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE && + // 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) ) { + 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) - valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE); 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; } - if ( !mBracketingRunning ) - { +#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); + } - if ( NO_ERROR == ret ) - { - burst = mParameters.getInt(TICameraParameters::KEY_BURST); + 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 > 1 ) - { - bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE; - if ( NULL != mAppCallbackNotifier.get() ) - { + 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 ( NULL != mAppCallbackNotifier.get() ) - { + } 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() && - burst < 1) { + if ( (NO_ERROR == ret) && (NULL != mDisplayAdapter.get()) ) { if (mCameraAdapter->getState() != CameraAdapter::VIDEO_STATE) { mDisplayPaused = true; mPreviewEnabled = false; @@ -2577,14 +3108,12 @@ status_t CameraHal::takePicture( ) if ( NO_ERROR == ret ) { - mParameters.getPictureSize(( int * ) &frame.mWidth, - ( int * ) &frame.mHeight); - - ret = allocImageBufs(frame.mWidth, + ret = allocImageBufs(frame.mAlignment, frame.mHeight, frame.mLength, mParameters.getPictureFormat(), - bufferCount); + bufferCount, + &max_queueable); if ( NO_ERROR != ret ) { CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret); @@ -2593,20 +3122,48 @@ status_t CameraHal::takePicture( ) if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) ) { - desc.mBuffers = mImageBufs; + desc.mBuffers = mImageBuffers; desc.mOffsets = mImageOffsets; desc.mFd = mImageFd; desc.mLength = mImageLength; desc.mCount = ( size_t ) bufferCount; - desc.mMaxQueueable = ( 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 ( ( NO_ERROR == ret ) && ( NULL != mCameraAdapter ) ) - { + 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 @@ -2619,7 +3176,7 @@ status_t CameraHal::takePicture( ) #endif - } + } return ret; } @@ -2637,11 +3194,9 @@ status_t CameraHal::takePicture( ) status_t CameraHal::cancelPicture( ) { LOG_FUNCTION_NAME; + status_t ret = NO_ERROR; - Mutex::Autolock lock(mLock); - - mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE); - + ret = signalEndImageCapture(); return NO_ERROR; } @@ -2654,7 +3209,7 @@ status_t CameraHal::cancelPicture( ) */ char* CameraHal::getParameters() { - String8 params_str8; + android::String8 params_str8; char* params_string; const char * valstr = NULL; @@ -2665,16 +3220,38 @@ char* CameraHal::getParameters() mCameraAdapter->getParameters(mParameters); } - CameraParameters mParams = mParameters; + 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)); + } + } + + android::CameraParameters mParams = mParameters; // Handle RECORDING_HINT to Set/Reset Video Mode Parameters - valstr = mParameters.get(CameraParameters::KEY_RECORDING_HINT); + valstr = mParameters.get(android::CameraParameters::KEY_RECORDING_HINT); if(valstr != NULL) { - if(strcmp(valstr, CameraParameters::TRUE) == 0) + if(strcmp(valstr, android::CameraParameters::TRUE) == 0) { //HACK FOR MMS MODE - resetPreviewRes(&mParams, mVideoWidth, mVideoHeight); + resetPreviewRes(&mParams); } } @@ -2695,6 +3272,80 @@ char* CameraHal::getParameters() 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); @@ -2714,7 +3365,6 @@ status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) LOG_FUNCTION_NAME; - if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) ) { CAMHAL_LOGEA("No CameraAdapter instance"); @@ -2724,24 +3374,31 @@ status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) /////////////////////////////////////////////////////// // Following commands do NOT need preview to be started /////////////////////////////////////////////////////// - switch(cmd) { - case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG: - bool enable = static_cast<bool>(arg1); - Mutex::Autolock lock(mLock); - if (enable) { - mMsgEnabled |= CAMERA_MSG_FOCUS_MOVE; - } else { - mMsgEnabled &= ~CAMERA_MSG_FOCUS_MOVE; - } - return NO_ERROR; - break; + + 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 ( ( NO_ERROR == ret ) && ( !previewEnabled() )) - { + 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 @@ -2760,7 +3417,7 @@ status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM); break; -#ifndef OMAP_TUNA + case CAMERA_CMD_START_FACE_DETECTION: ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD); @@ -2772,7 +3429,32 @@ status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) 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; }; @@ -2838,11 +3520,11 @@ CameraHal::CameraHal(int cameraId) ///Initialize all the member variables to their defaults mPreviewEnabled = false; - mPreviewBufs = NULL; - mImageBufs = NULL; + mPreviewBuffers = NULL; + mImageBuffers = NULL; mBufProvider = NULL; mPreviewStartInProgress = false; - mVideoBufs = NULL; + mVideoBuffers = NULL; mVideoBufProvider = NULL; mRecordingEnabled = false; mDisplayPaused = false; @@ -2859,7 +3541,7 @@ CameraHal::CameraHal(int cameraId) mMaxZoomSupported = 0; mShutterEnabled = true; mMeasurementEnabled = false; - mPreviewDataBufs = NULL; + mPreviewDataBuffers = NULL; mCameraProperties = NULL; mCurrentTime = 0; mFalsePreview = 0; @@ -2884,6 +3566,19 @@ CameraHal::CameraHal(int cameraId) 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 @@ -2933,6 +3628,7 @@ CameraHal::~CameraHal() } freeImageBufs(); + freeRawBufs(); /// Free the memory manager mMemoryManager.clear(); @@ -2957,6 +3653,7 @@ 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 @@ -2979,9 +3676,22 @@ status_t CameraHal::initialize(CameraProperties::Properties* properties) sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)); } - CAMHAL_LOGDB("Sensor index %d", 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 + } - mCameraAdapter = CameraAdapter_Factory(sensor_index); if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties)!=NO_ERROR)) { CAMHAL_LOGEA("Unable to create or initialize CameraAdapter"); @@ -3079,39 +3789,64 @@ status_t CameraHal::initialize(CameraProperties::Properties* properties) bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions) { - bool ret = true; + bool ret = false; status_t status = NO_ERROR; - char tmpBuffer[PARAM_BUFFER + 1]; + char tmpBuffer[MAX_PROP_VALUE_LENGTH]; char *pos = NULL; LOG_FUNCTION_NAME; - if ( NULL == supportedResolutions ) - { + if (NULL == supportedResolutions) { CAMHAL_LOGEA("Invalid supported resolutions string"); - ret = false; goto exit; - } + } - status = snprintf(tmpBuffer, PARAM_BUFFER, "%dx%d", width, height); - if ( 0 > status ) - { + status = snprintf(tmpBuffer, MAX_PROP_VALUE_LENGTH - 1, "%dx%d", width, height); + if (0 > status) { CAMHAL_LOGEA("Error encountered while generating validation string"); - ret = false; goto exit; - } + } - pos = strstr(supportedResolutions, tmpBuffer); - if ( NULL == pos ) - { - ret = false; - } - else - { - ret = true; - } + 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; @@ -3120,37 +3855,34 @@ exit: bool CameraHal::isParameterValid(const char *param, const char *supportedParams) { - bool ret = true; - char *pos = NULL; + bool ret = false; + char *pos; + char supported[MAX_PROP_VALUE_LENGTH]; LOG_FUNCTION_NAME; - if ( NULL == supportedParams ) - { + if (NULL == supportedParams) { CAMHAL_LOGEA("Invalid supported parameters string"); - ret = false; goto exit; - } + } - if ( NULL == param ) - { + if (NULL == param) { CAMHAL_LOGEA("Invalid parameter string"); - ret = false; goto exit; - } + } - pos = strstr(supportedParams, param); - if ( NULL == pos ) - { - ret = false; - } - else - { - ret = true; + 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; @@ -3158,40 +3890,26 @@ exit: bool CameraHal::isParameterValid(int param, const char *supportedParams) { - bool ret = true; - char *pos = NULL; + bool ret = false; status_t status; - char tmpBuffer[PARAM_BUFFER + 1]; + char tmpBuffer[MAX_PROP_VALUE_LENGTH]; LOG_FUNCTION_NAME; - if ( NULL == supportedParams ) - { + if (NULL == supportedParams) { CAMHAL_LOGEA("Invalid supported parameters string"); - ret = false; goto exit; - } + } - status = snprintf(tmpBuffer, PARAM_BUFFER, "%d", param); - if ( 0 > status ) - { + status = snprintf(tmpBuffer, MAX_PROP_VALUE_LENGTH - 1, "%d", param); + if (0 > status) { CAMHAL_LOGEA("Error encountered while generating validation string"); - ret = false; goto exit; - } + } - pos = strstr(supportedParams, tmpBuffer); - if ( NULL == pos ) - { - ret = false; - } - else - { - ret = true; - } + ret = isParameterValid(tmpBuffer, supportedParams); exit: - LOG_FUNCTION_NAME_EXIT; return ret; @@ -3215,7 +3933,6 @@ status_t CameraHal::parseResolution(const char *resStr, int &width, int &height) status_t ret = NO_ERROR; char *ctx, *pWidth, *pHeight; const char *sep = "x"; - char *tmp = NULL; LOG_FUNCTION_NAME; @@ -3226,11 +3943,10 @@ status_t CameraHal::parseResolution(const char *resStr, int &width, int &height) //This fixes "Invalid input resolution" char *resStr_copy = (char *)malloc(strlen(resStr) + 1); - if ( NULL!=resStr_copy ) { - if ( NO_ERROR == ret ) + if ( NULL != resStr_copy ) { strcpy(resStr_copy, resStr); - pWidth = strtok_r( (char *) resStr_copy, sep, &ctx); + pWidth = strtok_r(resStr_copy, sep, &ctx); if ( NULL != pWidth ) { @@ -3258,9 +3974,9 @@ status_t CameraHal::parseResolution(const char *resStr, int &width, int &height) } } - free(resStr_copy); - resStr_copy = NULL; - } + free(resStr_copy); + resStr_copy = NULL; + LOG_FUNCTION_NAME_EXIT; return ret; @@ -3268,51 +3984,65 @@ status_t CameraHal::parseResolution(const char *resStr, int &width, int &height) void CameraHal::insertSupportedParams() { - char tmpBuffer[PARAM_BUFFER + 1]; - LOG_FUNCTION_NAME; - CameraParameters &p = mParameters; + 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(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES)); - p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS)); - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)); - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)); - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)); - p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES)); - p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE)); - p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS)); - p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES)); - p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES)); - p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES)); - p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING)); - p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX)); - p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN)); - p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP)); - p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES)); + 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)); + 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)); + 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(CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS)); - p.set(CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES)); - p.set(CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED)); - p.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED)); + 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)); - p.set(TICameraParameters::KEY_S3D_SUPPORTED,mCameraProperties->get(CameraProperties::S3D_SUPPORTED)); - p.set(TICameraParameters::KEY_S3D2D_PREVIEW_MODE,mCameraProperties->get(CameraProperties::S3D2D_PREVIEW_MODES)); - p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE)); - p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES)); - p.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED)); - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED)); - p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION)); - p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES)); - p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED)); - p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED)); - p.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED)); + 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)); + 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)); + p.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED, mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED)); + p.set(TICameraParameters::KEY_CAP_MODE_VALUES, mCameraProperties->get(CameraProperties::CAP_MODE_VALUES)); LOG_FUNCTION_NAME_EXIT; @@ -3323,13 +4053,16 @@ void CameraHal::initDefaultParameters() //Purpose of this function is to initialize the default current and supported parameters for the currently //selected camera. - CameraParameters &p = mParameters; + 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 ) @@ -3356,62 +4089,78 @@ void CameraHal::initDefaultParameters() if ( NO_ERROR == ret ) { - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); + p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); + p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); } else { - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH); - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT); + p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH); + p.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT); } - insertSupportedParams(); - //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(CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY)); - p.set(CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE)); - p.set(CameraParameters::KEY_EFFECT, mCameraProperties->get(CameraProperties::EFFECT)); - p.set(CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING)); - p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE)); - p.set(CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE)); - p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION)); - p.set(CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE)); - p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE)); - p.set(CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM)); + 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_S3D2D_PREVIEW, mCameraProperties->get(CameraProperties::S3D2D_PREVIEW)); - p.set(TICameraParameters::KEY_AUTOCONVERGENCE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE)); - p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES)); - p.set(CameraParameters::KEY_VIDEO_STABILIZATION, mCameraProperties->get(CameraProperties::VSTAB)); - p.set(CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH)); - p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE)); - p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE)); - p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,mCameraProperties->get(CameraProperties::FRAMERATE_RANGE)); + 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)); + 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)); + 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_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES)); p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE)); p.set(TICameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL)); - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY)); - p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar"); - p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES)); - p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES)); - + 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)); + p.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION, mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION)); // Only one area a.k.a Touch AF for now. // TODO: Add support for multiple focus areas. - p.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS)); - p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK)); - p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK)); - p.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_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)); + + // 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); LOG_FUNCTION_NAME_EXIT; } @@ -3427,7 +4176,9 @@ void CameraHal::forceStopPreview() LOG_FUNCTION_NAME; // stop bracketing if it is running - stopImageBracketing(); + if ( mBracketingRunning ) { + stopImageBracketing(); + } if(mDisplayAdapter.get() != NULL) { ///Stop the buffer display first @@ -3504,66 +4255,51 @@ status_t CameraHal::storeMetaDataInBuffers(bool enable) LOG_FUNCTION_NAME_EXIT; } -void CameraHal::selectFPSRange(int framerate, int *min_fps, int *max_fps) +void CameraHal::getPreferredPreviewRes(int *width, int *height) { - char * ptr; - char supported[MAX_PROP_VALUE_LENGTH]; - int fpsrangeArray[2]; - int i = 0; - - LOG_FUNCTION_NAME; - size_t size = strlen(mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED))+1; - strncpy(supported, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED), size); - - ptr = strtok (supported," (,)"); + LOG_FUNCTION_NAME; - while (ptr != NULL) - { - fpsrangeArray[i]= atoi(ptr)/CameraHal::VFR_SCALE; - if (i == 1) - { - if (framerate == fpsrangeArray[i]) - { - CAMHAL_LOGDB("SETTING FPS RANGE min = %d max = %d \n", fpsrangeArray[0], fpsrangeArray[1]); - *min_fps = fpsrangeArray[0]*CameraHal::VFR_SCALE; - *max_fps = fpsrangeArray[1]*CameraHal::VFR_SCALE; - break; - } - } - ptr = strtok (NULL, " (,)"); - i++; - i%=2; + // 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; - + LOG_FUNCTION_NAME_EXIT; } -void CameraHal::setPreferredPreviewRes(int width, int height) +void CameraHal::resetPreviewRes(android::CameraParameters *params) { LOG_FUNCTION_NAME; - if ( (width == 320) && (height == 240)){ - mParameters.setPreviewSize(640,480); - } - if ( (width == 176) && (height == 144)){ - mParameters.setPreviewSize(704,576); + if ( (mVideoWidth <= 320) && (mVideoHeight <= 240)){ + params->setPreviewSize(mVideoWidth, mVideoHeight); } LOG_FUNCTION_NAME_EXIT; } -void CameraHal::resetPreviewRes(CameraParameters *mParams, int width, int height) +void * +camera_buffer_get_omx_ptr (CameraBuffer *buffer) { - LOG_FUNCTION_NAME; - - if ( (width <= 320) && (height <= 240)){ - mParams->setPreviewSize(mVideoWidth, mVideoHeight); - } - - LOG_FUNCTION_NAME_EXIT; + CAMHAL_LOGV("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_LOGV("anw %08x", *handle); + return (void *)*handle; + } else if (buffer->type == CAMERA_BUFFER_ION) { + return (void *)buffer->fd; + } else { + CAMHAL_LOGV("other %08x", buffer->opaque); + return (void *)buffer->opaque; + } } -}; - - +} // namespace Camera +} // namespace Ti |