Merge "CameraHal: Cuts down execution time of 'get-/setParameters()'" into jb-migration

Change-Id: Ic0cd6bc552836fa7410beb7b1fa877120dfb283e
Signed-off-by: Daniel Levin <dendy@ti.com>

10 files changed, 162 insertions, 151 deletions

diff --git a/camera/CameraHal.cpp b/camera/CameraHal.cpp
index 9be99c5..566fd7e 100644
--- a/camera/CameraHal.cpp
+++ b/camera/CameraHal.cpp
@@ -274,11 +274,12 @@ int CameraHal::setParameters(const android::CameraParameters& params)
     int framerate;
     int maxFPS, minFPS;
     const char *valstr = NULL;
+    int varint = 0;
     status_t ret = NO_ERROR;
     // Needed for KEY_RECORDING_HINT
     bool restartPreviewRequired = false;
     bool updateRequired = false;
-    android::CameraParameters oldParams(mParameters.flatten());
+    android::CameraParameters oldParams = mParameters;
 
 #ifdef V4L_CAMERA_ADAPTER
     if (strcmp (V4L_CAMERA_NAME_USB, mCameraProperties->get(CameraProperties::CAMERA_NAME)) == 0 ) {
@@ -306,10 +307,8 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             if ((valstr = params.get(TICameraParameters::KEY_VNF)) != NULL) {
                 if (strcmp(mCameraProperties->get(CameraProperties::VNF_SUPPORTED),
                            android::CameraParameters::TRUE) == 0) {
-                    CAMHAL_LOGDB("VNF %s",
-                                  params.get(TICameraParameters::KEY_VNF));
-                    mParameters.set(TICameraParameters::KEY_VNF,
-                                    params.get(TICameraParameters::KEY_VNF));
+                    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;
@@ -324,10 +323,8 @@ int CameraHal::setParameters(const android::CameraParameters& params)
                 // vstab then return an error
                 if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED),
                            android::CameraParameters::TRUE) == 0) {
-                    CAMHAL_LOGDB("VSTAB %s",
-                                  params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION));
-                    mParameters.set(android::CameraParameters::KEY_VIDEO_STABILIZATION,
-                                    params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION));
+                    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;
@@ -364,7 +361,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
 
             if ((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL) {
                 if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES))) {
-                    CAMHAL_LOGDB("IPP mode set %s", params.get(TICameraParameters::KEY_IPP));
+                    CAMHAL_LOGDB("IPP mode set %s", valstr);
                     mParameters.set(TICameraParameters::KEY_IPP, valstr);
                 } else {
                     CAMHAL_LOGEB("ERROR: Invalid IPP mode: %s", valstr);
@@ -405,6 +402,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
                 }
             }
 
+#ifdef OMAP_ENHANCEMENT
         int orientation =0;
         if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL)
             {
@@ -421,6 +419,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             CAMHAL_LOGD("Sensor Orientation is set to %d", orientation);
             mParameters.set(TICameraParameters::KEY_SENSOR_ORIENTATION, valstr);
             }
+#endif
 
         params.getPreviewSize(&w, &h);
         if (w == -1 && h == -1) {
@@ -462,7 +461,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             else
                 {
                 CAMHAL_LOGEA("Invalid RECORDING_HINT");
-                return -EINVAL;
+                return BAD_VALUE;
                 }
             }
         else
@@ -513,16 +512,6 @@ int CameraHal::setParameters(const android::CameraParameters& params)
              }
         }
 
-        ///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
@@ -553,7 +542,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
         CAMHAL_LOGDB("Picture Size by App %d x %d", w, h);
 
         if ( (valstr = params.getPictureFormat()) != NULL ) {
-            if (isParameterValid(params.getPictureFormat(),mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS))) {
+            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)) {
@@ -566,14 +555,14 @@ int CameraHal::setParameters(const android::CameraParameters& params)
                 mParameters.setPictureFormat(valstr);
             } else {
                 CAMHAL_LOGEB("ERROR: Invalid picture format: %s",valstr);
-                ret = -EINVAL;
+                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", params.get(TICameraParameters::KEY_BURST));
+                CAMHAL_LOGDB("Burst set %s", valstr);
                 mParameters.set(TICameraParameters::KEY_BURST, valstr);
             } else {
                 CAMHAL_LOGEB("ERROR: Invalid Burst value: %s",valstr);
@@ -663,6 +652,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             mParameters.set(TICameraParameters::KEY_GLBCE, android::CameraParameters::FALSE);
         }
 
+#ifdef OMAP_ENHANCEMENT_S3D
         ///Update the current parameter set
         if ( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE)) != NULL ) {
             CAMHAL_LOGDB("AutoConvergence mode set = %s", valstr);
@@ -748,6 +738,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
                 return BAD_VALUE;
             }
         }
+#endif
 
         if ((valstr = params.get(android::CameraParameters::KEY_WHITE_BALANCE)) != NULL) {
            if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE))) {
@@ -759,6 +750,7 @@ int CameraHal::setParameters(const android::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);
@@ -798,6 +790,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
                 return BAD_VALUE;
             }
          }
+#endif
 
         if ((valstr = params.get(android::CameraParameters::KEY_ANTIBANDING)) != NULL) {
             if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING))) {
@@ -809,6 +802,7 @@ int CameraHal::setParameters(const android::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);
@@ -818,6 +812,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
                 return BAD_VALUE;
             }
         }
+#endif
 
         if( (valstr = params.get(android::CameraParameters::KEY_FOCUS_AREAS)) != NULL )
             {
@@ -825,6 +820,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             mParameters.set(android::CameraParameters::KEY_FOCUS_AREAS, valstr);
             }
 
+#ifdef OMAP_ENHANCEMENT
         if( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
             {
             CAMHAL_LOGDB("Measurements set to %s", valstr);
@@ -844,6 +840,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
                 }
 
             }
+#endif
 
         if( (valstr = params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL)
             {
@@ -884,40 +881,35 @@ int CameraHal::setParameters(const android::CameraParameters& params)
              }
         }
 
-        if(( (valstr = params.get(android::CameraParameters::KEY_ROTATION)) != NULL)
-            && (params.getInt(android::CameraParameters::KEY_ROTATION) >=0))
-            {
-            CAMHAL_LOGDB("Rotation set %s", params.get(android::CameraParameters::KEY_ROTATION));
-            mParameters.set(android::CameraParameters::KEY_ROTATION, valstr);
-            }
+        varint = params.getInt(android::CameraParameters::KEY_ROTATION);
+        if ( varint >= 0 ) {
+            CAMHAL_LOGDB("Rotation set %d", varint);
+            mParameters.set(android::CameraParameters::KEY_ROTATION, varint);
+        }
 
-        if(( (valstr = params.get(android::CameraParameters::KEY_JPEG_QUALITY)) != NULL)
-            && (params.getInt(android::CameraParameters::KEY_JPEG_QUALITY) >=0))
-            {
-            CAMHAL_LOGDB("Jpeg quality set %s", params.get(android::CameraParameters::KEY_JPEG_QUALITY));
-            mParameters.set(android::CameraParameters::KEY_JPEG_QUALITY, valstr);
-            }
+        varint = params.getInt(android::CameraParameters::KEY_JPEG_QUALITY);
+        if ( varint >= 0 ) {
+            CAMHAL_LOGDB("Jpeg quality set %d", varint);
+            mParameters.set(android::CameraParameters::KEY_JPEG_QUALITY, varint);
+        }
 
-        if(( (valstr = params.get(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH)) != NULL)
-            && (params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH) >=0))
-            {
-            CAMHAL_LOGDB("Thumbnail width set %s", params.get(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH));
-            mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, valstr);
-            }
+        varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
+        if ( varint >= 0 ) {
+            CAMHAL_LOGDB("Thumbnail width set %d", varint);
+            mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, varint);
+        }
 
-        if(( (valstr = params.get(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT)) != NULL)
-            && (params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT) >=0))
-            {
-            CAMHAL_LOGDB("Thumbnail width set %s", params.get(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT));
-            mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, valstr);
-            }
+        varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
+        if ( varint >= 0 ) {
+            CAMHAL_LOGDB("Thumbnail width set %d", varint);
+            mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, varint);
+        }
 
-        if(( (valstr = params.get(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)) != NULL )
-            && (params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY) >=0))
-            {
-            CAMHAL_LOGDB("Thumbnail quality set %s", params.get(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY));
-            mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, valstr);
-            }
+        varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
+        if ( varint >= 0 ) {
+            CAMHAL_LOGDB("Thumbnail quality set %d", varint);
+            mParameters.set(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, varint);
+        }
 
         if( (valstr = params.get(android::CameraParameters::KEY_GPS_LATITUDE)) != NULL )
             {
@@ -953,7 +945,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
 
         if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL )
             {
-            CAMHAL_LOGDB("GPS datestamp set %s", params.get(TICameraParameters::KEY_GPS_DATESTAMP));
+            CAMHAL_LOGDB("GPS datestamp set %s", valstr);
             mParameters.set(TICameraParameters::KEY_GPS_DATESTAMP, valstr);
             }else{
                 mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP);
@@ -969,7 +961,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
 
         if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL )
             {
-            CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_MAPDATUM));
+            CAMHAL_LOGDB("GPS MAPDATUM set %s", valstr);
             mParameters.set(TICameraParameters::KEY_GPS_MAPDATUM, valstr);
             }else{
                 mParameters.remove(TICameraParameters::KEY_GPS_MAPDATUM);
@@ -977,7 +969,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
 
         if( (valstr = params.get(TICameraParameters::KEY_GPS_VERSION)) != NULL )
             {
-            CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_VERSION));
+            CAMHAL_LOGDB("GPS MAPDATUM set %s", valstr);
             mParameters.set(TICameraParameters::KEY_GPS_VERSION, valstr);
             }else{
                 mParameters.remove(TICameraParameters::KEY_GPS_VERSION);
@@ -985,16 +977,17 @@ int CameraHal::setParameters(const android::CameraParameters& params)
 
         if( (valstr = params.get(TICameraParameters::KEY_EXIF_MODEL)) != NULL )
             {
-            CAMHAL_LOGDB("EXIF Model set %s", params.get(TICameraParameters::KEY_EXIF_MODEL));
+            CAMHAL_LOGDB("EXIF Model set %s", valstr);
             mParameters.set(TICameraParameters::KEY_EXIF_MODEL, valstr);
             }
 
         if( (valstr = params.get(TICameraParameters::KEY_EXIF_MAKE)) != NULL )
             {
-            CAMHAL_LOGDB("EXIF Make set %s", params.get(TICameraParameters::KEY_EXIF_MAKE));
+            CAMHAL_LOGDB("EXIF Make set %s", valstr);
             mParameters.set(TICameraParameters::KEY_EXIF_MAKE, valstr);
             }
 
+#ifdef OMAP_ENHANCEMENT
         if( (valstr = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL )
             {
             CAMHAL_LOGDB("Exposure Bracketing set %s", params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE));
@@ -1016,11 +1009,12 @@ int CameraHal::setParameters(const android::CameraParameters& params)
         } else {
             mParameters.remove(TICameraParameters::KEY_ZOOM_BRACKETING_RANGE);
         }
+#endif
 
         if ((valstr = params.get(android::CameraParameters::KEY_ZOOM)) != NULL ) {
-            if ((params.getInt(android::CameraParameters::KEY_ZOOM) >= 0 ) &&
-                (params.getInt(android::CameraParameters::KEY_ZOOM) <= mMaxZoomSupported )) {
-                CAMHAL_LOGDB("Zoom set %s", valstr);
+            varint = atoi(valstr);
+            if ( varint >= 0 && varint <= mMaxZoomSupported ) {
+                CAMHAL_LOGDB("Zoom set %d", varint);
                 doesSetParameterNeedUpdate(valstr,
                                            mParameters.get(android::CameraParameters::KEY_ZOOM),
                                            updateRequired);
@@ -1033,7 +1027,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
 
         if( (valstr = params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL )
           {
-            CAMHAL_LOGDB("Auto Exposure Lock set %s", params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
+            CAMHAL_LOGDB("Auto Exposure Lock set %s", valstr);
             doesSetParameterNeedUpdate(valstr,
                                        mParameters.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK),
                                        updateRequired);
@@ -1042,7 +1036,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
 
         if( (valstr = params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL )
           {
-            CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
+            CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", valstr);
             doesSetParameterNeedUpdate(valstr,
                                        mParameters.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK),
                                        updateRequired);
@@ -1103,6 +1097,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
 
         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);
@@ -1149,6 +1144,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             adapterParams.remove(TICameraParameters::KEY_TEMP_BRACKETING);
             mParameters.remove(TICameraParameters::KEY_TEMP_BRACKETING);
         }
+#endif
 
 #ifdef OMAP_ENHANCEMENT_VTC
         if (mVTCUseCase && !mTunnelSetup && (mCameraAdapter != NULL) &&
@@ -1173,6 +1169,7 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             ret |= mCameraAdapter->setParameters(adapterParams);
         }
 
+#ifdef OMAP_ENHANCEMENT
         if( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
             ( strcmp(valstr, android::CameraParameters::TRUE) == 0 ))
             {
@@ -1191,12 +1188,12 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             mMsgEnabled &= ~CAMERA_MSG_SHUTTER;
             mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
             }
-
+#endif
     }
 
     //On fail restore old parameters
     if ( NO_ERROR != ret ) {
-        mParameters.unflatten(oldParams.flatten());
+        mParameters = oldParams;
     }
 
     // Restart Preview if needed by KEY_RECODING_HINT only if preview is already running.
@@ -2331,6 +2328,7 @@ status_t CameraHal::startRecording( )
 bool CameraHal::setVideoModeParameters(const android::CameraParameters& params)
 {
     const char *valstr = NULL;
+    const char *valstrRemote = NULL;
     bool restartPreviewRequired = false;
 
     LOG_FUNCTION_NAME;
@@ -2345,19 +2343,19 @@ bool CameraHal::setVideoModeParameters(const android::CameraParameters& params)
         restartPreviewRequired = true;
         }
 
-   // set VSTAB. restart is required if vstab value has changed
-   if (params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION) != NULL) {
+    // 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, params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION)) != 0) {
+                 strcmp(valstr, valstrRemote) != 0) {
                 restartPreviewRequired = true;
             }
             mParameters.set(android::CameraParameters::KEY_VIDEO_STABILIZATION,
-                            params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION));
+                            valstrRemote);
         }
     } else if (mParameters.get(android::CameraParameters::KEY_VIDEO_STABILIZATION)) {
         // vstab was configured but now unset
@@ -2366,16 +2364,16 @@ bool CameraHal::setVideoModeParameters(const android::CameraParameters& params)
     }
 
     // Set VNF
-    if (params.get(TICameraParameters::KEY_VNF) == NULL) {
+    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, params.get(TICameraParameters::KEY_VNF)) != 0) {
+        if (valstr && strcmp(valstr, valstrRemote) != 0) {
             restartPreviewRequired = true;
         }
-        mParameters.set(TICameraParameters::KEY_VNF, params.get(TICameraParameters::KEY_VNF));
+        mParameters.set(TICameraParameters::KEY_VNF, valstrRemote);
     }
 
     // For VSTAB alone for 1080p resolution, padded width goes > 2048, which cannot be rendered by GPU.
diff --git a/camera/OMXCameraAdapter/OMX3A.cpp b/camera/OMXCameraAdapter/OMX3A.cpp
index 2a0b111..9f87e87 100644
--- a/camera/OMXCameraAdapter/OMX3A.cpp
+++ b/camera/OMXCameraAdapter/OMX3A.cpp
@@ -70,6 +70,7 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
     status_t ret = NO_ERROR;
     int mode = 0;
     const char *str = NULL;
+    int varint = 0;
     BaseCameraAdapter::AdapterState nextState;
     BaseCameraAdapter::getNextState(nextState);
 
@@ -106,6 +107,7 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
         CAMHAL_LOGVB("SceneMode %d", mParameters3A.SceneMode);
     }
 
+#ifdef OMAP_ENHANCEMENT
     if ( (str = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL ) {
         mode = getLUTvalue_HALtoOMX(str, ExpLUT);
         if ( mParameters3A.Exposure != mode ) {
@@ -149,6 +151,7 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
             }
         }
     }
+#endif
 
     str = params.get(android::CameraParameters::KEY_WHITE_BALANCE);
     mode = getLUTvalue_HALtoOMX( str, WBalLUT);
@@ -162,53 +165,55 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
             }
         }
 
-    if ( 0 <= params.getInt(TICameraParameters::KEY_CONTRAST) )
+#ifdef OMAP_ENHANCEMENT
+    varint = params.getInt(TICameraParameters::KEY_CONTRAST);
+    if ( 0 <= varint )
         {
         if ( mFirstTimeInit ||
-             ( (mParameters3A.Contrast  + CONTRAST_OFFSET) !=
-                     params.getInt(TICameraParameters::KEY_CONTRAST)) )
+             ( (mParameters3A.Contrast  + CONTRAST_OFFSET) != varint ) )
             {
-            mParameters3A.Contrast = params.getInt(TICameraParameters::KEY_CONTRAST) - CONTRAST_OFFSET;
+            mParameters3A.Contrast = varint - CONTRAST_OFFSET;
             CAMHAL_LOGDB("Contrast %d", mParameters3A.Contrast);
             mPending3Asettings |= SetContrast;
             }
         }
 
-    if ( 0 <= params.getInt(TICameraParameters::KEY_SHARPNESS) )
+    varint = params.getInt(TICameraParameters::KEY_SHARPNESS);
+    if ( 0 <= varint )
         {
         if ( mFirstTimeInit ||
-             ((mParameters3A.Sharpness + SHARPNESS_OFFSET) !=
-                     params.getInt(TICameraParameters::KEY_SHARPNESS)))
+             ((mParameters3A.Sharpness + SHARPNESS_OFFSET) != varint ))
             {
-            mParameters3A.Sharpness = params.getInt(TICameraParameters::KEY_SHARPNESS) - SHARPNESS_OFFSET;
+            mParameters3A.Sharpness = varint - SHARPNESS_OFFSET;
             CAMHAL_LOGDB("Sharpness %d", mParameters3A.Sharpness);
             mPending3Asettings |= SetSharpness;
             }
         }
 
-    if ( 0 <= params.getInt(TICameraParameters::KEY_SATURATION) )
+    varint = params.getInt(TICameraParameters::KEY_SATURATION);
+    if ( 0 <= varint )
         {
         if ( mFirstTimeInit ||
-             ((mParameters3A.Saturation + SATURATION_OFFSET) !=
-                     params.getInt(TICameraParameters::KEY_SATURATION)) )
+             ((mParameters3A.Saturation + SATURATION_OFFSET) != varint ) )
             {
-            mParameters3A.Saturation = params.getInt(TICameraParameters::KEY_SATURATION) - SATURATION_OFFSET;
+            mParameters3A.Saturation = varint - SATURATION_OFFSET;
             CAMHAL_LOGDB("Saturation %d", mParameters3A.Saturation);
             mPending3Asettings |= SetSaturation;
             }
         }
 
-    if ( 0 <= params.getInt(TICameraParameters::KEY_BRIGHTNESS) )
+    varint = params.getInt(TICameraParameters::KEY_BRIGHTNESS);
+    if ( 0 <= varint )
         {
         if ( mFirstTimeInit ||
-             (( mParameters3A.Brightness !=
-                     ( unsigned int ) params.getInt(TICameraParameters::KEY_BRIGHTNESS))) )
+             (( mParameters3A.Brightness != varint )) )
             {
-            mParameters3A.Brightness = (unsigned)params.getInt(TICameraParameters::KEY_BRIGHTNESS);
+            mParameters3A.Brightness = (unsigned) varint;
             CAMHAL_LOGDB("Brightness %d", mParameters3A.Brightness);
             mPending3Asettings |= SetBrightness;
             }
         }
+#endif
 
     str = params.get(android::CameraParameters::KEY_ANTIBANDING);
     mode = getLUTvalue_HALtoOMX(str,FlickerLUT);
@@ -222,6 +227,7 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
             }
         }
 
+#ifdef OMAP_ENHANCEMENT
     str = params.get(TICameraParameters::KEY_ISO);
     mode = getLUTvalue_HALtoOMX(str, IsoLUT);
     CAMHAL_LOGVB("ISO mode arrived in HAL : %s", str);
@@ -234,6 +240,7 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
             mPending3Asettings |= SetISO;
             }
         }
+#endif
 
     str = params.get(android::CameraParameters::KEY_FOCUS_MODE);
     mode = getLUTvalue_HALtoOMX(str, FocusLUT);
@@ -252,15 +259,10 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
         }
 
     str = params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION);
-    if ( mFirstTimeInit ||
-          (( str != NULL ) &&
-                  (mParameters3A.EVCompensation !=
-                          params.getInt(android::CameraParameters::KEY_EXPOSURE_COMPENSATION))))
-        {
-        CAMHAL_LOGDB("Setting EV Compensation to %d",
-                     params.getInt(android::CameraParameters::KEY_EXPOSURE_COMPENSATION));
-
-        mParameters3A.EVCompensation = params.getInt(android::CameraParameters::KEY_EXPOSURE_COMPENSATION);
+    varint = params.getInt(android::CameraParameters::KEY_EXPOSURE_COMPENSATION);
+    if ( mFirstTimeInit || (str && (mParameters3A.EVCompensation != varint))) {
+        CAMHAL_LOGDB("Setting EV Compensation to %d", varint);
+        mParameters3A.EVCompensation = varint;
         mPending3Asettings |= SetEVCompensation;
         }
 
diff --git a/camera/OMXCameraAdapter/OMXAlgo.cpp b/camera/OMXCameraAdapter/OMXAlgo.cpp
index e96a472..9765f68 100644
--- a/camera/OMXCameraAdapter/OMXAlgo.cpp
+++ b/camera/OMXCameraAdapter/OMXAlgo.cpp
@@ -220,6 +220,8 @@ status_t OMXCameraAdapter::setParametersAlgo(const android::CameraParameters &pa
         mOMXStateSwitch = true;
         }
 
+#ifdef OMAP_ENHANCEMENT
+
     //Set Auto Convergence Mode
     valstr = params.get((const char *) TICameraParameters::KEY_AUTOCONVERGENCE_MODE);
     valManualStr = params.get(TICameraParameters::KEY_MANUAL_CONVERGENCE);
@@ -245,6 +247,8 @@ status_t OMXCameraAdapter::setParametersAlgo(const android::CameraParameters &pa
         }
     }
 
+#endif
+
     LOG_FUNCTION_NAME_EXIT;
 
     return ret;
diff --git a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
index a83707d..f2c1129 100644
--- a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
+++ b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
@@ -644,6 +644,7 @@ status_t OMXCameraAdapter::setParameters(const android::CameraParameters &params
         mOMXStateSwitch = true;
         }
 
+#ifdef OMAP_ENHANCEMENT
     if ( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
         {
         if (strcmp(valstr, android::CameraParameters::TRUE) == 0)
@@ -664,9 +665,12 @@ status_t OMXCameraAdapter::setParameters(const android::CameraParameters &params
         //Disable measurement data by default
         mMeasurementEnabled = false;
         }
+#endif
 
+#ifdef OMAP_ENHANCEMENT_S3D
     setParamS3D(mCameraAdapterParameters.mPrevPortIndex,
                params.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT));
+#endif
 
     ret |= setParametersCapture(params, state);
 
@@ -819,6 +823,7 @@ void OMXCameraAdapter::getParameters(android::CameraParameters& params)
                    mParameters.get(android::CameraParameters::KEY_FOCUS_DISTANCES));
         }
 
+#ifdef OMAP_ENHANCEMENT
     OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSUREVALUETYPE);
     exp.nPortIndex = OMX_ALL;
 
@@ -833,6 +838,7 @@ void OMXCameraAdapter::getParameters(android::CameraParameters& params)
         {
         CAMHAL_LOGEB("OMX error 0x%x, while retrieving current ISO value", eError);
         }
+#endif
 
     {
     android::AutoMutex lock(mZoomLock);
diff --git a/camera/OMXCameraAdapter/OMXCapture.cpp b/camera/OMXCameraAdapter/OMXCapture.cpp
index d5de2cf..d5c2d00 100644
--- a/camera/OMXCameraAdapter/OMXCapture.cpp
+++ b/camera/OMXCameraAdapter/OMXCapture.cpp
@@ -38,6 +38,7 @@ status_t OMXCameraAdapter::setParametersCapture(const android::CameraParameters
     OMX_COLOR_FORMATTYPE pixFormat;
     CodingMode codingMode = mCodingMode;
     const char *valstr = NULL;
+    int varint = 0;
     OMX_TI_STEREOFRAMELAYOUTTYPE capFrmLayout;
     bool inCaptureState = false;
 
@@ -145,6 +146,7 @@ status_t OMXCameraAdapter::setParametersCapture(const android::CameraParameters
         mCodingMode = codingMode;
     }
 
+#ifdef OMAP_ENHANCEMENT
     str = params.get(TICameraParameters::KEY_TEMP_BRACKETING);
     if ( ( str != NULL ) &&
          ( strcmp(str, android::CameraParameters::TRUE) == 0 ) ) {
@@ -203,6 +205,7 @@ status_t OMXCameraAdapter::setParametersCapture(const android::CameraParameters
         }
         mZoomBracketingEnabled = false;
     }
+#endif
 
     // Flush config queue
     // If TRUE: Flush queue and abort processing before enqueing
@@ -233,11 +236,12 @@ status_t OMXCameraAdapter::setParametersCapture(const android::CameraParameters
 
     CAMHAL_LOGVB("Picture Rotation set %d", mPictureRotation);
 
+#ifdef OMAP_ENHANCEMENT
     // Read Sensor Orientation and set it based on perating mode
-
-    if ( params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION) != -1 )
+    varint = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION);
+    if ( varint != -1 )
         {
-        mSensorOrientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION);
+        mSensorOrientation = varint;
         if (mSensorOrientation == 270 ||mSensorOrientation==90)
             {
             CAMHAL_LOGEA(" Orientation is 270/90. So setting counter rotation to Ducati");
@@ -251,14 +255,16 @@ status_t OMXCameraAdapter::setParametersCapture(const android::CameraParameters
         }
 
     CAMHAL_LOGVB("Sensor Orientation  set : %d", mSensorOrientation);
+#endif
 
 #ifdef OMAP_ENHANCEMENT_BURST_CAPTURE
-    if ( params.getInt(TICameraParameters::KEY_BURST)  >= 1 )
+    varint = params.getInt(TICameraParameters::KEY_BURST);
+    if ( varint >= 1 )
         {
-        if (params.getInt(TICameraParameters::KEY_BURST) != (int) mBurstFrames) {
+        if (varint != (int) mBurstFrames) {
             mPendingCaptureSettings |= SetBurst;
         }
-        mBurstFrames = params.getInt(TICameraParameters::KEY_BURST);
+        mBurstFrames = varint;
         }
     else
         {
@@ -269,67 +275,63 @@ status_t OMXCameraAdapter::setParametersCapture(const android::CameraParameters
     CAMHAL_LOGVB("Burst Frames set %d", mBurstFrames);
 #endif
 
-    if ( ( params.getInt(android::CameraParameters::KEY_JPEG_QUALITY)  >= MIN_JPEG_QUALITY ) &&
-         ( params.getInt(android::CameraParameters::KEY_JPEG_QUALITY)  <= MAX_JPEG_QUALITY ) )
-        {
-        if (params.getInt(android::CameraParameters::KEY_JPEG_QUALITY) != (int) mPictureQuality) {
+    varint = params.getInt(android::CameraParameters::KEY_JPEG_QUALITY);
+    if ( varint >= MIN_JPEG_QUALITY && varint <= MAX_JPEG_QUALITY ) {
+        if (varint != mPictureQuality) {
             mPendingCaptureSettings |= SetQuality;
+            mPictureQuality = varint;
         }
-        mPictureQuality = params.getInt(android::CameraParameters::KEY_JPEG_QUALITY);
-        }
-    else
-        {
-        if (mPictureQuality != MAX_JPEG_QUALITY) mPendingCaptureSettings |= SetQuality;
-        mPictureQuality = MAX_JPEG_QUALITY;
+    } else {
+        if (mPictureQuality != MAX_JPEG_QUALITY) {
+            mPendingCaptureSettings |= SetQuality;
+            mPictureQuality = MAX_JPEG_QUALITY;
         }
+    }
 
     CAMHAL_LOGVB("Picture Quality set %d", mPictureQuality);
 
-    if ( params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH)  >= 0 )
-        {
-        if (params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH) != (int) mThumbWidth) {
+    varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
+    if ( varint >= 0 ) {
+        if (varint != mThumbWidth) {
             mPendingCaptureSettings |= SetThumb;
+            mThumbWidth = varint;
         }
-        mThumbWidth = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
-        }
-    else
-        {
-        if (mThumbWidth != DEFAULT_THUMB_WIDTH) mPendingCaptureSettings |= SetThumb;
-        mThumbWidth = DEFAULT_THUMB_WIDTH;
+    } else {
+        if (mThumbWidth != DEFAULT_THUMB_WIDTH) {
+            mPendingCaptureSettings |= SetThumb;
+            mThumbWidth = DEFAULT_THUMB_WIDTH;
         }
-
+    }
 
     CAMHAL_LOGVB("Picture Thumb width set %d", mThumbWidth);
 
-    if ( params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT)  >= 0 )
-        {
-        if (params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT) != (int) mThumbHeight) {
+    varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
+    if ( varint >= 0 ) {
+        if (varint != mThumbHeight) {
             mPendingCaptureSettings |= SetThumb;
+            mThumbHeight = varint;
         }
-        mThumbHeight = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
-        }
-    else
-        {
-        if (mThumbHeight != DEFAULT_THUMB_HEIGHT) mPendingCaptureSettings |= SetThumb;
-        mThumbHeight = DEFAULT_THUMB_HEIGHT;
+    } else {
+        if (mThumbHeight != DEFAULT_THUMB_HEIGHT) {
+            mPendingCaptureSettings |= SetThumb;
+            mThumbHeight = DEFAULT_THUMB_HEIGHT;
         }
-
+    }
 
     CAMHAL_LOGVB("Picture Thumb height set %d", mThumbHeight);
 
-    if ( ( params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)  >= MIN_JPEG_QUALITY ) &&
-         ( params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)  <= MAX_JPEG_QUALITY ) )
-        {
-        if (params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY) != (int) mThumbQuality) {
+    varint = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
+    if ( varint >= MIN_JPEG_QUALITY && varint <= MAX_JPEG_QUALITY ) {
+        if (varint != mThumbQuality) {
             mPendingCaptureSettings |= SetThumb;
+            mThumbQuality = varint;
         }
-        mThumbQuality = params.getInt(android::CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
-        }
-    else
-        {
-        if (mThumbQuality != MAX_JPEG_QUALITY) mPendingCaptureSettings |= SetThumb;
-        mThumbQuality = MAX_JPEG_QUALITY;
+    } else {
+        if (mThumbQuality != MAX_JPEG_QUALITY) {
+            mPendingCaptureSettings |= SetThumb;
+            mThumbQuality = MAX_JPEG_QUALITY;
         }
+    }
 
     CAMHAL_LOGDB("Thumbnail Quality set %d", mThumbQuality);
 
diff --git a/libI420colorconvert/Android.mk b/libI420colorconvert/Android.mk
index aa792ba..ec54d31 100644
--- a/libI420colorconvert/Android.mk
+++ b/libI420colorconvert/Android.mk
@@ -7,8 +7,8 @@ LOCAL_SRC_FILES := \
     ColorConvert.cpp
 
 LOCAL_C_INCLUDES:= \
-        $(TOP)/frameworks/native/include/media/openmax \
-        $(TOP)/frameworks/native/include/media/editor
+        $(TOP)/frameworks/base/include/media/stagefright/openmax \
+        $(TOP)/frameworks/media/libvideoeditor/include
 
 LOCAL_SHARED_LIBRARIES :=       \
 
diff --git a/libI420colorconvert/ColorConvert.cpp b/libI420colorconvert/ColorConvert.cpp
index 7f9d93d..05194d2 100644
--- a/libI420colorconvert/ColorConvert.cpp
+++ b/libI420colorconvert/ColorConvert.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <II420ColorConverter.h>
+#include "II420ColorConverter.h"
 #include <OMX_IVCommon.h>
 #include <string.h>
 
diff --git a/libstagefrighthw/Android.mk b/libstagefrighthw/Android.mk
index cf18f69..c1757f2 100644
--- a/libstagefrighthw/Android.mk
+++ b/libstagefrighthw/Android.mk
@@ -7,8 +7,7 @@ LOCAL_SRC_FILES := \
     TIOMXPlugin.cpp
 
 LOCAL_C_INCLUDES:= \
-        $(TOP)/frameworks/native/include/media/openmax \
-        $(TOP)/frameworks/native/include/media/hardware
+        $(TOP)/frameworks/base/include/media/stagefright/openmax
 
 LOCAL_SHARED_LIBRARIES :=       \
         libbinder               \
diff --git a/libstagefrighthw/TIOMXPlugin.cpp b/libstagefrighthw/TIOMXPlugin.cpp
index bd97b77..b04c7b9 100644
--- a/libstagefrighthw/TIOMXPlugin.cpp
+++ b/libstagefrighthw/TIOMXPlugin.cpp
@@ -18,7 +18,7 @@
 
 #include <dlfcn.h>
 
-#include <HardwareAPI.h>
+#include <media/stagefright/HardwareAPI.h>
 
 namespace android {
 
diff --git a/libstagefrighthw/TIOMXPlugin.h b/libstagefrighthw/TIOMXPlugin.h
index 7b2e982..668c5ef 100644
--- a/libstagefrighthw/TIOMXPlugin.h
+++ b/libstagefrighthw/TIOMXPlugin.h
@@ -18,7 +18,7 @@
 
 #define TI_OMX_PLUGIN_H_
 
-#include <OMXPluginBase.h>
+#include <media/stagefright/OMXPluginBase.h>
 
 namespace android {