CameraHAL: Mechanical Misalignment parameter added

Mechanical misalignment param added in case of Stereo camera.
Supported values also added as capabilities.

Change-Id: I88b6e1f842b6d2ae60a096172da9193f53d16b0c
Signed-off-by: Yordan Lilov <ylilov@mm-sol.com>
Signed-off-by: Pavel Nedev <pnedev@mm-sol.com>

11 files changed, 123 insertions, 5 deletions

diff --git a/camera/CameraHal.cpp b/camera/CameraHal.cpp
index d64443a..d1f4d77 100644
--- a/camera/CameraHal.cpp
+++ b/camera/CameraHal.cpp
@@ -606,6 +606,12 @@ int CameraHal::setParameters(const CameraParameters& params)
             mParameters.set(TICameraParameters::KEY_MANUAL_CONVERGENCE, valstr);
              }
 
+        if( (valstr = params.get(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION)) != NULL)
+            {
+            CAMHAL_LOGDB("Mechanical Mialignment Correction is %s", valstr);
+            mParameters.set(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION, valstr);
+            }
+
         if ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL) {
             if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES))) {
                 CAMHAL_LOGDB("Exposure set = %s", valstr);
@@ -3342,6 +3348,7 @@ void CameraHal::insertSupportedParams()
     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_MECHANICAL_MISALIGNMENT_CORRECTION_VALUES, mCameraProperties->get(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION_VALUES));
 
     LOG_FUNCTION_NAME_EXIT;
 
@@ -3434,7 +3441,7 @@ void CameraHal::initDefaultParameters()
     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(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));
diff --git a/camera/CameraParameters.cpp b/camera/CameraParameters.cpp
index bfd3bd1..0107852 100644
--- a/camera/CameraParameters.cpp
+++ b/camera/CameraParameters.cpp
@@ -117,6 +117,8 @@ const char CameraProperties::VIDEO_SIZE[] = "video-size";
 const char CameraProperties::SUPPORTED_VIDEO_SIZES[] = "video-size-values";
 const char CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO[] = "preferred-preview-size-for-video";
 
+const char CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION[] = "prop-mechanical-misalignment-correction";
+const char CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION_VALUES[] = "prop-mechanical-misalignment-correction-values";
 
 const char CameraProperties::DEFAULT_VALUE[] = "";
 
diff --git a/camera/OMXCameraAdapter/OMXAlgo.cpp b/camera/OMXCameraAdapter/OMXAlgo.cpp
index d38c0ad..f166e3a 100644
--- a/camera/OMXCameraAdapter/OMXAlgo.cpp
+++ b/camera/OMXCameraAdapter/OMXAlgo.cpp
@@ -251,6 +251,14 @@ status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
             CAMHAL_LOGDB("AutoConvergenceMode %s", valstr);
         }
 
+    //Set Mechanical Misalignment Correction
+    valstr = params.get((const char *) TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION);
+    if ( valstr != NULL )
+        {
+        setMechanicalMisalignmentCorrection(valstr);
+        CAMHAL_LOGDB("Mechanical Misalignment Correction %s", valstr);
+        }
+
     LOG_FUNCTION_NAME_EXIT;
 
     return ret;
@@ -1195,4 +1203,30 @@ status_t OMXCameraAdapter::setVFramerate(OMX_U32 minFrameRate, OMX_U32 maxFrameR
     return ret;
  }
 
+status_t OMXCameraAdapter::setMechanicalMisalignmentCorrection(const char *mode)
+{
+    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.bMM = (OMX_BOOL)getLUTvalue_HALtoOMX(mode, mMechanicalMisalignmentCorrectionLUT);
+
+    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;
+}
+
 };
diff --git a/camera/OMXCameraAdapter/OMXCapabilities.cpp b/camera/OMXCameraAdapter/OMXCapabilities.cpp
index 8e3fc48..d5daa3d 100644
--- a/camera/OMXCameraAdapter/OMXCapabilities.cpp
+++ b/camera/OMXCameraAdapter/OMXCapabilities.cpp
@@ -234,7 +234,7 @@ const userToOMX_LUT OMXCameraAdapter::mAutoConvergence [] = {
     { TICameraParameters::AUTOCONVERGENCE_MODE_FRAME,   OMX_TI_AutoConvergenceModeFrame },
     { TICameraParameters::AUTOCONVERGENCE_MODE_CENTER,  OMX_TI_AutoConvergenceModeCenter },
     { TICameraParameters::AUTOCONVERGENCE_MODE_TOUCH,   OMX_TI_AutoConvergenceModeFocusFaceTouch },
-    { TICameraParameters::AUTOCONVERGENCE_MODE_MANUAL,  OMX_TI_AutoConvergenceModeManual },
+    { TICameraParameters::AUTOCONVERGENCE_MODE_MANUAL,  OMX_TI_AutoConvergenceModeManual }
 };
 
 const LUTtype OMXCameraAdapter::mAutoConvergenceLUT = {
@@ -242,6 +242,16 @@ const LUTtype OMXCameraAdapter::mAutoConvergenceLUT = {
     mAutoConvergence
 };
 
+const userToOMX_LUT OMXCameraAdapter::mMechanicalMisalignmentCorrection [] = {
+    { TICameraParameters::MECHANICAL_MISALIGNMENT_CORRECTION_DISABLE, OMX_FALSE },
+    { TICameraParameters::MECHANICAL_MISALIGNMENT_CORRECTION_ENABLE,  OMX_TRUE }
+};
+
+const LUTtype OMXCameraAdapter::mMechanicalMisalignmentCorrectionLUT = {
+    ARRAY_SIZE(mMechanicalMisalignmentCorrection),
+    mMechanicalMisalignmentCorrection
+};
+
 // values for supported camera facing direction
 const CapU32 OMXCameraAdapter::mFacing [] = {
     { OMX_TI_SENFACING_BACK , TICameraParameters::FACING_BACK },
@@ -1243,6 +1253,29 @@ status_t OMXCameraAdapter::insertManualConvergenceRange(CameraProperties::Proper
     return ret;
 }
 
+status_t OMXCameraAdapter::insertMechanicalMisalignmentCorrection(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps)
+{
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', sizeof(supported));
+
+    if (caps.bMechanicalMisalignmentSupported)
+    {
+        strncat(supported, TICameraParameters::MECHANICAL_MISALIGNMENT_CORRECTION_DISABLE, REMAINING_BYTES(supported));
+        strncat(supported, PARAM_SEP, REMAINING_BYTES(supported));
+        strncat(supported, TICameraParameters::MECHANICAL_MISALIGNMENT_CORRECTION_ENABLE, REMAINING_BYTES(supported));
+    }
+
+    params->set(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION_VALUES, supported);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
 status_t OMXCameraAdapter::insertDefaults(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps)
 {
     status_t ret = NO_ERROR;
@@ -1299,6 +1332,7 @@ status_t OMXCameraAdapter::insertDefaults(CameraProperties::Properties* params,
     params->set(CameraProperties::SENSOR_ORIENTATION, DEFAULT_SENSOR_ORIENTATION);
     params->set(CameraProperties::AUTOCONVERGENCE_MODE, DEFAULT_AUTOCONVERGENCE_MODE);
     params->set(CameraProperties::MANUAL_CONVERGENCE, DEFAULT_MANUAL_CONVERGENCE);
+    params->set(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION, DEFAULT_MECHANICAL_MISALIGNMENT_CORRECTION_MODE);
 
     LOG_FUNCTION_NAME_EXIT;
 
@@ -1411,6 +1445,10 @@ status_t OMXCameraAdapter::insertCapabilities(CameraProperties::Properties* para
         ret = insertManualConvergenceRange(params, caps);
     }
 
+    if ( NO_ERROR == ret) {
+        ret = insertMechanicalMisalignmentCorrection(params, caps);
+    }
+
     //NOTE: Ensure that we always call insertDefaults after inserting the supported capabilities
     //as there are checks inside insertDefaults to make sure a certain default is supported
     // or not
diff --git a/camera/OMXCameraAdapter/OMXDefaults.cpp b/camera/OMXCameraAdapter/OMXDefaults.cpp
index fa66339..d6de4f7 100644
--- a/camera/OMXCameraAdapter/OMXDefaults.cpp
+++ b/camera/OMXCameraAdapter/OMXDefaults.cpp
@@ -77,5 +77,6 @@ const char OMXCameraAdapter::DEFAULT_PREFERRED_PREVIEW_SIZE_FOR_VIDEO[] = "1920x
 const char OMXCameraAdapter::DEFAULT_SENSOR_ORIENTATION[] = "0";
 const char OMXCameraAdapter::DEFAULT_AUTOCONVERGENCE_MODE[] = "frame";
 const char OMXCameraAdapter::DEFAULT_MANUAL_CONVERGENCE[] = "0";
+const char OMXCameraAdapter::DEFAULT_MECHANICAL_MISALIGNMENT_CORRECTION_MODE[] = "enable";
 };
 
diff --git a/camera/TICameraParameters.cpp b/camera/TICameraParameters.cpp
index 724a529..600e191 100644
--- a/camera/TICameraParameters.cpp
+++ b/camera/TICameraParameters.cpp
@@ -206,5 +206,10 @@ const char TICameraParameters::ORIENTATION_SENSOR_90[] = "90";
 const char TICameraParameters::ORIENTATION_SENSOR_180[] = "180";
 const char TICameraParameters::ORIENTATION_SENSOR_270[] = "270";
 
+const char TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION[] = "mechanical-misalignment-correction";
+const char TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION_VALUES[] = "mechanical-misalignment-correction-values";
+
+const char TICameraParameters::MECHANICAL_MISALIGNMENT_CORRECTION_ENABLE[] = "enable";
+const char TICameraParameters::MECHANICAL_MISALIGNMENT_CORRECTION_DISABLE[] = "disable";
 };
 
diff --git a/camera/inc/CameraProperties.h b/camera/inc/CameraProperties.h
index c87719c..ba1058d 100644
--- a/camera/inc/CameraProperties.h
+++ b/camera/inc/CameraProperties.h
@@ -147,6 +147,9 @@ public:
     static const char SUPPORTED_VIDEO_SIZES[];
     static const char PREFERRED_PREVIEW_SIZE_FOR_VIDEO[];
 
+    static const char MECHANICAL_MISALIGNMENT_CORRECTION[];
+    static const char MECHANICAL_MISALIGNMENT_CORRECTION_VALUES[];
+
     CameraProperties();
     ~CameraProperties();
 
diff --git a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
index 1c4fb88..9c2fdcd 100644
--- a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
+++ b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
@@ -597,6 +597,7 @@ private:
     static status_t insertDefaults(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
     static status_t insertLocks(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
     static status_t insertAreas(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertMechanicalMisalignmentCorrection(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
     static status_t insertVideoSizes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
     static status_t insertFacing(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
     static status_t insertFocalLength(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
@@ -646,6 +647,9 @@ private:
 
     OMX_OTHER_EXTRADATATYPE *getExtradata(OMX_OTHER_EXTRADATATYPE *extraData, OMX_EXTRADATATYPE type);
 
+    // Mechanical Misalignment Correction
+    status_t setMechanicalMisalignmentCorrection(const char *mode);
+
     // DCC file data save
     status_t initDccFileDataSave(OMX_HANDLETYPE* omxHandle, int portIndex);
     status_t sniffDccFileDataSave(OMX_BUFFERHEADERTYPE* pBuffHeader);
@@ -754,6 +758,8 @@ private:
     static const CapU32 mFacing [];
     static const userToOMX_LUT mAutoConvergence [];
     static const LUTtype mAutoConvergenceLUT;
+    static const userToOMX_LUT mMechanicalMisalignmentCorrection[];
+    static const LUTtype mMechanicalMisalignmentCorrectionLUT;
 
     // OMX Camera defaults
     static const char DEFAULT_ANTIBANDING[];
@@ -805,6 +811,7 @@ private:
     static const char DEFAULT_FACING_SUPPORTED[];
     static const char DEFAULT_AUTOCONVERGENCE_MODE[];
     static const char DEFAULT_MANUAL_CONVERGENCE[];
+    static const char DEFAULT_MECHANICAL_MISALIGNMENT_CORRECTION_MODE[];
 
     static const size_t MAX_FOCUS_AREAS;
 
diff --git a/camera/inc/TICameraParameters.h b/camera/inc/TICameraParameters.h
index ae0f221..a2c111e 100644
--- a/camera/inc/TICameraParameters.h
+++ b/camera/inc/TICameraParameters.h
@@ -242,6 +242,11 @@ static const char ORIENTATION_SENSOR_270[];
 static const char FACING_FRONT[];
 static const char FACING_BACK[];
 
+static const char KEY_MECHANICAL_MISALIGNMENT_CORRECTION[];
+static const char KEY_MECHANICAL_MISALIGNMENT_CORRECTION_VALUES[];
+
+static const char MECHANICAL_MISALIGNMENT_CORRECTION_ENABLE[];
+static const char MECHANICAL_MISALIGNMENT_CORRECTION_DISABLE[];
 };
 
 };
diff --git a/test/CameraHal/camera_test.h b/test/CameraHal/camera_test.h
index ebc4a83..df32d5b 100644
--- a/test/CameraHal/camera_test.h
+++ b/test/CameraHal/camera_test.h
@@ -41,6 +41,8 @@
 #define KEY_AUTO_EXPOSURE_LOCK "auto-exposure-lock"
 #define KEY_AUTO_WHITEBALANCE_LOCK "auto-whitebalance-lock"
 
+#define KEY_MECHANICAL_MISALIGNMENT_CORRECTION "mechanical-misalignment-correction"
+
 #define SDCARD_PATH "/sdcard/"
 
 #define MAX_BURST   15
diff --git a/test/CameraHal/camera_test_menu.cpp b/test/CameraHal/camera_test_menu.cpp
index 3c189ae..251a78b 100644
--- a/test/CameraHal/camera_test_menu.cpp
+++ b/test/CameraHal/camera_test_menu.cpp
@@ -96,6 +96,8 @@ int wblockidx = 0;
 int afTimeoutIdx = 0;
 int platformID = BLAZE_TABLET2;
 
+int enableMisalignmentCorrectionIdx = 0;
+
 char dir_path[80] = SDCARD_PATH;
 
 const char *cameras[] = {"Primary Camera", "Secondary Camera 1", "Stereo Camera", "USB Camera", "Fake Camera"};
@@ -107,6 +109,8 @@ const char *faceDetection[] = {"disable", "enable"};
 const char *lock[] = {"false", "true"};
 const char *afTimeout[] = {"enable", "disable" };
 
+const char *misalignmentCorrection[] = {"enable", "disable" };
+
 #if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
 const char *ipp_mode[] = { "off", "Chroma Suppression", "Edge Enhancement" };
 #else
@@ -1388,6 +1392,8 @@ int functional_menu() {
         printf("   m. Metering mode:     %s\n" , metering[meter_mode]);
         printf("   <. Exposure Lock:     %s\n", lock[elockidx]);
         printf("   >. WhiteBalance Lock:  %s\n",lock[wblockidx]);
+        printf("   ). Mechanical Misalignment Correction:  %s\n",misalignmentCorrection[enableMisalignmentCorrectionIdx]);
+
         printf("\n");
         printf("   Choice: ");
     }
@@ -2140,10 +2146,18 @@ int functional_menu() {
         camera->setParameters(params.flatten());
       break;
 
-        default:
-            print_menu = 0;
+    case ')':
+      enableMisalignmentCorrectionIdx++;
+      enableMisalignmentCorrectionIdx %= ARRAY_SIZE(misalignmentCorrection);
+      params.set(KEY_MECHANICAL_MISALIGNMENT_CORRECTION, misalignmentCorrection[enableMisalignmentCorrectionIdx]);
+      if ( hardwareActive )
+        camera->setParameters(params.flatten());
+      break;
 
-            break;
+    default:
+      print_menu = 0;
+
+      break;
     }
 
     return 0;