remove TI and omap string

32 files changed, 690 insertions, 370 deletions

diff --git a/ANativeWindowDisplayAdapter.cpp b/ANativeWindowDisplayAdapter.cpp
index 0f31fd0..94282ab 100755
--- a/ANativeWindowDisplayAdapter.cpp
+++ b/ANativeWindowDisplayAdapter.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,10 +19,8 @@
 #define LOG_TAG "ANativeW"
 
 #include "ANativeWindowDisplayAdapter.h"
-//#include <OMX_IVCommon.h>
 #include <ui/GraphicBuffer.h>
 #include <ui/GraphicBufferMapper.h>
-//#include <hal_public.h>
 
 #if 0
 #undef LOG_FUNCTION_NAME
@@ -79,9 +77,9 @@ const char* getPixFormatConstant(const char* parameters_format)
     return pixFormat;
 }
 
-const size_t getBufSize(const char* parameters_format, int width, int height)
+static size_t getBufSize(const char* parameters_format, int width, int height)
 {
-    int buf_size;
+    size_t buf_size;
 
     if ( parameters_format != NULL ) {
         if (strcmp(parameters_format,
@@ -161,7 +159,7 @@ ANativeWindowDisplayAdapter::ANativeWindowDisplayAdapter():mDisplayThread(NULL),
 ANativeWindowDisplayAdapter::~ANativeWindowDisplayAdapter()
 {
     Semaphore sem;
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
 
     LOG_FUNCTION_NAME;
 
@@ -325,7 +323,7 @@ status_t ANativeWindowDisplayAdapter::setSnapshotTimeRef(struct timeval *refTime
 int ANativeWindowDisplayAdapter::enableDisplay(int width, int height, struct timeval *refTime, S3DParameters *s3dParams)
 {
     Semaphore sem;
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
 
     LOG_FUNCTION_NAME;
 
@@ -405,7 +403,7 @@ int ANativeWindowDisplayAdapter::disableDisplay(bool cancel_buffer)
         // and then wait for message
         Semaphore sem;
         sem.Create();
-        TIUTILS::Message msg;
+        MSGUTILS::Message msg;
         msg.command = DisplayThread::DISPLAY_STOP;
 
         // Send the semaphore to signal once the command is completed
@@ -896,7 +894,7 @@ void ANativeWindowDisplayAdapter::displayThread()
 
     while(shouldLive)
     {
-        ret = TIUTILS::MessageQueue::waitForMsg(&mDisplayThread->msgQ()
+        ret = MSGUTILS::MessageQueue::waitForMsg(&mDisplayThread->msgQ()
                                                                 ,  &mDisplayQ
                                                                 , NULL
                                                                 , ANativeWindowDisplayAdapter::DISPLAY_TIMEOUT);
@@ -917,7 +915,7 @@ void ANativeWindowDisplayAdapter::displayThread()
             }
             else
             {
-                TIUTILS::Message msg;
+                MSGUTILS::Message msg;
                 ///Get the dummy msg from the displayQ
                 if(mDisplayQ.get(&msg)!=NO_ERROR)
                 {
@@ -948,7 +946,7 @@ void ANativeWindowDisplayAdapter::displayThread()
 
 bool ANativeWindowDisplayAdapter::processHalMsg()
 {
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
 
     LOG_FUNCTION_NAME;
 
@@ -1081,7 +1079,7 @@ status_t ANativeWindowDisplayAdapter::PostFrame(ANativeWindowDisplayAdapter::Dis
 
         // HWComposer has not minimum buffer requirement. We should be able to dequeue
         // the buffer immediately
-        TIUTILS::Message msg;
+        MSGUTILS::Message msg;
         mDisplayQ.put(&msg);
 
 
@@ -1120,7 +1118,7 @@ status_t ANativeWindowDisplayAdapter::PostFrame(ANativeWindowDisplayAdapter::Dis
 
         mFramesWithCameraAdapterMap.removeItem((int) dispFrame.mBuffer);
 
-        TIUTILS::Message msg;
+        MSGUTILS::Message msg;
         mDisplayQ.put(&msg);
         ret = NO_ERROR;
     }
diff --git a/Android.mk b/Android.mk
index 1bfbb3b..791a159 100755
--- a/Android.mk
+++ b/Android.mk
@@ -16,7 +16,7 @@ CAMERA_HAL_SRC := \
 
 CAMERA_COMMON_SRC:= \
 	CameraParameters.cpp \
-	TICameraParameters.cpp \
+	ExCameraParameters.cpp \
 	CameraHalCommon.cpp
 
 CAMERA_V4L_SRC:= \
diff --git a/AppCallbackNotifier.cpp b/AppCallbackNotifier.cpp
index 0adfe4e..43a837e 100755
--- a/AppCallbackNotifier.cpp
+++ b/AppCallbackNotifier.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -276,7 +276,7 @@ bool AppCallbackNotifier::notificationThread()
     LOG_FUNCTION_NAME;
 
     //CAMHAL_LOGDA("Notification Thread waiting for message");
-    ret = TIUTILS::MessageQueue::waitForMsg(&mNotificationThread->msgQ(),
+    ret = MSGUTILS::MessageQueue::waitForMsg(&mNotificationThread->msgQ(),
                                             &mEventQ,
                                             &mFrameQ,
                                             AppCallbackNotifier::NOTIFIER_TIMEOUT);
@@ -311,7 +311,7 @@ bool AppCallbackNotifier::notificationThread()
 void AppCallbackNotifier::notifyEvent()
 {
     ///Receive and send the event notifications to app
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
     LOG_FUNCTION_NAME;
     {
     Mutex::Autolock lock(mLock);
@@ -453,7 +453,7 @@ static void copy2Dto1D(void *dst,
 
     unsigned int *y_uv = (unsigned int *)src;
 
-    CAMHAL_LOGDB("copy2Dto1D() y= %p ; uv=%p.",y_uv[0], y_uv[1]);
+    CAMHAL_LOGDB("copy2Dto1D() y= 0x%x ; uv=0x%x.",y_uv[0], y_uv[1]);
     CAMHAL_LOGDB("pixelFormat,= %d; offset=%d; length=%d;width=%d,%d;stride=%d;",*pixelFormat,offset,length,width,height,stride);
 
     if (pixelFormat!=NULL) {
@@ -766,7 +766,7 @@ status_t AppCallbackNotifier::dummyRaw()
 void AppCallbackNotifier::notifyFrame()
 {
     ///Receive and send the frame notifications to app
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
     CameraFrame *frame;
     MemoryHeapBase *heap;
     MemoryBase *buffer = NULL;
@@ -1087,7 +1087,7 @@ void AppCallbackNotifier::notifyFrame()
 #else
                             camera_memory_t* VideoCameraBufferMemoryBase = (camera_memory_t*)mVideoHeaps.valueFor((uint32_t)frame->mBuffer);
                             private_handle_t* gralloc_hnd = (private_handle_t*)frame->mBuffer;
-                            if((NULL == VideoCameraBufferMemoryBase) ||(NULL == gralloc_hnd->base))
+                            if((!VideoCameraBufferMemoryBase) ||(!gralloc_hnd->base))
                             {
                                 CAMHAL_LOGEA("Error! one of video buffer is NULL");
                                 break;
@@ -1165,7 +1165,7 @@ void AppCallbackNotifier::frameCallbackRelay(CameraFrame* caFrame)
 void AppCallbackNotifier::frameCallback(CameraFrame* caFrame)
 {
     ///Post the event to the event queue of AppCallbackNotifier
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
     CameraFrame *frame;
 
     LOG_FUNCTION_NAME;
@@ -1190,7 +1190,7 @@ void AppCallbackNotifier::frameCallback(CameraFrame* caFrame)
 
 void AppCallbackNotifier::flushAndReturnFrames()
 {
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
     CameraFrame *frame;
 
     Mutex::Autolock lock(mLock);
@@ -1218,7 +1218,7 @@ void AppCallbackNotifier::eventCallback(CameraHalEvent* chEvt)
 {
 
     ///Post the event to the event queue of AppCallbackNotifier
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
     CameraHalEvent *event;
 
 
@@ -1261,7 +1261,7 @@ void AppCallbackNotifier::flushEventQueue()
 bool AppCallbackNotifier::processMessage()
 {
     ///Retrieve the command from the command queue and process it
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
 
     LOG_FUNCTION_NAME;
 
@@ -1312,7 +1312,7 @@ AppCallbackNotifier::~AppCallbackNotifier()
         mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
         }
 
-    TIUTILS::Message msg = {0,0,0,0,0,0};
+    MSGUTILS::Message msg = {0,0,0,0,0,0};
     msg.command = NotificationThread::NOTIFIER_EXIT;
 
     ///Post the message to display thread
@@ -1362,7 +1362,7 @@ void AppCallbackNotifier::releaseSharedVideoBuffers()
             if(NULL != videoMedatadaBufferMemory)
             {
                 videoMedatadaBufferMemory->release(videoMedatadaBufferMemory);
-                CAMHAL_LOGDB("Released  videoMedatadaBufferMemory=0x%x", videoMedatadaBufferMemory);
+                CAMHAL_LOGDB("Released  videoMedatadaBufferMemory=0x%x", (uint32_t)videoMedatadaBufferMemory);
             }
         }
 
@@ -1383,7 +1383,7 @@ void AppCallbackNotifier::releaseSharedVideoBuffers()
             if(NULL != VideoCameraBufferMemoryBase)
             {
                 VideoCameraBufferMemoryBase->release(VideoCameraBufferMemoryBase);
-                CAMHAL_LOGDB("Released  VideoCameraBufferMemoryBase=0x%x", VideoCameraBufferMemoryBase);
+                CAMHAL_LOGDB("Released  VideoCameraBufferMemoryBase=0x%x", (uint32_t)VideoCameraBufferMemoryBase);
             }
         }
 #endif
@@ -1643,7 +1643,7 @@ status_t AppCallbackNotifier::initSharedVideoBuffers(void *buffers, uint32_t *of
             mVideoMetadataBufferMemoryMap.add(bufArr[i], (uint32_t)(videoMedatadaBufferMemory));
             mVideoMetadataBufferReverseMap.add((uint32_t)(videoMedatadaBufferMemory->data), bufArr[i]);
             CAMHAL_LOGDB("bufArr[%d]=0x%x, videoMedatadaBufferMemory=0x%x, videoMedatadaBufferMemory->data=0x%x",
-                    i, bufArr[i], videoMedatadaBufferMemory, videoMedatadaBufferMemory->data);
+                    i, bufArr[i], (uint32_t)videoMedatadaBufferMemory, (uint32_t)videoMedatadaBufferMemory->data);
 
             if (vidBufs != NULL)
             {
@@ -1680,7 +1680,7 @@ status_t AppCallbackNotifier::initSharedVideoBuffers(void *buffers, uint32_t *of
             mVideoHeaps.add(bufArr[i], (uint32_t)(VideoCameraBufferMemoryBase));
             mVideoMap.add((uint32_t)(VideoCameraBufferMemoryBase->data),bufArr[i]);
             CAMHAL_LOGDB("bufArr[%d]=0x%x, VideoCameraBufferMemoryBase=0x%x, VideoCameraBufferMemoryBase->data=0x%x",
-                    i, bufArr[i], VideoCameraBufferMemoryBase, VideoCameraBufferMemoryBase->data);
+                    i, bufArr[i], (uint32_t)VideoCameraBufferMemoryBase, (uint32_t)VideoCameraBufferMemoryBase->data);
         }
     }
 exit:
diff --git a/BaseCameraAdapter.cpp b/BaseCameraAdapter.cpp
index 495666c..a048e7f 100755
--- a/BaseCameraAdapter.cpp
+++ b/BaseCameraAdapter.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/CameraHal.cpp b/CameraHal.cpp
index 7318ce3..85fd423 100755
--- a/CameraHal.cpp
+++ b/CameraHal.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,7 +26,7 @@
 
 #include "CameraHal.h"
 #include "ANativeWindowDisplayAdapter.h"
-#include "TICameraParameters.h"
+#include "ExCameraParameters.h"
 #include "CameraProperties.h"
 #include <cutils/properties.h>
 
@@ -374,7 +374,7 @@ int CameraHal::setParameters(const CameraParameters& params)
     const char *valstr = NULL;
     const char *prevFormat;
     char *af_coord;
-    TIUTILS::Message msg;
+    MSGUTILS::Message msg;
     status_t ret = NO_ERROR;
     // Needed for KEY_RECORDING_HINT
     bool restartPreviewRequired = false;
@@ -401,10 +401,10 @@ int CameraHal::setParameters(const CameraParameters& params)
                 }
             }
 
-            if ((valstr = params.get(TICameraParameters::KEY_VNF)) != NULL) {
-                if ( (params.getInt(TICameraParameters::KEY_VNF)==0) || (params.getInt(TICameraParameters::KEY_VNF)==1) ) {
-                    CAMHAL_LOGDB("VNF set %s", params.get(TICameraParameters::KEY_VNF));
-                    mParameters.set(TICameraParameters::KEY_VNF, valstr);
+            if ((valstr = params.get(ExCameraParameters::KEY_VNF)) != NULL) {
+                if ( (params.getInt(ExCameraParameters::KEY_VNF)==0) || (params.getInt(ExCameraParameters::KEY_VNF)==1) ) {
+                    CAMHAL_LOGDB("VNF set %s", params.get(ExCameraParameters::KEY_VNF));
+                    mParameters.set(ExCameraParameters::KEY_VNF, valstr);
                 } else {
                     CAMHAL_LOGEB("ERROR: Invalid VNF: %s", valstr);
                     ret = -EINVAL;
@@ -429,16 +429,16 @@ int CameraHal::setParameters(const CameraParameters& params)
                 }
             }
 
-            if( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL)
+            if( (valstr = params.get(ExCameraParameters::KEY_CAP_MODE)) != NULL)
                 {
-                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", params.get(ExCameraParameters::KEY_CAP_MODE));
+                mParameters.set(ExCameraParameters::KEY_CAP_MODE, valstr);
                 }
 
-            if ((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL) {
+            if ((valstr = params.get(ExCameraParameters::KEY_IPP)) != NULL) {
                 if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES))) {
-                    CAMHAL_LOGDB("IPP mode set %s", params.get(TICameraParameters::KEY_IPP));
-                    mParameters.set(TICameraParameters::KEY_IPP, valstr);
+                    CAMHAL_LOGDB("IPP mode set %s", params.get(ExCameraParameters::KEY_IPP));
+                    mParameters.set(ExCameraParameters::KEY_IPP, valstr);
                 } else {
                     CAMHAL_LOGEB("ERROR: Invalid IPP mode: %s. Supported: %s", valstr,
                             mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES));
@@ -446,16 +446,16 @@ int CameraHal::setParameters(const CameraParameters& params)
                 }
             }
 
-            if((valstr = params.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL)
+            if((valstr = params.get(ExCameraParameters::KEY_S3D2D_PREVIEW)) != NULL)
                 {
-                CAMHAL_LOGDB("Stereo 3D->2D Preview mode is %s", params.get(TICameraParameters::KEY_S3D2D_PREVIEW));
-                mParameters.set(TICameraParameters::KEY_S3D2D_PREVIEW, valstr);
+                CAMHAL_LOGDB("Stereo 3D->2D Preview mode is %s", params.get(ExCameraParameters::KEY_S3D2D_PREVIEW));
+                mParameters.set(ExCameraParameters::KEY_S3D2D_PREVIEW, valstr);
                 }
 
-            if((valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
+            if((valstr = params.get(ExCameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
                 {
-                CAMHAL_LOGDB("AutoConvergence mode is %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE));
-                mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr);
+                CAMHAL_LOGDB("AutoConvergence mode is %s", params.get(ExCameraParameters::KEY_AUTOCONVERGENCE));
+                mParameters.set(ExCameraParameters::KEY_AUTOCONVERGENCE, valstr);
                 }
 
             }
@@ -470,11 +470,11 @@ int CameraHal::setParameters(const CameraParameters& params)
             mParameters.getPreviewSize(&oldWidth, &oldHeight);
 
             int orientation =0;
-            if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL)
+            if((valstr = params.get(ExCameraParameters::KEY_SENSOR_ORIENTATION)) != NULL)
                 {
-                CAMHAL_LOGDB("Sensor Orientation is set to %s", params.get(TICameraParameters::KEY_SENSOR_ORIENTATION));
-                mParameters.set(TICameraParameters::KEY_SENSOR_ORIENTATION, valstr);
-                orientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION);
+                CAMHAL_LOGDB("Sensor Orientation is set to %s", params.get(ExCameraParameters::KEY_SENSOR_ORIENTATION));
+                mParameters.set(ExCameraParameters::KEY_SENSOR_ORIENTATION, valstr);
+                orientation = params.getInt(ExCameraParameters::KEY_SENSOR_ORIENTATION);
                 }
 
             if(orientation ==90 || orientation ==270)
@@ -606,10 +606,10 @@ int CameraHal::setParameters(const CameraParameters& params)
 
         CAMHAL_LOGDB("Picture Size by App %d x %d", w, h);
 
-        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));
-                mParameters.set(TICameraParameters::KEY_BURST, valstr);
+        if ((valstr = params.get(ExCameraParameters::KEY_BURST)) != NULL) {
+            if (params.getInt(ExCameraParameters::KEY_BURST) >=0) {
+                CAMHAL_LOGDB("Burst set %s", params.get(ExCameraParameters::KEY_BURST));
+                mParameters.set(ExCameraParameters::KEY_BURST, valstr);
             } else {
                 CAMHAL_LOGEB("ERROR: Invalid Burst value: %s",valstr);
                 ret = -EINVAL;
@@ -714,38 +714,38 @@ int CameraHal::setParameters(const CameraParameters& params)
         mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
 
         CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS);
-        mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS);
-        mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS);
+        mParameters.set(ExCameraParameters::KEY_MINFRAMERATE, minFPS);
+        mParameters.set(ExCameraParameters::KEY_MAXFRAMERATE, maxFPS);
 
-        if( ( valstr = params.get(TICameraParameters::KEY_GBCE) ) != NULL )
+        if( ( valstr = params.get(ExCameraParameters::KEY_GBCE) ) != NULL )
             {
             CAMHAL_LOGDB("GBCE Value = %s", valstr);
-            mParameters.set(TICameraParameters::KEY_GBCE, valstr);
+            mParameters.set(ExCameraParameters::KEY_GBCE, valstr);
             }
 
-        if( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL )
+        if( ( valstr = params.get(ExCameraParameters::KEY_GLBCE) ) != NULL )
             {
             CAMHAL_LOGDB("GLBCE Value = %s", valstr);
-            mParameters.set(TICameraParameters::KEY_GLBCE, valstr);
+            mParameters.set(ExCameraParameters::KEY_GLBCE, valstr);
             }
 
         ///Update the current parameter set
-        if( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
+        if( (valstr = params.get(ExCameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
             {
-            CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE));
-            mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr);
+            CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(ExCameraParameters::KEY_AUTOCONVERGENCE));
+            mParameters.set(ExCameraParameters::KEY_AUTOCONVERGENCE, valstr);
             }
 
-        if( (valstr = params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES)) !=NULL )
+        if( (valstr = params.get(ExCameraParameters::KEY_MANUALCONVERGENCE_VALUES)) !=NULL )
             {
-            CAMHAL_LOGDB("ManualConvergence Value = %s", params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES));
-            mParameters.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, valstr);
+            CAMHAL_LOGDB("ManualConvergence Value = %s", params.get(ExCameraParameters::KEY_MANUALCONVERGENCE_VALUES));
+            mParameters.set(ExCameraParameters::KEY_MANUALCONVERGENCE_VALUES, valstr);
             }
 
-        if ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL) {
+        if ((valstr = params.get(ExCameraParameters::KEY_EXPOSURE_MODE)) != NULL) {
             if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES))) {
                 CAMHAL_LOGDB("Exposure set = %s", valstr);
-                mParameters.set(TICameraParameters::KEY_EXPOSURE_MODE, valstr);
+                mParameters.set(ExCameraParameters::KEY_EXPOSURE_MODE, valstr);
             } else {
                 CAMHAL_LOGEB("ERROR: Invalid Exposure  = %s", valstr);
                 ret = -EINVAL;
@@ -762,40 +762,40 @@ int CameraHal::setParameters(const CameraParameters& params)
             }
         }
 
-        if ((valstr = params.get(TICameraParameters::KEY_CONTRAST)) != NULL) {
-            if (params.getInt(TICameraParameters::KEY_CONTRAST) >= 0 ) {
+        if ((valstr = params.get(ExCameraParameters::KEY_CONTRAST)) != NULL) {
+            if (params.getInt(ExCameraParameters::KEY_CONTRAST) >= 0 ) {
                 CAMHAL_LOGDB("Contrast set %s", valstr);
-                mParameters.set(TICameraParameters::KEY_CONTRAST, valstr);
+                mParameters.set(ExCameraParameters::KEY_CONTRAST, valstr);
             } else {
                 CAMHAL_LOGEB("ERROR: Invalid Contrast  = %s", valstr);
                 ret = -EINVAL;
             }
         }
 
-        if ((valstr =params.get(TICameraParameters::KEY_SHARPNESS)) != NULL) {
-            if (params.getInt(TICameraParameters::KEY_SHARPNESS) >= 0 ) {
+        if ((valstr =params.get(ExCameraParameters::KEY_SHARPNESS)) != NULL) {
+            if (params.getInt(ExCameraParameters::KEY_SHARPNESS) >= 0 ) {
                 CAMHAL_LOGDB("Sharpness set %s", valstr);
-                mParameters.set(TICameraParameters::KEY_SHARPNESS, valstr);
+                mParameters.set(ExCameraParameters::KEY_SHARPNESS, valstr);
             } else {
                 CAMHAL_LOGEB("ERROR: Invalid Sharpness = %s", valstr);
                 ret = -EINVAL;
             }
         }
 
-        if ((valstr = params.get(TICameraParameters::KEY_SATURATION)) != NULL) {
-            if (params.getInt(TICameraParameters::KEY_SATURATION) >= 0 ) {
+        if ((valstr = params.get(ExCameraParameters::KEY_SATURATION)) != NULL) {
+            if (params.getInt(ExCameraParameters::KEY_SATURATION) >= 0 ) {
                 CAMHAL_LOGDB("Saturation set %s", valstr);
-                mParameters.set(TICameraParameters::KEY_SATURATION, valstr);
+                mParameters.set(ExCameraParameters::KEY_SATURATION, valstr);
              } else {
                 CAMHAL_LOGEB("ERROR: Invalid Saturation = %s", valstr);
                 ret = -EINVAL;
             }
         }
 
-        if ((valstr = params.get(TICameraParameters::KEY_BRIGHTNESS)) != NULL) {
-            if (params.getInt(TICameraParameters::KEY_BRIGHTNESS) >= 0 ) {
+        if ((valstr = params.get(ExCameraParameters::KEY_BRIGHTNESS)) != NULL) {
+            if (params.getInt(ExCameraParameters::KEY_BRIGHTNESS) >= 0 ) {
                 CAMHAL_LOGDB("Brightness set %s", valstr);
-                mParameters.set(TICameraParameters::KEY_BRIGHTNESS, valstr);
+                mParameters.set(ExCameraParameters::KEY_BRIGHTNESS, valstr);
             } else {
                 CAMHAL_LOGEB("ERROR: Invalid Brightness = %s", valstr);
                 ret = -EINVAL;
@@ -812,10 +812,10 @@ int CameraHal::setParameters(const CameraParameters& params)
              }
          }
 
-        if ((valstr = params.get(TICameraParameters::KEY_ISO)) != NULL) {
+        if ((valstr = params.get(ExCameraParameters::KEY_ISO)) != NULL) {
             if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES))) {
                 CAMHAL_LOGDB("ISO set %s", valstr);
-                mParameters.set(TICameraParameters::KEY_ISO, valstr);
+                mParameters.set(ExCameraParameters::KEY_ISO, valstr);
             } else {
                 CAMHAL_LOGEB("ERROR: Invalid ISO = %s", valstr);
                 ret = -EINVAL;
@@ -828,16 +828,16 @@ int CameraHal::setParameters(const CameraParameters& params)
             mParameters.set(CameraParameters::KEY_FOCUS_AREAS, valstr);
             }
 
-        if( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
+        if( (valstr = params.get(ExCameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
             {
-            CAMHAL_LOGDB("Measurements set to %s", params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE));
-            mParameters.set(TICameraParameters::KEY_MEASUREMENT_ENABLE, valstr);
+            CAMHAL_LOGDB("Measurements set to %s", params.get(ExCameraParameters::KEY_MEASUREMENT_ENABLE));
+            mParameters.set(ExCameraParameters::KEY_MEASUREMENT_ENABLE, valstr);
 
-            if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0)
+            if (strcmp(valstr, (const char *) ExCameraParameters::MEASUREMENT_ENABLE) == 0)
                 {
                 mMeasurementEnabled = true;
                 }
-            else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0)
+            else if (strcmp(valstr, (const char *) ExCameraParameters::MEASUREMENT_DISABLE) == 0)
                 {
                 mMeasurementEnabled = false;
                 }
@@ -954,12 +954,12 @@ int CameraHal::setParameters(const CameraParameters& params)
                 mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
             }
 
-        if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL )
+        if( (valstr = params.get(ExCameraParameters::KEY_GPS_DATESTAMP)) != NULL )
             {
-            CAMHAL_LOGDB("GPS datestamp set %s", params.get(TICameraParameters::KEY_GPS_DATESTAMP));
-            mParameters.set(TICameraParameters::KEY_GPS_DATESTAMP, valstr);
+            CAMHAL_LOGDB("GPS datestamp set %s", params.get(ExCameraParameters::KEY_GPS_DATESTAMP));
+            mParameters.set(ExCameraParameters::KEY_GPS_DATESTAMP, valstr);
             }else{
-                mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP);
+                mParameters.remove(ExCameraParameters::KEY_GPS_DATESTAMP);
             }
 
         if( (valstr = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL )
@@ -970,42 +970,42 @@ int CameraHal::setParameters(const CameraParameters& params)
                 mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
             }
 
-        if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL )
+        if( (valstr = params.get(ExCameraParameters::KEY_GPS_MAPDATUM )) != NULL )
             {
-            CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_MAPDATUM));
-            mParameters.set(TICameraParameters::KEY_GPS_MAPDATUM, valstr);
+            CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(ExCameraParameters::KEY_GPS_MAPDATUM));
+            mParameters.set(ExCameraParameters::KEY_GPS_MAPDATUM, valstr);
             }else{
-                mParameters.remove(TICameraParameters::KEY_GPS_MAPDATUM);
+                mParameters.remove(ExCameraParameters::KEY_GPS_MAPDATUM);
             }
 
-        if( (valstr = params.get(TICameraParameters::KEY_GPS_VERSION)) != NULL )
+        if( (valstr = params.get(ExCameraParameters::KEY_GPS_VERSION)) != NULL )
             {
-            CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_VERSION));
-            mParameters.set(TICameraParameters::KEY_GPS_VERSION, valstr);
+            CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(ExCameraParameters::KEY_GPS_VERSION));
+            mParameters.set(ExCameraParameters::KEY_GPS_VERSION, valstr);
             }else{
-                mParameters.remove(TICameraParameters::KEY_GPS_VERSION);
+                mParameters.remove(ExCameraParameters::KEY_GPS_VERSION);
             }
 
-        if( (valstr = params.get(TICameraParameters::KEY_EXIF_MODEL)) != NULL )
+        if( (valstr = params.get(ExCameraParameters::KEY_EXIF_MODEL)) != NULL )
             {
-            CAMHAL_LOGDB("EXIF Model set %s", params.get(TICameraParameters::KEY_EXIF_MODEL));
-            mParameters.set(TICameraParameters::KEY_EXIF_MODEL, valstr);
+            CAMHAL_LOGDB("EXIF Model set %s", params.get(ExCameraParameters::KEY_EXIF_MODEL));
+            mParameters.set(ExCameraParameters::KEY_EXIF_MODEL, valstr);
             }
 
-        if( (valstr = params.get(TICameraParameters::KEY_EXIF_MAKE)) != NULL )
+        if( (valstr = params.get(ExCameraParameters::KEY_EXIF_MAKE)) != NULL )
             {
-            CAMHAL_LOGDB("EXIF Make set %s", params.get(TICameraParameters::KEY_EXIF_MAKE));
-            mParameters.set(TICameraParameters::KEY_EXIF_MAKE, valstr);
+            CAMHAL_LOGDB("EXIF Make set %s", params.get(ExCameraParameters::KEY_EXIF_MAKE));
+            mParameters.set(ExCameraParameters::KEY_EXIF_MAKE, valstr);
             }
 
-        if( (valstr = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL )
+        if( (valstr = params.get(ExCameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL )
             {
-            CAMHAL_LOGDB("Exposure Bracketing set %s", params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE));
-            mParameters.set(TICameraParameters::KEY_EXP_BRACKETING_RANGE, valstr);
+            CAMHAL_LOGDB("Exposure Bracketing set %s", params.get(ExCameraParameters::KEY_EXP_BRACKETING_RANGE));
+            mParameters.set(ExCameraParameters::KEY_EXP_BRACKETING_RANGE, valstr);
             }
         else
             {
-            mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE);
+            mParameters.remove(ExCameraParameters::KEY_EXP_BRACKETING_RANGE);
             }
 
         if ((valstr = params.get(CameraParameters::KEY_ZOOM)) != NULL ) {
@@ -1052,15 +1052,15 @@ LOGD("setParameters, 1 mParameters KEY_PICTURE_SIZE=%s", mParameters.get(CameraP
         // enabled or doesSetParameterNeedUpdate says so. Initial setParameters to camera adapter,
         // will be called in startPreview()
         // TODO(XXX): Need to identify other parameters that need update from camera adapter
-LOGD("setParameters mCameraAdapter=%#x mPreviewEnabled=%d updateRequired=%d", mCameraAdapter, mPreviewEnabled, updateRequired);
+LOGD("setParameters mCameraAdapter=%#x mPreviewEnabled=%d updateRequired=%d", (uint32_t)mCameraAdapter, (uint32_t)mPreviewEnabled, (uint32_t)updateRequired);
         if ( (NULL != mCameraAdapter) && (mPreviewEnabled || updateRequired) ) {
             ret |= mCameraAdapter->setParameters(adapterParams);
         }
 LOGD("setParameters, 2 mParameters KEY_PICTURE_SIZE=%s", mParameters.get(CameraParameters::KEY_PICTURE_SIZE));
 
-        if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS) )
+        if( NULL != params.get(ExCameraParameters::KEY_TEMP_BRACKETING_RANGE_POS) )
             {
-            int posBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS);
+            int posBracketRange = params.getInt(ExCameraParameters::KEY_TEMP_BRACKETING_RANGE_POS);
             if ( 0 < posBracketRange )
                 {
                 mBracketRangePositive = posBracketRange;
@@ -1069,9 +1069,9 @@ LOGD("setParameters, 2 mParameters KEY_PICTURE_SIZE=%s", mParameters.get(CameraP
         CAMHAL_LOGDB("Positive bracketing range %d", mBracketRangePositive);
 
 
-        if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG) )
+        if( NULL != params.get(ExCameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG) )
             {
-            int negBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG);
+            int negBracketRange = params.getInt(ExCameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG);
             if ( 0 < negBracketRange )
                 {
                 mBracketRangeNegative = negBracketRange;
@@ -1079,8 +1079,8 @@ LOGD("setParameters, 2 mParameters KEY_PICTURE_SIZE=%s", mParameters.get(CameraP
             }
         CAMHAL_LOGDB("Negative bracketing range %d", mBracketRangeNegative);
 
-        if( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL) &&
-            ( strcmp(valstr, TICameraParameters::BRACKET_ENABLE) == 0 ))
+        if( ( (valstr = params.get(ExCameraParameters::KEY_TEMP_BRACKETING)) != NULL) &&
+            ( strcmp(valstr, ExCameraParameters::BRACKET_ENABLE) == 0 ))
             {
             if ( !mBracketingEnabled )
                 {
@@ -1098,8 +1098,8 @@ LOGD("setParameters, 2 mParameters KEY_PICTURE_SIZE=%s", mParameters.get(CameraP
                 CAMHAL_LOGDA("Bracketing already enabled");
                 }
             }
-        else if ( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL ) &&
-            ( strcmp(valstr, TICameraParameters::BRACKET_DISABLE) == 0 ))
+        else if ( ( (valstr = params.get(ExCameraParameters::KEY_TEMP_BRACKETING)) != NULL ) &&
+            ( strcmp(valstr, ExCameraParameters::BRACKET_DISABLE) == 0 ))
             {
             CAMHAL_LOGDA("Disabling bracketing");
 
@@ -1116,23 +1116,23 @@ LOGD("setParameters, 2 mParameters KEY_PICTURE_SIZE=%s", mParameters.get(CameraP
 
             }
 
-        if( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
-            ( strcmp(valstr, TICameraParameters::SHUTTER_ENABLE) == 0 ))
+        if( ( (valstr = params.get(ExCameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
+            ( strcmp(valstr, ExCameraParameters::SHUTTER_ENABLE) == 0 ))
             {
             CAMHAL_LOGDA("Enabling shutter sound");
 
             mShutterEnabled = true;
             mMsgEnabled |= CAMERA_MSG_SHUTTER;
-            mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
+            mParameters.set(ExCameraParameters::KEY_SHUTTER_ENABLE, valstr);
             }
-        else if ( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
-            ( strcmp(valstr, TICameraParameters::SHUTTER_DISABLE) == 0 ))
+        else if ( ( (valstr = params.get(ExCameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
+            ( strcmp(valstr, ExCameraParameters::SHUTTER_DISABLE) == 0 ))
             {
             CAMHAL_LOGDA("Disabling shutter sound");
 
             mShutterEnabled = false;
             mMsgEnabled &= ~CAMERA_MSG_SHUTTER;
-            mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
+            mParameters.set(ExCameraParameters::KEY_SHUTTER_ENABLE, valstr);
             }
 
     }
@@ -1433,23 +1433,23 @@ status_t CameraHal::allocVideoBufs(uint32_t width, uint32_t height, uint32_t buf
     buffer_handle_t *bufsArr = new buffer_handle_t [bufferCount];
 
     if (bufsArr != NULL){
-      for (int i = 0; i< bufferCount; i++){
+      for (uint32_t i = 0; i< bufferCount; i++){
         GraphicBufferAllocator &GrallocAlloc = GraphicBufferAllocator::get();
         buffer_handle_t buf;
         ret = GrallocAlloc.alloc(width, height, HAL_PIXEL_FORMAT_NV12, CAMHAL_GRALLOC_USAGE, &buf, &stride);
         if (ret != NO_ERROR){
           CAMHAL_LOGEA("Couldn't allocate video buffers using Gralloc");
           ret = -NO_MEMORY;
-          for (int j=0; j< i; j++){
+          for (uint32_t j=0; j< i; j++){
             buf = (buffer_handle_t)bufsArr[j];
-            CAMHAL_LOGEB("Freeing Gralloc Buffer 0x%x", buf);
+            CAMHAL_LOGEB("Freeing Gralloc Buffer 0x%x", (uint32_t)buf);
             GrallocAlloc.free(buf);
           }
           delete [] bufsArr;
           goto exit;
         }
         bufsArr[i] = buf;
-        CAMHAL_LOGVB("*** Gralloc Handle =0x%x ***", buf);
+        CAMHAL_LOGVB("*** Gralloc Handle =0x%x ***", (uint32_t)buf);
       }
 
       mVideoBufs = (int32_t *)bufsArr;
@@ -1559,7 +1559,7 @@ status_t CameraHal::freeVideoBufs(void *bufs)
 
   for(int i = 0; i < count; i++){
     buffer_handle_t ptr = *pBuf++;
-    CAMHAL_LOGVB("Free Video Gralloc Handle 0x%x", ptr);
+    CAMHAL_LOGVB("Free Video Gralloc Handle 0x%x", (uint32_t)ptr);
     GrallocAlloc.free(ptr);
   }
 
@@ -1612,8 +1612,8 @@ status_t CameraHal::startPreview()
         mPreviewWidth = frame.mWidth;
         mPreviewHeight = frame.mHeight;
         //Update the padded width and height - required for VNF and VSTAB
-        mParameters.set(TICameraParameters::KEY_PADDED_WIDTH, mPreviewWidth);
-        mParameters.set(TICameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight);
+        mParameters.set(ExCameraParameters::KEY_PADDED_WIDTH, mPreviewWidth);
+        mParameters.set(ExCameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight);
 
     }
 
@@ -1739,10 +1739,10 @@ status_t CameraHal::startPreview()
         int width, height;
         mParameters.getPreviewSize(&width, &height);
 #if 0 //TODO: s3d is not part of bringup...will reenable
-        if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_SUPPORTED)) != NULL) {
+        if ( (valstr = mParameters.get(ExCameraParameters::KEY_S3D_SUPPORTED)) != NULL) {
             isS3d = (strcmp(valstr, "true") == 0);
         }
-        if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) {
+        if ( (valstr = mParameters.get(ExCameraParameters::KEY_S3D2D_PREVIEW)) != NULL) {
             if (strcmp(valstr, "off") == 0)
             {
                 CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS OFF");
@@ -1932,7 +1932,7 @@ void CameraHal::stopPreview()
     // Reset Capture-Mode to default, so that when we switch from VideoRecording
     // to ImageCapture, CAPTURE_MODE is not left to VIDEO_MODE.
     CAMHAL_LOGDA("Resetting Capture-Mode to default");
-    mParameters.set(TICameraParameters::KEY_CAP_MODE, "");
+    mParameters.set(ExCameraParameters::KEY_CAP_MODE, "");
 
     LOG_FUNCTION_NAME_EXIT;
 }
@@ -1984,7 +1984,7 @@ status_t CameraHal::startRecording( )
 
     // set internal recording hint in case camera adapter needs to make some
     // decisions....(will only be sent to camera adapter if camera restart is required)
-    mParameters.set(TICameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
+    mParameters.set(ExCameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
 
     // if application starts recording in continuous focus picture mode...
     // then we need to force default capture mode (as opposed to video mode)
@@ -2016,7 +2016,7 @@ status_t CameraHal::startRecording( )
             if ( NO_ERROR != ret )
             {
                 CAMHAL_LOGEB("allocVideoBufs returned error 0x%x", ret);
-                mParameters.remove(TICameraParameters::KEY_RECORDING_HINT);
+                mParameters.remove(ExCameraParameters::KEY_RECORDING_HINT);
                 return ret;
             }
 
@@ -2074,18 +2074,18 @@ bool CameraHal::setVideoModeParameters(const CameraParameters& params)
     LOG_FUNCTION_NAME;
 
     // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
-    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
+    valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
     if ( (valstr == NULL) ||
-        ( (valstr != NULL) && (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) != 0) ) )
+        ( (valstr != NULL) && (strcmp(valstr, (const char *) ExCameraParameters::VIDEO_MODE) != 0) ) )
         {
         CAMHAL_LOGDA("Set CAPTURE_MODE to VIDEO_MODE");
-        mParameters.set(TICameraParameters::KEY_CAP_MODE, (const char *) TICameraParameters::VIDEO_MODE);
+        mParameters.set(ExCameraParameters::KEY_CAP_MODE, (const char *) ExCameraParameters::VIDEO_MODE);
         restartPreviewRequired = true;
         }
 
     // Check if CAPTURE_MODE is VIDEO_MODE, since VSTAB & VNF work only in VIDEO_MODE.
-    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
-    if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0) {
+    valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
+    if (strcmp(valstr, (const char *) ExCameraParameters::VIDEO_MODE) == 0) {
        // set VSTAB. restart is required if vstab value has changed
        if (params.get(CameraParameters::KEY_VIDEO_STABILIZATION) != NULL) {
             // make sure we support vstab
@@ -2107,16 +2107,16 @@ bool CameraHal::setVideoModeParameters(const CameraParameters& params)
         }
 
         // Set VNF
-        if (params.get(TICameraParameters::KEY_VNF) == NULL) {
+        if (params.get(ExCameraParameters::KEY_VNF) == NULL) {
             CAMHAL_LOGDA("Enable VNF");
-            mParameters.set(TICameraParameters::KEY_VNF, "1");
+            mParameters.set(ExCameraParameters::KEY_VNF, "1");
             restartPreviewRequired = true;
         } else {
-            valstr = mParameters.get(TICameraParameters::KEY_VNF);
-            if (valstr && strcmp(valstr, params.get(TICameraParameters::KEY_VNF)) != 0) {
+            valstr = mParameters.get(ExCameraParameters::KEY_VNF);
+            if (valstr && strcmp(valstr, params.get(ExCameraParameters::KEY_VNF)) != 0) {
                 restartPreviewRequired = true;
             }
-            mParameters.set(TICameraParameters::KEY_VNF, params.get(TICameraParameters::KEY_VNF));
+            mParameters.set(ExCameraParameters::KEY_VNF, params.get(ExCameraParameters::KEY_VNF));
         }
 
         // For VSTAB alone for 1080p resolution, padded width goes > 2048, which cannot be rendered by GPU.
@@ -2125,7 +2125,7 @@ bool CameraHal::setVideoModeParameters(const CameraParameters& params)
         valstr = mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION);
         if (valstr && (strcmp(valstr, CameraParameters::TRUE) == 0) && (mPreviewWidth == 1920)) {
             CAMHAL_LOGDA("Force Enable VNF for 1080p");
-            mParameters.set(TICameraParameters::KEY_VNF, "1");
+            mParameters.set(ExCameraParameters::KEY_VNF, "1");
             restartPreviewRequired = true;
         }
     }
@@ -2157,10 +2157,10 @@ bool CameraHal::resetVideoModeParameters()
     }
 
     // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
-    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
-    if ((valstr != NULL) && (strcmp(valstr, TICameraParameters::VIDEO_MODE) == 0)) {
+    valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
+    if ((valstr != NULL) && (strcmp(valstr, ExCameraParameters::VIDEO_MODE) == 0)) {
         CAMHAL_LOGDA("Reset Capture-Mode to default");
-        mParameters.set(TICameraParameters::KEY_CAP_MODE, "");
+        mParameters.set(ExCameraParameters::KEY_CAP_MODE, "");
         restartPreviewRequired = true;
     }
 
@@ -2188,7 +2188,7 @@ status_t CameraHal::restartPreview()
 
     // Retain CAPTURE_MODE before calling stopPreview(), since it is reset in stopPreview().
     tmpvalstr[0] = 0;
-    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
+    valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
     if(valstr != NULL)
         {
         if(sizeof(tmpvalstr) < (strlen(valstr)+1))
@@ -2204,7 +2204,7 @@ status_t CameraHal::restartPreview()
 
     {
         Mutex::Autolock lock(mLock);
-        mParameters.set(TICameraParameters::KEY_CAP_MODE, tmpvalstr);
+        mParameters.set(ExCameraParameters::KEY_CAP_MODE, tmpvalstr);
         mCameraAdapter->setParameters(mParameters);
     }
 
@@ -2249,7 +2249,7 @@ void CameraHal::stopRecording()
     if ( mAppCallbackNotifier->getUseVideoBuffers() ){
       freeVideoBufs(mVideoBufs);
       if (mVideoBufs){
-        CAMHAL_LOGVB(" FREEING mVideoBufs 0x%x", mVideoBufs);
+        CAMHAL_LOGVB(" FREEING mVideoBufs 0x%x", (uint32_t)mVideoBufs);
         delete [] mVideoBufs;
       }
       mVideoBufs = NULL;
@@ -2257,7 +2257,7 @@ void CameraHal::stopRecording()
 
     // reset internal recording hint in case camera adapter needs to make some
     // decisions....(will only be sent to camera adapter if camera restart is required)
-    mParameters.remove(TICameraParameters::KEY_RECORDING_HINT);
+    mParameters.remove(ExCameraParameters::KEY_RECORDING_HINT);
 
     LOG_FUNCTION_NAME_EXIT;
 }
@@ -2383,7 +2383,7 @@ status_t CameraHal::cancelAutoFocus()
 
     if( NULL != mCameraAdapter )
     {
-        adapterParams.set(TICameraParameters::KEY_AUTO_FOCUS_LOCK, CameraParameters::FALSE);
+        adapterParams.set(ExCameraParameters::KEY_AUTO_FOCUS_LOCK, CameraParameters::FALSE);
         mCameraAdapter->setParameters(adapterParams);
         mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
         mAppCallbackNotifier->flushEventQueue();
@@ -2618,9 +2618,9 @@ status_t CameraHal::takePicture( )
     }
 
     // we only support video snapshot if we are in video mode (recording hint is set)
-    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
+    valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
     if((mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE) &&
-      (valstr && strcmp(valstr, TICameraParameters::VIDEO_MODE)) ) {
+      (valstr && strcmp(valstr, ExCameraParameters::VIDEO_MODE)) ) {
         CAMHAL_LOGEA("Trying to capture while recording without recording hint set...");
         return INVALID_OPERATION;
     }
@@ -2629,7 +2629,7 @@ status_t CameraHal::takePicture( )
     {
         if ( NO_ERROR == ret )
         {
-            burst = mParameters.getInt(TICameraParameters::KEY_BURST);
+            burst = mParameters.getInt(ExCameraParameters::KEY_BURST);
         }
 
         //Allocate all buffers only in burst capture case
@@ -2791,8 +2791,8 @@ LOGD("getParameters, 2 mParameters KEY_PICTURE_SIZE=%s", mParameters.get(CameraP
       }
 
     // do not send internal parameters to upper layers
-    mParams.remove(TICameraParameters::KEY_RECORDING_HINT);
-    mParams.remove(TICameraParameters::KEY_AUTO_FOCUS_LOCK);
+    mParams.remove(ExCameraParameters::KEY_RECORDING_HINT);
+    mParams.remove(ExCameraParameters::KEY_AUTO_FOCUS_LOCK);
 
     params_str8 = mParams.flatten();
 
@@ -3470,7 +3470,7 @@ void CameraHal::insertSupportedParams()
     CameraParameters &p = mParameters;
 
     ///Set the name of the camera
-    p.set(TICameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME));
+    p.set(ExCameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME));
 
     mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
 
@@ -3495,21 +3495,21 @@ void CameraHal::insertSupportedParams()
     p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN));
     p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP));
     p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
-    p.set(TICameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES));
-    p.set(TICameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES));
+    p.set(ExCameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES));
+    p.set(ExCameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES));
     p.set(CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS));
     p.set(CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
     p.set(CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED));
     p.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED));
-    p.set(TICameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES));
-    p.set(TICameraParameters::KEY_S3D_SUPPORTED,mCameraProperties->get(CameraProperties::S3D_SUPPORTED));
-    p.set(TICameraParameters::KEY_S3D2D_PREVIEW_MODE,mCameraProperties->get(CameraProperties::S3D2D_PREVIEW_MODES));
-    p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE));
-    p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
+    p.set(ExCameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES));
+    p.set(ExCameraParameters::KEY_S3D_SUPPORTED,mCameraProperties->get(CameraProperties::S3D_SUPPORTED));
+    p.set(ExCameraParameters::KEY_S3D2D_PREVIEW_MODE,mCameraProperties->get(CameraProperties::S3D2D_PREVIEW_MODES));
+    p.set(ExCameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE));
+    p.set(ExCameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
     p.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED));
     p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
-    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
-    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
+    p.set(ExCameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
+    p.set(ExCameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
     p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED));
     p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED));
     p.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED));
@@ -3589,26 +3589,26 @@ void CameraHal::initDefaultParameters()
     }
 
     p.set(CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM));
-    p.set(TICameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST));
-    p.set(TICameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION));
-    p.set(TICameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS));
-    p.set(TICameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS));
-    p.set(TICameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE));
-    p.set(TICameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE));
-    p.set(TICameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP));
-    p.set(TICameraParameters::KEY_GBCE, mCameraProperties->get(CameraProperties::GBCE));
-    p.set(TICameraParameters::KEY_S3D2D_PREVIEW, mCameraProperties->get(CameraProperties::S3D2D_PREVIEW));
-    p.set(TICameraParameters::KEY_AUTOCONVERGENCE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE));
-    p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
+    p.set(ExCameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST));
+    p.set(ExCameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION));
+    p.set(ExCameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS));
+    p.set(ExCameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS));
+    p.set(ExCameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE));
+    p.set(ExCameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE));
+    p.set(ExCameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP));
+    p.set(ExCameraParameters::KEY_GBCE, mCameraProperties->get(CameraProperties::GBCE));
+    p.set(ExCameraParameters::KEY_S3D2D_PREVIEW, mCameraProperties->get(CameraProperties::S3D2D_PREVIEW));
+    p.set(ExCameraParameters::KEY_AUTOCONVERGENCE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE));
+    p.set(ExCameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
     p.set(CameraParameters::KEY_VIDEO_STABILIZATION, mCameraProperties->get(CameraProperties::VSTAB));
     p.set(CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH));
     p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE));
     p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE));
     p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
-    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
-    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
-    p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE));
-    p.set(TICameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL));
+    p.set(ExCameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
+    p.set(ExCameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
+    p.set(ExCameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE));
+    p.set(ExCameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL));
     p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY));
     p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP);
     p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES));
diff --git a/CameraHalCommon.cpp b/CameraHalCommon.cpp
index 6d4ea2c..ba80d40 100644..100755
--- a/CameraHalCommon.cpp
+++ b/CameraHalCommon.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/CameraHalUtilClasses.cpp b/CameraHalUtilClasses.cpp
index 3074bc4..52312d1 100644..100755
--- a/CameraHalUtilClasses.cpp
+++ b/CameraHalUtilClasses.cpp
@@ -1,5 +1,5 @@
 /*

- * Copyright (C) Texas Instruments - http://www.ti.com/

+ * Copyright (C) 2011 The Android Open Source Project

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

@@ -14,12 +14,6 @@
  * limitations under the License.

  */

 

-/**

-* @file CameraHalUtilClasses.cpp

-*

-* This file maps the CameraHardwareInterface to the Camera interfaces on OMAP4 (mainly OMX).

-*

-*/

 

 #define LOG_TAG "CameraHAL"

 

@@ -160,27 +154,27 @@ status_t CameraArea::checkArea(ssize_t top,
     }

 

     if ( ( CameraArea::WEIGHT_MIN > weight ) ||  ( CameraArea::WEIGHT_MAX < weight ) ) {

-        CAMHAL_LOGEB("Camera area weight is invalid %d", weight);

+        CAMHAL_LOGEB("Camera area weight is invalid %d", (uint32_t)weight);

         return -EINVAL;

     }

 

     if ( ( CameraArea::TOP > top ) || ( CameraArea::BOTTOM < top ) ) {

-        CAMHAL_LOGEB("Camera area top coordinate is invalid %d", top );

+        CAMHAL_LOGEB("Camera area top coordinate is invalid %d", (uint32_t)top );

         return -EINVAL;

     }

 

     if ( ( CameraArea::TOP > bottom ) || ( CameraArea::BOTTOM < bottom ) ) {

-        CAMHAL_LOGEB("Camera area bottom coordinate is invalid %d", bottom );

+        CAMHAL_LOGEB("Camera area bottom coordinate is invalid %d", (uint32_t)bottom );

         return -EINVAL;

     }

 

     if ( ( CameraArea::LEFT > left ) || ( CameraArea::RIGHT < left ) ) {

-        CAMHAL_LOGEB("Camera area left coordinate is invalid %d", left );

+        CAMHAL_LOGEB("Camera area left coordinate is invalid %d", (uint32_t)left );

         return -EINVAL;

     }

 

     if ( ( CameraArea::LEFT > right ) || ( CameraArea::RIGHT < right ) ) {

-        CAMHAL_LOGEB("Camera area right coordinate is invalid %d", right );

+        CAMHAL_LOGEB("Camera area right coordinate is invalid %d", (uint32_t)right );

         return -EINVAL;

     }

 

@@ -341,7 +335,7 @@ bool CameraArea::areAreasDifferent(Vector< sp<CameraArea> > &area1,
     }

 

     // not going to care about sorting order for now

-    for (int i = 0; i < area1.size(); i++) {

+    for (uint32_t i = 0; i < area1.size(); i++) {

         if (!area1.itemAt(i)->compare(area2.itemAt(i))) {

             return true;

         }

diff --git a/CameraHal_Module.cpp b/CameraHal_Module.cpp
index 675720b..378ceeb 100755
--- a/CameraHal_Module.cpp
+++ b/CameraHal_Module.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@
 
 #include "CameraHal.h"
 #include "CameraProperties.h"
-#include "TICameraParameters.h"
+#include "ExCameraParameters.h"
 
 
 static android::CameraProperties gCameraProperties;
@@ -57,7 +57,6 @@ camera_module_t HAL_MODULE_INFO_SYM = {
 
 typedef struct aml_camera_device {
     camera_device_t base;
-    /* TI specific "private" data can go here (base.priv) */
     int cameraid;
 } aml_camera_device_t;
 
@@ -648,11 +647,11 @@ int camera_get_camera_info(int camera_id, struct camera_info *info)
         valstr = properties->get(android::CameraProperties::FACING_INDEX);
         if(valstr != NULL)
         {
-            if (strcmp(valstr, (const char *) android::TICameraParameters::FACING_FRONT) == 0)
+            if (strcmp(valstr, (const char *) android::ExCameraParameters::FACING_FRONT) == 0)
             {
                 face_value = CAMERA_FACING_FRONT;
             }
-            else if (strcmp(valstr, (const char *) android::TICameraParameters::FACING_BACK) == 0)
+            else if (strcmp(valstr, (const char *) android::ExCameraParameters::FACING_BACK) == 0)
             {
                 face_value = CAMERA_FACING_BACK;
             }
diff --git a/CameraParameters.cpp b/CameraParameters.cpp
index 79c603e..79b2819 100755
--- a/CameraParameters.cpp
+++ b/CameraParameters.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,12 +14,6 @@
  * limitations under the License.
  */
 
-/**
-* @file CameraProperties.cpp
-*
-* This file maps the CameraHardwareInterface to the Camera interfaces on OMAP4 (mainly OMX).
-*
-*/
 
 #include "CameraHal.h"
 #include "CameraProperties.h"
diff --git a/CameraProperties.cpp b/CameraProperties.cpp
index d9d936a..b3baaf0 100755
--- a/CameraProperties.cpp
+++ b/CameraProperties.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,13 +14,6 @@
  * limitations under the License.
  */
 
-/**
-* @file CameraProperties.cpp
-*
-* This file maps the CameraHardwareInterface to the Camera interfaces on OMAP4 (mainly OMX).
-*
-*/
-
 #define LOG_NDEBUG 0
 #define LOG_TAG "CameraProperties"
 
diff --git a/Encoder_libjpeg.cpp b/Encoder_libjpeg.cpp
index 2cad9a2..da2816b 100755
--- a/Encoder_libjpeg.cpp
+++ b/Encoder_libjpeg.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/ExCameraParameters.cpp b/ExCameraParameters.cpp
new file mode 100755
index 0000000..ecd5eb7
--- a/dev/null
+++ b/ExCameraParameters.cpp
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+
+#define LOG_TAG "CameraHAL"
+#include <utils/Log.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <ExCameraParameters.h>
+#include "CameraHal.h"
+
+namespace android {
+
+//extensions to camera mode
+const char ExCameraParameters::HIGH_PERFORMANCE_MODE[] = "high-performance";
+const char ExCameraParameters::HIGH_QUALITY_MODE[] = "high-quality";
+const char ExCameraParameters::HIGH_QUALITY_ZSL_MODE[] = "high-quality-zsl";
+const char ExCameraParameters::VIDEO_MODE[] = "video-mode";
+
+//extensions to standard android Parameters
+const char ExCameraParameters::KEY_SUPPORTED_CAMERAS[] = "camera-indexes";
+const char ExCameraParameters::KEY_CAMERA[] = "camera-index";
+const char ExCameraParameters::KEY_SHUTTER_ENABLE[] = "shutter-enable";
+const char ExCameraParameters::KEY_CAMERA_NAME[] = "camera-name";
+const char ExCameraParameters::KEY_BURST[] = "burst-capture";
+const char ExCameraParameters::KEY_CAP_MODE[] = "mode";
+const char ExCameraParameters::KEY_VNF[] = "vnf";
+const char ExCameraParameters::KEY_SATURATION[] = "saturation";
+const char ExCameraParameters::KEY_BRIGHTNESS[] = "brightness";
+const char ExCameraParameters::KEY_EXPOSURE_MODE[] = "exposure";
+const char ExCameraParameters::KEY_SUPPORTED_EXPOSURE[] = "exposure-mode-values";
+const char ExCameraParameters::KEY_CONTRAST[] = "contrast";
+const char ExCameraParameters::KEY_SHARPNESS[] = "sharpness";
+const char ExCameraParameters::KEY_ISO[] = "iso";
+const char ExCameraParameters::KEY_SUPPORTED_ISO_VALUES[] = "iso-mode-values";
+const char ExCameraParameters::KEY_SUPPORTED_IPP[] = "ipp-values";
+const char ExCameraParameters::KEY_IPP[] = "ipp";
+const char ExCameraParameters::KEY_MAN_EXPOSURE[] = "manual-exposure";
+const char ExCameraParameters::KEY_METERING_MODE[] = "meter-mode";
+const char ExCameraParameters::KEY_PADDED_WIDTH[] = "padded-width";
+const char ExCameraParameters::KEY_PADDED_HEIGHT[] = "padded-height";
+const char ExCameraParameters::KEY_EXP_BRACKETING_RANGE[] = "exp-bracketing-range";
+const char ExCameraParameters::KEY_TEMP_BRACKETING[] = "temporal-bracketing";
+const char ExCameraParameters::KEY_TEMP_BRACKETING_RANGE_POS[] = "temporal-bracketing-range-positive";
+const char ExCameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG[] = "temporal-bracketing-range-negative";
+const char ExCameraParameters::KEY_S3D_SUPPORTED[] = "s3d-supported";
+const char ExCameraParameters::KEY_MEASUREMENT_ENABLE[] = "measurement";
+const char ExCameraParameters::KEY_GBCE[] = "gbce";
+const char ExCameraParameters::KEY_GLBCE[] = "glbce";
+const char ExCameraParameters::KEY_CURRENT_ISO[] = "current-iso";
+const char ExCameraParameters::KEY_SENSOR_ORIENTATION[] = "sensor-orientation";
+const char ExCameraParameters::KEY_SENSOR_ORIENTATION_VALUES[] = "sensor-orientation-values";
+const char ExCameraParameters::KEY_MINFRAMERATE[] = "min-framerate";
+const char ExCameraParameters::KEY_MAXFRAMERATE[] = "max-framerate";
+const char ExCameraParameters::KEY_RECORDING_HINT[] = "internal-recording-hint";
+const char ExCameraParameters::KEY_AUTO_FOCUS_LOCK[] = "auto-focus-lock";
+
+//extensions for enabling/disabling GLBCE
+const char ExCameraParameters::GLBCE_ENABLE[] = "enable";
+const char ExCameraParameters::GLBCE_DISABLE[] = "disable";
+
+//extensions for enabling/disabling GBCE
+const char ExCameraParameters::GBCE_ENABLE[] = "enable";
+const char ExCameraParameters::GBCE_DISABLE[] = "disable";
+
+//extensions for enabling/disabling measurement
+const char ExCameraParameters::MEASUREMENT_ENABLE[] = "enable";
+const char ExCameraParameters::MEASUREMENT_DISABLE[] = "disable";
+
+//extensions for zoom
+const char ExCameraParameters::ZOOM_SUPPORTED[] = "true";
+const char ExCameraParameters::ZOOM_UNSUPPORTED[] = "false";
+
+//extensions for 2D Preview in Stereo Mode
+const char ExCameraParameters::KEY_S3D2D_PREVIEW[] = "s3d2d-preview";
+const char ExCameraParameters::KEY_S3D2D_PREVIEW_MODE[] = "s3d2d-preview-values";
+
+//extensions for SAC/SMC
+const char ExCameraParameters::KEY_AUTOCONVERGENCE[] = "auto-convergence";
+const char ExCameraParameters::KEY_AUTOCONVERGENCE_MODE[] = "auto-convergence-mode";
+const char ExCameraParameters::KEY_MANUALCONVERGENCE_VALUES[] = "manual-convergence-values";
+
+//extensions for setting EXIF tags
+const char ExCameraParameters::KEY_EXIF_MODEL[] = "exif-model";
+const char ExCameraParameters::KEY_EXIF_MAKE[] = "exif-make";
+
+//extensions for additiona GPS data
+const char ExCameraParameters::KEY_GPS_MAPDATUM[] = "gps-mapdatum";
+const char ExCameraParameters::KEY_GPS_VERSION[] = "gps-version";
+const char ExCameraParameters::KEY_GPS_DATESTAMP[] = "gps-datestamp";
+
+//extensions for enabling/disabling shutter sound
+const char ExCameraParameters::SHUTTER_ENABLE[] = "true";
+const char ExCameraParameters::SHUTTER_DISABLE[] = "false";
+
+//extensions for Temporal Bracketing
+const char ExCameraParameters::BRACKET_ENABLE[] = "enable";
+const char ExCameraParameters::BRACKET_DISABLE[] = "disable";
+
+//extensions to Image post-processing
+const char ExCameraParameters::IPP_LDCNSF[] = "ldc-nsf";
+const char ExCameraParameters::IPP_LDC[] = "ldc";
+const char ExCameraParameters::IPP_NSF[] = "nsf";
+const char ExCameraParameters::IPP_NONE[] = "off";
+
+//extensions to standard android pixel formats
+const char ExCameraParameters::PIXEL_FORMAT_RAW[] = "raw";
+const char ExCameraParameters::PIXEL_FORMAT_JPS[] = "jps";
+const char ExCameraParameters::PIXEL_FORMAT_MPO[] = "mpo";
+const char ExCameraParameters::PIXEL_FORMAT_RAW_JPEG[] = "raw+jpeg";
+const char ExCameraParameters::PIXEL_FORMAT_RAW_MPO[] = "raw+mpo";
+
+//extensions to standard android scene mode settings
+const char ExCameraParameters::SCENE_MODE_SPORT[] = "sport";
+const char ExCameraParameters::SCENE_MODE_CLOSEUP[] = "closeup";
+const char ExCameraParameters::SCENE_MODE_AQUA[] = "aqua";
+const char ExCameraParameters::SCENE_MODE_SNOWBEACH[] = "snow-beach";
+const char ExCameraParameters::SCENE_MODE_MOOD[] = "mood";
+const char ExCameraParameters::SCENE_MODE_NIGHT_INDOOR[] = "night-indoor";
+const char ExCameraParameters::SCENE_MODE_DOCUMENT[] = "document";
+const char ExCameraParameters::SCENE_MODE_BARCODE[] = "barcode";
+const char ExCameraParameters::SCENE_MODE_VIDEO_SUPER_NIGHT[] = "super-night";
+const char ExCameraParameters::SCENE_MODE_VIDEO_CINE[] = "cine";
+const char ExCameraParameters::SCENE_MODE_VIDEO_OLD_FILM[] = "old-film";
+
+//extensions to standard android white balance values.
+const char ExCameraParameters::WHITE_BALANCE_TUNGSTEN[] = "tungsten";
+const char ExCameraParameters::WHITE_BALANCE_HORIZON[] = "horizon";
+const char ExCameraParameters::WHITE_BALANCE_SUNSET[] = "sunset";
+const char ExCameraParameters::WHITE_BALANCE_FACE[] = "face-priority";
+
+//extensions to  standard android focus modes.
+const char ExCameraParameters::FOCUS_MODE_PORTRAIT[] = "portrait";
+const char ExCameraParameters::FOCUS_MODE_EXTENDED[] = "extended";
+const char ExCameraParameters::FOCUS_MODE_FACE[] = "face-priority";
+
+//extensions to add  values for effect settings.
+const char ExCameraParameters::EFFECT_NATURAL[] = "natural";
+const char ExCameraParameters::EFFECT_VIVID[] = "vivid";
+const char ExCameraParameters::EFFECT_COLOR_SWAP[] = "color-swap";
+const char ExCameraParameters::EFFECT_BLACKWHITE[] = "blackwhite";
+
+//extensions to add exposure preset modes
+const char ExCameraParameters::EXPOSURE_MODE_OFF[] = "off";
+const char ExCameraParameters::EXPOSURE_MODE_AUTO[] = "auto";
+const char ExCameraParameters::EXPOSURE_MODE_NIGHT[] = "night";
+const char ExCameraParameters::EXPOSURE_MODE_BACKLIGHT[] = "backlighting";
+const char ExCameraParameters::EXPOSURE_MODE_SPOTLIGHT[] = "spotlight";
+const char ExCameraParameters::EXPOSURE_MODE_SPORTS[] = "sports";
+const char ExCameraParameters::EXPOSURE_MODE_SNOW[] = "snow";
+const char ExCameraParameters::EXPOSURE_MODE_BEACH[] = "beach";
+const char ExCameraParameters::EXPOSURE_MODE_APERTURE[] = "aperture";
+const char ExCameraParameters::EXPOSURE_MODE_SMALL_APERTURE[] = "small-aperture";
+const char ExCameraParameters::EXPOSURE_MODE_FACE[] = "face-priority";
+
+//extensions to add iso values
+const char ExCameraParameters::ISO_MODE_AUTO[] = "auto";
+const char ExCameraParameters::ISO_MODE_100[] = "100";
+const char ExCameraParameters::ISO_MODE_200[] = "200";
+const char ExCameraParameters::ISO_MODE_400[] = "400";
+const char ExCameraParameters::ISO_MODE_800[] = "800";
+const char ExCameraParameters::ISO_MODE_1000[] = "1000";
+const char ExCameraParameters::ISO_MODE_1200[] = "1200";
+const char ExCameraParameters::ISO_MODE_1600[] = "1600";
+
+//extensions to add auto convergence values
+const char ExCameraParameters::AUTOCONVERGENCE_MODE_DISABLE[] = "mode-disable";
+const char ExCameraParameters::AUTOCONVERGENCE_MODE_FRAME[] = "mode-frame";
+const char ExCameraParameters::AUTOCONVERGENCE_MODE_CENTER[] = "mode-center";
+const char ExCameraParameters::AUTOCONVERGENCE_MODE_FFT[] = "mode-fft";
+const char ExCameraParameters::AUTOCONVERGENCE_MODE_MANUAL[] = "mode-manual";
+
+//values for camera direction
+const char ExCameraParameters::FACING_FRONT[]="front";
+const char ExCameraParameters::FACING_BACK[]="back";
+
+//extensions to flash settings
+const char ExCameraParameters::FLASH_MODE_FILL_IN[] = "fill-in";
+
+//extensions to add sensor orientation parameters
+const char ExCameraParameters::ORIENTATION_SENSOR_NONE[] = "0";
+const char ExCameraParameters::ORIENTATION_SENSOR_90[] = "90";
+const char ExCameraParameters::ORIENTATION_SENSOR_180[] = "180";
+const char ExCameraParameters::ORIENTATION_SENSOR_270[] = "270";
+};
+
diff --git a/MemoryManager.cpp b/MemoryManager.cpp
index 0d5c182..bb8c4c9 100644..100755
--- a/MemoryManager.cpp
+++ b/MemoryManager.cpp
@@ -1,6 +1,5 @@
 /*
- * Copyright (C) Amlogic
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +17,7 @@
 #define LOG_TAG "MemoryManager"
 
 #include "CameraHal.h"
-#include "TICameraParameters.h"
+#include "ExCameraParameters.h"
 
 namespace android {
 /*--------------------MemoryManager Class STARTS here-----------------------------*/
@@ -70,7 +69,7 @@ void* MemoryManager::allocateBuffer(int width, int height, const char* format, i
                 goto error;
                 }
 
-            CAMHAL_LOGDB("handle = %x, nSize = %d", handle, bytes);
+            CAMHAL_LOGDB("handle = %x, nSize = %d", (uint32_t)handle, bytes);
             bufsArr[i] = (uint32_t)handle;
 
             mMemoryHandleMap.add(bufsArr[i], (unsigned int)handle);
diff --git a/SensorListener.cpp b/SensorListener.cpp
index ab15b14..3f84ce3 100644..100755
--- a/SensorListener.cpp
+++ b/SensorListener.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/V4LCameraAdapter/V4LCameraAdapter.cpp b/V4LCameraAdapter/V4LCameraAdapter.cpp
index 190b57b..7b2effa 100755
--- a/V4LCameraAdapter/V4LCameraAdapter.cpp
+++ b/V4LCameraAdapter/V4LCameraAdapter.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,7 +29,7 @@
 
 #include "V4LCameraAdapter.h"
 #include "CameraHal.h"
-#include "TICameraParameters.h"
+#include "ExCameraParameters.h"
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -66,7 +66,7 @@ static int mDebugFps = 0;
 namespace android {
 
 #undef LOG_TAG
-///Maintain a separate tag for V4LCameraAdapter logs to isolate issues OMX specific
+///Maintain a separate tag for V4LCameraAdapter logs to isolate issues
 #define LOG_TAG "V4LCameraAdapter"
 
 //redefine because of a bug with the log macros
@@ -163,7 +163,7 @@ status_t V4LCameraAdapter::initialize(CameraProperties::Properties* caps)
 	    return -EINVAL;
     }
 
-    if (strcmp(caps->get(CameraProperties::FACING_INDEX), (const char *) android::TICameraParameters::FACING_FRONT) == 0)
+    if (strcmp(caps->get(CameraProperties::FACING_INDEX), (const char *) android::ExCameraParameters::FACING_FRONT) == 0)
         mbFrontCamera = true;
     else
         mbFrontCamera = false;
@@ -373,6 +373,8 @@ status_t V4LCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, si
             ret = UseBuffersPreview(bufArr, num);
             //maxQueueable = queueable;
             break;
+        default:
+            break;
     }
 
     LOG_FUNCTION_NAME_EXIT;
@@ -732,7 +734,7 @@ status_t V4LCameraAdapter::startPreview()
     }
 
 #ifndef AMLOGIC_USB_CAMERA_SUPPORT
-    writefile(SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
+    writefile((char *)SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
 #endif
 
     nQueued = 0;
@@ -1091,10 +1093,10 @@ int V4LCameraAdapter::GenExif(ExifElementsTable* exiftable)
     char exifcontent[256];
 
     //Make
-    exiftable->insertElement("Make",(const char*)mParams.get(TICameraParameters::KEY_EXIF_MAKE));
+    exiftable->insertElement("Make",(const char*)mParams.get(ExCameraParameters::KEY_EXIF_MAKE));
 
     //Model
-    exiftable->insertElement("Model",(const char*)mParams.get(TICameraParameters::KEY_EXIF_MODEL));
+    exiftable->insertElement("Model",(const char*)mParams.get(ExCameraParameters::KEY_EXIF_MODEL));
 
     //Image orientation
     int orientation = mParams.getInt(CameraParameters::KEY_ROTATION);
@@ -1250,7 +1252,7 @@ int V4LCameraAdapter::pictureThread()
     CameraFrame frame;
 
 #ifndef AMLOGIC_USB_CAMERA_SUPPORT
-    writefile(SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
+    writefile((char *)SYSFILE_CAMERA_SET_MIRROR,(char*)(mbFrontCamera?"1":"0"));
 #endif
 
     if (true)
@@ -1302,7 +1304,7 @@ int V4LCameraAdapter::pictureThread()
         uint8_t* dest = (uint8_t*)mCaptureBuf->data;
         uint8_t* src = (uint8_t*) fp;
         mParams.getPictureSize(&width, &height);
-        LOGD("pictureThread mCaptureBuf=%#x dest=%#x fp=%#x width=%d height=%d", mCaptureBuf, dest, fp, width, height);
+        LOGD("pictureThread mCaptureBuf=%#x dest=%#x fp=%#x width=%d height=%d", (uint32_t)mCaptureBuf, (uint32_t)dest, (uint32_t)fp, width, height);
         LOGD("length=%d bytesused=%d index=%d", mVideoInfo->buf.length, mVideoInfo->buf.bytesused, index);
 
         if(DEFAULT_IMAGE_CAPTURE_PIXEL_FORMAT == V4L2_PIX_FMT_RGB24){ // rgb24
@@ -1631,7 +1633,7 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
     char property[64];
     memset(property,0,sizeof(property));
     if(bFrontCam == true) {
-        params->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_FRONT);
+        params->set(CameraProperties::FACING_INDEX, ExCameraParameters::FACING_FRONT);
         if(getCameraOrientation(bFrontCam,property)>=0){
             params->set(CameraProperties::ORIENTATION_INDEX,property);
         }else{
@@ -1642,7 +1644,7 @@ extern "C" void loadCaps(int camera_id, CameraProperties::Properties* params) {
 #endif
         }
     } else {
-        params->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_BACK);
+        params->set(CameraProperties::FACING_INDEX, ExCameraParameters::FACING_BACK);
         if(getCameraOrientation(bFrontCam,property)>=0){
             params->set(CameraProperties::ORIENTATION_INDEX,property);
         }else{
diff --git a/inc/ANativeWindowDisplayAdapter.h b/inc/ANativeWindowDisplayAdapter.h
index 40589ec..95685ee 100755
--- a/inc/ANativeWindowDisplayAdapter.h
+++ b/inc/ANativeWindowDisplayAdapter.h
@@ -1,5 +1,5 @@
 /*

- * Copyright (C) Texas Instruments - http://www.ti.com/

+ * Copyright (C) 2011 The Android Open Source Project

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

@@ -19,10 +19,7 @@
 #include "CameraHal.h"

 #include <ui/egl/android_natives.h>

 #include <ui/GraphicBufferMapper.h>

-//#include <hal_public.h>

 

-//temporarily define format here

-//#define HAL_PIXEL_FORMAT_TI_NV12 0x100

 

 namespace android {

 

@@ -109,14 +106,14 @@ public:
     class DisplayThread : public Thread

         {

         ANativeWindowDisplayAdapter* mDisplayAdapter;

-        TIUTILS::MessageQueue mDisplayThreadQ;

+        MSGUTILS::MessageQueue mDisplayThreadQ;

 

         public:

             DisplayThread(ANativeWindowDisplayAdapter* da)

             : Thread(false), mDisplayAdapter(da) { }

 

         ///Returns a reference to the display message Q for display adapter to post messages

-            TIUTILS::MessageQueue& msgQ()

+            MSGUTILS::MessageQueue& msgQ()

                 {

                 return mDisplayThreadQ;

                 }

@@ -150,7 +147,7 @@ private:
     preview_stream_ops_t*  mANativeWindow;

     sp<DisplayThread> mDisplayThread;

     FrameProvider *mFrameProvider; ///Pointer to the frame provider interface

-    TIUTILS::MessageQueue mDisplayQ;

+    MSGUTILS::MessageQueue mDisplayQ;

     unsigned int mDisplayState;

     ///@todo Have a common class for these members

     mutable Mutex mLock;

diff --git a/inc/BaseCameraAdapter.h b/inc/BaseCameraAdapter.h
index 079ea9a..c0e2767 100755
--- a/inc/BaseCameraAdapter.h
+++ b/inc/BaseCameraAdapter.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -245,8 +245,8 @@ protected:
     size_t mPreviewDataBuffersLength;
     mutable Mutex mPreviewDataBufferLock;
 
-    TIUTILS::MessageQueue mFrameQ;
-    TIUTILS::MessageQueue mAdapterQ;
+    MSGUTILS::MessageQueue mFrameQ;
+    MSGUTILS::MessageQueue mAdapterQ;
     mutable Mutex mSubscriberLock;
     ErrorNotifier *mErrorNotifier;
     release_image_buffers_callback mReleaseImageBuffersCallback;
diff --git a/inc/CameraHal.h b/inc/CameraHal.h
index 5143c95..1431ff4 100755
--- a/inc/CameraHal.h
+++ b/inc/CameraHal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -599,7 +599,7 @@ public:
     //Internal class definitions
     class NotificationThread : public Thread {
         AppCallbackNotifier* mAppCallbackNotifier;
-        TIUTILS::MessageQueue mNotificationThreadQ;
+        MSGUTILS::MessageQueue mNotificationThreadQ;
     public:
         enum NotificationThreadCommands
         {
@@ -614,7 +614,7 @@ public:
             return mAppCallbackNotifier->notificationThread();
         }
 
-        TIUTILS::MessageQueue &msgQ() { return mNotificationThreadQ;}
+        MSGUTILS::MessageQueue &msgQ() { return mNotificationThreadQ;}
     };
 
     //Friend declarations
@@ -654,8 +654,8 @@ private:
     sp< NotificationThread> mNotificationThread;
     EventProvider *mEventProvider;
     FrameProvider *mFrameProvider;
-    TIUTILS::MessageQueue mEventQ;
-    TIUTILS::MessageQueue mFrameQ;
+    MSGUTILS::MessageQueue mEventQ;
+    MSGUTILS::MessageQueue mFrameQ;
     NotifierState mNotifierState;
 
     bool mPreviewing;
@@ -903,9 +903,6 @@ static void endImageCapture(void *userData);
  /**
     Implementation of the Android Camera hardware abstraction layer
 
-    This class implements the interface methods defined in CameraHardwareInterface
-    for the OMAP4 platform
-
 */
 class CameraHal
 
diff --git a/inc/CameraProperties.h b/inc/CameraProperties.h
index 2fef678..c47613d 100755
--- a/inc/CameraProperties.h
+++ b/inc/CameraProperties.h
@@ -1,5 +1,5 @@
 /*

- * Copyright (C) Texas Instruments - http://www.ti.com/

+ * Copyright (C) 2011 The Android Open Source Project

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

diff --git a/inc/Encoder_libjpeg.h b/inc/Encoder_libjpeg.h
index c133663..5075f41 100755
--- a/inc/Encoder_libjpeg.h
+++ b/inc/Encoder_libjpeg.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/inc/ExCameraParameters.h b/inc/ExCameraParameters.h
new file mode 100755
index 0000000..7af46db
--- a/dev/null
+++ b/inc/ExCameraParameters.h
@@ -0,0 +1,242 @@
+/*

+ * Copyright (C) 2011 The Android Open Source Project

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *      http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+

+

+

+

+#ifndef EX_CAMERA_PARAMETERS_H

+#define EX_CAMERA_PARAMETERS_H

+

+#include <utils/KeyedVector.h>

+#include <utils/String8.h>

+

+namespace android {

+

+///Ex Specific Camera Parameters

+class ExCameraParameters

+{

+public:

+

+// Supported Camera indexes

+// Example value: "0,1,2,3", where 0-primary, 1-secondary1, 2-secondary2, 3-sterocamera

+static const  char KEY_SUPPORTED_CAMERAS[];

+// Select logical Camera index

+static const char KEY_CAMERA[];

+static const char KEY_CAMERA_NAME[];

+static const  char KEY_S3D_SUPPORTED[];

+static const char  KEY_BURST[];

+static const  char KEY_CAP_MODE[];

+static const  char KEY_VNF[];

+static const  char KEY_SATURATION[];

+static const  char KEY_BRIGHTNESS[];

+static const  char KEY_EXPOSURE_MODE[];

+static const  char KEY_SUPPORTED_EXPOSURE[];

+static const  char KEY_CONTRAST[];

+static const  char KEY_SHARPNESS[];

+static const  char KEY_ISO[];

+static const  char KEY_SUPPORTED_ISO_VALUES[];

+static const  char KEY_SUPPORTED_IPP[];

+static const  char KEY_IPP[];

+static const  char KEY_MAN_EXPOSURE[];

+static const  char KEY_METERING_MODE[];

+static const  char KEY_PADDED_WIDTH[];

+static const  char KEY_PADDED_HEIGHT[];

+static const char  KEY_EXP_BRACKETING_RANGE[];

+static const char  KEY_TEMP_BRACKETING[];

+static const char  KEY_TEMP_BRACKETING_RANGE_POS[];

+static const char  KEY_TEMP_BRACKETING_RANGE_NEG[];

+static const char  KEY_SHUTTER_ENABLE[];

+static const char  KEY_MEASUREMENT_ENABLE[];

+static const char  KEY_INITIAL_VALUES[];

+static const char  KEY_GBCE[];

+static const char  KEY_GLBCE[];

+static const char  KEY_MINFRAMERATE[];

+static const char  KEY_MAXFRAMERATE[];

+

+//recording hint to notify camera adapters of possible recording

+static const char  KEY_RECORDING_HINT[];

+static const char  KEY_AUTO_FOCUS_LOCK[];

+static const char  KEY_CURRENT_ISO[];

+

+static const char KEY_SENSOR_ORIENTATION[];

+static const char KEY_SENSOR_ORIENTATION_VALUES[];

+

+//extensions for zoom

+static const char ZOOM_SUPPORTED[];

+static const char ZOOM_UNSUPPORTED[];

+

+//extensions for camera capabilies

+static const char INITIAL_VALUES_TRUE[];

+static const char INITIAL_VALUES_FALSE[];

+

+//extensions for enabling/disabling measurements

+static const char MEASUREMENT_ENABLE[];

+static const char MEASUREMENT_DISABLE[];

+

+//extensions to add values for ManualConvergence and AutoConvergence mode

+static const char KEY_AUTOCONVERGENCE[];

+static const char KEY_AUTOCONVERGENCE_MODE[];

+static const char KEY_MANUALCONVERGENCE_VALUES[];

+

+//extensions for enabling/disabling GLBCE

+static const char GLBCE_ENABLE[];

+static const char GLBCE_DISABLE[];

+

+//extensions for enabling/disabling GBCE

+static const char GBCE_ENABLE[];

+static const char GBCE_DISABLE[];

+

+//extensions to add Min frame rate Values

+static const char VIDEO_MINFRAMERATE_5[];

+static const char VIDEO_MINFRAMERATE_10[];

+static const char VIDEO_MINFRAMERATE_15[];

+static const char VIDEO_MINFRAMERATE_20[];

+static const char VIDEO_MINFRAMERATE_24[];

+static const char VIDEO_MINFRAMERATE_25[];

+static const char VIDEO_MINFRAMERATE_30[];

+static const char VIDEO_MINFRAMERATE_33[];

+

+//extensions for Manual Gain and Manual Exposure

+static const char KEY_MANUAL_EXPOSURE_LEFT[];

+static const char KEY_MANUAL_EXPOSURE_RIGHT[];

+static const char KEY_MANUAL_EXPOSURE_MODES[];

+static const char KEY_MANUAL_GAIN_EV_RIGHT[];

+static const char KEY_MANUAL_GAIN_EV_LEFT[];

+static const char KEY_MANUAL_GAIN_ISO_RIGHT[];

+static const char KEY_MANUAL_GAIN_ISO_LEFT[];

+static const char KEY_MANUAL_GAIN_MODES[];

+

+//extensions for setting EXIF tags

+static const char KEY_EXIF_MODEL[];

+static const char KEY_EXIF_MAKE[];

+

+//extensions for additional GPS data

+static const char  KEY_GPS_MAPDATUM[];

+static const char  KEY_GPS_VERSION[];

+static const char  KEY_GPS_DATESTAMP[];

+

+//extensions for enabling/disabling shutter sound

+static const char SHUTTER_ENABLE[];

+static const char SHUTTER_DISABLE[];

+

+//extensions for Temporal bracketing

+static const char BRACKET_ENABLE[];

+static const char BRACKET_DISABLE[];

+

+//extensions to Image post-processing

+static const char IPP_LDCNSF[];

+static const char IPP_LDC[];

+static const char IPP_NSF[];

+static const char IPP_NONE[];

+

+//extensions to camera mode

+static const char HIGH_PERFORMANCE_MODE[];

+static const char HIGH_QUALITY_MODE[];

+static const char HIGH_QUALITY_ZSL_MODE[];

+static const char VIDEO_MODE[];

+

+

+//extensions to standard android pixel formats

+static const char PIXEL_FORMAT_RAW[];

+static const char PIXEL_FORMAT_JPS[];

+static const char PIXEL_FORMAT_MPO[];

+static const char PIXEL_FORMAT_RAW_JPEG[];

+static const char PIXEL_FORMAT_RAW_MPO[];

+

+//extensions to standard android scene mode settings

+static const  char SCENE_MODE_SPORT[];

+static const  char SCENE_MODE_CLOSEUP[];

+static const  char SCENE_MODE_AQUA[];

+static const  char SCENE_MODE_SNOWBEACH[];

+static const  char SCENE_MODE_MOOD[];

+static const  char SCENE_MODE_NIGHT_INDOOR[];

+static const  char SCENE_MODE_DOCUMENT[];

+static const  char SCENE_MODE_BARCODE[];

+static const  char SCENE_MODE_VIDEO_SUPER_NIGHT[];

+static const  char SCENE_MODE_VIDEO_CINE[];

+static const  char SCENE_MODE_VIDEO_OLD_FILM[];

+

+//extensions to standard android white balance settings.

+static const  char WHITE_BALANCE_TUNGSTEN[];

+static const  char WHITE_BALANCE_HORIZON[];

+static const  char WHITE_BALANCE_SUNSET[];

+static const  char WHITE_BALANCE_FACE[];

+

+//extensions to add exposure preset modes to android api

+static const  char EXPOSURE_MODE_OFF[];

+static const  char EXPOSURE_MODE_AUTO[];

+static const  char EXPOSURE_MODE_NIGHT[];

+static const  char EXPOSURE_MODE_BACKLIGHT[];

+static const  char EXPOSURE_MODE_SPOTLIGHT[];

+static const  char EXPOSURE_MODE_SPORTS[];

+static const  char EXPOSURE_MODE_SNOW[];

+static const  char EXPOSURE_MODE_BEACH[];

+static const  char EXPOSURE_MODE_APERTURE[];

+static const  char EXPOSURE_MODE_SMALL_APERTURE[];

+static const  char EXPOSURE_MODE_FACE[];

+

+//extensions to standard android focus presets.

+static const  char FOCUS_MODE_PORTRAIT[];

+static const  char FOCUS_MODE_EXTENDED[];

+static const char  FOCUS_MODE_FACE[];

+

+//extensions to add iso values

+static const char ISO_MODE_AUTO[];

+static const char ISO_MODE_100[];

+static const char ISO_MODE_200[];

+static const char ISO_MODE_400[];

+static const char ISO_MODE_800[];

+static const char ISO_MODE_1000[];

+static const char ISO_MODE_1200[];

+static const char ISO_MODE_1600[];

+

+//extensions to add  values for effect settings.

+static const char EFFECT_NATURAL[];

+static const char EFFECT_VIVID[];

+static const char EFFECT_COLOR_SWAP[];

+static const char EFFECT_BLACKWHITE[];

+

+static const char KEY_S3D2D_PREVIEW[];

+static const char KEY_S3D2D_PREVIEW_MODE[];

+

+//extensions to add values for AutoConvergence settings.

+static const char AUTOCONVERGENCE_MODE_DISABLE[];

+static const char AUTOCONVERGENCE_MODE_FRAME[];

+static const char AUTOCONVERGENCE_MODE_CENTER[];

+static const char AUTOCONVERGENCE_MODE_FFT[];

+static const char AUTOCONVERGENCE_MODE_MANUAL[];

+

+

+//extensions for flash mode settings

+static const char FLASH_MODE_FILL_IN[];

+

+//extensions to add sensor orientation parameters

+static const char ORIENTATION_SENSOR_NONE[];

+static const char ORIENTATION_SENSOR_90[];

+static const char ORIENTATION_SENSOR_180[];

+static const char ORIENTATION_SENSOR_270[];

+

+

+//values for camera direction

+static const char FACING_FRONT[];

+static const char FACING_BACK[];

+

+};

+

+};

+

+#endif

+

diff --git a/inc/SensorListener.h b/inc/SensorListener.h
index 913eb95..7b9a978 100644..100755
--- a/inc/SensorListener.h
+++ b/inc/SensorListener.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/inc/V4LCameraAdapter/V4LCameraAdapter.h b/inc/V4LCameraAdapter/V4LCameraAdapter.h
index 9cc854a..4809852 100755
--- a/inc/V4LCameraAdapter/V4LCameraAdapter.h
+++ b/inc/V4LCameraAdapter/V4LCameraAdapter.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -198,7 +198,6 @@ typedef enum camera_focus_mode_e {
 /**
   * Class which completely abstracts the camera hardware interaction from camera hal
   * TODO: Need to list down here, all the message types that will be supported by this class
-                Need to implement BufferProvider interface to use AllocateBuffer of OMX if needed
   */
 class V4LCameraAdapter : public BaseCameraAdapter
 {
@@ -207,8 +206,7 @@ public:
     /*--------------------Constant declarations----------------------------------------*/
     static const int32_t MAX_NO_BUFFERS = 20;
 
-    ///@remarks OMX Camera has six ports - buffer input, time input, preview, image, video, and meta data
-    static const int MAX_NO_PORTS = 6;
+    //static const int MAX_NO_PORTS = 6;
 
     ///Five second timeout
     static const int CAMERA_ADAPTER_TIMEOUT = 5000*1000;
diff --git a/inc/VideoMetadata.h b/inc/VideoMetadata.h
index f05ee50..a1460d6 100644..100755
--- a/inc/VideoMetadata.h
+++ b/inc/VideoMetadata.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/utils/Android.mk b/utils/Android.mk
index 9dd3f92..7538952 100755
--- a/utils/Android.mk
+++ b/utils/Android.mk
@@ -25,9 +25,7 @@ LOCAL_SHARED_LIBRARIES:= \
 
 LOCAL_C_INCLUDES += \
 	frameworks/base/include/utils \
-	bionic/libc/include \
-	hardware/ti/omap4xxx/domx/omx_core/inc \
-	hardware/ti/omap4xxx/domx/mm_osal/inc
+	bionic/libc/include
 	
 LOCAL_CFLAGS += -fno-short-enums 
 
diff --git a/utils/DebugUtils.h b/utils/DebugUtils.h
index 54edfc7..f339117 100644..100755
--- a/utils/DebugUtils.h
+++ b/utils/DebugUtils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/utils/ErrorUtils.cpp b/utils/ErrorUtils.cpp
index c35d24c..28f19a6 100644..100755
--- a/utils/ErrorUtils.cpp
+++ b/utils/ErrorUtils.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -59,83 +59,6 @@ status_t ErrorUtils::posixToAndroidError(int error)
     return NO_ERROR;
 }
 
-
-#if 0
-/**
-   @brief Method to convert from TI OSAL to Android errors
-
-   @param error Any of the standard TI OSAL error codes (defined in
-                                                                                            hardware/ti/omx/ducati/domx/system/mm_osal/inc/timm_osal_error.h)
-   @return Any of the standard Android error code  (defined in frameworks/base/include/utils/Errors.h)
- */
-status_t ErrorUtils::osalToAndroidError(TIMM_OSAL_ERRORTYPE error)
-{
-    switch(error)
-    {
-    case TIMM_OSAL_ERR_NONE:
-        return NO_ERROR;
-    case TIMM_OSAL_ERR_ALLOC:
-        return NO_MEMORY;
-    default:
-        return UNKNOWN_ERROR;
-    }
-
-    return NO_ERROR;
-}
-
-/**
-   @brief Method to convert from OMX to Android errors
-
-   @param error Any of the standard OMX error codes (defined in hardware/ti/omx/ducati/domx/system/omx_core/inc/OMX_Core.h)
-   @return Any of the standard Android error code (defined in frameworks/base/include/utils/Errors.h)
- */
-status_t ErrorUtils::omxToAndroidError(OMX_ERRORTYPE error)
-{
-    switch(error)
-        {
-        case OMX_ErrorNone:
-            return NO_ERROR;
-        case OMX_ErrorBadParameter:
-        case OMX_ErrorInvalidComponentName:
-        case OMX_ErrorUndefined:
-        case OMX_ErrorInvalidState:
-        case OMX_ErrorStreamCorrupt:
-        case OMX_ErrorPortsNotCompatible:
-        case OMX_ErrorVersionMismatch:
-        case OMX_ErrorMbErrorsInFrame:
-            return BAD_VALUE;
-        case OMX_ErrorInsufficientResources:
-            return NO_MEMORY;
-        case OMX_ErrorComponentNotFound:
-        case OMX_ErrorNotImplemented:
-        case OMX_ErrorFormatNotDetected:
-        case OMX_ErrorUnsupportedSetting:
-            return NAME_NOT_FOUND;
-        case OMX_ErrorUnderflow:
-        case OMX_ErrorOverflow:
-        case OMX_ErrorUnsupportedIndex:
-        case OMX_ErrorBadPortIndex:
-            return BAD_INDEX;
-        case OMX_ErrorHardware:
-        case OMX_ErrorContentPipeCreationFailed:
-        case OMX_ErrorContentPipeOpenFailed:
-            return FAILED_TRANSACTION;
-        case OMX_ErrorTimeout:
-           return TIMED_OUT;
-        case OMX_ErrorSameState:
-        case OMX_ErrorIncorrectStateTransition:
-        case OMX_ErrorIncorrectStateOperation:
-           return PERMISSION_DENIED;
-        case OMX_ErrorTunnelingUnsupported:
-           return INVALID_OPERATION;
-        default:
-            return UNKNOWN_ERROR;
-        }
-
-    return NO_ERROR;
-}
-#endif
-
 };
 
 
diff --git a/utils/ErrorUtils.h b/utils/ErrorUtils.h
index a4fb4a8..b9d5b6c 100644..100755
--- a/utils/ErrorUtils.h
+++ b/utils/ErrorUtils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,16 +20,6 @@
 ///Header file where all the android error codes are defined
 #include <Errors.h>
 
-///Header file where all the OMX error codes are defined
-//#include "OMX_Core.h"
-
-
-extern "C"
-{
-///Header file where all the TI OSAL error codes are defined
-//#include "timm_osal_error.h"
-};
-
 namespace android {
 
 ///Generic class with static methods to convert any standard error type to Android error type
@@ -39,12 +29,6 @@ public:
     ///Method to convert from POSIX to Android errors
     static status_t posixToAndroidError(int error);
 
-    ///Method to convert from TI OSAL to Android errors
-    //static status_t osalToAndroidError(TIMM_OSAL_ERRORTYPE error);
-
-    ///Method to convert from OMX to Android errors
-    //static status_t omxToAndroidError(OMX_ERRORTYPE error);
-
 };
 
 };
diff --git a/utils/MessageQueue.cpp b/utils/MessageQueue.cpp
index d4c1013..7fcedce 100755
--- a/utils/MessageQueue.cpp
+++ b/utils/MessageQueue.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@
 #include <utils/Log.h>
 #include "MessageQueue.h"
 
-namespace TIUTILS {
+namespace MSGUTILS {
 
 /**
    @brief Constructor for the message queue class
diff --git a/utils/MessageQueue.h b/utils/MessageQueue.h
index 8b40d59..f35c248 100755
--- a/utils/MessageQueue.h
+++ b/utils/MessageQueue.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -47,7 +47,7 @@
 #define MSGQ_LOGEB DBGUTILS_LOGEB
 
 
-namespace TIUTILS {
+namespace MSGUTILS {
 
 ///Message type
 struct Message
diff --git a/utils/Semaphore.cpp b/utils/Semaphore.cpp
index 41fa99c..9717f2e 100644..100755
--- a/utils/Semaphore.cpp
+++ b/utils/Semaphore.cpp
@@ -1,5 +1,5 @@
 /*

- * Copyright (C) Texas Instruments - http://www.ti.com/

+ * Copyright (C) 2011 The Android Open Source Project

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

diff --git a/utils/Semaphore.h b/utils/Semaphore.h
index 466e709..3b4b68f 100644..100755
--- a/utils/Semaphore.h
+++ b/utils/Semaphore.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) Texas Instruments - http://www.ti.com/
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.