summaryrefslogtreecommitdiffstats
path: root/camera/OMXCameraAdapter/OMXAlgo.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'camera/OMXCameraAdapter/OMXAlgo.cpp')
-rw-r--r--camera/OMXCameraAdapter/OMXAlgo.cpp571
1 files changed, 325 insertions, 246 deletions
diff --git a/camera/OMXCameraAdapter/OMXAlgo.cpp b/camera/OMXCameraAdapter/OMXAlgo.cpp
index 12b9058..84090e9 100644
--- a/camera/OMXCameraAdapter/OMXAlgo.cpp
+++ b/camera/OMXCameraAdapter/OMXAlgo.cpp
@@ -21,70 +21,82 @@
*
*/
-#undef LOG_TAG
-
-#define LOG_TAG "CameraHAL"
-
#include "CameraHal.h"
#include "OMXCameraAdapter.h"
#include "ErrorUtils.h"
#undef TRUE
-namespace android {
+namespace Ti {
+namespace Camera {
-status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
+status_t OMXCameraAdapter::setParametersAlgo(const android::CameraParameters &params,
BaseCameraAdapter::AdapterState state)
{
status_t ret = NO_ERROR;
const char *valstr = NULL;
+ const char *valManualStr = NULL;
const char *oldstr = NULL;
+ OMXCameraPortParameters *cap;
+ BrightnessMode gbce = BRIGHTNESS_OFF;
+ BrightnessMode glbce = BRIGHTNESS_OFF;
LOG_FUNCTION_NAME;
CaptureMode capMode;
CAMHAL_LOGDB("Capture mode %s", params.get(TICameraParameters::KEY_CAP_MODE));
- if ( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL )
- {
- if (strcmp(valstr, (const char *) TICameraParameters::HIGH_PERFORMANCE_MODE) == 0)
- {
+ if ( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL ) {
+ if (strcmp(valstr, (const char *) TICameraParameters::HIGH_PERFORMANCE_MODE) == 0) {
capMode = OMXCameraAdapter::HIGH_SPEED;
- }
- else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_MODE) == 0)
- {
+ mCapabilitiesOpMode = MODE_HIGH_SPEED;
+ } else if (strcmp(valstr, (const char *) TICameraParameters::EXPOSURE_BRACKETING) == 0) {
+ capMode = OMXCameraAdapter::HIGH_SPEED;
+ mCapabilitiesOpMode = MODE_HIGH_SPEED;
+ } else if (strcmp(valstr, (const char *) TICameraParameters::ZOOM_BRACKETING) == 0) {
+ capMode = OMXCameraAdapter::HIGH_SPEED;
+ mCapabilitiesOpMode = MODE_HIGH_SPEED;
+ } else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_MODE) == 0) {
capMode = OMXCameraAdapter::HIGH_QUALITY;
- }
- else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_ZSL_MODE) == 0)
- {
+ mCapabilitiesOpMode = MODE_HIGH_QUALITY;
+ } else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_ZSL_MODE) == 0) {
capMode = OMXCameraAdapter::HIGH_QUALITY_ZSL;
- }
- else if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0)
- {
+ mCapabilitiesOpMode = MODE_ZEROSHUTTERLAG;
+ } else if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0) {
capMode = OMXCameraAdapter::VIDEO_MODE;
- }
- else
- {
+ mCapabilitiesOpMode = MODE_VIDEO;
+ } else if (strcmp(valstr, (const char *) TICameraParameters::CP_CAM_MODE) == 0) {
+ capMode = OMXCameraAdapter::CP_CAM;
+ mCapabilitiesOpMode = MODE_CPCAM;
+ } else if (strcmp(valstr, (const char *) TICameraParameters::TEMP_BRACKETING) == 0) {
+ capMode = OMXCameraAdapter::HIGH_SPEED;
+ mCapabilitiesOpMode = MODE_HIGH_SPEED;
+ } else {
capMode = OMXCameraAdapter::HIGH_QUALITY;
- }
+ mCapabilitiesOpMode = MODE_HIGH_QUALITY;
}
- else
- {
- capMode = OMXCameraAdapter::HIGH_QUALITY_ZSL;
- }
+ } else {
+ capMode = OMXCameraAdapter::HIGH_QUALITY;
+ mCapabilitiesOpMode = MODE_HIGH_QUALITY;
+ }
- if ( mCapMode != capMode )
- {
+ if ( mSensorIndex == 2 ) {
+ mCapabilitiesOpMode = MODE_STEREO;
+ }
+
+ if ( mCapMode != capMode ) {
mCapMode = capMode;
mOMXStateSwitch = true;
- }
+ mPendingPreviewSettings |= SetCapMode;
+ }
CAMHAL_LOGDB("Capture Mode set %d", mCapMode);
/// Configure IPP, LDCNSF, GBCE and GLBCE only in HQ mode
IPPMode ipp;
if((mCapMode == OMXCameraAdapter::HIGH_QUALITY) || (mCapMode == OMXCameraAdapter::HIGH_QUALITY_ZSL)
- || (mCapMode == OMXCameraAdapter::VIDEO_MODE) )
+ || (mCapMode == OMXCameraAdapter::VIDEO_MODE)
+ || (mCapMode == OMXCameraAdapter::CP_CAM))
{
if ( (valstr = params.get(TICameraParameters::KEY_IPP)) != NULL )
{
@@ -116,95 +128,57 @@ status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
CAMHAL_LOGVB("IPP Mode set %d", ipp);
- if (((valstr = params.get(TICameraParameters::KEY_GBCE)) != NULL) )
- {
- // Configure GBCE only if the setting has changed since last time
- oldstr = mParams.get(TICameraParameters::KEY_GBCE);
- bool cmpRes = true;
- if ( NULL != oldstr )
- {
- cmpRes = strcmp(valstr, oldstr) != 0;
- }
- else
- {
- cmpRes = true;
- }
-
+ if (((valstr = params.get(TICameraParameters::KEY_GBCE)) != NULL) ) {
+ if (strcmp(valstr, android::CameraParameters::TRUE ) == 0) {
+ gbce = BRIGHTNESS_ON;
+ } else {
+ gbce = BRIGHTNESS_OFF;
+ }
- if( cmpRes )
- {
- if (strcmp(valstr, ( const char * ) TICameraParameters::GBCE_ENABLE ) == 0)
- {
- setGBCE(OMXCameraAdapter::BRIGHTNESS_ON);
- }
- else if (strcmp(valstr, ( const char * ) TICameraParameters::GBCE_DISABLE ) == 0)
- {
- setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
- }
- else
- {
- setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
- }
- }
+ if ( gbce != mGBCE ) {
+ mGBCE = gbce;
+ setGBCE(mGBCE);
}
- else if(mParams.get(TICameraParameters::KEY_GBCE) || mFirstTimeInit)
- {
+
+ } else if(mFirstTimeInit) {
//Disable GBCE by default
setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
- }
+ }
- if ( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL )
- {
- // Configure GLBCE only if the setting has changed since last time
-
- oldstr = mParams.get(TICameraParameters::KEY_GLBCE);
- bool cmpRes = true;
- if ( NULL != oldstr )
- {
- cmpRes = strcmp(valstr, oldstr) != 0;
- }
- else
- {
- cmpRes = true;
- }
+ if ( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL ) {
+ if (strcmp(valstr, android::CameraParameters::TRUE) == 0) {
+ glbce = BRIGHTNESS_ON;
+ } else {
+ glbce = BRIGHTNESS_OFF;
+ }
- if( cmpRes )
- {
- if (strcmp(valstr, ( const char * ) TICameraParameters::GLBCE_ENABLE ) == 0)
- {
- setGLBCE(OMXCameraAdapter::BRIGHTNESS_ON);
- }
- else if (strcmp(valstr, ( const char * ) TICameraParameters::GLBCE_DISABLE ) == 0)
- {
- setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
- }
- else
- {
- setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
- }
- }
+ if ( glbce != mGLBCE ) {
+ mGLBCE = glbce;
+ setGLBCE(mGLBCE);
}
- else if(mParams.get(TICameraParameters::KEY_GLBCE) || mFirstTimeInit)
- {
+
+ } else if(mFirstTimeInit) {
//Disable GLBCE by default
setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
- }
}
- else
- {
+
+ } else {
ipp = OMXCameraAdapter::IPP_NONE;
- }
+ }
if ( mIPP != ipp )
{
mIPP = ipp;
mOMXStateSwitch = true;
+ mPendingPreviewSettings |= SetLDC;
+ mPendingPreviewSettings |= SetNSF;
}
///Set VNF Configuration
bool vnfEnabled = false;
- if ( params.getInt(TICameraParameters::KEY_VNF) > 0 )
+ valstr = params.get(TICameraParameters::KEY_VNF);
+ if (valstr && strcmp(valstr, android::CameraParameters::TRUE) == 0)
{
CAMHAL_LOGDA("VNF Enabled");
vnfEnabled = true;
@@ -219,12 +193,13 @@ status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
{
mVnfEnabled = vnfEnabled;
mOMXStateSwitch = true;
+ mPendingPreviewSettings |= SetVNF;
}
///Set VSTAB Configuration
bool vstabEnabled = false;
- valstr = params.get(CameraParameters::KEY_VIDEO_STABILIZATION);
- if (valstr && strcmp(valstr, CameraParameters::TRUE) == 0) {
+ valstr = params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION);
+ if (valstr && strcmp(valstr, android::CameraParameters::TRUE) == 0) {
CAMHAL_LOGDA("VSTAB Enabled");
vstabEnabled = true;
}
@@ -238,6 +213,7 @@ status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
{
mVstabEnabled = vstabEnabled;
mOMXStateSwitch = true;
+ mPendingPreviewSettings |= SetVSTAB;
}
//A work-around for a failing call to OMX flush buffers
@@ -250,35 +226,30 @@ status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
#ifdef OMAP_ENHANCEMENT
//Set Auto Convergence Mode
- valstr = params.get((const char *) TICameraParameters::KEY_AUTOCONVERGENCE);
- if ( valstr != NULL )
- {
- // Set ManualConvergence default value
- OMX_S32 manualconvergence = -30;
- if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_DISABLE) == 0 )
- {
- setAutoConvergence(OMX_TI_AutoConvergenceModeDisable, manualconvergence);
+ valstr = params.get((const char *) TICameraParameters::KEY_AUTOCONVERGENCE_MODE);
+ valManualStr = params.get(TICameraParameters::KEY_MANUAL_CONVERGENCE);
+
+ cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+
+ if (cap->mFrameLayoutType != OMX_TI_StereoFrameLayout2D) {
+ if ((valstr != NULL) || (valManualStr != NULL)) {
+ setAutoConvergence(valstr, valManualStr, params);
+ if (valstr != NULL) {
+ CAMHAL_LOGDB("AutoConvergenceMode %s", valstr);
+ }
+ if (valManualStr != NULL) {
+ CAMHAL_LOGDB("Manual Convergence %s", valManualStr);
}
- else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_FRAME) == 0 )
- {
- setAutoConvergence(OMX_TI_AutoConvergenceModeFrame, manualconvergence);
- }
- else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_CENTER) == 0 )
- {
- setAutoConvergence(OMX_TI_AutoConvergenceModeCenter, manualconvergence);
- }
- else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_FFT) == 0 )
- {
- setAutoConvergence(OMX_TI_AutoConvergenceModeFocusFaceTouch, manualconvergence);
- }
- else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_MANUAL) == 0 )
- {
- manualconvergence = (OMX_S32)params.getInt(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES);
- setAutoConvergence(OMX_TI_AutoConvergenceModeManual, manualconvergence);
- }
- CAMHAL_LOGVB("AutoConvergenceMode %s, value = %d", valstr, (int) manualconvergence);
}
+ //Set Mechanical Misalignment Correction
+ valstr = params.get(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION);
+ if ( valstr != NULL ) {
+ setMechanicalMisalignmentCorrection(strcmp(valstr, android::CameraParameters::TRUE) == 0);
+ CAMHAL_LOGDB("Mechanical Misalignment Correction %s", valstr);
+ }
+ }
+
#endif
LOG_FUNCTION_NAME_EXIT;
@@ -286,67 +257,123 @@ status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
return ret;
}
-// Get AutoConvergence
-status_t OMXCameraAdapter::getAutoConvergence(OMX_TI_AUTOCONVERGENCEMODETYPE *pACMode,
- OMX_S32 *pManualConverence)
+// Set AutoConvergence
+status_t OMXCameraAdapter::setAutoConvergence(const char *pValstr, const char *pValManualstr, const android::CameraParameters &params)
{
status_t ret = NO_ERROR;
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_TI_CONFIG_CONVERGENCETYPE ACParams;
-
- ACParams.nSize = sizeof(OMX_TI_CONFIG_CONVERGENCETYPE);
- ACParams.nVersion = mLocalVersionParam;
- ACParams.nPortIndex = OMX_ALL;
+ const char *str = NULL;
+ android::Vector<android::sp<CameraArea> > tempAreas;
+ int mode;
+ int changed = 0;
LOG_FUNCTION_NAME;
- eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
- (OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence,
- &ACParams);
- if ( eError != OMX_ErrorNone )
- {
- CAMHAL_LOGEB("Error while getting AutoConvergence 0x%x", eError);
- ret = -EINVAL;
+ if ( pValManualstr != NULL ) {
+ OMX_S32 manualConvergence = (OMX_S32)strtol(pValManualstr ,0 ,0);
+
+ if (mManualConv != manualConvergence) {
+ mManualConv = manualConvergence;
+ changed = 1;
}
- else
- {
- *pManualConverence = ACParams.nManualConverence;
- *pACMode = ACParams.eACMode;
- CAMHAL_LOGDA("AutoConvergence got successfully");
+ }
+
+ if ( pValstr != NULL ) {
+ mode = getLUTvalue_HALtoOMX(pValstr, mAutoConvergenceLUT);
+
+ if ( NAME_NOT_FOUND == mode ) {
+ CAMHAL_LOGEB("Wrong convergence mode: %s", pValstr);
+ LOG_FUNCTION_NAME_EXIT;
+ return mode;
}
- LOG_FUNCTION_NAME_EXIT;
+ if ( mAutoConv != static_cast<OMX_TI_AUTOCONVERGENCEMODETYPE> (mode) ) {
+ mAutoConv = static_cast<OMX_TI_AUTOCONVERGENCEMODETYPE> (mode);
+ changed = 1;
+ }
+ }
- return ret;
-}
+ if ( OMX_TI_AutoConvergenceModeFocusFaceTouch == mAutoConv ) {
+ android::AutoMutex lock(mTouchAreasLock);
-// Set AutoConvergence
-status_t OMXCameraAdapter::setAutoConvergence(OMX_TI_AUTOCONVERGENCEMODETYPE pACMode,
- OMX_S32 pManualConverence)
-{
- status_t ret = NO_ERROR;
- OMX_ERRORTYPE eError = OMX_ErrorNone;
- OMX_TI_CONFIG_CONVERGENCETYPE ACParams;
+ str = params.get(android::CameraParameters::KEY_METERING_AREAS);
- LOG_FUNCTION_NAME;
+ if ( NULL != str ) {
+ ret = CameraArea::parseAreas(str, ( strlen(str) + 1 ), tempAreas);
+ } else {
+ CAMHAL_LOGEB("Touch areas not received in %s",
+ android::CameraParameters::KEY_METERING_AREAS);
+ LOG_FUNCTION_NAME_EXIT;
+ return BAD_VALUE;
+ }
+
+ if ( CameraArea::areAreasDifferent(mTouchAreas, tempAreas) ) {
+ mTouchAreas.clear();
+ mTouchAreas = tempAreas;
+ changed = 1;
+ }
+ }
- ACParams.nSize = sizeof(OMX_TI_CONFIG_CONVERGENCETYPE);
+ if (!changed) {
+ LOG_FUNCTION_NAME_EXIT;
+ return NO_ERROR;
+ }
+
+ OMXCameraPortParameters * mPreviewData;
+ mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+
+ ACParams.nSize = (OMX_U32)sizeof(OMX_TI_CONFIG_CONVERGENCETYPE);
ACParams.nVersion = mLocalVersionParam;
ACParams.nPortIndex = OMX_ALL;
- ACParams.nManualConverence = pManualConverence;
- ACParams.eACMode = pACMode;
+
+ OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+ (OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence,
+ &ACParams);
+
+ ACParams.eACMode = mAutoConv;
+ ACParams.nManualConverence = mManualConv;
+
+ if (1 == mTouchAreas.size()) {
+ int widthDivisor = 1;
+ int heightDivisor = 1;
+
+ if (mPreviewData->mFrameLayoutType == OMX_TI_StereoFrameLayoutTopBottom) {
+ heightDivisor = 2;
+ }
+ if (mPreviewData->mFrameLayoutType == OMX_TI_StereoFrameLayoutLeftRight) {
+ widthDivisor = 2;
+ }
+
+ // transform the coordinates to 3A-type coordinates
+ mTouchAreas.itemAt(0)->transfrom((size_t)mPreviewData->mWidth/widthDivisor,
+ (size_t)mPreviewData->mHeight/heightDivisor,
+ (size_t&) ACParams.nACProcWinStartY,
+ (size_t&) ACParams.nACProcWinStartX,
+ (size_t&) ACParams.nACProcWinWidth,
+ (size_t&) ACParams.nACProcWinHeight);
+ }
+
+ CAMHAL_LOGDB("nSize %d", (int)ACParams.nSize);
+ CAMHAL_LOGDB("nPortIndex %d", (int)ACParams.nPortIndex);
+ CAMHAL_LOGDB("nManualConverence %d", (int)ACParams.nManualConverence);
+ CAMHAL_LOGDB("eACMode %d", (int)ACParams.eACMode);
+ CAMHAL_LOGDB("nACProcWinStartX %d", (int)ACParams.nACProcWinStartX);
+ CAMHAL_LOGDB("nACProcWinStartY %d", (int)ACParams.nACProcWinStartY);
+ CAMHAL_LOGDB("nACProcWinWidth %d", (int)ACParams.nACProcWinWidth);
+ CAMHAL_LOGDB("nACProcWinHeight %d", (int)ACParams.nACProcWinHeight);
+ CAMHAL_LOGDB("bACStatus %d", (int)ACParams.bACStatus);
+
eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
(OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence,
&ACParams);
- if ( eError != OMX_ErrorNone )
- {
+
+ if ( eError != OMX_ErrorNone ) {
CAMHAL_LOGEB("Error while setting AutoConvergence 0x%x", eError);
- ret = -EINVAL;
- }
- else
- {
+ ret = BAD_VALUE;
+ } else {
CAMHAL_LOGDA("AutoConvergence applied successfully");
- }
+ }
LOG_FUNCTION_NAME_EXIT;
@@ -603,17 +630,18 @@ status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode)
status_t ret = NO_ERROR;
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_CONFIG_CAMOPERATINGMODETYPE camMode;
- OMX_TI_PARAM_ZSLHISTORYLENTYPE zslHistoryLen;
OMX_CONFIG_BOOLEANTYPE bCAC;
+#ifndef OMAP_TUNA
+ OMX_TI_CONFIG_SINGLEPREVIEWMODETYPE singlePrevMode;
+#endif
LOG_FUNCTION_NAME;
- //ZSL have 4 buffers history by default
- OMX_INIT_STRUCT_PTR (&zslHistoryLen, OMX_TI_PARAM_ZSLHISTORYLENTYPE);
- zslHistoryLen.nHistoryLen = 4;
-
//CAC is disabled by default
OMX_INIT_STRUCT_PTR (&bCAC, OMX_CONFIG_BOOLEANTYPE);
+#ifndef OMAP_TUNA
+ OMX_INIT_STRUCT_PTR (&singlePrevMode, OMX_TI_CONFIG_SINGLEPREVIEWMODETYPE);
+#endif
bCAC.bEnabled = OMX_FALSE;
if ( NO_ERROR == ret )
@@ -622,14 +650,32 @@ status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode)
OMX_INIT_STRUCT_PTR (&camMode, OMX_CONFIG_CAMOPERATINGMODETYPE);
if ( mSensorIndex == OMX_TI_StereoSensor )
{
- CAMHAL_LOGDA("Camera mode: STEREO");
- camMode.eCamOperatingMode = OMX_CaptureStereoImageCapture;
+#ifndef OMAP_TUNA
+ if ( OMXCameraAdapter::VIDEO_MODE == mode ) {
+ CAMHAL_LOGDA("Camera mode: STEREO VIDEO");
+ camMode.eCamOperatingMode = OMX_TI_StereoVideo;
+ } else {
+#endif
+ CAMHAL_LOGDA("Camera mode: STEREO");
+ camMode.eCamOperatingMode = OMX_CaptureStereoImageCapture;
+#ifndef OMAP_TUNA
+ }
+#endif
}
else if ( OMXCameraAdapter::HIGH_SPEED == mode )
{
CAMHAL_LOGDA("Camera mode: HIGH SPEED");
camMode.eCamOperatingMode = OMX_CaptureImageHighSpeedTemporalBracketing;
}
+ else if ( OMXCameraAdapter::CP_CAM == mode )
+ {
+ CAMHAL_LOGDA("Camera mode: CP CAM");
+#ifndef OMAP_TUNA
+ camMode.eCamOperatingMode = OMX_TI_CPCam;
+ // TODO(XXX): Hardcode for now until we implement re-proc pipe
+ singlePrevMode.eMode = OMX_TI_SinglePreviewMode_ImageCaptureHighSpeed;
+#endif
+ }
else if( OMXCameraAdapter::HIGH_QUALITY == mode )
{
CAMHAL_LOGDA("Camera mode: HIGH QUALITY");
@@ -641,9 +687,11 @@ status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode)
CAMHAL_LOGDA("Camera mode: HIGH QUALITY_ZSL");
camMode.eCamOperatingMode = OMX_TI_CaptureImageProfileZeroShutterLag;
+#ifdef CAMERAHAL_TUNA
if ( !mIternalRecordingHint ) {
zslHistoryLen.nHistoryLen = 5;
}
+#endif
}
else if( OMXCameraAdapter::VIDEO_MODE == mode )
@@ -660,31 +708,12 @@ status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode)
if( NO_ERROR == ret )
{
eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
- ( OMX_INDEXTYPE ) OMX_TI_IndexParamZslHistoryLen,
- &zslHistoryLen);
- if ( OMX_ErrorNone != eError )
- {
- CAMHAL_LOGEB("Error while configuring ZSL History len 0x%x", eError);
- // Don't return status for now
- // as high history values might lead
- // to errors on some platforms.
- // ret = ErrorUtils::omxToAndroidError(eError);
- }
- else
- {
- CAMHAL_LOGDA("ZSL History len configured successfully");
- }
- }
-
- if( NO_ERROR == ret )
- {
- eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
( OMX_INDEXTYPE ) OMX_IndexCameraOperatingMode,
&camMode);
if ( OMX_ErrorNone != eError )
{
CAMHAL_LOGEB("Error while configuring camera mode 0x%x", eError);
- ret = ErrorUtils::omxToAndroidError(eError);
+ ret = Utils::ErrorUtils::omxToAndroidError(eError);
}
else
{
@@ -692,6 +721,21 @@ status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode)
}
}
+#ifndef OMAP_TUNA
+ if((NO_ERROR == ret) && (OMXCameraAdapter::CP_CAM == mode)) {
+ //Configure Single Preview Mode
+ eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+ ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSinglePreviewMode,
+ &singlePrevMode);
+ if ( OMX_ErrorNone != eError ) {
+ CAMHAL_LOGEB("Error while configuring single preview mode 0x%x", eError);
+ ret = Utils::ErrorUtils::omxToAndroidError(eError);
+ } else {
+ CAMHAL_LOGDA("single preview mode configured successfully");
+ }
+ }
+#endif
+
if( NO_ERROR == ret )
{
//Configure CAC
@@ -701,7 +745,7 @@ status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode)
if ( OMX_ErrorNone != eError )
{
CAMHAL_LOGEB("Error while configuring CAC 0x%x", eError);
- ret = ErrorUtils::omxToAndroidError(eError);
+ ret = Utils::ErrorUtils::omxToAndroidError(eError);
}
else
{
@@ -1009,7 +1053,7 @@ status_t OMXCameraAdapter::setAlgoPriority(AlgoPriority priority,
LOG_FUNCTION_NAME_EXIT;
- return ErrorUtils::omxToAndroidError(eError);
+ return Utils::ErrorUtils::omxToAndroidError(eError);
}
status_t OMXCameraAdapter::setPictureRotation(unsigned int degree)
@@ -1055,76 +1099,83 @@ status_t OMXCameraAdapter::setSensorOrientation(unsigned int degree)
OMXCameraPortParameters *mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
LOG_FUNCTION_NAME;
- if ( OMX_StateInvalid == mComponentState )
- {
+ if ( OMX_StateInvalid == mComponentState ) {
CAMHAL_LOGEA("OMX component is in invalid state");
ret = -1;
- }
+ }
/* Set Temproary Port resolution.
- * For resolution with height > 1008,resolution cannot be set without configuring orientation.
+ * For resolution with height >= 720,
+ * resolution cannot be set without configuring orientation.
* So we first set a temp resolution. We have used VGA
*/
- tmpHeight = mPreviewData->mHeight;
- tmpWidth = mPreviewData->mWidth;
- mPreviewData->mWidth = 640;
- mPreviewData->mHeight = 480;
- ret = setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData);
- if ( ret != NO_ERROR )
- {
- CAMHAL_LOGEB("setFormat() failed %d", ret);
+ if ( mPreviewData->mHeight >= 720 ) {
+ tmpHeight = mPreviewData->mHeight;
+ tmpWidth = mPreviewData->mWidth;
+ mPreviewData->mWidth = 640;
+ mPreviewData->mHeight = 480;
+
+ ret = setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData);
+ if ( NO_ERROR != ret ) {
+ CAMHAL_LOGEB("Error while configuring format 0x%x", ret);
+ return ret;
}
+ mPreviewData->mWidth = tmpWidth;
+ mPreviewData->mHeight = tmpHeight;
+ mPreviewPortInitialized = true;
+ }
+ else if (!mPreviewPortInitialized) {
+ ret = setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData);
+ if ( NO_ERROR != ret ) {
+ CAMHAL_LOGEB("Error while configuring format 0x%x", ret);
+ return ret;
+ }
+ mPreviewPortInitialized = true;
+ }
+
/* Now set Required Orientation*/
- if ( NO_ERROR == ret )
- {
+ if ( NO_ERROR == ret ) {
OMX_INIT_STRUCT(sensorOrientation, OMX_CONFIG_ROTATIONTYPE);
sensorOrientation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
- eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
- OMX_IndexConfigCommonRotate,
- &sensorOrientation);
- if ( OMX_ErrorNone != eError )
- {
- CAMHAL_LOGEB("Error while Reading Sensor Orientation : 0x%x", eError);
- }
- CAMHAL_LOGVB(" Currently Sensor Orientation is set to : %d",
- ( unsigned int ) sensorOrientation.nRotation);
- sensorOrientation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
sensorOrientation.nRotation = degree;
eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
OMX_IndexConfigCommonRotate,
&sensorOrientation);
- if ( OMX_ErrorNone != eError )
- {
+ if ( OMX_ErrorNone != eError ) {
CAMHAL_LOGEB("Error while configuring rotation 0x%x", eError);
- }
- CAMHAL_LOGVA(" Read the Parameters that are set");
- eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
- OMX_IndexConfigCommonRotate,
- &sensorOrientation);
- if ( OMX_ErrorNone != eError )
- {
- CAMHAL_LOGEB("Error while Reading Sensor Orientation : 0x%x", eError);
- }
+ }
CAMHAL_LOGVB(" Currently Sensor Orientation is set to : %d",
( unsigned int ) sensorOrientation.nRotation);
CAMHAL_LOGVB(" Sensor Configured for Port : %d",
( unsigned int ) sensorOrientation.nPortIndex);
- }
+ }
/* Now set the required resolution as requested */
+ if ( NO_ERROR == ret ) {
+ bool portConfigured = false;
+ ret = setSensorQuirks(degree,
+ mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex],
+ portConfigured);
+ if ( NO_ERROR != ret ) {
+ CAMHAL_LOGEB("Error while configuring setSensorQuirks 0x%x", ret);
+ return ret;
+ }
- mPreviewData->mWidth = tmpWidth;
- mPreviewData->mHeight = tmpHeight;
- if ( NO_ERROR == ret )
- {
- ret = setFormat (mCameraAdapterParameters.mPrevPortIndex,
- mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]);
- if ( NO_ERROR != ret )
- {
- CAMHAL_LOGEB("setFormat() failed %d", ret);
+ if ( !portConfigured ) {
+ ret = setFormat (mCameraAdapterParameters.mPrevPortIndex,
+ mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]);
+ if ( NO_ERROR != ret ) {
+ CAMHAL_LOGEB("Error while configuring format 0x%x", ret);
+ return ret;
}
+
+ // Another WA: Setting the port definition will reset the VFR
+ // configuration.
+ setVFramerate(mPreviewData->mMinFrameRate,
+ mPreviewData->mMaxFrameRate);
}
+ }
LOG_FUNCTION_NAME_EXIT;
@@ -1146,9 +1197,7 @@ status_t OMXCameraAdapter::setVFramerate(OMX_U32 minFrameRate, OMX_U32 maxFrameR
ret = -EINVAL;
}
- // The port framerate should never be smaller
- // than max framerate.
- if ( mPreviewData->mFrameRate < maxFrameRate ) {
+ if ( !mSetFormatDone ) {
return NO_INIT;
}
@@ -1175,6 +1224,36 @@ status_t OMXCameraAdapter::setVFramerate(OMX_U32 minFrameRate, OMX_U32 maxFrameR
}
return ret;
- }
+}
+
+#ifndef OMAP_TUNA
+status_t OMXCameraAdapter::setMechanicalMisalignmentCorrection(const bool enable)
+{
+ status_t ret = NO_ERROR;
+ OMX_ERRORTYPE eError = OMX_ErrorNone;
+ OMX_TI_CONFIG_MM mm;
+
+ LOG_FUNCTION_NAME;
+
+ mm.nVersion = mLocalVersionParam;
+ mm.nSize = sizeof(OMX_TI_CONFIG_MM);
+ mm.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+ mm.bMM = enable ? OMX_TRUE : OMX_FALSE;
+
+ eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+ (OMX_INDEXTYPE)OMX_TI_IndexConfigMechanicalMisalignment,
+ &mm);
+
+ if(OMX_ErrorNone != eError) {
+ CAMHAL_LOGEB("Error while enabling mechanical misalignment correction. error = 0x%x", eError);
+ ret = -1;
+ }
+
+ LOG_FUNCTION_NAME_EXIT;
+
+ return ret;
+}
+#endif
-};
+} // namespace Camera
+} // namespace Ti
generated by cgit v1.1 at 2024-05-14 00:30:38 +0000