CameraHal: Queries picture sizes dynamically

- Currently the picture sizes are static and
  will not change with the capture mode. For
  some use-cases this is not sufficient.
  To overcome this the Properties class is
  extended to support an operating mode, which
  will switch the supported properties depending
  on the current setting. Additionally the
  Ducati capabilities are queried not only for
  one capture mode alone but for all use-cases
  in 2D and 3D. As a result once the camera
  client switches the capture mode, the supported
  picture sizes will change inside CameraParameters
  retrieved through a subsequent "getParameters()"
  call.

Related UI patch: http://review.omapzoom.org/#/c/21685

Signed-off-by: Emilian Peev <epeev@mm-sol.com>
Signed-off-by: Daniel Levin <dendy@ti.com>
Change-Id: Ib9f02ede94ff76feb86b3422dc453dfd8782ee43

9 files changed, 236 insertions, 107 deletions

diff --git a/camera/CameraHal.cpp b/camera/CameraHal.cpp
index b4f9843..bb8e207 100644
--- a/camera/CameraHal.cpp
+++ b/camera/CameraHal.cpp
@@ -332,8 +332,19 @@ int CameraHal::setParameters(const CameraParameters& params)
                     if (strcmp(TICameraParameters::VIDEO_MODE, valstr)) {
                         mCapModeBackup = valstr;
                     }
-                CAMHAL_LOGDB("Capture mode set %s", params.get(TICameraParameters::KEY_CAP_MODE));
-                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);
                 }
 
             if ((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL) {
diff --git a/camera/CameraParameters.cpp b/camera/CameraParameters.cpp
index 7d5952e..f9a444b 100644
--- a/camera/CameraParameters.cpp
+++ b/camera/CameraParameters.cpp
@@ -163,64 +163,75 @@ int CameraProperties::getProperties(int cameraIndex, CameraProperties::Propertie
     return 0;
 }
 
-ssize_t CameraProperties::Properties::set(const char *prop, const char *value)
-{
-    if(!prop)
-        return -EINVAL;
-    if(!value)
-        value = DEFAULT_VALUE;
+void CameraProperties::Properties::set(const char * const prop, const char * const value) {
+    CAMHAL_ASSERT(prop);
 
-    return mProperties->replaceValueFor(String8(prop), String8(value));
+    if ( !value ) {
+        mProperties[mCurrentMode].removeItem(String8(prop));
+    } else {
+        mProperties[mCurrentMode].replaceValueFor(String8(prop), String8(value));
+    }
 }
 
-ssize_t CameraProperties::Properties::set(const char *prop, int value)
-{
+void CameraProperties::Properties::set(const char * const prop, const int value) {
     char s_val[30];
-
     sprintf(s_val, "%d", value);
-
-    return set(prop, s_val);
+    set(prop, s_val);
 }
 
-const char* CameraProperties::Properties::get(const char * prop)
-{
-    String8 value = mProperties->valueFor(String8(prop));
-    return value.string();
+const char* CameraProperties::Properties::get(const char * prop) const {
+    return mProperties[mCurrentMode].valueFor(String8(prop)).string();
 }
 
-int CameraProperties::Properties::getInt(const char * prop)
-{
-    String8 value = mProperties->valueFor(String8(prop));
+int CameraProperties::Properties::getInt(const char * prop) const {
+    String8 value = mProperties[mCurrentMode].valueFor(String8(prop));
     if (value.isEmpty()) {
         return -1;
     }
     return strtol(value, 0, 0);
 }
 
-void CameraProperties::Properties::dump()
-{
-    for (size_t i = 0; i < mProperties->size(); i++)
-    {
-        CAMHAL_LOGDB("%s = %s\n",
-                        mProperties->keyAt(i).string(),
-                        mProperties->valueAt(i).string());
+void CameraProperties::Properties::setSensorIndex(int idx) {
+    OperatingMode originalMode = getMode();
+    for ( int i = 0 ; i < MODE_MAX ; i++ ) {
+        setMode(static_cast<OperatingMode>(i));
+        set(CAMERA_SENSOR_INDEX, idx);
     }
+    setMode(originalMode);
 }
 
-const char* CameraProperties::Properties::keyAt(unsigned int index)
-{
-    if(index < mProperties->size())
-    {
-        return mProperties->keyAt(index).string();
+void CameraProperties::Properties::setMode(OperatingMode mode) {
+    CAMHAL_ASSERT(mode >= 0 && mode < MODE_MAX);
+    mCurrentMode = mode;
+}
+
+OperatingMode CameraProperties::Properties::getMode() const {
+    return mCurrentMode;
+}
+
+void CameraProperties::Properties::dump() {
+    CAMHAL_LOGD("================================");
+    CAMHAL_LOGD("Dumping properties for camera: %d", getInt("prop-sensor-index"));
+
+    for (size_t i = 0; i < mProperties[mCurrentMode].size(); i++) {
+        CAMHAL_LOGD("%s = %s",
+                mProperties[mCurrentMode].keyAt(i).string(),
+                mProperties[mCurrentMode].valueAt(i).string());
+    }
+
+    CAMHAL_LOGD("--------------------------------");
+}
+
+const char* CameraProperties::Properties::keyAt(const unsigned int index) const {
+    if (index < mProperties[mCurrentMode].size()) {
+        return mProperties[mCurrentMode].keyAt(index).string();
     }
     return NULL;
 }
 
-const char* CameraProperties::Properties::valueAt(unsigned int index)
-{
-    if(index < mProperties->size())
-    {
-        return mProperties->valueAt(index).string();
+const char* CameraProperties::Properties::valueAt(const unsigned int index) const {
+    if (index < mProperties[mCurrentMode].size()) {
+        return mProperties[mCurrentMode].valueAt(index).string();
     }
     return NULL;
 }
diff --git a/camera/CameraProperties.cpp b/camera/CameraProperties.cpp
index 7d4034d..a533d5a 100644
--- a/camera/CameraProperties.cpp
+++ b/camera/CameraProperties.cpp
@@ -117,7 +117,7 @@ status_t CameraProperties::loadProperties()
         LOGI("num_cameras = %d", mCamerasSupported);
 
         for (int i = 0; i < mCamerasSupported; i++) {
-            mCameraProps[i].set(CAMERA_SENSOR_INDEX, i);
+            mCameraProps[i].setSensorIndex(i);
             mCameraProps[i].dump();
         }
     }
diff --git a/camera/OMXCameraAdapter/OMXAlgo.cpp b/camera/OMXCameraAdapter/OMXAlgo.cpp
index 11aad93..b4d5dc7 100644
--- a/camera/OMXCameraAdapter/OMXAlgo.cpp
+++ b/camera/OMXCameraAdapter/OMXAlgo.cpp
@@ -49,36 +49,47 @@ status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
         if (strcmp(valstr, (const char *) TICameraParameters::HIGH_PERFORMANCE_MODE) == 0)
             {
             capMode = OMXCameraAdapter::HIGH_SPEED;
+            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::HIGH_QUALITY_MODE) == 0)
             {
             capMode = OMXCameraAdapter::HIGH_QUALITY;
+            mCapabilitiesOpMode = MODE_HIGH_QUALITY;
             }
         else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_ZSL_MODE) == 0)
             {
             capMode = OMXCameraAdapter::HIGH_QUALITY_ZSL;
+            mCapabilitiesOpMode = MODE_ZEROSHUTTERLAG;
             }
         else if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0)
             {
             capMode = OMXCameraAdapter::VIDEO_MODE;
+            mCapabilitiesOpMode = MODE_VIDEO;
             }
         else if (strcmp(valstr, (const char *) TICameraParameters::CP_CAM_MODE) == 0)
             {
             capMode = OMXCameraAdapter::CP_CAM;
+            mCapabilitiesOpMode = MODE_CPCAM;
             }
         else
             {
             capMode = OMXCameraAdapter::HIGH_QUALITY;
+            mCapabilitiesOpMode = MODE_HIGH_QUALITY;
+            }
+
+            if ( mSensorIndex == 2 ) {
+                mCapabilitiesOpMode = MODE_STEREO;
             }
         }
     else
         {
         capMode = OMXCameraAdapter::HIGH_QUALITY;
-
+        mCapabilitiesOpMode = MODE_HIGH_QUALITY;
         }
 
     if ( mCapMode != capMode )
diff --git a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
index c737a17..4c05d5d 100644
--- a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
+++ b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
@@ -204,6 +204,7 @@ status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps)
     mSnapshotCount = 0;
     mPictureFormatFromClient = NULL;
 
+    mCapabilitiesOpMode = MODE_MAX;
     mCapMode = INITIAL_MODE;
     mIPP = IPP_NULL;
     mVstabEnabled = false;
@@ -244,6 +245,10 @@ status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps)
     mEXIFData.mModelValid = false;
     mEXIFData.mMakeValid = false;
 
+    if (mSensorIndex != 2) {
+        mCapabilities->setMode(MODE_HIGH_SPEED);
+    }
+
     if (mCapabilities->get(CameraProperties::SUPPORTED_ZOOM_STAGES) != NULL) {
         mMaxZoomSupported = mCapabilities->getInt(CameraProperties::SUPPORTED_ZOOM_STAGES) + 1;
     } else {
@@ -669,6 +674,10 @@ status_t OMXCameraAdapter::setParameters(const CameraParameters &params)
     mParams = params;
     mFirstTimeInit = false;
 
+    if ( MODE_MAX != mCapabilitiesOpMode ) {
+        mCapabilities->setMode(mCapabilitiesOpMode);
+    }
+
     LOG_FUNCTION_NAME_EXIT;
     return ret;
 }
@@ -871,6 +880,23 @@ void OMXCameraAdapter::getParameters(CameraParameters& params)
                 CameraParameters::FALSE);
     }
 
+    // Update Picture size capabilities dynamically
+    params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
+                mCapabilities->get(CameraProperties::SUPPORTED_PICTURE_SIZES));
+
+    // Update framerate capabilities dynamically
+    params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
+               mCapabilities->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
+
+    params.set(TICameraParameters::KEY_FRAMERATES_EXT_SUPPORTED,
+               mCapabilities->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES_EXT));
+
+    params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
+               mCapabilities->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
+
+    params.set(TICameraParameters::KEY_FRAMERATE_RANGES_EXT_SUPPORTED,
+               mCapabilities->get(CameraProperties::FRAMERATE_RANGE_EXT_SUPPORTED));
+
     LOG_FUNCTION_NAME_EXIT;
 }
 
@@ -4294,64 +4320,26 @@ public:
         return NO_ERROR;
     }
 
-    status_t fetchCapabilitiesForSensor(int sensorId, CameraProperties::Properties * properties)
+    status_t fetchCapabiltiesForMode(OMX_CAMOPERATINGMODETYPE mode,
+                                     int sensorId,
+                                     CameraProperties::Properties * properties)
     {
-        {
-            CAMHAL_LOGD("Disabling all ports...");
-            const status_t disableAllPortsError = disableAllPorts();
-            CAMHAL_LOGD("Disabling all ports... DONE");
-
-            if ( disableAllPortsError != NO_ERROR )
-            {
-                CAMHAL_LOGE("Failed to disable all ports, error: %d", disableAllPortsError);
-                return UNKNOWN_ERROR;
-            }
-        }
-
-        // sensor select
-        OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
-        OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
-        sensorSelect.eSensor = (OMX_SENSORSELECT)sensorId;
-
-        CAMHAL_LOGD("Selecting sensor %d...", sensorId);
-        const OMX_ERRORTYPE sensorSelectError = OMX_SetConfig(component(),
-                (OMX_INDEXTYPE)OMX_TI_IndexConfigSensorSelect, &sensorSelect);
-        CAMHAL_LOGD("Selecting sensor %d... DONE", sensorId);
-
-        if ( sensorSelectError != OMX_ErrorNone )
-        {
-            CAMHAL_LOGD("Max supported sensor number reached: %d", sensorId);
-            return BAD_VALUE;
-        }
-
         OMX_CONFIG_CAMOPERATINGMODETYPE camMode;
 
         OMX_INIT_STRUCT_PTR (&camMode, OMX_CONFIG_CAMOPERATINGMODETYPE);
+        camMode.eCamOperatingMode = mode;
 
-        if ( sensorId == 2 )
-        {
-            CAMHAL_LOGDA("Camera mode: STEREO");
-            camMode.eCamOperatingMode = OMX_CaptureStereoImageCapture;
-        }
-        else
-        {
-            CAMHAL_LOGDA("Camera mode: MONO");
-            camMode.eCamOperatingMode = OMX_CaptureImageHighSpeedTemporalBracketing;
-        }
-
-        const OMX_ERRORTYPE eError =  OMX_SetParameter(component(),
+        OMX_ERRORTYPE eError =  OMX_SetParameter(component(),
                            ( OMX_INDEXTYPE ) OMX_IndexCameraOperatingMode,
                            &camMode);
 
-        if ( OMX_ErrorNone != eError )
-        {
-            CAMHAL_LOGDB("Error while configuring camera mode in CameraAdapter_Capabilities 0x%x", eError);
+        if ( OMX_ErrorNone != eError ) {
+            CAMHAL_LOGE("Error while configuring camera mode in CameraAdapter_Capabilities 0x%x", eError);
             return BAD_VALUE;
         }
 
         const status_t idleSwitchError = switchToState(OMX_StateIdle);
-        if ( idleSwitchError != NO_ERROR )
-        {
+        if ( idleSwitchError != NO_ERROR ) {
             CAMHAL_LOGE("Failed to switch to Idle state, error: %d", idleSwitchError);
             return UNKNOWN_ERROR;
         }
@@ -4360,8 +4348,7 @@ public:
         OMXCameraAdapter::getCaps(sensorId, properties, component());
 
         const status_t loadedSwitchError = switchToState(OMX_StateLoaded);
-        if ( loadedSwitchError != NO_ERROR )
-        {
+        if ( loadedSwitchError != NO_ERROR ) {
             CAMHAL_LOGE("Failed to switch to Loaded state, error: %d", loadedSwitchError);
             return UNKNOWN_ERROR;
         }
@@ -4369,6 +4356,94 @@ public:
         return NO_ERROR;
     }
 
+    status_t fetchCapabilitiesForSensor(int sensorId,
+                                        CameraProperties::Properties * properties)
+    {
+        CAMHAL_LOGD("Disabling all ports...");
+        const status_t disableAllPortsError = disableAllPorts();
+        CAMHAL_LOGD("Disabling all ports... DONE");
+
+        if ( disableAllPortsError != NO_ERROR ) {
+            CAMHAL_LOGE("Failed to disable all ports, error: %d",
+                        disableAllPortsError);
+            return UNKNOWN_ERROR;
+        }
+
+        // sensor select
+        OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
+        OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
+        sensorSelect.eSensor = (OMX_SENSORSELECT)sensorId;
+
+        CAMHAL_LOGD("Selecting sensor %d...", sensorId);
+        const OMX_ERRORTYPE sensorSelectError = OMX_SetConfig(component(),
+                (OMX_INDEXTYPE)OMX_TI_IndexConfigSensorSelect, &sensorSelect);
+        CAMHAL_LOGD("Selecting sensor %d... DONE", sensorId);
+
+        if ( sensorSelectError != OMX_ErrorNone ) {
+            CAMHAL_LOGD("Max supported sensor number reached: %d", sensorId);
+            return BAD_VALUE;
+        }
+
+        status_t err = NO_ERROR;
+        if ( sensorId == 2 ) {
+            CAMHAL_LOGD("Camera mode: STEREO");
+            properties->setMode(MODE_STEREO);
+            err = fetchCapabiltiesForMode(OMX_CaptureStereoImageCapture,
+                                          sensorId,
+                                          properties);
+        } else {
+            CAMHAL_LOGD("Camera MONO");
+
+            CAMHAL_LOGD("Camera mode: HQ ");
+            properties->setMode(MODE_HIGH_QUALITY);
+            err = fetchCapabiltiesForMode(OMX_CaptureImageProfileBase,
+                                          sensorId,
+                                          properties);
+            if ( NO_ERROR != err ) {
+                return err;
+            }
+
+            CAMHAL_LOGD("Camera mode: VIDEO ");
+            properties->setMode(MODE_VIDEO);
+            err = fetchCapabiltiesForMode(OMX_CaptureVideo,
+                                          sensorId,
+                                          properties);
+            if ( NO_ERROR != err ) {
+                return err;
+            }
+
+            CAMHAL_LOGD("Camera mode: ZSL ");
+            properties->setMode(MODE_ZEROSHUTTERLAG);
+            err = fetchCapabiltiesForMode(OMX_TI_CaptureImageProfileZeroShutterLag,
+                                          sensorId,
+                                          properties);
+            if ( NO_ERROR != err ) {
+                return err;
+            }
+
+            CAMHAL_LOGD("Camera mode: HS ");
+            properties->setMode(MODE_HIGH_SPEED);
+            err = fetchCapabiltiesForMode(OMX_CaptureImageHighSpeedTemporalBracketing,
+                                          sensorId,
+                                          properties);
+            if ( NO_ERROR != err ) {
+                return err;
+            }
+
+            CAMHAL_LOGD("Camera mode: CPCAM ");
+            properties->setMode(MODE_CPCAM);
+            err = fetchCapabiltiesForMode(OMX_TI_CPCam,
+                                          sensorId,
+                                          properties);
+            if ( NO_ERROR != err ) {
+                return err;
+            }
+
+        }
+
+        return err;
+    }
+
 public:
     static OMX_ERRORTYPE eventCallback(const OMX_HANDLETYPE component,
             const OMX_PTR cookie, const OMX_EVENTTYPE event, const OMX_U32 data1, const OMX_U32 data2,
diff --git a/camera/OMXCameraAdapter/OMXCapabilities.cpp b/camera/OMXCameraAdapter/OMXCapabilities.cpp
index bb9079a..af7987d 100644
--- a/camera/OMXCameraAdapter/OMXCapabilities.cpp
+++ b/camera/OMXCameraAdapter/OMXCapabilities.cpp
@@ -1979,6 +1979,18 @@ status_t OMXCameraAdapter::insertDefaults(CameraProperties::Properties* params,
     params->set(CameraProperties::MANUAL_CONVERGENCE, DEFAULT_MANUAL_CONVERGENCE);
     params->set(CameraProperties::MECHANICAL_MISALIGNMENT_CORRECTION, DEFAULT_MECHANICAL_MISALIGNMENT_CORRECTION_MODE);
 
+    char property[PROPERTY_VALUE_MAX];
+    property_get("ro.product.manufacturer",
+                 property,
+                 DEFAULT_EXIF_MAKE);
+    property[0] = toupper(property[0]);
+    params->set(CameraProperties::EXIF_MAKE, property);
+    property_get("ro.product.model",
+                 property,
+                 DEFAULT_EXIF_MODEL);
+    property[0] = toupper(property[0]);
+    params->set(CameraProperties::EXIF_MODEL, property);
+
     LOG_FUNCTION_NAME_EXIT;
 
     return ret;
diff --git a/camera/OMXCameraAdapter/OMXDefaults.cpp b/camera/OMXCameraAdapter/OMXDefaults.cpp
index 816fdbf..e0c17d1 100644
--- a/camera/OMXCameraAdapter/OMXDefaults.cpp
+++ b/camera/OMXCameraAdapter/OMXDefaults.cpp
@@ -75,5 +75,7 @@ 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 = CameraParameters::TRUE;
+const char OMXCameraAdapter::DEFAULT_EXIF_MAKE[] = "default_make";
+const char OMXCameraAdapter::DEFAULT_EXIF_MODEL[] = "default_model";
 };
 
diff --git a/camera/inc/CameraProperties.h b/camera/inc/CameraProperties.h
index 96d4789..cec0e3d 100644
--- a/camera/inc/CameraProperties.h
+++ b/camera/inc/CameraProperties.h
@@ -44,11 +44,17 @@ namespace android {
 #define MAX_PROP_NAME_LENGTH 50
 #define MAX_PROP_VALUE_LENGTH 2048
 
-#define EXIF_MAKE_DEFAULT "default_make"
-#define EXIF_MODEL_DEFAULT "default_model"
-
 #define REMAINING_BYTES(buff) ((((int)sizeof(buff) - 1 - (int)strlen(buff)) < 0) ? 0 : (sizeof(buff) - 1 - strlen(buff)))
 
+enum OperatingMode {
+    MODE_HIGH_SPEED = 0,
+    MODE_HIGH_QUALITY,
+    MODE_ZEROSHUTTERLAG,
+    MODE_VIDEO,
+    MODE_STEREO,
+    MODE_CPCAM,
+    MODE_MAX
+};
 
 // Class that handles the Camera Properties
 class CameraProperties
@@ -189,33 +195,31 @@ public:
     class Properties
     {
         public:
+
             Properties()
             {
-                mProperties = new DefaultKeyedVector<String8, String8>(String8(DEFAULT_VALUE));
-                char property[PROPERTY_VALUE_MAX];
-                property_get("ro.product.manufacturer", property, EXIF_MAKE_DEFAULT);
-                property[0] = toupper(property[0]);
-                set(EXIF_MAKE, property);
-                property_get("ro.product.model", property, EXIF_MODEL_DEFAULT);
-                property[0] = toupper(property[0]);
-                set(EXIF_MODEL, property);
             }
+
             ~Properties()
             {
-                delete mProperties;
             }
-            ssize_t set(const char *prop, const char *value);
-            ssize_t set(const char *prop, int value);
-            const char* get(const char * prop);
-            int getInt(const char * prop);
+
+            void set(const char *prop, const char *value);
+            void set(const char *prop, int value);
+            const char* get(const char * prop) const;
+            int getInt(const char * prop) const;
+            void setSensorIndex(int idx);
+            void setMode(OperatingMode mode);
+            OperatingMode getMode() const;
             void dump();
 
         protected:
-            const char* keyAt(unsigned int);
-            const char* valueAt(unsigned int);
+            const char* keyAt(const unsigned int) const;
+            const char* valueAt(const unsigned int) const;
 
         private:
-            DefaultKeyedVector<String8, String8>* mProperties;
+            OperatingMode mCurrentMode;
+            DefaultKeyedVector<String8, String8> mProperties[MODE_MAX];
 
     };
 
diff --git a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
index 77649b6..f324b45 100644
--- a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
+++ b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
@@ -963,6 +963,8 @@ private:
     static const char DEFAULT_AUTOCONVERGENCE_MODE[];
     static const char DEFAULT_MANUAL_CONVERGENCE[];
     static const char * DEFAULT_MECHANICAL_MISALIGNMENT_CORRECTION_MODE;
+    static const char DEFAULT_EXIF_MODEL[];
+    static const char DEFAULT_EXIF_MAKE[];
 
     static const size_t MAX_FOCUS_AREAS;
 
@@ -996,6 +998,7 @@ private:
     Vector< sp<CameraArea> > mMeteringAreas;
     mutable Mutex mMeteringAreasLock;
 
+    OperatingMode mCapabilitiesOpMode;
     CaptureMode mCapMode;
     // TODO(XXX): Do we really need this lock? Let's
     // try to merge temporal bracketing and burst