initial commit

Change-Id: I8f7a7eeece0e516efa486b77e9d97805c0e65d3e
Signed-off-by: Iliyan Malchev <malchev@google.com>

178 files changed, 64547 insertions, 0 deletions

diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..2729bab
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,34 @@
+ifeq ($(TARGET_BOARD_PLATFORM),omap4)
+
+LOCAL_PATH:= $(call my-dir)
+HARDWARE_TI_OMAP4_BASE:= $(LOCAL_PATH)
+OMAP4_DEBUG_MEMLEAK:= false
+
+ifeq ($(OMAP4_DEBUG_MEMLEAK),true)
+
+OMAP4_DEBUG_CFLAGS:= -DHEAPTRACKER
+OMAP4_DEBUG_LDFLAGS:= $(foreach f, $(strip malloc realloc calloc free), -Wl,--wrap=$(f))
+OMAP4_DEBUG_SHARED_LIBRARIES:= liblog
+BUILD_HEAPTRACKED_SHARED_LIBRARY:= hardware/ti/omap4xxx/heaptracked-shared-library.mk
+BUILD_HEAPTRACKED_EXECUTABLE:= hardware/ti/omap4xxx/heaptracked-executable.mk
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES:= heaptracker.c stacktrace.c mapinfo.c
+LOCAL_MODULE:= libheaptracker
+LOCAL_MODULE_TAGS:= optional
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES:= tm.c
+LOCAL_MODULE:= tm
+LOCAL_MODULE_TAGS:= test
+include $(BUILD_HEAPTRACKED_EXECUTABLE)
+
+else
+BUILD_HEAPTRACKED_SHARED_LIBRARY:=$(BUILD_SHARED_LIBRARY)
+BUILD_HEAPTRACKED_EXECUTABLE:= $(BUILD_EXECUTABLE)
+endif
+
+include $(call first-makefiles-under,$(LOCAL_PATH))
+endif
diff --git a/CleanSpec.mk b/CleanSpec.mk
new file mode 100644
index 0000000..9450dc7
--- /dev/null
+++ b/CleanSpec.mk
@@ -0,0 +1,55 @@
+# Copyright (C) 2007 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.
+#
+
+# If you don't need to do a full clean build but would like to touch
+# a file or delete some intermediate files, add a clean step to the end
+# of the list.  These steps will only be run once, if they haven't been
+# run before.
+#
+# E.g.:
+#     $(call add-clean-step, touch -c external/sqlite/sqlite3.h)
+#     $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates)
+#
+# Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with
+# files that are missing or have been moved.
+#
+# Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory.
+# Use $(OUT_DIR) to refer to the "out" directory.
+#
+# If you need to re-do something that's already mentioned, just copy
+# the command and add it to the bottom of the list.  E.g., if a change
+# that you made last week required touching a file and a change you
+# made today requires touching the same file, just copy the old
+# touch step and add it to the end of the list.
+#
+# ************************************************
+# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
+# ************************************************
+
+# For example:
+#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates)
+#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates)
+#$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f)
+#$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f)
+#$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*)
+
+# ************************************************
+# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
+# ************************************************
+$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/vendor/lib/hw/hwcomposer.omap4.so)
+$(call add-clean-step, find $(PRODUCT_OUT) -type f -name "lib*cameraadapter*" -print0 | xargs -0 rm -f)
+$(call add-clean-step, find $(PRODUCT_OUT) -type f -name "libcamera.so" -print0 | xargs -0 rm -f)
+$(call add-clean-step, find $(PRODUCT_OUT) -type d -name "libcamera_intermediates" -print0 | xargs -0 rm -rf)
+$(call add-clean-step, find $(PRODUCT_OUT) -type d -name "lib*cameraadapter_intermediates" -print0 | xargs -0 rm -rf)
diff --git a/MODULE_LICENSE_APACHE2 b/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_APACHE2
diff --git a/camera/ANativeWindowDisplayAdapter.cpp b/camera/ANativeWindowDisplayAdapter.cpp
new file mode 100755
index 0000000..38e641f
--- /dev/null
+++ b/camera/ANativeWindowDisplayAdapter.cpp
@@ -0,0 +1,1096 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 "ANativeWindowDisplayAdapter.h"
+#include <OMX_IVCommon.h>
+#include <ui/GraphicBufferMapper.h>
+#include <hal_public.h>
+
+namespace android {
+
+///Constant declarations
+///@todo Check the time units
+const int ANativeWindowDisplayAdapter::DISPLAY_TIMEOUT = 1000;  // seconds
+
+//Suspends buffers after given amount of failed dq's
+const int ANativeWindowDisplayAdapter::FAILED_DQS_TO_SUSPEND = 3;
+
+
+
+OMX_COLOR_FORMATTYPE toOMXPixFormat(const char* parameters_format)
+{
+    OMX_COLOR_FORMATTYPE pixFormat;
+
+    if ( parameters_format != NULL )
+    {
+        if (strcmp(parameters_format, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
+            {
+            CAMHAL_LOGDA("CbYCrY format selected");
+            pixFormat = OMX_COLOR_FormatCbYCrY;
+            }
+        else if(strcmp(parameters_format, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0)
+            {
+            CAMHAL_LOGDA("YUV420SP format selected");
+            pixFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+            }
+        else if(strcmp(parameters_format, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
+            {
+            CAMHAL_LOGDA("RGB565 format selected");
+            pixFormat = OMX_COLOR_Format16bitRGB565;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Invalid format, CbYCrY format selected as default");
+            pixFormat = OMX_COLOR_FormatCbYCrY;
+        }
+    }
+    else {
+        CAMHAL_LOGEA("Preview format is NULL, defaulting to CbYCrY");
+        pixFormat = OMX_COLOR_FormatCbYCrY;
+    }
+
+    return pixFormat;
+}
+
+const char* getPixFormatConstant(const char* parameters_format)
+{
+    const char* pixFormat;
+
+    if ( parameters_format != NULL )
+    {
+        if (strcmp(parameters_format, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
+        {
+            CAMHAL_LOGVA("CbYCrY format selected");
+            pixFormat = (const char *) CameraParameters::PIXEL_FORMAT_YUV422I;
+        }
+        else if(strcmp(parameters_format, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 ||
+                strcmp(parameters_format, (const char *) CameraParameters::PIXEL_FORMAT_YUV420P) == 0)
+        {
+            // TODO(XXX): We are treating YV12 the same as YUV420SP
+            CAMHAL_LOGVA("YUV420SP format selected");
+            pixFormat = (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP;
+        }
+        else if(strcmp(parameters_format, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
+        {
+            CAMHAL_LOGVA("RGB565 format selected");
+            pixFormat = (const char *) CameraParameters::PIXEL_FORMAT_RGB565;
+        }
+        else
+        {
+            CAMHAL_LOGEA("Invalid format, CbYCrY format selected as default");
+            pixFormat = (const char *) CameraParameters::PIXEL_FORMAT_YUV422I;
+        }
+    }
+    else
+    {
+        CAMHAL_LOGEA("Preview format is NULL, defaulting to CbYCrY");
+        pixFormat = (const char *) CameraParameters::PIXEL_FORMAT_YUV422I;
+    }
+
+    return pixFormat;
+}
+
+const size_t getBufSize(const char* parameters_format, int width, int height)
+{
+    int buf_size;
+
+    if ( parameters_format != NULL ) {
+        if (strcmp(parameters_format,
+                  (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0) {
+            buf_size = width * height * 2;
+        }
+        else if((strcmp(parameters_format, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0) ||
+                (strcmp(parameters_format, CameraParameters::PIXEL_FORMAT_YUV420P) == 0)) {
+            buf_size = width * height * 3 / 2;
+        }
+        else if(strcmp(parameters_format,
+                      (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0) {
+            buf_size = width * height * 2;
+        } else {
+            CAMHAL_LOGEA("Invalid format");
+            buf_size = 0;
+        }
+    } else {
+        CAMHAL_LOGEA("Preview format is NULL");
+        buf_size = 0;
+    }
+
+    return buf_size;
+}
+/*--------------------ANativeWindowDisplayAdapter Class STARTS here-----------------------------*/
+
+
+/**
+ * Display Adapter class STARTS here..
+ */
+ANativeWindowDisplayAdapter::ANativeWindowDisplayAdapter():mDisplayThread(NULL),
+                                        mDisplayState(ANativeWindowDisplayAdapter::DISPLAY_INIT),
+                                        mDisplayEnabled(false),
+                                        mBufferCount(0)
+
+
+
+{
+    LOG_FUNCTION_NAME;
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    mShotToShot = false;
+    mStartCapture.tv_sec = 0;
+    mStartCapture.tv_usec = 0;
+    mStandbyToShot.tv_sec = 0;
+    mStandbyToShot.tv_usec = 0;
+    mMeasureStandby = false;
+#endif
+
+    mPixelFormat = NULL;
+    mBufferHandleMap = NULL;
+    mGrallocHandleMap = NULL;
+    mOffsetsMap = NULL;
+    mFrameProvider = NULL;
+
+    mFrameWidth = 0;
+    mFrameHeight = 0;
+    mPreviewWidth = 0;
+    mPreviewHeight = 0;
+
+    mSuspend = false;
+    mFailedDQs = 0;
+
+    mPaused = false;
+    mXOff = 0;
+    mYOff = 0;
+    mFirstInit = false;
+
+    mFD = -1;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+ANativeWindowDisplayAdapter::~ANativeWindowDisplayAdapter()
+{
+    Semaphore sem;
+    TIUTILS::Message msg;
+
+    LOG_FUNCTION_NAME;
+
+    ///If Frame provider exists
+    if(mFrameProvider)
+        {
+        // Unregister with the frame provider
+        mFrameProvider->disableFrameNotification(CameraFrame::ALL_FRAMES);
+    }
+
+    ///The ANativeWindow object will get destroyed here
+    destroy();
+
+    ///If Display thread exists
+    if(mDisplayThread.get())
+        {
+        ///Kill the display thread
+        sem.Create();
+        msg.command = DisplayThread::DISPLAY_EXIT;
+
+        // Send the semaphore to signal once the command is completed
+        msg.arg1 = &sem;
+
+        ///Post the message to display thread
+        mDisplayThread->msgQ().put(&msg);
+
+        ///Wait for the ACK - implies that the thread is now started and waiting for frames
+        sem.Wait();
+
+        // Exit and cleanup the thread
+        mDisplayThread->requestExitAndWait();
+
+        // Delete the display thread
+        mDisplayThread.clear();
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+}
+
+status_t ANativeWindowDisplayAdapter::initialize()
+{
+    LOG_FUNCTION_NAME;
+
+    ///Create the display thread
+    mDisplayThread = new DisplayThread(this);
+    if ( !mDisplayThread.get() )
+        {
+        CAMHAL_LOGEA("Couldn't create display thread");
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_MEMORY;
+    }
+
+    ///Start the display thread
+    status_t ret = mDisplayThread->run("DisplayThread", PRIORITY_URGENT_DISPLAY);
+    if ( ret != NO_ERROR )
+        {
+        CAMHAL_LOGEA("Couldn't run display thread");
+        LOG_FUNCTION_NAME_EXIT;
+        return ret;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+int ANativeWindowDisplayAdapter::setPreviewWindow(preview_stream_ops_t* window)
+{
+    LOG_FUNCTION_NAME;
+    ///Note that Display Adapter cannot work without a valid window object
+    if ( !window)
+        {
+        CAMHAL_LOGEA("NULL window object passed to DisplayAdapter");
+        LOG_FUNCTION_NAME_EXIT;
+        return BAD_VALUE;
+    }
+
+    ///Destroy the existing window object, if it exists
+    destroy();
+
+    ///Move to new window obj
+    mANativeWindow = window;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NO_ERROR;
+}
+
+int ANativeWindowDisplayAdapter::setFrameProvider(FrameNotifier *frameProvider)
+{
+    LOG_FUNCTION_NAME;
+
+    // Check for NULL pointer
+    if ( !frameProvider )
+        {
+        CAMHAL_LOGEA("NULL passed for frame provider");
+        LOG_FUNCTION_NAME_EXIT;
+        return BAD_VALUE;
+    }
+
+    /** Dont do anything here, Just save the pointer for use when display is
+         actually enabled or disabled
+    */
+    mFrameProvider = new FrameProvider(frameProvider, this, frameCallbackRelay);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NO_ERROR;
+}
+
+int ANativeWindowDisplayAdapter::setErrorHandler(ErrorNotifier *errorNotifier)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == errorNotifier )
+        {
+        CAMHAL_LOGEA("Invalid Error Notifier reference");
+        ret = -EINVAL;
+    }
+
+    if ( NO_ERROR == ret )
+        {
+        mErrorNotifier = errorNotifier;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+status_t ANativeWindowDisplayAdapter::setSnapshotTimeRef(struct timeval *refTime)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != refTime )
+        {
+        Mutex::Autolock lock(mLock);
+        memcpy(&mStartCapture, refTime, sizeof(struct timeval));
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+#endif
+
+
+int ANativeWindowDisplayAdapter::enableDisplay(int width, int height, struct timeval *refTime, S3DParameters *s3dParams)
+{
+    Semaphore sem;
+    TIUTILS::Message msg;
+
+    LOG_FUNCTION_NAME;
+
+    if ( mDisplayEnabled )
+        {
+        CAMHAL_LOGDA("Display is already enabled");
+        LOG_FUNCTION_NAME_EXIT;
+
+        return NO_ERROR;
+    }
+
+#if 0 //TODO: s3d is not part of bringup...will reenable
+    if (s3dParams)
+        mOverlay->set_s3d_params(s3dParams->mode, s3dParams->framePacking,
+                                    s3dParams->order, s3dParams->subSampling);
+#endif
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    if ( NULL != refTime )
+        {
+        Mutex::Autolock lock(mLock);
+        memcpy(&mStandbyToShot, refTime, sizeof(struct timeval));
+        mMeasureStandby = true;
+    }
+
+#endif
+
+    //Send START_DISPLAY COMMAND to display thread. Display thread will start and then wait for a message
+    sem.Create();
+    msg.command = DisplayThread::DISPLAY_START;
+
+    // Send the semaphore to signal once the command is completed
+    msg.arg1 = &sem;
+
+    ///Post the message to display thread
+    mDisplayThread->msgQ().put(&msg);
+
+    ///Wait for the ACK - implies that the thread is now started and waiting for frames
+    sem.Wait();
+
+    // Register with the frame provider for frames
+    mFrameProvider->enableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
+
+    mDisplayEnabled = true;
+    mPreviewWidth = width;
+    mPreviewHeight = height;
+
+    CAMHAL_LOGVB("mPreviewWidth = %d mPreviewHeight = %d", mPreviewWidth, mPreviewHeight);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NO_ERROR;
+}
+
+int ANativeWindowDisplayAdapter::disableDisplay()
+{
+    LOG_FUNCTION_NAME;
+
+    if(!mDisplayEnabled)
+        {
+        CAMHAL_LOGDA("Display is already disabled");
+        LOG_FUNCTION_NAME_EXIT;
+        return ALREADY_EXISTS;
+    }
+
+    // Unregister with the frame provider here
+    mFrameProvider->disableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
+
+    if ( NULL != mDisplayThread.get() )
+        {
+        //Send STOP_DISPLAY COMMAND to display thread. Display thread will stop and dequeue all messages
+        // and then wait for message
+        Semaphore sem;
+        sem.Create();
+        TIUTILS::Message msg;
+        msg.command = DisplayThread::DISPLAY_STOP;
+
+        // Send the semaphore to signal once the command is completed
+        msg.arg1 = &sem;
+
+        ///Post the message to display thread
+        mDisplayThread->msgQ().put(&msg);
+
+        ///Wait for the ACK for display to be disabled
+
+        sem.Wait();
+
+    }
+
+    Mutex::Autolock lock(mLock);
+    {
+        ///Reset the display enabled flag
+        mDisplayEnabled = false;
+
+        ///Reset the offset values
+        mXOff = 0;
+        mYOff = 0;
+
+        ///Reset the frame width and height values
+        mFrameWidth =0;
+        mFrameHeight = 0;
+        mPreviewWidth = 0;
+        mPreviewHeight = 0;
+
+
+        if (mANativeWindow)
+            for(unsigned int i = 0; i < mFramesWithCameraAdapterMap.size(); i++) {
+                int value = mFramesWithCameraAdapterMap.valueAt(i);
+                mANativeWindow->cancel_buffer(mANativeWindow, mBufferHandleMap[value]);
+            }
+        else
+            LOGE("mANativeWindow is NULL");
+
+        ///Clear the frames with camera adapter map
+        mFramesWithCameraAdapterMap.clear();
+    }
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NO_ERROR;
+}
+
+status_t ANativeWindowDisplayAdapter::pauseDisplay(bool pause)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    {
+        Mutex::Autolock lock(mLock);
+        mPaused = pause;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+
+void ANativeWindowDisplayAdapter::destroy()
+{
+    LOG_FUNCTION_NAME;
+
+    ///Check if the display is disabled, if not disable it
+    if ( mDisplayEnabled )
+    {
+        CAMHAL_LOGDA("WARNING: Calling destroy of Display adapter when display enabled. Disabling display..");
+        disableDisplay();
+    }
+
+    mBufferCount = 0;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+// Implementation of inherited interfaces
+void* ANativeWindowDisplayAdapter::allocateBuffer(int width, int height, const char* format, int &bytes, int numBufs)
+{
+    LOG_FUNCTION_NAME;
+    status_t err;
+    int i = -1;
+    const int lnumBufs = numBufs;
+    int32_t *buffers = new int32_t[lnumBufs];
+    mBufferHandleMap = new buffer_handle_t*[lnumBufs];
+    mGrallocHandleMap = new IMG_native_handle_t*[lnumBufs];
+    int undequeued = 0;
+
+    // Set gralloc usage bits for window.
+    err = mANativeWindow->set_usage(mANativeWindow, GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN
+            | GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP);
+    if (err != 0) {
+        LOGE("native_window_set_usage failed: %s (%d)", strerror(-err), -err);
+        return NULL;
+    }
+
+    CAMHAL_LOGDB("Number of buffers set to ANativeWindow %d", numBufs);
+    //if(mBufferCount != numBufs)
+    //    {
+        ///Set the number of buffers needed for camera preview
+        err = mANativeWindow->set_buffer_count(mANativeWindow, numBufs);
+        if (err != 0) {
+            LOGE("native_window_set_buffer_count failed: %s (%d)", strerror(-err), -err);
+            return NULL;
+        }
+        CAMHAL_LOGDB("Configuring %d buffers for ANativeWindow", numBufs);
+        mBufferCount = numBufs;
+    //}
+
+    // Set window geometry
+    err = mANativeWindow->set_buffers_geometry(
+            mANativeWindow,
+            width,
+            height,
+            /*toOMXPixFormat(format)*/HAL_PIXEL_FORMAT_NV12);  // Gralloc only supports NV12 alloc!
+
+    if (err != 0) {
+        LOGE("native_window_set_buffers_geometry failed: %s (%d)", strerror(-err), -err);
+        return NULL;
+    }
+
+    ///We just return the buffers from ANativeWindow, if the width and height are same, else (vstab, vnf case)
+    ///re-allocate buffers using ANativeWindow and then get them
+    ///@todo - Re-allocate buffers for vnf and vstab using the width, height, format, numBufs etc
+    if ( (buffers == NULL) || (mBufferHandleMap == NULL) )
+    {
+        CAMHAL_LOGEA("Couldn't create array for ANativeWindow buffers");
+        LOG_FUNCTION_NAME_EXIT;
+        delete [] buffers;
+        return NULL;
+    }
+
+    mANativeWindow->get_min_undequeued_buffer_count(mANativeWindow, &undequeued);
+
+    for ( i=0; i < mBufferCount; i++ )
+    {
+        IMG_native_handle_t** hndl2hndl;
+        IMG_native_handle_t* handle;
+        int stride;  // dummy variable to get stride
+        // TODO(XXX): Do we need to keep stride information in camera hal?
+
+        err = mANativeWindow->dequeue_buffer(mANativeWindow, (buffer_handle_t**) &hndl2hndl, &stride);
+
+        if (err != 0) {
+            CAMHAL_LOGEB("dequeueBuffer failed: %s (%d)", strerror(-err), -err);
+            goto fail;
+        }
+
+        handle = *hndl2hndl;
+
+        mBufferHandleMap[i] = (buffer_handle_t*) hndl2hndl;
+        mGrallocHandleMap[i] = handle;
+        mFramesWithCameraAdapterMap.add((int) mGrallocHandleMap[i], i);
+
+        bytes =  getBufSize(format, width, height);
+
+        CAMHAL_LOGDB("Adding buffer index=%d, address=0x%x", i, buffers[i]);
+    }
+
+
+    // lock the initial queueable buffers
+    for( i = 0;  i < mBufferCount-undequeued; i++ )
+    {
+        mANativeWindow->lock_buffer(mANativeWindow, mBufferHandleMap[i]);
+    }
+
+    // return the rest of the buffers back to ANativeWindow
+    for(i = (mBufferCount-undequeued); i >= 0 && i < mBufferCount; i++)
+    {
+        mANativeWindow->cancel_buffer(mANativeWindow, mBufferHandleMap[i]);
+    }
+
+    mFirstInit = true;
+    mPixelFormat = getPixFormatConstant(format);
+    mFrameWidth = width;
+    mFrameHeight = height;
+
+    return mGrallocHandleMap;
+
+ fail:
+    // need to cancel buffers if any were dequeued
+    for (int start = 0; start < i && i > 0; start++) {
+        int err = mANativeWindow->cancel_buffer(mANativeWindow, mBufferHandleMap[start]);
+        if (err != 0) {
+          CAMHAL_LOGEB("cancelBuffer failed w/ error 0x%08x", err);
+        }
+    }
+    CAMHAL_LOGEA("Error occurred, performing cleanup");
+    if ( buffers )
+        {
+        delete [] buffers;
+    }
+
+    if ( NULL != mErrorNotifier.get() )
+        {
+        mErrorNotifier->errorNotify(-ENOMEM);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+    return NULL;
+
+}
+
+uint32_t * ANativeWindowDisplayAdapter::getOffsets()
+{
+    const int lnumBufs = mBufferCount;
+
+    LOG_FUNCTION_NAME;
+
+    // TODO(XXX): Need to remove getOffsets from the API. No longer needed
+
+    if ( NULL == mANativeWindow )
+    {
+        CAMHAL_LOGEA("mANativeWindow reference is missing");
+        goto fail;
+    }
+
+    if( mBufferHandleMap == NULL)
+    {
+        CAMHAL_LOGEA("Buffers not allocated yet!!");
+        goto fail;
+    }
+
+    if(mOffsetsMap == NULL)
+    {
+        mOffsetsMap = new uint32_t[lnumBufs];
+        for(int i = 0; i < mBufferCount; i++)
+        {
+            IMG_native_handle_t* handle =  (IMG_native_handle_t*) *(mBufferHandleMap[i]);
+            mOffsetsMap[i] = 0;
+        }
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return mOffsetsMap;
+
+ fail:
+
+    if ( NULL != mOffsetsMap )
+    {
+        delete [] mOffsetsMap;
+        mOffsetsMap = NULL;
+    }
+
+    if ( NULL != mErrorNotifier.get() )
+    {
+        mErrorNotifier->errorNotify(-ENOSYS);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NULL;
+}
+
+int ANativeWindowDisplayAdapter::maxQueueableBuffers(unsigned int& queueable)
+{
+    LOG_FUNCTION_NAME;
+    int ret = NO_ERROR;
+    int undequeued = 0;
+
+    if(mBufferCount == 0)
+    {
+        ret = -ENOSYS;
+        goto end;
+    }
+
+    if(!mANativeWindow)
+    {
+        ret = -ENOSYS;
+        goto end;
+    }
+
+    mANativeWindow->get_min_undequeued_buffer_count(mANativeWindow, &undequeued);
+
+    queueable = mBufferCount - undequeued;
+
+ end:
+    return ret;
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+int ANativeWindowDisplayAdapter::getFd()
+{
+    LOG_FUNCTION_NAME;
+
+    if(mFD == -1)
+    {
+        IMG_native_handle_t* handle =  (IMG_native_handle_t*) *(mBufferHandleMap[0]);
+        // TODO: should we dup the fd? not really necessary and another thing for ANativeWindow
+        // to manage and close...
+        mFD = dup(handle->fd[0]);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return mFD;
+
+}
+
+int ANativeWindowDisplayAdapter::freeBuffer(void* buf)
+{
+    LOG_FUNCTION_NAME;
+
+    int *buffers = (int *) buf;
+    if((int *)mGrallocHandleMap != buffers)
+    {
+        CAMHAL_LOGEA("CameraHal passed wrong set of buffers to free!!!");
+        if (mGrallocHandleMap != NULL)
+            delete []mGrallocHandleMap;
+        mGrallocHandleMap = NULL;
+    }
+
+    if ( NULL != buf )
+    {
+        delete [] buffers;
+    }
+
+    if( mBufferHandleMap != NULL)
+    {
+        delete [] mBufferHandleMap;
+        mBufferHandleMap = NULL;
+    }
+
+    if ( NULL != mOffsetsMap )
+    {
+        delete [] mOffsetsMap;
+        mOffsetsMap = NULL;
+    }
+
+    if( mFD != -1)
+    {
+        close(mFD);  // close duped handle
+        mFD = -1;
+    }
+
+    return NO_ERROR;
+}
+
+
+bool ANativeWindowDisplayAdapter::supportsExternalBuffering()
+{
+    return false;
+}
+
+int ANativeWindowDisplayAdapter::useBuffers(void *bufArr, int num)
+{
+    return NO_ERROR;
+}
+
+void ANativeWindowDisplayAdapter::displayThread()
+{
+    bool shouldLive = true;
+    int timeout = 0;
+    status_t ret;
+
+    LOG_FUNCTION_NAME;
+
+    while(shouldLive)
+        {
+        ret = TIUTILS::MessageQueue::waitForMsg(&mDisplayThread->msgQ()
+                                                                ,  &mDisplayQ
+                                                                , NULL
+                                                                , ANativeWindowDisplayAdapter::DISPLAY_TIMEOUT);
+
+        if ( !mDisplayThread->msgQ().isEmpty() )
+            {
+            ///Received a message from CameraHal, process it
+            shouldLive = processHalMsg();
+
+            }
+        else  if( !mDisplayQ.isEmpty())
+            {
+            if ( mDisplayState== ANativeWindowDisplayAdapter::DISPLAY_INIT )
+                {
+
+                ///If display adapter is not started, continue
+                continue;
+
+                }
+            else
+                {
+                TIUTILS::Message msg;
+                ///Get the dummy msg from the displayQ
+                if(mDisplayQ.get(&msg)!=NO_ERROR)
+                    {
+                    CAMHAL_LOGEA("Error in getting message from display Q");
+                    continue;
+                }
+
+                // There is a frame from ANativeWindow for us to dequeue
+                // We dequeue and return the frame back to Camera adapter
+                if(mDisplayState == ANativeWindowDisplayAdapter::DISPLAY_STARTED)
+                {
+                    handleFrameReturn();
+                }
+
+                if (mDisplayState == ANativeWindowDisplayAdapter::DISPLAY_EXITED)
+                    {
+                    ///we exit the thread even though there are frames still to dequeue. They will be dequeued
+                    ///in disableDisplay
+                    shouldLive = false;
+                }
+            }
+        }
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+bool ANativeWindowDisplayAdapter::processHalMsg()
+{
+    TIUTILS::Message msg;
+
+    LOG_FUNCTION_NAME;
+
+
+    mDisplayThread->msgQ().get(&msg);
+    bool ret = true, invalidCommand = false;
+
+    switch ( msg.command )
+        {
+
+        case DisplayThread::DISPLAY_START:
+
+            CAMHAL_LOGDA("Display thread received DISPLAY_START command from Camera HAL");
+            mDisplayState = ANativeWindowDisplayAdapter::DISPLAY_STARTED;
+
+            break;
+
+        case DisplayThread::DISPLAY_STOP:
+
+            ///@bug There is no API to disable SF without destroying it
+            ///@bug Buffers might still be w/ display and will get displayed
+            ///@remarks Ideal seqyence should be something like this
+            ///mOverlay->setParameter("enabled", false);
+            CAMHAL_LOGDA("Display thread received DISPLAY_STOP command from Camera HAL");
+            mDisplayState = ANativeWindowDisplayAdapter::DISPLAY_STOPPED;
+
+            break;
+
+        case DisplayThread::DISPLAY_EXIT:
+
+            CAMHAL_LOGDA("Display thread received DISPLAY_EXIT command from Camera HAL.");
+            CAMHAL_LOGDA("Stopping display thread...");
+            mDisplayState = ANativeWindowDisplayAdapter::DISPLAY_EXITED;
+            ///Note that the SF can have pending buffers when we disable the display
+            ///This is normal and the expectation is that they may not be displayed.
+            ///This is to ensure that the user experience is not impacted
+            ret = false;
+            break;
+
+        default:
+
+            CAMHAL_LOGEB("Invalid Display Thread Command 0x%x.", msg.command);
+            invalidCommand = true;
+
+            break;
+    }
+
+    ///Signal the semaphore if it is sent as part of the message
+    if ( ( msg.arg1 ) && ( !invalidCommand ) )
+        {
+
+        CAMHAL_LOGDA("+Signalling display semaphore");
+        Semaphore &sem = *((Semaphore*)msg.arg1);
+
+        sem.Signal();
+
+        CAMHAL_LOGDA("-Signalling display semaphore");
+    }
+
+
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+
+status_t ANativeWindowDisplayAdapter::PostFrame(ANativeWindowDisplayAdapter::DisplayFrame &dispFrame)
+{
+    status_t ret = NO_ERROR;
+    uint32_t actualFramesWithDisplay = 0;
+    android_native_buffer_t *buffer = NULL;
+    int i;
+
+    ///@todo Do cropping based on the stabilized frame coordinates
+    ///@todo Insert logic to drop frames here based on refresh rate of
+    ///display or rendering rate whichever is lower
+    ///Queue the buffer to overlay
+    for ( i = 0; i < mBufferCount; i++ )
+        {
+        if ( ((int) dispFrame.mBuffer ) == (int)mGrallocHandleMap[i] )
+            {
+            break;
+        }
+    }
+
+    if ( mDisplayState == ANativeWindowDisplayAdapter::DISPLAY_STARTED &&
+                (!mPaused ||  CameraFrame::CameraFrame::SNAPSHOT_FRAME == dispFrame.mType) &&
+                !mSuspend)
+    {
+        Mutex::Autolock lock(mLock);
+        uint32_t xOff = (dispFrame.mOffset% PAGE_SIZE);
+        uint32_t yOff = (dispFrame.mOffset / PAGE_SIZE);
+
+        // Set crop only if current x and y offsets do not match with frame offsets
+        if((mXOff!=xOff) || (mYOff!=yOff))
+        {
+            CAMHAL_LOGDB("Offset %d xOff = %d, yOff = %d", dispFrame.mOffset, xOff, yOff);
+            uint8_t bytesPerPixel;
+            ///Calculate bytes per pixel based on the pixel format
+            if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
+                {
+                bytesPerPixel = 2;
+                }
+            else if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
+                {
+                bytesPerPixel = 2;
+                }
+            else if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0)
+                {
+                bytesPerPixel = 1;
+                }
+            else
+                {
+                bytesPerPixel = 1;
+            }
+
+            CAMHAL_LOGVB(" crop.left = %d crop.top = %d crop.right = %d crop.bottom = %d",
+                          xOff/bytesPerPixel, yOff , (xOff/bytesPerPixel)+mPreviewWidth, yOff+mPreviewHeight);
+            // We'll ignore any errors here, if the surface is
+            // already invalid, we'll know soon enough.
+            mANativeWindow->set_crop(mANativeWindow, xOff/bytesPerPixel, yOff,
+                                     (xOff/bytesPerPixel)+mPreviewWidth, yOff+mPreviewHeight);
+
+            ///Update the current x and y offsets
+            mXOff = xOff;
+            mYOff = yOff;
+        }
+
+        ret = mANativeWindow->enqueue_buffer(mANativeWindow, mBufferHandleMap[i]);
+        if (ret != 0) {
+            LOGE("Surface::queueBuffer returned error %d", ret);
+        }
+
+        mFramesWithCameraAdapterMap.removeItem((int) dispFrame.mBuffer);
+
+
+        // HWComposer has not minimum buffer requirement. We should be able to dequeue
+        // the buffer immediately
+        TIUTILS::Message msg;
+        mDisplayQ.put(&msg);
+
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+        if ( mMeasureStandby )
+            {
+            CameraHal::PPM("Standby to first shot: Sensor Change completed - ", &mStandbyToShot);
+            mMeasureStandby = false;
+            }
+        else if (CameraFrame::CameraFrame::SNAPSHOT_FRAME == dispFrame.mType)
+            {
+            CameraHal::PPM("Shot to snapshot: ", &mStartCapture);
+            mShotToShot = true;
+            }
+        else if ( mShotToShot )
+            {
+            CameraHal::PPM("Shot to shot: ", &mStartCapture);
+            mShotToShot = false;
+        }
+#endif
+
+    }
+    else
+    {
+        Mutex::Autolock lock(mLock);
+        // cancel buffer and dequeue another one
+        ret = mANativeWindow->cancel_buffer(mANativeWindow, mBufferHandleMap[i]);
+        if (ret != 0) {
+            LOGE("Surface::queueBuffer returned error %d", ret);
+        }
+
+        mFramesWithCameraAdapterMap.removeItem((int) dispFrame.mBuffer);
+
+        TIUTILS::Message msg;
+        mDisplayQ.put(&msg);
+        ret = NO_ERROR;
+    }
+
+    return ret;
+}
+
+
+bool ANativeWindowDisplayAdapter::handleFrameReturn()
+{
+    status_t err;
+    buffer_handle_t* buf;
+    int i = 0;
+    int stride;  // dummy variable to get stride
+    // TODO(XXX): Do we need to keep stride information in camera hal?
+
+    err = mANativeWindow->dequeue_buffer(mANativeWindow, &buf, &stride);
+    if (err != 0) {
+        CAMHAL_LOGEB("dequeueBuffer failed: %s (%d)", strerror(-err), -err);
+    }
+
+    err = mANativeWindow->lock_buffer(mANativeWindow, buf);
+    if (err != 0) {
+        CAMHAL_LOGEB("lockbuffer failed: %s (%d)", strerror(-err), -err);
+    }
+
+    for(i = 0; i < mBufferCount; i++)
+    {
+        if (mBufferHandleMap[i] == buf)
+            break;
+    }
+
+    mFramesWithCameraAdapterMap.add((int) mGrallocHandleMap[i], i);
+
+    CAMHAL_LOGVB("handleFrameReturn: found graphic buffer %d of %d", i, mBufferCount-1);
+    mFrameProvider->returnFrame( (void*)mGrallocHandleMap[i], CameraFrame::PREVIEW_FRAME_SYNC);
+    return true;
+}
+
+void ANativeWindowDisplayAdapter::frameCallbackRelay(CameraFrame* caFrame)
+{
+
+    if ( NULL != caFrame )
+        {
+        if ( NULL != caFrame->mCookie )
+            {
+            ANativeWindowDisplayAdapter *da = (ANativeWindowDisplayAdapter*) caFrame->mCookie;
+            da->frameCallback(caFrame);
+        }
+        else
+            {
+            CAMHAL_LOGEB("Invalid Cookie in Camera Frame = %p, Cookie = %p", caFrame, caFrame->mCookie);
+            }
+        }
+    else
+        {
+        CAMHAL_LOGEB("Invalid Camera Frame = %p", caFrame);
+    }
+
+}
+
+void ANativeWindowDisplayAdapter::frameCallback(CameraFrame* caFrame)
+{
+    ///Call queueBuffer of overlay in the context of the callback thread
+    DisplayFrame df;
+    df.mBuffer = caFrame->mBuffer;
+    df.mType = (CameraFrame::FrameType) caFrame->mFrameType;
+    df.mOffset = caFrame->mOffset;
+    df.mWidthStride = caFrame->mAlignment;
+    df.mLength = caFrame->mLength;
+    df.mWidth = caFrame->mWidth;
+    df.mHeight = caFrame->mHeight;
+    PostFrame(df);
+}
+
+
+/*--------------------ANativeWindowDisplayAdapter Class ENDS here-----------------------------*/
+
+};
+
diff --git a/camera/Android.mk b/camera/Android.mk
new file mode 100644
index 0000000..0e2bb8c
--- /dev/null
+++ b/camera/Android.mk
@@ -0,0 +1,131 @@
+ifeq ($(TARGET_BOARD_PLATFORM),omap4)
+
+LOCAL_PATH:= $(call my-dir)
+
+OMAP4_CAMERA_HAL_USES:= OMX
+# OMAP4_CAMERA_HAL_USES:= USB
+
+OMAP4_CAMERA_HAL_SRC := \
+	CameraHal_Module.cpp \
+	CameraHal.cpp \
+	CameraHalUtilClasses.cpp \
+	AppCallbackNotifier.cpp \
+	ANativeWindowDisplayAdapter.cpp \
+	CameraProperties.cpp \
+	MemoryManager.cpp \
+	SensorListener.cpp
+
+OMAP4_CAMERA_COMMON_SRC:= \
+	CameraParameters.cpp \
+	TICameraParameters.cpp \
+	CameraHalCommon.cpp
+
+OMAP4_CAMERA_OMX_SRC:= \
+	BaseCameraAdapter.cpp \
+	OMXCameraAdapter/OMX3A.cpp \
+	OMXCameraAdapter/OMXAlgo.cpp \
+	OMXCameraAdapter/OMXCameraAdapter.cpp \
+	OMXCameraAdapter/OMXCapabilities.cpp \
+	OMXCameraAdapter/OMXCapture.cpp \
+	OMXCameraAdapter/OMXDefaults.cpp \
+	OMXCameraAdapter/OMXExif.cpp \
+	OMXCameraAdapter/OMXFD.cpp \
+	OMXCameraAdapter/OMXFocus.cpp \
+	OMXCameraAdapter/OMXZoom.cpp \
+
+OMAP4_CAMERA_USB_SRC:= \
+	BaseCameraAdapter.cpp \
+	V4LCameraAdapter/V4LCameraAdapter.cpp
+
+#
+# OMX Camera HAL 
+#
+
+ifeq ($(OMAP4_CAMERA_HAL_USES),OMX)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	$(OMAP4_CAMERA_HAL_SRC) \
+	$(OMAP4_CAMERA_OMX_SRC) \
+	$(OMAP4_CAMERA_COMMON_SRC)
+
+LOCAL_C_INCLUDES += \
+    $(LOCAL_PATH)/inc/ \
+    $(LOCAL_PATH)/../hwc \
+    $(LOCAL_PATH)/../include \
+    $(LOCAL_PATH)/inc/OMXCameraAdapter \
+    $(LOCAL_PATH)/../libtiutils \
+    hardware/ti/omap4xxx/tiler \
+    frameworks/base/include/ui \
+    frameworks/base/include/utils \
+    hardware/ti/omap4xxx/domx/omx_core/inc \
+    hardware/ti/omap4xxx/domx/mm_osal/inc \
+    frameworks/base/include/media/stagefright \
+    frameworks/base/include/media/stagefright/openmax
+
+LOCAL_SHARED_LIBRARIES:= \
+    libui \
+    libbinder \
+    libutils \
+    libcutils \
+    libtiutils \
+    libmm_osal \
+    libOMX_Core \
+    libtimemmgr \
+    libcamera_client \
+    libgui \
+    libdomx
+
+LOCAL_CFLAGS := -fno-short-enums -DCOPY_IMAGE_BUFFER
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_MODULE:= camera.$(TARGET_BOARD_PLATFORM)
+LOCAL_MODULE_TAGS:= optional
+
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
+else
+ifeq ($(OMAP4_CAMERA_HAL_USES),USB)
+
+#
+# USB Camera Adapter
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	$(OMAP4_CAMERA_HAL_SRC) \
+	$(OMAP4_CAMERA_USB_SRC) \
+	$(OMAP4_CAMERA_COMMON_SRC)
+
+LOCAL_C_INCLUDES += \
+    $(LOCAL_PATH)/inc/ \
+    $(LOCAL_PATH)/../hwc \
+    $(LOCAL_PATH)/../include \
+    $(LOCAL_PATH)/inc/V4LCameraAdapter \
+    $(LOCAL_PATH)/../libtiutils \
+    hardware/ti/omap4xxx/tiler \
+    frameworks/base/include/ui \
+    frameworks/base/include/utils \
+    frameworks/base/include/media/stagefright/openmax
+
+LOCAL_SHARED_LIBRARIES:= \
+    libui \
+    libbinder \
+    libutils \
+    libcutils \
+    libtiutils \
+    libtimemmgr \
+    libcamera_client
+
+LOCAL_CFLAGS := -fno-short-enums -DCOPY_IMAGE_BUFFER
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_MODULE:= camera.$(TARGET_BOARD_PLATFORM)
+LOCAL_MODULE_TAGS:= optional
+
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+endif
+endif 
+endif
diff --git a/camera/AppCallbackNotifier.cpp b/camera/AppCallbackNotifier.cpp
new file mode 100644
index 0000000..d266cc2
--- /dev/null
+++ b/camera/AppCallbackNotifier.cpp
@@ -0,0 +1,1399 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 "CameraHal.h"
+#include "VideoMetadata.h"
+#include <MetadataBufferType.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/GraphicBufferMapper.h>
+
+
+namespace android {
+
+const int AppCallbackNotifier::NOTIFIER_TIMEOUT = -1;
+
+/*--------------------NotificationHandler Class STARTS here-----------------------------*/
+
+/**
+  * NotificationHandler class
+  */
+
+
+///Initialization function for AppCallbackNotifier
+status_t AppCallbackNotifier::initialize()
+{
+    LOG_FUNCTION_NAME;
+
+    mMeasurementEnabled = false;
+
+    ///Create the app notifier thread
+    mNotificationThread = new NotificationThread(this);
+    if(!mNotificationThread.get())
+        {
+        CAMHAL_LOGEA("Couldn't create Notification thread");
+        return NO_MEMORY;
+        }
+
+    ///Start the display thread
+    status_t ret = mNotificationThread->run("NotificationThread", PRIORITY_URGENT_DISPLAY);
+    if(ret!=NO_ERROR)
+        {
+        CAMHAL_LOGEA("Couldn't run NotificationThread");
+        mNotificationThread.clear();
+        return ret;
+        }
+
+    mUseMetaDataBufferMode = true;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+void AppCallbackNotifier::setCallbacks(CameraHal* cameraHal,
+                                        camera_notify_callback notify_cb,
+                                        camera_data_callback data_cb,
+                                        camera_data_timestamp_callback data_cb_timestamp,
+                                        camera_request_memory get_memory,
+                                        void *user)
+{
+    Mutex::Autolock lock(mLock);
+
+    LOG_FUNCTION_NAME;
+
+    mCameraHal = cameraHal;
+    mNotifyCb = notify_cb;
+    mDataCb = data_cb;
+    mDataCbTimestamp = data_cb_timestamp;
+    mRequestMemory = get_memory;
+    mCallbackCookie = user;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void AppCallbackNotifier::setMeasurements(bool enable)
+{
+    Mutex::Autolock lock(mLock);
+
+    LOG_FUNCTION_NAME;
+
+    mMeasurementEnabled = enable;
+
+    if (  enable  )
+        {
+         mFrameProvider->enableFrameNotification(CameraFrame::FRAME_DATA_SYNC);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+//All sub-components of Camera HAL call this whenever any error happens
+void AppCallbackNotifier::errorNotify(int error)
+{
+    LOG_FUNCTION_NAME;
+
+    CAMHAL_LOGEB("AppCallbackNotifier received error %d", error);
+
+    ///Notify errors to application in callback thread. Post error event to event queue
+    TIUTILS::Message msg;
+    msg.command = AppCallbackNotifier::NOTIFIER_CMD_PROCESS_ERROR;
+    msg.arg1 = (void*)error;
+
+    mEventQ.put(&msg);
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void AppCallbackNotifier::notificationThread()
+{
+    bool shouldLive = true;
+    status_t ret;
+
+    LOG_FUNCTION_NAME;
+
+    while(shouldLive)
+        {
+        //CAMHAL_LOGDA("Notification Thread waiting for message");
+        ret = TIUTILS::MessageQueue::waitForMsg(&mNotificationThread->msgQ(),
+                                                &mEventQ,
+                                                &mFrameQ,
+                                                AppCallbackNotifier::NOTIFIER_TIMEOUT);
+
+        //CAMHAL_LOGDA("Notification Thread received message");
+
+        if(mNotificationThread->msgQ().hasMsg())
+            {
+            ///Received a message from CameraHal, process it
+            CAMHAL_LOGDA("Notification Thread received message from Camera HAL");
+            shouldLive = processMessage();
+            if(!shouldLive)
+                {
+                CAMHAL_LOGDA("Notification Thread exiting.");
+                }
+            }
+        if(mEventQ.hasMsg())
+            {
+            ///Received an event from one of the event providers
+            CAMHAL_LOGDA("Notification Thread received an event from event provider (CameraAdapter)");
+            notifyEvent();
+            }
+        if(mFrameQ.hasMsg())
+            {
+            ///Received a frame from one of the frame providers
+            //CAMHAL_LOGDA("Notification Thread received a frame from frame provider (CameraAdapter)");
+            notifyFrame();
+            }
+        }
+
+    CAMHAL_LOGDA("Notification Thread exited.");
+    LOG_FUNCTION_NAME_EXIT;
+
+}
+
+void AppCallbackNotifier::notifyEvent()
+{
+    ///Receive and send the event notifications to app
+    TIUTILS::Message msg;
+    LOG_FUNCTION_NAME;
+    mEventQ.get(&msg);
+    bool ret = true;
+    CameraHalEvent *evt = NULL;
+    CameraHalEvent::FocusEventData *focusEvtData;
+    CameraHalEvent::ZoomEventData *zoomEvtData;
+    CameraHalEvent::FaceEventData faceEvtData;
+
+    if(mNotifierState != AppCallbackNotifier::NOTIFIER_STARTED)
+    {
+        return;
+    }
+
+    switch(msg.command)
+        {
+        case AppCallbackNotifier::NOTIFIER_CMD_PROCESS_EVENT:
+
+            evt = ( CameraHalEvent * ) msg.arg1;
+
+            if ( NULL == evt )
+                {
+                CAMHAL_LOGEA("Invalid CameraHalEvent");
+                return;
+                }
+
+            switch(evt->mEventType)
+                {
+                case CameraHalEvent::EVENT_SHUTTER:
+
+                    if ( ( NULL != mCameraHal ) &&
+                          ( NULL != mNotifyCb ) &&
+                          ( mCameraHal->msgTypeEnabled(CAMERA_MSG_SHUTTER) ) )
+                        {
+                            mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
+                        }
+
+                    break;
+
+                case CameraHalEvent::EVENT_FOCUS_LOCKED:
+                case CameraHalEvent::EVENT_FOCUS_ERROR:
+
+                    focusEvtData = &evt->mEventData->focusEvent;
+                    if ( ( focusEvtData->focusLocked ) &&
+                          ( NULL != mCameraHal ) &&
+                          ( NULL != mNotifyCb ) &&
+                          ( mCameraHal->msgTypeEnabled(CAMERA_MSG_FOCUS) ) )
+                        {
+                         mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
+                        }
+                    else if ( focusEvtData->focusError &&
+                                ( NULL != mCameraHal ) &&
+                                ( NULL != mNotifyCb ) &&
+                                ( mCameraHal->msgTypeEnabled(CAMERA_MSG_FOCUS) ) )
+                        {
+                         mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
+                        }
+
+                    break;
+
+                case CameraHalEvent::EVENT_ZOOM_INDEX_REACHED:
+
+                    zoomEvtData = &evt->mEventData->zoomEvent;
+
+                    if ( ( NULL != mCameraHal ) &&
+                         ( NULL != mNotifyCb) &&
+                         ( mCameraHal->msgTypeEnabled(CAMERA_MSG_ZOOM) ) )
+                        {
+                        mNotifyCb(CAMERA_MSG_ZOOM, zoomEvtData->currentZoomIndex, zoomEvtData->targetZoomIndexReached, mCallbackCookie);
+                        }
+
+                    break;
+
+                case CameraHalEvent::EVENT_FACE:
+
+                    faceEvtData = evt->mEventData->faceEvent;
+
+                    if ( ( NULL != mCameraHal ) &&
+                         ( NULL != mNotifyCb) &&
+                         ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_METADATA) ) )
+                        {
+                        // WA for an issue inside CameraService
+                        camera_memory_t *tmpBuffer = mRequestMemory(-1, 1, 1, NULL);
+
+                        mDataCb(CAMERA_MSG_PREVIEW_METADATA,
+                                tmpBuffer,
+                                0,
+                                faceEvtData->getFaceResult(),
+                                mCallbackCookie);
+
+                        faceEvtData.clear();
+
+                        if ( NULL != tmpBuffer ) {
+                            tmpBuffer->release(tmpBuffer);
+                        }
+
+                        }
+
+                    break;
+
+                case CameraHalEvent::ALL_EVENTS:
+                    break;
+                default:
+                    break;
+                }
+
+            break;
+
+        case AppCallbackNotifier::NOTIFIER_CMD_PROCESS_ERROR:
+
+            if (  ( NULL != mCameraHal ) &&
+                  ( NULL != mNotifyCb ) &&
+                  ( mCameraHal->msgTypeEnabled(CAMERA_MSG_ERROR) ) )
+                {
+                mNotifyCb(CAMERA_MSG_ERROR, CAMERA_ERROR_UNKNOWN, 0, mCallbackCookie);
+                }
+
+            break;
+
+        }
+
+    if ( NULL != evt )
+        {
+        delete evt;
+        }
+
+
+    LOG_FUNCTION_NAME_EXIT;
+
+}
+
+static void copy2Dto1D(void *dst,
+                       void *src,
+                       int width,
+                       int height,
+                       size_t stride,
+                       uint32_t offset,
+                       unsigned int bytesPerPixel,
+                       size_t length,
+                       const char *pixelFormat)
+{
+    unsigned int alignedRow, row;
+    unsigned char *bufferDst, *bufferSrc;
+    unsigned char *bufferDstEnd, *bufferSrcEnd;
+    uint16_t *bufferSrc_UV;
+    void *y_uv[2];     //y_uv[0]=> y pointer; y_uv[1]=>uv pointer
+
+    GraphicBufferMapper &mapper = GraphicBufferMapper::get();
+    Rect bounds;
+
+    bounds.left = offset % stride;
+    bounds.top = offset / stride;
+    bounds.right = width;
+    bounds.bottom = height;
+
+    // get the y & uv pointers from the gralloc handle;
+    mapper.lock((buffer_handle_t)src, GRALLOC_USAGE_SW_READ_OFTEN, bounds, y_uv);
+
+    CAMHAL_LOGDB("copy2Dto1D() y= %p ; uv=%p.",y_uv[0],y_uv[1]);
+    CAMHAL_LOGDB("pixelFormat,= %d; offset=%d",*pixelFormat,offset);
+
+    if (pixelFormat!=NULL) {
+        if (strcmp(pixelFormat, CameraParameters::PIXEL_FORMAT_YUV422I) == 0) {
+            bytesPerPixel = 2;
+        } else if (strcmp(pixelFormat, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 ||
+                   strcmp(pixelFormat, CameraParameters::PIXEL_FORMAT_YUV420P) == 0) {
+            bytesPerPixel = 1;
+            bufferDst = ( unsigned char * ) dst;
+            bufferDstEnd = ( unsigned char * ) dst + width*height*bytesPerPixel;
+            bufferSrc = ( unsigned char * ) y_uv[0] + offset;
+            bufferSrcEnd = ( unsigned char * ) ( ( size_t ) y_uv[0] + length + offset);
+            row = width*bytesPerPixel;
+            alignedRow = stride-width;
+            int stride_bytes = stride / 8;
+            uint32_t xOff = offset % stride;
+            uint32_t yOff = offset / stride;
+
+            // going to convert from NV12 here and return
+            // Step 1: Y plane: iterate through each row and copy
+            for ( int i = 0 ; i < height ; i++) {
+                memcpy(bufferDst, bufferSrc, row);
+                bufferSrc += stride;
+                bufferDst += row;
+                if ( ( bufferSrc > bufferSrcEnd ) || ( bufferDst > bufferDstEnd ) ) {
+                    break;
+                }
+            }
+
+            bufferSrc_UV = ( uint16_t * ) y_uv[1] + (stride/2)*yOff + xOff;
+
+            if (strcmp(pixelFormat, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0) {
+                 uint16_t *bufferDst_UV;
+
+                // Step 2: UV plane: convert NV12 to NV21 by swapping U & V
+                bufferDst_UV = (uint16_t *) (((uint8_t*)dst)+row*height);
+
+                for (int i = 0 ; i < height/2 ; i++, bufferSrc_UV += alignedRow/2) {
+                    int n = width;
+                    asm volatile (
+                    "   pld [%[src], %[src_stride], lsl #2]                         \n\t"
+                    "   cmp %[n], #32                                               \n\t"
+                    "   blt 1f                                                      \n\t"
+                    "0: @ 32 byte swap                                              \n\t"
+                    "   sub %[n], %[n], #32                                         \n\t"
+                    "   vld2.8  {q0, q1} , [%[src]]!                                \n\t"
+                    "   vswp q0, q1                                                 \n\t"
+                    "   cmp %[n], #32                                               \n\t"
+                    "   vst2.8  {q0,q1},[%[dst]]!                                   \n\t"
+                    "   bge 0b                                                      \n\t"
+                    "1: @ Is there enough data?                                     \n\t"
+                    "   cmp %[n], #16                                               \n\t"
+                    "   blt 3f                                                      \n\t"
+                    "2: @ 16 byte swap                                              \n\t"
+                    "   sub %[n], %[n], #16                                         \n\t"
+                    "   vld2.8  {d0, d1} , [%[src]]!                                \n\t"
+                    "   vswp d0, d1                                                 \n\t"
+                    "   cmp %[n], #16                                               \n\t"
+                    "   vst2.8  {d0,d1},[%[dst]]!                                   \n\t"
+                    "   bge 2b                                                      \n\t"
+                    "3: @ Is there enough data?                                     \n\t"
+                    "   cmp %[n], #8                                                \n\t"
+                    "   blt 5f                                                      \n\t"
+                    "4: @ 8 byte swap                                               \n\t"
+                    "   sub %[n], %[n], #8                                          \n\t"
+                    "   vld2.8  {d0, d1} , [%[src]]!                                \n\t"
+                    "   vswp d0, d1                                                 \n\t"
+                    "   cmp %[n], #8                                                \n\t"
+                    "   vst2.8  {d0[0],d1[0]},[%[dst]]!                             \n\t"
+                    "   bge 4b                                                      \n\t"
+                    "5: @ end                                                       \n\t"
+#ifdef NEEDS_ARM_ERRATA_754319_754320
+                    "   vmov s0,s0  @ add noop for errata item                      \n\t"
+#endif
+                    : [dst] "+r" (bufferDst_UV), [src] "+r" (bufferSrc_UV), [n] "+r" (n)
+                    : [src_stride] "r" (stride_bytes)
+                    : "cc", "memory", "q0", "q1"
+                    );
+                }
+            } else if (strcmp(pixelFormat, CameraParameters::PIXEL_FORMAT_YUV420P) == 0) {
+                 uint16_t *bufferDst_U;
+                 uint16_t *bufferDst_V;
+
+                // Step 2: UV plane: convert NV12 to YV12 by de-interleaving U & V
+                // TODO(XXX): This version of CameraHal assumes NV12 format it set at
+                //            camera adapter to support YV12. Need to address for
+                //            USBCamera
+
+                bufferDst_V = (uint16_t *) (((uint8_t*)dst)+row*height);
+                bufferDst_U = (uint16_t *) (((uint8_t*)dst)+row*height+row*height/4);
+
+                for (int i = 0 ; i < height/2 ; i++, bufferSrc_UV += alignedRow/2) {
+                    int n = width;
+                    asm volatile (
+                    "   pld [%[src], %[src_stride], lsl #2]                         \n\t"
+                    "   cmp %[n], #32                                               \n\t"
+                    "   blt 1f                                                      \n\t"
+                    "0: @ 32 byte swap                                              \n\t"
+                    "   sub %[n], %[n], #32                                         \n\t"
+                    "   vld2.8  {q0, q1} , [%[src]]!                                \n\t"
+                    "   cmp %[n], #32                                               \n\t"
+                    "   vst1.8  {q1},[%[dst_v]]!                                    \n\t"
+                    "   vst1.8  {q0},[%[dst_u]]!                                    \n\t"
+                    "   bge 0b                                                      \n\t"
+                    "1: @ Is there enough data?                                     \n\t"
+                    "   cmp %[n], #16                                               \n\t"
+                    "   blt 3f                                                      \n\t"
+                    "2: @ 16 byte swap                                              \n\t"
+                    "   sub %[n], %[n], #16                                         \n\t"
+                    "   vld2.8  {d0, d1} , [%[src]]!                                \n\t"
+                    "   cmp %[n], #16                                               \n\t"
+                    "   vst1.8  {d1},[%[dst_v]]!                                    \n\t"
+                    "   vst1.8  {d0},[%[dst_u]]!                                    \n\t"
+                    "   bge 2b                                                      \n\t"
+                    "3: @ Is there enough data?                                     \n\t"
+                    "   cmp %[n], #8                                                \n\t"
+                    "   blt 5f                                                      \n\t"
+                    "4: @ 8 byte swap                                               \n\t"
+                    "   sub %[n], %[n], #8                                          \n\t"
+                    "   vld2.8  {d0, d1} , [%[src]]!                                \n\t"
+                    "   cmp %[n], #8                                                \n\t"
+                    "   vst1.8  {d1[0]},[%[dst_v]]!                                 \n\t"
+                    "   vst1.8  {d0[0]},[%[dst_u]]!                                 \n\t"
+                    "   bge 4b                                                      \n\t"
+                    "5: @ end                                                       \n\t"
+#ifdef NEEDS_ARM_ERRATA_754319_754320
+                    "   vmov s0,s0  @ add noop for errata item                      \n\t"
+#endif
+                    : [dst_u] "+r" (bufferDst_U), [dst_v] "+r" (bufferDst_V),
+                      [src] "+r" (bufferSrc_UV), [n] "+r" (n)
+                    : [src_stride] "r" (stride_bytes)
+                    : "cc", "memory", "q0", "q1"
+                    );
+                }
+            }
+            mapper.unlock((buffer_handle_t)src);
+            return ;
+
+        } else if(strcmp(pixelFormat, CameraParameters::PIXEL_FORMAT_RGB565) == 0) {
+            bytesPerPixel = 2;
+        }
+    }
+
+    bufferDst = ( unsigned char * ) dst;
+    bufferSrc = ( unsigned char * ) y_uv[0];
+    row = width*bytesPerPixel;
+    alignedRow = ( row + ( stride -1 ) ) & ( ~ ( stride -1 ) );
+
+    //iterate through each row
+    for ( int i = 0 ; i < height ; i++,  bufferSrc += alignedRow, bufferDst += row) {
+        memcpy(bufferDst, bufferSrc, row);
+    }
+    mapper.unlock((buffer_handle_t)src);
+}
+
+void AppCallbackNotifier::notifyFrame()
+{
+    ///Receive and send the frame notifications to app
+    TIUTILS::Message msg;
+    CameraFrame *frame;
+    MemoryHeapBase *heap;
+    MemoryBase *buffer = NULL;
+    sp<MemoryBase> memBase;
+    void *buf = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    if(!mFrameQ.isEmpty())
+        {
+    mFrameQ.get(&msg);
+        }
+    else
+        {
+        return;
+        }
+
+    bool ret = true;
+
+    if(mNotifierState != AppCallbackNotifier::NOTIFIER_STARTED)
+    {
+        return;
+    }
+
+    frame = NULL;
+    switch(msg.command)
+        {
+        case AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME:
+
+                frame = (CameraFrame *) msg.arg1;
+                if(!frame)
+                    {
+                    break;
+                    }
+
+                if ( (CameraFrame::RAW_FRAME == frame->mFrameType )&&
+                    ( NULL != mCameraHal ) &&
+                    ( NULL != mDataCb) &&
+                    ( mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE) ) )
+                    {
+
+#ifdef COPY_IMAGE_BUFFER
+
+                    camera_memory_t* raw_picture = mRequestMemory(-1, frame->mLength, 1, NULL);
+
+                    if ( NULL != raw_picture )
+                    {
+                        buf = raw_picture->data;
+                        if ( NULL != buf )
+                            {
+                            memcpy(buf,
+                                   ( void * ) ( (unsigned int) frame->mBuffer + frame->mOffset),
+                                   frame->mLength);
+                            }
+                        mFrameProvider->returnFrame(frame->mBuffer,
+                                                    ( CameraFrame::FrameType ) frame->mFrameType);
+                    }
+
+                    mDataCb(CAMERA_MSG_RAW_IMAGE, raw_picture, 0, NULL, mCallbackCookie);
+#else
+
+                     //TODO: Find a way to map a Tiler buffer to a MemoryHeapBase
+
+#endif
+                    if(raw_picture)
+                        {
+                        raw_picture->release(raw_picture);
+                        }
+
+                    }
+                else if ( ( CameraFrame::IMAGE_FRAME == frame->mFrameType ) &&
+                             ( NULL != mCameraHal ) &&
+                             ( NULL != mDataCb) )
+                    {
+                    Mutex::Autolock lock(mLock);
+
+#ifdef COPY_IMAGE_BUFFER
+
+                        camera_memory_t* raw_picture = mRequestMemory(-1, frame->mLength, 1, NULL);
+
+                        if(raw_picture)
+                            {
+                            buf = raw_picture->data;
+                            }
+
+                        if ( NULL != buf)
+                            {
+                            memcpy(buf,
+                                   ( void * ) ( (unsigned int) frame->mBuffer + frame->mOffset),
+                                   frame->mLength);
+                            }
+
+                        {
+                            Mutex::Autolock lock(mBurstLock);
+#if 0 //TODO: enable burst mode later
+                            if ( mBurst )
+                            {
+                                `(CAMERA_MSG_BURST_IMAGE, JPEGPictureMemBase, mCallbackCookie);
+                            }
+                            else
+#endif
+                            {
+                                mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, raw_picture,
+                                        0, NULL,
+                                        mCallbackCookie);
+                            }
+                        }
+#else
+
+                     //TODO: Find a way to map a Tiler buffer to a MemoryHeapBase
+
+#endif
+                        if(raw_picture)
+                            {
+                            raw_picture->release(raw_picture);
+                            }
+
+                        mFrameProvider->returnFrame(frame->mBuffer,
+                                                    ( CameraFrame::FrameType ) frame->mFrameType);
+
+                    }
+                else if ( ( CameraFrame::VIDEO_FRAME_SYNC == frame->mFrameType ) &&
+                             ( NULL != mCameraHal ) &&
+                             ( NULL != mDataCb) &&
+                             ( mCameraHal->msgTypeEnabled(CAMERA_MSG_VIDEO_FRAME)  ) )
+                    {
+                    mRecordingLock.lock();
+                    if(mRecording)
+                        {
+                        if(mUseMetaDataBufferMode)
+                            {
+                            camera_memory_t *videoMedatadaBufferMemory =
+                                             (camera_memory_t *) mVideoMetadataBufferMemoryMap.valueFor((uint32_t) frame->mBuffer);
+                            video_metadata_t *videoMetadataBuffer = (video_metadata_t *) videoMedatadaBufferMemory->data;
+
+                            if( (NULL == videoMedatadaBufferMemory) || (NULL == videoMetadataBuffer) || (NULL == frame->mBuffer) )
+                                {
+                                CAMHAL_LOGEA("Error! One of the video buffers is NULL");
+                                break;
+                                }
+
+                            videoMetadataBuffer->metadataBufferType = (int) kMetadataBufferTypeCameraSource;
+                            videoMetadataBuffer->handle = frame->mBuffer;
+                            videoMetadataBuffer->offset = frame->mOffset;
+
+                            CAMHAL_LOGVB("mDataCbTimestamp : frame->mBuffer=0x%x, videoMetadataBuffer=0x%x, videoMedatadaBufferMemory=0x%x",
+                                            frame->mBuffer, videoMetadataBuffer, videoMedatadaBufferMemory);
+
+                            mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME,
+                                                videoMedatadaBufferMemory, 0, mCallbackCookie);
+                            }
+                        else
+                            {
+                            //TODO: Need to revisit this, should ideally be mapping the TILER buffer using mRequestMemory
+                            camera_memory_t* fakebuf = mRequestMemory(-1, 4, 1, NULL);
+                            if( (NULL == fakebuf) || ( NULL == fakebuf->data) || ( NULL == frame->mBuffer))
+                                {
+                                CAMHAL_LOGEA("Error! One of the video buffers is NULL");
+                                break;
+                                }
+
+                            fakebuf->data = frame->mBuffer;
+                            mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME, fakebuf, 0, mCallbackCookie);
+                            fakebuf->release(fakebuf);
+                            }
+                        }
+                    mRecordingLock.unlock();
+
+                    }
+                else if(( CameraFrame::SNAPSHOT_FRAME == frame->mFrameType ) &&
+                             ( NULL != mCameraHal ) &&
+                             ( NULL != mDataCb) &&
+                             ( NULL != mNotifyCb)) {
+                    Mutex::Autolock lock(mLock);
+                    //When enabled, measurement data is sent instead of video data
+                    if ( !mMeasurementEnabled ) {
+                        if (!mPreviewMemory || !frame->mBuffer) {
+                            CAMHAL_LOGDA("Error! One of the buffer is NULL");
+                            break;
+                        }
+
+                        buf = (void*) mPreviewBufs[mPreviewBufCount];
+
+                        CAMHAL_LOGVB("%d:copy2Dto1D(%p, %p, %d, %d, %d, %d, %d,%s)",
+                                     __LINE__,
+                                     buf,
+                                     frame->mBuffer,
+                                     frame->mWidth,
+                                     frame->mHeight,
+                                     frame->mAlignment,
+                                     2,
+                                     frame->mLength,
+                                     mPreviewPixelFormat);
+
+                        if ( NULL != buf ) {
+                            copy2Dto1D(buf,
+                                       frame->mBuffer,
+                                       frame->mWidth,
+                                       frame->mHeight,
+                                       frame->mAlignment,
+                                       frame->mOffset,
+                                       2,
+                                       frame->mLength,
+                                       mPreviewPixelFormat);
+                        }
+
+                        if (mCameraHal->msgTypeEnabled(CAMERA_MSG_POSTVIEW_FRAME)) {
+                            ///Give preview callback to app
+                            mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPreviewMemory, mPreviewBufCount, NULL, mCallbackCookie);
+                        }
+
+                        // increment for next buffer
+                        mPreviewBufCount = (mPreviewBufCount+1) % AppCallbackNotifier::MAX_BUFFERS;
+                    }
+
+                    mFrameProvider->returnFrame(frame->mBuffer,
+                                                ( CameraFrame::FrameType ) frame->mFrameType);
+                } else if ( ( CameraFrame::PREVIEW_FRAME_SYNC== frame->mFrameType ) &&
+                            ( NULL != mCameraHal ) &&
+                            ( NULL != mDataCb) &&
+                            ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) ) {
+                    Mutex::Autolock lock(mLock);
+                    //When enabled, measurement data is sent instead of video data
+                    if ( !mMeasurementEnabled ) {
+                        if (!mPreviewMemory || !frame->mBuffer) {
+                            CAMHAL_LOGDA("Error! One of the buffer is NULL");
+                            break;
+                        }
+
+                        buf = (void*) mPreviewBufs[mPreviewBufCount];
+
+                        CAMHAL_LOGVB("%d:copy2Dto1D(%p, %p, %d, %d, %d, %d, %d,%s)",
+                                     __LINE__,
+                                     buf,
+                                     frame->mBuffer,
+                                     frame->mWidth,
+                                     frame->mHeight,
+                                     frame->mAlignment,
+                                     2,
+                                     frame->mLength,
+                                     mPreviewPixelFormat);
+
+                        if ( NULL != buf ) {
+                            copy2Dto1D(buf,
+                                       frame->mBuffer,
+                                       frame->mWidth,
+                                       frame->mHeight,
+                                       frame->mAlignment,
+                                       frame->mOffset,
+                                       2,
+                                       frame->mLength,
+                                       mPreviewPixelFormat);
+                        }
+
+                        // Give preview callback to app
+                        mDataCb(CAMERA_MSG_PREVIEW_FRAME, mPreviewMemory, mPreviewBufCount, NULL, mCallbackCookie);
+
+                        // increment for next buffer
+                        mPreviewBufCount = (mPreviewBufCount+1) % AppCallbackNotifier::MAX_BUFFERS;
+                    }
+                    mFrameProvider->returnFrame(frame->mBuffer,
+                                                ( CameraFrame::FrameType ) frame->mFrameType);
+                } else if ( ( CameraFrame::FRAME_DATA_SYNC == frame->mFrameType ) &&
+                            ( NULL != mCameraHal ) &&
+                            ( NULL != mDataCb) &&
+                            ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) ) {
+                    if (!mPreviewMemory || !frame->mBuffer) {
+                        CAMHAL_LOGDA("Error! One of the buffer is NULL");
+                        break;
+                    }
+
+                    buf = (void*) mPreviewBufs[mPreviewBufCount];
+                    if (buf) {
+                        if ( (mPreviewMemory->size / MAX_BUFFERS) >= frame->mLength ) {
+                            memcpy(buf, ( void * )  frame->mBuffer, frame->mLength);
+                        } else {
+                            memset(buf, 0, (mPreviewMemory->size / MAX_BUFFERS));
+                        }
+                    }
+
+                    // Give preview callback to app
+                    mDataCb(CAMERA_MSG_PREVIEW_FRAME, mPreviewMemory, mPreviewBufCount, NULL, mCallbackCookie);
+
+                    //Increment the buffer count
+                    mPreviewBufCount = (mPreviewBufCount+1) % AppCallbackNotifier::MAX_BUFFERS;
+
+                    mFrameProvider->returnFrame(frame->mBuffer,
+                                                ( CameraFrame::FrameType ) frame->mFrameType);
+                } else {
+                    mFrameProvider->returnFrame(frame->mBuffer,
+                                                ( CameraFrame::FrameType ) frame->mFrameType);
+                    CAMHAL_LOGDB("Frame type 0x%x is still unsupported!", frame->mFrameType);
+                }
+
+                break;
+
+        default:
+
+            break;
+
+        };
+
+exit:
+
+    if ( NULL != frame )
+        {
+        delete frame;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void AppCallbackNotifier::frameCallbackRelay(CameraFrame* caFrame)
+{
+    LOG_FUNCTION_NAME;
+    AppCallbackNotifier *appcbn = (AppCallbackNotifier*) (caFrame->mCookie);
+    appcbn->frameCallback(caFrame);
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void AppCallbackNotifier::frameCallback(CameraFrame* caFrame)
+{
+    ///Post the event to the event queue of AppCallbackNotifier
+    TIUTILS::Message msg;
+    CameraFrame *frame;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != caFrame )
+        {
+
+        frame = new CameraFrame(*caFrame);
+        if ( NULL != frame )
+            {
+            msg.command = AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME;
+            msg.arg1 = frame;
+            mFrameQ.put(&msg);
+            }
+        else
+            {
+            CAMHAL_LOGEA("Not enough resources to allocate CameraFrame");
+            }
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+void AppCallbackNotifier::eventCallbackRelay(CameraHalEvent* chEvt)
+{
+    LOG_FUNCTION_NAME;
+    AppCallbackNotifier *appcbn = (AppCallbackNotifier*) (chEvt->mCookie);
+    appcbn->eventCallback(chEvt);
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void AppCallbackNotifier::eventCallback(CameraHalEvent* chEvt)
+{
+
+    ///Post the event to the event queue of AppCallbackNotifier
+    TIUTILS::Message msg;
+    CameraHalEvent *event;
+
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != chEvt )
+        {
+
+        event = new CameraHalEvent(*chEvt);
+        if ( NULL != event )
+            {
+            msg.command = AppCallbackNotifier::NOTIFIER_CMD_PROCESS_EVENT;
+            msg.arg1 = event;
+            mEventQ.put(&msg);
+            }
+        else
+            {
+            CAMHAL_LOGEA("Not enough resources to allocate CameraHalEvent");
+            }
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+bool AppCallbackNotifier::processMessage()
+{
+    ///Retrieve the command from the command queue and process it
+    TIUTILS::Message msg;
+
+    LOG_FUNCTION_NAME;
+
+    CAMHAL_LOGDA("+Msg get...");
+    mNotificationThread->msgQ().get(&msg);
+    CAMHAL_LOGDA("-Msg get...");
+    bool ret = true;
+
+    switch(msg.command)
+      {
+        case NotificationThread::NOTIFIER_EXIT:
+          {
+            CAMHAL_LOGEA("Received NOTIFIER_EXIT command from Camera HAL");
+            mNotifierState = AppCallbackNotifier::NOTIFIER_EXITED;
+            ret = false;
+            break;
+          }
+        default:
+          {
+            CAMHAL_LOGEA("Error: ProcessMsg() command from Camera HAL");
+            break;
+          }
+      }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+
+
+}
+
+AppCallbackNotifier::~AppCallbackNotifier()
+{
+    LOG_FUNCTION_NAME;
+
+    ///Stop app callback notifier if not already stopped
+    stop();
+
+    ///Unregister with the frame provider
+    if ( NULL != mFrameProvider )
+        {
+        mFrameProvider->disableFrameNotification(CameraFrame::ALL_FRAMES);
+        }
+
+    //unregister with the event provider
+    if ( NULL != mEventProvider )
+        {
+        mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
+        }
+
+    TIUTILS::Message msg = {0,0,0,0,0,0};
+    msg.command = NotificationThread::NOTIFIER_EXIT;
+
+    ///Post the message to display thread
+    mNotificationThread->msgQ().put(&msg);
+
+    //Exit and cleanup the thread
+    mNotificationThread->requestExitAndWait();
+
+    //Delete the display thread
+    mNotificationThread.clear();
+
+
+    ///Free the event and frame providers
+    if ( NULL != mEventProvider )
+        {
+        ///Deleting the event provider
+        CAMHAL_LOGDA("Stopping Event Provider");
+        delete mEventProvider;
+        mEventProvider = NULL;
+        }
+
+    if ( NULL != mFrameProvider )
+        {
+        ///Deleting the frame provider
+        CAMHAL_LOGDA("Stopping Frame Provider");
+        delete mFrameProvider;
+        mFrameProvider = NULL;
+        }
+
+    releaseSharedVideoBuffers();
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+//Free all video heaps and buffers
+void AppCallbackNotifier::releaseSharedVideoBuffers()
+{
+    LOG_FUNCTION_NAME;
+
+    if(mUseMetaDataBufferMode)
+    {
+        camera_memory_t* videoMedatadaBufferMemory;
+        for (unsigned int i = 0; i < mVideoMetadataBufferMemoryMap.size();  i++)
+            {
+            videoMedatadaBufferMemory = (camera_memory_t*) mVideoMetadataBufferMemoryMap.valueAt(i);
+            if(NULL != videoMedatadaBufferMemory)
+                {
+                videoMedatadaBufferMemory->release(videoMedatadaBufferMemory);
+                CAMHAL_LOGDB("Released  videoMedatadaBufferMemory=0x%x", videoMedatadaBufferMemory);
+                }
+            }
+
+        mVideoMetadataBufferMemoryMap.clear();
+        mVideoMetadataBufferReverseMap.clear();
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void AppCallbackNotifier::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier)
+{
+
+    LOG_FUNCTION_NAME;
+    ///@remarks There is no NULL check here. We will check
+    ///for NULL when we get start command from CameraHal
+    ///@Remarks Currently only one event provider (CameraAdapter) is supported
+    ///@todo Have an array of event providers for each event bitmask
+    mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay);
+    if ( NULL == mEventProvider )
+        {
+        CAMHAL_LOGEA("Error in creating EventProvider");
+        }
+    else
+        {
+        mEventProvider->enableEventNotification(eventMask);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void AppCallbackNotifier::setFrameProvider(FrameNotifier *frameNotifier)
+{
+    LOG_FUNCTION_NAME;
+    ///@remarks There is no NULL check here. We will check
+    ///for NULL when we get the start command from CameraAdapter
+    mFrameProvider = new FrameProvider(frameNotifier, this, frameCallbackRelay);
+    if ( NULL == mFrameProvider )
+        {
+        CAMHAL_LOGEA("Error in creating FrameProvider");
+        }
+    else
+        {
+        //Register only for captured images and RAW for now
+        //TODO: Register for and handle all types of frames
+        mFrameProvider->enableFrameNotification(CameraFrame::IMAGE_FRAME);
+        mFrameProvider->enableFrameNotification(CameraFrame::RAW_FRAME);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+status_t AppCallbackNotifier::startPreviewCallbacks(CameraParameters &params, void *buffers, uint32_t *offsets, int fd, size_t length, size_t count)
+{
+    sp<MemoryHeapBase> heap;
+    sp<MemoryBase> buffer;
+    unsigned int *bufArr;
+    size_t size = 0;
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mLock);
+
+    if ( NULL == mFrameProvider )
+        {
+        CAMHAL_LOGEA("Trying to start video recording without FrameProvider");
+        return -EINVAL;
+        }
+
+    if ( mPreviewing )
+        {
+        CAMHAL_LOGDA("+Already previewing");
+        return NO_INIT;
+        }
+
+    int w,h;
+    ///Get preview size
+    params.getPreviewSize(&w, &h);
+
+    //Get the preview pixel format
+    mPreviewPixelFormat = params.getPreviewFormat();
+
+     if(strcmp(mPreviewPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
+        {
+        size = w*h*2;
+        mPreviewPixelFormat = CameraParameters::PIXEL_FORMAT_YUV422I;
+        }
+    else if(strcmp(mPreviewPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 ||
+            strcmp(mPreviewPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV420P) == 0)
+        {
+        size = (w*h*3)/2;
+        mPreviewPixelFormat = CameraParameters::PIXEL_FORMAT_YUV420SP;
+        }
+    else if(strcmp(mPreviewPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
+        {
+        size = w*h*2;
+        mPreviewPixelFormat = CameraParameters::PIXEL_FORMAT_RGB565;
+        }
+
+    mPreviewMemory = mRequestMemory(-1, size, AppCallbackNotifier::MAX_BUFFERS, NULL);
+    if (!mPreviewMemory) {
+        return NO_MEMORY;
+    }
+
+    for (int i=0; i < AppCallbackNotifier::MAX_BUFFERS; i++) {
+        mPreviewBufs[i] = (unsigned char*) mPreviewMemory->data + (i*size);
+    }
+
+    if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME ) ) {
+         mFrameProvider->enableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
+    }
+
+    mPreviewBufCount = 0;
+
+    mPreviewing = true;
+
+    LOG_FUNCTION_NAME;
+
+    return NO_ERROR;
+}
+
+void AppCallbackNotifier::setBurst(bool burst)
+{
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mBurstLock);
+
+    mBurst = burst;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+status_t AppCallbackNotifier::stopPreviewCallbacks()
+{
+    sp<MemoryHeapBase> heap;
+    sp<MemoryBase> buffer;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == mFrameProvider )
+        {
+        CAMHAL_LOGEA("Trying to stop preview callbacks without FrameProvider");
+        return -EINVAL;
+        }
+
+    if ( !mPreviewing )
+        {
+        return NO_INIT;
+        }
+
+    mFrameProvider->disableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
+
+    mPreviewMemory->release(mPreviewMemory);
+
+    mPreviewing = false;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NO_ERROR;
+
+}
+
+status_t AppCallbackNotifier::useMetaDataBufferMode(bool enable)
+{
+    mUseMetaDataBufferMode = enable;
+
+    return NO_ERROR;
+}
+
+
+status_t AppCallbackNotifier::startRecording()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+   Mutex::Autolock lock(mRecordingLock);
+
+    if ( NULL == mFrameProvider )
+        {
+        CAMHAL_LOGEA("Trying to start video recording without FrameProvider");
+        ret = -1;
+        }
+
+    if(mRecording)
+        {
+        return NO_INIT;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+         mFrameProvider->enableFrameNotification(CameraFrame::VIDEO_FRAME_SYNC);
+        }
+
+    mRecording = true;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+//Allocate metadata buffers for video recording
+status_t AppCallbackNotifier::initSharedVideoBuffers(void *buffers, uint32_t *offsets, int fd, size_t length, size_t count)
+{
+    status_t ret = NO_ERROR;
+    LOG_FUNCTION_NAME;
+
+    if(mUseMetaDataBufferMode)
+        {
+        uint32_t *bufArr = NULL;
+        camera_memory_t* videoMedatadaBufferMemory = NULL;
+
+        if(NULL == buffers)
+            {
+            CAMHAL_LOGEA("Error! Video buffers are NULL");
+            return BAD_VALUE;
+            }
+        bufArr = (uint32_t *) buffers;
+
+        for (uint32_t i = 0; i < count; i++)
+            {
+            videoMedatadaBufferMemory = mRequestMemory(-1, sizeof(video_metadata_t), 1, NULL);
+            if((NULL == videoMedatadaBufferMemory) || (NULL == videoMedatadaBufferMemory->data))
+                {
+                CAMHAL_LOGEA("Error! Could not allocate memory for Video Metadata Buffers");
+                return NO_MEMORY;
+                }
+
+            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);
+            }
+        }
+
+exit:
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t AppCallbackNotifier::stopRecording()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mRecordingLock);
+
+    if ( NULL == mFrameProvider )
+        {
+        CAMHAL_LOGEA("Trying to stop video recording without FrameProvider");
+        ret = -1;
+        }
+
+    if(!mRecording)
+        {
+        return NO_INIT;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+         mFrameProvider->disableFrameNotification(CameraFrame::VIDEO_FRAME_SYNC);
+        }
+
+    ///Release the shared video buffers
+    releaseSharedVideoBuffers();
+
+    mRecording = false;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t AppCallbackNotifier::releaseRecordingFrame(const void* mem)
+{
+    status_t ret = NO_ERROR;
+    void *frame = NULL;
+
+    LOG_FUNCTION_NAME;
+    if ( NULL == mFrameProvider )
+        {
+        CAMHAL_LOGEA("Trying to stop video recording without FrameProvider");
+        ret = -1;
+        }
+
+    if ( NULL == mem )
+        {
+        CAMHAL_LOGEA("Video Frame released is invalid");
+        ret = -1;
+        }
+
+    if( NO_ERROR != ret )
+        {
+        return ret;
+        }
+
+    if(mUseMetaDataBufferMode)
+        {
+        video_metadata_t *videoMetadataBuffer = (video_metadata_t *) mem ;
+        frame = (void*) mVideoMetadataBufferReverseMap.valueFor((uint32_t) videoMetadataBuffer);
+        CAMHAL_LOGVB("Releasing frame with videoMetadataBuffer=0x%x, videoMetadataBuffer->handle=0x%x & frame handle=0x%x\n",
+                       videoMetadataBuffer, videoMetadataBuffer->handle, frame);
+        }
+    else
+        {
+        frame = (void*)(*((uint32_t *)mem));
+        }
+
+    if ( NO_ERROR == ret )
+        {
+         ret = mFrameProvider->returnFrame(frame, CameraFrame::VIDEO_FRAME_SYNC);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t AppCallbackNotifier::enableMsgType(int32_t msgType)
+{
+    if(msgType & CAMERA_MSG_POSTVIEW_FRAME)
+        {
+        mFrameProvider->enableFrameNotification(CameraFrame::SNAPSHOT_FRAME);
+        }
+
+    if(msgType & CAMERA_MSG_PREVIEW_FRAME)
+        {
+         mFrameProvider->enableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
+        }
+
+    return NO_ERROR;
+}
+
+status_t AppCallbackNotifier::disableMsgType(int32_t msgType)
+{
+    if(msgType & CAMERA_MSG_POSTVIEW_FRAME)
+        {
+        mFrameProvider->disableFrameNotification(CameraFrame::SNAPSHOT_FRAME);
+        }
+
+    if(msgType & CAMERA_MSG_PREVIEW_FRAME)
+        {
+        mFrameProvider->disableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
+        }
+
+    return NO_ERROR;
+
+}
+
+status_t AppCallbackNotifier::start()
+{
+    LOG_FUNCTION_NAME;
+    if(mNotifierState==AppCallbackNotifier::NOTIFIER_STARTED)
+        {
+        CAMHAL_LOGDA("AppCallbackNotifier already running");
+        LOG_FUNCTION_NAME_EXIT;
+        return ALREADY_EXISTS;
+        }
+
+    ///Check whether initial conditions are met for us to start
+    ///A frame provider should be available, if not return error
+    if(!mFrameProvider)
+        {
+        ///AppCallbackNotifier not properly initialized
+        CAMHAL_LOGEA("AppCallbackNotifier not properly initialized - Frame provider is NULL");
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    ///At least one event notifier should be available, if not return error
+    ///@todo Modify here when there is an array of event providers
+    if(!mEventProvider)
+        {
+        CAMHAL_LOGEA("AppCallbackNotifier not properly initialized - Event provider is NULL");
+        LOG_FUNCTION_NAME_EXIT;
+        ///AppCallbackNotifier not properly initialized
+        return NO_INIT;
+        }
+
+    mNotifierState = AppCallbackNotifier::NOTIFIER_STARTED;
+    CAMHAL_LOGDA(" --> AppCallbackNotifier NOTIFIER_STARTED \n");
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NO_ERROR;
+
+}
+
+status_t AppCallbackNotifier::stop()
+{
+    LOG_FUNCTION_NAME;
+
+    if(mNotifierState!=AppCallbackNotifier::NOTIFIER_STARTED)
+        {
+        CAMHAL_LOGDA("AppCallbackNotifier already in stopped state");
+        LOG_FUNCTION_NAME_EXIT;
+        return ALREADY_EXISTS;
+        }
+
+    mNotifierState = AppCallbackNotifier::NOTIFIER_STOPPED;
+    CAMHAL_LOGDA(" --> AppCallbackNotifier NOTIFIER_STOPPED \n");
+
+    LOG_FUNCTION_NAME_EXIT;
+    return NO_ERROR;
+}
+
+
+/*--------------------NotificationHandler Class ENDS here-----------------------------*/
+
+
+
+};
diff --git a/camera/BaseCameraAdapter.cpp b/camera/BaseCameraAdapter.cpp
new file mode 100644
index 0000000..fb90a79
--- /dev/null
+++ b/camera/BaseCameraAdapter.cpp
@@ -0,0 +1,1969 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 "BaseCameraAdapter.h"
+
+namespace android {
+
+/*--------------------Camera Adapter Class STARTS here-----------------------------*/
+
+BaseCameraAdapter::BaseCameraAdapter()
+{
+    mReleaseImageBuffersCallback = NULL;
+    mEndImageCaptureCallback = NULL;
+    mErrorNotifier = NULL;
+    mEndCaptureData = NULL;
+    mReleaseData = NULL;
+    mRecording = false;
+
+    mPreviewBuffers = NULL;
+    mPreviewBufferCount = 0;
+    mPreviewBuffersLength = 0;
+
+    mVideoBuffers = NULL;
+    mVideoBuffersCount = 0;
+    mVideoBuffersLength = 0;
+
+    mCaptureBuffers = NULL;
+    mCaptureBuffersCount = 0;
+    mCaptureBuffersLength = 0;
+
+    mPreviewDataBuffers = NULL;
+    mPreviewDataBuffersCount = 0;
+    mPreviewDataBuffersLength = 0;
+
+    mAdapterState = INTIALIZED_STATE;
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+    mStartFocus.tv_sec = 0;
+    mStartFocus.tv_usec = 0;
+    mStartCapture.tv_sec = 0;
+    mStartCapture.tv_usec = 0;
+#endif
+
+}
+
+BaseCameraAdapter::~BaseCameraAdapter()
+{
+     LOG_FUNCTION_NAME;
+
+     Mutex::Autolock lock(mSubscriberLock);
+
+     mFrameSubscribers.clear();
+     mImageSubscribers.clear();
+     mRawSubscribers.clear();
+     mVideoSubscribers.clear();
+     mFocusSubscribers.clear();
+     mShutterSubscribers.clear();
+     mZoomSubscribers.clear();
+     mFaceSubscribers.clear();
+
+     LOG_FUNCTION_NAME_EXIT;
+}
+
+status_t BaseCameraAdapter::registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    mReleaseImageBuffersCallback = callback;
+    mReleaseData = user_data;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::registerEndCaptureCallback(end_image_capture_callback callback, void *user_data)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    mEndImageCaptureCallback= callback;
+    mEndCaptureData = user_data;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::setErrorHandler(ErrorNotifier *errorNotifier)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == errorNotifier )
+        {
+        CAMHAL_LOGEA("Invalid Error Notifier reference");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        mErrorNotifier = errorNotifier;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+void BaseCameraAdapter::enableMsgType(int32_t msgs, frame_callback callback, event_callback eventCb, void* cookie)
+{
+    Mutex::Autolock lock(mSubscriberLock);
+
+    LOG_FUNCTION_NAME;
+
+    if ( CameraFrame::PREVIEW_FRAME_SYNC == msgs )
+        {
+        mFrameSubscribers.add((int) cookie, callback);
+        }
+    else if ( CameraFrame::FRAME_DATA_SYNC == msgs )
+        {
+        mFrameDataSubscribers.add((int) cookie, callback);
+        }
+    else if ( CameraFrame::IMAGE_FRAME == msgs)
+        {
+        mImageSubscribers.add((int) cookie, callback);
+        }
+    else if ( CameraFrame::RAW_FRAME == msgs)
+        {
+        mRawSubscribers.add((int) cookie, callback);
+        }
+    else if ( CameraFrame::VIDEO_FRAME_SYNC == msgs)
+        {
+        mVideoSubscribers.add((int) cookie, callback);
+        }
+    else if ( CameraHalEvent::ALL_EVENTS == msgs)
+        {
+        mFocusSubscribers.add((int) cookie, eventCb);
+        mShutterSubscribers.add((int) cookie, eventCb);
+        mZoomSubscribers.add((int) cookie, eventCb);
+        mFaceSubscribers.add((int) cookie, eventCb);
+        }
+    else
+        {
+        CAMHAL_LOGEA("Message type subscription no supported yet!");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void BaseCameraAdapter::disableMsgType(int32_t msgs, void* cookie)
+{
+    Mutex::Autolock lock(mSubscriberLock);
+
+    LOG_FUNCTION_NAME;
+
+    if ( CameraFrame::PREVIEW_FRAME_SYNC == msgs )
+        {
+        mFrameSubscribers.removeItem((int) cookie);
+        }
+    else if ( CameraFrame::FRAME_DATA_SYNC == msgs )
+        {
+        mFrameDataSubscribers.removeItem((int) cookie);
+        }
+    else if ( CameraFrame::IMAGE_FRAME == msgs)
+        {
+        mImageSubscribers.removeItem((int) cookie);
+        }
+    else if ( CameraFrame::RAW_FRAME == msgs)
+        {
+        mRawSubscribers.removeItem((int) cookie);
+        }
+    else if ( CameraFrame::VIDEO_FRAME_SYNC == msgs)
+        {
+        mVideoSubscribers.removeItem((int) cookie);
+        }
+    else if ( CameraFrame::ALL_FRAMES  == msgs )
+        {
+        mFrameSubscribers.removeItem((int) cookie);
+        mFrameDataSubscribers.removeItem((int) cookie);
+        mImageSubscribers.removeItem((int) cookie);
+        mRawSubscribers.removeItem((int) cookie);
+        mVideoSubscribers.removeItem((int) cookie);
+        }
+    else if ( CameraHalEvent::ALL_EVENTS == msgs)
+        {
+         //Subscribe only for focus
+         //TODO: Process case by case
+        mFocusSubscribers.removeItem((int) cookie);
+        mShutterSubscribers.removeItem((int) cookie);
+        mZoomSubscribers.removeItem((int) cookie);
+        mFaceSubscribers.removeItem((int) cookie);
+        }
+    else
+        {
+        CAMHAL_LOGEB("Message type 0x%x subscription no supported yet!", msgs);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void BaseCameraAdapter::returnFrame(void* frameBuf, CameraFrame::FrameType frameType)
+{
+    status_t res = NO_ERROR;
+    size_t subscriberCount = 0;
+    int refCount = -1;
+
+    Mutex::Autolock lock(mReturnFrameLock);
+
+    if ( NULL == frameBuf )
+        {
+        CAMHAL_LOGEA("Invalid frameBuf");
+        return;
+        }
+
+    if ( NO_ERROR == res)
+        {
+
+        refCount = getFrameRefCount(frameBuf,  frameType);
+
+        if ( 0 < refCount )
+            {
+
+            refCount--;
+            setFrameRefCount(frameBuf, frameType, refCount);
+
+            if ( ( mRecording ) && (  CameraFrame::VIDEO_FRAME_SYNC == frameType ) )
+                {
+                refCount += getFrameRefCount(frameBuf, CameraFrame::PREVIEW_FRAME_SYNC);
+                }
+            else if ( ( mRecording ) && (  CameraFrame::PREVIEW_FRAME_SYNC == frameType ) )
+                {
+                refCount += getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC);
+                }
+
+            }
+        else
+            {
+            return;
+            }
+        }
+
+    if ( NO_ERROR == res )
+        {
+        //check if someone is holding this buffer
+        if ( 0 == refCount )
+            {
+            res = fillThisBuffer(frameBuf, frameType);
+            }
+        }
+
+}
+
+status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, int value2, int value3)
+{
+    status_t ret = NO_ERROR;
+    struct timeval *refTimestamp;
+    BuffersDescriptor *desc = NULL;
+    CameraFrame *frame = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    switch ( operation ) {
+        case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW:
+                CAMHAL_LOGDA("Use buffers for preview");
+                desc = ( BuffersDescriptor * ) value1;
+
+                if ( NULL == desc )
+                    {
+                    CAMHAL_LOGEA("Invalid preview buffers!");
+                    return -EINVAL;
+                    }
+
+                if ( ret == NO_ERROR )
+                    {
+                    ret = setState(operation);
+                    }
+
+                if ( ret == NO_ERROR )
+                    {
+                    Mutex::Autolock lock(mPreviewBufferLock);
+                    mPreviewBuffers = (int *) desc->mBuffers;
+                    mPreviewBuffersLength = desc->mLength;
+                    mPreviewBuffersAvailable.clear();
+                    for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
+                        {
+                        mPreviewBuffersAvailable.add(mPreviewBuffers[i], 0);
+                        }
+                    // initial ref count for undeqeueued buffers is 1 since buffer provider
+                    // is still holding on to it
+                    for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
+                        {
+                        mPreviewBuffersAvailable.add(mPreviewBuffers[i], 1);
+                        }
+                    }
+
+                if ( NULL != desc )
+                    {
+                    ret = useBuffers(CameraAdapter::CAMERA_PREVIEW,
+                                     desc->mBuffers,
+                                     desc->mCount,
+                                     desc->mLength,
+                                     desc->mMaxQueueable);
+                    }
+
+                if ( ret == NO_ERROR )
+                    {
+                    ret = commitState();
+                    }
+                else
+                    {
+                    ret |= rollbackState();
+                    }
+
+                break;
+
+        case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA:
+                    CAMHAL_LOGDA("Use buffers for preview data");
+                    desc = ( BuffersDescriptor * ) value1;
+
+                    if ( NULL == desc )
+                        {
+                        CAMHAL_LOGEA("Invalid preview data buffers!");
+                        return -EINVAL;
+                        }
+
+                    if ( ret == NO_ERROR )
+                        {
+                        ret = setState(operation);
+                        }
+
+                    if ( ret == NO_ERROR )
+                        {
+                        Mutex::Autolock lock(mPreviewDataBufferLock);
+                        mPreviewDataBuffers = (int *) desc->mBuffers;
+                        mPreviewDataBuffersLength = desc->mLength;
+                        mPreviewDataBuffersAvailable.clear();
+                        for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
+                            {
+                            mPreviewDataBuffersAvailable.add(mPreviewDataBuffers[i], true);
+                            }
+                        // initial ref count for undeqeueued buffers is 1 since buffer provider
+                        // is still holding on to it
+                        for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
+                            {
+                            mPreviewDataBuffersAvailable.add(mPreviewBuffers[i], 1);
+                            }
+                        }
+
+                    if ( NULL != desc )
+                        {
+                        ret = useBuffers(CameraAdapter::CAMERA_MEASUREMENT,
+                                         desc->mBuffers,
+                                         desc->mCount,
+                                         desc->mLength,
+                                         desc->mMaxQueueable);
+                        }
+
+                    if ( ret == NO_ERROR )
+                        {
+                        ret = commitState();
+                        }
+                    else
+                        {
+                        ret |= rollbackState();
+                        }
+
+                    break;
+
+        case CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
+                CAMHAL_LOGDA("Use buffers for image capture");
+                desc = ( BuffersDescriptor * ) value1;
+
+                if ( NULL == desc )
+                    {
+                    CAMHAL_LOGEA("Invalid capture buffers!");
+                    return -EINVAL;
+                    }
+
+                if ( ret == NO_ERROR )
+                    {
+                    ret = setState(operation);
+                    }
+
+                if ( ret == NO_ERROR )
+                    {
+                    Mutex::Autolock lock(mCaptureBufferLock);
+                    mCaptureBuffers = (int *) desc->mBuffers;
+                    mCaptureBuffersLength = desc->mLength;
+                    mCaptureBuffersAvailable.clear();
+                    for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
+                        {
+                        mCaptureBuffersAvailable.add(mCaptureBuffers[i], true);
+                        }
+                    // initial ref count for undeqeueued buffers is 1 since buffer provider
+                    // is still holding on to it
+                    for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
+                        {
+                        mCaptureBuffersAvailable.add(mPreviewBuffers[i], 1);
+                        }
+                    }
+
+                if ( NULL != desc )
+                    {
+                    ret = useBuffers(CameraAdapter::CAMERA_IMAGE_CAPTURE,
+                                     desc->mBuffers,
+                                     desc->mCount,
+                                     desc->mLength,
+                                     desc->mMaxQueueable);
+                    }
+
+                if ( ret == NO_ERROR )
+                    {
+                    ret = commitState();
+                    }
+                else
+                    {
+                    ret |= rollbackState();
+                    }
+
+                break;
+
+        case CameraAdapter::CAMERA_START_SMOOTH_ZOOM:
+            {
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = startSmoothZoom(value1);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM:
+            {
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = stopSmoothZoom();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_START_PREVIEW:
+            {
+
+                CAMHAL_LOGDA("Start Preview");
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = startPreview();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_STOP_PREVIEW:
+            {
+
+            CAMHAL_LOGDA("Stop Preview");
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = stopPreview();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_START_VIDEO:
+            {
+
+            CAMHAL_LOGDA("Start video recording");
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = startVideoCapture();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_STOP_VIDEO:
+            {
+
+            CAMHAL_LOGDA("Stop video recording");
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = stopVideoCapture();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_PREVIEW_FLUSH_BUFFERS:
+            {
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = flushBuffers();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_START_IMAGE_CAPTURE:
+            {
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+            refTimestamp = ( struct timeval * ) value1;
+            if ( NULL != refTimestamp )
+                {
+                memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval ));
+                }
+
+#endif
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = takePicture();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE:
+            {
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = stopImageCapture();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_START_BRACKET_CAPTURE:
+            {
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+            refTimestamp = ( struct timeval * ) value2;
+            if ( NULL != refTimestamp )
+                {
+                memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval ));
+                }
+
+#endif
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = startBracketing(value1);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE:
+            {
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = stopBracketing();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+            }
+
+        case CameraAdapter::CAMERA_PERFORM_AUTOFOCUS:
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+            refTimestamp = ( struct timeval * ) value1;
+            if ( NULL != refTimestamp )
+                {
+                memcpy( &mStartFocus, refTimestamp, sizeof( struct timeval ));
+                }
+
+#endif
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = autoFocus();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+        case CameraAdapter::CAMERA_CANCEL_AUTOFOCUS:
+
+            if ( ret == NO_ERROR )
+                {
+                ret = setState(operation);
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = cancelAutoFocus();
+                }
+
+            if ( ret == NO_ERROR )
+                {
+                ret = commitState();
+                }
+            else
+                {
+                ret |= rollbackState();
+                }
+
+            break;
+
+        case CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW:
+
+             if ( ret == NO_ERROR )
+                 {
+                 ret = setState(operation);
+                 }
+
+             if ( ret == NO_ERROR )
+                 {
+                 frame = ( CameraFrame * ) value1;
+
+                 if ( NULL != frame )
+                     {
+                     ret = getFrameSize(frame->mWidth, frame->mHeight);
+                     }
+                 else
+                     {
+                     ret = -EINVAL;
+                     }
+                 }
+
+             if ( ret == NO_ERROR )
+                 {
+                 ret = commitState();
+                 }
+             else
+                 {
+                 ret |= rollbackState();
+                 }
+
+             break;
+
+         case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
+
+             if ( ret == NO_ERROR )
+                 {
+                 ret = setState(operation);
+                 }
+
+             if ( ret == NO_ERROR )
+                 {
+                 frame = ( CameraFrame * ) value1;
+
+                 if ( NULL != frame )
+                     {
+                     ret = getPictureBufferSize(frame->mLength, value2);
+                     }
+                 else
+                     {
+                     ret = -EINVAL;
+                     }
+                 }
+
+             if ( ret == NO_ERROR )
+                 {
+                 ret = commitState();
+                 }
+             else
+                 {
+                 ret |= rollbackState();
+                 }
+
+             break;
+
+         case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:
+
+             if ( ret == NO_ERROR )
+                 {
+                 ret = setState(operation);
+                 }
+
+             if ( ret == NO_ERROR )
+                 {
+                 frame = ( CameraFrame * ) value1;
+
+                 if ( NULL != frame )
+                     {
+                     ret = getFrameDataSize(frame->mLength, value2);
+                     }
+                 else
+                     {
+                     ret = -EINVAL;
+                     }
+                 }
+
+             if ( ret == NO_ERROR )
+                 {
+                 ret = commitState();
+                 }
+             else
+                 {
+                 ret |= rollbackState();
+                 }
+
+             break;
+
+         case CameraAdapter::CAMERA_START_FD:
+
+             ret = startFaceDetection();
+
+             break;
+
+         case CameraAdapter::CAMERA_STOP_FD:
+
+             ret = stopFaceDetection();
+
+             break;
+
+        default:
+            CAMHAL_LOGEB("Command 0x%x unsupported!", operation);
+            break;
+    };
+
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+status_t BaseCameraAdapter::notifyFocusSubscribers(bool status)
+{
+    event_callback eventCb;
+    CameraHalEvent focusEvent;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( mFocusSubscribers.size() == 0 ) {
+        CAMHAL_LOGDA("No Focus Subscribers!");
+        return NO_INIT;
+    }
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+     //dump the AF latency
+     CameraHal::PPM("Focus finished in: ", &mStartFocus);
+
+#endif
+
+    focusEvent.mEventData = new CameraHalEvent::CameraHalEventData();
+    if ( NULL == focusEvent.mEventData.get() ) {
+        return -ENOMEM;
+    }
+
+    focusEvent.mEventType = CameraHalEvent::EVENT_FOCUS_LOCKED;
+    focusEvent.mEventData->focusEvent.focusLocked = status;
+    focusEvent.mEventData->focusEvent.focusError = !status;
+
+    for (unsigned int i = 0 ; i < mFocusSubscribers.size(); i++ )
+        {
+        focusEvent.mCookie = (void *) mFocusSubscribers.keyAt(i);
+        eventCb = (event_callback) mFocusSubscribers.valueAt(i);
+        eventCb ( &focusEvent );
+        }
+
+    focusEvent.mEventData.clear();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::notifyShutterSubscribers()
+{
+    CameraHalEvent shutterEvent;
+    event_callback eventCb;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( mShutterSubscribers.size() == 0 )
+        {
+        CAMHAL_LOGEA("No shutter Subscribers!");
+        return NO_INIT;
+        }
+
+    shutterEvent.mEventData = new CameraHalEvent::CameraHalEventData();
+    if ( NULL == shutterEvent.mEventData.get() ) {
+        return -ENOMEM;
+    }
+
+    shutterEvent.mEventType = CameraHalEvent::EVENT_SHUTTER;
+    shutterEvent.mEventData->shutterEvent.shutterClosed = true;
+
+    for (unsigned int i = 0 ; i < mShutterSubscribers.size() ; i++ ) {
+        shutterEvent.mCookie = ( void * ) mShutterSubscribers.keyAt(i);
+        eventCb = ( event_callback ) mShutterSubscribers.valueAt(i);
+
+        CAMHAL_LOGEA("Sending shutter callback");
+
+        eventCb ( &shutterEvent );
+    }
+
+    shutterEvent.mEventData.clear();
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::notifyZoomSubscribers(int zoomIdx, bool targetReached)
+{
+    event_callback eventCb;
+    CameraHalEvent zoomEvent;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( mZoomSubscribers.size() == 0 ) {
+        CAMHAL_LOGDA("No zoom Subscribers!");
+        return NO_INIT;
+    }
+
+    zoomEvent.mEventData = new CameraHalEvent::CameraHalEventData();
+    if ( NULL == zoomEvent.mEventData.get() ) {
+        return -ENOMEM;
+    }
+
+    zoomEvent.mEventType = CameraHalEvent::EVENT_ZOOM_INDEX_REACHED;
+    zoomEvent.mEventData->zoomEvent.currentZoomIndex = zoomIdx;
+    zoomEvent.mEventData->zoomEvent.targetZoomIndexReached = targetReached;
+
+    for (unsigned int i = 0 ; i < mZoomSubscribers.size(); i++ ) {
+        zoomEvent.mCookie = (void *) mZoomSubscribers.keyAt(i);
+        eventCb = (event_callback) mZoomSubscribers.valueAt(i);
+
+        eventCb ( &zoomEvent );
+    }
+
+    zoomEvent.mEventData.clear();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::notifyFaceSubscribers(sp<CameraFDResult> &faces)
+{
+    event_callback eventCb;
+    CameraHalEvent faceEvent;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( mFaceSubscribers.size() == 0 ) {
+        CAMHAL_LOGDA("No face detection subscribers!");
+        return NO_INIT;
+    }
+
+    faceEvent.mEventData = new CameraHalEvent::CameraHalEventData();
+    if ( NULL == faceEvent.mEventData.get() ) {
+        return -ENOMEM;
+    }
+
+    faceEvent.mEventType = CameraHalEvent::EVENT_FACE;
+    faceEvent.mEventData->faceEvent = faces;
+
+    for (unsigned int i = 0 ; i < mFaceSubscribers.size(); i++ ) {
+        faceEvent.mCookie = (void *) mFaceSubscribers.keyAt(i);
+        eventCb = (event_callback) mFaceSubscribers.valueAt(i);
+
+        eventCb ( &faceEvent );
+    }
+
+    faceEvent.mEventData.clear();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::sendFrameToSubscribers(CameraFrame *frame)
+{
+    status_t ret = NO_ERROR;
+    frame_callback callback;
+    uint32_t i = 0;
+    KeyedVector<int, frame_callback> *subscribers = NULL;
+    size_t refCount = 0;
+
+    if ( NULL == frame )
+        {
+        CAMHAL_LOGEA("Invalid CameraFrame");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        switch(frame->mFrameType)
+            {
+                case CameraFrame::IMAGE_FRAME:
+                    {
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+                    CameraHal::PPM("Shot to Jpeg: ", &mStartCapture);
+
+#endif
+
+                    subscribers = &mImageSubscribers;
+                    break;
+                    }
+                case CameraFrame::RAW_FRAME:
+                    {
+                    subscribers = &mRawSubscribers;
+                    break;
+                    }
+                case CameraFrame::VIDEO_FRAME_SYNC:
+                    {
+                    subscribers = &mVideoSubscribers;
+                    break;
+                    }
+                case CameraFrame::FRAME_DATA_SYNC:
+                    {
+                    subscribers = &mFrameDataSubscribers;
+                    break;
+                    }
+                case CameraFrame::PREVIEW_FRAME_SYNC:
+                case CameraFrame::SNAPSHOT_FRAME:
+                    {
+                    subscribers = &mFrameSubscribers;
+                    break;
+                    }
+                default:
+                    {
+                    ret = -EINVAL;
+                    break;
+                    }
+            };
+
+        }
+
+    if ( ( NO_ERROR == ret ) &&
+         ( NULL != subscribers ) )
+        {
+        Mutex::Autolock lock(mSubscriberLock);
+
+        refCount = subscribers->size();
+        CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
+                                    frame->mFrameType,
+                                    ( uint32_t ) frame->mBuffer,
+                                    refCount);
+
+        setFrameRefCount(frame->mBuffer,
+                         (  CameraFrame::FrameType ) frame->mFrameType,
+                         refCount);
+
+        for ( i = 0 ; i < subscribers->size(); i++ )
+            {
+            frame->mCookie = ( void * ) subscribers->keyAt(i);
+            callback = (frame_callback) subscribers->valueAt(i);
+            callback(frame);
+            }
+        }
+
+    if ( 0 == i )
+        {
+        //No subscribers for this frame
+        ret = -1;
+        }
+
+    return ret;
+}
+
+int BaseCameraAdapter::getFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType)
+{
+    int res = -1;
+
+    LOG_FUNCTION_NAME;
+
+    switch ( frameType )
+        {
+        case CameraFrame::IMAGE_FRAME:
+        case CameraFrame::RAW_FRAME:
+                {
+                Mutex::Autolock lock(mCaptureBufferLock);
+                res = mCaptureBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
+                }
+            break;
+        case CameraFrame::PREVIEW_FRAME_SYNC:
+        case CameraFrame::SNAPSHOT_FRAME:
+                {
+                Mutex::Autolock lock(mPreviewBufferLock);
+                res = mPreviewBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
+                }
+            break;
+        case CameraFrame::FRAME_DATA_SYNC:
+                {
+                Mutex::Autolock lock(mPreviewDataBufferLock);
+                res = mPreviewDataBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
+                }
+            break;
+        case CameraFrame::VIDEO_FRAME_SYNC:
+                {
+                Mutex::Autolock lock(mVideoBufferLock);
+                res = mVideoBuffersAvailable.valueFor( ( unsigned int ) frameBuf );
+                }
+            break;
+        default:
+            break;
+        };
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return res;
+}
+
+void BaseCameraAdapter::setFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType, int refCount)
+{
+
+    LOG_FUNCTION_NAME;
+
+    switch ( frameType )
+        {
+        case CameraFrame::IMAGE_FRAME:
+        case CameraFrame::RAW_FRAME:
+                {
+                Mutex::Autolock lock(mCaptureBufferLock);
+                mCaptureBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
+                }
+            break;
+        case CameraFrame::PREVIEW_FRAME_SYNC:
+        case CameraFrame::SNAPSHOT_FRAME:
+                {
+                Mutex::Autolock lock(mPreviewBufferLock);
+                mPreviewBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
+                }
+            break;
+        case CameraFrame::FRAME_DATA_SYNC:
+                {
+                Mutex::Autolock lock(mPreviewDataBufferLock);
+                mPreviewDataBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
+                }
+            break;
+        case CameraFrame::VIDEO_FRAME_SYNC:
+                {
+                Mutex::Autolock lock(mVideoBufferLock);
+                mVideoBuffersAvailable.replaceValueFor(  ( unsigned int ) frameBuf, refCount);
+                }
+            break;
+        default:
+            break;
+        };
+
+    LOG_FUNCTION_NAME_EXIT;
+
+}
+
+status_t BaseCameraAdapter::startVideoCapture()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mVideoBufferLock);
+
+    //If the capture is already ongoing, return from here.
+    if ( mRecording )
+        {
+        ret = NO_INIT;
+        }
+
+
+    if ( NO_ERROR == ret )
+        {
+
+        for ( unsigned int i = 0 ; i < mPreviewBuffersAvailable.size() ; i++ )
+            {
+            mVideoBuffersAvailable.add(mPreviewBuffersAvailable.keyAt(i), 0);
+            }
+
+        mRecording = true;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::stopVideoCapture()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( !mRecording )
+        {
+        ret = NO_INIT;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        for ( unsigned int i = 0 ; i < mVideoBuffersAvailable.size() ; i++ )
+            {
+            void *frameBuf = ( void * ) mVideoBuffersAvailable.keyAt(i);
+            if( getFrameRefCount(frameBuf,  CameraFrame::VIDEO_FRAME_SYNC) > 0)
+                {
+                returnFrame(frameBuf, CameraFrame::VIDEO_FRAME_SYNC);
+                }
+            }
+
+        mVideoBuffersAvailable.clear();
+
+        mRecording = false;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+//-----------------Stub implementation of the interface ------------------------------
+
+status_t BaseCameraAdapter::takePicture()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::stopImageCapture()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::startBracketing(int range)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::stopBracketing()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::autoFocus()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    notifyFocusSubscribers(false);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::cancelAutoFocus()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::startSmoothZoom(int targetIdx)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::stopSmoothZoom()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::startPreview()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::stopPreview()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::getFrameSize(size_t &width, size_t &height)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::getPictureBufferSize(size_t &length, size_t bufferCount)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::startFaceDetection()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::stopFaceDetection()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::setState(CameraCommands operation)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    mLock.lock();
+
+    switch ( mAdapterState )
+        {
+
+        case INTIALIZED_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_USE_BUFFERS_PREVIEW:
+                    CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->LOADED_PREVIEW_STATE event = 0x%x",
+                                 operation);
+                    mNextState = LOADED_PREVIEW_STATE;
+                    break;
+
+                //These events don't change the current state
+                case CAMERA_QUERY_RESOLUTION_PREVIEW:
+                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
+                case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:
+                    CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->INTIALIZED_STATE event = 0x%x",
+                                 operation);
+                    mNextState = INTIALIZED_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch INTIALIZED_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case LOADED_PREVIEW_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_START_PREVIEW:
+                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->PREVIEW_STATE event = 0x%x",
+                                 operation);
+                    mNextState = PREVIEW_STATE;
+                    break;
+
+                //These events don't change the current state
+                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
+                case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA:
+                case CAMERA_USE_BUFFERS_PREVIEW_DATA:
+                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->LOADED_PREVIEW_STATE event = 0x%x",
+                                 operation);
+                    mNextState = LOADED_PREVIEW_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case PREVIEW_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_STOP_PREVIEW:
+                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->INTIALIZED_STATE event = 0x%x",
+                                 operation);
+                    mNextState = INTIALIZED_STATE;
+                    break;
+
+                case CAMERA_PERFORM_AUTOFOCUS:
+                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->AF_STATE event = 0x%x",
+                                 operation);
+                    mNextState = AF_STATE;
+                    break;
+
+                case CAMERA_START_SMOOTH_ZOOM:
+                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->ZOOM_STATE event = 0x%x",
+                                 operation);
+                    mNextState = ZOOM_STATE;
+                    break;
+
+                case CAMERA_USE_BUFFERS_IMAGE_CAPTURE:
+                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->LOADED_CAPTURE_STATE event = 0x%x",
+                                 operation);
+                    mNextState = LOADED_CAPTURE_STATE;
+                    break;
+
+                case CAMERA_START_VIDEO:
+                    CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->VIDEO_STATE event = 0x%x",
+                                 operation);
+                    mNextState = VIDEO_STATE;
+                    break;
+
+                case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE:
+                case CAMERA_STOP_SMOOTH_ZOOM:
+                    CAMHAL_LOGDB("Adapter state switch PREVIEW_ACTIVE->PREVIEW_ACTIVE event = 0x%x",
+                                 operation);
+                    mNextState = PREVIEW_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch PREVIEW_ACTIVE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case LOADED_CAPTURE_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_START_IMAGE_CAPTURE:
+                    CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->CAPTURE_STATE event = 0x%x",
+                                 operation);
+                    mNextState = CAPTURE_STATE;
+                    break;
+
+                case CAMERA_START_BRACKET_CAPTURE:
+                    CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->BRACKETING_STATE event = 0x%x",
+                                 operation);
+                    mNextState = BRACKETING_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch LOADED_CAPTURE_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case CAPTURE_STATE:
+
+            switch ( operation )
+                {
+                case CAMERA_STOP_IMAGE_CAPTURE:
+                    CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->PREVIEW_STATE event = 0x%x",
+                                 operation);
+                    mNextState = PREVIEW_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch CAPTURE_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case BRACKETING_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_STOP_BRACKET_CAPTURE:
+                    CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->PREVIEW_STATE event = 0x%x",
+                                 operation);
+                    mNextState = PREVIEW_STATE;
+                    break;
+
+                case CAMERA_START_IMAGE_CAPTURE:
+                    CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->CAPTURE_STATE event = 0x%x",
+                                 operation);
+                    mNextState = CAPTURE_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch BRACKETING_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case AF_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_CANCEL_AUTOFOCUS:
+                    CAMHAL_LOGDB("Adapter state switch AF_STATE->PREVIEW_STATE event = 0x%x",
+                                 operation);
+                    mNextState = PREVIEW_STATE;
+                    break;
+
+                case CAMERA_START_SMOOTH_ZOOM:
+                    CAMHAL_LOGDB("Adapter state switch AF_STATE->AF_ZOOM_STATE event = 0x%x",
+                                 operation);
+                    mNextState = AF_ZOOM_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch AF_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case ZOOM_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_STOP_SMOOTH_ZOOM:
+                    CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->PREVIEW_STATE event = 0x%x",
+                                 operation);
+                    mNextState = PREVIEW_STATE;
+                    break;
+
+                case CAMERA_PERFORM_AUTOFOCUS:
+                    CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->AF_ZOOM_STATE event = 0x%x",
+                                 operation);
+                    mNextState = AF_ZOOM_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch ZOOM_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case VIDEO_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_STOP_VIDEO:
+                    CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->PREVIEW_STATE event = 0x%x",
+                                 operation);
+                    mNextState = PREVIEW_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch VIDEO_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case AF_ZOOM_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_STOP_SMOOTH_ZOOM:
+                    CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->AF_STATE event = 0x%x",
+                                 operation);
+                    mNextState = AF_STATE;
+                    break;
+
+                case CAMERA_CANCEL_AUTOFOCUS:
+                    CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->ZOOM_STATE event = 0x%x",
+                                 operation);
+                    mNextState = ZOOM_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch AF_ZOOM_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case VIDEO_ZOOM_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_STOP_SMOOTH_ZOOM:
+                    CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->VIDEO_STATE event = 0x%x",
+                                 operation);
+                    mNextState = VIDEO_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch VIDEO_ZOOM_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        case BRACKETING_ZOOM_STATE:
+
+            switch ( operation )
+                {
+
+                case CAMERA_STOP_SMOOTH_ZOOM:
+                    CAMHAL_LOGDB("Adapter state switch BRACKETING_ZOOM_STATE->BRACKETING_STATE event = 0x%x",
+                                 operation);
+                    mNextState = BRACKETING_STATE;
+                    break;
+
+                default:
+                    CAMHAL_LOGEB("Adapter state switch BRACKETING_ZOOM_STATE Invalid Op! event = 0x%x",
+                                 operation);
+                    ret = INVALID_OPERATION;
+                    break;
+
+                }
+
+            break;
+
+        default:
+            CAMHAL_LOGEA("Invalid Adapter state!");
+            ret = INVALID_OPERATION;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+//State transition finished successfully.
+//Commit the state and unlock the adapter state.
+status_t BaseCameraAdapter::commitState()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    mAdapterState = mNextState;
+
+    mLock.unlock();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::rollbackState()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    mNextState = mAdapterState;
+
+    mLock.unlock();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+// getNextState() and getState()
+// publicly exposed functions to retrieve the adapter states
+// please notice that these functions are locked
+CameraAdapter::AdapterState BaseCameraAdapter::getState()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mLock);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return mAdapterState;
+}
+
+CameraAdapter::AdapterState BaseCameraAdapter::getNextState()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mLock);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return mNextState;
+}
+
+// getNextState() and getState()
+// internal protected functions to retrieve the adapter states
+// please notice that these functions are NOT locked to help
+// internal functions query state in the middle of state
+// transition
+status_t BaseCameraAdapter::getState(AdapterState &state)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    state = mAdapterState;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t BaseCameraAdapter::getNextState(AdapterState &state)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    state = mNextState;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+void BaseCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt)
+{
+    LOG_FUNCTION_NAME;
+    LOG_FUNCTION_NAME_EXIT;
+}
+//-----------------------------------------------------------------------------
+
+
+
+};
+
+/*--------------------Camera Adapter Class ENDS here-----------------------------*/
+
diff --git a/camera/CameraHal.cpp b/camera/CameraHal.cpp
new file mode 100755
index 0000000..53bc377
--- /dev/null
+++ b/camera/CameraHal.cpp
@@ -0,0 +1,3030 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file CameraHal.cpp
+*
+* This file maps the Camera Hardware Interface to V4L2.
+*
+*/
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "ANativeWindowDisplayAdapter.h"
+#include "TICameraParameters.h"
+#include "CameraProperties.h"
+#include <cutils/properties.h>
+
+#include <poll.h>
+#include <math.h>
+
+namespace android {
+
+extern "C" CameraAdapter* CameraAdapter_Factory();
+
+/*****************************************************************************/
+
+////Constant definitions and declarations
+////@todo Have a CameraProperties class to store these parameters as constants for every camera
+////       Currently, they are hard-coded
+
+const int CameraHal::NO_BUFFERS_PREVIEW = MAX_CAMERA_BUFFERS;
+const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE = 2;
+
+const uint32_t MessageNotifier::EVENT_BIT_FIELD_POSITION = 0;
+const uint32_t MessageNotifier::FRAME_BIT_FIELD_POSITION = 0;
+
+/******************************************************************************/
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+struct timeval CameraHal::mStartPreview;
+struct timeval CameraHal::mStartFocus;
+struct timeval CameraHal::mStartCapture;
+
+#endif
+
+static void orientation_cb(uint32_t orientation, uint32_t tilt, void* cookie) {
+    CameraHal *camera = NULL;
+
+    if (cookie) {
+        camera = (CameraHal*) cookie;
+        camera->onOrientationEvent(orientation, tilt);
+    }
+
+}
+/*-------------Camera Hal Interface Method definitions STARTS here--------------------*/
+
+/**
+  Callback function to receive orientation events from SensorListener
+ */
+void CameraHal::onOrientationEvent(uint32_t orientation, uint32_t tilt) {
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != mCameraAdapter ) {
+        mCameraAdapter->onOrientationEvent(orientation, tilt);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Set the notification and data callbacks
+
+   @param[in] notify_cb Notify callback for notifying the app about events and errors
+   @param[in] data_cb   Buffer callback for sending the preview/raw frames to the app
+   @param[in] data_cb_timestamp Buffer callback for sending the video frames w/ timestamp
+   @param[in] user  Callback cookie
+   @return none
+
+ */
+void CameraHal::setCallbacks(camera_notify_callback notify_cb,
+                            camera_data_callback data_cb,
+                            camera_data_timestamp_callback data_cb_timestamp,
+                            camera_request_memory get_memory,
+                            void *user)
+{
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != mAppCallbackNotifier.get() )
+    {
+            mAppCallbackNotifier->setCallbacks(this,
+                                                notify_cb,
+                                                data_cb,
+                                                data_cb_timestamp,
+                                                get_memory,
+                                                user);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Enable a message, or set of messages.
+
+   @param[in] msgtype Bitmask of the messages to enable (defined in include/ui/Camera.h)
+   @return none
+
+ */
+void CameraHal::enableMsgType(int32_t msgType)
+{
+    LOG_FUNCTION_NAME;
+
+    if ( ( msgType & CAMERA_MSG_SHUTTER ) && ( !mShutterEnabled ) )
+        {
+        msgType &= ~CAMERA_MSG_SHUTTER;
+        }
+
+    {
+    Mutex::Autolock lock(mLock);
+    mMsgEnabled |= msgType;
+    }
+
+    if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
+    {
+        if(mDisplayPaused)
+        {
+            CAMHAL_LOGDA("Preview currently paused...will enable preview callback when restarted");
+            msgType &= ~CAMERA_MSG_PREVIEW_FRAME;
+        }else
+        {
+            CAMHAL_LOGDA("Enabling Preview Callback");
+        }
+    }
+    else
+    {
+        CAMHAL_LOGDB("Preview callback not enabled %x", msgType);
+    }
+
+
+    ///Configure app callback notifier with the message callback required
+    mAppCallbackNotifier->enableMsgType (msgType);
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Disable a message, or set of messages.
+
+   @param[in] msgtype Bitmask of the messages to disable (defined in include/ui/Camera.h)
+   @return none
+
+ */
+void CameraHal::disableMsgType(int32_t msgType)
+{
+    LOG_FUNCTION_NAME;
+
+        {
+        Mutex::Autolock lock(mLock);
+        mMsgEnabled &= ~msgType;
+        }
+
+    if( msgType & CAMERA_MSG_PREVIEW_FRAME)
+        {
+        CAMHAL_LOGDA("Disabling Preview Callback");
+        }
+
+    ///Configure app callback notifier
+    mAppCallbackNotifier->disableMsgType (msgType);
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Query whether a message, or a set of messages, is enabled.
+
+   Note that this is operates as an AND, if any of the messages queried are off, this will
+   return false.
+
+   @param[in] msgtype Bitmask of the messages to query (defined in include/ui/Camera.h)
+   @return true If all message types are enabled
+          false If any message type
+
+ */
+int CameraHal::msgTypeEnabled(int32_t msgType)
+{
+    LOG_FUNCTION_NAME;
+    Mutex::Autolock lock(mLock);
+    LOG_FUNCTION_NAME_EXIT;
+    return (mMsgEnabled & msgType);
+}
+
+/**
+   @brief Set the camera parameters.
+
+   @param[in] params Camera parameters to configure the camera
+   @return NO_ERROR
+   @todo Define error codes
+
+ */
+int CameraHal::setParameters(const char* parameters)
+{
+
+   LOG_FUNCTION_NAME;
+
+    CameraParameters params;
+
+    String8 str_params(parameters);
+    params.unflatten(str_params);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return setParameters(params);
+}
+
+/**
+   @brief Set the camera parameters.
+
+   @param[in] params Camera parameters to configure the camera
+   @return NO_ERROR
+   @todo Define error codes
+
+ */
+int CameraHal::setParameters(const CameraParameters& params)
+{
+
+   LOG_FUNCTION_NAME;
+
+    int w, h;
+    int w_orig, h_orig;
+    int framerate,minframerate;
+    bool framerateUpdated = true;
+    int maxFPS, minFPS;
+    int error;
+    int base;
+    const char *valstr = NULL;
+    const char *prevFormat;
+    char *af_coord;
+    TIUTILS::Message msg;
+    status_t ret = NO_ERROR;
+
+    Mutex::Autolock lock(mLock);
+
+    ///Ensure that preview is not enabled when the below parameters are changed.
+    if(!previewEnabled())
+        {
+
+        CAMHAL_LOGDB("PreviewFormat %s", params.getPreviewFormat());
+
+        if ( !isParameterValid(params.getPreviewFormat(), mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS)))
+            {
+            CAMHAL_LOGEB("Invalid preview format %s",  mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS));
+            return -EINVAL;
+            }
+        else
+          {
+            if ( (valstr = params.getPreviewFormat()) != NULL)
+              mParameters.setPreviewFormat(valstr);
+          }
+
+        params.getPreviewSize(&w, &h);
+        if (w == -1 && h == -1) {
+            CAMHAL_LOGEA("Unable to get preview size");
+            return ret;
+          }
+
+        int orientation =0;
+        if((valstr = params.get(TICameraParameters::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);
+            }
+
+        if(orientation ==90 || orientation ==270)
+       {
+          if ( !isResolutionValid(h,w, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)))
+           {
+            CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h);
+            return -EINVAL;
+           }
+          else
+          {
+            mParameters.setPreviewSize(w, h);
+           }
+       }
+       else
+       {
+        if ( !isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)))
+            {
+            CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h);
+            return -EINVAL;
+            }
+        else
+            {
+            mParameters.setPreviewSize(w, h);
+            }
+       }
+
+        CAMHAL_LOGDB("PreviewResolution by App %d x %d", w, h);
+
+        if(( (valstr = params.get(TICameraParameters::KEY_VNF)) != NULL)
+            && ((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(TICameraParameters::KEY_VSTAB)) != NULL)
+             && ((params.getInt(TICameraParameters::KEY_VSTAB)==0) || (params.getInt(TICameraParameters::KEY_VSTAB)==1)))
+            {
+            CAMHAL_LOGDB("VSTAB set %s", params.get(TICameraParameters::KEY_VSTAB));
+            mParameters.set(TICameraParameters::KEY_VSTAB, valstr);
+            }
+
+        if( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL)
+            {
+            CAMHAL_LOGDB("Capture mode set %s", params.get(TICameraParameters::KEY_CAP_MODE));
+            mParameters.set(TICameraParameters::KEY_CAP_MODE, valstr);
+            }
+
+        if((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL)
+            {
+            CAMHAL_LOGDB("IPP mode set %s", params.get(TICameraParameters::KEY_IPP));
+            mParameters.set(TICameraParameters::KEY_IPP, valstr);
+            }
+
+        if((valstr = params.get(TICameraParameters::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);
+            }
+
+        if((valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
+            {
+            CAMHAL_LOGDB("AutoConvergence mode is %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE));
+            mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr);
+            }
+        if((valstr = params.get(TICameraParameters::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);
+            }
+
+        }
+
+    ///Below parameters can be changed when the preview is running
+    if ( !isParameterValid(params.getPictureFormat(),
+            mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS)))
+        {
+        CAMHAL_LOGEA("Invalid picture format");
+        return -EINVAL;
+        }
+    else
+        {
+        valstr = params.getPictureFormat();
+        if (valstr)
+        mParameters.setPictureFormat(valstr);
+        }
+
+    params.getPictureSize(&w, &h);
+    if ( !isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES)))
+        {
+        CAMHAL_LOGEB("Invalid picture resolution %dx%d", w, h);
+        return -EINVAL;
+        }
+    else
+        {
+        mParameters.setPictureSize(w, h);
+        }
+
+    CAMHAL_LOGDB("Picture Size by App %d x %d", w, h);
+
+    if(( (valstr = params.get(TICameraParameters::KEY_BURST)) != NULL)
+        && (params.getInt(TICameraParameters::KEY_BURST) >=0))
+        {
+        CAMHAL_LOGDB("Burst set %s", params.get(TICameraParameters::KEY_BURST));
+        mParameters.set(TICameraParameters::KEY_BURST, valstr);
+        }
+
+    framerate = params.getPreviewFrameRate();
+    if ( isParameterValid(framerate, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)))
+        {
+        if ( mLastPreviewFramerate != framerate )
+            {
+            mLastPreviewFramerate = framerate;
+            mParameters.setPreviewFrameRate(framerate);
+            framerateUpdated = true;
+            }
+        else
+            {
+            framerateUpdated = false;
+            }
+        }
+    else
+        {
+        framerateUpdated = false;
+        }
+
+    CAMHAL_LOGDB("FRAMERATE %d", framerate);
+
+    //If client uses fixed framerate than
+    //give it a higher piority than VFR.
+    if ( framerateUpdated )
+        {
+
+        minFPS = framerate;
+        maxFPS = framerate;
+
+        CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS);
+        mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS);
+        mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS);
+        mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE));
+        }
+    else if ( ( valstr = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE) ) != NULL )
+        {
+        CAMHAL_LOGDB("FPS Range = %s", valstr);
+        params.getPreviewFpsRange(&minFPS, &maxFPS);
+
+        if ( ( 0 > minFPS ) || ( 0 > maxFPS ) )
+            {
+            CAMHAL_LOGEA("FPS Range is negative!");
+            return -EINVAL;
+            }
+
+        minFPS /= CameraHal::VFR_SCALE;
+        maxFPS /= CameraHal::VFR_SCALE;
+
+        if ( ( 0 == minFPS ) || ( 0 == maxFPS ) )
+            {
+            CAMHAL_LOGEA("FPS Range is invalid!");
+            return -EINVAL;
+            }
+
+        if ( maxFPS < minFPS )
+            {
+            CAMHAL_LOGEA("Max FPS is smaller than Min FPS!");
+            return -EINVAL;
+            }
+
+        if ( maxFPS > framerate )
+            {
+            framerate = maxFPS;
+            mParameters.setPreviewFrameRate(framerate);
+            }
+
+        CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS);
+        mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS);
+        mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS);
+        mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
+        }
+
+    if( ( valstr = params.get(TICameraParameters::KEY_GBCE) ) != NULL )
+        {
+        CAMHAL_LOGDB("GBCE Value = %s", valstr);
+        mParameters.set(TICameraParameters::KEY_GBCE, valstr);
+        }
+
+    if( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL )
+        {
+        CAMHAL_LOGDB("GLBCE Value = %s", valstr);
+        mParameters.set(TICameraParameters::KEY_GLBCE, valstr);
+        }
+
+    ///Update the current parameter set
+    if( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
+        {
+        CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE));
+        mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr);
+       }
+
+//    if(params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE)!=NULL)
+//        {
+//        CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE));
+//        mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE));
+//        }
+
+    if( (valstr = params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES)) !=NULL )
+        {
+        CAMHAL_LOGDB("ManualConvergence Value = %s", params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES));
+        mParameters.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, valstr);
+        }
+
+    if( ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL)
+        && isParameterValid(params.get(TICameraParameters::KEY_EXPOSURE_MODE),
+                mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES)))
+        {
+        CAMHAL_LOGDB("Exposure set = %s", params.get(TICameraParameters::KEY_EXPOSURE_MODE));
+        mParameters.set(TICameraParameters::KEY_EXPOSURE_MODE, valstr);
+        }
+
+    if( ((valstr = params.get(CameraParameters::KEY_WHITE_BALANCE)) != NULL)
+        && isParameterValid(params.get(CameraParameters::KEY_WHITE_BALANCE),
+            mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE)))
+        {
+        CAMHAL_LOGDB("White balance set %s", params.get(CameraParameters::KEY_WHITE_BALANCE));
+        mParameters.set(CameraParameters::KEY_WHITE_BALANCE, valstr);
+        }
+
+    if( ((valstr = params.get(TICameraParameters::KEY_CONTRAST)) != NULL)
+            && (params.getInt(TICameraParameters::KEY_CONTRAST) >= 0 ))
+        {
+        CAMHAL_LOGDB("Contrast set %s", params.get(TICameraParameters::KEY_CONTRAST));
+        mParameters.set(TICameraParameters::KEY_CONTRAST, valstr);
+        }
+
+    if( ((valstr =params.get(TICameraParameters::KEY_SHARPNESS)) != NULL) && params.getInt(TICameraParameters::KEY_SHARPNESS) >= 0 )
+        {
+        CAMHAL_LOGDB("Sharpness set %s", params.get(TICameraParameters::KEY_SHARPNESS));
+        mParameters.set(TICameraParameters::KEY_SHARPNESS, valstr);
+        }
+
+
+    if( ((valstr = params.get(TICameraParameters::KEY_SATURATION)) != NULL)
+        && (params.getInt(TICameraParameters::KEY_SATURATION) >= 0 ) )
+        {
+        CAMHAL_LOGDB("Saturation set %s", params.get(TICameraParameters::KEY_SATURATION));
+        mParameters.set(TICameraParameters::KEY_SATURATION, valstr);
+        }
+
+    if( ((valstr = params.get(TICameraParameters::KEY_BRIGHTNESS)) != NULL)
+        && (params.getInt(TICameraParameters::KEY_BRIGHTNESS) >= 0 ))
+        {
+        CAMHAL_LOGDB("Brightness set %s", params.get(TICameraParameters::KEY_BRIGHTNESS));
+        mParameters.set(TICameraParameters::KEY_BRIGHTNESS, valstr);
+        }
+
+
+    if( ((valstr = params.get(CameraParameters::KEY_ANTIBANDING)) != NULL)
+        && isParameterValid(params.get(CameraParameters::KEY_ANTIBANDING),
+                mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING)))
+        {
+        CAMHAL_LOGDB("Antibanding set %s", params.get(CameraParameters::KEY_ANTIBANDING));
+        mParameters.set(CameraParameters::KEY_ANTIBANDING, valstr);
+        }
+
+    if( ((valstr = params.get(TICameraParameters::KEY_ISO)) != NULL)
+        && isParameterValid(params.get(TICameraParameters::KEY_ISO),
+                mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES)))
+        {
+        CAMHAL_LOGDB("ISO set %s", params.get(TICameraParameters::KEY_ISO));
+        mParameters.set(TICameraParameters::KEY_ISO, valstr);
+        }
+
+    if( ((valstr = params.get(CameraParameters::KEY_FOCUS_MODE)) != NULL)
+        && isParameterValid(params.get(CameraParameters::KEY_FOCUS_MODE),
+                mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES)))
+        {
+        CAMHAL_LOGDB("Focus mode set %s", params.get(CameraParameters::KEY_FOCUS_MODE));
+        mParameters.set(CameraParameters::KEY_FOCUS_MODE, valstr);
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_FOCUS_AREAS)) != NULL )
+        {
+        CAMHAL_LOGEB("Focus areas position set %s", params.get(CameraParameters::KEY_FOCUS_AREAS));
+        mParameters.set(CameraParameters::KEY_FOCUS_AREAS, valstr);
+        }
+
+    if( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
+        {
+        CAMHAL_LOGDB("Measurements set to %s", params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE));
+        mParameters.set(TICameraParameters::KEY_MEASUREMENT_ENABLE, valstr);
+
+        if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0)
+            {
+            mMeasurementEnabled = true;
+            }
+        else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0)
+            {
+            mMeasurementEnabled = false;
+            }
+        else
+            {
+            mMeasurementEnabled = false;
+            }
+
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL)
+        {
+        CAMHAL_LOGDB("Exposure compensation set %s", params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION));
+        mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, valstr);
+        }
+
+    if(( (valstr = params.get(CameraParameters::KEY_SCENE_MODE)) != NULL)
+        && isParameterValid(params.get(CameraParameters::KEY_SCENE_MODE),
+                mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES)))
+        {
+        CAMHAL_LOGDB("Scene mode set %s", params.get(CameraParameters::KEY_SCENE_MODE));
+        mParameters.set(CameraParameters::KEY_SCENE_MODE, valstr);
+        }
+
+    if(( (valstr = params.get(CameraParameters::KEY_FLASH_MODE)) != NULL)
+        && isParameterValid(params.get(CameraParameters::KEY_FLASH_MODE),
+                mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES)))
+        {
+        CAMHAL_LOGDB("Flash mode set %s", params.get(CameraParameters::KEY_FLASH_MODE));
+        mParameters.set(CameraParameters::KEY_FLASH_MODE, valstr);
+        }
+
+    if(( (valstr = params.get(CameraParameters::KEY_EFFECT)) != NULL)
+        && isParameterValid(params.get(CameraParameters::KEY_EFFECT),
+                mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS)))
+        {
+        CAMHAL_LOGDB("Effect set %s", params.get(CameraParameters::KEY_EFFECT));
+        mParameters.set(CameraParameters::KEY_EFFECT, valstr);
+        }
+
+    if(( (valstr = params.get(CameraParameters::KEY_ROTATION)) != NULL)
+        && (params.getInt(CameraParameters::KEY_ROTATION) >=0))
+        {
+        CAMHAL_LOGDB("Rotation set %s", params.get(CameraParameters::KEY_ROTATION));
+        mParameters.set(CameraParameters::KEY_ROTATION, valstr);
+        }
+
+    if(( (valstr = params.get(CameraParameters::KEY_JPEG_QUALITY)) != NULL)
+        && (params.getInt(CameraParameters::KEY_JPEG_QUALITY) >=0))
+        {
+        CAMHAL_LOGDB("Jpeg quality set %s", params.get(CameraParameters::KEY_JPEG_QUALITY));
+        mParameters.set(CameraParameters::KEY_JPEG_QUALITY, valstr);
+        }
+
+    if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH)) != NULL)
+        && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH) >=0))
+        {
+        CAMHAL_LOGDB("Thumbnail width set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH));
+        mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, valstr);
+        }
+
+    if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT)) != NULL)
+        && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT) >=0))
+        {
+        CAMHAL_LOGDB("Thumbnail width set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT));
+        mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, valstr);
+        }
+
+    if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)) != NULL )
+        && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY) >=0))
+        {
+        CAMHAL_LOGDB("Thumbnail quality set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY));
+        mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, valstr);
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_GPS_LATITUDE)) != NULL )
+        {
+        CAMHAL_LOGDB("GPS latitude set %s", params.get(CameraParameters::KEY_GPS_LATITUDE));
+        mParameters.set(CameraParameters::KEY_GPS_LATITUDE, valstr);
+        }else{
+            mParameters.remove(CameraParameters::KEY_GPS_LATITUDE);
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_GPS_LONGITUDE)) != NULL )
+        {
+        CAMHAL_LOGDB("GPS longitude set %s", params.get(CameraParameters::KEY_GPS_LONGITUDE));
+        mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, valstr);
+        }else{
+            mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE);
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_GPS_ALTITUDE)) != NULL )
+        {
+        CAMHAL_LOGDB("GPS altitude set %s", params.get(CameraParameters::KEY_GPS_ALTITUDE));
+        mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, valstr);
+        }else{
+            mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE);
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_GPS_TIMESTAMP)) != NULL )
+        {
+        CAMHAL_LOGDB("GPS timestamp set %s", params.get(CameraParameters::KEY_GPS_TIMESTAMP));
+        mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, valstr);
+        }else{
+            mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
+        }
+
+    if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL )
+        {
+        CAMHAL_LOGDB("GPS datestamp set %s", params.get(TICameraParameters::KEY_GPS_DATESTAMP));
+        mParameters.set(TICameraParameters::KEY_GPS_DATESTAMP, valstr);
+        }else{
+            mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP);
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL )
+        {
+        CAMHAL_LOGDB("GPS processing method set %s", params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD));
+        mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, valstr);
+        }else{
+            mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
+        }
+
+    if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL )
+        {
+        CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_MAPDATUM));
+        mParameters.set(TICameraParameters::KEY_GPS_MAPDATUM, valstr);
+        }else{
+            mParameters.remove(TICameraParameters::KEY_GPS_MAPDATUM);
+        }
+
+    if( (valstr = params.get(TICameraParameters::KEY_GPS_VERSION)) != NULL )
+        {
+        CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_VERSION));
+        mParameters.set(TICameraParameters::KEY_GPS_VERSION, valstr);
+        }else{
+            mParameters.remove(TICameraParameters::KEY_GPS_VERSION);
+        }
+
+    if( (valstr = params.get(TICameraParameters::KEY_EXIF_MODEL)) != NULL )
+        {
+        CAMHAL_LOGDB("EXIF Model set %s", params.get(TICameraParameters::KEY_EXIF_MODEL));
+        mParameters.set(TICameraParameters::KEY_EXIF_MODEL, valstr);
+        }
+
+    if( (valstr = params.get(TICameraParameters::KEY_EXIF_MAKE)) != NULL )
+        {
+        CAMHAL_LOGDB("EXIF Make set %s", params.get(TICameraParameters::KEY_EXIF_MAKE));
+        mParameters.set(TICameraParameters::KEY_EXIF_MAKE, valstr);
+        }
+
+    if( (valstr = params.get(TICameraParameters::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);
+        }
+    else
+        {
+        mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE);
+        }
+
+    if( ( (valstr = params.get(CameraParameters::KEY_ZOOM)) != NULL )
+        && (params.getInt(CameraParameters::KEY_ZOOM) >= 0 )
+        && (params.getInt(CameraParameters::KEY_ZOOM) <= mMaxZoomSupported ) )
+        {
+        CAMHAL_LOGDB("Zoom set %s", params.get(CameraParameters::KEY_ZOOM));
+        mParameters.set(CameraParameters::KEY_ZOOM, valstr);
+        }
+    else
+        {
+        //CTS requirement: Invalid zoom values should always return an error.
+        ret = -EINVAL;
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL )
+      {
+        CAMHAL_LOGDB("Auto Exposure Lock set %s", params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
+        mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr);
+      }
+
+    if( (valstr = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL )
+      {
+        CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
+        mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr);
+      }
+
+    CameraParameters adapterParams = mParameters;
+
+    //If the app has not set the capture mode, set the capture resolution as preview resolution
+    //so that black bars are not displayed in preview.
+    //Later in takePicture we will configure the correct picture size
+    if(params.get(TICameraParameters::KEY_CAP_MODE) == NULL)
+        {
+        CAMHAL_LOGDA("Capture mode not set by app, setting picture res to preview res");
+        mParameters.getPreviewSize(&w, &h);
+        adapterParams.setPictureSize(w,h);
+        }
+
+    // Only send parameters to adapter if preview is already
+    // enabled. Initial setParameters to camera adapter, will
+    // be called in startPreview()
+    if ( NULL != mCameraAdapter && mPreviewEnabled ) {
+        ret |= mCameraAdapter->setParameters(adapterParams);
+    }
+
+    if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS) )
+        {
+        int posBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS);
+        if ( 0 < posBracketRange )
+            {
+            mBracketRangePositive = posBracketRange;
+            }
+        }
+    CAMHAL_LOGDB("Positive bracketing range %d", mBracketRangePositive);
+
+
+    if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG) )
+        {
+        int negBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG);
+        if ( 0 < negBracketRange )
+            {
+            mBracketRangeNegative = negBracketRange;
+            }
+        }
+    CAMHAL_LOGDB("Negative bracketing range %d", mBracketRangeNegative);
+
+    if( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL) &&
+        ( strcmp(valstr, TICameraParameters::BRACKET_ENABLE) == 0 ))
+        {
+        if ( !mBracketingEnabled )
+            {
+            CAMHAL_LOGDA("Enabling bracketing");
+            mBracketingEnabled = true;
+
+            //Wait for AF events to enable bracketing
+            if ( NULL != mCameraAdapter )
+                {
+                setEventProvider( CameraHalEvent::ALL_EVENTS, mCameraAdapter );
+                }
+            }
+        else
+            {
+            CAMHAL_LOGDA("Bracketing already enabled");
+            }
+        }
+    else if ( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL ) &&
+        ( strcmp(valstr, TICameraParameters::BRACKET_DISABLE) == 0 ))
+        {
+        CAMHAL_LOGDA("Disabling bracketing");
+
+        mBracketingEnabled = false;
+        stopImageBracketing();
+
+        //Remove AF events subscription
+        if ( NULL != mEventProvider )
+            {
+            mEventProvider->disableEventNotification( CameraHalEvent::ALL_EVENTS );
+            delete mEventProvider;
+            mEventProvider = NULL;
+            }
+
+        }
+
+    if( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
+        ( strcmp(valstr, TICameraParameters::SHUTTER_ENABLE) == 0 ))
+        {
+        CAMHAL_LOGDA("Enabling shutter sound");
+
+        mShutterEnabled = true;
+        mMsgEnabled |= CAMERA_MSG_SHUTTER;
+        mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
+        }
+    else if ( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
+        ( strcmp(valstr, TICameraParameters::SHUTTER_DISABLE) == 0 ))
+        {
+        CAMHAL_LOGDA("Disabling shutter sound");
+
+        mShutterEnabled = false;
+        mMsgEnabled &= ~CAMERA_MSG_SHUTTER;
+        mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+
+    }
+
+status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewFormat,
+                                        unsigned int buffercount, unsigned int &max_queueable)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if(mDisplayAdapter.get() == NULL)
+    {
+        // Memory allocation of preview buffers is now placed in gralloc
+        // CameraHal should not allocate preview buffers without DisplayAdapter
+        return NO_MEMORY;
+    }
+
+    if(!mPreviewBufs)
+    {
+        ///@todo Pluralise the name of this method to allocateBuffers
+        mPreviewLength = 0;
+        mPreviewBufs = (int32_t *) mDisplayAdapter->allocateBuffer(width, height,
+                                                                    previewFormat,
+                                                                    mPreviewLength,
+                                                                    buffercount);
+
+	if (NULL == mPreviewBufs ) {
+            CAMHAL_LOGEA("Couldn't allocate preview buffers");
+            return NO_MEMORY;
+         }
+
+        mPreviewOffsets = (uint32_t *) mDisplayAdapter->getOffsets();
+        if ( NULL == mPreviewOffsets ) {
+            CAMHAL_LOGEA("Buffer mapping failed");
+            return BAD_VALUE;
+         }
+
+        mPreviewFd = mDisplayAdapter->getFd();
+        if ( -1 == mPreviewFd ) {
+            CAMHAL_LOGEA("Invalid handle");
+            return BAD_VALUE;
+          }
+
+        mBufProvider = (BufferProvider*) mDisplayAdapter.get();
+
+        ret = mDisplayAdapter->maxQueueableBuffers(max_queueable);
+        if (ret != NO_ERROR) {
+            return ret;
+         }
+
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+
+}
+
+status_t CameraHal::freePreviewBufs()
+{
+    status_t ret = NO_ERROR;
+    LOG_FUNCTION_NAME;
+
+    CAMHAL_LOGDB("mPreviewBufs = 0x%x", (unsigned int)mPreviewBufs);
+    if(mPreviewBufs)
+        {
+        ///@todo Pluralise the name of this method to freeBuffers
+        ret = mBufProvider->freeBuffer(mPreviewBufs);
+        mPreviewBufs = NULL;
+        LOG_FUNCTION_NAME_EXIT;
+        return ret;
+        }
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+
+status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount)
+{
+    status_t ret = NO_ERROR;
+    int bytes;
+
+    LOG_FUNCTION_NAME;
+
+    bytes = size;
+
+    if ( NO_ERROR == ret )
+        {
+        if( NULL != mPreviewDataBufs )
+            {
+            ret = freePreviewDataBufs();
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        mPreviewDataBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, NULL, bytes, bufferCount);
+
+        CAMHAL_LOGDB("Size of Preview data buffer = %d", bytes);
+        if( NULL == mPreviewDataBufs )
+            {
+            CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager");
+            ret = -NO_MEMORY;
+            }
+        else
+            {
+            bytes = size;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        mPreviewDataFd = mMemoryManager->getFd();
+        mPreviewDataLength = bytes;
+        mPreviewDataOffsets = mMemoryManager->getOffsets();
+        }
+    else
+        {
+        mPreviewDataFd = -1;
+        mPreviewDataLength = 0;
+        mPreviewDataOffsets = NULL;
+        }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t CameraHal::freePreviewDataBufs()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NO_ERROR == ret )
+        {
+
+        if( NULL != mPreviewDataBufs )
+            {
+
+            ///@todo Pluralise the name of this method to freeBuffers
+            ret = mMemoryManager->freeBuffer(mPreviewDataBufs);
+            mPreviewDataBufs = NULL;
+
+            }
+        else
+            {
+            CAMHAL_LOGEA("Couldn't free PreviewDataBufs allocated by memory manager");
+            ret = -EINVAL;
+            }
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t CameraHal::allocImageBufs(unsigned int width, unsigned int height, size_t size, const char* previewFormat, unsigned int bufferCount)
+{
+    status_t ret = NO_ERROR;
+    int bytes;
+
+    LOG_FUNCTION_NAME;
+
+    bytes = size;
+
+    ///Always allocate the buffers for image capture using MemoryManager
+    if ( NO_ERROR == ret )
+        {
+        if( ( NULL != mImageBufs ) )
+            {
+            ret = freeImageBufs();
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        mImageBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, previewFormat, bytes, bufferCount);
+
+        CAMHAL_LOGDB("Size of Image cap buffer = %d", bytes);
+        if( NULL == mImageBufs )
+            {
+            CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager");
+            ret = -NO_MEMORY;
+            }
+        else
+            {
+            bytes = size;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        mImageFd = mMemoryManager->getFd();
+        mImageLength = bytes;
+        mImageOffsets = mMemoryManager->getOffsets();
+        }
+    else
+        {
+        mImageFd = -1;
+        mImageLength = 0;
+        mImageOffsets = NULL;
+        }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+void endImageCapture( void *userData)
+{
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != userData )
+        {
+        CameraHal *c = reinterpret_cast<CameraHal *>(userData);
+        c->signalEndImageCapture();
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void releaseImageBuffers(void *userData)
+{
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != userData )
+        {
+        CameraHal *c = reinterpret_cast<CameraHal *>(userData);
+        c->freeImageBufs();
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+status_t CameraHal::signalEndImageCapture()
+{
+    status_t ret = NO_ERROR;
+    int w,h;
+    CameraParameters adapterParams = mParameters;
+    Mutex::Autolock lock(mLock);
+
+    LOG_FUNCTION_NAME;
+
+    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
+
+    //If the app has not set the capture mode, restore the capture resolution
+    //back to the preview resolution to get rid of the black bars issue
+    if (mParameters.get(TICameraParameters::KEY_CAP_MODE) == NULL) {
+        CAMHAL_LOGDA("Capture mode not set by app, setting picture res back to preview res");
+        mParameters.getPreviewSize(&w, &h);
+        adapterParams.setPictureSize(w,h);
+        ret = mCameraAdapter->setParameters(adapterParams);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t CameraHal::freeImageBufs()
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NO_ERROR == ret )
+        {
+
+        if( NULL != mImageBufs )
+            {
+
+            ///@todo Pluralise the name of this method to freeBuffers
+            ret = mMemoryManager->freeBuffer(mImageBufs);
+            mImageBufs = NULL;
+
+            }
+        else
+            {
+            ret = -EINVAL;
+            }
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+
+
+/**
+   @brief Start preview mode.
+
+   @param none
+   @return NO_ERROR Camera switched to VF mode
+   @todo Update function header with the different errors that are possible
+
+ */
+status_t CameraHal::startPreview()
+{
+
+    status_t ret = NO_ERROR;
+    CameraAdapter::BuffersDescriptor desc;
+    CameraFrame frame;
+    const char *valstr = NULL;
+    unsigned int required_buffer_count;
+    unsigned int max_queueble_buffers;
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+        gettimeofday(&mStartPreview, NULL);
+
+#endif
+
+    LOG_FUNCTION_NAME;
+
+    if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) )
+        {
+        CAMHAL_LOGDA("Preview is in paused state");
+
+        mDisplayPaused = false;
+        mPreviewEnabled = true;
+        if ( NO_ERROR == ret )
+            {
+            ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
+
+            if ( NO_ERROR != ret )
+                {
+                CAMHAL_LOGEB("Display adapter resume failed %x", ret);
+                }
+            }
+        //restart preview callbacks
+        if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
+        {
+            mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME);
+        }
+        return ret;
+
+        }
+    else if ( mPreviewEnabled )
+        {
+        CAMHAL_LOGDA("Preview already running");
+
+        LOG_FUNCTION_NAME_EXIT;
+
+        return ALREADY_EXISTS;
+        }
+
+    ///If we don't have the preview callback enabled and display adapter,
+    if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL))
+    {
+        CAMHAL_LOGEA("Preview not started. Preview in progress flag set");
+        mPreviewStartInProgress = true;
+        return NO_ERROR;
+    }
+
+    if ( NULL != mCameraAdapter ) {
+
+        CameraParameters adapterParams = mParameters;
+
+        //If the app has not set the capture mode, set the capture resolution as preview resolution
+        //so that black bars are not displayed in preview.
+        //Later in takePicture we will configure the correct picture size
+        if(mParameters.get(TICameraParameters::KEY_CAP_MODE) == NULL)
+            {
+            int w,h;
+            CAMHAL_LOGDA("Capture mode not set by app, setting picture res to preview res");
+            mParameters.getPreviewSize(&w, &h);
+            adapterParams.setPictureSize(w,h);
+            }
+
+        ret = mCameraAdapter->setParameters(adapterParams);
+    }
+
+    /// Ensure that buffers for preview are allocated before we start the camera
+    ///Get the updated size from Camera Adapter, to account for padding etc
+    ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,
+                                      ( int ) &frame);
+    if ( NO_ERROR != ret )
+        {
+        return ret;
+        }
+
+    ///Update the current preview width and height
+    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);
+
+    required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
+
+    ///Allocate the preview buffers
+    ret = allocPreviewBufs(frame.mWidth, frame.mHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers);
+
+    if ( NO_ERROR != ret )
+        {
+        CAMHAL_LOGEA("Couldn't allocate buffers for Preview");
+        goto error;
+        }
+
+    if ( mMeasurementEnabled )
+        {
+
+        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA,
+                                          ( int ) &frame,
+                                          required_buffer_count);
+        if ( NO_ERROR != ret )
+            {
+            return ret;
+            }
+
+         ///Allocate the preview data buffers
+        ret = allocPreviewDataBufs(frame.mLength, required_buffer_count);
+        if ( NO_ERROR != ret ) {
+            CAMHAL_LOGEA("Couldn't allocate preview data buffers");
+            goto error;
+           }
+
+        if ( NO_ERROR == ret )
+            {
+            desc.mBuffers = mPreviewDataBufs;
+            desc.mOffsets = mPreviewDataOffsets;
+            desc.mFd = mPreviewDataFd;
+            desc.mLength = mPreviewDataLength;
+            desc.mCount = ( size_t ) required_buffer_count;
+            desc.mMaxQueueable = (size_t) required_buffer_count;
+
+            mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,
+                                        ( int ) &desc);
+            }
+
+        }
+
+    ///Pass the buffers to Camera Adapter
+    desc.mBuffers = mPreviewBufs;
+    desc.mOffsets = mPreviewOffsets;
+    desc.mFd = mPreviewFd;
+    desc.mLength = mPreviewLength;
+    desc.mCount = ( size_t ) required_buffer_count;
+    desc.mMaxQueueable = (size_t) max_queueble_buffers;
+
+    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW,
+                                ( int ) &desc);
+
+    mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count);
+
+    ///Start the callback notifier
+    ret = mAppCallbackNotifier->start();
+
+    if( ALREADY_EXISTS == ret )
+        {
+        //Already running, do nothing
+        CAMHAL_LOGDA("AppCallbackNotifier already running");
+        ret = NO_ERROR;
+        }
+    else if ( NO_ERROR == ret ) {
+        CAMHAL_LOGDA("Started AppCallbackNotifier..");
+        mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
+        }
+    else
+        {
+        CAMHAL_LOGDA("Couldn't start AppCallbackNotifier");
+        goto error;
+        }
+
+    ///Enable the display adapter if present, actual overlay enable happens when we post the buffer
+    if(mDisplayAdapter.get() != NULL)
+        {
+        CAMHAL_LOGDA("Enabling display");
+        bool isS3d = false;
+        DisplayAdapter::S3DParameters s3dParams;
+        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) {
+            isS3d = (strcmp(valstr, "true") == 0);
+        }
+        if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) {
+            if (strcmp(valstr, "off") == 0)
+                {
+                CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS OFF");
+                //TODO: obtain the frame packing configuration from camera or user settings
+                //once side by side configuration is supported
+                s3dParams.mode = OVERLAY_S3D_MODE_ON;
+                s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
+                s3dParams.order = OVERLAY_S3D_ORDER_LF;
+                s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
+                }
+            else
+                {
+                CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS ON");
+                s3dParams.mode = OVERLAY_S3D_MODE_OFF;
+                s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
+                s3dParams.order = OVERLAY_S3D_ORDER_LF;
+                s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
+                }
+        }
+#endif //if 0
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+        ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview, isS3d ? &s3dParams : NULL);
+
+#else
+
+        ret = mDisplayAdapter->enableDisplay(width, height, NULL, isS3d ? &s3dParams : NULL);
+
+#endif
+
+        if ( ret != NO_ERROR )
+            {
+            CAMHAL_LOGEA("Couldn't enable display");
+            goto error;
+            }
+
+        }
+
+    ///Send START_PREVIEW command to adapter
+    CAMHAL_LOGDA("Starting CameraAdapter preview mode");
+
+    ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
+
+    if(ret!=NO_ERROR)
+        {
+        CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");
+        goto error;
+        }
+    CAMHAL_LOGDA("Started preview");
+
+
+    mPreviewEnabled = true;
+    mPreviewStartInProgress = false;
+    return ret;
+
+    error:
+
+        CAMHAL_LOGEA("Performing cleanup after error");
+
+        //Do all the cleanup
+        freePreviewBufs();
+        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
+        if(mDisplayAdapter.get() != NULL)
+            {
+            mDisplayAdapter->disableDisplay();
+            }
+        mAppCallbackNotifier->stop();
+        mPreviewStartInProgress = false;
+        mPreviewEnabled = false;
+        LOG_FUNCTION_NAME_EXIT;
+
+        return ret;
+}
+
+/**
+   @brief Sets ANativeWindow object.
+
+   Preview buffers provided to CameraHal via this object. DisplayAdapter will be interfacing with it
+   to render buffers to display.
+
+   @param[in] window The ANativeWindow object created by Surface flinger
+   @return NO_ERROR If the ANativeWindow object passes validation criteria
+   @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios
+
+ */
+status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window)
+{
+    status_t ret = NO_ERROR;
+    CameraAdapter::BuffersDescriptor desc;
+
+    LOG_FUNCTION_NAME;
+    mSetPreviewWindowCalled = true;
+
+   ///If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter
+    if(!window)
+    {
+        if(mDisplayAdapter.get() != NULL)
+        {
+            ///NULL window passed, destroy the display adapter if present
+            CAMHAL_LOGEA("NULL window passed, destroying display adapter");
+            mDisplayAdapter.clear();
+            ///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client
+            ///@remarks so, we will wait until it passes a valid window to begin the preview again
+            mSetPreviewWindowCalled = false;
+        }
+        CAMHAL_LOGEA("NULL ANativeWindow passed to setPreviewWindow");
+        return NO_ERROR;
+    }else if(mDisplayAdapter.get() == NULL)
+    {
+        // Need to create the display adapter since it has not been created
+        // Create display adapter
+        mDisplayAdapter = new ANativeWindowDisplayAdapter();
+        ret = NO_ERROR;
+        if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR))
+        {
+            if(ret!=NO_ERROR)
+            {
+                mDisplayAdapter.clear();
+                CAMHAL_LOGEA("DisplayAdapter initialize failed");
+                LOG_FUNCTION_NAME_EXIT;
+                return ret;
+            }
+            else
+            {
+                CAMHAL_LOGEA("Couldn't create DisplayAdapter");
+                LOG_FUNCTION_NAME_EXIT;
+                return NO_MEMORY;
+            }
+        }
+
+        // DisplayAdapter needs to know where to get the CameraFrames from inorder to display
+        // Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter
+        mDisplayAdapter->setFrameProvider(mCameraAdapter);
+
+        // Any dynamic errors that happen during the camera use case has to be propagated back to the application
+        // via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that  notifies such errors to the application
+        // Set it as the error handler for the DisplayAdapter
+        mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get());
+
+        // Update the display adapter with the new window that is passed from CameraService
+        ret  = mDisplayAdapter->setPreviewWindow(window);
+        if(ret!=NO_ERROR)
+            {
+            CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret);
+            }
+
+        if(mPreviewStartInProgress)
+        {
+            CAMHAL_LOGDA("setPreviewWindow called when preview running");
+            // Start the preview since the window is now available
+            ret = startPreview();
+        }
+    }else
+    {
+        /* If mDisplayAdpater is already created. No need to do anything.
+         * We get a surface handle directly now, so we can reconfigure surface
+         * itself in DisplayAdapter if dimensions have changed
+         */
+    }
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+
+}
+
+
+/**
+   @brief Stop a previously started preview.
+
+   @param none
+   @return none
+
+ */
+void CameraHal::stopPreview()
+{
+    LOG_FUNCTION_NAME;
+
+    if(!previewEnabled() && !mDisplayPaused)
+        {
+        LOG_FUNCTION_NAME_EXIT;
+        return;
+        }
+
+    if(mDisplayPaused)
+        {
+        // Display is paused, which essentially means there is no preview active.
+        // Note: this is done so that when stopPreview is called by client after
+        // an image capture, we do not de-initialize the camera adapter and
+        // restart over again.
+        return;
+        }
+
+    forceStopPreview();
+
+    CAMHAL_LOGDA("Resetting Capture-Mode to default");
+    mParameters.set(TICameraParameters::KEY_CAP_MODE, "");
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Returns true if preview is enabled
+
+   @param none
+   @return true If preview is running currently
+         false If preview has been stopped
+
+ */
+bool CameraHal::previewEnabled()
+{
+    LOG_FUNCTION_NAME;
+
+    return (mPreviewEnabled || mPreviewStartInProgress);
+}
+
+/**
+   @brief Start record mode.
+
+  When a record image is available a CAMERA_MSG_VIDEO_FRAME message is sent with
+  the corresponding frame. Every record frame must be released by calling
+  releaseRecordingFrame().
+
+   @param none
+   @return NO_ERROR If recording could be started without any issues
+   @todo Update the header with possible error values in failure scenarios
+
+ */
+status_t CameraHal::startRecording( )
+{
+    int w, h;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+            gettimeofday(&mStartPreview, NULL);
+
+#endif
+
+    if(!previewEnabled())
+        {
+        return NO_INIT;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        ret = setVideoModeParameters();
+        }
+
+    if ( NO_ERROR == ret )
+        {
+         ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)));
+        }
+
+    if ( NO_ERROR == ret )
+        {
+         ret = mAppCallbackNotifier->startRecording();
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        ///Buffers for video capture (if different from preview) are expected to be allocated within CameraAdapter
+         ret =  mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_VIDEO);
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        mRecordingEnabled = true;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+/**
+   @brief Set the camera parameters specific to Video Recording.
+
+   This function checks for the camera parameters which have to be set for recording.
+   Video Recording needs CAPTURE_MODE to be VIDEO_MODE. This function sets it.
+   This function also enables Video Recording specific functions like VSTAB & VNF.
+
+   @param none
+   @return NO_ERROR If recording parameters could be set without any issues
+   @todo Modify the policies for enabling VSTAB & VNF usecase based later.
+
+ */
+status_t CameraHal::setVideoModeParameters()
+{
+    const char *valstr = NULL;
+    bool restartPreviewRequired = false;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
+    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
+    if ( (valstr == NULL) ||
+        ( (valstr != NULL) && (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) != 0) ) )
+        {
+        CAMHAL_LOGDA("Set CAPTURE_MODE to VIDEO_MODE");
+        mParameters.set(TICameraParameters::KEY_CAP_MODE, (const char *) TICameraParameters::VIDEO_MODE);
+        restartPreviewRequired = true;
+        }
+
+    // FIXME: This check is put since currently VSTAB and VNF are functional only for Primary Camera.
+    // Remove this check once VSTAB and VNF are functional for Secondary Camera as well.
+    if(mCameraIndex == 0)
+        {
+        // 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)
+            {
+            // Enable VSTAB, if not enabled already
+            valstr = mParameters.get(TICameraParameters::KEY_VSTAB);
+            if ( (valstr == NULL) ||
+                ( (valstr != NULL) && (strcmp(valstr, "1") != 0) ) )
+                {
+                CAMHAL_LOGDA("Enable VSTAB");
+                mParameters.set(TICameraParameters::KEY_VSTAB, "1");
+                restartPreviewRequired = true;
+                }
+
+            // Enable VNF, if not enabled already
+            valstr = mParameters.get(TICameraParameters::KEY_VNF);
+            if ( (valstr == NULL) ||
+                ( (valstr != NULL) && (strcmp(valstr, "1") != 0) ) )
+                {
+                CAMHAL_LOGDA("Enable VNF");
+                mParameters.set(TICameraParameters::KEY_VNF, "1");
+                restartPreviewRequired = true;
+                }
+
+            // For VSTAB alone for 1080p resolution, padded width goes > 2048, which cannot be rendered by GPU.
+            // In such case, there is support in Ducati for combination of VSTAB & VNF requiring padded width < 2048.
+            // So we are forcefully enabling VNF, if VSTAB is enabled for 1080p resolution.
+            valstr = mParameters.get(TICameraParameters::KEY_VSTAB);
+            if ((valstr != NULL) && (strcmp(valstr, "1") == 0) && (mPreviewWidth == 1920))
+                {
+                CAMHAL_LOGDA("Force Enable VNF for 1080p");
+                mParameters.set(TICameraParameters::KEY_VNF, "1");
+                restartPreviewRequired = true;
+                }
+            }
+        }
+
+    if (restartPreviewRequired)
+        {
+        CAMHAL_LOGDA("Restarting preview");
+        stopPreview();
+        // Setting CAPTURE_MODE to VIDEO_MODE again, since it is reset in stopPreview()
+        mParameters.set(TICameraParameters::KEY_CAP_MODE, (const char *) TICameraParameters::VIDEO_MODE);
+        mCameraAdapter->setParameters(mParameters);
+        ret = startPreview();
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+/**
+   @brief Stop a previously started recording.
+
+   @param none
+   @return none
+
+ */
+void CameraHal::stopRecording()
+{
+    LOG_FUNCTION_NAME;
+
+    if (!mRecordingEnabled )
+        {
+        return;
+        }
+
+    mAppCallbackNotifier->stopRecording();
+
+    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_VIDEO);
+
+    mRecordingEnabled = false;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Returns true if recording is enabled.
+
+   @param none
+   @return true If recording is currently running
+         false If recording has been stopped
+
+ */
+int CameraHal::recordingEnabled()
+{
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return mRecordingEnabled;
+}
+
+/**
+   @brief Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
+
+   @param[in] mem MemoryBase pointer to the frame being released. Must be one of the buffers
+               previously given by CameraHal
+   @return none
+
+ */
+void CameraHal::releaseRecordingFrame(const void* mem)
+{
+    LOG_FUNCTION_NAME;
+
+    //CAMHAL_LOGDB(" 0x%x", mem->pointer());
+
+    if ( ( mRecordingEnabled ) && mem != NULL)
+    {
+        mAppCallbackNotifier->releaseRecordingFrame(mem);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return;
+}
+
+/**
+   @brief Start auto focus
+
+   This call asynchronous.
+   The notification callback routine is called with CAMERA_MSG_FOCUS once when
+   focusing is complete. autoFocus() will be called again if another auto focus is
+   needed.
+
+   @param none
+   @return NO_ERROR
+   @todo Define the error codes if the focus is not locked
+
+ */
+status_t CameraHal::autoFocus()
+{
+    status_t ret = NO_ERROR;
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    gettimeofday(&mStartFocus, NULL);
+
+#endif
+
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != mCameraAdapter )
+        {
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    //pass the autoFocus timestamp along with the command to camera adapter
+    ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS, ( int ) &mStartFocus);
+
+#else
+
+    ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS);
+
+#endif
+
+        }
+    else
+        {
+            ret = -1;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+/**
+   @brief Cancels auto-focus function.
+
+   If the auto-focus is still in progress, this function will cancel it.
+   Whether the auto-focus is in progress or not, this function will return the
+   focus position to the default. If the camera does not support auto-focus, this is a no-op.
+
+
+   @param none
+   @return NO_ERROR If the cancel succeeded
+   @todo Define error codes if cancel didnt succeed
+
+ */
+status_t CameraHal::cancelAutoFocus()
+{
+    LOG_FUNCTION_NAME;
+    if( NULL != mCameraAdapter )
+    {
+        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
+    }
+    LOG_FUNCTION_NAME_EXIT;
+    return NO_ERROR;
+}
+
+void CameraHal::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier)
+{
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != mEventProvider )
+        {
+        mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
+        delete mEventProvider;
+        mEventProvider = NULL;
+        }
+
+    mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay);
+    if ( NULL == mEventProvider )
+        {
+        CAMHAL_LOGEA("Error in creating EventProvider");
+        }
+    else
+        {
+        mEventProvider->enableEventNotification(eventMask);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void CameraHal::eventCallbackRelay(CameraHalEvent* event)
+{
+    LOG_FUNCTION_NAME;
+
+    CameraHal *appcbn = ( CameraHal * ) (event->mCookie);
+    appcbn->eventCallback(event );
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void CameraHal::eventCallback(CameraHalEvent* event)
+{
+    LOG_FUNCTION_NAME;
+
+    if ( NULL != event )
+        {
+        switch( event->mEventType )
+            {
+            case CameraHalEvent::EVENT_FOCUS_LOCKED:
+            case CameraHalEvent::EVENT_FOCUS_ERROR:
+                {
+                if ( mBracketingEnabled )
+                    {
+                    startImageBracketing();
+                    }
+                break;
+                }
+            default:
+                {
+                break;
+                }
+            };
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+status_t CameraHal::startImageBracketing()
+{
+        status_t ret = NO_ERROR;
+        CameraFrame frame;
+        CameraAdapter::BuffersDescriptor desc;
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+        gettimeofday(&mStartCapture, NULL);
+
+#endif
+
+        LOG_FUNCTION_NAME;
+
+        if(!previewEnabled() && !mDisplayPaused)
+            {
+            LOG_FUNCTION_NAME_EXIT;
+            return NO_INIT;
+            }
+
+        if ( !mBracketingEnabled )
+            {
+            return ret;
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            mBracketingRunning = true;
+            }
+
+        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
+            {
+            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
+                                              ( int ) &frame,
+                                              ( mBracketRangeNegative + 1 ));
+
+            if ( NO_ERROR != ret )
+                {
+                CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
+                }
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            if ( NULL != mAppCallbackNotifier.get() )
+                 {
+                 mAppCallbackNotifier->setBurst(true);
+                 }
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            mParameters.getPictureSize(( int * ) &frame.mWidth,
+                                       ( int * ) &frame.mHeight);
+
+            ret = allocImageBufs(frame.mWidth,
+                                 frame.mHeight,
+                                 frame.mLength,
+                                 mParameters.getPictureFormat(),
+                                 ( mBracketRangeNegative + 1 ));
+            if ( NO_ERROR != ret )
+                {
+                CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
+                }
+            }
+
+        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
+            {
+
+            desc.mBuffers = mImageBufs;
+            desc.mOffsets = mImageOffsets;
+            desc.mFd = mImageFd;
+            desc.mLength = mImageLength;
+            desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 );
+            desc.mMaxQueueable = ( size_t ) ( mBracketRangeNegative + 1 );
+
+            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
+                                              ( int ) &desc);
+
+            if ( NO_ERROR == ret )
+                {
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+                 //pass capture timestamp along with the camera adapter command
+                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE,  ( mBracketRangePositive + 1 ),  (int) &mStartCapture);
+
+#else
+
+                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ));
+
+#endif
+
+                }
+            }
+
+        return ret;
+}
+
+status_t CameraHal::stopImageBracketing()
+{
+        status_t ret = NO_ERROR;
+
+        LOG_FUNCTION_NAME;
+
+        if ( !mBracketingRunning )
+            {
+            return ret;
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            mBracketingRunning = false;
+            }
+
+        if(!previewEnabled() && !mDisplayPaused)
+            {
+            return NO_INIT;
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE);
+            }
+
+        LOG_FUNCTION_NAME_EXIT;
+
+        return ret;
+}
+
+/**
+   @brief Take a picture.
+
+   @param none
+   @return NO_ERROR If able to switch to image capture
+   @todo Define error codes if unable to switch to image capture
+
+ */
+status_t CameraHal::takePicture( )
+{
+    status_t ret = NO_ERROR;
+    CameraFrame frame;
+    CameraAdapter::BuffersDescriptor desc;
+    int burst;
+    unsigned int bufferCount = 1;
+
+    Mutex::Autolock lock(mLock);
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    gettimeofday(&mStartCapture, NULL);
+
+#endif
+
+    LOG_FUNCTION_NAME;
+
+    if(!previewEnabled() && !mDisplayPaused)
+        {
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    //If capture has already started, then queue this call for later execution
+    if ( mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
+         mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) {
+        return NO_INIT;
+    }
+
+    if ( !mBracketingRunning )
+        {
+
+         if ( NO_ERROR == ret )
+            {
+            burst = mParameters.getInt(TICameraParameters::KEY_BURST);
+            }
+
+         //Allocate all buffers only in burst capture case
+         if ( burst > 1 )
+             {
+             bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE;
+             if ( NULL != mAppCallbackNotifier.get() )
+                 {
+                 mAppCallbackNotifier->setBurst(true);
+                 }
+             }
+         else
+             {
+             if ( NULL != mAppCallbackNotifier.get() )
+                 {
+                 mAppCallbackNotifier->setBurst(false);
+                 }
+             }
+
+        //Pause Preview during capture
+        if ( (NO_ERROR == ret) && ( NULL != mDisplayAdapter.get() ) && ( burst < 1 ) )
+            {
+            mDisplayPaused = true;
+            mPreviewEnabled = false;
+            ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+            mDisplayAdapter->setSnapshotTimeRef(&mStartCapture);
+
+#endif
+            // since preview is paused we should stop sending preview frames too
+            if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
+                {
+                    mAppCallbackNotifier->disableMsgType (CAMERA_MSG_PREVIEW_FRAME);
+                }
+            }
+
+        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
+            {
+
+            //Configure the correct picture resolution now if the capture mode is not set
+            if(mParameters.get(TICameraParameters::KEY_CAP_MODE) == NULL)
+                {
+                ret = mCameraAdapter->setParameters(mParameters);
+                }
+
+            if ( NO_ERROR == ret )
+                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
+                                                  ( int ) &frame,
+                                                  bufferCount);
+
+            if ( NO_ERROR != ret )
+                {
+                CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
+                }
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            mParameters.getPictureSize(( int * ) &frame.mWidth,
+                                       ( int * ) &frame.mHeight);
+
+            ret = allocImageBufs(frame.mWidth,
+                                 frame.mHeight,
+                                 frame.mLength,
+                                 mParameters.getPictureFormat(),
+                                 bufferCount);
+            if ( NO_ERROR != ret )
+                {
+                CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
+                }
+            }
+
+        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
+            {
+            desc.mBuffers = mImageBufs;
+            desc.mOffsets = mImageOffsets;
+            desc.mFd = mImageFd;
+            desc.mLength = mImageLength;
+            desc.mCount = ( size_t ) bufferCount;
+            desc.mMaxQueueable = ( size_t ) bufferCount;
+
+            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
+                                              ( int ) &desc);
+            }
+        }
+    else
+        {
+        mBracketingRunning = false;
+        }
+
+    if ( ( NO_ERROR == ret ) && ( NULL != mCameraAdapter ) )
+        {
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+         //pass capture timestamp along with the camera adapter command
+        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE,  (int) &mStartCapture);
+
+#else
+
+        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE);
+
+#endif
+
+        }
+
+    return ret;
+}
+
+/**
+   @brief Cancel a picture that was started with takePicture.
+
+   Calling this method when no picture is being taken is a no-op.
+
+   @param none
+   @return NO_ERROR If cancel succeeded. Cancel can succeed if image callback is not sent
+   @todo Define error codes
+
+ */
+status_t CameraHal::cancelPicture( )
+{
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mLock);
+
+    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
+
+    return NO_ERROR;
+}
+
+/**
+   @brief Return the camera parameters.
+
+   @param none
+   @return Currently configured camera parameters
+
+ */
+char* CameraHal::getParameters()
+{
+    CameraParameters params;
+    String8 params_str8;
+    char* params_string;
+
+    LOG_FUNCTION_NAME;
+
+    params = mParameters;
+    if( NULL != mCameraAdapter )
+    {
+        mCameraAdapter->getParameters(params);
+    }
+
+    params_str8 = params.flatten();
+    // camera service frees this string...
+    params_string = (char*) malloc(sizeof(char) * (params_str8.length()+1));
+    strcpy(params_string, params_str8.string());
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    ///Return the current set of parameters
+
+    return params_string;
+}
+
+void CameraHal::putParameters(char *parms)
+{
+    free(parms);
+}
+
+/**
+   @brief Send command to camera driver.
+
+   @param none
+   @return NO_ERROR If the command succeeds
+   @todo Define the error codes that this function can return
+
+ */
+status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+
+    if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) )
+        {
+        CAMHAL_LOGEA("No CameraAdapter instance");
+        ret = -EINVAL;
+        }
+
+    if ( ( NO_ERROR == ret ) && ( !previewEnabled() ))
+        {
+        CAMHAL_LOGEA("Preview is not running");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        switch(cmd)
+            {
+            case CAMERA_CMD_START_SMOOTH_ZOOM:
+
+                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_SMOOTH_ZOOM, arg1);
+
+                break;
+            case CAMERA_CMD_STOP_SMOOTH_ZOOM:
+
+                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM);
+
+            case CAMERA_CMD_START_FACE_DETECTION:
+
+                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD);
+
+                break;
+
+            case CAMERA_CMD_STOP_FACE_DETECTION:
+
+                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD);
+
+                break;
+
+            default:
+                break;
+            };
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+/**
+   @brief Release the hardware resources owned by this object.
+
+   Note that this is *not* done in the destructor.
+
+   @param none
+   @return none
+
+ */
+void CameraHal::release()
+{
+    LOG_FUNCTION_NAME;
+    ///@todo Investigate on how release is used by CameraService. Vaguely remember that this is called
+    ///just before CameraHal object destruction
+    deinitialize();
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+/**
+   @brief Dump state of the camera hardware
+
+   @param[in] fd    File descriptor
+   @param[in] args  Arguments
+   @return NO_ERROR Dump succeeded
+   @todo  Error codes for dump fail
+
+ */
+status_t  CameraHal::dump(int fd) const
+{
+    LOG_FUNCTION_NAME;
+    ///Implement this method when the h/w dump function is supported on Ducati side
+    return NO_ERROR;
+}
+
+/*-------------Camera Hal Interface Method definitions ENDS here--------------------*/
+
+
+
+
+/*-------------Camera Hal Internal Method definitions STARTS here--------------------*/
+
+/**
+   @brief Constructor of CameraHal
+
+   Member variables are initialized here.  No allocations should be done here as we
+   don't use c++ exceptions in the code.
+
+ */
+CameraHal::CameraHal(int cameraId)
+{
+    LOG_FUNCTION_NAME;
+
+    ///Initialize all the member variables to their defaults
+    mPreviewEnabled = false;
+    mPreviewBufs = NULL;
+    mImageBufs = NULL;
+    mBufProvider = NULL;
+    mPreviewStartInProgress = false;
+    mVideoBufs = NULL;
+    mVideoBufProvider = NULL;
+    mRecordingEnabled = false;
+    mDisplayPaused = false;
+    mSetPreviewWindowCalled = false;
+    mMsgEnabled = 0;
+    mAppCallbackNotifier = NULL;
+    mMemoryManager = NULL;
+    mCameraAdapter = NULL;
+    mBracketingEnabled = false;
+    mBracketingRunning = false;
+    mEventProvider = NULL;
+    mBracketRangePositive = 1;
+    mBracketRangeNegative = 1;
+    mMaxZoomSupported = 0;
+    mShutterEnabled = true;
+    mMeasurementEnabled = false;
+    mPreviewDataBufs = NULL;
+    mCameraProperties = NULL;
+    mCurrentTime = 0;
+    mFalsePreview = 0;
+    mImageOffsets = NULL;
+    mImageLength = 0;
+    mImageFd = 0;
+    mVideoOffsets = NULL;
+    mVideoFd = 0;
+    mVideoLength = 0;
+    mPreviewDataOffsets = NULL;
+    mPreviewDataFd = 0;
+    mPreviewDataLength = 0;
+    mPreviewFd = 0;
+    mPreviewWidth = 0;
+    mPreviewHeight = 0;
+    mPreviewLength = 0;
+    mPreviewOffsets = NULL;
+    mPreviewRunning = 0;
+    mPreviewStateOld = 0;
+    mRecordingEnabled = 0;
+    mRecordEnabled = 0;
+    mSensorListener = NULL;
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    //Initialize the CameraHAL constructor timestamp, which is used in the
+    // PPM() method as time reference if the user does not supply one.
+    gettimeofday(&ppm_start, NULL);
+
+#endif
+
+    mCameraIndex = cameraId;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Destructor of CameraHal
+
+   This function simply calls deinitialize() to free up memory allocate during construct
+   phase
+ */
+CameraHal::~CameraHal()
+{
+    LOG_FUNCTION_NAME;
+
+    ///Call de-initialize here once more - it is the last chance for us to relinquish all the h/w and s/w resources
+    deinitialize();
+
+    if ( NULL != mEventProvider )
+        {
+        mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
+        delete mEventProvider;
+        mEventProvider = NULL;
+        }
+
+    /// Free the callback notifier
+    mAppCallbackNotifier.clear();
+
+    /// Free the memory manager
+    mMemoryManager.clear();
+
+    /// Free the display adapter
+    mDisplayAdapter.clear();
+
+    if ( NULL != mCameraAdapter ) {
+        int strongCount = mCameraAdapter->getStrongCount();
+
+        mCameraAdapter->decStrong(mCameraAdapter);
+
+        mCameraAdapter = NULL;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Initialize the Camera HAL
+
+   Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager
+
+   @param None
+   @return NO_ERROR - On success
+         NO_MEMORY - On failure to allocate memory for any of the objects
+   @remarks Camera Hal internal function
+
+ */
+
+status_t CameraHal::initialize(CameraProperties::Properties* properties)
+{
+    LOG_FUNCTION_NAME;
+
+    int sensor_index = 0;
+
+    mLastPreviewFramerate = 0;
+
+    ///Initialize the event mask used for registering an event provider for AppCallbackNotifier
+    ///Currently, registering all events as to be coming from CameraAdapter
+    int32_t eventMask = CameraHalEvent::ALL_EVENTS;
+
+    // Get my camera properties
+    mCameraProperties = properties;
+
+    if(!mCameraProperties)
+    {
+        goto fail_loop;
+    }
+
+    // Dump the properties of this Camera
+    // will only print if DEBUG macro is defined
+    mCameraProperties->dump();
+
+    if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 )
+        {
+        sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX));
+        }
+
+    CAMHAL_LOGDB("Sensor index %d", sensor_index);
+
+    mCameraAdapter = CameraAdapter_Factory();
+    if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties, sensor_index)!=NO_ERROR))
+        {
+        CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
+        mCameraAdapter = NULL;
+        goto fail_loop;
+        }
+
+    mCameraAdapter->incStrong(mCameraAdapter);
+    mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
+    mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
+
+    if(!mAppCallbackNotifier.get())
+        {
+        /// Create the callback notifier
+        mAppCallbackNotifier = new AppCallbackNotifier();
+        if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR))
+            {
+            CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
+            goto fail_loop;
+            }
+        }
+
+    if(!mMemoryManager.get())
+        {
+        /// Create Memory Manager
+        mMemoryManager = new MemoryManager();
+        if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR))
+            {
+            CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
+            goto fail_loop;
+            }
+        }
+
+    ///Setup the class dependencies...
+
+    ///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from.
+    ///CameraAdapter is the one which provides those events
+    ///Set it as the frame and event providers for AppCallbackNotifier
+    ///@remarks  setEventProvider API takes in a bit mask of events for registering a provider for the different events
+    ///         That way, if events can come from DisplayAdapter in future, we will be able to add it as provider
+    ///         for any event
+    mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
+    mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
+
+    ///Any dynamic errors that happen during the camera use case has to be propagated back to the application
+    ///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that  notifies such errors to the application
+    ///Set it as the error handler for CameraAdapter
+    mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());
+
+    ///Start the callback notifier
+    if(mAppCallbackNotifier->start() != NO_ERROR)
+      {
+        CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
+        goto fail_loop;
+      }
+
+    CAMHAL_LOGDA("Started AppCallbackNotifier..");
+    mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
+
+    ///Initialize default parameters
+    initDefaultParameters();
+
+
+    if ( setParameters(mParameters) != NO_ERROR )
+        {
+        CAMHAL_LOGEA("Failed to set default parameters?!");
+        }
+
+    // register for sensor events
+    mSensorListener = new SensorListener();
+    if (mSensorListener.get()) {
+        if (mSensorListener->initialize() == NO_ERROR) {
+            mSensorListener->setCallbacks(orientation_cb, this);
+            mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
+        } else {
+            CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
+            mSensorListener.clear();
+            mSensorListener = NULL;
+        }
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NO_ERROR;
+
+    fail_loop:
+
+        ///Free up the resources because we failed somewhere up
+        deinitialize();
+        LOG_FUNCTION_NAME_EXIT;
+
+        return NO_MEMORY;
+
+}
+
+bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions)
+{
+    bool ret = true;
+    status_t status = NO_ERROR;
+    char tmpBuffer[PARAM_BUFFER + 1];
+    char *pos = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == supportedResolutions )
+        {
+        CAMHAL_LOGEA("Invalid supported resolutions string");
+        ret = false;
+        goto exit;
+        }
+
+    status = snprintf(tmpBuffer, PARAM_BUFFER, "%dx%d", width, height);
+    if ( 0 > status )
+        {
+        CAMHAL_LOGEA("Error encountered while generating validation string");
+        ret = false;
+        goto exit;
+        }
+
+    pos = strstr(supportedResolutions, tmpBuffer);
+    if ( NULL == pos )
+        {
+        ret = false;
+        }
+    else
+        {
+        ret = true;
+        }
+
+exit:
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
+{
+    bool ret = true;
+    char *pos = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == supportedParams )
+        {
+        CAMHAL_LOGEA("Invalid supported parameters string");
+        ret = false;
+        goto exit;
+        }
+
+    if ( NULL == param )
+        {
+        CAMHAL_LOGEA("Invalid parameter string");
+        ret = false;
+        goto exit;
+        }
+
+    pos = strstr(supportedParams, param);
+    if ( NULL == pos )
+        {
+        ret = false;
+        }
+    else
+        {
+        ret = true;
+        }
+
+exit:
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+bool CameraHal::isParameterValid(int param, const char *supportedParams)
+{
+    bool ret = true;
+    char *pos = NULL;
+    status_t status;
+    char tmpBuffer[PARAM_BUFFER + 1];
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == supportedParams )
+        {
+        CAMHAL_LOGEA("Invalid supported parameters string");
+        ret = false;
+        goto exit;
+        }
+
+    status = snprintf(tmpBuffer, PARAM_BUFFER, "%d", param);
+    if ( 0 > status )
+        {
+        CAMHAL_LOGEA("Error encountered while generating validation string");
+        ret = false;
+        goto exit;
+        }
+
+    pos = strstr(supportedParams, tmpBuffer);
+    if ( NULL == pos )
+        {
+        ret = false;
+        }
+    else
+        {
+        ret = true;
+        }
+
+exit:
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t CameraHal::parseResolution(const char *resStr, int &width, int &height)
+{
+    status_t ret = NO_ERROR;
+    char *ctx, *pWidth, *pHeight;
+    const char *sep = "x";
+    char *tmp = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == resStr )
+        {
+        return -EINVAL;
+        }
+
+    //This fixes "Invalid input resolution"
+    char *resStr_copy = (char *)malloc(strlen(resStr) + 1);
+    if ( NULL!=resStr_copy ) {
+    if ( NO_ERROR == ret )
+        {
+        strcpy(resStr_copy, resStr);
+        pWidth = strtok_r( (char *) resStr_copy, sep, &ctx);
+
+        if ( NULL != pWidth )
+            {
+            width = atoi(pWidth);
+            }
+        else
+            {
+            CAMHAL_LOGEB("Invalid input resolution %s", resStr);
+            ret = -EINVAL;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        pHeight = strtok_r(NULL, sep, &ctx);
+
+        if ( NULL != pHeight )
+            {
+            height = atoi(pHeight);
+            }
+        else
+            {
+            CAMHAL_LOGEB("Invalid input resolution %s", resStr);
+            ret = -EINVAL;
+            }
+        }
+
+        free(resStr_copy);
+        resStr_copy = NULL;
+     }
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+void CameraHal::insertSupportedParams()
+{
+    char tmpBuffer[PARAM_BUFFER + 1];
+
+    LOG_FUNCTION_NAME;
+
+    CameraParameters &p = mParameters;
+
+    ///Set the name of the camera
+    p.set(TICameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME));
+
+    mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
+
+    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES));
+    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS));
+    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES));
+    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS));
+    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
+    p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES));
+    p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE));
+    p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS));
+    p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
+    p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES));
+    p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES));
+    p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING));
+    p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX));
+    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(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(TICameraParameters::KEY_VSTAB,mCameraProperties->get(CameraProperties::VSTAB));
+    p.set(TICameraParameters::KEY_VSTAB_VALUES,mCameraProperties->get(CameraProperties::VSTAB_VALUES));
+    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(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));
+
+    LOG_FUNCTION_NAME_EXIT;
+
+}
+
+void CameraHal::initDefaultParameters()
+{
+    //Purpose of this function is to initialize the default current and supported parameters for the currently
+    //selected camera.
+
+    CameraParameters &p = mParameters;
+    int currentRevision, adapterRevision;
+    status_t ret = NO_ERROR;
+    int width, height;
+
+    LOG_FUNCTION_NAME;
+
+    ret = parseResolution(mCameraProperties->get(CameraProperties::PREVIEW_SIZE), width, height);
+
+    if ( NO_ERROR == ret )
+        {
+        p.setPreviewSize(width, height);
+        }
+    else
+        {
+        p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT);
+        }
+
+    ret = parseResolution(mCameraProperties->get(CameraProperties::PICTURE_SIZE), width, height);
+
+    if ( NO_ERROR == ret )
+        {
+        p.setPictureSize(width, height);
+        }
+    else
+        {
+        p.setPictureSize(PICTURE_WIDTH, PICTURE_HEIGHT);
+        }
+
+    ret = parseResolution(mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_SIZE), width, height);
+
+    if ( NO_ERROR == ret )
+        {
+        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
+        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
+        }
+    else
+        {
+        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH);
+        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT);
+        }
+
+    insertSupportedParams();
+
+    //Insert default values
+    p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)));
+    p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT));
+    p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT));
+    p.set(CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY));
+    p.set(CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE));
+    p.set(CameraParameters::KEY_EFFECT,  mCameraProperties->get(CameraProperties::EFFECT));
+    p.set(CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING));
+    p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
+    p.set(CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE));
+    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION));
+    p.set(CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE));
+    p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
+    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_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(TICameraParameters::KEY_VSTAB,mCameraProperties->get(CameraProperties::VSTAB));
+    p.set(TICameraParameters::KEY_VSTAB_VALUES,mCameraProperties->get(CameraProperties::VSTAB_VALUES));
+    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(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY));
+    p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar");
+    p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES));
+    p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES));
+
+    // Only one area a.k.a Touch AF for now.
+    // TODO: Add support for multiple focus areas.
+    p.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS));
+    p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK));
+    p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK));
+    p.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS));
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Stop a previously started preview.
+   @param none
+   @return none
+
+ */
+void CameraHal::forceStopPreview()
+{
+    LOG_FUNCTION_NAME;
+
+    // stop bracketing if it is running
+    stopImageBracketing();
+
+    if(mDisplayAdapter.get() != NULL) {
+        ///Stop the buffer display first
+        mDisplayAdapter->disableDisplay();
+    }
+
+    if(mAppCallbackNotifier.get() != NULL) {
+        //Stop the callback sending
+        mAppCallbackNotifier->stop();
+        mAppCallbackNotifier->stopPreviewCallbacks();
+    }
+
+    // since prerequisite for capturing is for camera system
+    // to be previewing...cancel all captures before stopping
+    // preview
+    if ( mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
+         mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) {
+        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
+    }
+
+    if ( NULL != mCameraAdapter ) {
+        cancelAutoFocus();
+        //Stop the source of frames
+        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
+    }
+
+    freePreviewBufs();
+    freePreviewDataBufs();
+
+    mPreviewEnabled = false;
+    mDisplayPaused = false;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Deallocates memory for all the resources held by Camera HAL.
+
+   Frees the following objects- CameraAdapter, AppCallbackNotifier, DisplayAdapter,
+   and Memory Manager
+
+   @param none
+   @return none
+
+ */
+void CameraHal::deinitialize()
+{
+    LOG_FUNCTION_NAME;
+
+    if ( mPreviewEnabled ) {
+        forceStopPreview();
+    }
+
+    freeImageBufs();
+
+    mSetPreviewWindowCalled = false;
+
+    if (mSensorListener.get()) {
+        mSensorListener->disableSensor(SensorListener::SENSOR_ORIENTATION);
+        mSensorListener.clear();
+        mSensorListener = NULL;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+}
+
+status_t CameraHal::storeMetaDataInBuffers(bool enable)
+{
+    LOG_FUNCTION_NAME;
+
+    return mAppCallbackNotifier->useMetaDataBufferMode(enable);
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+};
+
+
diff --git a/camera/CameraHalCommon.cpp b/camera/CameraHalCommon.cpp
new file mode 100644
index 0000000..6d4ea2c
--- /dev/null
+++ b/camera/CameraHalCommon.cpp
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+#include "CameraHal.h"
+
+namespace android {
+
+const char CameraHal::PARAMS_DELIMITER []= ",";
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+struct timeval CameraHal::ppm_start;
+
+#endif
+
+#if PPM_INSTRUMENTATION
+
+/**
+   @brief PPM instrumentation
+
+   Dumps the current time offset. The time reference point
+   lies within the CameraHAL constructor.
+
+   @param str - log message
+   @return none
+
+ */
+void CameraHal::PPM(const char* str){
+    struct timeval ppm;
+
+    gettimeofday(&ppm, NULL);
+    ppm.tv_sec = ppm.tv_sec - ppm_start.tv_sec;
+    ppm.tv_sec = ppm.tv_sec * 1000000;
+    ppm.tv_sec = ppm.tv_sec + ppm.tv_usec - ppm_start.tv_usec;
+
+    LOGD("PPM: %s :%ld.%ld ms", str, ( ppm.tv_sec /1000 ), ( ppm.tv_sec % 1000 ));
+}
+
+#elif PPM_INSTRUMENTATION_ABS
+
+/**
+   @brief PPM instrumentation
+
+   Dumps the current time offset. The time reference point
+   lies within the CameraHAL constructor. This implemetation
+   will also dump the abosolute timestamp, which is useful when
+   post calculation is done with data coming from the upper
+   layers (Camera application etc.)
+
+   @param str - log message
+   @return none
+
+ */
+void CameraHal::PPM(const char* str){
+    struct timeval ppm;
+
+    unsigned long long elapsed, absolute;
+    gettimeofday(&ppm, NULL);
+    elapsed = ppm.tv_sec - ppm_start.tv_sec;
+    elapsed *= 1000000;
+    elapsed += ppm.tv_usec - ppm_start.tv_usec;
+    absolute = ppm.tv_sec;
+    absolute *= 1000;
+    absolute += ppm.tv_usec /1000;
+
+    LOGD("PPM: %s :%llu.%llu ms : %llu ms", str, ( elapsed /1000 ), ( elapsed % 1000 ), absolute);
+}
+
+#endif
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+/**
+   @brief PPM instrumentation
+
+   Calculates and dumps the elapsed time using 'ppm_first' as
+   reference.
+
+   @param str - log message
+   @return none
+
+ */
+void CameraHal::PPM(const char* str, struct timeval* ppm_first, ...){
+    char temp_str[256];
+    struct timeval ppm;
+    unsigned long long absolute;
+    va_list args;
+
+    va_start(args, ppm_first);
+    vsprintf(temp_str, str, args);
+    gettimeofday(&ppm, NULL);
+    absolute = ppm.tv_sec;
+    absolute *= 1000;
+    absolute += ppm.tv_usec /1000;
+    ppm.tv_sec = ppm.tv_sec - ppm_first->tv_sec;
+    ppm.tv_sec = ppm.tv_sec * 1000000;
+    ppm.tv_sec = ppm.tv_sec + ppm.tv_usec - ppm_first->tv_usec;
+
+    LOGD("PPM: %s :%ld.%ld ms :  %llu ms", temp_str, ( ppm.tv_sec /1000 ), ( ppm.tv_sec % 1000 ), absolute);
+
+    va_end(args);
+}
+
+#endif
+
+};
+
+
diff --git a/camera/CameraHalUtilClasses.cpp b/camera/CameraHalUtilClasses.cpp
new file mode 100644
index 0000000..84eea38
--- /dev/null
+++ b/camera/CameraHalUtilClasses.cpp
@@ -0,0 +1,273 @@
+/*

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

+ *

+ * 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.

+ */

+

+/**

+* @file CameraHalUtilClasses.cpp

+*

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

+*

+*/

+

+#define LOG_TAG "CameraHAL"

+

+

+#include "CameraHal.h"

+

+namespace android {

+

+/*--------------------FrameProvider Class STARTS here-----------------------------*/

+

+int FrameProvider::enableFrameNotification(int32_t frameTypes)

+{

+    LOG_FUNCTION_NAME;

+    status_t ret = NO_ERROR;

+

+    ///Enable the frame notification to CameraAdapter (which implements FrameNotifier interface)

+    mFrameNotifier->enableMsgType(frameTypes<<MessageNotifier::FRAME_BIT_FIELD_POSITION

+                                    , mFrameCallback

+                                    , NULL

+                                    , mCookie

+                                    );

+

+    LOG_FUNCTION_NAME_EXIT;

+    return ret;

+}

+

+int FrameProvider::disableFrameNotification(int32_t frameTypes)

+{

+    LOG_FUNCTION_NAME;

+    status_t ret = NO_ERROR;

+

+    mFrameNotifier->disableMsgType(frameTypes<<MessageNotifier::FRAME_BIT_FIELD_POSITION

+                                    , mCookie

+                                    );

+

+    LOG_FUNCTION_NAME_EXIT;

+    return ret;

+}

+

+int FrameProvider::returnFrame(void *frameBuf, CameraFrame::FrameType frameType)

+{

+    status_t ret = NO_ERROR;

+

+    mFrameNotifier->returnFrame(frameBuf, frameType);

+

+    return ret;

+}

+

+

+/*--------------------FrameProvider Class ENDS here-----------------------------*/

+

+/*--------------------EventProvider Class STARTS here-----------------------------*/

+

+int EventProvider::enableEventNotification(int32_t frameTypes)

+{

+    LOG_FUNCTION_NAME;

+    status_t ret = NO_ERROR;

+

+    ///Enable the frame notification to CameraAdapter (which implements FrameNotifier interface)

+    mEventNotifier->enableMsgType(frameTypes<<MessageNotifier::EVENT_BIT_FIELD_POSITION

+                                    , NULL

+                                    , mEventCallback

+                                    , mCookie

+                                    );

+

+    LOG_FUNCTION_NAME_EXIT;

+    return ret;

+}

+

+int EventProvider::disableEventNotification(int32_t frameTypes)

+{

+    LOG_FUNCTION_NAME;

+    status_t ret = NO_ERROR;

+

+    mEventNotifier->disableMsgType(frameTypes<<MessageNotifier::FRAME_BIT_FIELD_POSITION

+                                    , mCookie

+                                    );

+

+    LOG_FUNCTION_NAME_EXIT;

+    return ret;

+}

+

+/*--------------------EventProvider Class ENDS here-----------------------------*/

+

+/*--------------------CameraArea Class STARTS here-----------------------------*/

+

+status_t CameraArea::transfrom(size_t width,

+                               size_t height,

+                               size_t &top,

+                               size_t &left,

+                               size_t &areaWidth,

+                               size_t &areaHeight)

+{

+    status_t ret = NO_ERROR;

+    size_t hRange, vRange;

+    double hScale, vScale;

+

+    LOG_FUNCTION_NAME

+

+    hRange = CameraArea::RIGHT - CameraArea::LEFT;

+    vRange = CameraArea::BOTTOM - CameraArea::TOP;

+    hScale = ( double ) width / ( double ) hRange;

+    vScale = ( double ) height / ( double ) vRange;

+

+    top = ( mTop + vRange / 2 ) * vScale;

+    left = ( mLeft + hRange / 2 ) * hScale;

+    areaHeight = ( mBottom + vRange / 2 ) * vScale;

+    areaHeight -= top;

+    areaWidth = ( mRight + hRange / 2) * hScale;

+    areaWidth -= left;

+

+    LOG_FUNCTION_NAME_EXIT

+

+    return ret;

+}

+

+status_t CameraArea::parseFocusArea(const char *area,

+                               size_t areaLength,

+                               Vector< sp<CameraArea> > &areas)

+{

+    status_t ret = NO_ERROR;

+    char *ctx;

+    char *pArea = NULL;

+    char *pStart = NULL;

+    char *pEnd = NULL;

+    const char *startToken = "(";

+    const char endToken = ')';

+    const char sep = ',';

+    ssize_t top, left, bottom, right, weight;

+    char *tmpBuffer = NULL;

+    sp<CameraArea> currentArea;

+

+    LOG_FUNCTION_NAME

+

+    if ( ( NULL == area ) ||

+         ( 0 >= areaLength ) )

+        {

+        return -EINVAL;

+        }

+

+    tmpBuffer = ( char * ) malloc(areaLength);

+    if ( NULL == tmpBuffer )

+        {

+        return -ENOMEM;

+        }

+

+    memcpy(tmpBuffer, area, areaLength);

+

+    pArea = strtok_r(tmpBuffer, startToken, &ctx);

+

+    do

+        {

+

+        pStart = pArea;

+        if ( NULL == pStart )

+            {

+            CAMHAL_LOGEA("Parsing of the left area coordinate failed!");

+            ret = -EINVAL;

+            break;

+            }

+        else

+            {

+            left = static_cast<ssize_t>(strtol(pStart, &pEnd, 10));

+            }

+

+        if ( sep != *pEnd )

+            {

+            CAMHAL_LOGEA("Parsing of the top area coordinate failed!");

+            ret = -EINVAL;

+            break;

+            }

+        else

+            {

+            top = static_cast<ssize_t>(strtol(pEnd+1, &pEnd, 10));

+            }

+

+        if ( sep != *pEnd )

+            {

+            CAMHAL_LOGEA("Parsing of the right area coordinate failed!");

+            ret = -EINVAL;

+            break;

+            }

+        else

+            {

+            right = static_cast<ssize_t>(strtol(pEnd+1, &pEnd, 10));

+            }

+

+        if ( sep != *pEnd )

+            {

+            CAMHAL_LOGEA("Parsing of the bottom area coordinate failed!");

+            ret = -EINVAL;

+            break;

+            }

+        else

+            {

+            bottom = static_cast<ssize_t>(strtol(pEnd+1, &pEnd, 10));

+            }

+

+        if ( sep != *pEnd )

+            {

+            CAMHAL_LOGEA("Parsing of the weight area coordinate failed!");

+            ret = -EINVAL;

+            break;

+            }

+        else

+            {

+            weight = static_cast<ssize_t>(strtol(pEnd+1, &pEnd, 10));

+            }

+

+        if ( endToken != *pEnd )

+            {

+            CAMHAL_LOGEA("Malformed area!");

+            ret = -EINVAL;

+            break;

+            }

+

+        currentArea = new CameraArea(top, left, bottom, right, weight);

+        CAMHAL_LOGDB("Area parsed [%dx%d, %dx%d] %d",

+                     ( int ) top,

+                     ( int ) left,

+                     ( int ) bottom,

+                     ( int ) right,

+                     ( int )weight);

+        if ( NULL != currentArea.get() )

+            {

+            areas.add(currentArea);

+            }

+        else

+            {

+            ret = -ENOMEM;

+            break;

+            }

+

+        pArea = strtok_r(NULL, startToken, &ctx);

+

+        }

+    while ( NULL != pArea );

+

+    if ( NULL != tmpBuffer )

+        {

+        free(tmpBuffer);

+        }

+

+    LOG_FUNCTION_NAME_EXIT

+

+    return ret;

+}

+

+/*--------------------CameraArea Class ENDS here-----------------------------*/

+

+};

diff --git a/camera/CameraHal_Module.cpp b/camera/CameraHal_Module.cpp
new file mode 100644
index 0000000..cf3ec60
--- /dev/null
+++ b/camera/CameraHal_Module.cpp
@@ -0,0 +1,676 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file CameraHal.cpp
+*
+* This file maps the Camera Hardware Interface to V4L2.
+*
+*/
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "CameraProperties.h"
+#include "TICameraParameters.h"
+
+
+static android::CameraProperties gCameraProperties;
+static android::CameraHal* gCameraHals[MAX_CAMERAS_SUPPORTED];
+
+static int camera_device_open(const hw_module_t* module, const char* name,
+                hw_device_t** device);
+static int camera_device_close(hw_device_t* device);
+static int camera_get_number_of_cameras(void);
+static int camera_get_camera_info(int camera_id, struct camera_info *info);
+
+static struct hw_module_methods_t camera_module_methods = {
+        open: camera_device_open
+};
+
+camera_module_t HAL_MODULE_INFO_SYM = {
+    common: {
+         tag: HARDWARE_MODULE_TAG,
+         version_major: 1,
+         version_minor: 0,
+         id: CAMERA_HARDWARE_MODULE_ID,
+         name: "TI OMAP CameraHal Module",
+         author: "TI",
+         methods: &camera_module_methods,
+         dso: NULL, /* remove compilation warnings */
+         reserved: {0}, /* remove compilation warnings */
+    },
+    get_number_of_cameras: camera_get_number_of_cameras,
+    get_camera_info: camera_get_camera_info,
+};
+
+typedef struct ti_camera_device {
+    camera_device_t base;
+    /* TI specific "private" data can go here (base.priv) */
+    int cameraid;
+} ti_camera_device_t;
+
+
+/*******************************************************************
+ * implementation of camera_device_ops functions
+ *******************************************************************/
+
+int camera_set_preview_window(struct camera_device * device,
+        struct preview_stream_ops *window)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->setPreviewWindow(window);
+
+    return rv;
+}
+
+void camera_set_callbacks(struct camera_device * device,
+        camera_notify_callback notify_cb,
+        camera_data_callback data_cb,
+        camera_data_timestamp_callback data_cb_timestamp,
+        camera_request_memory get_memory,
+        void *user)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    gCameraHals[ti_dev->cameraid]->setCallbacks(notify_cb, data_cb, data_cb_timestamp, get_memory, user);
+}
+
+void camera_enable_msg_type(struct camera_device * device, int32_t msg_type)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    gCameraHals[ti_dev->cameraid]->enableMsgType(msg_type);
+}
+
+void camera_disable_msg_type(struct camera_device * device, int32_t msg_type)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    gCameraHals[ti_dev->cameraid]->disableMsgType(msg_type);
+}
+
+int camera_msg_type_enabled(struct camera_device * device, int32_t msg_type)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return 0;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    return gCameraHals[ti_dev->cameraid]->msgTypeEnabled(msg_type);
+}
+
+int camera_start_preview(struct camera_device * device)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->startPreview();
+
+    return rv;
+}
+
+void camera_stop_preview(struct camera_device * device)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    gCameraHals[ti_dev->cameraid]->stopPreview();
+}
+
+int camera_preview_enabled(struct camera_device * device)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->previewEnabled();
+    return rv;
+}
+
+int camera_store_meta_data_in_buffers(struct camera_device * device, int enable)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    //  TODO: meta data buffer not current supported
+    rv = gCameraHals[ti_dev->cameraid]->storeMetaDataInBuffers(enable);
+    return rv;
+    //return enable ? android::INVALID_OPERATION: android::OK;
+}
+
+int camera_start_recording(struct camera_device * device)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->startRecording();
+    return rv;
+}
+
+void camera_stop_recording(struct camera_device * device)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    gCameraHals[ti_dev->cameraid]->stopRecording();
+}
+
+int camera_recording_enabled(struct camera_device * device)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->recordingEnabled();
+    return rv;
+}
+
+void camera_release_recording_frame(struct camera_device * device,
+                const void *opaque)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    gCameraHals[ti_dev->cameraid]->releaseRecordingFrame(opaque);
+}
+
+int camera_auto_focus(struct camera_device * device)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->autoFocus();
+    return rv;
+}
+
+int camera_cancel_auto_focus(struct camera_device * device)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->cancelAutoFocus();
+    return rv;
+}
+
+int camera_take_picture(struct camera_device * device)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->takePicture();
+    return rv;
+}
+
+int camera_cancel_picture(struct camera_device * device)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->cancelPicture();
+    return rv;
+}
+
+int camera_set_parameters(struct camera_device * device, const char *params)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->setParameters(params);
+    return rv;
+}
+
+char* camera_get_parameters(struct camera_device * device)
+{
+    char* param = NULL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return NULL;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    param = gCameraHals[ti_dev->cameraid]->getParameters();
+
+    return param;
+}
+
+static void camera_put_parameters(struct camera_device *device, char *parms)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    gCameraHals[ti_dev->cameraid]->putParameters(parms);
+}
+
+int camera_send_command(struct camera_device * device,
+            int32_t cmd, int32_t arg1, int32_t arg2)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->sendCommand(cmd, arg1, arg2);
+    return rv;
+}
+
+void camera_release(struct camera_device * device)
+{
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if(!device)
+        return;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    gCameraHals[ti_dev->cameraid]->release();
+}
+
+int camera_dump(struct camera_device * device, int fd)
+{
+    int rv = -EINVAL;
+    ti_camera_device_t* ti_dev = NULL;
+
+    if(!device)
+        return rv;
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    rv = gCameraHals[ti_dev->cameraid]->dump(fd);
+    return rv;
+}
+
+extern "C" void heaptracker_free_leaked_memory(void);
+
+int camera_device_close(hw_device_t* device)
+{
+    int ret = 0;
+    ti_camera_device_t* ti_dev = NULL;
+
+    LOGV("%s", __FUNCTION__);
+
+    if (!device) {
+        ret = -EINVAL;
+        goto done;
+    }
+
+    ti_dev = (ti_camera_device_t*) device;
+
+    if (gCameraHals[ti_dev->cameraid]) {
+        delete gCameraHals[ti_dev->cameraid];
+        gCameraHals[ti_dev->cameraid] = NULL;
+    }
+
+    if (ti_dev->base.ops) {
+        free(ti_dev->base.ops);
+    }
+    free(ti_dev);
+
+done:
+#ifdef HEAPTRACKER
+    heaptracker_free_leaked_memory();
+#endif
+    return ret;
+}
+
+/*******************************************************************
+ * implementation of camera_module functions
+ *******************************************************************/
+
+/* open device handle to one of the cameras
+ *
+ * assume camera service will keep singleton of each camera
+ * so this function will always only be called once per camera instance
+ */
+
+int camera_device_open(const hw_module_t* module, const char* name,
+                hw_device_t** device)
+{
+    int rv = -EINVAL;
+    int num_cameras = 0;
+    int cameraid;
+    ti_camera_device_t* camera_device = NULL;
+    camera_device_ops_t* camera_ops = NULL;
+    android::CameraHal* camera = NULL;
+    android::CameraProperties::Properties* properties = NULL;
+
+    LOGI("camera_device open");
+
+    if (name != NULL) {
+        cameraid = atoi(name);
+        num_cameras = gCameraProperties.camerasSupported();
+
+        if(cameraid > num_cameras)
+        {
+            LOGE("camera service provided cameraid out of bounds, "
+                    "cameraid = %d, num supported = %d",
+                    cameraid, num_cameras);
+            goto fail;
+        }
+
+        camera_device = (ti_camera_device_t*)malloc(sizeof(*camera_device));
+        if(!camera_device)
+        {
+            LOGE("camera_device allocation fail");
+            rv = -ENOMEM;
+            goto fail;
+        }
+
+        camera_ops = (camera_device_ops_t*)malloc(sizeof(*camera_ops));
+        if(!camera_ops)
+        {
+            LOGE("camera_ops allocation fail");
+            rv = -ENOMEM;
+            goto fail;
+        }
+
+        memset(camera_device, 0, sizeof(*camera_device));
+        memset(camera_ops, 0, sizeof(*camera_ops));
+
+        camera_device->base.common.tag = HARDWARE_DEVICE_TAG;
+        camera_device->base.common.version = 0;
+        camera_device->base.common.module = (hw_module_t *)(module);
+        camera_device->base.common.close = camera_device_close;
+        camera_device->base.ops = camera_ops;
+
+        camera_ops->set_preview_window = camera_set_preview_window;
+        camera_ops->set_callbacks = camera_set_callbacks;
+        camera_ops->enable_msg_type = camera_enable_msg_type;
+        camera_ops->disable_msg_type = camera_disable_msg_type;
+        camera_ops->msg_type_enabled = camera_msg_type_enabled;
+        camera_ops->start_preview = camera_start_preview;
+        camera_ops->stop_preview = camera_stop_preview;
+        camera_ops->preview_enabled = camera_preview_enabled;
+        camera_ops->store_meta_data_in_buffers = camera_store_meta_data_in_buffers;
+        camera_ops->start_recording = camera_start_recording;
+        camera_ops->stop_recording = camera_stop_recording;
+        camera_ops->recording_enabled = camera_recording_enabled;
+        camera_ops->release_recording_frame = camera_release_recording_frame;
+        camera_ops->auto_focus = camera_auto_focus;
+        camera_ops->cancel_auto_focus = camera_cancel_auto_focus;
+        camera_ops->take_picture = camera_take_picture;
+        camera_ops->cancel_picture = camera_cancel_picture;
+        camera_ops->set_parameters = camera_set_parameters;
+        camera_ops->get_parameters = camera_get_parameters;
+        camera_ops->put_parameters = camera_put_parameters;
+        camera_ops->send_command = camera_send_command;
+        camera_ops->release = camera_release;
+        camera_ops->dump = camera_dump;
+
+        *device = &camera_device->base.common;
+
+        // -------- TI specific stuff --------
+
+        camera_device->cameraid = cameraid;
+
+        if(gCameraProperties.getProperties(cameraid, &properties) < 0)
+        {
+            LOGE("Couldn't get camera properties");
+            rv = -ENOMEM;
+            goto fail;
+        }
+
+        camera = new android::CameraHal(cameraid);
+
+        if(!camera)
+        {
+            LOGE("Couldn't create instance of CameraHal class");
+            rv = -ENOMEM;
+            goto fail;
+        }
+
+        if(properties && (camera->initialize(properties) != android::NO_ERROR))
+        {
+            LOGE("Couldn't initialize camera instance");
+            rv = -ENODEV;
+            goto fail;
+        }
+
+        gCameraHals[cameraid] = camera;
+    }
+
+    return rv;
+
+fail:
+
+    if(camera_device)
+        free(camera_device);
+    if(camera_ops)
+        free(camera_ops);
+    if(camera)
+        delete camera;
+
+    return rv;
+}
+
+int camera_get_number_of_cameras(void)
+{
+    int num_cameras = MAX_CAMERAS_SUPPORTED;
+
+    // TODO(XXX): Ducati is not loaded yet when camera service gets here
+    //  Lets revisit this later to see if we can somehow get this working
+#if 0
+    // this going to be the first call from camera service
+    // initialize camera properties here...
+    if(gCameraProperties.initialize() != android::NO_ERROR)
+    {
+        CAMHAL_LOGEA("Unable to create or initialize CameraProperties");
+        return NULL;
+    }
+
+    num_cameras = gCameraProperties.camerasSupported();
+#endif
+
+    return num_cameras;
+}
+
+int camera_get_camera_info(int camera_id, struct camera_info *info)
+{
+    int rv = 0;
+    int face_value = CAMERA_FACING_BACK;
+    int orientation = 0;
+    const char *valstr = NULL;
+    android::CameraProperties::Properties* properties = NULL;
+
+    // this going to be the first call from camera service
+    // initialize camera properties here...
+    if(gCameraProperties.initialize() != android::NO_ERROR)
+    {
+        CAMHAL_LOGEA("Unable to create or initialize CameraProperties");
+        return NULL;
+    }
+
+    //Get camera properties for camera index
+    if(gCameraProperties.getProperties(camera_id, &properties) < 0)
+    {
+        LOGE("Couldn't get camera properties");
+        rv = -EINVAL;
+        goto end;
+    }
+
+    if(properties)
+    {
+        valstr = properties->get(android::CameraProperties::FACING_INDEX);
+        if(valstr != NULL)
+        {
+            if (strcmp(valstr, (const char *) android::TICameraParameters::FACING_FRONT) == 0)
+            {
+                face_value = CAMERA_FACING_FRONT;
+            }
+            else if (strcmp(valstr, (const char *) android::TICameraParameters::FACING_BACK) == 0)
+            {
+                face_value = CAMERA_FACING_BACK;
+            }
+         }
+
+         valstr = properties->get(android::CameraProperties::ORIENTATION_INDEX);
+         if(valstr != NULL)
+         {
+             orientation = atoi(valstr);
+         }
+    }
+    else
+    {
+        CAMHAL_LOGEB("getProperties() returned a NULL property set for Camera id %d", camera_id);
+    }
+
+    info->facing = face_value;
+    info->orientation = orientation;
+
+end:
+    return rv;
+}
+
+
+
+
+
diff --git a/camera/CameraParameters.cpp b/camera/CameraParameters.cpp
new file mode 100644
index 0000000..f19a0fe
--- /dev/null
+++ b/camera/CameraParameters.cpp
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file CameraProperties.cpp
+*
+* This file maps the CameraHardwareInterface to the Camera interfaces on OMAP4 (mainly OMX).
+*
+*/
+
+#include "CameraHal.h"
+#include "CameraProperties.h"
+
+namespace android {
+
+const char CameraProperties::INVALID[]="prop-invalid-key";
+const char CameraProperties::CAMERA_NAME[]="prop-camera-name";
+const char CameraProperties::CAMERA_SENSOR_INDEX[]="prop-sensor-index";
+const char CameraProperties::ORIENTATION_INDEX[]="prop-orientation";
+const char CameraProperties::FACING_INDEX[]="prop-facing";
+const char CameraProperties::S3D_SUPPORTED[]="prop-s3d-supported";
+const char CameraProperties::SUPPORTED_PREVIEW_SIZES[] = "prop-preview-size-values";
+const char CameraProperties::SUPPORTED_PREVIEW_FORMATS[] = "prop-preview-format-values";
+const char CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES[] = "prop-preview-frame-rate-values";
+const char CameraProperties::SUPPORTED_PICTURE_SIZES[] = "prop-picture-size-values";
+const char CameraProperties::SUPPORTED_PICTURE_FORMATS[] = "prop-picture-format-values";
+const char CameraProperties::SUPPORTED_THUMBNAIL_SIZES[] = "prop-jpeg-thumbnail-size-values";
+const char CameraProperties::SUPPORTED_WHITE_BALANCE[] = "prop-whitebalance-values";
+const char CameraProperties::SUPPORTED_EFFECTS[] = "prop-effect-values";
+const char CameraProperties::SUPPORTED_ANTIBANDING[] = "prop-antibanding-values";
+const char CameraProperties::SUPPORTED_EXPOSURE_MODES[] = "prop-exposure-mode-values";
+const char CameraProperties::SUPPORTED_EV_MAX[] = "prop-ev-compensation-max";
+const char CameraProperties::SUPPORTED_EV_MIN[] = "prop-ev-compensation-min";
+const char CameraProperties::SUPPORTED_EV_STEP[] = "prop-ev-compensation-step";
+const char CameraProperties::SUPPORTED_ISO_VALUES[] = "prop-iso-mode-values";
+const char CameraProperties::SUPPORTED_SCENE_MODES[] = "prop-scene-mode-values";
+const char CameraProperties::SUPPORTED_FLASH_MODES[] = "prop-flash-mode-values";
+const char CameraProperties::SUPPORTED_FOCUS_MODES[] = "prop-focus-mode-values";
+const char CameraProperties::REQUIRED_PREVIEW_BUFS[] = "prop-required-preview-bufs";
+const char CameraProperties::REQUIRED_IMAGE_BUFS[] = "prop-required-image-bufs";
+const char CameraProperties::SUPPORTED_ZOOM_RATIOS[] = "prop-zoom-ratios";
+const char CameraProperties::SUPPORTED_ZOOM_STAGES[] = "prop-zoom-stages";
+const char CameraProperties::SUPPORTED_IPP_MODES[] = "prop-ipp-values";
+const char CameraProperties::SMOOTH_ZOOM_SUPPORTED[] = "prop-smooth-zoom-supported";
+const char CameraProperties::ZOOM_SUPPORTED[] = "prop-zoom-supported";
+const char CameraProperties::PREVIEW_SIZE[] = "prop-preview-size-default";
+const char CameraProperties::PREVIEW_FORMAT[] = "prop-preview-format-default";
+const char CameraProperties::PREVIEW_FRAME_RATE[] = "prop-preview-frame-rate-default";
+const char CameraProperties::ZOOM[] = "prop-zoom-default";
+const char CameraProperties::PICTURE_SIZE[] = "prop-picture-size-default";
+const char CameraProperties::PICTURE_FORMAT[] = "prop-picture-format-default";
+const char CameraProperties::JPEG_THUMBNAIL_SIZE[] = "prop-jpeg-thumbnail-size-default";
+const char CameraProperties::WHITEBALANCE[] = "prop-whitebalance-default";
+const char CameraProperties::EFFECT[] = "prop-effect-default";
+const char CameraProperties::ANTIBANDING[] = "prop-antibanding-default";
+const char CameraProperties::EXPOSURE_MODE[] = "prop-exposure-mode-default";
+const char CameraProperties::EV_COMPENSATION[] = "prop-ev-compensation-default";
+const char CameraProperties::ISO_MODE[] = "prop-iso-mode-default";
+const char CameraProperties::FOCUS_MODE[] = "prop-focus-mode-default";
+const char CameraProperties::SCENE_MODE[] = "prop-scene-mode-default";
+const char CameraProperties::FLASH_MODE[] = "prop-flash-mode-default";
+const char CameraProperties::JPEG_QUALITY[] = "prop-jpeg-quality-default";
+const char CameraProperties::CONTRAST[] = "prop-contrast-default";
+const char CameraProperties::BRIGHTNESS[] = "prop-brightness-default";
+const char CameraProperties::SATURATION[] = "prop-saturation-default";
+const char CameraProperties::SHARPNESS[] = "prop-sharpness-default";
+const char CameraProperties::IPP[] = "prop-ipp-default";
+const char CameraProperties::S3D2D_PREVIEW[] = "prop-s3d2d-preview";
+const char CameraProperties::S3D2D_PREVIEW_MODES[] = "prop-s3d2d-preview-values";
+const char CameraProperties::AUTOCONVERGENCE[] = "prop-auto-convergence";
+const char CameraProperties::AUTOCONVERGENCE_MODE[] = "prop-auto-convergence-mode";
+const char CameraProperties::MANUALCONVERGENCE_VALUES[] = "prop-manual-convergence-values";
+const char CameraProperties::VSTAB[] = "prop-vstab-default";
+const char CameraProperties::VSTAB_VALUES[] = "prop-vstab-values";
+const char CameraProperties::REVISION[] = "prop-revision";
+const char CameraProperties::FOCAL_LENGTH[] = "prop-focal-length";
+const char CameraProperties::HOR_ANGLE[] = "prop-horizontal-angle";
+const char CameraProperties::VER_ANGLE[] = "prop-vertical-angle";
+const char CameraProperties::FRAMERATE_RANGE[]="prop-framerate-range-default";
+const char CameraProperties::FRAMERATE_RANGE_SUPPORTED[]="prop-framerate-range-values";
+const char CameraProperties::SENSOR_ORIENTATION[]= "sensor-orientation";
+const char CameraProperties::SENSOR_ORIENTATION_VALUES[]= "sensor-orientation-values";
+const char CameraProperties::EXIF_MAKE[] = "prop-exif-make";
+const char CameraProperties::EXIF_MODEL[] = "prop-exif-model";
+const char CameraProperties::JPEG_THUMBNAIL_QUALITY[] = "prop-jpeg-thumbnail-quality-default";
+const char CameraProperties::MAX_FOCUS_AREAS[] = "prop-max-focus-areas";
+const char CameraProperties::MAX_FD_HW_FACES[] = "prop-max-fd-hw-faces";
+const char CameraProperties::MAX_FD_SW_FACES[] = "prop-max-fd-sw-faces";
+const char CameraProperties::AUTO_EXPOSURE_LOCK[] = "prop-auto-exposure-lock";
+const char CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED[] = "prop-auto-exposure-lock-supported";
+const char CameraProperties::AUTO_WHITEBALANCE_LOCK[] = "prop-auto-whitebalance-lock";
+const char CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED[] = "prop-auto-whitebalance-lock-supported";
+const char CameraProperties::MAX_NUM_METERING_AREAS[] = "prop-max-num-metering-areas";
+const char CameraProperties::METERING_AREAS[] = "prop-metering-areas";
+
+const char CameraProperties::DEFAULT_VALUE[] = "";
+
+const char CameraProperties::PARAMS_DELIMITER []= ",";
+
+// Returns the properties class for a specific Camera
+// Each value is indexed by the CameraProperties::CameraPropertyIndex enum
+int CameraProperties::getProperties(int cameraIndex, CameraProperties::Properties** properties)
+{
+    LOG_FUNCTION_NAME;
+
+    if((unsigned int)cameraIndex >= mCamerasSupported)
+    {
+        LOG_FUNCTION_NAME_EXIT;
+        return -EINVAL;
+    }
+
+    *properties = mCameraProps+cameraIndex;
+
+    LOG_FUNCTION_NAME_EXIT;
+    return 0;
+}
+
+ssize_t CameraProperties::Properties::set(const char *prop, const char *value)
+{
+    if(!prop)
+        return -EINVAL;
+    if(!value)
+        value = DEFAULT_VALUE;
+
+    return mProperties->replaceValueFor(String8(prop), String8(value));
+}
+
+ssize_t CameraProperties::Properties::set(const char *prop, int value)
+{
+    char s_val[30];
+
+    sprintf(s_val, "%d", value);
+
+    return set(prop, s_val);
+}
+
+const char* CameraProperties::Properties::get(const char * prop)
+{
+    String8 value = mProperties->valueFor(String8(prop));
+    return value.string();
+}
+
+void CameraProperties::Properties::dump()
+{
+    for (size_t i = 0; i < mProperties->size(); i++)
+    {
+        CAMHAL_LOGDB("%s = %s\n",
+                        mProperties->keyAt(i).string(),
+                        mProperties->valueAt(i).string());
+    }
+}
+
+const char* CameraProperties::Properties::keyAt(unsigned int index)
+{
+    if(index < mProperties->size())
+    {
+        return mProperties->keyAt(index).string();
+    }
+    return NULL;
+}
+
+const char* CameraProperties::Properties::valueAt(unsigned int index)
+{
+    if(index < mProperties->size())
+    {
+        return mProperties->valueAt(index).string();
+    }
+    return NULL;
+}
+
+};
diff --git a/camera/CameraProperties.cpp b/camera/CameraProperties.cpp
new file mode 100644
index 0000000..47b2177
--- /dev/null
+++ b/camera/CameraProperties.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file CameraProperties.cpp
+*
+* This file maps the CameraHardwareInterface to the Camera interfaces on OMAP4 (mainly OMX).
+*
+*/
+
+//#include "CameraHal.h"
+#include "DebugUtils.h"
+#include "CameraProperties.h"
+
+#define CAMERA_ROOT         "CameraRoot"
+#define CAMERA_INSTANCE     "CameraInstance"
+
+namespace android {
+
+// lower entries have higher priority
+static const char* g_camera_adapters[] = {
+#ifdef OMAP4_SUPPORT_OMX_CAMERA_ADAPTER
+    "libomxcameraadapter.so",
+#endif
+#ifdef OMAP4_SUPPORT_USB_CAMERA_ADAPTER
+    "libusbcameraadapter.so"
+#endif
+};
+
+/*********************************************************
+ CameraProperties - public function implemetation
+**********************************************************/
+
+CameraProperties::CameraProperties() : mCamerasSupported(0)
+{
+    LOG_FUNCTION_NAME;
+
+    mCamerasSupported = 0;
+    mInitialized = 0;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+CameraProperties::~CameraProperties()
+{
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+// Initializes the CameraProperties class
+status_t CameraProperties::initialize()
+{
+    LOG_FUNCTION_NAME;
+
+    status_t ret;
+
+    if(mInitialized)
+        return NO_ERROR;
+
+    ret = loadProperties();
+
+    mInitialized = 1;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+extern "C" int CameraAdapter_Capabilities(CameraProperties::Properties* properties_array,
+                                          const unsigned int starting_camera,
+                                          const unsigned int max_camera);
+
+///Loads all the Camera related properties
+status_t CameraProperties::loadProperties()
+{
+    LOG_FUNCTION_NAME;
+
+    status_t ret = NO_ERROR;
+
+    // adapter updates capabilities and we update camera count
+    mCamerasSupported = CameraAdapter_Capabilities(mCameraProps, mCamerasSupported, MAX_CAMERAS_SUPPORTED);
+
+    if((int)mCamerasSupported < 0) {
+        LOGE("error while getting capabilities");
+        ret = UNKNOWN_ERROR;
+    } else if (mCamerasSupported > MAX_CAMERAS_SUPPORTED) {
+        LOGE("returned too many adapaters");
+        ret = UNKNOWN_ERROR;
+    } else {
+        LOGE("num_cameras = %d", mCamerasSupported);
+
+        for (unsigned int i = 0; i < mCamerasSupported; i++) {
+            mCameraProps[i].set(CAMERA_SENSOR_INDEX, i);
+            mCameraProps[i].dump();
+        }
+    }
+
+    LOGV("mCamerasSupported = %d", mCamerasSupported);
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+// Returns the number of Cameras found
+int CameraProperties::camerasSupported()
+{
+    LOG_FUNCTION_NAME;
+    return mCamerasSupported;
+}
+
+};
diff --git a/camera/MemoryManager.cpp b/camera/MemoryManager.cpp
new file mode 100644
index 0000000..f86b263
--- /dev/null
+++ b/camera/MemoryManager.cpp
@@ -0,0 +1,284 @@
+/*

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

+ *

+ * 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 "CameraHal.h"

+#include "TICameraParameters.h"

+

+extern "C" {

+

+#include "memmgr.h"

+#include "tiler.h"

+//#include <timm_osal_interfaces.h>

+//#include <timm_osal_trace.h>

+

+

+};

+

+namespace android {

+

+///@todo Move these constants to a common header file, preferably in tiler.h

+#define STRIDE_8BIT (4 * 1024)

+#define STRIDE_16BIT (4 * 1024)

+

+#define ALLOCATION_2D 2

+

+///Utility Macro Declarations

+#define ZERO_OUT_ARR(a,b) { for(unsigned int i=0;i<b;i++) a[i]=NULL;}

+

+#define ZERO_OUT_STRUCT(a, b) memset(a, 0, sizeof(b));

+

+/*--------------------MemoryManager Class STARTS here-----------------------------*/

+void* MemoryManager::allocateBuffer(int width, int height, const char* format, int &bytes, int numBufs)

+{

+    LOG_FUNCTION_NAME;

+    ///We allocate numBufs+1 because the last entry will be marked NULL to indicate end of array, which is used when freeing

+    ///the buffers

+    const uint numArrayEntriesC = (uint)(numBufs+1);

+

+    MemAllocBlock *tMemBlock;

+

+

+    ///Allocate a buffer array

+    uint32_t *bufsArr = new uint32_t[numArrayEntriesC];

+    if(!bufsArr)

+        {

+        CAMHAL_LOGEB("Allocation failed when creating buffers array of %d uint32_t elements", numArrayEntriesC);

+        LOG_FUNCTION_NAME_EXIT;

+        return NULL;

+        }

+

+    ///Initialize the array with zeros - this will help us while freeing the array in case of error

+    ///If a value of an array element is NULL, it means we didnt allocate it

+    ZERO_OUT_ARR(bufsArr, numArrayEntriesC);

+

+    ///If the bytes field is not zero, it means it is a 1-D tiler buffer request (possibly for image capture bit stream buffer)

+    if(bytes!=0)

+        {

+        ///MemAllocBlock is the structure that describes the buffer alloc request to MemMgr

+        tMemBlock = (MemAllocBlock*)malloc(sizeof(MemAllocBlock));

+

+        if(!tMemBlock)

+            {

+            delete [] bufsArr;

+            return NULL;

+            }

+

+        ZERO_OUT_STRUCT(tMemBlock, MemAllocBlock );

+

+        ///1D buffers

+        for (int i = 0; i < numBufs; i++)

+            {

+            tMemBlock->dim.len = bytes;

+            tMemBlock->pixelFormat = PIXEL_FMT_PAGE;

+            tMemBlock->stride = 0;

+            CAMHAL_LOGDB("requested bytes = %d", bytes);

+            CAMHAL_LOGDB("tMemBlock.dim.len = %d", tMemBlock->dim.len);

+            bufsArr[i] = (uint32_t)MemMgr_Alloc(tMemBlock, 1);

+            if(!bufsArr[i])

+                {

+                LOGE("Buffer allocation failed for iteration %d", i);

+                goto error;

+                }

+            else

+                {

+                CAMHAL_LOGDB("Allocated Tiler PAGED mode buffer address[%x]", bufsArr[i]);

+                }

+            }

+

+        }

+    else ///If bytes is not zero, then it is a 2-D tiler buffer request

+        {

+        ///2D buffers

+        ///MemAllocBlock is the structure that describes the buffer alloc request to MemMgr

+        tMemBlock = (MemAllocBlock*)malloc(sizeof(MemAllocBlock)*ALLOCATION_2D);

+

+        if(!tMemBlock)

+            {

+            delete [] bufsArr;

+            return NULL;

+            }

+

+        memset(tMemBlock, 0, sizeof(MemAllocBlock)*ALLOCATION_2D);

+

+        for (int i = 0; i < numBufs; i++)

+            {

+            int numAllocs = 1;

+            pixel_fmt_t pixelFormat[ALLOCATION_2D];

+            int stride[ALLOCATION_2D];

+

+            if(!strcmp(format,(const char *) CameraParameters::PIXEL_FORMAT_YUV422I))

+                {

+                ///YUV422I format

+                pixelFormat[0] = PIXEL_FMT_16BIT;

+                stride[0] = STRIDE_16BIT;

+                numAllocs = 1;

+                }

+            else if(!strcmp(format,(const char *) CameraParameters::PIXEL_FORMAT_YUV420SP))

+                {

+                ///YUV420 NV12 format

+                pixelFormat[0] = PIXEL_FMT_8BIT;

+                pixelFormat[1] = PIXEL_FMT_16BIT;

+                stride[0] = STRIDE_8BIT;

+                stride[1] = STRIDE_16BIT;

+                numAllocs = 2;

+                }

+            else if(!strcmp(format,(const char *) CameraParameters::PIXEL_FORMAT_RGB565))

+                {

+                ///RGB 565 format

+                pixelFormat[0] = PIXEL_FMT_16BIT;

+                stride[0] = STRIDE_16BIT;

+                numAllocs = 1;

+                }

+            else if(!strcmp(format,(const char *) TICameraParameters::PIXEL_FORMAT_RAW))

+                {

+                ///RAW format

+                pixelFormat[0] = PIXEL_FMT_16BIT;

+                stride[0] = STRIDE_16BIT;

+                numAllocs = 1;

+                }

+            else

+                {

+                ///By default assume YUV420 NV12 format

+                ///YUV420 NV12 format

+                pixelFormat[0] = PIXEL_FMT_8BIT;

+                pixelFormat[1] = PIXEL_FMT_16BIT;

+                stride[0] = STRIDE_8BIT;

+                stride[1] = STRIDE_16BIT;

+                numAllocs = 2;

+                }

+

+            for(int index=0;index<numAllocs;index++)

+                {

+                tMemBlock[index].pixelFormat = pixelFormat[index];

+                tMemBlock[index].stride = stride[index];

+                tMemBlock[index].dim.area.width=  width;/*width*/

+                tMemBlock[index].dim.area.height=  height;/*height*/

+                }

+

+            bufsArr[i] = (uint32_t)MemMgr_Alloc(tMemBlock, numAllocs);

+            if(!bufsArr[i])

+                {

+                CAMHAL_LOGEB("Buffer allocation failed for iteration %d", i);

+                goto error;

+                }

+            else

+                {

+                CAMHAL_LOGDB("Allocated Tiler PAGED mode buffer address[%x]", bufsArr[i]);

+                }

+            }

+

+        }

+

+        LOG_FUNCTION_NAME_EXIT;

+

+

+        ///Free the request structure before returning from the function

+        free(tMemBlock);

+

+        return (void*)bufsArr;

+

+    error:

+        LOGE("Freeing buffers already allocated after error occurred");

+        freeBuffer(bufsArr);

+        free(tMemBlock);

+

+        if ( NULL != mErrorNotifier.get() )

+            {

+            mErrorNotifier->errorNotify(-ENOMEM);

+            }

+

+        LOG_FUNCTION_NAME_EXIT;

+        return NULL;

+}

+

+//TODO: Get needed data to map tiler buffers

+//Return dummy data for now

+uint32_t * MemoryManager::getOffsets()

+{

+    LOG_FUNCTION_NAME;

+

+    LOG_FUNCTION_NAME_EXIT;

+

+    return NULL;

+}

+

+int MemoryManager::getFd()

+{

+    LOG_FUNCTION_NAME;

+

+    LOG_FUNCTION_NAME_EXIT;

+

+    return -1;

+}

+

+int MemoryManager::freeBuffer(void* buf)

+{

+    status_t ret = NO_ERROR;

+    LOG_FUNCTION_NAME;

+

+    uint32_t *bufEntry = (uint32_t*)buf;

+

+    if(!bufEntry)

+        {

+        CAMHAL_LOGEA("NULL pointer passed to freebuffer");

+        LOG_FUNCTION_NAME_EXIT;

+        return BAD_VALUE;

+        }

+

+    while(*bufEntry)

+        {

+        ret |= MemMgr_Free((void*)*bufEntry++);

+        }

+

+    ///@todo Check if this way of deleting array is correct, else use malloc/free

+    uint32_t * bufArr = (uint32_t*)buf;

+    delete [] bufArr;

+

+    LOG_FUNCTION_NAME_EXIT;

+    return ret;

+}

+

+status_t MemoryManager::setErrorHandler(ErrorNotifier *errorNotifier)

+{

+    status_t ret = NO_ERROR;

+

+    LOG_FUNCTION_NAME;

+

+    if ( NULL == errorNotifier )

+        {

+        CAMHAL_LOGEA("Invalid Error Notifier reference");

+        ret = -EINVAL;

+        }

+

+    if ( NO_ERROR == ret )

+        {

+        mErrorNotifier = errorNotifier;

+        }

+

+    LOG_FUNCTION_NAME_EXIT;

+

+    return ret;

+}

+

+};

+

+

+/*--------------------MemoryManager Class ENDS here-----------------------------*/

diff --git a/camera/OMXCameraAdapter/OMX3A.cpp b/camera/OMXCameraAdapter/OMX3A.cpp
new file mode 100644
index 0000000..1c347a2
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMX3A.cpp
@@ -0,0 +1,1083 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMX3A.cpp
+*
+* This file contains functionality for handling 3A configurations.
+*
+*/
+
+#undef LOG_TAG
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+#include "ErrorUtils.h"
+
+namespace android {
+
+status_t OMXCameraAdapter::setParameters3A(const CameraParameters &params,
+                                           BaseCameraAdapter::AdapterState state)
+{
+    status_t ret = NO_ERROR;
+    int mode = 0;
+    const char *str = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    str = params.get(TICameraParameters::KEY_EXPOSURE_MODE);
+    mode = getLUTvalue_HALtoOMX( str, ExpLUT);
+    if ( ( str != NULL ) && ( mParameters3A.Exposure != mode ) )
+        {
+        mParameters3A.Exposure = mode;
+        CAMHAL_LOGDB("Exposure mode %d", mode);
+        if ( 0 <= mParameters3A.Exposure )
+            {
+            mPending3Asettings |= SetExpMode;
+            }
+        }
+
+    str = params.get(CameraParameters::KEY_WHITE_BALANCE);
+    mode = getLUTvalue_HALtoOMX( str, WBalLUT);
+    if ( ( mFirstTimeInit || ( str != NULL ) ) && ( mode != mParameters3A.WhiteBallance ) )
+        {
+        mParameters3A.WhiteBallance = mode;
+        CAMHAL_LOGDB("Whitebalance mode %d", mode);
+        if ( 0 <= mParameters3A.WhiteBallance )
+            {
+            mPending3Asettings |= SetWhiteBallance;
+            }
+        }
+
+    if ( 0 <= params.getInt(TICameraParameters::KEY_CONTRAST) )
+        {
+        if ( mFirstTimeInit ||
+             ( (mParameters3A.Contrast  + CONTRAST_OFFSET) !=
+                     params.getInt(TICameraParameters::KEY_CONTRAST)) )
+            {
+            mParameters3A.Contrast = params.getInt(TICameraParameters::KEY_CONTRAST) - CONTRAST_OFFSET;
+            CAMHAL_LOGDB("Contrast %d", mParameters3A.Contrast);
+            mPending3Asettings |= SetContrast;
+            }
+        }
+
+    if ( 0 <= params.getInt(TICameraParameters::KEY_SHARPNESS) )
+        {
+        if ( mFirstTimeInit ||
+             ((mParameters3A.Sharpness + SHARPNESS_OFFSET) !=
+                     params.getInt(TICameraParameters::KEY_SHARPNESS)))
+            {
+            mParameters3A.Sharpness = params.getInt(TICameraParameters::KEY_SHARPNESS) - SHARPNESS_OFFSET;
+            CAMHAL_LOGDB("Sharpness %d", mParameters3A.Sharpness);
+            mPending3Asettings |= SetSharpness;
+            }
+        }
+
+    if ( 0 <= params.getInt(TICameraParameters::KEY_SATURATION) )
+        {
+        if ( mFirstTimeInit ||
+             ((mParameters3A.Saturation + SATURATION_OFFSET) !=
+                     params.getInt(TICameraParameters::KEY_SATURATION)) )
+            {
+            mParameters3A.Saturation = params.getInt(TICameraParameters::KEY_SATURATION) - SATURATION_OFFSET;
+            CAMHAL_LOGDB("Saturation %d", mParameters3A.Saturation);
+            mPending3Asettings |= SetSaturation;
+            }
+        }
+
+    if ( 0 <= params.getInt(TICameraParameters::KEY_BRIGHTNESS) )
+        {
+        if ( mFirstTimeInit ||
+             (( mParameters3A.Brightness !=
+                     ( unsigned int ) params.getInt(TICameraParameters::KEY_BRIGHTNESS))) )
+            {
+            mParameters3A.Brightness = (unsigned)params.getInt(TICameraParameters::KEY_BRIGHTNESS);
+            CAMHAL_LOGDB("Brightness %d", mParameters3A.Brightness);
+            mPending3Asettings |= SetBrightness;
+            }
+        }
+
+    str = params.get(CameraParameters::KEY_ANTIBANDING);
+    mode = getLUTvalue_HALtoOMX(str,FlickerLUT);
+    if ( mFirstTimeInit || ( ( str != NULL ) && ( mParameters3A.Flicker != mode ) ))
+        {
+        mParameters3A.Flicker = mode;
+        CAMHAL_LOGDB("Flicker %d", mParameters3A.Flicker);
+        if ( 0 <= mParameters3A.Flicker )
+            {
+            mPending3Asettings |= SetFlicker;
+            }
+        }
+
+    str = params.get(TICameraParameters::KEY_ISO);
+    mode = getLUTvalue_HALtoOMX(str, IsoLUT);
+    CAMHAL_LOGVB("ISO mode arrived in HAL : %s", str);
+    if ( mFirstTimeInit || (  ( str != NULL ) && ( mParameters3A.ISO != mode )) )
+        {
+        mParameters3A.ISO = mode;
+        CAMHAL_LOGDB("ISO %d", mParameters3A.ISO);
+        if ( 0 <= mParameters3A.ISO )
+            {
+            mPending3Asettings |= SetISO;
+            }
+        }
+
+    str = params.get(CameraParameters::KEY_FOCUS_MODE);
+    mode = getLUTvalue_HALtoOMX(str, FocusLUT);
+    if ( mFirstTimeInit || ( ( str != NULL ) && ( mParameters3A.Focus != mode ) ) )
+        {
+        //Apply focus mode immediatly only if  CAF  or Inifinity are selected
+        if ( ( mode == OMX_IMAGE_FocusControlAuto ) ||
+             ( mode == OMX_IMAGE_FocusControlAutoInfinity ) )
+            {
+            mPending3Asettings |= SetFocus;
+            mParameters3A.Focus = mode;
+            }
+        else if ( mParameters3A.Focus == OMX_IMAGE_FocusControlAuto )
+            {
+            //If we switch from CAF to something else, then disable CAF
+            mPending3Asettings |= SetFocus;
+            mParameters3A.Focus = OMX_IMAGE_FocusControlOff;
+            }
+
+        mParameters3A.Focus = mode;
+        CAMHAL_LOGDB("Focus %x", mParameters3A.Focus);
+        }
+
+    str = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION);
+    if ( mFirstTimeInit ||
+          (( str != NULL ) &&
+                  (mParameters3A.EVCompensation !=
+                          params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION))))
+        {
+        CAMHAL_LOGDB("Setting EV Compensation to %d",
+                     params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION));
+
+        mParameters3A.EVCompensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
+        mPending3Asettings |= SetEVCompensation;
+        }
+
+    str = params.get(CameraParameters::KEY_SCENE_MODE);
+    mode = getLUTvalue_HALtoOMX( str, SceneLUT);
+    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.SceneMode != mode )) )
+        {
+        if ( 0 <= mode )
+            {
+            mParameters3A.SceneMode = mode;
+            mPending3Asettings |= SetSceneMode;
+            }
+        else
+            {
+            mParameters3A.SceneMode = OMX_Manual;
+            }
+
+        CAMHAL_LOGDB("SceneMode %d", mParameters3A.SceneMode);
+        }
+
+    str = params.get(CameraParameters::KEY_FLASH_MODE);
+    mode = getLUTvalue_HALtoOMX( str, FlashLUT);
+    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.FlashMode != mode )) )
+        {
+        if ( 0 <= mode )
+            {
+            mParameters3A.FlashMode = mode;
+            mPending3Asettings |= SetFlash;
+            }
+        else
+            {
+            mParameters3A.FlashMode = OMX_Manual;
+            }
+        }
+
+    CAMHAL_LOGVB("Flash Setting %s", str);
+    CAMHAL_LOGVB("FlashMode %d", mParameters3A.FlashMode);
+
+    str = params.get(CameraParameters::KEY_EFFECT);
+    mode = getLUTvalue_HALtoOMX( str, EffLUT);
+    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.Effect != mode )) )
+        {
+        mParameters3A.Effect = mode;
+        CAMHAL_LOGDB("Effect %d", mParameters3A.Effect);
+        if ( 0 <= mParameters3A.Effect )
+            {
+            mPending3Asettings |= SetEffect;
+            }
+        }
+
+    str = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
+    if ( (str != NULL) && (!strcmp(str, "true")) )
+      {
+        OMX_BOOL lock = OMX_FALSE;
+        str = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
+        if ( (strcmp(str, "true")) == 0)
+          {
+            CAMHAL_LOGVA("Locking Exposure");
+            lock = OMX_TRUE;
+          }
+        else
+          {
+            CAMHAL_LOGVA("UnLocking Exposure");
+          }
+        if (mParameters3A.ExposureLock != lock)
+          {
+            mParameters3A.ExposureLock = lock;
+            CAMHAL_LOGDB("ExposureLock %d", lock);
+            mPending3Asettings |= SetExpLock;
+          }
+      }
+
+    str = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
+    if ( (str != NULL) && (!strcmp(str, "true")) )
+      {
+        OMX_BOOL lock = OMX_FALSE;
+        str = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
+        if ( (strcmp(str, "true")) == 0)
+          {
+            CAMHAL_LOGVA("Locking WhiteBalance");
+            lock = OMX_TRUE;
+          }
+        else
+          {
+            CAMHAL_LOGVA("UnLocking WhiteBalance");
+          }
+        if (mParameters3A.WhiteBalanceLock != lock)
+          {
+            mParameters3A.WhiteBalanceLock = lock;
+            CAMHAL_LOGDB("WhiteBalanceLock %d", lock);
+            mPending3Asettings |= SetWBLock;
+          }
+      }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+int OMXCameraAdapter::getLUTvalue_HALtoOMX(const char * HalValue, LUTtype LUT)
+{
+    int LUTsize = LUT.size;
+    if( HalValue )
+        for(int i = 0; i < LUTsize; i++)
+            if( 0 == strcmp(LUT.Table[i].userDefinition, HalValue) )
+                return LUT.Table[i].omxDefinition;
+
+    return -ENOENT;
+}
+
+const char* OMXCameraAdapter::getLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT)
+{
+    int LUTsize = LUT.size;
+    for(int i = 0; i < LUTsize; i++)
+        if( LUT.Table[i].omxDefinition == OMXValue )
+            return LUT.Table[i].userDefinition;
+
+    return NULL;
+}
+
+status_t OMXCameraAdapter::setExposureMode(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_EXPOSURECONTROLTYPE exp;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    if ( EXPOSURE_FACE_PRIORITY == Gen3A.Exposure )
+        {
+        //Disable Region priority and enable Face priority
+        setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
+        setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, true);
+
+        //Then set the mode to auto
+        Gen3A.WhiteBallance = OMX_ExposureControlAuto;
+        }
+    else
+        {
+        //Disable Face and Region priority
+        setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, false);
+        setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
+        }
+
+    OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSURECONTROLTYPE);
+    exp.nPortIndex = OMX_ALL;
+    exp.eExposureControl = (OMX_EXPOSURECONTROLTYPE)Gen3A.Exposure;
+
+    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                            OMX_IndexConfigCommonExposure,
+                            &exp);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring exposure mode 0x%x", eError);
+        }
+    else
+        {
+        CAMHAL_LOGDA("Camera exposure mode configured successfully");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setFlashMode(Gen3A_settings& Gen3A)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
+    flash.nPortIndex = OMX_ALL;
+    flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) Gen3A.FlashMode;
+
+    CAMHAL_LOGDB("Configuring flash mode 0x%x", flash.eFlashControl);
+    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                            (OMX_INDEXTYPE) OMX_IndexConfigFlashControl,
+                            &flash);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring flash mode 0x%x", eError);
+        }
+    else
+        {
+        CAMHAL_LOGDA("Camera flash mode configured successfully");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setFocusMode(Gen3A_settings& Gen3A)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    //First Disable Face and Region priority
+    ret |= setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
+    ret |= setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
+        focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+
+        focus.eFocusControl = (OMX_IMAGE_FOCUSCONTROLTYPE)Gen3A.Focus;
+
+        CAMHAL_LOGDB("Configuring focus mode 0x%x", focus.eFocusControl);
+        eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError);
+            }
+        else
+            {
+            CAMHAL_LOGDA("Camera focus mode configured successfully");
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setScene(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_SCENEMODETYPE scene;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&scene, OMX_CONFIG_SCENEMODETYPE);
+    scene.nPortIndex = OMX_ALL;
+    scene.eSceneMode = ( OMX_SCENEMODETYPE ) Gen3A.SceneMode;
+
+    CAMHAL_LOGDB("Configuring scene mode 0x%x", scene.eSceneMode);
+    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                            ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSceneMode,
+                            &scene);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring scene mode 0x%x", eError);
+        }
+    else
+        {
+        CAMHAL_LOGDA("Camera scene configured successfully");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setEVCompensation(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
+    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
+                   OMX_IndexConfigCommonExposureValue,
+                   &expValues);
+    CAMHAL_LOGDB("old EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
+    CAMHAL_LOGDB("EV Compensation for HAL = %d", Gen3A.EVCompensation);
+
+    expValues.xEVCompensation = ( Gen3A.EVCompensation * ( 1 << Q16_OFFSET ) )  / 10;
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                            OMX_IndexConfigCommonExposureValue,
+                            &expValues);
+    CAMHAL_LOGDB("new EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring EV Compensation 0x%x error = 0x%x",
+                     ( unsigned int ) expValues.xEVCompensation,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("EV Compensation 0x%x configured successfully",
+                     ( unsigned int ) expValues.xEVCompensation);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setWBMode(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE);
+    wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+    wb.eWhiteBalControl = ( OMX_WHITEBALCONTROLTYPE ) Gen3A.WhiteBallance;
+
+    if ( WB_FACE_PRIORITY == Gen3A.WhiteBallance )
+        {
+        //Disable Region priority and enable Face priority
+        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
+        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, true);
+
+        //Then set the mode to auto
+        Gen3A.WhiteBallance = OMX_WhiteBalControlAuto;
+        }
+    else
+        {
+        //Disable Face and Region priority
+        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, false);
+        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
+        }
+
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                         OMX_IndexConfigCommonWhiteBalance,
+                         &wb);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring Whitebalance mode 0x%x error = 0x%x",
+                     ( unsigned int ) wb.eWhiteBalControl,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("Whitebalance mode 0x%x configured successfully",
+                     ( unsigned int ) wb.eWhiteBalControl);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return eError;
+}
+
+status_t OMXCameraAdapter::setFlicker(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_FLICKERCANCELTYPE flicker;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&flicker, OMX_CONFIG_FLICKERCANCELTYPE);
+    flicker.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+    flicker.eFlickerCancel = (OMX_COMMONFLICKERCANCELTYPE)Gen3A.Flicker;
+
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                            (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel,
+                            &flicker );
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring Flicker mode 0x%x error = 0x%x",
+                     ( unsigned int ) flicker.eFlickerCancel,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("Flicker mode 0x%x configured successfully",
+                     ( unsigned int ) flicker.eFlickerCancel);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setBrightness(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_BRIGHTNESSTYPE brightness;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&brightness, OMX_CONFIG_BRIGHTNESSTYPE);
+    brightness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+    brightness.nBrightness = Gen3A.Brightness;
+
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                         OMX_IndexConfigCommonBrightness,
+                         &brightness);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring Brightness 0x%x error = 0x%x",
+                     ( unsigned int ) brightness.nBrightness,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("Brightness 0x%x configured successfully",
+                     ( unsigned int ) brightness.nBrightness);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setContrast(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_CONTRASTTYPE contrast;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&contrast, OMX_CONFIG_CONTRASTTYPE);
+    contrast.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+    contrast.nContrast = Gen3A.Contrast;
+
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                         OMX_IndexConfigCommonContrast,
+                         &contrast);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring Contrast 0x%x error = 0x%x",
+                     ( unsigned int ) contrast.nContrast,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("Contrast 0x%x configured successfully",
+                     ( unsigned int ) contrast.nContrast);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return eError;
+}
+
+status_t OMXCameraAdapter::setSharpness(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE);
+    procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+    procSharpness.nLevel = Gen3A.Sharpness;
+
+    if( procSharpness.nLevel == 0 )
+        {
+        procSharpness.bAuto = OMX_TRUE;
+        }
+    else
+        {
+        procSharpness.bAuto = OMX_FALSE;
+        }
+
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                         (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel,
+                         &procSharpness);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring Sharpness 0x%x error = 0x%x",
+                     ( unsigned int ) procSharpness.nLevel,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("Sharpness 0x%x configured successfully",
+                     ( unsigned int ) procSharpness.nLevel);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setSaturation(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_SATURATIONTYPE saturation;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE);
+    saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+    saturation.nSaturation = Gen3A.Saturation;
+
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                         OMX_IndexConfigCommonSaturation,
+                         &saturation);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring Saturation 0x%x error = 0x%x",
+                     ( unsigned int ) saturation.nSaturation,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("Saturation 0x%x configured successfully",
+                     ( unsigned int ) saturation.nSaturation);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setISO(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
+    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
+                   OMX_IndexConfigCommonExposureValue,
+                   &expValues);
+
+    if( 0 == Gen3A.ISO )
+        {
+        expValues.bAutoSensitivity = OMX_TRUE;
+        }
+    else
+        {
+        expValues.bAutoSensitivity = OMX_FALSE;
+        expValues.nSensitivity = Gen3A.ISO;
+        }
+
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                         OMX_IndexConfigCommonExposureValue,
+                         &expValues);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring ISO 0x%x error = 0x%x",
+                     ( unsigned int ) expValues.nSensitivity,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("ISO 0x%x configured successfully",
+                     ( unsigned int ) expValues.nSensitivity);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setEffect(Gen3A_settings& Gen3A)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_IMAGEFILTERTYPE effect;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        return NO_INIT;
+        }
+
+    OMX_INIT_STRUCT_PTR (&effect, OMX_CONFIG_IMAGEFILTERTYPE);
+    effect.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+    effect.eImageFilter = (OMX_IMAGEFILTERTYPE ) Gen3A.Effect;
+
+    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                         OMX_IndexConfigCommonImageFilter,
+                         &effect);
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while configuring Effect 0x%x error = 0x%x",
+                     ( unsigned int )  effect.eImageFilter,
+                     eError);
+        }
+    else
+        {
+        CAMHAL_LOGDB("Effect 0x%x configured successfully",
+                     ( unsigned int )  effect.eImageFilter);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setWhiteBalanceLock(Gen3A_settings& Gen3A)
+{
+  OMX_ERRORTYPE eError = OMX_ErrorNone;
+  OMX_IMAGE_CONFIG_LOCKTYPE lock;
+
+  LOG_FUNCTION_NAME
+
+  if ( OMX_StateInvalid == mComponentState )
+    {
+      CAMHAL_LOGEA("OMX component is in invalid state");
+      return NO_INIT;
+    }
+
+  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
+  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+  lock.bLock = Gen3A.WhiteBalanceLock;
+  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
+                          &lock);
+  if ( OMX_ErrorNone != eError )
+    {
+      CAMHAL_LOGEB("Error while configuring WhiteBalance Lock error = 0x%x", eError);
+    }
+  else
+    {
+      CAMHAL_LOGDB("WhiteBalance Lock configured successfully %d ", lock.bLock);
+    }
+  LOG_FUNCTION_NAME_EXIT
+
+  return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::setExposureLock(Gen3A_settings& Gen3A)
+{
+  OMX_ERRORTYPE eError = OMX_ErrorNone;
+  OMX_IMAGE_CONFIG_LOCKTYPE lock;
+
+  LOG_FUNCTION_NAME
+
+  if ( OMX_StateInvalid == mComponentState )
+    {
+      CAMHAL_LOGEA("OMX component is in invalid state");
+      return NO_INIT;
+    }
+
+  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
+  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+  lock.bLock = Gen3A.ExposureLock;
+  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
+                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
+                          &lock);
+  if ( OMX_ErrorNone != eError )
+    {
+      CAMHAL_LOGEB("Error while configuring Exposure Lock error = 0x%x", eError);
+    }
+  else
+    {
+      CAMHAL_LOGDB("Exposure Lock configured successfully %d ", lock.bLock);
+    }
+  LOG_FUNCTION_NAME_EXIT
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::release3ALock()
+{
+  OMX_ERRORTYPE eError = OMX_ErrorNone;
+  OMX_IMAGE_CONFIG_LOCKTYPE lock;
+
+  LOG_FUNCTION_NAME
+
+  if ( OMX_StateInvalid == mComponentState )
+    {
+      CAMHAL_LOGEA("OMX component is in invalid state");
+      return NO_INIT;
+    }
+
+  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
+  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+
+  mParameters3A.ExposureLock = OMX_FALSE;
+  mParameters3A.WhiteBalanceLock = OMX_FALSE;
+
+  eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
+                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
+                          &lock);
+  if ( OMX_ErrorNone != eError )
+    {
+      CAMHAL_LOGEB("Error GetConfig Exposure Lock error = 0x%x", eError);
+    }
+  else
+    {
+      CAMHAL_LOGDA("Exposure Lock GetConfig successfull");
+    }
+
+  /*if locked then unlock */
+  if ( lock.bLock )
+    {
+      setExposureLock(mParameters3A);
+    }
+
+  eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
+                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
+                          &lock);
+  if ( OMX_ErrorNone != eError )
+    {
+      CAMHAL_LOGEB("Error GetConfig WhiteBalance Lock error = 0x%x", eError);
+    }
+  else
+    {
+      CAMHAL_LOGDA("WhiteBalance Lock GetConfig successfull");
+    }
+
+  /*if locked then unlock */
+  if ( lock.bLock )
+    {
+      setWhiteBalanceLock(mParameters3A);
+    }
+
+    return ErrorUtils::omxToAndroidError(eError);
+
+}
+
+status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
+{
+    status_t ret = NO_ERROR;
+    unsigned int currSett; // 32 bit
+    int portIndex;
+
+    /*
+     * Scenes have a priority during the process
+     * of applying 3A related parameters.
+     * They can override pretty much all other 3A
+     * settings and similarly get overridden when
+     * for instance the focus mode gets switched.
+     * There is only one exception to this rule,
+     * the manual a.k.a. auto scene.
+     */
+    if ( ( SetSceneMode & mPending3Asettings ) )
+        {
+        mPending3Asettings &= ~SetSceneMode;
+        return setScene(Gen3A);
+        }
+    else if ( OMX_Manual != Gen3A.SceneMode )
+        {
+        mPending3Asettings = 0;
+        return NO_ERROR;
+        }
+
+    for( currSett = 1; currSett < E3aSettingMax; currSett <<= 1)
+        {
+        if( currSett & mPending3Asettings )
+            {
+            switch( currSett )
+                {
+                case SetEVCompensation:
+                    {
+                    ret |= setEVCompensation(Gen3A);
+                    break;
+                    }
+
+                case SetWhiteBallance:
+                    {
+                    ret |= setWBMode(Gen3A);
+                    break;
+                    }
+
+                case SetFlicker:
+                    {
+                    ret |= setFlicker(Gen3A);
+                    break;
+                    }
+
+                case SetBrightness:
+                    {
+                    ret |= setBrightness(Gen3A);
+                    break;
+                    }
+
+                case SetContrast:
+                    {
+                    ret |= setContrast(Gen3A);
+                    break;
+                    }
+
+                case SetSharpness:
+                    {
+                    ret |= setSharpness(Gen3A);
+                    break;
+                    }
+
+                case SetSaturation:
+                    {
+                    ret |= setSaturation(Gen3A);
+                    break;
+                    }
+
+                case SetISO:
+                    {
+                    ret |= setISO(Gen3A);
+                    break;
+                    }
+
+                case SetEffect:
+                    {
+                    ret |= setEffect(Gen3A);
+                    break;
+                    }
+
+                case SetFocus:
+                    {
+                    ret |= setFocusMode(Gen3A);
+                    break;
+                    }
+
+                case SetExpMode:
+                    {
+                    ret |= setExposureMode(Gen3A);
+                    break;
+                    }
+
+                case SetFlash:
+                    {
+                    ret |= setFlashMode(Gen3A);
+                    break;
+                    }
+
+                case SetExpLock:
+                  {
+                    ret |= setExposureLock(Gen3A);
+                    break;
+                  }
+
+                case SetWBLock:
+                  {
+                    ret |= setWhiteBalanceLock(Gen3A);
+                    break;
+                  }
+
+                default:
+                    CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
+                                 currSett);
+                    break;
+                }
+                mPending3Asettings &= ~currSett;
+            }
+        }
+        return ret;
+}
+
+};
diff --git a/camera/OMXCameraAdapter/OMXAlgo.cpp b/camera/OMXCameraAdapter/OMXAlgo.cpp
new file mode 100644
index 0000000..ef9414e
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXAlgo.cpp
@@ -0,0 +1,1181 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMXAlgo.cpp
+*
+* This file contains functionality for handling algorithm configurations.
+*
+*/
+
+#undef LOG_TAG
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+
+namespace android {
+
+status_t OMXCameraAdapter::setParametersAlgo(const CameraParameters &params,
+                                             BaseCameraAdapter::AdapterState state)
+{
+    status_t ret = NO_ERROR;
+    const char *valstr = NULL;
+    const char *oldstr = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    CaptureMode capMode;
+    CAMHAL_LOGEB("Capture mode %s",  params.get(TICameraParameters::KEY_CAP_MODE));
+    if ( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL )
+        {
+        if (strcmp(valstr, (const char *) TICameraParameters::HIGH_PERFORMANCE_MODE) == 0)
+            {
+            capMode = OMXCameraAdapter::HIGH_SPEED;
+            }
+        else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_MODE) == 0)
+            {
+            capMode = OMXCameraAdapter::HIGH_QUALITY;
+            }
+        else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_ZSL_MODE) == 0)
+            {
+            capMode = OMXCameraAdapter::HIGH_QUALITY_ZSL;
+            }
+        else if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0)
+            {
+            capMode = OMXCameraAdapter::VIDEO_MODE;
+            }
+        else
+            {
+            capMode = OMXCameraAdapter::HIGH_QUALITY;
+            }
+        }
+    else
+        {
+        capMode = OMXCameraAdapter::HIGH_QUALITY_ZSL;
+
+        }
+
+    if ( mCapMode != capMode )
+        {
+        mCapMode = capMode;
+        mOMXStateSwitch = true;
+        }
+
+    CAMHAL_LOGDB("Capture Mode set %d", mCapMode);
+
+    /// Configure IPP, LDCNSF, GBCE and GLBCE only in HQ mode
+    IPPMode ipp;
+    if((mCapMode == OMXCameraAdapter::HIGH_QUALITY) || (mCapMode == OMXCameraAdapter::HIGH_QUALITY_ZSL))
+        {
+          if ( (valstr = params.get(TICameraParameters::KEY_IPP)) != NULL )
+            {
+            if (strcmp(valstr, (const char *) TICameraParameters::IPP_LDCNSF) == 0)
+                {
+                ipp = OMXCameraAdapter::IPP_LDCNSF;
+                }
+            else if (strcmp(valstr, (const char *) TICameraParameters::IPP_LDC) == 0)
+                {
+                ipp = OMXCameraAdapter::IPP_LDC;
+                }
+            else if (strcmp(valstr, (const char *) TICameraParameters::IPP_NSF) == 0)
+                {
+                ipp = OMXCameraAdapter::IPP_NSF;
+                }
+            else if (strcmp(valstr, (const char *) TICameraParameters::IPP_NONE) == 0)
+                {
+                ipp = OMXCameraAdapter::IPP_NONE;
+                }
+            else
+                {
+                ipp = OMXCameraAdapter::IPP_NONE;
+                }
+            }
+        else
+            {
+            ipp = OMXCameraAdapter::IPP_NONE;
+            }
+
+        CAMHAL_LOGVB("IPP Mode set %d", ipp);
+
+        if (((valstr = params.get(TICameraParameters::KEY_GBCE)) != NULL) )
+            {
+            // Configure GBCE only if the setting has changed since last time
+            oldstr = mParams.get(TICameraParameters::KEY_GBCE);
+            bool cmpRes = true;
+            if ( NULL != oldstr )
+                {
+                cmpRes = strcmp(valstr, oldstr) != 0;
+                }
+            else
+                {
+                cmpRes = true;
+                }
+
+
+            if( cmpRes )
+                {
+                if (strcmp(valstr, ( const char * ) TICameraParameters::GBCE_ENABLE ) == 0)
+                    {
+                    setGBCE(OMXCameraAdapter::BRIGHTNESS_ON);
+                    }
+                else if (strcmp(valstr, ( const char * ) TICameraParameters::GBCE_DISABLE ) == 0)
+                    {
+                    setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
+                    }
+                else
+                    {
+                    setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
+                    }
+                }
+            }
+        else
+            {
+            //Disable GBCE by default
+            setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
+            }
+
+        if ( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL )
+            {
+            // Configure GLBCE only if the setting has changed since last time
+
+            oldstr = mParams.get(TICameraParameters::KEY_GLBCE);
+            bool cmpRes = true;
+            if ( NULL != oldstr )
+                {
+                cmpRes = strcmp(valstr, oldstr) != 0;
+                }
+            else
+                {
+                cmpRes = true;
+                }
+
+
+            if( cmpRes )
+                {
+                if (strcmp(valstr, ( const char * ) TICameraParameters::GLBCE_ENABLE ) == 0)
+                    {
+                    setGLBCE(OMXCameraAdapter::BRIGHTNESS_ON);
+                    }
+                else if (strcmp(valstr, ( const char * ) TICameraParameters::GLBCE_DISABLE ) == 0)
+                    {
+                    setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
+                    }
+                else
+                    {
+                    setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
+                    }
+                }
+            }
+        else
+            {
+            //Disable GLBCE by default
+            setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
+            }
+        }
+    else
+        {
+        ipp = OMXCameraAdapter::IPP_NONE;
+        }
+
+    if ( mIPP != ipp )
+        {
+        mIPP = ipp;
+        mOMXStateSwitch = true;
+        }
+
+    ///Set VNF Configuration
+    bool vnfEnabled = false;
+    if ( params.getInt(TICameraParameters::KEY_VNF)  > 0 )
+        {
+        CAMHAL_LOGDA("VNF Enabled");
+        vnfEnabled = true;
+        }
+    else
+        {
+        CAMHAL_LOGDA("VNF Disabled");
+        vnfEnabled = false;
+        }
+
+    if ( mVnfEnabled != vnfEnabled )
+        {
+        mVnfEnabled = vnfEnabled;
+        mOMXStateSwitch = true;
+        }
+
+    ///Set VSTAB Configuration
+    bool vstabEnabled = false;
+    if ( params.getInt(TICameraParameters::KEY_VSTAB)  > 0 )
+        {
+        CAMHAL_LOGDA("VSTAB Enabled");
+        vstabEnabled = true;
+        }
+    else
+        {
+        CAMHAL_LOGDA("VSTAB Disabled");
+        vstabEnabled = false;
+        }
+
+    if ( mVstabEnabled != vstabEnabled )
+        {
+        mVstabEnabled = vstabEnabled;
+        mOMXStateSwitch = true;
+        }
+
+    //A work-around for a failing call to OMX flush buffers
+    if ( ( capMode = OMXCameraAdapter::VIDEO_MODE ) &&
+         ( mVstabEnabled ) )
+        {
+        mOMXStateSwitch = true;
+        }
+
+    //Set Auto Convergence Mode
+    valstr = params.get((const char *) TICameraParameters::KEY_AUTOCONVERGENCE);
+    if ( valstr != NULL )
+        {
+        // Set ManualConvergence default value
+        OMX_S32 manualconvergence = -30;
+        if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_DISABLE) == 0 )
+            {
+            setAutoConvergence(OMX_TI_AutoConvergenceModeDisable, manualconvergence);
+            }
+        else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_FRAME) == 0 )
+                {
+                setAutoConvergence(OMX_TI_AutoConvergenceModeFrame, manualconvergence);
+                }
+        else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_CENTER) == 0 )
+                {
+                setAutoConvergence(OMX_TI_AutoConvergenceModeCenter, manualconvergence);
+                }
+        else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_FFT) == 0 )
+                {
+                setAutoConvergence(OMX_TI_AutoConvergenceModeFocusFaceTouch, manualconvergence);
+                }
+        else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_MANUAL) == 0 )
+                {
+                manualconvergence = (OMX_S32)params.getInt(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES);
+                setAutoConvergence(OMX_TI_AutoConvergenceModeManual, manualconvergence);
+                }
+        CAMHAL_LOGVB("AutoConvergenceMode %s, value = %d", valstr, (int) manualconvergence);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+// Get AutoConvergence
+status_t OMXCameraAdapter::getAutoConvergence(OMX_TI_AUTOCONVERGENCEMODETYPE *pACMode,
+                                              OMX_S32 *pManualConverence)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_CONFIG_CONVERGENCETYPE ACParams;
+
+    ACParams.nSize = sizeof(OMX_TI_CONFIG_CONVERGENCETYPE);
+    ACParams.nVersion = mLocalVersionParam;
+    ACParams.nPortIndex = OMX_ALL;
+
+    LOG_FUNCTION_NAME;
+
+    eError =  OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+                            (OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence,
+                            &ACParams);
+    if ( eError != OMX_ErrorNone )
+        {
+        CAMHAL_LOGEB("Error while getting AutoConvergence 0x%x", eError);
+        ret = -EINVAL;
+        }
+    else
+        {
+        *pManualConverence = ACParams.nManualConverence;
+        *pACMode = ACParams.eACMode;
+        CAMHAL_LOGDA("AutoConvergence got successfully");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+// Set AutoConvergence
+status_t OMXCameraAdapter::setAutoConvergence(OMX_TI_AUTOCONVERGENCEMODETYPE pACMode,
+                                              OMX_S32 pManualConverence)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_CONFIG_CONVERGENCETYPE ACParams;
+
+    LOG_FUNCTION_NAME;
+
+    ACParams.nSize = sizeof(OMX_TI_CONFIG_CONVERGENCETYPE);
+    ACParams.nVersion = mLocalVersionParam;
+    ACParams.nPortIndex = OMX_ALL;
+    ACParams.nManualConverence = pManualConverence;
+    ACParams.eACMode = pACMode;
+    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                            (OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence,
+                            &ACParams);
+    if ( eError != OMX_ErrorNone )
+        {
+        CAMHAL_LOGEB("Error while setting AutoConvergence 0x%x", eError);
+        ret = -EINVAL;
+        }
+    else
+        {
+        CAMHAL_LOGDA("AutoConvergence applied successfully");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::enableVideoNoiseFilter(bool enable)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_PARAM_VIDEONOISEFILTERTYPE vnfCfg;
+
+
+    LOG_FUNCTION_NAME;
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&vnfCfg, OMX_PARAM_VIDEONOISEFILTERTYPE);
+
+        if ( enable )
+            {
+            CAMHAL_LOGDA("VNF is enabled");
+            vnfCfg.eMode = OMX_VideoNoiseFilterModeOn;
+            }
+        else
+            {
+            CAMHAL_LOGDA("VNF is disabled");
+            vnfCfg.eMode = OMX_VideoNoiseFilterModeOff;
+            }
+
+        eError =  OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                                   ( OMX_INDEXTYPE ) OMX_IndexParamVideoNoiseFilter,
+                                   &vnfCfg);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring video noise filter 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Video noise filter is configured successfully");
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::enableVideoStabilization(bool enable)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_FRAMESTABTYPE frameStabCfg;
+
+
+    LOG_FUNCTION_NAME;
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_CONFIG_BOOLEANTYPE vstabp;
+        OMX_INIT_STRUCT_PTR (&vstabp, OMX_CONFIG_BOOLEANTYPE);
+        if(enable)
+            {
+            vstabp.bEnabled = OMX_TRUE;
+            }
+        else
+            {
+            vstabp.bEnabled = OMX_FALSE;
+            }
+
+        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                                  (OMX_INDEXTYPE)OMX_IndexParamFrameStabilisation,
+                                  &vstabp);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring video stabilization param 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Video stabilization param configured successfully");
+            }
+
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        OMX_INIT_STRUCT_PTR (&frameStabCfg, OMX_CONFIG_FRAMESTABTYPE);
+
+
+        eError =  OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+                                ( OMX_INDEXTYPE ) OMX_IndexConfigCommonFrameStabilisation,
+                                &frameStabCfg);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while getting video stabilization mode 0x%x",
+                         (unsigned int)eError);
+            ret = -1;
+            }
+
+        CAMHAL_LOGDB("VSTAB Port Index = %d", (int)frameStabCfg.nPortIndex);
+
+        frameStabCfg.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+        if ( enable )
+            {
+            CAMHAL_LOGDA("VSTAB is enabled");
+            frameStabCfg.bStab = OMX_TRUE;
+            }
+        else
+            {
+            CAMHAL_LOGDA("VSTAB is disabled");
+            frameStabCfg.bStab = OMX_FALSE;
+
+            }
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                ( OMX_INDEXTYPE ) OMX_IndexConfigCommonFrameStabilisation,
+                                &frameStabCfg);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring video stabilization mode 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Video stabilization mode configured successfully");
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setGBCE(OMXCameraAdapter::BrightnessMode mode)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE bControl;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&bControl, OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE);
+
+        bControl.nPortIndex = OMX_ALL;
+
+        switch ( mode )
+            {
+            case OMXCameraAdapter::BRIGHTNESS_ON:
+                {
+                bControl.eControl = OMX_TI_BceModeOn;
+                break;
+                }
+            case OMXCameraAdapter::BRIGHTNESS_AUTO:
+                {
+                bControl.eControl = OMX_TI_BceModeAuto;
+                break;
+                }
+            case OMXCameraAdapter::BRIGHTNESS_OFF:
+            default:
+                {
+                bControl.eControl = OMX_TI_BceModeOff;
+                break;
+                }
+            }
+
+        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                               ( OMX_INDEXTYPE ) OMX_TI_IndexConfigGlobalBrightnessContrastEnhance,
+                               &bControl);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while setting GBCE 0x%x", eError);
+            }
+        else
+            {
+            CAMHAL_LOGDB("GBCE configured successfully 0x%x", mode);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setGLBCE(OMXCameraAdapter::BrightnessMode mode)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE bControl;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&bControl, OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE);
+        bControl.nPortIndex = OMX_ALL;
+
+        switch ( mode )
+            {
+            case OMXCameraAdapter::BRIGHTNESS_ON:
+                {
+                bControl.eControl = OMX_TI_BceModeOn;
+                break;
+                }
+            case OMXCameraAdapter::BRIGHTNESS_AUTO:
+                {
+                bControl.eControl = OMX_TI_BceModeAuto;
+                break;
+                }
+            case OMXCameraAdapter::BRIGHTNESS_OFF:
+            default:
+                {
+                bControl.eControl = OMX_TI_BceModeOff;
+                break;
+                }
+            }
+
+        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                               ( OMX_INDEXTYPE ) OMX_TI_IndexConfigLocalBrightnessContrastEnhance,
+                               &bControl);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configure GLBCE 0x%x", eError);
+            }
+        else
+            {
+            CAMHAL_LOGDA("GLBCE configured successfully");
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_CAMOPERATINGMODETYPE camMode;
+    OMX_CONFIG_BOOLEANTYPE bCAC;
+
+    LOG_FUNCTION_NAME;
+
+    OMX_INIT_STRUCT_PTR (&bCAC, OMX_CONFIG_BOOLEANTYPE);
+    bCAC.bEnabled = OMX_FALSE;
+
+    if ( NO_ERROR == ret )
+        {
+
+        OMX_INIT_STRUCT_PTR (&camMode, OMX_CONFIG_CAMOPERATINGMODETYPE);
+        if ( mSensorIndex == OMX_TI_StereoSensor )
+            {
+            CAMHAL_LOGDA("Camera mode: STEREO");
+            camMode.eCamOperatingMode = OMX_CaptureStereoImageCapture;
+            }
+        else if ( OMXCameraAdapter::HIGH_SPEED == mode )
+            {
+            CAMHAL_LOGDA("Camera mode: HIGH SPEED");
+            camMode.eCamOperatingMode = OMX_CaptureImageHighSpeedTemporalBracketing;
+            }
+        else if( OMXCameraAdapter::HIGH_QUALITY == mode )
+            {
+            CAMHAL_LOGDA("Camera mode: HIGH QUALITY");
+            camMode.eCamOperatingMode = OMX_CaptureImageProfileBase;
+            bCAC.bEnabled = OMX_TRUE;
+            }
+        else if( OMXCameraAdapter::HIGH_QUALITY_ZSL== mode )
+            {
+            CAMHAL_LOGDA("Camera mode: HIGH QUALITY_ZSL");
+            camMode.eCamOperatingMode = OMX_TI_CaptureImageProfileZeroShutterLag;
+            bCAC.bEnabled = OMX_TRUE;
+            }
+        else if( OMXCameraAdapter::VIDEO_MODE == mode )
+            {
+            CAMHAL_LOGDA("Camera mode: VIDEO MODE");
+            camMode.eCamOperatingMode = OMX_CaptureVideo;
+            }
+        else
+            {
+            CAMHAL_LOGEA("Camera mode: INVALID mode passed!");
+            return BAD_VALUE;
+            }
+
+        if(ret != -1)
+            {
+            eError =  OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                                       ( OMX_INDEXTYPE ) OMX_IndexCameraOperatingMode,
+                                       &camMode);
+            if ( OMX_ErrorNone != eError )
+                {
+                CAMHAL_LOGEB("Error while configuring camera mode 0x%x", eError);
+                ret = -1;
+                }
+            else
+                {
+                CAMHAL_LOGDA("Camera mode configured successfully");
+                }
+            }
+
+        if(ret != -1)
+            {
+            //Configure CAC
+            eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                    ( OMX_INDEXTYPE ) OMX_IndexConfigChromaticAberrationCorrection,
+                                    &bCAC);
+            if ( OMX_ErrorNone != eError )
+                {
+                CAMHAL_LOGEB("Error while configuring CAC 0x%x", eError);
+                ret = -1;
+                }
+            else
+                {
+                CAMHAL_LOGDA("CAC configured successfully");
+                }
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setLDC(OMXCameraAdapter::IPPMode mode)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_BOOLEANTYPE bOMX;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateLoaded != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is not in loaded state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
+
+        switch ( mode )
+            {
+            case OMXCameraAdapter::IPP_LDCNSF:
+            case OMXCameraAdapter::IPP_LDC:
+                {
+                bOMX.bEnabled = OMX_TRUE;
+                break;
+                }
+            case OMXCameraAdapter::IPP_NONE:
+            case OMXCameraAdapter::IPP_NSF:
+            default:
+                {
+                bOMX.bEnabled = OMX_FALSE;
+                break;
+                }
+            }
+
+        CAMHAL_LOGVB("Configuring LDC mode 0x%x", bOMX.bEnabled);
+        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                                  ( OMX_INDEXTYPE ) OMX_IndexParamLensDistortionCorrection,
+                                  &bOMX);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEA("Error while setting LDC");
+            ret = -1;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setNSF(OMXCameraAdapter::IPPMode mode)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_PARAM_ISONOISEFILTERTYPE nsf;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateLoaded != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is not in loaded state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&nsf, OMX_PARAM_ISONOISEFILTERTYPE);
+        nsf.nPortIndex = OMX_ALL;
+
+        switch ( mode )
+            {
+            case OMXCameraAdapter::IPP_LDCNSF:
+            case OMXCameraAdapter::IPP_NSF:
+                {
+                nsf.eMode = OMX_ISONoiseFilterModeOn;
+                break;
+                }
+            case OMXCameraAdapter::IPP_LDC:
+            case OMXCameraAdapter::IPP_NONE:
+            default:
+                {
+                nsf.eMode = OMX_ISONoiseFilterModeOff;
+                break;
+                }
+            }
+
+        CAMHAL_LOGVB("Configuring NSF mode 0x%x", nsf.eMode);
+        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                                  (OMX_INDEXTYPE)OMX_IndexParamHighISONoiseFiler,
+                                  &nsf);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEA("Error while setting NSF");
+            ret = -1;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setImageQuality(unsigned int quality)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_IMAGE_PARAM_QFACTORTYPE jpegQualityConf;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT(jpegQualityConf, OMX_IMAGE_PARAM_QFACTORTYPE);
+        jpegQualityConf.nQFactor = quality;
+        jpegQualityConf.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
+
+        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                                  OMX_IndexParamQFactor,
+                                  &jpegQualityConf);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring jpeg Quality 0x%x", eError);
+            ret = -1;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setThumbnailParams(unsigned int width,
+                                              unsigned int height,
+                                              unsigned int quality)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_PARAM_THUMBNAILTYPE thumbConf;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT(thumbConf, OMX_PARAM_THUMBNAILTYPE);
+        thumbConf.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
+
+        eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp,
+                                  ( OMX_INDEXTYPE ) OMX_IndexParamThumbnail,
+                                  &thumbConf);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while retrieving thumbnail size 0x%x", eError);
+            ret = -1;
+            }
+
+        //CTS Requirement: width or height equal to zero should
+        //result in absent EXIF thumbnail
+        if ( ( 0 == width ) || ( 0 == height ) )
+            {
+            thumbConf.nWidth = mThumbRes[0].width;
+            thumbConf.nHeight = mThumbRes[0].height;
+            thumbConf.eCompressionFormat = OMX_IMAGE_CodingUnused;
+            }
+        else
+            {
+            thumbConf.nWidth = width;
+            thumbConf.nHeight = height;
+            thumbConf.nQuality = quality;
+            thumbConf.eCompressionFormat = OMX_IMAGE_CodingJPEG;
+            }
+
+        CAMHAL_LOGDB("Thumbnail width = %d, Thumbnail Height = %d", width, height);
+
+        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                                  ( OMX_INDEXTYPE ) OMX_IndexParamThumbnail,
+                                  &thumbConf);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring thumbnail size 0x%x", eError);
+            ret = -1;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setAlgoPriority(AlgoPriority priority,
+                                           Algorithm3A algo,
+                                           bool enable)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_CONFIG_3A_REGION_PRIORITY regionPriority;
+    OMX_TI_CONFIG_3A_FACE_PRIORITY facePriority;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -1;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        if ( FACE_PRIORITY == priority )
+            {
+            OMX_INIT_STRUCT_PTR (&facePriority, OMX_TI_CONFIG_3A_FACE_PRIORITY);
+            facePriority.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
+
+            if ( algo & WHITE_BALANCE_ALGO )
+                {
+                if ( enable )
+                    {
+                    facePriority.bAwbFaceEnable = OMX_TRUE;
+                    }
+                else
+                    {
+                    facePriority.bAwbFaceEnable = OMX_FALSE;
+                    }
+                }
+
+            if ( algo & EXPOSURE_ALGO )
+                {
+                if ( enable )
+                    {
+                    facePriority.bAeFaceEnable = OMX_TRUE;
+                    }
+                else
+                    {
+                    facePriority.bAeFaceEnable = OMX_FALSE;
+                    }
+                }
+
+            if ( algo & FOCUS_ALGO )
+                {
+                if ( enable )
+                    {
+                    facePriority.bAfFaceEnable= OMX_TRUE;
+                    }
+                else
+                    {
+                    facePriority.bAfFaceEnable = OMX_FALSE;
+                    }
+                }
+
+            eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                    ( OMX_INDEXTYPE ) OMX_TI_IndexConfigFacePriority3a,
+                                    &facePriority);
+            if ( OMX_ErrorNone != eError )
+                {
+                CAMHAL_LOGEB("Error while configuring face priority 0x%x", eError);
+                }
+            else
+                {
+                CAMHAL_LOGDA("Face priority for algorithms set successfully");
+                }
+
+            }
+        else if ( REGION_PRIORITY == priority )
+            {
+
+            OMX_INIT_STRUCT_PTR (&regionPriority, OMX_TI_CONFIG_3A_REGION_PRIORITY);
+            regionPriority.nPortIndex =  mCameraAdapterParameters.mImagePortIndex;
+
+            if ( algo & WHITE_BALANCE_ALGO )
+                {
+                if ( enable )
+                    {
+                    regionPriority.bAwbRegionEnable= OMX_TRUE;
+                    }
+                else
+                    {
+                    regionPriority.bAwbRegionEnable = OMX_FALSE;
+                    }
+                }
+
+            if ( algo & EXPOSURE_ALGO )
+                {
+                if ( enable )
+                    {
+                    regionPriority.bAeRegionEnable = OMX_TRUE;
+                    }
+                else
+                    {
+                    regionPriority.bAeRegionEnable = OMX_FALSE;
+                    }
+                }
+
+            if ( algo & FOCUS_ALGO )
+                {
+                if ( enable )
+                    {
+                    regionPriority.bAfRegionEnable = OMX_TRUE;
+                    }
+                else
+                    {
+                    regionPriority.bAfRegionEnable = OMX_FALSE;
+                    }
+                }
+
+            eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                    ( OMX_INDEXTYPE ) OMX_TI_IndexConfigRegionPriority3a,
+                                    &regionPriority);
+            if ( OMX_ErrorNone != eError )
+                {
+                CAMHAL_LOGEB("Error while configuring region priority 0x%x", eError);
+                }
+            else
+                {
+                CAMHAL_LOGDA("Region priority for algorithms set successfully");
+                }
+
+            }
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setPictureRotation(unsigned int degree)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_ROTATIONTYPE rotation;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -1;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT(rotation, OMX_CONFIG_ROTATIONTYPE);
+        rotation.nRotation = degree;
+        rotation.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
+
+        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                               OMX_IndexConfigCommonRotate,
+                               &rotation);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring rotation 0x%x", eError);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setSensorOrientation(unsigned int degree)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_ROTATIONTYPE sensorOrientation;
+    int tmpHeight, tmpWidth;
+    OMXCameraPortParameters *mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+
+    LOG_FUNCTION_NAME;
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -1;
+        }
+
+    /* Set Temproary Port resolution.
+    * For resolution with height > 1008,resolution cannot be set without configuring orientation.
+    * So we first set a temp resolution. We have used VGA
+    */
+    tmpHeight = mPreviewData->mHeight;
+    tmpWidth = mPreviewData->mWidth;
+    mPreviewData->mWidth = 640;
+    mPreviewData->mHeight = 480;
+    ret = setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData);
+    if ( ret != NO_ERROR )
+        {
+        CAMHAL_LOGEB("setFormat() failed %d", ret);
+        }
+
+    /* Now set Required Orientation*/
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT(sensorOrientation, OMX_CONFIG_ROTATIONTYPE);
+        sensorOrientation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+                               OMX_IndexConfigCommonRotate,
+                               &sensorOrientation);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while Reading Sensor Orientation :  0x%x", eError);
+            }
+        CAMHAL_LOGVB(" Currently Sensor Orientation is set to : %d",
+                     ( unsigned int ) sensorOrientation.nRotation);
+        sensorOrientation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+        sensorOrientation.nRotation = degree;
+        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                               OMX_IndexConfigCommonRotate,
+                               &sensorOrientation);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring rotation 0x%x", eError);
+            }
+        CAMHAL_LOGVA(" Read the Parameters that are set");
+        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+                               OMX_IndexConfigCommonRotate,
+                               &sensorOrientation);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while Reading Sensor Orientation :  0x%x", eError);
+            }
+        CAMHAL_LOGVB(" Currently Sensor Orientation is set to : %d",
+                     ( unsigned int ) sensorOrientation.nRotation);
+        CAMHAL_LOGVB(" Sensor Configured for Port : %d",
+                     ( unsigned int ) sensorOrientation.nPortIndex);
+        }
+
+    /* Now set the required resolution as requested */
+
+    mPreviewData->mWidth = tmpWidth;
+    mPreviewData->mHeight = tmpHeight;
+    if ( NO_ERROR == ret )
+        {
+        ret = setFormat (mCameraAdapterParameters.mPrevPortIndex,
+                         mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("setFormat() failed %d", ret);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setVFramerate(OMX_U32 minFrameRate, OMX_U32 maxFrameRate)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_CONFIG_VARFRMRANGETYPE vfr;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&vfr, OMX_TI_CONFIG_VARFRMRANGETYPE);
+
+        vfr.xMin = minFrameRate<<16;
+        vfr.xMax = maxFrameRate<<16;
+
+        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                               (OMX_INDEXTYPE)OMX_TI_IndexConfigVarFrmRange,
+                               &vfr);
+        if(OMX_ErrorNone != eError)
+            {
+            CAMHAL_LOGEB("Error while setting VFR min = %d, max = %d, error = 0x%x",
+                         ( unsigned int ) minFrameRate,
+                         ( unsigned int ) maxFrameRate,
+                         eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDB("VFR Configured Successfully [%d:%d]",
+                        ( unsigned int ) minFrameRate,
+                        ( unsigned int ) maxFrameRate);
+            }
+        }
+
+    return ret;
+ }
+
+};
diff --git a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
new file mode 100644
index 0000000..899e3dc
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
@@ -0,0 +1,3160 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMXCameraAdapter.cpp
+*
+* This file maps the Camera Hardware Interface to OMX.
+*
+*/
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+#include "ErrorUtils.h"
+#include "TICameraParameters.h"
+#include <signal.h>
+#include <math.h>
+
+#include <cutils/properties.h>
+#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
+static int mDebugFps = 0;
+
+#define HERE(Msg) {CAMHAL_LOGEB("--===line %d, %s===--\n", __LINE__, Msg);}
+
+namespace android {
+
+#undef LOG_TAG
+///Maintain a separate tag for OMXCameraAdapter logs to isolate issues OMX specific
+#define LOG_TAG "CameraHAL"
+
+//frames skipped before recalculating the framerate
+#define FPS_PERIOD 30
+
+static OMXCameraAdapter *gCameraAdapter = NULL;
+Mutex gAdapterLock;
+
+/*--------------------Camera Adapter Class STARTS here-----------------------------*/
+
+status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps, int sensor_index)
+{
+    LOG_FUNCTION_NAME;
+
+    char value[PROPERTY_VALUE_MAX];
+    property_get("debug.camera.showfps", value, "0");
+    mDebugFps = atoi(value);
+
+    TIMM_OSAL_ERRORTYPE osalError = OMX_ErrorNone;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    status_t ret = NO_ERROR;
+
+
+    mLocalVersionParam.s.nVersionMajor = 0x1;
+    mLocalVersionParam.s.nVersionMinor = 0x1;
+    mLocalVersionParam.s.nRevision = 0x0 ;
+    mLocalVersionParam.s.nStep =  0x0;
+
+    mPending3Asettings = 0;//E3AsettingsAll;
+
+    if ( 0 != mInitSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mInitSem semaphore count %d", mInitSem.Count());
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    if (mComponentState != OMX_StateLoaded && mComponentState != OMX_StateInvalid) {
+       LOG_FUNCTION_NAME_EXIT;
+       return NO_INIT;
+    }
+
+    if ( mComponentState != OMX_StateExecuting ){
+        ///Update the preview and image capture port indexes
+        mCameraAdapterParameters.mPrevPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW;
+        // temp changed in order to build OMX_CAMERA_PORT_VIDEO_OUT_IMAGE;
+        mCameraAdapterParameters.mImagePortIndex = OMX_CAMERA_PORT_IMAGE_OUT_IMAGE;
+        mCameraAdapterParameters.mMeasurementPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT;
+        //currently not supported use preview port instead
+        mCameraAdapterParameters.mVideoPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW;
+
+        if(!mCameraAdapterParameters.mHandleComp)
+            {
+            ///Initialize the OMX Core
+            eError = OMX_Init();
+
+            if(eError!=OMX_ErrorNone)
+                {
+                CAMHAL_LOGEB("OMX_Init -0x%x", eError);
+                }
+            GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+            ///Setup key parameters to send to Ducati during init
+            OMX_CALLBACKTYPE oCallbacks;
+
+            /* Initialize the callback handles */
+            oCallbacks.EventHandler    = android::OMXCameraAdapterEventHandler;
+            oCallbacks.EmptyBufferDone = android::OMXCameraAdapterEmptyBufferDone;
+            oCallbacks.FillBufferDone  = android::OMXCameraAdapterFillBufferDone;
+
+            ///Get the handle to the OMX Component
+            mCameraAdapterParameters.mHandleComp = NULL;
+            eError = OMX_GetHandle(&(mCameraAdapterParameters.mHandleComp), //     previously used: OMX_GetHandle
+                                        (OMX_STRING)"OMX.TI.DUCATI1.VIDEO.CAMERA" ///@todo Use constant instead of hardcoded name
+                                        , this
+                                        , &oCallbacks);
+
+            if(eError!=OMX_ErrorNone)
+                {
+                CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError);
+                }
+            GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+
+             eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                                          OMX_CommandPortDisable,
+                                          OMX_ALL,
+                                          NULL);
+
+             if(eError!=OMX_ErrorNone)
+                 {
+                 CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortDisable) -0x%x", eError);
+                 }
+
+             GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+             ///Register for port enable event
+             ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                                         OMX_EventCmdComplete,
+                                         OMX_CommandPortEnable,
+                                         mCameraAdapterParameters.mPrevPortIndex,
+                                         mInitSem);
+             if(ret!=NO_ERROR)
+                 {
+                 CAMHAL_LOGEB("Error in registering for event %d", ret);
+                 goto EXIT;
+                 }
+
+            ///Enable PREVIEW Port
+             eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                                         OMX_CommandPortEnable,
+                                         mCameraAdapterParameters.mPrevPortIndex,
+                                         NULL);
+
+             if(eError!=OMX_ErrorNone)
+                 {
+                 CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError);
+                 }
+
+             GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+             //Wait for the port enable event to occur
+             ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT);
+             if ( NO_ERROR == ret )
+                 {
+                 CAMHAL_LOGDA("-Port enable event arrived");
+                 }
+             else
+                 {
+                 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                                    OMX_EventCmdComplete,
+                                    OMX_CommandPortEnable,
+                                    mCameraAdapterParameters.mPrevPortIndex,
+                                    NULL);
+                 CAMHAL_LOGEA("Timeout for enabling preview port expired!");
+                 goto EXIT;
+                 }
+
+            }
+        else
+            {
+            OMXCameraPortParameters * mPreviewData =
+                &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+
+            //Apply default configs before trying to swtich to a new sensor
+            if ( NO_ERROR != setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData) )
+                {
+                CAMHAL_LOGEB("Error 0x%x while applying defaults", ret);
+                goto EXIT;
+                }
+            }
+    }
+    ///Select the sensor
+    OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
+    OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
+    sensorSelect.eSensor = (OMX_SENSORSELECT)sensor_index;
+    eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect);
+
+    if ( OMX_ErrorNone != eError )
+        {
+        CAMHAL_LOGEB("Error while selecting the sensor index as %d - 0x%x", sensor_index, eError);
+        return BAD_VALUE;
+        }
+    else
+        {
+        CAMHAL_LOGDB("Sensor %d selected successfully", sensor_index);
+        }
+
+    printComponentVersion(mCameraAdapterParameters.mHandleComp);
+
+    mSensorIndex = sensor_index;
+    mBracketingEnabled = false;
+    mBracketingBuffersQueuedCount = 0;
+    mBracketingRange = 1;
+    mLastBracetingBufferIdx = 0;
+    mOMXStateSwitch = false;
+
+    if ( mComponentState != OMX_StateExecuting ){
+        mCaptureSignalled = false;
+        mCaptureConfigured = false;
+        mRecording = false;
+        mWaitingForSnapshot = false;
+        mSnapshotCount = 0;
+        mComponentState = OMX_StateLoaded;
+
+        mCapMode = HIGH_QUALITY;
+        mBurstFrames = 1;
+        mCapturedFrames = 0;
+        mPictureQuality = 100;
+        mCurrentZoomIdx = 0;
+        mTargetZoomIdx = 0;
+        mReturnZoomStatus = false;
+        mZoomInc = 1;
+        mZoomParameterIdx = 0;
+        mExposureBracketingValidEntries = 0;
+        mSensorOverclock = false;
+
+        mDeviceOrientation = 0;
+        mCapabilities = caps;
+
+        mEXIFData.mGPSData.mAltitudeValid = false;
+        mEXIFData.mGPSData.mDatestampValid = false;
+        mEXIFData.mGPSData.mLatValid = false;
+        mEXIFData.mGPSData.mLongValid = false;
+        mEXIFData.mGPSData.mMapDatumValid = false;
+        mEXIFData.mGPSData.mProcMethodValid = false;
+        mEXIFData.mGPSData.mVersionIdValid = false;
+        mEXIFData.mGPSData.mTimeStampValid = false;
+        mEXIFData.mModelValid = false;
+        mEXIFData.mMakeValid = false;
+
+        // initialize command handling thread
+        if(mCommandHandler.get() == NULL)
+            mCommandHandler = new CommandHandler(this);
+
+        if ( NULL == mCommandHandler.get() )
+        {
+            CAMHAL_LOGEA("Couldn't create command handler");
+            return NO_MEMORY;
+        }
+
+        ret = mCommandHandler->run("CallbackThread", PRIORITY_URGENT_DISPLAY);
+        if ( ret != NO_ERROR )
+        {
+            if( ret == INVALID_OPERATION){
+                CAMHAL_LOGDA("command handler thread already runnning!!");
+            }else
+            {
+                CAMHAL_LOGEA("Couldn't run command handlerthread");
+                return ret;
+            }
+        }
+
+        // initialize omx callback handling thread
+        if(mOMXCallbackHandler.get() == NULL)
+            mOMXCallbackHandler = new OMXCallbackHandler(this);
+
+        if ( NULL == mOMXCallbackHandler.get() )
+        {
+            CAMHAL_LOGEA("Couldn't create omx callback handler");
+            return NO_MEMORY;
+        }
+
+        ret = mOMXCallbackHandler->run("OMXCallbackThread", PRIORITY_URGENT_DISPLAY);
+        if ( ret != NO_ERROR )
+        {
+            if( ret == INVALID_OPERATION){
+                CAMHAL_LOGDA("omx callback handler thread already runnning!!");
+            }else
+            {
+                CAMHAL_LOGEA("Couldn't run omx callback handler thread");
+                return ret;
+            }
+        }
+
+        //Remove any unhandled events
+        if ( !mEventSignalQ.isEmpty() )
+            {
+            for (unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ )
+                {
+                TIUTILS::Message *msg = mEventSignalQ.itemAt(i);
+                //remove from queue and free msg
+                mEventSignalQ.removeAt(i);
+                if ( NULL != msg )
+                    {
+                    free(msg);
+                    }
+                }
+            }
+
+        //Setting this flag will that the first setParameter call will apply all 3A settings
+        //and will not conditionally apply based on current values.
+        mFirstTimeInit = true;
+
+        memset(mExposureBracketingValues, 0, EXP_BRACKET_RANGE*sizeof(int));
+        mMeasurementEnabled = false;
+        mFaceDetectionRunning = false;
+
+        memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex], 0, sizeof(OMXCameraPortParameters));
+        memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex], 0, sizeof(OMXCameraPortParameters));
+    }
+    LOG_FUNCTION_NAME_EXIT;
+    return ErrorUtils::omxToAndroidError(eError);
+
+    EXIT:
+
+    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
+
+    if(mCameraAdapterParameters.mHandleComp)
+        {
+        ///Free the OMX component handle in case of error
+        OMX_FreeHandle(mCameraAdapterParameters.mHandleComp);
+        }
+
+    ///De-init the OMX
+    OMX_Deinit();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+OMXCameraAdapter::OMXCameraPortParameters *OMXCameraAdapter::getPortParams(CameraFrame::FrameType frameType)
+{
+    OMXCameraAdapter::OMXCameraPortParameters *ret = NULL;
+
+    switch ( frameType )
+    {
+    case CameraFrame::IMAGE_FRAME:
+    case CameraFrame::RAW_FRAME:
+        ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+        break;
+    case CameraFrame::PREVIEW_FRAME_SYNC:
+    case CameraFrame::SNAPSHOT_FRAME:
+    case CameraFrame::VIDEO_FRAME_SYNC:
+        ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+        break;
+    case CameraFrame::FRAME_DATA_SYNC:
+        ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
+        break;
+    default:
+        break;
+    };
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType)
+{
+    status_t ret = NO_ERROR;
+    OMXCameraPortParameters *port = NULL;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    BaseCameraAdapter::AdapterState state;
+    BaseCameraAdapter::getState(state);
+
+    if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE )
+        {
+        return NO_INIT;
+        }
+
+    if ( NULL == frameBuf )
+        {
+        return -EINVAL;
+        }
+
+    if ( (NO_ERROR == ret) &&
+         ((CameraFrame::IMAGE_FRAME == frameType) || (CameraFrame::RAW_FRAME == frameType)) &&
+         (1 > mCapturedFrames) &&
+         (!mBracketingEnabled)) {
+        // Signal end of image capture
+        if ( NULL != mEndImageCaptureCallback) {
+            mEndImageCaptureCallback(mEndCaptureData);
+        }
+        return NO_ERROR;
+     }
+
+    if ( NO_ERROR == ret )
+        {
+        port = getPortParams(frameType);
+        if ( NULL == port )
+            {
+            CAMHAL_LOGEB("Invalid frameType 0x%x", frameType);
+            ret = -EINVAL;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        for ( int i = 0 ; i < port->mNumBufs ; i++)
+            {
+            if ( port->mBufferHeader[i]->pBuffer == frameBuf )
+                {
+                eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, port->mBufferHeader[i]);
+                if ( eError != OMX_ErrorNone )
+                    {
+                    CAMHAL_LOGDB("OMX_FillThisBuffer 0x%x", eError);
+                    ret = ErrorUtils::omxToAndroidError(eError);
+                    }
+                break;
+                }
+            }
+
+        }
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setParameters(const CameraParameters &params)
+{
+    LOG_FUNCTION_NAME;
+
+    const char * str = NULL;
+    int mode = 0;
+    status_t ret = NO_ERROR;
+    bool updateImagePortParams = false;
+    int minFramerate, maxFramerate, frameRate;
+    const char *valstr = NULL;
+    const char *oldstr = NULL;
+    int w, h;
+    OMX_COLOR_FORMATTYPE pixFormat;
+    BaseCameraAdapter::AdapterState state;
+    BaseCameraAdapter::getState(state);
+
+    ///@todo Include more camera parameters
+    if ( (valstr = params.getPreviewFormat()) != NULL )
+        {
+        if (strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
+            {
+            CAMHAL_LOGDA("CbYCrY format selected");
+            pixFormat = OMX_COLOR_FormatCbYCrY;
+            }
+        else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 ||
+                strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV420P) == 0)
+            {
+            CAMHAL_LOGDA("YUV420SP format selected");
+            pixFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+            }
+        else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
+            {
+            CAMHAL_LOGDA("RGB565 format selected");
+            pixFormat = OMX_COLOR_Format16bitRGB565;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Invalid format, CbYCrY format selected as default");
+            pixFormat = OMX_COLOR_FormatCbYCrY;
+            }
+        }
+    else
+        {
+        CAMHAL_LOGEA("Preview format is NULL, defaulting to CbYCrY");
+        pixFormat = OMX_COLOR_FormatCbYCrY;
+        }
+
+    OMXCameraPortParameters *cap;
+    cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+
+    params.getPreviewSize(&w, &h);
+    frameRate = params.getPreviewFrameRate();
+    minFramerate = params.getInt(TICameraParameters::KEY_MINFRAMERATE);
+    maxFramerate = params.getInt(TICameraParameters::KEY_MAXFRAMERATE);
+    if ( ( 0 < minFramerate ) &&
+         ( 0 < maxFramerate ) )
+        {
+        if ( minFramerate > maxFramerate )
+            {
+             CAMHAL_LOGEA(" Min FPS set higher than MAX. So setting MIN and MAX to the higher value");
+             maxFramerate = minFramerate;
+            }
+
+        if ( 0 >= frameRate )
+            {
+            frameRate = maxFramerate;
+            }
+
+        if( ( cap->mMinFrameRate != minFramerate ) ||
+            ( cap->mMaxFrameRate != maxFramerate ) )
+            {
+            cap->mMinFrameRate = minFramerate;
+            cap->mMaxFrameRate = maxFramerate;
+            setVFramerate(cap->mMinFrameRate, cap->mMaxFrameRate);
+            }
+        }
+
+    if ( 0 < frameRate )
+        {
+        cap->mColorFormat = pixFormat;
+        cap->mWidth = w;
+        cap->mHeight = h;
+        cap->mFrameRate = frameRate;
+
+        CAMHAL_LOGVB("Prev: cap.mColorFormat = %d", (int)cap->mColorFormat);
+        CAMHAL_LOGVB("Prev: cap.mWidth = %d", (int)cap->mWidth);
+        CAMHAL_LOGVB("Prev: cap.mHeight = %d", (int)cap->mHeight);
+        CAMHAL_LOGVB("Prev: cap.mFrameRate = %d", (int)cap->mFrameRate);
+
+        //TODO: Add an additional parameter for video resolution
+       //use preview resolution for now
+        cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+        cap->mColorFormat = pixFormat;
+        cap->mWidth = w;
+        cap->mHeight = h;
+        cap->mFrameRate = frameRate;
+
+        CAMHAL_LOGVB("Video: cap.mColorFormat = %d", (int)cap->mColorFormat);
+        CAMHAL_LOGVB("Video: cap.mWidth = %d", (int)cap->mWidth);
+        CAMHAL_LOGVB("Video: cap.mHeight = %d", (int)cap->mHeight);
+        CAMHAL_LOGVB("Video: cap.mFrameRate = %d", (int)cap->mFrameRate);
+
+        ///mStride is set from setBufs() while passing the APIs
+        cap->mStride = 4096;
+        cap->mBufSize = cap->mStride * cap->mHeight;
+        }
+
+    if ( ( cap->mWidth >= 1920 ) &&
+         ( cap->mHeight >= 1080 ) &&
+         ( cap->mFrameRate >= FRAME_RATE_FULL_HD ) &&
+         ( !mSensorOverclock ) )
+        {
+        mOMXStateSwitch = true;
+        }
+    else if ( ( ( cap->mWidth < 1920 ) ||
+               ( cap->mHeight < 1080 ) ||
+               ( cap->mFrameRate < FRAME_RATE_FULL_HD ) ) &&
+               ( mSensorOverclock ) )
+        {
+        mOMXStateSwitch = true;
+        }
+
+    if ( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
+        {
+        if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0)
+            {
+            mMeasurementEnabled = true;
+            }
+        else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0)
+            {
+            mMeasurementEnabled = false;
+            }
+        else
+            {
+            mMeasurementEnabled = false;
+            }
+        }
+    else
+        {
+        //Disable measurement data by default
+        mMeasurementEnabled = false;
+        }
+
+    ret |= setParametersCapture(params, state);
+
+    ret |= setParameters3A(params, state);
+
+    ret |= setParametersAlgo(params, state);
+
+    ret |= setParametersFocus(params, state);
+
+    ret |= setParametersFD(params, state);
+
+    ret |= setParametersZoom(params, state);
+
+    ret |= setParametersEXIF(params, state);
+
+    mParams = params;
+    mFirstTimeInit = false;
+
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+void saveFile(unsigned char   *buff, int width, int height, int format) {
+    static int      counter = 1;
+    int             fd = -1;
+    char            fn[256];
+
+    LOG_FUNCTION_NAME;
+
+    fn[0] = 0;
+    sprintf(fn, "/preview%03d.yuv", counter);
+    fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777);
+    if(fd < 0) {
+        LOGE("Unable to open file %s: %s", fn, strerror(fd));
+        return;
+    }
+
+    CAMHAL_LOGVB("Copying from 0x%x, size=%d x %d", buff, width, height);
+
+    //method currently supports only nv12 dumping
+    int stride = width;
+    uint8_t *bf = (uint8_t*) buff;
+    for(int i=0;i<height;i++)
+        {
+        write(fd, bf, width);
+        bf += 4096;
+        }
+
+    for(int i=0;i<height/2;i++)
+        {
+        write(fd, bf, stride);
+        bf += 4096;
+        }
+
+    close(fd);
+
+
+    counter++;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void OMXCameraAdapter::getParameters(CameraParameters& params)
+{
+    status_t ret = NO_ERROR;
+    OMX_CONFIG_EXPOSUREVALUETYPE exp;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    BaseCameraAdapter::AdapterState state;
+    BaseCameraAdapter::getState(state);
+
+    LOG_FUNCTION_NAME;
+
+#ifdef PARAM_FEEDBACK
+
+    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
+    OMX_CONFIG_FLICKERCANCELTYPE flicker;
+    OMX_CONFIG_SCENEMODETYPE scene;
+    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
+    OMX_CONFIG_BRIGHTNESSTYPE brightness;
+    OMX_CONFIG_CONTRASTTYPE contrast;
+    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
+    OMX_CONFIG_SATURATIONTYPE saturation;
+    OMX_CONFIG_IMAGEFILTERTYPE effect;
+    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
+
+    exp.nSize = sizeof(OMX_CONFIG_EXPOSURECONTROLTYPE);
+    exp.nVersion = mLocalVersionParam;
+    exp.nPortIndex = OMX_ALL;
+
+    expValues.nSize = sizeof(OMX_CONFIG_EXPOSUREVALUETYPE);
+    expValues.nVersion = mLocalVersionParam;
+    expValues.nPortIndex = OMX_ALL;
+
+    wb.nSize = sizeof(OMX_CONFIG_WHITEBALCONTROLTYPE);
+    wb.nVersion = mLocalVersionParam;
+    wb.nPortIndex = OMX_ALL;
+
+    flicker.nSize = sizeof(OMX_CONFIG_FLICKERCANCELTYPE);
+    flicker.nVersion = mLocalVersionParam;
+    flicker.nPortIndex = OMX_ALL;
+
+    scene.nSize = sizeof(OMX_CONFIG_SCENEMODETYPE);
+    scene.nVersion = mLocalVersionParam;
+    scene.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+
+    flash.nSize = sizeof(OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
+    flash.nVersion = mLocalVersionParam;
+    flash.nPortIndex = OMX_ALL;
+
+
+    brightness.nSize = sizeof(OMX_CONFIG_BRIGHTNESSTYPE);
+    brightness.nVersion = mLocalVersionParam;
+    brightness.nPortIndex = OMX_ALL;
+
+    contrast.nSize = sizeof(OMX_CONFIG_CONTRASTTYPE);
+    contrast.nVersion = mLocalVersionParam;
+    contrast.nPortIndex = OMX_ALL;
+
+    procSharpness.nSize = sizeof( OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE );
+    procSharpness.nVersion = mLocalVersionParam;
+    procSharpness.nPortIndex = OMX_ALL;
+
+    saturation.nSize = sizeof(OMX_CONFIG_SATURATIONTYPE);
+    saturation.nVersion = mLocalVersionParam;
+    saturation.nPortIndex = OMX_ALL;
+
+    effect.nSize = sizeof(OMX_CONFIG_IMAGEFILTERTYPE);
+    effect.nVersion = mLocalVersionParam;
+    effect.nPortIndex = OMX_ALL;
+
+    focus.nSize = sizeof(OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
+    focus.nVersion = mLocalVersionParam;
+    focus.nPortIndex = OMX_ALL;
+
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,OMX_IndexConfigCommonExposure, &exp);
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonWhiteBalance, &wb);
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel, &flicker );
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexParamSceneMode, &scene);
+    OMX_GetParameter( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexParamFlashControl, &flash);
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonBrightness, &brightness);
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonContrast, &contrast);
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel, &procSharpness);
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonSaturation, &saturation);
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonImageFilter, &effect);
+    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus);
+
+    char * str = NULL;
+
+    for(int i = 0; i < ExpLUT.size; i++)
+        if( ExpLUT.Table[i].omxDefinition == exp.eExposureControl )
+            str = (char*)ExpLUT.Table[i].userDefinition;
+    params.set( TICameraParameters::KEY_EXPOSURE_MODE , str);
+
+    for(int i = 0; i < WBalLUT.size; i++)
+        if( WBalLUT.Table[i].omxDefinition == wb.eWhiteBalControl )
+            str = (char*)WBalLUT.Table[i].userDefinition;
+    params.set( CameraParameters::KEY_WHITE_BALANCE , str );
+
+    for(int i = 0; i < FlickerLUT.size; i++)
+        if( FlickerLUT.Table[i].omxDefinition == flicker.eFlickerCancel )
+            str = (char*)FlickerLUT.Table[i].userDefinition;
+    params.set( CameraParameters::KEY_ANTIBANDING , str );
+
+    for(int i = 0; i < SceneLUT.size; i++)
+        if( SceneLUT.Table[i].omxDefinition == scene.eSceneMode )
+            str = (char*)SceneLUT.Table[i].userDefinition;
+    params.set( CameraParameters::KEY_SCENE_MODE , str );
+
+    for(int i = 0; i < FlashLUT.size; i++)
+        if( FlashLUT.Table[i].omxDefinition == flash.eFlashControl )
+            str = (char*)FlashLUT.Table[i].userDefinition;
+    params.set( CameraParameters::KEY_FLASH_MODE, str );
+
+    for(int i = 0; i < EffLUT.size; i++)
+        if( EffLUT.Table[i].omxDefinition == effect.eImageFilter )
+            str = (char*)EffLUT.Table[i].userDefinition;
+    params.set( CameraParameters::KEY_EFFECT , str );
+
+    for(int i = 0; i < FocusLUT.size; i++)
+        if( FocusLUT.Table[i].omxDefinition == focus.eFocusControl )
+            str = (char*)FocusLUT.Table[i].userDefinition;
+
+    params.set( CameraParameters::KEY_FOCUS_MODE , str );
+
+    int comp = ((expValues.xEVCompensation * 10) >> Q16_OFFSET);
+
+    params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, comp );
+    params.set( TICameraParameters::KEY_MAN_EXPOSURE, expValues.nShutterSpeedMsec);
+    params.set( TICameraParameters::KEY_BRIGHTNESS, brightness.nBrightness);
+    params.set( TICameraParameters::KEY_CONTRAST, contrast.nContrast );
+    params.set( TICameraParameters::KEY_SHARPNESS, procSharpness.nLevel);
+    params.set( TICameraParameters::KEY_SATURATION, saturation.nSaturation);
+
+#else
+
+    //Query focus distances only during CAF, Infinity
+    //or when focus is running
+    if ( ( AF_ACTIVE & state ) ||
+         ( mParameters3A.Focus == OMX_IMAGE_FocusControlAuto )  ||
+         ( mParameters3A.Focus == OMX_IMAGE_FocusControlAutoInfinity ) ||
+         ( NULL == mParameters.get(CameraParameters::KEY_FOCUS_DISTANCES) ) )
+        {
+        updateFocusDistances(params);
+        }
+    else
+        {
+        params.set(CameraParameters::KEY_FOCUS_DISTANCES,
+                   mParameters.get(CameraParameters::KEY_FOCUS_DISTANCES));
+        }
+
+    OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSUREVALUETYPE);
+    exp.nPortIndex = OMX_ALL;
+
+    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+                           OMX_IndexConfigCommonExposureValue,
+                           &exp);
+    if ( OMX_ErrorNone == eError )
+        {
+        params.set(TICameraParameters::KEY_CURRENT_ISO, exp.nSensitivity);
+        }
+    else
+        {
+        CAMHAL_LOGEB("OMX error 0x%x, while retrieving current ISO value", eError);
+        }
+
+    {
+    Mutex::Autolock lock(mZoomLock);
+    //Immediate zoom should not be avaialable while smooth zoom is running
+    if ( ZOOM_ACTIVE & state )
+        {
+        if ( mZoomParameterIdx != mCurrentZoomIdx )
+            {
+            mZoomParameterIdx += mZoomInc;
+            }
+        params.set( CameraParameters::KEY_ZOOM, mZoomParameterIdx);
+        if ( ( mCurrentZoomIdx == mTargetZoomIdx ) &&
+             ( mZoomParameterIdx == mCurrentZoomIdx ) )
+            {
+
+            if ( NO_ERROR == ret )
+                {
+
+                ret =  BaseCameraAdapter::setState(CAMERA_STOP_SMOOTH_ZOOM);
+
+                if ( NO_ERROR == ret )
+                    {
+                    ret = BaseCameraAdapter::commitState();
+                    }
+                else
+                    {
+                    ret |= BaseCameraAdapter::rollbackState();
+                    }
+
+                }
+
+            }
+
+        CAMHAL_LOGDB("CameraParameters Zoom = %d", mCurrentZoomIdx);
+        }
+    else
+        {
+        params.set( CameraParameters::KEY_ZOOM, mCurrentZoomIdx);
+        }
+    }
+
+#endif
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+status_t OMXCameraAdapter::setFormat(OMX_U32 port, OMXCameraPortParameters &portParams)
+{
+    size_t bufferCount;
+
+    LOG_FUNCTION_NAME;
+
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_PARAM_PORTDEFINITIONTYPE portCheck;
+
+    OMX_INIT_STRUCT_PTR (&portCheck, OMX_PARAM_PORTDEFINITIONTYPE);
+
+    portCheck.nPortIndex = port;
+
+    eError = OMX_GetParameter (mCameraAdapterParameters.mHandleComp,
+                                OMX_IndexParamPortDefinition, &portCheck);
+    if(eError!=OMX_ErrorNone)
+        {
+        CAMHAL_LOGEB("OMX_GetParameter - %x", eError);
+        }
+    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+    if ( OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW == port )
+        {
+        portCheck.format.video.nFrameWidth      = portParams.mWidth;
+        portCheck.format.video.nFrameHeight     = portParams.mHeight;
+        portCheck.format.video.eColorFormat     = portParams.mColorFormat;
+        portCheck.format.video.nStride          = portParams.mStride;
+        if( ( portCheck.format.video.nFrameWidth >= 1920 ) &&
+            ( portCheck.format.video.nFrameHeight >= 1080 ) &&
+            ( portParams.mFrameRate >= FRAME_RATE_FULL_HD ) )
+            {
+            setSensorOverclock(true);
+            }
+        else
+            {
+            setSensorOverclock(false);
+            }
+
+        portCheck.format.video.xFramerate       = portParams.mFrameRate<<16;
+        portCheck.nBufferSize                   = portParams.mStride * portParams.mHeight;
+        portCheck.nBufferCountActual = portParams.mNumBufs;
+        mFocusThreshold = FOCUS_THRESHOLD * portParams.mFrameRate;
+        }
+    else if ( OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port )
+        {
+        portCheck.format.image.nFrameWidth      = portParams.mWidth;
+        portCheck.format.image.nFrameHeight     = portParams.mHeight;
+        if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingNone )
+            {
+            portCheck.format.image.eColorFormat     = OMX_COLOR_FormatCbYCrY;
+            portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
+            }
+        else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingJPS )
+            {
+            portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
+            portCheck.format.image.eCompressionFormat = (OMX_IMAGE_CODINGTYPE) OMX_TI_IMAGE_CodingJPS;
+            }
+        else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingMPO )
+            {
+            portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
+            portCheck.format.image.eCompressionFormat = (OMX_IMAGE_CODINGTYPE) OMX_TI_IMAGE_CodingMPO;
+            }
+        else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingRAWJPEG )
+            {
+            //TODO: OMX_IMAGE_CodingJPEG should be changed to OMX_IMAGE_CodingRAWJPEG when
+            // RAW format is supported
+            portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
+            portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
+            }
+        else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingRAWMPO )
+            {
+            //TODO: OMX_IMAGE_CodingJPEG should be changed to OMX_IMAGE_CodingRAWMPO when
+            // RAW format is supported
+            portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
+            portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
+            }
+        else
+            {
+            portCheck.format.image.eColorFormat     = portParams.mColorFormat;
+            portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
+            }
+
+        //Stride for 1D tiler buffer is zero
+        portCheck.format.image.nStride          =  0;
+        portCheck.nBufferSize                   =  portParams.mStride * portParams.mWidth * portParams.mHeight;
+        portCheck.nBufferCountActual = portParams.mNumBufs;
+        }
+    else
+        {
+        CAMHAL_LOGEB("Unsupported port index 0x%x", (unsigned int)port);
+        }
+
+    eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                            OMX_IndexParamPortDefinition, &portCheck);
+    if(eError!=OMX_ErrorNone)
+        {
+        CAMHAL_LOGEB("OMX_SetParameter - %x", eError);
+        }
+    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+    /* check if parameters are set correctly by calling GetParameter() */
+    eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp,
+                                        OMX_IndexParamPortDefinition, &portCheck);
+    if(eError!=OMX_ErrorNone)
+        {
+        CAMHAL_LOGEB("OMX_GetParameter - %x", eError);
+        }
+    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+    portParams.mBufSize = portCheck.nBufferSize;
+
+    if ( OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port )
+        {
+        CAMHAL_LOGDB("\n *** IMG Width = %ld", portCheck.format.image.nFrameWidth);
+        CAMHAL_LOGDB("\n ***IMG Height = %ld", portCheck.format.image.nFrameHeight);
+
+        CAMHAL_LOGDB("\n ***IMG IMG FMT = %x", portCheck.format.image.eColorFormat);
+        CAMHAL_LOGDB("\n ***IMG portCheck.nBufferSize = %ld\n",portCheck.nBufferSize);
+        CAMHAL_LOGDB("\n ***IMG portCheck.nBufferCountMin = %ld\n",
+                                                portCheck.nBufferCountMin);
+        CAMHAL_LOGDB("\n ***IMG portCheck.nBufferCountActual = %ld\n",
+                                                portCheck.nBufferCountActual);
+        CAMHAL_LOGDB("\n ***IMG portCheck.format.image.nStride = %ld\n",
+                                                portCheck.format.image.nStride);
+        }
+    else
+        {
+        CAMHAL_LOGDB("\n *** PRV Width = %ld", portCheck.format.video.nFrameWidth);
+        CAMHAL_LOGDB("\n ***PRV Height = %ld", portCheck.format.video.nFrameHeight);
+
+        CAMHAL_LOGDB("\n ***PRV IMG FMT = %x", portCheck.format.video.eColorFormat);
+        CAMHAL_LOGDB("\n ***PRV portCheck.nBufferSize = %ld\n",portCheck.nBufferSize);
+        CAMHAL_LOGDB("\n ***PRV portCheck.nBufferCountMin = %ld\n",
+                                                portCheck.nBufferCountMin);
+        CAMHAL_LOGDB("\n ***PRV portCheck.nBufferCountActual = %ld\n",
+                                                portCheck.nBufferCountActual);
+        CAMHAL_LOGDB("\n ***PRV portCheck.format.video.nStride = %ld\n",
+                                                portCheck.format.video.nStride);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+
+    EXIT:
+
+    CAMHAL_LOGEB("Exiting function %s because of eError=%x", __FUNCTION__, eError);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ErrorUtils::omxToAndroidError(eError);
+}
+
+status_t OMXCameraAdapter::flushBuffers()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    TIMM_OSAL_ERRORTYPE err;
+    TIMM_OSAL_U32 uRequestedEvents = OMXCameraAdapter::CAMERA_PORT_FLUSH;
+    TIMM_OSAL_U32 pRetrievedEvents;
+
+    if ( 0 != mFlushSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mFlushSem semaphore count %d", mFlushSem.Count());
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    LOG_FUNCTION_NAME;
+
+    OMXCameraPortParameters * mPreviewData = NULL;
+    mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+
+    ///Register for the FLUSH event
+    ///This method just inserts a message in Event Q, which is checked in the callback
+    ///The sempahore passed is signalled by the callback
+    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                                OMX_EventCmdComplete,
+                                OMX_CommandFlush,
+                                OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW,
+                                mFlushSem);
+    if(ret!=NO_ERROR)
+        {
+        CAMHAL_LOGEB("Error in registering for event %d", ret);
+        goto EXIT;
+        }
+
+    ///Send FLUSH command to preview port
+    eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
+                              OMX_CommandFlush,
+                              mCameraAdapterParameters.mPrevPortIndex,
+                              NULL);
+
+    if(eError!=OMX_ErrorNone)
+        {
+        CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandFlush)-0x%x", eError);
+        }
+    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+    CAMHAL_LOGDA("Waiting for flush event");
+
+    ///Wait for the FLUSH event to occur
+    ret = mFlushSem.WaitTimeout(OMX_CMD_TIMEOUT);
+    if ( NO_ERROR == ret )
+        {
+        CAMHAL_LOGDA("Flush event received");
+        }
+    else
+        {
+        ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandFlush,
+                           OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW,
+                           NULL);
+        CAMHAL_LOGDA("Flush event timeout expired");
+        goto EXIT;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return (ret | ErrorUtils::omxToAndroidError(eError));
+
+    EXIT:
+    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
+    LOG_FUNCTION_NAME_EXIT;
+
+    return (ret | ErrorUtils::omxToAndroidError(eError));
+}
+
+///API to give the buffers to Adapter
+status_t OMXCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable)
+{
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    switch(mode)
+        {
+        case CAMERA_PREVIEW:
+            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mNumBufs =  num;
+            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mMaxQueueable = queueable;
+            ret = UseBuffersPreview(bufArr, num);
+            break;
+
+        case CAMERA_IMAGE_CAPTURE:
+            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mNumBufs = num;
+            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mMaxQueueable = queueable;
+            ret = UseBuffersCapture(bufArr, num);
+            break;
+
+        case CAMERA_VIDEO:
+            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mNumBufs =  num;
+            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mMaxQueueable = queueable;
+            ret = UseBuffersPreview(bufArr, num);
+            break;
+
+        case CAMERA_MEASUREMENT:
+            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mNumBufs = num;
+            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mMaxQueueable = queueable;
+            ret = UseBuffersPreviewData(bufArr, num);
+            break;
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::UseBuffersPreviewData(void* bufArr, int num)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMXCameraPortParameters * measurementData = NULL;
+    uint32_t *buffers;
+    Mutex::Autolock lock( mPreviewDataBufferLock);
+
+    LOG_FUNCTION_NAME;
+
+    if ( mComponentState != OMX_StateLoaded )
+        {
+        CAMHAL_LOGEA("Calling UseBuffersPreviewData() when not in LOADED state");
+        ret = BAD_VALUE;
+        }
+
+    if ( NULL == bufArr )
+        {
+        CAMHAL_LOGEA("NULL pointer passed for buffArr");
+        ret = BAD_VALUE;
+        }
+
+    if ( 0 != mUsePreviewDataSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mUsePreviewDataSem semaphore count %d", mUsePreviewDataSem.Count());
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
+        measurementData->mNumBufs = num ;
+        buffers= (uint32_t*) bufArr;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+         ///Register for port enable event on measurement port
+        ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                                      OMX_EventCmdComplete,
+                                      OMX_CommandPortEnable,
+                                      mCameraAdapterParameters.mMeasurementPortIndex,
+                                      mUsePreviewDataSem);
+
+        if ( ret == NO_ERROR )
+            {
+            CAMHAL_LOGDB("Registering for event %d", ret);
+            }
+        else
+            {
+            CAMHAL_LOGEB("Error in registering for event %d", ret);
+            ret = BAD_VALUE;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+         ///Enable MEASUREMENT Port
+         eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                                      OMX_CommandPortEnable,
+                                      mCameraAdapterParameters.mMeasurementPortIndex,
+                                      NULL);
+
+            if ( eError == OMX_ErrorNone )
+                {
+                CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError);
+                }
+            else
+                {
+                CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError);
+                ret = BAD_VALUE;
+                }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        ret = mUsePreviewDataSem.WaitTimeout(OMX_CMD_TIMEOUT);
+
+        if ( NO_ERROR == ret )
+            {
+            CAMHAL_LOGDA("Port enable event arrived on measurement port");
+            }
+        else
+            {
+            ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                               OMX_EventCmdComplete,
+                               OMX_CommandPortEnable,
+                               mCameraAdapterParameters.mMeasurementPortIndex,
+                               NULL);
+            CAMHAL_LOGEA("Timeout expoired during port enable on measurement port");
+            }
+
+        CAMHAL_LOGDA("Port enable event arrived on measurement port");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::switchToLoaded()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+    LOG_FUNCTION_NAME;
+
+    if ( mComponentState == OMX_StateLoaded )
+        {
+        CAMHAL_LOGDA("Already in OMX_Loaded state");
+        goto EXIT;
+        }
+
+    if ( 0 != mSwitchToLoadedSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mSwitchToLoadedSem semaphore count %d", mSwitchToLoadedSem.Count());
+        goto EXIT;
+        }
+
+    ///Register for EXECUTING state transition.
+    ///This method just inserts a message in Event Q, which is checked in the callback
+    ///The sempahore passed is signalled by the callback
+    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandStateSet,
+                           OMX_StateIdle,
+                           mSwitchToLoadedSem);
+
+    if(ret!=NO_ERROR)
+        {
+        CAMHAL_LOGEB("Error in registering for event %d", ret);
+        goto EXIT;
+        }
+
+    eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
+                              OMX_CommandStateSet,
+                              OMX_StateIdle,
+                              NULL);
+
+    if(eError!=OMX_ErrorNone)
+        {
+        CAMHAL_LOGEB("OMX_SendCommand(OMX_StateIdle) - %x", eError);
+        }
+
+    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+    ///Wait for the EXECUTING ->IDLE transition to arrive
+
+    CAMHAL_LOGDA("EXECUTING->IDLE state changed");
+    ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
+    if ( NO_ERROR == ret )
+        {
+        CAMHAL_LOGDA("EXECUTING->IDLE state changed");
+        }
+    else
+        {
+        ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandStateSet,
+                           OMX_StateIdle,
+                           NULL);
+        CAMHAL_LOGEA("Timeout expired on EXECUTING->IDLE state change");
+        goto EXIT;
+        }
+
+    ///Register for LOADED state transition.
+    ///This method just inserts a message in Event Q, which is checked in the callback
+    ///The sempahore passed is signalled by the callback
+    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandStateSet,
+                           OMX_StateLoaded,
+                           mSwitchToLoadedSem);
+
+    if(ret!=NO_ERROR)
+        {
+        CAMHAL_LOGEB("Error in registering for event %d", ret);
+        goto EXIT;
+        }
+
+    eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
+                              OMX_CommandStateSet,
+                              OMX_StateLoaded,
+                              NULL);
+
+    if(eError!=OMX_ErrorNone)
+        {
+        CAMHAL_LOGEB("OMX_SendCommand(OMX_StateLoaded) - %x", eError);
+        }
+    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+    CAMHAL_LOGDA("Switching IDLE->LOADED state");
+    ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
+    if ( NO_ERROR == ret )
+        {
+        CAMHAL_LOGDA("IDLE->LOADED state changed");
+        }
+    else
+        {
+        ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandStateSet,
+                           OMX_StateLoaded,
+                           NULL);
+        CAMHAL_LOGEA("Timeout expired on IDLE->LOADED state change");
+        goto EXIT;
+        }
+
+    mComponentState = OMX_StateLoaded;
+
+    ///Register for Preview port ENABLE event
+    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandPortEnable,
+                           mCameraAdapterParameters.mPrevPortIndex,
+                           mSwitchToLoadedSem);
+
+    if ( NO_ERROR != ret )
+        {
+        CAMHAL_LOGEB("Error in registering for event %d", ret);
+        goto EXIT;
+        }
+
+    ///Enable Preview Port
+    eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                             OMX_CommandPortEnable,
+                             mCameraAdapterParameters.mPrevPortIndex,
+                             NULL);
+
+    CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandStateSet) 0x%x", eError);
+
+    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+    CAMHAL_LOGDA("Enabling Preview port");
+    ///Wait for state to switch to idle
+    ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
+    if ( NO_ERROR == ret )
+        {
+        CAMHAL_LOGDA("Preview port enabled!");
+        }
+    else
+        {
+        ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandPortEnable,
+                           mCameraAdapterParameters.mPrevPortIndex,
+                           NULL);
+        CAMHAL_LOGEA("Preview enable timedout");
+        goto EXIT;
+        }
+
+    EXIT:
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::UseBuffersPreview(void* bufArr, int num)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    int tmpHeight, tmpWidth;
+
+    LOG_FUNCTION_NAME;
+
+    ///Flag to determine whether it is 3D camera or not
+    bool isS3d = false;
+    const char *valstr = NULL;
+    if ( (valstr = mParams.get(TICameraParameters::KEY_S3D_SUPPORTED)) != NULL) {
+        isS3d = (strcmp(valstr, "true") == 0);
+    }
+
+    if(!bufArr)
+        {
+        CAMHAL_LOGEA("NULL pointer passed for buffArr");
+        LOG_FUNCTION_NAME_EXIT;
+        return BAD_VALUE;
+        }
+
+    OMXCameraPortParameters * mPreviewData = NULL;
+    OMXCameraPortParameters *measurementData = NULL;
+    mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+    measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
+    mPreviewData->mNumBufs = num ;
+    uint32_t *buffers = (uint32_t*)bufArr;
+
+    if ( 0 != mUsePreviewSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mUsePreviewSem semaphore count %d", mUsePreviewSem.Count());
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    if(mPreviewData->mNumBufs != num)
+        {
+        CAMHAL_LOGEA("Current number of buffers doesnt equal new num of buffers passed!");
+        LOG_FUNCTION_NAME_EXIT;
+        return BAD_VALUE;
+        }
+
+    if ( mComponentState == OMX_StateLoaded )
+        {
+
+        ret = setLDC(mIPP);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("setLDC() failed %d", ret);
+            LOG_FUNCTION_NAME_EXIT;
+            return ret;
+            }
+
+        ret = setNSF(mIPP);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("setNSF() failed %d", ret);
+            LOG_FUNCTION_NAME_EXIT;
+            return ret;
+            }
+
+        ret = setCaptureMode(mCapMode);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("setCaptureMode() failed %d", ret);
+            LOG_FUNCTION_NAME_EXIT;
+            return ret;
+            }
+
+        CAMHAL_LOGDB("Camera Mode = %d", mCapMode);
+
+        if( ( mCapMode == OMXCameraAdapter::VIDEO_MODE ) ||
+            ( isS3d && (mCapMode == OMXCameraAdapter::HIGH_QUALITY)) )
+            {
+            ///Enable/Disable Video Noise Filter
+            ret = enableVideoNoiseFilter(mVnfEnabled);
+            if ( NO_ERROR != ret)
+                {
+                CAMHAL_LOGEB("Error configuring VNF %x", ret);
+                return ret;
+                }
+
+            ///Enable/Disable Video Stabilization
+            ret = enableVideoStabilization(mVstabEnabled);
+            if ( NO_ERROR != ret)
+                {
+                CAMHAL_LOGEB("Error configuring VSTAB %x", ret);
+                return ret;
+                }
+            }
+        else
+            {
+            ret = enableVideoNoiseFilter(false);
+            if ( NO_ERROR != ret)
+                {
+                CAMHAL_LOGEB("Error configuring VNF %x", ret);
+                return ret;
+                }
+            ///Enable/Disable Video Stabilization
+            ret = enableVideoStabilization(false);
+            if ( NO_ERROR != ret)
+                {
+                CAMHAL_LOGEB("Error configuring VSTAB %x", ret);
+                return ret;
+                }
+            }
+        }
+
+    ret = setSensorOrientation(mSensorOrientation);
+    if ( NO_ERROR != ret )
+        {
+        CAMHAL_LOGEB("Error configuring Sensor Orientation %x", ret);
+        mSensorOrientation = 0;
+        }
+
+    ret = setVFramerate(mPreviewData->mMinFrameRate, mPreviewData->mMaxFrameRate);
+    if ( ret != NO_ERROR )
+        {
+        CAMHAL_LOGEB("VFR configuration failed 0x%x", ret);
+        LOG_FUNCTION_NAME_EXIT;
+        return ret;
+        }
+
+    if ( mComponentState == OMX_StateLoaded )
+        {
+        ///Register for IDLE state switch event
+        ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                               OMX_EventCmdComplete,
+                               OMX_CommandStateSet,
+                               OMX_StateIdle,
+                               mUsePreviewSem);
+
+        if(ret!=NO_ERROR)
+            {
+            CAMHAL_LOGEB("Error in registering for event %d", ret);
+            goto EXIT;
+            }
+
+        ///Once we get the buffers, move component state to idle state and pass the buffers to OMX comp using UseBuffer
+        eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp ,
+                                  OMX_CommandStateSet,
+                                  OMX_StateIdle,
+                                  NULL);
+
+        CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandStateSet) 0x%x", eError);
+
+        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+        mComponentState = OMX_StateIdle;
+        }
+    else
+        {
+            ///Register for Preview port ENABLE event
+            ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                                   OMX_EventCmdComplete,
+                                   OMX_CommandPortEnable,
+                                   mCameraAdapterParameters.mPrevPortIndex,
+                                   mUsePreviewSem);
+
+            if ( NO_ERROR != ret )
+                {
+                CAMHAL_LOGEB("Error in registering for event %d", ret);
+                goto EXIT;
+                }
+
+            ///Enable Preview Port
+            eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                                     OMX_CommandPortEnable,
+                                     mCameraAdapterParameters.mPrevPortIndex,
+                                     NULL);
+        }
+
+
+    ///Configure DOMX to use either gralloc handles or vptrs
+    OMX_TI_PARAMUSENATIVEBUFFER domxUseGrallocHandles;
+    OMX_INIT_STRUCT_PTR (&domxUseGrallocHandles, OMX_TI_PARAMUSENATIVEBUFFER);
+
+    domxUseGrallocHandles.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+    domxUseGrallocHandles.bEnable = OMX_TRUE;
+
+    eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
+                            (OMX_INDEXTYPE)OMX_TI_IndexUseNativeBuffers, &domxUseGrallocHandles);
+    if(eError!=OMX_ErrorNone)
+        {
+        CAMHAL_LOGEB("OMX_SetParameter - %x", eError);
+        }
+    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+    OMX_BUFFERHEADERTYPE *pBufferHdr;
+    for(int index=0;index<num;index++) {
+
+        CAMHAL_LOGDB("OMX_UseBuffer(0x%x)", buffers[index]);
+        eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp,
+                                &pBufferHdr,
+                                mCameraAdapterParameters.mPrevPortIndex,
+                                0,
+                                mPreviewData->mBufSize,
+                                (OMX_U8*)buffers[index]);
+        if(eError!=OMX_ErrorNone)
+            {
+            CAMHAL_LOGEB("OMX_UseBuffer-0x%x", eError);
+            }
+        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+        //pBufferHdr->pAppPrivate =  (OMX_PTR)pBufferHdr;
+        pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
+        pBufferHdr->nVersion.s.nVersionMajor = 1 ;
+        pBufferHdr->nVersion.s.nVersionMinor = 1 ;
+        pBufferHdr->nVersion.s.nRevision = 0 ;
+        pBufferHdr->nVersion.s.nStep =  0;
+        mPreviewData->mBufferHeader[index] = pBufferHdr;
+    }
+
+    if ( mMeasurementEnabled )
+        {
+
+        for( int i = 0; i < num; i++ )
+            {
+            OMX_BUFFERHEADERTYPE *pBufHdr;
+            eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp,
+                                    &pBufHdr,
+                                    mCameraAdapterParameters.mMeasurementPortIndex,
+                                    0,
+                                    measurementData->mBufSize,
+                                    (OMX_U8*)(mPreviewDataBuffers[i]));
+
+             if ( eError == OMX_ErrorNone )
+                {
+                pBufHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
+                pBufHdr->nVersion.s.nVersionMajor = 1 ;
+                pBufHdr->nVersion.s.nVersionMinor = 1 ;
+                pBufHdr->nVersion.s.nRevision = 0 ;
+                pBufHdr->nVersion.s.nStep =  0;
+                measurementData->mBufferHeader[i] = pBufHdr;
+                }
+            else
+                {
+                CAMHAL_LOGEB("OMX_UseBuffer -0x%x", eError);
+                ret = BAD_VALUE;
+                break;
+                }
+            }
+
+        }
+
+    CAMHAL_LOGDA("Registering preview buffers");
+
+    ret = mUsePreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
+    if ( NO_ERROR == ret )
+        {
+        CAMHAL_LOGDA("Preview buffer registration successfull");
+        }
+    else
+        {
+        if ( mComponentState == OMX_StateLoaded )
+            {
+            ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                               OMX_EventCmdComplete,
+                               OMX_CommandStateSet,
+                               OMX_StateIdle,
+                               NULL);
+            }
+        else
+            {
+            ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                               OMX_EventCmdComplete,
+                               OMX_CommandPortEnable,
+                               mCameraAdapterParameters.mPrevPortIndex,
+                               NULL);
+            }
+        CAMHAL_LOGEA("Timeout expired on preview buffer registration");
+        goto EXIT;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return (ret | ErrorUtils::omxToAndroidError(eError));
+
+    ///If there is any failure, we reach here.
+    ///Here, we do any resource freeing and convert from OMX error code to Camera Hal error code
+    EXIT:
+
+    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return (ret | ErrorUtils::omxToAndroidError(eError));
+}
+
+status_t OMXCameraAdapter::startPreview()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMXCameraPortParameters *mPreviewData = NULL;
+    OMXCameraPortParameters *measurementData = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    if( 0 != mStartPreviewSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mStartPreviewSem semaphore count %d", mStartPreviewSem.Count());
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+    measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
+
+    if( OMX_StateIdle == mComponentState )
+        {
+        ///Register for EXECUTING state transition.
+        ///This method just inserts a message in Event Q, which is checked in the callback
+        ///The sempahore passed is signalled by the callback
+        ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                               OMX_EventCmdComplete,
+                               OMX_CommandStateSet,
+                               OMX_StateExecuting,
+                               mStartPreviewSem);
+
+        if(ret!=NO_ERROR)
+            {
+            CAMHAL_LOGEB("Error in registering for event %d", ret);
+            goto EXIT;
+            }
+
+        ///Switch to EXECUTING state
+        eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                                 OMX_CommandStateSet,
+                                 OMX_StateExecuting,
+                                 NULL);
+
+        if(eError!=OMX_ErrorNone)
+            {
+            CAMHAL_LOGEB("OMX_SendCommand(OMX_StateExecuting)-0x%x", eError);
+            }
+
+        CAMHAL_LOGDA("+Waiting for component to go into EXECUTING state");
+        ret = mStartPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
+        if ( NO_ERROR == ret )
+            {
+            CAMHAL_LOGDA("+Great. Component went into executing state!!");
+            }
+        else
+            {
+            ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                               OMX_EventCmdComplete,
+                               OMX_CommandStateSet,
+                               OMX_StateExecuting,
+                               NULL);
+            CAMHAL_LOGDA("Timeout expired on executing state switch!");
+            goto EXIT;
+            }
+
+        mComponentState = OMX_StateExecuting;
+
+        }
+
+    //Queue all the buffers on preview port
+    for(int index=0;index< mPreviewData->mMaxQueueable;index++)
+        {
+        CAMHAL_LOGDB("Queuing buffer on Preview port - 0x%x", (uint32_t)mPreviewData->mBufferHeader[index]->pBuffer);
+        eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp,
+                    (OMX_BUFFERHEADERTYPE*)mPreviewData->mBufferHeader[index]);
+        if(eError!=OMX_ErrorNone)
+            {
+            CAMHAL_LOGEB("OMX_FillThisBuffer-0x%x", eError);
+            }
+        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+        }
+
+    if ( mMeasurementEnabled )
+        {
+
+        for(int index=0;index< mPreviewData->mNumBufs;index++)
+            {
+            CAMHAL_LOGDB("Queuing buffer on Measurement port - 0x%x", (uint32_t) measurementData->mBufferHeader[index]->pBuffer);
+            eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp,
+                            (OMX_BUFFERHEADERTYPE*) measurementData->mBufferHeader[index]);
+            if(eError!=OMX_ErrorNone)
+                {
+                CAMHAL_LOGEB("OMX_FillThisBuffer-0x%x", eError);
+                }
+            GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+            }
+
+        }
+
+    if ( mPending3Asettings )
+        apply3Asettings(mParameters3A);
+
+    //Query current focus distance after
+    //starting the preview
+    updateFocusDistances(mParameters);
+
+    //reset frame rate estimates
+    mFPS = 0.0f;
+    mLastFPS = 0.0f;
+    mFrameCount = 0;
+    mLastFrameCount = 0;
+    mIter = 1;
+    mLastFPSTime = systemTime();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+
+    EXIT:
+
+    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return (ret | ErrorUtils::omxToAndroidError(eError));
+
+}
+
+status_t OMXCameraAdapter::stopPreview()
+{
+    LOG_FUNCTION_NAME;
+
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    status_t ret = NO_ERROR;
+
+    OMXCameraPortParameters *mCaptureData , *mPreviewData, *measurementData;
+    mCaptureData = mPreviewData = measurementData = NULL;
+
+    mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+    mCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+    measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
+
+    if ( mComponentState != OMX_StateExecuting )
+        {
+        CAMHAL_LOGEA("Calling StopPreview() when not in EXECUTING state");
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    ret = cancelAutoFocus();
+    if(ret!=NO_ERROR)
+    {
+        CAMHAL_LOGEB("Error canceling autofocus %d", ret);
+        // Error, but we probably still want to continue to stop preview
+    }
+
+    ret = release3ALock();
+    if(ret!=NO_ERROR)
+      {
+        CAMHAL_LOGEB("Error Releaseing 3A locks%d", ret);
+      }
+
+    if ( 0 != mStopPreviewSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mStopPreviewSem semaphore count %d", mStopPreviewSem.Count());
+        LOG_FUNCTION_NAME_EXIT;
+        return NO_INIT;
+        }
+
+    CAMHAL_LOGDB("Average framerate: %f", mFPS);
+
+    //Avoid state switching of the OMX Component
+    ret = flushBuffers();
+    if ( NO_ERROR != ret )
+        {
+        CAMHAL_LOGEB("Flush Buffers failed 0x%x", ret);
+        goto EXIT;
+        }
+
+    ///Register for Preview port Disable event
+    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandPortDisable,
+                           mCameraAdapterParameters.mPrevPortIndex,
+                           mStopPreviewSem);
+
+    ///Disable Preview Port
+    eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                             OMX_CommandPortDisable,
+                             mCameraAdapterParameters.mPrevPortIndex,
+                             NULL);
+
+    ///Free the OMX Buffers
+    for ( int i = 0 ; i < mPreviewData->mNumBufs ; i++ )
+        {
+        eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp,
+                                mCameraAdapterParameters.mPrevPortIndex,
+                                mPreviewData->mBufferHeader[i]);
+
+        if(eError!=OMX_ErrorNone)
+            {
+            CAMHAL_LOGEB("OMX_FreeBuffer - %x", eError);
+            }
+        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+        }
+
+    if ( mMeasurementEnabled )
+        {
+
+            for ( int i = 0 ; i < measurementData->mNumBufs ; i++ )
+                {
+                eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp,
+                                        mCameraAdapterParameters.mMeasurementPortIndex,
+                                        measurementData->mBufferHeader[i]);
+                if(eError!=OMX_ErrorNone)
+                    {
+                    CAMHAL_LOGEB("OMX_FreeBuffer - %x", eError);
+                    }
+                GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+                }
+
+            {
+            Mutex::Autolock lock(mPreviewDataBufferLock);
+            mPreviewDataBuffersAvailable.clear();
+            }
+
+        }
+
+    CAMHAL_LOGDA("Disabling preview port");
+    ret = mStopPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
+    if ( NO_ERROR == ret )
+        {
+        CAMHAL_LOGDA("Preview port disabled");
+        }
+    else
+        {
+        ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandPortDisable,
+                           mCameraAdapterParameters.mPrevPortIndex,
+                           NULL);
+        CAMHAL_LOGEA("Timeout expired on preview port disable");
+        goto EXIT;
+        }
+
+        {
+        Mutex::Autolock lock(mPreviewBufferLock);
+        ///Clear all the available preview buffers
+        mPreviewBuffersAvailable.clear();
+        }
+
+    switchToLoaded();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return (ret | ErrorUtils::omxToAndroidError(eError));
+
+    EXIT:
+
+    {
+    Mutex::Autolock lock(mPreviewBufferLock);
+    ///Clear all the available preview buffers
+    mPreviewBuffersAvailable.clear();
+    }
+
+    switchToLoaded();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return (ret | ErrorUtils::omxToAndroidError(eError));
+
+}
+
+status_t OMXCameraAdapter::setSensorOverclock(bool enable)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_BOOLEANTYPE bOMX;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateLoaded != mComponentState )
+        {
+        CAMHAL_LOGDA("OMX component is not in loaded state");
+        return ret;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
+
+        if ( enable )
+            {
+            bOMX.bEnabled = OMX_TRUE;
+            }
+        else
+            {
+            bOMX.bEnabled = OMX_FALSE;
+            }
+
+        CAMHAL_LOGDB("Configuring Sensor overclock mode 0x%x", bOMX.bEnabled);
+        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexParamSensorOverClockMode, &bOMX);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while setting Sensor overclock 0x%x", eError);
+            ret = BAD_VALUE;
+            }
+        else
+            {
+            mSensorOverclock = enable;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::printComponentVersion(OMX_HANDLETYPE handle)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_VERSIONTYPE compVersion;
+    char compName[OMX_MAX_STRINGNAME_SIZE];
+    char *currentUUID = NULL;
+    size_t offset = 0;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == handle )
+        {
+        CAMHAL_LOGEB("Invalid OMX Handle =0x%x",  ( unsigned int ) handle);
+        ret = -EINVAL;
+        }
+
+    mCompUUID[0] = 0;
+
+    if ( NO_ERROR == ret )
+        {
+        eError = OMX_GetComponentVersion(handle,
+                                      compName,
+                                      &compVersion,
+                                      &mCompRevision,
+                                      &mCompUUID
+                                    );
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("OMX_GetComponentVersion returned 0x%x", eError);
+            ret = BAD_VALUE;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        CAMHAL_LOGVB("OMX Component name: [%s]", compName);
+        CAMHAL_LOGVB("OMX Component version: [%u]", ( unsigned int ) compVersion.nVersion);
+        CAMHAL_LOGVB("Spec version: [%u]", ( unsigned int ) mCompRevision.nVersion);
+        CAMHAL_LOGVB("Git Commit ID: [%s]", mCompUUID);
+        currentUUID = ( char * ) mCompUUID;
+        }
+
+    if ( NULL != currentUUID )
+        {
+        offset = strlen( ( const char * ) mCompUUID) + 1;
+        if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
+            {
+            currentUUID += offset;
+            CAMHAL_LOGVB("Git Branch: [%s]", currentUUID);
+            }
+        else
+            {
+            ret = BAD_VALUE;
+            }
+    }
+
+    if ( NO_ERROR == ret )
+        {
+        offset = strlen( ( const char * ) currentUUID) + 1;
+
+        if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
+            {
+            currentUUID += offset;
+            CAMHAL_LOGVB("Build date and time: [%s]", currentUUID);
+            }
+        else
+            {
+            ret = BAD_VALUE;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        offset = strlen( ( const char * ) currentUUID) + 1;
+
+        if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
+            {
+            currentUUID += offset;
+            CAMHAL_LOGVB("Build description: [%s]", currentUUID);
+            }
+        else
+            {
+            ret = BAD_VALUE;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::autoFocus()
+{
+    status_t ret = NO_ERROR;
+    TIUTILS::Message msg;
+
+    LOG_FUNCTION_NAME;
+
+    msg.command = CommandHandler::CAMERA_PERFORM_AUTOFOCUS;
+    msg.arg1 = mErrorNotifier;
+    ret = mCommandHandler->put(&msg);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::takePicture()
+{
+    status_t ret = NO_ERROR;
+    TIUTILS::Message msg;
+
+    LOG_FUNCTION_NAME;
+
+    msg.command = CommandHandler::CAMERA_START_IMAGE_CAPTURE;
+    msg.arg1 = mErrorNotifier;
+    ret = mCommandHandler->put(&msg);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::startVideoCapture()
+{
+    return BaseCameraAdapter::startVideoCapture();
+}
+
+status_t OMXCameraAdapter::stopVideoCapture()
+{
+    return BaseCameraAdapter::stopVideoCapture();
+}
+
+//API to get the frame size required to be allocated. This size is used to override the size passed
+//by camera service when VSTAB/VNF is turned ON for example
+status_t OMXCameraAdapter::getFrameSize(size_t &width, size_t &height)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_RECTTYPE tFrameDim;
+
+    LOG_FUNCTION_NAME;
+
+    OMX_INIT_STRUCT_PTR (&tFrameDim, OMX_CONFIG_RECTTYPE);
+    tFrameDim.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+
+    if ( mOMXStateSwitch )
+        {
+
+        ret = switchToLoaded();
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("switchToLoaded() failed 0x%x", ret);
+            goto exit;
+            }
+
+        mOMXStateSwitch = false;
+        }
+
+    if ( OMX_StateLoaded == mComponentState )
+        {
+
+        ret = setLDC(mIPP);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("setLDC() failed %d", ret);
+            LOG_FUNCTION_NAME_EXIT;
+            goto exit;
+            }
+
+        ret = setNSF(mIPP);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("setNSF() failed %d", ret);
+            LOG_FUNCTION_NAME_EXIT;
+            goto exit;
+            }
+
+        ret = setCaptureMode(mCapMode);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("setCaptureMode() failed %d", ret);
+            }
+
+        if(mCapMode == OMXCameraAdapter::VIDEO_MODE)
+            {
+            if ( NO_ERROR == ret )
+                {
+                ///Enable/Disable Video Noise Filter
+                ret = enableVideoNoiseFilter(mVnfEnabled);
+                }
+
+            if ( NO_ERROR != ret)
+                {
+                CAMHAL_LOGEB("Error configuring VNF %x", ret);
+                }
+
+            if ( NO_ERROR == ret )
+                {
+                ///Enable/Disable Video Stabilization
+                ret = enableVideoStabilization(mVstabEnabled);
+                }
+
+            if ( NO_ERROR != ret)
+                {
+                CAMHAL_LOGEB("Error configuring VSTAB %x", ret);
+                }
+             }
+        else
+            {
+            if ( NO_ERROR == ret )
+                {
+                ///Enable/Disable Video Noise Filter
+                ret = enableVideoNoiseFilter(false);
+                }
+
+            if ( NO_ERROR != ret)
+                {
+                CAMHAL_LOGEB("Error configuring VNF %x", ret);
+                }
+
+            if ( NO_ERROR == ret )
+                {
+                ///Enable/Disable Video Stabilization
+                ret = enableVideoStabilization(false);
+                }
+
+            if ( NO_ERROR != ret)
+                {
+                CAMHAL_LOGEB("Error configuring VSTAB %x", ret);
+                }
+            }
+
+        }
+
+    ret = setSensorOrientation(mSensorOrientation);
+    if ( NO_ERROR != ret )
+        {
+        CAMHAL_LOGEB("Error configuring Sensor Orientation %x", ret);
+        mSensorOrientation = 0;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexParam2DBufferAllocDimension, &tFrameDim);
+        if ( OMX_ErrorNone == eError)
+            {
+            width = tFrameDim.nWidth;
+            height = tFrameDim.nHeight;
+            }
+        }
+
+exit:
+
+    CAMHAL_LOGDB("Required frame size %dx%d", width, height);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount)
+{
+    status_t ret = NO_ERROR;
+    OMX_PARAM_PORTDEFINITIONTYPE portCheck;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateLoaded != mComponentState )
+        {
+        CAMHAL_LOGEA("Calling getFrameDataSize() when not in LOADED state");
+        dataFrameSize = 0;
+        ret = BAD_VALUE;
+        }
+
+    if ( NO_ERROR == ret  )
+        {
+        OMX_INIT_STRUCT_PTR(&portCheck, OMX_PARAM_PORTDEFINITIONTYPE);
+        portCheck.nPortIndex = mCameraAdapterParameters.mMeasurementPortIndex;
+
+        eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("OMX_GetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError);
+            dataFrameSize = 0;
+            ret = BAD_VALUE;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        portCheck.nBufferCountActual = bufferCount;
+        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("OMX_SetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError);
+            dataFrameSize = 0;
+            ret = BAD_VALUE;
+            }
+        }
+
+    if ( NO_ERROR == ret  )
+        {
+        eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("OMX_GetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError);
+            ret = BAD_VALUE;
+            }
+        else
+            {
+            mCameraAdapterParameters.mCameraPortParams[portCheck.nPortIndex].mBufSize = portCheck.nBufferSize;
+            dataFrameSize = portCheck.nBufferSize;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+void OMXCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt)
+{
+    LOG_FUNCTION_NAME;
+
+    static const int DEGREES_TILT_IGNORE = 45;
+    int device_orientation = 0;
+    int mount_orientation = 0;
+    const char *facing_direction = NULL;
+
+    // if tilt angle is greater than DEGREES_TILT_IGNORE
+    // we are going to ignore the orientation returned from
+    // sensor. the orientation returned from sensor is not
+    // reliable. Value of DEGREES_TILT_IGNORE may need adjusting
+    if (tilt > DEGREES_TILT_IGNORE) {
+        return;
+    }
+
+    if (mCapabilities) {
+        if (mCapabilities->get(CameraProperties::ORIENTATION_INDEX)) {
+            mount_orientation = atoi(mCapabilities->get(CameraProperties::ORIENTATION_INDEX));
+        }
+        facing_direction = mCapabilities->get(CameraProperties::FACING_INDEX);
+    }
+
+    // calculate device orientation relative to the sensor orientation
+    // front camera display is mirrored
+    if (facing_direction && !strcmp(facing_direction, TICameraParameters::FACING_FRONT)) {
+        device_orientation = (orientation - mount_orientation + 360) % 360;
+    } else {  // back-facing camera
+        device_orientation = (orientation + mount_orientation) % 360;
+    }
+
+    if (device_orientation != mDeviceOrientation) {
+        mDeviceOrientation = device_orientation;
+
+        mFaceDetectionLock.lock();
+        if (mFaceDetectionRunning) {
+            // restart face detection with new rotation
+            setFaceDetection(true, mDeviceOrientation);
+        }
+        mFaceDetectionLock.unlock();
+    }
+    CAMHAL_LOGVB("orientation = %d tilt = %d device_orientation = %d", orientation, tilt, mDeviceOrientation);
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/* Application callback Functions */
+/*========================================================*/
+/* @ fn SampleTest_EventHandler :: Application callback   */
+/*========================================================*/
+OMX_ERRORTYPE OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+                                          OMX_IN OMX_PTR pAppData,
+                                          OMX_IN OMX_EVENTTYPE eEvent,
+                                          OMX_IN OMX_U32 nData1,
+                                          OMX_IN OMX_U32 nData2,
+                                          OMX_IN OMX_PTR pEventData)
+{
+    LOG_FUNCTION_NAME;
+
+    CAMHAL_LOGDB("Event %d", eEvent);
+
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMXCameraAdapter *oca = (OMXCameraAdapter*)pAppData;
+    ret = oca->OMXCameraAdapterEventHandler(hComponent, eEvent, nData1, nData2, pEventData);
+
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+/* Application callback Functions */
+/*========================================================*/
+/* @ fn SampleTest_EventHandler :: Application callback   */
+/*========================================================*/
+OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+                                          OMX_IN OMX_EVENTTYPE eEvent,
+                                          OMX_IN OMX_U32 nData1,
+                                          OMX_IN OMX_U32 nData2,
+                                          OMX_IN OMX_PTR pEventData)
+{
+
+    LOG_FUNCTION_NAME;
+
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    CAMHAL_LOGDB("+OMX_Event %x, %d %d", eEvent, (int)nData1, (int)nData2);
+
+    switch (eEvent) {
+        case OMX_EventCmdComplete:
+            CAMHAL_LOGDB("+OMX_EventCmdComplete %d %d", (int)nData1, (int)nData2);
+
+            if (OMX_CommandStateSet == nData1) {
+                mCameraAdapterParameters.mState = (OMX_STATETYPE) nData2;
+
+            } else if (OMX_CommandFlush == nData1) {
+                CAMHAL_LOGDB("OMX_CommandFlush received for port %d", (int)nData2);
+
+            } else if (OMX_CommandPortDisable == nData1) {
+                CAMHAL_LOGDB("OMX_CommandPortDisable received for port %d", (int)nData2);
+
+            } else if (OMX_CommandPortEnable == nData1) {
+                CAMHAL_LOGDB("OMX_CommandPortEnable received for port %d", (int)nData2);
+
+            } else if (OMX_CommandMarkBuffer == nData1) {
+                ///This is not used currently
+            }
+
+            CAMHAL_LOGDA("-OMX_EventCmdComplete");
+        break;
+
+        case OMX_EventIndexSettingChanged:
+            CAMHAL_LOGDB("OMX_EventIndexSettingChanged event received data1 0x%x, data2 0x%x",
+                            ( unsigned int ) nData1, ( unsigned int ) nData2);
+            break;
+
+        case OMX_EventError:
+            CAMHAL_LOGDB("OMX interface failed to execute OMX command %d", (int)nData1);
+            CAMHAL_LOGDA("See OMX_INDEXTYPE for reference");
+            if ( NULL != mErrorNotifier && ( ( OMX_U32 ) OMX_ErrorHardware == nData1 ) && mComponentState != OMX_StateInvalid)
+              {
+                CAMHAL_LOGEA("***Got Fatal Error Notification***\n");
+                mComponentState = OMX_StateInvalid;
+                ///Report Error to App
+                mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN);
+              }
+            break;
+
+        case OMX_EventMark:
+        break;
+
+        case OMX_EventPortSettingsChanged:
+        break;
+
+        case OMX_EventBufferFlag:
+        break;
+
+        case OMX_EventResourcesAcquired:
+        break;
+
+        case OMX_EventComponentResumed:
+        break;
+
+        case OMX_EventDynamicResourcesAvailable:
+        break;
+
+        case OMX_EventPortFormatDetected:
+        break;
+
+        default:
+        break;
+    }
+
+    ///Signal to the thread(s) waiting that the event has occured
+    SignalEvent(hComponent, eEvent, nData1, nData2, pEventData);
+
+   LOG_FUNCTION_NAME_EXIT;
+   return eError;
+
+    EXIT:
+
+    CAMHAL_LOGEB("Exiting function %s because of eError=%x", __FUNCTION__, eError);
+    LOG_FUNCTION_NAME_EXIT;
+    return eError;
+}
+
+OMX_ERRORTYPE OMXCameraAdapter::SignalEvent(OMX_IN OMX_HANDLETYPE hComponent,
+                                          OMX_IN OMX_EVENTTYPE eEvent,
+                                          OMX_IN OMX_U32 nData1,
+                                          OMX_IN OMX_U32 nData2,
+                                          OMX_IN OMX_PTR pEventData)
+{
+    Mutex::Autolock lock(mEventLock);
+    TIUTILS::Message *msg;
+
+    LOG_FUNCTION_NAME;
+
+    if ( !mEventSignalQ.isEmpty() )
+        {
+        CAMHAL_LOGDA("Event queue not empty");
+
+        for ( unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ )
+            {
+            msg = mEventSignalQ.itemAt(i);
+            if ( NULL != msg )
+                {
+                if( ( msg->command != 0 || msg->command == ( unsigned int ) ( eEvent ) )
+                    && ( !msg->arg1 || ( OMX_U32 ) msg->arg1 == nData1 )
+                    && ( !msg->arg2 || ( OMX_U32 ) msg->arg2 == nData2 )
+                    && msg->arg3)
+                    {
+                    Semaphore *sem  = (Semaphore*) msg->arg3;
+                    CAMHAL_LOGDA("Event matched, signalling sem");
+                    mEventSignalQ.removeAt(i);
+                    //Signal the semaphore provided
+                    sem->Signal();
+                    free(msg);
+                    break;
+                    }
+                }
+            }
+        }
+    else
+        {
+        CAMHAL_LOGEA("Event queue empty!!!");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return OMX_ErrorNone;
+}
+
+status_t OMXCameraAdapter::RegisterForEvent(OMX_IN OMX_HANDLETYPE hComponent,
+                                          OMX_IN OMX_EVENTTYPE eEvent,
+                                          OMX_IN OMX_U32 nData1,
+                                          OMX_IN OMX_U32 nData2,
+                                          OMX_IN Semaphore &semaphore)
+{
+    status_t ret = NO_ERROR;
+    ssize_t res;
+    Mutex::Autolock lock(mEventLock);
+
+    LOG_FUNCTION_NAME;
+
+    TIUTILS::Message * msg = ( struct TIUTILS::Message * ) malloc(sizeof(struct TIUTILS::Message));
+    if ( NULL != msg )
+        {
+        msg->command = ( unsigned int ) eEvent;
+        msg->arg1 = ( void * ) nData1;
+        msg->arg2 = ( void * ) nData2;
+        msg->arg3 = ( void * ) &semaphore;
+        msg->arg4 =  ( void * ) hComponent;
+        res = mEventSignalQ.add(msg);
+        if ( NO_MEMORY == res )
+            {
+            CAMHAL_LOGEA("No ressources for inserting OMX events");
+            ret = -ENOMEM;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+/*========================================================*/
+/* @ fn SampleTest_EmptyBufferDone :: Application callback*/
+/*========================================================*/
+OMX_ERRORTYPE OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                   OMX_IN OMX_PTR pAppData,
+                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader)
+{
+    LOG_FUNCTION_NAME;
+
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+    OMXCameraAdapter *oca = (OMXCameraAdapter*)pAppData;
+    eError = oca->OMXCameraAdapterEmptyBufferDone(hComponent, pBuffHeader);
+
+    LOG_FUNCTION_NAME_EXIT;
+    return eError;
+}
+
+
+/*========================================================*/
+/* @ fn SampleTest_EmptyBufferDone :: Application callback*/
+/*========================================================*/
+OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader)
+{
+
+   LOG_FUNCTION_NAME;
+
+   LOG_FUNCTION_NAME_EXIT;
+
+   return OMX_ErrorNone;
+}
+
+static void debugShowFPS()
+{
+    static int mFrameCount = 0;
+    static int mLastFrameCount = 0;
+    static nsecs_t mLastFpsTime = 0;
+    static float mFps = 0;
+    mFrameCount++;
+    if (!(mFrameCount & 0x1F)) {
+        nsecs_t now = systemTime();
+        nsecs_t diff = now - mLastFpsTime;
+        mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
+        mLastFpsTime = now;
+        mLastFrameCount = mFrameCount;
+        LOGD("Camera %d Frames, %f FPS", mFrameCount, mFps);
+    }
+    // XXX: mFPS has the value we want
+}
+
+/*========================================================*/
+/* @ fn SampleTest_FillBufferDone ::  Application callback*/
+/*========================================================*/
+OMX_ERRORTYPE OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                   OMX_IN OMX_PTR pAppData,
+                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader)
+{
+    TIUTILS::Message msg;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+    if (UNLIKELY(mDebugFps)) {
+        debugShowFPS();
+    }
+
+    OMXCameraAdapter *adapter =  ( OMXCameraAdapter * ) pAppData;
+    if ( NULL != adapter )
+        {
+        msg.command = OMXCameraAdapter::OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE;
+        msg.arg1 = ( void * ) hComponent;
+        msg.arg2 = ( void * ) pBuffHeader;
+        adapter->mOMXCallbackHandler->put(&msg);
+        }
+
+    return eError;
+}
+
+/*========================================================*/
+/* @ fn SampleTest_FillBufferDone ::  Application callback*/
+/*========================================================*/
+OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader)
+{
+
+    status_t  stat = NO_ERROR;
+    status_t  res1, res2;
+    OMXCameraPortParameters  *pPortParam;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    CameraFrame::FrameType typeOfFrame = CameraFrame::ALL_FRAMES;
+    unsigned int refCount = 0;
+    BaseCameraAdapter::AdapterState state;
+    BaseCameraAdapter::getState(state);
+    sp<CameraFDResult> fdResult = NULL;
+
+    res1 = res2 = NO_ERROR;
+    pPortParam = &(mCameraAdapterParameters.mCameraPortParams[pBuffHeader->nOutputPortIndex]);
+    if (pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW)
+        {
+
+        if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE )
+            {
+            return OMX_ErrorNone;
+            }
+
+        recalculateFPS();
+
+            {
+            Mutex::Autolock lock(mFaceDetectionLock);
+            if ( mFaceDetectionRunning ) {
+                detectFaces(pBuffHeader, fdResult, pPortParam->mWidth, pPortParam->mHeight);
+                if ( NULL != fdResult.get() ) {
+                    notifyFaceSubscribers(fdResult);
+                    fdResult.clear();
+                }
+            }
+            }
+
+        stat |= advanceZoom();
+
+        ///On the fly update to 3A settings not working
+        if( mPending3Asettings )
+            {
+            apply3Asettings(mParameters3A);
+            }
+
+        ///Prepare the frames to be sent - initialize CameraFrame object and reference count
+        CameraFrame cameraFrameVideo, cameraFramePreview;
+        if ( mRecording )
+            {
+            res1 = initCameraFrame(cameraFrameVideo,
+                                   pBuffHeader,
+                                   CameraFrame::VIDEO_FRAME_SYNC,
+                                   pPortParam);
+            }
+
+        if( mWaitingForSnapshot )
+            {
+            typeOfFrame = CameraFrame::SNAPSHOT_FRAME;
+            }
+        else
+            {
+            typeOfFrame = CameraFrame::PREVIEW_FRAME_SYNC;
+            }
+
+        LOGV("FBD pBuffer = 0x%x", pBuffHeader->pBuffer);
+
+        res2 = initCameraFrame(cameraFramePreview,
+                               pBuffHeader,
+                               typeOfFrame,
+                               pPortParam);
+
+        stat |= res1 | res2;
+
+        if ( mRecording )
+            {
+            res1  = sendFrame(cameraFrameVideo);
+            }
+
+        if( mWaitingForSnapshot )
+            {
+            mSnapshotCount++;
+
+            if (  ( mSnapshotCount == 1 ) &&
+                ( HIGH_SPEED == mCapMode ) )
+                {
+                notifyShutterSubscribers();
+                }
+            }
+
+        res2 = sendFrame(cameraFramePreview);
+
+        stat |= ( ( NO_ERROR == res1 ) || ( NO_ERROR == res2 ) ) ? ( ( int ) NO_ERROR ) : ( -1 );
+
+        }
+    else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT )
+        {
+        typeOfFrame = CameraFrame::FRAME_DATA_SYNC;
+        CameraFrame cameraFrame;
+        stat |= initCameraFrame(cameraFrame,
+                                pBuffHeader,
+                                typeOfFrame,
+                                pPortParam);
+        stat |= sendFrame(cameraFrame);
+       }
+    else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_IMAGE_OUT_IMAGE )
+        {
+
+        if ( OMX_COLOR_FormatUnused == mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mColorFormat )
+            {
+            typeOfFrame = CameraFrame::IMAGE_FRAME;
+            }
+        else
+            {
+            typeOfFrame = CameraFrame::RAW_FRAME;
+            }
+
+            pPortParam->mImageType = typeOfFrame;
+
+            if((mCapturedFrames>0) && !mCaptureSignalled)
+                {
+                mCaptureSignalled = true;
+                mCaptureSem.Signal();
+                }
+
+            if( ( CAPTURE_ACTIVE & state ) != CAPTURE_ACTIVE )
+                {
+                goto EXIT;
+                }
+
+            {
+            Mutex::Autolock lock(mBracketingLock);
+            if ( mBracketingEnabled )
+                {
+                doBracketing(pBuffHeader, typeOfFrame);
+                return eError;
+                }
+            }
+
+        if ( 1 > mCapturedFrames )
+            {
+            goto EXIT;
+            }
+
+        CAMHAL_LOGDB("Captured Frames: %d", mCapturedFrames);
+
+        mCapturedFrames--;
+
+        CameraFrame cameraFrame;
+        stat |= initCameraFrame(cameraFrame,
+                                pBuffHeader,
+                                typeOfFrame,
+                                pPortParam);
+        stat |= sendFrame(cameraFrame);
+        }
+    else
+        {
+        CAMHAL_LOGEA("Frame received for non-(preview/capture/measure) port. This is yet to be supported");
+        goto EXIT;
+        }
+
+    if ( NO_ERROR != stat )
+        {
+        CAMHAL_LOGDB("sendFrameToSubscribers error: %d", stat);
+        returnFrame(pBuffHeader->pBuffer, typeOfFrame);
+        }
+
+    return eError;
+
+    EXIT:
+
+    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, stat, eError);
+
+    if ( NO_ERROR != stat )
+        {
+        if ( NULL != mErrorNotifier )
+            {
+            mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN);
+            }
+        }
+
+    return eError;
+}
+
+status_t OMXCameraAdapter::recalculateFPS()
+{
+    float currentFPS;
+
+    mFrameCount++;
+
+    if ( ( mFrameCount % FPS_PERIOD ) == 0 )
+        {
+        nsecs_t now = systemTime();
+        nsecs_t diff = now - mLastFPSTime;
+        currentFPS =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
+        mLastFPSTime = now;
+        mLastFrameCount = mFrameCount;
+
+        if ( 1 == mIter )
+            {
+            mFPS = currentFPS;
+            }
+        else
+            {
+            //cumulative moving average
+            mFPS = mLastFPS + (currentFPS - mLastFPS)/mIter;
+            }
+
+        mLastFPS = mFPS;
+        mIter++;
+        }
+
+    return NO_ERROR;
+}
+
+status_t OMXCameraAdapter::sendFrame(CameraFrame &frame)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+
+    if ( NO_ERROR == ret )
+        {
+        ret = sendFrameToSubscribers(&frame);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::initCameraFrame( CameraFrame &frame,
+                                            OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader,
+                                            int typeOfFrame,
+                                            OMXCameraPortParameters *port)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == port)
+        {
+        CAMHAL_LOGEA("Invalid portParam");
+        return -EINVAL;
+        }
+
+    if ( NULL == pBuffHeader )
+        {
+        CAMHAL_LOGEA("Invalid Buffer header");
+        return -EINVAL;
+        }
+
+    frame.mFrameType = typeOfFrame;
+    frame.mBuffer = pBuffHeader->pBuffer;
+    frame.mLength = pBuffHeader->nFilledLen;
+    frame.mAlignment = port->mStride;
+    frame.mOffset = pBuffHeader->nOffset;
+    frame.mWidth = port->mWidth;
+    frame.mHeight = port->mHeight;
+
+    // Calculating the time source delta of Ducati & system time only once at the start of camera.
+    // It's seen that there is a one-time constant diff between the ducati source clock &
+    // System monotonic timer, although both derived from the same 32KHz clock.
+    // This delta is offsetted to/from ducati timestamp to match with system time so that
+    // video timestamps are aligned with Audio with a periodic timestamp intervals.
+    if ( onlyOnce )
+        {
+        mTimeSourceDelta = (pBuffHeader->nTimeStamp * 1000) - systemTime(SYSTEM_TIME_MONOTONIC);
+        onlyOnce = false;
+        }
+
+    // Calculating the new video timestamp based on offset from ducati source.
+    frame.mTimestamp = (pBuffHeader->nTimeStamp * 1000) - mTimeSourceDelta;
+
+        LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+bool OMXCameraAdapter::CommandHandler::Handler()
+{
+    TIUTILS::Message msg;
+    volatile int forever = 1;
+    status_t stat;
+    ErrorNotifier *errorNotify = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    while ( forever )
+        {
+        stat = NO_ERROR;
+        CAMHAL_LOGDA("Handler: waiting for messsage...");
+        TIUTILS::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1);
+        mCommandMsgQ.get(&msg);
+        CAMHAL_LOGDB("msg.command = %d", msg.command);
+        switch ( msg.command ) {
+            case CommandHandler::CAMERA_START_IMAGE_CAPTURE:
+            {
+                stat = mCameraAdapter->startImageCapture();
+                break;
+            }
+            case CommandHandler::CAMERA_PERFORM_AUTOFOCUS:
+            {
+                stat = mCameraAdapter->doAutoFocus();
+                break;
+            }
+            case CommandHandler::COMMAND_EXIT:
+            {
+                CAMHAL_LOGEA("Exiting command handler");
+                forever = 0;
+                break;
+            }
+        }
+
+        if ( NO_ERROR != stat )
+            {
+            errorNotify = ( ErrorNotifier * ) msg.arg1;
+            if ( NULL != errorNotify )
+                {
+                errorNotify->errorNotify(CAMERA_ERROR_UNKNOWN);
+                }
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return false;
+}
+
+bool OMXCameraAdapter::OMXCallbackHandler::Handler()
+{
+    TIUTILS::Message msg;
+    volatile int forever = 1;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    while(forever){
+        TIUTILS::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1);
+        mCommandMsgQ.get(&msg);
+        switch ( msg.command ) {
+            case OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE:
+            {
+                ret = mCameraAdapter->OMXCameraAdapterFillBufferDone(( OMX_HANDLETYPE ) msg.arg1,
+                                                                     ( OMX_BUFFERHEADERTYPE *) msg.arg2);
+                break;
+            }
+            case CommandHandler::COMMAND_EXIT:
+            {
+                CAMHAL_LOGEA("Exiting OMX callback handler");
+                forever = 0;
+                break;
+            }
+        }
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+    return false;
+}
+
+OMXCameraAdapter::OMXCameraAdapter():mComponentState (OMX_StateInvalid)
+{
+    LOG_FUNCTION_NAME;
+
+    mPictureRotation = 0;
+    // Initial values
+    mTimeSourceDelta = 0;
+    onlyOnce = true;
+
+    mDoAFSem.Create(0);
+    mInitSem.Create(0);
+    mFlushSem.Create(0);
+    mUsePreviewDataSem.Create(0);
+    mUsePreviewSem.Create(0);
+    mUseCaptureSem.Create(0);
+    mStartPreviewSem.Create(0);
+    mStopPreviewSem.Create(0);
+    mStartCaptureSem.Create(0);
+    mStopCaptureSem.Create(0);
+    mSwitchToLoadedSem.Create(0);
+    mCaptureSem.Create(0);
+
+    mCameraAdapterParameters.mHandleComp = 0;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+OMXCameraAdapter::~OMXCameraAdapter()
+{
+    LOG_FUNCTION_NAME;
+
+    //Return to OMX Loaded state
+    switchToLoaded();
+
+    ///Free the handle for the Camera component
+    if(mCameraAdapterParameters.mHandleComp)
+        {
+        OMX_FreeHandle(mCameraAdapterParameters.mHandleComp);
+        }
+
+    ///De-init the OMX
+    if( (mComponentState==OMX_StateLoaded) || (mComponentState==OMX_StateInvalid))
+        {
+        OMX_Deinit();
+        }
+
+    //Exit and free ref to command handling thread
+    if ( NULL != mCommandHandler.get() )
+    {
+        TIUTILS::Message msg;
+        msg.command = CommandHandler::COMMAND_EXIT;
+        msg.arg1 = mErrorNotifier;
+        mCommandHandler->put(&msg);
+        mCommandHandler->requestExitAndWait();
+        mCommandHandler.clear();
+    }
+
+    //Exit and free ref to callback handling thread
+    if ( NULL != mOMXCallbackHandler.get() )
+    {
+        TIUTILS::Message msg;
+        msg.command = OMXCallbackHandler::COMMAND_EXIT;
+        mOMXCallbackHandler->put(&msg);
+        mOMXCallbackHandler->requestExitAndWait();
+        mOMXCallbackHandler.clear();
+    }
+
+    gCameraAdapter = NULL;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+extern "C" CameraAdapter* CameraAdapter_Factory()
+{
+    Mutex::Autolock lock(gAdapterLock);
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == gCameraAdapter )
+        {
+        CAMHAL_LOGDA("Creating new Camera adapter instance");
+        gCameraAdapter= new OMXCameraAdapter();
+        }
+    else
+        {
+        CAMHAL_LOGDA("Reusing existing Camera adapter instance");
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return gCameraAdapter;
+}
+
+extern "C" int CameraAdapter_Capabilities(CameraProperties::Properties* properties_array,
+                                          const unsigned int starting_camera,
+                                          const unsigned int max_camera) {
+    int num_cameras_supported = 0;
+    CameraProperties::Properties* properties = NULL;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_HANDLETYPE handle = NULL;
+    OMX_TI_CAPTYPE caps;
+
+    LOG_FUNCTION_NAME;
+
+    if (!properties_array) {
+        CAMHAL_LOGEB("invalid param: properties = 0x%p", properties_array);
+        LOG_FUNCTION_NAME_EXIT;
+        return -EINVAL;
+    }
+
+    // OMX_Init
+    eError = OMX_Init();
+    if (eError != OMX_ErrorNone) {
+        CAMHAL_LOGEB("OMX_Init -0x%x", eError);
+        return 0;  // no cameras supported
+    }
+
+    // Setup key parameters to send to Ducati during init
+    OMX_CALLBACKTYPE oCallbacks;
+
+    // Initialize the callback handles
+    oCallbacks.EventHandler    = android::OMXCameraAdapterEventHandler;
+    oCallbacks.EmptyBufferDone = android::OMXCameraAdapterEmptyBufferDone;
+    oCallbacks.FillBufferDone  = android::OMXCameraAdapterFillBufferDone;
+
+    // Get Handle
+    eError = OMX_GetHandle(&handle, (OMX_STRING)"OMX.TI.DUCATI1.VIDEO.CAMERA", NULL, &oCallbacks);
+    if (eError != OMX_ErrorNone) {
+        CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError);
+        goto EXIT;
+    }
+
+    // Continue selecting sensor and then querying OMX Camera for it's capabilities
+    // When sensor select returns an error, we know to break and stop
+    while (eError == OMX_ErrorNone &&
+           (starting_camera + num_cameras_supported) < max_camera) {
+        // sensor select
+        OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
+        OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
+        sensorSelect.eSensor = (OMX_SENSORSELECT) num_cameras_supported;
+        eError = OMX_SetConfig(handle, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect);
+
+        if ( OMX_ErrorNone != eError ) {
+            break;
+        }
+
+        // get and fill capabilities
+        properties = properties_array + starting_camera + num_cameras_supported;
+        OMXCameraAdapter::getCaps(properties, handle);
+
+        // need to fill facing information
+        // assume that only sensor 0 is back facing
+        if (num_cameras_supported == 0) {
+            properties->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_BACK);
+        } else {
+            properties->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_FRONT);
+        }
+
+        num_cameras_supported++;
+    }
+
+ EXIT:
+    // clean up
+    if(handle) {
+        OMX_FreeHandle(handle);
+    }
+    OMX_Deinit();
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return num_cameras_supported;
+}
+
+};
+
+
+/*--------------------Camera Adapter Class ENDS here-----------------------------*/
+
diff --git a/camera/OMXCameraAdapter/OMXCapabilities.cpp b/camera/OMXCameraAdapter/OMXCapabilities.cpp
new file mode 100644
index 0000000..fc961fa
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXCapabilities.cpp
@@ -0,0 +1,1181 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMXCap.cpp
+*
+* This file implements the OMX Capabilities feature.
+*
+*/
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+#include "ErrorUtils.h"
+#include "TICameraParameters.h"
+
+extern "C" {
+#include "memmgr.h"
+}
+
+namespace android {
+
+#undef LOG_TAG
+
+// Maintain a separate tag for OMXCameraAdapter logs to isolate issues OMX specific
+#define LOG_TAG "CameraHAL"
+
+/************************************
+ * global constants and variables
+ *************************************/
+
+#define ARRAY_SIZE(array) (sizeof((array)) / sizeof((array)[0]))
+#define FPS_MIN 5
+#define FPS_STEP 5
+#define FPS_RANGE_STEP 10
+
+static const char PARAM_SEP[] = ",";
+static const int PARAM_SEP_CHAR = ',';
+static const uint32_t VFR_OFFSET = 8;
+static const char VFR_BACKET_START[] = "(";
+static const char VFR_BRACKET_END[] = ")";
+static const char FRAMERATE_COUNT = 10;
+
+/**** look up tables to translate OMX Caps to Parameter ****/
+
+const CapResolution OMXCameraAdapter::mImageCapRes [] = {
+    { 4032, 3024, "4032x3024" },
+    { 4000, 3000, "4000x3000" },
+    { 3648, 2736, "3648x2736" },
+    { 3264, 2448, "3264x2448" },
+    { 2592, 1944, "2592x1944" },
+    { 2048, 1536, "2048x1536" },
+    { 1600, 1200, "1600x1200" },
+    { 1280, 1024, "1280x1024" },
+    { 1152, 864, "1152x864" },
+    { 1280, 960, "1280x960" },
+    { 640, 480, "640x480" },
+    { 320, 240, "320x240" },
+};
+
+const CapResolution OMXCameraAdapter::mPreviewRes [] = {
+    { 1920, 1080, "1920x1080" },
+    { 1280, 720, "1280x720" },
+    { 800, 480, "800x480" },
+    { 720, 576, "720x576" },
+    { 720, 480, "720x480" },
+    { 768, 576, "768x576" },
+    { 640, 480, "640x480" },
+    { 320, 240, "320x240" },
+    { 352, 288, "352x288" },
+    { 240, 160, "240x160" },
+    { 176, 144, "176x144" },
+    { 128, 96, "128x96" },
+};
+
+const CapResolution OMXCameraAdapter::mThumbRes [] = {
+    { 640, 480, "640x480" },
+    { 160, 120, "160x120" },
+    { 200, 120, "200x120" },
+    { 320, 240, "320x240" },
+    { 512, 384, "512x384" },
+    { 352, 144, "352x144" },
+    { 176, 144, "176x144" },
+    { 96, 96, "96x96" },
+};
+
+const CapPixelformat OMXCameraAdapter::mPixelformats [] = {
+    { OMX_COLOR_FormatCbYCrY, CameraParameters::PIXEL_FORMAT_YUV422I },
+    { OMX_COLOR_FormatYUV420SemiPlanar, CameraParameters::PIXEL_FORMAT_YUV420SP },
+    { OMX_COLOR_Format16bitRGB565, CameraParameters::PIXEL_FORMAT_RGB565 },
+    { OMX_COLOR_FormatRawBayer10bit, TICameraParameters::PIXEL_FORMAT_RAW },
+};
+
+const CapFramerate OMXCameraAdapter::mFramerates [] = {
+    { 30, "30" },
+    { 25, "25" },
+    { 24, "24" },
+    { 20, "20" },
+    { 15, "15" },
+    { 10, "10" },
+};
+
+const CapZoom OMXCameraAdapter::mZoomStages [] = {
+    { 65536, "100" },
+    { 68157, "104" },
+    { 70124, "107" },
+    { 72745, "111" },
+    { 75366, "115" },
+    { 77988, "119" },
+    { 80609, "123" },
+    { 83231, "127" },
+    { 86508, "132" },
+    { 89784, "137" },
+    { 92406, "141" },
+    { 95683, "146" },
+    { 99615, "152" },
+    { 102892, "157" },
+    { 106168, "162" },
+    { 110100, "168" },
+    { 114033, "174" },
+    { 117965, "180" },
+    { 122552, "187" },
+    { 126484, "193" },
+    { 131072, "200" },
+    { 135660, "207" },
+    { 140247, "214" },
+    { 145490, "222" },
+    { 150733, "230" },
+    { 155976, "238" },
+    { 161219, "246" },
+    { 167117, "255" },
+    { 173015, "264" },
+    { 178913, "273" },
+    { 185467, "283" },
+    { 192020, "293" },
+    { 198574, "303" },
+    { 205783, "314" },
+    { 212992, "325" },
+    { 220201, "336" },
+    { 228065, "348" },
+    { 236585, "361" },
+    { 244449, "373" },
+    { 252969, "386" },
+    { 262144, "400" },
+    { 271319, "414" },
+    { 281149, "429" },
+    { 290980, "444" },
+    { 300810, "459" },
+    { 311951, "476" },
+    { 322437, "492" },
+    { 334234, "510" },
+    { 346030, "528" },
+    { 357827, "546" },
+    { 370934, "566" },
+    { 384041, "586" },
+    { 397148, "606" },
+    { 411566, "628" },
+    { 425984, "650" },
+    { 441057, "673" },
+    { 456131, "696" },
+    { 472515, "721" },
+    { 488899, "746" },
+    { 506593, "773" },
+    { 524288, "800" },
+};
+
+const CapISO OMXCameraAdapter::mISOStages [] = {
+    { 0, "auto" },
+    { 100, "100" },
+    { 200, "200"},
+    { 400, "400" },
+    { 800, "800" },
+    { 1000, "1000" },
+    { 1200, "1200" },
+    { 1600, "1600" },
+};
+
+// mapped values have to match with new_sensor_MSP.h
+const CapU32 OMXCameraAdapter::mSensorNames [] = {
+    { 300, "IMX060" },
+    { 301, "OV5650" },
+    { 305, "S5K4E1GA"},
+    { 306, "S5K6A1GX03" }
+    // TODO(XXX): need to account for S3D camera later
+};
+
+/************************************
+ * static helper functions
+ *************************************/
+
+// utility function to remove last seperator
+void remove_last_sep(char* buffer) {
+    char* last_sep = NULL;
+    last_sep = strrchr(buffer, PARAM_SEP_CHAR);
+    if (last_sep != NULL) {
+        last_sep[0] = '\0';
+    }
+}
+
+
+/*****************************************
+ * internal static function declarations
+ *****************************************/
+
+/**** Utility functions to help translate OMX Caps to Parameter ****/
+
+status_t OMXCameraAdapter::encodePixelformatCap(OMX_COLOR_FORMATTYPE format,
+                              const CapPixelformat *cap,
+                              size_t capCount,
+                              char * buffer,
+                              size_t bufferSize) {
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( ( NULL == buffer ) || ( NULL == cap ) ) {
+        CAMHAL_LOGEA("Invalid input arguments");
+        return -EINVAL;
+    }
+
+    for ( unsigned int i = 0; i < capCount; i++ ) {
+        if ( format == cap[i].pixelformat ) {
+            strncat(buffer, cap[i].param, bufferSize - 1);
+            strncat(buffer, PARAM_SEP, bufferSize - 1);
+        }
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::encodeFramerateCap(OMX_U32 framerateMax,
+                            OMX_U32 framerateMin,
+                            const CapFramerate *cap,
+                            size_t capCount,
+                            char * buffer,
+                            size_t bufferSize) {
+    status_t ret = NO_ERROR;
+    bool minInserted = false;
+    bool maxInserted = false;
+    char tmpBuffer[FRAMERATE_COUNT];
+
+    LOG_FUNCTION_NAME;
+
+    if ( ( NULL == buffer ) || ( NULL == cap ) ) {
+        CAMHAL_LOGEA("Invalid input arguments");
+        return -EINVAL;
+    }
+
+    for ( unsigned int i = 0; i < capCount; i++ ) {
+        if ( (framerateMax >= cap[i].num) && (framerateMin <= cap[i].num) ) {
+            strncat(buffer, cap[i].param, bufferSize - 1);
+            strncat(buffer, PARAM_SEP, bufferSize - 1);
+
+            if ( cap[i].num ==  framerateMin ) {
+                minInserted = true;
+            }
+        }
+        if ( cap[i].num ==  framerateMax ) {
+            maxInserted = true;
+        }
+    }
+
+    if ( !maxInserted ) {
+        memset(tmpBuffer, 0, FRAMERATE_COUNT);
+        snprintf(tmpBuffer, FRAMERATE_COUNT - 1, "%u,", ( unsigned int ) framerateMax);
+        strncat(buffer, tmpBuffer, bufferSize - 1);
+        strncat(buffer, PARAM_SEP, bufferSize - 1);
+    }
+
+    if ( !minInserted ) {
+        memset(tmpBuffer, 0, FRAMERATE_COUNT);
+        snprintf(tmpBuffer, FRAMERATE_COUNT - 1, "%u,", ( unsigned int ) framerateMin);
+        strncat(buffer, tmpBuffer, bufferSize - 1);
+        strncat(buffer, PARAM_SEP, bufferSize - 1);
+    }
+
+    remove_last_sep(buffer);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::encodeVFramerateCap(OMX_TI_CAPTYPE &caps,
+                                               char *buffer,
+                                               char *defaultRange,
+                                               size_t bufferSize) {
+    status_t ret = NO_ERROR;
+    uint32_t minVFR, maxVFR;
+    char tmpBuffer[MAX_PROP_VALUE_LENGTH];
+    bool skipLast = false;
+    uint32_t min, max;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == buffer ) {
+        CAMHAL_LOGEA("Invalid input arguments");
+        return -EINVAL;
+    }
+
+    if(caps.ulPrvVarFPSModesCount < 1) {
+        return NO_ERROR;
+    }
+
+    // Assumption: last range in tPrvVarFPSModes will be for S30FPSHD mode
+    minVFR = caps.tPrvVarFPSModes[caps.ulPrvVarFPSModesCount-1].nVarFPSMin >> VFR_OFFSET;
+    maxVFR = caps.tPrvVarFPSModes[caps.ulPrvVarFPSModesCount-1].nVarFPSMax >> VFR_OFFSET;
+
+    if (minVFR < FPS_MIN) {
+        minVFR = FPS_MIN;
+    }
+
+    memset(tmpBuffer, '\0', MAX_PROP_VALUE_LENGTH);
+    min = max = 0;
+    for (unsigned int i = minVFR; i <= maxVFR; i += FPS_STEP) {
+
+        min = i * CameraHal::VFR_SCALE;
+        max = (i + FPS_RANGE_STEP) * CameraHal::VFR_SCALE;
+
+        snprintf(tmpBuffer, ( MAX_PROP_VALUE_LENGTH - 1 ), "(%d,%d)", min, min);
+        strncat(buffer, tmpBuffer, ( bufferSize - 1 ));
+        strncat(buffer, PARAM_SEP, bufferSize - 1);
+
+        if (max <= maxVFR * CameraHal::VFR_SCALE) {
+            snprintf(tmpBuffer, ( MAX_PROP_VALUE_LENGTH - 1 ), "(%d,%d)", min, max);
+            strncat(buffer, tmpBuffer, ( bufferSize - 1 ));
+            strncat(buffer, PARAM_SEP, bufferSize - 1);
+        }
+    }
+    remove_last_sep(buffer);
+
+    if ( 1 < strlen(tmpBuffer) ) {
+        snprintf(defaultRange, ( MAX_PROP_VALUE_LENGTH - 1 ), "%d,%d", min, min);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+size_t OMXCameraAdapter::encodeZoomCap(OMX_S32 maxZoom,
+                     const CapZoom *cap,
+                     size_t capCount,
+                     char * buffer,
+                     size_t bufferSize) {
+    status_t res = NO_ERROR;
+    size_t ret = 0;
+
+    LOG_FUNCTION_NAME;
+
+    if ( (NULL == buffer) || (NULL == cap) ) {
+        CAMHAL_LOGEA("Invalid input arguments");
+        return -EINVAL;
+    }
+
+
+    for ( unsigned int i = 0; i < capCount; i++ ) {
+        if ( cap[i].num <= maxZoom ) {
+            strncat(buffer, cap[i].param, bufferSize - 1);
+            strncat(buffer, PARAM_SEP, bufferSize - 1);
+            ret++;
+        }
+    }
+    remove_last_sep(buffer);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::encodeISOCap(OMX_U32 maxISO,
+                      const CapISO *cap,
+                      size_t capCount,
+                      char * buffer,
+                      size_t bufferSize) {
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( (NULL == buffer) || (NULL == cap) ) {
+        CAMHAL_LOGEA("Invalid input arguments");
+        return -EINVAL;
+    }
+
+    for ( unsigned int i = 0; i < capCount; i++ ) {
+        if ( cap[i].num <= maxISO) {
+            strncat(buffer, cap[i].param, bufferSize - 1);
+            strncat(buffer, PARAM_SEP, bufferSize - 1);
+        }
+    }
+    remove_last_sep(buffer);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::encodeSizeCap(OMX_TI_CAPRESTYPE &res,
+                       const CapResolution *cap,
+                       size_t capCount,
+                       char * buffer,
+                       size_t bufferSize) {
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( (NULL == buffer) || (NULL == cap) ) {
+        CAMHAL_LOGEA("Invalid input arguments");
+        return -EINVAL;
+    }
+
+    for ( unsigned int i = 0 ; i < capCount ; i++ ) {
+        if ( (cap[i].width <= res.nWidthMax) &&
+             (cap[i].height <= res.nHeightMax) &&
+             (cap[i].width >= res.nWidthMin) &&
+             (cap[i].height >= res.nHeightMin) ) {
+                strncat(buffer, cap[i].param, bufferSize -1);
+                strncat(buffer, PARAM_SEP, bufferSize - 1);
+        }
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertImageSizes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    ret = encodeSizeCap(caps.tImageResRange,
+                        mImageCapRes,
+                        ARRAY_SIZE(mImageCapRes),
+                        supported,
+                        MAX_PROP_VALUE_LENGTH);
+
+    if ( NO_ERROR != ret ) {
+        CAMHAL_LOGEB("Error inserting supported picture sizes 0x%x", ret);
+    } else {
+        remove_last_sep(supported);
+        params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, supported);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertPreviewSizes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    ret = encodeSizeCap(caps.tPreviewResRange,
+                        mPreviewRes,
+                        ARRAY_SIZE(mPreviewRes),
+                        supported,
+                        MAX_PROP_VALUE_LENGTH);
+
+    if ( NO_ERROR != ret ) {
+        CAMHAL_LOGEB("Error inserting supported preview sizes 0x%x", ret);
+    } else {
+        remove_last_sep(supported);
+        params->set(CameraProperties::SUPPORTED_PREVIEW_SIZES, supported);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertThumbSizes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    ret = encodeSizeCap(caps.tThumbResRange,
+                        mThumbRes,
+                        ARRAY_SIZE(mThumbRes),
+                        supported,
+                        MAX_PROP_VALUE_LENGTH);
+
+    if ( NO_ERROR != ret ) {
+        CAMHAL_LOGEB("Error inserting supported thumbnail sizes 0x%x", ret);
+    } else {
+        //CTS Requirement: 0x0 should always be supported
+        strncat(supported, "0x0", MAX_PROP_NAME_LENGTH);
+        params->set(CameraProperties::SUPPORTED_THUMBNAIL_SIZES, supported);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertZoomStages(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps)
+{
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    size_t zoomStageCount = 0;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    zoomStageCount = encodeZoomCap(caps.xMaxWidthZoom,
+                                   mZoomStages,
+                                   ARRAY_SIZE(mZoomStages),
+                                   supported,
+                                   MAX_PROP_VALUE_LENGTH);
+
+    params->set(CameraProperties::SUPPORTED_ZOOM_RATIOS, supported);
+    params->set(CameraProperties::SUPPORTED_ZOOM_STAGES, zoomStageCount - 1); //As per CTS requirement
+
+    if ( 0 == zoomStageCount ) {
+        params->set(CameraProperties::ZOOM_SUPPORTED, TICameraParameters::ZOOM_UNSUPPORTED);
+        params->set(CameraProperties::SMOOTH_ZOOM_SUPPORTED, TICameraParameters::ZOOM_UNSUPPORTED);
+    } else {
+        params->set(CameraProperties::ZOOM_SUPPORTED, TICameraParameters::ZOOM_SUPPORTED);
+        params->set(CameraProperties::SMOOTH_ZOOM_SUPPORTED, TICameraParameters::ZOOM_SUPPORTED);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertImageFormats(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( int i = 0 ; i < caps.ulImageFormatCount ; i++ ) {
+        ret = encodePixelformatCap(caps.eImageFormats[i],
+                                   mPixelformats,
+                                   ARRAY_SIZE(mPixelformats),
+                                   supported,
+                                   MAX_PROP_VALUE_LENGTH);
+        if ( NO_ERROR != ret ) {
+            CAMHAL_LOGEB("Error inserting supported picture formats 0x%x", ret);
+            break;
+        }
+    }
+
+    if ( NO_ERROR == ret ) {
+        //jpeg is not supported in OMX capabilies yet
+        strncat(supported, CameraParameters::PIXEL_FORMAT_JPEG, MAX_PROP_VALUE_LENGTH - 1);
+        params->set(CameraProperties::SUPPORTED_PICTURE_FORMATS, supported);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertPreviewFormats(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( int i = 0 ; i < caps.ulPreviewFormatCount; i++ ) {
+        ret = encodePixelformatCap(caps.ePreviewFormats[i],
+                                   mPixelformats,
+                                   ARRAY_SIZE(mPixelformats),
+                                   supported,
+                                   MAX_PROP_VALUE_LENGTH);
+        if ( NO_ERROR != ret ) {
+            CAMHAL_LOGEB("Error inserting supported preview formats 0x%x", ret);
+            break;
+        }
+    }
+
+    if ( NO_ERROR == ret ) {
+        // need to advertise we support YV12 format
+        // We will program preview port with NV21 when we see application set YV12
+        strncat(supported, CameraParameters::PIXEL_FORMAT_YUV420P, MAX_PROP_VALUE_LENGTH - 1);
+        params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS, supported);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertFramerates(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    ret = encodeFramerateCap(caps.xFramerateMax >> VFR_OFFSET,
+                             caps.xFramerateMin >> VFR_OFFSET,
+                             mFramerates,
+                             ARRAY_SIZE(mFramerates),
+                             supported,
+                             MAX_PROP_VALUE_LENGTH);
+
+    if ( NO_ERROR != ret ) {
+        CAMHAL_LOGEB("Error inserting supported preview framerates 0x%x", ret);
+    } else {
+        params->set(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES, supported);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertVFramerates(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    char defaultRange[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    ret = encodeVFramerateCap(caps, supported, defaultRange, MAX_PROP_VALUE_LENGTH);
+
+    if ( NO_ERROR != ret ) {
+        CAMHAL_LOGEB("Error inserting supported preview framerate ranges 0x%x", ret);
+    } else {
+        params->set(CameraProperties::FRAMERATE_RANGE_SUPPORTED, supported);
+        CAMHAL_LOGDB("framerate ranges %s", supported);
+        params->set(CameraProperties::FRAMERATE_RANGE, defaultRange);
+        CAMHAL_LOGDB("Default framerate range: [%s]", defaultRange);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertEVs(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    snprintf(supported, MAX_PROP_VALUE_LENGTH, "%d", ( int ) ( caps.xEVCompensationMin * 10 ));
+    params->set(CameraProperties::SUPPORTED_EV_MIN, supported);
+
+    snprintf(supported, MAX_PROP_VALUE_LENGTH, "%d", ( int ) ( caps.xEVCompensationMax * 10 ));
+    params->set(CameraProperties::SUPPORTED_EV_MAX, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertISOModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    ret = encodeISOCap(caps.nSensitivityMax,
+                       mISOStages,
+                       ARRAY_SIZE(mISOStages),
+                       supported,
+                       MAX_PROP_VALUE_LENGTH);
+    if ( NO_ERROR != ret ) {
+        CAMHAL_LOGEB("Error inserting supported ISO modes 0x%x", ret);
+    } else {
+        params->set(CameraProperties::SUPPORTED_ISO_VALUES, supported);
+    }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertIPPModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    //Off is always supported
+    strncat(supported, TICameraParameters::IPP_NONE, MAX_PROP_NAME_LENGTH);
+    strncat(supported, PARAM_SEP, 1);
+
+    if ( caps.bLensDistortionCorrectionSupported ) {
+        strncat(supported, TICameraParameters::IPP_LDC, MAX_PROP_NAME_LENGTH);
+        strncat(supported, PARAM_SEP, 1);
+    }
+
+    if ( caps.bISONoiseFilterSupported ) {
+        strncat(supported, TICameraParameters::IPP_NSF, MAX_PROP_NAME_LENGTH);
+        strncat(supported, PARAM_SEP, 1);
+    }
+
+    if ( caps.bISONoiseFilterSupported && caps.bLensDistortionCorrectionSupported ) {
+        strncat(supported, TICameraParameters::IPP_LDCNSF, MAX_PROP_NAME_LENGTH);
+        strncat(supported, PARAM_SEP, 1);
+    }
+
+    remove_last_sep(supported);
+    params->set(CameraProperties::SUPPORTED_IPP_MODES, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertWBModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( unsigned int i = 0 ; i < caps.ulWhiteBalanceCount ; i++ ) {
+        p = getLUTvalue_OMXtoHAL(caps.eWhiteBalanceModes[i], WBalLUT);
+        if ( NULL != p ) {
+            strncat(supported, p, MAX_PROP_NAME_LENGTH);
+            strncat(supported, PARAM_SEP, 1);
+        }
+    }
+
+    //These modes are not supported by the capability feature
+    strncat(supported, TICameraParameters::WHITE_BALANCE_FACE, MAX_PROP_NAME_LENGTH);
+
+    params->set(CameraProperties::SUPPORTED_WHITE_BALANCE, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertEffects(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( unsigned int i = 0 ; i < caps.ulColorEffectCount; i++ ) {
+        p = getLUTvalue_OMXtoHAL(caps.eColorEffects[i], EffLUT);
+        if ( NULL != p ) {
+            strncat(supported, p, MAX_PROP_NAME_LENGTH);
+            strncat(supported, PARAM_SEP, 1);
+        }
+    }
+    remove_last_sep(supported);
+    params->set(CameraProperties::SUPPORTED_EFFECTS, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertExpModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( unsigned int i = 0 ; i < caps.ulExposureModeCount; i++ ) {
+        p = getLUTvalue_OMXtoHAL(caps.eExposureModes[i], ExpLUT);
+        if ( NULL != p ) {
+            strncat(supported, p, MAX_PROP_NAME_LENGTH);
+            strncat(supported, PARAM_SEP, 1);
+        }
+    }
+
+    //These modes are not supported by the capability feature
+    strncat(supported, TICameraParameters::EXPOSURE_MODE_FACE, MAX_PROP_NAME_LENGTH);
+
+    params->set(CameraProperties::SUPPORTED_EXPOSURE_MODES, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertFlashModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( unsigned int i = 0 ; i < caps.ulFlashCount; i++ ) {
+        p = getLUTvalue_OMXtoHAL(caps.eFlashModes[i], FlashLUT);
+        if ( NULL != p ) {
+            strncat(supported, p, MAX_PROP_NAME_LENGTH);
+            strncat(supported, PARAM_SEP, 1);
+        }
+    }
+
+    remove_last_sep(supported);
+    params->set(CameraProperties::SUPPORTED_FLASH_MODES, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertSceneModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( unsigned int i = 0 ; i < caps.ulSceneCount; i++ ) {
+        p = getLUTvalue_OMXtoHAL(caps.eSceneModes[i], SceneLUT);
+        if ( NULL != p ) {
+            strncat(supported, p, MAX_PROP_NAME_LENGTH);
+            strncat(supported, PARAM_SEP, 1);
+        }
+    }
+
+    remove_last_sep(supported);
+    params->set(CameraProperties::SUPPORTED_SCENE_MODES, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertFocusModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( unsigned int i = 0 ; i < caps.ulFocusModeCount; i++ ) {
+        p = getLUTvalue_OMXtoHAL(caps.eFocusModes[i], FocusLUT);
+        if ( NULL != p ) {
+            strncat(supported, p, MAX_PROP_NAME_LENGTH);
+            strncat(supported, PARAM_SEP, 1);
+        }
+    }
+
+    // Check if focus is supported by camera
+    if (caps.ulFocusModeCount == 1 &&
+        caps.eFocusModes[0] == OMX_IMAGE_FocusControlOff) {
+        // Focus is not supported by camera
+        // Advertise this to app as infinitiy focus mode
+        strncat(supported, CameraParameters::FOCUS_MODE_INFINITY, MAX_PROP_NAME_LENGTH);
+    } else {
+        // Focus is supported but these modes are not supported by the
+        // capability feature. Apply manually
+        strncat(supported, TICameraParameters::FOCUS_MODE_FACE, MAX_PROP_NAME_LENGTH);
+    }
+
+    params->set(CameraProperties::SUPPORTED_FOCUS_MODES, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertFlickerModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    for ( unsigned int i = 0 ; i < caps.ulFlickerCount; i++ ) {
+        p = getLUTvalue_OMXtoHAL(caps.eFlicker[i], FlickerLUT);
+        if ( NULL != p ) {
+            strncat(supported, p, MAX_PROP_NAME_LENGTH);
+            strncat(supported, PARAM_SEP, 1);
+        }
+    }
+    remove_last_sep(supported);
+    params->set(CameraProperties::SUPPORTED_ANTIBANDING, supported);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertLocks(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME
+
+    params->set(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED, DEFAULT_LOCK_SUPPORTED);
+    params->set(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED, DEFAULT_LOCK_SUPPORTED);
+
+    LOG_FUNCTION_NAME
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertDefaults(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+
+    LOG_FUNCTION_NAME;
+
+    params->set(CameraProperties::ANTIBANDING, DEFAULT_ANTIBANDING);
+    params->set(CameraProperties::BRIGHTNESS, DEFAULT_BRIGHTNESS);
+    params->set(CameraProperties::CONTRAST, DEFAULT_CONTRAST);
+    params->set(CameraProperties::EFFECT, DEFAULT_EFFECT);
+    params->set(CameraProperties::EV_COMPENSATION, DEFAULT_EV_COMPENSATION);
+    params->set(CameraProperties::SUPPORTED_EV_STEP, DEFAULT_EV_STEP);
+    params->set(CameraProperties::EXPOSURE_MODE, DEFAULT_EXPOSURE_MODE);
+    params->set(CameraProperties::FLASH_MODE, DEFAULT_FLASH_MODE);
+    params->set(CameraProperties::FOCUS_MODE, DEFAULT_FOCUS_MODE);
+    params->set(CameraProperties::IPP, DEFAULT_IPP);
+    params->set(CameraProperties::ISO_MODE, DEFAULT_ISO_MODE);
+    params->set(CameraProperties::JPEG_QUALITY, DEFAULT_JPEG_QUALITY);
+    params->set(CameraProperties::JPEG_THUMBNAIL_QUALITY, DEFAULT_THUMBNAIL_QUALITY);
+    params->set(CameraProperties::JPEG_THUMBNAIL_SIZE, DEFAULT_THUMBNAIL_SIZE);
+    params->set(CameraProperties::PICTURE_FORMAT, DEFAULT_PICTURE_FORMAT);
+    params->set(CameraProperties::PICTURE_SIZE, DEFAULT_PICTURE_SIZE);
+    params->set(CameraProperties::PREVIEW_FORMAT, DEFAULT_PREVIEW_FORMAT);
+    params->set(CameraProperties::PREVIEW_FRAME_RATE, DEFAULT_FRAMERATE);
+    params->set(CameraProperties::PREVIEW_SIZE, DEFAULT_PREVIEW_SIZE);
+    params->set(CameraProperties::REQUIRED_PREVIEW_BUFS, DEFAULT_NUM_PREV_BUFS);
+    params->set(CameraProperties::REQUIRED_IMAGE_BUFS, DEFAULT_NUM_PIC_BUFS);
+    params->set(CameraProperties::MAX_FOCUS_AREAS, DEFAULT_MAX_FOCUS_AREAS);
+    params->set(CameraProperties::SATURATION, DEFAULT_SATURATION);
+    params->set(CameraProperties::SCENE_MODE, DEFAULT_SCENE_MODE);
+    params->set(CameraProperties::SHARPNESS, DEFAULT_SHARPNESS);
+    params->set(CameraProperties::VSTAB, DEFAULT_VSTAB);
+    params->set(CameraProperties::WHITEBALANCE, DEFAULT_WB);
+    params->set(CameraProperties::ZOOM, DEFAULT_ZOOM);
+    params->set(CameraProperties::MAX_FD_HW_FACES, DEFAULT_MAX_FD_HW_FACES);
+    params->set(CameraProperties::MAX_FD_SW_FACES, DEFAULT_MAX_FD_SW_FACES);
+    params->set(CameraProperties::AUTO_EXPOSURE_LOCK, DEFAULT_AE_LOCK);
+    params->set(CameraProperties::AUTO_WHITEBALANCE_LOCK, DEFAULT_AWB_LOCK);
+    params->set(CameraProperties::MAX_NUM_METERING_AREAS, DEFAULT_MAX_NUM_METERING_AREAS);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertSenMount(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+    const char *p;
+    int i = 0;
+
+    LOG_FUNCTION_NAME;
+
+    memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+
+    // 1) Look up and assign sensor name
+    for (i = 0; i < ARRAY_SIZE(mSensorNames); i++) {
+        if(mSensorNames[i].num == caps.tSenMounting.nSenId) {
+            // sensor found
+            break;
+        }
+    }
+    if ( i == ARRAY_SIZE(mSensorNames) ) {
+        p = "UNKNOWN_SENSOR";
+    } else {
+        p = mSensorNames[i].param;
+    }
+    strncat(supported, p, MAX_PROP_NAME_LENGTH);
+    params->set(CameraProperties::CAMERA_NAME, supported);
+
+    // 2) Assign mounting rotation
+    params->set(CameraProperties::ORIENTATION_INDEX, caps.tSenMounting.nRotation);
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::insertCapabilities(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
+    status_t ret = NO_ERROR;
+    char supported[MAX_PROP_VALUE_LENGTH];
+
+    LOG_FUNCTION_NAME;
+
+    if ( NO_ERROR == ret ) {
+        ret = insertImageSizes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertPreviewSizes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertThumbSizes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertZoomStages(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertImageFormats(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertPreviewFormats(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertFramerates(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertVFramerates(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertEVs(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertISOModes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertIPPModes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertWBModes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertEffects(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertExpModes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertFlashModes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertSceneModes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertFocusModes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertFlickerModes(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertSenMount(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertLocks(params, caps);
+    }
+
+    if ( NO_ERROR == ret ) {
+        ret = insertDefaults(params, caps);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+/*****************************************
+ * public exposed function declarations
+ *****************************************/
+
+status_t OMXCameraAdapter::getCaps(CameraProperties::Properties* params, OMX_HANDLETYPE handle) {
+    status_t ret = NO_ERROR;
+    int caps_size = 0;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_CAPTYPE** caps = NULL;;
+    OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
+    MemoryManager memMgr;
+
+    LOG_FUNCTION_NAME;
+
+    // allocate tiler (or ion) buffer for caps
+    caps_size = sizeof(OMX_TI_CAPTYPE);
+    caps = (OMX_TI_CAPTYPE**) memMgr.allocateBuffer(0, 0, NULL, caps_size, 1);
+
+    if (!caps) {
+        CAMHAL_LOGEB("Error allocating buffer for caps %d", eError);
+        ret = -ENOMEM;
+        goto EXIT;
+    }
+
+    // initialize structures to be passed to OMX Camera
+    OMX_INIT_STRUCT_PTR (caps[0], OMX_TI_CAPTYPE);
+    caps[0]->nPortIndex = OMX_ALL;
+
+    OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
+    sharedBuffer.nPortIndex = OMX_ALL;
+    sharedBuffer.nSharedBuffSize = caps_size;
+    sharedBuffer.pSharedBuff = (OMX_U8 *) caps[0];
+
+    // Get capabilities from OMX Camera
+    eError =  OMX_GetConfig(handle, (OMX_INDEXTYPE) OMX_TI_IndexConfigCamCapabilities, &sharedBuffer);
+    if ( OMX_ErrorNone != eError ) {
+        CAMHAL_LOGEB("Error during capabilities query 0x%x", eError);
+        ret = UNKNOWN_ERROR;
+        goto EXIT;
+    } else {
+        CAMHAL_LOGDA("OMX capability query success");
+    }
+
+    // Translate and insert Ducati capabilities to CameraProperties
+    if ( NO_ERROR == ret ) {
+        ret = insertCapabilities(params, *caps[0]);
+    }
+
+    CAMHAL_LOGDB("sen mount id=%u", (unsigned int)caps[0]->tSenMounting.nSenId);
+
+
+ EXIT:
+    if (caps) {
+        memMgr.freeBuffer((void*) caps);
+        caps = NULL;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+};
+
diff --git a/camera/OMXCameraAdapter/OMXCapture.cpp b/camera/OMXCameraAdapter/OMXCapture.cpp
new file mode 100644
index 0000000..42fb384
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXCapture.cpp
@@ -0,0 +1,1066 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMXCapture.cpp
+*
+* This file contains functionality for handling image capture.
+*
+*/
+
+#undef LOG_TAG
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+
+namespace android {
+
+status_t OMXCameraAdapter::setParametersCapture(const CameraParameters &params,
+                                                BaseCameraAdapter::AdapterState state)
+{
+    status_t ret = NO_ERROR;
+    const char *str = NULL;
+    int w, h;
+    OMX_COLOR_FORMATTYPE pixFormat;
+    const char *valstr = NULL;
+    bool updateImagePortParams = false;
+
+    LOG_FUNCTION_NAME;
+
+    OMXCameraPortParameters *cap;
+    cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+
+    params.getPictureSize(&w, &h);
+
+    if ( ( w != ( int ) cap->mWidth ) ||
+          ( h != ( int ) cap->mHeight ) )
+        {
+        updateImagePortParams = true;
+        }
+
+    cap->mWidth = w;
+    cap->mHeight = h;
+    //TODO: Support more pixelformats
+    cap->mStride = 2;
+
+    CAMHAL_LOGVB("Image: cap.mWidth = %d", (int)cap->mWidth);
+    CAMHAL_LOGVB("Image: cap.mHeight = %d", (int)cap->mHeight);
+
+    if ( (valstr = params.getPictureFormat()) != NULL )
+        {
+        if (strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
+            {
+            CAMHAL_LOGDA("CbYCrY format selected");
+            pixFormat = OMX_COLOR_FormatCbYCrY;
+            }
+        else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0)
+            {
+            CAMHAL_LOGDA("YUV420SP format selected");
+            pixFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+            }
+        else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
+            {
+            CAMHAL_LOGDA("RGB565 format selected");
+            pixFormat = OMX_COLOR_Format16bitRGB565;
+            }
+        else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_JPEG) == 0)
+            {
+            CAMHAL_LOGDA("JPEG format selected");
+            pixFormat = OMX_COLOR_FormatUnused;
+            mCodingMode = CodingNone;
+            }
+        else if(strcmp(valstr, (const char *) TICameraParameters::PIXEL_FORMAT_JPS) == 0)
+            {
+            CAMHAL_LOGDA("JPS format selected");
+            pixFormat = OMX_COLOR_FormatUnused;
+            mCodingMode = CodingJPS;
+            }
+        else if(strcmp(valstr, (const char *) TICameraParameters::PIXEL_FORMAT_MPO) == 0)
+            {
+            CAMHAL_LOGDA("MPO format selected");
+            pixFormat = OMX_COLOR_FormatUnused;
+            mCodingMode = CodingMPO;
+            }
+        else if(strcmp(valstr, (const char *) TICameraParameters::PIXEL_FORMAT_RAW_JPEG) == 0)
+            {
+            CAMHAL_LOGDA("RAW + JPEG format selected");
+            pixFormat = OMX_COLOR_FormatUnused;
+            mCodingMode = CodingRAWJPEG;
+            }
+        else if(strcmp(valstr, (const char *) TICameraParameters::PIXEL_FORMAT_RAW_MPO) == 0)
+            {
+            CAMHAL_LOGDA("RAW + MPO format selected");
+            pixFormat = OMX_COLOR_FormatUnused;
+            mCodingMode = CodingRAWMPO;
+            }
+        else if(strcmp(valstr, (const char *) TICameraParameters::PIXEL_FORMAT_RAW) == 0)
+            {
+            CAMHAL_LOGDA("RAW Picture format selected");
+            pixFormat = OMX_COLOR_FormatRawBayer10bit;
+            }
+        else
+            {
+            CAMHAL_LOGEA("Invalid format, JPEG format selected as default");
+            pixFormat = OMX_COLOR_FormatUnused;
+            }
+        }
+    else
+        {
+        CAMHAL_LOGEA("Picture format is NULL, defaulting to JPEG");
+        pixFormat = OMX_COLOR_FormatUnused;
+        }
+
+    if ( pixFormat != cap->mColorFormat )
+        {
+        updateImagePortParams = true;
+        cap->mColorFormat = pixFormat;
+        }
+
+    if ( updateImagePortParams )
+        {
+        if ( ( CAPTURE_ACTIVE & state ) != CAPTURE_ACTIVE )
+            {
+            setFormat(OMX_CAMERA_PORT_IMAGE_OUT_IMAGE, *cap);
+            }
+        }
+
+    str = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE);
+    if ( NULL != str ) {
+        parseExpRange(str, mExposureBracketingValues, EXP_BRACKET_RANGE, mExposureBracketingValidEntries);
+    } else {
+        mExposureBracketingValidEntries = 0;
+    }
+
+    if ( params.getInt(CameraParameters::KEY_ROTATION) != -1 )
+        {
+        mPictureRotation = params.getInt(CameraParameters::KEY_ROTATION);
+        }
+    else
+        {
+        mPictureRotation = 0;
+        }
+
+    CAMHAL_LOGVB("Picture Rotation set %d", mPictureRotation);
+
+    // Read Sensor Orientation and set it based on perating mode
+
+     if (( params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION) != -1 ) && (mCapMode == OMXCameraAdapter::VIDEO_MODE))
+        {
+         mSensorOrientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION);
+         if (mSensorOrientation == 270 ||mSensorOrientation==90)
+             {
+             CAMHAL_LOGEA(" Orientation is 270/90. So setting counter rotation  to Ducati");
+             mSensorOrientation +=180;
+             mSensorOrientation%=360;
+              }
+         }
+     else
+        {
+         mSensorOrientation = 0;
+        }
+
+     CAMHAL_LOGVB("Sensor Orientation  set : %d", mSensorOrientation);
+
+    if ( params.getInt(TICameraParameters::KEY_BURST)  >= 1 )
+        {
+        mBurstFrames = params.getInt(TICameraParameters::KEY_BURST);
+        }
+    else
+        {
+        mBurstFrames = 1;
+        }
+
+    CAMHAL_LOGVB("Burst Frames set %d", mBurstFrames);
+
+    if ( ( params.getInt(CameraParameters::KEY_JPEG_QUALITY)  >= MIN_JPEG_QUALITY ) &&
+         ( params.getInt(CameraParameters::KEY_JPEG_QUALITY)  <= MAX_JPEG_QUALITY ) )
+        {
+        mPictureQuality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
+        }
+    else
+        {
+        mPictureQuality = MAX_JPEG_QUALITY;
+        }
+
+    CAMHAL_LOGVB("Picture Quality set %d", mPictureQuality);
+
+    if ( params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH)  >= 0 )
+        {
+        mThumbWidth = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
+        }
+    else
+        {
+        mThumbWidth = DEFAULT_THUMB_WIDTH;
+        }
+
+
+    CAMHAL_LOGVB("Picture Thumb width set %d", mThumbWidth);
+
+    if ( params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT)  >= 0 )
+        {
+        mThumbHeight = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
+        }
+    else
+        {
+        mThumbHeight = DEFAULT_THUMB_HEIGHT;
+        }
+
+
+    CAMHAL_LOGVB("Picture Thumb height set %d", mThumbHeight);
+
+    if ( ( params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)  >= MIN_JPEG_QUALITY ) &&
+         ( params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)  <= MAX_JPEG_QUALITY ) )
+        {
+        mThumbQuality = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
+        }
+    else
+        {
+        mThumbQuality = MAX_JPEG_QUALITY;
+        }
+
+    CAMHAL_LOGDB("Thumbnail Quality set %d", mThumbQuality);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::getPictureBufferSize(size_t &length, size_t bufferCount)
+{
+    status_t ret = NO_ERROR;
+    OMXCameraPortParameters *imgCaptureData = NULL;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NO_ERROR == ret )
+        {
+        imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+
+        imgCaptureData->mNumBufs = bufferCount;
+        ret = setFormat(OMX_CAMERA_PORT_IMAGE_OUT_IMAGE, *imgCaptureData);
+        if ( ret == NO_ERROR )
+            {
+            length = imgCaptureData->mBufSize;
+            }
+        else
+            {
+            CAMHAL_LOGEB("setFormat() failed 0x%x", ret);
+            length = 0;
+            }
+        }
+
+    CAMHAL_LOGDB("getPictureBufferSize %d", length);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::parseExpRange(const char *rangeStr,
+                                         int * expRange,
+                                         size_t count,
+                                         size_t &validEntries)
+{
+    status_t ret = NO_ERROR;
+    char *ctx, *expVal;
+    char *tmp = NULL;
+    size_t i = 0;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == rangeStr )
+        {
+        return -EINVAL;
+        }
+
+    if ( NULL == expRange )
+        {
+        return -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        tmp = ( char * ) malloc( strlen(rangeStr) + 1 );
+
+        if ( NULL == tmp )
+            {
+            CAMHAL_LOGEA("No resources for temporary buffer");
+            return -1;
+            }
+        memset(tmp, '\0', strlen(rangeStr) + 1);
+
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        strncpy(tmp, rangeStr, strlen(rangeStr) );
+        expVal = strtok_r( (char *) tmp, CameraHal::PARAMS_DELIMITER, &ctx);
+
+        i = 0;
+        while ( ( NULL != expVal ) && ( i < count ) )
+            {
+            expRange[i] = atoi(expVal);
+            expVal = strtok_r(NULL, CameraHal::PARAMS_DELIMITER, &ctx);
+            i++;
+            }
+        validEntries = i;
+        }
+
+    if ( NULL != tmp )
+        {
+        free(tmp);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setExposureBracketing(int *evValues,
+                                                 size_t evCount,
+                                                 size_t frameCount)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_CAPTUREMODETYPE expCapMode;
+    OMX_CONFIG_EXTCAPTUREMODETYPE extExpCapMode;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -EINVAL;
+        }
+
+    if ( NULL == evValues )
+        {
+        CAMHAL_LOGEA("Exposure compensation values pointer is invalid");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&expCapMode, OMX_CONFIG_CAPTUREMODETYPE);
+        expCapMode.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
+
+        /// If frameCount>0 but evCount<=0, then this is the case of HQ burst.
+        //Otherwise, it is normal HQ capture
+        ///If frameCount>0 and evCount>0 then this is the cause of HQ Exposure bracketing.
+        if ( 0 == evCount && 0 == frameCount )
+            {
+            expCapMode.bFrameLimited = OMX_FALSE;
+            }
+        else
+            {
+            expCapMode.bFrameLimited = OMX_TRUE;
+            expCapMode.nFrameLimit = frameCount;
+            }
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                OMX_IndexConfigCaptureMode,
+                                &expCapMode);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring capture mode 0x%x", eError);
+            }
+        else
+            {
+            CAMHAL_LOGDA("Camera capture mode configured successfully");
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&extExpCapMode, OMX_CONFIG_EXTCAPTUREMODETYPE);
+        extExpCapMode.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
+
+        if ( 0 == evCount )
+            {
+            extExpCapMode.bEnableBracketing = OMX_FALSE;
+            }
+        else
+            {
+            extExpCapMode.bEnableBracketing = OMX_TRUE;
+            extExpCapMode.tBracketConfigType.eBracketMode = OMX_BracketExposureRelativeInEV;
+            extExpCapMode.tBracketConfigType.nNbrBracketingValues = evCount - 1;
+            }
+
+        for ( unsigned int i = 0 ; i < evCount ; i++ )
+            {
+            extExpCapMode.tBracketConfigType.nBracketValues[i]  =  ( evValues[i] * ( 1 << Q16_OFFSET ) )  / 10;
+            }
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                ( OMX_INDEXTYPE ) OMX_IndexConfigExtCaptureMode,
+                                &extExpCapMode);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring extended capture mode 0x%x", eError);
+            }
+        else
+            {
+            CAMHAL_LOGDA("Extended camera capture mode configured successfully");
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setShutterCallback(bool enabled)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_CALLBACKREQUESTTYPE shutterRequstCallback;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateExecuting != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component not in executing state");
+        ret = -1;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        OMX_INIT_STRUCT_PTR (&shutterRequstCallback, OMX_CONFIG_CALLBACKREQUESTTYPE);
+        shutterRequstCallback.nPortIndex = OMX_ALL;
+
+        if ( enabled )
+            {
+            shutterRequstCallback.bEnable = OMX_TRUE;
+            shutterRequstCallback.nIndex = ( OMX_INDEXTYPE ) OMX_TI_IndexConfigShutterCallback;
+            CAMHAL_LOGDA("Enabling shutter callback");
+            }
+        else
+            {
+            shutterRequstCallback.bEnable = OMX_FALSE;
+            shutterRequstCallback.nIndex = ( OMX_INDEXTYPE ) OMX_TI_IndexConfigShutterCallback;
+            CAMHAL_LOGDA("Disabling shutter callback");
+            }
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                ( OMX_INDEXTYPE ) OMX_IndexConfigCallbackRequest,
+                                &shutterRequstCallback);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error registering shutter callback 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDB("Shutter callback for index 0x%x registered successfully",
+                         OMX_TI_IndexConfigShutterCallback);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::doBracketing(OMX_BUFFERHEADERTYPE *pBuffHeader,
+                                        CameraFrame::FrameType typeOfFrame)
+{
+    status_t ret = NO_ERROR;
+    int currentBufferIdx, nextBufferIdx;
+    OMXCameraPortParameters * imgCaptureData = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+
+    if ( OMX_StateExecuting != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is not in executing state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        currentBufferIdx = ( unsigned int ) pBuffHeader->pAppPrivate;
+
+        if ( currentBufferIdx >= imgCaptureData->mNumBufs)
+            {
+            CAMHAL_LOGEB("Invalid bracketing buffer index 0x%x", currentBufferIdx);
+            ret = -EINVAL;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        mBracketingBuffersQueued[currentBufferIdx] = false;
+        mBracketingBuffersQueuedCount--;
+
+        if ( 0 >= mBracketingBuffersQueuedCount )
+            {
+            nextBufferIdx = ( currentBufferIdx + 1 ) % imgCaptureData->mNumBufs;
+            mBracketingBuffersQueued[nextBufferIdx] = true;
+            mBracketingBuffersQueuedCount++;
+            mLastBracetingBufferIdx = nextBufferIdx;
+            setFrameRefCount(imgCaptureData->mBufferHeader[nextBufferIdx]->pBuffer, typeOfFrame, 1);
+            returnFrame(imgCaptureData->mBufferHeader[nextBufferIdx]->pBuffer, typeOfFrame);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::sendBracketFrames()
+{
+    status_t ret = NO_ERROR;
+    int currentBufferIdx;
+    OMXCameraPortParameters * imgCaptureData = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+
+    if ( OMX_StateExecuting != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is not in executing state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        currentBufferIdx = mLastBracetingBufferIdx;
+        do
+            {
+            currentBufferIdx++;
+            currentBufferIdx %= imgCaptureData->mNumBufs;
+            if (!mBracketingBuffersQueued[currentBufferIdx] )
+                {
+                CameraFrame cameraFrame;
+                initCameraFrame(cameraFrame,
+                                imgCaptureData->mBufferHeader[currentBufferIdx],
+                                imgCaptureData->mImageType,
+                                imgCaptureData);
+                sendFrame(cameraFrame);
+                }
+            } while ( currentBufferIdx != mLastBracetingBufferIdx );
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::startBracketing(int range)
+{
+    status_t ret = NO_ERROR;
+    OMXCameraPortParameters * imgCaptureData = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+
+    if ( OMX_StateExecuting != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is not in executing state");
+        ret = -EINVAL;
+        }
+
+        {
+        Mutex::Autolock lock(mBracketingLock);
+
+        if ( mBracketingEnabled )
+            {
+            return ret;
+            }
+        }
+
+    if ( 0 == imgCaptureData->mNumBufs )
+        {
+        CAMHAL_LOGEB("Image capture buffers set to %d", imgCaptureData->mNumBufs);
+        ret = -EINVAL;
+        }
+
+    if ( mPending3Asettings )
+        apply3Asettings(mParameters3A);
+
+    if ( NO_ERROR == ret )
+        {
+        Mutex::Autolock lock(mBracketingLock);
+
+        mBracketingRange = range;
+        mBracketingBuffersQueued = new bool[imgCaptureData->mNumBufs];
+        if ( NULL == mBracketingBuffersQueued )
+            {
+            CAMHAL_LOGEA("Unable to allocate bracketing management structures");
+            ret = -1;
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            mBracketingBuffersQueuedCount = imgCaptureData->mNumBufs;
+            mLastBracetingBufferIdx = mBracketingBuffersQueuedCount - 1;
+
+            for ( int i = 0 ; i  < imgCaptureData->mNumBufs ; i++ )
+                {
+                mBracketingBuffersQueued[i] = true;
+                }
+
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        ret = startImageCapture();
+            {
+            Mutex::Autolock lock(mBracketingLock);
+
+            if ( NO_ERROR == ret )
+                {
+                mBracketingEnabled = true;
+                }
+            else
+                {
+                mBracketingEnabled = false;
+                }
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::stopBracketing()
+{
+  status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mBracketingLock);
+
+    if ( mBracketingEnabled )
+        {
+
+        if ( NULL != mBracketingBuffersQueued )
+        {
+            delete [] mBracketingBuffersQueued;
+        }
+
+        ret = stopImageCapture();
+
+        mBracketingBuffersQueued = NULL;
+        mBracketingEnabled = false;
+        mBracketingBuffersQueuedCount = 0;
+        mLastBracetingBufferIdx = 0;
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::startImageCapture()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMXCameraPortParameters * capData = NULL;
+    OMX_CONFIG_BOOLEANTYPE bOMX;
+
+    LOG_FUNCTION_NAME;
+
+    if(!mCaptureConfigured)
+        {
+        ///Image capture was cancelled before we could start
+        return NO_ERROR;
+        }
+
+    if ( 0 != mStartCaptureSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mStartCaptureSem semaphore count %d", mStartCaptureSem.Count());
+        return NO_INIT;
+        }
+
+    //During bracketing image capture is already active
+    {
+    Mutex::Autolock lock(mBracketingLock);
+    if ( mBracketingEnabled )
+        {
+        //Stop bracketing, activate normal burst for the remaining images
+        mBracketingEnabled = false;
+        mCapturedFrames = mBracketingRange;
+        ret = sendBracketFrames();
+        goto EXIT;
+        }
+    }
+
+    if ( NO_ERROR == ret )
+        {
+        ret = setPictureRotation(mPictureRotation);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("Error configuring image rotation %x", ret);
+            }
+        }
+
+    //OMX shutter callback events are only available in hq mode
+    if ( (HIGH_QUALITY == mCapMode) || (HIGH_QUALITY_ZSL== mCapMode))
+        {
+
+        if ( NO_ERROR == ret )
+            {
+            ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                                        (OMX_EVENTTYPE) OMX_EventIndexSettingChanged,
+                                        OMX_ALL,
+                                        OMX_TI_IndexConfigShutterCallback,
+                                        mStartCaptureSem);
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            ret = setShutterCallback(true);
+            }
+
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        capData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+
+        ///Queue all the buffers on capture port
+        for ( int index = 0 ; index < capData->mNumBufs ; index++ )
+            {
+            CAMHAL_LOGDB("Queuing buffer on Capture port - 0x%x",
+                         ( unsigned int ) capData->mBufferHeader[index]->pBuffer);
+            eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp,
+                        (OMX_BUFFERHEADERTYPE*)capData->mBufferHeader[index]);
+
+            GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+            }
+
+        mWaitingForSnapshot = true;
+        mCaptureSignalled = false;
+
+        OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
+        bOMX.bEnabled = OMX_TRUE;
+
+        /// sending Capturing Command to the component
+        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                               OMX_IndexConfigCapturing,
+                               &bOMX);
+
+        CAMHAL_LOGDB("Capture set - 0x%x", eError);
+
+        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+
+        }
+
+    //OMX shutter callback events are only available in hq mode
+    if ( (HIGH_QUALITY == mCapMode) || (HIGH_QUALITY_ZSL== mCapMode))
+        {
+
+        if ( NO_ERROR == ret )
+            {
+            ret = mStartCaptureSem.WaitTimeout(OMX_CAPTURE_TIMEOUT);
+            }
+
+        if ( NO_ERROR == ret )
+            {
+            CAMHAL_LOGDA("Shutter callback received");
+            notifyShutterSubscribers();
+            }
+        else
+            {
+            ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                               (OMX_EVENTTYPE) OMX_EventIndexSettingChanged,
+                               OMX_ALL,
+                               OMX_TI_IndexConfigShutterCallback,
+                               NULL);
+            CAMHAL_LOGEA("Timeout expired on shutter callback");
+            goto EXIT;
+            }
+
+        }
+
+    EXIT:
+
+    if ( eError != OMX_ErrorNone )
+        {
+
+        mWaitingForSnapshot = false;
+        mCaptureSignalled = false;
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::stopImageCapture()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError;
+    OMX_CONFIG_BOOLEANTYPE bOMX;
+    OMXCameraPortParameters *imgCaptureData = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    if (!mCaptureConfigured) {
+        //Capture is not ongoing, return from here
+        return NO_ERROR;
+    }
+
+    if ( 0 != mStopCaptureSem.Count() ) {
+        CAMHAL_LOGEB("Error mStopCaptureSem semaphore count %d", mStopCaptureSem.Count());
+        goto EXIT;
+    }
+
+    //Disable the callback first
+    mWaitingForSnapshot = false;
+    mSnapshotCount = 0;
+
+    //Disable the callback first
+    ret = setShutterCallback(false);
+
+    //release any 3A locks if locked
+    ret = release3ALock();
+    if(ret!=NO_ERROR)
+      {
+        CAMHAL_LOGEB("Error Releaseing 3A locks%d", ret);
+      }
+
+    //Wait here for the capture to be done, in worst case timeout and proceed with cleanup
+    ret = mCaptureSem.WaitTimeout(OMX_CAPTURE_TIMEOUT);
+    if ( NO_ERROR != ret ) {
+        ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                           (OMX_EVENTTYPE) OMX_EventIndexSettingChanged,
+                           OMX_ALL,
+                           OMX_TI_IndexConfigShutterCallback,
+                           NULL);
+        CAMHAL_LOGEA("Timeout expired on shutter callback");
+    }
+
+    //Disable image capture
+    OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
+    bOMX.bEnabled = OMX_FALSE;
+    imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+    eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                           OMX_IndexConfigCapturing,
+                           &bOMX);
+    if ( OMX_ErrorNone != eError ) {
+        CAMHAL_LOGDB("Error during SetConfig- 0x%x", eError);
+        ret = -1;
+    }
+
+    CAMHAL_LOGDB("Capture set - 0x%x", eError);
+
+    mCaptureSignalled = true; //set this to true if we exited because of timeout
+
+    mCaptureConfigured = false;
+
+    ///Register for Image port Disable event
+    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                                OMX_EventCmdComplete,
+                                OMX_CommandPortDisable,
+                                mCameraAdapterParameters.mImagePortIndex,
+                                mStopCaptureSem);
+    ///Disable Capture Port
+    eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                                OMX_CommandPortDisable,
+                                mCameraAdapterParameters.mImagePortIndex,
+                                NULL);
+
+    ///Free all the buffers on capture port
+    if (imgCaptureData) {
+        CAMHAL_LOGDB("Freeing buffer on Capture port - %d", imgCaptureData->mNumBufs);
+        for ( int index = 0 ; index < imgCaptureData->mNumBufs ; index++) {
+            CAMHAL_LOGDB("Freeing buffer on Capture port - 0x%x",
+                         ( unsigned int ) imgCaptureData->mBufferHeader[index]->pBuffer);
+            eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp,
+                                    mCameraAdapterParameters.mImagePortIndex,
+                                    (OMX_BUFFERHEADERTYPE*)imgCaptureData->mBufferHeader[index]);
+
+            GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
+        }
+    }
+    CAMHAL_LOGDA("Waiting for port disable");
+    //Wait for the image port enable event
+    ret = mStopCaptureSem.WaitTimeout(OMX_CMD_TIMEOUT);
+    if ( NO_ERROR == ret ) {
+        CAMHAL_LOGDA("Port disabled");
+    } else {
+        ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandPortDisable,
+                           mCameraAdapterParameters.mImagePortIndex,
+                           NULL);
+        CAMHAL_LOGDA("Timeout expired on port disable");
+        goto EXIT;
+    }
+
+    EXIT:
+
+    //Release image buffers
+    if ( NULL != mReleaseImageBuffersCallback ) {
+        mReleaseImageBuffersCallback(mReleaseData);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::UseBuffersCapture(void* bufArr, int num)
+{
+    LOG_FUNCTION_NAME;
+
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError;
+    OMXCameraPortParameters * imgCaptureData = NULL;
+    uint32_t *buffers = (uint32_t*)bufArr;
+    OMXCameraPortParameters cap;
+
+    imgCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+
+    if ( 0 != mUseCaptureSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mUseCaptureSem semaphore count %d", mUseCaptureSem.Count());
+        goto EXIT;
+        }
+
+    imgCaptureData->mNumBufs = num;
+
+    //TODO: Support more pixelformats
+
+    CAMHAL_LOGDB("Params Width = %d", (int)imgCaptureData->mWidth);
+    CAMHAL_LOGDB("Params Height = %d", (int)imgCaptureData->mWidth);
+
+    ret = setFormat(OMX_CAMERA_PORT_IMAGE_OUT_IMAGE, *imgCaptureData);
+    if ( ret != NO_ERROR )
+        {
+        CAMHAL_LOGEB("setFormat() failed %d", ret);
+        LOG_FUNCTION_NAME_EXIT;
+        return ret;
+        }
+
+    ret = setThumbnailParams(mThumbWidth, mThumbHeight, mThumbQuality);
+    if ( NO_ERROR != ret)
+        {
+        CAMHAL_LOGEB("Error configuring thumbnail size %x", ret);
+        return ret;
+        }
+
+    ret = setExposureBracketing( mExposureBracketingValues,
+                                 mExposureBracketingValidEntries, mBurstFrames);
+    if ( ret != NO_ERROR )
+        {
+        CAMHAL_LOGEB("setExposureBracketing() failed %d", ret);
+        return ret;
+        }
+
+    ret = setImageQuality(mPictureQuality);
+    if ( NO_ERROR != ret)
+        {
+        CAMHAL_LOGEB("Error configuring image quality %x", ret);
+        return ret;
+        }
+
+    ///Register for Image port ENABLE event
+    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandPortEnable,
+                           mCameraAdapterParameters.mImagePortIndex,
+                           mUseCaptureSem);
+
+    ///Enable Capture Port
+    eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
+                             OMX_CommandPortEnable,
+                             mCameraAdapterParameters.mImagePortIndex,
+                             NULL);
+
+    for ( int index = 0 ; index < imgCaptureData->mNumBufs ; index++ )
+    {
+        OMX_BUFFERHEADERTYPE *pBufferHdr;
+        CAMHAL_LOGDB("OMX_UseBuffer Capture address: 0x%x, size = %d",
+                     (unsigned int)buffers[index],
+                     (int)imgCaptureData->mBufSize);
+
+        eError = OMX_UseBuffer(mCameraAdapterParameters.mHandleComp,
+                               &pBufferHdr,
+                               mCameraAdapterParameters.mImagePortIndex,
+                               0,
+                               mCaptureBuffersLength,
+                               (OMX_U8*)buffers[index]);
+
+        CAMHAL_LOGDB("OMX_UseBuffer = 0x%x", eError);
+
+        GOTO_EXIT_IF(( eError != OMX_ErrorNone ), eError);
+
+        pBufferHdr->pAppPrivate = (OMX_PTR) index;
+        pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
+        pBufferHdr->nVersion.s.nVersionMajor = 1 ;
+        pBufferHdr->nVersion.s.nVersionMinor = 1 ;
+        pBufferHdr->nVersion.s.nRevision = 0;
+        pBufferHdr->nVersion.s.nStep =  0;
+        imgCaptureData->mBufferHeader[index] = pBufferHdr;
+    }
+
+    //Wait for the image port enable event
+    CAMHAL_LOGDA("Waiting for port enable");
+    ret = mUseCaptureSem.WaitTimeout(OMX_CMD_TIMEOUT);
+    if ( ret == NO_ERROR )
+        {
+        CAMHAL_LOGDA("Port enabled");
+        }
+    else
+        {
+        ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                           OMX_EventCmdComplete,
+                           OMX_CommandPortEnable,
+                           mCameraAdapterParameters.mImagePortIndex,
+                           NULL);
+        CAMHAL_LOGDA("Timeout expired on port enable");
+        goto EXIT;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        ret = setupEXIF();
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("Error configuring EXIF Buffer %x", ret);
+            }
+        }
+
+    mCapturedFrames = mBurstFrames;
+    mCaptureConfigured = true;
+
+    EXIT:
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+};
diff --git a/camera/OMXCameraAdapter/OMXDefaults.cpp b/camera/OMXCameraAdapter/OMXDefaults.cpp
new file mode 100644
index 0000000..670f562
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXDefaults.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMXDefaults.cpp
+*
+* This file contains definitions are OMX Camera defaults
+*
+*/
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+
+namespace android {
+
+#undef LOG_TAG
+#define LOG_TAG "CameraHAL"
+
+// OMX Camera defaults
+const char OMXCameraAdapter::DEFAULT_ANTIBANDING[] = "auto";
+const char OMXCameraAdapter::DEFAULT_BRIGHTNESS[] = "50";
+const char OMXCameraAdapter::DEFAULT_CONTRAST[] = "100";
+const char OMXCameraAdapter::DEFAULT_EFFECT[] = "none";
+const char OMXCameraAdapter::DEFAULT_EV_COMPENSATION[] = "0";
+const char OMXCameraAdapter::DEFAULT_EV_STEP[] = "0.1";
+const char OMXCameraAdapter::DEFAULT_EXPOSURE_MODE[] = "auto";
+const char OMXCameraAdapter::DEFAULT_FLASH_MODE[] = "off";
+const char OMXCameraAdapter::DEFAULT_FOCUS_MODE[] = "infinity";
+const char OMXCameraAdapter::DEFAULT_FRAMERATE_RANGE[] = "20000,30000";
+const char OMXCameraAdapter::DEFAULT_IPP[] = "off";
+const char OMXCameraAdapter::DEFAULT_ISO_MODE[] = "auto";
+const char OMXCameraAdapter::DEFAULT_JPEG_QUALITY[] = "95";
+const char OMXCameraAdapter::DEFAULT_THUMBNAIL_QUALITY[] = "60";
+const char OMXCameraAdapter::DEFAULT_THUMBNAIL_SIZE[] = "160x120";
+const char OMXCameraAdapter::DEFAULT_PICTURE_FORMAT[] = "jpeg";
+const char OMXCameraAdapter::DEFAULT_PICTURE_SIZE[] = "320x240";
+const char OMXCameraAdapter::DEFAULT_PREVIEW_FORMAT[] = "yuv420sp";
+const char OMXCameraAdapter::DEFAULT_FRAMERATE[] = "30";
+const char OMXCameraAdapter::DEFAULT_PREVIEW_SIZE[] = "640x480";
+const char OMXCameraAdapter::DEFAULT_NUM_PREV_BUFS[] = "6";
+const char OMXCameraAdapter::DEFAULT_NUM_PIC_BUFS[] = "1";
+const char OMXCameraAdapter::DEFAULT_MAX_FOCUS_AREAS[] = "1";
+const char OMXCameraAdapter::DEFAULT_SATURATION[] = "100";
+const char OMXCameraAdapter::DEFAULT_SCENE_MODE[] = "auto";
+const char OMXCameraAdapter::DEFAULT_SHARPNESS[] = "100";
+const char OMXCameraAdapter::DEFAULT_VSTAB[] = "0";
+const char OMXCameraAdapter::DEFAULT_WB[] = "auto";
+const char OMXCameraAdapter::DEFAULT_ZOOM[] = "0";
+const char OMXCameraAdapter::DEFAULT_MAX_FD_HW_FACES[] = "35";
+const char OMXCameraAdapter::DEFAULT_MAX_FD_SW_FACES[] = "0";
+
+const char OMXCameraAdapter::DEFAULT_AE_LOCK[] = "false";
+const char OMXCameraAdapter::DEFAULT_AWB_LOCK[] = "false";
+const char OMXCameraAdapter::DEFAULT_MAX_NUM_METERING_AREAS[] = "0";
+const char OMXCameraAdapter::DEFAULT_LOCK_SUPPORTED[] = "true";
+const char OMXCameraAdapter::DEFAULT_LOCK_UNSUPPORTED[] = "false";
+};
+
diff --git a/camera/OMXCameraAdapter/OMXExif.cpp b/camera/OMXCameraAdapter/OMXExif.cpp
new file mode 100644
index 0000000..56b1694
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXExif.cpp
@@ -0,0 +1,567 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMXExif.cpp
+*
+* This file contains functionality for handling EXIF insertion.
+*
+*/
+
+#undef LOG_TAG
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+#include <math.h>
+
+namespace android {
+
+const char OMXCameraAdapter::EXIFASCIIPrefix [] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };
+
+status_t OMXCameraAdapter::setParametersEXIF(const CameraParameters &params,
+                                             BaseCameraAdapter::AdapterState state)
+{
+    status_t ret = NO_ERROR;
+    const char *valstr = NULL;
+    double gpsPos;
+
+    LOG_FUNCTION_NAME;
+
+    if( ( valstr = params.get(CameraParameters::KEY_GPS_LATITUDE) ) != NULL )
+        {
+        gpsPos = strtod(valstr, NULL);
+
+        if ( convertGPSCoord( gpsPos, &mEXIFData.mGPSData.mLatDeg,
+                                        &mEXIFData.mGPSData.mLatMin,
+                                        &mEXIFData.mGPSData.mLatSec ) == NO_ERROR )
+            {
+
+            if ( 0 < gpsPos )
+                {
+                strncpy(mEXIFData.mGPSData.mLatRef, GPS_NORTH_REF, GPS_REF_SIZE);
+                }
+            else
+                {
+                strncpy(mEXIFData.mGPSData.mLatRef, GPS_SOUTH_REF, GPS_REF_SIZE);
+                }
+
+            mEXIFData.mGPSData.mLatValid = true;
+            }
+        else
+            {
+            mEXIFData.mGPSData.mLatValid = false;
+            }
+        }
+    else
+        {
+        mEXIFData.mGPSData.mLatValid = false;
+        }
+
+    if( ( valstr = params.get(CameraParameters::KEY_GPS_LONGITUDE) ) != NULL )
+        {
+        gpsPos = strtod(valstr, NULL);
+
+        if ( convertGPSCoord( gpsPos, &mEXIFData.mGPSData.mLongDeg,
+                                        &mEXIFData.mGPSData.mLongMin,
+                                        &mEXIFData.mGPSData.mLongSec ) == NO_ERROR )
+            {
+
+            if ( 0 < gpsPos )
+                {
+                strncpy(mEXIFData.mGPSData.mLongRef, GPS_EAST_REF, GPS_REF_SIZE);
+                }
+            else
+                {
+                strncpy(mEXIFData.mGPSData.mLongRef, GPS_WEST_REF, GPS_REF_SIZE);
+                }
+
+            mEXIFData.mGPSData.mLongValid= true;
+            }
+        else
+            {
+            mEXIFData.mGPSData.mLongValid = false;
+            }
+        }
+    else
+        {
+        mEXIFData.mGPSData.mLongValid = false;
+        }
+
+    if( ( valstr = params.get(CameraParameters::KEY_GPS_ALTITUDE) ) != NULL )
+        {
+        gpsPos = strtod(valstr, NULL);
+        mEXIFData.mGPSData.mAltitude = floor(fabs(gpsPos));
+        if (gpsPos < 0) {
+            mEXIFData.mGPSData.mAltitudeRef = 1;
+        } else {
+            mEXIFData.mGPSData.mAltitudeRef = 0;
+        }
+        mEXIFData.mGPSData.mAltitudeValid = true;
+        }
+    else
+        {
+        mEXIFData.mGPSData.mAltitudeValid= false;
+        }
+
+    if( (valstr = params.get(CameraParameters::KEY_GPS_TIMESTAMP)) != NULL )
+        {
+        long gpsTimestamp = strtol(valstr, NULL, 10);
+        struct tm *timeinfo = localtime( ( time_t * ) & (gpsTimestamp) );
+        if ( NULL != timeinfo )
+            {
+            mEXIFData.mGPSData.mTimeStampHour = timeinfo->tm_hour;
+            mEXIFData.mGPSData.mTimeStampMin = timeinfo->tm_min;
+            mEXIFData.mGPSData.mTimeStampSec = timeinfo->tm_sec;
+            mEXIFData.mGPSData.mTimeStampValid = true;
+            }
+        else
+            {
+            mEXIFData.mGPSData.mTimeStampValid = false;
+            }
+        }
+    else
+        {
+        mEXIFData.mGPSData.mTimeStampValid = false;
+        }
+
+    if( ( valstr = params.get(CameraParameters::KEY_GPS_TIMESTAMP) ) != NULL )
+        {
+        long gpsDatestamp = strtol(valstr, NULL, 10);
+        struct tm *timeinfo = localtime( ( time_t * ) & (gpsDatestamp) );
+        if ( NULL != timeinfo )
+            {
+            strftime(mEXIFData.mGPSData.mDatestamp, GPS_DATESTAMP_SIZE, "%Y:%m:%d", timeinfo);
+            mEXIFData.mGPSData.mDatestampValid = true;
+            }
+        else
+            {
+            mEXIFData.mGPSData.mDatestampValid = false;
+            }
+        }
+    else
+        {
+        mEXIFData.mGPSData.mDatestampValid = false;
+        }
+
+    if( ( valstr = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD) ) != NULL )
+        {
+        strncpy(mEXIFData.mGPSData.mProcMethod, valstr, GPS_PROCESSING_SIZE-1);
+        mEXIFData.mGPSData.mProcMethodValid = true;
+        }
+    else
+        {
+        mEXIFData.mGPSData.mProcMethodValid = false;
+        }
+
+    if( ( valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM) ) != NULL )
+        {
+        strncpy(mEXIFData.mGPSData.mMapDatum, valstr, GPS_MAPDATUM_SIZE-1);
+        mEXIFData.mGPSData.mMapDatumValid = true;
+        }
+    else
+        {
+        mEXIFData.mGPSData.mMapDatumValid = false;
+        }
+
+    if( ( valstr = params.get(TICameraParameters::KEY_GPS_VERSION) ) != NULL )
+        {
+        strncpy(mEXIFData.mGPSData.mVersionId, valstr, GPS_VERSION_SIZE-1);
+        mEXIFData.mGPSData.mVersionIdValid = true;
+        }
+    else
+        {
+        mEXIFData.mGPSData.mVersionIdValid = false;
+        }
+
+    if( ( valstr = params.get(TICameraParameters::KEY_EXIF_MODEL ) ) != NULL )
+        {
+        CAMHAL_LOGVB("EXIF Model: %s", valstr);
+        mEXIFData.mModelValid= true;
+        }
+    else
+        {
+        mEXIFData.mModelValid= false;
+        }
+
+    if( ( valstr = params.get(TICameraParameters::KEY_EXIF_MAKE ) ) != NULL )
+        {
+        CAMHAL_LOGVB("EXIF Make: %s", valstr);
+        mEXIFData.mMakeValid = true;
+        }
+    else
+        {
+        mEXIFData.mMakeValid= false;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setupEXIF()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
+    OMX_TI_CONFIG_EXIF_TAGS *exifTags;
+    unsigned char *sharedPtr = NULL;
+    struct timeval sTv;
+    struct tm *pTime;
+    OMXCameraPortParameters * capData = NULL;
+    MemoryManager memMgr;
+    OMX_U8** memmgr_buf_array = NULL;
+    int buf_size = 0;
+
+    LOG_FUNCTION_NAME;
+
+    sharedBuffer.pSharedBuff = NULL;
+    capData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
+        sharedBuffer.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
+
+        //We allocate the shared buffer dynamically based on the
+        //requirements of the EXIF tags. The additional buffers will
+        //get stored after the EXIF configuration structure and the pointers
+        //will contain offsets within the shared buffer itself.
+        buf_size = sizeof(OMX_TI_CONFIG_EXIF_TAGS) +
+                          ( EXIF_MODEL_SIZE ) +
+                          ( EXIF_MAKE_SIZE ) +
+                          ( EXIF_DATE_TIME_SIZE ) +
+                          ( GPS_MAPDATUM_SIZE ) +
+                          ( GPS_PROCESSING_SIZE );
+        sharedBuffer.nSharedBuffSize = buf_size;
+
+        memmgr_buf_array = (OMX_U8 **)memMgr.allocateBuffer(0, 0, NULL, buf_size, 1);
+        sharedBuffer.pSharedBuff =  ( OMX_U8 * ) memmgr_buf_array[0];
+
+        if ( NULL == sharedBuffer.pSharedBuff )
+            {
+            CAMHAL_LOGEA("No resources to allocate OMX shared buffer");
+            ret = -1;
+            }
+
+        //Extra data begins right after the EXIF configuration structure.
+        sharedPtr = sharedBuffer.pSharedBuff + sizeof(OMX_TI_CONFIG_EXIF_TAGS);
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        exifTags = ( OMX_TI_CONFIG_EXIF_TAGS * ) sharedBuffer.pSharedBuff;
+        OMX_INIT_STRUCT_PTR (exifTags, OMX_TI_CONFIG_EXIF_TAGS);
+        exifTags->nPortIndex = mCameraAdapterParameters.mImagePortIndex;
+
+        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+                               ( OMX_INDEXTYPE ) OMX_TI_IndexConfigExifTags,
+                               &sharedBuffer );
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while retrieving EXIF configuration structure 0x%x", eError);
+            ret = -1;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusModel ) &&
+              ( mEXIFData.mModelValid ) )
+            {
+            strncpy(( char * ) sharedPtr,
+                    ( char * ) mParams.get(TICameraParameters::KEY_EXIF_MODEL ),
+                    EXIF_MODEL_SIZE - 1);
+
+            exifTags->pModelBuff = ( OMX_S8 * ) ( sharedPtr - sharedBuffer.pSharedBuff );
+            sharedPtr += EXIF_MODEL_SIZE;
+            exifTags->ulModelBuffSizeBytes = EXIF_MODEL_SIZE;
+            exifTags->eStatusModel = OMX_TI_TagUpdated;
+            }
+
+         if ( ( OMX_TI_TagReadWrite == exifTags->eStatusMake) &&
+               ( mEXIFData.mMakeValid ) )
+             {
+             strncpy( ( char * ) sharedPtr,
+                          ( char * ) mParams.get(TICameraParameters::KEY_EXIF_MAKE ),
+                          EXIF_MAKE_SIZE - 1);
+
+             exifTags->pMakeBuff = ( OMX_S8 * ) ( sharedPtr - sharedBuffer.pSharedBuff );
+             sharedPtr += EXIF_MAKE_SIZE;
+             exifTags->ulMakeBuffSizeBytes = EXIF_MAKE_SIZE;
+             exifTags->eStatusMake = OMX_TI_TagUpdated;
+             }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusFocalLength ))
+        {
+                char *ctx;
+                int len;
+                char* temp = (char*) mParams.get(CameraParameters::KEY_FOCAL_LENGTH);
+                char * tempVal = NULL;
+                if(temp != NULL)
+                {
+                    len = strlen(temp);
+                    tempVal = (char*) malloc( sizeof(char) * (len + 1));
+                }
+                if(tempVal != NULL)
+                {
+                    memset(tempVal, '\0', len + 1);
+                    strncpy(tempVal, temp, len);
+                    CAMHAL_LOGDB("KEY_FOCAL_LENGTH = %s", tempVal);
+
+                    // convert the decimal string into a rational
+                    size_t den_len;
+                    OMX_U32 numerator = 0;
+                    OMX_U32 denominator = 0;
+                    char* temp = strtok_r(tempVal, ".", &ctx);
+
+                    if(temp != NULL)
+                        numerator = atoi(temp);
+
+                    temp = strtok_r(NULL, ".", &ctx);
+                    if(temp != NULL)
+                    {
+                        den_len = strlen(temp);
+                        if(HUGE_VAL == den_len )
+                            {
+                            den_len = 0;
+                            }
+                        denominator = static_cast<OMX_U32>(pow(10, den_len));
+                        numerator = numerator*denominator + atoi(temp);
+                    }else{
+                        denominator = 1;
+                    }
+
+                    free(tempVal);
+
+                    exifTags->ulFocalLength[0] = numerator;
+                    exifTags->ulFocalLength[1] = denominator;
+                    CAMHAL_LOGVB("exifTags->ulFocalLength = [%u] [%u]",
+                                 (unsigned int)(exifTags->ulFocalLength[0]),
+                                 (unsigned int)(exifTags->ulFocalLength[1]));
+                    exifTags->eStatusFocalLength = OMX_TI_TagUpdated;
+                }
+        }
+
+         if ( OMX_TI_TagReadWrite == exifTags->eStatusDateTime )
+             {
+             int status = gettimeofday (&sTv, NULL);
+             pTime = localtime (&sTv.tv_sec);
+             if ( ( 0 == status ) && ( NULL != pTime ) )
+                {
+                snprintf(( char * ) sharedPtr, EXIF_DATE_TIME_SIZE,
+                         "%04d:%02d:%02d %02d:%02d:%02d",
+                         pTime->tm_year + 1900,
+                         pTime->tm_mon + 1,
+                         pTime->tm_mday,
+                         pTime->tm_hour,
+                         pTime->tm_min,
+                         pTime->tm_sec );
+                }
+
+             exifTags->pDateTimeBuff = ( OMX_S8 * ) ( sharedPtr - sharedBuffer.pSharedBuff );
+             sharedPtr += EXIF_DATE_TIME_SIZE;
+             exifTags->ulDateTimeBuffSizeBytes = EXIF_DATE_TIME_SIZE;
+             exifTags->eStatusDateTime = OMX_TI_TagUpdated;
+             }
+
+         if ( OMX_TI_TagReadWrite == exifTags->eStatusImageWidth )
+             {
+             exifTags->ulImageWidth = capData->mWidth;
+             exifTags->eStatusImageWidth = OMX_TI_TagUpdated;
+             }
+
+         if ( OMX_TI_TagReadWrite == exifTags->eStatusImageHeight )
+             {
+             exifTags->ulImageHeight = capData->mHeight;
+             exifTags->eStatusImageHeight = OMX_TI_TagUpdated;
+             }
+
+         if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsLatitude ) &&
+              ( mEXIFData.mGPSData.mLatValid ) )
+            {
+            exifTags->ulGpsLatitude[0] = abs(mEXIFData.mGPSData.mLatDeg);
+            exifTags->ulGpsLatitude[2] = abs(mEXIFData.mGPSData.mLatMin);
+            exifTags->ulGpsLatitude[4] = abs(mEXIFData.mGPSData.mLatSec);
+            exifTags->ulGpsLatitude[1] = 1;
+            exifTags->ulGpsLatitude[3] = 1;
+            exifTags->ulGpsLatitude[5] = 1;
+            exifTags->eStatusGpsLatitude = OMX_TI_TagUpdated;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpslatitudeRef ) &&
+             ( mEXIFData.mGPSData.mLatValid ) )
+            {
+            exifTags->cGpslatitudeRef[0] = ( OMX_S8 ) mEXIFData.mGPSData.mLatRef[0];
+            exifTags->cGpslatitudeRef[1] = '\0';
+            exifTags->eStatusGpslatitudeRef = OMX_TI_TagUpdated;
+            }
+
+         if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsLongitude ) &&
+              ( mEXIFData.mGPSData.mLongValid ) )
+            {
+            exifTags->ulGpsLongitude[0] = abs(mEXIFData.mGPSData.mLongDeg);
+            exifTags->ulGpsLongitude[2] = abs(mEXIFData.mGPSData.mLongMin);
+            exifTags->ulGpsLongitude[4] = abs(mEXIFData.mGPSData.mLongSec);
+            exifTags->ulGpsLongitude[1] = 1;
+            exifTags->ulGpsLongitude[3] = 1;
+            exifTags->ulGpsLongitude[5] = 1;
+            exifTags->eStatusGpsLongitude = OMX_TI_TagUpdated;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsLongitudeRef ) &&
+             ( mEXIFData.mGPSData.mLongValid ) )
+            {
+            exifTags->cGpsLongitudeRef[0] = ( OMX_S8 ) mEXIFData.mGPSData.mLongRef[0];
+            exifTags->cGpsLongitudeRef[1] = '\0';
+            exifTags->eStatusGpsLongitudeRef = OMX_TI_TagUpdated;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsAltitude ) &&
+             ( mEXIFData.mGPSData.mAltitudeValid) )
+            {
+            exifTags->ulGpsAltitude[0] = ( OMX_U32 ) mEXIFData.mGPSData.mAltitude;
+            exifTags->ulGpsAltitude[1] = 1;
+            exifTags->eStatusGpsAltitude = OMX_TI_TagUpdated;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsAltitudeRef ) &&
+             ( mEXIFData.mGPSData.mAltitudeValid) )
+            {
+            exifTags->ucGpsAltitudeRef = (OMX_U8) mEXIFData.mGPSData.mAltitudeRef;
+            exifTags->eStatusGpsAltitudeRef = OMX_TI_TagUpdated;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsMapDatum ) &&
+             ( mEXIFData.mGPSData.mMapDatumValid ) )
+            {
+            memcpy(sharedPtr, mEXIFData.mGPSData.mMapDatum, GPS_MAPDATUM_SIZE);
+
+            exifTags->pGpsMapDatumBuff = ( OMX_S8 * ) ( sharedPtr - sharedBuffer.pSharedBuff );
+            exifTags->ulGpsMapDatumBuffSizeBytes = GPS_MAPDATUM_SIZE;
+            exifTags->eStatusGpsMapDatum = OMX_TI_TagUpdated;
+            sharedPtr += GPS_MAPDATUM_SIZE;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsProcessingMethod ) &&
+             ( mEXIFData.mGPSData.mProcMethodValid ) )
+            {
+            exifTags->pGpsProcessingMethodBuff = ( OMX_S8 * ) ( sharedPtr - sharedBuffer.pSharedBuff );
+            memcpy(sharedPtr, EXIFASCIIPrefix, sizeof(EXIFASCIIPrefix));
+            sharedPtr += sizeof(EXIFASCIIPrefix);
+
+            memcpy(sharedPtr,
+                   mEXIFData.mGPSData.mProcMethod,
+                   ( GPS_PROCESSING_SIZE - sizeof(EXIFASCIIPrefix) ) );
+            exifTags->ulGpsProcessingMethodBuffSizeBytes = GPS_PROCESSING_SIZE;
+            exifTags->eStatusGpsProcessingMethod = OMX_TI_TagUpdated;
+            sharedPtr += GPS_PROCESSING_SIZE;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsVersionId ) &&
+             ( mEXIFData.mGPSData.mVersionIdValid ) )
+            {
+            exifTags->ucGpsVersionId[0] = ( OMX_U8 ) mEXIFData.mGPSData.mVersionId[0];
+            exifTags->ucGpsVersionId[1] =  ( OMX_U8 ) mEXIFData.mGPSData.mVersionId[1];
+            exifTags->ucGpsVersionId[2] = ( OMX_U8 ) mEXIFData.mGPSData.mVersionId[2];
+            exifTags->ucGpsVersionId[3] = ( OMX_U8 ) mEXIFData.mGPSData.mVersionId[3];
+            exifTags->eStatusGpsVersionId = OMX_TI_TagUpdated;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsTimeStamp ) &&
+             ( mEXIFData.mGPSData.mTimeStampValid ) )
+            {
+            exifTags->ulGpsTimeStamp[0] = mEXIFData.mGPSData.mTimeStampHour;
+            exifTags->ulGpsTimeStamp[2] = mEXIFData.mGPSData.mTimeStampMin;
+            exifTags->ulGpsTimeStamp[4] = mEXIFData.mGPSData.mTimeStampSec;
+            exifTags->ulGpsTimeStamp[1] = 1;
+            exifTags->ulGpsTimeStamp[3] = 1;
+            exifTags->ulGpsTimeStamp[5] = 1;
+            exifTags->eStatusGpsTimeStamp = OMX_TI_TagUpdated;
+            }
+
+        if ( ( OMX_TI_TagReadWrite == exifTags->eStatusGpsDateStamp ) &&
+             ( mEXIFData.mGPSData.mDatestampValid ) )
+            {
+            strncpy( ( char * ) exifTags->cGpsDateStamp,
+                         ( char * ) mEXIFData.mGPSData.mDatestamp,
+                         GPS_DATESTAMP_SIZE );
+            exifTags->eStatusGpsDateStamp = OMX_TI_TagUpdated;
+            }
+
+        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                               ( OMX_INDEXTYPE ) OMX_TI_IndexConfigExifTags,
+                               &sharedBuffer );
+
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while setting EXIF configuration 0x%x", eError);
+            ret = -1;
+            }
+        }
+
+    if ( NULL != memmgr_buf_array )
+        {
+        memMgr.freeBuffer(memmgr_buf_array);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::convertGPSCoord(double coord, int *deg, int *min, int *sec)
+{
+    double tmp;
+
+    LOG_FUNCTION_NAME;
+
+    if ( coord == 0 ) {
+
+        LOGE("Invalid GPS coordinate");
+
+        return -EINVAL;
+    }
+
+    *deg = (int) floor(fabs(coord));
+    tmp = ( fabs(coord) - floor(fabs(coord)) )*60;
+    *min = (int) floor(tmp);
+    tmp = ( tmp - floor(tmp) )*60;
+    *sec = (int) floor(tmp);
+
+    if( *sec >= 60 ) {
+        *sec = 0;
+        *min += 1;
+    }
+
+    if( *min >= 60 ) {
+        *min = 0;
+        *deg += 1;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return NO_ERROR;
+}
+
+};
diff --git a/camera/OMXCameraAdapter/OMXFD.cpp b/camera/OMXCameraAdapter/OMXFD.cpp
new file mode 100644
index 0000000..c1617d7
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXFD.cpp
@@ -0,0 +1,327 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMXFD.cpp
+*
+* This file contains functionality for handling face detection.
+*
+*/
+
+#undef LOG_TAG
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+
+namespace android {
+
+status_t OMXCameraAdapter::setParametersFD(const CameraParameters &params,
+                                           BaseCameraAdapter::AdapterState state)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::startFaceDetection()
+{
+    Mutex::Autolock lock(mFaceDetectionLock);
+    return setFaceDetection(true, mDeviceOrientation);
+}
+
+status_t OMXCameraAdapter::stopFaceDetection()
+{
+    Mutex::Autolock lock(mFaceDetectionLock);
+    return setFaceDetection(false, mDeviceOrientation);
+}
+
+status_t OMXCameraAdapter::setFaceDetection(bool enable, OMX_U32 orientation)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_EXTRADATATYPE extraDataControl;
+    OMX_CONFIG_OBJDETECTIONTYPE objDetection;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        if ( orientation < 0 || orientation > 270 ) {
+            orientation = 0;
+        }
+
+        OMX_INIT_STRUCT_PTR (&objDetection, OMX_CONFIG_OBJDETECTIONTYPE);
+        objDetection.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+        objDetection.nDeviceOrientation = orientation;
+        if  ( enable )
+            {
+            objDetection.bEnable = OMX_TRUE;
+            }
+        else
+            {
+            objDetection.bEnable = OMX_FALSE;
+            }
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                ( OMX_INDEXTYPE ) OMX_IndexConfigImageFaceDetection,
+                                &objDetection);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring face detection 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Face detection configured successfully");
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&extraDataControl, OMX_CONFIG_EXTRADATATYPE);
+        extraDataControl.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+        extraDataControl.eExtraDataType = OMX_FaceDetection;
+        extraDataControl.eCameraView = OMX_2D;
+        if  ( enable )
+            {
+            extraDataControl.bEnable = OMX_TRUE;
+            }
+        else
+            {
+            extraDataControl.bEnable = OMX_FALSE;
+            }
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                ( OMX_INDEXTYPE ) OMX_IndexConfigOtherExtraDataControl,
+                                &extraDataControl);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring face detection extra data 0x%x",
+                         eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Face detection extra data configured successfully");
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        mFaceDetectionRunning = enable;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::detectFaces(OMX_BUFFERHEADERTYPE* pBuffHeader,
+                                       sp<CameraFDResult> &result,
+                                       size_t previewWidth,
+                                       size_t previewHeight)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_TI_FACERESULT *faceResult;
+    OMX_OTHER_EXTRADATATYPE *extraData;
+    OMX_FACEDETECTIONTYPE *faceData;
+    OMX_TI_PLATFORMPRIVATE *platformPrivate;
+    camera_frame_metadata_t *faces;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateExecuting != mComponentState ) {
+        CAMHAL_LOGEA("OMX component is not in executing state");
+        return NO_INIT;
+    }
+
+    if ( NULL == pBuffHeader ) {
+        CAMHAL_LOGEA("Invalid Buffer header");
+        return-EINVAL;
+    }
+
+    platformPrivate = (OMX_TI_PLATFORMPRIVATE *) (pBuffHeader->pPlatformPrivate);
+    if ( NULL != platformPrivate ) {
+        if ( sizeof(OMX_TI_PLATFORMPRIVATE) == platformPrivate->nSize ) {
+            CAMHAL_LOGVB("Size = %d, sizeof = %d, pAuxBuf = 0x%x, pAuxBufSize= %d, pMetaDataBufer = 0x%x, nMetaDataSize = %d",
+                         platformPrivate->nSize,
+                         sizeof(OMX_TI_PLATFORMPRIVATE),
+                         platformPrivate->pAuxBuf1,
+                         platformPrivate->pAuxBufSize1,
+                         platformPrivate->pMetaDataBuffer,
+                         platformPrivate->nMetaDataSize);
+        } else {
+            CAMHAL_LOGEB("OMX_TI_PLATFORMPRIVATE size mismatch: expected = %d, received = %d",
+                         ( unsigned int ) sizeof(OMX_TI_PLATFORMPRIVATE),
+                         ( unsigned int ) platformPrivate->nSize);
+            ret = -EINVAL;
+        }
+    }  else {
+        CAMHAL_LOGEA("Invalid OMX_TI_PLATFORMPRIVATE");
+        return-EINVAL;
+    }
+
+
+    if ( 0 >= platformPrivate->nMetaDataSize ) {
+        CAMHAL_LOGEB("OMX_TI_PLATFORMPRIVATE nMetaDataSize is size is %d",
+                     ( unsigned int ) platformPrivate->nMetaDataSize);
+        return -EINVAL;
+    }
+
+    extraData = (OMX_OTHER_EXTRADATATYPE *) (platformPrivate->pMetaDataBuffer);
+    if ( NULL != extraData ) {
+        CAMHAL_LOGVB("Size = %d, sizeof = %d, eType = 0x%x, nDataSize= %d, nPortIndex = 0x%x, nVersion = 0x%x",
+                     extraData->nSize,
+                     sizeof(OMX_OTHER_EXTRADATATYPE),
+                     extraData->eType,
+                     extraData->nDataSize,
+                     extraData->nPortIndex,
+                     extraData->nVersion);
+    } else {
+        CAMHAL_LOGEA("Invalid OMX_OTHER_EXTRADATATYPE");
+        return -EINVAL;
+    }
+
+    faceData = ( OMX_FACEDETECTIONTYPE * ) extraData->data;
+    if ( NULL != faceData ) {
+        if ( sizeof(OMX_FACEDETECTIONTYPE) == faceData->nSize ) {
+            CAMHAL_LOGVB("Faces detected %d",
+                         faceData->ulFaceCount,
+                         faceData->nSize,
+                         sizeof(OMX_FACEDETECTIONTYPE),
+                         faceData->eCameraView,
+                         faceData->nPortIndex,
+                         faceData->nVersion);
+        } else {
+            CAMHAL_LOGEB("OMX_FACEDETECTIONTYPE size mismatch: expected = %d, received = %d",
+                         ( unsigned int ) sizeof(OMX_FACEDETECTIONTYPE),
+                         ( unsigned int ) faceData->nSize);
+            return -EINVAL;
+        }
+    } else {
+        CAMHAL_LOGEA("Invalid OMX_FACEDETECTIONTYPE");
+        return -EINVAL;
+    }
+
+    ret = encodeFaceCoordinates(faceData, &faces, previewWidth, previewHeight);
+
+    if ( NO_ERROR == ret ) {
+        result = new CameraFDResult(faces);
+    } else {
+        result.clear();
+        result = NULL;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::encodeFaceCoordinates(const OMX_FACEDETECTIONTYPE *faceData,
+                                                 camera_frame_metadata_t **pFaces,
+                                                 size_t previewWidth,
+                                                 size_t previewHeight)
+{
+    status_t ret = NO_ERROR;
+    camera_face_t *faces;
+    camera_frame_metadata_t *faceResult;
+    size_t hRange, vRange;
+    double tmp;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == faceData ) {
+        CAMHAL_LOGEA("Invalid OMX_FACEDETECTIONTYPE parameter");
+        return EINVAL;
+    }
+
+    LOG_FUNCTION_NAME
+
+    hRange = CameraFDResult::RIGHT - CameraFDResult::LEFT;
+    vRange = CameraFDResult::BOTTOM - CameraFDResult::TOP;
+
+    faceResult = ( camera_frame_metadata_t * ) malloc(sizeof(camera_frame_metadata_t));
+    if ( NULL == faceResult ) {
+        return -ENOMEM;
+    }
+
+    if ( 0 < faceData->ulFaceCount ) {
+
+        faces = ( camera_face_t * ) malloc(sizeof(camera_face_t)*faceData->ulFaceCount);
+        if ( NULL == faces ) {
+            return -ENOMEM;
+        }
+
+        for ( int i = 0  ; i < faceData->ulFaceCount ; i++)
+            {
+
+            tmp = ( double ) faceData->tFacePosition[i].nLeft / ( double ) previewWidth;
+            tmp *= hRange;
+            tmp -= hRange/2;
+            faces[i].rect[0] = tmp;
+
+            tmp = ( double ) faceData->tFacePosition[i].nTop / ( double )previewHeight;
+            tmp *= vRange;
+            tmp -= vRange/2;
+            faces[i].rect[1] = tmp;
+
+            tmp = ( double ) faceData->tFacePosition[i].nWidth / ( double ) previewWidth;
+            tmp *= hRange;
+            faces[i].rect[2] = faces[i].rect[0] + tmp;
+
+            tmp = ( double ) faceData->tFacePosition[i].nHeight / ( double ) previewHeight;
+            tmp *= vRange;
+            faces[i].rect[3] = faces[i].rect[1] + tmp;
+
+            faces[i].score = faceData->tFacePosition[i].nScore;
+            faces[i].id = 0;
+            faces[i].left_eye[0] = CameraFDResult::INVALID_DATA;
+            faces[i].left_eye[1] = CameraFDResult::INVALID_DATA;
+            faces[i].right_eye[0] = CameraFDResult::INVALID_DATA;
+            faces[i].right_eye[1] = CameraFDResult::INVALID_DATA;
+            faces[i].mouth[0] = CameraFDResult::INVALID_DATA;
+            faces[i].mouth[1] = CameraFDResult::INVALID_DATA;
+            }
+
+        faceResult->number_of_faces = faceData->ulFaceCount;
+        faceResult->faces = faces;
+
+    } else {
+        faceResult->number_of_faces = 0;
+        faceResult->faces = NULL;
+    }
+
+    *pFaces = faceResult;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+};
diff --git a/camera/OMXCameraAdapter/OMXFocus.cpp b/camera/OMXCameraAdapter/OMXFocus.cpp
new file mode 100644
index 0000000..19286ea
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXFocus.cpp
@@ -0,0 +1,673 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+
+/**
+* @file OMXFocus.cpp
+*
+* This file contains functionality for handling focus configurations.
+*
+*/
+
+#undef LOG_TAG
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+
+#define TOUCH_FOCUS_RANGE 0xFF
+#define AF_CALLBACK_TIMEOUT 10000000 //10 seconds timeout
+
+namespace android {
+
+status_t OMXCameraAdapter::setParametersFocus(const CameraParameters &params,
+                                              BaseCameraAdapter::AdapterState state)
+{
+    status_t ret = NO_ERROR;
+    const char *str = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    str = params.get(CameraParameters::KEY_FOCUS_AREAS);
+    mFocusAreas.clear();
+    if ( NULL != str )
+        {
+        CameraArea::parseFocusArea(str, strlen(str), mFocusAreas);
+        }
+
+    LOG_FUNCTION_NAME;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::doAutoFocus()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focusControl;
+    size_t top, left, width, height, weight;
+    sp<CameraArea> focusArea = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateExecuting != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component not in executing state");
+        returnFocusStatus(false);
+        return NO_INIT;
+        }
+
+    if ( 0 != mDoAFSem.Count() )
+        {
+        CAMHAL_LOGEB("Error mDoAFSem semaphore count %d", mDoAFSem.Count());
+        return NO_INIT;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        if ( !mFocusAreas.isEmpty() )
+            {
+            focusArea = mFocusAreas.itemAt(0);
+            }
+
+        OMX_INIT_STRUCT_PTR (&focusControl, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
+        focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) mParameters3A.Focus;
+
+        //If touch AF is set, then necessary configuration first
+        if ( ( NULL != focusArea.get() ) && ( focusArea->isValid() ) )
+            {
+
+            //Disable face priority first
+            setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
+
+            //Enable region algorithm priority
+            setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true);
+
+            //Set position
+            OMXCameraPortParameters * mPreviewData = NULL;
+            mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
+            focusArea->transfrom(mPreviewData->mWidth,
+                                 mPreviewData->mHeight,
+                                 top,
+                                 left,
+                                 width,
+                                 height);
+            setTouchFocus(left,
+                          top,
+                          width,
+                          height,
+                          mPreviewData->mWidth,
+                          mPreviewData->mHeight);
+
+            //Do normal focus afterwards
+            focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
+
+            }
+        else if ( FOCUS_FACE_PRIORITY == focusControl.eFocusControl )
+            {
+
+            //Disable region priority first
+            setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
+
+            //Enable face algorithm priority
+            setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, true);
+
+            //Do normal focus afterwards
+            focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
+
+            }
+        else
+            {
+
+            //Disable both region and face priority
+            setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
+
+            setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
+
+            }
+
+        if ( ( mParameters3A.Focus != OMX_IMAGE_FocusControlAuto )  &&
+             ( mParameters3A.Focus != OMX_IMAGE_FocusControlAutoInfinity ) )
+            {
+
+            ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
+                                        (OMX_EVENTTYPE) OMX_EventIndexSettingChanged,
+                                        OMX_ALL,
+                                        OMX_IndexConfigCommonFocusStatus,
+                                        mDoAFSem);
+
+            if ( NO_ERROR == ret )
+                {
+                ret = setFocusCallback(true);
+                }
+            }
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                OMX_IndexConfigFocusControl,
+                                &focusControl);
+
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while starting focus 0x%x", eError);
+            return INVALID_OPERATION;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Autofocus started successfully");
+            }
+        }
+
+    if ( ( mParameters3A.Focus != OMX_IMAGE_FocusControlAuto )  &&
+         ( mParameters3A.Focus != OMX_IMAGE_FocusControlAutoInfinity ) )
+        {
+
+        ret = mDoAFSem.WaitTimeout(AF_CALLBACK_TIMEOUT);
+        //Disable auto focus callback from Ducati
+        setFocusCallback(false);
+        //Signal a dummy AF event so that in case the callback from ducati
+        //does come then it doesnt crash after
+        //exiting this function since eventSem will go out of scope.
+        if(ret != NO_ERROR)
+            {
+            CAMHAL_LOGEA("Autofocus callback timeout expired");
+            SignalEvent(mCameraAdapterParameters.mHandleComp,
+                                        (OMX_EVENTTYPE) OMX_EventIndexSettingChanged,
+                                        OMX_ALL,
+                                        OMX_IndexConfigCommonFocusStatus,
+                                        NULL );
+            returnFocusStatus(true);
+            }
+        else
+            {
+            CAMHAL_LOGDA("Autofocus callback received");
+            ret = returnFocusStatus(false);
+            }
+
+        }
+    else
+        {
+        if ( NO_ERROR == ret )
+            {
+            ret = returnFocusStatus(true);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::stopAutoFocus()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focusControl;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateExecuting != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component not in executing state");
+        return NO_INIT;
+        }
+
+    if ( mParameters3A.Focus == OMX_IMAGE_FocusControlAutoInfinity ) {
+        // No need to stop focus if we are in infinity mode. Nothing to stop.
+        return NO_ERROR;
+    }
+
+    if ( NO_ERROR == ret )
+       {
+       //Disable the callback first
+       ret = setFocusCallback(false);
+       }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&focusControl, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
+        focusControl.eFocusControl = OMX_IMAGE_FocusControlOff;
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                OMX_IndexConfigFocusControl,
+                                &focusControl);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while stopping focus 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            mParameters3A.Focus = OMX_IMAGE_FocusControlOff;
+            CAMHAL_LOGDA("Autofocus stopped successfully");
+            }
+        }
+
+    //Query current focus distance after AF is complete
+    updateFocusDistances(mParameters);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::cancelAutoFocus()
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+    LOG_FUNCTION_NAME;
+
+    stopAutoFocus();
+    //Signal a dummy AF event so that in case the callback from ducati
+    //does come then it doesnt crash after
+    //exiting this function since eventSem will go out of scope.
+    ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
+                                (OMX_EVENTTYPE) OMX_EventIndexSettingChanged,
+                                OMX_ALL,
+                                OMX_IndexConfigCommonFocusStatus,
+                                NULL );
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+
+}
+
+status_t OMXCameraAdapter::setFocusCallback(bool enabled)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_CALLBACKREQUESTTYPE focusRequstCallback;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateExecuting != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component not in executing state");
+        ret = -1;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        OMX_INIT_STRUCT_PTR (&focusRequstCallback, OMX_CONFIG_CALLBACKREQUESTTYPE);
+        focusRequstCallback.nPortIndex = OMX_ALL;
+        focusRequstCallback.nIndex = OMX_IndexConfigCommonFocusStatus;
+
+        if ( enabled )
+            {
+            focusRequstCallback.bEnable = OMX_TRUE;
+            }
+        else
+            {
+            focusRequstCallback.bEnable = OMX_FALSE;
+            }
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                (OMX_INDEXTYPE) OMX_IndexConfigCallbackRequest,
+                                &focusRequstCallback);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error registering focus callback 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDB("Autofocus callback for index 0x%x registered successfully",
+                         OMX_IndexConfigCommonFocusStatus);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::returnFocusStatus(bool timeoutReached)
+{
+    status_t ret = NO_ERROR;
+    OMX_PARAM_FOCUSSTATUSTYPE eFocusStatus;
+    bool focusStatus = false;
+    BaseCameraAdapter::AdapterState state;
+    BaseCameraAdapter::getState(state);
+
+    LOG_FUNCTION_NAME;
+
+    OMX_INIT_STRUCT(eFocusStatus, OMX_PARAM_FOCUSSTATUSTYPE);
+
+    if( ( AF_ACTIVE & state ) != AF_ACTIVE )
+       {
+        /// We don't send focus callback if focus was not started
+       return NO_ERROR;
+       }
+
+    if ( NO_ERROR == ret )
+        {
+
+        if ( !timeoutReached )
+            {
+            ret = checkFocus(&eFocusStatus);
+
+            if ( NO_ERROR != ret )
+                {
+                CAMHAL_LOGEA("Focus status check failed!");
+                }
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        if ( timeoutReached )
+            {
+            focusStatus = false;
+            }
+        else
+            {
+
+            switch (eFocusStatus.eFocusStatus)
+                {
+                    case OMX_FocusStatusReached:
+                        {
+                        focusStatus = true;
+                        break;
+                        }
+                    case OMX_FocusStatusOff:
+                    case OMX_FocusStatusUnableToReach:
+                    case OMX_FocusStatusRequest:
+                    default:
+                        {
+                        focusStatus = false;
+                        break;
+                        }
+                }
+
+            stopAutoFocus();
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+
+        ret =  BaseCameraAdapter::setState(CAMERA_CANCEL_AUTOFOCUS);
+
+        if ( NO_ERROR == ret )
+            {
+            ret = BaseCameraAdapter::commitState();
+            }
+        else
+            {
+            ret |= BaseCameraAdapter::rollbackState();
+            }
+
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        notifyFocusSubscribers(focusStatus);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::checkFocus(OMX_PARAM_FOCUSSTATUSTYPE *eFocusStatus)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == eFocusStatus )
+        {
+        CAMHAL_LOGEA("Invalid focus status");
+        ret = -EINVAL;
+        }
+
+    if ( OMX_StateExecuting != mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component not in executing state");
+        ret = -EINVAL;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (eFocusStatus, OMX_PARAM_FOCUSSTATUSTYPE);
+
+        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+                               OMX_IndexConfigCommonFocusStatus,
+                               eFocusStatus);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while retrieving focus status: 0x%x", eError);
+            ret = -1;
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        CAMHAL_LOGDB("Focus Status: %d", eFocusStatus->eFocusStatus);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::updateFocusDistances(CameraParameters &params)
+{
+    OMX_U32 focusNear, focusOptimal, focusFar;
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    ret = getFocusDistances(focusNear, focusOptimal, focusFar);
+    if ( NO_ERROR == ret)
+        {
+        ret = addFocusDistances(focusNear, focusOptimal, focusFar, params);
+            if ( NO_ERROR != ret )
+                {
+                CAMHAL_LOGEB("Error in call to addFocusDistances() 0x%x", ret);
+                }
+        }
+    else
+        {
+        CAMHAL_LOGEB("Error in call to getFocusDistances() 0x%x", ret);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::getFocusDistances(OMX_U32 &near,OMX_U32 &optimal, OMX_U32 &far)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError;
+
+    OMX_TI_CONFIG_FOCUSDISTANCETYPE focusDist;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = UNKNOWN_ERROR;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR(&focusDist, OMX_TI_CONFIG_FOCUSDISTANCETYPE);
+        focusDist.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
+
+        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
+                               ( OMX_INDEXTYPE ) OMX_TI_IndexConfigFocusDistance,
+                               &focusDist);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while querying focus distances 0x%x", eError);
+            ret = UNKNOWN_ERROR;
+            }
+
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        near = focusDist.nFocusDistanceNear;
+        optimal = focusDist.nFocusDistanceOptimal;
+        far = focusDist.nFocusDistanceFar;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::encodeFocusDistance(OMX_U32 dist, char *buffer, size_t length)
+{
+    status_t ret = NO_ERROR;
+    uint32_t focusScale = 1000;
+    float distFinal;
+
+    LOG_FUNCTION_NAME;
+
+    if(mParameters3A.Focus == OMX_IMAGE_FocusControlAutoInfinity)
+        {
+        dist=0;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        if ( 0 == dist )
+            {
+            strncpy(buffer, CameraParameters::FOCUS_DISTANCE_INFINITY, ( length - 1 ));
+            }
+        else
+            {
+            distFinal = dist;
+            distFinal /= focusScale;
+            snprintf(buffer, ( length - 1 ) , "%5.3f", distFinal);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::addFocusDistances(OMX_U32 &near,
+                                             OMX_U32 &optimal,
+                                             OMX_U32 &far,
+                                             CameraParameters& params)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    if ( NO_ERROR == ret )
+        {
+        ret = encodeFocusDistance(near, mFocusDistNear, FOCUS_DIST_SIZE);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("Error encoding near focus distance 0x%x", ret);
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        ret = encodeFocusDistance(optimal, mFocusDistOptimal, FOCUS_DIST_SIZE);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("Error encoding near focus distance 0x%x", ret);
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        ret = encodeFocusDistance(far, mFocusDistFar, FOCUS_DIST_SIZE);
+        if ( NO_ERROR != ret )
+            {
+            CAMHAL_LOGEB("Error encoding near focus distance 0x%x", ret);
+            }
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        snprintf(mFocusDistBuffer, ( FOCUS_DIST_BUFFER_SIZE - 1) ,"%s,%s,%s", mFocusDistNear,
+                                                                              mFocusDistOptimal,
+                                                                              mFocusDistFar);
+
+        params.set(CameraParameters::KEY_FOCUS_DISTANCES, mFocusDistBuffer);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::setTouchFocus(size_t posX,
+                                         size_t posY,
+                                         size_t posWidth,
+                                         size_t posHeight,
+                                         size_t previewWidth,
+                                         size_t previewHeight)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_EXTFOCUSREGIONTYPE touchControl;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -1;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&touchControl, OMX_CONFIG_EXTFOCUSREGIONTYPE);
+        touchControl.nLeft = ( posX * TOUCH_FOCUS_RANGE ) / previewWidth;
+        touchControl.nTop =  ( posY * TOUCH_FOCUS_RANGE ) / previewHeight;
+        touchControl.nWidth = ( posWidth * TOUCH_FOCUS_RANGE ) / previewWidth;
+        touchControl.nHeight = ( posHeight * TOUCH_FOCUS_RANGE ) / previewHeight;
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                ( OMX_INDEXTYPE ) OMX_IndexConfigExtFocusRegion,
+                                &touchControl);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while configuring touch focus 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDB("Touch focus %d,%d %d,%d configured successfuly",
+                         ( int ) touchControl.nLeft,
+                         ( int ) touchControl.nTop,
+                         ( int ) touchControl.nWidth,
+                         ( int ) touchControl.nHeight);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+};
diff --git a/camera/OMXCameraAdapter/OMXZoom.cpp b/camera/OMXCameraAdapter/OMXZoom.cpp
new file mode 100644
index 0000000..9e59f3d
--- /dev/null
+++ b/camera/OMXCameraAdapter/OMXZoom.cpp
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file OMXZoom.cpp
+*
+* This file contains functionality for handling zoom configurations.
+*
+*/
+
+#undef LOG_TAG
+
+#define LOG_TAG "CameraHAL"
+
+#include "CameraHal.h"
+#include "OMXCameraAdapter.h"
+
+namespace android {
+
+const int32_t OMXCameraAdapter::ZOOM_STEPS [ZOOM_STAGES] =  {
+                                65536, 68157, 70124, 72745,
+                                75366, 77988, 80609, 83231,
+                                86508, 89784, 92406, 95683,
+                                99615, 102892, 106168, 110100,
+                                114033, 117965, 122552, 126484,
+                                131072, 135660, 140247, 145490,
+                                150733, 155976, 161219, 167117,
+                                173015, 178913, 185467, 192020,
+                                198574, 205783, 212992, 220201,
+                                228065, 236585, 244449, 252969,
+                                262144, 271319, 281149, 290980,
+                                300810, 311951, 322437, 334234,
+                                346030, 357827, 370934, 384041,
+                                397148, 411566, 425984, 441057,
+                                456131, 472515, 488899, 506593,
+                                524288 };
+
+
+status_t OMXCameraAdapter::setParametersZoom(const CameraParameters &params,
+                                             BaseCameraAdapter::AdapterState state)
+{
+    status_t ret = NO_ERROR;
+    Mutex::Autolock lock(mZoomLock);
+
+    LOG_FUNCTION_NAME;
+
+    //Immediate zoom should not be avaialable while smooth zoom is running
+    if ( ( ZOOM_ACTIVE & state ) != ZOOM_ACTIVE )
+        {
+        int zoom = params.getInt(CameraParameters::KEY_ZOOM);
+        if( ( zoom >= 0 ) && ( zoom < ZOOM_STAGES ) )
+            {
+            mTargetZoomIdx = zoom;
+
+            //Immediate zoom should be applied instantly ( CTS requirement )
+            mCurrentZoomIdx = mTargetZoomIdx;
+            doZoom(mCurrentZoomIdx);
+
+            CAMHAL_LOGDB("Zoom by App %d", zoom);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::doZoom(int index)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    OMX_CONFIG_SCALEFACTORTYPE zoomControl;
+    static int prevIndex = 0;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState )
+        {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = -1;
+        }
+
+    if (  ( 0 > index) || ( ( ZOOM_STAGES - 1 ) < index ) )
+        {
+        CAMHAL_LOGEB("Zoom index %d out of range", index);
+        ret = -EINVAL;
+        }
+
+    if ( prevIndex == index )
+        {
+        return NO_ERROR;
+        }
+
+    if ( NO_ERROR == ret )
+        {
+        OMX_INIT_STRUCT_PTR (&zoomControl, OMX_CONFIG_SCALEFACTORTYPE);
+        zoomControl.nPortIndex = OMX_ALL;
+        zoomControl.xHeight = ZOOM_STEPS[index];
+        zoomControl.xWidth = ZOOM_STEPS[index];
+
+        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                                OMX_IndexConfigCommonDigitalZoom,
+                                &zoomControl);
+        if ( OMX_ErrorNone != eError )
+            {
+            CAMHAL_LOGEB("Error while applying digital zoom 0x%x", eError);
+            ret = -1;
+            }
+        else
+            {
+            CAMHAL_LOGDA("Digital zoom applied successfully");
+            prevIndex = index;
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::advanceZoom()
+{
+    status_t ret = NO_ERROR;
+    AdapterState state;
+    BaseCameraAdapter::getState(state);
+
+    if ( mReturnZoomStatus )
+        {
+        mTargetZoomIdx = mCurrentZoomIdx;
+        mReturnZoomStatus = false;
+        ret = doZoom(mCurrentZoomIdx);
+        notifyZoomSubscribers(mCurrentZoomIdx, true);
+        }
+    else if ( mCurrentZoomIdx != mTargetZoomIdx )
+        {
+        if ( ZOOM_ACTIVE & state )
+            {
+            if ( mCurrentZoomIdx < mTargetZoomIdx )
+                {
+                mZoomInc = 1;
+                }
+            else
+                {
+                mZoomInc = -1;
+                }
+
+            mCurrentZoomIdx += mZoomInc;
+            }
+        else
+            {
+            mCurrentZoomIdx = mTargetZoomIdx;
+            }
+
+        ret = doZoom(mCurrentZoomIdx);
+
+        if ( ZOOM_ACTIVE & state )
+            {
+            if ( mCurrentZoomIdx == mTargetZoomIdx )
+                {
+                CAMHAL_LOGDB("[Goal Reached] Smooth Zoom notify currentIdx = %d, targetIdx = %d",
+                             mCurrentZoomIdx,
+                             mTargetZoomIdx);
+                notifyZoomSubscribers(mCurrentZoomIdx, true);
+
+                if ( NO_ERROR == ret )
+                    {
+
+                    ret =  BaseCameraAdapter::setState(CAMERA_STOP_SMOOTH_ZOOM);
+
+                    if ( NO_ERROR == ret )
+                        {
+                        ret = BaseCameraAdapter::commitState();
+                        }
+                    else
+                        {
+                        ret |= BaseCameraAdapter::rollbackState();
+                        }
+
+                    }
+                }
+            else
+                {
+                CAMHAL_LOGDB("[Advancing] Smooth Zoom notify currentIdx = %d, targetIdx = %d",
+                             mCurrentZoomIdx,
+                             mTargetZoomIdx);
+                notifyZoomSubscribers(mCurrentZoomIdx, false);
+                }
+            }
+        }
+    else if ( (mCurrentZoomIdx == mTargetZoomIdx ) &&
+              ( ZOOM_ACTIVE & state ) )
+        {
+        ret = BaseCameraAdapter::setState(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM);
+
+        if ( NO_ERROR == ret )
+            {
+            ret = BaseCameraAdapter::commitState();
+            }
+        else
+            {
+            ret |= BaseCameraAdapter::rollbackState();
+            }
+        }
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::startSmoothZoom(int targetIdx)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mZoomLock);
+
+    CAMHAL_LOGDB("Start smooth zoom target = %d, mCurrentIdx = %d",
+                 targetIdx,
+                 mCurrentZoomIdx);
+
+    if ( ( targetIdx >= 0 ) && ( targetIdx < ZOOM_STAGES ) )
+        {
+        mTargetZoomIdx = targetIdx;
+        mZoomParameterIdx = mCurrentZoomIdx;
+        }
+    else
+        {
+        CAMHAL_LOGEB("Smooth value out of range %d!", targetIdx);
+        ret = -EINVAL;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t OMXCameraAdapter::stopSmoothZoom()
+{
+    status_t ret = NO_ERROR;
+    Mutex::Autolock lock(mZoomLock);
+
+    LOG_FUNCTION_NAME;
+
+    if ( mTargetZoomIdx != mCurrentZoomIdx )
+        {
+        mTargetZoomIdx = mCurrentZoomIdx;
+        mReturnZoomStatus = true;
+        CAMHAL_LOGDB("Stop smooth zoom mCurrentZoomIdx = %d, mTargetZoomIdx = %d",
+                     mCurrentZoomIdx,
+                     mTargetZoomIdx);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+};
diff --git a/camera/SensorListener.cpp b/camera/SensorListener.cpp
new file mode 100644
index 0000000..8b3e942
--- /dev/null
+++ b/camera/SensorListener.cpp
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file SensorListener.cpp
+*
+* This file listens and propogates sensor events to CameraHal.
+*
+*/
+
+#define LOG_TAG "CameraHAL"
+
+#include "SensorListener.h"
+#include "CameraHal.h"
+
+#include <stdint.h>
+#include <math.h>
+#include <sys/types.h>
+
+namespace android {
+
+/*** static declarations ***/
+static const float RADIANS_2_DEG = (float) (180 / M_PI);
+// measured values on device...might need tuning
+static const int DEGREES_90_THRESH = 50;
+static const int DEGREES_180_THRESH = 170;
+static const int DEGREES_270_THRESH = 250;
+
+static int sensor_events_listener(int fd, int events, void* data)
+{
+    SensorListener* listener = (SensorListener*) data;
+    ssize_t num_sensors;
+    ASensorEvent sen_events[8];
+    while ((num_sensors = listener->mSensorEventQueue->read(sen_events, 8)) > 0) {
+        for (int i = 0; i < num_sensors; i++) {
+            if (sen_events[i].type == Sensor::TYPE_ACCELEROMETER) {
+                float x = sen_events[i].vector.azimuth;
+                float y = sen_events[i].vector.pitch;
+                float z = sen_events[i].vector.roll;
+                float radius = 0;
+                int tilt = 0, orient = 0;
+
+                CAMHAL_LOGVA("ACCELEROMETER EVENT");
+                CAMHAL_LOGVB(" azimuth = %f pitch = %f roll = %f",
+                             sen_events[i].vector.azimuth,
+                             sen_events[i].vector.pitch,
+                             sen_events[i].vector.roll);
+                // see http://en.wikipedia.org/wiki/Spherical_coordinate_system#Cartesian_coordinates
+                // about conversion from cartesian to spherical for orientation calculations
+                radius = (float) sqrt(x * x + y * y + z * z);
+                tilt = (int) asinf(z / radius) * RADIANS_2_DEG;
+                orient = (int) atan2f(-x, y) * RADIANS_2_DEG;
+
+                if (orient < 0) {
+                    orient += 360;
+                }
+
+                if (orient >= DEGREES_270_THRESH) {
+                    orient = 270;
+                } else if (orient >= DEGREES_180_THRESH) {
+                    orient = 180;
+                } else if (orient >= DEGREES_90_THRESH) {
+                    orient = 90;
+                } else {
+                    orient = 0;
+                }
+                listener->handleOrientation(orient, tilt);
+                CAMHAL_LOGVB(" tilt = %d orientation = %d", tilt, orient);
+            } else if (sen_events[i].type == Sensor::TYPE_GYROSCOPE) {
+                CAMHAL_LOGVA("GYROSCOPE EVENT");
+            }
+        }
+    }
+
+    if (num_sensors < 0 && num_sensors != -EAGAIN) {
+        CAMHAL_LOGEB("reading events failed: %s", strerror(-num_sensors));
+    }
+
+    return 1;
+}
+
+/****** public - member functions ******/
+SensorListener::SensorListener() {
+    LOG_FUNCTION_NAME;
+
+    sensorsEnabled = 0;
+    mOrientationCb = NULL;
+    mSensorEventQueue = NULL;
+    mSensorLooperThread = NULL;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+SensorListener::~SensorListener() {
+    LOG_FUNCTION_NAME;
+
+    CAMHAL_LOGDA("Kill looper thread");
+    if (mSensorLooperThread.get()) {
+        // 1. Request exit
+        // 2. Wake up looper which should be polling for an event
+        // 3. Wait for exit
+        mSensorLooperThread->requestExit();
+        mSensorLooperThread->wake();
+        mSensorLooperThread->join();
+        mSensorLooperThread.clear();
+        mSensorLooperThread = NULL;
+    }
+
+    CAMHAL_LOGDA("Kill looper");
+    if (mLooper.get()) {
+        mLooper->removeFd(mSensorEventQueue->getFd());
+        mLooper.clear();
+        mLooper = NULL;
+    }
+    CAMHAL_LOGDA("SensorListener destroyed");
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+status_t SensorListener::initialize() {
+    status_t ret = NO_ERROR;
+    SensorManager& mgr(SensorManager::getInstance());
+    Sensor const* const* list;
+    ssize_t count = 0;
+    Sensor const* accelerometer;
+
+    LOG_FUNCTION_NAME;
+
+    count = mgr.getSensorList(&list);
+    CAMHAL_LOGDB("numSensors = %lu", count);
+
+    mSensorEventQueue = mgr.createEventQueue();
+
+    sp<Looper> mLooper = new Looper(false);
+    mLooper->addFd(mSensorEventQueue->getFd(), 0, ALOOPER_EVENT_INPUT, sensor_events_listener, this);
+
+    if (mSensorLooperThread.get() == NULL)
+            mSensorLooperThread = new SensorLooperThread(mLooper.get());
+
+    if (mSensorLooperThread.get() == NULL) {
+        CAMHAL_LOGEA("Couldn't create sensor looper thread");
+        ret = NO_MEMORY;
+        goto out;
+    }
+
+    ret = mSensorLooperThread->run("sensor looper thread", PRIORITY_URGENT_DISPLAY);
+    if (ret == INVALID_OPERATION){
+        CAMHAL_LOGDA("thread already running ?!?");
+    } else if (ret != NO_ERROR) {
+        CAMHAL_LOGEA("couldn't run thread");
+        goto out;
+    }
+
+ out:
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+void SensorListener::setCallbacks(orientation_callback_t orientation_cb, void *cookie) {
+    LOG_FUNCTION_NAME;
+
+    if (orientation_cb) {
+        mOrientationCb = orientation_cb;
+    }
+    mCbCookie = cookie;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void SensorListener::handleOrientation(uint32_t orientation, uint32_t tilt) {
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(&mLock);
+
+    if (mOrientationCb && (sensorsEnabled & SENSOR_ORIENTATION)) {
+        mOrientationCb(orientation, tilt, mCbCookie);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void SensorListener::enableSensor(sensor_type_t type) {
+    Sensor const* sensor;
+    SensorManager& mgr(SensorManager::getInstance());
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(&mLock);
+
+    if ((type & SENSOR_ORIENTATION) && !(sensorsEnabled & SENSOR_ORIENTATION)) {
+        sensor = mgr.getDefaultSensor(Sensor::TYPE_ACCELEROMETER);
+        CAMHAL_LOGDB("orientation = %p (%s)", sensor, sensor->getName().string());
+        mSensorEventQueue->enableSensor(sensor);
+        mSensorEventQueue->setEventRate(sensor, ms2ns(100));
+        sensorsEnabled |= SENSOR_ORIENTATION;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void SensorListener::disableSensor(sensor_type_t type) {
+    Sensor const* sensor;
+    SensorManager& mgr(SensorManager::getInstance());
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(&mLock);
+
+    if ((type & SENSOR_ORIENTATION) && (sensorsEnabled & SENSOR_ORIENTATION)) {
+        sensor = mgr.getDefaultSensor(Sensor::TYPE_ACCELEROMETER);
+        CAMHAL_LOGDB("orientation = %p (%s)", sensor, sensor->getName().string());
+        mSensorEventQueue->disableSensor(sensor);
+        sensorsEnabled &= ~SENSOR_ORIENTATION;
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+} // namespace android
diff --git a/camera/TICameraParameters.cpp b/camera/TICameraParameters.cpp
new file mode 100644
index 0000000..2980645
--- /dev/null
+++ b/camera/TICameraParameters.cpp
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 <TICameraParameters.h>
+#include "CameraHal.h"
+
+namespace android {
+
+//TI extensions to camera mode
+const char TICameraParameters::HIGH_PERFORMANCE_MODE[] = "high-performance";
+const char TICameraParameters::HIGH_QUALITY_MODE[] = "high-quality";
+const char TICameraParameters::HIGH_QUALITY_ZSL_MODE[] = "high-quality-zsl";
+const char TICameraParameters::VIDEO_MODE[] = "video-mode";
+
+// TI extensions to standard android Parameters
+const char TICameraParameters::KEY_SUPPORTED_CAMERAS[] = "camera-indexes";
+const char TICameraParameters::KEY_CAMERA[] = "camera-index";
+const char TICameraParameters::KEY_SHUTTER_ENABLE[] = "shutter-enable";
+const char TICameraParameters::KEY_CAMERA_NAME[] = "camera-name";
+const char TICameraParameters::KEY_BURST[] = "burst-capture";
+const char TICameraParameters::KEY_CAP_MODE[] = "mode";
+const char TICameraParameters::KEY_VSTAB[] = "vstab";
+const char TICameraParameters::KEY_VSTAB_VALUES[] = "vstab-values";
+const char TICameraParameters::KEY_VNF[] = "vnf";
+const char TICameraParameters::KEY_SATURATION[] = "saturation";
+const char TICameraParameters::KEY_BRIGHTNESS[] = "brightness";
+const char TICameraParameters::KEY_EXPOSURE_MODE[] = "exposure";
+const char TICameraParameters::KEY_SUPPORTED_EXPOSURE[] = "exposure-mode-values";
+const char TICameraParameters::KEY_CONTRAST[] = "contrast";
+const char TICameraParameters::KEY_SHARPNESS[] = "sharpness";
+const char TICameraParameters::KEY_ISO[] = "iso";
+const char TICameraParameters::KEY_SUPPORTED_ISO_VALUES[] = "iso-mode-values";
+const char TICameraParameters::KEY_SUPPORTED_IPP[] = "ipp-values";
+const char TICameraParameters::KEY_IPP[] = "ipp";
+const char TICameraParameters::KEY_MAN_EXPOSURE[] = "manual-exposure";
+const char TICameraParameters::KEY_METERING_MODE[] = "meter-mode";
+const char TICameraParameters::KEY_PADDED_WIDTH[] = "padded-width";
+const char TICameraParameters::KEY_PADDED_HEIGHT[] = "padded-height";
+const char TICameraParameters::KEY_EXP_BRACKETING_RANGE[] = "exp-bracketing-range";
+const char TICameraParameters::KEY_TEMP_BRACKETING[] = "temporal-bracketing";
+const char TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS[] = "temporal-bracketing-range-positive";
+const char TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG[] = "temporal-bracketing-range-negative";
+const char TICameraParameters::KEY_S3D_SUPPORTED[] = "s3d-supported";
+const char TICameraParameters::KEY_MEASUREMENT_ENABLE[] = "measurement";
+const char TICameraParameters::KEY_GBCE[] = "gbce";
+const char TICameraParameters::KEY_GLBCE[] = "glbce";
+const char TICameraParameters::KEY_CURRENT_ISO[] = "current-iso";
+const char TICameraParameters::KEY_SENSOR_ORIENTATION[] = "sensor-orientation";
+const char TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES[] = "sensor-orientation-values";
+const char TICameraParameters::KEY_MINFRAMERATE[] = "min-framerate";
+const char TICameraParameters::KEY_MAXFRAMERATE[] = "max-framerate";
+
+//TI extensions for enabling/disabling GLBCE
+const char TICameraParameters::GLBCE_ENABLE[] = "enable";
+const char TICameraParameters::GLBCE_DISABLE[] = "disable";
+
+//TI extensions for enabling/disabling GBCE
+const char TICameraParameters::GBCE_ENABLE[] = "enable";
+const char TICameraParameters::GBCE_DISABLE[] = "disable";
+
+//TI extensions for enabling/disabling measurement
+const char TICameraParameters::MEASUREMENT_ENABLE[] = "enable";
+const char TICameraParameters::MEASUREMENT_DISABLE[] = "disable";
+
+//TI extensions for zoom
+const char TICameraParameters::ZOOM_SUPPORTED[] = "true";
+const char TICameraParameters::ZOOM_UNSUPPORTED[] = "false";
+
+// TI extensions for 2D Preview in Stereo Mode
+const char TICameraParameters::KEY_S3D2D_PREVIEW[] = "s3d2d-preview";
+const char TICameraParameters::KEY_S3D2D_PREVIEW_MODE[] = "s3d2d-preview-values";
+
+//TI extensions for SAC/SMC
+const char TICameraParameters::KEY_AUTOCONVERGENCE[] = "auto-convergence";
+const char TICameraParameters::KEY_AUTOCONVERGENCE_MODE[] = "auto-convergence-mode";
+const char TICameraParameters::KEY_MANUALCONVERGENCE_VALUES[] = "manual-convergence-values";
+
+//TI extensions for setting EXIF tags
+const char TICameraParameters::KEY_EXIF_MODEL[] = "exif-model";
+const char TICameraParameters::KEY_EXIF_MAKE[] = "exif-make";
+
+//TI extensions for additiona GPS data
+const char TICameraParameters::KEY_GPS_MAPDATUM[] = "gps-mapdatum";
+const char TICameraParameters::KEY_GPS_VERSION[] = "gps-version";
+const char TICameraParameters::KEY_GPS_DATESTAMP[] = "gps-datestamp";
+
+//TI extensions for enabling/disabling shutter sound
+const char TICameraParameters::SHUTTER_ENABLE[] = "true";
+const char TICameraParameters::SHUTTER_DISABLE[] = "false";
+
+//TI extensions for Temporal Bracketing
+const char TICameraParameters::BRACKET_ENABLE[] = "enable";
+const char TICameraParameters::BRACKET_DISABLE[] = "disable";
+
+//TI extensions to Image post-processing
+const char TICameraParameters::IPP_LDCNSF[] = "ldc-nsf";
+const char TICameraParameters::IPP_LDC[] = "ldc";
+const char TICameraParameters::IPP_NSF[] = "nsf";
+const char TICameraParameters::IPP_NONE[] = "off";
+
+// TI extensions to standard android pixel formats
+const char TICameraParameters::PIXEL_FORMAT_RAW[] = "raw";
+const char TICameraParameters::PIXEL_FORMAT_JPS[] = "jps";
+const char TICameraParameters::PIXEL_FORMAT_MPO[] = "mpo";
+const char TICameraParameters::PIXEL_FORMAT_RAW_JPEG[] = "raw+jpeg";
+const char TICameraParameters::PIXEL_FORMAT_RAW_MPO[] = "raw+mpo";
+
+// TI extensions to standard android scene mode settings
+const char TICameraParameters::SCENE_MODE_SPORT[] = "sport";
+const char TICameraParameters::SCENE_MODE_CLOSEUP[] = "closeup";
+const char TICameraParameters::SCENE_MODE_AQUA[] = "aqua";
+const char TICameraParameters::SCENE_MODE_SNOWBEACH[] = "snow-beach";
+const char TICameraParameters::SCENE_MODE_MOOD[] = "mood";
+const char TICameraParameters::SCENE_MODE_NIGHT_INDOOR[] = "night-indoor";
+const char TICameraParameters::SCENE_MODE_DOCUMENT[] = "document";
+const char TICameraParameters::SCENE_MODE_BARCODE[] = "barcode";
+const char TICameraParameters::SCENE_MODE_VIDEO_SUPER_NIGHT[] = "super-night";
+const char TICameraParameters::SCENE_MODE_VIDEO_CINE[] = "cine";
+const char TICameraParameters::SCENE_MODE_VIDEO_OLD_FILM[] = "old-film";
+
+// TI extensions to standard android white balance values.
+const char TICameraParameters::WHITE_BALANCE_TUNGSTEN[] = "tungsten";
+const char TICameraParameters::WHITE_BALANCE_HORIZON[] = "horizon";
+const char TICameraParameters::WHITE_BALANCE_SUNSET[] = "sunset";
+const char TICameraParameters::WHITE_BALANCE_FACE[] = "face-priority";
+
+// TI extensions to  standard android focus modes.
+const char TICameraParameters::FOCUS_MODE_PORTRAIT[] = "portrait";
+const char TICameraParameters::FOCUS_MODE_EXTENDED[] = "extended";
+const char TICameraParameters::FOCUS_MODE_FACE[] = "face-priority";
+
+//  TI extensions to add  values for effect settings.
+const char TICameraParameters::EFFECT_NATURAL[] = "natural";
+const char TICameraParameters::EFFECT_VIVID[] = "vivid";
+const char TICameraParameters::EFFECT_COLOR_SWAP[] = "color-swap";
+const char TICameraParameters::EFFECT_BLACKWHITE[] = "blackwhite";
+
+// TI extensions to add exposure preset modes
+const char TICameraParameters::EXPOSURE_MODE_OFF[] = "off";
+const char TICameraParameters::EXPOSURE_MODE_AUTO[] = "auto";
+const char TICameraParameters::EXPOSURE_MODE_NIGHT[] = "night";
+const char TICameraParameters::EXPOSURE_MODE_BACKLIGHT[] = "backlighting";
+const char TICameraParameters::EXPOSURE_MODE_SPOTLIGHT[] = "spotlight";
+const char TICameraParameters::EXPOSURE_MODE_SPORTS[] = "sports";
+const char TICameraParameters::EXPOSURE_MODE_SNOW[] = "snow";
+const char TICameraParameters::EXPOSURE_MODE_BEACH[] = "beach";
+const char TICameraParameters::EXPOSURE_MODE_APERTURE[] = "aperture";
+const char TICameraParameters::EXPOSURE_MODE_SMALL_APERTURE[] = "small-aperture";
+const char TICameraParameters::EXPOSURE_MODE_FACE[] = "face-priority";
+
+// TI extensions to add iso values
+const char TICameraParameters::ISO_MODE_AUTO[] = "auto";
+const char TICameraParameters::ISO_MODE_100[] = "100";
+const char TICameraParameters::ISO_MODE_200[] = "200";
+const char TICameraParameters::ISO_MODE_400[] = "400";
+const char TICameraParameters::ISO_MODE_800[] = "800";
+const char TICameraParameters::ISO_MODE_1000[] = "1000";
+const char TICameraParameters::ISO_MODE_1200[] = "1200";
+const char TICameraParameters::ISO_MODE_1600[] = "1600";
+
+//  TI extensions to add auto convergence values
+const char TICameraParameters::AUTOCONVERGENCE_MODE_DISABLE[] = "mode-disable";
+const char TICameraParameters::AUTOCONVERGENCE_MODE_FRAME[] = "mode-frame";
+const char TICameraParameters::AUTOCONVERGENCE_MODE_CENTER[] = "mode-center";
+const char TICameraParameters::AUTOCONVERGENCE_MODE_FFT[] = "mode-fft";
+const char TICameraParameters::AUTOCONVERGENCE_MODE_MANUAL[] = "mode-manual";
+
+//TI values for camera direction
+const char TICameraParameters::FACING_FRONT[]="front";
+const char TICameraParameters::FACING_BACK[]="back";
+
+//TI extensions to flash settings
+const char TICameraParameters::FLASH_MODE_FILL_IN[] = "fill-in";
+
+//TI extensions to add sensor orientation parameters
+const char TICameraParameters::ORIENTATION_SENSOR_NONE[] = "0";
+const char TICameraParameters::ORIENTATION_SENSOR_90[] = "90";
+const char TICameraParameters::ORIENTATION_SENSOR_180[] = "180";
+const char TICameraParameters::ORIENTATION_SENSOR_270[] = "270";
+};
+
diff --git a/camera/V4LCameraAdapter/V4LCameraAdapter.cpp b/camera/V4LCameraAdapter/V4LCameraAdapter.cpp
new file mode 100644
index 0000000..446a809
--- /dev/null
+++ b/camera/V4LCameraAdapter/V4LCameraAdapter.cpp
@@ -0,0 +1,615 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file V4LCameraAdapter.cpp
+*
+* This file maps the Camera Hardware Interface to V4L2.
+*
+*/
+
+
+#include "V4LCameraAdapter.h"
+#include "CameraHal.h"
+#include "TICameraParameters.h"
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/select.h>
+#include <linux/videodev.h>
+
+
+#include <cutils/properties.h>
+#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
+static int mDebugFps = 0;
+
+#define Q16_OFFSET 16
+
+#define HERE(Msg) {CAMHAL_LOGEB("--===line %d, %s===--\n", __LINE__, Msg);}
+
+namespace android {
+
+#undef LOG_TAG
+///Maintain a separate tag for V4LCameraAdapter logs to isolate issues OMX specific
+#define LOG_TAG "CameraHAL"
+
+//frames skipped before recalculating the framerate
+#define FPS_PERIOD 30
+
+static V4LCameraAdapter *gCameraAdapter = NULL;
+Mutex gAdapterLock;
+const char *device = DEVICE;
+
+
+/*--------------------Camera Adapter Class STARTS here-----------------------------*/
+
+status_t V4LCameraAdapter::initialize(CameraProperties::Properties* caps, int sensor_index)
+{
+    LOG_FUNCTION_NAME;
+
+    char value[PROPERTY_VALUE_MAX];
+    property_get("debug.camera.showfps", value, "0");
+    mDebugFps = atoi(value);
+
+    int ret = NO_ERROR;
+
+    // Allocate memory for video info structure
+    mVideoInfo = (struct VideoInfo *) calloc (1, sizeof (struct VideoInfo));
+    if(!mVideoInfo)
+        {
+        return NO_MEMORY;
+        }
+
+    if ((mCameraHandle = open(device, O_RDWR)) == -1)
+        {
+        CAMHAL_LOGEB("Error while opening handle to V4L2 Camera: %s", strerror(errno));
+        return -EINVAL;
+        }
+
+    ret = ioctl (mCameraHandle, VIDIOC_QUERYCAP, &mVideoInfo->cap);
+    if (ret < 0)
+        {
+        CAMHAL_LOGEA("Error when querying the capabilities of the V4L Camera");
+        return -EINVAL;
+        }
+
+    if ((mVideoInfo->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0)
+        {
+        CAMHAL_LOGEA("Error while adapter initialization: video capture not supported.");
+        return -EINVAL;
+        }
+
+    if (!(mVideoInfo->cap.capabilities & V4L2_CAP_STREAMING))
+        {
+        CAMHAL_LOGEA("Error while adapter initialization: Capture device does not support streaming i/o");
+        return -EINVAL;
+        }
+
+    // Initialize flags
+    mPreviewing = false;
+    mVideoInfo->isStreaming = false;
+    mRecording = false;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t V4LCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType)
+{
+
+    status_t ret = NO_ERROR;
+
+    if ( !mVideoInfo->isStreaming )
+        {
+        return NO_ERROR;
+        }
+
+    int i = mPreviewBufs.valueFor(( unsigned int )frameBuf);
+    if(i<0)
+        {
+        return BAD_VALUE;
+        }
+
+    mVideoInfo->buf.index = i;
+    mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
+
+    ret = ioctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
+    if (ret < 0) {
+       CAMHAL_LOGEA("Init: VIDIOC_QBUF Failed");
+       return -1;
+    }
+
+     nQueued++;
+
+    return ret;
+
+}
+
+status_t V4LCameraAdapter::setParameters(const CameraParameters &params)
+{
+    LOG_FUNCTION_NAME;
+
+    status_t ret = NO_ERROR;
+
+    int width, height;
+
+    params.getPreviewSize(&width, &height);
+
+    CAMHAL_LOGDB("Width * Height %d x %d format 0x%x", width, height, DEFAULT_PIXEL_FORMAT);
+
+    mVideoInfo->width = width;
+    mVideoInfo->height = height;
+    mVideoInfo->framesizeIn = (width * height << 1);
+    mVideoInfo->formatIn = DEFAULT_PIXEL_FORMAT;
+
+    mVideoInfo->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    mVideoInfo->format.fmt.pix.width = width;
+    mVideoInfo->format.fmt.pix.height = height;
+    mVideoInfo->format.fmt.pix.pixelformat = DEFAULT_PIXEL_FORMAT;
+
+    ret = ioctl(mCameraHandle, VIDIOC_S_FMT, &mVideoInfo->format);
+    if (ret < 0) {
+        CAMHAL_LOGEB("Open: VIDIOC_S_FMT Failed: %s", strerror(errno));
+        return ret;
+    }
+
+    // Udpate the current parameter set
+    mParams = params;
+
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+}
+
+
+void V4LCameraAdapter::getParameters(CameraParameters& params)
+{
+    LOG_FUNCTION_NAME;
+
+    // Return the current parameter set
+    params = mParams;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+///API to give the buffers to Adapter
+status_t V4LCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable)
+{
+    status_t ret = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    Mutex::Autolock lock(mLock);
+
+    switch(mode)
+        {
+        case CAMERA_PREVIEW:
+            ret = UseBuffersPreview(bufArr, num);
+            break;
+
+        //@todo Insert Image capture case here
+
+        case CAMERA_VIDEO:
+            //@warn Video capture is not fully supported yet
+            ret = UseBuffersPreview(bufArr, num);
+            break;
+
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t V4LCameraAdapter::UseBuffersPreview(void* bufArr, int num)
+{
+    int ret = NO_ERROR;
+
+    if(NULL == bufArr)
+        {
+        return BAD_VALUE;
+        }
+
+    //First allocate adapter internal buffers at V4L level for USB Cam
+    //These are the buffers from which we will copy the data into overlay buffers
+    /* Check if camera can handle NB_BUFFER buffers */
+    mVideoInfo->rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    mVideoInfo->rb.memory = V4L2_MEMORY_MMAP;
+    mVideoInfo->rb.count = num;
+
+    ret = ioctl(mCameraHandle, VIDIOC_REQBUFS, &mVideoInfo->rb);
+    if (ret < 0) {
+        CAMHAL_LOGEB("VIDIOC_REQBUFS failed: %s", strerror(errno));
+        return ret;
+    }
+
+    for (int i = 0; i < num; i++) {
+
+        memset (&mVideoInfo->buf, 0, sizeof (struct v4l2_buffer));
+
+        mVideoInfo->buf.index = i;
+        mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
+
+        ret = ioctl (mCameraHandle, VIDIOC_QUERYBUF, &mVideoInfo->buf);
+        if (ret < 0) {
+            CAMHAL_LOGEB("Unable to query buffer (%s)", strerror(errno));
+            return ret;
+        }
+
+        mVideoInfo->mem[i] = mmap (0,
+               mVideoInfo->buf.length,
+               PROT_READ | PROT_WRITE,
+               MAP_SHARED,
+               mCameraHandle,
+               mVideoInfo->buf.m.offset);
+
+        if (mVideoInfo->mem[i] == MAP_FAILED) {
+            CAMHAL_LOGEB("Unable to map buffer (%s)", strerror(errno));
+            return -1;
+        }
+
+        uint32_t *ptr = (uint32_t*) bufArr;
+
+        //Associate each Camera internal buffer with the one from Overlay
+        mPreviewBufs.add((int)ptr[i], i);
+
+    }
+
+    // Update the preview buffer count
+    mPreviewBufferCount = num;
+
+    return ret;
+}
+
+status_t V4LCameraAdapter::startPreview()
+{
+    status_t ret = NO_ERROR;
+
+  Mutex::Autolock lock(mPreviewBufsLock);
+
+  if(mPreviewing)
+    {
+    return BAD_VALUE;
+    }
+
+   for (int i = 0; i < mPreviewBufferCount; i++) {
+
+       mVideoInfo->buf.index = i;
+       mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
+
+       ret = ioctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
+       if (ret < 0) {
+           CAMHAL_LOGEA("VIDIOC_QBUF Failed");
+           return -EINVAL;
+       }
+
+       nQueued++;
+   }
+
+    enum v4l2_buf_type bufType;
+   if (!mVideoInfo->isStreaming) {
+       bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+       ret = ioctl (mCameraHandle, VIDIOC_STREAMON, &bufType);
+       if (ret < 0) {
+           CAMHAL_LOGEB("StartStreaming: Unable to start capture: %s", strerror(errno));
+           return ret;
+       }
+
+       mVideoInfo->isStreaming = true;
+   }
+
+   // Create and start preview thread for receiving buffers from V4L Camera
+   mPreviewThread = new PreviewThread(this);
+
+   CAMHAL_LOGDA("Created preview thread");
+
+
+   //Update the flag to indicate we are previewing
+   mPreviewing = true;
+
+   return ret;
+
+}
+
+status_t V4LCameraAdapter::stopPreview()
+{
+    enum v4l2_buf_type bufType;
+    int ret = NO_ERROR;
+
+    Mutex::Autolock lock(mPreviewBufsLock);
+
+    if(!mPreviewing)
+        {
+        return NO_INIT;
+        }
+
+    if (mVideoInfo->isStreaming) {
+        bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        ret = ioctl (mCameraHandle, VIDIOC_STREAMOFF, &bufType);
+        if (ret < 0) {
+            CAMHAL_LOGEB("StopStreaming: Unable to stop capture: %s", strerror(errno));
+            return ret;
+        }
+
+        mVideoInfo->isStreaming = false;
+    }
+
+    mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
+
+    nQueued = 0;
+    nDequeued = 0;
+
+    /* Unmap buffers */
+    for (int i = 0; i < mPreviewBufferCount; i++)
+        if (munmap(mVideoInfo->mem[i], mVideoInfo->buf.length) < 0)
+            CAMHAL_LOGEA("Unmap failed");
+
+    mPreviewBufs.clear();
+
+    mPreviewThread->requestExitAndWait();
+    mPreviewThread.clear();
+
+    return ret;
+
+}
+
+char * V4LCameraAdapter::GetFrame(int &index)
+{
+    int ret;
+
+    mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
+
+    /* DQ */
+    ret = ioctl(mCameraHandle, VIDIOC_DQBUF, &mVideoInfo->buf);
+    if (ret < 0) {
+        CAMHAL_LOGEA("GetFrame: VIDIOC_DQBUF Failed");
+        return NULL;
+    }
+    nDequeued++;
+
+    index = mVideoInfo->buf.index;
+
+    return (char *)mVideoInfo->mem[mVideoInfo->buf.index];
+}
+
+//API to get the frame size required to be allocated. This size is used to override the size passed
+//by camera service when VSTAB/VNF is turned ON for example
+status_t V4LCameraAdapter::getFrameSize(size_t &width, size_t &height)
+{
+    status_t ret = NO_ERROR;
+
+    // Just return the current preview size, nothing more to do here.
+    mParams.getPreviewSize(( int * ) &width,
+                           ( int * ) &height);
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
+status_t V4LCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount)
+{
+    // We don't support meta data, so simply return
+    return NO_ERROR;
+}
+
+status_t V4LCameraAdapter::getPictureBufferSize(size_t &length, size_t bufferCount)
+{
+    // We don't support image capture yet, safely return from here without messing up
+    return NO_ERROR;
+}
+
+static void debugShowFPS()
+{
+    static int mFrameCount = 0;
+    static int mLastFrameCount = 0;
+    static nsecs_t mLastFpsTime = 0;
+    static float mFps = 0;
+    mFrameCount++;
+    if (!(mFrameCount & 0x1F)) {
+        nsecs_t now = systemTime();
+        nsecs_t diff = now - mLastFpsTime;
+        mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
+        mLastFpsTime = now;
+        mLastFrameCount = mFrameCount;
+        LOGD("Camera %d Frames, %f FPS", mFrameCount, mFps);
+    }
+    // XXX: mFPS has the value we want
+}
+
+status_t V4LCameraAdapter::recalculateFPS()
+{
+    float currentFPS;
+
+    mFrameCount++;
+
+    if ( ( mFrameCount % FPS_PERIOD ) == 0 )
+        {
+        nsecs_t now = systemTime();
+        nsecs_t diff = now - mLastFPSTime;
+        currentFPS =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
+        mLastFPSTime = now;
+        mLastFrameCount = mFrameCount;
+
+        if ( 1 == mIter )
+            {
+            mFPS = currentFPS;
+            }
+        else
+            {
+            //cumulative moving average
+            mFPS = mLastFPS + (currentFPS - mLastFPS)/mIter;
+            }
+
+        mLastFPS = mFPS;
+        mIter++;
+        }
+
+    return NO_ERROR;
+}
+
+void V4LCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt)
+{
+    LOG_FUNCTION_NAME;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+V4LCameraAdapter::V4LCameraAdapter()
+{
+    LOG_FUNCTION_NAME;
+
+    // Nothing useful to do in the constructor
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+V4LCameraAdapter::~V4LCameraAdapter()
+{
+    LOG_FUNCTION_NAME;
+
+    // Close the camera handle and free the video info structure
+    close(mCameraHandle);
+
+    if (mVideoInfo)
+      {
+        free(mVideoInfo);
+        mVideoInfo = NULL;
+      }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/* Preview Thread */
+// ---------------------------------------------------------------------------
+
+int V4LCameraAdapter::previewThread()
+{
+    status_t ret = NO_ERROR;
+    int width, height;
+    CameraFrame frame;
+
+    if (mPreviewing)
+        {
+        int index = 0;
+        char *fp = this->GetFrame(index);
+        if(!fp)
+            {
+            return BAD_VALUE;
+            }
+
+        uint8_t* ptr = (uint8_t*) mPreviewBufs.keyAt(index);
+
+        int width, height;
+        uint16_t* dest = (uint16_t*)ptr;
+        uint16_t* src = (uint16_t*) fp;
+        mParams.getPreviewSize(&width, &height);
+        for(int i=0;i<height;i++)
+            {
+            for(int j=0;j<width;j++)
+                {
+                //*dest = *src;
+                //convert from YUYV to UYVY supported in Camera service
+                *dest = (((*src & 0xFF000000)>>24)<<16)|(((*src & 0x00FF0000)>>16)<<24) |
+                        (((*src & 0xFF00)>>8)<<0)|(((*src & 0x00FF)>>0)<<8);
+                src++;
+                dest++;
+                }
+                dest += 4096/2-width;
+            }
+
+        mParams.getPreviewSize(&width, &height);
+        frame.mFrameType = CameraFrame::PREVIEW_FRAME_SYNC;
+        frame.mBuffer = ptr;
+        frame.mLength = width*height*2;
+        frame.mAlignment = width*2;
+        frame.mOffset = 0;
+        frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);;
+
+        ret = sendFrameToSubscribers(&frame);
+
+        }
+
+    return ret;
+}
+
+extern "C" CameraAdapter* CameraAdapter_Factory()
+{
+    Mutex::Autolock lock(gAdapterLock);
+
+    LOG_FUNCTION_NAME;
+
+    if ( NULL == gCameraAdapter )
+        {
+        CAMHAL_LOGDA("Creating new Camera adapter instance");
+        gCameraAdapter= new V4LCameraAdapter();
+        }
+    else
+        {
+        CAMHAL_LOGDA("Reusing existing Camera adapter instance");
+        }
+
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return gCameraAdapter;
+}
+
+extern "C" int CameraAdapter_Capabilities(CameraProperties::Properties* properties_array,
+                                          const unsigned int starting_camera,
+                                          const unsigned int max_camera) {
+    int num_cameras_supported = 0;
+    CameraProperties::Properties* properties = NULL;
+
+    LOG_FUNCTION_NAME;
+
+    if(!properties_array)
+    {
+        return -EINVAL;
+    }
+
+    // TODO: Need to tell camera properties what other cameras we can support
+    if (starting_camera + num_cameras_supported < max_camera) {
+        num_cameras_supported++;
+        properties = properties_array + starting_camera;
+        properties->set(CameraProperties::CAMERA_NAME, "USBCamera");
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return num_cameras_supported;
+}
+
+};
+
+
+/*--------------------Camera Adapter Class ENDS here-----------------------------*/
+
diff --git a/camera/inc/ANativeWindowDisplayAdapter.h b/camera/inc/ANativeWindowDisplayAdapter.h
new file mode 100644
index 0000000..89c2cf1
--- /dev/null
+++ b/camera/inc/ANativeWindowDisplayAdapter.h
@@ -0,0 +1,188 @@
+/*

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

+ *

+ * 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.

+ */

+

+

+

+#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_NV12 0x100

+

+namespace android {

+

+/**

+ * Display handler class - This class basically handles the buffer posting to display

+ */

+

+class ANativeWindowDisplayAdapter : public DisplayAdapter

+{

+public:

+

+    typedef struct

+        {

+        void *mBuffer;

+        void *mUser;

+        int mOffset;

+        int mWidth;

+        int mHeight;

+        int mWidthStride;

+        int mHeightStride;

+        int mLength;

+        CameraFrame::FrameType mType;

+        } DisplayFrame;

+

+    enum DisplayStates

+        {

+        DISPLAY_INIT = 0,

+        DISPLAY_STARTED,

+        DISPLAY_STOPPED,

+        DISPLAY_EXITED

+        };

+

+public:

+

+    ANativeWindowDisplayAdapter();

+    virtual ~ANativeWindowDisplayAdapter();

+

+    ///Initializes the display adapter creates any resources required

+    virtual status_t initialize();

+

+    virtual int setPreviewWindow(struct preview_stream_ops *window);

+    virtual int setFrameProvider(FrameNotifier *frameProvider);

+    virtual int setErrorHandler(ErrorNotifier *errorNotifier);

+    virtual int enableDisplay(int width, int height, struct timeval *refTime = NULL, S3DParameters *s3dParams = NULL);

+    virtual int disableDisplay();

+    virtual status_t pauseDisplay(bool pause);

+

+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS

+

+    //Used for shot to snapshot measurement

+    virtual status_t setSnapshotTimeRef(struct timeval *refTime = NULL);

+

+#endif

+

+    virtual int useBuffers(void* bufArr, int num);

+    virtual bool supportsExternalBuffering();

+

+    //Implementation of inherited interfaces

+    virtual void* allocateBuffer(int width, int height, const char* format, int &bytes, int numBufs);

+    virtual uint32_t * getOffsets() ;

+    virtual int getFd() ;

+    virtual int freeBuffer(void* buf);

+

+    virtual int maxQueueableBuffers(unsigned int& queueable);

+

+    ///Class specific functions

+    static void frameCallbackRelay(CameraFrame* caFrame);

+    void frameCallback(CameraFrame* caFrame);

+

+    void displayThread();

+

+    private:

+    void destroy();

+    bool processHalMsg();

+    status_t PostFrame(ANativeWindowDisplayAdapter::DisplayFrame &dispFrame);

+    bool handleFrameReturn();

+

+public:

+

+    static const int DISPLAY_TIMEOUT;

+    static const int FAILED_DQS_TO_SUSPEND;

+

+    class DisplayThread : public Thread

+        {

+        ANativeWindowDisplayAdapter* mDisplayAdapter;

+        TIUTILS::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()

+                {

+                return mDisplayThreadQ;

+                }

+

+            virtual bool threadLoop()

+                {

+                mDisplayAdapter->displayThread();

+                return false;

+                }

+

+            enum DisplayThreadCommands

+                {

+                DISPLAY_START,

+                DISPLAY_STOP,

+                DISPLAY_FRAME,

+                DISPLAY_EXIT

+                };

+        };

+

+    //friend declarations

+friend class DisplayThread;

+

+private:

+    int postBuffer(void* displayBuf);

+

+private:

+    bool mFirstInit;

+    bool mSuspend;

+    int mFailedDQs;

+    bool mPaused; //Pause state

+    preview_stream_ops_t*  mANativeWindow;

+    sp<DisplayThread> mDisplayThread;

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

+    TIUTILS::MessageQueue mDisplayQ;

+    unsigned int mDisplayState;

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

+    mutable Mutex mLock;

+    bool mDisplayEnabled;

+    int mBufferCount;

+    buffer_handle_t** mBufferHandleMap;

+    IMG_native_handle_t** mGrallocHandleMap;

+    uint32_t* mOffsetsMap;

+    int mFD;

+    KeyedVector<int, int> mFramesWithCameraAdapterMap;

+    sp<ErrorNotifier> mErrorNotifier;

+

+    uint32_t mFrameWidth;

+    uint32_t mFrameHeight;

+    uint32_t mPreviewWidth;

+    uint32_t mPreviewHeight;

+

+    uint32_t mXOff;

+    uint32_t mYOff;

+

+    const char *mPixelFormat;

+

+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS

+    //Used for calculating standby to first shot

+    struct timeval mStandbyToShot;

+    bool mMeasureStandby;

+    //Used for shot to snapshot/shot calculation

+    struct timeval mStartCapture;

+    bool mShotToShot;

+

+#endif

+

+};

+

+};

+

diff --git a/camera/inc/BaseCameraAdapter.h b/camera/inc/BaseCameraAdapter.h
new file mode 100644
index 0000000..15fb73f
--- /dev/null
+++ b/camera/inc/BaseCameraAdapter.h
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 BASE_CAMERA_ADAPTER_H
+#define BASE_CAMERA_ADAPTER_H
+
+#include "CameraHal.h"
+
+namespace android {
+
+class BaseCameraAdapter : public CameraAdapter
+{
+
+public:
+
+    BaseCameraAdapter();
+    virtual ~BaseCameraAdapter();
+
+    ///Initialzes the camera adapter creates any resources required
+    virtual status_t initialize(CameraProperties::Properties*, int sensor_index = 0) = 0;
+
+    virtual int setErrorHandler(ErrorNotifier *errorNotifier);
+
+    //Message/Frame notification APIs
+    virtual void enableMsgType(int32_t msgs, frame_callback callback=NULL, event_callback eventCb=NULL, void* cookie=NULL);
+    virtual void disableMsgType(int32_t msgs, void* cookie);
+    virtual void returnFrame(void * frameBuf, CameraFrame::FrameType frameType);
+
+    //APIs to configure Camera adapter and get the current parameter set
+    virtual status_t setParameters(const CameraParameters& params) = 0;
+    virtual void getParameters(CameraParameters& params)  = 0;
+
+    //API to send a command to the camera
+    virtual status_t sendCommand(CameraCommands operation, int value1 = 0, int value2 = 0, int value3 = 0 );
+
+    virtual status_t registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data);
+
+    virtual status_t registerEndCaptureCallback(end_image_capture_callback callback, void *user_data);
+
+    //Retrieves the current Adapter state
+    virtual AdapterState getState();
+    //Retrieves the next Adapter state
+    virtual AdapterState getNextState();
+
+protected:
+    //The first two methods will try to switch the adapter state.
+    //Every call to setState() should be followed by a corresponding
+    //call to commitState(). If the state switch fails, then it will
+    //get reset to the previous state via rollbackState().
+    virtual status_t setState(CameraCommands operation);
+    virtual status_t commitState();
+    virtual status_t rollbackState();
+
+    // Retrieves the current Adapter state - for internal use (not locked)
+    virtual status_t getState(AdapterState &state);
+    // Retrieves the next Adapter state - for internal use (not locked)
+    virtual status_t getNextState(AdapterState &state);
+
+    //-----------Interface that needs to be implemented by deriving classes --------------------
+
+    //Should be implmented by deriving classes in order to start image capture
+    virtual status_t takePicture();
+
+    //Should be implmented by deriving classes in order to start image capture
+    virtual status_t stopImageCapture();
+
+    //Should be implmented by deriving classes in order to start temporal bracketing
+    virtual status_t startBracketing(int range);
+
+    //Should be implemented by deriving classes in order to stop temporal bracketing
+    virtual status_t stopBracketing();
+
+    //Should be implemented by deriving classes in oder to initiate autoFocus
+    virtual status_t autoFocus();
+
+    //Should be implemented by deriving classes in oder to initiate autoFocus
+    virtual status_t cancelAutoFocus();
+
+    //Should be called by deriving classes in order to do some bookkeeping
+    virtual status_t startVideoCapture();
+
+    //Should be called by deriving classes in order to do some bookkeeping
+    virtual status_t stopVideoCapture();
+
+    //Should be implemented by deriving classes in order to start camera preview
+    virtual status_t startPreview();
+
+    //Should be implemented by deriving classes in order to stop camera preview
+    virtual status_t stopPreview();
+
+    //Should be implemented by deriving classes in order to start smooth zoom
+    virtual status_t startSmoothZoom(int targetIdx);
+
+    //Should be implemented by deriving classes in order to stop smooth zoom
+    virtual status_t stopSmoothZoom();
+
+    //Should be implemented by deriving classes in order to stop smooth zoom
+    virtual status_t useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable);
+
+    //Should be implemented by deriving classes in order queue a released buffer in CameraAdapter
+    virtual status_t fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType);
+
+    //API to get the frame size required to be allocated. This size is used to override the size passed
+    //by camera service when VSTAB/VNF is turned ON for example
+    virtual status_t getFrameSize(size_t &width, size_t &height);
+
+    //API to get required data frame size
+    virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount);
+
+    //API to get required picture buffers size with the current configuration in CameraParameters
+    virtual status_t getPictureBufferSize(size_t &length, size_t bufferCount);
+
+    // Should be implemented by deriving classes in order to start face detection
+    // ( if supported )
+    virtual status_t startFaceDetection();
+
+    // Should be implemented by deriving classes in order to stop face detection
+    // ( if supported )
+    virtual status_t stopFaceDetection();
+
+    // Receive orientation events from CameraHal
+    virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt);
+
+    // ---------------------Interface ends-----------------------------------
+
+    status_t notifyFocusSubscribers(bool status);
+    status_t notifyShutterSubscribers();
+    status_t notifyZoomSubscribers(int zoomIdx, bool targetReached);
+    status_t notifyFaceSubscribers(sp<CameraFDResult> &faces);
+
+    //Send the frame to subscribers
+    status_t sendFrameToSubscribers(CameraFrame *frame);
+
+    //Resets the refCount for this particular frame
+    status_t resetFrameRefCount(CameraFrame &frame);
+
+    //A couple of helper functions
+    void setFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType, int refCount);
+    int getFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType);
+
+    enum FrameState {
+        STOPPED = 0,
+        RUNNING
+    };
+
+    enum FrameCommands {
+        START_PREVIEW = 0,
+        START_RECORDING,
+        RETURN_FRAME,
+        STOP_PREVIEW,
+        STOP_RECORDING,
+        DO_AUTOFOCUS,
+        TAKE_PICTURE,
+        FRAME_EXIT
+    };
+
+    enum AdapterCommands {
+        ACK = 0,
+        ERROR
+    };
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    struct timeval mStartFocus;
+    struct timeval mStartCapture;
+
+#endif
+
+    mutable Mutex mReturnFrameLock;
+
+    //Lock protecting the Adapter state
+    mutable Mutex mLock;
+    AdapterState mAdapterState;
+    AdapterState mNextState;
+
+    //Different frame subscribers get stored using these
+    KeyedVector<int, frame_callback> mFrameSubscribers;
+    KeyedVector<int, frame_callback> mFrameDataSubscribers;
+    KeyedVector<int, frame_callback> mVideoSubscribers;
+    KeyedVector<int, frame_callback> mImageSubscribers;
+    KeyedVector<int, frame_callback> mRawSubscribers;
+    KeyedVector<int, event_callback> mFocusSubscribers;
+    KeyedVector<int, event_callback> mZoomSubscribers;
+    KeyedVector<int, event_callback> mShutterSubscribers;
+    KeyedVector<int, event_callback> mFaceSubscribers;
+
+    //Preview buffer management data
+    int *mPreviewBuffers;
+    int mPreviewBufferCount;
+    size_t mPreviewBuffersLength;
+    KeyedVector<int, int> mPreviewBuffersAvailable;
+    mutable Mutex mPreviewBufferLock;
+
+    //Video buffer management data
+    int *mVideoBuffers;
+    KeyedVector<int, int> mVideoBuffersAvailable;
+    int mVideoBuffersCount;
+    size_t mVideoBuffersLength;
+    mutable Mutex mVideoBufferLock;
+
+    //Image buffer management data
+    int *mCaptureBuffers;
+    KeyedVector<int, bool> mCaptureBuffersAvailable;
+    int mCaptureBuffersCount;
+    size_t mCaptureBuffersLength;
+    mutable Mutex mCaptureBufferLock;
+
+    //Metadata buffermanagement
+    int *mPreviewDataBuffers;
+    KeyedVector<int, bool> mPreviewDataBuffersAvailable;
+    int mPreviewDataBuffersCount;
+    size_t mPreviewDataBuffersLength;
+    mutable Mutex mPreviewDataBufferLock;
+
+    TIUTILS::MessageQueue mFrameQ;
+    TIUTILS::MessageQueue mAdapterQ;
+    mutable Mutex mSubscriberLock;
+    ErrorNotifier *mErrorNotifier;
+    release_image_buffers_callback mReleaseImageBuffersCallback;
+    end_image_capture_callback mEndImageCaptureCallback;
+    void *mReleaseData;
+    void *mEndCaptureData;
+    bool mRecording;
+};
+
+};
+
+#endif //BASE_CAMERA_ADAPTER_H
+
+
diff --git a/camera/inc/CameraHal.h b/camera/inc/CameraHal.h
new file mode 100644
index 0000000..94ed67d
--- /dev/null
+++ b/camera/inc/CameraHal.h
@@ -0,0 +1,1144 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 ANDROID_HARDWARE_CAMERA_HARDWARE_H
+#define ANDROID_HARDWARE_CAMERA_HARDWARE_H
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <utils/Log.h>
+#include <utils/threads.h>
+#include <linux/videodev2.h>
+#include "binder/MemoryBase.h"
+#include "binder/MemoryHeapBase.h"
+#include <utils/threads.h>
+#include <camera/CameraParameters.h>
+#include <hardware/camera.h>
+#include "MessageQueue.h"
+#include "Semaphore.h"
+#include "CameraProperties.h"
+#include "DebugUtils.h"
+#include "SensorListener.h"
+
+#define MIN_WIDTH           640
+#define MIN_HEIGHT          480
+#define PICTURE_WIDTH   3264 /* 5mp - 2560. 8mp - 3280 */ /* Make sure it is a multiple of 16. */
+#define PICTURE_HEIGHT  2448 /* 5mp - 2048. 8mp - 2464 */ /* Make sure it is a multiple of 16. */
+#define PREVIEW_WIDTH 176
+#define PREVIEW_HEIGHT 144
+#define PIXEL_FORMAT           V4L2_PIX_FMT_UYVY
+
+#define VIDEO_FRAME_COUNT_MAX    8 //NUM_OVERLAY_BUFFERS_REQUESTED
+#define MAX_CAMERA_BUFFERS    8 //NUM_OVERLAY_BUFFERS_REQUESTED
+#define MAX_ZOOM        3
+#define THUMB_WIDTH     80
+#define THUMB_HEIGHT    60
+#define PIX_YUV422I 0
+#define PIX_YUV420P 1
+
+#define SATURATION_OFFSET 100
+#define SHARPNESS_OFFSET 100
+#define CONTRAST_OFFSET 100
+
+//Enables Absolute PPM measurements in logcat
+#define PPM_INSTRUMENTATION_ABS 1
+
+//Uncomment to enable more verbose/debug logs
+//#define DEBUG_LOG
+
+///Camera HAL Logging Functions
+#ifndef DEBUG_LOG
+
+#define CAMHAL_LOGDA(str)
+#define CAMHAL_LOGDB(str, ...)
+#define CAMHAL_LOGVA(str)
+#define CAMHAL_LOGVB(str, ...)
+
+#define CAMHAL_LOGEA LOGE
+#define CAMHAL_LOGEB LOGE
+
+#undef LOG_FUNCTION_NAME
+#undef LOG_FUNCTION_NAME_EXIT
+#define LOG_FUNCTION_NAME
+#define LOG_FUNCTION_NAME_EXIT
+
+#else
+
+#define CAMHAL_LOGDA DBGUTILS_LOGDA
+#define CAMHAL_LOGDB DBGUTILS_LOGDB
+#define CAMHAL_LOGVA DBGUTILS_LOGVA
+#define CAMHAL_LOGVB DBGUTILS_LOGVB
+
+#define CAMHAL_LOGEA DBGUTILS_LOGEA
+#define CAMHAL_LOGEB DBGUTILS_LOGEB
+
+#endif
+
+
+
+#define NONNEG_ASSIGN(x,y) \
+    if(x > -1) \
+        y = x
+
+namespace android {
+
+#define PARAM_BUFFER            6000
+
+///Forward declarations
+class CameraHal;
+class CameraFrame;
+class CameraHalEvent;
+class DisplayFrame;
+
+class CameraArea : public RefBase
+{
+public:
+
+    CameraArea(ssize_t top,
+               ssize_t left,
+               ssize_t bottom,
+               ssize_t right,
+               size_t weight) : mTop(top),
+                                mLeft(left),
+                                mBottom(bottom),
+                                mRight(right),
+                                mWeight(weight) {}
+
+    status_t transfrom(size_t width,
+                       size_t height,
+                       size_t &top,
+                       size_t &left,
+                       size_t &areaWidth,
+                       size_t &areaHeight);
+
+    bool isValid()
+        {
+        return ( ( 0 != mTop ) || ( 0 != mLeft ) || ( 0 != mBottom ) || ( 0 != mRight) );
+        }
+
+    size_t getWeight()
+        {
+        return mWeight;
+        }
+
+    static status_t parseFocusArea(const char *area,
+                                   size_t areaLength,
+                                   Vector< sp<CameraArea> > &areas);
+
+private:
+
+    static const ssize_t TOP = -1000;
+    static const ssize_t LEFT = -1000;
+    static const ssize_t BOTTOM = 1000;
+    static const ssize_t RIGHT = 1000;
+
+    ssize_t mTop;
+    ssize_t mLeft;
+    ssize_t mBottom;
+    ssize_t mRight;
+    size_t mWeight;
+};
+
+class CameraFDResult : public RefBase
+{
+public:
+
+    CameraFDResult() : mFaceData(NULL) {};
+    CameraFDResult(camera_frame_metadata_t *faces) : mFaceData(faces) {};
+
+    virtual ~CameraFDResult() {
+        if ( ( NULL != mFaceData ) && ( NULL != mFaceData->faces ) ) {
+            free(mFaceData->faces);
+            free(mFaceData);
+        }
+    }
+
+    camera_frame_metadata_t *getFaceResult() { return mFaceData; };
+
+    static const ssize_t TOP = -1000;
+    static const ssize_t LEFT = -1000;
+    static const ssize_t BOTTOM = 1000;
+    static const ssize_t RIGHT = 1000;
+    static const ssize_t INVALID_DATA = -2000;
+
+private:
+
+    camera_frame_metadata_t *mFaceData;
+};
+
+class CameraFrame
+{
+    public:
+
+    enum FrameType
+        {
+            PREVIEW_FRAME_SYNC = 0x1, ///SYNC implies that the frame needs to be explicitly returned after consuming in order to be filled by camera again
+            PREVIEW_FRAME = 0x2   , ///Preview frame includes viewfinder and snapshot frames
+            IMAGE_FRAME_SYNC = 0x4, ///Image Frame is the image capture output frame
+            IMAGE_FRAME = 0x8,
+            VIDEO_FRAME_SYNC = 0x10, ///Timestamp will be updated for these frames
+            VIDEO_FRAME = 0x20,
+            FRAME_DATA_SYNC = 0x40, ///Any extra data assosicated with the frame. Always synced with the frame
+            FRAME_DATA= 0x80,
+            RAW_FRAME = 0x100,
+            SNAPSHOT_FRAME = 0x200,
+            ALL_FRAMES = 0xFFFF   ///Maximum of 16 frame types supported
+        };
+
+    //default contrustor
+    CameraFrame():
+    mCookie(NULL),
+    mBuffer(NULL),
+    mFrameType(0),
+    mTimestamp(0),
+    mWidth(0),
+    mHeight(0),
+    mOffset(0),
+    mAlignment(0),
+    mFd(0),
+    mLength(0) {}
+
+    //copy constructor
+    CameraFrame(const CameraFrame &frame) :
+    mCookie(frame.mCookie),
+    mBuffer(frame.mBuffer),
+    mFrameType(frame.mFrameType),
+    mTimestamp(frame.mTimestamp),
+    mWidth(frame.mWidth),
+    mHeight(frame.mHeight),
+    mOffset(frame.mOffset),
+    mAlignment(frame.mAlignment),
+    mFd(frame.mFd),
+    mLength(frame.mLength) {}
+
+    void *mCookie;
+    void *mBuffer;
+    int mFrameType;
+    nsecs_t mTimestamp;
+    unsigned int mWidth, mHeight;
+    uint32_t mOffset;
+    unsigned int mAlignment;
+    int mFd;
+    size_t mLength;
+    ///@todo add other member vars like  stride etc
+};
+
+///Common Camera Hal Event class which is visible to CameraAdapter,DisplayAdapter and AppCallbackNotifier
+///@todo Rename this class to CameraEvent
+class CameraHalEvent
+{
+public:
+    //Enums
+    enum CameraHalEventType {
+        NO_EVENTS = 0x0,
+        EVENT_FOCUS_LOCKED = 0x1,
+        EVENT_FOCUS_ERROR = 0x2,
+        EVENT_ZOOM_INDEX_REACHED = 0x4,
+        EVENT_SHUTTER = 0x8,
+        EVENT_FACE = 0x10,
+        ///@remarks Future enum related to display, like frame displayed event, could be added here
+        ALL_EVENTS = 0xFFFF ///Maximum of 16 event types supported
+    };
+
+    ///Class declarations
+    ///@remarks Add a new class for a new event type added above
+
+    //Shutter event specific data
+    typedef struct ShutterEventData_t {
+        bool shutterClosed;
+    }ShutterEventData;
+
+    ///Focus event specific data
+    typedef struct FocusEventData_t {
+        bool focusLocked;
+        bool focusError;
+        int currentFocusValue;
+    } FocusEventData;
+
+    ///Zoom specific event data
+    typedef struct ZoomEventData_t {
+        int currentZoomIndex;
+        bool targetZoomIndexReached;
+    } ZoomEventData;
+
+    typedef struct FaceData_t {
+        ssize_t top;
+        ssize_t left;
+        ssize_t bottom;
+        ssize_t right;
+        size_t score;
+    } FaceData;
+
+    typedef sp<CameraFDResult> FaceEventData;
+
+    class CameraHalEventData : public RefBase{
+
+    public:
+
+        CameraHalEvent::FocusEventData focusEvent;
+        CameraHalEvent::ZoomEventData zoomEvent;
+        CameraHalEvent::ShutterEventData shutterEvent;
+        CameraHalEvent::FaceEventData faceEvent;
+    };
+
+    //default contrustor
+    CameraHalEvent():
+    mCookie(NULL),
+    mEventType(NO_EVENTS) {}
+
+    //copy constructor
+    CameraHalEvent(const CameraHalEvent &event) :
+        mCookie(event.mCookie),
+        mEventType(event.mEventType),
+        mEventData(event.mEventData) {};
+
+    void* mCookie;
+    CameraHalEventType mEventType;
+    sp<CameraHalEventData> mEventData;
+
+};
+
+///      Have a generic callback class based on template - to adapt CameraFrame and Event
+typedef void (*frame_callback) (CameraFrame *cameraFrame);
+typedef void (*event_callback) (CameraHalEvent *event);
+
+//signals CameraHAL to relase image buffers
+typedef void (*release_image_buffers_callback) (void *userData);
+typedef void (*end_image_capture_callback) (void *userData);
+
+/**
+  * Interface class implemented by classes that have some events to communicate to dependendent classes
+  * Dependent classes use this interface for registering for events
+  */
+class MessageNotifier
+{
+public:
+    static const uint32_t EVENT_BIT_FIELD_POSITION;
+    static const uint32_t FRAME_BIT_FIELD_POSITION;
+
+    ///@remarks Msg type comes from CameraFrame and CameraHalEvent classes
+    ///           MSB 16 bits is for events and LSB 16 bits is for frame notifications
+    ///         FrameProvider and EventProvider classes act as helpers to event/frame
+    ///         consumers to call this api
+    virtual void enableMsgType(int32_t msgs, frame_callback frameCb=NULL, event_callback eventCb=NULL, void* cookie=NULL) = 0;
+    virtual void disableMsgType(int32_t msgs, void* cookie) = 0;
+
+    virtual ~MessageNotifier() {};
+};
+
+class ErrorNotifier : public virtual RefBase
+{
+public:
+    virtual void errorNotify(int error) = 0;
+
+    virtual ~ErrorNotifier() {};
+};
+
+
+/**
+  * Interace class abstraction for Camera Adapter to act as a frame provider
+  * This interface is fully implemented by Camera Adapter
+  */
+class FrameNotifier : public MessageNotifier
+{
+public:
+    virtual void returnFrame(void* frameBuf, CameraFrame::FrameType frameType) = 0;
+
+    virtual ~FrameNotifier() {};
+};
+
+/**   * Wrapper class around Frame Notifier, which is used by display and notification classes for interacting with Camera Adapter
+  */
+class FrameProvider
+{
+    FrameNotifier* mFrameNotifier;
+    void* mCookie;
+    frame_callback mFrameCallback;
+
+public:
+    FrameProvider(FrameNotifier *fn, void* cookie, frame_callback frameCallback)
+        :mFrameNotifier(fn), mCookie(cookie),mFrameCallback(frameCallback) { }
+
+    int enableFrameNotification(int32_t frameTypes);
+    int disableFrameNotification(int32_t frameTypes);
+    int returnFrame(void *frameBuf, CameraFrame::FrameType frameType);
+};
+
+/** Wrapper class around MessageNotifier, which is used by display and notification classes for interacting with
+   *  Camera Adapter
+  */
+class EventProvider
+{
+public:
+    MessageNotifier* mEventNotifier;
+    void* mCookie;
+    event_callback mEventCallback;
+
+public:
+    EventProvider(MessageNotifier *mn, void* cookie, event_callback eventCallback)
+        :mEventNotifier(mn), mCookie(cookie), mEventCallback(eventCallback) {}
+
+    int enableEventNotification(int32_t eventTypes);
+    int disableEventNotification(int32_t eventTypes);
+};
+
+/*
+  * Interface for providing buffers
+  */
+class BufferProvider
+{
+public:
+    virtual void* allocateBuffer(int width, int height, const char* format, int &bytes, int numBufs) = 0;
+
+    //additional methods used for memory mapping
+    virtual uint32_t * getOffsets() = 0;
+    virtual int getFd() = 0;
+
+    virtual int freeBuffer(void* buf) = 0;
+
+    virtual ~BufferProvider() {}
+};
+
+/**
+  * Class for handling data and notify callbacks to application
+  */
+class   AppCallbackNotifier: public ErrorNotifier , public virtual RefBase
+{
+
+public:
+
+    ///Constants
+    static const int NOTIFIER_TIMEOUT;
+    static const int32_t MAX_BUFFERS = 8;
+
+    enum NotifierCommands
+        {
+        NOTIFIER_CMD_PROCESS_EVENT,
+        NOTIFIER_CMD_PROCESS_FRAME,
+        NOTIFIER_CMD_PROCESS_ERROR
+        };
+
+    enum NotifierState
+        {
+        NOTIFIER_STOPPED,
+        NOTIFIER_STARTED,
+        NOTIFIER_EXITED
+        };
+
+public:
+
+    ~AppCallbackNotifier();
+
+    ///Initialzes the callback notifier, creates any resources required
+    status_t initialize();
+
+    ///Starts the callbacks to application
+    status_t start();
+
+    ///Stops the callbacks from going to application
+    status_t stop();
+
+    void setEventProvider(int32_t eventMask, MessageNotifier * eventProvider);
+    void setFrameProvider(FrameNotifier *frameProvider);
+
+    //All sub-components of Camera HAL call this whenever any error happens
+    virtual void errorNotify(int error);
+
+    status_t startPreviewCallbacks(CameraParameters &params, void *buffers, uint32_t *offsets, int fd, size_t length, size_t count);
+    status_t stopPreviewCallbacks();
+
+    status_t enableMsgType(int32_t msgType);
+    status_t disableMsgType(int32_t msgType);
+
+    //API for enabling/disabling measurement data
+    void setMeasurements(bool enable);
+
+    //thread loops
+    void notificationThread();
+
+    ///Notification callback functions
+    static void frameCallbackRelay(CameraFrame* caFrame);
+    static void eventCallbackRelay(CameraHalEvent* chEvt);
+    void frameCallback(CameraFrame* caFrame);
+    void eventCallback(CameraHalEvent* chEvt);
+
+    void setCallbacks(CameraHal *cameraHal,
+                        camera_notify_callback notify_cb,
+                        camera_data_callback data_cb,
+                        camera_data_timestamp_callback data_cb_timestamp,
+                        camera_request_memory get_memory,
+                        void *user);
+
+    //Set Burst mode
+    void setBurst(bool burst);
+
+    //Notifications from CameraHal for video recording case
+    status_t startRecording();
+    status_t stopRecording();
+    status_t initSharedVideoBuffers(void *buffers, uint32_t *offsets, int fd, size_t length, size_t count);
+    status_t releaseRecordingFrame(const void *opaque);
+
+	status_t useMetaDataBufferMode(bool enable);
+
+    //Internal class definitions
+    class NotificationThread : public Thread {
+        AppCallbackNotifier* mAppCallbackNotifier;
+        TIUTILS::MessageQueue mNotificationThreadQ;
+    public:
+        enum NotificationThreadCommands
+        {
+        NOTIFIER_START,
+        NOTIFIER_STOP,
+        NOTIFIER_EXIT,
+        };
+    public:
+        NotificationThread(AppCallbackNotifier* nh)
+            : Thread(false), mAppCallbackNotifier(nh) { }
+        virtual bool threadLoop() {
+            mAppCallbackNotifier->notificationThread();
+            return false;
+        }
+
+        TIUTILS::MessageQueue &msgQ() { return mNotificationThreadQ;}
+    };
+
+    //Friend declarations
+    friend class NotificationThread;
+
+private:
+    void notifyEvent();
+    void notifyFrame();
+    bool processMessage();
+    void releaseSharedVideoBuffers();
+
+private:
+    mutable Mutex mLock;
+    mutable Mutex mBurstLock;
+    CameraHal* mCameraHal;
+    camera_notify_callback mNotifyCb;
+    camera_data_callback   mDataCb;
+    camera_data_timestamp_callback mDataCbTimestamp;
+    camera_request_memory mRequestMemory;
+    void *mCallbackCookie;
+
+    //Keeps Video MemoryHeaps and Buffers within
+    //these objects
+    KeyedVector<unsigned int, unsigned int> mVideoHeaps;
+    KeyedVector<unsigned int, unsigned int> mVideoBuffers;
+    KeyedVector<unsigned int, unsigned int> mVideoMap;
+
+    //Keeps list of Gralloc handles and associated Video Metadata Buffers
+    KeyedVector<uint32_t, uint32_t> mVideoMetadataBufferMemoryMap;
+    KeyedVector<uint32_t, uint32_t> mVideoMetadataBufferReverseMap;
+
+    bool mBufferReleased;
+
+    sp< NotificationThread> mNotificationThread;
+    EventProvider *mEventProvider;
+    FrameProvider *mFrameProvider;
+    TIUTILS::MessageQueue mEventQ;
+    TIUTILS::MessageQueue mFrameQ;
+    NotifierState mNotifierState;
+
+    bool mPreviewing;
+    camera_memory_t* mPreviewMemory;
+    unsigned char* mPreviewBufs[MAX_BUFFERS];
+    int mPreviewBufCount;
+    const char *mPreviewPixelFormat;
+    KeyedVector<unsigned int, sp<MemoryHeapBase> > mSharedPreviewHeaps;
+    KeyedVector<unsigned int, sp<MemoryBase> > mSharedPreviewBuffers;
+
+    //Burst mode active
+    bool mBurst;
+    mutable Mutex mRecordingLock;
+    bool mRecording;
+    bool mMeasurementEnabled;
+
+	bool mUseMetaDataBufferMode;
+
+};
+
+
+/**
+  * Class used for allocating memory for JPEG bit stream buffers, output buffers of camera in no overlay case
+  */
+class MemoryManager : public BufferProvider, public virtual RefBase
+{
+public:
+    ///Initializes the display adapter creates any resources required
+    status_t initialize(){ return NO_ERROR; }
+
+    int setErrorHandler(ErrorNotifier *errorNotifier);
+    virtual void* allocateBuffer(int width, int height, const char* format, int &bytes, int numBufs);
+    virtual uint32_t * getOffsets();
+    virtual int getFd() ;
+    virtual int freeBuffer(void* buf);
+
+private:
+
+    sp<ErrorNotifier> mErrorNotifier;
+};
+
+
+
+
+/**
+  * CameraAdapter interface class
+  * Concrete classes derive from this class and provide implementations based on the specific camera h/w interface
+  */
+
+class CameraAdapter: public FrameNotifier, public virtual RefBase
+{
+protected:
+    enum AdapterActiveStates {
+        INTIALIZED_ACTIVE =     1 << 0,
+        LOADED_PREVIEW_ACTIVE = 1 << 1,
+        PREVIEW_ACTIVE =        1 << 2,
+        LOADED_CAPTURE_ACTIVE = 1 << 3,
+        CAPTURE_ACTIVE =        1 << 4,
+        BRACKETING_ACTIVE =     1 << 5,
+        AF_ACTIVE =             1 << 6,
+        ZOOM_ACTIVE =           1 << 7,
+        VIDEO_ACTIVE =          1 << 8,
+    };
+public:
+    typedef struct
+        {
+         void *mBuffers;
+         uint32_t *mOffsets;
+         int mFd;
+         size_t mLength;
+         size_t mCount;
+         size_t mMaxQueueable;
+        } BuffersDescriptor;
+
+    enum CameraCommands
+        {
+        CAMERA_START_PREVIEW                        = 0,
+        CAMERA_STOP_PREVIEW                         = 1,
+        CAMERA_START_VIDEO                          = 2,
+        CAMERA_STOP_VIDEO                           = 3,
+        CAMERA_START_IMAGE_CAPTURE                  = 4,
+        CAMERA_STOP_IMAGE_CAPTURE                   = 5,
+        CAMERA_PERFORM_AUTOFOCUS                    = 6,
+        CAMERA_CANCEL_AUTOFOCUS                     = 7,
+        CAMERA_PREVIEW_FLUSH_BUFFERS                = 8,
+        CAMERA_START_SMOOTH_ZOOM                    = 9,
+        CAMERA_STOP_SMOOTH_ZOOM                     = 10,
+        CAMERA_USE_BUFFERS_PREVIEW                  = 11,
+        CAMERA_SET_TIMEOUT                          = 12,
+        CAMERA_CANCEL_TIMEOUT                       = 13,
+        CAMERA_START_BRACKET_CAPTURE                = 14,
+        CAMERA_STOP_BRACKET_CAPTURE                 = 15,
+        CAMERA_QUERY_RESOLUTION_PREVIEW             = 16,
+        CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE      = 17,
+        CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA       = 18,
+        CAMERA_USE_BUFFERS_IMAGE_CAPTURE            = 19,
+        CAMERA_USE_BUFFERS_PREVIEW_DATA             = 20,
+        CAMERA_TIMEOUT_EXPIRED                      = 21,
+        CAMERA_START_FD                             = 22,
+        CAMERA_STOP_FD                              = 23,
+        };
+
+    enum CameraMode
+        {
+        CAMERA_PREVIEW,
+        CAMERA_IMAGE_CAPTURE,
+        CAMERA_VIDEO,
+        CAMERA_MEASUREMENT
+        };
+
+    enum AdapterState {
+        INTIALIZED_STATE           = INTIALIZED_ACTIVE,
+        LOADED_PREVIEW_STATE       = LOADED_PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        PREVIEW_STATE              = PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        LOADED_CAPTURE_STATE       = LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        CAPTURE_STATE              = CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        BRACKETING_STATE           = BRACKETING_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE ,
+        AF_STATE                   = AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        ZOOM_STATE                 = ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        VIDEO_STATE                = VIDEO_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        VIDEO_ZOOM_STATE           = VIDEO_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        AF_ZOOM_STATE              = AF_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+        BRACKETING_ZOOM_STATE      = BRACKETING_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
+    };
+
+public:
+
+    ///Initialzes the camera adapter creates any resources required
+    virtual int initialize(CameraProperties::Properties*, int sensor_index=0) = 0;
+
+    virtual int setErrorHandler(ErrorNotifier *errorNotifier) = 0;
+
+    //Message/Frame notification APIs
+    virtual void enableMsgType(int32_t msgs,
+                               frame_callback callback = NULL,
+                               event_callback eventCb = NULL,
+                               void *cookie = NULL) = 0;
+    virtual void disableMsgType(int32_t msgs, void* cookie) = 0;
+    virtual void returnFrame(void* frameBuf, CameraFrame::FrameType frameType) = 0;
+
+    //APIs to configure Camera adapter and get the current parameter set
+    virtual int setParameters(const CameraParameters& params) = 0;
+    virtual void getParameters(CameraParameters& params) = 0;
+
+    //API to flush the buffers from Camera
+     status_t flushBuffers()
+        {
+        return sendCommand(CameraAdapter::CAMERA_PREVIEW_FLUSH_BUFFERS);
+        }
+
+    //Registers callback for returning image buffers back to CameraHAL
+    virtual int registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data) = 0;
+
+    //Registers callback, which signals a completed image capture
+    virtual int registerEndCaptureCallback(end_image_capture_callback callback, void *user_data) = 0;
+
+    //API to send a command to the camera
+    virtual status_t sendCommand(CameraCommands operation, int value1=0, int value2=0, int value3=0) = 0;
+
+    virtual ~CameraAdapter() {};
+
+    //Retrieves the current Adapter state
+    virtual AdapterState getState() = 0;
+
+    //Retrieves the next Adapter state
+    virtual AdapterState getNextState() = 0;
+
+    // Receive orientation events from CameraHal
+    virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt) = 0;
+protected:
+    //The first two methods will try to switch the adapter state.
+    //Every call to setState() should be followed by a corresponding
+    //call to commitState(). If the state switch fails, then it will
+    //get reset to the previous state via rollbackState().
+    virtual status_t setState(CameraCommands operation) = 0;
+    virtual status_t commitState() = 0;
+    virtual status_t rollbackState() = 0;
+
+    // Retrieves the current Adapter state - for internal use (not locked)
+    virtual status_t getState(AdapterState &state) = 0;
+    // Retrieves the next Adapter state - for internal use (not locked)
+    virtual status_t getNextState(AdapterState &state) = 0;
+};
+
+class DisplayAdapter : public BufferProvider, public virtual RefBase
+{
+public:
+    typedef struct S3DParameters_t
+    {
+        int mode;
+        int framePacking;
+        int order;
+        int subSampling;
+    } S3DParameters;
+
+    ///Initializes the display adapter creates any resources required
+    virtual int initialize() = 0;
+
+    virtual int setPreviewWindow(struct preview_stream_ops *window) = 0;
+    virtual int setFrameProvider(FrameNotifier *frameProvider) = 0;
+    virtual int setErrorHandler(ErrorNotifier *errorNotifier) = 0;
+    virtual int enableDisplay(int width, int height, struct timeval *refTime = NULL, S3DParameters *s3dParams = NULL) = 0;
+    virtual int disableDisplay() = 0;
+    //Used for Snapshot review temp. pause
+    virtual int pauseDisplay(bool pause) = 0;
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+    //Used for shot to snapshot measurement
+    virtual int setSnapshotTimeRef(struct timeval *refTime = NULL) = 0;
+#endif
+
+    virtual int useBuffers(void *bufArr, int num) = 0;
+    virtual bool supportsExternalBuffering() = 0;
+
+    // Get max queueable buffers display supports
+    // This function should only be called after
+    // allocateBuffer
+    virtual int maxQueueableBuffers(unsigned int& queueable) = 0;
+};
+
+static void releaseImageBuffers(void *userData);
+
+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
+
+{
+
+public:
+    ///Constants
+    static const int NO_BUFFERS_PREVIEW;
+    static const int NO_BUFFERS_IMAGE_CAPTURE;
+    static const uint32_t VFR_SCALE = 1000;
+
+
+    /*--------------------Interface Methods---------------------------------*/
+
+     //@{
+public:
+
+    /** Set the notification and data callbacks */
+    void setCallbacks(camera_notify_callback notify_cb,
+                        camera_data_callback data_cb,
+                        camera_data_timestamp_callback data_cb_timestamp,
+                        camera_request_memory get_memory,
+                        void *user);
+
+    /** Receives orientation events from SensorListener **/
+    void onOrientationEvent(uint32_t orientation, uint32_t tilt);
+
+    /**
+     * The following three functions all take a msgtype,
+     * which is a bitmask of the messages defined in
+     * include/ui/Camera.h
+     */
+
+    /**
+     * Enable a message, or set of messages.
+     */
+    void        enableMsgType(int32_t msgType);
+
+    /**
+     * Disable a message, or a set of messages.
+     */
+    void        disableMsgType(int32_t msgType);
+
+    /**
+     * Query whether a message, or a set of messages, is enabled.
+     * Note that this is operates as an AND, if any of the messages
+     * queried are off, this will return false.
+     */
+    int        msgTypeEnabled(int32_t msgType);
+
+    /**
+     * Start preview mode.
+     */
+    int    startPreview();
+
+    /**
+     * Only used if overlays are used for camera preview.
+     */
+    int setPreviewWindow(struct preview_stream_ops *window);
+
+    /**
+     * Stop a previously started preview.
+     */
+    void        stopPreview();
+
+    /**
+     * Returns true if preview is enabled.
+     */
+    bool        previewEnabled();
+
+    /**
+     * Start record mode. When a record image is available a CAMERA_MSG_VIDEO_FRAME
+     * message is sent with the corresponding frame. Every record frame must be released
+     * by calling releaseRecordingFrame().
+     */
+    int    startRecording();
+
+    /**
+     * Stop a previously started recording.
+     */
+    void        stopRecording();
+
+    /**
+     * Returns true if recording is enabled.
+     */
+    int        recordingEnabled();
+
+    /**
+     * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
+     */
+    void        releaseRecordingFrame(const void *opaque);
+
+    /**
+     * Set the camera parameters specific to Video Recording.
+     */
+    status_t        setVideoModeParameters();
+
+    /**
+     * Start auto focus, the notification callback routine is called
+     * with CAMERA_MSG_FOCUS once when focusing is complete. autoFocus()
+     * will be called again if another auto focus is needed.
+     */
+    int    autoFocus();
+
+    /**
+     * Cancels auto-focus function. If the auto-focus is still in progress,
+     * this function will cancel it. Whether the auto-focus is in progress
+     * or not, this function will return the focus position to the default.
+     * If the camera does not support auto-focus, this is a no-op.
+     */
+    int    cancelAutoFocus();
+
+    /**
+     * Take a picture.
+     */
+    int    takePicture();
+
+    /**
+     * Cancel a picture that was started with takePicture.  Calling this
+     * method when no picture is being taken is a no-op.
+     */
+    int    cancelPicture();
+
+    /** Set the camera parameters. */
+    int    setParameters(const char* params);
+    int    setParameters(const CameraParameters& params);
+
+    /** Return the camera parameters. */
+    char*  getParameters();
+    void putParameters(char *);
+
+    /**
+     * Send command to camera driver.
+     */
+    int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
+
+    /**
+     * Release the hardware resources owned by this object.  Note that this is
+     * *not* done in the destructor.
+     */
+    void release();
+
+    /**
+     * Dump state of the camera hardware
+     */
+    int dump(int fd) const;
+
+
+		status_t storeMetaDataInBuffers(bool enable);
+
+     //@}
+
+/*--------------------Internal Member functions - Public---------------------------------*/
+
+public:
+ /** @name internalFunctionsPublic */
+  //@{
+
+    /** Constructor of CameraHal */
+    CameraHal(int cameraId);
+
+    // Destructor of CameraHal
+    ~CameraHal();
+
+    /** Initialize CameraHal */
+    status_t initialize(CameraProperties::Properties*);
+
+    /** Deinitialize CameraHal */
+    void deinitialize();
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    //Uses the constructor timestamp as a reference to calcluate the
+    // elapsed time
+    static void PPM(const char *);
+    //Uses a user provided timestamp as a reference to calcluate the
+    // elapsed time
+    static void PPM(const char *, struct timeval*, ...);
+
+#endif
+
+    /** Free image bufs */
+    status_t freeImageBufs();
+
+    //Signals the end of image capture
+    status_t signalEndImageCapture();
+
+    //Events
+    static void eventCallbackRelay(CameraHalEvent* event);
+    void eventCallback(CameraHalEvent* event);
+    void setEventProvider(int32_t eventMask, MessageNotifier * eventProvider);
+
+/*--------------------Internal Member functions - Private---------------------------------*/
+private:
+
+    /** @name internalFunctionsPrivate */
+    //@{
+
+    status_t parseResolution(const char *resStr, int &width, int &height);
+
+    void insertSupportedParams();
+
+    /** Allocate preview data buffers */
+    status_t allocPreviewDataBufs(size_t size, size_t bufferCount);
+
+    /** Free preview data buffers */
+    status_t freePreviewDataBufs();
+
+    /** Allocate preview buffers */
+    status_t allocPreviewBufs(int width, int height, const char* previewFormat, unsigned int bufferCount, unsigned int &max_queueable);
+
+    /** Allocate video buffers */
+    status_t allocVideoBufs(int width, int height, const char* previewFormat);
+
+    /** Allocate image capture buffers */
+    status_t allocImageBufs(unsigned int width, unsigned int height, size_t length, const char* previewFormat, unsigned int bufferCount);
+
+    /** Free preview buffers */
+    status_t freePreviewBufs();
+
+    /** Free video bufs */
+    status_t freeVideoBufs();
+
+    //Check if a given resolution is supported by the current camera
+    //instance
+    bool isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions);
+
+    //Check if a given parameter is supported by the current camera
+    // instance
+    bool isParameterValid(const char *param, const char *supportedParams);
+    bool isParameterValid(int param, const char *supportedParams);
+
+    /** Initialize default parameters */
+    void initDefaultParameters();
+
+    void dumpProperties(CameraProperties::Properties& cameraProps);
+
+    status_t startImageBracketing();
+
+    status_t stopImageBracketing();
+
+    void setShutter(bool enable);
+
+    void forceStopPreview();
+
+    //@}
+
+
+/*----------Member variables - Public ---------------------*/
+public:
+    int32_t mMsgEnabled;
+    bool mRecordEnabled;
+    nsecs_t mCurrentTime;
+    bool mFalsePreview;
+    bool mPreviewEnabled;
+    uint32_t mTakePictureQueue;
+    bool mBracketingEnabled;
+    bool mBracketingRunning;
+    //User shutter override
+    bool mShutterEnabled;
+    bool mMeasurementEnabled;
+    //Google's parameter delimiter
+    static const char PARAMS_DELIMITER[];
+
+    CameraAdapter *mCameraAdapter;
+    sp<AppCallbackNotifier> mAppCallbackNotifier;
+    sp<DisplayAdapter> mDisplayAdapter;
+    sp<MemoryManager> mMemoryManager;
+
+    sp<IMemoryHeap> mPictureHeap;
+
+	int* mGrallocHandles;
+
+
+
+///static member vars
+
+#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
+
+    //Timestamp from the CameraHal constructor
+    static struct timeval ppm_start;
+    //Timestamp of the autoFocus command
+    static struct timeval mStartFocus;
+    //Timestamp of the startPreview command
+    static struct timeval mStartPreview;
+    //Timestamp of the takePicture command
+    static struct timeval mStartCapture;
+
+#endif
+
+/*----------Member variables - Private ---------------------*/
+private:
+    //keeps paused state of display
+    bool mDisplayPaused;
+    //Index of current camera adapter
+    int mCameraIndex;
+
+    mutable Mutex mLock;
+
+    sp<SensorListener> mSensorListener;
+
+    void* mCameraAdapterHandle;
+
+    CameraParameters mParameters;
+    bool mPreviewRunning;
+    bool mPreviewStateOld;
+    bool mRecordingEnabled;
+    EventProvider *mEventProvider;
+
+    int32_t *mPreviewDataBufs;
+    uint32_t *mPreviewDataOffsets;
+    int mPreviewDataFd;
+    int mPreviewDataLength;
+    int32_t *mImageBufs;
+    uint32_t *mImageOffsets;
+    int mImageFd;
+    int mImageLength;
+    int32_t *mPreviewBufs;
+    uint32_t *mPreviewOffsets;
+    int mPreviewLength;
+    int mPreviewFd;
+    int32_t *mVideoBufs;
+    uint32_t *mVideoOffsets;
+    int mVideoFd;
+    int mVideoLength;
+
+    int32_t mLastPreviewFramerate;
+
+    int mBracketRangePositive;
+    int mBracketRangeNegative;
+
+    ///@todo Rename this as preview buffer provider
+    BufferProvider *mBufProvider;
+    BufferProvider *mVideoBufProvider;
+
+
+    CameraProperties::Properties* mCameraProperties;
+
+    bool mPreviewStartInProgress;
+
+    bool mSetPreviewWindowCalled;
+
+    uint32_t mPreviewWidth;
+    uint32_t mPreviewHeight;
+    int32_t mMaxZoomSupported;
+};
+
+
+}; // namespace android
+
+#endif
diff --git a/camera/inc/CameraProperties.h b/camera/inc/CameraProperties.h
new file mode 100644
index 0000000..83d1b10
--- /dev/null
+++ b/camera/inc/CameraProperties.h
@@ -0,0 +1,180 @@
+/*

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

+ *

+ * 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 CAMERA_PROPERTIES_H

+#define CAMERA_PROPERTIES_H

+

+#include <utils/KeyedVector.h>

+#include <utils/String8.h>

+#include <stdio.h>

+#include <dirent.h>

+#include <errno.h>

+#include <stdio.h>

+#include <string.h>

+

+namespace android {

+

+#define MAX_CAMERAS_SUPPORTED 2

+#define MAX_PROP_NAME_LENGTH 50

+#define MAX_PROP_VALUE_LENGTH 2048

+

+#define EXIF_MAKE_DEFAULT "default_make"

+#define EXIF_MODEL_DEFAULT "default_model"

+

+// Class that handles the Camera Properties

+class CameraProperties

+{

+public:

+    static const char INVALID[];

+    static const char CAMERA_NAME[];

+    static const char CAMERA_SENSOR_INDEX[];

+    static const char ORIENTATION_INDEX[];

+    static const char FACING_INDEX[];

+    static const char S3D_SUPPORTED[];

+    static const char SUPPORTED_PREVIEW_SIZES[];

+    static const char SUPPORTED_PREVIEW_FORMATS[];

+    static const char SUPPORTED_PREVIEW_FRAME_RATES[];

+    static const char SUPPORTED_PICTURE_SIZES[];

+    static const char SUPPORTED_PICTURE_FORMATS[];

+    static const char SUPPORTED_THUMBNAIL_SIZES[];

+    static const char SUPPORTED_WHITE_BALANCE[];

+    static const char SUPPORTED_EFFECTS[];

+    static const char SUPPORTED_ANTIBANDING[];

+    static const char SUPPORTED_EXPOSURE_MODES[];

+    static const char SUPPORTED_EV_MIN[];

+    static const char SUPPORTED_EV_MAX[];

+    static const char SUPPORTED_EV_STEP[];

+    static const char SUPPORTED_ISO_VALUES[];

+    static const char SUPPORTED_SCENE_MODES[];

+    static const char SUPPORTED_FLASH_MODES[];

+    static const char SUPPORTED_FOCUS_MODES[];

+    static const char REQUIRED_PREVIEW_BUFS[];

+    static const char REQUIRED_IMAGE_BUFS[];

+    static const char SUPPORTED_ZOOM_RATIOS[];

+    static const char SUPPORTED_ZOOM_STAGES[];

+    static const char SUPPORTED_IPP_MODES[];

+    static const char SMOOTH_ZOOM_SUPPORTED[];

+    static const char ZOOM_SUPPORTED[];

+    static const char PREVIEW_SIZE[];

+    static const char PREVIEW_FORMAT[];

+    static const char PREVIEW_FRAME_RATE[];

+    static const char ZOOM[];

+    static const char PICTURE_SIZE[];

+    static const char PICTURE_FORMAT[];

+    static const char JPEG_THUMBNAIL_SIZE[];

+    static const char WHITEBALANCE[];

+    static const char EFFECT[];

+    static const char ANTIBANDING[];

+    static const char EXPOSURE_MODE[];

+    static const char EV_COMPENSATION[];

+    static const char ISO_MODE[];

+    static const char FOCUS_MODE[];

+    static const char SCENE_MODE[];

+    static const char FLASH_MODE[];

+    static const char JPEG_QUALITY[];

+    static const char BRIGHTNESS[];

+    static const char SATURATION[];

+    static const char SHARPNESS[];

+    static const char CONTRAST[];

+    static const char IPP[];

+    static const char AUTOCONVERGENCE[];

+    static const char AUTOCONVERGENCE_MODE[];

+    static const char MANUALCONVERGENCE_VALUES[];

+    static const char SENSOR_ORIENTATION[];

+    static const char SENSOR_ORIENTATION_VALUES[];

+    static const char REVISION[];

+    static const char FOCAL_LENGTH[];

+    static const char HOR_ANGLE[];

+    static const char VER_ANGLE[];

+    static const char EXIF_MAKE[];

+    static const char EXIF_MODEL[];

+    static const char JPEG_THUMBNAIL_QUALITY[];

+    static const char MAX_FOCUS_AREAS[];

+    static const char MAX_FD_HW_FACES[];

+    static const char MAX_FD_SW_FACES[];

+

+    static const char PARAMS_DELIMITER [];

+

+    static const char S3D2D_PREVIEW[];

+    static const char S3D2D_PREVIEW_MODES[];

+    static const char VSTAB[];

+    static const char VSTAB_VALUES[];

+    static const char FRAMERATE_RANGE[];

+    static const char FRAMERATE_RANGE_SUPPORTED[];

+

+    static const char DEFAULT_VALUE[];

+

+    static const char AUTO_EXPOSURE_LOCK[];

+    static const char AUTO_EXPOSURE_LOCK_SUPPORTED[];

+    static const char AUTO_WHITEBALANCE_LOCK[];

+    static const char AUTO_WHITEBALANCE_LOCK_SUPPORTED[];

+    static const char MAX_NUM_METERING_AREAS[];

+    static const char METERING_AREAS[];

+

+    CameraProperties();

+    ~CameraProperties();

+

+    // container class passed around for accessing properties

+    class Properties

+    {

+        public:

+            Properties()

+            {

+                mProperties = new DefaultKeyedVector<String8, String8>(String8(DEFAULT_VALUE));

+                // set properties that are same for all cameras

+                set(EXIF_MAKE, EXIF_MAKE_DEFAULT);

+                set(EXIF_MODEL, EXIF_MODEL_DEFAULT);

+            }

+            ~Properties()

+            {

+                delete mProperties;

+            }

+            ssize_t set(const char *prop, const char *value);

+            ssize_t set(const char *prop, int value);

+            const char* get(const char * prop);

+            void dump();

+

+        protected:

+            const char* keyAt(unsigned int);

+            const char* valueAt(unsigned int);

+

+        private:

+            DefaultKeyedVector<String8, String8>* mProperties;

+

+    };

+

+    ///Initializes the CameraProperties class

+    status_t initialize();

+    status_t loadProperties();

+    int camerasSupported();

+    int getProperties(int cameraIndex, Properties** properties);

+

+private:

+

+    uint32_t mCamerasSupported;

+    int mInitialized;

+

+    Properties mCameraProps[MAX_CAMERAS_SUPPORTED];

+

+};

+

+};

+

+#endif //CAMERA_PROPERTIES_H

+

diff --git a/camera/inc/General3A_Settings.h b/camera/inc/General3A_Settings.h
new file mode 100644
index 0000000..af33518
--- /dev/null
+++ b/camera/inc/General3A_Settings.h
@@ -0,0 +1,262 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file General3A_Settings.h
+*
+* This file maps the Camera Hardware Interface to OMX.
+*
+*/
+
+#include "OMX_TI_IVCommon.h"
+#include "OMX_TI_Common.h"
+#include "OMX_TI_Index.h"
+#include "TICameraParameters.h"
+
+#ifndef GENERAL_3A_SETTINGS_H
+#define GENERAL_3A_SETTINGS_H
+
+#define FOCUS_FACE_PRIORITY OMX_IMAGE_FocusControlMax -1
+#define FOCUS_REGION_PRIORITY OMX_IMAGE_FocusControlMax -2
+#define WB_FACE_PRIORITY OMX_WhiteBalControlMax -1
+#define EXPOSURE_FACE_PRIORITY OMX_ExposureControlMax - 1
+
+namespace android {
+
+struct userToOMX_LUT{
+    const char * userDefinition;
+    int         omxDefinition;
+};
+
+struct LUTtype{
+    int size;
+    const userToOMX_LUT *Table;
+};
+
+const userToOMX_LUT isoUserToOMX[] = {
+    { TICameraParameters::ISO_MODE_AUTO, 0 },
+    { TICameraParameters::ISO_MODE_100, 100 },
+    { TICameraParameters::ISO_MODE_200, 200 },
+    { TICameraParameters::ISO_MODE_400, 400 },
+    { TICameraParameters::ISO_MODE_800, 800 },
+    { TICameraParameters::ISO_MODE_1000, 1000 },
+    { TICameraParameters::ISO_MODE_1200, 1200 },
+    { TICameraParameters::ISO_MODE_1600, 1600 },
+};
+
+const userToOMX_LUT effects_UserToOMX [] = {
+    { CameraParameters::EFFECT_NONE, OMX_ImageFilterNone },
+    { CameraParameters::EFFECT_NEGATIVE, OMX_ImageFilterNegative },
+    { CameraParameters::EFFECT_SOLARIZE,  OMX_ImageFilterSolarize },
+    { CameraParameters::EFFECT_SEPIA, OMX_ImageFilterSepia },
+    { CameraParameters::EFFECT_MONO, OMX_ImageFilterGrayScale },
+    { TICameraParameters::EFFECT_NATURAL, OMX_ImageFilterNatural },
+    { TICameraParameters::EFFECT_VIVID, OMX_ImageFilterVivid },
+    { TICameraParameters::EFFECT_COLOR_SWAP, OMX_ImageFilterColourSwap   },
+    { CameraParameters::EFFECT_BLACKBOARD, OMX_TI_ImageFilterBlackBoard },
+    { CameraParameters::EFFECT_WHITEBOARD, OMX_TI_ImageFilterWhiteBoard },
+    { CameraParameters::EFFECT_AQUA, OMX_TI_ImageFilterAqua },
+    { CameraParameters::EFFECT_POSTERIZE, OMX_TI_ImageFilterPosterize },
+    { TICameraParameters::EFFECT_BLACKWHITE, OMX_TI_ImageFilterBlackWhite }
+};
+
+const userToOMX_LUT scene_UserToOMX [] = {
+    { CameraParameters::SCENE_MODE_AUTO, OMX_Manual },
+    { TICameraParameters::SCENE_MODE_CLOSEUP, OMX_Closeup },
+    { CameraParameters::SCENE_MODE_LANDSCAPE, OMX_Landscape },
+    { TICameraParameters::SCENE_MODE_AQUA, OMX_Underwater },
+    { TICameraParameters::SCENE_MODE_SPORT, OMX_Sport },
+    { TICameraParameters::SCENE_MODE_MOOD, OMX_Mood },
+    { CameraParameters::SCENE_MODE_NIGHT_PORTRAIT, OMX_NightPortrait },
+    { TICameraParameters::SCENE_MODE_NIGHT_INDOOR, OMX_NightIndoor },
+    { CameraParameters::SCENE_MODE_FIREWORKS, OMX_Fireworks },
+    { TICameraParameters::SCENE_MODE_DOCUMENT, OMX_Document },
+    { TICameraParameters::SCENE_MODE_BARCODE, OMX_Barcode },
+    { TICameraParameters::SCENE_MODE_VIDEO_SUPER_NIGHT, OMX_SuperNight },
+    { TICameraParameters::SCENE_MODE_VIDEO_CINE, OMX_Cine },
+    { TICameraParameters::SCENE_MODE_VIDEO_OLD_FILM, OMX_OldFilm },
+    { CameraParameters::SCENE_MODE_ACTION, OMX_TI_Action },
+    { CameraParameters::SCENE_MODE_BEACH, OMX_TI_Beach },
+    { CameraParameters::SCENE_MODE_CANDLELIGHT, OMX_TI_Candlelight },
+    { CameraParameters::SCENE_MODE_NIGHT, OMX_TI_Night },
+    { CameraParameters::SCENE_MODE_PARTY, OMX_TI_Party },
+    { CameraParameters::SCENE_MODE_PORTRAIT, OMX_TI_Portrait },
+    { CameraParameters::SCENE_MODE_SNOW, OMX_TI_Snow },
+    { CameraParameters::SCENE_MODE_STEADYPHOTO, OMX_TI_Steadyphoto },
+    { CameraParameters::SCENE_MODE_SUNSET, OMX_TI_Sunset },
+    { CameraParameters::SCENE_MODE_THEATRE, OMX_TI_Theatre }
+};
+
+const userToOMX_LUT whiteBal_UserToOMX [] = {
+    { CameraParameters::WHITE_BALANCE_AUTO, OMX_WhiteBalControlAuto },
+    { CameraParameters::WHITE_BALANCE_DAYLIGHT, OMX_WhiteBalControlSunLight },
+    { CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT, OMX_WhiteBalControlCloudy },
+    { TICameraParameters::WHITE_BALANCE_TUNGSTEN, OMX_WhiteBalControlTungsten },
+    { CameraParameters::WHITE_BALANCE_FLUORESCENT, OMX_WhiteBalControlFluorescent },
+    { CameraParameters::WHITE_BALANCE_INCANDESCENT, OMX_WhiteBalControlIncandescent },
+    { TICameraParameters::WHITE_BALANCE_HORIZON, OMX_WhiteBalControlHorizon },
+    { CameraParameters::WHITE_BALANCE_SHADE, OMX_TI_WhiteBalControlShade },
+    { CameraParameters::WHITE_BALANCE_TWILIGHT, OMX_TI_WhiteBalControlTwilight },
+    { CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT, OMX_TI_WhiteBalControlWarmFluorescent },
+    { TICameraParameters::WHITE_BALANCE_FACE, WB_FACE_PRIORITY },
+    { TICameraParameters::WHITE_BALANCE_SUNSET, OMX_TI_WhiteBalControlSunset }
+};
+
+const userToOMX_LUT antibanding_UserToOMX [] = {
+    { CameraParameters::ANTIBANDING_OFF, OMX_FlickerCancelOff },
+    { CameraParameters::ANTIBANDING_AUTO, OMX_FlickerCancelAuto },
+    { CameraParameters::ANTIBANDING_50HZ, OMX_FlickerCancel50 },
+    { CameraParameters::ANTIBANDING_60HZ, OMX_FlickerCancel60 }
+};
+
+const userToOMX_LUT focus_UserToOMX [] = {
+    { CameraParameters::FOCUS_MODE_AUTO, OMX_IMAGE_FocusControlAutoLock },
+    { CameraParameters::FOCUS_MODE_INFINITY, OMX_IMAGE_FocusControlAutoInfinity },
+    { CameraParameters::FOCUS_MODE_MACRO, OMX_IMAGE_FocusControlAutoMacro },
+    { TICameraParameters::FOCUS_MODE_PORTRAIT, OMX_IMAGE_FocusControlPortrait },
+    { TICameraParameters::FOCUS_MODE_EXTENDED, OMX_IMAGE_FocusControlExtended },
+    { CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO, OMX_IMAGE_FocusControlAuto },
+    { TICameraParameters::FOCUS_MODE_FACE , FOCUS_FACE_PRIORITY },
+
+};
+
+const userToOMX_LUT exposure_UserToOMX [] = {
+    { TICameraParameters::EXPOSURE_MODE_OFF, OMX_ExposureControlOff },
+    { TICameraParameters::EXPOSURE_MODE_AUTO, OMX_ExposureControlAuto },
+    { TICameraParameters::EXPOSURE_MODE_NIGHT, OMX_ExposureControlNight },
+    { TICameraParameters::EXPOSURE_MODE_BACKLIGHT, OMX_ExposureControlBackLight },
+    { TICameraParameters::EXPOSURE_MODE_SPOTLIGHT, OMX_ExposureControlSpotLight},
+    { TICameraParameters::EXPOSURE_MODE_SPORTS, OMX_ExposureControlSports },
+    { TICameraParameters::EXPOSURE_MODE_SNOW, OMX_ExposureControlSnow },
+    { TICameraParameters::EXPOSURE_MODE_BEACH, OMX_ExposureControlBeach },
+    { TICameraParameters::EXPOSURE_MODE_APERTURE, OMX_ExposureControlLargeAperture },
+    { TICameraParameters::EXPOSURE_MODE_SMALL_APERTURE, OMX_ExposureControlSmallApperture },
+    { TICameraParameters::EXPOSURE_MODE_FACE, EXPOSURE_FACE_PRIORITY },
+};
+
+const userToOMX_LUT flash_UserToOMX [] = {
+    { CameraParameters::FLASH_MODE_OFF           ,OMX_IMAGE_FlashControlOff             },
+    { CameraParameters::FLASH_MODE_ON            ,OMX_IMAGE_FlashControlOn              },
+    { CameraParameters::FLASH_MODE_AUTO          ,OMX_IMAGE_FlashControlAuto            },
+    { CameraParameters::FLASH_MODE_TORCH         ,OMX_IMAGE_FlashControlTorch           },
+    { CameraParameters::FLASH_MODE_RED_EYE        ,OMX_IMAGE_FlashControlRedEyeReduction },
+    { TICameraParameters::FLASH_MODE_FILL_IN        ,OMX_IMAGE_FlashControlFillin          }
+};
+
+const LUTtype ExpLUT =
+    {
+    sizeof(exposure_UserToOMX)/sizeof(exposure_UserToOMX[0]),
+    exposure_UserToOMX
+    };
+
+const LUTtype WBalLUT =
+    {
+    sizeof(whiteBal_UserToOMX)/sizeof(whiteBal_UserToOMX[0]),
+    whiteBal_UserToOMX
+    };
+
+const LUTtype FlickerLUT =
+    {
+    sizeof(antibanding_UserToOMX)/sizeof(antibanding_UserToOMX[0]),
+    antibanding_UserToOMX
+    };
+
+const LUTtype SceneLUT =
+    {
+    sizeof(scene_UserToOMX)/sizeof(scene_UserToOMX[0]),
+    scene_UserToOMX
+    };
+
+const LUTtype FlashLUT =
+    {
+    sizeof(flash_UserToOMX)/sizeof(flash_UserToOMX[0]),
+    flash_UserToOMX
+    };
+
+const LUTtype EffLUT =
+    {
+    sizeof(effects_UserToOMX)/sizeof(effects_UserToOMX[0]),
+    effects_UserToOMX
+    };
+
+const LUTtype FocusLUT =
+    {
+    sizeof(focus_UserToOMX)/sizeof(focus_UserToOMX[0]),
+    focus_UserToOMX
+    };
+
+const LUTtype IsoLUT =
+    {
+    sizeof(isoUserToOMX)/sizeof(isoUserToOMX[0]),
+    isoUserToOMX
+    };
+
+/*
+*   class Gen3A_settings
+*   stores the 3A settings
+*   also defines the look up tables
+*   for mapping settings from Hal to OMX
+*/
+class Gen3A_settings{
+    public:
+
+    int Exposure;
+    int WhiteBallance;
+    int Flicker;
+    int SceneMode;
+    int Effect;
+    int Focus;
+    int EVCompensation;
+    int Contrast;
+    int Saturation;
+    int Sharpness;
+    int ISO;
+    int FlashMode;
+
+    unsigned int Brightness;
+    OMX_BOOL ExposureLock;
+    OMX_BOOL WhiteBalanceLock;
+};
+
+/*
+*   Flags raised when a setting is changed
+*/
+enum E3ASettingsFlags
+{
+    SetSceneMode            = 1 << 0,
+    SetEVCompensation       = 1 << 1,
+    SetWhiteBallance        = 1 << 2,
+    SetFlicker              = 1 << 3,
+    SetExposure             = 1 << 4,
+    SetSharpness            = 1 << 5,
+    SetBrightness           = 1 << 6,
+    SetContrast             = 1 << 7,
+    SetISO                  = 1 << 8,
+    SetSaturation           = 1 << 9,
+    SetEffect               = 1 << 10,
+    SetFocus                = 1 << 11,
+    SetExpMode              = 1 << 14,
+    SetFlash                = 1 << 15,
+    SetExpLock              = 1 << 16,
+    SetWBLock               = 1 << 17,
+
+    E3aSettingMax,
+    E3AsettingsAll = ( ((E3aSettingMax -1 ) << 1) -1 ) /// all possible flags raised
+};
+
+};
+
+#endif //GENERAL_3A_SETTINGS_H
diff --git a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
new file mode 100644
index 0000000..2a41ba0
--- /dev/null
+++ b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
@@ -0,0 +1,834 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 OMX_CAMERA_ADAPTER_H
+#define OMX_CAMERA_ADAPTER_H
+
+#include "CameraHal.h"
+#include "OMX_Types.h"
+#include "OMX_Core.h"
+#include "OMX_CoreExt.h"
+#include "OMX_IVCommon.h"
+#include "OMX_Component.h"
+#include "OMX_Index.h"
+#include "OMX_IndexExt.h"
+#include "OMX_TI_Index.h"
+#include "OMX_TI_IVCommon.h"
+#include "OMX_TI_Common.h"
+#include "OMX_TI_Image.h"
+#include "General3A_Settings.h"
+
+#include "BaseCameraAdapter.h"
+#include "DebugUtils.h"
+
+
+extern "C"
+{
+#include "timm_osal_error.h"
+#include "timm_osal_events.h"
+#include "timm_osal_trace.h"
+#include "timm_osal_semaphores.h"
+}
+
+namespace android {
+
+#define Q16_OFFSET                  16
+
+#define OMX_CMD_TIMEOUT             3000000  //3 sec.
+#define AF_CALLBACK_TIMEOUT         10000000 //10 seconds timeout
+#define OMX_CAPTURE_TIMEOUT         5000000  //5 sec.
+
+#define FOCUS_THRESHOLD             5 //[s.]
+
+#define MIN_JPEG_QUALITY            1
+#define MAX_JPEG_QUALITY            100
+#define EXP_BRACKET_RANGE           10
+
+#define FOCUS_DIST_SIZE             100
+#define FOCUS_DIST_BUFFER_SIZE      500
+
+#define TOUCH_DATA_SIZE             200
+#define DEFAULT_THUMB_WIDTH         160
+#define DEFAULT_THUMB_HEIGHT        120
+#define FRAME_RATE_FULL_HD          27
+#define ZOOM_STAGES                 61
+
+#define FACE_DETECTION_BUFFER_SIZE  0x1000
+
+#define EXIF_MODEL_SIZE             100
+#define EXIF_MAKE_SIZE              100
+#define EXIF_DATE_TIME_SIZE         20
+
+#define GPS_TIMESTAMP_SIZE          6
+#define GPS_DATESTAMP_SIZE          11
+#define GPS_REF_SIZE                2
+#define GPS_MAPDATUM_SIZE           100
+#define GPS_PROCESSING_SIZE         100
+#define GPS_VERSION_SIZE            4
+#define GPS_NORTH_REF               "N"
+#define GPS_SOUTH_REF               "S"
+#define GPS_EAST_REF                "E"
+#define GPS_WEST_REF                "W"
+
+/* Default portstartnumber of Camera component */
+#define OMX_CAMERA_DEFAULT_START_PORT_NUM 0
+
+/* Define number of ports for differt domains */
+#define OMX_CAMERA_PORT_OTHER_NUM 1
+#define OMX_CAMERA_PORT_VIDEO_NUM 4
+#define OMX_CAMERA_PORT_IMAGE_NUM 1
+#define OMX_CAMERA_PORT_AUDIO_NUM 0
+#define OMX_CAMERA_NUM_PORTS (OMX_CAMERA_PORT_OTHER_NUM + OMX_CAMERA_PORT_VIDEO_NUM + OMX_CAMERA_PORT_IMAGE_NUM + OMX_CAMERA_PORT_AUDIO_NUM)
+
+/* Define start port number for differt domains */
+#define OMX_CAMERA_PORT_OTHER_START OMX_CAMERA_DEFAULT_START_PORT_NUM
+#define OMX_CAMERA_PORT_VIDEO_START (OMX_CAMERA_PORT_OTHER_START + OMX_CAMERA_PORT_OTHER_NUM)
+#define OMX_CAMERA_PORT_IMAGE_START (OMX_CAMERA_PORT_VIDEO_START + OMX_CAMERA_PORT_VIDEO_NUM)
+#define OMX_CAMERA_PORT_AUDIO_START (OMX_CAMERA_PORT_IMAGE_START + OMX_CAMERA_PORT_IMAGE_NUM)
+
+/* Port index for camera component */
+#define OMX_CAMERA_PORT_OTHER_IN (OMX_CAMERA_PORT_OTHER_START + 0)
+#define OMX_CAMERA_PORT_VIDEO_IN_VIDEO (OMX_CAMERA_PORT_VIDEO_START + 0)
+#define OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW (OMX_CAMERA_PORT_VIDEO_START + 1)
+#define OMX_CAMERA_PORT_VIDEO_OUT_VIDEO (OMX_CAMERA_PORT_VIDEO_START + 2)
+#define OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT (OMX_CAMERA_PORT_VIDEO_START + 3)
+#define OMX_CAMERA_PORT_IMAGE_OUT_IMAGE (OMX_CAMERA_PORT_IMAGE_START + 0)
+
+
+#define OMX_INIT_STRUCT(_s_, _name_)	\
+    memset(&(_s_), 0x0, sizeof(_name_));	\
+    (_s_).nSize = sizeof(_name_);		\
+    (_s_).nVersion.s.nVersionMajor = 0x1;	\
+    (_s_).nVersion.s.nVersionMinor = 0x1;	\
+    (_s_).nVersion.s.nRevision = 0x0;		\
+    (_s_).nVersion.s.nStep = 0x0
+
+#define OMX_INIT_STRUCT_PTR(_s_, _name_)   \
+    memset((_s_), 0x0, sizeof(_name_));         \
+    (_s_)->nSize = sizeof(_name_);              \
+    (_s_)->nVersion.s.nVersionMajor = 0x1;      \
+    (_s_)->nVersion.s.nVersionMinor = 0x1;      \
+    (_s_)->nVersion.s.nRevision = 0x0;          \
+    (_s_)->nVersion.s.nStep = 0x0
+
+#define GOTO_EXIT_IF(_CONDITION,_ERROR) {                                       \
+    if ((_CONDITION)) {                                                         \
+        eError = (_ERROR);                                                      \
+        goto EXIT;                                                              \
+    }                                                                           \
+}
+
+///OMX Specific Functions
+static OMX_ERRORTYPE OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+                                        OMX_IN OMX_PTR pAppData,
+                                        OMX_IN OMX_EVENTTYPE eEvent,
+                                        OMX_IN OMX_U32 nData1,
+                                        OMX_IN OMX_U32 nData2,
+                                        OMX_IN OMX_PTR pEventData);
+
+static OMX_ERRORTYPE OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                        OMX_IN OMX_PTR pAppData,
+                                        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
+
+static OMX_ERRORTYPE OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                        OMX_IN OMX_PTR pAppData,
+                                        OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader);
+
+struct CapResolution {
+    size_t width, height;
+    const char *param;
+};
+
+struct CapPixelformat {
+    OMX_COLOR_FORMATTYPE pixelformat;
+    const char *param;
+};
+
+struct CapU32 {
+    OMX_U32 num;
+    const char *param;
+};
+
+struct CapS32 {
+    OMX_S32 num;
+    const char *param;
+};
+
+typedef CapU32 CapFramerate;
+typedef CapU32 CapISO;
+typedef CapU32 CapSensorName;
+typedef CapS32 CapZoom;
+typedef CapS32 CapEVComp;
+
+/**
+  * 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 OMXCameraAdapter : public BaseCameraAdapter
+{
+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;
+
+    ///Five second timeout
+    static const int CAMERA_ADAPTER_TIMEOUT = 5000*1000;
+
+    //EXIF ASCII prefix
+    static const char EXIFASCIIPrefix[];
+
+    enum OMXCameraEvents
+        {
+        CAMERA_PORT_ENABLE  = 0x1,
+        CAMERA_PORT_FLUSH   = 0x2,
+        CAMERA_PORT_DISABLE = 0x4,
+        };
+
+    enum CaptureMode
+        {
+        HIGH_SPEED = 1,
+        HIGH_QUALITY = 2,
+        VIDEO_MODE = 3,
+        HIGH_QUALITY_ZSL = 4,
+        };
+
+    enum IPPMode
+        {
+        IPP_NONE = 0,
+        IPP_NSF,
+        IPP_LDC,
+        IPP_LDCNSF,
+        };
+
+    enum CodingMode
+        {
+        CodingNone = 0,
+        CodingJPS,
+        CodingMPO,
+        CodingRAWJPEG,
+        CodingRAWMPO,
+        };
+
+    enum Algorithm3A
+        {
+        WHITE_BALANCE_ALGO = 0x1,
+        EXPOSURE_ALGO = 0x2,
+        FOCUS_ALGO = 0x4,
+        };
+
+    enum AlgoPriority
+        {
+        FACE_PRIORITY = 0,
+        REGION_PRIORITY,
+        };
+
+    enum BrightnessMode
+        {
+        BRIGHTNESS_OFF = 0,
+        BRIGHTNESS_ON,
+        BRIGHTNESS_AUTO,
+        };
+
+    class GPSData
+    {
+        public:
+                int mLongDeg, mLongMin, mLongSec;
+                char mLongRef[GPS_REF_SIZE];
+                bool mLongValid;
+                int mLatDeg, mLatMin, mLatSec;
+                char mLatRef[GPS_REF_SIZE];
+                bool mLatValid;
+                int mAltitude;
+                unsigned char mAltitudeRef;
+                bool mAltitudeValid;
+                char mMapDatum[GPS_MAPDATUM_SIZE];
+                bool mMapDatumValid;
+                char mVersionId[GPS_VERSION_SIZE];
+                bool mVersionIdValid;
+                char mProcMethod[GPS_PROCESSING_SIZE];
+                bool mProcMethodValid;
+                char mDatestamp[GPS_DATESTAMP_SIZE];
+                bool mDatestampValid;
+                uint32_t mTimeStampHour;
+                uint32_t mTimeStampMin;
+                uint32_t mTimeStampSec;
+                bool mTimeStampValid;
+    };
+
+    class EXIFData
+    {
+        public:
+            GPSData mGPSData;
+            bool mMakeValid;
+            bool mModelValid;
+    };
+
+    ///Parameters specific to any port of the OMX Camera component
+    class OMXCameraPortParameters
+    {
+        public:
+            OMX_U32                         mHostBufaddr[MAX_NO_BUFFERS];
+            OMX_BUFFERHEADERTYPE           *mBufferHeader[MAX_NO_BUFFERS];
+            OMX_U32                         mWidth;
+            OMX_U32                         mHeight;
+            OMX_U32                         mStride;
+            OMX_U8                          mNumBufs;
+
+            // defines maximum number of buffers our of mNumBufs
+            // queueable at given moment
+            OMX_U8                          mMaxQueueable;
+
+            OMX_U32                         mBufSize;
+            OMX_COLOR_FORMATTYPE            mColorFormat;
+            OMX_PARAM_VIDEONOISEFILTERTYPE  mVNFMode;
+            OMX_PARAM_VIDEOYUVRANGETYPE     mYUVRange;
+            OMX_CONFIG_BOOLEANTYPE          mVidStabParam;
+            OMX_CONFIG_FRAMESTABTYPE        mVidStabConfig;
+            OMX_U32                         mCapFrame;
+            OMX_U32                         mFrameRate;
+            OMX_S32                         mMinFrameRate;
+            OMX_S32                         mMaxFrameRate;
+            CameraFrame::FrameType mImageType;
+    };
+
+    ///Context of the OMX Camera component
+    class OMXCameraAdapterComponentContext
+    {
+        public:
+            OMX_HANDLETYPE              mHandleComp;
+            OMX_U32                     mNumPorts;
+            OMX_STATETYPE               mState ;
+            OMX_U32                     mVideoPortIndex;
+            OMX_U32                     mPrevPortIndex;
+            OMX_U32                     mImagePortIndex;
+            OMX_U32                     mMeasurementPortIndex;
+            OMXCameraPortParameters     mCameraPortParams[MAX_NO_PORTS];
+    };
+
+public:
+
+    OMXCameraAdapter();
+    ~OMXCameraAdapter();
+
+    ///Initialzes the camera adapter creates any resources required
+    virtual status_t initialize(CameraProperties::Properties*, int sensor_index=0);
+
+    //APIs to configure Camera adapter and get the current parameter set
+    virtual status_t setParameters(const CameraParameters& params);
+    virtual void getParameters(CameraParameters& params);
+
+    // API
+    virtual status_t UseBuffersPreview(void* bufArr, int num);
+
+    //API to flush the buffers for preview
+    status_t flushBuffers();
+
+    // API
+    virtual status_t setFormat(OMX_U32 port, OMXCameraPortParameters &cap);
+
+    // Function to get and populate caps from handle
+    static status_t getCaps(CameraProperties::Properties* props, OMX_HANDLETYPE handle);
+    static const char* getLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT);
+    static int getLUTvalue_HALtoOMX(const char * HalValue, LUTtype LUT);
+
+ OMX_ERRORTYPE OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+                                    OMX_IN OMX_EVENTTYPE eEvent,
+                                    OMX_IN OMX_U32 nData1,
+                                    OMX_IN OMX_U32 nData2,
+                                    OMX_IN OMX_PTR pEventData);
+
+ OMX_ERRORTYPE OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                    OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
+
+ OMX_ERRORTYPE OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                    OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader);
+protected:
+
+    //Parent class method implementation
+    virtual status_t takePicture();
+    virtual status_t stopImageCapture();
+    virtual status_t startBracketing(int range);
+    virtual status_t stopBracketing();
+    virtual status_t autoFocus();
+    virtual status_t cancelAutoFocus();
+    virtual status_t startSmoothZoom(int targetIdx);
+    virtual status_t stopSmoothZoom();
+    virtual status_t startVideoCapture();
+    virtual status_t stopVideoCapture();
+    virtual status_t startPreview();
+    virtual status_t stopPreview();
+    virtual status_t useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable);
+    virtual status_t fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType);
+    virtual status_t getFrameSize(size_t &width, size_t &height);
+    virtual status_t getPictureBufferSize(size_t &length, size_t bufferCount);
+    virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount);
+    virtual status_t startFaceDetection();
+    virtual status_t stopFaceDetection();
+    virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt);
+
+private:
+
+    status_t switchToLoaded();
+
+    OMXCameraPortParameters *getPortParams(CameraFrame::FrameType frameType);
+
+    OMX_ERRORTYPE SignalEvent(OMX_IN OMX_HANDLETYPE hComponent,
+                                                  OMX_IN OMX_EVENTTYPE eEvent,
+                                                  OMX_IN OMX_U32 nData1,
+                                                  OMX_IN OMX_U32 nData2,
+                                                  OMX_IN OMX_PTR pEventData);
+
+    status_t RegisterForEvent(OMX_IN OMX_HANDLETYPE hComponent,
+                                          OMX_IN OMX_EVENTTYPE eEvent,
+                                          OMX_IN OMX_U32 nData1,
+                                          OMX_IN OMX_U32 nData2,
+                                          OMX_IN Semaphore &semaphore);
+
+    status_t setPictureRotation(unsigned int degree);
+    status_t setSensorOrientation(unsigned int degree);
+    status_t setImageQuality(unsigned int quality);
+    status_t setThumbnailParams(unsigned int width, unsigned int height, unsigned int quality);
+
+    //EXIF
+    status_t setParametersEXIF(const CameraParameters &params,
+                               BaseCameraAdapter::AdapterState state);
+    status_t convertGPSCoord(double coord, int *deg, int *min, int *sec);
+    status_t setupEXIF();
+
+    //Focus functionality
+    status_t doAutoFocus();
+    status_t stopAutoFocus();
+    status_t checkFocus(OMX_PARAM_FOCUSSTATUSTYPE *eFocusStatus);
+    status_t returnFocusStatus(bool timeoutReached);
+
+    //Focus distances
+    status_t setParametersFocus(const CameraParameters &params,
+                                BaseCameraAdapter::AdapterState state);
+    status_t addFocusDistances(OMX_U32 &near,
+                               OMX_U32 &optimal,
+                               OMX_U32 &far,
+                               CameraParameters& params);
+    status_t encodeFocusDistance(OMX_U32 dist, char *buffer, size_t length);
+    status_t getFocusDistances(OMX_U32 &near,OMX_U32 &optimal, OMX_U32 &far);
+
+    //VSTAB and VNF Functionality
+    status_t enableVideoNoiseFilter(bool enable);
+    status_t enableVideoStabilization(bool enable);
+
+    //Digital zoom
+    status_t setParametersZoom(const CameraParameters &params,
+                               BaseCameraAdapter::AdapterState state);
+    status_t doZoom(int index);
+    status_t advanceZoom();
+
+    //3A related parameters
+    status_t setParameters3A(const CameraParameters &params,
+                             BaseCameraAdapter::AdapterState state);
+    status_t setScene(Gen3A_settings& Gen3A);
+
+    //Flash modes
+    status_t setFlashMode(Gen3A_settings& Gen3A);
+    status_t setFocusMode(Gen3A_settings& Gen3A);
+
+    //Exposure Modes
+    status_t setExposureMode(Gen3A_settings& Gen3A);
+    status_t setEVCompensation(Gen3A_settings& Gen3A);
+    status_t setWBMode(Gen3A_settings& Gen3A);
+    status_t setFlicker(Gen3A_settings& Gen3A);
+    status_t setBrightness(Gen3A_settings& Gen3A);
+    status_t setContrast(Gen3A_settings& Gen3A);
+    status_t setSharpness(Gen3A_settings& Gen3A);
+    status_t setSaturation(Gen3A_settings& Gen3A);
+    status_t setISO(Gen3A_settings& Gen3A);
+    status_t setEffect(Gen3A_settings& Gen3A);
+
+    status_t setExposureLock(Gen3A_settings& Gen3A);
+    status_t setWhiteBalanceLock(Gen3A_settings& Gen3A);
+    status_t release3ALock();
+
+    //API to set FrameRate using VFR interface
+    status_t setVFramerate(OMX_U32 minFrameRate,OMX_U32 maxFrameRate);
+
+    status_t setParametersAlgo(const CameraParameters &params,
+                               BaseCameraAdapter::AdapterState state);
+
+    //Noise filtering
+    status_t setNSF(OMXCameraAdapter::IPPMode mode);
+
+    //LDC
+    status_t setLDC(OMXCameraAdapter::IPPMode mode);
+
+    //GLBCE
+    status_t setGLBCE(OMXCameraAdapter::BrightnessMode mode);
+
+    //GBCE
+    status_t setGBCE(OMXCameraAdapter::BrightnessMode mode);
+
+    status_t printComponentVersion(OMX_HANDLETYPE handle);
+
+    //Touch AF
+    status_t setTouchFocus(size_t posX,
+                           size_t posY,
+                           size_t posWidth,
+                           size_t posHeight,
+                           size_t previewWidth,
+                           size_t previewHeight);
+
+    //Face detection
+    status_t setParametersFD(const CameraParameters &params,
+                             BaseCameraAdapter::AdapterState state);
+    status_t updateFocusDistances(CameraParameters &params);
+    status_t setFaceDetection(bool enable, OMX_U32 orientation);
+    status_t detectFaces(OMX_BUFFERHEADERTYPE* pBuffHeader,
+                         sp<CameraFDResult> &result,
+                         size_t previewWidth,
+                         size_t previewHeight);
+    status_t encodeFaceCoordinates(const OMX_FACEDETECTIONTYPE *faceData,
+                                   camera_frame_metadata_t **pFaces,
+                                   size_t previewWidth,
+                                   size_t previewHeight);
+
+    //3A Algorithms priority configuration
+    status_t setAlgoPriority(AlgoPriority priority, Algorithm3A algo, bool enable);
+
+    //Sensor overclocking
+    status_t setSensorOverclock(bool enable);
+
+    // Utility methods for OMX Capabilities
+    static status_t insertCapabilities(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t encodeSizeCap(OMX_TI_CAPRESTYPE&, const CapResolution *, size_t, char *, size_t);
+    static status_t encodeISOCap(OMX_U32, const CapISO*, size_t, char*, size_t);
+    static size_t encodeZoomCap(OMX_S32, const CapZoom*, size_t, char*, size_t);
+    static status_t encodeFramerateCap(OMX_U32, OMX_U32, const CapFramerate*, size_t, char*, size_t);
+    static status_t encodeVFramerateCap(OMX_TI_CAPTYPE&, char*, char*, size_t);
+    static status_t encodePixelformatCap(OMX_COLOR_FORMATTYPE,
+                                         const CapPixelformat*,
+                                         size_t,
+                                         char*,
+                                         size_t);
+    static status_t insertImageSizes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertPreviewSizes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertThumbSizes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertZoomStages(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertImageFormats(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertPreviewFormats(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertFramerates(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertVFramerates(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertEVs(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertISOModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertIPPModes(CameraProperties::Properties*, OMX_TI_CAPTYPE &);
+    static status_t insertWBModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertEffects(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertExpModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertSceneModes(CameraProperties::Properties*, OMX_TI_CAPTYPE &);
+    static status_t insertFocusModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertFlickerModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertFlashModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertSenMount(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertDefaults(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+    static status_t insertLocks(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
+
+    status_t setParametersCapture(const CameraParameters &params,
+                                  BaseCameraAdapter::AdapterState state);
+
+    //Exposure Bracketing
+    status_t setExposureBracketing(int *evValues, size_t evCount, size_t frameCount);
+    status_t parseExpRange(const char *rangeStr, int * expRange, size_t count, size_t &validEntries);
+
+    //Temporal Bracketing
+    status_t doBracketing(OMX_BUFFERHEADERTYPE *pBuffHeader, CameraFrame::FrameType typeOfFrame);
+    status_t sendBracketFrames();
+
+    // Image Capture Service
+    status_t startImageCapture();
+
+    //Shutter callback notifications
+    status_t setShutterCallback(bool enabled);
+
+    //Sets eithter HQ or HS mode and the frame count
+    status_t setCaptureMode(OMXCameraAdapter::CaptureMode mode);
+    status_t UseBuffersCapture(void* bufArr, int num);
+    status_t UseBuffersPreviewData(void* bufArr, int num);
+
+    //Used for calculation of the average frame rate during preview
+    status_t recalculateFPS();
+
+    //Helper method for initializing a CameFrame object
+    status_t initCameraFrame(CameraFrame &frame, OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader, int typeOfFrame, OMXCameraPortParameters *port);
+
+    //Sends the incoming OMX buffer header to subscribers
+    status_t sendFrame(CameraFrame &frame);
+
+    status_t apply3Asettings( Gen3A_settings& Gen3A );
+
+    // AutoConvergence
+    status_t setAutoConvergence(OMX_TI_AUTOCONVERGENCEMODETYPE pACMode, OMX_S32 pManualConverence);
+    status_t getAutoConvergence(OMX_TI_AUTOCONVERGENCEMODETYPE *pACMode, OMX_S32 *pManualConverence);
+
+    class CommandHandler : public Thread {
+        public:
+            CommandHandler(OMXCameraAdapter* ca)
+                : Thread(false), mCameraAdapter(ca) { }
+
+            virtual bool threadLoop() {
+                bool ret;
+                ret = Handler();
+                return ret;
+            }
+
+            status_t put(TIUTILS::Message* msg){
+                return mCommandMsgQ.put(msg);
+            }
+
+            enum {
+                COMMAND_EXIT = -1,
+                CAMERA_START_IMAGE_CAPTURE = 0,
+                CAMERA_PERFORM_AUTOFOCUS
+            };
+
+        private:
+            bool Handler();
+            TIUTILS::MessageQueue mCommandMsgQ;
+            OMXCameraAdapter* mCameraAdapter;
+    };
+    sp<CommandHandler> mCommandHandler;
+
+public:
+
+    class OMXCallbackHandler : public Thread {
+        public:
+        OMXCallbackHandler(OMXCameraAdapter* ca)
+            : Thread(false), mCameraAdapter(ca) { }
+
+        virtual bool threadLoop() {
+            bool ret;
+            ret = Handler();
+            return ret;
+        }
+
+        status_t put(TIUTILS::Message* msg){
+            return mCommandMsgQ.put(msg);
+        }
+
+        enum {
+            COMMAND_EXIT = -1,
+            CAMERA_FILL_BUFFER_DONE,
+        };
+
+    private:
+        bool Handler();
+        TIUTILS::MessageQueue mCommandMsgQ;
+        OMXCameraAdapter* mCameraAdapter;
+    };
+
+    sp<OMXCallbackHandler> mOMXCallbackHandler;
+
+private:
+
+    //AF callback
+    status_t setFocusCallback(bool enabled);
+
+    //OMX Capabilities data
+    static const CapResolution mImageCapRes [];
+    static const CapResolution mPreviewRes [];
+    static const CapResolution mThumbRes [];
+    static const CapPixelformat mPixelformats [];
+    static const CapFramerate mFramerates [];
+    static const CapU32 mSensorNames[] ;
+    static const CapZoom mZoomStages [];
+    static const CapEVComp mEVCompRanges [];
+    static const CapISO mISOStages [];
+
+    // OMX Camera defaults
+    static const char DEFAULT_ANTIBANDING[];
+    static const char DEFAULT_BRIGHTNESS[];
+    static const char DEFAULT_CONTRAST[];
+    static const char DEFAULT_EFFECT[];
+    static const char DEFAULT_EV_COMPENSATION[];
+    static const char DEFAULT_EV_STEP[];
+    static const char DEFAULT_EXPOSURE_MODE[];
+    static const char DEFAULT_FLASH_MODE[];
+    static const char DEFAULT_FOCUS_MODE[];
+    static const char DEFAULT_FRAMERATE_RANGE[];
+    static const char DEFAULT_IPP[];
+    static const char DEFAULT_ISO_MODE[];
+    static const char DEFAULT_JPEG_QUALITY[];
+    static const char DEFAULT_THUMBNAIL_QUALITY[];
+    static const char DEFAULT_THUMBNAIL_SIZE[];
+    static const char DEFAULT_PICTURE_FORMAT[];
+    static const char DEFAULT_PICTURE_SIZE[];
+    static const char DEFAULT_PREVIEW_FORMAT[];
+    static const char DEFAULT_FRAMERATE[];
+    static const char DEFAULT_PREVIEW_SIZE[];
+    static const char DEFAULT_NUM_PREV_BUFS[];
+    static const char DEFAULT_NUM_PIC_BUFS[];
+    static const char DEFAULT_MAX_FOCUS_AREAS[];
+    static const char DEFAULT_SATURATION[];
+    static const char DEFAULT_SCENE_MODE[];
+    static const char DEFAULT_SHARPNESS[];
+    static const char DEFAULT_VSTAB[];
+    static const char DEFAULT_WB[];
+    static const char DEFAULT_ZOOM[];
+    static const char DEFAULT_MAX_FD_HW_FACES[];
+    static const char DEFAULT_MAX_FD_SW_FACES[];
+    static const char DEFAULT_AE_LOCK[];
+    static const char DEFAULT_AWB_LOCK[];
+    static const char DEFAULT_MAX_NUM_METERING_AREAS[];
+    static const char DEFAULT_LOCK_SUPPORTED[];
+    static const char DEFAULT_LOCK_UNSUPPORTED[];
+
+    OMX_VERSIONTYPE mCompRevision;
+
+    //OMX Component UUID
+    OMX_UUIDTYPE mCompUUID;
+
+    //Current Focus distances
+    char mFocusDistNear[FOCUS_DIST_SIZE];
+    char mFocusDistOptimal[FOCUS_DIST_SIZE];
+    char mFocusDistFar[FOCUS_DIST_SIZE];
+    char mFocusDistBuffer[FOCUS_DIST_BUFFER_SIZE];
+
+    // Current Focus areas
+    Vector< sp<CameraArea> > mFocusAreas;
+
+    CaptureMode mCapMode;
+    size_t mBurstFrames;
+    size_t mCapturedFrames;
+
+    bool mMeasurementEnabled;
+
+    //Exposure Bracketing
+    int mExposureBracketingValues[EXP_BRACKET_RANGE];
+    size_t mExposureBracketingValidEntries;
+
+    mutable Mutex mFaceDetectionLock;
+    //Face detection status
+    bool mFaceDetectionRunning;
+
+    //Geo-tagging
+    EXIFData mEXIFData;
+
+    //Image post-processing
+    IPPMode mIPP;
+
+    //jpeg Picture Quality
+    unsigned int mPictureQuality;
+
+    //thumbnail resolution
+    unsigned int mThumbWidth, mThumbHeight;
+
+    //thumbnail quality
+    unsigned int mThumbQuality;
+
+    //variables holding the estimated framerate
+    float mFPS, mLastFPS;
+
+    //automatically disable AF after a given amount of frames
+    unsigned int mFocusThreshold;
+
+    //This is needed for the CTS tests. They falsely assume, that during
+    //smooth zoom the current zoom stage will not change within the
+    //zoom callback scope, which in a real world situation is not always the
+    //case. This variable will "simulate" the expected behavior
+    unsigned int mZoomParameterIdx;
+
+    //current zoom
+    Mutex mZoomLock;
+    unsigned int mCurrentZoomIdx, mTargetZoomIdx;
+    int mZoomInc;
+    bool mReturnZoomStatus;
+    static const int32_t ZOOM_STEPS [];
+
+     //local copy
+    OMX_VERSIONTYPE mLocalVersionParam;
+
+    unsigned int mPending3Asettings;
+    Gen3A_settings mParameters3A;
+
+    CameraParameters mParams;
+    CameraProperties::Properties* mCapabilities;
+    unsigned int mPictureRotation;
+    bool mWaitingForSnapshot;
+    int mSnapshotCount;
+    bool mCaptureConfigured;
+
+    //Temporal bracketing management data
+    mutable Mutex mBracketingLock;
+    bool *mBracketingBuffersQueued;
+    int mBracketingBuffersQueuedCount;
+    int mLastBracetingBufferIdx;
+    bool mBracketingEnabled;
+    int mBracketingRange;
+
+    CameraParameters mParameters;
+    OMXCameraAdapterComponentContext mCameraAdapterParameters;
+    bool mFirstTimeInit;
+
+    ///Semaphores used internally
+    Semaphore mDoAFSem;
+    Semaphore mInitSem;
+    Semaphore mFlushSem;
+    Semaphore mUsePreviewDataSem;
+    Semaphore mUsePreviewSem;
+    Semaphore mUseCaptureSem;
+    Semaphore mStartPreviewSem;
+    Semaphore mStopPreviewSem;
+    Semaphore mStartCaptureSem;
+    Semaphore mStopCaptureSem;
+    Semaphore mSwitchToLoadedSem;
+
+    Vector<struct TIUTILS::Message *> mEventSignalQ;
+    Mutex mEventLock;
+
+    OMX_STATETYPE mComponentState;
+
+    bool mVnfEnabled;
+    bool mVstabEnabled;
+
+    int mSensorOrientation;
+    int mDeviceOrientation;
+    bool mSensorOverclock;
+
+    //Indicates if we should leave
+    //OMX_Executing state during
+    //stop-/startPreview
+    bool mOMXStateSwitch;
+
+    int mFrameCount;
+    int mLastFrameCount;
+    unsigned int mIter;
+    nsecs_t mLastFPSTime;
+
+    int mSensorIndex;
+    CodingMode mCodingMode;
+
+    // Time source delta of ducati & system time
+    OMX_TICKS mTimeSourceDelta;
+    bool onlyOnce;
+
+    Semaphore mCaptureSem;
+    bool mCaptureSignalled;
+
+};
+}; //// namespace
+#endif //OMX_CAMERA_ADAPTER_H
+
diff --git a/camera/inc/SensorListener.h b/camera/inc/SensorListener.h
new file mode 100644
index 0000000..913eb95
--- /dev/null
+++ b/camera/inc/SensorListener.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/**
+* @file SensorListener.h
+*
+* This defines API for camerahal to get sensor events
+*
+*/
+
+#ifndef ANDROID_CAMERA_HARDWARE_SENSOR_LISTENER_H
+#define ANDROID_CAMERA_HARDWARE_SENSOR_LISTENER_H
+
+#include <android/sensor.h>
+#include <gui/Sensor.h>
+#include <gui/SensorManager.h>
+#include <gui/SensorEventQueue.h>
+#include <utils/Looper.h>
+
+namespace android {
+
+/**
+ * SensorListner class - Registers with sensor manager to get sensor events
+ */
+
+typedef void (*orientation_callback_t) (uint32_t orientation, uint32_t tilt, void* cookie);
+
+class SensorLooperThread : public Thread {
+    public:
+        SensorLooperThread(Looper* looper)
+            : Thread(false) {
+            mLooper = sp<Looper>(looper);
+        }
+        ~SensorLooperThread() {
+            mLooper.clear();
+        }
+
+        virtual bool threadLoop() {
+            int32_t ret = mLooper->pollOnce(-1);
+            return true;
+        }
+
+        // force looper wake up
+        void wake() {
+            mLooper->wake();
+        }
+    private:
+        sp<Looper> mLooper;
+};
+
+
+class SensorListener : public RefBase
+{
+/* public - types */
+public:
+    typedef enum {
+        SENSOR_ACCELEROMETER  = 1 << 0,
+        SENSOR_MAGNETIC_FIELD = 1 << 1,
+        SENSOR_GYROSCOPE      = 1 << 2,
+        SENSOR_LIGHT          = 1 << 3,
+        SENSOR_PROXIMITY      = 1 << 4,
+        SENSOR_ORIENTATION    = 1 << 5,
+    } sensor_type_t;
+/* public - functions */
+public:
+    SensorListener();
+    ~SensorListener();
+    status_t initialize();
+    void setCallbacks(orientation_callback_t orientation_cb, void *cookie);
+    void enableSensor(sensor_type_t type);
+    void disableSensor(sensor_type_t type);
+    void handleOrientation(uint32_t orientation, uint32_t tilt);
+/* public - member variables */
+public:
+    sp<SensorEventQueue> mSensorEventQueue;
+/* private - member variables */
+private:
+    int sensorsEnabled;
+    orientation_callback_t mOrientationCb;
+    void *mCbCookie;
+    sp<Looper> mLooper;
+    sp<SensorLooperThread> mSensorLooperThread;
+    Mutex mLock;
+};
+
+}
+
+#endif
diff --git a/camera/inc/TICameraParameters.h b/camera/inc/TICameraParameters.h
new file mode 100644
index 0000000..1886d0c
--- /dev/null
+++ b/camera/inc/TICameraParameters.h
@@ -0,0 +1,241 @@
+/*

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

+ *

+ * 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 TI_CAMERA_PARAMETERS_H

+#define TI_CAMERA_PARAMETERS_H

+

+#include <utils/KeyedVector.h>

+#include <utils/String8.h>

+

+namespace android {

+

+///TI Specific Camera Parameters

+class TICameraParameters

+{

+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_VSTAB[];

+static const  char KEY_VSTAB_VALUES[];

+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[];

+

+static const char  KEY_CURRENT_ISO[];

+

+static const char KEY_SENSOR_ORIENTATION[];

+static const char KEY_SENSOR_ORIENTATION_VALUES[];

+

+//TI extensions for zoom

+static const char ZOOM_SUPPORTED[];

+static const char ZOOM_UNSUPPORTED[];

+

+//TI extensions for camera capabilies

+static const char INITIAL_VALUES_TRUE[];

+static const char INITIAL_VALUES_FALSE[];

+

+//TI extensions for enabling/disabling measurements

+static const char MEASUREMENT_ENABLE[];

+static const char MEASUREMENT_DISABLE[];

+

+//  TI 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[];

+

+//TI extensions for enabling/disabling GLBCE

+static const char GLBCE_ENABLE[];

+static const char GLBCE_DISABLE[];

+

+//TI extensions for enabling/disabling GBCE

+static const char GBCE_ENABLE[];

+static const char GBCE_DISABLE[];

+

+// TI 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[];

+

+//  TI 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[];

+

+//TI extensions for setting EXIF tags

+static const char KEY_EXIF_MODEL[];

+static const char KEY_EXIF_MAKE[];

+

+//TI extensions for additional GPS data

+static const char  KEY_GPS_MAPDATUM[];

+static const char  KEY_GPS_VERSION[];

+static const char  KEY_GPS_DATESTAMP[];

+

+//TI extensions for enabling/disabling shutter sound

+static const char SHUTTER_ENABLE[];

+static const char SHUTTER_DISABLE[];

+

+//TI extensions for Temporal bracketing

+static const char BRACKET_ENABLE[];

+static const char BRACKET_DISABLE[];

+

+//TI 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[];

+

+//TI 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[];

+

+

+// TI 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[];

+

+// TI 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[];

+

+// TI 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[];

+

+// TI 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[];

+

+// TI extensions to standard android focus presets.

+static const  char FOCUS_MODE_PORTRAIT[];

+static const  char FOCUS_MODE_EXTENDED[];

+static const char  FOCUS_MODE_FACE[];

+

+// TI 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[];

+

+//  TI 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[];

+

+//  TI 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[];

+

+

+//TI extensions for flash mode settings

+static const char FLASH_MODE_FILL_IN[];

+

+//TI 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[];

+

+

+//TI values for camera direction

+static const char FACING_FRONT[];

+static const char FACING_BACK[];

+

+};

+

+};

+

+#endif

+

diff --git a/camera/inc/V4LCameraAdapter/V4LCameraAdapter.h b/camera/inc/V4LCameraAdapter/V4LCameraAdapter.h
new file mode 100644
index 0000000..b9d3952
--- /dev/null
+++ b/camera/inc/V4LCameraAdapter/V4LCameraAdapter.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 V4L_CAMERA_ADAPTER_H
+#define V4L_CAMERA_ADAPTER_H
+
+#include "CameraHal.h"
+#include "BaseCameraAdapter.h"
+#include "DebugUtils.h"
+
+namespace android {
+
+#define DEFAULT_PIXEL_FORMAT V4L2_PIX_FMT_YUYV
+#define NB_BUFFER 10
+#define DEVICE "/dev/video4"
+
+
+struct VideoInfo {
+    struct v4l2_capability cap;
+    struct v4l2_format format;
+    struct v4l2_buffer buf;
+    struct v4l2_requestbuffers rb;
+    void *mem[NB_BUFFER];
+    bool isStreaming;
+    int width;
+    int height;
+    int formatIn;
+    int framesizeIn;
+};
+
+
+/**
+  * 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
+{
+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;
+
+    ///Five second timeout
+    static const int CAMERA_ADAPTER_TIMEOUT = 5000*1000;
+
+public:
+
+    V4LCameraAdapter();
+    ~V4LCameraAdapter();
+
+
+    ///Initialzes the camera adapter creates any resources required
+    virtual status_t initialize(CameraProperties::Properties*, int sensor_index=0);
+
+    //APIs to configure Camera adapter and get the current parameter set
+    virtual status_t setParameters(const CameraParameters& params);
+    virtual void getParameters(CameraParameters& params);
+
+    // API
+    virtual status_t UseBuffersPreview(void* bufArr, int num);
+
+    //API to flush the buffers for preview
+    status_t flushBuffers();
+
+protected:
+
+//----------Parent class method implementation------------------------------------
+    virtual status_t startPreview();
+    virtual status_t stopPreview();
+    virtual status_t useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable);
+    virtual status_t fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType);
+    virtual status_t getFrameSize(size_t &width, size_t &height);
+    virtual status_t getPictureBufferSize(size_t &length, size_t bufferCount);
+    virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount);
+    virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt);
+//-----------------------------------------------------------------------------
+
+
+private:
+
+    class PreviewThread : public Thread {
+            V4LCameraAdapter* mAdapter;
+        public:
+            PreviewThread(V4LCameraAdapter* hw) :
+                    Thread(false), mAdapter(hw) { }
+            virtual void onFirstRef() {
+                run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY);
+            }
+            virtual bool threadLoop() {
+                mAdapter->previewThread();
+                // loop until we need to quit
+                return true;
+            }
+        };
+
+    //Used for calculation of the average frame rate during preview
+    status_t recalculateFPS();
+
+    char * GetFrame(int &index);
+
+    int previewThread();
+
+public:
+
+private:
+    int mPreviewBufferCount;
+    KeyedVector<int, int> mPreviewBufs;
+    mutable Mutex mPreviewBufsLock;
+
+    CameraParameters mParams;
+
+    bool mPreviewing;
+    bool mCapturing;
+    Mutex mLock;
+
+    int mFrameCount;
+    int mLastFrameCount;
+    unsigned int mIter;
+    nsecs_t mLastFPSTime;
+
+    //variables holding the estimated framerate
+    float mFPS, mLastFPS;
+
+    int mSensorIndex;
+
+     // protected by mLock
+     sp<PreviewThread>   mPreviewThread;
+
+     struct VideoInfo *mVideoInfo;
+     int mCameraHandle;
+
+
+    int nQueued;
+    int nDequeued;
+
+};
+}; //// namespace
+#endif //V4L_CAMERA_ADAPTER_H
+
diff --git a/camera/inc/VideoMetadata.h b/camera/inc/VideoMetadata.h
new file mode 100644
index 0000000..f05ee50
--- /dev/null
+++ b/camera/inc/VideoMetadata.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 VIDEO_METADATA_H
+#define VIDEO_METADATA_H
+
+/* This structure is used to pass buffer offset from Camera-Hal to Encoder component
+ * for specific algorithms like VSTAB & VNF
+ */
+
+typedef struct
+{
+    int metadataBufferType;
+    void* handle;
+    int offset;
+}
+video_metadata_t;
+
+#endif
diff --git a/domx/Android.mk b/domx/Android.mk
new file mode 100644
index 0000000..6571161
--- /dev/null
+++ b/domx/Android.mk
@@ -0,0 +1 @@
+include $(all-subdir-makefiles)
diff --git a/domx/Ducati_binary/Android.mk b/domx/Ducati_binary/Android.mk
new file mode 100644
index 0000000..1c71ed0
--- /dev/null
+++ b/domx/Ducati_binary/Android.mk
@@ -0,0 +1,36 @@
+ifeq (0,1)
+LOCAL_PATH := $(call my-dir)
+
+define _add-ducati-vendor-bin
+include $$(CLEAR_VARS)
+$(if $(word 2,$1),$(error Invalid DUCATI module name $1))
+LOCAL_MODULE := $(basename $(notdir $1))
+LOCAL_SRC_FILES := $1
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_SUFFIX := $(suffix $1)
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_MODULE_PATH := $$(TARGET_OUT)$(abspath /$(dir $1))
+OVERRIDE_BUILT_MODULE_PATH := $$(TARGET_OUT_INTERMEDIATE_EXECUTABLES)
+include $$(BUILD_PREBUILT)
+endef
+
+prebuilt_ducati_vendor_bins := \
+	etc/firmware/ducati-m3.bin 
+
+prebuilt_ducati_modules := \
+  $(foreach _file, $(prebuilt_ducati_vendor_bins),\
+    $(notdir $(basename $(_file))))
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := ti_omap4_ducati_bins
+LOCAL_MODULE_TAGS := optional
+LOCAL_REQUIRED_MODULES := $(prebuilt_ducati_modules)
+include $(BUILD_PHONY_PACKAGE)
+
+$(foreach _file,$(prebuilt_ducati_vendor_bins),\
+  $(eval $(call _add-ducati-vendor-bin,$(_file))))
+
+prebuilt_ducati_modules :=
+prebuilt_ducati_vendor_bins :=
+_add-ducati-vendor-bin :=
+endif
diff --git a/domx/Ducati_binary/ReadMe b/domx/Ducati_binary/ReadMe
new file mode 100644
index 0000000..43cf4e6
--- /dev/null
+++ b/domx/Ducati_binary/ReadMe
@@ -0,0 +1,4 @@
+Corresponding gollum version in this binary : 05be6962a64d7dc351a49510ad8b0cab937d0c10 (increase the const and heap areas for core1)
+Corresponding ducati version in this binary : b70ffd4cc728fb22ccc34adb0ad46b6648cb09dc (Adding TI NV12 as a custom color format)
+Corresponding kernel commit tested with: c2bfda0d4830a1f745aea955de516424b3b85e02 ( omap4: Kconfig: select ipc/omx modules by default)
+Corresponding DOMX commit tested with: 8d67c6dc2f8972a9f9110b1f2fe8179966258843 ( Enabling Android build for Linux_DOMX)
diff --git a/domx/Ducati_binary/etc/firmware/ducati-m3.bin b/domx/Ducati_binary/etc/firmware/ducati-m3.bin
new file mode 100755
index 0000000..9592a70
--- /dev/null
+++ b/domx/Ducati_binary/etc/firmware/ducati-m3.bin
diff --git a/domx/Makefile b/domx/Makefile
new file mode 100644
index 0000000..f6fb3f0
--- /dev/null
+++ b/domx/Makefile
@@ -0,0 +1,89 @@
+#
+#  Copyright 2001-2008 Texas Instruments - http://www.ti.com/
+# 
+#  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.
+#
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#  SEP xx,2002    REF=ORG			Swamy MC
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+#PROJROOT = $(ROOTDIR)/src
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = DEBUG
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  =
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+#TARGETTYPE  = ST_LIB
+TARGETTYPE  =
+
+# For shared object library, soname is filename.so.maj_ver
+SH_SONAME = 
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+mm_osal \
+omx_core \
+domx \
+omx_proxy_component \
+ 
+#video/omx_proxy_component/test 
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     =
+
+# Search path for include files
+
+INCLUDES    =
+
+# Libraries needed for linking.
+
+ST_LIBS        =
+SH_LIBS        =
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES =
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
diff --git a/domx/domx/Android.mk b/domx/domx/Android.mk
new file mode 100644
index 0000000..a724e62
--- /dev/null
+++ b/domx/domx/Android.mk
@@ -0,0 +1,34 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+    omx_rpc/src/omx_rpc.c \
+    omx_rpc/src/omx_rpc_skel.c \
+    omx_rpc/src/omx_rpc_stub.c \
+    omx_rpc/src/omx_rpc_config.c \
+    omx_rpc/src/omx_rpc_platform.c \
+    omx_proxy_common/src/omx_proxy_common.c
+
+LOCAL_C_INCLUDES += \
+    $(LOCAL_PATH)/omx_rpc/inc \
+    $(LOCAL_PATH)/../omx_core/inc \
+    $(LOCAL_PATH)/../mm_osal/inc \
+    $(HARDWARE_TI_OMAP4_BASE)/tiler/ \
+    $(HARDWARE_TI_OMAP4_BASE)/hwc/ \
+    system/core/include/cutils \
+    $(HARDWARE_TI_OMAP4_BASE)/../../libhardware/include
+
+LOCAL_CFLAGS += -D_Android -DENABLE_GRALLOC_BUFFERS -DUSE_ENHANCED_PORTRECONFIG -DANDROID_QUIRK_LOCK_BUFFER
+
+
+LOCAL_SHARED_LIBRARIES := \
+    libmm_osal \
+    libc \
+    liblog \
+    libtimemmgr
+
+LOCAL_MODULE:= libdomx
+LOCAL_MODULE_TAGS:= optional
+
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
diff --git a/domx/domx/Makefile b/domx/domx/Makefile
new file mode 100644
index 0000000..4e3639e
--- /dev/null
+++ b/domx/domx/Makefile
@@ -0,0 +1,111 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  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.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+#PROJROOT = ..
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = 
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG 
+endif
+CDEFS          +=
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = libdomx
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = SH_LIB
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = lib
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = lib
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+omx_rpc/src/omx_rpc.c \
+omx_rpc/src/omx_rpc_skel.c \
+omx_rpc/src/omx_rpc_stub.c \
+omx_rpc/src/omx_rpc_config.c \
+omx_rpc/src/omx_rpc_platform.c \
+omx_proxy_common/src/omx_proxy_common.c
+
+
+
+# Search path for include files
+
+INCLUDES    = \
+    $(PROJROOT)/omx_core/inc \
+    $(PROJROOT)/mm_osal/inc \
+    $(PROJROOT)/domx \
+    $(PROJROOT)/domx/omx_rpc \
+    $(PROJROOT)/domx/omx_rpc/inc \
+    ../../memmgrheaders \
+
+
+# Libraries needed for linking.
+
+ST_LIBS        = 
+#mm_osal
+SH_LIBS        = omx_core mm_osal 
+#rcm ipc
+#pthread rt utils procmgr ipc rcm notify
+#SH_LIBS        += sysmgr sysmemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/mm_osal \
+              $(PROJROOT)/omx_core
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
diff --git a/domx/domx/memmgr_rpc/src/Android.mk b/domx/domx/memmgr_rpc/src/Android.mk
new file mode 100755
index 0000000..3a6e733
--- /dev/null
+++ b/domx/domx/memmgr_rpc/src/Android.mk
@@ -0,0 +1,35 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	memmgr_rpc.c
+
+LOCAL_C_INCLUDES += \
+	$(LOCAL_PATH)/../inc \
+	$(LOCAL_PATH)/../../ \
+	$(LOCAL_PATH)/../../omx_rpc/inc \
+	$(LOCAL_PATH)/../../../domx \
+	$(HARDWARE_TI_OMAP4_BASE)/omx/ducati/domx/system/omx_core/inc \
+	$(HARDWARE_TI_OMAP4_BASE)/omx/ducati/domx/system/mm_osal/inc \
+	$(HARDWARE_TI_OMAP4_BASE)/tiler \
+	$(HARDWARE_TI_OMAP4_BASE)/syslink/syslink/d2c \
+	$(HARDWARE_TI_OMAP4_BASE)/syslink/syslink/api/include
+
+LOCAL_CFLAGS += -D_Android
+
+LOCAL_SHARED_LIBRARIES := \
+	libOMX_CoreOsal \
+	libipcutils \
+	libsysmgr \
+	libipc \
+	librcm \
+	libnotify \
+	libc \
+	liblog    \
+	libtimemmgr \
+	libd2cmap
+
+LOCAL_MODULE:= libmemmgr_rpc
+
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
diff --git a/domx/domx/omx_proxy_common.h b/domx/domx/omx_proxy_common.h
new file mode 100755
index 0000000..04f2b71
--- /dev/null
+++ b/domx/domx/omx_proxy_common.h
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_proxy_common.h
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework OMX Common Proxy.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_proxy_common\
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+#ifdef ANDROID_QUIRK_LOCK_BUFFER
+#include <hardware/gralloc.h>
+#endif
+
+#ifndef OMX_PROXY_H
+#define OMX_PROXY_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/* ------compilation control switches ----------------------------------------*/
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+/* ----- system and platform files ----------------------------*/
+#include <OMX_Core.h>
+/*-------program files ----------------------------------------*/
+#include "omx_rpc.h"
+#include "omx_rpc_internal.h"
+#include "omx_rpc_utils.h"
+
+/****************************************************************
+ * PUBLIC DECLARATIONS Defined here, used elsewhere
+ ****************************************************************/
+/*--------data declarations -----------------------------------*/
+/*OMX versions supported by DOMX*/
+#define OMX_VER_MAJOR 0x1
+#define OMX_VER_MINOR 0x1
+
+#define MAX_NUM_PROXY_BUFFERS             32
+#define MAX_COMPONENT_NAME_LENGTH         128
+#define PROXY_MAXNUMOFPORTS               8
+
+/******************************************************************
+ *   MACROS - ASSERTS
+ ******************************************************************/
+#define PROXY_assert  PROXY_paramCheck
+#define PROXY_require PROXY_paramCheck
+#define PROXY_ensure  PROXY_paramCheck
+
+#define PROXY_paramCheck(C, V, S) do {\
+    if (!(C)) { eError = V;\
+    if(S) DOMX_ERROR("failed check:" #C" - returning error: 0x%x - %s",V,S);\
+    else DOMX_ERROR("failed check:" #C" - returning error: 0x%x",C, V); \
+    goto EXIT; }\
+    } while(0)
+
+#define PROXY_CHK_VERSION(_pStruct_, _sName_) do { \
+    PROXY_require((((_sName_ *)_pStruct_)->nSize == sizeof(_sName_)), \
+                  OMX_ErrorBadParameter, "Incorrect nSize"); \
+    PROXY_require(((((_sName_ *)_pStruct_)->nVersion.s.nVersionMajor == \
+                  OMX_VER_MAJOR) && \
+                  (((_sName_ *)_pStruct_)->nVersion.s.nVersionMinor == \
+                  OMX_VER_MINOR)), \
+                  OMX_ErrorVersionMismatch, NULL); \
+    } while(0)
+
+
+	typedef OMX_ERRORTYPE(*PROXY_EMPTYBUFFER_DONE) (OMX_HANDLETYPE
+	    hComponent, OMX_U32 remoteBufHdr, OMX_U32 nfilledLen,
+	    OMX_U32 nOffset, OMX_U32 nFlags);
+
+	typedef OMX_ERRORTYPE(*PROXY_FILLBUFFER_DONE) (OMX_HANDLETYPE
+	    hComponent, OMX_U32 remoteBufHdr, OMX_U32 nfilledLen,
+	    OMX_U32 nOffset, OMX_U32 nFlags, OMX_TICKS nTimeStamp,
+	    OMX_HANDLETYPE hMarkTargetComponent, OMX_PTR pMarkData);
+
+	typedef OMX_ERRORTYPE(*PROXY_EVENTHANDLER) (OMX_HANDLETYPE hComponent,
+	    OMX_PTR pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1,
+	    OMX_U32 nData2, OMX_PTR pEventData);
+
+/*******************************************************************************
+* Structures
+*******************************************************************************/
+/*===============================================================*/
+/** PROXY_BUFFER_INFO        : This structure maintains a table of A9 and
+ *                             Ducati side buffers and headers.
+ *
+ * @param pBufHeader         : This is a pointer to the A9 bufferheader.
+ *
+ * @param pBufHeaderRemote   : This is pointer to Ducati side bufferheader.
+ */
+/*===============================================================*/
+	typedef struct PROXY_BUFFER_INFO
+	{
+		OMX_BUFFERHEADERTYPE *pBufHeader;
+		OMX_U32 pBufHeaderRemote;
+		OMX_PTR pYBuffer;
+	} PROXY_BUFFER_INFO;
+
+/*===============================================================*/
+/** PROXY_BUFFER_TYPE        : This enumeration tells the type of buffer pointers coming to OMX in 
+				UseBuffer call.
+ */
+/*===============================================================*/
+	typedef enum PROXY_BUFFER_TYPE
+	{
+		VirtualPointers,   /*Used when buffer pointers come from the normal A9 virtual space */
+		GrallocPointers,   /*Used when buffer pointers come from Gralloc allocations */
+		IONPointers,       /*Used when buffer pointers come from ION allocations */
+		EncoderMetadataPointers		/*Used when buffer pointers come from Stagefright in camcorder usecase */
+	} PROXY_BUFFER_TYPE;
+
+/*===============================================================*/
+/** PROXY_BUFFER_TYPE        : This enumeration tells the type of buffer pointers coming to OMX in
+                               UseBuffer call.
+ */
+/*===============================================================*/
+	typedef struct PROXY_PORT_TYPE
+	{
+		PROXY_BUFFER_TYPE proxyBufferType;   /*Used when buffer pointers come from the normal A9 virtual space */
+		OMX_U32 IsBuffer2D;   /*Used when buffer pointers come from Gralloc allocations */
+	} PROXY_PORT_TYPE;
+
+/* ========================================================================== */
+/**
+* PROXY_COMPONENT_PRIVATE
+*
+*/
+/* ========================================================================== */
+	typedef struct PROXY_COMPONENT_PRIVATE
+	{
+		/* OMX Related Information */
+		OMX_CALLBACKTYPE tCBFunc;
+		OMX_PTR pILAppData;
+		OMX_HANDLETYPE hRemoteComp;
+
+		PROXY_BUFFER_INFO tBufList[MAX_NUM_PROXY_BUFFERS];
+		PROXY_PORT_TYPE proxyPortBuffers[PROXY_MAXNUMOFPORTS];
+		OMX_BOOL IsLoadedState;
+		OMX_U32 nTotalBuffers;
+		OMX_U32 nAllocatedBuffers;
+
+		/* PROXY specific data - PROXY PRIVATE DATA */
+		char *cCompName;
+
+		PROXY_EMPTYBUFFER_DONE proxyEmptyBufferDone;
+		PROXY_FILLBUFFER_DONE proxyFillBufferDone;
+		PROXY_EVENTHANDLER proxyEventHandler;
+
+#ifdef ANDROID_QUIRK_LOCK_BUFFER
+		gralloc_module_t const *grallocModule;
+#endif
+	} PROXY_COMPONENT_PRIVATE;
+
+
+
+/*===============================================================*/
+/** PROXY_MARK_DATA        : A pointer to this structure is sent as mark data to
+ *                           the remote core when a MarkBuffer command is made.
+ *
+ * @param hComponentActual : This is the actual handle of the component to be
+ *                           marked. When marked buffers come from the remote
+ *                           to the local core then remote handle of the mark
+ *                           component is replaced by this in the header.
+ *
+ * @param pMarkdataActual : This is the mark data set by the client.
+ */
+/*===============================================================*/
+	typedef struct PROXY_MARK_DATA
+	{
+		OMX_HANDLETYPE hComponentActual;
+		OMX_PTR pMarkDataActual;
+	} PROXY_MARK_DATA;
+/*******************************************************************************
+* Functions
+*******************************************************************************/
+	OMX_ERRORTYPE OMX_ProxyCommonInit(OMX_HANDLETYPE hComponent);
+	OMX_ERRORTYPE PROXY_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+	    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct);
+	OMX_ERRORTYPE PROXY_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+	    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct);
+	OMX_ERRORTYPE PROXY_EventHandler(OMX_HANDLETYPE hComponent,
+	    OMX_PTR pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2,
+	    OMX_PTR pEventData);
+	OMX_ERRORTYPE PROXY_SendCommand(OMX_IN OMX_HANDLETYPE hComponent,
+	    OMX_IN OMX_COMMANDTYPE eCmd,
+	    OMX_IN OMX_U32 nParam, OMX_IN OMX_PTR pCmdData);
+	OMX_ERRORTYPE PROXY_EmptyThisBuffer(OMX_HANDLETYPE hComponent,
+	    OMX_BUFFERHEADERTYPE * pBufferHdr);
+	OMX_ERRORTYPE PROXY_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,
+	    OMX_IN OMX_STRING cParameterName, OMX_OUT OMX_INDEXTYPE * pIndexType);
+	OMX_ERRORTYPE PROXY_FillBufferDone(OMX_HANDLETYPE hComponent,
+	OMX_U32 remoteBufHdr, OMX_U32 nfilledLen, OMX_U32 nOffset, OMX_U32 nFlags,
+	    OMX_TICKS nTimeStamp, OMX_HANDLETYPE hMarkTargetComponent,
+	    OMX_PTR pMarkData);
+	OMX_ERRORTYPE PROXY_FillThisBuffer(OMX_HANDLETYPE hComponent,
+	    OMX_BUFFERHEADERTYPE * pBufferHdr);
+
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif
diff --git a/domx/domx/omx_proxy_common/src/omx_proxy_common.c b/domx/domx/omx_proxy_common/src/omx_proxy_common.c
new file mode 100644
index 0000000..a72c462
--- /dev/null
+++ b/domx/domx/omx_proxy_common/src/omx_proxy_common.c
@@ -0,0 +1,2461 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_proxy_common.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework OMX Common Proxy .
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_proxy_common\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+/* ------compilation control switches ----------------------------------------*/
+#define TILER_BUFF
+#define ALLOCATE_TILER_BUFFER_IN_PROXY
+// This has been enabled enbled only in Android.mk
+// #define ENABLE_GRALLOC_BUFFER
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+/* ----- system and platform files ----------------------------*/
+#include <string.h>
+
+#include "timm_osal_memory.h"
+#include "timm_osal_mutex.h"
+#include "OMX_TI_Common.h"
+#include "OMX_TI_Index.h"
+#include "OMX_TI_Core.h"
+/*-------program files ----------------------------------------*/
+#include "omx_proxy_common.h"
+#include "omx_rpc.h"
+#include "omx_rpc_stub.h"
+#include "omx_rpc_utils.h"
+#include "OMX_TI_IVCommon.h"
+
+#ifdef ALLOCATE_TILER_BUFFER_IN_PROXY
+#include "memmgr.h"
+#include "tiler.h"
+#endif
+
+
+#ifdef  ENABLE_GRALLOC_BUFFERS
+#include "native_handle.h"
+#include "hal_public.h"
+#endif
+
+#ifdef TILER_BUFF
+#define PortFormatIsNotYUV 0
+
+#if 0
+static OMX_ERRORTYPE RPC_PrepareBuffer_Remote(PROXY_COMPONENT_PRIVATE *
+    pCompPrv, OMX_COMPONENTTYPE * hRemoteComp, OMX_U32 nPortIndex,
+    OMX_U32 nSizeBytes, OMX_BUFFERHEADERTYPE * pChironBuf,
+    OMX_BUFFERHEADERTYPE * pDucBuf, OMX_PTR pBufToBeMapped);
+static OMX_ERRORTYPE RPC_PrepareBuffer_Chiron(PROXY_COMPONENT_PRIVATE *
+    pCompPrv, OMX_COMPONENTTYPE * hRemoteComp, OMX_U32 nPortIndex,
+    OMX_U32 nSizeBytes, OMX_BUFFERHEADERTYPE * pDucBuf,
+    OMX_BUFFERHEADERTYPE * pChironBuf);
+static OMX_ERRORTYPE RPC_UnMapBuffer_Ducati(OMX_PTR pBuffer);
+static OMX_ERRORTYPE RPC_MapBuffer_Ducati(OMX_U8 * pBuf, OMX_U32 nBufLineSize,
+    OMX_U32 nBufLines, OMX_U8 ** pMappedBuf, OMX_PTR pBufToBeMapped);
+
+static OMX_ERRORTYPE RPC_MapMetaData_Host(OMX_BUFFERHEADERTYPE * pBufHdr);
+static OMX_ERRORTYPE RPC_UnMapMetaData_Host(OMX_BUFFERHEADERTYPE * pBufHdr);
+#endif
+
+static OMX_ERRORTYPE _RPC_IsProxyComponent(OMX_HANDLETYPE hComponent,
+    OMX_BOOL * bIsProxy);
+OMX_ERRORTYPE RPC_UTIL_GetStride(OMX_COMPONENTTYPE * hRemoteComp,
+    OMX_U32 nPortIndex, OMX_U32 * nStride);
+OMX_ERRORTYPE RPC_UTIL_GetNumLines(OMX_COMPONENTTYPE * hComp,
+    OMX_U32 nPortIndex, OMX_U32 * nNumOfLines);
+
+#endif
+
+#ifdef ALLOCATE_TILER_BUFFER_IN_PROXY
+
+static OMX_ERRORTYPE PROXY_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,
+    OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_PTR pAppPrivate,
+    OMX_IN OMX_U32 nSizeBytes, OMX_IN OMX_U8 * pBuffer);
+#endif
+
+#define LINUX_PAGE_SIZE (4 * 1024)
+#define MAXNAMESIZE 128
+
+#define CORE_MAX 4
+#define CORE_CHIRON 3
+#define CORE_SYSM3 2
+#define CORE_APPM3 1
+#define CORE_TESLA 0
+
+#define MAX_CORENAME_LENGTH 32
+char Core_Array[][MAX_CORENAME_LENGTH] =
+    { "TESLA", "DUCATI1", "DUCATI0", "CHIRON" };
+
+/******************************************************************
+ *   MACROS - LOCAL
+ ******************************************************************/
+
+#define PROXY_checkRpcError() do { \
+    if (eRPCError == RPC_OMX_ErrorNone) \
+    { \
+        DOMX_DEBUG("Corresponding RPC function executed successfully"); \
+        eError = eCompReturn; \
+        PROXY_assert(eError == OMX_ErrorNone, eError, "Error returned from OMX API in ducati"); \
+    } else \
+    { \
+        DOMX_ERROR("RPC function returned error 0x%x", eRPCError); \
+        switch (eRPCError) \
+        { \
+            case RPC_OMX_ErrorHardware: \
+                eError = OMX_ErrorHardware; \
+            break; \
+            case RPC_OMX_ErrorInsufficientResources: \
+                eError = OMX_ErrorInsufficientResources; \
+            break; \
+            case RPC_OMX_ErrorBadParameter: \
+                eError = OMX_ErrorBadParameter; \
+            break; \
+            case RPC_OMX_ErrorUnsupportedIndex: \
+                eError = OMX_ErrorUnsupportedIndex; \
+            break; \
+            case RPC_OMX_ErrorTimeout: \
+                eError = OMX_ErrorTimeout; \
+            break; \
+            default: \
+                eError = OMX_ErrorUndefined; \
+        } \
+    } \
+} while(0)
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_EventHandler()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_EventHandler(OMX_HANDLETYPE hComponent,
+    OMX_PTR pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2,
+    OMX_PTR pEventData)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_PTR pTmpData = NULL;
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter,
+	    "This is fatal error, processing cant proceed - please debug");
+
+	DOMX_ENTER
+	    ("hComponent=%p, pCompPrv=%p, eEvent=%p, nData1=%p, nData2=%p, pEventData=%p",
+	    hComponent, pCompPrv, eEvent, nData1, nData2, pEventData);
+
+	switch (eEvent)
+	{
+#if 0
+	case OMX_TI_EventBufferRefCount:
+		DOMX_DEBUG("Received Ref Count Event");
+		/*nData1 will be pBufferHeader, nData2 will be present count. Need to find local
+		   buffer header for nData1 which is remote buffer header */
+
+		PROXY_assert((nData1 != 0), OMX_ErrorBadParameter,
+		    "Received NULL buffer header from OMX component");
+
+		/*find local buffer header equivalent */
+		for (count = 0; count < pCompPrv->nTotalBuffers; ++count)
+		{
+			if (pCompPrv->tBufList[count].pBufHeaderRemote ==
+			    nData1)
+			{
+				pLocalBufHdr =
+				    pCompPrv->tBufList[count].pBufHeader;
+				pLocalBufHdr->pBuffer =
+				    (OMX_U8 *) pCompPrv->tBufList[count].
+				    pBufferActual;
+				break;
+			}
+		}
+		PROXY_assert((count != pCompPrv->nTotalBuffers),
+		    OMX_ErrorBadParameter,
+		    "Received invalid-buffer header from OMX component");
+
+		/*update local buffer header */
+		nData1 = (OMX_U32) pLocalBufHdr;
+		break;
+#endif
+	case OMX_EventMark:
+		DOMX_DEBUG("Received Mark Event");
+		PROXY_assert((pEventData != NULL), OMX_ErrorUndefined,
+		    "MarkData corrupted");
+		pTmpData = pEventData;
+		pEventData =
+		    ((PROXY_MARK_DATA *) pEventData)->pMarkDataActual;
+		TIMM_OSAL_Free(pTmpData);
+		break;
+
+	default:
+		break;
+	}
+
+      EXIT:
+	if (eError == OMX_ErrorNone)
+	{
+		pCompPrv->tCBFunc.EventHandler(hComponent,
+		    pCompPrv->pILAppData, eEvent, nData1, nData2, pEventData);
+	} else if (pCompPrv)
+	{
+		pCompPrv->tCBFunc.EventHandler(hComponent,
+		    pCompPrv->pILAppData, OMX_EventError, eError, 0, NULL);
+	}
+
+	DOMX_EXIT("eError: %d", eError);
+	return OMX_ErrorNone;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_EmptyBufferDone()
+ * @brief
+ * @param
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_EmptyBufferDone(OMX_HANDLETYPE hComponent,
+    OMX_U32 remoteBufHdr, OMX_U32 nfilledLen, OMX_U32 nOffset, OMX_U32 nFlags)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_U16 count;
+	OMX_BUFFERHEADERTYPE *pBufHdr = NULL;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter,
+	    "This is fatal error, processing cant proceed - please debug");
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent=%p, pCompPrv=%p, remoteBufHdr=%p, nFilledLen=%d, nOffset=%d, nFlags=%08x",
+	    hComponent, pCompPrv, remoteBufHdr, nfilledLen, nOffset, nFlags);
+
+	for (count = 0; count < pCompPrv->nTotalBuffers; ++count)
+	{
+		if (pCompPrv->tBufList[count].pBufHeaderRemote ==
+		    remoteBufHdr)
+		{
+			pBufHdr = pCompPrv->tBufList[count].pBufHeader;
+			pBufHdr->nFilledLen = nfilledLen;
+			pBufHdr->nOffset = nOffset;
+			pBufHdr->nFlags = nFlags;
+			/* Setting mark info to NULL. This would always be
+			   NULL in EBD, whether component has propagated the
+			   mark or has generated mark event */
+			pBufHdr->hMarkTargetComponent = NULL;
+			pBufHdr->pMarkData = NULL;
+			break;
+		}
+	}
+	PROXY_assert((count != pCompPrv->nTotalBuffers),
+	    OMX_ErrorBadParameter,
+	    "Received invalid-buffer header from OMX component");
+
+      EXIT:
+	if (eError == OMX_ErrorNone)
+	{
+		pCompPrv->tCBFunc.EmptyBufferDone(hComponent,
+		    pCompPrv->pILAppData, pBufHdr);
+	} else if (pCompPrv)
+	{
+		pCompPrv->tCBFunc.EventHandler(hComponent,
+		    pCompPrv->pILAppData, OMX_EventError, eError, 0, NULL);
+	}
+
+	DOMX_EXIT("eError: %d", eError);
+	return OMX_ErrorNone;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_FillBufferDone()
+ * @brief
+ * @param
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_FillBufferDone(OMX_HANDLETYPE hComponent,
+    OMX_U32 remoteBufHdr, OMX_U32 nfilledLen, OMX_U32 nOffset, OMX_U32 nFlags,
+    OMX_TICKS nTimeStamp, OMX_HANDLETYPE hMarkTargetComponent,
+    OMX_PTR pMarkData)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_U16 count;
+	OMX_BUFFERHEADERTYPE *pBufHdr = NULL;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter,
+	    "This is fatal error, processing cant proceed - please debug");
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent=%p, pCompPrv=%p, remoteBufHdr=%p, nFilledLen=%d, nOffset=%d, nFlags=%08x",
+	    hComponent, pCompPrv, remoteBufHdr, nfilledLen, nOffset, nFlags);
+
+	for (count = 0; count < pCompPrv->nTotalBuffers; ++count)
+	{
+		if (pCompPrv->tBufList[count].pBufHeaderRemote ==
+		    remoteBufHdr)
+		{
+			pBufHdr = pCompPrv->tBufList[count].pBufHeader;
+			pBufHdr->nFilledLen = nfilledLen;
+			pBufHdr->nOffset = nOffset;
+			pBufHdr->nFlags = nFlags;
+			pBufHdr->nTimeStamp = nTimeStamp;
+			if (pMarkData != NULL)
+			{
+				/*Update mark info in the buffer header */
+				pBufHdr->pMarkData =
+				    ((PROXY_MARK_DATA *)
+				    pMarkData)->pMarkDataActual;
+				pBufHdr->hMarkTargetComponent =
+				    ((PROXY_MARK_DATA *)
+				    pMarkData)->hComponentActual;
+				TIMM_OSAL_Free(pMarkData);
+			}
+			break;
+		}
+	}
+	PROXY_assert((count != pCompPrv->nTotalBuffers),
+	    OMX_ErrorBadParameter,
+	    "Received invalid-buffer header from OMX component");
+
+      EXIT:
+	if (eError == OMX_ErrorNone)
+	{
+		pCompPrv->tCBFunc.FillBufferDone(hComponent,
+		    pCompPrv->pILAppData, pBufHdr);
+	} else if (pCompPrv)
+	{
+		pCompPrv->tCBFunc.EventHandler(hComponent,
+		    pCompPrv->pILAppData, OMX_EventError, eError, 0, NULL);
+	}
+
+	DOMX_EXIT("eError: %d", eError);
+	return OMX_ErrorNone;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_EmptyThisBuffer()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_EmptyThisBuffer(OMX_HANDLETYPE hComponent,
+    OMX_BUFFERHEADERTYPE * pBufferHdr)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_U32 count = 0;
+	OMX_COMPONENTTYPE *pMarkComp = NULL;
+	PROXY_COMPONENT_PRIVATE *pMarkCompPrv = NULL;
+	OMX_PTR pMarkData = NULL;
+	OMX_BOOL bFreeMarkIfError = OMX_FALSE;
+	OMX_BOOL bIsProxy = OMX_FALSE , bMapBuffer;
+
+	PROXY_require(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter,
+	    NULL);
+	PROXY_CHK_VERSION(pBufferHdr, OMX_BUFFERHEADERTYPE);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent=%p, pCompPrv=%p, nFilledLen=%d, nOffset=%d, nFlags=%08x",
+	    hComponent, pCompPrv, pBufferHdr->nFilledLen,
+	    pBufferHdr->nOffset, pBufferHdr->nFlags);
+
+	/*First find the index of this buffer header to retrieve remote buffer header */
+	for (count = 0; count < pCompPrv->nTotalBuffers; count++)
+	{
+		if (pCompPrv->tBufList[count].pBufHeader == pBufferHdr)
+		{
+			DOMX_DEBUG("Buffer Index of Match %d ", count);
+			break;
+		}
+	}
+	PROXY_assert((count != pCompPrv->nTotalBuffers),
+	    OMX_ErrorBadParameter,
+	    "Could not find the remote header in buffer list");
+
+	if (pBufferHdr->hMarkTargetComponent != NULL)
+	{
+		pMarkComp =
+		    (OMX_COMPONENTTYPE *) (pBufferHdr->hMarkTargetComponent);
+		/* Check is mark comp is proxy */
+		eError = _RPC_IsProxyComponent(pMarkComp, &bIsProxy);
+		PROXY_assert(eError == OMX_ErrorNone, eError, "");
+
+		/*Replacing original mark data with proxy specific structure */
+		pMarkData = pBufferHdr->pMarkData;
+		pBufferHdr->pMarkData =
+		    TIMM_OSAL_Malloc(sizeof(PROXY_MARK_DATA), TIMM_OSAL_TRUE,
+		    0, TIMMOSAL_MEM_SEGMENT_INT);
+		PROXY_assert(pBufferHdr->pMarkData != NULL,
+		    OMX_ErrorInsufficientResources, "Malloc failed");
+		bFreeMarkIfError = OMX_TRUE;
+		((PROXY_MARK_DATA *) (pBufferHdr->
+			pMarkData))->hComponentActual = pMarkComp;
+		((PROXY_MARK_DATA *) (pBufferHdr->
+			pMarkData))->pMarkDataActual = pMarkData;
+
+		/* If proxy comp then replace hMarkTargetComponent with remote
+		   handle */
+		if (bIsProxy)
+		{
+			pMarkCompPrv = pMarkComp->pComponentPrivate;
+			PROXY_assert(pMarkCompPrv != NULL,
+			    OMX_ErrorBadParameter, NULL);
+
+			/* Replacing with remote component handle */
+			pBufferHdr->hMarkTargetComponent =
+			    ((RPC_OMX_CONTEXT *) pMarkCompPrv->hRemoteComp)->
+			    hActualRemoteCompHandle;
+		}
+	}
+
+	bMapBuffer =
+		pCompPrv->proxyPortBuffers[pBufferHdr->nInputPortIndex].proxyBufferType ==
+			EncoderMetadataPointers;
+	eRPCError =
+	    RPC_EmptyThisBuffer(pCompPrv->hRemoteComp, pBufferHdr,
+	    pCompPrv->tBufList[count].pBufHeaderRemote, &eCompReturn,bMapBuffer);
+
+	PROXY_checkRpcError();
+
+      EXIT:
+	/*If ETB is about to return an error then this means that buffer has not
+	   been accepted by the component. Thus the allocated mark data will be
+	   lost so free it here. Also replace original mark data in the header */
+	if ((eError != OMX_ErrorNone) && bFreeMarkIfError)
+	{
+		pBufferHdr->hMarkTargetComponent =
+		    ((PROXY_MARK_DATA *) (pBufferHdr->
+			pMarkData))->hComponentActual;
+		pMarkData =
+		    ((PROXY_MARK_DATA *) (pBufferHdr->
+			pMarkData))->pMarkDataActual;
+		TIMM_OSAL_Free(pBufferHdr->pMarkData);
+		pBufferHdr->pMarkData = pMarkData;
+	}
+
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_FillThisBuffer()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_FillThisBuffer(OMX_HANDLETYPE hComponent,
+    OMX_BUFFERHEADERTYPE * pBufferHdr)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_U32 count = 0;
+
+	PROXY_require(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter,
+	    NULL);
+	PROXY_CHK_VERSION(pBufferHdr, OMX_BUFFERHEADERTYPE);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nFilledLen = %d, nOffset = %d, nFlags = %08x",
+	    hComponent, pCompPrv, pBufferHdr->nFilledLen,
+	    pBufferHdr->nOffset, pBufferHdr->nFlags);
+
+	/*First find the index of this buffer header to retrieve remote buffer header */
+	for (count = 0; count < pCompPrv->nTotalBuffers; count++)
+	{
+		if (pCompPrv->tBufList[count].pBufHeader == pBufferHdr)
+		{
+			DOMX_DEBUG("Buffer Index of Match %d ", count);
+			break;
+		}
+	}
+	PROXY_assert((count != pCompPrv->nTotalBuffers),
+	    OMX_ErrorBadParameter,
+	    "Could not find the remote header in buffer list");
+
+	eRPCError = RPC_FillThisBuffer(pCompPrv->hRemoteComp, pBufferHdr,
+	    pCompPrv->tBufList[count].pBufHeaderRemote, &eCompReturn);
+
+	PROXY_checkRpcError();
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_AllocateBuffer()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,
+    OMX_IN OMX_U32 nPortIndex,
+    OMX_IN OMX_PTR pAppPrivate, OMX_IN OMX_U32 nSizeBytes)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_U32 currentBuffer = 0, i = 0;
+	OMX_BOOL bSlotFound = OMX_FALSE;
+
+#ifdef ALLOCATE_TILER_BUFFER_IN_PROXY
+	// Do the tiler allocations in Proxy and call use buffers on Ducati.
+
+	OMX_U32 nSize = nSizeBytes, nStride = 0;
+	OMX_U8* pMemptr = NULL;
+	OMX_CONFIG_RECTTYPE tParamRect;
+	OMX_PARAM_PORTDEFINITIONTYPE tParamPortDef;
+
+     	MemAllocBlock block;
+        MemAllocBlock blocks[2];
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+	PROXY_require(ppBufferHdr != NULL, OMX_ErrorBadParameter,
+	    "Pointer to buffer header is NULL");
+
+    	memset(&block, 0, sizeof(MemAllocBlock));
+        memset(blocks, 0, sizeof(MemAllocBlock)*2);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nPortIndex = %p, pAppPrivate = %p, nSizeBytes = %d",
+	    hComponent, pCompPrv, nPortIndex, pAppPrivate, nSizeBytes);
+
+	/*To find whether buffer is 2D or 1D */
+	eError =
+	    RPC_UTIL_GetStride(pCompPrv->hRemoteComp, nPortIndex, &nStride);
+	PROXY_assert(eError == OMX_ErrorNone, eError,
+	    "Failed to get stride of component");
+
+	if (nStride == LINUX_PAGE_SIZE) //Allocate 2D buffer
+	{
+	    	tParamRect.nSize = sizeof(OMX_CONFIG_RECTTYPE);
+	    	tParamRect.nVersion.s.nVersionMajor = 1;
+	    	tParamRect.nVersion.s.nVersionMinor = 1;
+	    	tParamRect.nVersion.s.nRevision = 0;
+	    	tParamRect.nVersion.s.nStep = 0;
+		tParamRect.nPortIndex = nPortIndex;
+
+		eError = PROXY_GetParameter(hComponent, (OMX_INDEXTYPE)OMX_TI_IndexParam2DBufferAllocDimension, &tParamRect);
+		if(eError == OMX_ErrorNone)
+		{
+			blocks[0].pixelFormat = PIXEL_FMT_8BIT;
+			blocks[0].dim.area.width  = tParamRect.nWidth;
+			blocks[0].dim.area.height = tParamRect.nHeight;
+			blocks[0].stride = 0;
+
+			blocks[1].pixelFormat = PIXEL_FMT_16BIT;
+			blocks[1].dim.area.width  = tParamRect.nWidth >> 1;
+			blocks[1].dim.area.height = tParamRect.nHeight >> 1;
+			blocks[1].stride = 0;
+		}
+		else if(eError == OMX_ErrorUnsupportedIndex)
+		{
+			DOMX_ERROR("Component does not support OMX_TI_IndexParam2DBufferAllocDimension, \
+					reverting to OMX_PARAM_PORTDEFINITIONTYPE");
+			tParamPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
+		    	tParamPortDef.nVersion.s.nVersionMajor = 1;
+		    	tParamPortDef.nVersion.s.nVersionMinor = 1;
+		    	tParamPortDef.nVersion.s.nRevision = 0;
+		    	tParamPortDef.nVersion.s.nStep = 0;
+			tParamPortDef.nPortIndex = nPortIndex;
+
+			eError = PROXY_GetParameter(hComponent, OMX_IndexParamPortDefinition, &tParamPortDef);
+			if(eError != OMX_ErrorNone)
+			{
+				DOMX_ERROR("PROXY_GetParameter returns err %d (0x%x)", eError, eError);
+				return eError;
+			}
+
+			blocks[0].pixelFormat = PIXEL_FMT_8BIT;
+			blocks[0].dim.area.width  = tParamPortDef.format.video.nFrameWidth;
+			blocks[0].dim.area.height = tParamPortDef.format.video.nFrameHeight;
+			blocks[0].stride = 0;
+
+			blocks[1].pixelFormat = PIXEL_FMT_16BIT;
+			blocks[1].dim.area.width  = tParamPortDef.format.video.nFrameWidth >> 1;
+			blocks[1].dim.area.height = tParamPortDef.format.video.nFrameHeight >> 1;
+			blocks[1].stride = 0;
+
+		}
+		if(eError != OMX_ErrorNone)
+		{
+			DOMX_ERROR("PROXY_GetParameter returns err %d (0x%x)", eError, eError);
+			return eError;
+		}
+
+		pMemptr = (OMX_U8*) MemMgr_Alloc(blocks, 2);
+		PROXY_assert((pMemptr != NULL), OMX_ErrorInsufficientResources, "MemMgr_Alloc returns NULL, abort,");
+
+		DOMX_DEBUG(" Y Buffer : Allocated Width:%d, Height:%d",blocks[0].dim.area.width, blocks[0].dim.area.height);
+	}
+	else //Allocate 1D buffer
+	{
+		block.pixelFormat = PIXEL_FMT_PAGE;
+    		block.dim.len = nSize;
+    	        block.stride = 0;
+
+    	        pMemptr = (OMX_U8*) MemMgr_Alloc(&block, 1);
+                PROXY_assert((pMemptr != NULL), OMX_ErrorInsufficientResources,"MemMgr_Alloc returns NULL, abort,");
+
+    	}
+
+	/*Pick up 1st empty slot */
+	/*The same empty spot will be picked up by the subsequent
+	Use buffer call to fill in the corresponding buffer
+	Buffer header in the list */
+
+        for (i = 0; i < pCompPrv->nTotalBuffers; i++)
+        {
+                if (pCompPrv->tBufList[i].pBufHeader == NULL)
+                {
+                        currentBuffer = i;
+                        bSlotFound = OMX_TRUE;
+                        break;
+		}
+        }
+
+	if (!bSlotFound)
+	{
+		currentBuffer = pCompPrv->nTotalBuffers;
+	}
+
+	/*No need to increment Allocated buffers here.
+	It will be done in the subsequent use buffer call below*/
+
+	eError = PROXY_UseBuffer(hComponent, ppBufferHdr, nPortIndex, pAppPrivate, nSize, pMemptr);
+
+	if(eError != OMX_ErrorNone) {
+		DOMX_ERROR("PROXY_UseBuffer in PROXY_AllocateBuffer failed with error %d (0x%08x)", eError, eError);
+		MemMgr_Free(pMemptr);
+	}
+	else {
+		pCompPrv->tBufList[currentBuffer].pYBuffer = pMemptr;
+	}
+
+#else
+	//This code is the un-changed version of original implementation.
+	OMX_BUFFERHEADERTYPE *pBufferHeader = NULL;
+	OMX_U32 pBufHeaderRemote = 0;
+	OMX_U32 currentBuffer = 0, i = 0;
+	OMX_U8 *pBuffer = NULL;
+	OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL;
+	OMX_BOOL bSlotFound = OMX_FALSE;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_ERRORTYPE eCompReturn = OMX_ErrorNone;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+	PROXY_require(ppBufferHdr != NULL, OMX_ErrorBadParameter,
+	    "Pointer to buffer header is NULL");
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nPortIndex = %p, pAppPrivate = %p, nSizeBytes = %d",
+	    hComponent, pCompPrv, nPortIndex, pAppPrivate, nSizeBytes);
+
+	/*Pick up 1st empty slot */
+	for (i = 0; i < pCompPrv->nTotalBuffers; i++)
+	{
+		if (pCompPrv->tBufList[i].pBufHeader == 0)
+		{
+			currentBuffer = i;
+			bSlotFound = OMX_TRUE;
+			break;
+		}
+	}
+	if (!bSlotFound)
+	{
+		currentBuffer = pCompPrv->nTotalBuffers;
+	}
+
+	DOMX_DEBUG("In AB, no. of buffers = %d", pCompPrv->nTotalBuffers);
+	PROXY_assert((pCompPrv->nTotalBuffers < MAX_NUM_PROXY_BUFFERS),
+	    OMX_ErrorInsufficientResources,
+	    "Proxy cannot handle more than MAX buffers");
+
+	//Allocating Local bufferheader to be maintained locally within proxy
+	pBufferHeader =
+	    (OMX_BUFFERHEADERTYPE *)
+	    TIMM_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE), TIMM_OSAL_TRUE, 0,
+	    TIMMOSAL_MEM_SEGMENT_INT);
+	PROXY_assert((pBufferHeader != NULL), OMX_ErrorInsufficientResources,
+	    "Allocation of Buffer Header structure failed");
+
+	pPlatformPrivate =
+	    (OMX_TI_PLATFORMPRIVATE *)
+	    TIMM_OSAL_Malloc(sizeof(OMX_TI_PLATFORMPRIVATE), TIMM_OSAL_TRUE,
+	    0, TIMMOSAL_MEM_SEGMENT_INT);
+	PROXY_assert(pPlatformPrivate != NULL, OMX_ErrorInsufficientResources,
+	    "Allocation of platform private structure failed");
+	pBufferHeader->pPlatformPrivate = pPlatformPrivate;
+
+	DOMX_DEBUG(" Calling RPC ");
+
+	eRPCError =
+	    RPC_AllocateBuffer(pCompPrv->hRemoteComp, &pBufferHeader,
+	    nPortIndex, &pBufHeaderRemote, pAppPrivate, nSizeBytes,
+	    &eCompReturn);
+
+	PROXY_checkRpcError();
+
+	DOMX_DEBUG("Allocate Buffer Successful");
+	DOMX_DEBUG("Value of pBufHeaderRemote: %p   LocalBufferHdr :%p",
+	    pBufHeaderRemote, pBufferHeader);
+
+	pCompPrv->tBufList[currentBuffer].pBufHeader = pBufferHeader;
+	pCompPrv->tBufList[currentBuffer].pBufHeaderRemote = pBufHeaderRemote;
+
+
+	//keeping track of number of Buffers
+	pCompPrv->nAllocatedBuffers++;
+
+	if (pCompPrv->nTotalBuffers < pCompPrv->nAllocatedBuffers)
+	{
+		pCompPrv->nTotalBuffers = pCompPrv->nAllocatedBuffers;
+	}
+
+	*ppBufferHdr = pBufferHeader;
+
+      EXIT:
+	if (eError != OMX_ErrorNone)
+	{
+		if (pPlatformPrivate)
+			TIMM_OSAL_Free(pPlatformPrivate);
+		if (pBufferHeader)
+			TIMM_OSAL_Free(pBufferHeader);
+	}
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+#endif //ALLOCATE_TILER_BUFFER_IN_PROXY
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_UseBuffer()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,
+    OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_PTR pAppPrivate,
+    OMX_IN OMX_U32 nSizeBytes, OMX_IN OMX_U8 * pBuffer)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	OMX_BUFFERHEADERTYPE *pBufferHeader = NULL;
+	OMX_U32 pBufHeaderRemote = 0;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_U32 currentBuffer = 0, i = 0, nStride = 0, nNumLines = 0;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_BOOL bSlotFound = OMX_FALSE;
+	OMX_PTR pAuxBuf0 = pBuffer;
+	OMX_TI_PARAM_METADATABUFFERINFO tMetaDataBuffer;
+	MemAllocBlock block;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+	PROXY_require(ppBufferHdr != NULL, OMX_ErrorBadParameter,
+	    "Pointer to buffer header is NULL");
+
+	memset(&block, 0, sizeof(MemAllocBlock));
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nPortIndex = %p, pAppPrivate = %p, nSizeBytes = %d, pBuffer = %p",
+	    hComponent, pCompPrv, nPortIndex, pAppPrivate, nSizeBytes,
+	    pBuffer);
+
+	/*Pick up 1st empty slot */
+	for (i = 0; i < pCompPrv->nTotalBuffers; i++)
+	{
+		if (pCompPrv->tBufList[i].pBufHeader == 0)
+		{
+			currentBuffer = i;
+			bSlotFound = OMX_TRUE;
+			break;
+		}
+	}
+	if (!bSlotFound)
+	{
+		currentBuffer = pCompPrv->nTotalBuffers;
+	}
+	DOMX_DEBUG("In UB, no. of buffers = %d", pCompPrv->nTotalBuffers);
+
+	PROXY_assert((pCompPrv->nTotalBuffers < MAX_NUM_PROXY_BUFFERS),
+	    OMX_ErrorInsufficientResources,
+	    "Proxy cannot handle more than MAX buffers");
+
+	//Allocating Local bufferheader to be maintained locally within proxy
+	pBufferHeader =
+	    (OMX_BUFFERHEADERTYPE *)
+	    TIMM_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE), TIMM_OSAL_TRUE, 0,
+	    TIMMOSAL_MEM_SEGMENT_INT);
+	PROXY_assert((pBufferHeader != NULL), OMX_ErrorInsufficientResources,
+	    "Allocation of Buffer Header structure failed");
+
+	pPlatformPrivate =
+	    (OMX_TI_PLATFORMPRIVATE *)
+	    TIMM_OSAL_Malloc(sizeof(OMX_TI_PLATFORMPRIVATE), TIMM_OSAL_TRUE,
+	    0, TIMMOSAL_MEM_SEGMENT_INT);
+	PROXY_assert(pPlatformPrivate != NULL, OMX_ErrorInsufficientResources,
+	    "Allocation of platform private structure failed");
+	TIMM_OSAL_Memset(pPlatformPrivate, 0, sizeof(OMX_TI_PLATFORMPRIVATE));
+
+	pBufferHeader->pPlatformPrivate = pPlatformPrivate;
+	((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->nSize = sizeof(OMX_TI_PLATFORMPRIVATE);
+
+#ifdef ENABLE_GRALLOC_BUFFERS
+
+	if(pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == GrallocPointers)
+	{
+		//Extracting buffer pointer from the gralloc buffer
+		pAuxBuf0 = (OMX_U8 *)(((IMG_native_handle_t*)pBuffer)->fd[0]);
+	}
+#endif
+
+	DOMX_DEBUG("Preparing buffer to Remote Core...");
+	pBufferHeader->pBuffer = pBuffer;
+	/*To find whether buffer is 2D or 1D */
+	eError =
+	    RPC_UTIL_GetStride(pCompPrv->hRemoteComp, nPortIndex, &nStride);
+	PROXY_assert(eError == OMX_ErrorNone, eError,
+	    "Failed to get stride of component");
+	if (nStride == LINUX_PAGE_SIZE)
+	{
+		// Change this to extract UV pointer from gralloc handle once new gralloc interface is available
+		/*2D buffer, assume NV12 format */
+		eError =
+		    RPC_UTIL_GetNumLines(pCompPrv->hRemoteComp, nPortIndex,
+		    &nNumLines);
+		PROXY_assert(eError == OMX_ErrorNone, eError,
+		    "Failed to get num of lines");
+
+		if(pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == GrallocPointers)
+		{
+			((OMX_TI_PLATFORMPRIVATE *) pBufferHeader->pPlatformPrivate)->
+				pAuxBuf1 = (OMX_U8 *)(((IMG_native_handle_t*)pBuffer)->fd[1]);
+		}
+
+		if(pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == EncoderMetadataPointers)
+		{
+			((OMX_TI_PLATFORMPRIVATE *) pBufferHeader->pPlatformPrivate)->
+				pAuxBuf1 = NULL;
+		}
+	}
+
+	/*Initializing Structure */
+	tMetaDataBuffer.nSize = sizeof(OMX_TI_PARAM_METADATABUFFERINFO);
+	tMetaDataBuffer.nVersion.s.nVersionMajor = OMX_VER_MAJOR;
+	tMetaDataBuffer.nVersion.s.nVersionMinor = OMX_VER_MINOR;
+	tMetaDataBuffer.nVersion.s.nRevision = 0x0;
+	tMetaDataBuffer.nVersion.s.nStep = 0x0;
+	tMetaDataBuffer.nPortIndex = nPortIndex;
+	eError = PROXY_GetParameter(hComponent, (OMX_INDEXTYPE)OMX_TI_IndexParamMetaDataBufferInfo, (OMX_PTR)&tMetaDataBuffer);
+	PROXY_assert(eError == OMX_ErrorNone, eError,
+	    "Get Parameter for Metadata infor failed");
+
+	DOMX_DEBUG("Metadata size = %d",tMetaDataBuffer.nMetaDataSize);
+
+	if(tMetaDataBuffer.bIsMetaDataEnabledOnPort)
+	{
+		block.pixelFormat = PIXEL_FMT_PAGE;
+		block.dim.len = tMetaDataBuffer.nMetaDataSize;
+		((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->
+			pPlatformPrivate)->pMetaDataBuffer = MemMgr_Alloc(&block, 1);
+		PROXY_assert(((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->
+			pPlatformPrivate)->pMetaDataBuffer != NULL,OMX_ErrorInsufficientResources,
+				"MemMngr alloc call for allocating metadata buffers failed");
+		((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->nMetaDataSize = tMetaDataBuffer.nMetaDataSize;
+		DOMX_DEBUG("Metadata buffer = %d",((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->pMetaDataBuffer);
+	}
+
+	eRPCError = RPC_UseBuffer(pCompPrv->hRemoteComp, &pBufferHeader, nPortIndex,
+		pAppPrivate, nSizeBytes, pAuxBuf0, &pBufHeaderRemote, &eCompReturn);
+
+	PROXY_checkRpcError();
+
+	DOMX_DEBUG("Use Buffer Successful");
+	DOMX_DEBUG
+	    ("Value of pBufHeaderRemote: %p LocalBufferHdr :%p, LocalBuffer :%p",
+	    pBufHeaderRemote, pBufferHeader, pBufferHeader->pBuffer);
+
+	//Storing details of pBufferHeader/Mapped/Actual buffer address locally.
+	pCompPrv->tBufList[currentBuffer].pBufHeader = pBufferHeader;
+	pCompPrv->tBufList[currentBuffer].pBufHeaderRemote = pBufHeaderRemote;
+
+	//keeping track of number of Buffers
+	pCompPrv->nAllocatedBuffers++;
+	if (pCompPrv->nTotalBuffers < pCompPrv->nAllocatedBuffers)
+		pCompPrv->nTotalBuffers = pCompPrv->nAllocatedBuffers;
+
+	DOMX_DEBUG("Updating no. of buffer to %d", pCompPrv->nTotalBuffers);
+
+	*ppBufferHdr = pBufferHeader;
+
+      EXIT:
+	if (eError != OMX_ErrorNone)
+	{
+		if (pPlatformPrivate)
+			TIMM_OSAL_Free(pPlatformPrivate);
+		if (pBufferHeader)
+			TIMM_OSAL_Free(pBufferHeader);
+	}
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_FreeBuffer()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_BUFFERHEADERTYPE * pBufferHdr)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone, eTmpRPCError =
+	    RPC_OMX_ErrorNone;
+	OMX_U32 count = 0;
+	OMX_U32 pBuffer = 0;
+	OMX_PTR pMetaDataBuffer = NULL;
+
+	PROXY_require(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter,
+	    NULL);
+	PROXY_CHK_VERSION(pBufferHdr, OMX_BUFFERHEADERTYPE);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nPortIndex = %p, pBufferHdr = %p, pBuffer = %p",
+	    hComponent, pCompPrv, nPortIndex, pBufferHdr,
+	    pBufferHdr->pBuffer);
+
+	for (count = 0; count < pCompPrv->nTotalBuffers; count++)
+	{
+		if (pCompPrv->tBufList[count].pBufHeader == pBufferHdr)
+		{
+			DOMX_DEBUG("Buffer Index of Match %d", count);
+			break;
+		}
+	}
+	PROXY_assert((count != pCompPrv->nTotalBuffers),
+	    OMX_ErrorBadParameter,
+	    "Could not find the mapped address in component private buffer list");
+
+	pBuffer = pBufferHdr->pBuffer;
+	/*Not having asserts from this point since even if error occurs during
+	   unmapping/freeing, still trying to clean up as much as possible */
+
+	eRPCError =
+	    RPC_FreeBuffer(pCompPrv->hRemoteComp, nPortIndex,
+	    pCompPrv->tBufList[count].pBufHeaderRemote, pBuffer,
+	    &eCompReturn);
+
+	if (eRPCError != RPC_OMX_ErrorNone)
+		eTmpRPCError = eRPCError;
+
+	if (pCompPrv->tBufList[count].pBufHeader)
+	{
+#ifdef ALLOCATE_TILER_BUFFER_IN_PROXY
+		if(pCompPrv->tBufList[count].pYBuffer)
+		{
+			MemMgr_Free(pCompPrv->tBufList[count].pYBuffer);
+			pCompPrv->tBufList[count].pYBuffer = NULL;
+		}
+#endif
+		pMetaDataBuffer = ((OMX_TI_PLATFORMPRIVATE *)(pCompPrv->tBufList[count].pBufHeader)->
+			pPlatformPrivate)->pMetaDataBuffer;
+		if (pMetaDataBuffer)
+		{
+			MemMgr_Free(pMetaDataBuffer);
+		}
+		if (pCompPrv->tBufList[count].pBufHeader->pPlatformPrivate)
+		{
+			TIMM_OSAL_Free(pCompPrv->tBufList[count].pBufHeader->
+			    pPlatformPrivate);
+		}
+		TIMM_OSAL_Free(pCompPrv->tBufList[count].pBufHeader);
+		TIMM_OSAL_Memset(&(pCompPrv->tBufList[count]), 0,
+		    sizeof(PROXY_BUFFER_INFO));
+	}
+	pCompPrv->nAllocatedBuffers--;
+
+	PROXY_checkRpcError();
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_SetParameter()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE __PROXY_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+	OMX_IN OMX_INDEXTYPE nParamIndex, OMX_IN OMX_PTR pParamStruct,
+	OMX_PTR pLocBufNeedMap)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+#ifdef ENABLE_GRALLOC_BUFFERS
+	OMX_TI_PARAMUSENATIVEBUFFER *pParamNativeBuffer = NULL;
+#endif
+
+	PROXY_require((pParamStruct != NULL), OMX_ErrorBadParameter, NULL);
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+		("hComponent = %p, pCompPrv = %p, nParamIndex = %d, pParamStruct = %p",
+		hComponent, pCompPrv, nParamIndex, pParamStruct);
+#ifdef ENABLE_GRALLOC_BUFFERS
+	switch(nParamIndex)
+	{
+		case OMX_TI_IndexUseNativeBuffers:
+		{
+			//Add check version.
+			pParamNativeBuffer = (OMX_TI_PARAMUSENATIVEBUFFER* )pParamStruct;
+			if(pParamNativeBuffer->bEnable == OMX_TRUE)
+			{
+				pCompPrv->proxyPortBuffers[pParamNativeBuffer->nPortIndex].proxyBufferType = GrallocPointers;
+				pCompPrv->proxyPortBuffers[pParamNativeBuffer->nPortIndex].IsBuffer2D = OMX_TRUE;
+			}
+			break;
+		}
+		default:
+			eRPCError =
+				RPC_SetParameter(pCompPrv->hRemoteComp, nParamIndex, pParamStruct,
+					pLocBufNeedMap, &eCompReturn);
+	}
+#else
+	eRPCError =
+		RPC_SetParameter(pCompPrv->hRemoteComp, nParamIndex, pParamStruct,
+			pLocBufNeedMap, &eCompReturn);
+#endif
+
+	PROXY_checkRpcError();
+
+ EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_SetParameter()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_IN OMX_PTR pParamStruct)
+{
+	return __PROXY_SetParameter(hComponent, nParamIndex, pParamStruct, NULL);
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name __PROXY_GetParameter()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE __PROXY_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+	OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct,
+	OMX_PTR pLocBufNeedMap)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+
+	PROXY_require((pParamStruct != NULL), OMX_ErrorBadParameter, NULL);
+	PROXY_assert((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nParamIndex = %d, pParamStruct = %p",
+	    hComponent, pCompPrv, nParamIndex, pParamStruct);
+
+	eRPCError =
+		RPC_GetParameter(pCompPrv->hRemoteComp, nParamIndex, pParamStruct,
+			pLocBufNeedMap, &eCompReturn);
+
+	PROXY_checkRpcError();
+
+      EXIT:
+	DOMX_EXIT("eError: %d index: 0x%x", eError, nParamIndex);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_GetParameter()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct)
+{
+	return __PROXY_GetParameter(hComponent, nParamIndex, pParamStruct, NULL);
+}
+
+/* ===========================================================================*/
+/**
+ * @name __PROXY_GetConfig()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE __PROXY_GetConfig(OMX_HANDLETYPE hComponent,
+	OMX_INDEXTYPE nConfigIndex, OMX_PTR pConfigStruct, OMX_PTR pLocBufNeedMap)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+
+	PROXY_require((pConfigStruct != NULL), OMX_ErrorBadParameter, NULL);
+	PROXY_require((hComp->pComponentPrivate != NULL),
+		OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER("hComponent = %p, pCompPrv = %p, nConfigIndex = %d, "
+				"pConfigStruct = %p",
+				hComponent, pCompPrv, nConfigIndex,
+				pConfigStruct);
+
+	eRPCError =
+		RPC_GetConfig(pCompPrv->hRemoteComp, nConfigIndex, pConfigStruct,
+			pLocBufNeedMap, &eCompReturn);
+
+	PROXY_checkRpcError();
+
+ EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_GetConfig()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_GetConfig(OMX_HANDLETYPE hComponent,
+	OMX_INDEXTYPE nConfigIndex, OMX_PTR pConfigStruct)
+{
+	return __PROXY_GetConfig(hComponent, nConfigIndex, pConfigStruct, NULL);
+}
+
+/* ===========================================================================*/
+/**
+ * @name __PROXY_SetConfig()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE __PROXY_SetConfig(OMX_IN OMX_HANDLETYPE hComponent,
+	OMX_IN OMX_INDEXTYPE nConfigIndex, OMX_IN OMX_PTR pConfigStruct,
+	OMX_PTR pLocBufNeedMap)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+
+	PROXY_require((pConfigStruct != NULL), OMX_ErrorBadParameter, NULL);
+
+	PROXY_assert((hComp->pComponentPrivate != NULL),
+		OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER("hComponent = %p, pCompPrv = %p, nConfigIndex = %d, "
+				"pConfigStruct = %p",
+				hComponent, pCompPrv, nConfigIndex,
+				pConfigStruct);
+
+	eRPCError =
+		RPC_SetConfig(pCompPrv->hRemoteComp, nConfigIndex, pConfigStruct,
+			pLocBufNeedMap, &eCompReturn);
+
+	PROXY_checkRpcError();
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_SetConfig()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_SetConfig(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nConfigIndex, OMX_IN OMX_PTR pConfigStruct)
+{
+	return __PROXY_SetConfig(hComponent, nConfigIndex, pConfigStruct, NULL);
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_GetState()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_GetState(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_OUT OMX_STATETYPE * pState)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_COMPONENTTYPE *hComp = hComponent;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+
+	PROXY_require((pState != NULL), OMX_ErrorBadParameter, NULL);
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER("hComponent = %p, pCompPrv = %p", hComponent, pCompPrv);
+
+	eRPCError = RPC_GetState(pCompPrv->hRemoteComp, pState, &eCompReturn);
+
+	DOMX_DEBUG("Returned from RPC_GetState, state: ", *pState);
+
+	PROXY_checkRpcError();
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_SendCommand()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_SendCommand(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_COMMANDTYPE eCmd,
+    OMX_IN OMX_U32 nParam, OMX_IN OMX_PTR pCmdData)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_COMPONENTTYPE *pMarkComp = NULL;
+	PROXY_COMPONENT_PRIVATE *pMarkCompPrv = NULL;
+	OMX_PTR pMarkData = NULL, pMarkToBeFreedIfError = NULL;
+	OMX_BOOL bIsProxy = OMX_FALSE;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, eCmd = %d, nParam = %d, pCmdData = %p",
+	    hComponent, pCompPrv, eCmd, nParam, pCmdData);
+
+	if (eCmd == OMX_CommandMarkBuffer)
+	{
+		PROXY_require(pCmdData != NULL, OMX_ErrorBadParameter, NULL);
+		pMarkComp = (OMX_COMPONENTTYPE *)
+		    (((OMX_MARKTYPE *) pCmdData)->hMarkTargetComponent);
+		PROXY_require(pMarkComp != NULL, OMX_ErrorBadParameter, NULL);
+
+		/* To check if mark comp is a proxy or a real component */
+		eError = _RPC_IsProxyComponent(pMarkComp, &bIsProxy);
+		PROXY_assert(eError == OMX_ErrorNone, eError, "");
+
+		/*Replacing original mark data with proxy specific structure */
+		pMarkData = ((OMX_MARKTYPE *) pCmdData)->pMarkData;
+		((OMX_MARKTYPE *) pCmdData)->pMarkData =
+		    TIMM_OSAL_Malloc(sizeof(PROXY_MARK_DATA), TIMM_OSAL_TRUE,
+		    0, TIMMOSAL_MEM_SEGMENT_INT);
+		PROXY_assert(((OMX_MARKTYPE *) pCmdData)->pMarkData != NULL,
+		    OMX_ErrorInsufficientResources, "Malloc failed");
+		pMarkToBeFreedIfError =
+		    ((OMX_MARKTYPE *) pCmdData)->pMarkData;
+		((PROXY_MARK_DATA *) (((OMX_MARKTYPE *)
+			    pCmdData)->pMarkData))->hComponentActual =
+		    pMarkComp;
+		((PROXY_MARK_DATA *) (((OMX_MARKTYPE *)
+			    pCmdData)->pMarkData))->pMarkDataActual =
+		    pMarkData;
+
+		/* If it is proxy component then replace hMarkTargetComponent
+		   with remote handle */
+		if (bIsProxy)
+		{
+			pMarkCompPrv = pMarkComp->pComponentPrivate;
+			PROXY_assert(pMarkCompPrv != NULL,
+			    OMX_ErrorBadParameter, NULL);
+
+			/* Replacing with remote component handle */
+			((OMX_MARKTYPE *) pCmdData)->hMarkTargetComponent =
+			    ((RPC_OMX_CONTEXT *) pMarkCompPrv->hRemoteComp)->
+			    hActualRemoteCompHandle;
+		}
+	}
+
+	eRPCError =
+	    RPC_SendCommand(pCompPrv->hRemoteComp, eCmd, nParam, pCmdData,
+	    &eCompReturn);
+
+	if (eCmd == OMX_CommandMarkBuffer && bIsProxy)
+	{
+		/*Resetting to original values */
+		((OMX_MARKTYPE *) pCmdData)->hMarkTargetComponent = pMarkComp;
+		((OMX_MARKTYPE *) pCmdData)->pMarkData = pMarkData;
+	}
+
+	PROXY_checkRpcError();
+
+      EXIT:
+	/*If SendCommand is about to return an error then this means that the
+	   command has not been accepted by the component. Thus the allocated mark data
+	   will be lost so free it here */
+	if ((eError != OMX_ErrorNone) && pMarkToBeFreedIfError)
+	{
+		TIMM_OSAL_Free(pMarkToBeFreedIfError);
+	}
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_GetComponentVersion()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_GetComponentVersion(OMX_IN OMX_HANDLETYPE
+    hComponent, OMX_OUT OMX_STRING pComponentName,
+    OMX_OUT OMX_VERSIONTYPE * pComponentVersion,
+    OMX_OUT OMX_VERSIONTYPE * pSpecVersion,
+    OMX_OUT OMX_UUIDTYPE * pComponentUUID)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = hComponent;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+
+	DOMX_ENTER("hComponent = %p, pCompPrv = %p", hComponent, pCompPrv);
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+	PROXY_require(pComponentName != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(pComponentVersion != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(pSpecVersion != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(pComponentUUID != NULL, OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	eRPCError = RPC_GetComponentVersion(pCompPrv->hRemoteComp,
+	    pComponentName,
+	    pComponentVersion, pSpecVersion, pComponentUUID, &eCompReturn);
+
+	PROXY_checkRpcError();
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_GetExtensionIndex()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_STRING cParameterName, OMX_OUT OMX_INDEXTYPE * pIndexType)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = hComponent;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+	PROXY_require(cParameterName != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(pIndexType != NULL, OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER("hComponent = %p, pCompPrv = %p, cParameterName = %s",
+	    hComponent, pCompPrv, cParameterName);
+
+
+#ifdef ENABLE_GRALLOC_BUFFERS
+	// Check for NULL Parameters
+	PROXY_require((cParameterName != NULL && pIndexType != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	// Ensure that String length is not greater than Max allowed length
+	PROXY_require(strlen(cParameterName) <= 127, OMX_ErrorBadParameter, NULL);
+
+	if(strcmp(cParameterName, "OMX.google.android.index.enableAndroidNativeBuffers") == 0)
+	{
+		// If Index type is 2D Buffer Allocated Dimension
+		*pIndexType = (OMX_INDEXTYPE) OMX_TI_IndexUseNativeBuffers;
+		goto EXIT;
+	}
+	else if (strcmp(cParameterName, "OMX.google.android.index.useAndroidNativeBuffer2") == 0)
+	{
+		//This is call just a dummy for android to support backward compatibility
+		*pIndexType = (OMX_INDEXTYPE) NULL;
+		goto EXIT;
+	}
+	else
+	{
+		eRPCError = RPC_GetExtensionIndex(pCompPrv->hRemoteComp,
+                   cParameterName, pIndexType, &eCompReturn);
+
+		PROXY_checkRpcError();
+	}
+#else
+	eRPCError = RPC_GetExtensionIndex(pCompPrv->hRemoteComp,
+	    cParameterName, pIndexType, &eCompReturn);
+
+	PROXY_checkRpcError();
+#endif
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_ComponentRoleEnum()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_ComponentRoleEnum(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_OUT OMX_U8 * cRole, OMX_IN OMX_U32 nIndex)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+	DOMX_ENTER("hComponent = %p", hComponent);
+	DOMX_DEBUG(" EMPTY IMPLEMENTATION ");
+
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_ComponentTunnelRequest()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE
+    hComponent, OMX_IN OMX_U32 nPort, OMX_IN OMX_HANDLETYPE hTunneledComp,
+    OMX_IN OMX_U32 nTunneledPort,
+    OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+	DOMX_ENTER("hComponent = %p", hComponent);
+	DOMX_DEBUG(" EMPTY IMPLEMENTATION ");
+
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_SetCallbacks()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_SetCallbacks(OMX_HANDLETYPE hComponent,
+    OMX_CALLBACKTYPE * pCallBacks, OMX_PTR pAppData)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+
+	PROXY_require((pCallBacks != NULL), OMX_ErrorBadParameter, NULL);
+
+	PROXY_assert((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER("hComponent = %p, pCompPrv = %p", hComponent, pCompPrv);
+
+	/*Store App callback and data to proxy- managed by proxy */
+	pCompPrv->tCBFunc = *pCallBacks;
+	pCompPrv->pILAppData = pAppData;
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_UseEGLImage()
+ * @brief : This returns error not implemented by default as no component
+ *          implements this. In case there is a requiremet, support for this
+ *          can be added later.
+ *
+ */
+/* ===========================================================================*/
+static OMX_ERRORTYPE PROXY_UseEGLImage(OMX_HANDLETYPE hComponent,
+    OMX_BUFFERHEADERTYPE ** ppBufferHdr,
+    OMX_U32 nPortIndex, OMX_PTR pAppPrivate, void *pBuffer)
+{
+	return OMX_ErrorNotImplemented;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_ComponentDeInit()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_ComponentDeInit(OMX_HANDLETYPE hComponent)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone, eTmpRPCError =
+	    RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_U32 count = 0;
+
+	DOMX_ENTER("hComponent = %p", hComponent);
+
+	PROXY_assert((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	for (count = 0; count < pCompPrv->nTotalBuffers; count++)
+	{
+		if (pCompPrv->tBufList[count].pBufHeader)
+		{
+#ifdef ALLOCATE_TILER_BUFFER_IN_PROXY
+			if(pCompPrv->tBufList[count].pYBuffer)
+			{
+				MemMgr_Free(pCompPrv->tBufList[count].pYBuffer);
+			}
+#endif
+			if (pCompPrv->tBufList[count].pBufHeader->pPlatformPrivate)
+			{
+				TIMM_OSAL_Free(pCompPrv->tBufList[count].pBufHeader->
+				    pPlatformPrivate);
+			}
+			TIMM_OSAL_Free(pCompPrv->tBufList[count].pBufHeader);
+			TIMM_OSAL_Memset(&(pCompPrv->tBufList[count]), 0,
+			    sizeof(PROXY_BUFFER_INFO));
+		}
+	}
+
+	eRPCError = RPC_FreeHandle(pCompPrv->hRemoteComp, &eCompReturn);
+	if (eRPCError != RPC_OMX_ErrorNone)
+		eTmpRPCError = eRPCError;
+
+	eRPCError = RPC_InstanceDeInit(pCompPrv->hRemoteComp);
+	if (eRPCError != RPC_OMX_ErrorNone)
+		eTmpRPCError = eRPCError;
+
+	if (pCompPrv->cCompName)
+	{
+		TIMM_OSAL_Free(pCompPrv->cCompName);
+	}
+
+	if (pCompPrv)
+	{
+		TIMM_OSAL_Free(pCompPrv);
+	}
+
+	eRPCError = eTmpRPCError;
+	PROXY_checkRpcError();
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name OMX_ProxyCommonInit()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE OMX_ProxyCommonInit(OMX_HANDLETYPE hComponent)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_HANDLETYPE hRemoteComp = NULL;
+        OMX_U32 i = 0;
+
+	DOMX_ENTER("hComponent = %p", hComponent);
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	pCompPrv->nTotalBuffers = 0;
+	pCompPrv->nAllocatedBuffers = 0;
+	pCompPrv->proxyEmptyBufferDone = PROXY_EmptyBufferDone;
+	pCompPrv->proxyFillBufferDone = PROXY_FillBufferDone;
+	pCompPrv->proxyEventHandler = PROXY_EventHandler;
+
+        for (i=0; i<PROXY_MAXNUMOFPORTS ; i++)
+        {
+              pCompPrv->proxyPortBuffers[i].proxyBufferType = VirtualPointers;
+        }
+
+	eRPCError = RPC_InstanceInit(pCompPrv->cCompName, &hRemoteComp);
+	PROXY_assert(eRPCError == RPC_OMX_ErrorNone,
+	    OMX_ErrorUndefined, "Error initializing RPC");
+	PROXY_assert(hRemoteComp != NULL,
+	    OMX_ErrorUndefined, "Error initializing RPC");
+
+	//Send the proxy component handle for pAppData
+	eRPCError =
+	    RPC_GetHandle(hRemoteComp, pCompPrv->cCompName,
+	    (OMX_PTR) hComponent, NULL, &eCompReturn);
+
+	PROXY_checkRpcError();
+
+	hComp->SetCallbacks = PROXY_SetCallbacks;
+	hComp->ComponentDeInit = PROXY_ComponentDeInit;
+	hComp->UseBuffer = PROXY_UseBuffer;
+	hComp->GetParameter = PROXY_GetParameter;
+	hComp->SetParameter = PROXY_SetParameter;
+	hComp->EmptyThisBuffer = PROXY_EmptyThisBuffer;
+	hComp->FillThisBuffer = PROXY_FillThisBuffer;
+	hComp->GetComponentVersion = PROXY_GetComponentVersion;
+	hComp->SendCommand = PROXY_SendCommand;
+	hComp->GetConfig = PROXY_GetConfig;
+	hComp->SetConfig = PROXY_SetConfig;
+	hComp->GetState = PROXY_GetState;
+	hComp->GetExtensionIndex = PROXY_GetExtensionIndex;
+	hComp->FreeBuffer = PROXY_FreeBuffer;
+	hComp->ComponentRoleEnum = PROXY_ComponentRoleEnum;
+	hComp->AllocateBuffer = PROXY_AllocateBuffer;
+	hComp->ComponentTunnelRequest = PROXY_ComponentTunnelRequest;
+	hComp->UseEGLImage = PROXY_UseEGLImage;
+
+	pCompPrv->hRemoteComp = hRemoteComp;
+
+
+      EXIT:
+	if (eError != OMX_ErrorNone)
+		RPC_InstanceDeInit(hRemoteComp);
+	DOMX_EXIT("eError: %d", eError);
+
+	return eError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_UTIL_GetStride()
+ * @brief Gets stride on this port. Used to determine whether buffer is 1D or 2D
+ * @param hRemoteComp [IN]  : Remote component handle.
+ * @param nPortIndex [IN]   : Port index.
+ * @param nStride [OUT]     : Stride returned by the component.
+ * @return OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE RPC_UTIL_GetStride(OMX_COMPONENTTYPE * hRemoteComp,
+    OMX_U32 nPortIndex, OMX_U32 * nStride)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_PARAM_PORTDEFINITIONTYPE sPortDef = { 0 };
+
+	/*Initializing Structure */
+	sPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
+	sPortDef.nVersion.s.nVersionMajor = OMX_VER_MAJOR;
+	sPortDef.nVersion.s.nVersionMinor = OMX_VER_MINOR;
+	sPortDef.nVersion.s.nRevision = 0x0;
+	sPortDef.nVersion.s.nStep = 0x0;
+	sPortDef.nPortIndex = nPortIndex;
+
+	eRPCError =
+	    RPC_GetParameter(hRemoteComp, OMX_IndexParamPortDefinition,
+	    (OMX_PTR) (&sPortDef), NULL, &eCompReturn);
+	PROXY_checkRpcError();
+
+	if (sPortDef.eDomain == OMX_PortDomainVideo)
+	{
+		*nStride = sPortDef.format.video.nStride;
+	} else if (sPortDef.eDomain == OMX_PortDomainImage)
+	{
+		*nStride = sPortDef.format.image.nStride;
+	} else if (sPortDef.eDomain == OMX_PortDomainMax && nPortIndex == 0)
+	{
+		/*Temp - just for testing sample */
+		*nStride = LINUX_PAGE_SIZE;
+	} else
+	{
+		*nStride = 0;
+	}
+
+      EXIT:
+	return eError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_UTIL_GetNumLines()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE RPC_UTIL_GetNumLines(OMX_COMPONENTTYPE * hRemoteComp,
+    OMX_U32 nPortIndex, OMX_U32 * nNumOfLines)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_ERRORTYPE eCompReturn;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_BOOL bUseEnhancedPortReconfig = OMX_FALSE;
+
+	OMX_PARAM_PORTDEFINITIONTYPE portDef;
+	OMX_CONFIG_RECTTYPE sRect;
+
+	DOMX_ENTER("");
+
+	/*initializing Structure */
+	portDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
+	portDef.nVersion.s.nVersionMajor = 0x1;
+	portDef.nVersion.s.nVersionMinor = 0x1;
+	portDef.nVersion.s.nRevision = 0x0;
+	portDef.nVersion.s.nStep = 0x0;
+
+	portDef.nPortIndex = nPortIndex;
+
+	sRect.nSize = sizeof(OMX_CONFIG_RECTTYPE);
+	sRect.nVersion.s.nVersionMajor = 0x1;
+	sRect.nVersion.s.nVersionMinor = 0x1;
+	sRect.nVersion.s.nRevision = 0x0;
+	sRect.nVersion.s.nStep = 0x0;
+
+	sRect.nPortIndex = nPortIndex;
+	sRect.nLeft = 0;
+	sRect.nTop = 0;
+	sRect.nHeight = 0;
+	sRect.nWidth = 0;
+
+#ifdef USE_ENHANCED_PORTRECONFIG
+	bUseEnhancedPortReconfig = OMX_TRUE;
+#endif
+	eRPCError = RPC_GetParameter(hRemoteComp,
+	    OMX_TI_IndexParam2DBufferAllocDimension,
+	    (OMX_PTR) & sRect, NULL, &eCompReturn);
+	if (eRPCError == RPC_OMX_ErrorNone)
+	{
+		DOMX_DEBUG(" PROXY_UTIL Get Parameter Successful");
+		eError = eCompReturn;
+	} else
+	{
+		DOMX_ERROR("RPC_GetParameter returned error 0x%x", eRPCError);
+		eError = OMX_ErrorUndefined;
+		goto EXIT;
+	}
+
+	if (eCompReturn == OMX_ErrorNone && bUseEnhancedPortReconfig == OMX_FALSE)
+	{
+		*nNumOfLines = sRect.nHeight;
+	} else if (eCompReturn == OMX_ErrorUnsupportedIndex || bUseEnhancedPortReconfig == OMX_TRUE)
+	{
+		eRPCError =
+		    RPC_GetParameter(hRemoteComp,
+		    OMX_IndexParamPortDefinition, (OMX_PTR) & portDef,
+		    NULL, &eCompReturn);
+
+		if (eRPCError == RPC_OMX_ErrorNone)
+		{
+			DOMX_DEBUG(" PROXY_UTIL Get Parameter Successful");
+			eError = eCompReturn;
+		} else
+		{
+			DOMX_ERROR("RPC_GetParameter returned error 0x%x",
+			    eRPCError);
+			eError = OMX_ErrorUndefined;
+			goto EXIT;
+		}
+
+		if (eCompReturn == OMX_ErrorNone)
+		{
+
+			//start with 1 meaning 1D buffer
+			*nNumOfLines = 1;
+
+			if (portDef.eDomain == OMX_PortDomainVideo)
+			{
+				*nNumOfLines =
+				    portDef.format.video.nFrameHeight;
+				//DOMX_DEBUG("Port definition Type is video...");
+				//DOMX_DEBUG("&&Colorformat is:%p", portDef.format.video.eColorFormat);
+				//DOMX_DEBUG("nFrameHeight is:%d", portDef.format.video.nFrameHeight);
+				//*nNumOfLines = portDef.format.video.nFrameHeight;
+
+				//if((portDef.format.video.eColorFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar) ||
+				//  (portDef.format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar))
+				//{
+				//DOMX_DEBUG("Setting FrameHeight as Number of lines...");
+				//*nNumOfLines = portDef.format.video.nFrameHeight;
+				//}
+			} else if (portDef.eDomain == OMX_PortDomainImage)
+			{
+				DOMX_DEBUG
+				    ("Image DOMAIN TILER SUPPORT for NV12 format only");
+				*nNumOfLines =
+				    portDef.format.image.nFrameHeight;
+			} else if (portDef.eDomain == OMX_PortDomainAudio)
+			{
+				DOMX_DEBUG("Audio DOMAIN TILER SUPPORT");
+			} else if (portDef.eDomain == OMX_PortDomainOther)
+			{
+				DOMX_DEBUG("Other DOMAIN TILER SUPPORT");
+			} else
+			{	//this is the sample component test
+				//Temporary - just to get check functionality
+				DOMX_DEBUG("Sample component TILER SUPPORT");
+				*nNumOfLines = 4;
+			}
+		} else
+		{
+			DOMX_ERROR(" ERROR IN RECOVERING UV POINTER");
+		}
+	} else
+	{
+		DOMX_ERROR(" ERROR IN RECOVERING UV POINTER");
+	}
+
+	DOMX_DEBUG("Port Number: %d :: NumOfLines %d", nPortIndex,
+	    *nNumOfLines);
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+
+#if 0
+
+OMX_ERRORTYPE RPC_PrepareBuffer_Chiron(PROXY_COMPONENT_PRIVATE * pCompPrv,
+    OMX_COMPONENTTYPE * hRemoteComp, OMX_U32 nPortIndex, OMX_U32 nSizeBytes,
+    OMX_BUFFERHEADERTYPE * pDucBuf, OMX_BUFFERHEADERTYPE * pChironBuf)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_U32 nNumOfLines = 1;
+	OMX_U8 *pBuffer;
+
+	DSPtr dsptr[2];
+	bytes_t lengths[2];
+	OMX_U32 i = 0;
+	OMX_U32 numBlocks = 0;
+
+	pBuffer = pDucBuf->pBuffer;
+
+	DOMX_ENTER("");
+
+	if (((OMX_TI_PLATFORMPRIVATE *) pDucBuf->pPlatformPrivate)->
+	    pAuxBuf1 == NULL)
+	{
+		DOMX_DEBUG("One component buffer");
+
+		if (!(pCompPrv->nNumOfLines[nPortIndex]))
+		{
+			pCompPrv->nNumOfLines[nPortIndex] = 1;
+		}
+
+		dsptr[0] = (OMX_U32) pBuffer;
+		numBlocks = 1;
+		lengths[0] =
+		    LINUX_PAGE_SIZE * ((nSizeBytes + (LINUX_PAGE_SIZE -
+			    1)) / LINUX_PAGE_SIZE);
+	} else
+	{
+		DOMX_DEBUG("Two component buffers");
+		dsptr[0] = (OMX_U32) pBuffer;
+		dsptr[1] =
+		    (OMX_U32) (((OMX_TI_PLATFORMPRIVATE *)
+			pDucBuf->pPlatformPrivate)->pAuxBuf1);
+
+		if (!(pCompPrv->nNumOfLines[nPortIndex]))
+		{
+			eError =
+			    RPC_UTIL_GetNumLines(hRemoteComp, nPortIndex,
+			    &nNumOfLines);
+			PROXY_assert((eError == OMX_ErrorNone),
+			    OMX_ErrorUndefined,
+			    "ERROR WHILE GETTING FRAME HEIGHT");
+
+			pCompPrv->nNumOfLines[nPortIndex] = nNumOfLines;
+		} else
+		{
+			nNumOfLines = pCompPrv->nNumOfLines[nPortIndex];
+		}
+
+		lengths[0] = nNumOfLines * LINUX_PAGE_SIZE;
+		lengths[1] = nNumOfLines / 2 * LINUX_PAGE_SIZE;
+		numBlocks = 2;
+	}
+
+	//Map back to chiron
+	DOMX_DEBUG("NumBlocks = %d", numBlocks);
+	for (i = 0; i < numBlocks; i++)
+	{
+		DOMX_DEBUG("dsptr[%d] = %p", i, dsptr[i]);
+		DOMX_DEBUG("length[%d] = %d", i, lengths[i]);
+	}
+
+	pDucBuf->pBuffer =
+	    tiler_assisted_phase1_D2CReMap(numBlocks, dsptr, lengths);
+	PROXY_assert((pDucBuf->pBuffer != NULL), OMX_ErrorUndefined,
+	    "Mapping to Chiron failed");
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+//Takes chiron buffer buffer header and updates with ducati buffer ptr and UV ptr
+OMX_ERRORTYPE RPC_PrepareBuffer_Remote(PROXY_COMPONENT_PRIVATE * pCompPrv,
+    OMX_COMPONENTTYPE * hRemoteComp, OMX_U32 nPortIndex,
+    OMX_U32 nSizeBytes, OMX_BUFFERHEADERTYPE * pChironBuf,
+    OMX_BUFFERHEADERTYPE * pDucBuf, OMX_PTR pBufToBeMapped)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_U32 nNumOfLines = 1;
+	OMX_U8 *pBuffer;
+
+	DOMX_ENTER("");
+
+	pBuffer = pChironBuf->pBuffer;
+
+	if (!MemMgr_Is2DBlock(pBuffer))
+	{
+
+		if (!(pCompPrv->nNumOfLines[nPortIndex]))
+		{
+			pCompPrv->nNumOfLines[nPortIndex] = 1;
+		}
+
+		pChironBuf->pBuffer = NULL;
+		eError =
+		    RPC_MapBuffer_Ducati(pBuffer, nSizeBytes, nNumOfLines,
+		    &(pChironBuf->pBuffer), pBufToBeMapped);
+		PROXY_assert(eError == OMX_ErrorNone, eError, "Map failed");
+	} else
+	{
+		if (!(pCompPrv->nNumOfLines[nPortIndex]))
+		{
+			eError =
+			    RPC_UTIL_GetNumLines(hRemoteComp, nPortIndex,
+			    &nNumOfLines);
+			PROXY_assert((eError == OMX_ErrorNone), eError,
+			    "ERROR WHILE GETTING FRAME HEIGHT");
+
+			pCompPrv->nNumOfLines[nPortIndex] = nNumOfLines;
+		} else
+		{
+			nNumOfLines = pCompPrv->nNumOfLines[nPortIndex];
+		}
+
+		pChironBuf->pBuffer = NULL;
+		((OMX_TI_PLATFORMPRIVATE *) (pChironBuf->pPlatformPrivate))->
+		    pAuxBuf1 = NULL;
+
+		eError =
+		    RPC_MapBuffer_Ducati(pBuffer, LINUX_PAGE_SIZE,
+		    nNumOfLines, &(pChironBuf->pBuffer), pBufToBeMapped);
+		PROXY_assert(eError == OMX_ErrorNone, eError, "Map failed");
+		eError =
+		    RPC_MapBuffer_Ducati((OMX_U8 *) ((OMX_U32) pBuffer +
+			nNumOfLines * LINUX_PAGE_SIZE), LINUX_PAGE_SIZE,
+		    nNumOfLines / 2,
+		    (OMX_U8 **) (&((OMX_TI_PLATFORMPRIVATE
+				*) (pChironBuf->pPlatformPrivate))->pAuxBuf1),
+		    pBufToBeMapped);
+		PROXY_assert(eError == OMX_ErrorNone, eError, "Map failed");
+		*(OMX_U32 *) pBufToBeMapped = (OMX_U32) pBuffer;
+	}
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_MapBuffer_Ducati()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE RPC_MapBuffer_Ducati(OMX_U8 * pBuf, OMX_U32 nBufLineSize,
+    OMX_U32 nBufLines, OMX_U8 ** pMappedBuf, OMX_PTR pBufToBeMapped)
+{
+	ProcMgr_MapType mapType;
+	SyslinkMemUtils_MpuAddrToMap MpuAddr_list_1D = { 0 };
+	MemAllocBlock block = { 0 };
+	OMX_S32 status;
+	OMX_U32 nDiff = 0;
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+	DOMX_ENTER("");
+
+	*(OMX_U32 *) pBufToBeMapped = (OMX_U32) pBuf;
+
+	if (!MemMgr_IsMapped(pBuf) && (nBufLines == 1))
+	{
+		DOMX_DEBUG
+		    ("Buffer is not mapped: Mapping as 1D buffer now..");
+		block.pixelFormat = PIXEL_FMT_PAGE;
+		block.ptr = (OMX_PTR) (((OMX_U32) pBuf / LINUX_PAGE_SIZE) *
+		    LINUX_PAGE_SIZE);
+		block.dim.len = (OMX_U32) ((((OMX_U32) pBuf + nBufLineSize +
+			    LINUX_PAGE_SIZE - 1) / LINUX_PAGE_SIZE) *
+		    LINUX_PAGE_SIZE) - (OMX_U32) block.ptr;
+		block.stride = 0;
+		nDiff = (OMX_U32) pBuf - (OMX_U32) block.ptr;
+
+		(*(OMX_U32 *) (pBufToBeMapped)) =
+		    (OMX_U32) (MemMgr_Map(&block, 1));
+		PROXY_assert(*(OMX_U32 *) pBufToBeMapped != 0,
+		    OMX_ErrorInsufficientResources,
+		    "Map to TILER space failed");
+		//*pMappedBuf = MemMgr_Map(&block, 1);
+	}
+
+	if (MemMgr_IsMapped((OMX_PTR) (*(OMX_U32 *) pBufToBeMapped)))
+	{
+		//If Tiler 1D buffer, get corresponding ducati address and send out buffer to ducati
+		//For 2D buffers, in phase1, retrive the ducati address (SSPtrs) for Y and UV buffers
+		//and send out buffer to ducati
+		mapType = ProcMgr_MapType_Tiler;
+		MpuAddr_list_1D.mpuAddr =
+		    (*(OMX_U32 *) pBufToBeMapped) + nDiff;
+		MpuAddr_list_1D.size = nBufLineSize * nBufLines;
+
+		status =
+		    SysLinkMemUtils_map(&MpuAddr_list_1D, 1,
+		    (UInt32 *) pMappedBuf, mapType, PROC_APPM3);
+		PROXY_assert(status >= 0, OMX_ErrorInsufficientResources,
+		    "Syslink map failed");
+	}
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_UnMapBuffer_Ducati()
+ * @brief
+ * @param
+ * @return
+ * @sa
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE RPC_UnMapBuffer_Ducati(OMX_PTR pBuffer)
+{
+	OMX_U32 status = 0;
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+	DOMX_ENTER("");
+
+	status = MemMgr_UnMap(pBuffer);
+	PROXY_assert(status == 0, OMX_ErrorUndefined,
+	    "MemMgr_UnMap returned an error");
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name RPC_MapMetaData_Host()
+ * @brief This utility maps metadata buffer in OMX buffer header to Chiron
+ * virtual address space (metadata buffer is TILER 1D buffer in Ducati Virtual
+ * space). It overrides the metadata buffer with Chiron address in the same
+ * field. Metadata buffer size represents max size (alloc size) that needs to
+ * be mapped
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE RPC_MapMetaData_Host(OMX_BUFFERHEADERTYPE * pBufHdr)
+{
+	OMX_PTR pMappedMetaDataBuffer = NULL;
+	OMX_U32 nMetaDataSize = 0;
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+	DSPtr dsptr[2];
+	bytes_t lengths[2];
+	OMX_U32 numBlocks = 0;
+
+	DOMX_ENTER("");
+
+	if ((pBufHdr->pPlatformPrivate != NULL) &&
+	    (((OMX_TI_PLATFORMPRIVATE *) pBufHdr->pPlatformPrivate)->
+		pMetaDataBuffer != NULL))
+	{
+
+		pMappedMetaDataBuffer = NULL;
+
+		nMetaDataSize =
+		    ((OMX_TI_PLATFORMPRIVATE *) pBufHdr->pPlatformPrivate)->
+		    nMetaDataSize;
+		PROXY_assert((nMetaDataSize != 0), OMX_ErrorBadParameter,
+		    "Received ZERO metadata size from Ducati, cannot map");
+
+		dsptr[0] =
+		    (OMX_U32) ((OMX_TI_PLATFORMPRIVATE *)
+		    pBufHdr->pPlatformPrivate)->pMetaDataBuffer;
+		numBlocks = 1;
+		lengths[0] =
+		    LINUX_PAGE_SIZE * ((nMetaDataSize + (LINUX_PAGE_SIZE -
+			    1)) / LINUX_PAGE_SIZE);
+
+		pMappedMetaDataBuffer =
+		    tiler_assisted_phase1_D2CReMap(numBlocks, dsptr, lengths);
+
+		PROXY_assert((pMappedMetaDataBuffer != NULL),
+		    OMX_ErrorInsufficientResources,
+		    "Mapping metadata to Chiron space failed");
+
+		((OMX_TI_PLATFORMPRIVATE *) pBufHdr->pPlatformPrivate)->
+		    pMetaDataBuffer = pMappedMetaDataBuffer;
+	}
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name RPC_UnMapMetaData_Host()
+ * @brief This utility unmaps the previously mapped metadata on host from remote
+ * components
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE RPC_UnMapMetaData_Host(OMX_BUFFERHEADERTYPE * pBufHdr)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_S32 nReturn = 0;
+
+	DOMX_ENTER("");
+
+	if ((pBufHdr->pPlatformPrivate != NULL) &&
+	    (((OMX_TI_PLATFORMPRIVATE *) pBufHdr->pPlatformPrivate)->
+		pMetaDataBuffer != NULL))
+	{
+
+		nReturn =
+		    tiler_assisted_phase1_DeMap((((OMX_TI_PLATFORMPRIVATE *)
+			    pBufHdr->pPlatformPrivate)->pMetaDataBuffer));
+		PROXY_assert((nReturn == 0), OMX_ErrorUndefined,
+		    "Metadata unmap failed");
+	}
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+#endif
+
+/* ===========================================================================*/
+/**
+ * @name _RPC_IsProxyComponent()
+ * @brief This function calls GetComponentVersion API on the component and
+ *        based on the component name decidec whether the component is a proxy
+ *        or real component. The naming component convention assumed is
+ *        <OMX>.<Company Name>.<Core Name>.<Domain>.<Component Details> with
+ *        all characters in upper case for e.g. OMX.TI.DUCATI1.VIDEO.H264E
+ * @param hComponent [IN] : The component handle
+ *        bIsProxy [OUT]  : Set to true is handle is for a proxy component
+ * @return OMX_ErrorNone = Successful
+ *
+ **/
+/* ===========================================================================*/
+OMX_ERRORTYPE _RPC_IsProxyComponent(OMX_HANDLETYPE hComponent,
+    OMX_BOOL * bIsProxy)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_S8 cComponentName[MAXNAMESIZE] = { 0 }
+	, cCoreName[32] =
+	{
+	0};
+	OMX_VERSIONTYPE sCompVer, sSpecVer;
+	OMX_UUIDTYPE sCompUUID;
+	OMX_U32 i = 0, ret = 0;
+
+	eError =
+	    OMX_GetComponentVersion(hComponent, (OMX_STRING) cComponentName,
+	    &sCompVer, &sSpecVer, &sCompUUID);
+	PROXY_assert(eError == OMX_ErrorNone, eError, "");
+	ret =
+	    sscanf((char *)cComponentName, "%*[^'.'].%*[^'.'].%[^'.'].%*s",
+	    cCoreName);
+	PROXY_assert(ret == 1, OMX_ErrorBadParameter,
+	    "Incorrect component name");
+	for (i = 0; i < CORE_MAX; i++)
+	{
+		if (strcmp((char *)cCoreName, Core_Array[i]) == 0)
+			break;
+	}
+	PROXY_assert(i < CORE_MAX, OMX_ErrorBadParameter,
+	    "Unknown core name");
+
+	/* If component name indicates remote core, it means proxy
+	   component */
+	if ((i == CORE_SYSM3) || (i == CORE_APPM3) || (i == CORE_TESLA))
+		*bIsProxy = OMX_TRUE;
+	else
+		*bIsProxy = OMX_FALSE;
+
+      EXIT:
+	return eError;
+}
diff --git a/domx/domx/omx_rpc.h b/domx/domx/omx_rpc.h
new file mode 100755
index 0000000..84c00d0
--- /dev/null
+++ b/domx/domx/omx_rpc.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc.h
+ *  @brief This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+#ifndef OMXRPC_H
+#define OMXRPC_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <stdio.h>
+#include <OMX_Types.h>
+#include <OMX_Core.h>
+
+
+/******************************************************************
+ *   DATA TYPES
+ ******************************************************************/
+
+
+ /*******************************************************************************
+* Enumerated Types
+*******************************************************************************/
+	typedef enum RPC_OMX_ERRORTYPE
+	{
+		RPC_OMX_ErrorNone = 0,
+
+		/* OMX Error Mapped */
+		RPC_OMX_ErrorInsufficientResources = 0x81000,
+		RPC_OMX_ErrorUndefined = 0x81001,
+		RPC_OMX_ErrorBadParameter = 0x81005,
+		RPC_OMX_ErrorHardware = 0x81009,
+		RPC_OMX_ErrorUnsupportedIndex = 0x8101A,
+		RPC_OMX_ErrorTimeout = 0x81011,
+		/* END OF OMX Error */
+
+		/* RPC Specific Error - to depricate */
+		RPC_OMX_ErrorUnknown = 0x70000,
+		RPC_OMX_ErrorProccesorInit = 0x70001,
+		RPC_OMX_InvalidRPCCmd = 0x70002,
+		RPC_OMX_ErrorHLOS = 0x70003,
+		RPC_OMX_ErrorInvalidMsg = 0x70004,
+
+		/* RCM Specific */
+		RPC_OMX_RCM_ErrorExecFail = 0x70005,
+		RPC_OMX_RCM_ErrorExecDpcFail = 0x70006,
+		RPC_OMX_RCM_ErrorTimeout = 0x70007,
+		RPC_OMX_RCM_ServerFail = 0x70008,
+		RPC_OMX_RCM_ClientFail = 0x70009,
+
+	} RPC_OMX_ERRORTYPE;
+
+
+/****************************************************************
+ * PUBLIC DECLARATIONS Defined here, used elsewhere
+
+****************************************************************/
+/* ===========================================================================*/
+/**
+ * @name RPC_InstanceInit()
+ * @brief RPC instance init is used to bring up a instance of a client - this should be ideally invokable from any core
+ *        For this the parameters it would require are
+ *        Heap ID - this needs to be configured at startup (CFG) and indicates the heaps available for a RCM client to pick from
+ *        Server - this contains the RCM server name that the client should connect to
+ *        rcmHndl - Contains the Client once the call is completed
+ *        rcmParams -
+ *        These values can be picked up from the RPC handle. But an unique identifier is required -Server
+ * @param cComponentName  : Pointer to the Components Name that is requires the RCM client to be initialized
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+	RPC_OMX_ERRORTYPE RPC_InstanceInit(OMX_STRING cComponentName,
+	    OMX_HANDLETYPE * phRPCCtx);
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_InstanceDeInit()
+ * @brief This function Removes or deinitializes RCM client instances. This also manages the number of active users
+ *        of a given RCM client
+ * @param cComponentName  : Pointer to the Components Name that is active user of the RCM client to be deinitialized
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+	RPC_OMX_ERRORTYPE RPC_InstanceDeInit(OMX_HANDLETYPE hRPCCtx);
+
+
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif
diff --git a/domx/domx/omx_rpc/inc/omx_rpc_internal.h b/domx/domx/omx_rpc/inc/omx_rpc_internal.h
new file mode 100755
index 0000000..f4ad7d8
--- /dev/null
+++ b/domx/domx/omx_rpc/inc/omx_rpc_internal.h
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_internal.h
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\inc
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+
+#ifndef OMXRPC_INTERNAL_H
+#define OMXRPC_INTERNAL_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+/* ----- system and platform files ----------------------------*/
+#include <pthread.h>
+
+#include <OMX_Component.h>
+#include <OMX_Core.h>
+#include <OMX_Audio.h>
+#include <OMX_Video.h>
+#include <OMX_Types.h>
+#include <OMX_Index.h>
+#include <OMX_TI_Index.h>
+#include <OMX_TI_Common.h>
+
+/*-------program files ----------------------------------------*/
+#include "omx_rpc.h"
+
+
+/******************************************************************
+ *   DEFINES - CONSTANTS
+ ******************************************************************/
+/* *********************** OMX RPC DEFINES***********************************/
+
+/*This defines the maximum number of remote functions that can be registered*/
+#define RPC_OMX_MAX_FUNCTION_LIST 21
+/*Packet size for each message*/
+#define RPC_PACKET_SIZE 0xF0
+
+
+
+/*******************************************************************************
+* Enumerated Types
+*******************************************************************************/
+
+	typedef enum OMX_RPC_CORE_TYPE
+	{
+		OMX_RPC_CORE_TESLA = 0,
+		OMX_RPC_CORE_APPM3 = 1,
+		OMX_RPC_CORE_SYSM3 = 2,
+		RPC_CORE_CHIRON = 3,
+		OMX_RPC_CORE_MAX = 4
+	} OMX_RPC_CORE_TYPE;
+
+
+
+/*===============================================================*/
+/** RPC_OMX_FXN_IDX_TYPE   : A unique function index for each OMX function
+ */
+/*===============================================================*/
+	typedef enum RPC_OMX_FXN_IDX_TYPE
+	{
+
+		RPC_OMX_FXN_IDX_GET_HANDLE = 0,
+		RPC_OMX_FXN_IDX_SET_PARAMETER = 1,
+		RPC_OMX_FXN_IDX_GET_PARAMETER = 2,
+		RPC_OMX_FXN_IDX_USE_BUFFER = 3,
+		RPC_OMX_FXN_IDX_FREE_HANDLE = 4,
+		RPC_OMX_FXN_IDX_SET_CONFIG = 5,
+		RPC_OMX_FXN_IDX_GET_CONFIG = 6,
+		RPC_OMX_FXN_IDX_GET_STATE = 7,
+		RPC_OMX_FXN_IDX_SEND_CMD = 8,
+		RPC_OMX_FXN_IDX_GET_VERSION = 9,
+		RPC_OMX_FXN_IDX_GET_EXT_INDEX = 10,
+		RPC_OMX_FXN_IDX_FILLTHISBUFFER = 11,
+		RPC_OMX_FXN_IDX_FILLBUFFERDONE = 12,
+		RPC_OMX_FXN_IDX_FREE_BUFFER = 13,
+		RPC_OMX_FXN_IDX_EMPTYTHISBUFFER = 14,
+		RPC_OMX_FXN_IDX_EMPTYBUFFERDONE = 15,
+		RPC_OMX_FXN_IDX_EVENTHANDLER = 16,
+		RPC_OMX_FXN_IDX_ALLOCATE_BUFFER = 17,
+		RPC_OMX_FXN_IDX_COMP_TUNNEL_REQUEST = 18,
+		RPC_OMX_FXN_IDX_MAX = RPC_OMX_MAX_FUNCTION_LIST
+	} RPC_OMX_FXN_IDX_TYPE;
+
+
+
+/*===============================================================*/
+/** RPC_OMX_MAP_INFO_TYPE   : Tells the no. of buffers that the kernel has to
+                              map to remote core.
+ */
+/*===============================================================*/
+	typedef enum RPC_OMX_MAP_INFO_TYPE
+	{
+		RPC_OMX_MAP_INFO_NONE = 0,
+		RPC_OMX_MAP_INFO_ONE_BUF = 1,
+		RPC_OMX_MAP_INFO_TWO_BUF = 2,
+		RPC_OMX_MAP_INFO_THREE_BUF = 3,
+		RPC_OMX_MAP_INFO_MAX = 0x7FFFFFFF
+	} RPC_OMX_MAP_INFO_TYPE;
+
+
+
+/*******************************************************************************
+* STRUCTURES
+*******************************************************************************/
+
+/*===============================================================*/
+/** RPC_OMX_CONTEXT                 : RPC context structure
+ *
+ *  @ param fd_omx                  : File descriptor corresponding to this
+ *                                    instance on remote core.
+ *  @ param fd_killcb               : File descriptor used to shut down the
+ *                                    callback thread.
+ *  @ param cbThread                : Callback thread.
+ *  @ param pMsgPipe                : Array of message pipes. One for each OMX
+ *                                    function. Used to post and receive the
+ *                                    return messages of each function.
+ *  @ param hRemoteHandle           : Handle to the context structure on the
+ *                                    remote core.
+ *  @ param hActualRemoteCompHandle : Actual component handle on remote core.
+ *  @ param pAppData                : App data of RPC caller
+ *
+ */
+/*===============================================================*/
+	typedef struct RPC_OMX_CONTEXT
+	{
+		OMX_S32 fd_omx;
+		OMX_S32 fd_killcb;
+		pthread_t cbThread;
+		OMX_PTR pMsgPipe[RPC_OMX_MAX_FUNCTION_LIST];
+		OMX_HANDLETYPE hRemoteHandle;
+		OMX_HANDLETYPE hActualRemoteCompHandle;
+		OMX_PTR pAppData;
+	} RPC_OMX_CONTEXT;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/domx/domx/omx_rpc/inc/omx_rpc_skel.h b/domx/domx/omx_rpc/inc/omx_rpc_skel.h
new file mode 100755
index 0000000..b36281c
--- /dev/null
+++ b/domx/domx/omx_rpc/inc/omx_rpc_skel.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_skel.h
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\inc
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+
+#ifndef OMX_RPC_SKELH
+#define OMX_RPC_SKELH
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+
+#include "../inc/omx_rpc_internal.h"
+#include "../inc/omx_rpc_stub.h"
+
+	RPC_OMX_ERRORTYPE RPC_SKEL_EmptyBufferDone(void *data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_FillBufferDone(void *data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_EventHandler(void *data);
+
+/*Empty SKEL*/
+	RPC_OMX_ERRORTYPE RPC_SKEL_GetHandle(uint32_t size, uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_SetParameter(uint32_t size,
+	    uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_GetParameter(uint32_t size,
+	    uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_FreeHandle(uint32_t size, uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_EmptyThisBuffer(uint32_t size,
+	    uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_FillThisBuffer(uint32_t size,
+	    uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_UseBuffer(uint32_t size, uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_FreeBuffer(uint32_t size, uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_SetConfig(uint32_t size, uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_GetConfig(uint32_t size, uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_GetState(uint32_t size, uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_SendCommand(uint32_t size,
+	    uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_GetComponentVersion(uint32_t size,
+	    uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_GetExtensionIndex(uint32_t size,
+	    uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_AllocateBuffer(uint32_t size,
+	    uint32_t * data);
+	RPC_OMX_ERRORTYPE RPC_SKEL_ComponentTunnelRequest(uint32_t size,
+	    uint32_t * data);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/domx/domx/omx_rpc/inc/omx_rpc_stub.h b/domx/domx/omx_rpc/inc/omx_rpc_stub.h
new file mode 100755
index 0000000..5e3837f
--- /dev/null
+++ b/domx/domx/omx_rpc/inc/omx_rpc_stub.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_stub.h
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\inc
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+#ifndef OMX_RPC_STUBH
+#define OMX_RPC_STUBH
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include "omx_rpc.h"
+#include "omx_rpc_internal.h"
+
+	RPC_OMX_ERRORTYPE RPC_GetHandle(OMX_HANDLETYPE hRPCCtx,
+	    OMX_STRING cComponentName, OMX_PTR pAppData,
+	    OMX_CALLBACKTYPE * pCallBacks, OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_FreeHandle(OMX_HANDLETYPE hRPCCtx,
+	    OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_UseBuffer(OMX_HANDLETYPE hRPCCtx,
+	    OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, OMX_U32 nPortIndex,
+	    OMX_PTR pAppPrivate, OMX_U32 nSizeBytes, OMX_U8 * pBuffer,
+	    OMX_U32 * pBufHeaderRemote, OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_SetParameter(OMX_HANDLETYPE hRPCCtx,
+	    OMX_INDEXTYPE nParamIndex, OMX_PTR pCompParam,
+	    OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_GetParameter(OMX_HANDLETYPE hRPCCtx,
+	    OMX_INDEXTYPE nParamIndex, OMX_PTR pCompParam,
+	    OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_FillThisBuffer(OMX_HANDLETYPE hRPCCtx,
+	    OMX_BUFFERHEADERTYPE * pBufferHdr, OMX_U32 BufHdrRemote,
+	    OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_EmptyThisBuffer(OMX_HANDLETYPE hRPCCtx,
+	    OMX_BUFFERHEADERTYPE * pBufferHdr, OMX_U32 BufHdrRemote,
+	    OMX_ERRORTYPE * nCmdStatus,OMX_BOOL bMapBuffer);
+
+	RPC_OMX_ERRORTYPE RPC_FreeBuffer(OMX_HANDLETYPE hRPCCtx,
+	    OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_U32 BufHdrRemote,
+	    OMX_U32 pBuffer, OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_SetConfig(OMX_HANDLETYPE hRPCCtx,
+		OMX_INDEXTYPE nConfigIndex, OMX_PTR pCompConfig,
+		OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_GetConfig(OMX_HANDLETYPE hRPCCtx,
+		OMX_INDEXTYPE nConfigIndex, OMX_PTR pCompConfig,
+		OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_GetComponentVersion(OMX_HANDLETYPE hRPCCtx,
+	    OMX_STRING pComponentName, OMX_VERSIONTYPE * pComponentVersion,
+	    OMX_VERSIONTYPE * pSpecVersion, OMX_UUIDTYPE * pComponentUUID,
+	    OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_SendCommand(OMX_HANDLETYPE hRPCCtx,
+	    OMX_COMMANDTYPE eCmd, OMX_U32 nParam, OMX_PTR pCmdData,
+	    OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_GetState(OMX_HANDLETYPE hRPCCtx,
+	    OMX_STATETYPE * pState, OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_GetExtensionIndex(OMX_HANDLETYPE hComponent,
+	    OMX_STRING cParameterName, OMX_INDEXTYPE * pIndexType,
+	    OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_AllocateBuffer(OMX_HANDLETYPE hRPCCtx,
+	    OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,
+	    OMX_IN OMX_U32 nPortIndex, OMX_U32 * pBufHeaderRemote,
+	    OMX_PTR pAppPrivate, OMX_U32 nSizeBytes,
+	    OMX_ERRORTYPE * nCmdStatus);
+
+	RPC_OMX_ERRORTYPE RPC_ComponentTunnelRequest(OMX_HANDLETYPE hRPCCtx,
+	    OMX_IN OMX_U32 nPort, OMX_HANDLETYPE hTunneledremoteHandle,
+	    OMX_U32 nTunneledPort,
+	    OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup,
+	    OMX_ERRORTYPE * nCmdStatus);
+
+/*Empty Stubs*/
+	OMX_ERRORTYPE RPC_EventHandler(OMX_HANDLETYPE hRPCCtx,
+	    OMX_PTR pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1,
+	    OMX_U32 nData2, OMX_PTR pEventData);
+	OMX_ERRORTYPE RPC_EmptyBufferDone(OMX_HANDLETYPE hRPCCtx,
+	    OMX_PTR pAppData, OMX_BUFFERHEADERTYPE * pBuffer);
+	OMX_ERRORTYPE RPC_FillBufferDone(OMX_HANDLETYPE hRPCCtx,
+	    OMX_PTR pAppData, OMX_BUFFERHEADERTYPE * pBuffer);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/domx/domx/omx_rpc/inc/omx_rpc_utils.h b/domx/domx/omx_rpc/inc/omx_rpc_utils.h
new file mode 100755
index 0000000..9d1c871
--- /dev/null
+++ b/domx/domx/omx_rpc/inc/omx_rpc_utils.h
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_utils.h
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\inc
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+#ifndef OMX_RPC_UTILSH
+#define OMX_RPC_UTILSH
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include "omx_rpc.h"
+#include "omx_rpc_internal.h"
+
+#include <timm_osal_trace.h>
+
+#define DOMX_ERROR(fmt,...)  TIMM_OSAL_Error(fmt, ##__VA_ARGS__)
+#define DOMX_WARN(fmt,...)   TIMM_OSAL_Warning(fmt, ##__VA_ARGS__)
+#define DOMX_INFO(fmt,...)   TIMM_OSAL_Info(fmt, ##__VA_ARGS__)
+#define DOMX_DEBUG(fmt,...)  TIMM_OSAL_Debug(fmt, ##__VA_ARGS__)
+#define DOMX_ENTER(fmt,...)  TIMM_OSAL_Entering(fmt, ##__VA_ARGS__)
+#define DOMX_EXIT(fmt,...)   TIMM_OSAL_Exiting(fmt, ##__VA_ARGS__)
+
+
+/******************************************************************
+ *   MACROS - ASSERTS
+ ******************************************************************/
+#define RPC_assert  RPC_paramCheck
+#define RPC_require RPC_paramCheck
+#define RPC_ensure  RPC_paramCheck
+
+#define RPC_paramCheck(C, V, S) do { \
+    if (!(C)) { eRPCError = V;\
+    if(S) DOMX_ERROR("failed check:" #C" - returning error: 0x%x - %s",V,S);\
+    else DOMX_ERROR("failed check: %s - returning error: 0x%x",C, V); \
+    goto EXIT; } \
+    } while(0)
+
+/* ************************* OFFSET DEFINES ******************************** */
+#define GET_PARAM_DATA_OFFSET    (sizeof(RPC_OMX_HANDLE) + sizeof(OMX_INDEXTYPE) + sizeof(OMX_U32) /*4 bytes for offset*/ )
+#define USE_BUFFER_DATA_OFFSET   (sizeof(OMX_U32)*5)
+
+/******************************************************************
+ *   MACROS
+ ******************************************************************/
+#define RPC_UTIL_GETSTRUCTSIZE(PTR) *((OMX_U32*)PTR)
+
+/******************************************************************
+ *   MACROS - COMMON MARSHALLING UTILITIES
+ ******************************************************************/
+#define RPC_SETFIELDVALUE(MSGBODY, POS, VALUE, TYPE) do { \
+    *((TYPE *) ((OMX_U32)MSGBODY+POS)) = VALUE; \
+    POS += sizeof(TYPE); \
+    } while(0)
+
+#define RPC_SETFIELDOFFSET(MSGBODY, POS, OFFSET, TYPE) do { \
+    *((TYPE *) ((OMX_U32)MSGBODY+POS)) = OFFSET; \
+    POS += sizeof(TYPE); \
+    } while(0)
+
+#define RPC_SETFIELDCOPYGEN(MSGBODY, POS, PTR, SIZE) do { \
+    TIMM_OSAL_Memcpy((OMX_U8*)((OMX_U32)MSGBODY+POS), PTR, SIZE); \
+    POS += SIZE; \
+    } while (0)
+
+#define RPC_SETFIELDCOPYTYPE(MSGBODY, POS, PSTRUCT, TYPE) do { \
+    *((TYPE *)((OMX_U32)MSGBODY+POS)) = *PSTRUCT; \
+    POS += sizeof(TYPE); \
+    } while (0)
+
+/******************************************************************
+ *   MACROS - COMMON UNMARSHALLING UTILITIES
+ ******************************************************************/
+#define RPC_GETFIELDVALUE(MSGBODY, POS, VALUE, TYPE) do { \
+    VALUE = *((TYPE *) ((OMX_U32)MSGBODY+POS)); \
+    POS += sizeof(TYPE); \
+    } while(0)
+
+#define RPC_GETFIELDOFFSET(MSGBODY, POS, OFFSET, TYPE) do { \
+    OFFSET = *((TYPE *) ((OMX_U32)MSGBODY+POS)); \
+    POS += sizeof(TYPE); \
+    } while(0)
+
+#define RPC_GETFIELDCOPYGEN(MSGBODY, POS, PTR, SIZE)  do { \
+    TIMM_OSAL_Memcpy(PTR, (OMX_U8*)((OMX_U32)MSGBODY+POS), SIZE); \
+    POS += SIZE; \
+    } while(0)
+
+#define RPC_GETFIELDCOPYTYPE(MSGBODY, POS, PSTRUCT, TYPE) do { \
+    *PSTRUCT = *((TYPE *)((OMX_U32)MSGBODY+POS)); \
+    POS += sizeof(TYPE); \
+    } while(0)
+
+#define RPC_GETFIELDPATCHED(MSGBODY, OFFSET, PTR, TYPE) \
+PTR = (TYPE *) (MSGBODY+OFFSET);
+
+/******************************************************************
+ *   FUNCTIONS
+ ******************************************************************/
+	RPC_OMX_ERRORTYPE RPC_UnMapBuffer(OMX_U32 mappedBuffer);
+	RPC_OMX_ERRORTYPE RPC_MapBuffer(OMX_U32 mappedBuffer);
+	RPC_OMX_ERRORTYPE RPC_FlushBuffer(OMX_U8 * pBuffer, OMX_U32 size,
+	    OMX_U32 nTargetCoreId);
+	RPC_OMX_ERRORTYPE RPC_InvalidateBuffer(OMX_U8 * pBuffer,
+	    OMX_U32 size, OMX_U32 nTargetCoreId);
+
+	RPC_OMX_ERRORTYPE RPC_UTIL_GetTargetServerName(OMX_STRING
+	    ComponentName, OMX_STRING ServerName);
+	RPC_OMX_ERRORTYPE RPC_UTIL_GetLocalServerName(OMX_STRING
+	    ComponentName, OMX_STRING * ServerName);
+	RPC_OMX_ERRORTYPE RPC_UTIL_GenerateLocalServerName(OMX_STRING
+	    cServerName);
+	RPC_OMX_ERRORTYPE RPC_UTIL_GetTargetCore(OMX_STRING cComponentName,
+	    OMX_U32 * nCoreId);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/domx/domx/omx_rpc/src/omx_rpc.c b/domx/domx/omx_rpc/src/omx_rpc.c
new file mode 100755
index 0000000..78ae973
--- /dev/null
+++ b/domx/domx/omx_rpc/src/omx_rpc.c
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_stub.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC Stub implementations.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\src
+ *
+ *  @rev 1.0
+ */
+
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+/* ----- system and platform files ----------------------------*/
+#include <errno.h>
+//#include <errno-base.h>
+
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/eventfd.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <OMX_Types.h>
+#include <timm_osal_interfaces.h>
+#include <timm_osal_trace.h>
+
+
+/*-------program files ----------------------------------------*/
+#include "omx_rpc.h"
+#include "omx_proxy_common.h"
+#include "omx_rpc_stub.h"
+#include "omx_rpc_skel.h"
+#include "omx_rpc_internal.h"
+#include "omx_rpc_utils.h"
+
+#include "rpmsg_omx_defs.h"
+
+#define RPC_MSGPIPE_SIZE (4)
+#define RPC_MSG_SIZE_FOR_PIPE (sizeof(OMX_PTR))
+
+
+#define RPC_getPacket(nPacketSize, pPacket) do { \
+    pPacket = TIMM_OSAL_Malloc(nPacketSize, TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT); \
+    RPC_assert(pPacket != NULL, RPC_OMX_ErrorInsufficientResources, \
+           "Error Allocating RCM Message Frame"); \
+    } while(0)
+
+#define RPC_freePacket(pPacket) do { \
+    if(pPacket != NULL) TIMM_OSAL_Free(pPacket); \
+    } while(0)
+
+
+
+void *RPC_CallbackThread(void *data);
+
+
+/* ===========================================================================*/
+/**
+* @name RPC_InstanceInit()
+* @brief RPC instance init is used for initialization. It is called once for
+*        every instance of an OMX component.
+* @param cComponentName [IN] : Name of the component.
+* @param phRPCCtx [OUT] : RPC Context structure - to be filled in and returned
+* @return RPC_OMX_ErrorNone = Successful
+*/
+/* ===========================================================================*/
+
+RPC_OMX_ERRORTYPE RPC_InstanceInit(OMX_STRING cComponentName,
+    OMX_HANDLETYPE * phRPCCtx)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	RPC_OMX_CONTEXT *pRPCCtx = NULL;
+	OMX_S32 status = 0;
+	struct omx_conn_req sReq = { .name = "OMX" };
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	OMX_U32 i = 0;
+	//pthread_t cbThread;
+
+//	sReq.name = "OMX";
+
+	/*pRPCCtx contains context information for each instance */
+	pRPCCtx =
+	    (RPC_OMX_CONTEXT *) TIMM_OSAL_Malloc(sizeof(RPC_OMX_CONTEXT),
+	    TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
+	RPC_assert(pRPCCtx != NULL, RPC_OMX_ErrorInsufficientResources,
+	    "Malloc failed");
+	TIMM_OSAL_Memset(pRPCCtx, 0, sizeof(RPC_OMX_CONTEXT));
+	*(RPC_OMX_CONTEXT **) phRPCCtx = pRPCCtx;
+
+	/*Assuming that open maintains an internal count for multi instance */
+	DOMX_DEBUG("Calling open on the device");
+	pRPCCtx->fd_omx = open("/dev/rpmsg-omx1", O_RDWR);
+	RPC_assert(pRPCCtx->fd_omx >= 0, RPC_OMX_ErrorInsufficientResources,
+	    "Can't open device");
+	DOMX_DEBUG("Open was successful, pRPCCtx->fd_omx = %d",
+	    pRPCCtx->fd_omx);
+//AD
+//      strncpy(sReq.name, cComponentName, OMX_MAX_STRINGNAME_SIZE);
+
+	DOMX_DEBUG("Calling ioctl");
+	status = ioctl(pRPCCtx->fd_omx, OMX_IOCCONNECT, &sReq);
+	RPC_assert(status >= 0, RPC_OMX_ErrorInsufficientResources,
+	    "Can't connect");
+
+	for (i = 0; i < RPC_OMX_MAX_FUNCTION_LIST; i++)
+	{
+		eError =
+		    TIMM_OSAL_CreatePipe(&(pRPCCtx->pMsgPipe[i]),
+		    RPC_MSGPIPE_SIZE, RPC_MSG_SIZE_FOR_PIPE, 1);
+		RPC_assert(eError == TIMM_OSAL_ERR_NONE,
+		    RPC_OMX_ErrorInsufficientResources,
+		    "Pipe creation failed");
+	}
+
+	DOMX_DEBUG("Creating event fd");
+	pRPCCtx->fd_killcb = eventfd(0, 0);
+	RPC_assert(pRPCCtx->fd_killcb >= 0,
+	    RPC_OMX_ErrorInsufficientResources, "Can't create kill fd");
+	/*Create a listener/server thread to listen for Ducati callbacks */
+	DOMX_DEBUG("Create listener thread");
+	status =
+	    pthread_create(&(pRPCCtx->cbThread), NULL, RPC_CallbackThread,
+	    pRPCCtx);
+	RPC_assert(status == 0, RPC_OMX_ErrorInsufficientResources,
+	    "Can't create cb thread");
+
+      EXIT:
+	if (eRPCError != RPC_OMX_ErrorNone)
+	{
+		RPC_InstanceDeInit(pRPCCtx);
+	}
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+* @name RPC_InstanceDeInit()
+* @brief RPC instance deinit is used for tear down. It is called once when an
+*        instance of OMX component is going down.
+* @param phRPCCtx [IN] : RPC Context structure.
+* @return RPC_OMX_ErrorNone = Successful
+*/
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_InstanceDeInit(OMX_HANDLETYPE hRPCCtx)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	RPC_OMX_CONTEXT *pRPCCtx = (RPC_OMX_CONTEXT *) hRPCCtx;
+	OMX_S32 status = 0;
+	OMX_U32 i = 0;
+	OMX_U64 nKillEvent = 1;
+
+	RPC_assert(hRPCCtx != NULL, RPC_OMX_ErrorUndefined,
+	    "NULL context handle supplied - no further cleanup possible");
+
+	if (pRPCCtx->fd_killcb)
+	{
+		status =
+		    write(pRPCCtx->fd_killcb, &nKillEvent, sizeof(OMX_U64));
+		if (status <= 0)
+		{
+			DOMX_ERROR
+			    ("Write to kill fd failed - cb thread may not exit");
+			eRPCError = RPC_OMX_ErrorUndefined;
+		} else if (pRPCCtx->cbThread)
+		{
+			DOMX_DEBUG("Waiting for cb thread to exit");
+			status = pthread_join(pRPCCtx->cbThread, NULL);
+			if (status != 0)
+			{
+				DOMX_ERROR("Join for cb thread failed");
+				eRPCError = RPC_OMX_ErrorUndefined;
+			}
+		}
+		DOMX_DEBUG("Closing the kill fd");
+		status = close(pRPCCtx->fd_killcb);
+		if (status != 0)
+		{
+			DOMX_ERROR("Close failed on kill fd");
+			eRPCError = RPC_OMX_ErrorUndefined;
+		}
+	}
+
+	for (i = 0; i < RPC_OMX_MAX_FUNCTION_LIST; i++)
+	{
+		if (pRPCCtx->pMsgPipe[i])
+		{
+			eError = TIMM_OSAL_DeletePipe(pRPCCtx->pMsgPipe[i]);
+			if (eError != TIMM_OSAL_ERR_NONE)
+			{
+				DOMX_ERROR("Pipe deletion failed");
+				eRPCError = RPC_OMX_ErrorUndefined;
+			}
+		}
+	}
+
+	DOMX_DEBUG("Closing the omx fd");
+	if (pRPCCtx->fd_omx)
+	{
+		status = close(pRPCCtx->fd_omx);
+		if (status != 0)
+		{
+			DOMX_ERROR("Close failed on omx fd");
+			eRPCError = RPC_OMX_ErrorUndefined;
+		}
+	}
+	TIMM_OSAL_Free(pRPCCtx);
+
+      EXIT:
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+* @name RPC_CallbackThread()
+* @brief This is the entry function of the thread which keeps spinning, waiting
+*        for messages from Ducati.
+* @param data [IN] : The RPC Context structure is passed here.
+* @return RPC_OMX_ErrorNone = Successful
+*/
+/* ===========================================================================*/
+void *RPC_CallbackThread(void *data)
+{
+	OMX_PTR pBuffer = NULL;
+	RPC_OMX_CONTEXT *pRPCCtx = (RPC_OMX_CONTEXT *) data;
+	fd_set readfds;
+	OMX_S32 maxfd = 0, status = 0;
+	OMX_U32 nFxnIdx = 0, nPacketSize = RPC_PACKET_SIZE, nPos = 0;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	OMX_COMPONENTTYPE *hComp = NULL;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+
+	maxfd =
+	    (pRPCCtx->fd_killcb >
+	    pRPCCtx->fd_omx ? pRPCCtx->fd_killcb : pRPCCtx->fd_omx) + 1;
+	while (1)
+	{
+		FD_ZERO(&readfds);
+		FD_SET(pRPCCtx->fd_omx, &readfds);
+		FD_SET(pRPCCtx->fd_killcb, &readfds);
+
+		DOMX_DEBUG("Waiting for messages from remote core");
+		status = select(maxfd, &readfds, NULL, NULL, NULL);
+		RPC_assert(status > 0, RPC_OMX_ErrorUndefined,
+		    "select failed");
+
+		if (FD_ISSET(pRPCCtx->fd_killcb, &readfds))
+		{
+			DOMX_DEBUG("Recd. kill message - exiting the thread");
+			break;
+		}
+
+		if (FD_ISSET(pRPCCtx->fd_omx, &readfds))
+		{
+			DOMX_DEBUG("Recd. omx message");
+			RPC_getPacket(nPacketSize, pBuffer);
+			status = read(pRPCCtx->fd_omx, pBuffer, nPacketSize);
+            if(status < 0)
+            {
+                if(errno == ENXIO)
+                {
+                    /*Indicate fatal error and exit*/
+                    RPC_assert(0, RPC_OMX_ErrorHardware,
+                    "Remote processor fatal error");
+                }
+                else
+                {
+                    RPC_assert(0, RPC_OMX_ErrorUndefined,
+                    "read failed");
+                }
+            }
+
+			nPos = 0;
+			nFxnIdx = ((struct omx_packet *) pBuffer)->fxn_idx;
+			/*Indices from static table will have bit 31 set */
+			if (nFxnIdx & 0x80000000)
+				nFxnIdx &= 0x0FFFFFFF;
+			RPC_assert(nFxnIdx < RPC_OMX_MAX_FUNCTION_LIST,
+			    RPC_OMX_ErrorUndefined,
+			    "Bad function index recd");
+			switch (nFxnIdx)
+			{
+			case RPC_OMX_FXN_IDX_EVENTHANDLER:
+				RPC_SKEL_EventHandler(((struct omx_packet *)
+					pBuffer)->data);
+				RPC_freePacket(pBuffer);
+				pBuffer = NULL;
+				break;
+			case RPC_OMX_FXN_IDX_EMPTYBUFFERDONE:
+				RPC_SKEL_EmptyBufferDone(((struct omx_packet *)
+					pBuffer)->data);
+				RPC_freePacket(pBuffer);
+				pBuffer = NULL;
+				break;
+			case RPC_OMX_FXN_IDX_FILLBUFFERDONE:
+				RPC_SKEL_FillBufferDone(((struct omx_packet *)
+					pBuffer)->data);
+				RPC_freePacket(pBuffer);
+				pBuffer = NULL;
+				break;
+			default:
+				eError =
+				    TIMM_OSAL_WriteToPipe(pRPCCtx->
+				    pMsgPipe[nFxnIdx], &pBuffer,
+				    RPC_MSG_SIZE_FOR_PIPE, TIMM_OSAL_SUSPEND);
+				RPC_assert(eError == TIMM_OSAL_ERR_NONE,
+				    RPC_OMX_ErrorUndefined,
+				    "Write to pipe failed");
+				break;
+			}
+		}
+EXIT:
+		if (eRPCError != RPC_OMX_ErrorNone)
+		{
+			//AD TODO: Send error CB to client and then go back in loop to wait for killfd
+			if (pBuffer != NULL)
+			{
+				RPC_freePacket(pBuffer);
+				pBuffer = NULL;
+			}
+			/*Report all hardware errors as fatal and exit from listener thread*/
+			if (eRPCError == RPC_OMX_ErrorHardware)
+			{
+				/*Implicit detail: pAppData is proxy component handle updated during
+                  RPC_GetHandle*/
+				hComp = (OMX_COMPONENTTYPE *) pRPCCtx->pAppData;
+                if(hComp != NULL)
+				{
+					pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+                    /*Indicate fatal error. Users are expected to cleanup the OMX instance
+                    to ensure all resources are cleaned up.*/
+					pCompPrv->proxyEventHandler(hComp, pCompPrv->pILAppData, OMX_EventError,
+												OMX_ErrorHardware, 0, NULL);
+				}
+				break;
+			}
+		}
+	}
+        return (void*)0;
+}
diff --git a/domx/domx/omx_rpc/src/omx_rpc_config.c b/domx/domx/omx_rpc/src/omx_rpc_config.c
new file mode 100755
index 0000000..07e46ed
--- /dev/null
+++ b/domx/domx/omx_rpc/src/omx_rpc_config.c
@@ -0,0 +1,132 @@
+#if 0
+
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_config.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+ /******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+ /* ----- system and platform files ---------------------------- */
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <Std.h>
+
+#include <OMX_Types.h>
+#include <timm_osal_interfaces.h>
+#include <timm_osal_trace.h>
+
+#include <MultiProc.h>
+#include <RcmClient.h>
+#include <RcmServer.h>
+
+/*-------program files ----------------------------------------*/
+#include "omx_rpc.h"
+#include "omx_rpc_stub.h"
+#include "omx_rpc_skel.h"
+#include "omx_rpc_internal.h"
+#include "omx_rpc_utils.h"
+
+extern Int32 RPC_MemFree(UInt32 * dataSize, UInt32 * data);
+extern Int32 RPC_MemAlloc(UInt32 * dataSize, UInt32 * data);
+
+/* contains configurations or structures to be passed to omx_rpc layer */
+char rpcFxns[][MAX_FUNCTION_NAME_LENGTH] = {
+	"RPC_SKEL_SetParameter",
+	"RPC_SKEL_GetParameter",
+	"RPC_SKEL_GetHandle",
+	"RPC_SKEL_UseBuffer",
+
+	"RPC_SKEL_FreeHandle",
+
+	"RPC_SKEL_SetConfig",
+	"RPC_SKEL_GetConfig",
+	"RPC_SKEL_GetState",
+	"RPC_SKEL_SendCommand",
+	"RPC_SKEL_GetComponentVersion",
+	"RPC_SKEL_GetExtensionIndex",
+	"RPC_SKEL_FillThisBuffer",
+	"RPC_SKEL_FillBufferDone",
+	"RPC_SKEL_FreeBuffer",
+
+	"RPC_SKEL_EmptyThisBuffer",
+	"RPC_SKEL_EmptyBufferDone",
+	"RPC_SKEL_EventHandler",
+	"RPC_SKEL_AllocateBuffer",
+	"RPC_SKEL_ComponentTunnelRequest",
+
+	"MemMgr_Alloc",
+	"MemMgr_Free"
+};
+
+rpcSkelArr rpcSkelFxns[] = {
+	{RPC_SKEL_SetParameter},
+	{RPC_SKEL_GetParameter},
+	{RPC_SKEL_GetHandle},
+	{RPC_SKEL_UseBuffer},
+	{RPC_SKEL_FreeHandle},
+	{RPC_SKEL_SetConfig},
+	{RPC_SKEL_GetConfig},
+	{RPC_SKEL_GetState},
+	{RPC_SKEL_SendCommand},
+	{RPC_SKEL_GetComponentVersion},
+	{RPC_SKEL_GetExtensionIndex},
+	{RPC_SKEL_FillThisBuffer},
+	{RPC_SKEL_FillBufferDone},
+	{RPC_SKEL_FreeBuffer},
+	{RPC_SKEL_EmptyThisBuffer},
+	{RPC_SKEL_EmptyBufferDone},
+	{RPC_SKEL_EventHandler},
+	{RPC_SKEL_AllocateBuffer},
+	{RPC_SKEL_ComponentTunnelRequest},
+	{RPC_MemAlloc},
+	{RPC_MemFree}
+};
+
+#endif
diff --git a/domx/domx/omx_rpc/src/omx_rpc_platform.c b/domx/domx/omx_rpc/src/omx_rpc_platform.c
new file mode 100755
index 0000000..65d4cf5
--- /dev/null
+++ b/domx/domx/omx_rpc/src/omx_rpc_platform.c
@@ -0,0 +1,85 @@
+#if 0
+
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_platform.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+  /******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+ /* ----- system and platform files ---------------------------- */
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <Std.h>
+
+#include <OMX_Types.h>
+#include <timm_osal_interfaces.h>
+#include <timm_osal_trace.h>
+
+#include <MultiProc.h>
+#include <RcmClient.h>
+#include <RcmServer.h>
+
+/*-------program files ----------------------------------------*/
+#include "omx_rpc.h"
+#include "omx_rpc_stub.h"
+#include "omx_rpc_skel.h"
+#include "omx_rpc_internal.h"
+#include "omx_rpc_utils.h"
+
+/*This list needs to be a comprehensive list of all possible communicating RCM servers avalilable across the whole system (core 0 core 1, tesla, chiron)*/
+char Core_Array[][MAX_CORENAME_LENGTH] =
+    { "TESLA", "DUCATI1", "DUCATI0", "CHIRON" };
+
+char rcmservertable[][MAX_SERVER_NAME_LENGTH] =
+    { "RSrv_Tesla", "RSrv_Ducati1", "RSrv_Ducati0", "RSrv_Chiron" };
+
+OMX_U32 heapIdArray[MAX_NUMBER_OF_HEAPS] = { 0, 1, 0, 1 };
+
+#endif
diff --git a/domx/domx/omx_rpc/src/omx_rpc_skel.c b/domx/domx/omx_rpc/src/omx_rpc_skel.c
new file mode 100755
index 0000000..5b8d423
--- /dev/null
+++ b/domx/domx/omx_rpc/src/omx_rpc_skel.c
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_skel.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC Skeleton implementations.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+
+#include <timm_osal_interfaces.h>
+#include <OMX_TI_Common.h>
+
+#include "omx_rpc.h"
+#include "omx_proxy_common.h"
+#include "omx_rpc_skel.h"
+#include "omx_rpc_utils.h"
+#include "omx_rpc_internal.h"
+
+/* FUNCTION LIST*/
+/*
+RPC_OMX_ERRORTYPE RPC_SKEL_EmptyBufferDone(uint32_t size, uint32_t *data)
+RPC_OMX_ERRORTYPE RPC_SKEL_FillBufferDone(uint32_t size, uint32_t *data)
+RPC_OMX_ERRORTYPE RPC_SKEL_EventHandler(uint32_t size, uint32_t *data)
+*/
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_SKEL_FillBufferDone()
+ * @brief Skeleton for OMX_AllocateBuffer()
+ * @param size   : Size of the incoming RCM message (parameter used in the RCM alloc call)
+ * @param *data  : Pointer to the RCM message/buffer received
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_SKEL_EmptyBufferDone(void *data)
+{
+
+	OMX_HANDLETYPE hComp;
+	RPC_OMX_ERRORTYPE tRPCError = RPC_OMX_ErrorNone;
+	OMX_U32 nfilledLen = 0;
+	OMX_U32 nOffset = 0;
+	OMX_U32 nFlags = 0;
+	OMX_U32 bufferHdr;
+	OMX_COMPONENTTYPE *pHandle = NULL;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_U32 nPos = 0;
+	//RPC_OMX_MESSAGE *recdMsg;
+	OMX_U8 *pMsgBody = NULL;
+	//recdMsg = (RPC_OMX_MESSAGE *) (data);
+
+	pMsgBody = data;	//&recdMsg->msgBody[0];
+
+	DOMX_ENTER("");
+
+	//Marshalled:[>hComp|>bufferHdr|>nFilledLen|>nOffset|>nFlags]
+
+	RPC_GETFIELDVALUE(pMsgBody, nPos, hComp, OMX_HANDLETYPE);
+	pHandle = (OMX_COMPONENTTYPE *) hComp;
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
+
+	RPC_GETFIELDVALUE(pMsgBody, nPos, bufferHdr, OMX_U32);
+
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nfilledLen, OMX_U32);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nOffset, OMX_U32);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nFlags, OMX_U32);
+
+	tRPCError =
+	    pCompPrv->proxyEmptyBufferDone(hComp, bufferHdr, nfilledLen,
+	    nOffset, nFlags);
+
+	DOMX_EXIT("");
+	return tRPCError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name RPC_SKEL_FillBufferDone()
+ * @brief Skeleton for OMX_AllocateBuffer()
+ * @param size   : Size of the incoming RCM message (parameter used in the RCM alloc call)
+ * @param *data  : Pointer to the RCM message/buffer received
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_SKEL_FillBufferDone(void *data)
+{
+
+	OMX_HANDLETYPE hComp;
+	RPC_OMX_ERRORTYPE tRPCError = RPC_OMX_ErrorNone;
+	OMX_U32 nfilledLen = 0;
+	OMX_U32 nOffset = 0;
+	OMX_U32 nFlags = 0;
+	OMX_TICKS nTimeStamp;
+	OMX_U32 bufferHdr;
+	OMX_COMPONENTTYPE *pHandle = NULL;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_U32 nPos = 0;
+	//RPC_OMX_MESSAGE *recdMsg;
+	OMX_U8 *pMsgBody = NULL;
+	OMX_HANDLETYPE hMarkTargetComponent = NULL;
+	OMX_PTR pMarkData = NULL;
+	//recdMsg = (RPC_OMX_MESSAGE *) (data);
+
+	pMsgBody = data;	//&recdMsg->msgBody[0];
+
+	DOMX_ENTER("");
+
+	//Marshalled:[>hComp|>bufferHdr|>nFilledLen|>nOffset|>nFlags|>nTimeStamp]
+
+	RPC_GETFIELDVALUE(pMsgBody, nPos, hComp, OMX_HANDLETYPE);
+	pHandle = (OMX_COMPONENTTYPE *) hComp;
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
+
+	RPC_GETFIELDVALUE(pMsgBody, nPos, bufferHdr, OMX_U32);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nfilledLen, OMX_U32);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nOffset, OMX_U32);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nFlags, OMX_U32);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nTimeStamp, OMX_TICKS);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, hMarkTargetComponent,
+	    OMX_HANDLETYPE);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, pMarkData, OMX_PTR);
+
+	tRPCError =
+	    pCompPrv->proxyFillBufferDone(hComp, bufferHdr, nfilledLen,
+	    nOffset, nFlags, nTimeStamp, hMarkTargetComponent, pMarkData);
+
+	DOMX_EXIT("");
+	return tRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_SKEL_EventHandler()
+ * @brief Skeleton for OMX_AllocateBuffer()
+ * @param size   : Size of the incoming RCM message (parameter used in the RCM alloc call)
+ * @param *data  : Pointer to the RCM message/buffer received
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_SKEL_EventHandler(void *data)
+{
+	OMX_HANDLETYPE hComp;
+	RPC_OMX_ERRORTYPE tRPCError = RPC_OMX_ErrorNone;
+	OMX_COMPONENTTYPE *pHandle = NULL;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_EVENTTYPE eEvent;
+	OMX_U32 nData1;
+	OMX_U32 nData2;
+	OMX_PTR pEventData;
+	OMX_U32 nPos = 0;
+	//RPC_OMX_MESSAGE *recdMsg;
+	OMX_U8 *pMsgBody = NULL;
+	//recdMsg = (RPC_OMX_MESSAGE *) (data);
+	pMsgBody = data;	//&recdMsg->msgBody[0];
+
+	DOMX_ENTER("");
+
+	//Marshalled:[>hComp|>eEvent|>nData1|>nData2|>pEventData]
+
+	RPC_GETFIELDVALUE(pMsgBody, nPos, hComp, OMX_HANDLETYPE);
+	pHandle = (OMX_COMPONENTTYPE *) hComp;
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
+
+	RPC_GETFIELDVALUE(pMsgBody, nPos, eEvent, OMX_EVENTTYPE);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nData1, OMX_U32);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, nData2, OMX_U32);
+	RPC_GETFIELDVALUE(pMsgBody, nPos, pEventData, OMX_PTR);
+
+	DOMX_DEBUG
+	    ("\n**__**Got eventhandler from Remote Core succesffuly - values are : **__**");
+	DOMX_DEBUG
+	    ("hComp :0x%x,eEvent: 0x%x,nData1: 0x%x,nData2: 0x%x,pEventData: 0x%x",
+	    hComp, eEvent, nData1, nData2, pEventData);
+	DOMX_DEBUG("Just Before Entering Proxy Event handler call");
+
+	tRPCError =
+	    pCompPrv->proxyEventHandler(hComp, pCompPrv->pILAppData, eEvent,
+	    nData1, nData2, pEventData);
+
+	DOMX_EXIT("");
+	return tRPCError;
+
+}
+
+/* ===========================================================================*/
+/**
+ * @name EMPTY-SKEL
+ * @brief
+ * @param
+ * @return
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_SKEL_GetHandle(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_SetParameter(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_GetParameter(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_FreeHandle(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_EmptyThisBuffer(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_FillThisBuffer(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_UseBuffer(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_FreeBuffer(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_SetConfig(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_GetConfig(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_GetState(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_SendCommand(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_GetComponentVersion(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_GetExtensionIndex(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_AllocateBuffer(uint32_t size, uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_SKEL_ComponentTunnelRequest(uint32_t size,
+    uint32_t * data)
+{
+	return RPC_OMX_ErrorNone;
+}
diff --git a/domx/domx/omx_rpc/src/omx_rpc_stub.c b/domx/domx/omx_rpc/src/omx_rpc_stub.c
new file mode 100755
index 0000000..d91c899
--- /dev/null
+++ b/domx/domx/omx_rpc/src/omx_rpc_stub.c
@@ -0,0 +1,1429 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_stub.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC Stub implementations.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 30-Apr-2010 Abhishek Ranka : Fixed GetExtension issue
+ *!
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "omx_rpc.h"
+#include "omx_rpc_utils.h"
+#include "omx_proxy_common.h"
+#include "omx_rpc_stub.h"
+#include <OMX_TI_Common.h>
+#include <timm_osal_interfaces.h>
+
+#include <linux/rpmsg_omx.h>
+#include "rpmsg_omx_defs.h"
+
+/******************************************************************
+ *   EXTERNS
+ ******************************************************************/
+
+/******************************************************************
+ *   MACROS - LOCAL
+ ******************************************************************/
+
+//#define RPC_MSGPIPE_SIZE (4)
+#define RPC_MSG_SIZE_FOR_PIPE (sizeof(OMX_PTR))
+
+/* When this is defined ETB/FTB calls are made in sync mode. Undefining will
+ * result in these calls being sent via async mode. Sync mode leads to correct
+ * functionality as per OMX spec but has a slight performance penalty. Async
+ * mode sacrifices strict adherence to spec for some gain in performance. */
+#define RPC_SYNC_MODE
+
+
+#define RPC_getPacket(nPacketSize, pPacket) do { \
+    pPacket = TIMM_OSAL_Malloc(nPacketSize, TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT); \
+    RPC_assert(pPacket != NULL, RPC_OMX_ErrorInsufficientResources, \
+           "Error Allocating RCM Message Frame"); \
+    TIMM_OSAL_Memset(pPacket, 0, nPacketSize); \
+    } while(0)
+
+#define RPC_freePacket(pPacket) do { \
+    if(pPacket != NULL) TIMM_OSAL_Free(pPacket); \
+    } while(0)
+
+#define RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, nSize) do { \
+    status = write(hCtx->fd_omx, pPacket, nPacketSize); \
+    RPC_freePacket(pPacket); \
+    pPacket = NULL; \
+    RPC_assert(status >= 0, RPC_OMX_ErrorUndefined, "Write failed"); \
+    eError = TIMM_OSAL_ReadFromPipe(hCtx->pMsgPipe[nFxnIdx], &pRetPacket, \
+        RPC_MSG_SIZE_FOR_PIPE, (TIMM_OSAL_U32 *)(&nSize), TIMM_OSAL_SUSPEND); \
+    RPC_assert(eError == TIMM_OSAL_ERR_NONE, RPC_OMX_ErrorUndefined, \
+        "Read failed"); \
+    } while(0)
+
+/*Set bit 31 on fxn idx as it is static function*/
+#define RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize) do { \
+    pOmxPacket = (struct omx_packet *)pPacket; \
+    pData = pOmxPacket->data; \
+    pOmxPacket->desc |= OMX_DESC_MSG << OMX_DESC_TYPE_SHIFT; \
+    pOmxPacket->msg_id = 0; \
+    pOmxPacket->flags = OMX_POOLID_JOBID_DEFAULT; \
+    pOmxPacket->fxn_idx = (nFxnIdx | 0x80000000); \
+    pOmxPacket->result = 0; \
+    pOmxPacket->data_size = nPacketSize; \
+    } while(0)
+
+//Async to be checked later - most probably same as sync but without the read
+#if 0
+
+#define RPC_sendPacket_async(HRCM, pPacket, nFxnIdx) do { \
+    pPacket->nFxnIdx = nFxnIdx; \
+    status = RcmClient_execCmd(HRCM, pPacket); \
+    if(status < 0) { \
+    RPC_freePacket(HRCM, pPacket); \
+    pPacket = NULL; \
+    RPC_assert(0, RPC_OMX_RCM_ErrorExecFail, \
+           "RcmClient_exec failed"); \
+    } \
+    } while(0)
+
+#define RPC_checkAsyncErrors(rcmHndl, pPacket) do { \
+    status = RcmClient_checkForError(rcmHndl, &pPacket); \
+    if(status < 0) { \
+        RPC_freePacket(rcmHndl, pPacket); \
+        pPacket = NULL; \
+    } \
+    RPC_assert(status >= 0, RPC_OMX_RCM_ClientFail, \
+        "Async error check returned error"); \
+    } while(0)
+
+#endif
+/* ===========================================================================*/
+/**
+ * @name RPC_GetHandle()
+ * @brief Remote invocation stub for OMX_GetHandle
+ * @param hRPCCtx [OUT]         : The RPC context handle.
+ * @param cComponentName [IN]   : Name of the component that is to be created
+ *                                on Remote core.
+ * @param pAppData [IN]         : The AppData passed by the user.
+ * @param pCallBacks [IN]       : The callback pointers passed by the caller.
+ * @param eCompReturn [OUT]     : This is return value returned by the remote
+ *                                component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_GetHandle(OMX_HANDLETYPE hRPCCtx,
+    OMX_STRING cComponentName, OMX_PTR pAppData,
+    OMX_CALLBACKTYPE * pCallBacks, OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData =
+	    NULL, pRetData = NULL;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = NULL;
+	OMX_HANDLETYPE hActualComp = NULL;
+	OMX_S32 status = 0;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+	DOMX_DEBUG("RPC_GetHandle: Recieved GetHandle request from %s",
+	    cComponentName);
+
+	nFxnIdx = RPC_OMX_FXN_IDX_GET_HANDLE;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	DOMX_DEBUG("Packing data");
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDCOPYGEN(pData, nPos, cComponentName,
+	    OMX_MAX_STRINGNAME_SIZE);
+	RPC_SETFIELDVALUE(pData, nPos, pAppData, OMX_PTR);
+
+	DOMX_DEBUG("Sending data");
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+	if (*eCompReturn == OMX_ErrorNone)
+	{
+		pRetData = ((struct omx_packet *) pRetPacket)->data;
+		RPC_GETFIELDVALUE(pRetData, nPos, hComp, OMX_HANDLETYPE);
+		DOMX_DEBUG("Remote Handle 0x%x", hComp);
+		hCtx->hRemoteHandle = hComp;
+		/* The handle received above is used for all communications
+		   with the remote component but is not the actual component
+		   handle (it is actually the rpc context handle which
+		   contains lot of other info). The handle recd. below is the
+		   actual remote component handle. This is used at present for
+		   mark buffer implementation since in that case it is not
+		   feasible to send the context handle */
+		RPC_GETFIELDVALUE(pRetData, nPos, hActualComp,
+		    OMX_HANDLETYPE);
+		DOMX_DEBUG("Actual Remote Comp Handle 0x%x", hActualComp);
+		hCtx->hActualRemoteCompHandle = hActualComp;
+	}
+
+    /* Save context information */
+    hCtx->pAppData = pAppData;
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_FreeHandle()
+ * @brief Remote invocation stub for OMX_FreeHandle
+ * @param hRPCCtx [IN]      : The RPC context handle.
+ * @param eCompReturn [OUT] : Return value returned by the remote component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_FreeHandle(OMX_HANDLETYPE hRPCCtx,
+    OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL;
+	OMX_S32 status = 0;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_FREE_HANDLE;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_SetParameter()
+ * @brief Remote invocation stub for OMX_SetParameter
+ * @param hRPCCtx [IN]      : The RPC context handle.
+ * @param nParamIndex [IN]  : Same as nParamIndex received at the proxy.
+ * @param pCompParam [IN]   : Same as pCompParam recieved at the proxy.
+ * @param eCompReturn [OUT] : Return value returned by the remote component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_SetParameter(OMX_HANDLETYPE hRPCCtx,
+    OMX_INDEXTYPE nParamIndex, OMX_PTR pCompParam,
+    OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * eCompReturn)
+{
+
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_U32 structSize = 0;
+	struct omx_packet *pOmxPacket = NULL;
+
+	nFxnIdx = RPC_OMX_FXN_IDX_SET_PARAMETER;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	if (pLocBufNeedMap != NULL && (pLocBufNeedMap - pCompParam) >= 0 ) {
+		RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF,
+			RPC_OMX_MAP_INFO_TYPE);
+		nOffset = (pLocBufNeedMap - pCompParam) +
+			sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) +
+			sizeof(OMX_HANDLETYPE) + sizeof(OMX_INDEXTYPE);
+	} else {
+		/*No buffer mapping required */
+		RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+			RPC_OMX_MAP_INFO_TYPE);
+	}
+
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nParamIndex, OMX_INDEXTYPE);
+	structSize = RPC_UTIL_GETSTRUCTSIZE(pCompParam);
+	RPC_SETFIELDCOPYGEN(pData, nPos, pCompParam, structSize);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_GetParameter()
+ * @brief Remote invocation stub for OMX_GetParameter
+ * @param hRPCCtx [IN]      : The RPC context handle.
+ * @param nParamIndex [IN]  : Same as nParamIndex received at the proxy.
+ * @param pCompParam [IN]   : Same as pCompParam recieved at the proxy.
+ * @param eCompReturn [OUT] : Return value returned by the remote component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_GetParameter(OMX_HANDLETYPE hRPCCtx,
+    OMX_INDEXTYPE nParamIndex, OMX_PTR pCompParam,
+    OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData =
+	    NULL, pRetData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nDataOffset = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_U32 structSize = 0;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_GET_PARAMETER;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	if (pLocBufNeedMap != NULL && (pLocBufNeedMap - pCompParam) >= 0 ) {
+		RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF,
+			RPC_OMX_MAP_INFO_TYPE);
+		nOffset = (pLocBufNeedMap - pCompParam) +
+			sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) +
+			sizeof(OMX_HANDLETYPE) + sizeof(OMX_INDEXTYPE);
+	} else {
+		/*No buffer mapping required */
+		RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+			RPC_OMX_MAP_INFO_TYPE);
+	}
+
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nParamIndex, OMX_INDEXTYPE);
+	nDataOffset = nPos;
+	structSize = RPC_UTIL_GETSTRUCTSIZE(pCompParam);
+	RPC_SETFIELDCOPYGEN(pData, nPos, pCompParam, structSize);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+	if (*eCompReturn == OMX_ErrorNone)
+	{
+		pRetData = ((struct omx_packet *) pRetPacket)->data;
+		/*pCompParam is returned in the same location in which it was sent */
+		RPC_GETFIELDCOPYGEN(pRetData, nDataOffset, pCompParam,
+		    structSize);
+	}
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_SetConfig()
+ * @brief Remote invocation stub for OMX_SetConfig
+ * @param hRPCCtx [IN]      : The RPC context handle.
+ * @param nConfigIndex [IN] : Same as nConfigIndex received at the proxy.
+ * @param pCompConfig [IN]  : Same as pCompConfig recieved at the proxy.
+ * @param eCompReturn [OUT] : Return value returned by the remote component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_SetConfig(OMX_HANDLETYPE hRPCCtx,
+    OMX_INDEXTYPE nConfigIndex, OMX_PTR pCompConfig,
+    OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_U32 structSize = 0;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_SET_CONFIG;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	if (pLocBufNeedMap != NULL && (pLocBufNeedMap - pCompConfig) >= 0 ) {
+		RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF,
+			RPC_OMX_MAP_INFO_TYPE);
+		nOffset = (pLocBufNeedMap - pCompConfig) +
+			sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) +
+			sizeof(OMX_HANDLETYPE) + sizeof(OMX_INDEXTYPE);
+	} else {
+		/*No buffer mapping required */
+		RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+			RPC_OMX_MAP_INFO_TYPE);
+	}
+
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nConfigIndex, OMX_INDEXTYPE);
+	structSize = RPC_UTIL_GETSTRUCTSIZE(pCompConfig);
+	RPC_SETFIELDCOPYGEN(pData, nPos, pCompConfig, structSize);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name RPC_GetConfig()
+ * @brief Remote invocation stub for OMX_GetConfig
+ * @param hRPCCtx [IN]      : The RPC context handle.
+ * @param nConfigIndex [IN] : Same as nConfigIndex received at the proxy.
+ * @param pCompConfig [IN]  : Same as pCompConfig recieved at the proxy.
+ * @param eCompReturn [OUT] : Return value returned by the remote component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_GetConfig(OMX_HANDLETYPE hRPCCtx,
+    OMX_INDEXTYPE nConfigIndex, OMX_PTR pCompConfig,
+    OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData =
+		NULL, pRetData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0, nDataOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_U32 structSize = 0;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_GET_CONFIG;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	if (pLocBufNeedMap != NULL && (pLocBufNeedMap - pCompConfig) >= 0 ) {
+		RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF,
+			RPC_OMX_MAP_INFO_TYPE);
+		nOffset = (pLocBufNeedMap - pCompConfig) +
+			sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) +
+			sizeof(OMX_HANDLETYPE) + sizeof(OMX_INDEXTYPE);
+	} else {
+		/*No buffer mapping required */
+		RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+			RPC_OMX_MAP_INFO_TYPE);
+	}
+
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nConfigIndex, OMX_INDEXTYPE);
+	nDataOffset = nPos;
+	structSize = RPC_UTIL_GETSTRUCTSIZE(pCompConfig);
+	RPC_SETFIELDCOPYGEN(pData, nPos, pCompConfig, structSize);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+	if (*eCompReturn == RPC_OMX_ErrorNone)
+	{
+		pRetData = ((struct omx_packet *) pRetPacket)->data;
+		/*pCompParam is returned in the same location in which it was sent */
+		RPC_GETFIELDCOPYGEN(pRetData, nDataOffset, pCompConfig,
+		    structSize);
+	}
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_SendCommand()
+ * @brief Remote invocation stub for OMX_SendCommand
+ * @param hRPCCtx [IN]      : The RPC context handle.
+ * @param eCmd [IN]         : Same as eCmd received at the proxy.
+ * @param nParam [IN]       : Same as nParam recieved at the proxy.
+ * @param pCmdData [IN]     : Same as pCmdData recieved at the proxy.
+ * @param eCompReturn [OUT] : Return value returned by the remote component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_SendCommand(OMX_HANDLETYPE hRPCCtx,
+    OMX_COMMANDTYPE eCmd, OMX_U32 nParam, OMX_PTR pCmdData,
+    OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_U32 structSize = 0;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_SEND_CMD;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, eCmd, OMX_COMMANDTYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nParam, OMX_U32);
+
+	if (pCmdData != NULL && eCmd == OMX_CommandMarkBuffer)
+	{
+		/*The RPC_UTIL_GETSTRUCTSIZE will not work here since OMX_MARKTYPE structure
+		   does not have nSize field */
+		structSize = sizeof(OMX_MARKTYPE);
+		RPC_SETFIELDCOPYGEN(pData, nPos, pCmdData, structSize);
+	} else if (pCmdData != NULL)
+	{
+		structSize = RPC_UTIL_GETSTRUCTSIZE(pCmdData);
+		RPC_SETFIELDCOPYGEN(pData, nPos, pCmdData, structSize);
+	}
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_GetState()
+ * @brief Remote invocation stub for OMX_GetState
+ * @param hRPCCtx [IN]      : The RPC context handle.
+ * @param pState [OUT]      : State variable, to be filled in and returned by
+ *                            the remote component..
+ * @param eCompReturn [OUT] : Return value returned by the remote component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_GetState(OMX_HANDLETYPE hRPCCtx, OMX_STATETYPE * pState,
+    OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData =
+	    NULL, pRetData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_GET_STATE;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+	if (*eCompReturn == OMX_ErrorNone)
+	{
+		pRetData = ((struct omx_packet *) pRetPacket)->data;
+		RPC_GETFIELDCOPYTYPE(pRetData, nPos, pState, OMX_STATETYPE);
+	}
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_GetComponentVersion()
+ * @brief Remote invocation stub for OMX_GetComponentVersion
+ * @param hRPCCtx [IN]            : The RPC context handle.
+ * @param pComponentName [OUT]    : Component name, to be filled in and returned
+ *                                  by the remote component.
+ * @param pComponentVersion [OUT] : Component version info, to be filled in and
+ *                                  returned by the remote component.
+ * @param pSpecVersion [OUT]      : Spec version info, to be filled in and
+ *                                  returned by the remote component.
+ * @param pComponentUUID [OUT]    : Component UUID info, to be filled in and
+ *                                  returned by the remote component (optional).
+ * @param eCompReturn [OUT]       : Return value returned by the remote
+ *                                  component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_GetComponentVersion(OMX_HANDLETYPE hRPCCtx,
+    OMX_STRING pComponentName, OMX_VERSIONTYPE * pComponentVersion,
+    OMX_VERSIONTYPE * pSpecVersion, OMX_UUIDTYPE * pComponentUUID,
+    OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData =
+	    NULL, pRetData = NULL;
+	OMX_S32 status = 0;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_GET_VERSION;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+	if (*eCompReturn == OMX_ErrorNone)
+	{
+		pRetData = ((struct omx_packet *) pRetPacket)->data;
+		RPC_GETFIELDCOPYGEN(pRetData, nPos, pComponentName,
+		    OMX_MAX_STRINGNAME_SIZE);
+		RPC_GETFIELDCOPYTYPE(pRetData, nPos, pComponentVersion,
+		    OMX_VERSIONTYPE);
+		RPC_GETFIELDCOPYTYPE(pRetData, nPos, pSpecVersion,
+		    OMX_VERSIONTYPE);
+		//RPC_GETFIELDCOPYTYPE(pRetData, nPos, pComponentUUID, OMX_UUIDTYPE);
+	}
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_GetExtensionIndex()
+ * @brief Remote invocation stub for OMX_GetExtensionIndex
+ * @param hRPCCtx [IN]        : The RPC context handle.
+ * @param cParameterName [IN] : The parameter name sent by the user.
+ * @param pIndexType [OUT]    : Index type returned by the remote component.
+ * @param eCompReturn [OUT]   : Return value returned by the remote component.
+ * @return RPC_OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_GetExtensionIndex(OMX_HANDLETYPE hRPCCtx,
+    OMX_STRING cParameterName, OMX_INDEXTYPE * pIndexType,
+    OMX_ERRORTYPE * eCompReturn)
+{
+
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData =
+	    NULL, pRetData = NULL;
+	OMX_S32 status = 0;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	struct omx_packet *pOmxPacket = NULL;
+
+	nFxnIdx = RPC_OMX_FXN_IDX_GET_EXT_INDEX;
+
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDCOPYGEN(pData, nPos, cParameterName,
+	    OMX_MAX_STRINGNAME_SIZE);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+	if (*eCompReturn == OMX_ErrorNone)
+	{
+		pRetData = ((struct omx_packet *) pRetPacket)->data;
+		RPC_GETFIELDCOPYTYPE(pRetData, nPos, pIndexType,
+		    OMX_INDEXTYPE);
+	}
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	return eRPCError;
+
+}
+
+/* ***************************** DATA APIs ******************************** */
+
+/* ===========================================================================*/
+/**
+ * @name RPC_AllocateBuffer()
+ * @brief Remote invocation stub for OMX_AllcateBuffer()
+ * @param size   : Size of the incoming RCM message (parameter used in the RCM alloc call)
+ * @param *data  : Pointer to the RCM message/buffer received
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_AllocateBuffer(OMX_HANDLETYPE hRPCCtx,
+    OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, OMX_IN OMX_U32 nPortIndex,
+    OMX_U32 * pBufHeaderRemote, OMX_PTR pAppPrivate, OMX_U32 nSizeBytes,
+    OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData =
+	    NULL, pRetData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL;
+	OMX_BUFFERHEADERTYPE *pBufferHdr = *ppBufferHdr;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_ALLOCATE_BUFFER;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nPortIndex, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pAppPrivate, OMX_PTR);
+	RPC_SETFIELDVALUE(pData, nPos, nSizeBytes, OMX_U32);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+	if (*eCompReturn == OMX_ErrorNone)
+	{
+		pRetData = ((struct omx_packet *) pRetPacket)->data;
+		RPC_GETFIELDVALUE(pRetData, nPos, *pBufHeaderRemote, OMX_U32);
+		//save platform private before overwriting
+		pPlatformPrivate = (*ppBufferHdr)->pPlatformPrivate;
+		//RPC_GETFIELDCOPYTYPE(pData, nPos, pBufferHdr, OMX_BUFFERHEADERTYPE);
+		/*Copying each field of the header separately due to padding issues in
+		   the buffer header structure */
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nSize, OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nVersion,
+		    OMX_VERSIONTYPE);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pBuffer,
+		    OMX_U8 *);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nAllocLen,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nFilledLen,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nOffset,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pAppPrivate,
+		    OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->pPlatformPrivate, OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->pInputPortPrivate, OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->pOutputPortPrivate, OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->hMarkTargetComponent, OMX_HANDLETYPE);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pMarkData,
+		    OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nTickCount,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nTimeStamp,
+		    OMX_TICKS);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nFlags,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->nInputPortIndex, OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->nOutputPortIndex, OMX_U32);
+
+		(*ppBufferHdr)->pPlatformPrivate = pPlatformPrivate;
+
+#ifdef TILER_BUFF
+		DOMX_DEBUG(" Copying plat pvt. ");
+		//if (offset != 0)
+		{
+			RPC_GETFIELDCOPYTYPE(pRetData, nPos,
+			    (OMX_TI_PLATFORMPRIVATE
+				*) ((*ppBufferHdr)->pPlatformPrivate),
+			    OMX_TI_PLATFORMPRIVATE);
+			DOMX_DEBUG("Done copying plat pvt., aux buf = 0x%x",
+			    ((OMX_TI_PLATFORMPRIVATE
+				    *) ((*ppBufferHdr)->pPlatformPrivate))->
+			    pAuxBuf1);
+		}
+#endif
+
+	} else
+	{
+		//DOMX_DEBUG("OMX Error received: 0x%x",
+		//  pRPCMsg->msgHeader.nOMXReturn);
+	}
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name RPC_UseBuffer()
+ * @brief Remote invocation stub for OMX_AllcateBuffer()
+ * @param hComp: This is the handle on the Remote core, the proxy will replace
+                 it's handle with actual OMX Component handle that recides on the specified core
+ * @param ppBufferHdr:
+ * @param nPortIndex:
+ * @param pAppPrivate:
+ * @param eCompReturn: This is return value that will be supplied by Proxy to the caller.
+ *                    This is actual return value returned by the Remote component
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_UseBuffer(OMX_HANDLETYPE hRPCCtx,
+    OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, OMX_U32 nPortIndex,
+    OMX_PTR pAppPrivate, OMX_U32 nSizeBytes, OMX_U8 * pBuffer,
+    OMX_U32 * pBufHeaderRemote, OMX_ERRORTYPE * eCompReturn)
+{
+
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData =
+	    NULL, pRetData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL;
+	OMX_BUFFERHEADERTYPE *pBufferHdr = *ppBufferHdr;
+	struct omx_packet *pOmxPacket = NULL;
+	RPC_OMX_MAP_INFO_TYPE eMapInfo = RPC_OMX_MAP_INFO_NONE;
+	OMX_PTR pMetaDataBuffer = NULL;
+	OMX_U32 a =32;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_USE_BUFFER;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	DOMX_DEBUG("Marshaling data");
+	/*Buffer mapping required */
+	eMapInfo = RPC_OMX_MAP_INFO_ONE_BUF;
+	if (((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->
+	    pAuxBuf1 != NULL)
+		eMapInfo = RPC_OMX_MAP_INFO_TWO_BUF;
+	if (((OMX_TI_PLATFORMPRIVATE *)pBufferHdr->pPlatformPrivate)->
+	    pMetaDataBuffer != NULL)
+		eMapInfo = RPC_OMX_MAP_INFO_THREE_BUF;
+
+	/*Offset is the location of the buffer pointer from the start of the data packet */
+	nOffset =
+	    sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) +
+	    sizeof(OMX_HANDLETYPE) + sizeof(OMX_U32) + sizeof(OMX_PTR) +
+	    sizeof(OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, eMapInfo, RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nPortIndex, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pAppPrivate, OMX_PTR);
+	RPC_SETFIELDVALUE(pData, nPos, nSizeBytes, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, pBuffer, OMX_U32);
+	DOMX_DEBUG("eMapInfo = %x",eMapInfo);
+	if (eMapInfo >= RPC_OMX_MAP_INFO_TWO_BUF)
+	{
+		RPC_SETFIELDVALUE(pData, nPos,
+		    ((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->
+			pPlatformPrivate)->pAuxBuf1, OMX_U32);
+		DOMX_DEBUG("UV buffer fd= %d",((OMX_TI_PLATFORMPRIVATE *)pBufferHdr->pPlatformPrivate)->pAuxBuf1);
+	}
+
+	if (eMapInfo >= RPC_OMX_MAP_INFO_THREE_BUF)
+	{
+		RPC_SETFIELDVALUE(pData, nPos,
+		    ((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->
+			pPlatformPrivate)->pMetaDataBuffer, OMX_U32);
+		DOMX_DEBUG("Metadata buffer = %d",((OMX_TI_PLATFORMPRIVATE *)pBufferHdr->pPlatformPrivate)->pMetaDataBuffer);
+	}
+
+	DOMX_DEBUG("About to send packet");
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+	DOMX_DEBUG("Remote call returned");
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+	if (*eCompReturn == OMX_ErrorNone)
+	{
+		pRetData = ((struct omx_packet *) pRetPacket)->data;
+		RPC_GETFIELDVALUE(pRetData, nPos, *pBufHeaderRemote, OMX_U32);
+		//save platform private before overwriting
+		pPlatformPrivate = (*ppBufferHdr)->pPlatformPrivate;
+
+		/*Copying each field of the header separately due to padding issues in
+		   the buffer header structure */
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nSize, OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nVersion,
+		    OMX_VERSIONTYPE);
+		/*
+		   Do not expect buffer pointer - local buffer pointer is already
+		   present in the local header.
+		   RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pBuffer,
+		   OMX_U8 *);
+		 */
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nAllocLen,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nFilledLen,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nOffset,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pAppPrivate,
+		    OMX_PTR);
+		//Do not expect PlatformPrivate from Ducati
+		//RPC_GETFIELDVALUE(pRetData, nPos,pBufferHdr->pPlatformPrivate, OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->pInputPortPrivate, OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->pOutputPortPrivate, OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->hMarkTargetComponent, OMX_HANDLETYPE);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pMarkData,
+		    OMX_PTR);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nTickCount,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nTimeStamp,
+		    OMX_TICKS);
+		RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nFlags,
+		    OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->nInputPortIndex, OMX_U32);
+		RPC_GETFIELDVALUE(pRetData, nPos,
+		    pBufferHdr->nOutputPortIndex, OMX_U32);
+
+		//Do not expect PlatformPrivate from Ducati
+		/*
+		(*ppBufferHdr)->pPlatformPrivate = pPlatformPrivate;
+
+		DOMX_DEBUG(" Copying plat pvt. ");
+		RPC_GETFIELDCOPYTYPE(pRetData, nPos,
+		    (OMX_TI_PLATFORMPRIVATE *) ((*ppBufferHdr)->
+			pPlatformPrivate), OMX_TI_PLATFORMPRIVATE);*/
+
+		/*Resetting size as it might be diff on Ducati due to padding issues */
+		pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
+	}
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name RPC_FreeBuffer()
+ * @brief Remote invocation stub for OMX_AllcateBuffer()
+ * @param size   : Size of the incoming RCM message (parameter used in the RCM alloc call)
+ * @param *data  : Pointer to the RCM message/buffer received
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_FreeBuffer(OMX_HANDLETYPE hRPCCtx,
+    OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_U32 BufHdrRemote, OMX_U32 pBuffer,
+    OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	struct omx_packet *pOmxPacket = NULL;
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_FREE_BUFFER;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nPortIndex, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, BufHdrRemote, OMX_U32);
+	/* Buffer is being sent separately only to catch NULL buffer errors
+	   in PA mode */
+	RPC_SETFIELDVALUE(pData, nPos, pBuffer, OMX_U32);
+
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_EmptyThisBuffer()
+ * @brief
+ * @param size   : Size of the incoming RCM message (parameter used in the RCM alloc call)
+ * @param *data  : Pointer to the RCM message/buffer received
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+
+RPC_OMX_ERRORTYPE RPC_EmptyThisBuffer(OMX_HANDLETYPE hRPCCtx,
+    OMX_BUFFERHEADERTYPE * pBufferHdr, OMX_U32 BufHdrRemote,
+    OMX_ERRORTYPE * eCompReturn, OMX_BOOL bMapBuffer)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_U8 *pAuxBuf1 = NULL;
+	struct omx_packet *pOmxPacket = NULL;
+	RPC_OMX_MAP_INFO_TYPE eMapInfo = RPC_OMX_MAP_INFO_NONE;
+#ifdef RPC_SYNC_MODE
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL;
+#endif
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_EMPTYTHISBUFFER;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	if(bMapBuffer == OMX_TRUE)
+	{
+		pAuxBuf1 = ((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->pAuxBuf1;
+		/*Buffer mapping required */
+		if (((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->pAuxBuf1 == NULL)
+			eMapInfo = RPC_OMX_MAP_INFO_ONE_BUF;
+		else
+			eMapInfo = RPC_OMX_MAP_INFO_TWO_BUF;
+		/*Offset is the location of the buffer pointer from the start of the data packet */
+		nOffset =
+	    		sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) +
+	   		sizeof(OMX_HANDLETYPE) + sizeof(OMX_BUFFERHEADERTYPE *) + 3*sizeof(OMX_U32) +
+			sizeof(OMX_TICKS) + sizeof(OMX_HANDLETYPE) + sizeof(OMX_PTR) + 3*sizeof(OMX_U32);
+	}
+
+	RPC_SETFIELDVALUE(pData, nPos, eMapInfo, RPC_OMX_MAP_INFO_TYPE);
+
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos,
+	    (OMX_BUFFERHEADERTYPE *) BufHdrRemote, OMX_BUFFERHEADERTYPE *);
+
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nFilledLen, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nOffset, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nFlags, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nTimeStamp, OMX_TICKS);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->hMarkTargetComponent,
+	    OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->pMarkData, OMX_PTR);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nAllocLen, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nOutputPortIndex, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nInputPortIndex, OMX_U32);
+
+	if(bMapBuffer == OMX_TRUE)
+	{
+		RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->pBuffer, OMX_U32);
+		if (eMapInfo == RPC_OMX_MAP_INFO_TWO_BUF)
+		{
+			RPC_SETFIELDVALUE(pData, nPos,
+			    ((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->pAuxBuf1, OMX_U32);
+		}
+	}
+
+	DOMX_DEBUG(" pBufferHdr = %x BufHdrRemote %x", pBufferHdr,
+	    BufHdrRemote);
+
+#ifdef RPC_SYNC_MODE
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+#else
+	RPC_sendPacket_async(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket,
+	    nFxnIdx);
+	RPC_checkAsyncErrors(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket);
+
+	*eCompReturn = OMX_ErrorNone;
+#endif
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_FillThisBuffer()
+ * @brief Remote invocation stub for OMX_AllcateBuffer()
+ * @param size   : Size of the incoming RCM message (parameter used in the RCM alloc call)
+ * @param *data  : Pointer to the RCM message/buffer received
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_FillThisBuffer(OMX_HANDLETYPE hRPCCtx,
+    OMX_BUFFERHEADERTYPE * pBufferHdr, OMX_U32 BufHdrRemote,
+    OMX_ERRORTYPE * eCompReturn)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+	OMX_U32 nPacketSize = RPC_PACKET_SIZE;
+	RPC_OMX_FXN_IDX_TYPE nFxnIdx;
+	OMX_U32 nPos = 0, nSize = 0, nOffset = 0;
+	OMX_S32 status = 0;
+	RPC_OMX_CONTEXT *hCtx = hRPCCtx;
+	OMX_HANDLETYPE hComp = hCtx->hRemoteHandle;
+	OMX_U8 *pAuxBuf1 = NULL;
+	struct omx_packet *pOmxPacket = NULL;
+#ifdef RPC_SYNC_MODE
+	TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL;
+#endif
+
+	DOMX_ENTER("");
+
+	nFxnIdx = RPC_OMX_FXN_IDX_FILLTHISBUFFER;
+	RPC_getPacket(nPacketSize, pPacket);
+	RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize);
+
+	/*No buffer mapping required */
+	RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE,
+	    RPC_OMX_MAP_INFO_TYPE);
+	RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32);
+
+	RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE);
+	RPC_SETFIELDVALUE(pData, nPos,
+	    (OMX_BUFFERHEADERTYPE *) BufHdrRemote, OMX_BUFFERHEADERTYPE *);
+
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nFilledLen, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nOffset, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nFlags, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nAllocLen, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nOutputPortIndex, OMX_U32);
+	RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nInputPortIndex, OMX_U32);
+
+	DOMX_DEBUG(" pBufferHdr = %x BufHdrRemote %x", pBufferHdr,
+	    BufHdrRemote);
+
+#ifdef RPC_SYNC_MODE
+	RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket,
+	    nSize);
+
+	*eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result);
+
+#else
+	RPC_sendPacket_async(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket,
+	    nFxnIdx);
+	RPC_checkAsyncErrors(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket);
+
+	*eCompReturn = OMX_ErrorNone;
+#endif
+
+      EXIT:
+	if (pPacket)
+		RPC_freePacket(pPacket);
+	if (pRetPacket)
+		RPC_freePacket(pRetPacket);
+
+	DOMX_EXIT("");
+	return eRPCError;
+}
+
+
+/* ***************************** EMPTY APIs ******************************** */
+
+/* ===========================================================================*/
+/**
+ * @name EMPTY-STUB
+ * @brief
+ * @param
+ * @return
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE RPC_EventHandler(OMX_HANDLETYPE hRPCCtx, OMX_PTR pAppData,
+    OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2, OMX_PTR pEventData)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE RPC_EmptyBufferDone(OMX_HANDLETYPE hRPCCtx, OMX_PTR pAppData,
+    OMX_BUFFERHEADERTYPE * pBuffer)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE RPC_FillBufferDone(OMX_HANDLETYPE hRPCCtx, OMX_PTR pAppData,
+    OMX_BUFFERHEADERTYPE * pBuffer)
+{
+	return RPC_OMX_ErrorNone;
+}
+
+RPC_OMX_ERRORTYPE RPC_ComponentTunnelRequest(OMX_HANDLETYPE hRPCCtx,
+    OMX_IN OMX_U32 nPort, OMX_HANDLETYPE hTunneledhRemoteHandle,
+    OMX_U32 nTunneledPort, OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup,
+    OMX_ERRORTYPE * nCmdStatus)
+{
+	return RPC_OMX_ErrorNone;
+}
diff --git a/domx/domx/omx_rpc/src/omx_rpc_utils.c b/domx/domx/omx_rpc/src/omx_rpc_utils.c
new file mode 100755
index 0000000..b1e47a8
--- /dev/null
+++ b/domx/domx/omx_rpc/src/omx_rpc_utils.c
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_rpc_utils.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework RPC.
+ *
+ *  @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation
+ *!
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <string.h>
+#include <stdio.h>
+
+#include "omx_rpc.h"
+#include "omx_rpc_internal.h"
+#include "omx_rpc_utils.h"
+#include <MultiProc.h>
+#include <ProcMgr.h>
+
+extern char rcmservertable[MAX_PROC][MAX_SERVER_NAME_LENGTH];
+extern char Core_Array[MAX_PROC][MAX_CORENAME_LENGTH];
+
+/* ===========================================================================*/
+/**
+ * @name EMPTY-STUB
+ * @brief
+ * @param
+ * @return
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_UTIL_GetTargetServerName(OMX_STRING ComponentName,
+    OMX_STRING ServerName)
+{
+	OMX_U8 count = 0;
+	OMX_U8 i = 0;
+	OMX_U8 servertable_idx = 0;
+	OMX_STRING str;
+	char Core[MAX_CORENAME_LENGTH];
+
+	DOMX_ENTER("");
+	DOMX_DEBUG(" Calling Component Name %s", ComponentName);
+
+	while (*ComponentName != '\0')
+	{
+		if (*ComponentName == '.')
+		{
+			count++;
+			if (count == 2)
+			{
+				ComponentName++;
+				str = ComponentName;
+
+				while (*str != '.')
+				{
+					Core[i] = *str;
+					i++;
+					str++;
+				}
+				Core[i] = '\0';
+				break;
+			}
+
+		}
+
+		ComponentName++;
+	}
+
+	DOMX_DEBUG(" CORE NAME RECOVERED: %s", Core);
+	DOMX_DEBUG
+	    ("____________________________________________________________");
+	DOMX_DEBUG("Recovering Server Table Index");
+	for (i = 0; i < CORE_MAX; i++)
+	{
+
+		if (strcmp(Core, Core_Array[i]) == 0)
+		{
+			servertable_idx = i;
+			DOMX_DEBUG("Recovered Server table index = %d", i);
+			break;
+		}
+	}
+	strncpy(ServerName, (OMX_STRING) rcmservertable[servertable_idx],
+	    MAX_SERVER_NAME_LENGTH);
+	DOMX_DEBUG(" ServerName recovered = %s", ServerName);
+
+	return RPC_OMX_ErrorNone;
+}
+
+/* ===========================================================================*/
+/**
+ * @name EMPTY-STUB
+ * @brief
+ * @param
+ * @return
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_UTIL_GetLocalServerName(OMX_STRING ComponentName,
+    OMX_STRING * ServerName)
+{
+/* Implementation returns only current core ID - But this is a place holder to abstract out the
+default server and other additional servers available on the current core. This additional servers
+should be available in the RPC global that is indexed using the calling component name*/
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_U8 servertable_idx = 0;
+
+	servertable_idx = MultiProc_getId(NULL);	//This can be replace with the mechanism to obtain new addition rcm servers
+	if (MultiProc_INVALIDID != servertable_idx)
+		*ServerName = rcmservertable[servertable_idx];
+	else
+		eRPCError = RPC_OMX_ErrorUndefined;
+
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_UTIL_GenerateLocalServerName()
+ * @brief This function generates a server name to be used while creating the
+ *        RCM server. The name is based on the pid so that eacj process gets a
+ *        unique server name.
+ * @param cServerName - This is filled in and returned with a valid value.
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_UTIL_GenerateLocalServerName(OMX_STRING cServerName)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_S32 pid = 0;
+	OMX_U32 nProcId = 0;
+
+	pid = getpid();
+	/*Using pid as the server name, thus limiting to only 1 server per process.
+	   This limitaion is partly enforce by syslink as well since max size of server
+	   name is 32 so only pid can fit into the name */
+	sprintf(cServerName, "%ld", pid);
+
+	nProcId = MultiProc_getId(NULL);
+	if (MultiProc_INVALIDID != nProcId)
+		/*Fill the server table with the newly generated name */
+		strncpy(rcmservertable[nProcId], cServerName,
+		    MAX_SERVER_NAME_LENGTH);
+	else
+		eRPCError = RPC_OMX_ErrorUndefined;
+
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_UTIL_GetTargetCore()
+ * @brief This function gets the target core id by parsing the component name.
+ *        It is assumed that component names follow the convention
+ *        <OMX>.<Company Name>.<Core Name>.<Domain>.<Component Details> with
+ *        all characters in upper case for e.g. OMX.TI.DUCATI1.VIDEO.H264E
+ * @param cComponentName - Name of the component.
+ * @param nCoreId - Core ID, this is filled in and returned.
+ * @return RPC_OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_UTIL_GetTargetCore(OMX_STRING cComponentName,
+    OMX_U32 * nCoreId)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_S8 cCoreName[MAX_SERVER_NAME_LENGTH] = { 0 };
+	OMX_S32 ret = 0;
+	OMX_U32 i = 0;
+
+	ret =
+	    sscanf(cComponentName, "%*[^'.'].%*[^'.'].%[^'.'].%*s",
+	    cCoreName);
+	RPC_assert(ret == 1, RPC_OMX_ErrorBadParameter,
+	    "Incorrect component name");
+
+	for (i = 0; i < CORE_MAX; i++)
+	{
+		if (strcmp((char *)cCoreName, Core_Array[i]) == 0)
+			break;
+	}
+	RPC_assert(i < CORE_MAX, RPC_OMX_ErrorBadParameter,
+	    "Unknown core name");
+	*nCoreId = i;
+
+      EXIT:
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name EMPTY-STUB
+ * @brief  the Api creates the RCM client on the target core(where the component sits).
+This happens in the context of the Default RCM server on the target core.
+The RCM server name to connect for this client will be the default RCM server on the calling core.
+This can be provided as an option as the name that you pass in the string server is used as the RCM server name
+input to the client create call.
+@Default_RcmServer - The default rcm server on the target core
+@Server - The name of the server on the calling core to connect to
+ * @param
+ * @return
+ *
+ */
+/* ===========================================================================*/
+/*
+RPC_OMX_ERRORTYPE RPC_GetTargetClient(OMX_STRING Default_RcmServer, OMX_STRING server, rcmhHndl)
+{
+
+
+}
+*/
+
+/* ===========================================================================*/
+/**
+ * @name EMPTY-STUB
+ * @brief
+ * @param
+ * @return
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_MapBuffer(OMX_U32 mappedBuffer)
+{
+	DOMX_ENTER("");
+	DOMX_DEBUG("Empty implementation ");
+	//PlaceHolder for Mapping Buffers - Cuurently no implementation here
+	return RPC_OMX_ErrorNone;
+}
+
+/* ===========================================================================*/
+/**
+ * @name EMPTY-STUB
+ * @brief
+ * @param
+ * @return
+ *
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_UnMapBuffer(OMX_U32 mappedBuffer)
+{
+	DOMX_ENTER("");
+	DOMX_DEBUG("Empty implementation ");
+	//PlaceHolder for UnMapping Buffers - Cuurently no implementation here
+	return RPC_OMX_ErrorNone;
+}
+
+/* ===========================================================================*/
+/**
+ * @name RPC_FlushBuffer
+ * @brief Used to flush buffers from cache to memory. Used when buffers are
+ *        being transferred across processor boundaries.
+ * @param pBuffer       : Pointer to the data that has to be flushed.
+ *        size          : Size of the data to be flushed.
+ *        nTargetCoreId : Core to which buffer is being transferred.
+ * @return RPC_OMX_ErrorNone      : Success.
+ *         RPC_OMX_ErrorUndefined : Flush operation failed.
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_FlushBuffer(OMX_U8 * pBuffer, OMX_U32 size,
+    OMX_U32 nTargetCoreId)
+{
+	DOMX_ENTER("");
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_S32 nStatus = 0;
+
+	DOMX_DEBUG("About to flush %d bytes", size);
+	nStatus = ProcMgr_flushMemory((OMX_PTR) pBuffer, size,
+	    (ProcMgr_ProcId) nTargetCoreId);
+	RPC_assert(nStatus >= 0, RPC_OMX_ErrorUndefined,
+	    "Cache flush failed");
+
+      EXIT:
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_InvalidateBuffer
+ * @brief Used to flush buffers from cache to memory. Used when buffers are
+ *        being transferred across processor boundaries.
+ * @param pBuffer       : Pointer to the data that has to be flushed.
+ *        size          : Size of the data to be flushed.
+ *        nTargetCoreId : Core to which buffer is being transferred.
+ * @return RPC_OMX_ErrorNone      : Success.
+ *         RPC_OMX_ErrorUndefined : Invalidate operation failed.
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_InvalidateBuffer(OMX_U8 * pBuffer, OMX_U32 size,
+    OMX_U32 nTargetCoreId)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_S32 nStatus = 0;
+	DOMX_ENTER("");
+
+	DOMX_DEBUG("About to invalidate %d bytes", size);
+	nStatus = ProcMgr_invalidateMemory((OMX_PTR) pBuffer, size,
+	    (ProcMgr_ProcId) nTargetCoreId);
+	RPC_assert(nStatus >= 0, RPC_OMX_ErrorUndefined,
+	    "Cache invalidate failed");
+
+      EXIT:
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_Util_AcquireJobId
+ * @brief Used to get a new job id from syslink - all messages sent with the
+ *        same job id will be processed serially. Messages with different job id
+ *        will be processed parallely.
+ * @param hRPCCtx       : RPC context handle.
+ *        pJobId        : Pointer to job id - this'll be filled in and returned.
+ * @return RPC_OMX_ErrorNone      : Success.
+ *         Any other              : Operation failed.
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_Util_AcquireJobId(RPC_OMX_CONTEXT * hRPCCtx,
+    OMX_U16 * pJobId)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_S32 nStatus = 0;
+	DOMX_ENTER("");
+
+	nStatus =
+	    RcmClient_acquireJobId(hRPCCtx->ClientHndl[RCM_DEFAULT_CLIENT],
+	    pJobId);
+	RPC_assert(nStatus >= 0, RPC_OMX_ErrorUndefined,
+	    "Acquire job id failed");
+
+      EXIT:
+	DOMX_EXIT("eRPCError = %d", eRPCError);
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_Util_ReleaseJobId
+ * @brief Used to release job id to syslink. Once release, this job id cannot be
+ *        reused.
+ * @param hRPCCtx       : RPC context handle.
+ *        nJobId        : Job ID to be released.
+ * @return RPC_OMX_ErrorNone      : Success.
+ *         Any other              : Operation failed.
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_Util_ReleaseJobId(RPC_OMX_CONTEXT * hRPCCtx,
+    OMX_U16 nJobId)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	OMX_S32 nStatus = 0;
+	DOMX_ENTER("");
+
+	nStatus =
+	    RcmClient_releaseJobId(hRPCCtx->ClientHndl[RCM_DEFAULT_CLIENT],
+	    nJobId);
+	RPC_assert(nStatus >= 0, RPC_OMX_ErrorUndefined,
+	    "Release job id failed");
+
+      EXIT:
+	DOMX_EXIT("eRPCError = %d", eRPCError);
+	return eRPCError;
+}
+
+
+
+/* ===========================================================================*/
+/**
+ * @name RPC_Util_GetPoolId
+ * @brief Used to get pool id. Messages sent with same pool id will get
+ *        processed at the same priority on remote core.
+ * @param hRPCCtx       : RPC context handle.
+ *        pPoolId       : Pointer to pool id - this'll be filled in and
+ *                        returned.
+ * @return RPC_OMX_ErrorNone      : Success.
+ *         Any other              : Operation failed.
+ */
+/* ===========================================================================*/
+RPC_OMX_ERRORTYPE RPC_Util_GetPoolId(RPC_OMX_CONTEXT * hRPCCtx,
+    OMX_U16 * pPoolId)
+{
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	DOMX_ENTER("");
+
+	*pPoolId = 0x8001;
+
+//EXIT:
+	DOMX_EXIT("eRPCError = %d", eRPCError);
+	return eRPCError;
+}
diff --git a/domx/domx/rpmsg_omx_defs.h b/domx/domx/rpmsg_omx_defs.h
new file mode 100644
index 0000000..d3df1f5
--- /dev/null
+++ b/domx/domx/rpmsg_omx_defs.h
@@ -0,0 +1,54 @@
+/*
+ * OMX offloading remote processor driver
+ */
+
+#ifndef RPMSG_OMX_DEFS_H
+#define RPMSG_OMX_DEFS_H
+
+#include <linux/rpmsg_omx.h>
+
+//AD - from SDO
+/*
+ *  ======== OMX_Packet ========
+ *
+ *  OMX_Packet.desc: the package descriptor field. Note that the
+ *  format is different for out-bound and in-bound messages.
+ *
+ *  out-bound message descriptor
+ *
+ *  Bits    Description
+ *  --------------------------------------------------------------------
+ *  [15:12] reserved
+ *  [11:8]  omx message type
+ *  [7:0]   omx client protocol version
+ *
+ *
+ *  in-bound message descriptor
+ *
+ *  Bits    Description
+ *  --------------------------------------------------------------------
+ *  [15:12] reserved
+ *  [11:8]  omx server status code
+ *  [7:0]   omx server protocol version
+ */
+/* message type values */
+#define OMX_DESC_MSG        0x1       // exec sync command
+#define OMX_DESC_SYM_ADD    0x3       // symbol add message
+#define OMX_DESC_SYM_IDX    0x4       // query symbox index
+#define OMX_DESC_CMD        0x5       // exec non-blocking command.
+#define OMX_DESC_TYPE_MASK  0x0F00    // field mask
+#define OMX_DESC_TYPE_SHIFT 8         // field shift width
+
+/* omx server status codes must be 0 - 15, it has to fit in a 4-bit field */
+#define OMXSERVER_STATUS_SUCCESS          ((uint16_t)0) // success
+#define OMXSERVER_STATUS_INVALID_FXN      ((uint16_t)1) // invalid fxn index
+#define OMXSERVER_STATUS_SYMBOL_NOT_FOUND ((uint16_t)2) // symbol not found
+#define OMXSERVER_STATUS_INVALID_MSG_TYPE ((uint16_t)3) // invalid msg type
+#define OMXSERVER_STATUS_MSG_FXN_ERR      ((uint16_t)4) // msg function error
+#define OMXSERVER_STATUS_ERROR            ((uint16_t)5) // general failure
+#define OMXSERVER_STATUS_UNPROCESSED      ((uint16_t)6) // unprocessed message
+
+#define OMX_POOLID_JOBID_DEFAULT (0x00008000)
+#define OMX_INVALIDFXNIDX ((uint32_t)(0xFFFFFFFF))
+
+#endif /* RPMSG_OMX_DEFS_H */
diff --git a/domx/make/build.mk b/domx/make/build.mk
new file mode 100644
index 0000000..2faeffa
--- /dev/null
+++ b/domx/make/build.mk
@@ -0,0 +1,379 @@
+#
+#  Copyright 2001-2009 Texas Instruments - http://www.ti.com/
+# 
+#  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.
+
+#
+#  dspbridge/mpu_api/make/build.mk
+#
+#  DSP-BIOS Bridge build rules.
+
+# ALL PATHS IN MAKEFILE MUST BE RELATIVE TO ITS DIRECTORY
+
+CDEFS       += $(CMDDEFS) # Add command line definitions
+CDEFS       += $(PROCFAMILY) # Processor Family e.g. 3430
+CDEFS	    += $(CMDDEFS_START) # Definitions from start.mk
+#   ----------------------------------------------------------
+#   REMOVE LEADING AND TRAILING SPACES FROM MAKEFILE MACROS
+#   ----------------------------------------------------------
+
+TARGETNAME  := $(strip $(TARGETNAME))
+TARGETTYPE  := $(strip $(TARGETTYPE))
+SUBMODULES  := $(strip $(SUBMODULES))
+SOURCES     := $(strip $(SOURCES))
+INCLUDES    := $(strip $(INCLUDES))
+LIBINCLUDES := $(strip $(LIBINCLUDES))
+
+SH_SONAME   := $(strip $(SH_SONAME))
+ST_LIBS     := $(strip $(ST_LIBS))
+SH_LIBS     := $(strip $(SH_LIBS))
+
+CFLAGS      := $(strip $(CFLAGS))
+CDEFS       := $(strip $(CDEFS))
+EXEC_ARGS   := $(strip $(EXEC_ARGS))
+ST_LIB_ARGS := $(strip $(ST_LIB_ARGS))
+SH_LIB_ARGS := $(strip $(SH_LIB_ARGS))
+
+#   ----------------------------------------------------------
+#   COMPILER OPTIONS
+#   ----------------------------------------------------------
+
+# Preprocessor : dependency file generation
+ifndef NODEPENDS
+ifndef nodepends
+CFLAGS += -MD
+endif
+endif
+
+#   Overall
+CFLAGS += -pipe
+#   Preprocessor
+CFLAGS +=
+#   Debugging
+ifeq ($(BUILD),deb)
+CFLAGS += -g
+else
+CFLAGS += -fomit-frame-pointer
+endif
+#   Warnings
+CFLAGS += -Wall  -Wno-trigraphs -Werror-implicit-function-declaration #-Wno-format
+#   Optimizations
+#CFLAGS += -O2 -fno-strict-aliasing
+#CFLAGS += -Os -fno-strict-aliasing
+CFLAGS += -fno-strict-aliasing
+#   Machine dependent
+
+ifeq ($(PROCFAMILY),OMAP_3430)
+CFLAGS += -mapcs -mno-sched-prolog -mabi=aapcs-linux -mno-thumb-interwork -march=armv7-a -msoft-float -Uarm -D"KBUILD_STR(s)=\#s" -D"KBUILD_BASENAME=KBUILD_STR($(basename $(TARGETNAME)))" -D"KBUILD_MODNAME=KBUILD_STR($(basename $(TARGETNAME)))"  -DMODULE -D__LINUX_ARM_ARCH__=7 
+endif
+
+ifeq ($(PROCFAMILY),OMAP_4430)
+CFLAGS += -mapcs -mno-sched-prolog -mabi=aapcs-linux -mno-thumb-interwork -march=armv7-a -msoft-float -Uarm -D"KBUILD_STR(s)=\#s" -D"KBUILD_BASENAME=KBUILD_STR($(basename $(TARGETNAME)))" -D"KBUILD_MODNAME=KBUILD_STR($(basename $(TARGETNAME)))"  -DMODULE -D__LINUX_ARM_ARCH__=7
+endif
+
+#   Code generation
+CFLAGS += -fno-common
+#   Macros
+CFLAGS += -DLINUX $(addprefix -D, $(CDEFS))
+
+ifdef __KERNEL__
+CFLAGS      += -D__KERNEL__  -fno-builtin
+endif
+
+#   ----------------------------------------------------------
+#   OBJECTS
+#   ----------------------------------------------------------
+
+BUILDDIR    = .obj/
+
+# setup the target - check the given type - make sure we have the
+# correct suffix on it
+# TARGETNAME should not have a suffix on it - give an error if it does
+#ifneq ($(suffix $(TARGETNAME)),)
+#   $(error TARGETNAME can not have a suffix)
+#endif
+ifeq ($(TARGETTYPE),SH_LIB)
+   TARGET      := $(basename $(TARGETNAME)).so
+else
+ifeq ($(TARGETTYPE),MODULE)
+   TARGET      := $(basename $(TARGETNAME)).o
+   TARGETKO    := $(addsuffix .ko,$(basename $(TARGET)))
+   TARGETMOD   := $(addsuffix .mod,$(basename $(TARGET)))
+else
+ifeq ($(TARGETTYPE),ST_LIB)
+   TARGET      := $(basename $(TARGETNAME)).a
+else
+ifeq ($(TARGETTYPE),EXEC)
+   TARGET      := $(basename $(TARGETNAME)).out
+else
+ifneq ($(TARGETTYPE),)
+TARGET         := $(error Invalid TARGETTYPE)
+endif
+endif
+endif
+endif
+endif
+
+#LIBINCLUDES += $(TARGETDIR) $(TGTROOT)/lib $(TGTROOT)/usr/lib
+LIBINCLUDES += $(TARGETDIR)/lib $(TARGETDIR)/usr/lib 
+SRCDIRS :=  $(sort $(dir $(SOURCES)))
+OBJDIRS :=  $(addprefix $(BUILDDIR),$(SRCDIRS)) $(BUILDDIR)
+
+BASEOBJ := $(addsuffix .o,$(basename $(SOURCES)))
+OBJECTS := $(addprefix $(BUILDDIR), $(BASEOBJ))
+
+ST_LIBNAMES := $(addsuffix .a, $(addprefix lib, $(ST_LIBS)))
+DL_LIBNAMES := $(addsuffix .so, $(addprefix lib, $(SH_LIBS)))
+
+vpath %.a $(LIBINCLUDES) $(TGTROOT)/lib $(TGTROOT)/usr/lib
+vpath %.so $(LIBINCLUDES) $(TGTROOT)/lib $(TGTROOT)/usr/lib
+
+#   ----------------------------------------------------------
+#   BUILD ARGUMENTS
+#   ----------------------------------------------------------
+
+MAPFILE := -Wl,-Map,$(TARGET).map
+INCPATH := $(addprefix -I, . $(INCLUDES)) $(LINUXINCLUDE)
+LIBPATH := $(addprefix -L, $(LIBINCLUDES))
+LIBFILE := $(addprefix -l, $(ST_LIBS) $(SH_LIBS)) $(LIB_OBJS)
+
+ifeq ($(TARGETTYPE),SH_LIB)
+CFLAGS += -fpic
+TARGETARGS := $(SH_LIB_ARGS) -nostartfiles -nodefaultlibs -nostdlib -shared -Wl
+ifneq ($(SH_SONAME),)
+TARGETARGS += -Wl,-soname,$(SH_SONAME)
+endif
+endif
+
+ifeq ($(TARGETTYPE),MODULE)
+TARGETARGS := $(SH_LIB_ARGS) -nostartfiles -nodefaultlibs -nostdlib -Wl,-r
+ifneq ($(SH_SONAME),)
+TARGETARGS += -Wl,-soname,$(SH_SONAME)
+endif
+endif
+
+ifeq ($(TARGETTYPE),ST_LIB)
+TARGETARGS := $(ST_LIB_ARGS) -nostartfiles -nodefaultlibs -nostdlib -Wl,-r
+endif
+
+ifeq ($(TARGETTYPE),EXEC)
+TARGETARGS := $(EXEC_ARGS)
+endif
+
+.PHONY  :   all $(SUBMODULES) clean cleantrg SHELLERR Debug
+
+#   ==========================================================
+#   all
+#   ==========================================================
+all :  $(CHECKSHELL) $(SUBMODULES)
+
+#   ==========================================================
+#   Make submodules
+#   ==========================================================
+$(SUBMODULES):
+ifndef NORECURSE
+ifndef norecurse
+	$(MAKE) -C $@ $(filter-out $(SUBMODULES),$(MAKECMDGOALS))
+endif
+endif
+
+ifneq ($(TARGETTYPE),)
+
+# if this is driver module level , build KO file too
+ifneq ($(TOPLEVEL),)
+all :  $(OBJDIRS) $(TARGETKO)
+else
+all :  $(OBJDIRS) $(TARGET)
+endif
+
+#   ==========================================================
+#   Create directories
+#   ==========================================================
+$(OBJDIRS) $(TARGETDIR) :
+	@$(call MKDIR, $@)
+
+#   ==========================================================
+#   Product 2.6.x kernel module based on target
+#   ==========================================================
+
+# Link module .o with vermagic .o
+$(TARGETKO): $(TARGETMOD).o $(TARGET) 
+	$(LD) -EL -r -o $@ $^ 
+
+# Compile vermagic
+$(TARGETMOD).o: $(TARGETMOD).c 
+	$(CC) -c $(TARGETARGS) $(CFLAGS) $(INCPATH) -o $@ $<
+
+# Generate Module vermagic
+$(TARGETMOD).c: $(TARGET) 
+	$(MODPOST) $(TARGET)
+# removed - need to be done as a pre-step to building
+#	$(MAKE) -C $(KRNLSRC) modules	
+
+#   ==========================================================
+#   Build target
+#   ==========================================================
+$(TARGET):$(OBJECTS) $(ST_LIBNAMES) $(DL_LIBNAMES)
+#   @$(SHELLCMD) echo Building $@
+#	$(CC) $(TARGETARGS) $(CFLAGS) $(LIBPATH) $(MAPFILE) -o $@ $(BASEOBJ) $(LIBFILE)
+#	$(CC) $(TARGETARGS) $(CFLAGS) $(LIBPATH) $(MAPFILE) -o $@ $(OBJECTS) $(LIBFILE)
+ifeq ($(TARGETTYPE),ST_LIB)
+	$(AR) r $@ $(OBJECTS)
+else
+	$(CC) $(TARGETARGS) $(CFLAGS) $(LIBPATH) $(MAPFILE) -o $@ $(OBJECTS) $(LIBFILE)
+endif
+
+#   ==========================================================
+#   Compile .c file
+#   ==========================================================
+$(BUILDDIR)%.o:%.c
+#   echo Compiling $(patsubst $(BUILDDIR)%.o,%.c, $@)
+	$(CC) -c $(CFLAGS) $(INCPATH) -o $@ $(patsubst $(BUILDDIR)%.o,%.c, $@)
+
+#   ==========================================================
+#   Compile .S file
+#   ==========================================================
+$(BUILDDIR)%.o:%.S
+#   echo Compiling $(patsubst $(BUILDDIR)%.o,%.S, $@)
+	$(CC) -c $(CFLAGS) $(INCPATH) -o $@ $(patsubst $(BUILDDIR)%.o,%.S, $@)
+
+endif   # ifneq ($(TARGETTYPE),)
+
+#   ----------------------------------------------------------
+#   install - install the files
+#   ----------------------------------------------------------
+install:: $(TARGETDIR) $(SUBMODULES) $(TARGET)
+ifdef HOSTRELEASE
+ifdef SH_SONAME
+	$(INSTALL) -D $(TARGET) $(TARGETDIR)/$(HOSTRELEASE)/$(SH_SONAME)
+	$(RM) -f $(TARGETDIR)/$(HOSTRELEASE)/$(TARGET)
+	ln -s $(SH_SONAME) $(TARGETDIR)/$(HOSTRELEASE)/$(TARGET)
+else
+ifneq ($(TOPLEVEL),)
+	$(INSTALL) -D $(TARGETKO) $(TARGETDIR)/$(HOSTRELEASE)/$(TARGETKO)
+else
+	$(INSTALL) -D $(TARGET) $(TARGETDIR)/$(HOSTRELEASE)/$(TARGET)
+endif
+endif
+endif
+ifdef 0 # removed - components shouldn't put things in the production fs
+ifdef ROOTFSRELEASE
+	$(call MKDIR, $(ROOTFSDIR)/$(ROOTFSRELEASE))
+ifdef SH_SONAME
+	$(STRIP) --strip-unneeded -xgo $(ROOTFSDIR)/$(ROOTFSRELEASE)/$(SH_SONAME) $(TARGET)
+	$(RM) -f $(ROOTFSDIR)/$(ROOTFSRELEASE)/$(TARGET)
+	ln -s $(SH_SONAME) $(ROOTFSDIR)/$(ROOTFSRELEASE)/$(TARGET)
+else
+ifneq ($(TOPLEVEL),)
+	$(STRIP) --strip-unneeded -xgo $(ROOTFSDIR)/$(ROOTFSRELEASE)/$(TARGETKO) $(TARGETKO)
+else
+	$(STRIP) --strip-unneeded -xgo $(ROOTFSDIR)/$(ROOTFSRELEASE)/$(TARGET) $(TARGET)
+endif
+endif
+endif
+endif
+
+#   ----------------------------------------------------------
+#   clean - Remove build directory and target files
+#   Linux : Removes object and dependency files in build folder
+#   DOS   : Removes object dirs in build folder
+#   ----------------------------------------------------------
+clean : $(SUBMODULES)
+ifneq ($(TARGETTYPE),)
+ifneq ($(OBJECTS),)
+	- $(call RM,-f $(OBJECTS))
+	- $(call RM,-f $(OBJECTS:.o=.d))
+	- $(call RMDIR,-f $(BUILDDIR))
+endif
+	- $(call RM,-f $(TARGET))
+	- $(call RM,-f $(TARGET).map)
+	- $(call RM,-f $(TARGETKO))
+	- $(call RM,-f $(TARGETMOD).c)
+	- $(call RM,-f $(TARGETMOD).o)
+	- $(call RM,-f $(TARGETMOD).d)
+ifneq ($(TOPLEVEL),)
+	- @$(call RM,-f $(TARGETKO))
+	- @$(call RM,-f $(TARGETMOD).c)
+	- @$(call RM,-f $(TARGETMOD).o)
+	- @$(call RM,-f $(TARGETMOD).d)
+endif
+endif
+
+cleantrg : $(SUBMODULES)
+ifneq ($(TARGETTYPE),)
+	- @$(call RM, $(TARGET))
+	- @$(call RM, $(TARGET).map)
+ifneq ($(TOPLEVEL),)
+	- @$(call RM, $(TARGETKO))
+	- @$(call RM, $(TARGETMOD).c)
+	- @$(call RM, $(TARGETMOD).o)
+	- @$(call RM, $(TARGETMOD).d)
+endif
+endif
+
+#   ----------------------------------------------------------
+#   Include dependency files generated by preprocessor.
+#
+#   Dependency files are placed in main object directory because
+#   dependent files' paths for same source file varies with the
+#   directory from where gmake is run
+#   ----------------------------------------------------------
+ifndef NODEPENDS
+ifndef nodepends
+ifneq ($(OBJECTS),)
+-include $(OBJECTS:.o=.d)
+endif
+endif
+endif
+
+#   ----------------------------------------------------------
+#   Generate fatal error if make variable SHELL is incorrect
+#   ----------------------------------------------------------
+SHELLERR::
+	@$(SHELLCMD) echo Fatal error: SHELL set to $(SHELL) instead of $(MYSHELL)
+	@$(SHELLCMD) echo set $(MYSHELL) to correct path and CASE SENSITIVE FILE NAME and EXTENSTION
+	@$(SHELLCMD) echo of your command shell
+	$(ERR)
+
+
+#   ----------------------------------------------------------
+#   For debugging script
+#   ----------------------------------------------------------
+Debug::$(SUBMODULES)
+	@$(SHELLCMD) echo SHELL: $(SHELL)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo CDEFS: $(CDEFS)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo CONFIG_SHELL: $(CONFIG_SHELL)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo CURDIR: $(CURDIR)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo SRCDIRS: $(SRCDIRS)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo OBJDIRS: $(OBJDIRS)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo OBJECTS: $(OBJECTS)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo BUILDDIR: $(BUILDDIR)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo TARGETDIR TARGETNAME: $(TARGET)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo MAKEDIR: $(MAKEDIR)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo INCLUDES: $(INCLUDES)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo DL_LIBNAMES: $(DL_LIBNAMES)
+	@$(SHELLCMD) echo
+	@$(SHELLCMD) echo LIBFILE: $(LIBFILE)
+	@$(SHELLCMD) echo
+
diff --git a/domx/make/start.mk b/domx/make/start.mk
new file mode 100644
index 0000000..57921ac
--- /dev/null
+++ b/domx/make/start.mk
@@ -0,0 +1,101 @@
+#
+#  Copyright 2001-2009 Texas Instruments - http://www.ti.com/
+# 
+#  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.
+
+#
+#  dspbridge/mpu_api/make/start.mk
+#
+#  DSP-BIOS Bridge build rules.
+#
+
+# make sure we have a rootdir
+ifndef PROJROOT
+$(error Error: variable PROJROOT not defined)
+endif
+
+# make sure we have a bridgeroot
+#ifndef BRIDGEROOT
+#$(error Error: variable BRIDGEROOT not defined)
+#endif
+
+
+CMDDEFS =
+CMDDEFS_START =
+
+
+CROSS=arm-none-linux-gnueabi-
+PROCFAMILY=OMAP_4430
+
+
+ifndef PROCFAMILY
+$(error Error: PROCFAMILY can not be determined from Kernel .config)
+endif
+
+ifndef TARGETDIR
+TARGETDIR=$(PROJROOT)/target
+endif
+
+
+
+#default (first) target should be "all"
+#make sure the target directories are created
+#all: $(HOSTDIR) $(ROOTFSDIR) $(TARGETDIR)
+#all: $(TARGETDIR)
+
+CONFIG_SHELL := /bin/bash
+
+SHELL := $(CONFIG_SHELL)
+
+# Current version of gmake (3.79.1) cannot run windows shell's internal commands
+# We need to invoke command interpreter explicitly to do so.
+# for winnt it is cmd /c <command>
+SHELLCMD:=
+
+ifneq ($(SHELL),$(CONFIG_SHELL))
+CHECKSHELL:=SHELLERR
+else
+CHECKSHELL:=
+endif
+
+# Error string to generate fatal error and abort gmake
+ERR = $(error Makefile generated fatal error while building target "$@")
+
+CP  :=   cp
+
+MAKEFLAGS = r
+
+QUIET := &> /dev/null
+
+# Should never be :=
+RM    = rm $(1) 
+MV    = mv $(1) $(2)
+RMDIR = rm -r $(1)
+MKDIR = mkdir -p $(1)
+INSTALL = install
+
+# Current Makefile directory
+MAKEDIR := $(CURDIR)
+
+# Implicit rule search not needed for *.d, *.c, *.h
+%.d:
+%.c:
+%.h:
+
+#   Tools
+CC	:= $(CROSS)gcc
+AR	:= $(CROSS)ar
+LD	:= $(CROSS)ld
+STRIP	:= $(CROSS)strip
+
+
diff --git a/domx/mm_osal/Android.mk b/domx/mm_osal/Android.mk
new file mode 100644
index 0000000..a4862ec
--- /dev/null
+++ b/domx/mm_osal/Android.mk
@@ -0,0 +1,29 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+    src/timm_osal.c \
+    src/timm_osal_events.c \
+    src/timm_osal_memory.c \
+    src/timm_osal_mutex.c \
+    src/timm_osal_pipes.c \
+    src/timm_osal_semaphores.c \
+    src/timm_osal_task.c \
+    src/timm_osal_trace.c
+
+LOCAL_C_INCLUDES += \
+    $(LOCAL_PATH)/inc
+
+LOCAL_SHARED_LIBRARIES := \
+    libdl \
+    liblog \
+    libc
+
+LOCAL_CFLAGS += -DOMAP_2430 -DOMX_DEBUG -D_Android -D_POSIX_VERSION_1_
+LOCAL_CFLAGS += -DTIMM_OSAL_DEBUG_TRACE_DETAIL=1 # quiet
+
+LOCAL_MODULE:= libmm_osal
+LOCAL_MODULE_TAGS:= optional
+
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
diff --git a/domx/mm_osal/Makefile b/domx/mm_osal/Makefile
new file mode 100644
index 0000000..a83814f
--- /dev/null
+++ b/domx/mm_osal/Makefile
@@ -0,0 +1,61 @@
+
+include $(PROJROOT)/make/start.mk
+
+
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = libmm_osal
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = SH_LIB
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = lib
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = lib
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+    src/timm_osal.c \
+	src/timm_osal_events.c \
+	src/timm_osal_memory.c \
+	src/timm_osal_mutex.c \
+	src/timm_osal_pipes.c \
+	src/timm_osal_semaphores.c \
+	src/timm_osal_task.c \
+	src/timm_osal_trace.c
+
+
+
+# Search path for include files
+
+INCLUDES    = \
+    inc/ \
+
+
+
+ST_LIBS        = 
+SH_LIBS        = 
+#pthread
+#pthread rt utils procmgr ipc rcm notify
+#SH_LIBS        += sysmgr sysmemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES =
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
diff --git a/domx/mm_osal/inc/timm_osal_error.h b/domx/mm_osal/inc/timm_osal_error.h
new file mode 100755
index 0000000..37b20e7
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_error.h
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_timm_osal_error.h
+*  The osal header file defines the error codes
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_ERROR_H_
+#define _TIMM_OSAL_ERROR_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+#include "timm_osal_types.h"
+
+/** A unique ID for each component*/
+	typedef TIMM_OSAL_U16 TIMM_OSAL_COMPID;
+
+/** TIMM_OSAL_ERROR is a 32 bits unsigned integer.
+ *   Each error code can be broken up into three fields as given below:
+ * - Type of error (2 bits): NO_ERROR: 00, WARNING: 01, FATAL_ERROR: 10
+ * - Component ID (14 bits): A unique ID which indicates which of the component generated the error
+ * - Error ID (16 bits): The specific error generated by a component
+ */
+	typedef TIMM_OSAL_U32 TIMM_OSAL_ERRORTYPE;
+
+#define TIMM_OSAL_OK  0
+#define TIMM_OSAL_WAR 1
+#define TIMM_OSAL_ERR 2
+
+
+/* Macro to process TIMM_OSAL_ERROR */
+
+/** This macro tests if the provided M4OSA_ERR is a warning or not*/
+#define TIMM_OSAL_IS_WARNING(error)   ((((error)>>30) == TIMM_OSAL_WAR) ? 1:0)
+
+/** This macro tests if the provided M4OSA_ERR is a fatal error or not*/
+#define TIMM_OSAL_IS_ERROR(error)   ((((error)>>30) == TIMM_OSAL_ERR) ? 1:0)
+
+/** This macro returns an error code accroding to the 3 provided fields:
+  * @arg Type: (IN) [TIMM_OSAL_U32] Type of error to put in the error code
+  * @arg compID: (IN) [TIMM_OSAL_U32] CompID to put in the error code
+  * @arg errorID: (IN) [TIMM_OSAL_U32] ErrorID to put in the error code*/
+#define TIMM_OSAL_ERR_CREATE(type, compID, errorID)\
+   (((type)<<30)+(((compID)&0x003FFF)<<16)+((errorID)&0x00FFFF))
+
+/** This macro extracts the 3 fields from the error:
+  * @arg error: (IN) [TIMM_OSAL_ERRORTYPE] Error code
+  * @arg type: (OUT) [TIMM_OSAL_U32] Type of error in the error code
+  * @arg compID: (OUT) [TIMM_OSAL_U32] CompID to put in the error code
+  * @arg errorID: (OUT) [TIMM_OSAL_U32] ErrorID to put in the error code*/
+#define TIMM_OSAL_ERR_SPLIT(error, type, compID, errorID)\
+   { type=(TIMM_OSAL_U32)((error)>>30);\
+     compID=(TIMM_OSAL_U32)(((error)>>16)&0x003FFF);\
+     (TIMM_OSAL_U32)(errorID=(error)&0x00FFFF); }
+
+/* Component IDs */
+#define TIMM_OSAL_COMP_GENERAL      0x00
+#define TIMM_OSAL_COMP_MEMORY       0x01
+#define TIMM_OSAL_COMP_PIPES        0x02
+#define TIMM_OSAL_COMP_EVENTS       0x03
+#define TIMM_OSAL_COMP_SEMAPHORES   0x04
+#define TIMM_OSAL_COMP_TASK         0x05
+
+/* Definition of common error codes */
+/** there is no error*/
+#define TIMM_OSAL_ERR_NONE                 ((TIMM_OSAL_ERRORTYPE) 0x00000000)
+
+
+/** There is no more memory available*/
+#define TIMM_OSAL_ERR_ALLOC                ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000001))
+#define TIMM_OSAL_ERR_OUT_OF_RESOURCE      ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000002))
+
+/** Time out */
+#define TIMM_OSAL_WAR_TIMEOUT              ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_WAR,TIMM_OSAL_COMP_GENERAL,0x000003))
+#define TIMM_OSAL_ERR_PARAMETER            ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000004))
+#define TIMM_OSAL_ERR_NOT_READY            ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000005))
+#define TIMM_OSAL_ERR_OMX                  ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000006))
+#define TIMM_OSAL_ERR_PIPE_FULL            ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000007))
+#define TIMM_OSAL_ERR_PIPE_EMPTY           ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000008))
+#define TIMM_OSAL_ERR_PIPE_DELETED         ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000009))
+#define TIMM_OSAL_ERR_PIPE_RESET           ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x00000A))
+#define TIMM_OSAL_ERR_GROUP_DELETED        ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x00000B))
+#define TIMM_OSAL_ERR_UNKNOWN              ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x00000C))
+
+
+#define TIMM_OSAL_ERR_SEM_CREATE_FAILED    ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_SEMAPHORE,0x000001))
+
+/*Added during Linux Porting*/
+#define TIMM_OSAL_ERR_NO_PERMISSIONS		((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x00000D))
+#define TIMM_OSAL_ERR_RESOURCE_EXISTS		((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x00000E))
+#define TIMM_OSAL_ERR_RESOURCE_REMOVED		((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x00000F))
+#define TIMM_OSAL_ERR_SYSTEM_LIMIT_EXCEEDED	((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000010))
+#define TIMM_OSAL_ERR_NOT_SUPPORTED		((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000011))
+#define TIMM_OSAL_ERR_SIGNAL_CAUGHT		((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000012))
+#define TIMM_OSAL_ERR_TIMEOUT              ((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_GENERAL,0x000013))
+
+
+
+#define TIMM_OSAL_COMP_MSG_Q        0x06
+#define TIMM_OSAL_ERR_MSG_SIZE_MISMATCH		((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_MSG_Q,0x000001))
+#define TIMM_OSAL_ERR_MSG_TYPE_NOT_FOUND	((TIMM_OSAL_ERRORTYPE) TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR,TIMM_OSAL_COMP_MSG_Q,0x000002))
+
+
+/*
+#define GOTO_EXIT_IF(_Cond,_ErrorCode) { \
+    if ((_Cond)) { \
+        status = _ErrorCode; \
+        printf ("Error :: %s : %s : %d :: Exiting because : %s\n", \
+                __FILE__, __FUNCTION__, __LINE__, #_Cond); \
+        goto EXIT; \
+    } \
+}
+*/
+
+#define SWITCH_CASE(_Case, _ErrCode, _ErrMsg)\
+	case _Case:\
+		TIMM_OSAL_Error(_ErrMsg);\
+		bReturnStatus = _ErrCode;\
+		break;
+
+#define SWITCH_DEFAULT_CASE(_ErrCode, _ErrMsg )\
+	default:\
+		TIMM_OSAL_Error(_ErrMsg);\
+		bReturnStatus = _ErrCode;\
+		break;
+
+
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif /*_TIMM_OSAL_ERROR_H_*/
diff --git a/domx/mm_osal/inc/timm_osal_events.h b/domx/mm_osal/inc/timm_osal_events.h
new file mode 100755
index 0000000..20a4d84
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_events.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_defines.h
+*  The osal header file defines
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_EVENTS_H_
+#define _TIMM_OSAL_EVENTS_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+#include "timm_osal_types.h"
+
+	typedef enum TIMM_OSAL_EVENT_OPERATION
+	{
+		TIMM_OSAL_EVENT_AND,
+		TIMM_OSAL_EVENT_AND_CONSUME,
+		TIMM_OSAL_EVENT_OR,
+		TIMM_OSAL_EVENT_OR_CONSUME
+	} TIMM_OSAL_EVENT_OPERATION;
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_EventCreate(TIMM_OSAL_PTR * pEvents);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_EventDelete(TIMM_OSAL_PTR pEvents);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_EventSet(TIMM_OSAL_PTR pEvents,
+	    TIMM_OSAL_U32 uEventFlag, TIMM_OSAL_EVENT_OPERATION eOperation);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_EventRetrieve(TIMM_OSAL_PTR pEvents,
+	    TIMM_OSAL_U32 uRequestedEvents,
+	    TIMM_OSAL_EVENT_OPERATION eOperation,
+	    TIMM_OSAL_U32 * pRetrievedEvents, TIMM_OSAL_U32 uTimeOut);
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_EVENTS_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_interfaces.h b/domx/mm_osal/inc/timm_osal_interfaces.h
new file mode 100755
index 0000000..dd3fd81
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_interfaces.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_memory.h
+*  The osal header file defines
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_INTERFACES_H_
+#define _TIMM_OSAL_INTERFACES_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/*******************************************************************************
+* External interface
+*******************************************************************************/
+#include "timm_osal_types.h"
+#include "timm_osal_error.h"
+#include "timm_osal_memory.h"
+#include "timm_osal_pipes.h"
+#include "timm_osal_events.h"
+#include "timm_osal_semaphores.h"
+#include "timm_osal_mutex.h"
+#include "timm_osal_task.h"
+#include "timm_osal_osal.h"
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_INTERFACES_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_memory.h b/domx/mm_osal/inc/timm_osal_memory.h
new file mode 100755
index 0000000..ed21636
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_memory.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_memory.h
+*  The osal header file defines
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_MEMORY_H_
+#define _TIMM_OSAL_MEMORY_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/*******************************************************************************
+* Includes
+*******************************************************************************/
+
+#include "timm_osal_types.h"
+#include "timm_osal_error.h"
+
+
+/* Enumeration Flag for Memory Segmenation Id */
+	typedef enum TIMMOSAL_MEM_SEGMENTID
+	{
+
+		TIMMOSAL_MEM_SEGMENT_EXT = 0,
+		TIMMOSAL_MEM_SEGMENT_INT,
+		TIMMOSAL_MEM_SEGMENT_UNCACHED
+	} TIMMOSAL_MEM_SEGMENTID;
+
+
+/*******************************************************************************
+* External interface
+*******************************************************************************/
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreateMemoryPool(void);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_DeleteMemoryPool(void);
+
+	TIMM_OSAL_PTR TIMM_OSAL_Malloc(TIMM_OSAL_U32 size,
+	    TIMM_OSAL_BOOL bBlockContiguous, TIMM_OSAL_U32 unBlockAlignment,
+	    TIMMOSAL_MEM_SEGMENTID tMemSegId);
+
+	void TIMM_OSAL_Free(TIMM_OSAL_PTR pData);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_Memset(TIMM_OSAL_PTR pBuffer,
+	    TIMM_OSAL_U8 uValue, TIMM_OSAL_U32 uSize);
+
+	TIMM_OSAL_S32 TIMM_OSAL_Memcmp(TIMM_OSAL_PTR pBuffer1,
+	    TIMM_OSAL_PTR pBuffer2, TIMM_OSAL_U32 uSize);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_Memcpy(TIMM_OSAL_PTR pBufDst,
+	    TIMM_OSAL_PTR pBufSrc, TIMM_OSAL_U32 uSize);
+
+	TIMM_OSAL_U32 TIMM_OSAL_GetMemCounter(void);
+
+#define TIMM_OSAL_MallocExtn(size, bBlockContiguous, unBlockAlignment, tMemSegId, hHeap) \
+    TIMM_OSAL_Malloc(size, bBlockContiguous, unBlockAlignment, tMemSegId )
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_DEFINES_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_mutex.h b/domx/mm_osal/inc/timm_osal_mutex.h
new file mode 100755
index 0000000..1d12c91
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_mutex.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_defines.h
+*  The osal header file defines
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_MUTEX_H_
+#define _TIMM_OSAL_MUTEX_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/*******************************************************************************
+* Includes
+*******************************************************************************/
+
+#include "timm_osal_types.h"
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_MutexCreate(TIMM_OSAL_PTR * pMutex);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_MutexDelete(TIMM_OSAL_PTR pMutex);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_MutexObtain(TIMM_OSAL_PTR pMutex,
+	    TIMM_OSAL_U32 uTimeOut);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_MutexRelease(TIMM_OSAL_PTR pMutex);
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_MUTEX_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_osal.h b/domx/mm_osal/inc/timm_osal_osal.h
new file mode 100755
index 0000000..a4e0e9e
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_osal.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_osal.h
+*  The osal header file defines
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_OSAL_H_
+#define _TIMM_OSAL_OSAL_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/*******************************************************************************
+* Includes
+*******************************************************************************/
+
+#include "timm_osal_types.h"
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_Init(void);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_Deinit(void);
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_OSAL_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_pipes.h b/domx/mm_osal/inc/timm_osal_pipes.h
new file mode 100755
index 0000000..79d7d61
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_pipes.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_defines.h
+*  The osal header file defines
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_PIPES_H_
+#define _TIMM_OSAL_PIPES_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+#include "timm_osal_types.h"
+
+/*
+* Defined for Pipe timeout value
+*/
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreatePipe(TIMM_OSAL_PTR * pPipe,
+	    TIMM_OSAL_U32 pipeSize,
+	    TIMM_OSAL_U32 messageSize, TIMM_OSAL_U8 isFixedMessage);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_DeletePipe(TIMM_OSAL_PTR pPipe);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_WriteToPipe(TIMM_OSAL_PTR pPipe,
+	    void *pMessage, TIMM_OSAL_U32 size, TIMM_OSAL_S32 timeout);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_WriteToFrontOfPipe(TIMM_OSAL_PTR pPipe,
+	    void *pMessage, TIMM_OSAL_U32 size, TIMM_OSAL_S32 timeout);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_ReadFromPipe(TIMM_OSAL_PTR pPipe,
+	    void *pMessage,
+	    TIMM_OSAL_U32 size,
+	    TIMM_OSAL_U32 * actualSize, TIMM_OSAL_S32 timeout);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_ClearPipe(TIMM_OSAL_PTR pPipe);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_IsPipeReady(TIMM_OSAL_PTR pPipe);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_GetPipeReadyMessageCount(TIMM_OSAL_PTR
+	    pPipe, TIMM_OSAL_U32 * count);
+
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_PIPES_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_semaphores.h b/domx/mm_osal/inc/timm_osal_semaphores.h
new file mode 100755
index 0000000..86037d7
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_semaphores.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_defines.h
+*  The osal header file defines
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_SEMAPHORE_H_
+#define _TIMM_OSAL_SEMAPHORE_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/*******************************************************************************
+* Includes
+*******************************************************************************/
+
+#include "timm_osal_types.h"
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreCreate(TIMM_OSAL_PTR *
+	    pSemaphore, TIMM_OSAL_U32 uInitCount);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreDelete(TIMM_OSAL_PTR
+	    pSemaphore);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreObtain(TIMM_OSAL_PTR
+	    pSemaphore, TIMM_OSAL_U32 uTimeOut);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreRelease(TIMM_OSAL_PTR
+	    pSemaphore);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreReset(TIMM_OSAL_PTR pSemaphore,
+	    TIMM_OSAL_U32 uInitCount);
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_GetSemaphoreCount(TIMM_OSAL_PTR
+	    pSemaphore, TIMM_OSAL_U32 * count);
+
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_SEMAPHORE_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_task.h b/domx/mm_osal/inc/timm_osal_task.h
new file mode 100755
index 0000000..6f67a82
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_task.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_task.h
+*  The osal header file defines
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_TASK_H_
+#define _TIMM_OSAL_TASK_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/*******************************************************************************
+* Includes
+*******************************************************************************/
+
+#include "timm_osal_types.h"
+
+/*******************************************************************************
+* Tasks
+*******************************************************************************/
+
+/**
+* prototype for the task function
+*/
+	/*typedef void (*TIMM_OSAL_TaskProc)(TIMM_OSAL_U32 argc, TIMM_OSAL_PTR argv);*//*Nucleus */
+
+	typedef void *(*TIMM_OSAL_TaskProc) (void *arg);	/*Linux */
+
+
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreateTask(TIMM_OSAL_PTR * pTask,
+	    TIMM_OSAL_TaskProc pFunc,
+	    TIMM_OSAL_U32 uArgc,
+	    TIMM_OSAL_PTR pArgv,
+	    TIMM_OSAL_U32 uStackSize,
+	    TIMM_OSAL_U32 uPriority, TIMM_OSAL_S8 * pName);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_DeleteTask(TIMM_OSAL_PTR pTask);
+
+	TIMM_OSAL_ERRORTYPE TIMM_OSAL_SleepTask(TIMM_OSAL_U32 mSec);
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_TASK_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_trace.h b/domx/mm_osal/inc/timm_osal_trace.h
new file mode 100755
index 0000000..3c4b8d7
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_trace.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_trace.h
+*  The timm_osal_types header file defines the primative osal type definitions.
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_TRACES_H_
+#define _TIMM_OSAL_TRACES_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/*******************************************************************************
+* Traces
+*******************************************************************************/
+
+
+/******************************************************************************
+* Debug Trace defines
+******************************************************************************/
+
+	typedef enum TIMM_OSAL_TRACEGRP_TYPE
+	{
+		TIMM_OSAL_TRACEGRP_SYSTEM = 1,
+		TIMM_OSAL_TRACEGRP_OMXBASE = (1 << 1),
+		TIMM_OSAL_TRACEGRP_DOMX = (1 << 2),
+		TIMM_OSAL_TRACEGRP_OMXVIDEOENC = (1 << 3),
+		TIMM_OSAL_TRACEGRP_OMXVIDEODEC = (1 << 4),
+		TIMM_OSAL_TRACEGRP_OMXCAM = (1 << 5),
+		TIMM_OSAL_TRACEGRP_OMXIMGDEC = (1 << 6),
+		TIMM_OSAL_TRACEGRP_DRIVERS = (1 << 7),
+		TIMM_OSAL_TRACEGRP_SIMCOPALGOS = (1 << 8)
+	} TIMM_OSAL_TRACEGRP;
+
+
+/**
+* The OSAL debug trace level can be set at runtime by defining the environment
+* variable TIMM_OSAL_DEBUG_TRACE_LEVEL=<Level>.  The default level is 1
+* The debug levels are:
+* Level 0 - No trace
+* Level 1 - Error   [Errors]
+* Level 2 - Warning [Warnings that are useful to know about]
+* Level 3 - Info    [General information]
+* Level 4 - Debug   [most-commonly used statement for us developers]
+* Level 5 - Trace   ["ENTERING <function>" and "EXITING <function>" statements]
+*
+* Example: if TIMM_OSAL_DEBUG_TRACE_LEVEL=3, then level 1,2 and 3 traces messages
+* are enabled.
+*/
+
+/**
+ * Information about the trace location/type, passed as a single pointer to
+ * internal trace function.  Not part of the public API
+ */
+	typedef struct
+	{
+		const char *file;
+		const char *function;
+		const int line;
+		const short level;
+		const short tracegrp;	/* TIMM_OSAL_TRACEGRP */
+	} __TIMM_OSAL_TRACE_LOCATION;
+
+/**
+ * Trace implementation function.  Not part of public API.  Default
+ * implementation uses printf(), but you can use LD_PRELOAD to plug in
+ * alternative trace system at runtime.
+ */
+	void __TIMM_OSAL_TraceFunction(const __TIMM_OSAL_TRACE_LOCATION * loc,
+	    const char *fmt, ...);
+
+/**
+ * Internal trace macro.  Not part of public API.
+ */
+#define __TIMM_OSAL_Trace(level, tracegrp, fmt, ...)                          \
+    do {                                                                      \
+        static const __TIMM_OSAL_TRACE_LOCATION loc = {                       \
+                __FILE__, __FUNCTION__, __LINE__, (level), (tracegrp)         \
+        };                                                                    \
+        __TIMM_OSAL_TraceFunction(&loc, fmt"\n", ##__VA_ARGS__);              \
+    } while(0)
+
+/**
+* TIMM_OSAL_Error() -- Fatal errors
+*/
+#define TIMM_OSAL_Error(fmt,...)  TIMM_OSAL_ErrorExt(TIMM_OSAL_TRACEGRP_SYSTEM, fmt, ##__VA_ARGS__)
+
+/**
+* TIMM_OSAL_Warning() -- Warnings that are useful to know about
+*/
+#define TIMM_OSAL_Warning(fmt,...)  TIMM_OSAL_WarningExt(TIMM_OSAL_TRACEGRP_SYSTEM, fmt, ##__VA_ARGS__)
+
+/**
+* TIMM_OSAL_Info() -- general information
+*/
+#define TIMM_OSAL_Info(fmt,...)  TIMM_OSAL_InfoExt(TIMM_OSAL_TRACEGRP_SYSTEM, fmt, ##__VA_ARGS__)
+
+/**
+* TIMM_OSAL_Debug() -- debug traces, most-commonly useful for developers
+*/
+#define TIMM_OSAL_Debug(fmt,...)  TIMM_OSAL_DebugExt(TIMM_OSAL_TRACEGRP_SYSTEM, fmt, ##__VA_ARGS__)
+
+/**
+* TIMM_OSAL_Entering() -- "ENTERING <function>" statements
+* TIMM_OSAL_Exiting()  -- "EXITING <function>" statements
+*/
+#define TIMM_OSAL_Entering(fmt,...)  TIMM_OSAL_EnteringExt(TIMM_OSAL_TRACEGRP_SYSTEM, fmt, ##__VA_ARGS__)
+#define TIMM_OSAL_Exiting(fmt,...)  TIMM_OSAL_ExitingExt(TIMM_OSAL_TRACEGRP_SYSTEM, fmt, ##__VA_ARGS__)
+
+/*******************************************************************************
+** New Trace to be used by Applications
+*******************************************************************************/
+
+/**
+* TIMM_OSAL_ErrorExt() -- Fatal errors
+*/
+#define TIMM_OSAL_ErrorExt(tracegrp, fmt, ...)  __TIMM_OSAL_Trace(1, tracegrp, "ERROR: "fmt, ##__VA_ARGS__)
+
+/**
+* TIMM_OSAL_WarningExt() -- Warnings that are useful to know about
+*/
+#define TIMM_OSAL_WarningExt(tracegrp, fmt, ...)  __TIMM_OSAL_Trace(2, tracegrp, "WARNING: "fmt, ##__VA_ARGS__)
+
+/**
+* TIMM_OSAL_InfoExt() -- general information
+*/
+#define TIMM_OSAL_InfoExt(tracegrp, fmt, ...)  __TIMM_OSAL_Trace(3, tracegrp, "INFO: "fmt, ##__VA_ARGS__)
+
+/**
+* TIMM_OSAL_DebugExt() -- most-commonly used statement for us developers
+*/
+#define TIMM_OSAL_DebugExt(tracegrp, fmt, ...)  __TIMM_OSAL_Trace(4, tracegrp, "TRACE: "fmt, ##__VA_ARGS__)
+
+/**
+* TIMM_OSAL_EnteringExt() -- "ENTERING <function>" statements
+* TIMM_OSAL_ExitingExt()  -- "EXITING <function>" statements
+*/
+#define TIMM_OSAL_EnteringExt(tracegrp, fmt, ...)  __TIMM_OSAL_Trace(5, tracegrp, "ENTER: "fmt, ##__VA_ARGS__)
+#define TIMM_OSAL_ExitingExt(tracegrp, fmt, ...)  __TIMM_OSAL_Trace(5, tracegrp, "EXIT: "fmt, ##__VA_ARGS__)
+
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_TRACES_H_ */
diff --git a/domx/mm_osal/inc/timm_osal_types.h b/domx/mm_osal/inc/timm_osal_types.h
new file mode 100755
index 0000000..882148d
--- /dev/null
+++ b/domx/mm_osal/inc/timm_osal_types.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*  @file timm_osal_types.h
+*  The timm_osal_types header file defines the primative osal type definitions.
+*  @path
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+#ifndef _TIMM_OSAL_TYPES_H_
+#define _TIMM_OSAL_TYPES_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#else
+#include <stdint.h>
+#endif
+
+	typedef int8_t TIMM_OSAL_S8;	/*INT8 */
+	typedef int16_t TIMM_OSAL_S16;	/*INT16 */
+	typedef int32_t TIMM_OSAL_S32;	/*INT32 */
+
+#define TIMM_OSAL_INT8_MIN 0xFF
+#define TIMM_OSAL_INT8_MAX 0x7F
+
+#define TIMM_OSAL_INT16_MIN 0xFFFF
+#define TIMM_OSAL_INT16_MAX 0x7FFF
+
+#define TIMM_OSAL_INT32_MIN 0xFFFFFFFF
+#define TIMM_OSAL_INT32_MAX 0x7FFFFFFF
+
+	typedef uint8_t TIMM_OSAL_U8;	/*UINT8 */
+	typedef uint16_t TIMM_OSAL_U16;	/*UINT16 */
+	typedef uint32_t TIMM_OSAL_U32;	/*UINT32 */
+
+#define TIMM_OSAL_UINT8_MIN 0
+#define TIMM_OSAL_UINT8_MAX 0xFF
+
+#define TIMM_OSAL_UINT16_MIN 0
+#define TIMM_OSAL_UINT16_MAX 0xFFFF
+
+#define TIMM_OSAL_UINT32_MIN 0
+#define TIMM_OSAL_UINT32_MAX 0xFFFFFFFF
+
+
+	typedef char TIMM_OSAL_CHAR;
+	  /*CHAR*/ typedef void *TIMM_OSAL_HANDLE;
+	typedef void *TIMM_OSAL_PTR;
+
+	typedef enum TIMM_OSAL_BOOL
+	{
+		TIMM_OSAL_FALSE = 0,
+		TIMM_OSAL_TRUE = !TIMM_OSAL_FALSE,
+		TIMM_OSAL_BOOL_MAX = 0x7FFFFFFF
+	} TIMM_OSAL_BOOL;
+
+#define TIMM_OSAL_SUSPEND     0xFFFFFFFFUL
+#define TIMM_OSAL_NO_SUSPEND  0x0
+#define TIMM_OSAL_TIMED_OUT   0x7FFFFFFFUL
+
+
+#define SUCCESS 0
+#define NO_SUCCESS -1
+
+#define ERROR 1
+/*
+#define TRUE 0
+#define FALSE 1
+*/
+#define URGENT_MESSAGE 2
+#define NORMAL_MESSAGE 1
+
+
+#define TIMM_OSAL_NULL 0
+
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif				/* _TIMM_OSAL_TYPES_H_ */
diff --git a/domx/mm_osal/src/timm_osal.c b/domx/mm_osal/src/timm_osal.c
new file mode 100755
index 0000000..85fdb66
--- /dev/null
+++ b/domx/mm_osal/src/timm_osal.c
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*   @file  tiimm_osal.c
+*   This file contains methods that provides the functionality
+*   initializing/deinitializing the osal.
+*
+*  @path \
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 20-Oct-2008 Maiya ShreeHarsha:Linux specific changes
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+#include "timm_osal_types.h"
+#include "timm_osal_error.h"
+#include "timm_osal_memory.h"
+/*#include "timm_osal_trace.h"*/
+
+
+/******************************************************************************
+* Function Prototypes
+******************************************************************************/
+
+/****************************************************************
+*  PRIVATE DECLARATIONS  : only used in this file
+****************************************************************/
+/*--------data declarations -----------------------------------*/
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_Init function initilize the osal with initial settings.
+*
+* @return  TIMM_OSAL_ERR_NONE if successful
+*               !TIMM_OSAL_ERR_NONE if an error occurs
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_Init(void)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	return bReturnStatus;
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_Init function de-initilize the osal.
+*
+* @return  TIMM_OSAL_ERR_NONE if successful
+*               !TIMM_OSAL_ERR_NONE if an error occurs
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_Deinit(void)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	return bReturnStatus;
+}
diff --git a/domx/mm_osal/src/timm_osal_events.c b/domx/mm_osal/src/timm_osal_events.c
new file mode 100755
index 0000000..96f8e59
--- /dev/null
+++ b/domx/mm_osal/src/timm_osal_events.c
@@ -0,0 +1,420 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*   @file  timm_osal_events.c
+*   This file contains methods that provides the functionality
+*   for creating/using events.
+*
+*  @path \
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 06-Nov-2008 Maiya ShreeHarsha: Linux specific changes
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+#include <stdio.h>
+#include <pthread.h>		/*for POSIX calls */
+#include <sys/time.h>
+#include <errno.h>
+
+#include "timm_osal_types.h"
+#include "timm_osal_trace.h"
+#include "timm_osal_error.h"
+#include "timm_osal_memory.h"
+#include "timm_osal_events.h"
+
+
+typedef struct
+{
+	TIMM_OSAL_BOOL bSignaled;
+	TIMM_OSAL_U32 eFlags;
+	pthread_mutex_t mutex;
+	pthread_cond_t condition;
+} TIMM_OSAL_THREAD_EVENT;
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_EventCreate function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_EventCreate(TIMM_OSAL_PTR * pEvents)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	TIMM_OSAL_THREAD_EVENT *plEvent = NULL;
+
+	plEvent =
+	    (TIMM_OSAL_THREAD_EVENT *)
+	    TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_THREAD_EVENT), 0, 0, 0);
+
+	if (TIMM_OSAL_NULL == plEvent)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_ALLOC;
+		goto EXIT;
+	}
+	plEvent->bSignaled = TIMM_OSAL_FALSE;
+	plEvent->eFlags = 0;
+
+	if (SUCCESS != pthread_mutex_init(&(plEvent->mutex), NULL))
+	{
+		TIMM_OSAL_Error("Event Create:Mutex Init failed !");
+		goto EXIT;	/*bReturnStatus = TIMM_OSAL_ERR_UNKNOWN */
+	}
+
+	if (SUCCESS != pthread_cond_init(&(plEvent->condition), NULL))
+	{
+		TIMM_OSAL_Error
+		    ("Event Create:Conditional Variable  Init failed !");
+		pthread_mutex_destroy(&(plEvent->mutex));
+		/*TIMM_OSAL_Free(plEvent); */
+	} else
+	{
+		*pEvents = (TIMM_OSAL_PTR) plEvent;
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+	}
+      EXIT:
+	if ((TIMM_OSAL_ERR_NONE != bReturnStatus) &&
+	    (TIMM_OSAL_NULL != plEvent))
+	{
+		TIMM_OSAL_Free(plEvent);
+	}
+	return bReturnStatus;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_EventDelete function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_EventDelete(TIMM_OSAL_PTR pEvents)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_THREAD_EVENT *plEvent = (TIMM_OSAL_THREAD_EVENT *) pEvents;
+
+	if (TIMM_OSAL_NULL == plEvent)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	if (SUCCESS != pthread_mutex_lock(&(plEvent->mutex)))
+	{
+		TIMM_OSAL_Error("Event Delete: Mutex Lock failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	}
+	if (SUCCESS != pthread_cond_destroy(&(plEvent->condition)))
+	{
+		TIMM_OSAL_Error
+		    ("Event Delete: Conditional Variable Destroy failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	}
+
+	if (SUCCESS != pthread_mutex_unlock(&(plEvent->mutex)))
+	{
+		TIMM_OSAL_Error("Event Delete: Mutex Unlock failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	}
+
+	if (SUCCESS != pthread_mutex_destroy(&(plEvent->mutex)))
+	{
+		TIMM_OSAL_Error("Event Delete: Mutex Destory failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	}
+
+	TIMM_OSAL_Free(plEvent);
+      EXIT:
+	return bReturnStatus;
+}
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_EventSet function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_EventSet(TIMM_OSAL_PTR pEvents,
+    TIMM_OSAL_U32 uEventFlags, TIMM_OSAL_EVENT_OPERATION eOperation)
+{
+
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	TIMM_OSAL_THREAD_EVENT *plEvent = (TIMM_OSAL_THREAD_EVENT *) pEvents;
+
+	if (TIMM_OSAL_NULL == plEvent)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	if (SUCCESS != pthread_mutex_lock(&(plEvent->mutex)))
+	{
+		TIMM_OSAL_Error("Event Set: Mutex Lock failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+		goto EXIT;
+	}
+
+	switch (eOperation)
+	{
+	case TIMM_OSAL_EVENT_AND:
+		plEvent->eFlags = plEvent->eFlags & uEventFlags;
+		break;
+	case TIMM_OSAL_EVENT_OR:
+		plEvent->eFlags = plEvent->eFlags | uEventFlags;
+		break;
+	default:
+		TIMM_OSAL_Error("Event Set: Bad eOperation !");
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		pthread_mutex_unlock(&plEvent->mutex);
+		goto EXIT;
+	}
+
+	plEvent->bSignaled = TIMM_OSAL_TRUE;
+
+	if (SUCCESS != pthread_cond_signal(&plEvent->condition))
+	{
+		TIMM_OSAL_Error
+		    ("Event Set: Condition Variable Signal failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+		pthread_mutex_unlock(&plEvent->mutex);
+		goto EXIT;
+	}
+
+	if (SUCCESS != pthread_mutex_unlock(&plEvent->mutex))
+	{
+		TIMM_OSAL_Error("Event Set: Mutex Unlock failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	} else
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+      EXIT:
+	return bReturnStatus;
+
+
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_EventRetrieve function
+*
+*Spurious  wakeups  from  the  pthread_cond_timedwait() or pthread_cond_wait() functions  may  occur.
+*
+*A representative sequence for using condition variables is shown below
+*
+*Thread A (Retrieve Events)							|Thread B (Set Events)
+*------------------------------------------------------------------------------------------------------------
+*1) Do work up to the point where a certain condition 	|1)Do work
+*  must occur (such as "count" must reach a specified 	|2)Lock associated mutex
+*  value)											|3)Change the value of the global variable
+*2) Lock associated mutex and check value of a global 	|  that Thread-A is waiting upon.
+*  variable										|4)Check value of the global Thread-A wait
+*3) Call pthread_cond_wait() to perform a blocking wait 	|  variable. If it fulfills the desired
+*  for signal from Thread-B. Note that a call to 			|  condition, signal Thread-A.
+*  pthread_cond_wait() automatically and atomically 		|5)Unlock mutex.
+*  unlocks the associated mutex variable so that it can 	|6)Continue
+*  be used by Thread-B.							|
+*4) When signalled, wake up. Mutex is automatically and 	|
+*  atomically locked.								|
+*5) Explicitly unlock mutex							|
+*6) Continue										|
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_EventRetrieve(TIMM_OSAL_PTR pEvents,
+    TIMM_OSAL_U32 uRequestedEvents,
+    TIMM_OSAL_EVENT_OPERATION eOperation,
+    TIMM_OSAL_U32 * pRetrievedEvents, TIMM_OSAL_U32 uTimeOutMsec)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	struct timespec timeout;
+	struct timeval now;
+	TIMM_OSAL_U32 timeout_us;
+	TIMM_OSAL_U32 isolatedFlags;
+	int status = -1;
+	int and_operation;
+	TIMM_OSAL_THREAD_EVENT *plEvent = (TIMM_OSAL_THREAD_EVENT *) pEvents;
+
+	if (TIMM_OSAL_NULL == plEvent)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	/* Lock the mutex for access to the eFlags global variable */
+	if (SUCCESS != pthread_mutex_lock(&(plEvent->mutex)))
+	{
+		TIMM_OSAL_Error("Event Retrieve: Mutex Lock failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+		goto EXIT;
+	}
+
+	/*Check the eOperation and put it in a variable */
+	and_operation = ((TIMM_OSAL_EVENT_AND == eOperation) ||
+	    (TIMM_OSAL_EVENT_AND_CONSUME == eOperation));
+
+	/* Isolate the flags. The & operation is suffice for an TIMM_OSAL_EVENT_OR eOperation */
+	isolatedFlags = plEvent->eFlags & uRequestedEvents;
+
+	/*Check if it is the AND operation. If yes then, all the flags must match */
+	if (and_operation)
+	{
+		isolatedFlags = (isolatedFlags == uRequestedEvents);
+	}
+
+
+	if (isolatedFlags)
+	{
+
+		/*We have got required combination of the eFlags bits and will return it back */
+		*pRetrievedEvents = plEvent->eFlags;
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+	} else
+	{
+
+		/*Required combination of bits is not yet available */
+		if (TIMM_OSAL_NO_SUSPEND == uTimeOutMsec)
+		{
+			*pRetrievedEvents = 0;
+			bReturnStatus = TIMM_OSAL_ERR_NONE;
+		}
+
+		else if (TIMM_OSAL_SUSPEND == uTimeOutMsec)
+		{
+
+			/*Wait till we get the required combination of bits. We we get the required
+			 *bits then we go out of the while loop
+			 */
+			while (!isolatedFlags)
+			{
+
+				/*Wait on the conditional variable for another thread to set the eFlags and signal */
+				pthread_cond_wait(&(plEvent->condition),
+				    &(plEvent->mutex));
+
+				/* eFlags set by some thread. Now, isolate the flags.
+				 * The & operation is suffice for an TIMM_OSAL_EVENT_OR eOperation
+				 */
+				isolatedFlags =
+				    plEvent->eFlags & uRequestedEvents;
+
+				/*Check if it is the AND operation. If yes then, all the flags must match */
+				if (and_operation)
+				{
+					isolatedFlags =
+					    (isolatedFlags ==
+					    uRequestedEvents);
+				}
+			}
+
+			/* Obtained the requested combination of bits on eFlags */
+			*pRetrievedEvents = plEvent->eFlags;
+			bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+		} else
+		{
+
+			/* Calculate uTimeOutMsec in terms of the absolute time. uTimeOutMsec is in milliseconds */
+			gettimeofday(&now, NULL);
+			timeout_us = now.tv_usec + 1000 * uTimeOutMsec;
+			timeout.tv_sec = now.tv_sec + timeout_us / 1000000;
+			timeout.tv_nsec = (timeout_us % 1000000) * 1000;
+
+			while (!isolatedFlags)
+			{
+
+				/* Wait till uTimeOutMsec for a thread to signal on the conditional variable */
+				status =
+				    pthread_cond_timedwait(&(plEvent->
+					condition), &(plEvent->mutex),
+				    &timeout);
+
+				/*Timedout or error and returned without being signalled */
+				if (SUCCESS != status)
+				{
+					if (ETIMEDOUT == status)
+						bReturnStatus =
+						    TIMM_OSAL_ERR_NONE;
+					*pRetrievedEvents = 0;
+					break;
+				}
+
+				/* eFlags set by some thread. Now, isolate the flags.
+				 * The & operation is suffice for an TIMM_OSAL_EVENT_OR eOperation
+				 */
+				isolatedFlags =
+				    plEvent->eFlags & uRequestedEvents;
+
+				/*Check if it is the AND operation. If yes then, all the flags must match */
+				if (and_operation)
+				{
+					isolatedFlags =
+					    (isolatedFlags ==
+					    uRequestedEvents);
+				}
+
+			}
+		}
+	}
+
+	/*If we have got the required combination of bits, we will have to reset the eFlags if CONSUME is mentioned
+	 *in the eOperations
+	 */
+	if (isolatedFlags && ((eOperation == TIMM_OSAL_EVENT_AND_CONSUME) ||
+		(eOperation == TIMM_OSAL_EVENT_OR_CONSUME)))
+	{
+		plEvent->eFlags = 0;
+	}
+
+	/*Manually unlock the mutex */
+	if (SUCCESS != pthread_mutex_unlock(&(plEvent->mutex)))
+	{
+		TIMM_OSAL_Error("Event Retrieve: Mutex Unlock failed !");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	}
+
+      EXIT:
+	return bReturnStatus;
+
+}
diff --git a/domx/mm_osal/src/timm_osal_memory.c b/domx/mm_osal/src/timm_osal_memory.c
new file mode 100755
index 0000000..22eb0a4
--- /dev/null
+++ b/domx/mm_osal/src/timm_osal_memory.c
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*   @file  timm_osal_memory.c
+*   This file contains methods that provides the functionality
+*   for allocating/deallocating memory.
+*
+*  @path \
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *!23-Oct-2008 Maiya ShreeHarsha: Linux specific changes
+ *!0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+
+#include <string.h>
+#include <malloc.h>
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#else
+#include <stdint.h>
+#endif
+
+
+#include "timm_osal_types.h"
+#include "timm_osal_trace.h"
+#include "timm_osal_error.h"
+#include "timm_osal_memory.h"
+
+
+
+static TIMM_OSAL_U32 gMallocCounter = 0;
+
+/******************************************************************************
+* Function Prototypes
+******************************************************************************/
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_createMemoryPool function
+*
+* @see
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreateMemoryPool(void)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	return bReturnStatus;
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_DeleteMemoryPool function
+*
+* @see
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_DeleteMemoryPool(void)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	return bReturnStatus;
+
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_Malloc function
+*
+* @see
+*/
+/* ========================================================================== */
+TIMM_OSAL_PTR TIMM_OSAL_Malloc(TIMM_OSAL_U32 size,
+    TIMM_OSAL_BOOL bBlockContiguous,
+    TIMM_OSAL_U32 unBlockAlignment, TIMMOSAL_MEM_SEGMENTID tMemSegId)
+{
+
+	TIMM_OSAL_PTR pData = TIMM_OSAL_NULL;
+
+#ifdef HAVE_MEMALIGN
+	if (0 == unBlockAlignment)
+	{
+		pData = malloc((size_t) size);
+	} else
+	{
+		pData = memalign((size_t) unBlockAlignment, (size_t) size);
+	}
+#else
+	if (0 != unBlockAlignment)
+	{
+		TIMM_OSAL_Warning
+		    ("Memory Allocation:Not done for specified nBufferAlignment. Alignment of 0 will be used");
+
+	}
+	pData = malloc((size_t) size);	/*size_t is long long */
+#endif
+	if (TIMM_OSAL_NULL == pData)
+	{
+		TIMM_OSAL_Error("Malloc failed!!!");
+	} else
+	{
+		/* Memory Allocation was successfull */
+		gMallocCounter++;
+	}
+
+
+	return pData;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_Free function ....
+*
+* @see
+*/
+/* ========================================================================== */
+
+void TIMM_OSAL_Free(TIMM_OSAL_PTR pData)
+{
+	if (TIMM_OSAL_NULL == pData)
+	{
+		/*TIMM_OSAL_Warning("TIMM_OSAL_Free called on NULL pointer"); */
+		goto EXIT;
+	}
+
+	free(pData);
+	pData = NULL;
+	gMallocCounter--;
+      EXIT:
+	return;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_Memset function ....
+*
+* @see
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_Memset(TIMM_OSAL_PTR pBuffer,
+    TIMM_OSAL_U8 uValue, TIMM_OSAL_U32 uSize)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+
+	memset((void *)pBuffer, (int)uValue, (size_t) uSize);
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+	return bReturnStatus;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_Memcmp function ....
+*
+* @see
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_S32 TIMM_OSAL_Memcmp(TIMM_OSAL_PTR pBuffer1, TIMM_OSAL_PTR pBuffer2,
+    TIMM_OSAL_U32 uSize)
+{
+	TIMM_OSAL_S32 result = memcmp(pBuffer1, pBuffer2, uSize);
+
+	if (result > 0)
+	{
+		return 1;
+	} else if (result < 0)
+	{
+		return -1;
+	}
+
+	return 0;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_Memcpy function ....
+*
+* @see
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_Memcpy(TIMM_OSAL_PTR pBufDst,
+    TIMM_OSAL_PTR pBufSrc, TIMM_OSAL_U32 uSize)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+
+	memcpy(pBufDst, pBufSrc, uSize);
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+	return bReturnStatus;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_GetMemCounter function ....
+*
+* @see
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_U32 TIMM_OSAL_GetMemCounter(void)
+{
+
+	return gMallocCounter;
+}
diff --git a/domx/mm_osal/src/timm_osal_mutex.c b/domx/mm_osal/src/timm_osal_mutex.c
new file mode 100755
index 0000000..5cfecf8
--- /dev/null
+++ b/domx/mm_osal/src/timm_osal_mutex.c
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*   @file  timm_osal_Mutexs.c
+*   This file contains methods that provides the functionality
+*
+*  @path \
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 04-Nov-2008 Maiya ShreeHarsha: Linux specific changes
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+
+
+#include "timm_osal_types.h"
+#include "timm_osal_trace.h"
+#include "timm_osal_error.h"
+#include "timm_osal_memory.h"
+#include "timm_osal_semaphores.h"
+
+#include <errno.h>
+
+#include <pthread.h>
+#include <sys/time.h>
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_MutexCreate function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_MutexCreate(TIMM_OSAL_PTR * pMutex)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	pthread_mutex_t *plMutex = TIMM_OSAL_NULL;
+
+	plMutex =
+	    (pthread_mutex_t *) TIMM_OSAL_Malloc(sizeof(pthread_mutex_t), 0,
+	    0, 0);
+	if (TIMM_OSAL_NULL == plMutex)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_ALLOC;
+		goto EXIT;
+	}
+
+	/*if (SUCCESS != pthread_mutex_init(plMutex, pAttr)) */
+	if (SUCCESS != pthread_mutex_init(plMutex, TIMM_OSAL_NULL))
+	{
+		/*TIMM_OSAL_Error ("Mutex Create failed !"); */
+		/*goto EXIT; */
+	} else
+	{
+	/**pMutex = (TIMM_OSAL_PTR *)plMutex;*/
+		*pMutex = (TIMM_OSAL_PTR) plMutex;
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+	}
+      EXIT:
+	/*if((TIMM_OSAL_ERR_NONE != bReturnStatus)) {
+	   TIMM_OSAL_Free(plMutex);
+	   } */
+	if ((TIMM_OSAL_ERR_NONE != bReturnStatus) &&
+	    (TIMM_OSAL_NULL != plMutex))
+	{
+		TIMM_OSAL_Free(plMutex);
+	}
+	return bReturnStatus;
+
+/**********************************************************/
+/*return TIMM_OSAL_SemaphoreCreate(pMutex, 1);*/
+/**********************************************************/
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_MutexDelete function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_MutexDelete(TIMM_OSAL_PTR pMutex)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	pthread_mutex_t *plMutex = (pthread_mutex_t *) pMutex;
+
+	if (plMutex == TIMM_OSAL_NULL)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+	/*can we do away with if or with switch case */
+	if (SUCCESS != pthread_mutex_destroy(plMutex))
+	{
+		/*TIMM_OSAL_Error("Delete Mutex failed !"); */
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;;
+	}
+
+	TIMM_OSAL_Free(plMutex);
+      EXIT:
+	return bReturnStatus;
+/**********************************************************/
+/*return TIMM_OSAL_SemaphoreDelete(pMutex);*/
+/**********************************************************/
+
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_MutexObtain function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_MutexObtain(TIMM_OSAL_PTR pMutex,
+    TIMM_OSAL_U32 uTimeOut)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	struct timespec abs_timeout;
+	struct timeval ltime_now;
+	TIMM_OSAL_U32 ltimenow_us;
+	pthread_mutex_t *plMutex = (pthread_mutex_t *) pMutex;
+
+	if (plMutex == TIMM_OSAL_NULL)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	if (TIMM_OSAL_SUSPEND == uTimeOut)
+	{
+		if (SUCCESS != pthread_mutex_lock(plMutex))
+		{
+			/*TIMM_OSAL_Error("Lock Mutex failed !"); */
+			goto EXIT;
+		}
+	} else if (TIMM_OSAL_NO_SUSPEND == uTimeOut)
+	{
+		if (SUCCESS != pthread_mutex_trylock(plMutex))
+		{
+			/*TIMM_OSAL_Error("Lock Mutex failed !"); */
+			goto EXIT;
+		}
+	} else
+	{
+		gettimeofday(&ltime_now, NULL);
+		/*uTimeOut is assumed to be in milliseconds */
+		ltimenow_us = ltime_now.tv_usec + 1000 * uTimeOut;
+		abs_timeout.tv_sec = ltime_now.tv_sec + uTimeOut / 1000;
+		abs_timeout.tv_nsec = (ltimenow_us % 1000000) * 1000;
+
+#ifdef _POSIX_VERSION_1_
+		if (SUCCESS != pthread_mutex_lock(plMutex))
+		{		//Some Posix versions dont support timeout
+#else
+		if (SUCCESS != pthread_mutex_timedlock(plMutex, &abs_timeout))
+		{
+#endif
+			/*TIMM_OSAL_Error("Lock Mutex failed !"); */
+			goto EXIT;
+		}
+	}
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+      EXIT:
+	return bReturnStatus;
+/**********************************************************/
+/*return TIMM_OSAL_SemaphoreObtain(pMutex, uTimeOut);*/
+/**********************************************************/
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_MutexRelease function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_MutexRelease(TIMM_OSAL_PTR pMutex)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	pthread_mutex_t *plMutex = (pthread_mutex_t *) pMutex;
+
+	if (TIMM_OSAL_NULL == plMutex)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	if (SUCCESS != pthread_mutex_unlock(plMutex))
+	{
+		/*TIMM_OSAL_Error("Unlock Mutex failed !"); */
+	} else
+	{
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+	}
+      EXIT:
+	return bReturnStatus;
+/**********************************************************/
+/*return TIMM_OSAL_SemaphoreRelease(pMutex);*/
+/**********************************************************/
+}
diff --git a/domx/mm_osal/src/timm_osal_pipes.c b/domx/mm_osal/src/timm_osal_pipes.c
new file mode 100755
index 0000000..df2d313
--- /dev/null
+++ b/domx/mm_osal/src/timm_osal_pipes.c
@@ -0,0 +1,537 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*   @file  timm_osal_pipes.c
+*   This file contains methods that provides the functionality
+*   for creating/using Nucleus pipes.
+*
+*  @path \
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 07-Nov-2008 Maiya ShreeHarsha: Linux specific changes
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+
+#include "timm_osal_types.h"
+#include "timm_osal_error.h"
+#include "timm_osal_memory.h"
+#include "timm_osal_trace.h"
+
+#include <unistd.h>
+#include <stdio.h>
+#include <unistd.h>
+
+
+
+/**
+* TIMM_OSAL_PIPE structure define the OSAL pipe
+*/
+typedef struct TIMM_OSAL_PIPE
+{
+	int pfd[2];
+	TIMM_OSAL_U32 pipeSize;
+	TIMM_OSAL_U32 messageSize;
+	TIMM_OSAL_U8 isFixedMessage;
+	int messageCount;
+	int totalBytesInPipe;
+} TIMM_OSAL_PIPE;
+
+
+/******************************************************************************
+* Function Prototypes
+******************************************************************************/
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_CreatePipe function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreatePipe(TIMM_OSAL_PTR * pPipe,
+    TIMM_OSAL_U32 pipeSize,
+    TIMM_OSAL_U32 messageSize, TIMM_OSAL_U8 isFixedMessage)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	TIMM_OSAL_PIPE *pHandle = TIMM_OSAL_NULL;
+
+	TIMM_OSAL_PIPE *pHandleBackup = TIMM_OSAL_NULL;
+
+	pHandle =
+	    (TIMM_OSAL_PIPE *) TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_PIPE), 0, 0,
+	    0);
+
+	if (TIMM_OSAL_NULL == pHandle)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_ALLOC;
+		goto EXIT;
+	}
+	TIMM_OSAL_Memset(pHandle, 0x0, sizeof(TIMM_OSAL_PIPE));
+
+	if (SUCCESS != pipe(pHandle->pfd))
+	{
+		TIMM_OSAL_Error("Pipe failed!!!");
+		goto EXIT;
+	}
+/*AD - This ensures that file descriptors for stdin/out/err are not assigned to
+  component pipes incase those file descriptors are free Normally this if
+  condition will not be true and we'll go directly to the else part*/
+	if (pHandle->pfd[0] == 0 || pHandle->pfd[0] == 1 ||
+	    pHandle->pfd[0] == 2 || pHandle->pfd[1] == 0 ||
+	    pHandle->pfd[1] == 1 || pHandle->pfd[1] == 2)
+	{
+		pHandleBackup =
+		    (TIMM_OSAL_PIPE *)
+		    TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_PIPE), 0, 0, 0);
+		if (TIMM_OSAL_NULL == pHandleBackup)
+		{
+			bReturnStatus = TIMM_OSAL_ERR_ALLOC;
+			goto EXIT;
+		}
+		TIMM_OSAL_Memset(pHandleBackup, 0x0, sizeof(TIMM_OSAL_PIPE));
+/*Allocating the new pipe*/
+		if (SUCCESS != pipe(pHandleBackup->pfd))
+		{
+			goto EXIT;
+		}
+/*Really crazy case if all 3 reserved file descriptors have been freed up!!
+  Should never happen normally*/
+		if (pHandleBackup->pfd[0] == 2 || pHandleBackup->pfd[1] == 2)
+		{
+			int pfdDummy[2];
+
+			if (SUCCESS != close(pHandleBackup->pfd[0]))
+			{
+				goto EXIT;
+			}
+			if (SUCCESS != close(pHandleBackup->pfd[1]))
+			{
+				goto EXIT;
+			}
+			/*Allocating the reserved file descriptor to dummy */
+			if (SUCCESS != pipe(pfdDummy))
+			{
+				goto EXIT;
+			}
+			/*Now the backup pfd will not get a reserved value */
+			if (SUCCESS != pipe(pHandleBackup->pfd))
+			{
+				goto EXIT;
+			}
+			/*Closing the dummy pfd */
+			if (SUCCESS != close(pfdDummy[0]))
+			{
+				goto EXIT;
+			}
+			if (SUCCESS != close(pfdDummy[1]))
+			{
+				goto EXIT;
+			}
+
+		}
+/*Closing the previous pipe*/
+		if (SUCCESS != close(pHandle->pfd[0]))
+		{
+			goto EXIT;
+		}
+		if (SUCCESS != close(pHandle->pfd[1]))
+		{
+			goto EXIT;
+		}
+		TIMM_OSAL_Free(pHandle);
+
+		pHandleBackup->pipeSize = pipeSize;
+		pHandleBackup->messageSize = messageSize;
+		pHandleBackup->isFixedMessage = isFixedMessage;
+		pHandleBackup->messageCount = 0;
+		pHandleBackup->totalBytesInPipe = 0;
+
+		*pPipe = (TIMM_OSAL_PTR) pHandleBackup;
+	}
+/*This is the normal case when a reserved file descriptor is not assigned to our pipe*/
+	else
+	{
+		pHandle->pipeSize = pipeSize;
+		pHandle->messageSize = messageSize;
+		pHandle->isFixedMessage = isFixedMessage;
+		pHandle->messageCount = 0;
+		pHandle->totalBytesInPipe = 0;
+
+		*pPipe = (TIMM_OSAL_PTR) pHandle;
+	}
+
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+      EXIT:
+	if ((TIMM_OSAL_ERR_NONE != bReturnStatus) &&
+	    (TIMM_OSAL_NULL != pHandle))
+	{
+		TIMM_OSAL_Free(pHandle);
+	}
+
+	if ((TIMM_OSAL_ERR_NONE != bReturnStatus) &&
+	    (TIMM_OSAL_NULL != pHandleBackup))
+	{
+		TIMM_OSAL_Free(pHandleBackup);
+	}
+	return bReturnStatus;
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_DeletePipe function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_DeletePipe(TIMM_OSAL_PTR pPipe)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+
+	if (TIMM_OSAL_NULL == pHandle)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	if (SUCCESS != close(pHandle->pfd[0]))
+	{
+		TIMM_OSAL_Error("Delete_Pipe Read fd failed!!!");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	}
+	if (SUCCESS != close(pHandle->pfd[1]))
+	{
+		TIMM_OSAL_Error("Delete_Pipe Write fd failed!!!");
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	}
+
+	TIMM_OSAL_Free(pHandle);
+      EXIT:
+	return bReturnStatus;
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_WriteToPipe function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_WriteToPipe(TIMM_OSAL_PTR pPipe,
+    void *pMessage, TIMM_OSAL_U32 size, TIMM_OSAL_S32 timeout)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	TIMM_OSAL_U32 lSizeWritten = -1;
+
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+
+	if (size == 0)
+	{
+		TIMM_OSAL_Error("0 size!!!");
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+	lSizeWritten = write(pHandle->pfd[1], pMessage, size);
+
+	if (lSizeWritten != size)
+	{
+		TIMM_OSAL_Error("Write of pipe failed!!!");
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	/*Update message count and size */
+	pHandle->messageCount++;
+	pHandle->totalBytesInPipe += size;
+
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+      EXIT:
+	return bReturnStatus;
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_WriteToFrontOfPipe function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_WriteToFrontOfPipe(TIMM_OSAL_PTR pPipe,
+    void *pMessage, TIMM_OSAL_U32 size, TIMM_OSAL_S32 timeout)
+{
+
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	TIMM_OSAL_U32 lSizeWritten = -1;
+	TIMM_OSAL_U32 lSizeRead = -1;
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+	TIMM_OSAL_U8 *tempPtr = NULL;
+
+
+	/*First write to this pipe */
+	if (size == 0)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	lSizeWritten = write(pHandle->pfd[1], pMessage, size);
+
+	if (lSizeWritten != size)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	/*Update number of messages */
+	pHandle->messageCount++;
+
+
+	if (pHandle->messageCount > 1)
+	{
+		/*First allocate memory */
+		tempPtr =
+		    (TIMM_OSAL_U8 *) TIMM_OSAL_Malloc(pHandle->
+		    totalBytesInPipe, 0, 0, 0);
+
+		if (tempPtr == NULL)
+		{
+			bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+			goto EXIT;
+		}
+
+		/*Read out of pipe */
+		lSizeRead =
+		    read(pHandle->pfd[0], tempPtr, pHandle->totalBytesInPipe);
+
+		/*Write back to pipe */
+		lSizeWritten =
+		    write(pHandle->pfd[1], tempPtr,
+		    pHandle->totalBytesInPipe);
+
+		if (lSizeWritten != size)
+		{
+			bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+			goto EXIT;
+		}
+
+		/*Update Total bytes in pipe */
+		pHandle->totalBytesInPipe += size;
+	}
+
+
+      EXIT:
+	TIMM_OSAL_Free(tempPtr);
+
+	return bReturnStatus;
+
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_ReadFromPipe function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_ReadFromPipe(TIMM_OSAL_PTR pPipe,
+    void *pMessage,
+    TIMM_OSAL_U32 size, TIMM_OSAL_U32 * actualSize, TIMM_OSAL_S32 timeout)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	TIMM_OSAL_U32 lSizeRead = -1;
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+
+	if (size == 0)
+	{
+		TIMM_OSAL_Error("nRead size has error!!!");
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+	if ((pHandle->messageCount == 0) && (timeout == TIMM_OSAL_NO_SUSPEND))
+	{
+		/*If timeout is 0 and pipe is empty, return error */
+		TIMM_OSAL_Error("Pipe is empty!!!");
+		bReturnStatus = TIMM_OSAL_ERR_PIPE_EMPTY;
+		goto EXIT;
+	}
+	if ((timeout != TIMM_OSAL_NO_SUSPEND) &&
+	    (timeout != TIMM_OSAL_SUSPEND))
+	{
+		TIMM_OSAL_Warning("Only infinite or no timeouts \
+			supported. Going to read with infinite timeout now");
+	}
+	/*read blocks infinitely until message is available */
+	*actualSize = lSizeRead = read(pHandle->pfd[0], pMessage, size);
+	if (0 == lSizeRead)
+	{
+		TIMM_OSAL_Error("EOF reached or no data in pipe!!!");
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+	pHandle->messageCount--;
+	pHandle->totalBytesInPipe -= size;
+
+      EXIT:
+	return bReturnStatus;
+
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_ClearPipe function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_ClearPipe(TIMM_OSAL_PTR pPipe)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR;
+
+#if 0
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	STATUS status = NU_SUCCESS;
+
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+
+	status = NU_Reset_Pipe(&(pHandle->pipe));
+
+	if (NU_SUCCESS != status)
+	{
+		TIMM_OSAL_Error("NU_Reset_Pipe failed!!!");
+		bReturnStatus =
+		    TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR, TIMM_OSAL_COMP_PIPES,
+		    status);
+	}
+#endif
+	return bReturnStatus;
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_IsPipeReady function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_IsPipeReady(TIMM_OSAL_PTR pPipe)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR;
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+
+#if 0
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+	PI_PCB *pipe = (PI_PCB *) & (pHandle->pipe);
+
+	if (0 != pipe->pi_messages)
+	{
+		return TIMM_OSAL_ERR_NONE;
+	} else
+	{
+		return TIMM_OSAL_ERR_NOT_READY;
+	}
+#endif
+
+	if (pHandle->messageCount <= 0)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_NOT_READY;
+	} else
+	{
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+	}
+
+	return bReturnStatus;
+
+}
+
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_GetPipeReadyMessageCount function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_GetPipeReadyMessageCount(TIMM_OSAL_PTR pPipe,
+    TIMM_OSAL_U32 * count)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+#if 0
+
+	TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *) pPipe;
+	PI_PCB *pipe = (PI_PCB *) & (pHandle->pipe);
+
+	*count = pipe->pi_messages;
+
+#endif
+
+	*count = pHandle->messageCount;
+	return bReturnStatus;
+
+}
diff --git a/domx/mm_osal/src/timm_osal_semaphores.c b/domx/mm_osal/src/timm_osal_semaphores.c
new file mode 100755
index 0000000..b69ee3c
--- /dev/null
+++ b/domx/mm_osal/src/timm_osal_semaphores.c
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*   @file  timm_osal_semaphores.c
+*   This file contains methods that provides the functionality
+*
+*  @path \
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 30-Oct-2008 Maiya ShreeHarsha: Linux specific changes
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+
+#include <stdio.h>
+
+#include <semaphore.h>
+#include <sys/time.h>
+
+
+#include "timm_osal_types.h"
+#include "timm_osal_trace.h"
+#include "timm_osal_error.h"
+#include "timm_osal_memory.h"
+
+
+#define SEMNAME_MAX           7
+
+/*
+typedef struct TIMM_OSAL_SEMAPHORE {
+    sem_t  sem;
+    CHAR name[SEMNAME_MAX];
+} TIMM_OSAL_SEMAPHORE;
+*/
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_SemaphoreCreate function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreCreate(TIMM_OSAL_PTR * pSemaphore,
+    TIMM_OSAL_U32 uInitCount)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	*pSemaphore = TIMM_OSAL_NULL;
+
+	sem_t *psem = (sem_t *) TIMM_OSAL_Malloc(sizeof(sem_t), 0, 0, 0);
+
+	if (TIMM_OSAL_NULL == psem)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_ALLOC;
+		goto EXIT;
+	}
+
+	/*Unnamed semaphore */
+	if (SUCCESS != sem_init(psem, 0, uInitCount))
+	{
+		/*TIMM_OSAL_Error("Semaphore Create failed !"); */
+		/*goto EXIT; */
+	} else
+	{
+		*pSemaphore = (TIMM_OSAL_PTR) psem;
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+	}
+      EXIT:
+	if ((TIMM_OSAL_ERR_NONE != bReturnStatus) && (TIMM_OSAL_NULL != psem))
+	{
+		TIMM_OSAL_Free(psem);
+	}
+	return bReturnStatus;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_SemaphoreDelete function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreDelete(TIMM_OSAL_PTR pSemaphore)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
+	sem_t *psem = (sem_t *) pSemaphore;
+
+	if (psem == TIMM_OSAL_NULL)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+	/* Release the semaphore.  */
+	if (SUCCESS != sem_destroy(psem))
+	{
+		/*TIMM_OSAL_Error("Semaphore Delete failed !"); */
+		bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	}
+
+	TIMM_OSAL_Free(psem);
+      EXIT:
+	return bReturnStatus;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_SemaphoreObtain function
+*
+*
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreObtain(TIMM_OSAL_PTR pSemaphore,
+    TIMM_OSAL_U32 uTimeOut)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	struct timeval ltime_now;
+	struct timespec abs_timeout;
+	sem_t *psem = (sem_t *) pSemaphore;
+
+	if (psem == TIMM_OSAL_NULL)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	if (TIMM_OSAL_SUSPEND == uTimeOut)
+	{
+		if (SUCCESS != sem_wait(psem))
+		{
+			/*TIMM_OSAL_Error("Semaphore Wait failed !"); */
+			goto EXIT;
+		}
+
+	} else if (TIMM_OSAL_NO_SUSPEND == uTimeOut)
+	{
+		if (SUCCESS != sem_trywait(psem))
+		{
+			/*TIMM_OSAL_Error("Semaphore blocked !"); */
+			goto EXIT;
+		}
+	} else
+	{
+		/*Some delay in calling gettimeofday and sem_timedwait - cant
+		   be avoided. Possibility of thread switch after gettimeofday
+		   in which case time out will be less than expected */
+		gettimeofday(&ltime_now, NULL);
+		/*uTimeOut is assumed to be in milliseconds */
+		abs_timeout.tv_sec = ltime_now.tv_sec + (uTimeOut / 1000);
+		abs_timeout.tv_nsec =
+		    1000 * (ltime_now.tv_usec + ((uTimeOut % 1000) * 1000));
+
+		if (SUCCESS != sem_timedwait(psem, &abs_timeout))
+		{
+			/*TIMM_OSAL_Error("Semaphore Timed Wait failed !"); */
+			goto EXIT;
+		}
+	}
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+
+      EXIT:
+	return bReturnStatus;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_SemaphoreRelease function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreRelease(TIMM_OSAL_PTR pSemaphore)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	sem_t *psem = (sem_t *) pSemaphore;
+
+	if (TIMM_OSAL_NULL == psem)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+	/* Release the semaphore.  */
+	if (SUCCESS != sem_post(psem))
+	{
+		/*TIMM_OSAL_Error("Release failed !"); */
+	} else
+	{
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+	}
+
+      EXIT:
+	return bReturnStatus;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_SemaphoreReset function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreReset(TIMM_OSAL_PTR pSemaphore,
+    TIMM_OSAL_U32 uInitCount)
+{
+	/*  TIMM_OSAL_SEMAPHORE *pHandle = (TIMM_OSAL_SEMAPHORE *)pSemaphore;
+	   STATUS  status;
+	   TIMM_OSAL_ERRORTYPE bReturnStatus; */
+
+
+	/* Release the semaphore.  */
+	/*status = NU_Reset_Semaphore(&(pHandle->sem),
+	   uInitCount);
+	 */
+	/*   switch(status)
+	   {
+	   case NU_SUCCESS:
+	   bReturnStatus = TIMM_OSAL_ERR_NONE;
+	   break;
+	   default:
+	   bReturnStatus = TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR, TIMM_OSAL_COMP_SEMAPHORES, status);
+	   break;
+	   }
+	 */
+	/* return bReturnStatus; */
+	return TIMM_OSAL_ERR_UNKNOWN;
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_GetSemaphoreCount function
+*
+*
+*/
+/* ========================================================================== */
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_GetSemaphoreCount(TIMM_OSAL_PTR pSemaphore,
+    TIMM_OSAL_U32 * count)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	int sval = -2;		/*value that is not possible */
+	sem_t *psem = (sem_t *) pSemaphore;
+
+	if (TIMM_OSAL_NULL == psem)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+
+	/* Release the semaphore.  */
+	if (SUCCESS != sem_getvalue(psem, &sval))
+	{
+		/*TIMM_OSAL_Error("Get Semaphore Count failed !"); */
+	} else
+	{
+		*count = sval;
+		bReturnStatus = TIMM_OSAL_ERR_NONE;
+	}
+
+      EXIT:
+	return bReturnStatus;
+}
diff --git a/domx/mm_osal/src/timm_osal_task.c b/domx/mm_osal/src/timm_osal_task.c
new file mode 100755
index 0000000..7a243a9
--- /dev/null
+++ b/domx/mm_osal/src/timm_osal_task.c
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*   @file  timm_osal_task.c
+*   This file contains methods that provides the functionality
+*   for creating/destroying tasks.
+*
+*  @path \
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *! 21-Oct-2008 Maiya ShreeHarsha: Linux specific changes
+ *! 0.1: Created the first draft version, ksrini@ti.com
+ * ========================================================================= */
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+
+#include <stdio.h>
+#include <pthread.h>		/*for POSIX calls */
+#include <sched.h>		/*for sched structure */
+#include <unistd.h>
+
+
+
+#include "timm_osal_types.h"
+#include "timm_osal_trace.h"
+#include "timm_osal_error.h"
+#include "timm_osal_memory.h"
+#include "timm_osal_task.h"
+
+
+
+
+/**
+* TIMM_OSAL_TASK describe the different task information
+*/
+typedef struct TIMM_OSAL_TASK
+{
+	pthread_t threadID;	/*SHM check */
+	/* To set the priority and stack size */
+	pthread_attr_t ThreadAttr;	/*For setting the priority and stack size */
+    /** Name of the task */
+	/*    TIMM_OSAL_S8  name[8];*//* eight character plus null char */
+    /** Pointer to the task stack memory */
+/*    TIMM_OSAL_PTR stackPtr;*/
+    /** Size of the task stack */
+/*    TIMM_OSAL_S32 stackSize;*/
+	/*parameters to the task */
+	TIMM_OSAL_U32 uArgc;
+	TIMM_OSAL_PTR pArgv;
+    /** task priority */
+/*    TIMM_OSAL_S32 priority;*/
+    /** flag to check if task got created */
+	TIMM_OSAL_BOOL isCreated;
+} TIMM_OSAL_TASK;
+
+
+/******************************************************************************
+* Function Prototypes
+******************************************************************************/
+
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_CreateTask function
+*
+* @see
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreateTask(TIMM_OSAL_PTR * pTask,
+    TIMM_OSAL_TaskProc pFunc,
+    TIMM_OSAL_U32 uArgc,
+    TIMM_OSAL_PTR pArgv,
+    TIMM_OSAL_U32 uStackSize, TIMM_OSAL_U32 uPriority, TIMM_OSAL_S8 * pName)
+{
+
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+	TIMM_OSAL_TASK *pHandle = TIMM_OSAL_NULL;
+	struct sched_param sched;
+	size_t stackSize;
+	*pTask = TIMM_OSAL_NULL;
+
+
+	/*Task structure allocation */
+	pHandle =
+	    (TIMM_OSAL_TASK *) TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_TASK), 0, 0,
+	    0);
+	if (pHandle == TIMM_OSAL_NULL)
+	{
+		bReturnStatus = TIMM_OSAL_ERR_ALLOC;
+		goto EXIT;
+	}
+
+	/* Initial cleaning of the task structure */
+	TIMM_OSAL_Memset((TIMM_OSAL_PTR) pHandle, 0, sizeof(TIMM_OSAL_TASK));
+
+	/*Arguments for task */
+	pHandle->uArgc = uArgc;
+	pHandle->pArgv = pArgv;
+
+	pHandle->isCreated = TIMM_OSAL_FALSE;
+
+
+	if (SUCCESS != pthread_attr_init(&pHandle->ThreadAttr))
+	{
+		/*TIMM_OSAL_Error("Task Init Attr Init failed!"); */
+		goto EXIT;
+	}
+	/* Updation of the priority and the stack size */
+
+	if (SUCCESS != pthread_attr_getschedparam(&pHandle->ThreadAttr,
+		&sched))
+	{
+		/*TIMM_OSAL_Error("Task Init Get Sched Params failed!"); */
+		goto EXIT;
+	}
+
+	sched.sched_priority = uPriority;	/* relative to the default priority */
+	if (SUCCESS != pthread_attr_setschedparam(&pHandle->ThreadAttr,
+		&sched))
+	{
+		/*TIMM_OSAL_Error("Task Init Set Sched Paramsfailed!"); */
+		goto EXIT;
+	}
+
+	/*First get the default stack size */
+	if (SUCCESS != pthread_attr_getstacksize(&pHandle->ThreadAttr,
+		&stackSize))
+	{
+		/*TIMM_OSAL_Error("Task Init Set Stack Size failed!"); */
+		goto EXIT;
+	}
+
+	/*Check if requested stack size is larger than the current default stack size */
+	if (uStackSize > stackSize)
+	{
+		stackSize = uStackSize;
+		if (SUCCESS != pthread_attr_setstacksize(&pHandle->ThreadAttr,
+			stackSize))
+		{
+			/*TIMM_OSAL_Error("Task Init Set Stack Size failed!"); */
+			goto EXIT;
+		}
+	}
+
+
+
+	if (SUCCESS != pthread_create(&pHandle->threadID,
+		&pHandle->ThreadAttr, pFunc, pArgv))
+	{
+		/*TIMM_OSAL_Error ("Create_Task failed !"); */
+		goto EXIT;
+	}
+
+
+	/* Task was successfully created */
+	pHandle->isCreated = TIMM_OSAL_TRUE;
+	*pTask = (TIMM_OSAL_PTR) pHandle;
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+    /**pTask = (TIMM_OSAL_PTR *)pHandle;*/
+
+      EXIT:
+/*    if((TIMM_OSAL_ERR_NONE != bReturnStatus) && (TIMM_OSAL_NULL != pHandle)) {
+       TIMM_OSAL_Free (pHandle->stackPtr);*/
+	if ((TIMM_OSAL_ERR_NONE != bReturnStatus))
+	{
+		TIMM_OSAL_Free(pHandle);
+	}
+	return bReturnStatus;
+
+}
+
+/* ========================================================================== */
+/**
+* @fn TIMM_OSAL_DeleteTask
+*
+* @see
+*/
+/* ========================================================================== */
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_DeleteTask(TIMM_OSAL_PTR pTask)
+{
+	TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
+
+	TIMM_OSAL_TASK *pHandle = (TIMM_OSAL_TASK *) pTask;
+	void *retVal;
+
+	if ((NULL == pHandle) || (TIMM_OSAL_TRUE != pHandle->isCreated))
+	{
+		/* this task was never created */
+		bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
+		goto EXIT;
+	}
+	if (pthread_attr_destroy(&pHandle->ThreadAttr))
+	{
+		/*TIMM_OSAL_Error("Delete_Task failed !"); */
+		goto EXIT;
+	}
+	if (pthread_join(pHandle->threadID, &retVal))
+	{
+		/*TIMM_OSAL_Error("Delete_Task failed !"); */
+		goto EXIT;
+		/*	bReturnStatus = TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR, TIMM_OSAL_COMP_TASK, status);*//*shm to be done */
+	}
+	bReturnStatus = TIMM_OSAL_ERR_NONE;
+	TIMM_OSAL_Free(pHandle);
+      EXIT:
+	return bReturnStatus;
+}
+
+
+TIMM_OSAL_ERRORTYPE TIMM_OSAL_SleepTask(TIMM_OSAL_U32 mSec)
+{
+	TIMM_OSAL_S32 nReturn = 0;
+
+#ifdef _POSIX_VERSION_1_
+	usleep(1000 * mSec);
+#else
+	nReturn = usleep(1000 * mSec);
+#endif
+	if (nReturn == 0)
+		return TIMM_OSAL_ERR_NONE;
+	else
+		return TIMM_OSAL_ERR_UNKNOWN;
+}
diff --git a/domx/mm_osal/src/timm_osal_trace.c b/domx/mm_osal/src/timm_osal_trace.c
new file mode 100755
index 0000000..874deb7
--- /dev/null
+++ b/domx/mm_osal/src/timm_osal_trace.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+*   @file  timm_osal_trace.c
+*   This file contains methods that provides the functionality
+*   for logging errors/warings/information/etc.
+*
+*  @path \
+*
+*/
+/* -------------------------------------------------------------------------- */
+/* =========================================================================
+ *!
+ *! Revision History
+ *! ===================================
+ *!
+ * ========================================================================= */
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+
+/*#include "typedefs.h"*/
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "timm_osal_trace.h"
+
+#ifdef _Android
+#define LOG_TAG "DOMX"
+#include <utils/Log.h>
+#endif
+
+/**
+* The OSAL debug trace detail can be set at compile time by defining the flag
+* TIMM_OSAL_DEBUG_TRACE_DETAIL=<Details>
+* detail - 0 - no detail
+*          1 - function name
+*          2 - function name, line number
+* Prefix is added to every debug trace message
+*/
+#ifndef TIMM_OSAL_DEBUG_TRACE_DETAIL
+#define TIMM_OSAL_DEBUG_TRACE_DETAIL 2
+#endif
+
+#define DEFAULT_TRACE_LEVEL 1
+
+static int trace_level = -1;
+
+/* strip out leading ../ stuff that happens to __FILE__ for out-of-tree builds */
+static const char *simplify_path(const char *file)
+{
+	while (file)
+	{
+		char c = file[0];
+		if ((c != '.') && (c != '/') && (c != '\\'))
+			break;
+		file++;
+	}
+	return file;
+}
+
+void __TIMM_OSAL_TraceFunction(const __TIMM_OSAL_TRACE_LOCATION * loc,
+    const char *fmt, ...)
+{
+	if (trace_level == -1)
+	{
+		char *val = getenv("TIMM_OSAL_DEBUG_TRACE_LEVEL");
+		trace_level =
+		    val ? strtol(val, NULL, 0) : DEFAULT_TRACE_LEVEL;
+	}
+
+	if (trace_level >= loc->level)
+	{
+		va_list ap;
+
+		va_start(ap, fmt);	/* make ap point to first arg after 'fmt' */
+
+#ifdef _Android
+
+#if ( TIMM_OSAL_DEBUG_TRACE_DETAIL > 1 )
+		LOGD("%s:%d\t%s()\t", simplify_path(loc->file), loc->line,
+		    loc->function);
+#endif
+		char string[1000];
+		vsprintf(string, fmt, ap);
+		LOGD("%s",string);
+
+#else
+
+#if ( TIMM_OSAL_DEBUG_TRACE_DETAIL > 1 )
+		printf("%s:%d\t%s()\t", simplify_path(loc->file), loc->line,
+		    loc->function);
+#endif
+		vprintf(fmt, ap);
+
+#endif
+		va_end(ap);
+	}
+}
diff --git a/domx/omx_core/Android.mk b/domx/omx_core/Android.mk
new file mode 100644
index 0000000..072b81b
--- /dev/null
+++ b/domx/omx_core/Android.mk
@@ -0,0 +1,21 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+    src/OMX_Core.c \
+    src/OMX_Core_Wrapper.c
+
+LOCAL_C_INCLUDES += \
+    $(LOCAL_PATH)/inc \
+    $(LOCAL_PATH)/../mm_osal/inc
+
+LOCAL_SHARED_LIBRARIES := \
+    libdl \
+    liblog \
+    libmm_osal
+
+LOCAL_CFLAGS += -DSTATIC_TABLE -D_Android
+LOCAL_MODULE:= libOMX_Core
+LOCAL_MODULE_TAGS:= optional
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
diff --git a/domx/omx_core/Makefile b/domx/omx_core/Makefile
new file mode 100644
index 0000000..5c6c563
--- /dev/null
+++ b/domx/omx_core/Makefile
@@ -0,0 +1,99 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  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.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+#PROJROOT = ..
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         += -DSTATIC_TABLE 
+CDEFS          = 
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG 
+endif
+CDEFS          +=
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = libomx_core
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = SH_LIB
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = lib
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = lib
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+    src/OMX_Core.c \
+
+
+# Search path for include files
+
+INCLUDES    = \
+    $(PROJROOT)/omx_core/inc \
+    $(PROJROOT)/mm_osal/inc \
+
+# Libraries needed for linking.
+
+ST_LIBS        = 
+#mm_osal omx_proxy_component
+SH_LIBS        = mm_osal dl
+#pthread rt utils procmgr ipc rcm notify
+#SH_LIBS        += sysmgr sysmemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/mm_osal
+#              $(PROJROOT)/video/omx_proxy_component/src
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
diff --git a/domx/omx_core/inc/OMX_Audio.h b/domx/omx_core/inc/OMX_Audio.h
new file mode 100755
index 0000000..04f1a99
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Audio.h
@@ -0,0 +1,1311 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** @file OMX_Audio.h - OpenMax IL version 1.1.2
+ *  The structures needed by Audio components to exchange
+ *  parameters and configuration data with the componenmilts.
+ */
+
+#ifndef OMX_Audio_h
+#define OMX_Audio_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header must include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+
+#include <OMX_Core.h>
+
+/** @defgroup midi MIDI
+ * @ingroup audio
+ */
+ 
+/** @defgroup effects Audio effects
+ * @ingroup audio
+ */
+
+/** @defgroup audio OpenMAX IL Audio Domain
+ * Structures for OpenMAX IL Audio domain
+ * @{
+ */
+
+/** Enumeration used to define the possible audio codings.  
+ *  If "OMX_AUDIO_CodingUnused" is selected, the coding selection must 
+ *  be done in a vendor specific way.  Since this is for an audio 
+ *  processing element this enum is relevant.  However, for another 
+ *  type of component other enums would be in this area.
+ */
+typedef enum OMX_AUDIO_CODINGTYPE {
+    OMX_AUDIO_CodingUnused = 0,  /**< Placeholder value when coding is N/A  */
+    OMX_AUDIO_CodingAutoDetect,  /**< auto detection of audio format */
+    OMX_AUDIO_CodingPCM,         /**< Any variant of PCM coding */
+    OMX_AUDIO_CodingADPCM,       /**< Any variant of ADPCM encoded data */
+    OMX_AUDIO_CodingAMR,         /**< Any variant of AMR encoded data */
+    OMX_AUDIO_CodingGSMFR,       /**< Any variant of GSM fullrate (i.e. GSM610) */
+    OMX_AUDIO_CodingGSMEFR,      /**< Any variant of GSM Enhanced Fullrate encoded data*/
+    OMX_AUDIO_CodingGSMHR,       /**< Any variant of GSM Halfrate encoded data */
+    OMX_AUDIO_CodingPDCFR,       /**< Any variant of PDC Fullrate encoded data */
+    OMX_AUDIO_CodingPDCEFR,      /**< Any variant of PDC Enhanced Fullrate encoded data */
+    OMX_AUDIO_CodingPDCHR,       /**< Any variant of PDC Halfrate encoded data */
+    OMX_AUDIO_CodingTDMAFR,      /**< Any variant of TDMA Fullrate encoded data (TIA/EIA-136-420) */
+    OMX_AUDIO_CodingTDMAEFR,     /**< Any variant of TDMA Enhanced Fullrate encoded data (TIA/EIA-136-410) */
+    OMX_AUDIO_CodingQCELP8,      /**< Any variant of QCELP 8kbps encoded data */
+    OMX_AUDIO_CodingQCELP13,     /**< Any variant of QCELP 13kbps encoded data */
+    OMX_AUDIO_CodingEVRC,        /**< Any variant of EVRC encoded data */
+    OMX_AUDIO_CodingSMV,         /**< Any variant of SMV encoded data */
+    OMX_AUDIO_CodingG711,        /**< Any variant of G.711 encoded data */
+    OMX_AUDIO_CodingG723,        /**< Any variant of G.723 dot 1 encoded data */
+    OMX_AUDIO_CodingG726,        /**< Any variant of G.726 encoded data */
+    OMX_AUDIO_CodingG729,        /**< Any variant of G.729 encoded data */
+    OMX_AUDIO_CodingAAC,         /**< Any variant of AAC encoded data */
+    OMX_AUDIO_CodingMP3,         /**< Any variant of MP3 encoded data */
+    OMX_AUDIO_CodingSBC,         /**< Any variant of SBC encoded data */
+    OMX_AUDIO_CodingVORBIS,      /**< Any variant of VORBIS encoded data */
+    OMX_AUDIO_CodingWMA,         /**< Any variant of WMA encoded data */
+    OMX_AUDIO_CodingRA,          /**< Any variant of RA encoded data */
+    OMX_AUDIO_CodingMIDI,        /**< Any variant of MIDI encoded data */
+    OMX_AUDIO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_CodingMax = 0x7FFFFFFF
+} OMX_AUDIO_CODINGTYPE;
+
+
+/** The PortDefinition structure is used to define all of the parameters 
+ *  necessary for the compliant component to setup an input or an output audio 
+ *  path.  If additional information is needed to define the parameters of the
+ *  port (such as frequency), additional structures must be sent such as the
+ *  OMX_AUDIO_PARAM_PCMMODETYPE structure to supply the extra parameters for the port.
+ */
+typedef struct OMX_AUDIO_PORTDEFINITIONTYPE {
+    OMX_STRING cMIMEType;            /**< MIME type of data for the port */
+    OMX_NATIVE_DEVICETYPE pNativeRender; /** < platform specific reference
+                                               for an output device, 
+                                               otherwise this field is 0 */
+    OMX_BOOL bFlagErrorConcealment;  /**< Turns on error concealment if it is 
+                                          supported by the OMX component */
+    OMX_AUDIO_CODINGTYPE eEncoding;  /**< Type of data expected for this 
+                                          port (e.g. PCM, AMR, MP3, etc) */
+} OMX_AUDIO_PORTDEFINITIONTYPE;
+
+
+/**  Port format parameter.  This structure is used to enumerate
+  *  the various data input/output format supported by the port.
+  */
+typedef struct OMX_AUDIO_PARAM_PORTFORMATTYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_U32 nPortIndex;             /**< Indicates which port to set */
+    OMX_U32 nIndex;                 /**< Indicates the enumeration index for the format from 0x0 to N-1 */
+    OMX_AUDIO_CODINGTYPE eEncoding; /**< Type of data expected for this port (e.g. PCM, AMR, MP3, etc) */
+} OMX_AUDIO_PARAM_PORTFORMATTYPE;
+
+
+/** PCM mode type  */ 
+typedef enum OMX_AUDIO_PCMMODETYPE { 
+    OMX_AUDIO_PCMModeLinear = 0,  /**< Linear PCM encoded data */ 
+    OMX_AUDIO_PCMModeALaw,        /**< A law PCM encoded data (G.711) */ 
+    OMX_AUDIO_PCMModeMULaw,       /**< Mu law PCM encoded data (G.711)  */ 
+    OMX_AUDIO_PCMModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_PCMModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_PCMModeMax = 0x7FFFFFFF 
+} OMX_AUDIO_PCMMODETYPE; 
+
+
+typedef enum OMX_AUDIO_CHANNELTYPE {
+    OMX_AUDIO_ChannelNone = 0x0,    /**< Unused or empty */
+    OMX_AUDIO_ChannelLF   = 0x1,    /**< Left front */
+    OMX_AUDIO_ChannelRF   = 0x2,    /**< Right front */
+    OMX_AUDIO_ChannelCF   = 0x3,    /**< Center front */
+    OMX_AUDIO_ChannelLS   = 0x4,    /**< Left surround */
+    OMX_AUDIO_ChannelRS   = 0x5,    /**< Right surround */
+    OMX_AUDIO_ChannelLFE  = 0x6,    /**< Low frequency effects */
+    OMX_AUDIO_ChannelCS   = 0x7,    /**< Back surround */
+    OMX_AUDIO_ChannelLR   = 0x8,    /**< Left rear. */
+    OMX_AUDIO_ChannelRR   = 0x9,    /**< Right rear. */
+    OMX_AUDIO_ChannelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_ChannelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_ChannelMax  = 0x7FFFFFFF 
+} OMX_AUDIO_CHANNELTYPE;
+
+#define OMX_AUDIO_MAXCHANNELS 16  /**< maximum number distinct audio channels that a buffer may contain */
+#define OMX_MIN_PCMPAYLOAD_MSEC 5 /**< Minimum audio buffer payload size for uncompressed (PCM) audio */
+
+/** PCM format description */ 
+typedef struct OMX_AUDIO_PARAM_PCMMODETYPE { 
+    OMX_U32 nSize;                    /**< Size of this structure, in Bytes */ 
+    OMX_VERSIONTYPE nVersion;         /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;               /**< port that this structure applies to */ 
+    OMX_U32 nChannels;                /**< Number of channels (e.g. 2 for stereo) */ 
+    OMX_NUMERICALDATATYPE eNumData;   /**< indicates PCM data as signed or unsigned */ 
+    OMX_ENDIANTYPE eEndian;           /**< indicates PCM data as little or big endian */ 
+    OMX_BOOL bInterleaved;            /**< True for normal interleaved data; false for 
+                                           non-interleaved data (e.g. block data) */ 
+    OMX_U32 nBitPerSample;            /**< Bit per sample */ 
+    OMX_U32 nSamplingRate;            /**< Sampling rate of the source data.  Use 0 for 
+                                           variable or unknown sampling rate. */ 
+    OMX_AUDIO_PCMMODETYPE ePCMMode;   /**< PCM mode enumeration */ 
+    OMX_AUDIO_CHANNELTYPE eChannelMapping[OMX_AUDIO_MAXCHANNELS]; /**< Slot i contains channel defined by eChannelMap[i] */
+
+} OMX_AUDIO_PARAM_PCMMODETYPE; 
+
+
+/** Audio channel mode.  This is used by both AAC and MP3, although the names are more appropriate
+ * for the MP3.  For example, JointStereo for MP3 is CouplingChannels for AAC. 
+ */
+typedef enum OMX_AUDIO_CHANNELMODETYPE {
+    OMX_AUDIO_ChannelModeStereo = 0,  /**< 2 channels, the bitrate allocation between those 
+                                          two channels changes accordingly to each channel information */
+    OMX_AUDIO_ChannelModeJointStereo, /**< mode that takes advantage of what is common between 
+                                           2 channels for higher compression gain */
+    OMX_AUDIO_ChannelModeDual,        /**< 2 mono-channels, each channel is encoded with half 
+                                           the bitrate of the overall bitrate */
+    OMX_AUDIO_ChannelModeMono,        /**< Mono channel mode */
+    OMX_AUDIO_ChannelModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_ChannelModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_ChannelModeMax = 0x7FFFFFFF
+} OMX_AUDIO_CHANNELMODETYPE;
+
+
+typedef enum OMX_AUDIO_MP3STREAMFORMATTYPE {
+    OMX_AUDIO_MP3StreamFormatMP1Layer3 = 0, /**< MP3 Audio MPEG 1 Layer 3 Stream format */
+    OMX_AUDIO_MP3StreamFormatMP2Layer3,     /**< MP3 Audio MPEG 2 Layer 3 Stream format */
+    OMX_AUDIO_MP3StreamFormatMP2_5Layer3,   /**< MP3 Audio MPEG2.5 Layer 3 Stream format */
+    OMX_AUDIO_MP3StreamFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_MP3StreamFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_MP3StreamFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_MP3STREAMFORMATTYPE;
+
+/** MP3 params */
+typedef struct OMX_AUDIO_PARAM_MP3TYPE {
+    OMX_U32 nSize;                 /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
+    OMX_U32 nPortIndex;            /**< port that this structure applies to */
+    OMX_U32 nChannels;             /**< Number of channels */
+    OMX_U32 nBitRate;              /**< Bit rate of the input data.  Use 0 for variable
+                                        rate or unknown bit rates */
+    OMX_U32 nSampleRate;           /**< Sampling rate of the source data.  Use 0 for
+                                        variable or unknown sampling rate. */
+    OMX_U32 nAudioBandWidth;       /**< Audio band width (in Hz) to which an encoder should
+                                        limit the audio signal. Use 0 to let encoder decide */
+    OMX_AUDIO_CHANNELMODETYPE eChannelMode;   /**< Channel mode enumeration */
+    OMX_AUDIO_MP3STREAMFORMATTYPE eFormat;  /**< MP3 stream format */
+} OMX_AUDIO_PARAM_MP3TYPE;
+
+
+typedef enum OMX_AUDIO_AACSTREAMFORMATTYPE {
+    OMX_AUDIO_AACStreamFormatMP2ADTS = 0, /**< AAC Audio Data Transport Stream 2 format */
+    OMX_AUDIO_AACStreamFormatMP4ADTS,     /**< AAC Audio Data Transport Stream 4 format */
+    OMX_AUDIO_AACStreamFormatMP4LOAS,     /**< AAC Low Overhead Audio Stream format */
+    OMX_AUDIO_AACStreamFormatMP4LATM,     /**< AAC Low overhead Audio Transport Multiplex */
+    OMX_AUDIO_AACStreamFormatADIF,        /**< AAC Audio Data Interchange Format */
+    OMX_AUDIO_AACStreamFormatMP4FF,       /**< AAC inside MPEG-4/ISO File Format */
+    OMX_AUDIO_AACStreamFormatRAW,         /**< AAC Raw Format */
+    OMX_AUDIO_AACStreamFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_AACStreamFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_AACStreamFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_AACSTREAMFORMATTYPE;
+
+
+/** AAC mode type.  Note that the term profile is used with the MPEG-2
+ * standard and the term object type and profile is used with MPEG-4 */
+typedef enum OMX_AUDIO_AACPROFILETYPE{
+  OMX_AUDIO_AACObjectNull = 0,      /**< Null, not used */
+  OMX_AUDIO_AACObjectMain = 1,      /**< AAC Main object */
+  OMX_AUDIO_AACObjectLC,            /**< AAC Low Complexity object (AAC profile) */
+  OMX_AUDIO_AACObjectSSR,           /**< AAC Scalable Sample Rate object */
+  OMX_AUDIO_AACObjectLTP,           /**< AAC Long Term Prediction object */
+  OMX_AUDIO_AACObjectHE,            /**< AAC High Efficiency (object type SBR, HE-AAC profile) */
+  OMX_AUDIO_AACObjectScalable,      /**< AAC Scalable object */
+  OMX_AUDIO_AACObjectERLC = 17,     /**< ER AAC Low Complexity object (Error Resilient AAC-LC) */
+  OMX_AUDIO_AACObjectLD = 23,       /**< AAC Low Delay object (Error Resilient) */
+  OMX_AUDIO_AACObjectHE_PS = 29,    /**< AAC High Efficiency with Parametric Stereo coding (HE-AAC v2, object type PS) */
+  OMX_AUDIO_AACObjectKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_AACObjectVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_AACObjectMax = 0x7FFFFFFF
+} OMX_AUDIO_AACPROFILETYPE;
+
+
+/** AAC tool usage (for nAACtools in OMX_AUDIO_PARAM_AACPROFILETYPE).
+ * Required for encoder configuration and optional as decoder info output.
+ * For MP3, OMX_AUDIO_CHANNELMODETYPE is sufficient. */
+#define OMX_AUDIO_AACToolNone 0x00000000 /**< no AAC tools allowed (encoder config) or active (decoder info output) */
+#define OMX_AUDIO_AACToolMS   0x00000001 /**< MS: Mid/side joint coding tool allowed or active */
+#define OMX_AUDIO_AACToolIS   0x00000002 /**< IS: Intensity stereo tool allowed or active */
+#define OMX_AUDIO_AACToolTNS  0x00000004 /**< TNS: Temporal Noise Shaping tool allowed or active */
+#define OMX_AUDIO_AACToolPNS  0x00000008 /**< PNS: MPEG-4 Perceptual Noise substitution tool allowed or active */
+#define OMX_AUDIO_AACToolLTP  0x00000010 /**< LTP: MPEG-4 Long Term Prediction tool allowed or active */
+#define OMX_AUDIO_AACToolAll  0x7FFFFFFF /**< all AAC tools allowed or active (*/
+
+/** MPEG-4 AAC error resilience (ER) tool usage (for nAACERtools in OMX_AUDIO_PARAM_AACPROFILETYPE).
+ * Required for ER encoder configuration and optional as decoder info output */
+#define OMX_AUDIO_AACERNone  0x00000000  /**< no AAC ER tools allowed/used */
+#define OMX_AUDIO_AACERVCB11 0x00000001  /**< VCB11: Virtual Code Books for AAC section data */
+#define OMX_AUDIO_AACERRVLC  0x00000002  /**< RVLC: Reversible Variable Length Coding */
+#define OMX_AUDIO_AACERHCR   0x00000004  /**< HCR: Huffman Codeword Reordering */
+#define OMX_AUDIO_AACERAll   0x7FFFFFFF  /**< all AAC ER tools allowed/used */
+
+
+/** AAC params */
+typedef struct OMX_AUDIO_PARAM_AACPROFILETYPE {
+    OMX_U32 nSize;                 /**< Size of this structure, in Bytes */
+    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
+    OMX_U32 nPortIndex;            /**< Port that this structure applies to */
+    OMX_U32 nChannels;             /**< Number of channels */
+    OMX_U32 nSampleRate;           /**< Sampling rate of the source data.  Use 0 for
+                                        variable or unknown sampling rate. */
+    OMX_U32 nBitRate;              /**< Bit rate of the input data.  Use 0 for variable
+                                        rate or unknown bit rates */
+    OMX_U32 nAudioBandWidth;       /**< Audio band width (in Hz) to which an encoder should
+                                        limit the audio signal. Use 0 to let encoder decide */
+    OMX_U32 nFrameLength;          /**< Frame length (in audio samples per channel) of the codec.
+                                        Can be 1024 or 960 (AAC-LC), 2048 (HE-AAC), 480 or 512 (AAC-LD).
+                                        Use 0 to let encoder decide */
+    OMX_U32 nAACtools;             /**< AAC tool usage */
+    OMX_U32 nAACERtools;           /**< MPEG-4 AAC error resilience tool usage */
+    OMX_AUDIO_AACPROFILETYPE eAACProfile;   /**< AAC profile enumeration */
+    OMX_AUDIO_AACSTREAMFORMATTYPE eAACStreamFormat; /**< AAC stream format enumeration */
+    OMX_AUDIO_CHANNELMODETYPE eChannelMode;   /**< Channel mode enumeration */
+} OMX_AUDIO_PARAM_AACPROFILETYPE;
+
+
+/** VORBIS params */
+typedef struct OMX_AUDIO_PARAM_VORBISTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_U32 nChannels;        /**< Number of channels */
+    OMX_U32 nBitRate;         /**< Bit rate of the encoded data data.  Use 0 for variable
+                                   rate or unknown bit rates. Encoding is set to the
+                                   bitrate closest to specified  value (in bps) */
+    OMX_U32 nMinBitRate;      /**< Sets minimum bitrate (in bps). */
+    OMX_U32 nMaxBitRate;      /**< Sets maximum bitrate (in bps). */
+
+    OMX_U32 nSampleRate;      /**< Sampling rate of the source data.  Use 0 for
+                                   variable or unknown sampling rate. */
+    OMX_U32 nAudioBandWidth;  /**< Audio band width (in Hz) to which an encoder should
+                                   limit the audio signal. Use 0 to let encoder decide */
+    OMX_S32 nQuality;		  /**< Sets encoding quality to n, between -1 (low) and 10 (high).
+                                   In the default mode of operation, teh quality level is 3.
+                                   Normal quality range is 0 - 10. */
+    OMX_BOOL bManaged;		  /**< Set  bitrate  management  mode. This turns off the
+                                   normal VBR encoding, but allows hard or soft bitrate
+                                   constraints to be enforced by the encoder. This mode can
+                                   be slower, and may also be lower quality. It is
+                                   primarily useful for streaming. */
+    OMX_BOOL bDownmix;		  /**< Downmix input from stereo to mono (has no effect on 
+                                   non-stereo streams). Useful for lower-bitrate encoding. */     
+} OMX_AUDIO_PARAM_VORBISTYPE;
+
+
+/** WMA Version */
+typedef enum OMX_AUDIO_WMAFORMATTYPE {
+  OMX_AUDIO_WMAFormatUnused = 0, /**< format unused or unknown */
+  OMX_AUDIO_WMAFormat7,          /**< Windows Media Audio format 7 */
+  OMX_AUDIO_WMAFormat8,          /**< Windows Media Audio format 8 */
+  OMX_AUDIO_WMAFormat9,          /**< Windows Media Audio format 9 */
+  OMX_AUDIO_WMAFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_WMAFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_WMAFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_WMAFORMATTYPE;
+
+
+/** WMA Profile */
+typedef enum OMX_AUDIO_WMAPROFILETYPE {
+  OMX_AUDIO_WMAProfileUnused = 0,  /**< profile unused or unknown */
+  OMX_AUDIO_WMAProfileL1,          /**< Windows Media audio version 9 profile L1 */
+  OMX_AUDIO_WMAProfileL2,          /**< Windows Media audio version 9 profile L2 */
+  OMX_AUDIO_WMAProfileL3,          /**< Windows Media audio version 9 profile L3 */
+  OMX_AUDIO_WMAProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_WMAProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_WMAProfileMax = 0x7FFFFFFF
+} OMX_AUDIO_WMAPROFILETYPE;
+
+
+/** WMA params */
+typedef struct OMX_AUDIO_PARAM_WMATYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_U16 nChannels;        /**< Number of channels */
+    OMX_U32 nBitRate;         /**< Bit rate of the input data.  Use 0 for variable
+                                   rate or unknown bit rates */
+    OMX_AUDIO_WMAFORMATTYPE eFormat; /**< Version of WMA stream / data */
+	OMX_AUDIO_WMAPROFILETYPE eProfile;  /**< Profile of WMA stream / data */
+    OMX_U32 nSamplingRate;    /**< Sampling rate of the source data */
+    OMX_U16 nBlockAlign;      /**< is the block alignment, or block size, in bytes of the audio codec */
+    OMX_U16 nEncodeOptions;   /**< WMA Type-specific data */
+    OMX_U32 nSuperBlockAlign; /**< WMA Type-specific data */
+} OMX_AUDIO_PARAM_WMATYPE;
+
+/** 
+ * RealAudio format
+ */
+typedef enum OMX_AUDIO_RAFORMATTYPE {
+    OMX_AUDIO_RAFormatUnused = 0, /**< Format unused or unknown */
+    OMX_AUDIO_RA8,                /**< RealAudio 8 codec */
+    OMX_AUDIO_RA9,                /**< RealAudio 9 codec */
+    OMX_AUDIO_RA10_AAC,           /**< MPEG-4 AAC codec for bitrates of more than 128kbps */
+    OMX_AUDIO_RA10_CODEC,         /**< RealAudio codec for bitrates less than 128 kbps */
+    OMX_AUDIO_RA10_LOSSLESS,      /**< RealAudio Lossless */
+    OMX_AUDIO_RA10_MULTICHANNEL,  /**< RealAudio Multichannel */
+    OMX_AUDIO_RA10_VOICE,         /**< RealAudio Voice for bitrates below 15 kbps */
+    OMX_AUDIO_RAFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_RAFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_RAFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_RAFORMATTYPE;
+
+/** RA (Real Audio) params */ 
+typedef struct OMX_AUDIO_PARAM_RATYPE { 
+    OMX_U32 nSize;              /**< Size of this structure, in Bytes */ 
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;         /**< Port that this structure applies to */ 
+    OMX_U32 nChannels;          /**< Number of channels */ 
+    OMX_U32 nSamplingRate;      /**< is the sampling rate of the source data */ 
+    OMX_U32 nBitsPerFrame;      /**< is the value for bits per frame  */ 
+    OMX_U32 nSamplePerFrame;    /**< is the value for samples per frame */ 
+    OMX_U32 nCouplingQuantBits; /**< is the number of coupling quantization bits in the stream */ 
+    OMX_U32 nCouplingStartRegion;   /**< is the coupling start region in the stream  */ 
+    OMX_U32 nNumRegions;        /**< is the number of regions value */ 
+    OMX_AUDIO_RAFORMATTYPE eFormat; /**< is the RealAudio audio format */
+} OMX_AUDIO_PARAM_RATYPE; 
+
+
+/** SBC Allocation Method Type */
+typedef enum OMX_AUDIO_SBCALLOCMETHODTYPE {
+  OMX_AUDIO_SBCAllocMethodLoudness, /**< Loudness allocation method */
+  OMX_AUDIO_SBCAllocMethodSNR,      /**< SNR allocation method */
+  OMX_AUDIO_SBCAllocMethodKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_SBCAllocMethodVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_SBCAllocMethodMax = 0x7FFFFFFF
+} OMX_AUDIO_SBCALLOCMETHODTYPE;
+
+
+/** SBC params */
+typedef struct OMX_AUDIO_PARAM_SBCTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_U32 nChannels;         /**< Number of channels */
+    OMX_U32 nBitRate;          /**< Bit rate of the input data.  Use 0 for variable
+                                    rate or unknown bit rates */
+    OMX_U32 nSampleRate;       /**< Sampling rate of the source data.  Use 0 for
+                                    variable or unknown sampling rate. */
+    OMX_U32 nBlocks;           /**< Number of blocks */
+    OMX_U32 nSubbands;         /**< Number of subbands */
+    OMX_U32 nBitPool;          /**< Bitpool value */
+    OMX_BOOL bEnableBitrate;   /**< Use bitrate value instead of bitpool */
+    OMX_AUDIO_CHANNELMODETYPE eChannelMode; /**< Channel mode enumeration */
+    OMX_AUDIO_SBCALLOCMETHODTYPE eSBCAllocType;   /**< SBC Allocation method type */
+} OMX_AUDIO_PARAM_SBCTYPE;
+
+
+/** ADPCM stream format parameters */ 
+typedef struct OMX_AUDIO_PARAM_ADPCMTYPE { 
+    OMX_U32 nSize;              /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */ 
+    OMX_U32 nChannels;          /**< Number of channels in the data stream (not 
+                                     necessarily the same as the number of channels 
+                                     to be rendered. */ 
+    OMX_U32 nBitsPerSample;     /**< Number of bits in each sample */ 
+    OMX_U32 nSampleRate;        /**< Sampling rate of the source data.  Use 0 for 
+                                    variable or unknown sampling rate. */ 
+} OMX_AUDIO_PARAM_ADPCMTYPE; 
+
+
+/** G723 rate */
+typedef enum OMX_AUDIO_G723RATE {
+    OMX_AUDIO_G723ModeUnused = 0,  /**< AMRNB Mode unused / unknown */
+    OMX_AUDIO_G723ModeLow,         /**< 5300 bps */
+    OMX_AUDIO_G723ModeHigh,        /**< 6300 bps */
+    OMX_AUDIO_G723ModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_G723ModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_G723ModeMax = 0x7FFFFFFF
+} OMX_AUDIO_G723RATE;
+
+
+/** G723 - Sample rate must be 8 KHz */
+typedef struct OMX_AUDIO_PARAM_G723TYPE { 
+    OMX_U32 nSize;                /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */ 
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not 
+                                       necessarily the same as the number of channels 
+                                       to be rendered. */ 
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */ 
+    OMX_AUDIO_G723RATE eBitRate;  /**< todo: Should this be moved to a config? */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */ 
+    OMX_BOOL bPostFilter;         /**< Enable Post Filter */ 
+} OMX_AUDIO_PARAM_G723TYPE; 
+
+
+/** ITU G726 (ADPCM) rate */
+typedef enum OMX_AUDIO_G726MODE {
+    OMX_AUDIO_G726ModeUnused = 0,  /**< G726 Mode unused / unknown */
+    OMX_AUDIO_G726Mode16,          /**< 16 kbps */
+    OMX_AUDIO_G726Mode24,          /**< 24 kbps */
+    OMX_AUDIO_G726Mode32,          /**< 32 kbps, most common rate, also G721 */
+    OMX_AUDIO_G726Mode40,          /**< 40 kbps */
+    OMX_AUDIO_G726ModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_G726ModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_G726ModeMax = 0x7FFFFFFF
+} OMX_AUDIO_G726MODE;
+
+
+/** G.726 stream format parameters - must be at 8KHz */ 
+typedef struct OMX_AUDIO_PARAM_G726TYPE { 
+    OMX_U32 nSize;              /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */ 
+    OMX_U32 nChannels;          /**< Number of channels in the data stream (not 
+                                     necessarily the same as the number of channels 
+                                     to be rendered. */ 
+     OMX_AUDIO_G726MODE eG726Mode;
+} OMX_AUDIO_PARAM_G726TYPE; 
+
+
+/** G729 coder type */
+typedef enum OMX_AUDIO_G729TYPE {
+    OMX_AUDIO_G729 = 0,           /**< ITU G.729  encoded data */
+    OMX_AUDIO_G729A,              /**< ITU G.729 annex A  encoded data */
+    OMX_AUDIO_G729B,              /**< ITU G.729 with annex B encoded data */
+    OMX_AUDIO_G729AB,             /**< ITU G.729 annexes A and B encoded data */
+    OMX_AUDIO_G729KhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_G729VendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_G729Max = 0x7FFFFFFF
+} OMX_AUDIO_G729TYPE;
+
+
+/** G729 stream format parameters - fixed 6KHz sample rate */
+typedef struct OMX_AUDIO_PARAM_G729TYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_U32 nChannels;        /**< Number of channels in the data stream (not
+                                   necessarily the same as the number of channels
+                                   to be rendered. */
+    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
+    OMX_AUDIO_G729TYPE eBitType;
+} OMX_AUDIO_PARAM_G729TYPE;
+
+
+/** AMR Frame format */ 
+typedef enum OMX_AUDIO_AMRFRAMEFORMATTYPE { 
+    OMX_AUDIO_AMRFrameFormatConformance = 0,  /**< Frame Format is AMR Conformance 
+                                                   (Standard) Format */ 
+    OMX_AUDIO_AMRFrameFormatIF1,              /**< Frame Format is AMR Interface 
+                                                   Format 1 */ 
+    OMX_AUDIO_AMRFrameFormatIF2,              /**< Frame Format is AMR Interface 
+                                                   Format 2*/ 
+    OMX_AUDIO_AMRFrameFormatFSF,              /**< Frame Format is AMR File Storage 
+                                                   Format */ 
+    OMX_AUDIO_AMRFrameFormatRTPPayload,       /**< Frame Format is AMR Real-Time 
+                                                   Transport Protocol Payload Format */ 
+    OMX_AUDIO_AMRFrameFormatITU,              /**< Frame Format is ITU Format (added at Motorola request) */ 
+    OMX_AUDIO_AMRFrameFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_AMRFrameFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_AMRFrameFormatMax = 0x7FFFFFFF 
+} OMX_AUDIO_AMRFRAMEFORMATTYPE; 
+
+
+/** AMR band mode */
+typedef enum OMX_AUDIO_AMRBANDMODETYPE {
+    OMX_AUDIO_AMRBandModeUnused = 0,          /**< AMRNB Mode unused / unknown */
+    OMX_AUDIO_AMRBandModeNB0,                 /**< AMRNB Mode 0 =  4750 bps */
+    OMX_AUDIO_AMRBandModeNB1,                 /**< AMRNB Mode 1 =  5150 bps */
+    OMX_AUDIO_AMRBandModeNB2,                 /**< AMRNB Mode 2 =  5900 bps */ 
+    OMX_AUDIO_AMRBandModeNB3,                 /**< AMRNB Mode 3 =  6700 bps */
+    OMX_AUDIO_AMRBandModeNB4,                 /**< AMRNB Mode 4 =  7400 bps */
+    OMX_AUDIO_AMRBandModeNB5,                 /**< AMRNB Mode 5 =  7950 bps */
+    OMX_AUDIO_AMRBandModeNB6,                 /**< AMRNB Mode 6 = 10200 bps */
+    OMX_AUDIO_AMRBandModeNB7,                 /**< AMRNB Mode 7 = 12200 bps */
+    OMX_AUDIO_AMRBandModeWB0,                 /**< AMRWB Mode 0 =  6600 bps */
+    OMX_AUDIO_AMRBandModeWB1,                 /**< AMRWB Mode 1 =  8850 bps */
+    OMX_AUDIO_AMRBandModeWB2,                 /**< AMRWB Mode 2 = 12650 bps */ 
+    OMX_AUDIO_AMRBandModeWB3,                 /**< AMRWB Mode 3 = 14250 bps */ 
+    OMX_AUDIO_AMRBandModeWB4,                 /**< AMRWB Mode 4 = 15850 bps */
+    OMX_AUDIO_AMRBandModeWB5,                 /**< AMRWB Mode 5 = 18250 bps */
+    OMX_AUDIO_AMRBandModeWB6,                 /**< AMRWB Mode 6 = 19850 bps */
+    OMX_AUDIO_AMRBandModeWB7,                 /**< AMRWB Mode 7 = 23050 bps */
+    OMX_AUDIO_AMRBandModeWB8,                 /**< AMRWB Mode 8 = 23850 bps */      
+    OMX_AUDIO_AMRBandModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_AMRBandModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_AMRBandModeMax = 0x7FFFFFFF
+} OMX_AUDIO_AMRBANDMODETYPE;
+     
+
+/** AMR Discontinuous Transmission mode */ 
+typedef enum OMX_AUDIO_AMRDTXMODETYPE { 
+    OMX_AUDIO_AMRDTXModeOff = 0,        /**< AMR Discontinuous Transmission Mode is disabled */ 
+    OMX_AUDIO_AMRDTXModeOnVAD1,         /**< AMR Discontinuous Transmission Mode using 
+                                             Voice Activity Detector 1 (VAD1) is enabled */ 
+    OMX_AUDIO_AMRDTXModeOnVAD2,         /**< AMR Discontinuous Transmission Mode using 
+                                             Voice Activity Detector 2 (VAD2) is enabled */       
+    OMX_AUDIO_AMRDTXModeOnAuto,         /**< The codec will automatically select between 
+                                             Off, VAD1 or VAD2 modes */ 
+
+    OMX_AUDIO_AMRDTXasEFR,             /**< DTX as EFR instead of AMR standard (3GPP 26.101, frame type =8,9,10) */
+
+    OMX_AUDIO_AMRDTXModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_AMRDTXModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_AMRDTXModeMax = 0x7FFFFFFF 
+} OMX_AUDIO_AMRDTXMODETYPE; 
+ 
+
+/** AMR params */
+typedef struct OMX_AUDIO_PARAM_AMRTYPE {
+    OMX_U32 nSize;                          /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;               /**< OMX specification version information */
+    OMX_U32 nPortIndex;                     /**< port that this structure applies to */
+    OMX_U32 nChannels;                      /**< Number of channels */
+    OMX_U32 nBitRate;                       /**< Bit rate read only field */
+    OMX_AUDIO_AMRBANDMODETYPE eAMRBandMode; /**< AMR Band Mode enumeration */ 
+    OMX_AUDIO_AMRDTXMODETYPE  eAMRDTXMode;  /**< AMR DTX Mode enumeration */
+    OMX_AUDIO_AMRFRAMEFORMATTYPE eAMRFrameFormat; /**< AMR frame format enumeration */
+} OMX_AUDIO_PARAM_AMRTYPE;
+
+
+/** GSM_FR (ETSI 06.10, 3GPP 46.010) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_GSMFRTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_GSMFRTYPE;
+
+
+/** GSM-HR (ETSI 06.20, 3GPP 46.020) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_GSMHRTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_GSMHRTYPE;
+
+
+/** GSM-EFR (ETSI 06.60, 3GPP 46.060) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_GSMEFRTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_GSMEFRTYPE;
+
+
+/** TDMA FR (TIA/EIA-136-420, VSELP 7.95kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_TDMAFRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_TDMAFRTYPE;
+
+
+/** TDMA EFR (TIA/EIA-136-410, ACELP 7.4kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_TDMAEFRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_TDMAEFRTYPE;
+
+
+/** PDC FR ( RCR-27, VSELP 6.7kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_PDCFRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_PDCFRTYPE;
+
+
+/** PDC EFR ( RCR-27, ACELP 6.7kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_PDCEFRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_PDCEFRTYPE;
+
+/** PDC HR ( RCR-27, PSI-CELP 3.45kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_PDCHRTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
+    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
+} OMX_AUDIO_PARAM_PDCHRTYPE;
+
+
+/** CDMA Rate types */
+typedef enum OMX_AUDIO_CDMARATETYPE {
+    OMX_AUDIO_CDMARateBlank = 0,          /**< CDMA encoded frame is blank */
+    OMX_AUDIO_CDMARateFull,               /**< CDMA encoded frame in full rate */
+    OMX_AUDIO_CDMARateHalf,               /**< CDMA encoded frame in half rate */
+    OMX_AUDIO_CDMARateQuarter,            /**< CDMA encoded frame in quarter rate */
+    OMX_AUDIO_CDMARateEighth,             /**< CDMA encoded frame in eighth rate (DTX)*/
+    OMX_AUDIO_CDMARateErasure,            /**< CDMA erasure frame */
+    OMX_AUDIO_CDMARateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_CDMARateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_CDMARateMax = 0x7FFFFFFF
+} OMX_AUDIO_CDMARATETYPE;
+
+
+/** QCELP8 (TIA/EIA-96, up to 8kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_QCELP8TYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_U32 nBitRate;             /**< Bit rate of the input data.  Use 0 for variable
+                                       rate or unknown bit rates */
+    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
+    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
+    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
+} OMX_AUDIO_PARAM_QCELP8TYPE;
+
+
+/** QCELP13 ( CDMA, EIA/TIA-733, 13.3kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_QCELP13TYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
+    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
+    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
+} OMX_AUDIO_PARAM_QCELP13TYPE;
+
+
+/** EVRC ( CDMA, EIA/TIA-127, RCELP up to 8.55kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_EVRCTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< actual Frame rate */
+    OMX_BOOL bRATE_REDUCon;       /**< RATE_REDUCtion is requested for this frame */
+    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
+    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
+    OMX_BOOL bHiPassFilter;       /**< Enable encoder's High Pass Filter */
+    OMX_BOOL bNoiseSuppressor;    /**< Enable encoder's noise suppressor pre-processing */
+    OMX_BOOL bPostFilter;         /**< Enable decoder's post Filter */
+} OMX_AUDIO_PARAM_EVRCTYPE;
+
+
+/** SMV ( up to 8.55kbps coder) stream format parameters */
+typedef struct OMX_AUDIO_PARAM_SMVTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_U32 nChannels;            /**< Number of channels in the data stream (not
+                                       necessarily the same as the number of channels
+                                       to be rendered. */
+    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
+    OMX_BOOL bRATE_REDUCon;           /**< RATE_REDUCtion is requested for this frame */
+    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 ??*/
+    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 ??*/
+    OMX_BOOL bHiPassFilter;       /**< Enable encoder's High Pass Filter ??*/
+    OMX_BOOL bNoiseSuppressor;    /**< Enable encoder's noise suppressor pre-processing */
+    OMX_BOOL bPostFilter;         /**< Enable decoder's post Filter ??*/
+} OMX_AUDIO_PARAM_SMVTYPE;
+
+
+/** MIDI Format 
+ * @ingroup midi
+ */
+typedef enum OMX_AUDIO_MIDIFORMATTYPE
+{
+    OMX_AUDIO_MIDIFormatUnknown = 0, /**< MIDI Format unknown or don't care */
+    OMX_AUDIO_MIDIFormatSMF0,        /**< Standard MIDI File Type 0 */
+    OMX_AUDIO_MIDIFormatSMF1,        /**< Standard MIDI File Type 1 */
+    OMX_AUDIO_MIDIFormatSMF2,        /**< Standard MIDI File Type 2 */
+    OMX_AUDIO_MIDIFormatSPMIDI,      /**< SP-MIDI */
+    OMX_AUDIO_MIDIFormatXMF0,        /**< eXtensible Music Format type 0 */
+    OMX_AUDIO_MIDIFormatXMF1,        /**< eXtensible Music Format type 1 */
+    OMX_AUDIO_MIDIFormatMobileXMF,   /**< Mobile XMF (eXtensible Music Format type 2) */
+    OMX_AUDIO_MIDIFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_MIDIFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_MIDIFormatMax = 0x7FFFFFFF
+} OMX_AUDIO_MIDIFORMATTYPE;
+
+
+/** MIDI params 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_PARAM_MIDITYPE {
+    OMX_U32 nSize;                 /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
+    OMX_U32 nPortIndex;            /**< port that this structure applies to */
+    OMX_U32 nFileSize;             /**< size of the MIDI file in bytes, where the entire 
+                                        MIDI file passed in, otherwise if 0x0, the MIDI data 
+                                        is merged and streamed (instead of passed as an 
+                                        entire MIDI file) */
+    OMX_BU32 sMaxPolyphony;        /**< Specifies the maximum simultaneous polyphonic 
+                                        voices. A value of zero indicates that the default 
+                                        polyphony of the device is used  */                                    
+    OMX_BOOL bLoadDefaultSound;    /**< Whether to load default sound 
+                                        bank at initialization */
+    OMX_AUDIO_MIDIFORMATTYPE eMidiFormat; /**< Version of the MIDI file */                                                                           
+} OMX_AUDIO_PARAM_MIDITYPE;
+
+
+/** Type of the MIDI sound bank 
+ * @ingroup midi
+ */
+typedef enum OMX_AUDIO_MIDISOUNDBANKTYPE {
+    OMX_AUDIO_MIDISoundBankUnused = 0,           /**< unused/unknown soundbank type */
+    OMX_AUDIO_MIDISoundBankDLS1,                 /**< DLS version 1 */
+    OMX_AUDIO_MIDISoundBankDLS2,                 /**< DLS version 2 */
+    OMX_AUDIO_MIDISoundBankMobileDLSBase,        /**< Mobile DLS, using the base functionality */
+    OMX_AUDIO_MIDISoundBankMobileDLSPlusOptions, /**< Mobile DLS, using the specification-defined optional feature set */
+    OMX_AUDIO_MIDISoundBankKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_MIDISoundBankVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_MIDISoundBankMax = 0x7FFFFFFF
+} OMX_AUDIO_MIDISOUNDBANKTYPE;
+
+
+/** Bank Layout describes how bank MSB & LSB are used in the DLS instrument definitions sound bank 
+ * @ingroup midi
+ */
+typedef enum OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE {
+   OMX_AUDIO_MIDISoundBankLayoutUnused = 0,   /**< unused/unknown soundbank type */
+   OMX_AUDIO_MIDISoundBankLayoutGM,           /**< GS layout (based on bank MSB 0x00) */
+   OMX_AUDIO_MIDISoundBankLayoutGM2,          /**< General MIDI 2 layout (using MSB 0x78/0x79, LSB 0x00) */
+   OMX_AUDIO_MIDISoundBankLayoutUser,         /**< Does not conform to any bank numbering standards */
+   OMX_AUDIO_MIDISoundBankLayoutKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+   OMX_AUDIO_MIDISoundBankLayoutVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+   OMX_AUDIO_MIDISoundBankLayoutMax = 0x7FFFFFFF
+} OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE;
+
+
+/** MIDI params to load/unload user soundbank 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */
+    OMX_U32 nDLSIndex;        /**< DLS file index to be loaded */
+    OMX_U32 nDLSSize;         /**< Size in bytes */
+    OMX_PTR pDLSData;         /**< Pointer to DLS file data */
+    OMX_AUDIO_MIDISOUNDBANKTYPE eMidiSoundBank;   /**< Midi sound bank type enumeration */
+    OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE eMidiSoundBankLayout; /**< Midi sound bank layout enumeration */
+} OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE;
+
+
+/** Structure for Live MIDI events and MIP messages. 
+ * (MIP = Maximum Instantaneous Polyphony; part of the SP-MIDI standard.) 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex;       /**< Port that this structure applies to */
+    OMX_U32 nMidiEventSize;   /**< Size of immediate MIDI events or MIP message in bytes  */
+    OMX_U8 nMidiEvents[1];    /**< MIDI event array to be rendered immediately, or an
+                                   array for the MIP message buffer, where the size is 
+                                   indicated by nMidiEventSize */
+} OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE;
+
+
+/** MIDI sound bank/ program pair in a given channel 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port that this structure applies to */
+    OMX_U32 nChannel;           /**< Valid channel values range from 1 to 16 */
+    OMX_U16 nIDProgram;         /**< Valid program ID range is 1 to 128 */
+    OMX_U16 nIDSoundBank;       /**< Sound bank ID */
+    OMX_U32 nUserSoundBankIndex;/**< User soundbank index, easier to access soundbanks 
+                                     by index if multiple banks are present */
+} OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE;
+
+
+/** MIDI control 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDICONTROLTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_BS32 sPitchTransposition; /**< Pitch transposition in semitones, stored as Q22.10 
+                                       format based on JAVA MMAPI (JSR-135) requirement */
+    OMX_BU32 sPlayBackRate;       /**< Relative playback rate, stored as Q14.17 fixed-point
+                                       number based on JSR-135 requirement */
+    OMX_BU32 sTempo ;             /**< Tempo in beats per minute (BPM), stored as Q22.10 
+                                       fixed-point number based on JSR-135 requirement */
+    OMX_U32 nMaxPolyphony;        /**< Specifies the maximum simultaneous polyphonic 
+                                       voices. A value of zero indicates that the default 
+                                       polyphony of the device is used  */
+    OMX_U32 nNumRepeat;           /**< Number of times to repeat playback */
+    OMX_U32 nStopTime;            /**< Time in milliseconds to indicate when playback 
+                                       will stop automatically.  Set to zero if not used */
+    OMX_U16 nChannelMuteMask;     /**< 16 bit mask for channel mute status */
+    OMX_U16 nChannelSoloMask;     /**< 16 bit mask for channel solo status */
+    OMX_U32 nTrack0031MuteMask;   /**< 32 bit mask for track mute status. Note: This is for tracks 0-31 */
+    OMX_U32 nTrack3263MuteMask;   /**< 32 bit mask for track mute status. Note: This is for tracks 32-63 */
+    OMX_U32 nTrack0031SoloMask;   /**< 32 bit mask for track solo status. Note: This is for tracks 0-31 */
+    OMX_U32 nTrack3263SoloMask;   /**< 32 bit mask for track solo status. Note: This is for tracks 32-63 */
+
+} OMX_AUDIO_CONFIG_MIDICONTROLTYPE;
+
+
+/** MIDI Playback States 
+ * @ingroup midi
+ */
+typedef enum OMX_AUDIO_MIDIPLAYBACKSTATETYPE {
+  OMX_AUDIO_MIDIPlayBackStateUnknown = 0,      /**< Unknown state or state does not map to 
+  													other defined states */
+  OMX_AUDIO_MIDIPlayBackStateClosedEngaged,    /**< No MIDI resource is currently open. 
+                                                    The MIDI engine is currently processing 
+                                                    MIDI events. */
+  OMX_AUDIO_MIDIPlayBackStateParsing,          /**< A MIDI resource is open and is being 
+                                                    primed. The MIDI engine is currently 
+                                                    processing MIDI events. */
+  OMX_AUDIO_MIDIPlayBackStateOpenEngaged,      /**< A MIDI resource is open and primed but 
+                                                    not playing. The MIDI engine is currently
+                                                    processing MIDI events. The transition to
+                                                    this state is only possible from the 
+                                                    OMX_AUDIO_MIDIPlayBackStatePlaying state,
+                                                    when the 'playback head' reaches the end
+                                                    of media data or the playback stops due
+                                                    to stop time set.*/
+  OMX_AUDIO_MIDIPlayBackStatePlaying,          /**< A MIDI resource is open and currently
+                                                    playing. The MIDI engine is currently
+                                                    processing MIDI events.*/
+  OMX_AUDIO_MIDIPlayBackStatePlayingPartially, /**< Best-effort playback due to SP-MIDI/DLS
+                                                    resource constraints */
+  OMX_AUDIO_MIDIPlayBackStatePlayingSilently,  /**< Due to system resource constraints and
+                                                    SP-MIDI content constraints, there is
+                                                    no audible MIDI content during playback
+                                                    currently. The situation may change if
+                                                    resources are freed later.*/
+  OMX_AUDIO_MIDIPlayBackStateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_AUDIO_MIDIPlayBackStateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_AUDIO_MIDIPlayBackStateMax = 0x7FFFFFFF
+} OMX_AUDIO_MIDIPLAYBACKSTATETYPE;
+
+
+/** MIDI status 
+ * @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDISTATUSTYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */
+    OMX_U16 nNumTracks;         /**< Number of MIDI tracks in the file, read only field. 
+                                     NOTE: May not return a meaningful value until the entire 
+                                     file is parsed and buffered.  */
+    OMX_U32 nDuration;          /**< The length of the currently open MIDI resource 
+                                     in milliseconds. NOTE: May not return a meaningful value 
+                                     until the entire file is parsed and buffered.  */  
+    OMX_U32 nPosition;          /**< Current Position of the MIDI resource being played 
+                                     in milliseconds */
+    OMX_BOOL bVibra;            /**< Does Vibra track exist? NOTE: May not return a meaningful 
+                                     value until the entire file is parsed and buffered. */
+    OMX_U32 nNumMetaEvents;     /**< Total number of MIDI Meta Events in the currently 
+                                     open MIDI resource. NOTE: May not return a meaningful value 
+                                     until the entire file is parsed and buffered.  */
+    OMX_U32 nNumActiveVoices;   /**< Number of active voices in the currently playing 
+                                     MIDI resource. NOTE: May not return a meaningful value until 
+                                     the entire file is parsed and buffered. */
+    OMX_AUDIO_MIDIPLAYBACKSTATETYPE eMIDIPlayBackState;  /**< MIDI playback state enumeration, read only field */
+} OMX_AUDIO_CONFIG_MIDISTATUSTYPE;
+
+
+/** MIDI Meta Event structure one per Meta Event.
+ *  MIDI Meta Events are like audio metadata, except that they are interspersed 
+ *  with the MIDI content throughout the file and are not localized in the header. 
+ *  As such, it is necessary to retrieve information about these Meta Events from 
+ *  the engine, as it encounters these Meta Events within the MIDI content. 
+ *  For example, SMF files can have up to 14 types of MIDI Meta Events (copyright, 
+ *  author, default tempo, etc.) scattered throughout the file. 
+ *  @ingroup midi
+ */
+typedef struct OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE{ 
+    OMX_U32 nSize;            /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */ 
+    OMX_U32 nIndex;           /**< Index of Meta Event */ 
+    OMX_U8 nMetaEventType;    /**< Meta Event Type, 7bits (i.e. 0 - 127) */ 
+    OMX_U32 nMetaEventSize;   /**< size of the Meta Event in bytes */ 
+    OMX_U32 nTrack;           /**< track number for the meta event */
+    OMX_U32 nPosition;        /**< Position of the meta-event in milliseconds */
+} OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE; 
+
+
+/** MIDI Meta Event Data structure - one per Meta Event. 
+ * @ingroup midi
+ */ 
+typedef struct OMX_AUDIO_CONFIG_MIDIMETAEVENTDATATYPE{ 
+    OMX_U32 nSize;            /**< size of the structure in bytes */ 
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;       /**< port that this structure applies to */ 
+    OMX_U32 nIndex;           /**< Index of Meta Event */ 
+    OMX_U32 nMetaEventSize;   /**< size of the Meta Event in bytes */ 
+    OMX_U8 nData[1];          /**< array of one or more bytes of meta data 
+                                   as indicated by the nMetaEventSize field */ 
+} OMX_AUDIO_CONFIG__MIDIMETAEVENTDATATYPE; 
+
+
+/** Audio Volume adjustment for a port */
+typedef struct OMX_AUDIO_CONFIG_VOLUMETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port index indicating which port to 
+                                     set.  Select the input port to set 
+                                     just that port's volume.  Select the 
+                                     output port to adjust the master 
+                                     volume. */
+    OMX_BOOL bLinear;           /**< Is the volume to be set in linear (0.100) 
+                                     or logarithmic scale (mB) */
+    OMX_BS32 sVolume;           /**< Volume linear setting in the 0..100 range, OR
+                                     Volume logarithmic setting for this port.  The values
+                                     for volume are in mB (millibels = 1/100 dB) relative
+                                     to a gain of 1 (e.g. the output is the same as the 
+                                     input level).  Values are in mB from nMax 
+                                     (maximum volume) to nMin mB (typically negative).
+                                     Since the volume is "voltage"
+                                     and not a "power", it takes a setting of
+                                     -600 mB to decrease the volume by 1/2.  If
+                                     a component cannot accurately set the 
+                                     volume to the requested value, it must
+                                     set the volume to the closest value BELOW
+                                     the requested value.  When getting the
+                                     volume setting, the current actual volume
+                                     must be returned. */
+} OMX_AUDIO_CONFIG_VOLUMETYPE;
+
+
+/** Audio Volume adjustment for a channel */
+typedef struct OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port index indicating which port to 
+                                     set.  Select the input port to set 
+                                     just that port's volume.  Select the 
+                                     output port to adjust the master 
+                                     volume. */
+    OMX_U32 nChannel;           /**< channel to select from 0 to N-1, 
+                                     using OMX_ALL to apply volume settings
+                                     to all channels */
+    OMX_BOOL bLinear;           /**< Is the volume to be set in linear (0.100) or 
+                                     logarithmic scale (mB) */
+    OMX_BS32 sVolume;           /**< Volume linear setting in the 0..100 range, OR
+                                     Volume logarithmic setting for this port.  
+                                     The values for volume are in mB 
+                                     (millibels = 1/100 dB) relative to a gain
+                                     of 1 (e.g. the output is the same as the 
+                                     input level).  Values are in mB from nMax 
+                                     (maximum volume) to nMin mB (typically negative).  
+                                     Since the volume is "voltage"
+                                     and not a "power", it takes a setting of
+                                     -600 mB to decrease the volume by 1/2.  If
+                                     a component cannot accurately set the 
+                                     volume to the requested value, it must
+                                     set the volume to the closest value BELOW
+                                     the requested value.  When getting the
+                                     volume setting, the current actual volume
+                                     must be returned. */
+    OMX_BOOL bIsMIDI;           /**< TRUE if nChannel refers to a MIDI channel,
+                                     FALSE otherwise */
+} OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE;
+
+
+/** Audio balance setting */
+typedef struct OMX_AUDIO_CONFIG_BALANCETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port index indicating which port to 
+                                     set.  Select the input port to set 
+                                     just that port's balance.  Select the 
+                                     output port to adjust the master 
+                                     balance. */
+    OMX_S32 nBalance;           /**< balance setting for this port 
+                                     (-100 to 100, where -100 indicates
+                                     all left, and no right */
+} OMX_AUDIO_CONFIG_BALANCETYPE;
+
+
+/** Audio Port mute */
+typedef struct OMX_AUDIO_CONFIG_MUTETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< Port index indicating which port to 
+                                     set.  Select the input port to set 
+                                     just that port's mute.  Select the 
+                                     output port to adjust the master 
+                                     mute. */
+    OMX_BOOL bMute;             /**< Mute setting for this port */
+} OMX_AUDIO_CONFIG_MUTETYPE;
+
+
+/** Audio Channel mute */
+typedef struct OMX_AUDIO_CONFIG_CHANNELMUTETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */
+    OMX_U32 nChannel;           /**< channel to select from 0 to N-1, 
+                                     using OMX_ALL to apply mute settings
+                                     to all channels */
+    OMX_BOOL bMute;             /**< Mute setting for this channel */
+    OMX_BOOL bIsMIDI;           /**< TRUE if nChannel refers to a MIDI channel,
+                                     FALSE otherwise */ 
+} OMX_AUDIO_CONFIG_CHANNELMUTETYPE;
+
+
+
+/** Enable / Disable for loudness control, which boosts bass and to a 
+ *  smaller extent high end frequencies to compensate for hearing
+ *  ability at the extreme ends of the audio spectrum
+ */ 
+typedef struct OMX_AUDIO_CONFIG_LOUDNESSTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bLoudness;        /**< Enable/disable for loudness */
+} OMX_AUDIO_CONFIG_LOUDNESSTYPE;
+
+
+/** Enable / Disable for bass, which controls low frequencies
+ */ 
+typedef struct OMX_AUDIO_CONFIG_BASSTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for bass control */
+    OMX_S32 nBass;             /**< bass setting for the port, as a 
+                                    continuous value from -100 to 100  
+                                    (0 means no change in bass level)*/
+} OMX_AUDIO_CONFIG_BASSTYPE;
+
+
+/** Enable / Disable for treble, which controls high frequencies tones
+ */ 
+typedef struct OMX_AUDIO_CONFIG_TREBLETYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for treble control */
+    OMX_S32  nTreble;          /**< treble setting for the port, as a
+                                    continuous value from -100 to 100  
+                                    (0 means no change in treble level) */
+} OMX_AUDIO_CONFIG_TREBLETYPE;
+
+
+/** An equalizer is typically used for two reasons: to compensate for an 
+ *  sub-optimal frequency response of a system to make it sound more natural 
+ *  or to create intentionally some unnatural coloring to the sound to create
+ *  an effect.
+ *  @ingroup effects
+ */
+typedef struct OMX_AUDIO_CONFIG_EQUALIZERTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for equalizer */
+    OMX_BU32 sBandIndex;       /**< Band number to be set.  Upper Limit is 
+                                    N-1, where N is the number of bands, lower limit is 0 */
+    OMX_BU32 sCenterFreq;      /**< Center frequecies in Hz.  This is a
+                                    read only element and is used to determine 
+                                    the lower, center and upper frequency of 
+                                    this band.  */
+    OMX_BS32 sBandLevel;       /**< band level in millibels */
+} OMX_AUDIO_CONFIG_EQUALIZERTYPE;
+
+
+/** Stereo widening mode type 
+ * @ingroup effects
+ */ 
+typedef enum OMX_AUDIO_STEREOWIDENINGTYPE {
+    OMX_AUDIO_StereoWideningHeadphones,    /**< Stereo widening for loudspeakers */
+    OMX_AUDIO_StereoWideningLoudspeakers,  /**< Stereo widening for closely spaced loudspeakers */
+    OMX_AUDIO_StereoWideningKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_AUDIO_StereoWideningVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_AUDIO_StereoWideningMax = 0x7FFFFFFF
+} OMX_AUDIO_STEREOWIDENINGTYPE;
+
+
+/** Control for stereo widening, which is a special 2-channel
+ *  case of the audio virtualizer effect. For example, for 5.1-channel 
+ *  output, it translates to virtual surround sound. 
+ * @ingroup effects
+ */ 
+typedef struct OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for stereo widening control */
+    OMX_AUDIO_STEREOWIDENINGTYPE eWideningType; /**< Stereo widening algorithm type */
+    OMX_U32  nStereoWidening;  /**< stereo widening setting for the port,
+                                    as a continuous value from 0 to 100  */
+} OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE;
+
+
+/** The chorus effect (or ``choralizer'') is any signal processor which makes
+ *  one sound source (such as a voice) sound like many such sources singing 
+ *  (or playing) in unison. Since performance in unison is never exact, chorus 
+ *  effects simulate this by making independently modified copies of the input 
+ *  signal. Modifications may include (1) delay, (2) frequency shift, and 
+ *  (3) amplitude modulation.
+ * @ingroup effects
+ */
+typedef struct OMX_AUDIO_CONFIG_CHORUSTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bEnable;          /**< Enable/disable for chorus */
+    OMX_BU32 sDelay;           /**< average delay in milliseconds */
+    OMX_BU32 sModulationRate;  /**< rate of modulation in millihertz */
+    OMX_U32 nModulationDepth;  /**< depth of modulation as a percentage of 
+                                    delay (i.e. 0 to 100) */
+    OMX_BU32 nFeedback;        /**< Feedback from chorus output to input in percentage */
+} OMX_AUDIO_CONFIG_CHORUSTYPE;
+
+
+/** Reverberation is part of the reflected sound that follows the early 
+ *  reflections. In a typical room, this consists of a dense succession of 
+ *  echoes whose energy decays exponentially. The reverberation effect structure 
+ *  as defined here includes both (early) reflections as well as (late) reverberations. 
+ * @ingroup effects
+ */
+typedef struct OMX_AUDIO_CONFIG_REVERBERATIONTYPE {
+    OMX_U32 nSize;                /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;     /**< OMX specification version information */
+    OMX_U32 nPortIndex;           /**< port that this structure applies to */
+    OMX_BOOL bEnable;             /**< Enable/disable for reverberation control */
+    OMX_BS32 sRoomLevel;          /**< Intensity level for the whole room effect 
+                                       (i.e. both early reflections and late 
+                                       reverberation) in millibels */
+    OMX_BS32 sRoomHighFreqLevel;  /**< Attenuation at high frequencies
+                                       relative to the intensity at low
+                                       frequencies in millibels */
+    OMX_BS32 sReflectionsLevel;   /**< Intensity level of early reflections
+                                       (relative to room value), in millibels */
+    OMX_BU32 sReflectionsDelay;   /**< Delay time of the first reflection relative 
+                                       to the direct path, in milliseconds */
+    OMX_BS32 sReverbLevel;        /**< Intensity level of late reverberation
+                                       relative to room level, in millibels */
+    OMX_BU32 sReverbDelay;        /**< Time delay from the first early reflection 
+                                       to the beginning of the late reverberation 
+                                       section, in milliseconds */
+    OMX_BU32 sDecayTime;          /**< Late reverberation decay time at low
+                                       frequencies, in milliseconds */
+    OMX_BU32 nDecayHighFreqRatio; /**< Ratio of high frequency decay time relative 
+                                       to low frequency decay time in percent  */
+    OMX_U32 nDensity;             /**< Modal density in the late reverberation decay,
+                                       in percent (i.e. 0 - 100) */
+    OMX_U32 nDiffusion;           /**< Echo density in the late reverberation decay,
+                                       in percent (i.e. 0 - 100) */
+    OMX_BU32 sReferenceHighFreq;  /**< Reference high frequency in Hertz. This is 
+                                       the frequency used as the reference for all 
+                                       the high-frequency settings above */
+
+} OMX_AUDIO_CONFIG_REVERBERATIONTYPE;
+
+
+/** Possible settings for the Echo Cancelation structure to use 
+ * @ingroup effects
+ */
+typedef enum OMX_AUDIO_ECHOCANTYPE {
+   OMX_AUDIO_EchoCanOff = 0,    /**< Echo Cancellation is disabled */
+   OMX_AUDIO_EchoCanNormal,     /**< Echo Cancellation normal operation - 
+                                     echo from plastics and face */
+   OMX_AUDIO_EchoCanHFree,      /**< Echo Cancellation optimized for 
+                                     Hands Free operation */
+   OMX_AUDIO_EchoCanCarKit,    /**< Echo Cancellation optimized for 
+                                     Car Kit (longer echo) */
+   OMX_AUDIO_EchoCanKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+   OMX_AUDIO_EchoCanVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+   OMX_AUDIO_EchoCanMax = 0x7FFFFFFF
+} OMX_AUDIO_ECHOCANTYPE;
+
+
+/** Enable / Disable for echo cancelation, which removes undesired echo's
+ *  from the audio
+ * @ingroup effects
+ */ 
+typedef struct OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_AUDIO_ECHOCANTYPE eEchoCancelation; /**< Echo cancelation settings */
+} OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE;
+
+
+/** Enable / Disable for noise reduction, which undesired noise from
+ * the audio
+ * @ingroup effects
+ */ 
+typedef struct OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_U32 nPortIndex;        /**< port that this structure applies to */
+    OMX_BOOL bNoiseReduction;  /**< Enable/disable for noise reduction */
+} OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE;
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
+
diff --git a/domx/omx_core/inc/OMX_Component.h b/domx/omx_core/inc/OMX_Component.h
new file mode 100755
index 0000000..d595640
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Component.h
@@ -0,0 +1,579 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** OMX_Component.h - OpenMax IL version 1.1.2
+ *  The OMX_Component header file contains the definitions used to define
+ *  the public interface of a component.  This header file is intended to
+ *  be used by both the application and the component.
+ */
+
+#ifndef OMX_Component_h
+#define OMX_Component_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+/* Each OMX header must include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+
+#include <OMX_Audio.h>
+#include <OMX_Video.h>
+#include <OMX_Image.h>
+#include <OMX_Other.h>
+
+/** @ingroup comp */
+typedef enum OMX_PORTDOMAINTYPE { 
+    OMX_PortDomainAudio, 
+    OMX_PortDomainVideo, 
+    OMX_PortDomainImage, 
+    OMX_PortDomainOther,
+    OMX_PortDomainKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_PortDomainVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_PortDomainMax = 0x7ffffff
+} OMX_PORTDOMAINTYPE;
+
+/** @ingroup comp */
+typedef struct OMX_PARAM_PORTDEFINITIONTYPE {
+    OMX_U32 nSize;                 /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
+    OMX_U32 nPortIndex;            /**< Port number the structure applies to */
+    OMX_DIRTYPE eDir;              /**< Direction (input or output) of this port */
+    OMX_U32 nBufferCountActual;    /**< The actual number of buffers allocated on this port */
+    OMX_U32 nBufferCountMin;       /**< The minimum number of buffers this port requires */
+    OMX_U32 nBufferSize;           /**< Size, in bytes, for buffers to be used for this channel */
+    OMX_BOOL bEnabled;             /**< Ports default to enabled and are enabled/disabled by
+                                        OMX_CommandPortEnable/OMX_CommandPortDisable.
+                                        When disabled a port is unpopulated. A disabled port
+                                        is not populated with buffers on a transition to IDLE. */
+    OMX_BOOL bPopulated;           /**< Port is populated with all of its buffers as indicated by
+                                        nBufferCountActual. A disabled port is always unpopulated. 
+                                        An enabled port is populated on a transition to OMX_StateIdle
+                                        and unpopulated on a transition to loaded. */
+    OMX_PORTDOMAINTYPE eDomain;    /**< Domain of the port. Determines the contents of metadata below. */
+    union {
+        OMX_AUDIO_PORTDEFINITIONTYPE audio;
+        OMX_VIDEO_PORTDEFINITIONTYPE video;
+        OMX_IMAGE_PORTDEFINITIONTYPE image;
+        OMX_OTHER_PORTDEFINITIONTYPE other;
+    } format;
+    OMX_BOOL bBuffersContiguous;
+    OMX_U32 nBufferAlignment;
+} OMX_PARAM_PORTDEFINITIONTYPE;
+
+/** @ingroup comp */
+typedef struct OMX_PARAM_U32TYPE { 
+    OMX_U32 nSize;                    /**< Size of this structure, in Bytes */ 
+    OMX_VERSIONTYPE nVersion;         /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;               /**< port that this structure applies to */ 
+    OMX_U32 nU32;                     /**< U32 value */
+} OMX_PARAM_U32TYPE;
+
+/** @ingroup rpm */
+typedef enum OMX_SUSPENSIONPOLICYTYPE {
+    OMX_SuspensionDisabled, /**< No suspension; v1.0 behavior */
+    OMX_SuspensionEnabled,  /**< Suspension allowed */   
+    OMX_SuspensionPolicyKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_SuspensionPolicyStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_SuspensionPolicyMax = 0x7fffffff
+} OMX_SUSPENSIONPOLICYTYPE;
+
+/** @ingroup rpm */
+typedef struct OMX_PARAM_SUSPENSIONPOLICYTYPE {
+    OMX_U32 nSize;                  
+    OMX_VERSIONTYPE nVersion;        
+    OMX_SUSPENSIONPOLICYTYPE ePolicy;
+} OMX_PARAM_SUSPENSIONPOLICYTYPE;
+
+/** @ingroup rpm */
+typedef enum OMX_SUSPENSIONTYPE {
+    OMX_NotSuspended, /**< component is not suspended */
+    OMX_Suspended,    /**< component is suspended */
+    OMX_SuspensionKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_SuspensionVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_SuspendMax = 0x7FFFFFFF
+} OMX_SUSPENSIONTYPE;
+
+/** @ingroup rpm */
+typedef struct OMX_PARAM_SUSPENSIONTYPE {
+    OMX_U32 nSize;                  
+    OMX_VERSIONTYPE nVersion;       
+    OMX_SUSPENSIONTYPE eType;             
+} OMX_PARAM_SUSPENSIONTYPE ;
+
+typedef struct OMX_CONFIG_BOOLEANTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_BOOL bEnabled;    
+} OMX_CONFIG_BOOLEANTYPE;
+
+/* Parameter specifying the content uri to use. */
+/** @ingroup cp */
+typedef struct OMX_PARAM_CONTENTURITYPE
+{
+    OMX_U32 nSize;                      /**< size of the structure in bytes, including
+                                             actual URI name */
+    OMX_VERSIONTYPE nVersion;           /**< OMX specification version information */
+    OMX_U8 contentURI[1];               /**< The URI name */
+} OMX_PARAM_CONTENTURITYPE;
+
+/* Parameter specifying the pipe to use. */
+/** @ingroup cp */
+typedef struct OMX_PARAM_CONTENTPIPETYPE
+{
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_HANDLETYPE hPipe;       /**< The pipe handle*/
+} OMX_PARAM_CONTENTPIPETYPE;
+
+/** @ingroup rpm */
+typedef struct OMX_RESOURCECONCEALMENTTYPE {
+    OMX_U32 nSize;             /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+    OMX_BOOL bResourceConcealmentForbidden; /**< disallow the use of resource concealment 
+                                            methods (like degrading algorithm quality to 
+                                            lower resource consumption or functional bypass) 
+                                            on a component as a resolution to resource conflicts. */
+} OMX_RESOURCECONCEALMENTTYPE;
+
+
+/** @ingroup metadata */
+typedef enum OMX_METADATACHARSETTYPE {
+    OMX_MetadataCharsetUnknown = 0,
+    OMX_MetadataCharsetASCII,
+    OMX_MetadataCharsetBinary,
+    OMX_MetadataCharsetCodePage1252,
+    OMX_MetadataCharsetUTF8,
+    OMX_MetadataCharsetJavaConformantUTF8,
+    OMX_MetadataCharsetUTF7,
+    OMX_MetadataCharsetImapUTF7,
+    OMX_MetadataCharsetUTF16LE, 
+    OMX_MetadataCharsetUTF16BE,
+    OMX_MetadataCharsetGB12345,
+    OMX_MetadataCharsetHZGB2312,
+    OMX_MetadataCharsetGB2312,
+    OMX_MetadataCharsetGB18030,
+    OMX_MetadataCharsetGBK,
+    OMX_MetadataCharsetBig5,
+    OMX_MetadataCharsetISO88591,
+    OMX_MetadataCharsetISO88592,
+    OMX_MetadataCharsetISO88593,
+    OMX_MetadataCharsetISO88594,
+    OMX_MetadataCharsetISO88595,
+    OMX_MetadataCharsetISO88596,
+    OMX_MetadataCharsetISO88597,
+    OMX_MetadataCharsetISO88598,
+    OMX_MetadataCharsetISO88599,
+    OMX_MetadataCharsetISO885910,
+    OMX_MetadataCharsetISO885913,
+    OMX_MetadataCharsetISO885914,
+    OMX_MetadataCharsetISO885915,
+    OMX_MetadataCharsetShiftJIS,
+    OMX_MetadataCharsetISO2022JP,
+    OMX_MetadataCharsetISO2022JP1,
+    OMX_MetadataCharsetISOEUCJP,
+    OMX_MetadataCharsetSMS7Bit,
+    OMX_MetadataCharsetKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MetadataCharsetVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_MetadataCharsetTypeMax= 0x7FFFFFFF
+} OMX_METADATACHARSETTYPE;
+
+/** @ingroup metadata */
+typedef enum OMX_METADATASCOPETYPE
+{
+    OMX_MetadataScopeAllLevels,
+    OMX_MetadataScopeTopLevel,
+    OMX_MetadataScopePortLevel,
+    OMX_MetadataScopeNodeLevel,
+    OMX_MetadataScopeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MetadataScopeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_MetadataScopeTypeMax = 0x7fffffff
+} OMX_METADATASCOPETYPE;
+
+/** @ingroup metadata */
+typedef enum OMX_METADATASEARCHMODETYPE
+{
+    OMX_MetadataSearchValueSizeByIndex,
+    OMX_MetadataSearchItemByIndex,
+    OMX_MetadataSearchNextItemByKey,
+    OMX_MetadataSearchKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MetadataSearchVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_MetadataSearchTypeMax = 0x7fffffff
+} OMX_METADATASEARCHMODETYPE;
+/** @ingroup metadata */
+typedef struct OMX_CONFIG_METADATAITEMCOUNTTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_METADATASCOPETYPE eScopeMode;
+    OMX_U32 nScopeSpecifier;
+    OMX_U32 nMetadataItemCount;
+} OMX_CONFIG_METADATAITEMCOUNTTYPE;
+
+/** @ingroup metadata */
+typedef struct OMX_CONFIG_METADATAITEMTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_METADATASCOPETYPE eScopeMode;
+    OMX_U32 nScopeSpecifier;
+    OMX_U32 nMetadataItemIndex;  
+    OMX_METADATASEARCHMODETYPE eSearchMode;
+    OMX_METADATACHARSETTYPE eKeyCharset;
+    OMX_U8 nKeySizeUsed;
+    OMX_U8 nKey[128];
+    OMX_METADATACHARSETTYPE eValueCharset;
+    OMX_STRING sLanguageCountry;
+    OMX_U32 nValueMaxSize;
+    OMX_U32 nValueSizeUsed;
+    OMX_U8 nValue[1];
+} OMX_CONFIG_METADATAITEMTYPE;
+
+/* @ingroup metadata */
+typedef struct OMX_CONFIG_CONTAINERNODECOUNTTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_BOOL bAllKeys;
+    OMX_U32 nParentNodeID;
+    OMX_U32 nNumNodes;
+} OMX_CONFIG_CONTAINERNODECOUNTTYPE;
+
+/** @ingroup metadata */
+typedef struct OMX_CONFIG_CONTAINERNODEIDTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_BOOL bAllKeys;
+    OMX_U32 nParentNodeID;
+    OMX_U32 nNodeIndex; 
+    OMX_U32 nNodeID; 
+    OMX_STRING cNodeName;
+    OMX_BOOL bIsLeafType;
+} OMX_CONFIG_CONTAINERNODEIDTYPE;
+
+/** @ingroup metadata */
+typedef struct OMX_PARAM_METADATAFILTERTYPE 
+{ 
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion; 
+    OMX_BOOL bAllKeys;	/* if true then this structure refers to all keys and 
+                         * the three key fields below are ignored */
+    OMX_METADATACHARSETTYPE eKeyCharset;
+    OMX_U32 nKeySizeUsed; 
+    OMX_U8   nKey [128]; 
+    OMX_U32 nLanguageCountrySizeUsed;
+    OMX_U8 nLanguageCountry[128];
+    OMX_BOOL bEnabled;	/* if true then key is part of filter (e.g. 
+                         * retained for query later). If false then
+                         * key is not part of filter */
+} OMX_PARAM_METADATAFILTERTYPE; 
+
+/** The OMX_HANDLETYPE structure defines the component handle.  The component 
+ *  handle is used to access all of the component's public methods and also
+ *  contains pointers to the component's private data area.  The component
+ *  handle is initialized by the OMX core (with help from the component)
+ *  during the process of loading the component.  After the component is
+ *  successfully loaded, the application can safely access any of the
+ *  component's public functions (although some may return an error because
+ *  the state is inappropriate for the access).
+ * 
+ *  @ingroup comp
+ */
+typedef struct OMX_COMPONENTTYPE
+{
+    /** The size of this structure, in bytes.  It is the responsibility
+        of the allocator of this structure to fill in this value.  Since
+        this structure is allocated by the GetHandle function, this
+        function will fill in this value. */
+    OMX_U32 nSize;
+
+    /** nVersion is the version of the OMX specification that the structure 
+        is built against.  It is the responsibility of the creator of this 
+        structure to initialize this value and every user of this structure 
+        should verify that it knows how to use the exact version of 
+        this structure found herein. */
+    OMX_VERSIONTYPE nVersion;
+
+    /** pComponentPrivate is a pointer to the component private data area.  
+        This member is allocated and initialized by the component when the 
+        component is first loaded.  The application should not access this 
+        data area. */
+    OMX_PTR pComponentPrivate;
+
+    /** pApplicationPrivate is a pointer that is a parameter to the 
+        OMX_GetHandle method, and contains an application private value 
+        provided by the IL client.  This application private data is 
+        returned to the IL Client by OMX in all callbacks */
+    OMX_PTR pApplicationPrivate;
+
+    /** refer to OMX_GetComponentVersion in OMX_core.h or the OMX IL 
+        specification for details on the GetComponentVersion method.
+     */
+    OMX_ERRORTYPE (*GetComponentVersion)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_OUT OMX_STRING pComponentName,
+            OMX_OUT OMX_VERSIONTYPE* pComponentVersion,
+            OMX_OUT OMX_VERSIONTYPE* pSpecVersion,
+            OMX_OUT OMX_UUIDTYPE* pComponentUUID);
+
+    /** refer to OMX_SendCommand in OMX_core.h or the OMX IL 
+        specification for details on the SendCommand method.
+     */
+    OMX_ERRORTYPE (*SendCommand)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_COMMANDTYPE Cmd,
+            OMX_IN  OMX_U32 nParam1,
+            OMX_IN  OMX_PTR pCmdData);
+
+    /** refer to OMX_GetParameter in OMX_core.h or the OMX IL 
+        specification for details on the GetParameter method.
+     */
+    OMX_ERRORTYPE (*GetParameter)(
+            OMX_IN  OMX_HANDLETYPE hComponent, 
+            OMX_IN  OMX_INDEXTYPE nParamIndex,  
+            OMX_INOUT OMX_PTR pComponentParameterStructure);
+
+
+    /** refer to OMX_SetParameter in OMX_core.h or the OMX IL 
+        specification for details on the SetParameter method.
+     */
+    OMX_ERRORTYPE (*SetParameter)(
+            OMX_IN  OMX_HANDLETYPE hComponent, 
+            OMX_IN  OMX_INDEXTYPE nIndex,
+            OMX_IN  OMX_PTR pComponentParameterStructure);
+
+
+    /** refer to OMX_GetConfig in OMX_core.h or the OMX IL 
+        specification for details on the GetConfig method.
+     */
+    OMX_ERRORTYPE (*GetConfig)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_INDEXTYPE nIndex, 
+            OMX_INOUT OMX_PTR pComponentConfigStructure);
+
+
+    /** refer to OMX_SetConfig in OMX_core.h or the OMX IL 
+        specification for details on the SetConfig method.
+     */
+    OMX_ERRORTYPE (*SetConfig)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_INDEXTYPE nIndex, 
+            OMX_IN  OMX_PTR pComponentConfigStructure);
+
+
+    /** refer to OMX_GetExtensionIndex in OMX_core.h or the OMX IL 
+        specification for details on the GetExtensionIndex method.
+     */
+    OMX_ERRORTYPE (*GetExtensionIndex)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_STRING cParameterName,
+            OMX_OUT OMX_INDEXTYPE* pIndexType);
+
+
+    /** refer to OMX_GetState in OMX_core.h or the OMX IL 
+        specification for details on the GetState method.
+     */
+    OMX_ERRORTYPE (*GetState)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_OUT OMX_STATETYPE* pState);
+
+    
+    /** The ComponentTunnelRequest method will interact with another OMX
+        component to determine if tunneling is possible and to setup the
+        tunneling.  The return codes for this method can be used to 
+        determine if tunneling is not possible, or if tunneling is not
+        supported.  
+        
+        Base profile components (i.e. non-interop) do not support this
+        method and should return OMX_ErrorNotImplemented 
+
+        The interop profile component MUST support tunneling to another 
+        interop profile component with a compatible port parameters.  
+        A component may also support proprietary communication.
+        
+        If proprietary communication is supported the negotiation of 
+        proprietary communication is done outside of OMX in a vendor 
+        specific way. It is only required that the proper result be 
+        returned and the details of how the setup is done is left 
+        to the component implementation.  
+    
+        When this method is invoked when nPort in an output port, the
+        component will:
+        1.  Populate the pTunnelSetup structure with the output port's 
+            requirements and constraints for the tunnel.
+
+        When this method is invoked when nPort in an input port, the
+        component will:
+        1.  Query the necessary parameters from the output port to 
+            determine if the ports are compatible for tunneling
+        2.  If the ports are compatible, the component should store
+            the tunnel step provided by the output port
+        3.  Determine which port (either input or output) is the buffer
+            supplier, and call OMX_SetParameter on the output port to
+            indicate this selection.
+        
+        The component will return from this call within 5 msec.
+    
+        @param [in] hComp
+            Handle of the component to be accessed.  This is the component
+            handle returned by the call to the OMX_GetHandle method.
+        @param [in] nPort
+            nPort is used to select the port on the component to be used
+            for tunneling.
+        @param [in] hTunneledComp
+            Handle of the component to tunnel with.  This is the component 
+            handle returned by the call to the OMX_GetHandle method.  When
+            this parameter is 0x0 the component should setup the port for
+            communication with the application / IL Client.
+        @param [in] nPortOutput
+            nPortOutput is used indicate the port the component should
+            tunnel with.
+        @param [in] pTunnelSetup
+            Pointer to the tunnel setup structure.  When nPort is an output port
+            the component should populate the fields of this structure.  When
+            When nPort is an input port the component should review the setup
+            provided by the component with the output port.
+        @return OMX_ERRORTYPE
+            If the command successfully executes, the return code will be
+            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+        @ingroup tun
+    */
+
+    OMX_ERRORTYPE (*ComponentTunnelRequest)(
+        OMX_IN  OMX_HANDLETYPE hComp,
+        OMX_IN  OMX_U32 nPort,
+        OMX_IN  OMX_HANDLETYPE hTunneledComp,
+        OMX_IN  OMX_U32 nTunneledPort,
+        OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup); 
+
+    /** refer to OMX_UseBuffer in OMX_core.h or the OMX IL 
+        specification for details on the UseBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*UseBuffer)(
+            OMX_IN OMX_HANDLETYPE hComponent,
+            OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
+            OMX_IN OMX_U32 nPortIndex,
+            OMX_IN OMX_PTR pAppPrivate,
+            OMX_IN OMX_U32 nSizeBytes,
+            OMX_IN OMX_U8* pBuffer);
+
+    /** refer to OMX_AllocateBuffer in OMX_core.h or the OMX IL 
+        specification for details on the AllocateBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*AllocateBuffer)(
+            OMX_IN OMX_HANDLETYPE hComponent,
+            OMX_INOUT OMX_BUFFERHEADERTYPE** ppBuffer,
+            OMX_IN OMX_U32 nPortIndex,
+            OMX_IN OMX_PTR pAppPrivate,
+            OMX_IN OMX_U32 nSizeBytes);
+
+    /** refer to OMX_FreeBuffer in OMX_core.h or the OMX IL 
+        specification for details on the FreeBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*FreeBuffer)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_U32 nPortIndex,
+            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
+
+    /** refer to OMX_EmptyThisBuffer in OMX_core.h or the OMX IL 
+        specification for details on the EmptyThisBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*EmptyThisBuffer)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
+
+    /** refer to OMX_FillThisBuffer in OMX_core.h or the OMX IL 
+        specification for details on the FillThisBuffer method.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*FillThisBuffer)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
+
+    /** The SetCallbacks method is used by the core to specify the callback
+        structure from the application to the component.  This is a blocking
+        call.  The component will return from this call within 5 msec.
+        @param [in] hComponent
+            Handle of the component to be accessed.  This is the component
+            handle returned by the call to the GetHandle function.
+        @param [in] pCallbacks
+            pointer to an OMX_CALLBACKTYPE structure used to provide the 
+            callback information to the component
+        @param [in] pAppData
+            pointer to an application defined value.  It is anticipated that 
+            the application will pass a pointer to a data structure or a "this
+            pointer" in this area to allow the callback (in the application)
+            to determine the context of the call
+        @return OMX_ERRORTYPE
+            If the command successfully executes, the return code will be
+            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+     */
+    OMX_ERRORTYPE (*SetCallbacks)(
+            OMX_IN  OMX_HANDLETYPE hComponent,
+            OMX_IN  OMX_CALLBACKTYPE* pCallbacks, 
+            OMX_IN  OMX_PTR pAppData);
+
+    /** ComponentDeInit method is used to deinitialize the component
+        providing a means to free any resources allocated at component
+        initialization.  NOTE:  After this call the component handle is
+        not valid for further use.
+        @param [in] hComponent
+            Handle of the component to be accessed.  This is the component
+            handle returned by the call to the GetHandle function.
+        @return OMX_ERRORTYPE
+            If the command successfully executes, the return code will be
+            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+     */
+    OMX_ERRORTYPE (*ComponentDeInit)(
+            OMX_IN  OMX_HANDLETYPE hComponent);
+
+    /** @ingroup buf */
+    OMX_ERRORTYPE (*UseEGLImage)(
+            OMX_IN OMX_HANDLETYPE hComponent,
+            OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
+            OMX_IN OMX_U32 nPortIndex,
+            OMX_IN OMX_PTR pAppPrivate,
+            OMX_IN void* eglImage);
+
+    OMX_ERRORTYPE (*ComponentRoleEnum)(
+        OMX_IN OMX_HANDLETYPE hComponent,
+		OMX_OUT OMX_U8 *cRole,
+		OMX_IN OMX_U32 nIndex);
+
+} OMX_COMPONENTTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/domx/omx_core/inc/OMX_ComponentExt.h b/domx/omx_core/inc/OMX_ComponentExt.h
new file mode 100755
index 0000000..e32dcbe
--- /dev/null
+++ b/domx/omx_core/inc/OMX_ComponentExt.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/** OMX_ComponentExt.h - OpenMax IL version 1.1.2
+ * The OMX_ComponentExt header file contains extensions to the definitions used
+ * by both the application and the component to access common items.
+ */
+
+#ifndef OMX_ComponentExt_h
+#define OMX_ComponentExt_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Each OMX header must include all required header files to allow the
+ * header to compile without errors.  The includes below are required
+ * for this header file to compile successfully
+ */
+#include <OMX_Types.h>
+
+
+/** Set/query the commit mode */
+typedef struct OMX_CONFIG_COMMITMODETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_BOOL bDeferred;
+} OMX_CONFIG_COMMITMODETYPE;
+
+/** Explicit commit */
+typedef struct OMX_CONFIG_COMMITTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+} OMX_CONFIG_COMMITTYPE;
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* OMX_ComponentExt_h */
diff --git a/domx/omx_core/inc/OMX_ComponentRegistry.h b/domx/omx_core/inc/OMX_ComponentRegistry.h
new file mode 100755
index 0000000..7bedcfc
--- /dev/null
+++ b/domx/omx_core/inc/OMX_ComponentRegistry.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <dirent.h>
+
+#define MAX_ROLES 20
+#define MAX_TABLE_SIZE 50
+
+typedef struct _ComponentTable {
+    OMX_STRING name;
+    OMX_U16 nRoles;
+    OMX_STRING pRoleArray[MAX_ROLES];
+}ComponentTable;
+
+
+OMX_API OMX_ERRORTYPE OMX_GetRolesOfComponent (
+    OMX_IN      OMX_STRING compName,
+    OMX_INOUT   OMX_U32 *pNumRoles,
+    OMX_OUT     OMX_U8 **roles);
+
+OMX_ERRORTYPE OMX_PrintComponentTable();
+OMX_ERRORTYPE OMX_BuildComponentTable();
+OMX_ERRORTYPE ComponentTable_EventHandler(
+        OMX_IN OMX_HANDLETYPE hComponent,
+        OMX_IN OMX_PTR pAppData,
+        OMX_IN OMX_EVENTTYPE eEvent,
+        OMX_IN OMX_U32 nData1,
+        OMX_IN OMX_U32 nData2,
+        OMX_IN OMX_PTR pEventData);
+
+OMX_ERRORTYPE ComponentTable_EmptyBufferDone(
+        OMX_OUT OMX_HANDLETYPE hComponent,
+        OMX_OUT OMX_PTR pAppData,
+        OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer);
+
+OMX_ERRORTYPE ComponentTable_FillBufferDone(
+        OMX_OUT OMX_HANDLETYPE hComponent,
+        OMX_OUT OMX_PTR pAppData,
+        OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer);
diff --git a/domx/omx_core/inc/OMX_ContentPipe.h b/domx/omx_core/inc/OMX_ContentPipe.h
new file mode 100755
index 0000000..5f6310c
--- /dev/null
+++ b/domx/omx_core/inc/OMX_ContentPipe.h
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** OMX_ContentPipe.h - OpenMax IL version 1.1.2
+ *  The OMX_ContentPipe header file contains the definitions used to define
+ *  the public interface for content piples.  This header file is intended to
+ *  be used by the component.
+ */
+
+#ifndef OMX_CONTENTPIPE_H
+#define OMX_CONTENTPIPE_H
+
+#ifndef KD_EACCES
+/* OpenKODE error codes. CPResult values may be zero (indicating success
+   or one of the following values) */
+#define KD_EACCES (1)
+#define KD_EADDRINUSE (2)
+#define KD_EAGAIN (5)
+#define KD_EBADF (7)
+#define KD_EBUSY (8)
+#define KD_ECONNREFUSED (9)
+#define KD_ECONNRESET (10)
+#define KD_EDEADLK (11)
+#define KD_EDESTADDRREQ (12)
+#define KD_ERANGE (35)
+#define KD_EEXIST (13)
+#define KD_EFBIG (14)
+#define KD_EHOSTUNREACH (15)
+#define KD_EINVAL (17)
+#define KD_EIO (18)
+#define KD_EISCONN (20)
+#define KD_EISDIR (21)
+#define KD_EMFILE (22)
+#define KD_ENAMETOOLONG (23)
+#define KD_ENOENT (24)
+#define KD_ENOMEM (25)
+#define KD_ENOSPC (26)
+#define KD_ENOSYS (27)
+#define KD_ENOTCONN (28)
+#define KD_EPERM (33)
+#define KD_ETIMEDOUT (36)
+#define KD_EILSEQ (19)
+#endif
+
+/** Map types from OMX standard types only here so interface is as generic as possible. */
+typedef OMX_U32    CPresult;
+typedef char *     CPstring;  
+typedef void *     CPhandle;
+typedef OMX_U32    CPuint;
+typedef OMX_S32    CPint;  
+typedef char       CPbyte;  
+typedef OMX_BOOL   CPbool;
+
+/** enumeration of origin types used in the CP_PIPETYPE's Seek function 
+ * @ingroup cp
+ */
+typedef enum CP_ORIGINTYPE {
+    CP_OriginBegin,      
+    CP_OriginCur,      
+    CP_OriginEnd,      
+    CP_OriginKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    CP_OriginVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    CP_OriginMax = 0X7FFFFFFF
+} CP_ORIGINTYPE;
+
+/** enumeration of contact access types used in the CP_PIPETYPE's Open function 
+ * @ingroup cp
+ */
+typedef enum CP_ACCESSTYPE {
+    CP_AccessRead,      
+    CP_AccessWrite,  
+    CP_AccessReadWrite ,  
+    CP_AccessKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    CP_AccessVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    CP_AccessMax = 0X7FFFFFFF
+} CP_ACCESSTYPE;
+
+/** enumeration of results returned by the CP_PIPETYPE's CheckAvailableBytes function 
+ * @ingroup cp
+ */
+typedef enum CP_CHECKBYTESRESULTTYPE
+{
+    CP_CheckBytesOk,                    /**< There are at least the request number 
+                                              of bytes available */
+    CP_CheckBytesNotReady,              /**< The pipe is still retrieving bytes 
+                                              and presently lacks sufficient bytes. 
+                                              Client will be called when they are 
+                                              sufficient bytes are available. */
+    CP_CheckBytesInsufficientBytes  ,     /**< The pipe has retrieved all bytes 
+                                              but those available are less than those 
+                                              requested */
+    CP_CheckBytesAtEndOfStream,         /**< The pipe has reached the end of stream
+                                              and no more bytes are available. */
+    CP_CheckBytesOutOfBuffers,          /**< All read/write buffers are currently in use. */
+    CP_CheckBytesKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    CP_CheckBytesVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    CP_CheckBytesMax = 0X7FFFFFFF
+} CP_CHECKBYTESRESULTTYPE;
+
+/** enumeration of content pipe events sent to the client callback. 
+ * @ingroup cp
+ */
+typedef enum CP_EVENTTYPE{
+    CP_BytesAvailable,      	    /** bytes requested in a CheckAvailableBytes call are now available*/
+    CP_Overflow,  		           /** enumeration of content pipe events sent to the client callback*/
+    CP_PipeDisconnected  ,  		    /** enumeration of content pipe events sent to the client callback*/
+    CP_EventKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    CP_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    CP_EventMax = 0X7FFFFFFF
+} CP_EVENTTYPE;
+
+/** content pipe definition 
+ * @ingroup cp
+ */
+typedef struct CP_PIPETYPE
+{
+    /** Open a content stream for reading or writing. */ 
+    CPresult (*Open)( CPhandle* hContent, CPstring szURI, CP_ACCESSTYPE eAccess );
+
+    /** Close a content stream. */ 
+    CPresult (*Close)( CPhandle hContent );
+
+    /** Create a content source and open it for writing. */ 
+    CPresult (*Create)( CPhandle *hContent, CPstring szURI );
+
+    /** Check the that specified number of bytes are available for reading or writing (depending on access type).*/
+    CPresult (*CheckAvailableBytes)( CPhandle hContent, CPuint nBytesRequested, CP_CHECKBYTESRESULTTYPE *eResult );
+
+    /** Seek to certain position in the content relative to the specified origin. */
+    CPresult (*SetPosition)( CPhandle  hContent, CPint nOffset, CP_ORIGINTYPE eOrigin);
+
+    /** Retrieve the current position relative to the start of the content. */
+    CPresult (*GetPosition)( CPhandle hContent, CPuint *pPosition);
+
+    /** Retrieve data of the specified size from the content stream (advance content pointer by size of data).
+       Note: pipe client provides pointer. This function is appropriate for small high frequency reads. */
+    CPresult (*Read)( CPhandle hContent, CPbyte *pData, CPuint nSize); 
+
+    /** Retrieve a buffer allocated by the pipe that contains the requested number of bytes. 
+       Buffer contains the next block of bytes, as specified by nSize, of the content. nSize also
+       returns the size of the block actually read. Content pointer advances the by the returned size. 
+       Note: pipe provides pointer. This function is appropriate for large reads. The client must call 
+       ReleaseReadBuffer when done with buffer. 
+
+       In some cases the requested block may not reside in contiguous memory within the
+       pipe implementation. For instance if the pipe leverages a circular buffer then the requested 
+       block may straddle the boundary of the circular buffer. By default a pipe implementation 
+       performs a copy in this case to provide the block to the pipe client in one contiguous buffer.
+       If, however, the client sets bForbidCopy, then the pipe returns only those bytes preceding the memory 
+       boundary. Here the client may retrieve the data in segments over successive calls. */
+    CPresult (*ReadBuffer)( CPhandle hContent, CPbyte **ppBuffer, CPuint *nSize, CPbool bForbidCopy);
+
+    /** Release a buffer obtained by ReadBuffer back to the pipe. */
+    CPresult (*ReleaseReadBuffer)(CPhandle hContent, CPbyte *pBuffer);
+
+    /** Write data of the specified size to the content (advance content pointer by size of data).
+       Note: pipe client provides pointer. This function is appropriate for small high frequency writes. */
+    CPresult (*Write)( CPhandle hContent, CPbyte *data, CPuint nSize); 
+
+    /** Retrieve a buffer allocated by the pipe used to write data to the content. 
+       Client will fill buffer with output data. Note: pipe provides pointer. This function is appropriate
+       for large writes. The client must call WriteBuffer when done it has filled the buffer with data.*/
+    CPresult (*GetWriteBuffer)( CPhandle hContent, CPbyte **ppBuffer, CPuint nSize);
+
+    /** Deliver a buffer obtained via GetWriteBuffer to the pipe. Pipe will write the 
+       the contents of the buffer to content and advance content pointer by the size of the buffer */
+    CPresult (*WriteBuffer)( CPhandle hContent, CPbyte *pBuffer, CPuint nFilledSize);
+
+    /** Register a per-handle client callback with the content pipe. */
+    CPresult (*RegisterCallback)( CPhandle hContent, CPresult (*ClientCallback)(CP_EVENTTYPE eEvent, CPuint iParam));
+
+} CP_PIPETYPE;
+
+#endif
+
diff --git a/domx/omx_core/inc/OMX_Core.h b/domx/omx_core/inc/OMX_Core.h
new file mode 100755
index 0000000..a076f2f
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Core.h
@@ -0,0 +1,1431 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** OMX_Core.h - OpenMax IL version 1.1.2
+ *  The OMX_Core header file contains the definitions used by both the
+ *  application and the component to access common items.
+ */
+
+#ifndef OMX_Core_h
+#define OMX_Core_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header shall include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+
+#include <OMX_Index.h>
+
+
+/** The OMX_COMMANDTYPE enumeration is used to specify the action in the
+ *  OMX_SendCommand macro.  
+ *  @ingroup core
+ */
+typedef enum OMX_COMMANDTYPE
+{
+    OMX_CommandStateSet,    /**< Change the component state */
+    OMX_CommandFlush,       /**< Flush the data queue(s) of a component */
+    OMX_CommandPortDisable, /**< Disable a port on a component. */
+    OMX_CommandPortEnable,  /**< Enable a port on a component. */
+    OMX_CommandMarkBuffer,  /**< Mark a component/buffer for observation */
+    OMX_CommandKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_CommandVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_CommandMax = 0X7FFFFFFF
+} OMX_COMMANDTYPE;
+
+
+
+/** The OMX_STATETYPE enumeration is used to indicate or change the component
+ *  state.  This enumeration reflects the current state of the component when
+ *  used with the OMX_GetState macro or becomes the parameter in a state change
+ *  command when used with the OMX_SendCommand macro.
+ *
+ *  The component will be in the Loaded state after the component is initially
+ *  loaded into memory.  In the Loaded state, the component is not allowed to
+ *  allocate or hold resources other than to build it's internal parameter
+ *  and configuration tables.  The application will send one or more
+ *  SetParameters/GetParameters and SetConfig/GetConfig commands to the
+ *  component and the component will record each of these parameter and
+ *  configuration changes for use later.  When the application sends the
+ *  Idle command, the component will acquire the resources needed for the
+ *  specified configuration and will transition to the idle state if the
+ *  allocation is successful.  If the component cannot successfully
+ *  transition to the idle state for any reason, the state of the component
+ *  shall be fully rolled back to the Loaded state (e.g. all allocated 
+ *  resources shall be released).  When the component receives the command
+ *  to go to the Executing state, it shall begin processing buffers by
+ *  sending all input buffers it holds to the application.  While
+ *  the component is in the Idle state, the application may also send the
+ *  Pause command.  If the component receives the pause command while in the
+ *  Idle state, the component shall send all input buffers it holds to the 
+ *  application, but shall not begin processing buffers.  This will allow the
+ *  application to prefill buffers.
+ * 
+ *  @ingroup comp
+ */
+
+typedef enum OMX_STATETYPE
+{
+    OMX_StateInvalid,      /**< component has detected that it's internal data 
+                                structures are corrupted to the point that
+                                it cannot determine it's state properly */
+    OMX_StateLoaded,      /**< component has been loaded but has not completed
+                                initialization.  The OMX_SetParameter macro
+                                and the OMX_GetParameter macro are the only 
+                                valid macros allowed to be sent to the 
+                                component in this state. */
+    OMX_StateIdle,        /**< component initialization has been completed
+                                successfully and the component is ready to
+                                to start. */
+    OMX_StateExecuting,   /**< component has accepted the start command and
+                                is processing data (if data is available) */
+    OMX_StatePause,       /**< component has received pause command */
+    OMX_StateWaitForResources, /**< component is waiting for resources, either after 
+                                preemption or before it gets the resources requested.
+                                See specification for complete details. */
+    OMX_StateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_StateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_StateMax = 0X7FFFFFFF
+} OMX_STATETYPE;
+
+/** The OMX_ERRORTYPE enumeration defines the standard OMX Errors.  These 
+ *  errors should cover most of the common failure cases.  However, 
+ *  vendors are free to add additional error messages of their own as 
+ *  long as they follow these rules:
+ *  1.  Vendor error messages shall be in the range of 0x90000000 to
+ *      0x9000FFFF.
+ *  2.  Vendor error messages shall be defined in a header file provided
+ *      with the component.  No error messages are allowed that are
+ *      not defined.
+ */
+typedef enum OMX_ERRORTYPE
+{
+  OMX_ErrorNone = 0,
+
+  /** There were insufficient resources to perform the requested operation */
+  OMX_ErrorInsufficientResources = (OMX_S32) 0x80001000,
+
+  /** There was an error, but the cause of the error could not be determined */
+  OMX_ErrorUndefined = (OMX_S32) 0x80001001,
+
+  /** The component name string was not valid */
+  OMX_ErrorInvalidComponentName = (OMX_S32) 0x80001002,
+
+  /** No component with the specified name string was found */
+  OMX_ErrorComponentNotFound = (OMX_S32) 0x80001003,
+
+  /** The component specified did not have a "OMX_ComponentInit" or
+      "OMX_ComponentDeInit entry point */
+  OMX_ErrorInvalidComponent = (OMX_S32) 0x80001004,
+
+  /** One or more parameters were not valid */
+  OMX_ErrorBadParameter = (OMX_S32) 0x80001005,
+
+  /** The requested function is not implemented */
+  OMX_ErrorNotImplemented = (OMX_S32) 0x80001006,
+
+  /** The buffer was emptied before the next buffer was ready */
+  OMX_ErrorUnderflow = (OMX_S32) 0x80001007,
+
+  /** The buffer was not available when it was needed */
+  OMX_ErrorOverflow = (OMX_S32) 0x80001008,
+
+  /** The hardware failed to respond as expected */
+  OMX_ErrorHardware = (OMX_S32) 0x80001009,
+
+  /** The component is in the state OMX_StateInvalid */
+  OMX_ErrorInvalidState = (OMX_S32) 0x8000100A,
+
+  /** Stream is found to be corrupt */
+  OMX_ErrorStreamCorrupt = (OMX_S32) 0x8000100B,
+
+  /** Ports being connected are not compatible */
+  OMX_ErrorPortsNotCompatible = (OMX_S32) 0x8000100C,
+
+  /** Resources allocated to an idle component have been
+      lost resulting in the component returning to the loaded state */
+  OMX_ErrorResourcesLost = (OMX_S32) 0x8000100D,
+
+  /** No more indicies can be enumerated */
+  OMX_ErrorNoMore = (OMX_S32) 0x8000100E,
+
+  /** The component detected a version mismatch */
+  OMX_ErrorVersionMismatch = (OMX_S32) 0x8000100F,
+
+  /** The component is not ready to return data at this time */
+  OMX_ErrorNotReady = (OMX_S32) 0x80001010,
+
+  /** There was a timeout that occurred */
+  OMX_ErrorTimeout = (OMX_S32) 0x80001011,
+
+  /** This error occurs when trying to transition into the state you are already in */
+  OMX_ErrorSameState = (OMX_S32) 0x80001012,
+
+  /** Resources allocated to an executing or paused component have been 
+      preempted, causing the component to return to the idle state */
+  OMX_ErrorResourcesPreempted = (OMX_S32) 0x80001013, 
+
+  /** A non-supplier port sends this error to the IL client (via the EventHandler callback) 
+      during the allocation of buffers (on a transition from the LOADED to the IDLE state or
+      on a port restart) when it deems that it has waited an unusually long time for the supplier 
+      to send it an allocated buffer via a UseBuffer call. */
+  OMX_ErrorPortUnresponsiveDuringAllocation = (OMX_S32) 0x80001014,
+
+  /** A non-supplier port sends this error to the IL client (via the EventHandler callback) 
+      during the deallocation of buffers (on a transition from the IDLE to LOADED state or 
+      on a port stop) when it deems that it has waited an unusually long time for the supplier 
+      to request the deallocation of a buffer header via a FreeBuffer call. */
+  OMX_ErrorPortUnresponsiveDuringDeallocation = (OMX_S32) 0x80001015,
+
+  /** A supplier port sends this error to the IL client (via the EventHandler callback) 
+      during the stopping of a port (either on a transition from the IDLE to LOADED 
+      state or a port stop) when it deems that it has waited an unusually long time for 
+      the non-supplier to return a buffer via an EmptyThisBuffer or FillThisBuffer call. */
+  OMX_ErrorPortUnresponsiveDuringStop = (OMX_S32) 0x80001016,
+
+  /** Attempting a state transtion that is not allowed */
+  OMX_ErrorIncorrectStateTransition = (OMX_S32) 0x80001017,
+
+  /* Attempting a command that is not allowed during the present state. */
+  OMX_ErrorIncorrectStateOperation = (OMX_S32) 0x80001018, 
+
+  /** The values encapsulated in the parameter or config structure are not supported. */
+  OMX_ErrorUnsupportedSetting = (OMX_S32) 0x80001019,
+
+  /** The parameter or config indicated by the given index is not supported. */
+  OMX_ErrorUnsupportedIndex = (OMX_S32) 0x8000101A,
+
+  /** The port index supplied is incorrect. */
+  OMX_ErrorBadPortIndex = (OMX_S32) 0x8000101B,
+
+  /** The port has lost one or more of its buffers and it thus unpopulated. */
+  OMX_ErrorPortUnpopulated = (OMX_S32) 0x8000101C,
+
+  /** Component suspended due to temporary loss of resources */
+  OMX_ErrorComponentSuspended = (OMX_S32) 0x8000101D,
+
+  /** Component suspended due to an inability to acquire dynamic resources */
+  OMX_ErrorDynamicResourcesUnavailable = (OMX_S32) 0x8000101E,
+
+  /** When the macroblock error reporting is enabled the component returns new error 
+  for every frame that has errors */
+  OMX_ErrorMbErrorsInFrame = (OMX_S32) 0x8000101F,
+
+  /** A component reports this error when it cannot parse or determine the format of an input stream. */
+  OMX_ErrorFormatNotDetected = (OMX_S32) 0x80001020, 
+
+  /** The content open operation failed. */
+  OMX_ErrorContentPipeOpenFailed = (OMX_S32) 0x80001021,
+
+  /** The content creation operation failed. */
+  OMX_ErrorContentPipeCreationFailed = (OMX_S32) 0x80001022,
+
+  /** Separate table information is being used */
+  OMX_ErrorSeperateTablesUsed = (OMX_S32) 0x80001023,
+
+  /** Tunneling is unsupported by the component*/
+  OMX_ErrorTunnelingUnsupported = (OMX_S32) 0x80001024,
+
+  OMX_ErrorKhronosExtensions = (OMX_S32)0x8F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+  OMX_ErrorVendorStartUnused = (OMX_S32)0x90000000, /**< Reserved region for introducing Vendor Extensions */
+  OMX_ErrorMax = 0x7FFFFFFF
+} OMX_ERRORTYPE;
+
+/** @ingroup core */
+typedef OMX_ERRORTYPE (* OMX_COMPONENTINITTYPE)(OMX_IN  OMX_HANDLETYPE hComponent);
+
+/** @ingroup core */
+typedef struct OMX_COMPONENTREGISTERTYPE
+{
+  const char          * pName;       /* Component name, 128 byte limit (including '\0') applies */
+  OMX_COMPONENTINITTYPE pInitialize; /* Component instance initialization function */
+} OMX_COMPONENTREGISTERTYPE;
+
+/** @ingroup core */
+extern OMX_COMPONENTREGISTERTYPE OMX_ComponentRegistered[];
+
+/** @ingroup rpm */
+typedef struct OMX_PRIORITYMGMTTYPE {
+ OMX_U32 nSize;             /**< size of the structure in bytes */
+ OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
+ OMX_U32 nGroupPriority;            /**< Priority of the component group */
+ OMX_U32 nGroupID;                  /**< ID of the component group */
+} OMX_PRIORITYMGMTTYPE;
+
+/* Component name and Role names are limited to 128 characters including the terminating '\0'. */
+#define OMX_MAX_STRINGNAME_SIZE 128
+
+/** @ingroup comp */
+typedef struct OMX_PARAM_COMPONENTROLETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U8 cRole[OMX_MAX_STRINGNAME_SIZE];  /**< name of standard component which defines component role */
+} OMX_PARAM_COMPONENTROLETYPE;
+
+/** End of Stream Buffer Flag: 
+  *
+  * A component sets EOS when it has no more data to emit on a particular 
+  * output port. Thus an output port shall set EOS on the last buffer it 
+  * emits. A component's determination of when an output port should 
+  * cease sending data is implemenation specific.
+  * @ingroup buf
+  */
+
+#define OMX_BUFFERFLAG_EOS 0x00000001 
+
+/** Start Time Buffer Flag: 
+ *
+ * The source of a stream (e.g. a demux component) sets the STARTTIME
+ * flag on the buffer that contains the starting timestamp for the
+ * stream. The starting timestamp corresponds to the first data that
+ * should be displayed at startup or after a seek.
+ * The first timestamp of the stream is not necessarily the start time.
+ * For instance, in the case of a seek to a particular video frame, 
+ * the target frame may be an interframe. Thus the first buffer of 
+ * the stream will be the intra-frame preceding the target frame and
+ * the starttime will occur with the target frame (with any other
+ * required frames required to reconstruct the target intervening).
+ *
+ * The STARTTIME flag is directly associated with the buffer's 
+ * timestamp ' thus its association to buffer data and its 
+ * propagation is identical to the timestamp's.
+ *
+ * When a Sync Component client receives a buffer with the 
+ * STARTTIME flag it shall perform a SetConfig on its sync port 
+ * using OMX_ConfigTimeClientStartTime and passing the buffer's
+ * timestamp.
+ * 
+ * @ingroup buf
+ */
+
+#define OMX_BUFFERFLAG_STARTTIME 0x00000002
+
+ 
+
+/** Decode Only Buffer Flag: 
+ *
+ * The source of a stream (e.g. a demux component) sets the DECODEONLY
+ * flag on any buffer that should shall be decoded but should not be
+ * displayed. This flag is used, for instance, when a source seeks to 
+ * a target interframe that requires the decode of frames preceding the 
+ * target to facilitate the target's reconstruction. In this case the 
+ * source would emit the frames preceding the target downstream 
+ * but mark them as decode only.
+ *
+ * The DECODEONLY is associated with buffer data and propagated in a 
+ * manner identical to the buffer timestamp.
+ *
+ * A component that renders data should ignore all buffers with 
+ * the DECODEONLY flag set.
+ * 
+ * @ingroup buf
+ */
+
+#define OMX_BUFFERFLAG_DECODEONLY 0x00000004
+
+
+/* Data Corrupt Flag: This flag is set when the IL client believes the data in the associated buffer is corrupt 
+ * @ingroup buf
+ */
+
+#define OMX_BUFFERFLAG_DATACORRUPT 0x00000008
+
+/* End of Frame: The buffer contains exactly one end of frame and no data
+ *  occurs after the end of frame. This flag is an optional hint. The absence
+ *  of this flag does not imply the absence of an end of frame within the buffer. 
+ * @ingroup buf
+*/
+#define OMX_BUFFERFLAG_ENDOFFRAME 0x00000010
+
+/* Sync Frame Flag: This flag is set when the buffer content contains a coded sync frame ' 
+ *  a frame that has no dependency on any other frame information 
+ *  @ingroup buf
+ */
+#define OMX_BUFFERFLAG_SYNCFRAME 0x00000020
+
+/* Extra data present flag: there is extra data appended to the data stream
+ * residing in the buffer 
+ * @ingroup buf  
+ */
+#define OMX_BUFFERFLAG_EXTRADATA 0x00000040
+
+/** Codec Config Buffer Flag: 
+* OMX_BUFFERFLAG_CODECCONFIG is an optional flag that is set by an
+* output port when all bytes in the buffer form part or all of a set of
+* codec specific configuration data.  Examples include SPS/PPS nal units
+* for OMX_VIDEO_CodingAVC or AudioSpecificConfig data for
+* OMX_AUDIO_CodingAAC.  Any component that for a given stream sets 
+* OMX_BUFFERFLAG_CODECCONFIG shall not mix codec configuration bytes
+* with frame data in the same buffer, and shall send all buffers
+* containing codec configuration bytes before any buffers containing
+* frame data that those configurations bytes describe.
+* If the stream format for a particular codec has a frame specific
+* header at the start of each frame, for example OMX_AUDIO_CodingMP3 or
+* OMX_AUDIO_CodingAAC in ADTS mode, then these shall be presented as
+* normal without setting OMX_BUFFERFLAG_CODECCONFIG.
+ * @ingroup buf
+ */
+#define OMX_BUFFERFLAG_CODECCONFIG 0x00000080
+
+
+
+/** @ingroup buf */
+typedef struct OMX_BUFFERHEADERTYPE
+{
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U8* pBuffer;            /**< Pointer to actual block of memory 
+                                     that is acting as the buffer */
+    OMX_U32 nAllocLen;          /**< size of the buffer allocated, in bytes */
+    OMX_U32 nFilledLen;         /**< number of bytes currently in the 
+                                     buffer */
+    OMX_U32 nOffset;            /**< start offset of valid data in bytes from
+                                     the start of the buffer */
+    OMX_PTR pAppPrivate;        /**< pointer to any data the application
+                                     wants to associate with this buffer */
+    OMX_PTR pPlatformPrivate;   /**< pointer to any data the platform
+                                     wants to associate with this buffer */ 
+    OMX_PTR pInputPortPrivate;  /**< pointer to any data the input port
+                                     wants to associate with this buffer */
+    OMX_PTR pOutputPortPrivate; /**< pointer to any data the output port
+                                     wants to associate with this buffer */
+    OMX_HANDLETYPE hMarkTargetComponent; /**< The component that will generate a 
+                                              mark event upon processing this buffer. */
+    OMX_PTR pMarkData;          /**< Application specific data associated with 
+                                     the mark sent on a mark event to disambiguate 
+                                     this mark from others. */
+    OMX_U32 nTickCount;         /**< Optional entry that the component and
+                                     application can update with a tick count
+                                     when they access the component.  This
+                                     value should be in microseconds.  Since
+                                     this is a value relative to an arbitrary
+                                     starting point, this value cannot be used 
+                                     to determine absolute time.  This is an
+                                     optional entry and not all components
+                                     will update it.*/
+ OMX_TICKS nTimeStamp;          /**< Timestamp corresponding to the sample 
+                                     starting at the first logical sample 
+                                     boundary in the buffer. Timestamps of 
+                                     successive samples within the buffer may
+                                     be inferred by adding the duration of the 
+                                     of the preceding buffer to the timestamp
+                                     of the preceding buffer.*/
+  OMX_U32     nFlags;           /**< buffer specific flags */
+  OMX_U32 nOutputPortIndex;     /**< The index of the output port (if any) using 
+                                     this buffer */
+  OMX_U32 nInputPortIndex;      /**< The index of the input port (if any) using
+                                     this buffer */
+} OMX_BUFFERHEADERTYPE;
+
+/** The OMX_EXTRADATATYPE enumeration is used to define the 
+ * possible extra data payload types.
+ * NB: this enum is binary backwards compatible with the previous
+ * OMX_EXTRADATA_QUANT define.  This should be replaced with
+ * OMX_ExtraDataQuantization.
+ */
+typedef enum OMX_EXTRADATATYPE
+{
+   OMX_ExtraDataNone = 0,                       /**< Indicates that no more extra data sections follow */        
+   OMX_ExtraDataQuantization,                   /**< The data payload contains quantization data */
+   OMX_ExtraDataKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+   OMX_ExtraDataVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+   OMX_ExtraDataMax = 0x7FFFFFFF
+} OMX_EXTRADATATYPE;
+
+
+typedef struct OMX_OTHER_EXTRADATATYPE  {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;               
+    OMX_U32 nPortIndex;
+    OMX_EXTRADATATYPE eType;       /* Extra Data type */
+    OMX_U32 nDataSize;   /* Size of the supporting data to follow */
+    OMX_U8  data[1];     /* Supporting data hint  */
+} OMX_OTHER_EXTRADATATYPE;
+
+/** @ingroup comp */
+typedef struct OMX_PORT_PARAM_TYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPorts;             /**< The number of ports for this component */
+    OMX_U32 nStartPortNumber;   /** first port number for this type of port */
+} OMX_PORT_PARAM_TYPE; 
+
+/** @ingroup comp */
+typedef enum OMX_EVENTTYPE
+{
+    OMX_EventCmdComplete,         /**< component has sucessfully completed a command */
+    OMX_EventError,               /**< component has detected an error condition */
+    OMX_EventMark,                /**< component has detected a buffer mark */
+    OMX_EventPortSettingsChanged, /**< component is reported a port settings change */
+    OMX_EventBufferFlag,          /**< component has detected an EOS */ 
+    OMX_EventResourcesAcquired,   /**< component has been granted resources and is
+                                       automatically starting the state change from
+                                       OMX_StateWaitForResources to OMX_StateIdle. */
+   OMX_EventComponentResumed,     /**< Component resumed due to reacquisition of resources */
+   OMX_EventDynamicResourcesAvailable, /**< Component has acquired previously unavailable dynamic resources */
+   OMX_EventPortFormatDetected,      /**< Component has detected a supported format. */
+   OMX_EventKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+   OMX_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+   OMX_EventMax = 0x7FFFFFFF
+} OMX_EVENTTYPE;
+
+typedef struct OMX_CALLBACKTYPE
+{
+    /** The EventHandler method is used to notify the application when an
+        event of interest occurs.  Events are defined in the OMX_EVENTTYPE
+        enumeration.  Please see that enumeration for details of what will
+        be returned for each type of event. Callbacks should not return
+        an error to the component, so if an error occurs, the application 
+        shall handle it internally.  This is a blocking call.
+
+        The application should return from this call within 5 msec to avoid
+        blocking the component for an excessively long period of time.
+
+        @param hComponent
+            handle of the component to access.  This is the component
+            handle returned by the call to the GetHandle function.
+        @param pAppData
+            pointer to an application defined value that was provided in the 
+            pAppData parameter to the OMX_GetHandle method for the component.
+            This application defined value is provided so that the application 
+            can have a component specific context when receiving the callback.
+        @param eEvent
+            Event that the component wants to notify the application about.
+        @param nData1
+            nData will be the OMX_ERRORTYPE for an error event and will be 
+            an OMX_COMMANDTYPE for a command complete event and OMX_INDEXTYPE for a OMX_PortSettingsChanged event.
+         @param nData2
+            nData2 will hold further information related to the event. Can be OMX_STATETYPE for
+            a OMX_CommandStateSet command or port index for a OMX_PortSettingsChanged event.
+            Default value is 0 if not used. )
+        @param pEventData
+            Pointer to additional event-specific data (see spec for meaning).
+      */
+
+   OMX_ERRORTYPE (*EventHandler)(
+        OMX_IN OMX_HANDLETYPE hComponent,
+        OMX_IN OMX_PTR pAppData,
+        OMX_IN OMX_EVENTTYPE eEvent,
+        OMX_IN OMX_U32 nData1,
+        OMX_IN OMX_U32 nData2,
+        OMX_IN OMX_PTR pEventData);
+
+    /** The EmptyBufferDone method is used to return emptied buffers from an
+        input port back to the application for reuse.  This is a blocking call 
+        so the application should not attempt to refill the buffers during this
+        call, but should queue them and refill them in another thread.  There
+        is no error return, so the application shall handle any errors generated
+        internally.  
+        
+        The application should return from this call within 5 msec.
+        
+        @param hComponent
+            handle of the component to access.  This is the component
+            handle returned by the call to the GetHandle function.
+        @param pAppData
+            pointer to an application defined value that was provided in the 
+            pAppData parameter to the OMX_GetHandle method for the component.
+            This application defined value is provided so that the application 
+            can have a component specific context when receiving the callback.
+        @param pBuffer
+            pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+            or AllocateBuffer indicating the buffer that was emptied.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*EmptyBufferDone)(
+        OMX_IN OMX_HANDLETYPE hComponent,
+        OMX_IN OMX_PTR pAppData,
+        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
+
+    /** The FillBufferDone method is used to return filled buffers from an
+        output port back to the application for emptying and then reuse.  
+        This is a blocking call so the application should not attempt to 
+        empty the buffers during this call, but should queue the buffers 
+        and empty them in another thread.  There is no error return, so 
+        the application shall handle any errors generated internally.  The 
+        application shall also update the buffer header to indicate the
+        number of bytes placed into the buffer.  
+
+        The application should return from this call within 5 msec.
+        
+        @param hComponent
+            handle of the component to access.  This is the component
+            handle returned by the call to the GetHandle function.
+        @param pAppData
+            pointer to an application defined value that was provided in the 
+            pAppData parameter to the OMX_GetHandle method for the component.
+            This application defined value is provided so that the application 
+            can have a component specific context when receiving the callback.
+        @param pBuffer
+            pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+            or AllocateBuffer indicating the buffer that was filled.
+        @ingroup buf
+     */
+    OMX_ERRORTYPE (*FillBufferDone)(
+        OMX_OUT OMX_HANDLETYPE hComponent,
+        OMX_OUT OMX_PTR pAppData,
+        OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer);
+
+} OMX_CALLBACKTYPE;
+
+/** The OMX_BUFFERSUPPLIERTYPE enumeration is used to dictate port supplier
+    preference when tunneling between two ports.
+    @ingroup tun buf
+*/
+typedef enum OMX_BUFFERSUPPLIERTYPE
+{
+    OMX_BufferSupplyUnspecified = 0x0, /**< port supplying the buffers is unspecified,
+                                              or don't care */
+    OMX_BufferSupplyInput,             /**< input port supplies the buffers */
+    OMX_BufferSupplyOutput,            /**< output port supplies the buffers */
+    OMX_BufferSupplyKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_BufferSupplyVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_BufferSupplyMax = 0x7FFFFFFF
+} OMX_BUFFERSUPPLIERTYPE;
+
+
+/** buffer supplier parameter 
+ * @ingroup tun
+ */
+typedef struct OMX_PARAM_BUFFERSUPPLIERTYPE {
+    OMX_U32 nSize; /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex; /**< port that this structure applies to */
+    OMX_BUFFERSUPPLIERTYPE eBufferSupplier; /**< buffer supplier */
+} OMX_PARAM_BUFFERSUPPLIERTYPE;
+
+
+/**< indicates that buffers received by an input port of a tunnel 
+     may not modify the data in the buffers 
+     @ingroup tun
+ */
+#define OMX_PORTTUNNELFLAG_READONLY 0x00000001 
+
+
+/** The OMX_TUNNELSETUPTYPE structure is used to pass data from an output
+    port to an input port as part the two ComponentTunnelRequest calls
+    resulting from a OMX_SetupTunnel call from the IL Client. 
+    @ingroup tun
+ */   
+typedef struct OMX_TUNNELSETUPTYPE
+{
+    OMX_U32 nTunnelFlags;             /**< bit flags for tunneling */
+    OMX_BUFFERSUPPLIERTYPE eSupplier; /**< supplier preference */
+} OMX_TUNNELSETUPTYPE; 
+
+/* OMX Component headers is included to enable the core to use
+   macros for functions into the component for OMX release 1.0.  
+   Developers should not access any structures or data from within
+   the component header directly */
+/* TO BE REMOVED - #include <OMX_Component.h> */
+
+/** GetComponentVersion will return information about the component.  
+    This is a blocking call.  This macro will go directly from the
+    application to the component (via a core macro).  The
+    component will return from this call within 5 msec.
+    @param [in] hComponent
+        handle of component to execute the command
+    @param [out] pComponentName
+        pointer to an empty string of length 128 bytes.  The component 
+        will write its name into this string.  The name will be 
+        terminated by a single zero byte.  The name of a component will 
+        be 127 bytes or less to leave room for the trailing zero byte.  
+        An example of a valid component name is "OMX.ABC.ChannelMixer\0".
+    @param [out] pComponentVersion
+        pointer to an OMX Version structure that the component will fill 
+        in.  The component will fill in a value that indicates the 
+        component version.  NOTE: the component version is NOT the same 
+        as the OMX Specification version (found in all structures).  The 
+        component version is defined by the vendor of the component and 
+        its value is entirely up to the component vendor.
+    @param [out] pSpecVersion
+        pointer to an OMX Version structure that the component will fill 
+        in.  The SpecVersion is the version of the specification that the 
+        component was built against.  Please note that this value may or 
+        may not match the structure's version.  For example, if the 
+        component was built against the 2.0 specification, but the 
+        application (which creates the structure is built against the 
+        1.0 specification the versions would be different.
+    @param [out] pComponentUUID
+        pointer to the UUID of the component which will be filled in by 
+        the component.  The UUID is a unique identifier that is set at 
+        RUN time for the component and is unique to each instantion of 
+        the component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_GetComponentVersion(                            \
+        hComponent,                                         \
+        pComponentName,                                     \
+        pComponentVersion,                                  \
+        pSpecVersion,                                       \
+        pComponentUUID)                                     \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetComponentVersion(  \
+        hComponent,                                         \
+        pComponentName,                                     \
+        pComponentVersion,                                  \
+        pSpecVersion,                                       \
+        pComponentUUID)                 /* Macro End */
+
+
+/** Send a command to the component.  This call is a non-blocking call.
+    The component should check the parameters and then queue the command
+    to the component thread to be executed.  The component thread shall 
+    send the EventHandler() callback at the conclusion of the command. 
+    This macro will go directly from the application to the component (via
+    a core macro).  The component will return from this call within 5 msec.
+    
+    When the command is "OMX_CommandStateSet" the component will queue a
+    state transition to the new state idenfied in nParam.
+    
+    When the command is "OMX_CommandFlush", to flush a port's buffer queues,
+    the command will force the component to return all buffers NOT CURRENTLY 
+    BEING PROCESSED to the application, in the order in which the buffers 
+    were received.
+    
+    When the command is "OMX_CommandPortDisable" or 
+    "OMX_CommandPortEnable", the component's port (given by the value of
+    nParam) will be stopped or restarted. 
+    
+    When the command "OMX_CommandMarkBuffer" is used to mark a buffer, the
+    pCmdData will point to a OMX_MARKTYPE structure containing the component
+    handle of the component to examine the buffer chain for the mark.  nParam1
+    contains the index of the port on which the buffer mark is applied.
+
+    Specification text for more details. 
+    
+    @param [in] hComponent
+        handle of component to execute the command
+    @param [in] Cmd
+        Command for the component to execute
+    @param [in] nParam
+        Parameter for the command to be executed.  When Cmd has the value 
+        OMX_CommandStateSet, value is a member of OMX_STATETYPE.  When Cmd has 
+        the value OMX_CommandFlush, value of nParam indicates which port(s) 
+        to flush. -1 is used to flush all ports a single port index will 
+        only flush that port.  When Cmd has the value "OMX_CommandPortDisable"
+        or "OMX_CommandPortEnable", the component's port is given by 
+        the value of nParam.  When Cmd has the value "OMX_CommandMarkBuffer"
+        the components pot is given by the value of nParam.
+    @param [in] pCmdData
+        Parameter pointing to the OMX_MARKTYPE structure when Cmd has the value
+        "OMX_CommandMarkBuffer".     
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_SendCommand(                                    \
+         hComponent,                                        \
+         Cmd,                                               \
+         nParam,                                            \
+         pCmdData)                                          \
+     ((OMX_COMPONENTTYPE*)hComponent)->SendCommand(         \
+         hComponent,                                        \
+         Cmd,                                               \
+         nParam,                                            \
+         pCmdData)                          /* Macro End */
+
+
+/** The OMX_GetParameter macro will get one of the current parameter 
+    settings from the component.  This macro cannot only be invoked when 
+    the component is in the OMX_StateInvalid state.  The nParamIndex
+    parameter is used to indicate which structure is being requested from
+    the component.  The application shall allocate the correct structure 
+    and shall fill in the structure size and version information before 
+    invoking this macro.  When the parameter applies to a port, the
+    caller shall fill in the appropriate nPortIndex value indicating the
+    port on which the parameter applies. If the component has not had 
+    any settings changed, then the component should return a set of 
+    valid DEFAULT  parameters for the component.  This is a blocking 
+    call.  
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nParamIndex
+        Index of the structure to be filled.  This value is from the
+        OMX_INDEXTYPE enumeration.
+    @param [in,out] pComponentParameterStructure
+        Pointer to application allocated structure to be filled by the 
+        component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_GetParameter(                                   \
+        hComponent,                                         \
+        nParamIndex,                                        \
+        pComponentParameterStructure)                        \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetParameter(         \
+        hComponent,                                         \
+        nParamIndex,                                        \
+        pComponentParameterStructure)    /* Macro End */
+
+
+/** The OMX_SetParameter macro will send an initialization parameter
+    structure to a component.  Each structure shall be sent one at a time,
+    in a separate invocation of the macro.  This macro can only be
+    invoked when the component is in the OMX_StateLoaded state, or the
+    port is disabled (when the parameter applies to a port). The 
+    nParamIndex parameter is used to indicate which structure is being
+    passed to the component.  The application shall allocate the 
+    correct structure and shall fill in the structure size and version 
+    information (as well as the actual data) before invoking this macro.
+    The application is free to dispose of this structure after the call
+    as the component is required to copy any data it shall retain.  This 
+    is a blocking call.  
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nIndex
+        Index of the structure to be sent.  This value is from the
+        OMX_INDEXTYPE enumeration.
+    @param [in] pComponentParameterStructure
+        pointer to application allocated structure to be used for
+        initialization by the component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_SetParameter(                                   \
+        hComponent,                                         \
+        nParamIndex,                                        \
+        pComponentParameterStructure)                        \
+    ((OMX_COMPONENTTYPE*)hComponent)->SetParameter(         \
+        hComponent,                                         \
+        nParamIndex,                                        \
+        pComponentParameterStructure)    /* Macro End */
+
+
+/** The OMX_GetConfig macro will get one of the configuration structures 
+    from a component.  This macro can be invoked anytime after the 
+    component has been loaded.  The nParamIndex call parameter is used to 
+    indicate which structure is being requested from the component.  The 
+    application shall allocate the correct structure and shall fill in the 
+    structure size and version information before invoking this macro.  
+    If the component has not had this configuration parameter sent before, 
+    then the component should return a set of valid DEFAULT values for the 
+    component.  This is a blocking call.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nIndex
+        Index of the structure to be filled.  This value is from the
+        OMX_INDEXTYPE enumeration.
+    @param [in,out] pComponentConfigStructure
+        pointer to application allocated structure to be filled by the 
+        component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+*/        
+#define OMX_GetConfig(                                      \
+        hComponent,                                         \
+        nConfigIndex,                                       \
+        pComponentConfigStructure)                           \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetConfig(            \
+        hComponent,                                         \
+        nConfigIndex,                                       \
+        pComponentConfigStructure)       /* Macro End */
+
+
+/** The OMX_SetConfig macro will send one of the configuration 
+    structures to a component.  Each structure shall be sent one at a time,
+    each in a separate invocation of the macro.  This macro can be invoked 
+    anytime after the component has been loaded.  The application shall 
+    allocate the correct structure and shall fill in the structure size 
+    and version information (as well as the actual data) before invoking 
+    this macro.  The application is free to dispose of this structure after 
+    the call as the component is required to copy any data it shall retain.  
+    This is a blocking call.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nConfigIndex
+        Index of the structure to be sent.  This value is from the
+        OMX_INDEXTYPE enumeration above.
+    @param [in] pComponentConfigStructure
+        pointer to application allocated structure to be used for
+        initialization by the component.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_SetConfig(                                      \
+        hComponent,                                         \
+        nConfigIndex,                                       \
+        pComponentConfigStructure)                           \
+    ((OMX_COMPONENTTYPE*)hComponent)->SetConfig(            \
+        hComponent,                                         \
+        nConfigIndex,                                       \
+        pComponentConfigStructure)       /* Macro End */
+
+
+/** The OMX_GetExtensionIndex macro will invoke a component to translate 
+    a vendor specific configuration or parameter string into an OMX 
+    structure index.  There is no requirement for the vendor to support 
+    this command for the indexes already found in the OMX_INDEXTYPE 
+    enumeration (this is done to save space in small components).  The 
+    component shall support all vendor supplied extension indexes not found
+    in the master OMX_INDEXTYPE enumeration.  This is a blocking call.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the GetHandle function.
+    @param [in] cParameterName
+        OMX_STRING that shall be less than 128 characters long including
+        the trailing null byte.  This is the string that will get 
+        translated by the component into a configuration index.
+    @param [out] pIndexType
+        a pointer to a OMX_INDEXTYPE to receive the index value.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_GetExtensionIndex(                              \
+        hComponent,                                         \
+        cParameterName,                                     \
+        pIndexType)                                         \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetExtensionIndex(    \
+        hComponent,                                         \
+        cParameterName,                                     \
+        pIndexType)                     /* Macro End */
+
+
+/** The OMX_GetState macro will invoke the component to get the current 
+    state of the component and place the state value into the location
+    pointed to by pState.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [out] pState
+        pointer to the location to receive the state.  The value returned
+        is one of the OMX_STATETYPE members 
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp
+ */
+#define OMX_GetState(                                       \
+        hComponent,                                         \
+        pState)                                             \
+    ((OMX_COMPONENTTYPE*)hComponent)->GetState(             \
+        hComponent,                                         \
+        pState)                         /* Macro End */
+
+
+/** The OMX_UseBuffer macro will request that the component use
+    a buffer (and allocate its own buffer header) already allocated 
+    by another component, or by the IL Client. This is a blocking 
+    call.
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [out] ppBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure used to receive the 
+        pointer to the buffer header
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+
+#define OMX_UseBuffer(                                      \
+           hComponent,                                      \
+           ppBufferHdr,                                     \
+           nPortIndex,                                      \
+           pAppPrivate,                                     \
+           nSizeBytes,                                      \
+           pBuffer)                                         \
+    ((OMX_COMPONENTTYPE*)hComponent)->UseBuffer(            \
+           hComponent,                                      \
+           ppBufferHdr,                                     \
+           nPortIndex,                                      \
+           pAppPrivate,                                     \
+           nSizeBytes,                                      \
+           pBuffer)
+
+
+/** The OMX_AllocateBuffer macro will request that the component allocate 
+    a new buffer and buffer header.  The component will allocate the 
+    buffer and the buffer header and return a pointer to the buffer 
+    header.  This is a blocking call.
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [out] ppBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure used to receive 
+        the pointer to the buffer header
+    @param [in] nPortIndex
+        nPortIndex is used to select the port on the component the buffer will
+        be used with.  The port can be found by using the nPortIndex
+        value as an index into the Port Definition array of the component.
+    @param [in] pAppPrivate
+        pAppPrivate is used to initialize the pAppPrivate member of the 
+        buffer header structure.
+    @param [in] nSizeBytes
+        size of the buffer to allocate.  Used when bAllocateNew is true.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */    
+#define OMX_AllocateBuffer(                                 \
+        hComponent,                                         \
+        ppBuffer,                                           \
+        nPortIndex,                                         \
+        pAppPrivate,                                        \
+        nSizeBytes)                                         \
+    ((OMX_COMPONENTTYPE*)hComponent)->AllocateBuffer(       \
+        hComponent,                                         \
+        ppBuffer,                                           \
+        nPortIndex,                                         \
+        pAppPrivate,                                        \
+        nSizeBytes)                     /* Macro End */
+
+
+/** The OMX_FreeBuffer macro will release a buffer header from the component
+    which was allocated using either OMX_AllocateBuffer or OMX_UseBuffer. If  
+    the component allocated the buffer (see the OMX_UseBuffer macro) then 
+    the component shall free the buffer and buffer header. This is a 
+    blocking call. 
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] nPortIndex
+        nPortIndex is used to select the port on the component the buffer will
+        be used with.
+    @param [in] pBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+        or AllocateBuffer.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+#define OMX_FreeBuffer(                                     \
+        hComponent,                                         \
+        nPortIndex,                                         \
+        pBuffer)                                            \
+    ((OMX_COMPONENTTYPE*)hComponent)->FreeBuffer(           \
+        hComponent,                                         \
+        nPortIndex,                                         \
+        pBuffer)                        /* Macro End */
+
+
+/** The OMX_EmptyThisBuffer macro will send a buffer full of data to an 
+    input port of a component.  The buffer will be emptied by the component
+    and returned to the application via the EmptyBufferDone call back.
+    This is a non-blocking call in that the component will record the buffer
+    and return immediately and then empty the buffer, later, at the proper 
+    time.  As expected, this macro may be invoked only while the component 
+    is in the OMX_StateExecuting.  If nPortIndex does not specify an input
+    port, the component shall return an error.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] pBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+        or AllocateBuffer.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+#define OMX_EmptyThisBuffer(                                \
+        hComponent,                                         \
+        pBuffer)                                            \
+    ((OMX_COMPONENTTYPE*)hComponent)->EmptyThisBuffer(      \
+        hComponent,                                         \
+        pBuffer)                        /* Macro End */
+
+
+/** The OMX_FillThisBuffer macro will send an empty buffer to an 
+    output port of a component.  The buffer will be filled by the component
+    and returned to the application via the FillBufferDone call back.
+    This is a non-blocking call in that the component will record the buffer
+    and return immediately and then fill the buffer, later, at the proper 
+    time.  As expected, this macro may be invoked only while the component 
+    is in the OMX_ExecutingState.  If nPortIndex does not specify an output
+    port, the component shall return an error.  
+    
+    The component should return from this call within 5 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [in] pBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
+        or AllocateBuffer.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+#define OMX_FillThisBuffer(                                 \
+        hComponent,                                         \
+        pBuffer)                                            \
+    ((OMX_COMPONENTTYPE*)hComponent)->FillThisBuffer(       \
+        hComponent,                                         \
+        pBuffer)                        /* Macro End */
+
+
+
+/** The OMX_UseEGLImage macro will request that the component use
+    a EGLImage provided by EGL (and allocate its own buffer header)
+    This is a blocking call.
+    
+    The component should return from this call within 20 msec.
+    
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the OMX_GetHandle function.
+    @param [out] ppBuffer
+        pointer to an OMX_BUFFERHEADERTYPE structure used to receive the 
+        pointer to the buffer header.  Note that the memory location used
+        for this buffer is NOT visible to the IL Client.
+    @param [in] nPortIndex
+        nPortIndex is used to select the port on the component the buffer will
+        be used with.  The port can be found by using the nPortIndex
+        value as an index into the Port Definition array of the component.
+    @param [in] pAppPrivate
+        pAppPrivate is used to initialize the pAppPrivate member of the 
+        buffer header structure.
+    @param [in] eglImage
+        eglImage contains the handle of the EGLImage to use as a buffer on the
+        specified port.  The component is expected to validate properties of 
+        the EGLImage against the configuration of the port to ensure the component
+        can use the EGLImage as a buffer.          
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup comp buf
+ */
+#define OMX_UseEGLImage(                                    \
+           hComponent,                                      \
+           ppBufferHdr,                                     \
+           nPortIndex,                                      \
+           pAppPrivate,                                     \
+           eglImage)                                        \
+    ((OMX_COMPONENTTYPE*)hComponent)->UseEGLImage(          \
+           hComponent,                                      \
+           ppBufferHdr,                                     \
+           nPortIndex,                                      \
+           pAppPrivate,                                     \
+           eglImage)
+
+/** The OMX_Init method is used to initialize the OMX core.  It shall be the
+    first call made into OMX and it should only be executed one time without
+    an interviening OMX_Deinit call.  
+    
+    The core should return from this call within 20 msec.
+
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Init(void);
+
+
+/** The OMX_Deinit method is used to deinitialize the OMX core.  It shall be 
+    the last call made into OMX. In the event that the core determines that 
+    thare are components loaded when this call is made, the core may return 
+    with an error rather than try to unload the components.
+        
+    The core should return from this call within 20 msec.
+    
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Deinit(void);
+
+
+/** The OMX_ComponentNameEnum method will enumerate through all the names of
+    recognised valid components in the system. This function is provided
+    as a means to detect all the components in the system run-time. There is
+    no strict ordering to the enumeration order of component names, although
+    each name will only be enumerated once.  If the OMX core supports run-time
+    installation of new components, it is only requried to detect newly
+    installed components when the first call to enumerate component names
+    is made (i.e. when nIndex is 0x0).
+    
+    The core should return from this call in 20 msec.
+    
+    @param [out] cComponentName
+        pointer to a null terminated string with the component name.  The
+        names of the components are strings less than 127 bytes in length
+        plus the trailing null for a maximum size of 128 bytes.  An example 
+        of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0".  Names are 
+        assigned by the vendor, but shall start with "OMX." and then have 
+        the Vendor designation next.
+    @param [in] nNameLength
+        number of characters in the cComponentName string.  With all 
+        component name strings restricted to less than 128 characters 
+        (including the trailing null) it is recomended that the caller
+        provide a input string for the cComponentName of 128 characters.
+    @param [in] nIndex
+        number containing the enumeration index for the component. 
+        Multiple calls to OMX_ComponentNameEnum with increasing values
+        of nIndex will enumerate through the component names in the
+        system until OMX_ErrorNoMore is returned.  The value of nIndex
+        is 0 to (N-1), where N is the number of valid installed components
+        in the system.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  When the value of nIndex exceeds the number of 
+        components in the system minus 1, OMX_ErrorNoMore will be
+        returned. Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_ComponentNameEnum(
+    OMX_OUT OMX_STRING cComponentName,
+    OMX_IN  OMX_U32 nNameLength,
+    OMX_IN  OMX_U32 nIndex);
+
+
+/** The OMX_GetHandle method will locate the component specified by the
+    component name given, load that component into memory and then invoke
+    the component's methods to create an instance of the component.  
+    
+    The core should return from this call within 20 msec.
+    
+    @param [out] pHandle
+        pointer to an OMX_HANDLETYPE pointer to be filled in by this method.
+    @param [in] cComponentName
+        pointer to a null terminated string with the component name.  The
+        names of the components are strings less than 127 bytes in length
+        plus the trailing null for a maximum size of 128 bytes.  An example 
+        of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0".  Names are 
+        assigned by the vendor, but shall start with "OMX." and then have 
+        the Vendor designation next.
+    @param [in] pAppData
+        pointer to an application defined value that will be returned
+        during callbacks so that the application can identify the source
+        of the callback.
+    @param [in] pCallBacks
+        pointer to a OMX_CALLBACKTYPE structure that will be passed to the
+        component to initialize it with.  
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_GetHandle(
+    OMX_OUT OMX_HANDLETYPE* pHandle, 
+    OMX_IN  OMX_STRING cComponentName,
+    OMX_IN  OMX_PTR pAppData,
+    OMX_IN  OMX_CALLBACKTYPE* pCallBacks);
+
+
+/** The OMX_FreeHandle method will free a handle allocated by the OMX_GetHandle 
+    method.  If the component reference count goes to zero, the component will
+    be unloaded from memory.  
+    
+    The core should return from this call within 20 msec when the component is 
+    in the OMX_StateLoaded state.
+
+    @param [in] hComponent
+        Handle of the component to be accessed.  This is the component
+        handle returned by the call to the GetHandle function.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_FreeHandle(
+    OMX_IN  OMX_HANDLETYPE hComponent);
+
+
+
+/** The OMX_SetupTunnel method will handle the necessary calls to the components
+    to setup the specified tunnel the two components.  NOTE: This is
+    an actual method (not a #define macro).  This method will make calls into
+    the component ComponentTunnelRequest method to do the actual tunnel 
+    connection.  
+
+    The ComponentTunnelRequest method on both components will be called. 
+    This method shall not be called unless the component is in the 
+    OMX_StateLoaded state except when the ports used for the tunnel are
+    disabled. In this case, the component may be in the OMX_StateExecuting,
+    OMX_StatePause, or OMX_StateIdle states. 
+
+    The core should return from this call within 20 msec.
+    
+    @param [in] hOutput
+        Handle of the component to be accessed.  Also this is the handle
+        of the component whose port, specified in the nPortOutput parameter
+        will be used the source for the tunnel. This is the component handle
+        returned by the call to the OMX_GetHandle function.  There is a 
+        requirement that hOutput be the source for the data when
+        tunelling (i.e. nPortOutput is an output port).  If 0x0, the component
+        specified in hInput will have it's port specified in nPortInput
+        setup for communication with the application / IL client.
+    @param [in] nPortOutput
+        nPortOutput is used to select the source port on component to be
+        used in the tunnel. 
+    @param [in] hInput
+        This is the component to setup the tunnel with. This is the handle
+        of the component whose port, specified in the nPortInput parameter
+        will be used the destination for the tunnel. This is the component handle
+        returned by the call to the OMX_GetHandle function.  There is a 
+        requirement that hInput be the destination for the data when
+        tunelling (i.e. nPortInut is an input port).   If 0x0, the component
+        specified in hOutput will have it's port specified in nPortPOutput
+        setup for communication with the application / IL client.
+    @param [in] nPortInput
+        nPortInput is used to select the destination port on component to be
+        used in the tunnel.
+    @return OMX_ERRORTYPE
+        If the command successfully executes, the return code will be
+        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
+        When OMX_ErrorNotImplemented is returned, one or both components is 
+        a non-interop component and does not support tunneling.
+        
+        On failure, the ports of both components are setup for communication
+        with the application / IL Client.
+    @ingroup core tun
+ */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_SetupTunnel(
+    OMX_IN  OMX_HANDLETYPE hOutput,
+    OMX_IN  OMX_U32 nPortOutput,
+    OMX_IN  OMX_HANDLETYPE hInput,
+    OMX_IN  OMX_U32 nPortInput);
+    
+/** @ingroup cp */
+OMX_API OMX_ERRORTYPE   OMX_GetContentPipe(
+    OMX_OUT OMX_HANDLETYPE *hPipe,
+    OMX_IN OMX_STRING szURI);
+
+/** The OMX_GetComponentsOfRole method will return the number of components that support the given
+    role and (if the compNames field is non-NULL) the names of those components. The call will fail if 
+    an insufficiently sized array of names is supplied. To ensure the array is sufficiently sized the
+    client should:
+        * first call this function with the compNames field NULL to determine the number of component names
+        * second call this function with the compNames field pointing to an array of names allocated 
+          according to the number returned by the first call.
+
+    The core should return from this call within 5 msec.
+    
+    @param [in] role
+        This is generic standard component name consisting only of component class 
+        name and the type within that class (e.g. 'audio_decoder.aac').
+    @param [inout] pNumComps
+        This is used both as input and output. 
+ 
+        If compNames is NULL, the input is ignored and the output specifies how many components support
+        the given role.
+     
+        If compNames is not NULL, on input it bounds the size of the input structure and 
+        on output, it specifies the number of components string names listed within the compNames parameter.
+    @param [inout] compNames
+        If NULL this field is ignored. If non-NULL this points to an array of 128-byte strings which accepts 
+        a list of the names of all physical components that implement the specified standard component name. 
+        Each name is NULL terminated. numComps indicates the number of names.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_GetComponentsOfRole ( 
+	OMX_IN      OMX_STRING role,
+    OMX_INOUT   OMX_U32 *pNumComps,
+    OMX_INOUT   OMX_U8  **compNames);
+
+/** The OMX_GetRolesOfComponent method will return the number of roles supported by the given
+    component and (if the roles field is non-NULL) the names of those roles. The call will fail if 
+    an insufficiently sized array of names is supplied. To ensure the array is sufficiently sized the
+    client should:
+        * first call this function with the roles field NULL to determine the number of role names
+        * second call this function with the roles field pointing to an array of names allocated 
+          according to the number returned by the first call.
+
+    The core should return from this call within 5 msec.
+
+    @param [in] compName
+        This is the name of the component being queried about.
+    @param [inout] pNumRoles
+        This is used both as input and output. 
+ 
+        If roles is NULL, the input is ignored and the output specifies how many roles the component supports.
+     
+        If compNames is not NULL, on input it bounds the size of the input structure and 
+        on output, it specifies the number of roles string names listed within the roles parameter.
+    @param [out] roles
+        If NULL this field is ignored. If non-NULL this points to an array of 128-byte strings 
+        which accepts a list of the names of all standard components roles implemented on the 
+        specified component name. numComps indicates the number of names.
+    @ingroup core
+ */
+OMX_API OMX_ERRORTYPE OMX_GetRolesOfComponent ( 
+	OMX_IN      OMX_STRING compName, 
+    OMX_INOUT   OMX_U32 *pNumRoles,
+    OMX_OUT     OMX_U8 **roles);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
+
diff --git a/domx/omx_core/inc/OMX_CoreExt.h b/domx/omx_core/inc/OMX_CoreExt.h
new file mode 100755
index 0000000..5974d02
--- /dev/null
+++ b/domx/omx_core/inc/OMX_CoreExt.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/** OMX_CoreExt.h - OpenMax IL version 1.1.2
+ * The OMX_CoreExt header file contains extensions to the definitions used
+ * by both the application and the component to access common items.
+ */
+
+#ifndef OMX_CoreExt_h
+#define OMX_CoreExt_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Each OMX header shall include all required header files to allow the
+ * header to compile without errors.  The includes below are required
+ * for this header file to compile successfully
+ */
+#include <OMX_Core.h>
+
+/** Extensions to the standard IL errors. */
+typedef enum OMX_ERROREXTTYPE
+{
+    OMX_ErrorInvalidMode = (OMX_S32) (OMX_ErrorKhronosExtensions + 0x00000001),
+    OMX_ErrorExtMax = 0x7FFFFFFF
+} OMX_ERROREXTTYPE;
+
+
+/** Event type extensions. */
+typedef enum OMX_EVENTEXTTYPE
+{
+    OMX_EventIndexSettingChanged = OMX_EventKhronosExtensions, /**< component signals the IL client of a change
+                                                                    in a param, config, or extension */
+    OMX_EventExtMax = 0x7FFFFFFF
+} OMX_EVENTEXTTYPE;
+
+
+/** Enable or disable a callback event. */
+typedef struct OMX_CONFIG_CALLBACKREQUESTTYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */
+    OMX_INDEXTYPE nIndex;       /**< the index the callback is requested for */
+    OMX_BOOL bEnable;           /**< enable (OMX_TRUE) or disable (OMX_FALSE) the callback */
+} OMX_CONFIG_CALLBACKREQUESTTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* OMX_CoreExt_h */
+/* File EOF */
diff --git a/domx/omx_core/inc/OMX_Core_Wrapper.h b/domx/omx_core/inc/OMX_Core_Wrapper.h
new file mode 100755
index 0000000..567a357
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Core_Wrapper.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** OMX_Core.h
+ *  The OMX_Core header file contains the definitions used for PV core
+ */
+
+#ifndef OMX_TI_Core_h
+#define OMX_TI_Core_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header shall include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully
+ */
+
+#include <OMX_Core.h>
+OMX_API OMX_ERRORTYPE OMX_APIENTRY TIOMX_Init(void);
+OMX_API OMX_ERRORTYPE OMX_APIENTRY TIOMX_Deinit(void);
+OMX_API OMX_ERRORTYPE OMX_APIENTRY TIOMX_ComponentNameEnum(
+    OMX_OUT OMX_STRING cComponentName,
+    OMX_IN  OMX_U32 nNameLength,
+    OMX_IN  OMX_U32 nIndex);
+OMX_API OMX_ERRORTYPE OMX_APIENTRY TIOMX_GetHandle(
+    OMX_OUT OMX_HANDLETYPE* pHandle,
+    OMX_IN  OMX_STRING cComponentName,
+    OMX_IN  OMX_PTR pAppData,
+    OMX_IN  OMX_CALLBACKTYPE* pCallBacks);
+OMX_API OMX_ERRORTYPE OMX_APIENTRY TIOMX_FreeHandle(
+    OMX_IN  OMX_HANDLETYPE hComponent);
+OMX_API OMX_ERRORTYPE TIOMX_GetComponentsOfRole (
+	OMX_IN      OMX_STRING role,
+    OMX_INOUT   OMX_U32 *pNumComps,
+    OMX_INOUT   OMX_U8  **compNames);
+OMX_API OMX_ERRORTYPE OMX_APIENTRY TIOMX_SetupTunnel(
+    OMX_IN  OMX_HANDLETYPE hOutput,
+    OMX_IN  OMX_U32 nPortOutput,
+    OMX_IN  OMX_HANDLETYPE hInput,
+    OMX_IN  OMX_U32 nPortInput);
+OMX_API OMX_ERRORTYPE   OMX_APIENTRY  TIOMX_GetContentPipe(
+    OMX_OUT OMX_HANDLETYPE *hPipe,
+    OMX_IN OMX_STRING szURI);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
+
diff --git a/domx/omx_core/inc/OMX_Debug.h b/domx/omx_core/inc/OMX_Debug.h
new file mode 100755
index 0000000..0ccc351
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Debug.h
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef OMX_DEBUG_H
+#define OMX_DEBUG_H
+
+#include "OMX_DebugMem.h"
+
+#define OMX_NO_MESSAGES    0x00000000
+#define OMX_ALL_MESSAGES   0xffff0000
+
+#define OMX_MASK_FATAL     0x80000000
+#define OMX_MASK_ERROR     0x40000000
+#define OMX_MASK_WARN      0x20000000
+#define OMX_MASK_INFO      0x10000000
+#define OMX_MASK_DEBUG     0x08000000
+#define OMX_MASK_TRACE     0x04000000
+#define OMX_MASK_RESERVE1  0x02000000
+#define OMX_MASK_RESERVE2  0x01000000
+
+#define OMX_MASK_USERMASK  0x00FF0000
+
+#define OMX_OPTION_FILE    0x00000001
+#define OMX_OPTION_FUNC    0x00000002
+#define OMX_OPTION_LINE    0x00000004
+
+#define OMX_MASK_HANDLES   0x0000FFFF
+
+
+
+/*
+ *  ANSI escape sequences for outputing text in various colors
+ */
+#define DBG_TEXT_WHITE   "\x1b[1;37;40m"
+#define DBG_TEXT_YELLOW  "\x1b[1;33;40m"
+#define DBG_TEXT_MAGENTA "\x1b[1;35;40m"
+#define DBG_TEXT_GREEN   "\x1b[1;32;40m"
+#define DBG_TEXT_CYAN    "\x1b[1;36;40m"
+#define DBG_TEXT_RED     "\x1b[1;31;40m"
+
+
+/* Setup log format (adds newline if no newline provided) */
+// do not use this one directly....
+#define OMX_LOG_PRINT(HANDLE, STR, ARG...) \
+    (OMX_Log(HANDLE, __FILE__, __LINE__, __FUNCTION__, STR, ##ARG))
+
+#ifdef OMX_DEBUG
+    #define OMX_DPRINT(HANDLE, STR, ARG...) OMX_LOG_PRINT(OMX_MASK_DEBUG | HANDLE, STR, ##ARG)
+    #define OMX_TPRINT(HANDLE, STR, ARG...) OMX_LOG_PRINT(OMX_MASK_TRACE | HANDLE, STR, ##ARG)
+#else
+    #define OMX_DPRINT(HANDLE, STR, ARG...)
+    #define OMX_TPRINT(HANDLE, STR, ARG...)
+#endif
+
+/* Later this will be able to be turned on/off separately as a trace */
+#define OMX_DENTER(handle) OMX_TPRINT((handle), "+++ENTERING")
+#define OMX_DEXIT(handle,retVal) OMX_TPRINT((handle), "---EXITING(0x%x)", (retVal))
+
+#define OMX_DBG_INT(handle, intVar) OMX_DPRINT(OMX_MASK_DEBUG | (handle), #intVar ": %d", (intVar))
+#define OMX_DBG_PTR(handle, ptrVar) OMX_DPRINT(OMX_MASK_DEBUG | (handle), #ptrVar ": 0x%08x", (ptrVar))
+#define OMX_DBG_STR(handle, strVar) OMX_DPRINT(OMX_MASK_DEBUG | (handle), #strVar ": %s", (strVar))
+
+
+/* Error/warning printing defines to be used by all sub-components */
+#define OMX_INFOPRINT(handle, str,arg...)  (OMX_LOG_PRINT(OMX_MASK_INFO | (handle), "(INFO) "str, ##arg))
+#define OMX_WARNPRINT(handle, str,arg...)  (OMX_LOG_PRINT(OMX_MASK_WARN | (handle), "(WARN) "str, ##arg))
+#define OMX_ERRPRINT(handle, str,arg...)   (OMX_LOG_PRINT(OMX_MASK_ERROR | (handle), "(ERROR) "str, ##arg))
+#define OMX_FATALPRINT(handle, str,arg...)   (OMX_LOG_PRINT(OMX_MASK_FATAL | (handle), "(FATAL) "str, ##arg))
+
+/* assert macros */
+#ifdef OMX_DEBUG
+    #define OMX_ASSERT(COND) ((!(COND))?OMX_FATALPRINT(0,"OMX_ASSERT("#COND")"),abort():0)
+#else
+    #define OMX_ASSERT(COND)
+#endif
+
+#define OMX_LOG_ADD_MASK(HANDLE,NEW_BITS) (OMX_Log_SetMask((HANDLE), OMX_Log_GetMask(HANDLE) | (NEW_BITS)))
+#define OMX_LOG_CLEAR_MASK(HANDLE,NEW_BITS) (OMX_Log_SetMask((HANDLE), OMX_Log_GetMask(HANDLE) & ~(NEW_BITS)))
+
+#define OMX_LOG_ADD_OPTIONS(HANDLE,NEW_BITS) (OMX_Log_SetOptions((HANDLE), OMX_Log_GetOptions(HANDLE) | (NEW_BITS)))
+#define OMX_LOG_CLEAR_OPTIONS(HANDLE,NEW_BITS) (OMX_Log_SetOptions((HANDLE), OMX_Log_GetOptions(HANDLE) & ~(NEW_BITS)))
+
+typedef unsigned int OMX_DBG_HANDLE;
+
+OMX_DBG_HANDLE OMX_Log_GetDebugHandle(const char *description);
+void           OMX_Log_ReleaseDebugHandle(OMX_DBG_HANDLE hDebug);
+unsigned int   OMX_Log_GetMask(OMX_DBG_HANDLE hDebug);
+unsigned int   OMX_Log_SetMask(OMX_DBG_HANDLE hDebug, unsigned int uiNewMask);
+
+unsigned int   OMX_Log_GetOptions(OMX_DBG_HANDLE hDebug);
+unsigned int   OMX_Log_SetOptions(OMX_DBG_HANDLE hDebug, unsigned int uiNewOptions);
+
+void OMX_Log(unsigned int mask, const char *szFileName, int iLineNum,
+             const char *szFunctionName, const char *strFormat, ...);
+
+const char *OMX_GetErrorString(OMX_ERRORTYPE error);
+
+OMX_ERRORTYPE OMX_Log_LoadConfigFile(char* szConfigFile);
+
+
+/*
+ * The following macros are intended to make accessing a debug handle easier.
+ *
+ * For example, for the Util library, you would create a header file called
+ *   OMX_Util_Private.h.  This file will be included in all source files
+ *   compiled into the Util library.  The header file uses the 'define' macro
+ *   to generate a prototype for the getDebugHandle() function:
+ *
+ *   DEFINE_DEBUG_HANDLE_FN(UTIL);
+ *
+ * Now, in your private header file, define easier macros for printing:
+ *
+ *   #define UTIL_DPRINT(str,args...) OMX_DPRINT(ACCESS_DEBUG_HANDLE(UTIL),str,##args)
+ *   #define UTIL_WARNPRINT(str,args...) OMX_WARNPRINT(ACCESS_DEBUG_HANDLE(UTIL),str,##args)
+ *   #define UTIL_ERRPRINT(str,args...) OMX_ERRPRINT(ACCESS_DEBUG_HANDLE(UTIL),str,##args)
+ *
+ * Finally, in a source file which will be compiled into the lib, for example
+ *   OMX_Util_Private.c, you implement the function with the 'implement' macro:
+ *
+ *   IMPLEMENT_DEBUG_HANDLE_FN(UTIL)
+ *
+ */
+#define DEFINE_DEBUG_HANDLE_FN(MOD) OMX_DBG_HANDLE getDebugHandle_##MOD(void);
+
+#define ACCESS_DEBUG_HANDLE(MOD) getDebugHandle_##MOD()
+
+#define IMPLMENT_DEBUG_HANDLE_FN(MOD) \
+OMX_DBG_HANDLE getDebugHandle_##MOD(void)                    \
+{                                                            \
+    static OMX_DBG_HANDLE hDebug = 0;                        \
+    if(!hDebug) {                                            \
+        hDebug = OMX_Log_GetDebugHandle(#MOD);               \
+        OMX_DPRINT(0,"Component "#MOD": hDebug %d",hDebug);  \
+    }                                                        \
+    return hDebug;                                           \
+}
+
+
+
+#endif
+
diff --git a/domx/omx_core/inc/OMX_DebugMem.h b/domx/omx_core/inc/OMX_DebugMem.h
new file mode 100755
index 0000000..f45cfe0
--- /dev/null
+++ b/domx/omx_core/inc/OMX_DebugMem.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef OMX_DEBUGMEM_H
+#define OMX_DEBUGMEM_H
+
+#include <stdlib.h> // for size_t
+
+#if OMX_DEBUG
+void* OMX_DebugMem_calloc(size_t num, size_t size,
+                           const char* file, const char* func, int line);
+void* OMX_DebugMem_malloc(size_t size,
+                           const char* file, const char* func, int line);
+void* OMX_DebugMem_realloc(void *ptr, size_t size,
+                           const char* file, const char* func, int line);
+void  OMX_DebugMem_free(void* ptr,
+                         const char* file, const char* func, int line);
+int   OMX_DebugMem_validate(void *ptr,
+                         const char* file, const char* func, int line);
+
+void OMX_DebugMem_dump(const char *file, const char *func, int line);
+#endif
+
+#define OMX_MASK_MEMORY    0x00010000 /** One of the reserved bits from OMX_MASK_USERMASK */
+
+#define MEM_DEBUG_HANDLE_DESCR "DebugMemory"
+
+#if OMX_DEBUG
+    #define malloc(x)    OMX_DebugMem_malloc(x,__FILE__,__FUNCTION__,__LINE__)
+    #define calloc(n,s)  OMX_DebugMem_calloc(n,s,__FILE__,__FUNCTION__,__LINE__)
+    #define realloc(x,s) OMX_DebugMem_realloc(x,s,__FILE__,__FUNCTION__,__LINE__)
+    #define free(x)      OMX_DebugMem_free(x,__FILE__,__FUNCTION__ ,__LINE__)
+    #define validate(x)  OMX_DebugMem_validate(x, __FILE__,__FUNCTION__ ,__LINE__)
+    #define dump()      OMX_DebugMem_dump( __FILE__,__FUNCTION__ ,__LINE__)
+#else
+    #define validate(x)
+    #define dump()
+#endif
+
+
+#endif
+
diff --git a/domx/omx_core/inc/OMX_IVCommon.h b/domx/omx_core/inc/OMX_IVCommon.h
new file mode 100755
index 0000000..4c4995c
--- /dev/null
+++ b/domx/omx_core/inc/OMX_IVCommon.h
@@ -0,0 +1,920 @@
+/**
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** 
+ * @file OMX_IVCommon.h - OpenMax IL version 1.1.2
+ *  The structures needed by Video and Image components to exchange
+ *  parameters and configuration data with the components.
+ */
+#ifndef OMX_IVCommon_h
+#define OMX_IVCommon_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * Each OMX header must include all required header files to allow the header
+ * to compile without errors.  The includes below are required for this header
+ * file to compile successfully 
+ */
+
+#include <OMX_Core.h>
+
+/** @defgroup iv OpenMAX IL Imaging and Video Domain
+ * Common structures for OpenMAX IL Imaging and Video domains
+ * @{
+ */
+
+
+/** 
+ * Enumeration defining possible uncompressed image/video formats. 
+ *
+ * ENUMS:
+ *  Unused                 : Placeholder value when format is N/A
+ *  Monochrome             : black and white
+ *  8bitRGB332             : Red 7:5, Green 4:2, Blue 1:0
+ *  12bitRGB444            : Red 11:8, Green 7:4, Blue 3:0
+ *  16bitARGB4444          : Alpha 15:12, Red 11:8, Green 7:4, Blue 3:0
+ *  16bitARGB1555          : Alpha 15, Red 14:10, Green 9:5, Blue 4:0
+ *  16bitRGB565            : Red 15:11, Green 10:5, Blue 4:0
+ *  16bitBGR565            : Blue 15:11, Green 10:5, Red 4:0
+ *  18bitRGB666            : Red 17:12, Green 11:6, Blue 5:0
+ *  18bitARGB1665          : Alpha 17, Red 16:11, Green 10:5, Blue 4:0
+ *  19bitARGB1666          : Alpha 18, Red 17:12, Green 11:6, Blue 5:0
+ *  24bitRGB888            : Red 24:16, Green 15:8, Blue 7:0
+ *  24bitBGR888            : Blue 24:16, Green 15:8, Red 7:0
+ *  24bitARGB1887          : Alpha 23, Red 22:15, Green 14:7, Blue 6:0
+ *  25bitARGB1888          : Alpha 24, Red 23:16, Green 15:8, Blue 7:0
+ *  32bitBGRA8888          : Blue 31:24, Green 23:16, Red 15:8, Alpha 7:0
+ *  32bitARGB8888          : Alpha 31:24, Red 23:16, Green 15:8, Blue 7:0
+ *  YUV411Planar           : U,Y are subsampled by a factor of 4 horizontally
+ *  YUV411PackedPlanar     : packed per payload in planar slices
+ *  YUV420Planar           : Three arrays Y,U,V.
+ *  YUV420PackedPlanar     : packed per payload in planar slices
+ *  YUV420SemiPlanar       : Two arrays, one is all Y, the other is U and V
+ *  YUV422Planar           : Three arrays Y,U,V.
+ *  YUV422PackedPlanar     : packed per payload in planar slices
+ *  YUV422SemiPlanar       : Two arrays, one is all Y, the other is U and V
+ *  YCbYCr                 : Organized as 16bit YUYV (i.e. YCbYCr)
+ *  YCrYCb                 : Organized as 16bit YVYU (i.e. YCrYCb)
+ *  CbYCrY                 : Organized as 16bit UYVY (i.e. CbYCrY)
+ *  CrYCbY                 : Organized as 16bit VYUY (i.e. CrYCbY)
+ *  YUV444Interleaved      : Each pixel contains equal parts YUV
+ *  RawBayer8bit           : SMIA camera output format
+ *  RawBayer10bit          : SMIA camera output format
+ *  RawBayer8bitcompressed : SMIA camera output format
+ */
+typedef enum OMX_COLOR_FORMATTYPE {
+    OMX_COLOR_FormatUnused,
+    OMX_COLOR_FormatMonochrome,
+    OMX_COLOR_Format8bitRGB332,
+    OMX_COLOR_Format12bitRGB444,
+    OMX_COLOR_Format16bitARGB4444,
+    OMX_COLOR_Format16bitARGB1555,
+    OMX_COLOR_Format16bitRGB565,
+    OMX_COLOR_Format16bitBGR565,
+    OMX_COLOR_Format18bitRGB666,
+    OMX_COLOR_Format18bitARGB1665,
+    OMX_COLOR_Format19bitARGB1666, 
+    OMX_COLOR_Format24bitRGB888,
+    OMX_COLOR_Format24bitBGR888,
+    OMX_COLOR_Format24bitARGB1887,
+    OMX_COLOR_Format25bitARGB1888,
+    OMX_COLOR_Format32bitBGRA8888,
+    OMX_COLOR_Format32bitARGB8888,
+    OMX_COLOR_FormatYUV411Planar,
+    OMX_COLOR_FormatYUV411PackedPlanar,
+    OMX_COLOR_FormatYUV420Planar,
+    OMX_COLOR_FormatYUV420PackedPlanar,
+    OMX_COLOR_FormatYUV420SemiPlanar,
+    OMX_COLOR_FormatYUV422Planar,
+    OMX_COLOR_FormatYUV422PackedPlanar,
+    OMX_COLOR_FormatYUV422SemiPlanar,
+    OMX_COLOR_FormatYCbYCr,
+    OMX_COLOR_FormatYCrYCb,
+    OMX_COLOR_FormatCbYCrY,
+    OMX_COLOR_FormatCrYCbY,
+    OMX_COLOR_FormatYUV444Interleaved,
+    OMX_COLOR_FormatRawBayer8bit,
+    OMX_COLOR_FormatRawBayer10bit,
+    OMX_COLOR_FormatRawBayer8bitcompressed,
+    OMX_COLOR_FormatL2, 
+    OMX_COLOR_FormatL4, 
+    OMX_COLOR_FormatL8, 
+    OMX_COLOR_FormatL16, 
+    OMX_COLOR_FormatL24, 
+    OMX_COLOR_FormatL32,
+    OMX_COLOR_FormatYUV420PackedSemiPlanar,
+    OMX_COLOR_FormatYUV422PackedSemiPlanar,
+    OMX_COLOR_Format18BitBGR666,
+    OMX_COLOR_Format24BitARGB6666,
+    OMX_COLOR_Format24BitABGR6666,
+    OMX_COLOR_FormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_COLOR_FormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_COLOR_FormatMax = 0x7FFFFFFF
+} OMX_COLOR_FORMATTYPE;
+
+
+/** 
+ * Defines the matrix for conversion from RGB to YUV or vice versa.
+ * iColorMatrix should be initialized with the fixed point values 
+ * used in converting between formats.
+ */
+typedef struct OMX_CONFIG_COLORCONVERSIONTYPE {
+    OMX_U32 nSize;              /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version info */ 
+    OMX_U32 nPortIndex;         /**< Port that this struct applies to */
+    OMX_S32 xColorMatrix[3][3]; /**< Stored in signed Q16 format */
+    OMX_S32 xColorOffset[4];    /**< Stored in signed Q16 format */
+}OMX_CONFIG_COLORCONVERSIONTYPE;
+
+
+/** 
+ * Structure defining percent to scale each frame dimension.  For example:  
+ * To make the width 50% larger, use fWidth = 1.5 and to make the width
+ * 1/2 the original size, use fWidth = 0.5
+ */
+typedef struct OMX_CONFIG_SCALEFACTORTYPE {
+    OMX_U32 nSize;            /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version info */ 
+    OMX_U32 nPortIndex;       /**< Port that this struct applies to */
+    OMX_S32 xWidth;           /**< Fixed point value stored as Q16 */
+    OMX_S32 xHeight;          /**< Fixed point value stored as Q16 */
+}OMX_CONFIG_SCALEFACTORTYPE;
+
+
+/** 
+ * Enumeration of possible image filter types 
+ */
+typedef enum OMX_IMAGEFILTERTYPE {
+    OMX_ImageFilterNone,
+    OMX_ImageFilterNoise,
+    OMX_ImageFilterEmboss,
+    OMX_ImageFilterNegative,
+    OMX_ImageFilterSketch,
+    OMX_ImageFilterOilPaint,
+    OMX_ImageFilterHatch,
+    OMX_ImageFilterGpen,
+    OMX_ImageFilterAntialias, 
+    OMX_ImageFilterDeRing,       
+    OMX_ImageFilterSolarize,
+    OMX_ImageFilterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_ImageFilterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_ImageFilterMax = 0x7FFFFFFF
+} OMX_IMAGEFILTERTYPE;
+
+
+/** 
+ * Image filter configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes       
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to 
+ *  eImageFilter : Image filter type enumeration      
+ */
+typedef struct OMX_CONFIG_IMAGEFILTERTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGEFILTERTYPE eImageFilter;
+} OMX_CONFIG_IMAGEFILTERTYPE;
+
+
+/** 
+ * Customized U and V for color enhancement 
+ *
+ * STRUCT MEMBERS:
+ *  nSize             : Size of the structure in bytes
+ *  nVersion          : OMX specification version information 
+ *  nPortIndex        : Port that this structure applies to
+ *  bColorEnhancement : Enable/disable color enhancement
+ *  nCustomizedU      : Practical values: 16-240, range: 0-255, value set for 
+ *                      U component
+ *  nCustomizedV      : Practical values: 16-240, range: 0-255, value set for 
+ *                      V component
+ */
+typedef struct OMX_CONFIG_COLORENHANCEMENTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;
+    OMX_BOOL bColorEnhancement;
+    OMX_U8 nCustomizedU;
+    OMX_U8 nCustomizedV;
+} OMX_CONFIG_COLORENHANCEMENTTYPE;
+
+
+/** 
+ * Define color key and color key mask 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to
+ *  nARGBColor : 32bit Alpha, Red, Green, Blue Color
+ *  nARGBMask  : 32bit Mask for Alpha, Red, Green, Blue channels
+ */
+typedef struct OMX_CONFIG_COLORKEYTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nARGBColor;
+    OMX_U32 nARGBMask;
+} OMX_CONFIG_COLORKEYTYPE;
+
+
+/** 
+ * List of color blend types for pre/post processing 
+ *
+ * ENUMS:
+ *  None          : No color blending present
+ *  AlphaConstant : Function is (alpha_constant * src) + 
+ *                  (1 - alpha_constant) * dst)
+ *  AlphaPerPixel : Function is (alpha * src) + (1 - alpha) * dst)
+ *  Alternate     : Function is alternating pixels from src and dst
+ *  And           : Function is (src & dst)
+ *  Or            : Function is (src | dst)
+ *  Invert        : Function is ~src
+ */
+typedef enum OMX_COLORBLENDTYPE {
+    OMX_ColorBlendNone,
+    OMX_ColorBlendAlphaConstant,
+    OMX_ColorBlendAlphaPerPixel,
+    OMX_ColorBlendAlternate,
+    OMX_ColorBlendAnd,
+    OMX_ColorBlendOr,
+    OMX_ColorBlendInvert,
+    OMX_ColorBlendKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_ColorBlendVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_ColorBlendMax = 0x7FFFFFFF
+} OMX_COLORBLENDTYPE;
+
+
+/** 
+ * Color blend configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize             : Size of the structure in bytes                        
+ *  nVersion          : OMX specification version information                
+ *  nPortIndex        : Port that this structure applies to                   
+ *  nRGBAlphaConstant : Constant global alpha values when global alpha is used
+ *  eColorBlend       : Color blend type enumeration                         
+ */
+typedef struct OMX_CONFIG_COLORBLENDTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nRGBAlphaConstant;
+    OMX_COLORBLENDTYPE  eColorBlend;
+} OMX_CONFIG_COLORBLENDTYPE;
+
+
+/** 
+ * Hold frame dimension
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes      
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to     
+ *  nWidth     : Frame width in pixels                 
+ *  nHeight    : Frame height in pixels                
+ */
+typedef struct OMX_FRAMESIZETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+} OMX_FRAMESIZETYPE;
+
+
+/**
+ * Rotation configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes             
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nRotation  : +/- integer rotation value               
+ */
+typedef struct OMX_CONFIG_ROTATIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nRotation; 
+} OMX_CONFIG_ROTATIONTYPE;
+
+
+/** 
+ * Possible mirroring directions for pre/post processing 
+ *
+ * ENUMS:
+ *  None       : No mirroring                         
+ *  Vertical   : Vertical mirroring, flip on X axis   
+ *  Horizontal : Horizontal mirroring, flip on Y axis  
+ *  Both       : Both vertical and horizontal mirroring
+ */
+typedef enum OMX_MIRRORTYPE {
+    OMX_MirrorNone = 0,
+    OMX_MirrorVertical,
+    OMX_MirrorHorizontal,
+    OMX_MirrorBoth, 
+    OMX_MirrorKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MirrorVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_MirrorMax = 0x7FFFFFFF   
+} OMX_MIRRORTYPE;
+
+
+/** 
+ * Mirroring configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes      
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to  
+ *  eMirror    : Mirror type enumeration              
+ */
+typedef struct OMX_CONFIG_MIRRORTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;
+    OMX_MIRRORTYPE  eMirror;
+} OMX_CONFIG_MIRRORTYPE;
+
+
+/** 
+ * Position information only 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes               
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nX         : X coordinate for the point                     
+ *  nY         : Y coordinate for the point 
+ */                      
+typedef struct OMX_CONFIG_POINTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nX;
+    OMX_S32 nY;
+} OMX_CONFIG_POINTTYPE;
+
+
+/** 
+ * Frame size plus position 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes                    
+ *  nVersion   : OMX specification version information      
+ *  nPortIndex : Port that this structure applies to    
+ *  nLeft      : X Coordinate of the top left corner of the rectangle
+ *  nTop       : Y Coordinate of the top left corner of the rectangle
+ *  nWidth     : Width of the rectangle                              
+ *  nHeight    : Height of the rectangle                             
+ */
+typedef struct OMX_CONFIG_RECTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;  
+    OMX_U32 nPortIndex; 
+    OMX_S32 nLeft; 
+    OMX_S32 nTop;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+} OMX_CONFIG_RECTTYPE;
+
+
+/** 
+ * Deblocking state; it is required to be set up before starting the codec 
+ *
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes      
+ *  nVersion    : OMX specification version information 
+ *  nPortIndex  : Port that this structure applies to
+ *  bDeblocking : Enable/disable deblocking mode    
+ */
+typedef struct OMX_PARAM_DEBLOCKINGTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bDeblocking;
+} OMX_PARAM_DEBLOCKINGTYPE;
+
+
+/** 
+ * Stabilization state 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes          
+ *  nVersion   : OMX specification version information    
+ *  nPortIndex : Port that this structure applies to   
+ *  bStab      : Enable/disable frame stabilization state
+ */
+typedef struct OMX_CONFIG_FRAMESTABTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bStab;
+} OMX_CONFIG_FRAMESTABTYPE;
+
+
+/** 
+ * White Balance control type 
+ *
+ * STRUCT MEMBERS:
+ *  SunLight : Referenced in JSR-234
+ *  Flash    : Optimal for device's integrated flash
+ */
+typedef enum OMX_WHITEBALCONTROLTYPE {
+    OMX_WhiteBalControlOff = 0,
+    OMX_WhiteBalControlAuto,
+    OMX_WhiteBalControlSunLight,
+    OMX_WhiteBalControlCloudy,
+    OMX_WhiteBalControlShade,
+    OMX_WhiteBalControlTungsten,
+    OMX_WhiteBalControlFluorescent,
+    OMX_WhiteBalControlIncandescent,
+    OMX_WhiteBalControlFlash,
+    OMX_WhiteBalControlHorizon,
+    OMX_WhiteBalControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_WhiteBalControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_WhiteBalControlMax = 0x7FFFFFFF
+} OMX_WHITEBALCONTROLTYPE;
+
+
+/** 
+ * White Balance control configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize            : Size of the structure in bytes       
+ *  nVersion         : OMX specification version information
+ *  nPortIndex       : Port that this structure applies to                 
+ *  eWhiteBalControl : White balance enumeration            
+ */
+typedef struct OMX_CONFIG_WHITEBALCONTROLTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_WHITEBALCONTROLTYPE eWhiteBalControl;
+} OMX_CONFIG_WHITEBALCONTROLTYPE;
+
+
+/** 
+ * Exposure control type 
+ */
+typedef enum OMX_EXPOSURECONTROLTYPE {
+    OMX_ExposureControlOff = 0,
+    OMX_ExposureControlAuto,
+    OMX_ExposureControlNight,
+    OMX_ExposureControlBackLight,
+    OMX_ExposureControlSpotLight,
+    OMX_ExposureControlSports,
+    OMX_ExposureControlSnow,
+    OMX_ExposureControlBeach,
+    OMX_ExposureControlLargeAperture,
+    OMX_ExposureControlSmallApperture,
+    OMX_ExposureControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_ExposureControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_ExposureControlMax = 0x7FFFFFFF
+} OMX_EXPOSURECONTROLTYPE;
+
+
+/** 
+ * White Balance control configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize            : Size of the structure in bytes      
+ *  nVersion         : OMX specification version information
+ *  nPortIndex       : Port that this structure applies to                
+ *  eExposureControl : Exposure control enumeration         
+ */
+typedef struct OMX_CONFIG_EXPOSURECONTROLTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_EXPOSURECONTROLTYPE eExposureControl;
+} OMX_CONFIG_EXPOSURECONTROLTYPE;
+
+
+/** 
+ * Defines sensor supported mode. 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes           
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to 
+ *  nFrameRate : Single shot mode is indicated by a 0     
+ *  bOneShot   : Enable for single shot, disable for streaming
+ *  sFrameSize : Framesize                                          
+ */
+typedef struct OMX_PARAM_SENSORMODETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nFrameRate;
+    OMX_BOOL bOneShot;
+    OMX_FRAMESIZETYPE sFrameSize;
+} OMX_PARAM_SENSORMODETYPE;
+
+
+/** 
+ * Defines contrast level 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes                              
+ *  nVersion   : OMX specification version information                
+ *  nPortIndex : Port that this structure applies to                 
+ *  nContrast  : Values allowed for contrast -100 to 100, zero means no change
+ */
+typedef struct OMX_CONFIG_CONTRASTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nContrast;
+} OMX_CONFIG_CONTRASTTYPE;
+
+
+/** 
+ * Defines brightness level 
+ *
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes          
+ *  nVersion    : OMX specification version information 
+ *  nPortIndex  : Port that this structure applies to 
+ *  nBrightness : 0-100%        
+ */
+typedef struct OMX_CONFIG_BRIGHTNESSTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nBrightness;
+} OMX_CONFIG_BRIGHTNESSTYPE;
+
+
+/** 
+ * Defines backlight level configuration for a video sink, e.g. LCD panel 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to
+ *  nBacklight : Values allowed for backlight 0-100%
+ *  nTimeout   : Number of milliseconds before backlight automatically turns 
+ *               off.  A value of 0x0 disables backight timeout 
+ */
+typedef struct OMX_CONFIG_BACKLIGHTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nBacklight;
+    OMX_U32 nTimeout;
+} OMX_CONFIG_BACKLIGHTTYPE;
+
+
+/** 
+ * Defines setting for Gamma 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to
+ *  nGamma     : Values allowed for gamma -100 to 100, zero means no change
+ */
+typedef struct OMX_CONFIG_GAMMATYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nGamma;
+} OMX_CONFIG_GAMMATYPE;
+
+
+/** 
+ * Define for setting saturation 
+ * 
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes
+ *  nVersion    : OMX specification version information
+ *  nPortIndex  : Port that this structure applies to
+ *  nSaturation : Values allowed for saturation -100 to 100, zero means 
+ *                no change
+ */
+typedef struct OMX_CONFIG_SATURATIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nSaturation;
+} OMX_CONFIG_SATURATIONTYPE;
+
+
+/** 
+ * Define for setting Lightness 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nLightness : Values allowed for lightness -100 to 100, zero means no 
+ *               change
+ */
+typedef struct OMX_CONFIG_LIGHTNESSTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 nLightness;
+} OMX_CONFIG_LIGHTNESSTYPE;
+
+
+/** 
+ * Plane blend configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes 
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Index of input port associated with the plane.
+ *  nDepth     : Depth of the plane in relation to the screen. Higher 
+ *               numbered depths are "behind" lower number depths.  
+ *               This number defaults to the Port Index number.
+ *  nAlpha     : Transparency blending component for the entire plane.  
+ *               See blending modes for more detail.
+ */
+typedef struct OMX_CONFIG_PLANEBLENDTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nDepth;
+    OMX_U32 nAlpha;
+} OMX_CONFIG_PLANEBLENDTYPE;
+
+
+/** 
+ * Define interlace type
+ *
+ * STRUCT MEMBERS:
+ *  nSize                 : Size of the structure in bytes 
+ *  nVersion              : OMX specification version information 
+ *  nPortIndex            : Port that this structure applies to
+ *  bEnable               : Enable control variable for this functionality 
+ *                          (see below)
+ *  nInterleavePortIndex  : Index of input or output port associated with  
+ *                          the interleaved plane. 
+ *  pPlanarPortIndexes[4] : Index of input or output planar ports.
+ */
+typedef struct OMX_PARAM_INTERLEAVETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnable;
+    OMX_U32 nInterleavePortIndex;
+} OMX_PARAM_INTERLEAVETYPE;
+
+
+/** 
+ * Defines the picture effect used for an input picture 
+ */
+typedef enum OMX_TRANSITIONEFFECTTYPE {
+    OMX_EffectNone,
+    OMX_EffectFadeFromBlack,
+    OMX_EffectFadeToBlack,
+    OMX_EffectUnspecifiedThroughConstantColor,
+    OMX_EffectDissolve,
+    OMX_EffectWipe,
+    OMX_EffectUnspecifiedMixOfTwoScenes,
+    OMX_EffectKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_EffectVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_EffectMax = 0x7FFFFFFF
+} OMX_TRANSITIONEFFECTTYPE;
+
+
+/** 
+ * Structure used to configure current transition effect 
+ *
+ * STRUCT MEMBERS:
+ * nSize      : Size of the structure in bytes
+ * nVersion   : OMX specification version information 
+ * nPortIndex : Port that this structure applies to
+ * eEffect    : Effect to enable
+ */
+typedef struct OMX_CONFIG_TRANSITIONEFFECTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TRANSITIONEFFECTTYPE eEffect;
+} OMX_CONFIG_TRANSITIONEFFECTTYPE;
+
+
+/** 
+ * Defines possible data unit types for encoded video data. The data unit 
+ * types are used both for encoded video input for playback as well as
+ * encoded video output from recording. 
+ */
+typedef enum OMX_DATAUNITTYPE {
+    OMX_DataUnitCodedPicture,
+    OMX_DataUnitVideoSegment,
+    OMX_DataUnitSeveralSegments,
+    OMX_DataUnitArbitraryStreamSection,
+    OMX_DataUnitKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_DataUnitVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_DataUnitMax = 0x7FFFFFFF
+} OMX_DATAUNITTYPE;
+
+
+/** 
+ * Defines possible encapsulation types for coded video data unit. The 
+ * encapsulation information is used both for encoded video input for 
+ * playback as well as encoded video output from recording. 
+ */
+typedef enum OMX_DATAUNITENCAPSULATIONTYPE {
+    OMX_DataEncapsulationElementaryStream,
+    OMX_DataEncapsulationGenericPayload,
+    OMX_DataEncapsulationRtpPayload,
+    OMX_DataEncapsulationKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_DataEncapsulationVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_DataEncapsulationMax = 0x7FFFFFFF
+} OMX_DATAUNITENCAPSULATIONTYPE;
+
+
+/** 
+ * Structure used to configure the type of being decoded/encoded 
+ */
+typedef struct OMX_PARAM_DATAUNITTYPE {
+    OMX_U32 nSize;            /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;       /**< Port that this structure applies to */
+    OMX_DATAUNITTYPE eUnitType;
+    OMX_DATAUNITENCAPSULATIONTYPE eEncapsulationType;
+} OMX_PARAM_DATAUNITTYPE;
+
+
+/**
+ * Defines dither types 
+ */
+typedef enum OMX_DITHERTYPE {
+    OMX_DitherNone,
+    OMX_DitherOrdered,
+    OMX_DitherErrorDiffusion,
+    OMX_DitherOther,
+    OMX_DitherKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_DitherVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_DitherMax = 0x7FFFFFFF
+} OMX_DITHERTYPE;
+
+
+/** 
+ * Structure used to configure current type of dithering 
+ */
+typedef struct OMX_CONFIG_DITHERTYPE {
+    OMX_U32 nSize;            /**< Size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */ 
+    OMX_U32 nPortIndex;       /**< Port that this structure applies to */
+    OMX_DITHERTYPE eDither;   /**< Type of dithering to use */
+} OMX_CONFIG_DITHERTYPE;
+
+typedef struct OMX_CONFIG_CAPTUREMODETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;     /**< Port that this structure applies to */
+    OMX_BOOL bContinuous;   /**< If true then ignore frame rate and emit capture 
+                             *   data as fast as possible (otherwise obey port's frame rate). */
+    OMX_BOOL bFrameLimited; /**< If true then terminate capture after the port emits the 
+                             *   specified number of frames (otherwise the port does not 
+                             *   terminate the capture until instructed to do so by the client). 
+                             *   Even if set, the client may manually terminate the capture prior 
+                             *   to reaching the limit. */
+    OMX_U32 nFrameLimit;      /**< Limit on number of frames emitted during a capture (only
+                               *   valid if bFrameLimited is set). */
+} OMX_CONFIG_CAPTUREMODETYPE;
+
+typedef enum OMX_METERINGTYPE {
+ 
+    OMX_MeteringModeAverage,     /**< Center-weighted average metering. */
+    OMX_MeteringModeSpot,  	      /**< Spot (partial) metering. */
+    OMX_MeteringModeMatrix,      /**< Matrix or evaluative metering. */
+ 
+    OMX_MeteringKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_MeteringVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_EVModeMax = 0x7fffffff
+} OMX_METERINGTYPE;
+ 
+typedef struct OMX_CONFIG_EXPOSUREVALUETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_METERINGTYPE eMetering;
+    OMX_S32 xEVCompensation;      /**< Fixed point value stored as Q16 */
+    OMX_U32 nApertureFNumber;     /**< e.g. nApertureFNumber = 2 implies "f/2" - Q16 format */
+    OMX_BOOL bAutoAperture;		/**< Whether aperture number is defined automatically */
+    OMX_U32 nShutterSpeedMsec;    /**< Shutterspeed in milliseconds */ 
+    OMX_BOOL bAutoShutterSpeed;	/**< Whether shutter speed is defined automatically */ 
+    OMX_U32 nSensitivity;         /**< e.g. nSensitivity = 100 implies "ISO 100" */
+    OMX_BOOL bAutoSensitivity;	/**< Whether sensitivity is defined automatically */
+} OMX_CONFIG_EXPOSUREVALUETYPE;
+
+/** 
+ * Focus region configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize           : Size of the structure in bytes
+ *  nVersion        : OMX specification version information
+ *  nPortIndex      : Port that this structure applies to
+ *  bCenter         : Use center region as focus region of interest
+ *  bLeft           : Use left region as focus region of interest
+ *  bRight          : Use right region as focus region of interest
+ *  bTop            : Use top region as focus region of interest
+ *  bBottom         : Use bottom region as focus region of interest
+ *  bTopLeft        : Use top left region as focus region of interest
+ *  bTopRight       : Use top right region as focus region of interest
+ *  bBottomLeft     : Use bottom left region as focus region of interest
+ *  bBottomRight    : Use bottom right region as focus region of interest
+ */
+typedef struct OMX_CONFIG_FOCUSREGIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bCenter;
+    OMX_BOOL bLeft;
+    OMX_BOOL bRight;
+    OMX_BOOL bTop;
+    OMX_BOOL bBottom;
+    OMX_BOOL bTopLeft;
+    OMX_BOOL bTopRight;
+    OMX_BOOL bBottomLeft;
+    OMX_BOOL bBottomRight;
+} OMX_CONFIG_FOCUSREGIONTYPE;
+
+/** 
+ * Focus Status type 
+ */
+typedef enum OMX_FOCUSSTATUSTYPE {
+    OMX_FocusStatusOff = 0,
+    OMX_FocusStatusRequest,
+    OMX_FocusStatusReached,
+    OMX_FocusStatusUnableToReach,
+    OMX_FocusStatusLost,
+    OMX_FocusStatusKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_FocusStatusVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_FocusStatusMax = 0x7FFFFFFF
+} OMX_FOCUSSTATUSTYPE;
+
+/** 
+ * Focus status configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize               : Size of the structure in bytes
+ *  nVersion            : OMX specification version information
+ *  nPortIndex          : Port that this structure applies to
+ *  eFocusStatus        : Specifies the focus status
+ *  bCenterStatus       : Use center region as focus region of interest
+ *  bLeftStatus         : Use left region as focus region of interest
+ *  bRightStatus        : Use right region as focus region of interest
+ *  bTopStatus          : Use top region as focus region of interest
+ *  bBottomStatus       : Use bottom region as focus region of interest
+ *  bTopLeftStatus      : Use top left region as focus region of interest
+ *  bTopRightStatus     : Use top right region as focus region of interest
+ *  bBottomLeftStatus   : Use bottom left region as focus region of interest
+ *  bBottomRightStatus  : Use bottom right region as focus region of interest
+ */
+typedef struct OMX_PARAM_FOCUSSTATUSTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_FOCUSSTATUSTYPE eFocusStatus;
+    OMX_BOOL bCenterStatus;
+    OMX_BOOL bLeftStatus;
+    OMX_BOOL bRightStatus;
+    OMX_BOOL bTopStatus;
+    OMX_BOOL bBottomStatus;
+    OMX_BOOL bTopLeftStatus;
+    OMX_BOOL bTopRightStatus;
+    OMX_BOOL bBottomLeftStatus;
+    OMX_BOOL bBottomRightStatus;
+} OMX_PARAM_FOCUSSTATUSTYPE;
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/domx/omx_core/inc/OMX_Image.h b/domx/omx_core/inc/OMX_Image.h
new file mode 100755
index 0000000..a6d4666
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Image.h
@@ -0,0 +1,328 @@
+/**
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ */
+
+/** 
+ * @file OMX_Image.h - OpenMax IL version 1.1.2
+ * The structures needed by Image components to exchange parameters and 
+ * configuration data with the components.
+ */
+#ifndef OMX_Image_h
+#define OMX_Image_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/**
+ * Each OMX header must include all required header files to allow the 
+ * header to compile without errors.  The includes below are required  
+ * for this header file to compile successfully 
+ */
+
+#include <OMX_IVCommon.h>
+
+/** @defgroup imaging OpenMAX IL Imaging Domain
+ * @ingroup iv
+ * Structures for OpenMAX IL Imaging domain
+ * @{
+ */
+
+/** 
+ * Enumeration used to define the possible image compression coding. 
+ */
+typedef enum OMX_IMAGE_CODINGTYPE {
+    OMX_IMAGE_CodingUnused,      /**< Value when format is N/A */
+    OMX_IMAGE_CodingAutoDetect,  /**< Auto detection of image format */
+    OMX_IMAGE_CodingJPEG,        /**< JPEG/JFIF image format */
+    OMX_IMAGE_CodingJPEG2K,      /**< JPEG 2000 image format */
+    OMX_IMAGE_CodingEXIF,        /**< EXIF image format */
+    OMX_IMAGE_CodingTIFF,        /**< TIFF image format */
+    OMX_IMAGE_CodingGIF,         /**< Graphics image format */
+    OMX_IMAGE_CodingPNG,         /**< PNG image format */
+    OMX_IMAGE_CodingLZW,         /**< LZW image format */
+    OMX_IMAGE_CodingBMP,         /**< Windows Bitmap format */
+    OMX_IMAGE_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_CodingMax = 0x7FFFFFFF
+} OMX_IMAGE_CODINGTYPE;
+
+
+/**
+ * Data structure used to define an image path. The number of image paths 
+ * for input and output will vary by type of the image component.  
+ * 
+ *  Input (aka Source) : Zero Inputs, one Output,
+ *  Splitter           : One Input, 2 or more Outputs,
+ *  Processing Element : One Input, one output,
+ *  Mixer              : 2 or more inputs, one output,
+ *  Output (aka Sink)  : One Input, zero outputs.
+ * 
+ * The PortDefinition structure is used to define all of the parameters 
+ * necessary for the compliant component to setup an input or an output  
+ * image path.  If additional vendor specific data is required, it should  
+ * be transmitted to the component using the CustomCommand function.   
+ * Compliant components will prepopulate this structure with optimal  
+ * values during the OMX_GetParameter() command.
+ *
+ * STRUCT MEMBERS:
+ *  cMIMEType             : MIME type of data for the port
+ *  pNativeRender         : Platform specific reference for a display if a 
+ *                          sync, otherwise this field is 0
+ *  nFrameWidth           : Width of frame to be used on port if 
+ *                          uncompressed format is used.  Use 0 for 
+ *                          unknown, don't care or variable
+ *  nFrameHeight          : Height of frame to be used on port if 
+ *                          uncompressed format is used. Use 0 for 
+ *                          unknown, don't care or variable
+ *  nStride               : Number of bytes per span of an image (i.e. 
+ *                          indicates the number of bytes to get from
+ *                          span N to span N+1, where negative stride 
+ *                          indicates the image is bottom up
+ *  nSliceHeight          : Height used when encoding in slices
+ *  bFlagErrorConcealment : Turns on error concealment if it is supported by 
+ *                          the OMX component
+ *  eCompressionFormat    : Compression format used in this instance of  
+ *                          the component. When OMX_IMAGE_CodingUnused is 
+ *                          specified, eColorFormat is valid
+ *  eColorFormat          : Decompressed format used by this component
+ *  pNativeWindow         : Platform specific reference for a window object if a 
+ *                          display sink , otherwise this field is 0x0. 
+ */
+typedef struct OMX_IMAGE_PORTDEFINITIONTYPE {
+    OMX_STRING cMIMEType;
+    OMX_NATIVE_DEVICETYPE pNativeRender;
+    OMX_U32 nFrameWidth; 
+    OMX_U32 nFrameHeight;
+    OMX_S32 nStride;     
+    OMX_U32 nSliceHeight;
+    OMX_BOOL bFlagErrorConcealment;
+    OMX_IMAGE_CODINGTYPE eCompressionFormat;
+    OMX_COLOR_FORMATTYPE eColorFormat;
+    OMX_NATIVE_WINDOWTYPE pNativeWindow;
+} OMX_IMAGE_PORTDEFINITIONTYPE;
+
+
+/**  
+ * Port format parameter.  This structure is used to enumerate the various 
+ * data input/output format supported by the port.
+ * 
+ * STRUCT MEMBERS:
+ *  nSize              : Size of the structure in bytes
+ *  nVersion           : OMX specification version information
+ *  nPortIndex         : Indicates which port to set
+ *  nIndex             : Indicates the enumeration index for the format from 
+ *                       0x0 to N-1
+ *  eCompressionFormat : Compression format used in this instance of the 
+ *                       component. When OMX_IMAGE_CodingUnused is specified, 
+ *                       eColorFormat is valid
+ *  eColorFormat       : Decompressed format used by this component
+ */
+typedef struct OMX_IMAGE_PARAM_PORTFORMATTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nIndex;
+    OMX_IMAGE_CODINGTYPE eCompressionFormat;
+    OMX_COLOR_FORMATTYPE eColorFormat;
+} OMX_IMAGE_PARAM_PORTFORMATTYPE;
+
+
+/** 
+ * Flash control type 
+ *
+ * ENUMS
+ *  Torch : Flash forced constantly on
+ */
+typedef enum OMX_IMAGE_FLASHCONTROLTYPE {
+    OMX_IMAGE_FlashControlOn = 0,
+    OMX_IMAGE_FlashControlOff,
+    OMX_IMAGE_FlashControlAuto,
+    OMX_IMAGE_FlashControlRedEyeReduction,
+    OMX_IMAGE_FlashControlFillin,
+    OMX_IMAGE_FlashControlTorch,
+    OMX_IMAGE_FlashControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_FlashControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_FlashControlMax = 0x7FFFFFFF
+} OMX_IMAGE_FLASHCONTROLTYPE;
+
+
+/** 
+ * Flash control configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize         : Size of the structure in bytes
+ *  nVersion      : OMX specification version information
+ *  nPortIndex    : Port that this structure applies to
+ *  eFlashControl : Flash control type
+ */
+typedef struct OMX_IMAGE_PARAM_FLASHCONTROLTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGE_FLASHCONTROLTYPE eFlashControl;
+} OMX_IMAGE_PARAM_FLASHCONTROLTYPE;
+
+
+/** 
+ * Focus control type 
+ */
+typedef enum OMX_IMAGE_FOCUSCONTROLTYPE {
+    OMX_IMAGE_FocusControlOn = 0,
+    OMX_IMAGE_FocusControlOff,
+    OMX_IMAGE_FocusControlAuto,
+    OMX_IMAGE_FocusControlAutoLock,
+    OMX_IMAGE_FocusControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_FocusControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_FocusControlMax = 0x7FFFFFFF
+} OMX_IMAGE_FOCUSCONTROLTYPE;
+
+ 
+/** 
+ * Focus control configuration 
+ *
+ * STRUCT MEMBERS:
+ *  nSize           : Size of the structure in bytes
+ *  nVersion        : OMX specification version information
+ *  nPortIndex      : Port that this structure applies to
+ *  eFocusControl   : Focus control
+ *  nFocusSteps     : Focus can take on values from 0 mm to infinity. 
+ *                    Interest is only in number of steps over this range.
+ *  nFocusStepIndex : Current focus step index
+ */
+typedef struct OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGE_FOCUSCONTROLTYPE eFocusControl;
+    OMX_U32 nFocusSteps;
+    OMX_U32 nFocusStepIndex;
+} OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE;
+
+
+/** 
+ * Q Factor for JPEG compression, which controls the tradeoff between image
+ * quality and size.  Q Factor provides a more simple means of controlling
+ * JPEG compression quality, without directly programming Quantization
+ * tables for chroma and luma 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes         
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to 
+ *  nQFactor   : JPEG Q factor value in the range of 1-100. A factor of 1 
+ *               produces the smallest, worst quality images, and a factor 
+ *               of 100 produces the largest, best quality images.  A 
+ *               typical default is 75 for small good quality images               
+ */
+typedef struct OMX_IMAGE_PARAM_QFACTORTYPE {
+    OMX_U32 nSize;            
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;       
+    OMX_U32 nQFactor;                                        
+} OMX_IMAGE_PARAM_QFACTORTYPE;
+
+/** 
+ * Quantization table type 
+ */
+
+typedef enum OMX_IMAGE_QUANTIZATIONTABLETYPE {
+    OMX_IMAGE_QuantizationTableLuma = 0,
+    OMX_IMAGE_QuantizationTableChroma,
+    OMX_IMAGE_QuantizationTableChromaCb,
+    OMX_IMAGE_QuantizationTableChromaCr,
+    OMX_IMAGE_QuantizationTableKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_QuantizationTableVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_QuantizationTableMax = 0x7FFFFFFF
+} OMX_IMAGE_QUANTIZATIONTABLETYPE;
+
+/** 
+ * JPEG quantization tables are used to determine DCT compression for
+ * YUV data, as an alternative to specifying Q factor, providing exact 
+ * control of compression 
+ *
+ * STRUCT MEMBERS:
+ *  nSize                   : Size of the structure in bytes
+ *  nVersion                : OMX specification version information 
+ *  nPortIndex              : Port that this structure applies to
+ *  eQuantizationTable      : Quantization table type
+ *  nQuantizationMatrix[64] : JPEG quantization table of coefficients stored 
+ *                            in increasing columns then by rows of data (i.e. 
+ *                            row 1, ... row 8). Quantization values are in 
+ *                            the range 0-255 and stored in linear order
+ *                            (i.e. the component will zig-zag the 
+ *                            quantization table data if required internally) 
+ */
+typedef struct OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGE_QUANTIZATIONTABLETYPE eQuantizationTable;
+    OMX_U8 nQuantizationMatrix[64];
+} OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE;
+
+
+/** 
+ * Huffman table type, the same Huffman table is applied for chroma and 
+ * luma component 
+ */
+typedef enum OMX_IMAGE_HUFFMANTABLETYPE {
+    OMX_IMAGE_HuffmanTableAC = 0,
+    OMX_IMAGE_HuffmanTableDC,
+    OMX_IMAGE_HuffmanTableACLuma,
+    OMX_IMAGE_HuffmanTableACChroma,
+    OMX_IMAGE_HuffmanTableDCLuma,
+    OMX_IMAGE_HuffmanTableDCChroma,
+    OMX_IMAGE_HuffmanTableKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_IMAGE_HuffmanTableVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_HuffmanTableMax = 0x7FFFFFFF
+} OMX_IMAGE_HUFFMANTABLETYPE;
+
+/** 
+ * JPEG Huffman table 
+ *
+ * STRUCT MEMBERS:
+ *  nSize                            : Size of the structure in bytes
+ *  nVersion                         : OMX specification version information
+ *  nPortIndex                       : Port that this structure applies to
+ *  eHuffmanTable                    : Huffman table type
+ *  nNumberOfHuffmanCodeOfLength[16] : 0-16, number of Huffman codes of each 
+ *                                     possible length
+ *  nHuffmanTable[256]               : 0-255, the size used for AC and DC 
+ *                                     HuffmanTable are 16 and 162 
+ */
+typedef struct OMX_IMAGE_PARAM_HUFFMANTTABLETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGE_HUFFMANTABLETYPE eHuffmanTable;
+    OMX_U8 nNumberOfHuffmanCodeOfLength[16];
+    OMX_U8 nHuffmanTable[256];
+}OMX_IMAGE_PARAM_HUFFMANTTABLETYPE;
+
+/** @} */
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/domx/omx_core/inc/OMX_Index.h b/domx/omx_core/inc/OMX_Index.h
new file mode 100755
index 0000000..44d4ea7
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Index.h
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** @file OMX_Index.h - OpenMax IL version 1.1.2
+ *  The OMX_Index header file contains the definitions for both applications
+ *  and components .
+ */
+
+
+#ifndef OMX_Index_h
+#define OMX_Index_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header must include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully 
+ */
+#include <OMX_Types.h>
+
+
+/** The OMX_INDEXTYPE enumeration is used to select a structure when either
+ *  getting or setting parameters and/or configuration data.  Each entry in 
+ *  this enumeration maps to an OMX specified structure.  When the 
+ *  OMX_GetParameter, OMX_SetParameter, OMX_GetConfig or OMX_SetConfig methods
+ *  are used, the second parameter will always be an entry from this enumeration
+ *  and the third entry will be the structure shown in the comments for the entry.
+ *  For example, if the application is initializing a cropping function, the 
+ *  OMX_SetConfig command would have OMX_IndexConfigCommonInputCrop as the second parameter 
+ *  and would send a pointer to an initialized OMX_RECTTYPE structure as the 
+ *  third parameter.
+ *  
+ *  The enumeration entries named with the OMX_Config prefix are sent using
+ *  the OMX_SetConfig command and the enumeration entries named with the
+ *  OMX_PARAM_ prefix are sent using the OMX_SetParameter command.
+ */
+typedef enum OMX_INDEXTYPE {
+
+    OMX_IndexComponentStartUnused = 0x01000000,
+    OMX_IndexParamPriorityMgmt,             /**< reference: OMX_PRIORITYMGMTTYPE */
+    OMX_IndexParamAudioInit,                /**< reference: OMX_PORT_PARAM_TYPE */
+    OMX_IndexParamImageInit,                /**< reference: OMX_PORT_PARAM_TYPE */
+    OMX_IndexParamVideoInit,                /**< reference: OMX_PORT_PARAM_TYPE */
+    OMX_IndexParamOtherInit,                /**< reference: OMX_PORT_PARAM_TYPE */
+    OMX_IndexParamNumAvailableStreams,      /**< reference: OMX_PARAM_U32TYPE */
+    OMX_IndexParamActiveStream,             /**< reference: OMX_PARAM_U32TYPE */
+    OMX_IndexParamSuspensionPolicy,         /**< reference: OMX_PARAM_SUSPENSIONPOLICYTYPE */
+    OMX_IndexParamComponentSuspended,       /**< reference: OMX_PARAM_SUSPENSIONTYPE */
+    OMX_IndexConfigCapturing,               /**< reference: OMX_CONFIG_BOOLEANTYPE */ 
+    OMX_IndexConfigCaptureMode,             /**< reference: OMX_CONFIG_CAPTUREMODETYPE */ 
+    OMX_IndexAutoPauseAfterCapture,         /**< reference: OMX_CONFIG_BOOLEANTYPE */ 
+    OMX_IndexParamContentURI,               /**< reference: OMX_PARAM_CONTENTURITYPE */
+    OMX_IndexParamCustomContentPipe,        /**< reference: OMX_PARAM_CONTENTPIPETYPE */ 
+    OMX_IndexParamDisableResourceConcealment, /**< reference: OMX_RESOURCECONCEALMENTTYPE */
+    OMX_IndexConfigMetadataItemCount,       /**< reference: OMX_CONFIG_METADATAITEMCOUNTTYPE */
+    OMX_IndexConfigContainerNodeCount,      /**< reference: OMX_CONFIG_CONTAINERNODECOUNTTYPE */
+    OMX_IndexConfigMetadataItem,            /**< reference: OMX_CONFIG_METADATAITEMTYPE */
+    OMX_IndexConfigCounterNodeID,           /**< reference: OMX_CONFIG_CONTAINERNODEIDTYPE */
+    OMX_IndexParamMetadataFilterType,       /**< reference: OMX_PARAM_METADATAFILTERTYPE */
+    OMX_IndexParamMetadataKeyFilter,        /**< reference: OMX_PARAM_METADATAFILTERTYPE */
+    OMX_IndexConfigPriorityMgmt,            /**< reference: OMX_PRIORITYMGMTTYPE */
+    OMX_IndexParamStandardComponentRole,    /**< reference: OMX_PARAM_COMPONENTROLETYPE */
+
+    OMX_IndexPortStartUnused = 0x02000000,
+    OMX_IndexParamPortDefinition,           /**< reference: OMX_PARAM_PORTDEFINITIONTYPE */
+    OMX_IndexParamCompBufferSupplier,       /**< reference: OMX_PARAM_BUFFERSUPPLIERTYPE */ 
+    OMX_IndexReservedStartUnused = 0x03000000,
+
+    /* Audio parameters and configurations */
+    OMX_IndexAudioStartUnused = 0x04000000,
+    OMX_IndexParamAudioPortFormat,          /**< reference: OMX_AUDIO_PARAM_PORTFORMATTYPE */
+    OMX_IndexParamAudioPcm,                 /**< reference: OMX_AUDIO_PARAM_PCMMODETYPE */
+    OMX_IndexParamAudioAac,                 /**< reference: OMX_AUDIO_PARAM_AACPROFILETYPE */
+    OMX_IndexParamAudioRa,                  /**< reference: OMX_AUDIO_PARAM_RATYPE */
+    OMX_IndexParamAudioMp3,                 /**< reference: OMX_AUDIO_PARAM_MP3TYPE */
+    OMX_IndexParamAudioAdpcm,               /**< reference: OMX_AUDIO_PARAM_ADPCMTYPE */
+    OMX_IndexParamAudioG723,                /**< reference: OMX_AUDIO_PARAM_G723TYPE */
+    OMX_IndexParamAudioG729,                /**< reference: OMX_AUDIO_PARAM_G729TYPE */
+    OMX_IndexParamAudioAmr,                 /**< reference: OMX_AUDIO_PARAM_AMRTYPE */
+    OMX_IndexParamAudioWma,                 /**< reference: OMX_AUDIO_PARAM_WMATYPE */
+    OMX_IndexParamAudioSbc,                 /**< reference: OMX_AUDIO_PARAM_SBCTYPE */
+    OMX_IndexParamAudioMidi,                /**< reference: OMX_AUDIO_PARAM_MIDITYPE */
+    OMX_IndexParamAudioGsm_FR,              /**< reference: OMX_AUDIO_PARAM_GSMFRTYPE */
+    OMX_IndexParamAudioMidiLoadUserSound,   /**< reference: OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE */
+    OMX_IndexParamAudioG726,                /**< reference: OMX_AUDIO_PARAM_G726TYPE */
+    OMX_IndexParamAudioGsm_EFR,             /**< reference: OMX_AUDIO_PARAM_GSMEFRTYPE */
+    OMX_IndexParamAudioGsm_HR,              /**< reference: OMX_AUDIO_PARAM_GSMHRTYPE */
+    OMX_IndexParamAudioPdc_FR,              /**< reference: OMX_AUDIO_PARAM_PDCFRTYPE */
+    OMX_IndexParamAudioPdc_EFR,             /**< reference: OMX_AUDIO_PARAM_PDCEFRTYPE */
+    OMX_IndexParamAudioPdc_HR,              /**< reference: OMX_AUDIO_PARAM_PDCHRTYPE */
+    OMX_IndexParamAudioTdma_FR,             /**< reference: OMX_AUDIO_PARAM_TDMAFRTYPE */
+    OMX_IndexParamAudioTdma_EFR,            /**< reference: OMX_AUDIO_PARAM_TDMAEFRTYPE */
+    OMX_IndexParamAudioQcelp8,              /**< reference: OMX_AUDIO_PARAM_QCELP8TYPE */
+    OMX_IndexParamAudioQcelp13,             /**< reference: OMX_AUDIO_PARAM_QCELP13TYPE */
+    OMX_IndexParamAudioEvrc,                /**< reference: OMX_AUDIO_PARAM_EVRCTYPE */
+    OMX_IndexParamAudioSmv,                 /**< reference: OMX_AUDIO_PARAM_SMVTYPE */
+    OMX_IndexParamAudioVorbis,              /**< reference: OMX_AUDIO_PARAM_VORBISTYPE */
+
+    OMX_IndexConfigAudioMidiImmediateEvent, /**< reference: OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE */
+    OMX_IndexConfigAudioMidiControl,        /**< reference: OMX_AUDIO_CONFIG_MIDICONTROLTYPE */
+    OMX_IndexConfigAudioMidiSoundBankProgram, /**< reference: OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE */
+    OMX_IndexConfigAudioMidiStatus,         /**< reference: OMX_AUDIO_CONFIG_MIDISTATUSTYPE */
+    OMX_IndexConfigAudioMidiMetaEvent,      /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE */
+    OMX_IndexConfigAudioMidiMetaEventData,  /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTDATATYPE */
+    OMX_IndexConfigAudioVolume,             /**< reference: OMX_AUDIO_CONFIG_VOLUMETYPE */
+    OMX_IndexConfigAudioBalance,            /**< reference: OMX_AUDIO_CONFIG_BALANCETYPE */
+    OMX_IndexConfigAudioChannelMute,        /**< reference: OMX_AUDIO_CONFIG_CHANNELMUTETYPE */
+    OMX_IndexConfigAudioMute,               /**< reference: OMX_AUDIO_CONFIG_MUTETYPE */
+    OMX_IndexConfigAudioLoudness,           /**< reference: OMX_AUDIO_CONFIG_LOUDNESSTYPE */
+    OMX_IndexConfigAudioEchoCancelation,    /**< reference: OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE */
+    OMX_IndexConfigAudioNoiseReduction,     /**< reference: OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE */
+    OMX_IndexConfigAudioBass,               /**< reference: OMX_AUDIO_CONFIG_BASSTYPE */
+    OMX_IndexConfigAudioTreble,             /**< reference: OMX_AUDIO_CONFIG_TREBLETYPE */
+    OMX_IndexConfigAudioStereoWidening,     /**< reference: OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE */
+    OMX_IndexConfigAudioChorus,             /**< reference: OMX_AUDIO_CONFIG_CHORUSTYPE */
+    OMX_IndexConfigAudioEqualizer,          /**< reference: OMX_AUDIO_CONFIG_EQUALIZERTYPE */
+    OMX_IndexConfigAudioReverberation,      /**< reference: OMX_AUDIO_CONFIG_REVERBERATIONTYPE */
+    OMX_IndexConfigAudioChannelVolume,      /**< reference: OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE */
+
+    /* Image specific parameters and configurations */
+    OMX_IndexImageStartUnused = 0x05000000,
+    OMX_IndexParamImagePortFormat,          /**< reference: OMX_IMAGE_PARAM_PORTFORMATTYPE */
+    OMX_IndexParamFlashControl,             /**< reference: OMX_IMAGE_PARAM_FLASHCONTROLTYPE */
+    OMX_IndexConfigFocusControl,            /**< reference: OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE */
+    OMX_IndexParamQFactor,                  /**< reference: OMX_IMAGE_PARAM_QFACTORTYPE */
+    OMX_IndexParamQuantizationTable,        /**< reference: OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE */
+    OMX_IndexParamHuffmanTable,             /**< reference: OMX_IMAGE_PARAM_HUFFMANTTABLETYPE */
+    OMX_IndexConfigFlashControl,            /**< reference: OMX_IMAGE_PARAM_FLASHCONTROLTYPE */
+
+    /* Video specific parameters and configurations */
+    OMX_IndexVideoStartUnused = 0x06000000,
+    OMX_IndexParamVideoPortFormat,          /**< reference: OMX_VIDEO_PARAM_PORTFORMATTYPE */
+    OMX_IndexParamVideoQuantization,        /**< reference: OMX_VIDEO_PARAM_QUANTIZATIONTYPE */
+    OMX_IndexParamVideoFastUpdate,          /**< reference: OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE */
+    OMX_IndexParamVideoBitrate,             /**< reference: OMX_VIDEO_PARAM_BITRATETYPE */
+    OMX_IndexParamVideoMotionVector,        /**< reference: OMX_VIDEO_PARAM_MOTIONVECTORTYPE */
+    OMX_IndexParamVideoIntraRefresh,        /**< reference: OMX_VIDEO_PARAM_INTRAREFRESHTYPE */
+    OMX_IndexParamVideoErrorCorrection,     /**< reference: OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE */
+    OMX_IndexParamVideoVBSMC,               /**< reference: OMX_VIDEO_PARAM_VBSMCTYPE */
+    OMX_IndexParamVideoMpeg2,               /**< reference: OMX_VIDEO_PARAM_MPEG2TYPE */
+    OMX_IndexParamVideoMpeg4,               /**< reference: OMX_VIDEO_PARAM_MPEG4TYPE */
+    OMX_IndexParamVideoWmv,                 /**< reference: OMX_VIDEO_PARAM_WMVTYPE */
+    OMX_IndexParamVideoRv,                  /**< reference: OMX_VIDEO_PARAM_RVTYPE */
+    OMX_IndexParamVideoAvc,                 /**< reference: OMX_VIDEO_PARAM_AVCTYPE */
+    OMX_IndexParamVideoH263,                /**< reference: OMX_VIDEO_PARAM_H263TYPE */
+    OMX_IndexParamVideoProfileLevelQuerySupported, /**< reference: OMX_VIDEO_PARAM_PROFILELEVELTYPE */
+    OMX_IndexParamVideoProfileLevelCurrent, /**< reference: OMX_VIDEO_PARAM_PROFILELEVELTYPE */
+    OMX_IndexConfigVideoBitrate,            /**< reference: OMX_VIDEO_CONFIG_BITRATETYPE */
+    OMX_IndexConfigVideoFramerate,          /**< reference: OMX_CONFIG_FRAMERATETYPE */
+    OMX_IndexConfigVideoIntraVOPRefresh,    /**< reference: OMX_CONFIG_INTRAREFRESHVOPTYPE */
+    OMX_IndexConfigVideoIntraMBRefresh,     /**< reference: OMX_CONFIG_MACROBLOCKERRORMAPTYPE */
+    OMX_IndexConfigVideoMBErrorReporting,   /**< reference: OMX_CONFIG_MBERRORREPORTINGTYPE */
+    OMX_IndexParamVideoMacroblocksPerFrame, /**< reference: OMX_PARAM_MACROBLOCKSTYPE */
+    OMX_IndexConfigVideoMacroBlockErrorMap, /**< reference: OMX_CONFIG_MACROBLOCKERRORMAPTYPE */
+    OMX_IndexParamVideoSliceFMO,            /**< reference: OMX_VIDEO_PARAM_AVCSLICEFMO */
+    OMX_IndexConfigVideoAVCIntraPeriod,     /**< reference: OMX_VIDEO_CONFIG_AVCINTRAPERIOD */
+    OMX_IndexConfigVideoNalSize,            /**< reference: OMX_VIDEO_CONFIG_NALSIZE */
+
+    /* Image & Video common Configurations */
+    OMX_IndexCommonStartUnused = 0x07000000,
+    OMX_IndexParamCommonDeblocking,         /**< reference: OMX_PARAM_DEBLOCKINGTYPE */
+    OMX_IndexParamCommonSensorMode,         /**< reference: OMX_PARAM_SENSORMODETYPE */
+    OMX_IndexParamCommonInterleave,         /**< reference: OMX_PARAM_INTERLEAVETYPE */
+    OMX_IndexConfigCommonColorFormatConversion, /**< reference: OMX_CONFIG_COLORCONVERSIONTYPE */
+    OMX_IndexConfigCommonScale,             /**< reference: OMX_CONFIG_SCALEFACTORTYPE */
+    OMX_IndexConfigCommonImageFilter,       /**< reference: OMX_CONFIG_IMAGEFILTERTYPE */
+    OMX_IndexConfigCommonColorEnhancement,  /**< reference: OMX_CONFIG_COLORENHANCEMENTTYPE */
+    OMX_IndexConfigCommonColorKey,          /**< reference: OMX_CONFIG_COLORKEYTYPE */
+    OMX_IndexConfigCommonColorBlend,        /**< reference: OMX_CONFIG_COLORBLENDTYPE */
+    OMX_IndexConfigCommonFrameStabilisation,/**< reference: OMX_CONFIG_FRAMESTABTYPE */
+    OMX_IndexConfigCommonRotate,            /**< reference: OMX_CONFIG_ROTATIONTYPE */
+    OMX_IndexConfigCommonMirror,            /**< reference: OMX_CONFIG_MIRRORTYPE */
+    OMX_IndexConfigCommonOutputPosition,    /**< reference: OMX_CONFIG_POINTTYPE */
+    OMX_IndexConfigCommonInputCrop,         /**< reference: OMX_CONFIG_RECTTYPE */
+    OMX_IndexConfigCommonOutputCrop,        /**< reference: OMX_CONFIG_RECTTYPE */
+    OMX_IndexConfigCommonDigitalZoom,       /**< reference: OMX_CONFIG_SCALEFACTORTYPE */
+    OMX_IndexConfigCommonOpticalZoom,       /**< reference: OMX_CONFIG_SCALEFACTORTYPE*/
+    OMX_IndexConfigCommonWhiteBalance,      /**< reference: OMX_CONFIG_WHITEBALCONTROLTYPE */
+    OMX_IndexConfigCommonExposure,          /**< reference: OMX_CONFIG_EXPOSURECONTROLTYPE */
+    OMX_IndexConfigCommonContrast,          /**< reference: OMX_CONFIG_CONTRASTTYPE */
+    OMX_IndexConfigCommonBrightness,        /**< reference: OMX_CONFIG_BRIGHTNESSTYPE */
+    OMX_IndexConfigCommonBacklight,         /**< reference: OMX_CONFIG_BACKLIGHTTYPE */
+    OMX_IndexConfigCommonGamma,             /**< reference: OMX_CONFIG_GAMMATYPE */
+    OMX_IndexConfigCommonSaturation,        /**< reference: OMX_CONFIG_SATURATIONTYPE */
+    OMX_IndexConfigCommonLightness,         /**< reference: OMX_CONFIG_LIGHTNESSTYPE */
+    OMX_IndexConfigCommonExclusionRect,     /**< reference: OMX_CONFIG_RECTTYPE */
+    OMX_IndexConfigCommonDithering,         /**< reference: OMX_CONFIG_DITHERTYPE */
+    OMX_IndexConfigCommonPlaneBlend,        /**< reference: OMX_CONFIG_PLANEBLENDTYPE */
+    OMX_IndexConfigCommonExposureValue,     /**< reference: OMX_CONFIG_EXPOSUREVALUETYPE */
+    OMX_IndexConfigCommonOutputSize,        /**< reference: OMX_FRAMESIZETYPE */
+    OMX_IndexParamCommonExtraQuantData,     /**< reference: OMX_OTHER_EXTRADATATYPE */
+    OMX_IndexConfigCommonFocusRegion,       /**< reference: OMX_CONFIG_FOCUSREGIONTYPE */
+    OMX_IndexConfigCommonFocusStatus,       /**< reference: OMX_PARAM_FOCUSSTATUSTYPE */
+    OMX_IndexConfigCommonTransitionEffect,  /**< reference: OMX_CONFIG_TRANSITIONEFFECTTYPE */
+
+    /* Reserved Configuration range */
+    OMX_IndexOtherStartUnused = 0x08000000,
+    OMX_IndexParamOtherPortFormat,          /**< reference: OMX_OTHER_PARAM_PORTFORMATTYPE */
+    OMX_IndexConfigOtherPower,              /**< reference: OMX_OTHER_CONFIG_POWERTYPE */
+    OMX_IndexConfigOtherStats,              /**< reference: OMX_OTHER_CONFIG_STATSTYPE */
+
+
+    /* Reserved Time range */
+    OMX_IndexTimeStartUnused = 0x09000000,
+    OMX_IndexConfigTimeScale,               /**< reference: OMX_TIME_CONFIG_SCALETYPE */
+    OMX_IndexConfigTimeClockState,          /**< reference: OMX_TIME_CONFIG_CLOCKSTATETYPE */
+    OMX_IndexConfigTimeActiveRefClock,      /**< reference: OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE */
+    OMX_IndexConfigTimeCurrentMediaTime,    /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only) */
+    OMX_IndexConfigTimeCurrentWallTime,     /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only) */
+    OMX_IndexConfigTimeCurrentAudioReference, /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
+    OMX_IndexConfigTimeCurrentVideoReference, /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
+    OMX_IndexConfigTimeMediaTimeRequest,    /**< reference: OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE (write only) */
+    OMX_IndexConfigTimeClientStartTime,     /**<reference:  OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
+    OMX_IndexConfigTimePosition,            /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE */
+    OMX_IndexConfigTimeSeekMode,            /**< reference: OMX_TIME_CONFIG_SEEKMODETYPE */
+
+
+    OMX_IndexKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    /* Vendor specific area */
+    OMX_IndexVendorStartUnused = 0x7F000000,
+    /* Vendor specific structures should be in the range of 0x7F000000 
+       to 0x7FFFFFFE.  This range is not broken out by vendor, so
+       private indexes are not guaranteed unique and therefore should
+       only be sent to the appropriate component. */
+
+    OMX_IndexMax = 0x7FFFFFFF
+
+} OMX_INDEXTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/domx/omx_core/inc/OMX_IndexExt.h b/domx/omx_core/inc/OMX_IndexExt.h
new file mode 100755
index 0000000..733c3eb
--- /dev/null
+++ b/domx/omx_core/inc/OMX_IndexExt.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/** @file OMX_IndexExt.h - OpenMax IL version 1.1.2
+ * The OMX_IndexExt header file contains extensions to the definitions
+ * for both applications and components .
+ */
+
+#ifndef OMX_IndexExt_h
+#define OMX_IndexExt_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Each OMX header shall include all required header files to allow the
+ * header to compile without errors.  The includes below are required
+ * for this header file to compile successfully
+ */
+#include <OMX_Index.h>
+
+
+/** Khronos standard extension indices.
+
+This enum lists the current Khronos extension indices to OpenMAX IL.
+*/
+typedef enum OMX_INDEXEXTTYPE {
+
+    /* Component parameters and configurations */
+    OMX_IndexExtComponentStartUnused = OMX_IndexKhronosExtensions + 0x00100000,
+    OMX_IndexConfigCallbackRequest,                 /**< reference: OMX_CONFIG_CALLBACKREQUESTTYPE */
+    OMX_IndexConfigCommitMode,                      /**< reference: OMX_CONFIG_COMMITMODETYPE */
+    OMX_IndexConfigCommit,                          /**< reference: OMX_CONFIG_COMMITTYPE */
+
+    /* Port parameters and configurations */
+    OMX_IndexExtPortStartUnused = OMX_IndexKhronosExtensions + 0x00200000,
+
+    /* Audio parameters and configurations */
+    OMX_IndexExtAudioStartUnused = OMX_IndexKhronosExtensions + 0x00400000,
+
+    /* Image parameters and configurations */
+    OMX_IndexExtImageStartUnused = OMX_IndexKhronosExtensions + 0x00500000,
+
+    /* Video parameters and configurations */
+    OMX_IndexExtVideoStartUnused = OMX_IndexKhronosExtensions + 0x00600000,
+    OMX_IndexParamNalStreamFormatSupported,         /**< reference: OMX_NALSTREAMFORMATTYPE */
+    OMX_IndexParamNalStreamFormat,                  /**< reference: OMX_NALSTREAMFORMATTYPE */
+    OMX_IndexParamNalStreamFormatSelect,            /**< reference: OMX_NALSTREAMFORMATTYPE */
+
+    /* Image & Video common configurations */
+    OMX_IndexExtCommonStartUnused = OMX_IndexKhronosExtensions + 0x00700000,
+
+    /* Other configurations */
+    OMX_IndexExtOtherStartUnused = OMX_IndexKhronosExtensions + 0x00800000,
+
+    /* Time configurations */
+    OMX_IndexExtTimeStartUnused = OMX_IndexKhronosExtensions + 0x00900000,
+
+    OMX_IndexExtMax = 0x7FFFFFFF
+} OMX_INDEXEXTTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* OMX_IndexExt_h */
+/* File EOF */
diff --git a/domx/omx_core/inc/OMX_Other.h b/domx/omx_core/inc/OMX_Other.h
new file mode 100755
index 0000000..2cce9f8
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Other.h
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/** @file OMX_Other.h - OpenMax IL version 1.1.2
+ *  The structures needed by Other components to exchange
+ *  parameters and configuration data with the components.
+ */
+
+#ifndef OMX_Other_h
+#define OMX_Other_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Each OMX header must include all required header files to allow the
+ *  header to compile without errors.  The includes below are required
+ *  for this header file to compile successfully
+ */
+
+#include <OMX_Core.h>
+
+
+/**
+ * Enumeration of possible data types which match to multiple domains or no
+ * domain at all.  For types which are vendor specific, a value above
+ * OMX_OTHER_VENDORTSTART should be used.
+ */
+typedef enum OMX_OTHER_FORMATTYPE {
+    OMX_OTHER_FormatTime = 0, /**< Transmission of various timestamps, elapsed time,
+                                   time deltas, etc */
+    OMX_OTHER_FormatPower,    /**< Perhaps used for enabling/disabling power
+                                   management, setting clocks? */
+    OMX_OTHER_FormatStats,    /**< Could be things such as frame rate, frames
+                                   dropped, etc */
+    OMX_OTHER_FormatBinary,   /**< Arbitrary binary data */
+    OMX_OTHER_FormatVendorReserved = 1000, /**< Starting value for vendor specific
+                                                formats */
+
+    OMX_OTHER_FormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
+    OMX_OTHER_FormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_OTHER_FormatMax = 0x7FFFFFFF
+} OMX_OTHER_FORMATTYPE;
+
+/**
+ * Enumeration of seek modes.
+ */
+typedef enum OMX_TIME_SEEKMODETYPE {
+    OMX_TIME_SeekModeFast = 0, /**< Prefer seeking to an approximation
+                                * of the requested seek position over
+                                * the actual seek position if it
+                                * results in a faster seek. */
+    OMX_TIME_SeekModeAccurate, /**< Prefer seeking to the actual seek
+                                * position over an approximation
+                                * of the requested seek position even
+                                * if it results in a slower seek. */
+    OMX_TIME_SeekModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
+    OMX_TIME_SeekModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_TIME_SeekModeMax = 0x7FFFFFFF
+} OMX_TIME_SEEKMODETYPE;
+
+/* Structure representing the seekmode of the component */
+typedef struct OMX_TIME_CONFIG_SEEKMODETYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_TIME_SEEKMODETYPE eType;    /**< The seek mode */
+} OMX_TIME_CONFIG_SEEKMODETYPE;
+
+/** Structure representing a time stamp used with the following configs
+ * on the Clock Component (CC):
+ *
+ * OMX_IndexConfigTimeCurrentWallTime: query of the CC's current wall
+ *     time
+ * OMX_IndexConfigTimeCurrentMediaTime: query of the CC's current media
+ *     time
+ * OMX_IndexConfigTimeCurrentAudioReference and
+ * OMX_IndexConfigTimeCurrentVideoReference: audio/video reference
+ *     clock sending SC its reference time
+ * OMX_IndexConfigTimeClientStartTime: a Clock Component client sends
+ *     this structure to the Clock Component via a SetConfig on its
+ *     client port when it receives a buffer with
+ *     OMX_BUFFERFLAG_STARTTIME set. It must use the timestamp
+ *     specified by that buffer for nStartTimestamp.
+ *
+ * It's also used with the following config on components in general:
+ *
+ * OMX_IndexConfigTimePosition: IL client querying component position
+ * (GetConfig) or commanding a component to seek to the given location
+ * (SetConfig)
+ */
+typedef struct OMX_TIME_CONFIG_TIMESTAMPTYPE {
+    OMX_U32 nSize;               /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;    /**< OMX specification version
+                                  *   information */
+    OMX_U32 nPortIndex;     /**< port that this structure applies to */
+    OMX_TICKS nTimestamp;  	     /**< timestamp .*/
+} OMX_TIME_CONFIG_TIMESTAMPTYPE;
+
+/** Enumeration of possible reference clocks to the media time. */
+typedef enum OMX_TIME_UPDATETYPE {
+      OMX_TIME_UpdateRequestFulfillment,    /**< Update is the fulfillment of a media time request. */
+      OMX_TIME_UpdateScaleChanged,	        /**< Update was generated because the scale chagned. */
+      OMX_TIME_UpdateClockStateChanged,     /**< Update was generated because the clock state changed. */
+      OMX_TIME_UpdateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
+      OMX_TIME_UpdateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+      OMX_TIME_UpdateMax = 0x7FFFFFFF
+} OMX_TIME_UPDATETYPE;
+
+/** Enumeration of possible reference clocks to the media time. */
+typedef enum OMX_TIME_REFCLOCKTYPE {
+      OMX_TIME_RefClockNone,    /**< Use no references. */
+      OMX_TIME_RefClockAudio,	/**< Use references sent through OMX_IndexConfigTimeCurrentAudioReference */
+      OMX_TIME_RefClockVideo,   /**< Use references sent through OMX_IndexConfigTimeCurrentVideoReference */
+      OMX_TIME_RefClockKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
+      OMX_TIME_RefClockVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+      OMX_TIME_RefClockMax = 0x7FFFFFFF
+} OMX_TIME_REFCLOCKTYPE;
+
+/** Enumeration of clock states. */
+typedef enum OMX_TIME_CLOCKSTATE {
+      OMX_TIME_ClockStateRunning,             /**< Clock running. */
+      OMX_TIME_ClockStateWaitingForStartTime, /**< Clock waiting until the
+                                               *   prescribed clients emit their
+                                               *   start time. */
+      OMX_TIME_ClockStateStopped,             /**< Clock stopped. */
+      OMX_TIME_ClockStateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
+      OMX_TIME_ClockStateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+      OMX_TIME_ClockStateMax = 0x7FFFFFFF
+} OMX_TIME_CLOCKSTATE;
+
+/** Structure representing a media time request to the clock component.
+ *
+ *  A client component sends this structure to the Clock Component via a SetConfig
+ *  on its client port to specify a media timestamp the Clock Component
+ *  should emit.  The Clock Component should fulfill the request by sending a
+ *  OMX_TIME_MEDIATIMETYPE when its media clock matches the requested
+ *  timestamp.
+ *
+ *  The client may require a media time request be fulfilled slightly
+ *  earlier than the media time specified. In this case the client specifies
+ *  an offset which is equal to the difference between wall time corresponding
+ *  to the requested media time and the wall time when it will be
+ *  fulfilled.
+ *
+ *  A client component may uses these requests and the OMX_TIME_MEDIATIMETYPE to
+ *  time events according to timestamps. If a client must perform an operation O at
+ *  a time T (e.g. deliver a video frame at its corresponding timestamp), it makes a
+ *  media time request at T (perhaps specifying an offset to ensure the request fulfillment
+ *  is a little early). When the clock component passes the resulting OMX_TIME_MEDIATIMETYPE
+ *  structure back to the client component, the client may perform operation O (perhaps having
+ *  to wait a slight amount more time itself as specified by the return values).
+ */
+
+typedef struct OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
+    OMX_U32 nPortIndex;         /**< port that this structure applies to */
+    OMX_PTR pClientPrivate;     /**< Client private data to disabiguate this media time
+                                 *   from others (e.g. the number of the frame to deliver).
+                                 *   Duplicated in the media time structure that fulfills
+                                 *   this request. A value of zero is reserved for time scale
+                                 *   updates. */
+    OMX_TICKS nMediaTimestamp;  /**< Media timestamp requested.*/
+    OMX_TICKS nOffset;          /**< Amount of wall clock time by which this
+                                 *   request should be fulfilled early */
+} OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE;
+
+/**< Structure sent from the clock component client either when fulfilling
+ *   a media time request or when the time scale has changed.
+ *
+ *   In the former case the Clock Component fills this structure and times its emission
+ *   to a client component (via the client port) according to the corresponding media
+ *   time request sent by the client. The Clock Component should time the emission to occur
+ *   when the requested timestamp matches the Clock Component's media time but also the
+ *   prescribed offset early.
+ *
+ *   Upon scale changes the clock component clears the nClientPrivate data, sends the current
+ *   media time and sets the nScale to the new scale via the client port. It emits a
+ *   OMX_TIME_MEDIATIMETYPE to all clients independent of any requests. This allows clients to
+ *   alter processing to accomodate scaling. For instance a video component might skip inter-frames
+ *   in the case of extreme fastforward. Likewise an audio component might add or remove samples
+ *   from an audio frame to scale audio data.
+ *
+ *   It is expected that some clock components may not be able to fulfill requests
+ *   at exactly the prescribed time. This is acceptable so long as the request is
+ *   fulfilled at least as early as described and not later. This structure provides
+ *   fields the client may use to wait for the remaining time.
+ *
+ *   The client may use either the nOffset or nWallTimeAtMedia fields to determine the
+ *   wall time until the nMediaTimestamp actually occurs. In the latter case the
+ *   client can get a more accurate value for offset by getting the current wall
+ *   from the cloc component and subtracting it from nWallTimeAtMedia.
+ */
+
+typedef struct OMX_TIME_MEDIATIMETYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_U32 nClientPrivate;         /**< Client private data to disabiguate this media time
+                                     *   from others. Copied from the media time request.
+                                     *   A value of zero is reserved for time scale updates. */
+    OMX_TIME_UPDATETYPE eUpdateType; /**< Reason for the update */
+    OMX_TICKS nMediaTimestamp;      /**< Media time requested. If no media time was
+                                     *   requested then this is the current media time. */
+    OMX_TICKS nOffset;              /**< Amount of wall clock time by which this
+                                     *   request was actually fulfilled early */
+
+    OMX_TICKS nWallTimeAtMediaTime; /**< Wall time corresponding to nMediaTimeStamp.
+                                     *   A client may compare this value to current
+                                     *   media time obtained from the Clock Component to determine
+                                     *   the wall time until the media timestamp is really
+                                     *   current. */
+    OMX_S32 xScale;                 /**< Current media time scale in Q16 format. */
+    OMX_TIME_CLOCKSTATE eState;     /* Seeking Change. Added 7/12.*/
+                                    /**< State of the media time. */
+} OMX_TIME_MEDIATIMETYPE;
+
+/** Structure representing the current media time scale factor. Applicable only to clock
+ *  component, other components see scale changes via OMX_TIME_MEDIATIMETYPE buffers sent via
+ *  the clock component client ports. Upon recieving this config the clock component changes
+ *  the rate by which the media time increases or decreases effectively implementing trick modes.
+ */
+typedef struct OMX_TIME_CONFIG_SCALETYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_S32 xScale;                 /**< This is a value in Q16 format which is used for
+                                     * scaling the media time */
+} OMX_TIME_CONFIG_SCALETYPE;
+
+/** Bits used to identify a clock port. Used in OMX_TIME_CONFIG_CLOCKSTATETYPE's nWaitMask field */
+#define OMX_CLOCKPORT0 0x00000001
+#define OMX_CLOCKPORT1 0x00000002
+#define OMX_CLOCKPORT2 0x00000004
+#define OMX_CLOCKPORT3 0x00000008
+#define OMX_CLOCKPORT4 0x00000010
+#define OMX_CLOCKPORT5 0x00000020
+#define OMX_CLOCKPORT6 0x00000040
+#define OMX_CLOCKPORT7 0x00000080
+
+/** Structure representing the current mode of the media clock.
+ *  IL Client uses this config to change or query the mode of the
+ *  media clock of the clock component. Applicable only to clock
+ *  component.
+ *
+ *  On a SetConfig if eState is OMX_TIME_ClockStateRunning media time
+ *  starts immediately at the prescribed start time. If
+ *  OMX_TIME_ClockStateWaitingForStartTime the Clock Component ignores
+ *  the given nStartTime and waits for all clients specified in the
+ *  nWaitMask to send starttimes (via
+ *  OMX_IndexConfigTimeClientStartTime). The Clock Component then starts
+ *  the media clock using the earliest start time supplied. */
+typedef struct OMX_TIME_CONFIG_CLOCKSTATETYPE {
+    OMX_U32 nSize;              /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;   /**< OMX specification version
+                                 *   information */
+    OMX_TIME_CLOCKSTATE eState; /**< State of the media time. */
+    OMX_TICKS nStartTime;       /**< Start time of the media time. */
+    OMX_TICKS nOffset;          /**< Time to offset the media time by
+                                 * (e.g. preroll). Media time will be
+                                 * reported to be nOffset ticks earlier.
+                                 */
+    OMX_U32 nWaitMask;          /**< Mask of OMX_CLOCKPORT values. */
+} OMX_TIME_CONFIG_CLOCKSTATETYPE;
+
+/** Structure representing the reference clock currently being used to
+ *  compute media time. IL client uses this config to change or query the
+ *  clock component's active reference clock */
+typedef struct OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE {
+    OMX_U32 nSize;                  /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
+    OMX_TIME_REFCLOCKTYPE eClock;   /**< Reference clock used to compute media time */
+} OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE;
+
+/** Descriptor for setting specifics of power type.
+ *  Note: this structure is listed for backwards compatibility. */
+typedef struct OMX_OTHER_CONFIG_POWERTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_BOOL bEnablePM;       /**< Flag to enable Power Management */
+} OMX_OTHER_CONFIG_POWERTYPE;
+
+
+/** Descriptor for setting specifics of stats type.
+ *  Note: this structure is listed for backwards compatibility. */
+typedef struct OMX_OTHER_CONFIG_STATSTYPE {
+    OMX_U32 nSize;            /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    /* what goes here */
+} OMX_OTHER_CONFIG_STATSTYPE;
+
+
+/**
+ * The PortDefinition structure is used to define all of the parameters
+ * necessary for the compliant component to setup an input or an output other
+ * path.
+ */
+typedef struct OMX_OTHER_PORTDEFINITIONTYPE {
+    OMX_OTHER_FORMATTYPE eFormat;  /**< Type of data expected for this channel */
+} OMX_OTHER_PORTDEFINITIONTYPE;
+
+/**  Port format parameter.  This structure is used to enumerate
+  *  the various data input/output format supported by the port.
+  */
+typedef struct OMX_OTHER_PARAM_PORTFORMATTYPE {
+    OMX_U32 nSize; /**< size of the structure in bytes */
+    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+    OMX_U32 nPortIndex; /**< Indicates which port to set */
+    OMX_U32 nIndex; /**< Indicates the enumeration index for the format from 0x0 to N-1 */
+    OMX_OTHER_FORMATTYPE eFormat; /**< Type of data expected for this channel */
+} OMX_OTHER_PARAM_PORTFORMATTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/domx/omx_core/inc/OMX_TI_Common.h b/domx/omx_core/inc/OMX_TI_Common.h
new file mode 100755
index 0000000..457adb6
--- /dev/null
+++ b/domx/omx_core/inc/OMX_TI_Common.h
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_ti_common.h
+ *
+ *
+ *  @path \OMAPSW_SysDev\multimedia\omx\khronos1_1\omx_core\inc
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 20-Dec-2008 x0052661@ti.com, initial version
+ *================================================================*/
+
+#ifndef _OMX_TI_COMMON_H_
+#define _OMX_TI_COMMON_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <OMX_Core.h>
+
+/*******************************************************************
+ * EXTERNAL REFERENCE NOTE: only use if not found in header file
+ *******************************************************************/
+/*----------         function prototypes      ------------------- */
+/*----------         data declarations        ------------------- */
+/*******************************************************************
+ * PUBLIC DECLARATIONS: defined here, used elsewhere
+ *******************************************************************/
+/*----------         function prototypes      ------------------- */
+/*----------         data declarations        ------------------- */
+#define OMX_BUFFERHEADERFLAG_MODIFIED 0x00000100
+
+#define OMX_TI_BUFFERFLAG_READONLY 0x00000200
+
+/* TI extra data will be passed in the platform private structure rather than
+ * appended at the end of the buffer. Adding a new custom flag to indicate
+ * this.*/
+#define OMX_TI_BUFFERFLAG_DETACHEDEXTRADATA 0x00000400
+
+typedef struct OMX_CONFIG_CHANNELNAME {
+
+	OMX_U32 nSize; /**< Size of the structure in bytes */
+	OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
+	OMX_U32 nPortIndex; /**< Index of the port */
+	OMX_STRING cChannelName; /**< Channel name  */
+
+} OMX_CONFIG_CHANNELNAME;
+
+typedef struct OMX_TI_PLATFORMPRIVATE
+{
+	OMX_U32 nSize;
+	OMX_PTR pExtendedPlatformPrivate;
+	OMX_BOOL bReadViaCPU;
+	OMX_BOOL bWriteViaCPU;
+	OMX_PTR pMetaDataBuffer;
+	OMX_U32 nMetaDataSize;
+	OMX_PTR pAuxBuf1;
+	OMX_U32 pAuxBufSize1;
+}OMX_TI_PLATFORMPRIVATE;
+
+/*===============================================================*/
+/** OMX_TI_PARAM_BUFFERPREANNOUNCE    : This parameter is used to enable/disable
+ *                                      buffer pre announcement. Buffer pre
+ *                                      announcement is enabled by default i.e.
+ *                                      if buffer is being allocated by client
+ *                                      then the buffer ptrs will be made known
+ *                                      to the component at the time of
+ *                                      UseBuffer and these will not change in
+ *                                      lifetime of the component. If pre
+ *                                      announcement is disabled then new
+ *                                      buffers can be allocated by the client
+ *                                      at runtime and passed in ETB/FTB. This
+ *                                      parameter is valid only in cases where
+ *                                      client allocates the buffer
+ *                                      (i.e. UseBuffer cases).
+ *
+ *  @ param nSize                     : Size of the structure.
+ *  @ param nVersion                  : Version.
+ *  @ param nPortIndex                : Port index on which the parameter will
+ *                                      be applied.
+ *  @ param bEnabled                  : Whether buffer pre announcement is
+ *                                      enabled or not. Set to TRUE (enabled)
+ *                                      by default.
+ */
+/*===============================================================*/
+typedef struct OMX_TI_PARAM_BUFFERPREANNOUNCE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnabled;
+}OMX_TI_PARAM_BUFFERPREANNOUNCE;
+
+
+
+/*===============================================================*/
+/** OMX_TI_CONFIG_BUFFERREFCOUNTNOTIFYTYPE : This config is used to
+ *                                           enable/disable notification when
+ *                                           reference count of a buffer changes
+ *                                           This happens usually when buffers
+ *                                           are locked/unlocked by codecs. By
+ *                                           DEFAULT all notifications are
+ *                                           DISABLED.
+ *
+ *  @ param nSize                          : Size of the structure.
+ *  @ param nVersion                       : Version.
+ *  @ param nPortIndex                     : Port index on which the config will
+ *                                           be applied.
+ *  @param bNotifyOnIncrease              : Enable notification when reference
+ *                                           count is increased.
+ *  @ param bNotifyOnDecrease              : Enable notification when reference
+ *                                           count is decreased.
+ *  @ param nCountForNotification          : Count at which to trigger
+ *                                           notification. Count indicates no.
+ *                                           of copies of the buffer in
+ *                                           circulation e.g.
+ *                                           1 - Only the original buffer is in
+ *                                               circulation i.e. no buffers are
+ *                                               currently locked.
+ *                                           2 - There are two copies of the
+ *                                               buffer i.e. one original and
+ *                                               one copy which has been locked
+ *                                               by the codec.
+ *                                           And so on
+ *                                           SPECIAL CASE
+ *                                           0 - Indicates notify always
+ *                                               irrespective of count value.
+ */
+/*===============================================================*/
+typedef struct OMX_TI_CONFIG_BUFFERREFCOUNTNOTIFYTYPE
+{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bNotifyOnIncrease;
+    OMX_BOOL bNotifyOnDecrease;
+    OMX_U32 nCountForNotification;
+}OMX_TI_CONFIG_BUFFERREFCOUNTNOTIFYTYPE;
+
+
+
+
+
+/* OMX_TI_SEVERITYTYPE enumeration is used to indicate severity level of errors returned by TI OpenMax components.
+   Critcal      Requires reboot/reset DSP
+   Severe       Have to unload components and free memory and try again
+   Major        Can be handled without unloading the component
+   Minor        Essentially informational
+*/
+typedef enum OMX_TI_SEVERITYTYPE {
+    OMX_TI_ErrorCritical=1,
+    OMX_TI_ErrorSevere,
+    OMX_TI_ErrorMajor,
+    OMX_TI_ErrorMinor
+} OMX_TI_SEVERITYTYPE;
+
+/* ============================================================================= */
+/*
+@brief OMX_TI_PARAM_METADATABUFFERINFO : Structure to access metadata buffer info needed
+         by proxy to allocate metadat buffers.
+
+*/
+/* ============================================================================= */
+typedef struct OMX_TI_PARAM_METADATABUFFERINFO {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bIsMetaDataEnabledOnPort;
+    OMX_U32 nMetaDataSize;
+} OMX_TI_PARAM_METADATABUFFERINFO;
+
+/*******************************************************************
+ * PRIVATE DECLARATIONS: defined here, used only here
+ *******************************************************************/
+/*----------          data declarations        ------------------- */
+/*----------          function prototypes      ------------------- */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _OMX_TI_COMMON_H_ */
diff --git a/domx/omx_core/inc/OMX_TI_Core.h b/domx/omx_core/inc/OMX_TI_Core.h
new file mode 100755
index 0000000..eb4993e
--- /dev/null
+++ b/domx/omx_core/inc/OMX_TI_Core.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  @file  omx_ti_core.h
+ *         This file contains the vendor(TI) specific core extensions
+ *
+ *  @path domx/system/omx_core/inc
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 19-Jul-2010 admonga@ti.com : Initial version
+ *================================================================*/
+
+#ifndef _OMX_TI_CORE_H_
+#define _OMX_TI_CORE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/******************************************************************
+    INCLUDE FILES
+ ******************************************************************/
+#include <OMX_Types.h>
+#include <OMX_Core.h>
+
+/*******************************************************************
+ * EXTERNAL REFERENCE NOTE: only use if not found in header file
+ *******************************************************************/
+/*----------         function prototypes      ------------------- */
+/*----------         data declarations        ------------------- */
+/*******************************************************************
+ * PUBLIC DECLARATIONS: defined here, used elsewhere
+ *******************************************************************/
+/*----------         function prototypes      ------------------- */
+/*----------         data declarations        ------------------- */
+
+
+
+typedef enum OMX_TI_ERRORTYPE
+{
+    /* Vendor specific area for storing TI custom extended events */
+
+    /*Control attribute is pending - Dio_Dequeue will not work until attribute
+      is retreived*/
+    OMX_TI_WarningAttributePending = (OMX_S32)((OMX_ERRORTYPE)OMX_ErrorVendorStartUnused + 1),
+    /*Attribute buffer size is insufficient - reallocate the attribute buffer*/
+    OMX_TI_WarningInsufficientAttributeSize,
+    /*EOS buffer has been received*/
+    OMX_TI_WarningEosReceived,
+    /*Port enable is called on an already enabled port*/
+    OMX_TI_ErrorPortIsAlreadyEnabled,
+    /*Port disable is called on an already disabled port*/
+    OMX_TI_ErrorPortIsAlreadyDisabled
+} OMX_TI_ERRORTYPE;
+
+
+
+typedef enum OMX_TI_EVENTTYPE
+{
+    /* Vendor specific area for storing indices */
+    /*Reference count for the buffer has changed. In the callback, nData1 will
+      pBufferHeader, nData2 will be present count*/
+    OMX_TI_EventBufferRefCount = (OMX_S32)((OMX_EVENTTYPE)OMX_EventVendorStartUnused + 1)
+}OMX_TI_EVENTTYPE;
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _OMX_TI_INDEX_H_ */
+
diff --git a/domx/omx_core/inc/OMX_TI_IVCommon.h b/domx/omx_core/inc/OMX_TI_IVCommon.h
new file mode 100755
index 0000000..7cb098b
--- /dev/null
+++ b/domx/omx_core/inc/OMX_TI_IVCommon.h
@@ -0,0 +1,2593 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* -------------------------------------------------------------------------- *
+ *
+ * @file:OMX_TI_IVCommon.h
+ * This header defines the structures specific to the config indices of msp_VPPM.
+ *
+ * @path ..\OMAPSW_SysDev\multimedia\omx\khronos1_1\omx_core\inc
+ *
+ * -------------------------------------------------------------------------- */
+
+/* ======================================================================== *!
+ *! Revision History
+ *! ==================================================================== */
+
+#ifndef OMX_TI_IVCommon_H
+#define OMX_TI_IVCommon_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <OMX_IVCommon.h>
+#include <OMX_Image.h>
+
+
+#define MAX_URI_LENGTH      (OMX_MAX_STRINGNAME_SIZE)
+
+/*======================================================================= */
+/* Enumerated values for operation mode for compressed image
+ *
+ * ENUMS:
+ * Chunk         : Chunk based operation
+ * NonChunk    : Non-chunk based operation
+ */
+ /* ======================================================================= */
+typedef enum OMX_JPEG_COMPRESSEDMODETYPE {
+    OMX_JPEG_ModeChunk = 0,
+    OMX_JPEG_ModeNonChunk
+}OMX_JPEG_COMPRESSEDMODETYPE ;
+
+
+/*======================================================================= */
+/* Enumerated values for operation mode for uncompressed image
+ *
+ * ENUMS:
+ * Frame   :  Frame based operation
+ * Slice   : Slice based operation
+ * Stitch  : For stitching between image frames
+ * Burst   :  For stitching between image frames
+ */
+ /* ======================================================================= */
+typedef enum OMX_JPEG_UNCOMPRESSEDMODETYPE {
+    OMX_JPEG_UncompressedModeFrame = 0,
+    OMX_JPEG_UncompressedModeSlice,
+    OMX_JPEG_UncompressedModeStitch,
+    OMX_JPEG_UncompressedModeBurst
+}OMX_JPEG_UNCOMPRESSEDMODETYPE;
+
+
+
+/*======================================================================= */
+/* Configuration structure for compressed image
+ *
+ * STRUCT MEMBERS:
+ *  nSize                 : Size of the structure in bytes
+ *  nVersion              : OMX specification version information
+ *  nPortIndex            : Port that this structure applies to
+ *  eCompressedImageMode  : Operating mode enumeration for compressed image
+ */
+ /*======================================================================= */
+typedef struct OMX_JPEG_PARAM_COMPRESSEDMODETYPE{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_JPEG_COMPRESSEDMODETYPE eCompressedImageMode;
+}OMX_JPEG_PARAM_COMPRESSEDMODETYPE;
+
+
+
+/*======================================================================= */
+/* Uncompressed image Operating mode configuration structure
+ *
+ * STRUCT MEMBERS:
+ * nSize                     : Size of the structure in bytes
+ * nVersion                  : OMX specification version information
+ * nPortIndex                : Port that this structure applies to
+ * nBurstLength              : No of frames to be dumped in burst mode
+ * eUncompressedImageMode    : uncompressed image mode information
+ * eSourceType               : Image encode souce info
+ * tRotationInfo             : Rotation related information
+ */
+ /*======================================================================= */
+typedef struct OMX_JPEG_PARAM_UNCOMPRESSEDMODETYPE{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nBurstLength;
+    OMX_JPEG_UNCOMPRESSEDMODETYPE eUncompressedImageMode;
+}OMX_JPEG_PARAM_UNCOMPRESSEDMODETYPE;
+
+
+/*======================================================================= */
+/* Subregion Decode Parameter configuration structure
+ *
+ * STRUCT MEMBERS:
+ * nSize                     : Size of the structure in bytes
+ * nVersion                  : OMX specification version information
+ * nXOrg                     : Sectional decoding X origin
+ * nYOrg                     : Sectional decoding Y origin
+ * nXLength                  : Sectional decoding X length
+ * nYLength                  : Sectional decoding Y length
+ */
+ /*======================================================================= */
+typedef struct OMX_IMAGE_PARAM_DECODE_SUBREGION{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nXOrg;
+    OMX_U32 nYOrg;
+    OMX_U32 nXLength;
+    OMX_U32 nYLength;
+}OMX_IMAGE_PARAM_DECODE_SUBREGION;
+
+
+/**
+ * sensor select  types
+ */
+typedef enum OMX_SENSORSELECT{
+        OMX_PrimarySensor = 0,
+        OMX_SecondarySensor,
+        OMX_TI_StereoSensor,
+        OMX_SensorTypeMax = 0x7fffffff
+}OMX_SENSORSELECT;
+
+/**
+ *
+ * Sensor Select
+ */
+typedef  struct OMX_CONFIG_SENSORSELECTTYPE {
+OMX_U32  nSize; /**< Size of the structure in bytes */
+OMX_VERSIONTYPE nVersion; /**< OMX specification version info */
+OMX_U32 nPortIndex; /**< Port that this struct applies to */
+OMX_SENSORSELECT eSensor; /**< sensor select */
+} OMX_CONFIG_SENSORSELECTTYPE;
+
+/**
+ * Flicker cancellation types
+ */
+typedef enum OMX_COMMONFLICKERCANCELTYPE{
+        OMX_FlickerCancelOff = 0,
+        OMX_FlickerCancelAuto,
+        OMX_FlickerCancel50,
+        OMX_FlickerCancel60,
+        OMX_FlickerCancel100,
+        OMX_FlickerCancel120,
+        OMX_FlickerCancelMax = 0x7fffffff
+}OMX_COMMONFLICKERCANCELTYPE;
+
+typedef struct OMX_CONFIG_FLICKERCANCELTYPE {
+   OMX_U32 nSize;
+   OMX_VERSIONTYPE nVersion;
+   OMX_U32 nPortIndex;
+   OMX_COMMONFLICKERCANCELTYPE eFlickerCancel;
+} OMX_CONFIG_FLICKERCANCELTYPE;
+
+
+/**
+ * Sensor caleberation types
+ */
+typedef enum OMX_SENSORCALTYPE{
+        OMX_SensorCalFull = 0,
+        OMX_SensorCalQuick,
+        OMX_SensorCalMax = 0x7fffffff
+}OMX_SENSORCALTYPE;
+
+typedef struct OMX_CONFIG_SENSORCALTYPE {
+   OMX_U32 nSize;
+   OMX_VERSIONTYPE nVersion;
+   OMX_U32 nPortIndex;
+   OMX_SENSORCALTYPE eSensorCal;
+} OMX_CONFIG_SENSORCALTYPE;
+
+/**
+ * Scene mode types
+ */
+typedef enum OMX_SCENEMODETYPE{
+
+        OMX_Manual = 0,
+        OMX_Closeup,
+        OMX_Portrait,
+        OMX_Landscape,
+        OMX_Underwater,
+        OMX_Sport,
+        OMX_SnowBeach,
+        OMX_Mood,
+        OMX_NightPortrait,
+        OMX_NightIndoor,
+        OMX_Fireworks,
+        OMX_Document, /**< for still image */
+        OMX_Barcode, /**< for still image */
+        OMX_SuperNight, /**< for video */
+        OMX_Cine, /**< for video */
+        OMX_OldFilm, /**< for video */
+        OMX_TI_Action,
+        OMX_TI_Beach,
+        OMX_TI_Candlelight,
+        OMX_TI_Night,
+        OMX_TI_Party,
+        OMX_TI_Portrait,
+        OMX_TI_Snow,
+        OMX_TI_Steadyphoto,
+        OMX_TI_Sunset,
+        OMX_TI_Theatre,
+        OMX_SceneModeMax = 0x7fffffff
+}OMX_SCENEMODETYPE;
+
+typedef struct OMX_CONFIG_SCENEMODETYPE {
+   OMX_U32 nSize;
+   OMX_VERSIONTYPE nVersion;
+   OMX_U32 nPortIndex;
+   OMX_SCENEMODETYPE eSceneMode;
+} OMX_CONFIG_SCENEMODETYPE;
+
+ /**
+ * Port specific capture trigger
+ * useful for the usecases with multiple capture ports.
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  bExtCapturing : Start Captre at the specified port. Can be queried to know the status of a specific port.
+ */
+typedef struct OMX_CONFIG_EXTCAPTURING {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bExtCapturing;
+} OMX_CONFIG_EXTCAPTURING;
+
+
+ /**
+ * Digital Zoom Speed
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nDigitalZoomSpeed      :  Optical zoom speed level. Special values:
+ *      0 - stop current movement
+ *      values from 1 to 254 are mapped proportionally to supported zoom speeds inside optical zoom driver.
+ *      So 1 is slowest available optical zoom speed and 254 is fastest available optical zoom speed
+ *      255 - default optical zoom speed value
+ */
+typedef struct OMX_CONFIG_DIGITALZOOMSPEEDTYPE {
+   OMX_U32 nSize;
+   OMX_VERSIONTYPE nVersion;
+   OMX_U32 nPortIndex;
+   OMX_U8 nDigitalZoomSpeed;
+} OMX_CONFIG_DIGITALZOOMSPEEDTYPE;
+
+
+ /**
+ * Digital Zoom Target
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nDigitalZoomTarget      :  Default and minimum is 0. Maximum is determined by the current supported range
+ */
+
+typedef struct OMX_CONFIG_DIGITALZOOMTARGETTYPE {
+   OMX_U32 nSize;
+   OMX_VERSIONTYPE nVersion;
+   OMX_U32 nPortIndex;
+   OMX_U32 nDigitalZoomTarget;
+} OMX_CONFIG_DIGITALZOOMTARGETTYPE;
+
+
+/**
+* Scale quality enums
+*/
+typedef enum OMX_SCALEQUALITY{
+        OMX_DefaultScaling = 0, /** <default scaling if nothing is specified > */
+        OMX_BetterScaling,   /** <better scaling> */
+        OMX_BestScaling,  /** <best  scaling> */
+        OMX_AutoScalingQuality,  /** <auto scaling quality> */
+        OMX_FastScaling,   /** <fast scaling, prioritizes speed> */
+        OMX_ScaleQualityMax = 0x7fffffff
+}OMX_SCALEQUALITY;
+
+/**
+* Scaling Quality Mode
+*/
+typedef enum OMX_SCALEQUALITYMODE{
+        OMX_SingleFrameScalingMode = 0, /** <default > */
+        OMX_MultiFrameScalingMode,   /** <better scaling> */
+        OMX_AutoScalingMode,  /** <best  scaling> */
+        OMX_ScaleModeMax = 0x7fffffff
+}OMX_SCALEQUALITYMODE;
+
+ /**
+ * Rescale quality control type
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  eScaleQuality : controls the quality level.
+ *  eScaleQualityMode      :  controls the scaling algo types
+ */
+typedef struct OMX_CONFIG_SCALEQUALITYTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_SCALEQUALITY eScaleQuality;
+    OMX_SCALEQUALITYMODE eScaleQualityMode;
+} OMX_CONFIG_SCALEQUALITYTYPE;
+
+/**
+* Smooth Zoom mode enum
+* Starts or stops the Smooth Zoom.  Selecting INCREASE will cause an increasing digital zoom factor (increased cropping),
+* with a shrinking viewable area and crop height percentage.  Selecting DECREASE will cause a decreasing digital zoom (decreased cropping),
+* with a growing viewable area and crop height percentage.  The CaptureCropHeight will continue to update based on the SmoothZoomRate until
+* the SmoothZoomMin or SmoothZoomMax zoom step is reached, the framework minimum zoom step is reached, the SmoothZoomRate becomes 0,
+* or the SmoothZoomMode is set to OFF.
+* NOTE: The message payload includes all parts of the message that is NOT part of the message header as listed for the CAM_SEND_DATA message.
+*/
+typedef enum OMX_SMOOTHZOOMMODE{
+    OMX_Off=0, /**< default OFF */
+    OMX_Increase,
+    OMX_Decrease
+}OMX_SMOOTHZOOMMODE;
+
+
+ /**
+ * Rescale quality control type
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  eSmoothZoomMode : controls the smooth zoom feature.
+ *  nSmoothZoomRate      :  Values from 0 to 65535 which represents percentage to increase per second, where 65535 = 100%, and 0 = 0%.
+ *  nSmoothZoomQuantize:
+ *  nSmoothZoomThresh
+ *  nSmoothZoomMin
+ *  nSmoothZoomMax
+ */
+typedef struct OMX_CONFIG_SMOOTHZOOMTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_SMOOTHZOOMMODE eSmoothZoomMode;
+    OMX_U32 nSmoothZoomRate;
+    OMX_U32 nSmoothZoomQuantize;
+    OMX_U32 nSmoothZoomThresh;
+    OMX_U32 nSmoothZoomMin;
+    OMX_U32 nSmoothZoomMax;
+} OMX_CONFIG_SMOOTHZOOMTYPE;
+
+/**
+ * Enumeration of possible Extended image filter types for OMX_CONFIG_IMAGEFILTERTYPE
+ */
+typedef enum OMX_EXTIMAGEFILTERTYPE {
+    OMX_ImageFilterSepia = 0x7F000001,
+    OMX_ImageFilterGrayScale,
+    OMX_ImageFilterNatural,
+    OMX_ImageFilterVivid,
+    OMX_ImageFilterColourSwap,
+    OMX_ImageFilterOutOfFocus,
+    OMX_ImageFilterWaterColour,
+    OMX_ImageFilterPastel,
+    OMX_ImageFilterFilm,
+    OMX_TI_ImageFilterBlackWhite,
+    OMX_TI_ImageFilterWhiteBoard,
+    OMX_TI_ImageFilterBlackBoard,
+    OMX_TI_ImageFilterAqua,
+    OMX_TI_ImageFilterPosterize
+} OMX_EXTIMAGEFILTERTYPE;
+
+
+/**
+ * Image filter configuration extended
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bBlemish : Enable/Disable Blemish correction
+ */
+typedef struct OMX_CONFIG_BLEMISHTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bBlemish;
+} OMX_CONFIG_BLEMISHTYPE;
+
+/**
+ * Enumeration of Bracket types
+ * OMX_BracketExposureRelativeInEV:
+ *      Exposure value is changed relative to the value set by automatic exposure.
+ *      nBracketStartValue and nBracketStep are in Q16. Increment is additive.
+ * OMX_BracketExposureAbsoluteMs:
+ *      Exposure value is changed in absolute value in ms.
+ *      nBracketStartValue and nBracketStep are in Q16. Increment is multiplicative.
+ * OMX_BracketFocusRelative:
+ *      Focus is adjusted relative to the focus set by auto focus.
+ *      The value is S32 integer, and is the same as adjusting nFocusSteps of OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE relatively.
+ *      Increment is additive.
+ * OMX_BracketFocusAbsolute:
+ *      Focus position is adjusted absolutely. It is the same as setting nFocusSteps of
+ *      OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE relatively for each captures.
+ *      The value should be interpreted as U32 value.  Increment is additive.
+ * OMX_BracketFlashPower:
+ *      Power of flash is adjusted relative to the automatic level. Increment is multiplicative.
+ * OMX_BracketAperture:
+ *      Aperture number relative to the automatic setting. Data in Q16 format. Increment is multiplicative.
+ * OMX_BracketTemporal:
+ *      To suppport temporal bracketing.
+ */
+typedef enum OMX_BRACKETMODETYPE {
+    OMX_BracketExposureRelativeInEV = 0,
+    OMX_BracketExposureAbsoluteMs,
+    OMX_BracketFocusRelative,
+    OMX_BracketFocusAbsolute,
+    OMX_BracketFlashPower,
+    OMX_BracketAperture,
+    OMX_BracketTemporal,
+    OMX_BrackerTypeKhronosExtensions = 0x6f000000,
+    OMX_BrackerTypeVendorStartUnused = 0x7f000000,
+    OMX_BracketTypeMax = 0x7FFFFFFF
+} OMX_BRACKETMODETYPE;
+
+typedef struct OMX_CONFIG_BRACKETINGTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BRACKETMODETYPE eBracketMode;
+    OMX_U32 nNbrBracketingValues;
+    OMX_S32 nBracketValues[10]; /**< 10 can be assumed */
+} OMX_CONFIG_BRACKETINGTYPE;
+
+
+/**
+ * Capture mode types
+ * Note: this list could get extended modified based on the type of interenal use-case pipelines implemented within the camera component.
+ *
+ *       OMX_CaptureImageHighSpeedBurst = 0,
+ *       OMX_CaptureImageHighSpeedTemporalBracketing,
+ *       OMX_CaptureImageProfileBase(Base):
+ *       	Base one almost same as Highspeed one.
+ *       OMX_CaptureImageProfileLowLight1(LL1):
+ *       	Includes NSF2 in addition to Base processing
+ *       OMX_CaptureImageProfileLowLight2(LL2):
+ *       	Includes NSF2 and LBCE in addition to Base processing.
+ *       OMX_CaptureImageProfileOpticalCorr1(OC1):
+ *       	Includes LDC in addition to Base processing.
+ *       OMX_CaptureImageProfileOpticalCorr2(OC2):
+ *       	Includes LDC and CAC in addition to Base processing.
+ *       OMX_CaptureImageProfileExtended1(Ext1):
+ *       	Includes NSF2, LBCE, LDC, and CAC in addition to Base
+ *       OMX_CaptureStereoImageCapture:
+ *       	Stereo image capture use-case.
+ *       OMX_CaptureImageMemoryInput:
+ *       	need to take sensor input from INPUT port.
+ *       OMX_CaptureVideo:
+ *       OMX_CaptureHighSpeedVideo:
+ *       OMX_CaptureVideoMemoryInput:
+ *
+ */
+typedef enum OMX_CAMOPERATINGMODETYPE {
+        OMX_CaptureImageHighSpeedBurst = 0,
+        OMX_CaptureImageHighSpeedTemporalBracketing,
+        OMX_CaptureImageProfileBase,
+        OMX_CaptureImageProfileLowLight1,
+        OMX_CaptureImageProfileLowLight2,
+        OMX_CaptureImageProfileOpticalCorr1,
+        OMX_CaptureImageProfileOpticalCorr2,
+        OMX_CaptureImageProfileExtended1,
+	OMX_CaptureStereoImageCapture,
+        OMX_CaptureImageMemoryInput,
+        OMX_CaptureVideo,
+        OMX_CaptureHighSpeedVideo,
+        OMX_CaptureVideoMemoryInput,
+        OMX_TI_CaptureDummy,
+        OMX_TI_CaptureGestureRecognition,
+        OMX_TI_CaptureImageProfileZeroShutterLag,
+        OMX_CamOperatingModeMax = 0x7fffffff
+} OMX_CAMOPERATINGMODETYPE;
+/**
+ * Capture mode setting: applicable to multi shot capture also including bracketing.
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  eCamOperatingMode : specifies the camera operating mode.
+ */
+typedef struct OMX_CONFIG_CAMOPERATINGMODETYPE {
+   OMX_U32 nSize;
+   OMX_VERSIONTYPE nVersion;
+   OMX_CAMOPERATINGMODETYPE eCamOperatingMode;
+} OMX_CONFIG_CAMOPERATINGMODETYPE;
+
+
+/**
+ * Capture mode setting: applicable to multi shot capture also including bracketing.
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  nFrameRate   : when bContinuous is FALSE, need to define the frame rate of the muti-shot scenario. Since this would be applicable to IMAGE domain port, there is no port specific frame rate.
+ *  nFrameBefore :
+ * 	is specifying how many frames before the capture trigger shall be used.
+ * 	It is implementation dependent how many is supported. This shall only be supported for images and not for video frames.
+ * bPrepareCapture :
+ *	should be set to true when nFrameBefore is greater than zero and before capturing of before-frames should start.
+ *	The component is not allowed to deliver buffers until capturing starts. This shall only be supported for images and not for video frames.
+ * bEnableBracketing :
+ *	should be enabled when bracketing is used. In bracketing mode, one parameter can be changed per each capture.
+ * tBracketConfigType :
+ *	specifies bracket mode to use. Valid only when bEnableBracketing is set.
+ */
+typedef struct OMX_CONFIG_EXTCAPTUREMODETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nFrameRate;
+    OMX_U32 nFrameBefore;
+    OMX_BOOL bPrepareCapture;
+    OMX_BOOL bEnableBracketing;
+    OMX_CONFIG_BRACKETINGTYPE tBracketConfigType;
+} OMX_CONFIG_EXTCAPTUREMODETYPE;
+
+/**
+ * For Extended Focus region Type -
+ */
+typedef struct OMX_CONFIG_EXTFOCUSREGIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nRefPortIndex;
+    OMX_S32 nLeft;
+    OMX_S32 nTop;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+} OMX_CONFIG_EXTFOCUSREGIONTYPE;
+
+/**
+ * Digital Flash Control
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bDigitalFlash : Digital flash type Enable/Disable -
+ * Specifies whether the digital flash algorithm is enabled or disabled. This overrides the contrast and brightness settings.
+ */
+typedef struct OMX_CONFIG_DIGITALFLASHTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bDigitalFlash;
+} OMX_CONFIG_DIGITALFLASHTYPE;
+
+
+
+/**
+ * Privacy Indicator Enable/Disable
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bPrivacyIndicator :
+ *        Specifies whether the flash should be used to indicate image or video capture. When flash is not used for exposure,
+ *        flash will be activated after exposure to indicate image capture.
+ *        If video light is not used, the flash can be blinking or constant at low intensity to indicate capture but not affect exposure.
+ *        Specifies whether the digital flash algorithm is enabled or disabled. This overrides the contrast and brightness settings.
+ */
+typedef struct OMX_CONFIG_PRIVACYINDICATOR {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bPrivacyIndicator;
+} OMX_CONFIG_PRIVACYINDICATOR;
+
+
+/**
+ * Privacy Indicator Enable/Disable
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bTorchMode :
+ *        Enable/Disable
+ *      nIntensityLevel : relative intensity from 0 - 100
+ *      nDuration : duration in msec
+ */
+typedef struct OMX_CONFIG_TORCHMODETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bTorchMode;
+    OMX_U32 nIntensityLevel;
+    OMX_U32 nDuration;
+} OMX_CONFIG_TORCHMODETYPE;
+
+
+
+/**
+ * Privacy Indicator Enable/Disable
+ * DISABLE - Fire the xenon flash in the usual manner
+ * ENABLE - Reduce the light intensity of the main flash (ex 1EV)
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bSlowSync :
+ *        Enable - OMX_TRUE/Disable - OMX_FALSE
+ */
+typedef struct OMX_CONFIG_SLOWSYNCTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bSlowSync;
+} OMX_CONFIG_SLOWSYNCTYPE;
+
+
+/**
+ * Focus control extended enums. use this along with OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE
+ */
+typedef enum OMX_IMAGE_EXTFOCUSCONTROLTYPE {
+    OMX_IMAGE_FocusControlAutoMacro = 0x7F000001, /**< Reserved region for introducing Vendor Extensions */
+    OMX_IMAGE_FocusControlAutoInfinity,
+    OMX_IMAGE_FocusControlHyperfocal,
+    OMX_IMAGE_FocusControlPortrait, /**< from Xena */
+    OMX_IMAGE_FocusControlExtended, /**< from Xena */
+    OMX_IMAGE_FocusControlContinousNormal, /**< from Xena */
+    OMX_IMAGE_FocusControlContinousExtended /**< from Xena */
+} OMX_IMAGE_EXTFOCUSCONTROLTYPE;
+
+
+
+/**
+ * Specifies whether the LED can be used to assist in autofocus, due to low lighting conditions.
+ * ENABLE means use as determined by the auto exposure algorithm.
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bFocusAssist :
+ *        Enable - OMX_TRUE/Disable - OMX_FALSE
+ */
+typedef struct OMX_CONFIG_FOCUSASSISTTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bFocusAssist;
+} OMX_CONFIG_FOCUSASSISTTYPE;
+
+
+
+/**
+ *for locking the focus
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bFocusLock :
+ *        Enable - OMX_TRUE/Disable - OMX_FALSE
+ */
+typedef struct OMX_CONFIG_FOCUSLOCKTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bFocusLock;
+} OMX_CONFIG_FOCUSLOCKTYPE;
+
+
+/**
+ *for locking the White balance
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bWhiteBalanceLock :
+ *        Enable - OMX_TRUE/Disable - OMX_FALSE
+ */
+typedef struct OMX_CONFIG_WHITEBALANCELOCKTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bWhiteBalanceLock;
+} OMX_CONFIG_WHITEBALANCELOCKTYPE;
+
+/**
+ *for locking the Exposure
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bExposureLock :
+ *        Enable - OMX_TRUE/Disable - OMX_FALSE
+ */
+typedef struct OMX_CONFIG_EXPOSURELOCKTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bExposureLock;
+} OMX_CONFIG_EXPOSURELOCKTYPE;
+
+/**
+ *for locking the Exposure
+ *  Simultaneously lock focus, white balance and exposure (and relevant other settings).
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bAllLock :
+ *        Enable - OMX_TRUE/Disable - OMX_FALSE
+ */
+typedef struct OMX_CONFIG_ALLLOCKTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bAllLock;
+} OMX_CONFIG_ALLLOCKTYPE;
+
+/**
+ *for locking
+ *  Simultaneously lock focus, white balance and exposure (and relevant other settings).
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  bLock :
+ *        Enable - OMX_TRUE/Disable - OMX_FALSE
+ *  bAtCapture:
+ *
+ */
+typedef struct OMX_IMAGE_CONFIG_LOCKTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bLock;
+    OMX_BOOL bAtCapture;
+} OMX_IMAGE_CONFIG_LOCKTYPE;
+
+/**
+ * processig level types enum
+ */
+typedef enum OMX_PROCESSINGLEVEL{
+        OMX_Min = 0,
+        OMX_Low,
+        OMX_Medium,
+        OMX_High,
+        OMX_Max,
+        OMX_ProcessingLevelMax = 0x7fffffff
+}OMX_PROCESSINGLEVEL;
+
+/**
+ *processing level type
+ *  Simultaneously lock focus, white balance and exposure (and relevant other settings).
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  nLevel :
+ *               nLevel hinting processing amount. Range of values is -100 to 100.
+ *               0 causes no change to the image.  Increased values cause increased processing to occur, with 100 applying maximum processing.
+ *               Negative values have the opposite effect of positive values.
+ *  bAuto:
+ *		sets if the processing should be applied according to input data.
+ 		It is allowed to combine the hint level with the auto setting,
+ *		i.e. to give a bias to the automatic setting. When set to false, the processing should not take input data into account.
+ */
+
+typedef struct OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE {
+OMX_U32 nSize;
+OMX_VERSIONTYPE nVersion;
+OMX_U32 nPortIndex;
+OMX_S32 nLevel;
+OMX_BOOL bAuto;
+} OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE;
+
+
+/**
+ * White Balance control type extended enums - to be used along with the structure @OMX_CONFIG_WHITEBALCONTROLTYPE
+ *
+ *
+ *
+ */
+typedef enum OMX_EXTWHITEBALCONTROLTYPE {
+    OMX_WhiteBalControlFacePriorityMode = OMX_WhiteBalControlVendorStartUnused + 1, /**<  */
+    OMX_TI_WhiteBalControlSunset,
+    OMX_TI_WhiteBalControlShade,
+    OMX_TI_WhiteBalControlTwilight,
+    OMX_TI_WhiteBalControlWarmFluorescent
+} OMX_EXTWHITEBALCONTROLTYPE;
+
+/**
+ *white balance gain type
+ *  xWhiteBalanceGain and xWhiteBalanceOffset represents gain and offset for R, Gr, Gb, B channels respectively in Q16 format. \
+ *  For example, new red pixel value = xWhiteBalanceGain[1]* the current pixel value + xWhiteBalanceOffset[1].
+ *  All values assume that maximum value is 255. If internal implementation uses higher dynamic range, this value should be adjusted internally.
+ *  nWhiteThreshhold  represents thresholds for "white" area measurments in Q16 format.
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *
+ */
+typedef struct OMX_CONFIG_WHITEBALGAINTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 xWhiteBalanceGain[4];
+    OMX_S32 xWhiteBalanceOffset[4];
+    OMX_S32 nWhiteThreshhold[4];
+} OMX_CONFIG_WHITEBALGAINTYPE;
+
+/**
+ *  This structure represents linear color conversion from one space to another.  For example, to conversion from one RGB color into another RGB color space can be represented as
+ *  R' =  xColorMatrix[1][1]*R + xColorMatrix[1][2]*G + xColorMatrix[1][3]*B + xColorOffset[1]
+ *  G' = xColorMatrix[2][1]*R + xColorMatrix[2][2]*G + xColorMatrix[2][3]*B + xColorOffset[2]
+ *  B' = xColorMatrix[3][1]*R + xColorMatrix[3][2]*G + xColorMatrix[3][3]*B + xColorOffset[3]
+ *  Both xColorMatrix and xColorOffset are represented as Q16 value.
+ *  bFullColorRange represents represents whether valid range of color is 0 to 255 (when set to TRUE) or 16 to 235 (for FALSE).
+ *  Again all values assume that maximum value is 255. If internal implementation uses higher dynamic range, this value should be adjusted internally.
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *
+ */
+typedef struct OMX_CONFIG_EXT_COLORCONVERSIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_S32 xColorMatrix[3][3];
+    OMX_S32 xColorOffset[3];
+    OMX_BOOL bFullColorRange;
+}OMX_CONFIG_EXT_COLORCONVERSIONTYPE;
+
+
+/**
+ * xGamma represents lool-up table for gamma correction in Q16 format.
+ * All values assume that maximum value is 255. If internal implementation uses higher dynamic range, this value should be adjusted internally.
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *
+ */
+typedef struct OMX_CONFIG_GAMMATABLETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 xGamma[3][256];
+}OMX_CONFIG_GAMMATABLETYPE;
+
+
+
+/**
+ * processig types
+ */
+typedef enum OMX_PROCESSINGTYPE{
+        OMX_BloomingReduction = 0,
+        OMX_Denoise,
+        OMX_Sharpening,
+        OMX_Deblurring,
+        OMX_Demosaicing,
+        OMX_ContrastEnhancement,
+        OMX_ProcessingTypeMax = 0x7fffffff
+}OMX_PROCESSINGTYPE;
+
+
+typedef  struct OMX_CONFIGPROCESSINGORDERTYPE {
+OMX_U32  nSize; /**< Size of the structure in bytes */
+OMX_VERSIONTYPE nVersion; /**< OMX specification version info */
+OMX_U32 nPortIndex; /**< Port that this struct applies to */
+OMX_U32 nIndex;
+OMX_PROCESSINGTYPE eProc;
+} OMX_CONFIGPROCESSINGORDERTYPE;
+
+/**
+ * HIST TYPE
+ */
+typedef enum OMX_HISTTYPE{
+        OMX_HistControlLuminance = 0, /**< Luminance histogram is calculated (Y)*/
+        OMX_HistControlColorComponents, /**< A histogram per color component (R, G, B) is calculated*/
+        OMX_HistControlChrominanceComponents /**< A histogram per chrominance component (Cb, Cr) is calculated.*/
+}OMX_HISTTYPE;
+
+/**
+ * Histogram Setting
+ *  nPortIndex is an output port. The port index decides on which port the extra data structur is sent on.
+ *  bFrameLimited is a Boolean used to indicate if measurement shall be terminated after the specified number of
+ *  frames if true frame limited measurement is enabled; otherwise the port does not terminate measurement until
+ *  instructed to do so by the client.
+ *  nFrameLimit is the limit on number of frames measured, this parameter is only valid if bFrameLimited is enabled.
+ *  bMeasure is a Boolean that should be set to true when measurement shall begin, otherwise set to false. Query will give status information on if measurement is ongoing or not.
+ *  nBins specifies the number of histogram bins. When queried with set to zero, the respons gives the maximum number of bins allowed.
+ *  nLeft is the leftmost coordinate of the measurement area rectangle.
+ *  nTop is the topmost coordinate of the measurement area rectangle.
+ *  nWidth is the width of the measurement area rectangle in pixels.
+ *  nHeight is the height of the measurement area rectangle in pixels.
+ *  eHistType is an enumeration specifying the histogram type
+ *
+ *
+ */
+
+typedef struct OMX_CONFIG_HISTOGRAMTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bFrameLimited;
+    OMX_U32 nFrameLimit;
+    OMX_BOOL bMeasure;
+    OMX_U32 nBins;
+    OMX_S32 nLeft;
+    OMX_S32 nTop;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+    OMX_HISTTYPE eHistType;
+} OMX_CONFIG_HISTOGRAMTYPE;
+
+/**
+ * Enums for HIST component type.
+ */
+typedef enum OMX_HISTCOMPONENTTYPE{
+        OMX_HISTCOMP_Y = 0, /**<    Luminance histogram (Y) */
+        OMX_HISTCOMP_YLOG,  /**< Logarithmic luminance histogram (Y)*/
+        OMX_HISTCOMP_R, /**< Red histogram component (R)*/
+        OMX_HISTCOMP_G, /**< Green histogram component (G)*/
+        OMX_HISTCOMP_B, /**< Blue histogram component (B)*/
+        OMX_HISTCOMP_Cb,    /**< Chroma blue histogram component (Cb)*/
+        OMX_HISTCOMP_Cr /**< Chroma red histogram component (Cr) */
+}OMX_HISTCOMPONENTTYPE;
+
+ /**
+ * The OMX_TI_CAMERAVIEWTYPE enumeration is used to identify the
+ * particular camera view that the rest of the data in the structure is
+ * associated with.
+ */
+typedef enum OMX_TI_CAMERAVIEWTYPE
+{
+    OMX_2D,     /**< Camera view in 2D sensor configuration */
+    OMX_Left,   /**< Left camera view in stereo sensor configuration */
+    OMX_Right,  /**< Right camera view in stereo sensor configuration */
+    OMX_TI_CAMERAVIEWTYPE_32BIT_PATCH = 0x7FFFFFFF
+} OMX_TI_CAMERAVIEWTYPE;
+/**
+ *  nSize is the size of the structure including the length of data field containing
+ *  the histogram data.
+ *  nBins is the number of bins in the histogram.
+ *  eComponentType specifies the type of the histogram bins according to enum.
+ *  It can be selected to generate multiple component types, then the extradata struct
+ *  is repeated for each component type.
+ *  data[1] first byte of the histogram data
+ */
+typedef struct OMX_HISTOGRAMTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_U32 nBins;
+    OMX_HISTCOMPONENTTYPE eComponentType;
+    OMX_U8  data[1];
+} OMX_HISTOGRAMTYPE;
+
+#define OMX_OTHER_EXTRADATATYPE_SIZE ( (OMX_U32)(((OMX_OTHER_EXTRADATATYPE*)0x0)->data) ) /**< Size of OMX_OTHER_EXTRADATATYPE**/
+/**
+ * The extra data having ancillary data is described with the following structure.
+ * This data contains single flags and values
+ * (not arrays) that have general usage for camera applications.
+ */
+typedef  struct OMX_TI_ANCILLARYDATATYPE {
+    OMX_U32             nSize;
+    OMX_VERSIONTYPE     nVersion;
+    OMX_U32             nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE       eCameraView;
+    OMX_U32             nAncillaryDataVersion;
+    OMX_U32             nFrameNumber;
+    OMX_U32             nShotNumber;
+    OMX_U16             nInputImageHeight;
+    OMX_U16             nInputImageWidth;
+    OMX_U16             nOutputImageHeight;
+    OMX_U16             nOutputImageWidth;
+    OMX_U16             nDigitalZoomFactor;
+    OMX_S16             nCropCenterColumn;
+    OMX_S16             nCropCenterRow;
+    OMX_U16             nOpticalZoomValue;
+    OMX_U8              nFlashConfiguration;
+    OMX_U8              nFlashUsage;
+    OMX_U32             nFlashStatus;
+    OMX_U8              nAFStatus;
+    OMX_U8              nAWBStatus;
+    OMX_U8              nAEStatus;
+    OMX_U32             nExposureTime;
+    OMX_U16             nEVCompensation;
+    OMX_U8              nDigitalGainValue;
+    OMX_U8              nAnalogGainValue;
+    OMX_U16             nCurrentISO;
+    OMX_U16             nReferenceISO;
+    OMX_U8              nApertureValue;
+    OMX_U8              nPixelRange;
+    OMX_U16             nPixelAspectRatio;
+    OMX_U8              nCameraShake;
+    OMX_U16             nFocalDistance;
+    OMX_U64             nParameterChangeFlags;
+    OMX_U8              nNumFacesDetected;
+    OMX_U8              nConvergenceMode;
+    OMX_U8              nConvergenceStatus;
+    OMX_U8              nDCCStatus;
+} OMX_TI_ANCILLARYDATATYPE;
+
+typedef struct OMX_TI_WHITEBALANCERESULTTYPE {
+    OMX_U32             nSize;          /**< Size */
+    OMX_VERSIONTYPE     nVersion;       /**< Version */
+    OMX_U32             nPortIndex;     /**< Port Index */
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_U16             nColorTemperature;      /**< White Balance Color Temperature in Kelvins */
+    OMX_U16             nGainR;         /**< Bayer applied R color channel gain in (U13Q9) */
+    OMX_U16             nGainGR;        /**< Bayer applied Gr color channel gain in (U13Q9) */
+    OMX_U16             nGainGB;        /**< Bayer applied Gb color channel gain in (U13Q9) */
+    OMX_U16             nGainB;         /**< Bayer applied B color channel gain in (U13Q9) */
+    OMX_S16             nOffsetR;       /**< Bayer applied R color channel offset */
+    OMX_S16             nOffsetGR;      /**< Bayer applied Gr color channel offset */
+    OMX_S16             nOffsetGB;      /**< Bayer applied Gb color channel offset */
+    OMX_S16             nOffsetB;       /**< Bayer applied B color channel offset */
+} OMX_TI_WHITEBALANCERESULTTYPE;
+
+/**
+ * Unsaturated Regions data
+ * The extra data having unsaturated regions data is
+ * described with the following structure..
+ */
+typedef struct OMX_TI_UNSATURATEDREGIONSTYPE {
+    OMX_U32             nSize;          /**< Size */
+    OMX_VERSIONTYPE     nVersion;       /**< Version */
+    OMX_U32             nPortIndex;     /**< Port Index */
+    OMX_U16             nPaxelsX;       /**< The number of paxels in the horizontal direction */
+    OMX_U16             nPaxelsY;       /**< The number of paxels in the vertical direction */
+    OMX_U16             data[1];        /**< the first value of an array of values that represent */
+} OMX_TI_UNSATURATEDREGIONSTYPE;
+
+/**
+ * OMX_BARCODETYPE
+ */
+typedef enum OMX_BARCODETYPE{
+        OMX_BARCODE1D = 0,      /**< 1D barcode */
+        OMX_BARCODE2D,          /**< 2D barcode */
+}OMX_BARCODETYPE;
+/**
+ * Brcode detection data
+ *	nLeft is the leftmost coordinate of the detected area rectangle.
+ *	nTop is the topmost coordinate of the detected area rectangle.
+ *	nWidth is the width of the detected area rectangle in pixels.
+ *	nHeight is the height of the detected area rectangle in pixels.
+ *	nOrientation is the orientation of the axis of the detected object. This refers to the angle between the vertical axis of barcode and the horizontal axis.
+ *	eBarcodetype is an enumeration specifying the barcode type, as listed in the given table.
+ */
+typedef struct OMX_BARCODEDETECTIONTYPE {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_TI_CAMERAVIEWTYPE eCameraView;
+	OMX_S32 nLeft;
+	OMX_S32 nTop;
+	OMX_U32 nWidth;
+	OMX_U32 nHeight;
+	OMX_S32 nOrientation;
+	OMX_BARCODETYPE eBarcodetype;
+ } OMX_BARCODEDETECTIONTYPE;
+
+/**
+ * Front object detection data
+ *	nLeft is the leftmost coordinate of the detected area rectangle.
+ *	nTop is the topmost coordinate of the detected area rectangle.
+ *	nWidth is the width of the detected area rectangle in pixels.
+ *	nHeight is the height of the detected area rectangle in pixels.
+ */
+typedef struct OMX_FRONTOBJDETECTIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_S32 nLeft;
+    OMX_S32 nTop;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+} OMX_FRONTOBJDETECTIONTYPE;
+
+/**
+ * Distance estimation data
+ * nDistance is the estimated distance to the object in millimeters.
+ * nLargestDiscrepancy is the estimated largest discrepancy of the distance to the object in millimeters. When equal to MAX_INT the discrepancy is unknown.
+ */
+typedef struct OMX_DISTANCEESTIMATIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_U32 nDistance;
+    OMX_U32 nLargestDiscrepancy;
+} OMX_DISTANCEESTIMATIONTYPE;
+
+/**
+ * Distance estimation data
+ * nDistance is the estimated distance to the object in millimeters.
+ * nLargestDiscrepancy is the estimated largest discrepancy of the distance to the object in millimeters. When equal to MAX_INT the discrepancy is unknown.
+ */
+
+typedef struct OMX_MOTIONESTIMATIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_S32 nPanX;
+    OMX_S32 nPanY;
+} OMX_MOTIONESTIMATIONTYPE;
+
+
+/**
+ * Focus region data
+ *	nRefPortIndex is the port the image frame size is defined on. This image frame size is used as reference for the focus region rectangle.
+ *	nLeft is the leftmost coordinate of the focus region rectangle.
+ *	nTop is the topmost coordinate of the focus region rectangle.
+ *	nWidth is the width of the focus region rectangle in pixels.
+ *	nHeight is the height of the focus region rectangle in pixels.
+ *
+ */
+typedef struct OMX_FOCUSREGIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_U32 nRefPortIndex;
+    OMX_S32 nLeft;
+    OMX_S32 nTop;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+} OMX_FOCUSREGIONTYPE;
+
+/**
+ * OMX_ISOSETTINGTYPE: specifies its auto or manual setting
+ *
+ */
+typedef enum OMX_ISOSETTINGTYPE{
+        OMX_Auto = 0, /**<	*/
+        OMX_IsoManual	/**< */
+}OMX_ISOSETTINGTYPE;
+
+/**
+ *  nSize is the size of the structure including the length of data field containing
+ *  the histogram data.
+ *  eISOMode:
+ *  	specifies the ISO seetting mode - auto/manual
+ *  nISOSetting:
+ *  	for manual mode client can specify the ISO setting.
+ */
+
+typedef struct OMX_CONFIG_ISOSETTINGTYPE{
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_ISOSETTINGTYPE eISOMode;
+	OMX_U32 nISOSetting;
+}OMX_CONFIG_ISOSETTINGTYPE;
+
+/**
+ * custom RAW format
+ */
+typedef struct OMX_CONFIG_RAWFORMATTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VERSIONTYPE nFormatVersion;
+    OMX_STRING cVendorName;
+} OMX_CONFIG_RAWFORMATTYPE;
+
+/**
+ * Sensor type
+ */
+typedef struct OMX_CONFIG_SENSORTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VERSIONTYPE nSensorVersion;
+    OMX_STRING cModelName;
+} OMX_CONFIG_SENSORTYPE;
+
+/**
+ * Sensor custom data type
+ */
+typedef struct OMX_CONFIG_SENSORCUSTOMDATATYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nDataLength;
+    OMX_U8 xSensorData[1];
+} OMX_CONFIG_SENSORCUSTOMDATATYPE;
+
+/**
+ * OMX_OBJDETECTQUALITY
+ *
+ */
+typedef enum OMX_OBJDETECTQUALITY{
+        OMX_FastDetection = 0, /**< A detection that prioritizes speed*/
+        OMX_Default,    /**< The default detection, should be used when no control of the detection quality is given.*/
+        OMX_BetterDetection,    /**< A detection that levels correct detection with speed*/
+        OMX_BestDtection,   /**< A detection that prioritizes correct detection*/
+        OMX_AUTODETECTION   /**< Automatically decide which object detection quality is best.*/
+}OMX_OBJDETECTQUALITY;
+
+/**
+ * OBJECT DETECTION Type
+ *      nPortIndex: is an output port. The port index decides on which port the extra data structur of detected object is sent on.
+ *      bEnable : this controls ON/OFF for this object detection algirithm.
+ *      bFrameLimited: is a Boolean used to indicate if detection shall be terminated after the specified number of frames if
+ *          true frame limited detection is enabled; otherwise the port does not terminate detection until instructed to do so by the client.
+ *      nFrameLimit: is the limit on number of frames detection is executed for, this parameter is only valid if bFrameLimited is enabled.
+ *      nMaxNbrObjects: specifies the maximum number of objects that should be found in each frame. It is implementation dependent which objects are found.
+ *      nLeft: is the leftmost coordinate of the detection area rectangle.
+ *      nTop: is the topmost coordinate of the detection area rectangle.
+ *      nWidth: is the width of the detection area rectangle in pixels.
+ *      nHeight: is the height of the detection area rectangle in pixels.
+ *      eObjDetectQuality: is an enumeration specifying the quality desired by the detection.
+ *      nPriority: represents priority of each object when there are multiple objects detected.
+ */
+
+typedef struct OMX_CONFIG_OBJDETECTIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnable;
+    OMX_BOOL bFrameLimited;
+    OMX_U32 nFrameLimit;
+    OMX_U32 nMaxNbrObjects;
+    OMX_S32 nLeft;
+    OMX_S32 nTop;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+    OMX_OBJDETECTQUALITY eObjDetectQuality;
+    OMX_U32 nPriority;
+    OMX_U32 nDeviceOrientation;
+ } OMX_CONFIG_OBJDETECTIONTYPE;
+
+
+/**
+ * OMX_OBJDETECTQUALITY
+ *
+ */
+typedef enum OMX_DISTTYPE{
+        OMX_DistanceControlFocus = 0, /**< focus objects distance type*/
+        OMX_DISTANCECONTROL_RECT	/**< Evaluated distance to the object found in the rectangelar area indicated as input region.  */
+}OMX_DISTTYPE;
+
+
+/**
+ * Distance mesurement
+ *	bStarted is a Boolean. The IL client sets it to true to start the measurement .
+ *		the IL client sets to false to stop the measurement. The IL client can query it to check if the measurement is ongoing.
+ *	nLeft : is the leftmost coordinate of the rectangle.
+ *	nTop : is the topmost coordinate of the rectangle.
+ *	nWidth:  is the width of the rectangle in pixels.
+ *	nHeight:  is the height of the rectangle in pixels.
+ *	eDistType:  is an enumeration specifying the distance measurement type, as shown in
+ */
+typedef struct OMX_CONFIG_DISTANCETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bStarted;
+    OMX_S32 nLeft;
+    OMX_S32 nTop;
+    OMX_U32 nWidth;
+    OMX_U32 nHeight;
+    OMX_DISTTYPE eDistType;
+} OMX_CONFIG_DISTANCETYPE;
+
+
+/**
+ * face detect data - face attribute
+ *  nARGBEyeColor: is the indicates a 32-bit eye color of the person, where bits 0-7 are blue,
+ *      bits 15-8 are green, bits 24-16 are red, and bits 31-24 are for alpha.
+ *  nARGBSkinColor: is the indicates a 32-bit skin color of the person, where bits 0-7 are blue,
+ *      bits 15-8 are green, bits 24-16 are red, and bits 31-24 are for alpha.
+ *  nARGBHairColor: is the indicates a 32-bit hair color of the person, where bits 0-7 are blue,
+ *      bits 15-8 are green, bits 24-16 are red, and bits 31-24 are for alpha.
+ *  nSmileScore: a smile detection score between 0 and 100, where 0 means not detecting,
+ *      1 means least certain and 100 means most certain a smile is detected.
+ *  nBlinkScore: a eye-blink detection score between 0 and 100, where 0 means not detecting,
+ *      1 means least certain and 100 means most certain an eye-blink is detected.
+ *  xIdentity: represents the identity of the face. With identity equal to zero this is not supported.
+ *      This can be used by a face recognition application. The component shall not reuse an identity value unless the same face.
+ *      Can be used to track detected faces when it moves between frames. Specific usage of this field is implementation dependent.
+ *      It can be some kind of ID.
+ *
+ */
+typedef struct OMX_FACEATTRIBUTE {
+        OMX_U32 nARGBEyeColor;
+    OMX_U32 nARGBSkinColor;
+    OMX_U32 nARGBHairColor;
+    OMX_U32 nSmileScore;
+    OMX_U32 nBlinkScore;
+    OMX_U32 xIdentity[4];
+} OMX_FACEATTRIBUTE;
+
+/**
+ * xGamma represents lool-up table for gamma correction in Q16 format.
+ * All values assume that maximum value is 255. If internal implementation uses higher dynamic range, this value should be adjusted internally.
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nScore: is a detection score between 0 and 100, where 0 means unknown score, 1 means least certain and 100 means most certain the detection is correct.
+ *  nLeft: is the leftmost coordinate of the detected area rectangle.
+ *  nTop: is the topmost coordinate of the detected area rectangle.
+ *  nWidth: is the width of the detected area rectangle in pixels.
+ *  nHeight: is the height of the detected area rectangle in pixels.
+ *  nOrientationRoll/Yaw/Pitch is the orientation of the axis of the detected object. Here roll angle is defined as the angle between the vertical axis of face and the horizontal axis. All angles can have the value of -180 to 180 degree in Q16 format. Some face detection algorithm may not be able to fill in the angles, this is denoted by the use of MAX_INT value.
+ *  nPriority represents priority of each object when there are multiple objects detected.
+ *  nFaceAttr describe the attributes of the detected face object with the following structure:
+ *
+ *
+ */
+typedef struct OMX_TI_FACERESULT {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_U32 nScore;
+    OMX_S32 nLeft;
+    OMX_S32 nTop;
+OMX_U32 nWidth;
+OMX_U32 nHeight;
+OMX_S32 nOrientationRoll;
+OMX_S32 nOrientationYaw;
+OMX_S32 nOrientationPitch;
+OMX_U32 nPriority;
+OMX_FACEATTRIBUTE nFaceAttr;
+} OMX_TI_FACERESULT;
+
+
+/**
+ * Face detection data
+ * The extra data having face detection data is described with the following structure.
+ * The parser should only assume that the first tFacePosition[ulFaceCount] of the 35 elements
+ * of the array should contain valid data.
+ */
+typedef struct OMX_FACEDETECTIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE    eCameraView;
+    OMX_U16 ulFaceCount;
+    OMX_TI_FACERESULT tFacePosition[35];// 35 is max faces supported by FDIF
+} OMX_FACEDETECTIONTYPE;
+
+/**
+ * MTIS Vendor Specific Motion estimation
+ * The extra data having MTIS motion estimation data is
+ * described with the following structure.
+ */
+typedef struct OMX_TI_MTISTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_S32 nMaxMVh;            /**< The maximum MV for horizontal direction */
+    OMX_S32 nMaxMVv;            /**< The maximum MV for vertical direction */
+    OMX_U16 nMVRelY[9];         /**< The mask for MV reliability */
+    OMX_U16 nMVRelX[9];         /**< The mask for MV reliability */
+    OMX_S32 nMVh[9];            /**< The MVs for horizontal direction */
+    OMX_S32 nMVv[9];            /**< The MVs for vertical direction */
+} OMX_TI_MTISTYPE;
+
+/**
+ * The OMX_EXTRADATATYPE enumeration is used to define the
+ * possible extra data payload types.
+ */
+typedef enum OMX_EXT_EXTRADATATYPE
+{
+   OMX_ExifAttributes = 0x7F000001, /**< Reserved region for introducing Vendor Extensions */
+   OMX_AncillaryData,                   /**< 0x7F000002 ancillary data */
+   OMX_WhiteBalance,                    /**< 0x7F000003 white balance resultant data */
+   OMX_UnsaturatedRegions,              /**< 0x7F000004 unsaturated regions data */
+   OMX_FaceDetection, /**< face detect data */
+   OMX_BarcodeDetection, /**< bar-code detct data */
+   OMX_FrontObjectDetection, /**< Front object detection data */
+   OMX_MotionEstimation, /**< motion Estimation data */
+   OMX_TI_MTISType,                     /**< 0x7F000009 MTIS motion Estimation data */
+   OMX_DistanceEstimation, /**< disctance estimation */
+   OMX_Histogram, /**< histogram */
+   OMX_FocusRegion, /**< focus region data */
+   OMX_ExtraDataPanAndScan,             /**< 0x7F00000D pan and scan data */
+   OMX_RawFormat, /**< custom RAW data format */
+   OMX_SensorType, /**< vendor & model of the sensor being used */
+   OMX_SensorCustomDataLength, /**< vendor specific custom data length */
+   OMX_SensorCustomData, /**< vendor specific data */
+   OMX_TI_FrameLayout,                  /**< 0x7F000012 vendor specific data */
+   OMX_TI_SEIinfo2004Frame1,    /**< 0x7F000013 Used for 2004 SEI message to be provided by video decoders */
+   OMX_TI_SEIinfo2004Frame2,    /**< 0x7F000014 Used for 2004 SEI message to be provided by video decoders */
+   OMX_TI_SEIinfo2010Frame1,    /**< 0x7F000015 Used for 2010 SEI message to be provided by video decoders */
+   OMX_TI_SEIinfo2010Frame2,    /**< 0x7F000016 Used for 2010 SEI message to be provided by video decoders */
+   OMX_TI_RangeMappingInfo,     /**< 0x7F000017 Used for Range mapping info provided by Video Decoders */
+   OMX_TI_RescalingInfo,        /**< 0x7F000018 Used for width/height rescaling info provided by Video Decoders */
+   OMX_TI_WhiteBalanceOverWrite,        /**< 0x7F000019 Used for manual AWB settings */
+   OMX_TI_ExtraData_Count,
+   OMX_TI_ExtraData_Max = OMX_TI_ExtraData_Count - 1,
+} OMX_EXT_EXTRADATATYPE;
+
+
+/**
+ * Enable Extra-data on a specific port.
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port on which this extra data to be assosiated
+ *  eExtraDataType :  Extra data type
+ *  bEnable      : Eneble/Disable this extra-data through port.
+ *
+ */
+typedef struct OMX_CONFIG_EXTRADATATYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_EXT_EXTRADATATYPE eExtraDataType;
+    OMX_TI_CAMERAVIEWTYPE eCameraView;
+    OMX_BOOL bEnable;
+} OMX_CONFIG_EXTRADATATYPE;
+
+/**
+ * JPEG header type
+ * */
+
+typedef enum OMX_JPEGHEADERTYPE{
+	OMX_NoHeader = 0,
+	OMX_JFIF,
+	OMX_EXIF
+}OMX_JPEGHEADERTYPE;
+/**
+ * Re-start marker configuration
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port on which this extra data to be assosiated
+ *  eJpegHeaderType : JPEG header type EXIF, JFIF, or No heeader.
+ */
+
+typedef struct OMX_CONFIG_JPEGHEEADERTYPE{
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_JPEGHEADERTYPE eJpegHeaderType;
+}OMX_CONFIG_JPEGHEEADERTYPE;
+
+/**
+ * Re-start marker configuration
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port on which this extra data to be assosiated
+ *  nRstInterval :  interval at which RST markers are to be inserted.
+ *  bEnable      : Eneble/Disable this RST marker insertion feature.
+ *
+ */
+
+typedef struct OMX_CONFIG_RSTMARKER{
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_U32 nRstInterval;
+	OMX_BOOL nEnable;
+}OMX_CONFIG_RSTMARKER;
+
+/**
+ * Enable Extra-data on a specific port.
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ * nMaxSize : max size
+ *
+ *
+ */
+typedef struct OMX_IMAGE_JPEGMAXSIZE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nMaxSize;
+} OMX_IMAGE_JPEGMAXSIZE;
+
+
+typedef enum OMX_IMAGESTAMPOPERATION{
+    OMX_NewImageStamp = 0,
+    OMX_Continuation
+}OMX_IMAGESTAMPOPERATION;
+
+
+/**
+ * Enable Extra-data on a specific port.
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ * nMaxSize : max size
+ *
+ *
+ */
+typedef struct OMX_PARAM_IMAGESTAMPOVERLAYTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_IMAGESTAMPOPERATION nOp;
+    OMX_U32 nLeft;
+    OMX_U32 nTop;
+    OMX_U32 nHeight;
+    OMX_U32 nWidth;
+    OMX_COLOR_FORMATTYPE eFormat;
+    OMX_U8 * pBitMap;
+} OMX_PARAM_IMAGESTAMPOVERLAYTYPE;
+
+
+/**
+ * Enable Extra-data on a specific port.
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ * nMaxSize : max size
+ *
+ *
+ */
+typedef struct OMX_PARAM_THUMBNAILTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nHeight;
+    OMX_U32 nWidth;
+    OMX_IMAGE_CODINGTYPE eCompressionFormat;
+    OMX_COLOR_FORMATTYPE eColorFormat;
+    OMX_U32 nQuality;
+    OMX_U32 nMaxSize;
+} OMX_PARAM_THUMBNAILTYPE;
+
+/**
+ * Red-Eye Removal Enum
+ */
+typedef enum OMX_REDEYEREMOVALTYPE{
+    OMX_RedEyeRemovalOff    = 0, /** No red eye removal*/
+    OMX_RedEyeRemovalOn, /**    Red eye removal on*/
+    OMX_RedEyeRemovalAuto,  /** Red eye removal will be done automatically when detected*/
+    OMX_RedEyeRemovalKhronosExtensions = 0x6F000000,    /** Reserved region for introducing Khronos Standard Extensions*/
+    OMX_RedEyeRemovalVendorStartUnused = 0x7F000000,    /** Reserved region for introducing Vendor Extensions*/
+    OMX_RedEyeRemovalMax = 0x7FFFFFFF
+}OMX_REDEYEREMOVALTYPE;
+
+/**
+ * Enable Extra-data on a specific port.
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  nLeft: is the leftmost coordinate of the detection area rectangle (such as face region).
+ *  nTop: is the topmost coordinate of the detection area rectangle (such as face region).
+ *  nWidth: is the width of the detection area rectangle  in pixels.
+ *  nHeight: is the height of the detection area rectangle in pixels.
+ *  nARGBEyeColor indicates a 32-bit eye color to replace the red-eye, where bits 0-7 are blue, bits 15-8 are green, bits 24-16 are red, and bits 31-24 are for alpha. When all zero indicates automatic choice.
+
+ *
+ */
+typedef struct OMX_CONFIG_REDEYEREMOVALTYPE {
+   OMX_U32 nSize;
+   OMX_VERSIONTYPE nVersion;
+   OMX_U32 nPortIndex;
+   OMX_S32 nLeft;
+   OMX_S32 nTop;
+   OMX_U32 nWidth;
+   OMX_U32 nHeight;
+   OMX_U32 nARGBEyeColor;
+   OMX_REDEYEREMOVALTYPE eMode;
+} OMX_CONFIG_REDEYEREMOVALTYPE;
+
+
+
+
+
+
+/**
+ * Video capture YUV Range Enum
+ */
+typedef enum OMX_VIDEOYUVRANGETYPE{
+    OMX_ITURBT601 = 0,
+    OMX_Full8Bit,
+    OMX_VideoYUVRangeKhronosExtensions = 0x6F000000,    /** Reserved region for introducing Khronos Standard Extensions*/
+    OMX_VideoYUVRangeVendorStartUnused = 0x7F000000,    /** Reserved region for introducing Vendor Extensions*/
+    OMX_VideoYUVRangeMax = 0x7FFFFFFF
+}OMX_VIDEOYUVRANGETYPE;
+
+/**
+ * Enable Extra-data on a specific port.
+ *
+ *
+ *
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *
+ */
+typedef struct OMX_PARAM_VIDEOYUVRANGETYPE {
+   OMX_U32 nSize;
+   OMX_VERSIONTYPE nVersion;
+   OMX_U32 nPortIndex;
+   OMX_VIDEOYUVRANGETYPE eYUVRange;
+} OMX_PARAM_VIDEOYUVRANGETYPE;
+
+/**
+ * Video noise filter mode range enum
+ */
+typedef enum OMX_VIDEONOISEFILTERMODETYPE{
+    OMX_VideoNoiseFilterModeOff = 0,
+    OMX_VideoNoiseFilterModeOn,
+    OMX_VideoNoiseFilterModeAuto,
+    OMX_VideoNoiseFilterModeExtensions = 0x6F000000,    /** Reserved region for introducing Khronos Standard Extensions */
+    OMX_VideoNoiseFilterModeStartUnused = 0x7F000000,   /** Reserved region for introducing Vendor Extensions */
+    OMX_VideoNoiseFilterModeMax = 0x7FFFFFFF
+} OMX_VIDEONOISEFILTERMODETYPE;
+
+/**
+ * Enable video noise filter.
+ *
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes
+ *  nVersion    : OMX specification version information
+ *  nPortIndex  : Port that this structure applies to
+ *  eMode       : Video noise filter mode (on/off/auto)
+ */
+typedef struct OMX_PARAM_VIDEONOISEFILTERTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEONOISEFILTERMODETYPE eMode;
+} OMX_PARAM_VIDEONOISEFILTERTYPE;
+
+
+/**
+ * High ISO Noise filter mode range enum
+ */
+typedef enum OMX_ISONOISEFILTERMODETYPE{
+    OMX_ISONoiseFilterModeOff = 0,
+    OMX_ISONoiseFilterModeOn,
+    OMX_ISONoiseFilterModeAuto,
+    OMX_ISONoiseFilterModeExtensions = 0x6F000000,    /** Reserved region for introducing Khronos Standard Extensions */
+    OMX_ISONoiseFilterModeStartUnused = 0x7F000000,   /** Reserved region for introducing Vendor Extensions */
+    OMX_ISONoiseFilterModeMax = 0x7FFFFFFF
+} OMX_ISONOISEFILTERMODETYPE;
+
+/**
+ * Enable ISO noise filter.
+ *
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes
+ *  nVersion    : OMX specification version information
+ *  nPortIndex  : Port that this structure applies to
+ *  eMode       : ISO noise filter (NSF2 is used) mode (on/off/auto)
+ */
+typedef struct OMX_PARAM_ISONOISEFILTERTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_ISONOISEFILTERMODETYPE eMode;
+} OMX_PARAM_ISONOISEFILTERTYPE;
+
+/**
+ * Structure used to to call OMX_GetParams() for each
+ * increment of "Index" starting with "0"
+ *
+ * STRUCT MEMBERS:
+ * nSize            : Size of the structure in bytes
+ * nVersion         : OMX specification version information
+ * nIndex           : Index of the sDCCURI 0..MAX_URI_LENGTH
+ * sDCCURI          : Look-up table containing strings. Ends with '\0'
+ */
+typedef struct OMX_TI_PARAM_DCCURIINFO {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nIndex;
+    OMX_S8 sDCCURI[MAX_URI_LENGTH];
+} OMX_TI_PARAM_DCCURIINFO;
+
+/**
+ * Structure used to configure DCC buffer
+ *
+ * STRUCT MEMBERS:
+ * nSize            : Size of the structure in bytes
+ * nVersion         : OMX specification version information
+ * nDCCURIBuffSize  : Size of the pDCCURIBuff in bytes
+ * pDCCURIBuff      : Pointer to a buffer
+ */
+typedef struct OMX_TI_PARAM_DCCURIBUFFER {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nDCCURIBuffSize;
+    OMX_U8 *pDCCURIBuff;
+} OMX_TI_PARAM_DCCURIBUFFER;
+
+/**
+ * Manual White Balance color temperature
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  nColorTemperature : Color Temperature in K
+ */
+typedef struct OMX_TI_CONFIG_WHITEBALANCECOLORTEMPTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nColorTemperature;
+} OMX_TI_CONFIG_WHITEBALANCECOLORTEMPTYPE;
+
+/**
+ * Focus spot weighting range enum
+ */
+typedef enum OMX_TI_CONFIG_FOCUSSPOTMODETYPE {
+    OMX_FocusSpotDefault = 0,                           /** Makes CommonFocusRegion to be used. */
+    OMX_FocusSpotSinglecenter,
+    OMX_FocusSpotMultiNormal,
+    OMX_FocusSpotMultiAverage,
+    OMX_FocusSpotMultiCenter,
+    OMX_FocusSpotExtensions = 0x6F000000,               /** Reserved region for introducing Khronos Standard Extensions */
+    OMX_FocusSpotModeStartUnused = 0x7F000000,          /** Reserved region for introducing Vendor Extensions */
+    OMX_FocusSpotModeMax = 0x7FFFFFFF
+} OMX_TI_CONFIG_FOCUSSPOTMODETYPE;
+
+/**
+ * Focus Spot Weighting configuration.
+ *
+ * STRUCT MEMBERS:
+ *  nSize       : Size of the structure in bytes
+ *  nVersion    : OMX specification version information
+ *  nPortIndex  : Port that this structure applies to
+ *  eMode       : Spot Weighting mode
+ */
+typedef struct OMX_TI_CONFIG_FOCUSSPOTWEIGHTINGTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_CONFIG_FOCUSSPOTMODETYPE eMode;
+} OMX_TI_CONFIG_FOCUSSPOTWEIGHTINGTYPE;
+
+/**
+ * Enumeration of possible Exposure control types for OMX_EXPOSURECONTROLTYPE
+ */
+typedef enum OMX_TI_EXTEXPOSURECONTROLTYPE {
+    OMX_TI_ExposureControlVeryLong = OMX_ExposureControlVendorStartUnused + 1
+} OMX_TI_EXTEXPOSURECONTROLTYPE;
+
+/**
+ * Variable frame rate configuration.
+ *
+ * STRUCT MEMBERS:
+ *  nSize         : Size of the structure in bytes
+ *  nVersion      : OMX specification version information
+ *  nPortIndex    : Port that this structure applies to
+ *  xMinFramerate : Minimum variable frame rate value
+ */
+typedef struct OMX_TI_PARAM_VARFRAMERATETYPE {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_U32 xMinFramerate;
+} OMX_TI_PARAM_VARFRAMERATETYPE;
+
+/**
+ * Exposure config for right frame
+ */
+typedef struct OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_U32 nApertureFNumber;  /**< e.g. nApertureFNumber = 2 implies "f/2" - Q16 format */
+	OMX_U32 nShutterSpeedMsec; /**< Shutterspeed in milliseconds */
+	OMX_U32 nSensitivity;      /**< e.g. nSensitivity = 100 implies "ISO 100" */
+} OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE;
+
+/**
+ * Auto Convergence mode enum
+ */
+typedef enum OMX_TI_AUTOCONVERGENCEMODETYPE {
+	OMX_TI_AutoConvergenceModeDisable,
+	OMX_TI_AutoConvergenceModeFrame,
+	OMX_TI_AutoConvergenceModeCenter,
+	OMX_TI_AutoConvergenceModeFocusFaceTouch,
+	OMX_TI_AutoConvergenceModeManual,
+	OMX_TI_AutoConvergenceExtensions = 0x6F000000,    /** Reserved region for introducing Khronos Standard Extensions */
+	OMX_TI_AutoConvergenceStartUnused = 0x7F000000,   /** Reserved region for introducing Vendor Extensions */
+	OMX_TI_AutoConvergenceModeMax = 0x7FFFFFFF
+} OMX_TI_AUTOCONVERGENCEMODETYPE;
+
+/**
+ * Variable farame rate configuration.
+ *
+ * STRUCT MEMBERS:
+ *  nSize             : Size of the structure in bytes
+ *  nVersion          : OMX specification version information
+ *  nPortIndex        : Port that this structure applies to
+ *  eACMode           : Auto convergence mode
+ *  nManualConverence : Manual Converence value
+ *  nACProcWinStartX  : Start X AC Window
+ *  nACProcWinStartY  : Start Y AC Window
+ *  nACProcWinWidth   : Width of AC Window
+ *  nACProcWinHeight  : Height of AC Window
+ *  bACStatus         : output status from AL alg
+ */
+typedef struct OMX_TI_CONFIG_CONVERGENCETYPE {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_TI_AUTOCONVERGENCEMODETYPE eACMode;
+	OMX_S32 nManualConverence;
+	OMX_U32 nACProcWinStartX;
+	OMX_U32 nACProcWinStartY;
+	OMX_U32 nACProcWinWidth;
+	OMX_U32 nACProcWinHeight;
+	OMX_BOOL bACStatus;
+} OMX_TI_CONFIG_CONVERGENCETYPE;
+
+/**
+ * Camera specific version.
+ *
+ * STRUCT MEMBERS:
+ *  nBranch        : Branch
+ *  nCommitID      : Commit ID
+ *  nBuildDateTime : Build date and time
+ *  nExtraInfo     : rederved for future use
+ */
+typedef struct OMX_TI_CAMERASPECVERSIONTYPE {
+	OMX_U8 nBranch[64];
+	OMX_U8 nCommitID[64];
+	OMX_U8 nBuildDateTime[64];
+	OMX_U8 nExtraInfo[64];
+} OMX_TI_CAMERASPECVERSIONTYPE;
+
+/**
+ * Stereo frame layout enum
+ */
+typedef enum OMX_TI_STEREOFRAMELAYOUTTYPE {
+	OMX_TI_StereoFrameLayout2D,
+	OMX_TI_StereoFrameLayoutTopBottom,
+	OMX_TI_StereoFrameLayoutLeftRight,
+	OMX_TI_StereoFrameLayoutMax = 0x7FFFFFFF
+} OMX_TI_STEREOFRAMELAYOUTTYPE;
+
+/**
+ * Camera frame layout type.
+ *
+ * STRUCT MEMBERS:
+ *  eFrameLayout    : frame layout
+ *  nSubsampleRatio : subsample ratio
+ */
+typedef struct OMX_TI_FRAMELAYOUTTYPE {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_TI_STEREOFRAMELAYOUTTYPE eFrameLayout;
+	OMX_U32 nSubsampleRatio; /**  Subsampling ratio, Q15.7 */
+} OMX_TI_FRAMELAYOUTTYPE;
+
+/**
+ * The OMX_TI_COLOR_FORMATTYPE enumeration is used to define the
+ * extended color format types.
+ */
+typedef enum OMX_TI_COLOR_FORMATTYPE {
+	OMX_TI_COLOR_FormatYUV420PackedSemiPlanarInterlaced =
+	    (OMX_COLOR_FORMATTYPE) OMX_COLOR_FormatVendorStartUnused + 1,
+	OMX_TI_COLOR_FormatRawBayer10bitStereo =
+	    OMX_COLOR_FormatVendorStartUnused + 2, /**< 10 bit raw for stereo */
+        OMX_TI_COLOR_FormatYUV420PackedSemiPlanar =
+            (OMX_COLOR_FORMATTYPE) OMX_COLOR_FormatVendorStartUnused  + 0x100 /* 0x100 is used since it is the corresponding HAL pixel fromat */
+} OMX_TI_COLOR_FORMATTYPE;
+
+/**
+ * The OMX_TI_EXIFTAGSTATUS enumeration is used to define the
+ * tag status types.
+ */
+typedef enum OMX_TI_EXIFTAGSTATUS {
+	OMX_TI_TagReadOnly,     /**< implies this tag is generated within omx-camera >*/
+	OMX_TI_TagReadWrite,    /**< implies this tag can be overwritten by client >*/
+	OMX_TI_TagUpdated,      /**< client has to use this to indicate the specific tag is overwritten >*/
+	OMX_TI_ExifStatus_Max = 0x7fffffff
+} OMX_TI_EXIFTAGSTATUS;
+
+typedef struct OMX_TI_CONFIG_EXIF_TAGS {
+	OMX_U32                 nSize;
+	OMX_VERSIONTYPE         nVersion;
+	OMX_U32                 nPortIndex;
+	OMX_TI_EXIFTAGSTATUS    eStatusImageWidth;
+	OMX_U32                 ulImageWidth;
+	OMX_TI_EXIFTAGSTATUS    eStatusImageHeight;
+	OMX_U32                 ulImageHeight;
+	OMX_TI_EXIFTAGSTATUS    eStatusBitsPerSample;
+	OMX_U16                 usBitsPerSample[3];
+	OMX_TI_EXIFTAGSTATUS    eStatusCompression;
+	OMX_U16                 usCompression;
+	OMX_TI_EXIFTAGSTATUS    eStatusPhotometricInterpretation;
+	OMX_U16                 usPhotometricInterpretation;
+	OMX_TI_EXIFTAGSTATUS    eStatusOrientation;
+	OMX_U16                 usOrientation;
+	OMX_TI_EXIFTAGSTATUS    eStatusSamplesPerPixel;
+	OMX_U16                 usSamplesPerPixel;
+	OMX_TI_EXIFTAGSTATUS    eStatusPlanarConfiguration;
+	OMX_U16                 usPlanarConfiguration;
+	OMX_TI_EXIFTAGSTATUS    eStatusYCbCrSubSampling;
+	OMX_U16                 usYCbCrSubSampling[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusYCbCrPositioning;
+	OMX_U16                 usYCbCrPositioning;
+	OMX_TI_EXIFTAGSTATUS    eStatusXResolution;
+	OMX_U32                 ulXResolution[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusYResolution;
+	OMX_U32                 ulYResolution[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusResolutionUnit;
+	OMX_U16                 usResolutionUnit;
+
+	OMX_TI_EXIFTAGSTATUS    eStatusRowsPerStrip;
+	OMX_U32                 ulRowsPerStrip;
+	OMX_TI_EXIFTAGSTATUS    eStatusDataSize;
+	OMX_U32                 ulDataSize;
+
+	OMX_TI_EXIFTAGSTATUS    eStatusTransferFunction;
+	OMX_U16                 usTransferFunction[3*256];
+	OMX_TI_EXIFTAGSTATUS    eStatusWhitePoint;
+	OMX_U32                 ulWhitePoint[4]; //2x2
+	OMX_TI_EXIFTAGSTATUS    eStatusPrimaryChromaticities;
+	OMX_U32                 ulPrimaryChromaticities[12]; //2x6
+	OMX_TI_EXIFTAGSTATUS    eStatusYCbCrCoefficients;
+	OMX_U32                 ulYCbCrCoefficients[6]; //2x3
+	OMX_TI_EXIFTAGSTATUS    eStatusReferenceBlackWhite;
+	OMX_U32                 ulReferenceBlackWhite[12]; //2x6
+	OMX_TI_EXIFTAGSTATUS    eStatusDateTime;
+	OMX_S8*                 pDateTimeBuff;
+	OMX_U32                 ulDateTimeBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusImageDescription;
+	OMX_S8*                 pImageDescriptionBuff;
+	OMX_U32                 ulImageDescriptionBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusMake;
+	OMX_S8*                 pMakeBuff;
+	OMX_U32                 ulMakeBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusModel;
+	OMX_S8*                 pModelBuff;
+	OMX_U32                 ulModelBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusSoftware;
+	OMX_S8*                 pSoftwareBuff;
+	OMX_U32                 ulSoftwareBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusArtist;
+	OMX_S8*                 pArtistBuff;
+	OMX_U32                 ulArtistBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusCopyright;
+	OMX_S8*                 pCopyrightBuff;
+	OMX_U32                 ulCopyrightBuffSizeBytes;
+
+	OMX_TI_EXIFTAGSTATUS    eStatusExifVersion;
+	OMX_S8                  cExifVersion[4];
+	OMX_TI_EXIFTAGSTATUS    eStatusFlashpixVersion;
+	OMX_S8                  cFlashpixVersion[4];
+	OMX_TI_EXIFTAGSTATUS    eStatusColorSpace;
+	OMX_U16                 usColorSpace;
+	OMX_TI_EXIFTAGSTATUS    eStatusComponentsConfiguration;
+	OMX_S8                  cComponentsConfiguration[4];
+	OMX_TI_EXIFTAGSTATUS    eStatusCompressedBitsPerPixel;
+	OMX_U32                 ulCompressedBitsPerPixel[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusPixelXDimension;
+	OMX_U32                 ulPixelXDimension;
+	OMX_TI_EXIFTAGSTATUS    eStatusPixelYDimension;
+	OMX_U32                 ulPixelYDimension;
+	OMX_TI_EXIFTAGSTATUS    eStatusMakerNote;
+	OMX_S8*                 pMakerNoteBuff;
+	OMX_U32                 ulMakerNoteBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusUserComment;
+	OMX_S8*                 pUserCommentBuff;
+	OMX_U32                 ulUserCommentBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusRelatedSoundFile;
+	OMX_S8                  cRelatedSoundFile[13];
+	OMX_TI_EXIFTAGSTATUS    eStatusDateTimeOriginal;
+	OMX_S8*                 pDateTimeOriginalBuff;
+	OMX_U32                 ulDateTimeOriginalBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusDateTimeDigitized;
+	OMX_S8*                 pDateTimeDigitizedBuff;
+	OMX_U32                 ulDateTimeDigitizedBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusSubSecTime;
+	OMX_S8*                 pSubSecTimeBuff;
+	OMX_U32                 ulSubSecTimeBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusSubSecTimeOriginal;
+	OMX_S8*                 pSubSecTimeOriginalBuff;
+	OMX_U32                 ulSubSecTimeOriginalBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusSubSecTimeDigitized;
+	OMX_S8*                 pSubSecTimeDigitizedBuff;
+	OMX_U32                 ulSubSecTimeDigitizedBuffSizeBytes;
+
+	OMX_TI_EXIFTAGSTATUS    eStatusExposureTime;
+	OMX_U32                 ulExposureTime[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusFNumber;
+	OMX_U32                 ulFNumber[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusExposureProgram;
+	OMX_U16                 usExposureProgram;
+	OMX_TI_EXIFTAGSTATUS    eStatusSpectralSensitivity;
+	OMX_S8*                 pSpectralSensitivityBuff;
+	OMX_U32                 ulSpectralSensitivityBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusISOCount;
+	OMX_U16                 usISOCount;
+	OMX_TI_EXIFTAGSTATUS    eStatusISOSpeedRatings;
+	OMX_U16*                pISOSpeedRatings;
+	OMX_TI_EXIFTAGSTATUS    eStatusOECF;
+	OMX_S8*                 pOECFBuff;
+	OMX_U32                 ulOECFBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusShutterSpeedValue;
+	OMX_S32                 slShutterSpeedValue[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusApertureValue;
+	OMX_U32                 ulApertureValue[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusBrightnessValue;
+	OMX_S32                 slBrightnessValue[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusExposureBiasValue;
+	OMX_S32                 slExposureBiasValue[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusMaxApertureValue;
+	OMX_U32                 ulMaxApertureValue[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusSubjectDistance;
+	OMX_U32                 ulSubjectDistance[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusMeteringMode;
+	OMX_U16                 usMeteringMode;
+	OMX_TI_EXIFTAGSTATUS    eStatusLightSource;
+	OMX_U16                 usLightSource;
+	OMX_TI_EXIFTAGSTATUS    eStatusFlash;
+	OMX_U16                 usFlash;
+	OMX_TI_EXIFTAGSTATUS    eStatusFocalLength;
+	OMX_U32                 ulFocalLength[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusSubjectArea;
+	OMX_U16                 usSubjectArea[4];
+	OMX_TI_EXIFTAGSTATUS    eStatusFlashEnergy;
+	OMX_U32                 ulFlashEnergy[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusSpatialFrequencyResponse;
+	OMX_S8*                 pSpatialFrequencyResponseBuff;
+	OMX_U32                 ulSpatialFrequencyResponseBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusFocalPlaneXResolution;
+	OMX_U32                 ulFocalPlaneXResolution[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusFocalPlaneYResolution;
+	OMX_U32                 ulFocalPlaneYResolution[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusFocalPlaneResolutionUnit;
+	OMX_U16                 usFocalPlaneResolutionUnit;
+	OMX_TI_EXIFTAGSTATUS    eStatusSubjectLocation;
+	OMX_U16                 usSubjectLocation[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusExposureIndex;
+	OMX_U32                 ulExposureIndex[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusSensingMethod;
+	OMX_U16                 usSensingMethod;
+	OMX_TI_EXIFTAGSTATUS    eStatusFileSource;
+	OMX_S8                  cFileSource;
+	OMX_TI_EXIFTAGSTATUS    eStatusSceneType;
+	OMX_S8                  cSceneType;
+	OMX_TI_EXIFTAGSTATUS    eStatusCFAPattern;
+	OMX_S8*                 pCFAPatternBuff;
+	OMX_U32                 ulCFAPatternBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusCustomRendered;
+	OMX_U16                 usCustomRendered;
+	OMX_TI_EXIFTAGSTATUS    eStatusExposureMode;
+	OMX_U16                 usExposureMode;
+	OMX_TI_EXIFTAGSTATUS    eStatusWhiteBalance;
+	OMX_U16                 usWhiteBalance;
+	OMX_TI_EXIFTAGSTATUS    eStatusDigitalZoomRatio;
+	OMX_U32                 ulDigitalZoomRatio[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusFocalLengthIn35mmFilm;
+	OMX_U16                 usFocalLengthIn35mmFilm;
+	OMX_TI_EXIFTAGSTATUS    eStatusSceneCaptureType;
+	OMX_U16                 usSceneCaptureType;
+	OMX_TI_EXIFTAGSTATUS    eStatusGainControl;
+	OMX_U16                 usGainControl;
+	OMX_TI_EXIFTAGSTATUS    eStatusContrast;
+	OMX_U16                 usContrast;
+	OMX_TI_EXIFTAGSTATUS    eStatusSaturation;
+	OMX_U16                 usSaturation;
+	OMX_TI_EXIFTAGSTATUS    eStatusSharpness;
+	OMX_U16                 usSharpness;
+	OMX_TI_EXIFTAGSTATUS    eStatusDeviceSettingDescription;
+	OMX_S8*                 pDeviceSettingDescriptionBuff;
+	OMX_U32                 ulDeviceSettingDescriptionBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusSubjectDistanceRange;
+	OMX_U16                 usSubjectDistanceRange;
+
+	OMX_TI_EXIFTAGSTATUS    eStatusImageUniqueID;
+	OMX_S8                  cImageUniqueID[33];
+	OMX_U8*                 pPrivateNextIFDPointer;    //Should not be used by the application
+	OMX_U8*                 pPrivateThumbnailSize;     //Should not be used by the application
+	OMX_U8*                 pPrivateTiffHeaderPointer; //Should not be used by the application
+
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsVersionId;
+	OMX_U8                  ucGpsVersionId[4];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpslatitudeRef;
+	OMX_S8                  cGpslatitudeRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsLatitude;
+	OMX_U32                 ulGpsLatitude[6];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsLongitudeRef;
+	OMX_S8                  cGpsLongitudeRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsLongitude;
+	OMX_U32                 ulGpsLongitude[6];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsAltitudeRef;
+	OMX_U8                  ucGpsAltitudeRef;
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsAltitude;
+	OMX_U32                 ulGpsAltitude[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsTimeStamp;
+	OMX_U32                 ulGpsTimeStamp[6];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsSatellites;
+	OMX_S8*                 pGpsSatellitesBuff;
+	OMX_U32                 ulGpsSatellitesBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsStatus;
+	OMX_S8                  cGpsStatus[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsMeasureMode;
+	OMX_S8                  cGpsMeasureMode[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDop;
+	OMX_U32                 ulGpsDop[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsSpeedRef;
+	OMX_S8                  cGpsSpeedRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsSpeed;
+	OMX_U32                 ulGpsSpeed[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsTrackRef;
+	OMX_S8                  cGpsTrackRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsTrack;
+	OMX_U32                 ulGpsTrack[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsImgDirectionRef;
+	OMX_S8                  cGpsImgDirectionRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsImgDirection;
+	OMX_U32                 ulGpsImgDirection[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsMapDatum;
+	OMX_S8*                 pGpsMapDatumBuff;
+	OMX_U32                 ulGpsMapDatumBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDestLatitudeRef;
+	OMX_S8                  cGpsDestLatitudeRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDestLatitude;
+	OMX_U32                 ulGpsDestLatitude[6];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDestLongitudeRef;
+	OMX_S8                  cGpsDestLongitudeRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDestLongitude;
+	OMX_U32                 ulGpsDestLongitude[6];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDestBearingRef;
+	OMX_S8                  cGpsDestBearingRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDestBearing;
+	OMX_U32                 ulGpsDestBearing[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDestDistanceRef;
+	OMX_S8                  cGpsDestDistanceRef[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDestDistance;
+	OMX_U32                 ulGpsDestDistance[2];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsProcessingMethod;
+	OMX_S8*                 pGpsProcessingMethodBuff;
+	OMX_U32                 ulGpsProcessingMethodBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsAreaInformation;
+	OMX_S8*                 pGpsAreaInformationBuff;
+	OMX_U32                 ulGpsAreaInformationBuffSizeBytes;
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDateStamp;
+	OMX_S8                  cGpsDateStamp[11];
+	OMX_TI_EXIFTAGSTATUS    eStatusGpsDifferential;
+	OMX_U16                 usGpsDifferential;
+} OMX_TI_CONFIG_EXIF_TAGS;
+
+/**
+ * Structure used to configure current OMX_TI_SENMOUNT_TYPE
+ *
+ * @param nSenId
+ * @param nRotation
+ */
+typedef struct OMX_TI_SENMOUNT_TYPE {
+    OMX_U32             nSenId;
+    OMX_U32             nRotation;
+}OMX_TI_SENMOUNT_TYPE;
+
+/**
+ * Structure used to configure current OMX_TI_VARFPSTYPE
+ *
+ * @param nVarFPSMin    Number of the smallest FPS supported.
+ * @param nVarFPSMax    Number of the biggest FPS supported.
+ */
+typedef struct OMX_TI_VARFPSTYPE {
+    OMX_U32                 nVarFPSMin;
+    OMX_U32                 nVarFPSMax;
+} OMX_TI_VARFPSTYPE;
+
+/**
+ * Structure used to configure current OMX_TI_CONFIG_SHAREDBUFFER
+ *
+ * STRUCT MEMBERS:
+ * nSize            : Size of the structure in bytes
+ * nVersion         : OMX specification version information
+ * nPortIndex       : Port that this structure applies to
+ * nSharedBuffSize  : Size of the pSharedBuff in bytes
+ * pSharedBuff      : Pointer to a buffer
+ */
+typedef struct OMX_TI_CONFIG_SHAREDBUFFER {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_U32 nSharedBuffSize;
+	OMX_U8* pSharedBuff;
+} OMX_TI_CONFIG_SHAREDBUFFER;
+
+/**
+ * Structure used to configure current OMX_TI_CAPRESTYPE
+ *
+ * STRUCT MEMBERS:
+ * nSize            : Size of the structure in bytes
+ * nVersion         : OMX specification version information
+ * nPortIndex       : Port that this structure applies to
+ * nWidthMin        : Number of the smallest width supported
+ * nHeightMin       : Number of the smallest height supported
+ * nWidthMax        : Number of the biggest width supported
+ * nHeightMax       : Number of the biggest height supported
+ */
+typedef struct OMX_TI_CAPRESTYPE {
+	OMX_U32         nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32         nPortIndex;
+	OMX_U32         nWidthMin;  // smallest width supported
+	OMX_U32         nHeightMin; // smallest height supported
+	OMX_U32         nWidthMax;  // biggest width supported
+	OMX_U32         nHeightMax; // biggest height supported
+} OMX_TI_CAPRESTYPE;
+
+/**
+ * Structure used to configure current OMX_TI_CAPTYPE
+ *
+ * STRUCT MEMBERS:
+ * nSize                                : Size of the structure in bytes
+ * nVersion                             : OMX specification version information
+ * nPortIndex                           : Port that this structure applies to
+ * ulPreviewFormatCount                 : Number of the supported preview pixelformat count
+ * ePreviewFormats                      : Array containing the supported preview pixelformat count
+ * ulImageFormatCount                   : Number of the supported image pixelformat count
+ * eImageFormats                        : Array containing the supported image pixelformat count
+ * tPreviewResRange                     : Supported preview resolution range
+ * tImageResRange                       : Supported image resolution range
+ * tThumbResRange                       : Supported thumbnail resolution range
+ * ulWhiteBalanceCount                  : Supported whitebalance mode count
+ * eWhiteBalanceModes                   : Array containing the whitebalance modes
+ * ulColorEffectCount                   : Supported effects count
+ * eColorEffects                        : Array containing the supported effects
+ * xMaxWidthZoom                        : Fixed point value stored as Q16 representing the maximum value for the Zoom allowed on Width
+ * xMaxHeightZoom                       : Fixed point value stored as Q16 representing the maximum value for the Zoom allowed on Height
+ * ulFlickerCount                       : Number of the supported anti-flicker modes
+ * eFlicker                             : Array containing the supported anti-flicker modes
+ * ulExposureModeCount                  : Number of the supported exposure modes
+ * eExposureModes                       : Array containing the supported exposure modes
+ * bLensDistortionCorrectionSupported   : Flag for Lens Distortion Correction Algorithm support
+ * bISONoiseFilterSupported             : Flag for Noise Filter Algorithm support
+ * xEVCompensationMin                   : Fixed point value stored as Q16 representing the EVCompensation minumum allowed value
+ * xEVCompensationMax                   : Fixed point value stored as Q16 representing the EVCompensation maximum allowed value
+ * nSensitivityMax                      : nSensitivityMax = 100 implies maximum supported equal to "ISO 100"
+ * ulFocusModeCount                     : Number of the supported focus modes
+ * eFocusModes                          : Array containing the supported focus modes
+ * ulSceneCount                         : Number of the supported scenes
+ * eSceneModes                          : Array containing the supported scenes
+ * ulFlashCount                         : Number of the supported flash modes
+ * eFlashModes                          : Array containing the supported flash modes
+ * xFramerateMin                        : Fixed point value stored as Q16 representing the minimum framerate allowed
+ * xFramerateMax                        : Fixed point value stored as Q16 representing the maximum framerate allowed
+ * bContrastSupported                   : Flag showing if the contrast is supported
+ * bSaturationSupported                 : Flag showing if the saturation is supported
+ * bBrightnessSupported                 : Flag showing if the brightness is supported
+ * bProcessingLevelSupported            : Flag showing if the processing level is supported
+ * bQFactorSupported                    : Flag showing if the QFactor is supported
+ * ulPrvVarFPSModesCount                : Number of preview FPS modes
+ * tPrvVarFPSModes                      : Preview FPS modes
+ * ulCapVarFPSModesCount                : Number of capture FPS modes
+ * tCapVarFPSModes                      : Capture FPS modes
+ * tSenMounting                         : Sensor mount information
+ */
+typedef struct OMX_TI_CAPTYPE {
+	OMX_U32                 nSize;
+	OMX_VERSIONTYPE         nVersion;
+	OMX_U32                 nPortIndex;
+	OMX_U16                 ulPreviewFormatCount;   // supported preview pixelformat count
+	OMX_COLOR_FORMATTYPE    ePreviewFormats[100];
+	OMX_U16                 ulImageFormatCount;     // supported image pixelformat count
+	OMX_COLOR_FORMATTYPE    eImageFormats[100];
+	OMX_TI_CAPRESTYPE       tPreviewResRange;       // supported preview resolution range
+	OMX_TI_CAPRESTYPE       tImageResRange;         // supported image resolution range
+	OMX_TI_CAPRESTYPE       tThumbResRange;         // supported thumbnail resolution range
+	OMX_U16                 ulWhiteBalanceCount;    // supported whitebalance mode count
+	OMX_WHITEBALCONTROLTYPE eWhiteBalanceModes[100];
+	OMX_U16                 ulColorEffectCount;     // supported effects count
+	OMX_IMAGEFILTERTYPE     eColorEffects[100];
+	OMX_S32                 xMaxWidthZoom;          // Fixed point value stored as Q16
+	OMX_S32                 xMaxHeightZoom;         // Fixed point value stored as Q16
+	OMX_U16                 ulFlickerCount;         // supported anti-flicker mode count
+	OMX_COMMONFLICKERCANCELTYPE     eFlicker[100];
+	OMX_U16                 ulExposureModeCount;    // supported exposure mode count
+	OMX_EXPOSURECONTROLTYPE eExposureModes[100];
+	OMX_BOOL                bLensDistortionCorrectionSupported;
+	OMX_BOOL                bISONoiseFilterSupported;
+	OMX_S32                 xEVCompensationMin;     // Fixed point value stored as Q16
+	OMX_S32                 xEVCompensationMax;     // Fixed point value stored as Q16
+	OMX_U32                 nSensitivityMax;        // nSensitivityMax = 100 implies maximum supported equal to "ISO 100"
+	OMX_U16                 ulFocusModeCount;       // supported focus mode count
+	OMX_IMAGE_FOCUSCONTROLTYPE      eFocusModes[100];
+	OMX_U16                 ulSceneCount;           // supported scene count
+	OMX_SCENEMODETYPE       eSceneModes[100];
+	OMX_U16                 ulFlashCount;           // supported flash modes count
+	OMX_IMAGE_FLASHCONTROLTYPE      eFlashModes[100];
+	OMX_U32                 xFramerateMin;          // Fixed point value stored as Q16
+	OMX_U32                 xFramerateMax;          // Fixed point value stored as Q16
+	OMX_BOOL                bContrastSupported;
+	OMX_BOOL                bSaturationSupported;
+	OMX_BOOL                bBrightnessSupported;
+	OMX_BOOL                bProcessingLevelSupported;
+	OMX_BOOL                bQFactorSupported;
+	OMX_U16                 ulPrvVarFPSModesCount;  // supported variable FPS preview modes count
+	OMX_TI_VARFPSTYPE       tPrvVarFPSModes[10];
+	OMX_U16                 ulCapVarFPSModesCount;  // supported variable FPS capture modes count
+	OMX_TI_VARFPSTYPE       tCapVarFPSModes[10];
+	OMX_TI_SENMOUNT_TYPE    tSenMounting;
+} OMX_TI_CAPTYPE;
+
+/**
+ * Defines 3A Face priority mode.
+ *
+ * STRUCT MEMBERS:
+ *  nSize               : Size of the structure in bytes
+ *  nVersion            : OMX specification version information
+ *  nPortIndex          : Port that this structure applies to
+ *  bAwbFaceEnable      : Enable Face priority for Auto White Balance
+ *  bAeFaceEnable       : Enable Face priority for Auto Exposure
+ *  bAfFaceEnable       : Enable Face priority for Auto Focus
+ */
+typedef struct OMX_TI_CONFIG_3A_FACE_PRIORITY {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_BOOL bAwbFaceEnable;
+	OMX_BOOL bAeFaceEnable;
+	OMX_BOOL bAfFaceEnable;
+} OMX_TI_CONFIG_3A_FACE_PRIORITY;
+
+/**
+ * Defines 3A Region priority mode.
+ *
+ * STRUCT MEMBERS:
+ *  nSize               : Size of the structure in bytes
+ *  nVersion            : OMX specification version information
+ *  nPortIndex          : Port that this structure applies to
+ *  bAwbFaceEnable      : Enable Region priority for Auto White Balance
+ *  bAeFaceEnable       : Enable Region priority for Auto Exposure
+ *  bAfFaceEnable       : Enable Region priority for Auto Focus
+ */
+typedef struct OMX_TI_CONFIG_3A_REGION_PRIORITY {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_BOOL bAwbRegionEnable;
+	OMX_BOOL bAeRegionEnable;
+	OMX_BOOL bAfRegionEnable;
+} OMX_TI_CONFIG_3A_REGION_PRIORITY;
+
+/*
+* STRUCT MEMBERS:
+* nSize         : Size of the structure in bytes
+* nVersion      : OMX specification version information
+* nPortIndex    : Port that this structure applies to
+* bAutoConvergence : Enable/Disable Auto Convergence
+*/
+typedef struct OMX_TI_PARAM_AUTOCONVERGENCETYPE {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_BOOL bAutoConvergence;
+} OMX_TI_PARAM_AUTOCONVERGENCETYPE;
+
+/**
+ * Focus distance configuration
+ *
+ *  STRUCT MEMBERS:
+ *  nSize: Size of the structure in bytes
+ *  nVersion: OMX specification version information
+ *  nPortIndex: Port that this structure applies to
+ *  nFocusDistanceNear : Specifies the near focus distance in mm ( 0 equals infinity )
+ *  nFocusDistanceOptimal : Specifies the optimal focus distance in mm ( 0 equals infinity )
+ *  nFocusDistanceFar : Specifies the far focus distance in mm ( 0 equals infinity )
+ *  nLensPosition : Specifies the current lens position in driver units
+ */
+typedef struct OMX_TI_CONFIG_FOCUSDISTANCETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nFocusDistanceNear;
+    OMX_U32 nFocusDistanceOptimal;
+    OMX_U32 nFocusDistanceFar;
+    OMX_S32 nLensPosition;
+} OMX_TI_CONFIG_FOCUSDISTANCETYPE;
+
+/*
+* STRUCT MEMBERS:
+* nSize             : Size of the structure in bytes
+* nVersion          : OMX specification version information
+* nPortIndex        : Port that this structure applies to
+* pAAAskipBuff      : Pointer to a buffer
+* AAAskipBuffId     : Id of the send buffer
+* AAAskipBuffSize   : Size of the sent buffer
+*/
+typedef struct OMX_TI_CONFIG_AAASKIPBUFFERTYPE {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_PTR pAAAskipBuff;
+	OMX_U32 AAAskipBuffId;
+	OMX_U32 AAAskipBuffSize;
+} OMX_TI_CONFIG_AAASKIPBUFFERTYPE;
+
+
+/**
+ * The OMX_TI_BRIGHTNESSCONTRASTCRTLTYPE enumeration is used to define the
+ * brightness and contrast mode types.
+ */
+typedef enum OMX_TI_BRIGHTNESSCONTRASTCRTLTYPE {
+	OMX_TI_BceModeOff = 0,
+	OMX_TI_BceModeOn,
+	OMX_TI_BceModeAuto,
+	OMX_TI_BceModeMax = 0x7FFFFFFF
+} OMX_TI_BRIGHTNESSCONTRASTCRTLTYPE;
+
+/**
+ * Local and global brightness contrast type.
+ *
+ * STRUCT MEMBERS:
+ *  nSize             : Size of the structure in bytes
+ *  nVersion          : OMX specification version information
+ *  nPortIndex        : Port that this structure applies to
+ *  eControl          : Control field for GLBCE
+ */
+typedef struct OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_TI_BRIGHTNESSCONTRASTCRTLTYPE eControl;
+} OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE;
+
+/**
+ * Uncompressed image operating mode configuration structure.
+ *
+ * @param nSize         Size of the structure in bytes.
+ * @param nVersion      OMX specification version information.
+ * @param xMin          The minimum frame rate allowed.
+ *                      Units are Q16 frames per second.
+ * @param xMax          The maximum frame rate allowed.
+ *                      Units are Q16 frames per second.
+ */
+
+typedef struct OMX_TI_CONFIG_VARFRMRANGETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 xMin;
+    OMX_U32 xMax;
+} OMX_TI_CONFIG_VARFRMRANGETYPE;
+
+/**
+* A pointer to this struct is passed to the OMX_SetParameter when the extension
+* index for the 'OMX.google.android.index.enableAndroidNativeBuffers' extension
+* is given.
+* The corresponding extension Index is OMX_TI_IndexUseNativeBuffers.
+* This will be used to inform OMX about the presence of gralloc pointers instead
+* of virtual pointers
+*/
+typedef struct OMX_TI_PARAMUSENATIVEBUFFER {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnable;
+} OMX_TI_PARAMUSENATIVEBUFFER;
+
+/*==========================================================================*/
+/*!
+@brief OMX_TI_PARAM_ENHANCEDPORTRECONFIG : Suport added to new port reconfig usage
+@param bUsePortReconfigForCrop       Enables port reconfig for crop.
+@param bUsePortReconfigForPadding    Enables port reconfig for padding
+*/
+/*==========================================================================*/
+
+typedef struct OMX_TI_PARAM_ENHANCEDPORTRECONFIG {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bUsePortReconfigForCrop;
+    OMX_BOOL bUsePortReconfigForPadding;
+} OMX_TI_PARAM_ENHANCEDPORTRECONFIG;
+
+/**
+* Define the frames queue len for ZSL
+*
+* STRUCT MEMBERS:
+* nSize: Size of the structure in bytes
+* nVersion: OMX specification version information
+* nHistoryLen: History len in number of frames
+*/
+typedef struct OMX_TI_PARAM_ZSLHISTORYLENTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nHistoryLen;
+} OMX_TI_PARAM_ZSLHISTORYLENTYPE;
+
+/**
+* Define the frame delay in ms for ZSL
+*
+* STRUCT MEMBERS:
+* nSize: Size of the structure in bytes
+* nVersion: OMX specification version information
+* nDelay: Capture frame delay in ms
+*/
+typedef struct OMX_TI_CONFIG_ZSLDELAYTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_S32 nDelay;
+} OMX_TI_CONFIG_ZSLDELAYTYPE;
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+
+
diff --git a/domx/omx_core/inc/OMX_TI_Image.h b/domx/omx_core/inc/OMX_TI_Image.h
new file mode 100755
index 0000000..4035218
--- /dev/null
+++ b/domx/omx_core/inc/OMX_TI_Image.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * @file:OMX_TI_Image.h
+ * This header defines the structures specific to the param or config
+ * indices of Openmax Image Component.
+ *
+ *  @path domx/system/omx_core/inc
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 11-Oct-2010  KMotov 	x0106653@ti.com  	Initial Version
+ *================================================================*/
+
+#ifndef OMX_TI_IMAGE_H
+#define OMX_TI_IMAGE_H
+
+/**
+ * The OMX_TI_IMAGE_CODINGTYPE enumeration is used to define the
+ * extended image coding types.
+ */
+typedef enum OMX_TI_IMAGE_CODINGTYPE
+{
+	OMX_TI_IMAGE_CodingJPS = OMX_IMAGE_CodingVendorStartUnused + 1, /**< JPS format */
+	OMX_TI_IMAGE_CodingMPO          /**< MPO format */
+} OMX_TI_IMAGE_CODINGTYPE;
+
+#endif /* OMX_TI_IMAGE_H */
diff --git a/domx/omx_core/inc/OMX_TI_Index.h b/domx/omx_core/inc/OMX_TI_Index.h
new file mode 100755
index 0000000..3cc5a92
--- /dev/null
+++ b/domx/omx_core/inc/OMX_TI_Index.h
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_ti_index.h
+ *         This file contains the vendor(TI) specific indexes
+ *
+ *  @path \OMAPSW_SysDev\multimedia\omx\khronos1_1\omx_core\inc
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 20-Dec-2008 x0052661@ti.com, initial version
+ *================================================================*/
+
+#ifndef _OMX_TI_INDEX_H_
+#define _OMX_TI_INDEX_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <OMX_Types.h>
+
+/*******************************************************************
+ * EXTERNAL REFERENCE NOTE: only use if not found in header file
+ *******************************************************************/
+/*----------         function prototypes      ------------------- */
+/*----------         data declarations        ------------------- */
+/*******************************************************************
+ * PUBLIC DECLARATIONS: defined here, used elsewhere
+ *******************************************************************/
+/*----------         function prototypes      ------------------- */
+/*----------         data declarations        ------------------- */
+
+typedef enum OMX_TI_INDEXTYPE {
+
+    OMX_IndexConfigAutoPauseAfterCapture = OMX_IndexAutoPauseAfterCapture,
+
+    /* Vendor specific area for storing indices */
+    OMX_TI_IndexConfigChannelName = ((OMX_INDEXTYPE)OMX_IndexVendorStartUnused + 1), /**< reference: OMX_CONFIG_CHANNELNAME */
+
+    OMX_TI_IndexParamJPEGUncompressedMode,      /**< reference: OMX_JPEG_PARAM_UNCOMPRESSEDMODETYPE */
+    OMX_TI_IndexParamJPEGCompressedMode,        /**< reference: OMX_JPEG_PARAM_COMPRESSEDMODETYPE */
+    OMX_TI_IndexParamDecodeSubregion,           /**< reference: OMX_IMAGE_PARAM_DECODE_SUBREGION */
+
+    /* H264 Encoder Indices*/
+	OMX_TI_IndexParamVideoDataSyncMode, //!< Refer to OMX_VIDEO_PARAM_DATASYNCMODETYPE structure
+	OMX_TI_IndexParamVideoNALUsettings,	//!< use OMX_VIDEO_PARAM_AVCNALUCONTROLTYPE to configure the type os NALU to send along with the Different Frame Types
+	OMX_TI_IndexParamVideoMEBlockSize,	//!< use OMX_VIDEO_PARAM_MEBLOCKSIZETYPE to specify the minimum block size used for motion estimation
+	OMX_TI_IndexParamVideoIntraPredictionSettings,	//!< use OMX_VIDEO_PARAM_INTRAPREDTYPE to configure the intra prediction modes used for different block sizes
+	OMX_TI_IndexParamVideoEncoderPreset,	//!< use OMX_VIDEO_PARAM_ENCODER_PRESETTYPE to select the encoding mode & rate control preset
+	OMX_TI_IndexParamVideoFrameDataContentSettings,	//!< use OMX_TI_VIDEO_PARAM_FRAMEDATACONTENTTYPE to configure the data content tpye
+	OMX_TI_IndexParamVideoTransformBlockSize,	//!< use OMX_VIDEO_PARAM_TRANSFORM_BLOCKSIZETYPE to specify the block size used for ttransformation
+	OMX_TI_IndexParamVideoVUIsettings, //!use OMX_VIDEO_PARAM_VUIINFOTYPE
+	OMX_TI_IndexParamVideoAdvancedFMO,
+	OMX_TI_IndexConfigVideoPixelInfo,	//!<  Use OMX_VIDEO_CONFIG_PIXELINFOTYPE structure to know the pixel aspectratio & pixel range
+	OMX_TI_IndexConfigVideoMESearchRange,	//!< use OMX_VIDEO_CONFIG_MESEARCHRANGETYPE to specify the ME Search settings
+	OMX_TI_IndexConfigVideoQPSettings,	//!< use OMX_TI_VIDEO_CONFIG_QPSETTINGS to specify the ME Search settings
+	OMX_TI_IndexConfigSliceSettings,		//!<use OMX_VIDEO_CONFIG_SLICECODINGTYPE to specify the ME Search settings
+	OMX_TI_IndexParamAVCInterlaceSettings,            //!< use OMX_TI_VIDEO_PARAM_AVCINTERLACECODING to specify the ME Search settings
+	OMX_TI_IndexParamStereoInfo2004Settings,          //!< use OMX_TI_VIDEO_AVCENC_STEREOINFO2004 to specify the 2004 SEI for AVC Encoder
+	OMX_TI_IndexParamStereoFramePacking2010Settings,  //!< use OMX_TI_VIDEO_AVCENC_FRAMEPACKINGINFO2010 to specify 2010 SEI for AVC Encoder
+
+
+    /* Camera Indices */
+    OMX_TI_IndexConfigSensorSelect,             /**< reference: OMX_CONFIG_SENSORSELECTTYPE */
+    OMX_IndexConfigFlickerCancel,               /**< reference: OMX_CONFIG_FLICKERCANCELTYPE */
+    OMX_IndexConfigSensorCal,                   /**< reference: OMX_CONFIG_SENSORCALTYPE */
+	OMX_IndexConfigISOSetting, /**< reference: OMX_CONFIG_ISOSETTINGTYPE */
+    OMX_TI_IndexConfigSceneMode,                /**< reference: OMX_CONFIG_SCENEMODETYPE */
+
+    OMX_IndexConfigDigitalZoomSpeed,            /**< reference: OMX_CONFIG_DIGITALZOOMSPEEDTYPE */
+    OMX_IndexConfigDigitalZoomTarget,           /**< reference: OMX_CONFIG_DIGITALZOOMTARGETTYPE */
+
+    OMX_IndexConfigCommonScaleQuality,          /**< reference: OMX_CONFIG_SCALEQUALITYTYPE */
+
+    OMX_IndexConfigCommonDigitalZoomQuality,    /**< reference: OMX_CONFIG_SCALEQUALITYTYPE */
+
+    OMX_IndexConfigOpticalZoomSpeed,            /**< reference: OMX_CONFIG_DIGITALZOOMSPEEDTYPE */
+    OMX_IndexConfigOpticalZoomTarget,           /**< reference: OMX_CONFIG_DIGITALZOOMTARGETTYPE */
+
+    OMX_IndexConfigSmoothZoom,                  /**< reference: OMX_CONFIG_SMOOTHZOOMTYPE */
+
+    OMX_IndexConfigBlemish,                     /**< reference: OMX_CONFIG_BLEMISHTYPE */
+
+    OMX_IndexConfigExtCaptureMode,              /**< reference: OMX_CONFIG_EXTCAPTUREMODETYPE */
+	OMX_IndexConfigExtPrepareCapturing, /**< reference : OMX_CONFIG_BOOLEANTYPE */
+	OMX_IndexConfigExtCapturing, /**< reference : OMX_CONFIG_EXTCAPTURING */
+
+	OMX_IndexCameraOperatingMode, /**<  OMX_CONFIG_CAMOPERATINGMODETYPE */
+    OMX_IndexConfigDigitalFlash,                /**< reference: OMX_CONFIG_BOOLEANTYPE */
+    OMX_IndexConfigPrivacyIndicator,            /**< reference: OMX_CONFIG_BOOLEANTYPE */
+
+    OMX_IndexConfigTorchMode,                   /**< reference: OMX_CONFIG_TORCHMODETYPE */
+
+    OMX_IndexConfigSlowSync,                    /**< reference: OMX_CONFIG_BOOLEANTYPE */
+
+	OMX_IndexConfigExtFocusRegion, /**< reference : OMX_CONFIG_EXTFOCUSREGIONTYPE */
+    OMX_IndexConfigFocusAssist,                 /**< reference: OMX_CONFIG_BOOLEANTYPE */
+
+    OMX_IndexConfigImageFocusLock,              /**< reference: OMX_IMAGE_CONFIG_LOCKTYPE */
+    OMX_IndexConfigImageWhiteBalanceLock,       /**< reference: OMX_IMAGE_CONFIG_LOCKTYPE */
+    OMX_IndexConfigImageExposureLock,           /**< reference: OMX_IMAGE_CONFIG_LOCKTYPE */
+    OMX_IndexConfigImageAllLock,                /**< reference: OMX_IMAGE_CONFIG_LOCKTYPE */
+
+    OMX_IndexConfigImageDeNoiseLevel,           /**< reference: OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE */
+    OMX_IndexConfigSharpeningLevel,             /**< reference: OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE */
+    OMX_IndexConfigDeBlurringLevel,             /**< reference: OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE */
+    OMX_IndexConfigChromaCorrection,            /**< reference: OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE */
+    OMX_IndexConfigDeMosaicingLevel,            /**< reference: OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE */
+
+    OMX_IndexConfigCommonWhiteBalanceGain,      /**< reference: OMX_CONFIG_WHITEBALGAINTYPE */
+
+    OMX_IndexConfigCommonRGB2RGB,               /**< reference: OMX_CONFIG_COLORCONVERSIONTYPE_II */
+    OMX_IndexConfigCommonRGB2YUV,               /**< reference: OMX_CONFIG_COLORCONVERSIONTYPE_II */
+	OMX_IndexConfigCommonYUV2RGB, /**< reference : OMX_CONFIG_EXT_COLORCONVERSIONTYPE */
+
+    OMX_IndexConfigCommonGammaTable,            /**< reference: OMX_CONFIG_GAMMATABLETYPE */
+
+    OMX_IndexConfigImageFaceDetection,          /**< reference: OMX_CONFIG_OBJDETECTIONTYPE */
+    OMX_IndexConfigImageBarcodeDetection,       /**< reference: OMX_CONFIG_EXTRADATATYPE */
+    OMX_IndexConfigImageSmileDetection,         /**< reference: OMX_CONFIG_OBJDETECTIONTYPE */
+    OMX_IndexConfigImageBlinkDetection,         /**< reference: OMX_CONFIG_OBJDETECTIONTYPE */
+    OMX_IndexConfigImageFrontObjectDetection,   /**< reference: OMX_CONFIG_EXTRADATATYPE */
+    OMX_IndexConfigHistogramMeasurement,        /**< reference: OMX_CONFIG_HISTOGRAMTYPE */
+    OMX_IndexConfigDistanceMeasurement,         /**< reference: OMX_CONFIG_EXTRADATATYPE */
+
+    OMX_IndexConfigSnapshotToPreview,           /**< reference: OMX_CONFIG_BOOLEANTYPE */
+
+	OMX_IndexConfigJpegHeaderType , /**< reference : OMX_CONFIG_JPEGHEEADERTYPE */
+    OMX_IndexParamJpegMaxSize,                  /**< reference: OMX_IMAGE_JPEGMAXSIZE */
+
+    OMX_IndexConfigRestartMarker,               /**< reference: OMX_CONFIG_BOOLEANTYPE */
+
+    OMX_IndexParamImageStampOverlay,            /**< reference: OMX_PARAM_IMAGESTAMPOVERLAYTYPE */
+    OMX_IndexParamThumbnail,                    /**< reference: OMX_PARAM_THUMBNAILTYPE */
+    OMX_IndexConfigImageStabilization,          /**< reference: OMX_CONFIG_BOOLEANTYPE */
+	OMX_IndexConfigMotionTriggeredImageStabilisation, /**< reference : OMX_CONFIG_BOOLEANTYPE */
+    OMX_IndexConfigRedEyeRemoval,               /**< reference: OMX_CONFIG_REDEYEREMOVALTYPE */
+    OMX_IndexParamHighISONoiseFiler,            /**< reference: OMX_CONFIG_BOOLEANTYPE */
+    OMX_IndexParamLensDistortionCorrection,     /**< reference: OMX_CONFIG_BOOLEANTYPE */
+    OMX_IndexParamLocalBrightnessAndContrast,   /**< reference: OMX_CONFIG_BOOLEANTYPE */
+	OMX_IndexConfigChromaticAberrationCorrection, /**< reference: OMX_CONFIG_BOOLEANTYPE */
+    OMX_IndexParamVideoCaptureYUVRange,         /**< reference: OMX_PARAM_VIDEOYUVRANGETYPE */
+
+    OMX_IndexConfigFocusRegion,                 /**< reference: OMX_CONFIG_EXTFOCUSREGIONTYPE */
+    OMX_IndexConfigImageMotionEstimation,       /**< reference: OMX_CONFIG_OBJDETECTIONTYPE */
+    OMX_IndexParamProcessingOrder,              /**< reference: OMX_CONFIGPROCESSINGORDERTYPE */
+    OMX_IndexParamFrameStabilisation,           /**< reference: OMX_CONFIG_BOOLEANTYPE */
+    OMX_IndexParamVideoNoiseFilter,              /**< reference: OMX_PARAM_VIDEONOISEFILTERTYPE */
+
+    OMX_IndexConfigOtherExtraDataControl,        /**< reference:  OMX_CONFIG_EXTRADATATYPE */
+    OMX_TI_IndexParamBufferPreAnnouncement,             /**< reference: OMX_TI_PARAM_BUFFERPREANNOUNCE */
+    OMX_TI_IndexConfigBufferRefCountNotification,       /**< reference: OMX_TI_CONFIG_BUFFERREFCOUNTNOTIFYTYPE */
+    OMX_TI_IndexParam2DBufferAllocDimension,            /**< reference: OMX_CONFIG_RECTTYPE */
+    OMX_TI_IndexConfigWhiteBalanceManualColorTemp,      /**< reference: OMX_TI_CONFIG_WHITEBALANCECOLORTEMPTPYPE */
+    OMX_TI_IndexConfigFocusSpotWeighting,               /**< reference: OMX_TI_CONFIG_FOCUSSPOTWEIGHTINGTYPE */
+    OMX_TI_IndexParamSensorOverClockMode,               /**< reference: OMX_CONFIG_BOOLEANTYPE */
+    OMX_TI_IndexParamDccUriInfo,                        /**< reference: OMX_TI_PARAM_DCCURIINFO */
+    OMX_TI_IndexParamDccUriBuffer,                      /**< reference: OMX_TI_PARAM_DCCURIBUFFER */
+
+    /* MPEG4 and H264 encoder specific Indices */
+    OMX_TI_IndexParamVideoIntraRefresh,         /**< reference: OMX_TI_VIDEO_PARAM_INTRAREFRESHTYPE */
+
+    OMX_TI_IndexConfigShutterCallback,          /**< reference: OMX_CONFIG_BOOLEANTYPE */
+    OMX_TI_IndexParamVarFrameRate,              /**< reference: OMX_PARAM_VARFARAMERATETYPE */
+    OMX_TI_IndexConfigAutoConvergence,          /**< reference: OMX_TI_CONFIG_CONVERGENCETYPE */
+    OMX_TI_IndexConfigRightExposureValue,       /**< reference: OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE */
+    OMX_TI_IndexConfigExifTags,                 /**< reference: OMX_TI_CONFIG_SHAREDBUFFER */
+    OMX_TI_IndexParamVideoPayloadHeaderFlag,    /**< reference: OMX_TI_PARAM_PAYLOADHEADERFLAG */
+    OMX_TI_IndexParamVideoIvfMode,              /**< reference: OMX_TI_PARAM_IVFFLAG */
+    OMX_TI_IndexConfigCamCapabilities,          /**< reference: OMX_TI_CONFIG_SHAREDBUFFER */
+    OMX_TI_IndexConfigFacePriority3a,           /**< reference: OMX_TI_CONFIG_3A_FACE_PRIORITY */
+    OMX_TI_IndexConfigRegionPriority3a,         /**< reference: OMX_TI_CONFIG_3A_REGION_PRIORITY */
+    OMX_TI_IndexParamAutoConvergence,           /**< reference: OMX_TI_PARAM_AUTOCONVERGENCETYPE */
+    OMX_TI_IndexConfigAAAskipBuffer,            /**< reference: OMX_TI_CONFIG_AAASKIPBUFFERTYPE */
+    OMX_TI_IndexParamStereoFrmLayout,           /**< reference: OMX_TI_FRAMELAYOUTTYPE */
+    OMX_TI_IndexConfigLocalBrightnessContrastEnhance, /**< reference: OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE */
+    OMX_TI_IndexConfigGlobalBrightnessContrastEnhance, /**< reference: OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE */
+    OMX_TI_IndexConfigVarFrmRange,              /**< reference: OMX_TI_CONFIG_VARFRMRANGETYPE */
+    OMX_TI_IndexParamAVCHRDBufferSizeSetting,   /**< reference: OMX_TI_VIDEO_PARAM_AVCHRDBUFFERSETTING */
+    OMX_TI_IndexConfigAVCHRDBufferSizeSetting,   /**< reference: OMX_TI_VIDEO_CONFIG_AVCHRDBUFFERSETTING */
+    OMX_TI_IndexConfigFocusDistance,              /**< reference: OMX_TI_CONFIG_FOCUSDISTANCETYPE */
+    OMX_TI_IndexUseNativeBuffers,                /**< reference: OMX_TI_ParamUseNativeBuffer */
+    OMX_TI_IndexParamUseEnhancedPortReconfig,     /**< reference: OMX_TI_IndexParamUseEnhancedPortReconfig */
+    OMX_TI_IndexEncoderStoreMetadatInBuffers,
+    OMX_TI_IndexParamZslHistoryLen,                     /**< reference: OMX_TI_PARAM_ZSLHISTORYLENTYPE */
+    OMX_TI_IndexConfigZslDelay,                          /**< reference: OMX_TI_CONFIG_ZSLDELAYTYPE */
+    OMX_TI_IndexParamMetaDataBufferInfo,                  /***< reference: OMX_TI_PARAM_METADATABUFFERINFO */
+    OMX_TI_IndexConfigZslFrameSelectMethod              /**< reference: OMX_TI_CONFIG_ZSLFRAMESELECTMETHODTYPE */
+} OMX_TI_INDEXTYPE;
+
+
+
+/*******************************************************************
+ * PRIVATE DECLARATIONS: defined here, used only here
+ *******************************************************************/
+/*----------          data declarations        ------------------- */
+/*----------          function prototypes      ------------------- */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _OMX_TI_INDEX_H_ */
+
diff --git a/domx/omx_core/inc/OMX_TI_Video.h b/domx/omx_core/inc/OMX_TI_Video.h
new file mode 100755
index 0000000..55000c6
--- /dev/null
+++ b/domx/omx_core/inc/OMX_TI_Video.h
@@ -0,0 +1,723 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* -------------------------------------------------------------------------- */
+/*
+ * @file:Omx_ti_video.h
+ * This header defines the structures specific to the param or config indices of Openmax Video Component.
+ *
+ * @path:
+ * \WTSD_DucatiMMSW\ omx\omx_il_1_x\omx_core\
+
+ * -------------------------------------------------------------------------- */
+
+/* =========================================================================
+ *!
+ *! Revision History
+ *! =====================================================================
+ *! 24-Dec-2008  Navneet 	navneet@ti.com  	Initial Version
+ *! 14-Jul-2009	Radha Purnima  radhapurnima@ti.com
+ *! 25-Aug-2009	Radha Purnima  radhapurnima@ti.com
+ * =========================================================================*/
+
+
+#ifndef OMX_TI_VIDEO_H
+#define OMX_TI_VIDEO_H
+#define H264ENC_MAXNUMSLCGPS 2
+
+#include <OMX_Core.h>
+
+/**
+ *	@brief	mode selection for the data that is given to the Codec
+ */
+
+typedef enum OMX_VIDEO_DATASYNCMODETYPE {
+    OMX_Video_FixedLength,	//!<  Interms of multiples of 4K
+    OMX_Video_SliceMode,		//!<  Slice mode
+    OMX_Video_NumMBRows,	//!< Number of rows, each row is 16 lines of video
+    OMX_Video_EntireFrame  	//!< Processing of entire frame data
+} OMX_VIDEO_DATASYNCMODETYPE;
+
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_DATAMODE  :to configure how the input and output data is fed to the Codec
+ @param  nPortIndex  to specify the index of the port
+ @param  eDataMode 	to specify the data mode
+ 						@sa  OMX_VIDEO_DATASYNCMODETYPE
+ @param  nNumDataUnits	 to specify the number of data units (where units are of type defined by eDataMode)
+ */
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_PARAM_DATASYNCMODETYPE{
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_VIDEO_DATASYNCMODETYPE eDataMode;
+	OMX_U32 nNumDataUnits;
+} OMX_VIDEO_PARAM_DATASYNCMODETYPE;
+
+/**
+ *	@brief	Aspect Ratio type selection for the encoded bit stream
+ */
+typedef enum OMX_VIDEO_ASPECTRATIOTYPE{
+	OMX_Video_AR_Unspecified,  //!< Unspecified aspect ratio
+	OMX_Video_AR_Square ,  //!< 1:1 (square) aspect ratio
+	OMX_Video_AR_12_11  ,  //!<  12:11  aspect ratio
+	OMX_Video_AR_10_11  ,  //!<  10:11  aspect ratio
+	OMX_Video_AR_16_11  ,  //!<  16:11  aspect ratio
+	OMX_Video_AR_40_33  ,  //!<  40:33  aspect ratio
+	OMX_Video_AR_24_11  ,  //!<  24:11  aspect ratio
+	OMX_Video_AR_20_11  ,  //!<  20:11  aspect ratio
+	OMX_Video_AR_32_11  ,  //!<  32:11  aspect ratio
+	OMX_Video_AR_80_33  ,  //!<  80:33  aspect ratio
+	OMX_Video_AR_18_11  ,  //!<  18:11  aspect ratio
+	OMX_Video_AR_15_15  ,  //!<  15:15  aspect ratio
+	OMX_Video_AR_64_33  ,  //!<  64:33  aspect ratio
+	OMX_Video_AR_160_99 ,  //!<  160:99 aspect ratio
+	OMX_Video_AR_4_3    ,  //!<  4:3    aspect ratio
+	OMX_Video_AR_3_2    ,  //!<  3:2    aspect ratio
+	OMX_Video_AR_2_1    ,  //!<  2:1    aspect ratio
+	OMX_Video_AR_Extended = 255,       //!<  Extended aspect ratio
+   	OMX_Video_AR_Extended_MAX =  0X7FFFFFFF
+}OMX_VIDEO_ASPECTRATIOTYPE;
+
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_VUI_SELECT  :to select the VUI Settings
+ @param  bAspectRatioPresent flag to indicate the insertion of aspect ratio information in VUI part of bit-stream
+ @param  ePixelAspectRatio to specify the Aspect Ratio
+ @param  bFullRange to indicate whether pixel value range is specified as full range or not (0 to 255)
+*/
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_PARAM_VUIINFOTYPE {
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_BOOL bAspectRatioPresent;
+	OMX_VIDEO_ASPECTRATIOTYPE ePixelAspectRatio;
+	OMX_BOOL bFullRange;
+}OMX_VIDEO_PARAM_VUIINFOTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_VIDEO_CONFIG_PIXELINFOTYPE  :to specify the information related to the input pixel data (aspect ratio & range) to the Codec
+ 										so that codec can incorporate this info in the coded bit stream
+ @param  nWidth 	 to specify the Aspect ratio: width of the pixel
+ @param  nHeight 	 to specify the Aspect ratio: height of the pixel
+ */
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_CONFIG_PIXELINFOTYPE  {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_U32 nWidth;
+	OMX_U32 nHeight;
+} OMX_VIDEO_CONFIG_PIXELINFOTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_VIDEO_PARAM_AVCNALUCONTROLTYPE : to configure what NALU  need to send along the frames of different types (Intra,IDR...etc)
+ @param  nStartofSequence 	to configure the different NALU (specified via enabling/disabling (1/0) the bit positions) that need to send along with the Start of sequence frame
+ @param  nEndofSequence	 	to to configure the different NALU (specified via enabling/disabling (1/0) the bit positions) that need to send along with the End of sequence frame
+ @param  nIDR 				to to configure the different NALU (specified via enabling/disabling (1/0) the bit positions) that need to send along with the IDR frame
+ @param  nIntraPicture	  		to to configure the different NALU (specified via enabling/disabling (1/0) the bit positions) that need to send along with the Intra frame
+ @param  nNonIntraPicture	  	to to configure the different NALU (specified via enabling/disabling (1/0) the bit positions) that need to send along with the Non Intra frame
+
+Bit Position:   13|       12|      11|           10|      9|    8|    7|   6|      5|         4|              3|              2|              1|          0
+NALU TYPE:  SPS_VUI|FILLER|EOSTREAM|EOSEQ|AUD|PPS|SPS|SEI|IDR_SLICE|SLICE_DP_C|SLICE_DP_B|SLICE_DP_A|SLICE|UNSPECIFIED \n
+*/
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_PARAM_AVCNALUCONTROLTYPE {
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 	nPortIndex;
+	OMX_U32 	nStartofSequence;
+	OMX_U32 	nEndofSequence;
+	OMX_U32 	nIDR;
+	OMX_U32 	nIntraPicture;
+	OMX_U32 	nNonIntraPicture;
+}OMX_VIDEO_PARAM_AVCNALUCONTROLTYPE;
+
+
+/* ========================================================================== */
+/*!
+ @brief OMX_VIDEO_CONFIG_MESEARCHRANGETYPE : to configure Motion Estimation Parameters
+ @param  eMVAccuracy 		to specify the Motion Vector Accuracy
+ 							@sa OMX_VIDEO_MOTIONVECTORTYPE
+ @param  sHorSearchRangeP	 	to Specify the Horizontal Search range for P Frame
+ @param  sVerSearchRangeP		to Specify the Vertical Search range for P Frame
+ @param  sHorSearchRangeB	  	to Specify the Horizontal Search range for B Frame
+ @param  sVerSearchRangeB	  	to Specify the Vertical Search range for B Frame
+*/
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_CONFIG_MESEARCHRANGETYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_VIDEO_MOTIONVECTORTYPE eMVAccuracy;
+	OMX_U32	 nHorSearchRangeP;
+	OMX_U32	 nVerSearchRangeP;
+	OMX_U32	 nHorSearchRangeB;
+	OMX_U32	 nVerSearchRangeB;
+}OMX_VIDEO_CONFIG_MESEARCHRANGETYPE;
+
+/**
+ *	@brief	Block size specification
+ */
+typedef enum OMX_VIDEO_BLOCKSIZETYPE {
+	OMX_Video_Block_Size_16x16=0,
+	OMX_Video_Block_Size_8x8,
+	OMX_Video_Block_Size_8x4,
+	OMX_Video_Block_Size_4x8,
+	OMX_Video_Block_Size_4x4,
+   	OMX_Video_Block_Size_MAX =  0X7FFFFFFF
+}OMX_VIDEO_BLOCKSIZETYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_VIDEO_PARAM_MEBLOCKSIZETYPE : to configure the Min Motion Estimation block size for P and B frames
+ @param  eMinBlockSizeP 		to specify the Min Block size used for Motion Estimation incase of P Frames
+ 							@sa OMX_VIDEO_BLOCKSIZETYPE
+ @param  eMinBlockSizeB	 	to specify the Min Block size used for Motion Estimation incase of B Frames
+*/
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_PARAM_MEBLOCKSIZETYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_VIDEO_BLOCKSIZETYPE eMinBlockSizeP;
+	OMX_VIDEO_BLOCKSIZETYPE eMinBlockSizeB;
+}OMX_VIDEO_PARAM_MEBLOCKSIZETYPE;
+
+/**
+ *	@brief	to select the chroma component used for Intra Prediction
+ */
+typedef enum OMX_VIDEO_CHROMACOMPONENTTYPE {
+	OMX_Video_Chroma_Component_Cr_Only=0,	//!< consider only Cr chroma component for Intra prediction
+	OMX_Video_Chroma_Component_Cb_Cr_Both,  //!< consider both (Cb & Cr) chroma components for Intra prediction
+     OMX_Video_Chroma_Component_MAX =  0X7FFFFFFF
+}OMX_VIDEO_CHROMACOMPONENTTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_VIDEO_PARAM_INTRAPREDTYPE : to configure the Modes for the different block sizes during Intra Prediction
+ @param  nLumaIntra4x4Enable 	 	to configure the Modes for 4x4 block size during luma intra prediction: bit position specifies the modes that are enabled/disabled
+								 HOR_UP|VERT_LEFT|HOR_DOWN|VERT_RIGHT|DIAG_DOWN_RIGHT|DIAG_DOWN_LEFT|DC|HOR|VER
+ @param  nLumaIntra8x8Enable	 	to configure the Modes for 4x4 block size during luma intra prediction
+ 								HOR_UP|VERT_LEFT|HOR_DOWN|VERT_RIGHT|DIAG_DOWN_RIGHT|DIAG_DOWN_LEFT|DC|HOR|VER
+ @param  nLumaIntra16x16Enable	 	to configure the Modes for 4x4 block size during luma intra prediction
+								 PLANE|DC|HOR|VER
+ @param  nChromaIntra8x8Enable	 	to configure the Modes for 4x4 block size during luma intra prediction
+								 PLANE|DC|HOR|VER
+ @param  eChromaComponentEnable	to select the chroma components used for the intra prediction
+ 								@sa OMX_VIDEO_CHROMACOMPONENTTYPE
+*/
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_PARAM_INTRAPREDTYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_U32	 nLumaIntra4x4Enable;
+	OMX_U32 nLumaIntra8x8Enable;
+	OMX_U32 nLumaIntra16x16Enable;
+	OMX_U32 nChromaIntra8x8Enable;
+	OMX_VIDEO_CHROMACOMPONENTTYPE eChromaComponentEnable;
+}OMX_VIDEO_PARAM_INTRAPREDTYPE;
+
+
+/**
+ *	@brief	Encoding Mode Preset
+ */
+typedef enum OMX_VIDEO_ENCODING_MODE_PRESETTYPE {
+	OMX_Video_Enc_Default=0, 	//!<  for all the params default values are taken
+	OMX_Video_Enc_High_Quality, //!<  todo: mention the parameters that takes specific values depending on this selection
+	OMX_Video_Enc_User_Defined,
+	OMX_Video_Enc_High_Speed_Med_Quality,
+	OMX_Video_Enc_Med_Speed_Med_Quality,
+	OMX_Video_Enc_Med_Speed_High_Quality,
+	OMX_Video_Enc_High_Speed,
+   	OMX_Video_Enc_Preset_MAX =  0X7FFFFFFF
+}OMX_VIDEO_ENCODING_MODE_PRESETTYPE;
+
+/**
+ *	@brief	Rate Control Preset
+ */
+typedef enum OMX_VIDEO_RATECONTROL_PRESETTYPE {
+	OMX_Video_RC_Low_Delay,	//!<todo:  mention the parameters that takes specific values depending on this selection
+	OMX_Video_RC_Storage,
+	OMX_Video_RC_Twopass,
+	OMX_Video_RC_None,
+	OMX_Video_RC_User_Defined,
+   	OMX_Video_RC_MAX =  0X7FFFFFFF
+}OMX_VIDEO_RATECONTROL_PRESETTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_VIDEO_PARAM_ENCODER_PRESETTYPE : to select the preset for Encoding Mode & Rate Control
+ @param  eEncodingModePreset		to specify Encoding Mode Preset
+ 							@sa OMX_VIDEO_ENCODING_MODE_PRESETTYPE
+ @param  eRateControlPreset	to specify Rate Control Preset
+ 							@sa OMX_VIDEO_RATECONTROL_PRESETTYPE
+*/
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_PARAM_ENCODER_PRESETTYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_VIDEO_ENCODING_MODE_PRESETTYPE eEncodingModePreset;
+	OMX_VIDEO_RATECONTROL_PRESETTYPE eRateControlPreset;
+}OMX_VIDEO_PARAM_ENCODER_PRESETTYPE;
+
+
+/**
+ *	@brief	 input content type
+ */
+typedef enum OMX_TI_VIDEO_FRAMECONTENTTYPE {
+	OMX_TI_Video_Progressive = 0,			//!<Progressive frame
+	OMX_TI_Video_Interlace_BothFieldsTogether = 1,	//!<Interlaced frame
+	OMX_TI_Video_Interlace_OneField = 2,
+	OMX_TI_Video_AVC_2004_StereoInfoType = 3,
+	OMX_TI_Video_AVC_2010_StereoFramePackingType = 4,
+	OMX_TI_Video_FrameContentType_MAX = 0x7FFFFFFF
+}OMX_TI_VIDEO_FRAMECONTENTTYPE;
+
+/**
+ *	@brief	 Specifies the type of interlace content
+ */
+typedef enum OMX_TI_VIDEO_AVC_INTERLACE_CODINGTYPE {
+	OMX_TI_Video_Interlace_PICAFF = 0,	//!< PicAFF type of interlace coding
+	OMX_TI_Video_Interlace_MBAFF,		//!< MBAFF type of interlace coding
+	OMX_TI_Video_Interlace_Fieldonly,	//!< Field only coding
+	OMX_TI_Video_Interlace_Fieldonly_MRF=OMX_TI_Video_Interlace_Fieldonly,
+	OMX_TI_Video_Interlace_Fieldonly_ARF,
+	OMX_TI_Video_Interlace_Fieldonly_SPF,	//!< Field only coding where codec decides the partiy of the field to be used based upon content
+	OMX_Video_Interlace_MAX = 0x7FFFFFFF
+}OMX_TI_VIDEO_AVC_INTERLACE_CODINGTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_FRAMEDATACONTENTTYPE : to configure the data content
+ @param  eContentType		to specify Content type
+ 							@sa OMX_VIDEO_FRAMECONTENTTYPE
+*/
+/* ==========================================================================*/
+typedef struct OMX_TI_VIDEO_PARAM_FRAMEDATACONTENTTYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_TI_VIDEO_FRAMECONTENTTYPE eContentType;
+}OMX_TI_VIDEO_PARAM_FRAMEDATACONTENTTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_AVCINTERLACECODING : to configure the interlace encoding related settings
+ @param  eInterlaceCodingType	to specify the settings of interlace content
+ 							@sa OMX_VIDEO_INTERLACE_CODINGTYPE
+ @param  bTopFieldFirst				to specify the first field sent is top or bottom
+ @param  bBottomFieldIntra		to specify codec that encode bottomfield also as intra or not
+*/
+/* ==========================================================================*/
+typedef struct OMX_TI_VIDEO_PARAM_AVCINTERLACECODING{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_TI_VIDEO_AVC_INTERLACE_CODINGTYPE eInterlaceCodingType;
+	OMX_BOOL bTopFieldFirst;
+	OMX_BOOL bBottomFieldIntra;
+}OMX_TI_VIDEO_PARAM_AVCINTERLACECODING;
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_AVCENC_STEREOINFO2004  : to configure the 2004 related stereo information type
+*/
+/* ==========================================================================*/
+
+typedef struct OMX_TI_VIDEO_PARAM_AVCENC_STEREOINFO2004
+{
+	OMX_U32          nSize;
+	OMX_VERSIONTYPE  nVersion;
+	OMX_U32          nPortIndex;
+	OMX_BOOL         btopFieldIsLeftViewFlag;
+	OMX_BOOL         bViewSelfContainedFlag;
+} OMX_TI_VIDEO_AVCENC_STEREOINFO2004;
+
+typedef enum OMX_TI_VIDEO_AVCSTEREO_FRAMEPACKTYPE{
+	OMX_TI_Video_FRAMEPACK_CHECKERBOARD        = 0,
+	OMX_TI_Video_FRAMEPACK_COLUMN_INTERLEAVING = 1,
+	OMX_TI_Video_FRAMEPACK_ROW_INTERLEAVING    = 2,
+	OMX_TI_Video_FRAMEPACK_SIDE_BY_SIDE        = 3,
+	OMX_TI_Video_FRAMEPACK_TOP_BOTTOM          = 4,
+	OMX_TI_Video_FRAMEPACK_TYPE_DEFAULT        = OMX_TI_Video_FRAMEPACK_SIDE_BY_SIDE,
+	OMX_TI_Video_FRAMEPACK_TYPE_MAX = 0x7FFFFFFF
+} OMX_TI_VIDEO_AVCSTEREO_FRAMEPACKTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_AVCENC_FRAMEPACKINGINFO2010 : to configure the 2010 related stereo information type
+*/
+/* ==========================================================================*/
+
+typedef struct OMX_TI_VIDEO_PARAM_AVCENC_FRAMEPACKINGINFO2010
+{
+	OMX_U32          nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32          nPortIndex;
+	OMX_TI_VIDEO_AVCSTEREO_FRAMEPACKTYPE eFramePackingType;
+	OMX_U8         nFrame0PositionX;
+	OMX_U8         nFrame0PositionY;
+	OMX_U8         nFrame1PositionX;
+	OMX_U8         nFrame1PositionY;
+}OMX_TI_VIDEO_PARAM_AVCENC_FRAMEPACKINGINFO2010;
+
+/**
+ *	@brief	 Specifies Transform Block Size
+ */
+typedef enum OMX_VIDEO_TRANSFORMBLOCKSIZETYPE {
+	OMX_Video_Transform_Block_Size_4x4 =0,	//!< Transform blocks size is 8x8 : Valid for only High Profile
+	OMX_Video_Transform_Block_Size_8x8,	//!< Transform blocks size is 4x4
+	OMX_Video_Transform_Block_Size_Adaptive, //!< Adaptive transform block size : encoder decides as per content
+    OMX_Video_Transform_Block_Size_MAX =  0X7FFFFFFF
+}OMX_VIDEO_TRANSFORMBLOCKSIZETYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_VIDEO_PARAM_TRANSFORM_BLOCKSIZETYPE : to select the Block Size used for transformation
+ @param  eTransformBlocksize	to specify Block size used for transformation
+ 							@sa OMX_VIDEO_TRANSFORMBLOCKSIZETYPE
+*/
+/* ==========================================================================*/
+
+typedef struct OMX_VIDEO_PARAM_TRANSFORM_BLOCKSIZETYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_VIDEO_TRANSFORMBLOCKSIZETYPE eTransformBlocksize;
+}OMX_VIDEO_PARAM_TRANSFORM_BLOCKSIZETYPE;
+
+
+/* ========================================================================== */
+/*!
+ @brief OMX_VIDEO_CONFIG_SLICECODINGTYPE : to configure the Slice Settings
+ @param  eSliceMode	to specify the Slice mode
+ 							@sa OMX_VIDEO_AVCSLICEMODETYPE
+ @param  nSlicesize to specify the sliceSize
+*/
+/* ==========================================================================*/
+
+typedef struct OMX_VIDEO_CONFIG_SLICECODINGTYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_VIDEO_AVCSLICEMODETYPE eSliceMode;
+	OMX_U32	 nSlicesize;
+}OMX_VIDEO_CONFIG_SLICECODINGTYPE;
+
+/**
+ *	@brief	 Specifies Slice Group Change Direction Flag
+ */
+typedef enum OMX_VIDEO_SLIGRPCHANGEDIRTYPE{
+  OMX_Video_Raster_Scan             = 0 , //!< 0 : Raster scan order
+  OMX_Video_Clockwise              = 0 , //!< 0 : Clockwise (used for BOX OUT FMO Params)
+  OMX_Video_Right                   = 0 , //!< 0 : RIGHT (Used for Wipe FMO type)
+  OMX_Video_Reverse_Raster_Scan= 1 , //!< 1 : Reverse Raster Scan Order
+  OMX_Video_Counter_Clockwise       = 1 , //!< 1 : Counter Clockwise (used for BOX OUT FMO Params)
+  OMX_Video_Left                    = 1,  //!< 1 : LEFT (Used for Wipe FMO type)
+  OMX_Video_Left_MAX =  0X7FFFFFFF
+} OMX_VIDEO_SLICEGRPCHANGEDIRTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_FMO_ADVANCEDSETTINGS : to configure the FMO Settings
+ @param
+*/
+/* ==========================================================================*/
+typedef struct OMX_VIDEO_PARAM_AVCADVANCEDFMOTYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32 nPortIndex;
+	OMX_U8 nNumSliceGroups;
+	OMX_U8 nSliceGroupMapType;
+	OMX_VIDEO_SLICEGRPCHANGEDIRTYPE eSliceGrpChangeDir;
+	OMX_U32 nSliceGroupChangeRate;
+	OMX_U32 nSliceGroupChangeCycle;
+	OMX_U32 nSliceGroupParams[H264ENC_MAXNUMSLCGPS] ;
+}OMX_VIDEO_PARAM_AVCADVANCEDFMOTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_CONFIG_QPSETTINGS : to configure the Qp Settings of I, P &B Frames
+ @param  nQpI
+*/
+/* ==========================================================================*/
+
+typedef struct OMX_VIDEO_CONFIG_QPSETTINGSTYPE{
+	OMX_U32	 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_U32	 nPortIndex;
+	OMX_U32	 nQpI;
+	OMX_U32	 nQpMaxI;
+	OMX_U32	 nQpMinI;
+	OMX_U32	 nQpP;
+	OMX_U32	 nQpMaxP;
+	OMX_U32	 nQpMinP;
+	OMX_U32	 nQpOffsetB;
+	OMX_U32	 nQpMaxB;
+	OMX_U32	 nQpMinB;
+}OMX_VIDEO_CONFIG_QPSETTINGSTYPE;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_AVCHRDBUFFERSETTING : to configure the HRD
+	(Hypothetical Reference Decoder) related params
+ @param  nInitialBufferLevel	Initial buffer level for HRD compliance
+ @param  nHRDBufferSize		Hypothetical Reference Decoder buffer size
+ @param  nTargetBitrate		Target bitrate to encode with
+*/
+/* ==========================================================================*/
+
+typedef struct OMX_TI_VIDEO_PARAM_AVCHRDBUFFERSETTING {
+	OMX_U32     nSize;
+	OMX_VERSIONTYPE     nVersion;
+	OMX_U32    nPortIndex;
+	OMX_U32    nInitialBufferLevel;
+	OMX_U32    nHRDBufferSize;
+	OMX_U32    nTargetBitrate;
+} OMX_TI_VIDEO_PARAM_AVCHRDBUFFERSETTING;
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_CONFIG_AVCHRDBUFFERSETTING : to configure the HRD
+	(Hypothetical Reference Decoder) related params
+ @param  nHRDBufferSize		Hypothetical Reference Decoder Buffer Size
+ @param  nEncodeBitrate		Target bitrate to encode with
+
+*/
+/* ==========================================================================*/
+
+typedef struct OMX_TI_VIDEO_CONFIG_AVCHRDBUFFERSETTING {
+	OMX_U32    nSize;
+	OMX_VERSIONTYPE     nVersion;
+	OMX_U32     nPortIndex;
+	OMX_U32     nHRDBufferSize;
+	OMX_U32     nEncodeBitrate;
+} OMX_TI_VIDEO_CONFIG_AVCHRDBUFFERSETTING;
+
+/* ========================================================================= */
+/*!
+ @brief OMX_TI_VIDEO_CODINGTYPE :
+	Extension to video coding type enum for VP6 and VP7
+ @param
+*/
+/* ==========================================================================*/
+
+typedef enum OMX_TI_VIDEO_CODINGTYPE {
+	OMX_VIDEO_CodingVP6 =
+		(OMX_VIDEO_CODINGTYPE) OMX_VIDEO_CodingVendorStartUnused +1,  /* VP6 */
+	OMX_VIDEO_CodingVP7, /* VP7 */
+	OMX_TI_VIDEO_CodingSORENSONSPK   /* Sorenson Spark */
+}OMX_TI_VIDEO_CODINGTYPE;
+
+
+/* ========================================================================= */
+/*!
+ @brief OMX_TI_VIDEO_MPEG4LEVELTYPE:
+        Extension to MPEG-4 level to cater to level 6
+ @param
+*/
+/* ==========================================================================*/
+typedef enum OMX_TI_VIDEO_MPEG4LEVELTYPE {
+        OMX_TI_VIDEO_MPEG4Level6  =
+            (OMX_VIDEO_MPEG4LEVELTYPE) OMX_VIDEO_MPEG4LevelVendorStartUnused + 1
+} OMX_TI_VIDEO_MPEG4LEVELTYPE;
+
+
+
+/**
+ *	@brief	 Specifies various intra refresh methods
+ */
+typedef enum OMX_TI_VIDEO_INTRAREFRESHTYPE {
+    OMX_TI_VIDEO_IntraRefreshNone = 0,
+    OMX_TI_VIDEO_IntraRefreshCyclicMbs,
+    OMX_TI_VIDEO_IntraRefreshCyclicRows,
+    OMX_TI_VIDEO_IntraRefreshMandatory,
+    OMX_TI_VIDEO_IntraRefreshMax = 0x7FFFFFFF
+} OMX_TI_VIDEO_INTRAREFRESHTYPE;
+
+
+/* ========================================================================== */
+/*!
+ @brief OMX_TI_VIDEO_PARAM_INTRAREFRESHTYPE  : Configuration parameters for
+                                               intra refresh settings
+ @param  eRefreshMode		Various refresh modes supported
+ @param  nIntraRefreshRate 	Intra refresh rate
+*/
+/* ==========================================================================*/
+
+typedef struct OMX_TI_VIDEO_PARAM_INTRAREFRESHTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_TI_VIDEO_INTRAREFRESHTYPE eRefreshMode;
+    OMX_U32 nIntraRefreshRate;
+} OMX_TI_VIDEO_PARAM_INTRAREFRESHTYPE;
+
+
+/* ============================================================================= */
+/*!
+ @brief OMX_TI_STEREODECINFO : Structure to access 2004 SEI message generated by
+ H264 decoder as metatadata on its output port.
+ */
+/* ============================================================================= */
+
+typedef struct OMX_TI_STEREODECINFO {
+	OMX_U32 nFieldViewsFlag;
+	OMX_U32 nTopFieldIsLeftViewFlag;
+	OMX_U32 nCurrentFrameIsLeftViewFlag;
+	OMX_U32 nNextFrameIsSecondViewFlag;
+	OMX_U32 nLeftViewSelfContainedFlag;
+	OMX_U32 nRightViewSelfContainedFlag;
+} OMX_TI_STEREODECINFO;
+
+typedef struct OMX_TI_FRAMEPACKINGDECINFO {
+	OMX_U32 nFramePackingArrangementId;
+	OMX_U32 nFramePackingArrangementRepetitionPeriod;
+	OMX_U8  nFramePackingArrangementCancelFlag;
+	OMX_U8  nFramePackingArrangementType;
+	OMX_U8  nQuincunxSamplingFlag;
+	OMX_U8  nContentInterpretationType;
+	OMX_U8  nSpatialFlippingFlag;
+	OMX_U8  nFrame0FlippedFlag;
+	OMX_U8  nFieldViewsFlag;
+	OMX_U8  nCurrentFrameIsFrame0Flag;
+	OMX_U8  nFrame0SelfContainedFlag;
+	OMX_U8  nFrame1SelfContainedFlag;
+	OMX_U8  nFrame0GridPositionX;
+	OMX_U8  nFrame0GridPositionY;
+	OMX_U8  nFrame1GridPositionX;
+	OMX_U8  nFrame1GridPositionY;
+	OMX_U8  nFramePackingArrangementReservedByte;
+	OMX_U8  nFramePackingArrangementExtensionFlag;
+} OMX_TI_FRAMEPACKINGDECINFO;
+
+/* ============================================================================= */
+/*!
+ @brief OMX_TI_VIDEO_RANGEMAPPING : Structure to access luma and chroma range
+                                    mapping generated by decoders as
+                                    metatadata on its output port.
+ @param nRangeMappingLuma     Luma scale factor for range mapping.
+ @param nRangeMappingChroma   Chroma scale factor for range mapping.
+*/
+/* ============================================================================= */
+
+typedef struct OMX_TI_VIDEO_RANGEMAPPING {
+	OMX_U32 nRangeMappingLuma;
+	OMX_U32 nRangeMappingChroma;
+} OMX_TI_VIDEO_RANGEMAPPING;
+
+/* ============================================================================= */
+/*!
+ @brief OMX_TI_VIDEO_RESCALINGMATRIX : Structure to access rescaled
+                                       width/height generated by decoders
+                                       as metatadata on its output port.
+ @param nScaledHeight   Scaled image width for post processing for decoder.
+ @param nScaledWidth    Scaled image height for post processing for decoder.
+*/
+/* ============================================================================= */
+
+typedef struct OMX_TI_VIDEO_RESCALINGMATRIX {
+	OMX_U32 nScaledHeight;
+	OMX_U32 nScaledWidth;
+} OMX_TI_VIDEO_RESCALINGMATRIX;
+
+
+/*==========================================================================*/
+/*!
+ @brief OMX_TI_PARAM_PAYLOADHEADERFLAG : To specify the payload headerflag
+                                         for VP6/VP7 decoder.
+ @param bPayloadHeaderFlag      Flag - TRUE indicates that frame length and
+                                timestamp(for IVF format) will be part of
+                                frame input buffer.
+                                Flag - FALSE indecates that frame length and
+                                timestamp(for IVF format) will not be part of
+                                the input buffer.
+*/
+/*==========================================================================*/
+
+typedef struct OMX_TI_PARAM_PAYLOADHEADERFLAG {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_BOOL bPayloadHeaderFlag;
+} OMX_TI_PARAM_PAYLOADHEADERFLAG;
+
+
+/*==========================================================================*/
+/*!
+@brief OMX_TI_PARAM_IVFFLAG : Suport added to handle IVF header Decoding Mode
+@param bIvfFlag               TRUE enables IVF decoding mode.
+                              FALSE indicates bitstream format is non-IVF.
+*/
+/*==========================================================================*/
+
+typedef struct OMX_TI_PARAM_IVFFLAG {
+	OMX_U32 nSize;
+	OMX_VERSIONTYPE nVersion;
+	OMX_BOOL bIvfFlag;
+} OMX_TI_PARAM_IVFFLAG;
+
+// A pointer to this struct is passed to OMX_SetParameter() when the extension
+// index "OMX.google.android.index.storeMetaDataInBuffers"
+// is given.
+//
+// When meta data is stored in the video buffers passed between OMX clients
+// and OMX components, interpretation of the buffer data is up to the
+// buffer receiver, and the data may or may not be the actual video data, but
+// some information helpful for the receiver to locate the actual data.
+// The buffer receiver thus needs to know how to interpret what is stored
+// in these buffers, with mechanisms pre-determined externally. How to
+// interpret the meta data is outside of the scope of this method.
+//
+// Currently, this is specifically used to pass meta data from video source
+// (camera component, for instance) to video encoder to avoid memcpying of
+// input video frame data. To do this, bStoreMetaDta is set to OMX_TRUE.
+// If bStoreMetaData is set to false, real YUV frame data will be stored
+// in the buffers. In addition, if no OMX_SetParameter() call is made
+// with the corresponding extension index, real YUV data is stored
+// in the buffers.
+typedef struct OMX_VIDEO_STOREMETADATAINBUFFERSPARAMS {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bStoreMetaData;
+} OMX_VIDEO_STOREMETADATAINBUFFERSPARAMS;
+
+#endif /* OMX_TI_VIDEO_H */
+
diff --git a/domx/omx_core/inc/OMX_Types.h b/domx/omx_core/inc/OMX_Types.h
new file mode 100755
index 0000000..31be916
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Types.h
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** OMX_Types.h - OpenMax IL version 1.1.2
+ *  The OMX_Types header file contains the primitive type definitions used by 
+ *  the core, the application and the component.  This file may need to be
+ *  modified to be used on systems that do not have "char" set to 8 bits, 
+ *  "short" set to 16 bits and "long" set to 32 bits.
+ */
+
+#ifndef OMX_Types_h
+#define OMX_Types_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/** The OMX_API and OMX_APIENTRY are platform specific definitions used
+ *  to declare OMX function prototypes.  They are modified to meet the
+ *  requirements for a particular platform */
+#ifdef __SYMBIAN32__   
+#   ifdef __OMX_EXPORTS
+#       define OMX_API __declspec(dllexport)
+#   else
+#       ifdef _WIN32
+#           define OMX_API __declspec(dllexport) 
+#       else
+#           define OMX_API __declspec(dllimport)
+#       endif
+#   endif
+#else
+#   ifdef _WIN32
+#      ifdef __OMX_EXPORTS
+#          define OMX_API __declspec(dllexport)
+#      else
+#          define OMX_API __declspec(dllimport)
+#      endif
+#   else
+#      ifdef __OMX_EXPORTS
+#          define OMX_API
+#      else
+#          define OMX_API extern
+#      endif
+#   endif
+#endif
+
+#ifndef OMX_APIENTRY
+#define OMX_APIENTRY 
+#endif 
+
+/** OMX_IN is used to identify inputs to an OMX function.  This designation 
+    will also be used in the case of a pointer that points to a parameter 
+    that is used as an output. */
+#ifndef OMX_IN
+#define OMX_IN
+#endif
+
+/** OMX_OUT is used to identify outputs from an OMX function.  This 
+    designation will also be used in the case of a pointer that points 
+    to a parameter that is used as an input. */
+#ifndef OMX_OUT
+#define OMX_OUT
+#endif
+
+
+/** OMX_INOUT is used to identify parameters that may be either inputs or
+    outputs from an OMX function at the same time.  This designation will 
+    also be used in the case of a pointer that  points to a parameter that 
+    is used both as an input and an output. */
+#ifndef OMX_INOUT
+#define OMX_INOUT
+#endif
+
+/** OMX_ALL is used to as a wildcard to select all entities of the same type
+ *  when specifying the index, or referring to a object by an index.  (i.e.
+ *  use OMX_ALL to indicate all N channels). When used as a port index
+ *  for a config or parameter this OMX_ALL denotes that the config or
+ *  parameter applies to the entire component not just one port. */
+#define OMX_ALL 0xFFFFFFFF
+
+/** In the following we define groups that help building doxygen documentation */
+
+/** @defgroup core OpenMAX IL core
+ * Functions and structure related to the OMX IL core
+ */
+ 
+ /** @defgroup comp OpenMAX IL component
+ * Functions and structure related to the OMX IL component
+ */
+ 
+/** @defgroup rpm Resource and Policy Management 
+ * Structures for resource and policy management of components
+ */
+
+/** @defgroup buf Buffer Management
+ * Buffer handling functions and structures
+ */
+  
+/** @defgroup tun Tunneling
+ * @ingroup core comp
+ * Structures and functions to manage tunnels among component ports
+ */
+ 
+/** @defgroup cp Content Pipes
+ *  @ingroup core
+ */
+ 
+ /** @defgroup metadata Metadata handling
+  * 
+  */ 
+
+/** OMX_U8 is an 8 bit unsigned quantity that is byte aligned */
+typedef unsigned char OMX_U8;
+
+/** OMX_S8 is an 8 bit signed quantity that is byte aligned */
+typedef signed char OMX_S8;
+
+/** OMX_U16 is a 16 bit unsigned quantity that is 16 bit word aligned */
+typedef unsigned short OMX_U16;
+
+/** OMX_S16 is a 16 bit signed quantity that is 16 bit word aligned */
+typedef signed short OMX_S16;
+
+/** OMX_U32 is a 32 bit unsigned quantity that is 32 bit word aligned */
+typedef unsigned long OMX_U32;
+
+/** OMX_S32 is a 32 bit signed quantity that is 32 bit word aligned */
+typedef signed long OMX_S32;
+
+
+/* Users with compilers that cannot accept the "long long" designation should
+   define the OMX_SKIP64BIT macro.  It should be noted that this may cause 
+   some components to fail to compile if the component was written to require
+   64 bit integral types.  However, these components would NOT compile anyway
+   since the compiler does not support the way the component was written.
+*/
+#ifndef OMX_SKIP64BIT
+#ifdef __SYMBIAN32__
+/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
+typedef unsigned long long OMX_U64;
+
+/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
+typedef signed long long OMX_S64;
+
+#elif defined(WIN32)
+
+/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */   
+typedef unsigned __int64  OMX_U64;
+
+/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
+typedef signed   __int64  OMX_S64;
+
+#else /* WIN32 */
+
+/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
+typedef unsigned long long OMX_U64;
+
+/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
+typedef signed long long OMX_S64;
+
+#endif /* WIN32 */
+#endif
+
+
+/** The OMX_BOOL type is intended to be used to represent a true or a false 
+    value when passing parameters to and from the OMX core and components.  The
+    OMX_BOOL is a 32 bit quantity and is aligned on a 32 bit word boundary.
+ */
+typedef enum OMX_BOOL {
+    OMX_FALSE = 0,
+    OMX_TRUE = !OMX_FALSE,
+    OMX_BOOL_MAX = 0x7FFFFFFF
+} OMX_BOOL; 
+ 
+/** The OMX_PTR type is intended to be used to pass pointers between the OMX
+    applications and the OMX Core and components.  This is a 32 bit pointer and
+    is aligned on a 32 bit boundary.
+ */
+typedef void* OMX_PTR;
+
+/** The OMX_STRING type is intended to be used to pass "C" type strings between
+    the application and the core and component.  The OMX_STRING type is a 32 
+    bit pointer to a zero terminated string.  The  pointer is word aligned and 
+    the string is byte aligned.  
+ */
+typedef char* OMX_STRING;
+
+/** The OMX_BYTE type is intended to be used to pass arrays of bytes such as
+    buffers between the application and the component and core.  The OMX_BYTE 
+    type is a 32 bit pointer to a zero terminated string.  The  pointer is word
+    aligned and the string is byte aligned.
+ */
+typedef unsigned char* OMX_BYTE;
+
+/** OMX_UUIDTYPE is a very long unique identifier to uniquely identify
+    at runtime.  This identifier should be generated by a component in a way
+    that guarantees that every instance of the identifier running on the system
+    is unique. */
+typedef unsigned char OMX_UUIDTYPE[128];
+
+/** The OMX_DIRTYPE enumeration is used to indicate if a port is an input or
+    an output port.  This enumeration is common across all component types.    
+ */
+typedef enum OMX_DIRTYPE
+{
+    OMX_DirInput,              /**< Port is an input port */
+    OMX_DirOutput,             /**< Port is an output port */
+    OMX_DirMax = 0x7FFFFFFF
+} OMX_DIRTYPE;
+
+/** The OMX_ENDIANTYPE enumeration is used to indicate the bit ordering 
+    for numerical data (i.e. big endian, or little endian).    
+ */
+typedef enum OMX_ENDIANTYPE
+{
+    OMX_EndianBig, /**< big endian */
+    OMX_EndianLittle, /**< little endian */
+    OMX_EndianMax = 0x7FFFFFFF
+} OMX_ENDIANTYPE;
+
+
+/** The OMX_NUMERICALDATATYPE enumeration is used to indicate if data 
+    is signed or unsigned
+ */
+typedef enum OMX_NUMERICALDATATYPE
+{
+    OMX_NumericalDataSigned, /**< signed data */
+    OMX_NumericalDataUnsigned, /**< unsigned data */
+    OMX_NumercialDataMax = 0x7FFFFFFF
+} OMX_NUMERICALDATATYPE;
+
+
+/** Unsigned bounded value type */
+typedef struct OMX_BU32 {
+    OMX_U32 nValue; /**< actual value */
+    OMX_U32 nMin;   /**< minimum for value (i.e. nValue >= nMin) */
+    OMX_U32 nMax;   /**< maximum for value (i.e. nValue <= nMax) */
+} OMX_BU32;
+
+
+/** Signed bounded value type */
+typedef struct OMX_BS32 {
+    OMX_S32 nValue; /**< actual value */
+    OMX_S32 nMin;   /**< minimum for value (i.e. nValue >= nMin) */
+    OMX_S32 nMax;   /**< maximum for value (i.e. nValue <= nMax) */
+} OMX_BS32;
+
+
+/** Structure representing some time or duration in microseconds. This structure
+  *  must be interpreted as a signed 64 bit value. The quantity is signed to accommodate 
+  *  negative deltas and preroll scenarios. The quantity is represented in microseconds 
+  *  to accomodate high resolution timestamps (e.g. DVD presentation timestamps based
+  *  on a 90kHz clock) and to allow more accurate and synchronized delivery (e.g. 
+  *  individual audio samples delivered at 192 kHz). The quantity is 64 bit to 
+  *  accommodate a large dynamic range (signed 32 bit values would allow only for plus
+  *  or minus 35 minutes).
+  *
+  *  Implementations with limited precision may convert the signed 64 bit value to 
+  *  a signed 32 bit value internally but risk loss of precision.  
+  */
+#ifndef OMX_SKIP64BIT
+typedef OMX_S64 OMX_TICKS;
+#else
+typedef struct OMX_TICKS
+{
+    OMX_U32 nLowPart;    /** low bits of the signed 64 bit tick value */
+    OMX_U32 nHighPart;   /** high bits of the signed 64 bit tick value */
+} OMX_TICKS;
+#endif
+#define OMX_TICKS_PER_SECOND 1000000
+
+/** Define the public interface for the OMX Handle.  The core will not use
+    this value internally, but the application should only use this value.
+ */
+typedef void* OMX_HANDLETYPE;
+
+typedef struct OMX_MARKTYPE
+{
+    OMX_HANDLETYPE hMarkTargetComponent;   /**< The component that will 
+                                                generate a mark event upon 
+                                                processing the mark. */
+    OMX_PTR pMarkData;   /**< Application specific data associated with 
+                              the mark sent on a mark event to disambiguate 
+                              this mark from others. */
+} OMX_MARKTYPE;
+
+
+/** OMX_NATIVE_DEVICETYPE is used to map a OMX video port to the
+ *  platform & operating specific object used to reference the display 
+ *  or can be used by a audio port for native audio rendering */
+typedef void* OMX_NATIVE_DEVICETYPE;
+
+/** OMX_NATIVE_WINDOWTYPE is used to map a OMX video port to the
+ *  platform & operating specific object used to reference the window */
+typedef void* OMX_NATIVE_WINDOWTYPE;
+
+/** The OMX_VERSIONTYPE union is used to specify the version for
+    a structure or component.  For a component, the version is entirely
+    specified by the component vendor.  Components doing the same function
+    from different vendors may or may not have the same version.  For 
+    structures, the version shall be set by the entity that allocates the
+    structure.  For structures specified in the OMX 1.1 specification, the
+    value of the version shall be set to 1.1.0.0 in all cases.  Access to the
+    OMX_VERSIONTYPE can be by a single 32 bit access (e.g. by nVersion) or
+    by accessing one of the structure elements to, for example, check only
+    the Major revision.
+ */
+typedef union OMX_VERSIONTYPE
+{
+    struct
+    {
+        OMX_U8 nVersionMajor;   /**< Major version accessor element */
+        OMX_U8 nVersionMinor;   /**< Minor version accessor element */
+        OMX_U8 nRevision;       /**< Revision version accessor element */
+        OMX_U8 nStep;           /**< Step version accessor element */
+    } s;
+    OMX_U32 nVersion;           /**< 32 bit value to make accessing the
+                                    version easily done in a single word
+                                    size copy/compare operation */
+} OMX_VERSIONTYPE;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
diff --git a/domx/omx_core/inc/OMX_Video.h b/domx/omx_core/inc/OMX_Video.h
new file mode 100755
index 0000000..163e450
--- /dev/null
+++ b/domx/omx_core/inc/OMX_Video.h
@@ -0,0 +1,1060 @@
+/**
+ * Copyright (c) 2008 The Khronos Group Inc. 
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions: 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+ *
+ */
+
+/** 
+ *  @file OMX_Video.h - OpenMax IL version 1.1.2
+ *  The structures is needed by Video components to exchange parameters 
+ *  and configuration data with OMX components.
+ */
+#ifndef OMX_Video_h
+#define OMX_Video_h
+
+/** @defgroup video OpenMAX IL Video Domain
+ * @ingroup iv
+ * Structures for OpenMAX IL Video domain
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/**
+ * Each OMX header must include all required header files to allow the
+ * header to compile without errors.  The includes below are required
+ * for this header file to compile successfully 
+ */
+
+#include <OMX_IVCommon.h>
+
+
+/**
+ * Enumeration used to define the possible video compression codings.  
+ * NOTE:  This essentially refers to file extensions. If the coding is 
+ *        being used to specify the ENCODE type, then additional work 
+ *        must be done to configure the exact flavor of the compression 
+ *        to be used.  For decode cases where the user application can 
+ *        not differentiate between MPEG-4 and H.264 bit streams, it is 
+ *        up to the codec to handle this.
+ */
+typedef enum OMX_VIDEO_CODINGTYPE {
+    OMX_VIDEO_CodingUnused,     /**< Value when coding is N/A */
+    OMX_VIDEO_CodingAutoDetect, /**< Autodetection of coding type */
+    OMX_VIDEO_CodingMPEG2,      /**< AKA: H.262 */
+    OMX_VIDEO_CodingH263,       /**< H.263 */
+    OMX_VIDEO_CodingMPEG4,      /**< MPEG-4 */
+    OMX_VIDEO_CodingWMV,        /**< all versions of Windows Media Video */
+    OMX_VIDEO_CodingRV,         /**< all versions of Real Video */
+    OMX_VIDEO_CodingAVC,        /**< H.264/AVC */
+    OMX_VIDEO_CodingMJPEG,      /**< Motion JPEG */
+    OMX_VIDEO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_CodingMax = 0x7FFFFFFF
+} OMX_VIDEO_CODINGTYPE;
+
+
+/**
+ * Data structure used to define a video path.  The number of Video paths for 
+ * input and output will vary by type of the Video component.  
+ * 
+ *    Input (aka Source) : zero Inputs, one Output,
+ *    Splitter           : one Input, 2 or more Outputs,
+ *    Processing Element : one Input, one output,
+ *    Mixer              : 2 or more inputs, one output,
+ *    Output (aka Sink)  : one Input, zero outputs.
+ * 
+ * The PortDefinition structure is used to define all of the parameters 
+ * necessary for the compliant component to setup an input or an output video 
+ * path.  If additional vendor specific data is required, it should be 
+ * transmitted to the component using the CustomCommand function.  Compliant 
+ * components will prepopulate this structure with optimal values during the 
+ * GetDefaultInitParams command.
+ *
+ * STRUCT MEMBERS:
+ *  cMIMEType             : MIME type of data for the port
+ *  pNativeRender         : Platform specific reference for a display if a 
+ *                          sync, otherwise this field is 0
+ *  nFrameWidth           : Width of frame to be used on channel if 
+ *                          uncompressed format is used.  Use 0 for unknown,
+ *                          don't care or variable
+ *  nFrameHeight          : Height of frame to be used on channel if 
+ *                          uncompressed format is used. Use 0 for unknown,
+ *                          don't care or variable
+ *  nStride               : Number of bytes per span of an image 
+ *                          (i.e. indicates the number of bytes to get
+ *                          from span N to span N+1, where negative stride
+ *                          indicates the image is bottom up
+ *  nSliceHeight          : Height used when encoding in slices
+ *  nBitrate              : Bit rate of frame to be used on channel if 
+ *                          compressed format is used. Use 0 for unknown, 
+ *                          don't care or variable
+ *  xFramerate            : Frame rate to be used on channel if uncompressed 
+ *                          format is used. Use 0 for unknown, don't care or 
+ *                          variable.  Units are Q16 frames per second.
+ *  bFlagErrorConcealment : Turns on error concealment if it is supported by 
+ *                          the OMX component
+ *  eCompressionFormat    : Compression format used in this instance of the 
+ *                          component. When OMX_VIDEO_CodingUnused is 
+ *                          specified, eColorFormat is used
+ *  eColorFormat : Decompressed format used by this component
+ *  pNativeWindow : Platform specific reference for a window object if a 
+ *                          display sink , otherwise this field is 0x0. 
+ */
+typedef struct OMX_VIDEO_PORTDEFINITIONTYPE {
+    OMX_STRING cMIMEType;
+    OMX_NATIVE_DEVICETYPE pNativeRender;
+    OMX_U32 nFrameWidth;
+    OMX_U32 nFrameHeight;
+    OMX_S32 nStride;
+    OMX_U32 nSliceHeight;
+    OMX_U32 nBitrate;
+    OMX_U32 xFramerate;
+    OMX_BOOL bFlagErrorConcealment;
+    OMX_VIDEO_CODINGTYPE eCompressionFormat;
+    OMX_COLOR_FORMATTYPE eColorFormat;
+    OMX_NATIVE_WINDOWTYPE pNativeWindow;
+} OMX_VIDEO_PORTDEFINITIONTYPE;
+
+/**  
+ * Port format parameter.  This structure is used to enumerate the various 
+ * data input/output format supported by the port.
+ * 
+ * STRUCT MEMBERS:
+ *  nSize              : Size of the structure in bytes
+ *  nVersion           : OMX specification version information
+ *  nPortIndex         : Indicates which port to set
+ *  nIndex             : Indicates the enumeration index for the format from 
+ *                       0x0 to N-1
+ *  eCompressionFormat : Compression format used in this instance of the 
+ *                       component. When OMX_VIDEO_CodingUnused is specified, 
+ *                       eColorFormat is used 
+ *  eColorFormat       : Decompressed format used by this component
+ *  xFrameRate         : Indicates the video frame rate in Q16 format
+ */
+typedef struct OMX_VIDEO_PARAM_PORTFORMATTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nIndex;
+    OMX_VIDEO_CODINGTYPE eCompressionFormat; 
+    OMX_COLOR_FORMATTYPE eColorFormat;
+    OMX_U32 xFramerate;
+} OMX_VIDEO_PARAM_PORTFORMATTYPE;
+
+
+/**
+ * This is a structure for configuring video compression quantization 
+ * parameter values.  Codecs may support different QP values for different
+ * frame types.
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version info
+ *  nPortIndex : Port that this structure applies to
+ *  nQpI       : QP value to use for index frames
+ *  nQpP       : QP value to use for P frames
+ *  nQpB       : QP values to use for bidirectional frames 
+ */
+typedef struct OMX_VIDEO_PARAM_QUANTIZATIONTYPE {
+    OMX_U32 nSize;            
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nQpI;
+    OMX_U32 nQpP;
+    OMX_U32 nQpB;
+} OMX_VIDEO_PARAM_QUANTIZATIONTYPE;
+
+
+/** 
+ * Structure for configuration of video fast update parameters. 
+ *  
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version info 
+ *  nPortIndex : Port that this structure applies to
+ *  bEnableVFU : Enable/Disable video fast update
+ *  nFirstGOB  : Specifies the number of the first macroblock row
+ *  nFirstMB   : specifies the first MB relative to the specified first GOB
+ *  nNumMBs    : Specifies the number of MBs to be refreshed from nFirstGOB 
+ *               and nFirstMB
+ */
+typedef struct OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE {
+    OMX_U32 nSize;            
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;       
+    OMX_BOOL bEnableVFU;      
+    OMX_U32 nFirstGOB;                            
+    OMX_U32 nFirstMB;                            
+    OMX_U32 nNumMBs;                                  
+} OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE;
+
+
+/** 
+ * Enumeration of possible bitrate control types 
+ */
+typedef enum OMX_VIDEO_CONTROLRATETYPE {
+    OMX_Video_ControlRateDisable,
+    OMX_Video_ControlRateVariable,
+    OMX_Video_ControlRateConstant,
+    OMX_Video_ControlRateVariableSkipFrames,
+    OMX_Video_ControlRateConstantSkipFrames,
+    OMX_Video_ControlRateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_Video_ControlRateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_Video_ControlRateMax = 0x7FFFFFFF
+} OMX_VIDEO_CONTROLRATETYPE;
+
+
+/** 
+ * Structure for configuring bitrate mode of a codec. 
+ *
+ * STRUCT MEMBERS:
+ *  nSize          : Size of the struct in bytes
+ *  nVersion       : OMX spec version info
+ *  nPortIndex     : Port that this struct applies to
+ *  eControlRate   : Control rate type enum
+ *  nTargetBitrate : Target bitrate to encode with
+ */
+typedef struct OMX_VIDEO_PARAM_BITRATETYPE {
+    OMX_U32 nSize;                          
+    OMX_VERSIONTYPE nVersion;               
+    OMX_U32 nPortIndex;                     
+    OMX_VIDEO_CONTROLRATETYPE eControlRate; 
+    OMX_U32 nTargetBitrate;                 
+} OMX_VIDEO_PARAM_BITRATETYPE;
+
+
+/** 
+ * Enumeration of possible motion vector (MV) types 
+ */
+typedef enum OMX_VIDEO_MOTIONVECTORTYPE {
+    OMX_Video_MotionVectorPixel,
+    OMX_Video_MotionVectorHalfPel,
+    OMX_Video_MotionVectorQuarterPel,
+    OMX_Video_MotionVectorEighthPel,
+    OMX_Video_MotionVectorKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_Video_MotionVectorVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_Video_MotionVectorMax = 0x7FFFFFFF
+} OMX_VIDEO_MOTIONVECTORTYPE;
+
+
+/**
+ * Structure for configuring the number of motion vectors used as well
+ * as their accuracy.
+ * 
+ * STRUCT MEMBERS:
+ *  nSize            : Size of the struct in bytes
+ *  nVersion         : OMX spec version info
+ *  nPortIndex       : port that this structure applies to
+ *  eAccuracy        : Enumerated MV accuracy
+ *  bUnrestrictedMVs : Allow unrestricted MVs
+ *  bFourMV          : Allow use of 4 MVs
+ *  sXSearchRange    : Search range in horizontal direction for MVs
+ *  sYSearchRange    : Search range in vertical direction for MVs
+ */
+typedef struct OMX_VIDEO_PARAM_MOTIONVECTORTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEO_MOTIONVECTORTYPE eAccuracy;
+    OMX_BOOL bUnrestrictedMVs;
+    OMX_BOOL bFourMV;
+    OMX_S32 sXSearchRange;
+    OMX_S32 sYSearchRange;
+} OMX_VIDEO_PARAM_MOTIONVECTORTYPE;
+
+
+/** 
+ * Enumeration of possible methods to use for Intra Refresh 
+ */
+typedef enum OMX_VIDEO_INTRAREFRESHTYPE {
+    OMX_VIDEO_IntraRefreshCyclic,
+    OMX_VIDEO_IntraRefreshAdaptive,
+    OMX_VIDEO_IntraRefreshBoth,
+    OMX_VIDEO_IntraRefreshKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_IntraRefreshVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_IntraRefreshMax = 0x7FFFFFFF
+} OMX_VIDEO_INTRAREFRESHTYPE;
+
+
+/**
+ * Structure for configuring intra refresh mode 
+ * 
+ * STRUCT MEMBERS:
+ *  nSize        : Size of the structure in bytes
+ *  nVersion     : OMX specification version information
+ *  nPortIndex   : Port that this structure applies to
+ *  eRefreshMode : Cyclic, Adaptive, or Both
+ *  nAirMBs      : Number of intra macroblocks to refresh in a frame when 
+ *                 AIR is enabled
+ *  nAirRef      : Number of times a motion marked macroblock has to be  
+ *                 intra coded
+ *  nCirMBs      : Number of consecutive macroblocks to be coded as "intra"  
+ *                 when CIR is enabled
+ */
+typedef struct OMX_VIDEO_PARAM_INTRAREFRESHTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEO_INTRAREFRESHTYPE eRefreshMode;
+    OMX_U32 nAirMBs;
+    OMX_U32 nAirRef;
+    OMX_U32 nCirMBs;
+} OMX_VIDEO_PARAM_INTRAREFRESHTYPE;
+
+
+/**
+ * Structure for enabling various error correction methods for video 
+ * compression.
+ *
+ * STRUCT MEMBERS:
+ *  nSize                   : Size of the structure in bytes
+ *  nVersion                : OMX specification version information 
+ *  nPortIndex              : Port that this structure applies to 
+ *  bEnableHEC              : Enable/disable header extension codes (HEC)
+ *  bEnableResync           : Enable/disable resynchronization markers
+ *  nResynchMarkerSpacing   : Resynch markers interval (in bits) to be 
+ *                            applied in the stream 
+ *  bEnableDataPartitioning : Enable/disable data partitioning 
+ *  bEnableRVLC             : Enable/disable reversible variable length 
+ *                            coding
+ */
+typedef struct OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnableHEC;
+    OMX_BOOL bEnableResync;
+    OMX_U32  nResynchMarkerSpacing;
+    OMX_BOOL bEnableDataPartitioning;
+    OMX_BOOL bEnableRVLC;
+} OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE;
+
+
+/** 
+ * Configuration of variable block-size motion compensation (VBSMC) 
+ * 
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information 
+ *  nPortIndex : Port that this structure applies to
+ *  b16x16     : Enable inter block search 16x16
+ *  b16x8      : Enable inter block search 16x8
+ *  b8x16      : Enable inter block search 8x16
+ *  b8x8       : Enable inter block search 8x8
+ *  b8x4       : Enable inter block search 8x4
+ *  b4x8       : Enable inter block search 4x8
+ *  b4x4       : Enable inter block search 4x4
+ */
+typedef struct OMX_VIDEO_PARAM_VBSMCTYPE {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion; 
+    OMX_U32 nPortIndex;       
+    OMX_BOOL b16x16; 
+    OMX_BOOL b16x8; 
+    OMX_BOOL b8x16;
+    OMX_BOOL b8x8;
+    OMX_BOOL b8x4;
+    OMX_BOOL b4x8;
+    OMX_BOOL b4x4;
+} OMX_VIDEO_PARAM_VBSMCTYPE;
+
+
+/** 
+ * H.263 profile types, each profile indicates support for various 
+ * performance bounds and different annexes.
+ *
+ * ENUMS:
+ *  Baseline           : Baseline Profile: H.263 (V1), no optional modes                                                    
+ *  H320 Coding        : H.320 Coding Efficiency Backward Compatibility 
+ *                       Profile: H.263+ (V2), includes annexes I, J, L.4
+ *                       and T
+ *  BackwardCompatible : Backward Compatibility Profile: H.263 (V1), 
+ *                       includes annex F                                    
+ *  ISWV2              : Interactive Streaming Wireless Profile: H.263+ 
+ *                       (V2), includes annexes I, J, K and T                 
+ *  ISWV3              : Interactive Streaming Wireless Profile: H.263++  
+ *                       (V3), includes profile 3 and annexes V and W.6.3.8   
+ *  HighCompression    : Conversational High Compression Profile: H.263++  
+ *                       (V3), includes profiles 1 & 2 and annexes D and U   
+ *  Internet           : Conversational Internet Profile: H.263++ (V3),  
+ *                       includes profile 5 and annex K                       
+ *  Interlace          : Conversational Interlace Profile: H.263++ (V3),  
+ *                       includes profile 5 and annex W.6.3.11               
+ *  HighLatency        : High Latency Profile: H.263++ (V3), includes  
+ *                       profile 6 and annexes O.1 and P.5                       
+ */
+typedef enum OMX_VIDEO_H263PROFILETYPE {
+    OMX_VIDEO_H263ProfileBaseline            = 0x01,        
+    OMX_VIDEO_H263ProfileH320Coding          = 0x02,          
+    OMX_VIDEO_H263ProfileBackwardCompatible  = 0x04,  
+    OMX_VIDEO_H263ProfileISWV2               = 0x08,               
+    OMX_VIDEO_H263ProfileISWV3               = 0x10,               
+    OMX_VIDEO_H263ProfileHighCompression     = 0x20,     
+    OMX_VIDEO_H263ProfileInternet            = 0x40,            
+    OMX_VIDEO_H263ProfileInterlace           = 0x80,           
+    OMX_VIDEO_H263ProfileHighLatency         = 0x100,         
+    OMX_VIDEO_H263ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_H263ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_H263ProfileMax                 = 0x7FFFFFFF  
+} OMX_VIDEO_H263PROFILETYPE;
+
+
+/** 
+ * H.263 level types, each level indicates support for various frame sizes, 
+ * bit rates, decoder frame rates.
+ */
+typedef enum OMX_VIDEO_H263LEVELTYPE {
+    OMX_VIDEO_H263Level10  = 0x01,  
+    OMX_VIDEO_H263Level20  = 0x02,      
+    OMX_VIDEO_H263Level30  = 0x04,      
+    OMX_VIDEO_H263Level40  = 0x08,      
+    OMX_VIDEO_H263Level45  = 0x10,      
+    OMX_VIDEO_H263Level50  = 0x20,      
+    OMX_VIDEO_H263Level60  = 0x40,      
+    OMX_VIDEO_H263Level70  = 0x80, 
+    OMX_VIDEO_H263LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_H263LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_H263LevelMax = 0x7FFFFFFF  
+} OMX_VIDEO_H263LEVELTYPE;
+
+
+/** 
+ * Specifies the picture type. These values should be OR'd to signal all 
+ * pictures types which are allowed.
+ *
+ * ENUMS:
+ *  Generic Picture Types:          I, P and B
+ *  H.263 Specific Picture Types:   SI and SP
+ *  H.264 Specific Picture Types:   EI and EP
+ *  MPEG-4 Specific Picture Types:  S
+ */
+typedef enum OMX_VIDEO_PICTURETYPE {
+    OMX_VIDEO_PictureTypeI   = 0x01,
+    OMX_VIDEO_PictureTypeP   = 0x02,
+    OMX_VIDEO_PictureTypeB   = 0x04,
+    OMX_VIDEO_PictureTypeSI  = 0x08,
+    OMX_VIDEO_PictureTypeSP  = 0x10,
+    OMX_VIDEO_PictureTypeEI  = 0x11,
+    OMX_VIDEO_PictureTypeEP  = 0x12,
+    OMX_VIDEO_PictureTypeS   = 0x14,
+    OMX_VIDEO_PictureTypeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_PictureTypeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_PictureTypeMax = 0x7FFFFFFF
+} OMX_VIDEO_PICTURETYPE;
+
+
+/** 
+ * H.263 Params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize                    : Size of the structure in bytes
+ *  nVersion                 : OMX specification version information 
+ *  nPortIndex               : Port that this structure applies to
+ *  nPFrames                 : Number of P frames between each I frame
+ *  nBFrames                 : Number of B frames between each I frame
+ *  eProfile                 : H.263 profile(s) to use
+ *  eLevel                   : H.263 level(s) to use
+ *  bPLUSPTYPEAllowed        : Indicating that it is allowed to use PLUSPTYPE 
+ *                             (specified in the 1998 version of H.263) to 
+ *                             indicate custom picture sizes or clock 
+ *                             frequencies 
+ *  nAllowedPictureTypes     : Specifies the picture types allowed in the 
+ *                             bitstream
+ *  bForceRoundingTypeToZero : value of the RTYPE bit (bit 6 of MPPTYPE) is 
+ *                             not constrained. It is recommended to change 
+ *                             the value of the RTYPE bit for each reference 
+ *                             picture in error-free communication
+ *  nPictureHeaderRepetition : Specifies the frequency of picture header 
+ *                             repetition
+ *  nGOBHeaderInterval       : Specifies the interval of non-empty GOB  
+ *                             headers in units of GOBs
+ */
+typedef struct OMX_VIDEO_PARAM_H263TYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nPFrames;
+    OMX_U32 nBFrames;
+    OMX_VIDEO_H263PROFILETYPE eProfile;
+	OMX_VIDEO_H263LEVELTYPE eLevel;
+    OMX_BOOL bPLUSPTYPEAllowed;
+    OMX_U32 nAllowedPictureTypes;
+    OMX_BOOL bForceRoundingTypeToZero;
+    OMX_U32 nPictureHeaderRepetition;
+    OMX_U32 nGOBHeaderInterval;
+} OMX_VIDEO_PARAM_H263TYPE;
+
+
+/** 
+ * MPEG-2 profile types, each profile indicates support for various 
+ * performance bounds and different annexes.
+ */
+typedef enum OMX_VIDEO_MPEG2PROFILETYPE {
+    OMX_VIDEO_MPEG2ProfileSimple = 0,  /**< Simple Profile */
+    OMX_VIDEO_MPEG2ProfileMain,        /**< Main Profile */
+    OMX_VIDEO_MPEG2Profile422,         /**< 4:2:2 Profile */
+    OMX_VIDEO_MPEG2ProfileSNR,         /**< SNR Profile */
+    OMX_VIDEO_MPEG2ProfileSpatial,     /**< Spatial Profile */
+    OMX_VIDEO_MPEG2ProfileHigh,        /**< High Profile */
+    OMX_VIDEO_MPEG2ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_MPEG2ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_MPEG2ProfileMax = 0x7FFFFFFF  
+} OMX_VIDEO_MPEG2PROFILETYPE;
+
+
+/** 
+ * MPEG-2 level types, each level indicates support for various frame 
+ * sizes, bit rates, decoder frame rates.  No need 
+ */
+typedef enum OMX_VIDEO_MPEG2LEVELTYPE {
+    OMX_VIDEO_MPEG2LevelLL = 0,  /**< Low Level */ 
+    OMX_VIDEO_MPEG2LevelML,      /**< Main Level */ 
+    OMX_VIDEO_MPEG2LevelH14,     /**< High 1440 */ 
+    OMX_VIDEO_MPEG2LevelHL,      /**< High Level */   
+    OMX_VIDEO_MPEG2LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_MPEG2LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_MPEG2LevelMax = 0x7FFFFFFF  
+} OMX_VIDEO_MPEG2LEVELTYPE;
+
+
+/** 
+ * MPEG-2 params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nPFrames   : Number of P frames between each I frame
+ *  nBFrames   : Number of B frames between each I frame
+ *  eProfile   : MPEG-2 profile(s) to use
+ *  eLevel     : MPEG-2 levels(s) to use
+ */
+typedef struct OMX_VIDEO_PARAM_MPEG2TYPE {
+    OMX_U32 nSize;           
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;      
+    OMX_U32 nPFrames;        
+    OMX_U32 nBFrames;        
+    OMX_VIDEO_MPEG2PROFILETYPE eProfile;
+	OMX_VIDEO_MPEG2LEVELTYPE eLevel;   
+} OMX_VIDEO_PARAM_MPEG2TYPE;
+
+
+/** 
+ * MPEG-4 profile types, each profile indicates support for various 
+ * performance bounds and different annexes.
+ * 
+ * ENUMS:
+ *  - Simple Profile, Levels 1-3
+ *  - Simple Scalable Profile, Levels 1-2
+ *  - Core Profile, Levels 1-2
+ *  - Main Profile, Levels 2-4
+ *  - N-bit Profile, Level 2
+ *  - Scalable Texture Profile, Level 1
+ *  - Simple Face Animation Profile, Levels 1-2
+ *  - Simple Face and Body Animation (FBA) Profile, Levels 1-2
+ *  - Basic Animated Texture Profile, Levels 1-2
+ *  - Hybrid Profile, Levels 1-2
+ *  - Advanced Real Time Simple Profiles, Levels 1-4
+ *  - Core Scalable Profile, Levels 1-3
+ *  - Advanced Coding Efficiency Profile, Levels 1-4
+ *  - Advanced Core Profile, Levels 1-2
+ *  - Advanced Scalable Texture, Levels 2-3
+ */
+typedef enum OMX_VIDEO_MPEG4PROFILETYPE {
+    OMX_VIDEO_MPEG4ProfileSimple           = 0x01,        
+    OMX_VIDEO_MPEG4ProfileSimpleScalable   = 0x02,    
+    OMX_VIDEO_MPEG4ProfileCore             = 0x04,              
+    OMX_VIDEO_MPEG4ProfileMain             = 0x08,             
+    OMX_VIDEO_MPEG4ProfileNbit             = 0x10,              
+    OMX_VIDEO_MPEG4ProfileScalableTexture  = 0x20,   
+    OMX_VIDEO_MPEG4ProfileSimpleFace       = 0x40,        
+    OMX_VIDEO_MPEG4ProfileSimpleFBA        = 0x80,         
+    OMX_VIDEO_MPEG4ProfileBasicAnimated    = 0x100,     
+    OMX_VIDEO_MPEG4ProfileHybrid           = 0x200,            
+    OMX_VIDEO_MPEG4ProfileAdvancedRealTime = 0x400,  
+    OMX_VIDEO_MPEG4ProfileCoreScalable     = 0x800,      
+    OMX_VIDEO_MPEG4ProfileAdvancedCoding   = 0x1000,    
+    OMX_VIDEO_MPEG4ProfileAdvancedCore     = 0x2000,      
+    OMX_VIDEO_MPEG4ProfileAdvancedScalable = 0x4000,
+    OMX_VIDEO_MPEG4ProfileAdvancedSimple   = 0x8000,
+    OMX_VIDEO_MPEG4ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_MPEG4ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_MPEG4ProfileMax              = 0x7FFFFFFF  
+} OMX_VIDEO_MPEG4PROFILETYPE;
+
+
+/** 
+ * MPEG-4 level types, each level indicates support for various frame 
+ * sizes, bit rates, decoder frame rates.  No need 
+ */
+typedef enum OMX_VIDEO_MPEG4LEVELTYPE {
+    OMX_VIDEO_MPEG4Level0  = 0x01,   /**< Level 0 */   
+    OMX_VIDEO_MPEG4Level0b = 0x02,   /**< Level 0b */   
+    OMX_VIDEO_MPEG4Level1  = 0x04,   /**< Level 1 */ 
+    OMX_VIDEO_MPEG4Level2  = 0x08,   /**< Level 2 */ 
+    OMX_VIDEO_MPEG4Level3  = 0x10,   /**< Level 3 */ 
+    OMX_VIDEO_MPEG4Level4  = 0x20,   /**< Level 4 */  
+    OMX_VIDEO_MPEG4Level4a = 0x40,   /**< Level 4a */  
+    OMX_VIDEO_MPEG4Level5  = 0x80,   /**< Level 5 */  
+    OMX_VIDEO_MPEG4LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_MPEG4LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_MPEG4LevelMax = 0x7FFFFFFF  
+} OMX_VIDEO_MPEG4LEVELTYPE;
+
+
+/** 
+ * MPEG-4 configuration.  This structure handles configuration options
+ * which are specific to MPEG4 algorithms
+ *
+ * STRUCT MEMBERS:
+ *  nSize                : Size of the structure in bytes
+ *  nVersion             : OMX specification version information
+ *  nPortIndex           : Port that this structure applies to
+ *  nSliceHeaderSpacing  : Number of macroblocks between slice header (H263+ 
+ *                         Annex K). Put zero if not used
+ *  bSVH                 : Enable Short Video Header mode
+ *  bGov                 : Flag to enable GOV
+ *  nPFrames             : Number of P frames between each I frame (also called 
+ *                         GOV period)
+ *  nBFrames             : Number of B frames between each I frame
+ *  nIDCVLCThreshold     : Value of intra DC VLC threshold
+ *  bACPred              : Flag to use ac prediction
+ *  nMaxPacketSize       : Maximum size of packet in bytes.
+ *  nTimeIncRes          : Used to pass VOP time increment resolution for MPEG4. 
+ *                         Interpreted as described in MPEG4 standard.
+ *  eProfile             : MPEG-4 profile(s) to use.
+ *  eLevel               : MPEG-4 level(s) to use.
+ *  nAllowedPictureTypes : Specifies the picture types allowed in the bitstream
+ *  nHeaderExtension     : Specifies the number of consecutive video packet
+ *                         headers within a VOP
+ *  bReversibleVLC       : Specifies whether reversible variable length coding 
+ *                         is in use
+ */
+typedef struct OMX_VIDEO_PARAM_MPEG4TYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nSliceHeaderSpacing;
+    OMX_BOOL bSVH;
+    OMX_BOOL bGov;
+    OMX_U32 nPFrames;
+    OMX_U32 nBFrames;
+    OMX_U32 nIDCVLCThreshold;
+    OMX_BOOL bACPred;
+    OMX_U32 nMaxPacketSize;
+    OMX_U32 nTimeIncRes;
+    OMX_VIDEO_MPEG4PROFILETYPE eProfile;
+    OMX_VIDEO_MPEG4LEVELTYPE eLevel;
+    OMX_U32 nAllowedPictureTypes;
+    OMX_U32 nHeaderExtension;
+    OMX_BOOL bReversibleVLC;
+} OMX_VIDEO_PARAM_MPEG4TYPE;
+
+
+/** 
+ * WMV Versions 
+ */
+typedef enum OMX_VIDEO_WMVFORMATTYPE {
+    OMX_VIDEO_WMVFormatUnused = 0x01,   /**< Format unused or unknown */
+    OMX_VIDEO_WMVFormat7      = 0x02,   /**< Windows Media Video format 7 */
+    OMX_VIDEO_WMVFormat8      = 0x04,   /**< Windows Media Video format 8 */
+    OMX_VIDEO_WMVFormat9      = 0x08,   /**< Windows Media Video format 9 */
+    OMX_VIDEO_WMFFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_WMFFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_WMVFormatMax    = 0x7FFFFFFF
+} OMX_VIDEO_WMVFORMATTYPE;
+
+
+/** 
+ * WMV Params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  eFormat    : Version of WMV stream / data
+ */
+typedef struct OMX_VIDEO_PARAM_WMVTYPE {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEO_WMVFORMATTYPE eFormat;
+} OMX_VIDEO_PARAM_WMVTYPE;
+
+
+/** 
+ * Real Video Version 
+ */
+typedef enum OMX_VIDEO_RVFORMATTYPE {
+    OMX_VIDEO_RVFormatUnused = 0, /**< Format unused or unknown */
+    OMX_VIDEO_RVFormat8,          /**< Real Video format 8 */
+    OMX_VIDEO_RVFormat9,          /**< Real Video format 9 */
+    OMX_VIDEO_RVFormatG2,         /**< Real Video Format G2 */
+    OMX_VIDEO_RVFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_RVFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_RVFormatMax = 0x7FFFFFFF
+} OMX_VIDEO_RVFORMATTYPE;
+
+
+/** 
+ * Real Video Params 
+ *
+ * STUCT MEMBERS:
+ *  nSize              : Size of the structure in bytes
+ *  nVersion           : OMX specification version information 
+ *  nPortIndex         : Port that this structure applies to
+ *  eFormat            : Version of RV stream / data
+ *  nBitsPerPixel      : Bits per pixel coded in the frame
+ *  nPaddedWidth       : Padded width in pixel of a video frame
+ *  nPaddedHeight      : Padded Height in pixels of a video frame
+ *  nFrameRate         : Rate of video in frames per second
+ *  nBitstreamFlags    : Flags which internal information about the bitstream
+ *  nBitstreamVersion  : Bitstream version
+ *  nMaxEncodeFrameSize: Max encoded frame size
+ *  bEnablePostFilter  : Turn on/off post filter
+ *  bEnableTemporalInterpolation : Turn on/off temporal interpolation
+ *  bEnableLatencyMode : When enabled, the decoder does not display a decoded 
+ *                       frame until it has detected that no enhancement layer 
+ *  					 frames or dependent B frames will be coming. This 
+ *  					 detection usually occurs when a subsequent non-B 
+ *  					 frame is encountered 
+ */
+typedef struct OMX_VIDEO_PARAM_RVTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_VIDEO_RVFORMATTYPE eFormat;
+    OMX_U16 nBitsPerPixel;
+    OMX_U16 nPaddedWidth;
+    OMX_U16 nPaddedHeight;
+    OMX_U32 nFrameRate;
+    OMX_U32 nBitstreamFlags;
+    OMX_U32 nBitstreamVersion;
+    OMX_U32 nMaxEncodeFrameSize;
+    OMX_BOOL bEnablePostFilter;
+    OMX_BOOL bEnableTemporalInterpolation;
+    OMX_BOOL bEnableLatencyMode;
+} OMX_VIDEO_PARAM_RVTYPE;
+
+
+/** 
+ * AVC profile types, each profile indicates support for various 
+ * performance bounds and different annexes.
+ */
+typedef enum OMX_VIDEO_AVCPROFILETYPE {
+    OMX_VIDEO_AVCProfileBaseline = 0x01,   /**< Baseline profile */
+    OMX_VIDEO_AVCProfileMain     = 0x02,   /**< Main profile */
+    OMX_VIDEO_AVCProfileExtended = 0x04,   /**< Extended profile */
+    OMX_VIDEO_AVCProfileHigh     = 0x08,   /**< High profile */
+    OMX_VIDEO_AVCProfileHigh10   = 0x10,   /**< High 10 profile */
+    OMX_VIDEO_AVCProfileHigh422  = 0x20,   /**< High 4:2:2 profile */
+    OMX_VIDEO_AVCProfileHigh444  = 0x40,   /**< High 4:4:4 profile */
+    OMX_VIDEO_AVCProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_AVCProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_AVCProfileMax      = 0x7FFFFFFF  
+} OMX_VIDEO_AVCPROFILETYPE;
+
+
+/** 
+ * AVC level types, each level indicates support for various frame sizes, 
+ * bit rates, decoder frame rates.  No need 
+ */
+typedef enum OMX_VIDEO_AVCLEVELTYPE {
+    OMX_VIDEO_AVCLevel1   = 0x01,     /**< Level 1 */
+    OMX_VIDEO_AVCLevel1b  = 0x02,     /**< Level 1b */
+    OMX_VIDEO_AVCLevel11  = 0x04,     /**< Level 1.1 */
+    OMX_VIDEO_AVCLevel12  = 0x08,     /**< Level 1.2 */
+    OMX_VIDEO_AVCLevel13  = 0x10,     /**< Level 1.3 */
+    OMX_VIDEO_AVCLevel2   = 0x20,     /**< Level 2 */
+    OMX_VIDEO_AVCLevel21  = 0x40,     /**< Level 2.1 */
+    OMX_VIDEO_AVCLevel22  = 0x80,     /**< Level 2.2 */
+    OMX_VIDEO_AVCLevel3   = 0x100,    /**< Level 3 */
+    OMX_VIDEO_AVCLevel31  = 0x200,    /**< Level 3.1 */
+    OMX_VIDEO_AVCLevel32  = 0x400,    /**< Level 3.2 */
+    OMX_VIDEO_AVCLevel4   = 0x800,    /**< Level 4 */
+    OMX_VIDEO_AVCLevel41  = 0x1000,   /**< Level 4.1 */
+    OMX_VIDEO_AVCLevel42  = 0x2000,   /**< Level 4.2 */
+    OMX_VIDEO_AVCLevel5   = 0x4000,   /**< Level 5 */
+    OMX_VIDEO_AVCLevel51  = 0x8000,   /**< Level 5.1 */
+    OMX_VIDEO_AVCLevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_AVCLevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_AVCLevelMax = 0x7FFFFFFF  
+} OMX_VIDEO_AVCLEVELTYPE;
+
+
+/** 
+ * AVC loop filter modes 
+ *
+ * OMX_VIDEO_AVCLoopFilterEnable               : Enable
+ * OMX_VIDEO_AVCLoopFilterDisable              : Disable
+ * OMX_VIDEO_AVCLoopFilterDisableSliceBoundary : Disabled on slice boundaries
+ */
+typedef enum OMX_VIDEO_AVCLOOPFILTERTYPE {
+    OMX_VIDEO_AVCLoopFilterEnable = 0,
+    OMX_VIDEO_AVCLoopFilterDisable,
+    OMX_VIDEO_AVCLoopFilterDisableSliceBoundary,
+    OMX_VIDEO_AVCLoopFilterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_AVCLoopFilterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_AVCLoopFilterMax = 0x7FFFFFFF
+} OMX_VIDEO_AVCLOOPFILTERTYPE;
+
+
+/** 
+ * AVC params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize                     : Size of the structure in bytes
+ *  nVersion                  : OMX specification version information
+ *  nPortIndex                : Port that this structure applies to
+ *  nSliceHeaderSpacing       : Number of macroblocks between slice header, put  
+ *                              zero if not used
+ *  nPFrames                  : Number of P frames between each I frame
+ *  nBFrames                  : Number of B frames between each I frame
+ *  bUseHadamard              : Enable/disable Hadamard transform
+ *  nRefFrames                : Max number of reference frames to use for inter
+ *                              motion search (1-16)
+ *  nRefIdxTrailing           : Pic param set ref frame index (index into ref
+ *                              frame buffer of trailing frames list), B frame
+ *                              support
+ *  nRefIdxForward            : Pic param set ref frame index (index into ref
+ *                              frame buffer of forward frames list), B frame
+ *                              support
+ *  bEnableUEP                : Enable/disable unequal error protection. This 
+ *                              is only valid of data partitioning is enabled.
+ *  bEnableFMO                : Enable/disable flexible macroblock ordering
+ *  bEnableASO                : Enable/disable arbitrary slice ordering
+ *  bEnableRS                 : Enable/disable sending of redundant slices
+ *  eProfile                  : AVC profile(s) to use
+ *  eLevel                    : AVC level(s) to use
+ *  nAllowedPictureTypes      : Specifies the picture types allowed in the 
+ *                              bitstream
+ *  bFrameMBsOnly             : specifies that every coded picture of the 
+ *                              coded video sequence is a coded frame 
+ *                              containing only frame macroblocks
+ *  bMBAFF                    : Enable/disable switching between frame and 
+ *                              field macroblocks within a picture
+ *  bEntropyCodingCABAC       : Entropy decoding method to be applied for the 
+ *                              syntax elements for which two descriptors appear 
+ *                              in the syntax tables
+ *  bWeightedPPrediction      : Enable/disable weighted prediction shall not 
+ *                              be applied to P and SP slices
+ *  nWeightedBipredicitonMode : Default weighted prediction is applied to B 
+ *                              slices 
+ *  bconstIpred               : Enable/disable intra prediction
+ *  bDirect8x8Inference       : Specifies the method used in the derivation 
+ *                              process for luma motion vectors for B_Skip, 
+ *                              B_Direct_16x16 and B_Direct_8x8 as specified 
+ *                              in subclause 8.4.1.2 of the AVC spec 
+ *  bDirectSpatialTemporal    : Flag indicating spatial or temporal direct
+ *                              mode used in B slice coding (related to 
+ *                              bDirect8x8Inference) . Spatial direct mode is 
+ *                              more common and should be the default.
+ *  nCabacInitIdx             : Index used to init CABAC contexts
+ *  eLoopFilterMode           : Enable/disable loop filter
+ */
+typedef struct OMX_VIDEO_PARAM_AVCTYPE {
+    OMX_U32 nSize;                 
+    OMX_VERSIONTYPE nVersion;      
+    OMX_U32 nPortIndex;            
+    OMX_U32 nSliceHeaderSpacing;  
+    OMX_U32 nPFrames;     
+    OMX_U32 nBFrames;     
+    OMX_BOOL bUseHadamard;
+    OMX_U32 nRefFrames;  
+	OMX_U32 nRefIdx10ActiveMinus1;
+	OMX_U32 nRefIdx11ActiveMinus1;
+    OMX_BOOL bEnableUEP;  
+    OMX_BOOL bEnableFMO;  
+    OMX_BOOL bEnableASO;  
+    OMX_BOOL bEnableRS;   
+    OMX_VIDEO_AVCPROFILETYPE eProfile;
+	OMX_VIDEO_AVCLEVELTYPE eLevel; 
+    OMX_U32 nAllowedPictureTypes;  
+	OMX_BOOL bFrameMBsOnly;        									
+    OMX_BOOL bMBAFF;               
+    OMX_BOOL bEntropyCodingCABAC;  
+    OMX_BOOL bWeightedPPrediction; 
+    OMX_U32 nWeightedBipredicitonMode; 
+    OMX_BOOL bconstIpred ;
+    OMX_BOOL bDirect8x8Inference;  
+	OMX_BOOL bDirectSpatialTemporal;
+	OMX_U32 nCabacInitIdc;
+	OMX_VIDEO_AVCLOOPFILTERTYPE eLoopFilterMode;
+} OMX_VIDEO_PARAM_AVCTYPE;
+
+typedef struct OMX_VIDEO_PARAM_PROFILELEVELTYPE {
+   OMX_U32 nSize;                 
+   OMX_VERSIONTYPE nVersion;      
+   OMX_U32 nPortIndex;            
+   OMX_U32 eProfile;      /**< type is OMX_VIDEO_AVCPROFILETYPE, OMX_VIDEO_H263PROFILETYPE, 
+                                 or OMX_VIDEO_MPEG4PROFILETYPE depending on context */
+   OMX_U32 eLevel;        /**< type is OMX_VIDEO_AVCLEVELTYPE, OMX_VIDEO_H263LEVELTYPE, 
+                                 or OMX_VIDEO_MPEG4PROFILETYPE depending on context */
+   OMX_U32 nProfileIndex; /**< Used to query for individual profile support information,
+                               This parameter is valid only for 
+                               OMX_IndexParamVideoProfileLevelQuerySupported index,
+                               For all other indices this parameter is to be ignored. */
+} OMX_VIDEO_PARAM_PROFILELEVELTYPE;
+
+/** 
+ * Structure for dynamically configuring bitrate mode of a codec. 
+ *
+ * STRUCT MEMBERS:
+ *  nSize          : Size of the struct in bytes
+ *  nVersion       : OMX spec version info
+ *  nPortIndex     : Port that this struct applies to
+ *  nEncodeBitrate : Target average bitrate to be generated in bps
+ */
+typedef struct OMX_VIDEO_CONFIG_BITRATETYPE {
+    OMX_U32 nSize;                          
+    OMX_VERSIONTYPE nVersion;               
+    OMX_U32 nPortIndex;                     
+    OMX_U32 nEncodeBitrate;                 
+} OMX_VIDEO_CONFIG_BITRATETYPE;
+
+/** 
+ * Defines Encoder Frame Rate setting
+ *
+ * STRUCT MEMBERS:
+ *  nSize            : Size of the structure in bytes
+ *  nVersion         : OMX specification version information 
+ *  nPortIndex       : Port that this structure applies to
+ *  xEncodeFramerate : Encoding framerate represented in Q16 format
+ */
+typedef struct OMX_CONFIG_FRAMERATETYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 xEncodeFramerate; /* Q16 format */
+} OMX_CONFIG_FRAMERATETYPE;
+
+typedef struct OMX_CONFIG_INTRAREFRESHVOPTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL IntraRefreshVOP;
+} OMX_CONFIG_INTRAREFRESHVOPTYPE;
+
+typedef struct OMX_CONFIG_MACROBLOCKERRORMAPTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nErrMapSize;           /* Size of the Error Map in bytes */
+    OMX_U8  ErrMap[1];             /* Error map hint */
+} OMX_CONFIG_MACROBLOCKERRORMAPTYPE;
+
+typedef struct OMX_CONFIG_MBERRORREPORTINGTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_BOOL bEnabled;
+} OMX_CONFIG_MBERRORREPORTINGTYPE;
+
+typedef struct OMX_PARAM_MACROBLOCKSTYPE {
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nMacroblocks;
+} OMX_PARAM_MACROBLOCKSTYPE;
+
+/** 
+ * AVC Slice Mode modes 
+ *
+ * OMX_VIDEO_SLICEMODE_AVCDefault   : Normal frame encoding, one slice per frame
+ * OMX_VIDEO_SLICEMODE_AVCMBSlice   : NAL mode, number of MBs per frame
+ * OMX_VIDEO_SLICEMODE_AVCByteSlice : NAL mode, number of bytes per frame
+ */
+typedef enum OMX_VIDEO_AVCSLICEMODETYPE {
+    OMX_VIDEO_SLICEMODE_AVCDefault = 0,
+    OMX_VIDEO_SLICEMODE_AVCMBSlice,
+    OMX_VIDEO_SLICEMODE_AVCByteSlice,
+    OMX_VIDEO_SLICEMODE_AVCKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
+    OMX_VIDEO_SLICEMODE_AVCVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
+    OMX_VIDEO_SLICEMODE_AVCLevelMax = 0x7FFFFFFF
+} OMX_VIDEO_AVCSLICEMODETYPE;
+
+/** 
+ * AVC FMO Slice Mode Params 
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nNumSliceGroups : Specifies the number of slice groups
+ *  nSliceGroupMapType : Specifies the type of slice groups
+ *  eSliceMode : Specifies the type of slice
+ */
+typedef struct OMX_VIDEO_PARAM_AVCSLICEFMO {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U8 nNumSliceGroups;
+    OMX_U8 nSliceGroupMapType;
+    OMX_VIDEO_AVCSLICEMODETYPE eSliceMode;
+} OMX_VIDEO_PARAM_AVCSLICEFMO;
+
+/** 
+ * AVC IDR Period Configs
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nIDRPeriod : Specifies periodicity of IDR frames
+ *  nPFrames : Specifies internal of coding Intra frames
+ */
+typedef struct OMX_VIDEO_CONFIG_AVCINTRAPERIOD {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nIDRPeriod;
+    OMX_U32 nPFrames;
+} OMX_VIDEO_CONFIG_AVCINTRAPERIOD;
+
+/** 
+ * AVC NAL Size Configs
+ *
+ * STRUCT MEMBERS:
+ *  nSize      : Size of the structure in bytes
+ *  nVersion   : OMX specification version information
+ *  nPortIndex : Port that this structure applies to
+ *  nNaluBytes : Specifies the NAL unit size
+ */
+typedef struct OMX_VIDEO_CONFIG_NALSIZE {
+    OMX_U32 nSize; 
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_U32 nNaluBytes;
+} OMX_VIDEO_CONFIG_NALSIZE;
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+/* File EOF */
+
diff --git a/domx/omx_core/inc/OMX_VideoExt.h b/domx/omx_core/inc/OMX_VideoExt.h
new file mode 100755
index 0000000..416ea53
--- /dev/null
+++ b/domx/omx_core/inc/OMX_VideoExt.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2010 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/** OMX_VideoExt.h - OpenMax IL version 1.1.2
+ * The OMX_VideoExt header file contains extensions to the
+ * definitions used by both the application and the component to
+ * access video items.
+ */
+
+#ifndef OMX_VideoExt_h
+#define OMX_VideoExt_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Each OMX header shall include all required header files to allow the
+ * header to compile without errors.  The includes below are required
+ * for this header file to compile successfully
+ */
+#include <OMX_Core.h>
+
+/** NALU Formats */
+typedef enum OMX_NALUFORMATSTYPE {
+    OMX_NaluFormatStartCodes = 1,
+    OMX_NaluFormatOneNaluPerBuffer = 2,
+    OMX_NaluFormatOneByteInterleaveLength = 4,
+    OMX_NaluFormatTwoByteInterleaveLength = 8,
+    OMX_NaluFormatFourByteInterleaveLength = 16,
+    OMX_NaluFormatCodingMax = 0x7FFFFFFF
+} OMX_NALUFORMATSTYPE;
+
+
+/** NAL Stream Format */
+typedef struct OMX_NALSTREAMFORMATTYPE{
+    OMX_U32 nSize;
+    OMX_VERSIONTYPE nVersion;
+    OMX_U32 nPortIndex;
+    OMX_NALUFORMATSTYPE eNaluFormat;
+} OMX_NALSTREAMFORMATTYPE;
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* OMX_VideoExt_h */
+/* File EOF */
diff --git a/domx/omx_core/src/OMX_Core.c b/domx/omx_core/src/OMX_Core.c
new file mode 100755
index 0000000..9022415
--- /dev/null
+++ b/domx/omx_core/src/OMX_Core.c
@@ -0,0 +1,894 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <dlfcn.h>		/* For dynamic loading */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+
+/* #include "OMX_RegLib.h" */
+#include "OMX_Component.h"
+#include "OMX_Core.h"
+#include "OMX_ComponentRegistry.h"
+
+#include "timm_osal_types.h"
+#include "timm_osal_error.h"
+#include "timm_osal_trace.h"
+#include "timm_osal_mutex.h"
+
+/** size for the array of allocated components.  Sets the maximum
+ * number of components that can be allocated at once */
+#define MAXCOMP (50)
+#define MAXNAMESIZE (128)
+#define EMPTY_STRING "\0"
+
+/** Determine the number of elements in an array */
+#define COUNTOF(x) (sizeof(x)/sizeof(x[0]))
+
+/** Array to hold the DLL pointers for each allocated component */
+static void *pModules[MAXCOMP] = { 0 };
+
+/** Array to hold the component handles for each allocated component */
+static void *pComponents[COUNTOF(pModules)] = { 0 };
+
+/* count for call OMX_Init() */
+int count = 0;
+pthread_mutex_t mutex;
+TIMM_OSAL_PTR pCoreInitMutex = NULL;
+
+int tableCount = 0;
+ComponentTable componentTable[MAX_TABLE_SIZE];
+char *sRoleArray[60][20];
+char compName[60][200];
+
+
+char *tComponentName[MAXCOMP][MAX_ROLES] = {
+    /*video and image components */
+    {"OMX.TI.DUCATI1.VIDEO.DECODER", "video_decoder.mpeg4",
+        "video_decoder.avc",
+        "video_decoder.h263",
+        "video_decoder.wmv",
+        "video_decoder.vp6",
+        "video_decoder.vp7", NULL},
+    {"OMX.TI.DUCATI1.VIDEO.H264D",  "video_decoder.avc", NULL},
+    {"OMX.TI.DUCATI1.VIDEO.H264E",  "video_encoder.avc", NULL},
+    {"OMX.TI.DUCATI1.VIDEO.MPEG4D", "video_decoder.mpeg4", NULL},
+    {"OMX.TI.DUCATI1.VIDEO.MPEG4E", "video_encoder.mpeg4",
+                                    "video_encoder.h263",NULL},
+    {"OMX.TI.DUCATI1.VIDEO.VP6D",   "video_decoder.vp6", NULL},
+    {"OMX.TI.DUCATI1.VIDEO.VP7D",   "video_decoder.vp7", NULL},
+    {"OMX.TI.DUCATI1.IMAGE.JPEGD",  "jpeg_decoder.jpeg", NULL},
+    {"OMX.TI.DUCATI1.VIDEO.CAMERA",  "camera.omx", NULL},
+    /* terminate the table */
+    {NULL, NULL},
+};
+
+//AD
+extern OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent);
+
+
+#define CORE_assert  CORE_paramCheck
+#define CORE_require CORE_paramCheck
+#define CORE_ensure  CORE_paramCheck
+
+#define CORE_paramCheck(C, V, S) do {\
+    if (!(C)) { eError = V;\
+    TIMM_OSAL_Error("failed check: " #C);\
+    TIMM_OSAL_Error(" - returning error: " #V);\
+    if(S) TIMM_OSAL_Error(" - %s", S);\
+    goto EXIT; }\
+    } while(0)
+
+
+/******************************Public*Routine******************************\
+* OMX_Init()
+*
+* Description:This method will initialize the OMX Core.  It is the
+* responsibility of the application to call OMX_Init to ensure the proper
+* set up of core resources.
+*
+* Returns:    OMX_NOERROR          Successful
+*
+* Note
+*
+\**************************************************************************/
+OMX_ERRORTYPE OMX_Init()
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eOsalError = TIMM_OSAL_ERR_NONE;
+
+	eOsalError = TIMM_OSAL_MutexObtain(pCoreInitMutex, TIMM_OSAL_SUSPEND);
+	CORE_assert(eOsalError == TIMM_OSAL_ERR_NONE,
+	    OMX_ErrorInsufficientResources, "Mutex lock failed");
+
+	count++;
+
+	if (count == 1)
+	{
+		pthread_mutex_init(&mutex, NULL);
+		eError = OMX_BuildComponentTable();
+	}
+
+	eOsalError = TIMM_OSAL_MutexRelease(pCoreInitMutex);
+	CORE_assert(eOsalError == TIMM_OSAL_ERR_NONE,
+	    OMX_ErrorInsufficientResources, "Mutex release failed");
+      EXIT:
+	return eError;
+}
+
+/******************************Public*Routine******************************\
+* OMX_GetHandle
+*
+* Description: This method will create the handle of the COMPONENTTYPE
+* If the component is currently loaded, this method will reutrn the
+* hadle of existingcomponent or create a new instance of the component.
+* It will call the OMX_ComponentInit function and then the setcallback
+* method to initialize the callback functions
+* Parameters:
+* @param[out] pHandle            Handle of the loaded components
+* @param[in] cComponentName     Name of the component to load
+* @param[in] pAppData           Used to identify the callbacks of component
+* @param[in] pCallBacks         Application callbacks
+*
+* @retval OMX_ErrorUndefined
+* @retval OMX_ErrorInvalidComponentName
+* @retval OMX_ErrorInvalidComponent
+* @retval OMX_ErrorInsufficientResources
+* @retval OMX_NOERROR                      Successful
+*
+* Note
+*
+\**************************************************************************/
+
+OMX_ERRORTYPE OMX_GetHandle(OMX_HANDLETYPE * pHandle,
+    OMX_STRING cComponentName, OMX_PTR pAppData,
+    OMX_CALLBACKTYPE * pCallBacks)
+{
+	static const char prefix[] = "lib";
+	static const char postfix[] = ".so";
+	OMX_ERRORTYPE(*pComponentInit) (OMX_HANDLETYPE *);
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_COMPONENTTYPE *componentType;
+	int i;
+	char buf[sizeof(prefix) + MAXNAMESIZE + sizeof(postfix)];
+	const char *pErr = dlerror();
+	char *dlError = NULL;
+	if (pthread_mutex_lock(&mutex) != 0)
+	{
+		TIMM_OSAL_Error("Core: Error in Mutex lock");
+	}
+
+	CORE_require(NULL != cComponentName, OMX_ErrorBadParameter, NULL);
+	CORE_require(NULL != pHandle, OMX_ErrorBadParameter, NULL);
+	CORE_require(NULL != pCallBacks, OMX_ErrorBadParameter, NULL);
+	CORE_require(count > 0, OMX_ErrorUndefined,
+	    "OMX_GetHandle called without calling OMX_Init first");
+
+	/* Verify that the name is not too long and could cause a crash.  Notice
+	 * that the comparison is a greater than or equals.  This is to make
+	 * sure that there is room for the terminating NULL at the end of the
+	 * name. */
+	CORE_require(strlen(cComponentName) < MAXNAMESIZE,
+	    OMX_ErrorInvalidComponentName, NULL);
+
+	/* Locate the first empty slot for a component.  If no slots
+	 * are available, error out */
+	for (i = 0; i < COUNTOF(pModules); i++)
+	{
+		if (pModules[i] == NULL)
+			break;
+	}
+	CORE_assert(i != COUNTOF(pModules), OMX_ErrorInsufficientResources,
+	    NULL);
+
+	/* load the component and check for an error.  If filename is not an
+	 * absolute path (i.e., it does not  begin with a "/"), then the
+	 * file is searched for in the following locations:
+	 *
+	 *     The LD_LIBRARY_PATH environment variable locations
+	 *     The library cache, /etc/ld.so.cache.
+	 *     /lib
+	 *     /usr/lib
+	 *
+	 * If there is an error, we can't go on, so set the error code and exit */
+	strcpy(buf, prefix);	/* the lengths are defined herein or have been */
+	strcat(buf, cComponentName);	/* checked already, so strcpy and strcat are  */
+	strcat(buf, postfix);	/* are safe to use in this context. */
+//#if 0
+	pModules[i] = dlopen(buf, RTLD_LAZY | RTLD_GLOBAL);
+	if (pModules[i] == NULL)
+	{
+		dlError = dlerror();
+		TIMM_OSAL_Error("Failed because %s", dlError);
+		eError = OMX_ErrorComponentNotFound;
+		goto EXIT;
+	}
+
+	/* Get a function pointer to the "OMX_ComponentInit" function.  If
+	 * there is an error, we can't go on, so set the error code and exit */
+	pComponentInit = dlsym(pModules[i], "OMX_ComponentInit");
+	pErr = dlerror();
+	CORE_assert(((pErr == NULL) && (pComponentInit != NULL)),
+	    OMX_ErrorInvalidComponent, NULL);
+//#endif
+
+	/* We now can access the dll.  So, we need to call the "OMX_ComponentInit"
+	 * method to load up the "handle" (which is just a list of functions to
+	 * call) and we should be all set.*/
+	*pHandle = malloc(sizeof(OMX_COMPONENTTYPE));
+	CORE_assert((*pHandle != NULL), OMX_ErrorInsufficientResources,
+	    "Malloc of pHandle* failed");
+
+	pComponents[i] = *pHandle;
+	componentType = (OMX_COMPONENTTYPE *) * pHandle;
+	componentType->nSize = sizeof(OMX_COMPONENTTYPE);
+
+	componentType->nVersion.s.nVersionMajor = 1;
+	componentType->nVersion.s.nVersionMinor = 1;
+	componentType->nVersion.s.nRevision = 0;
+	componentType->nVersion.s.nStep = 0;
+
+	eError = (*pComponentInit) (*pHandle);
+//eError = OMX_ComponentInit(*pHandle);
+	if (OMX_ErrorNone == eError)
+	{
+		eError =
+		    (componentType->SetCallbacks) (*pHandle, pCallBacks,
+		    pAppData);
+		CORE_assert(eError == OMX_ErrorNone, eError,
+		    "Core: Error returned from component SetCallBack");
+	} else
+	{
+		/* when the component fails to initialize, release the
+		   component handle structure */
+		free(*pHandle);
+		/* mark the component handle as NULL to prevent the caller from
+		   actually trying to access the component with it, should they
+		   ignore the return code */
+		*pHandle = NULL;
+		pComponents[i] = NULL;
+		dlclose(pModules[i]);
+		goto EXIT;
+	}
+	eError = OMX_ErrorNone;
+      EXIT:
+	if (pthread_mutex_unlock(&mutex) != 0)
+	{
+		TIMM_OSAL_Error("Core: Error in Mutex unlock");
+	}
+	return (eError);
+}
+
+
+/******************************Public*Routine******************************\
+* OMX_FreeHandle()
+*
+* Description:This method will unload the OMX component pointed by
+* OMX_HANDLETYPE. It is the responsibility of the calling method to ensure that
+* the Deinit method of the component has been called prior to unloading component
+*
+* Parameters:
+* @param[in] hComponent the component to unload
+*
+* Returns:    OMX_NOERROR          Successful
+*
+* Note
+*
+\**************************************************************************/
+OMX_ERRORTYPE OMX_FreeHandle(OMX_HANDLETYPE hComponent)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorUndefined;
+	OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *) hComponent;
+	int i;
+
+	if (pthread_mutex_lock(&mutex) != 0)
+	{
+		TIMM_OSAL_Error("Core: Error in Mutex lock");
+	}
+
+	CORE_require(pHandle != NULL, OMX_ErrorBadParameter, NULL);
+	CORE_require(count > 0, OMX_ErrorUndefined,
+	    "OMX_FreeHandle called without calling OMX_Init first");
+
+	/* Locate the component handle in the array of handles */
+	for (i = 0; i < COUNTOF(pModules); i++)
+	{
+		if (pComponents[i] == hComponent)
+			break;
+	}
+
+	CORE_assert(i != COUNTOF(pModules), OMX_ErrorBadParameter, NULL);
+
+	eError = pHandle->ComponentDeInit(hComponent);
+	if (eError != OMX_ErrorNone)
+	{
+		TIMM_OSAL_Error("Error From ComponentDeInit..");
+	}
+
+	/* release the component and the component handle */
+	dlclose(pModules[i]);
+	pModules[i] = NULL;
+	free(pComponents[i]);
+
+	pComponents[i] = NULL;
+	eError = OMX_ErrorNone;
+
+      EXIT:
+	/* The unload is now complete, so set the error code to pass and exit */
+	if (pthread_mutex_unlock(&mutex) != 0)
+	{
+		TIMM_OSAL_Error("Core: Error in Mutex unlock");
+	}
+
+	return eError;
+}
+
+/******************************Public*Routine******************************\
+* OMX_DeInit()
+*
+* Description:This method will release the resources of the OMX Core.  It is the
+* responsibility of the application to call OMX_DeInit to ensure the clean up of these
+* resources.
+*
+* Returns:    OMX_NOERROR          Successful
+*
+* Note
+*
+\**************************************************************************/
+OMX_ERRORTYPE OMX_Deinit()
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eOsalError = TIMM_OSAL_ERR_NONE;
+
+	eOsalError = TIMM_OSAL_MutexObtain(pCoreInitMutex, TIMM_OSAL_SUSPEND);
+	if (eOsalError != TIMM_OSAL_ERR_NONE)
+	{
+		TIMM_OSAL_Error("Mutex lock failed");
+	}
+	/*Returning error none because of OMX spec limitation on error codes that
+	   can be returned by OMX_Deinit */
+	CORE_assert(count > 0, OMX_ErrorNone,
+	    "OMX_Deinit being called without a corresponding OMX_Init");
+	count--;
+
+	if (pthread_mutex_lock(&mutex) != 0)
+		TIMM_OSAL_Error("Core: Error in Mutex lock");
+
+	if (count == 0)
+	{
+		if (pthread_mutex_unlock(&mutex) != 0)
+			TIMM_OSAL_Error("Core: Error in Mutex unlock");
+		if (pthread_mutex_destroy(&mutex) != 0)
+		{
+			/*printf("%d :: Core: Error in Mutex destroy\n",__LINE__); */
+		}
+	} else
+	{
+		if (pthread_mutex_unlock(&mutex) != 0)
+			TIMM_OSAL_Error("Core: Error in Mutex unlock");
+	}
+
+      EXIT:
+	eOsalError = TIMM_OSAL_MutexRelease(pCoreInitMutex);
+	if (eOsalError != TIMM_OSAL_ERR_NONE)
+	{
+		TIMM_OSAL_Error("Mutex release failed");
+	}
+	return eError;
+}
+
+/*************************************************************************
+* OMX_SetupTunnel()
+*
+* Description: Setup the specified tunnel the two components
+*
+* Parameters:
+* @param[in] hOutput     Handle of the component to be accessed
+* @param[in] nPortOutput Source port used in the tunnel
+* @param[in] hInput      Component to setup the tunnel with.
+* @param[in] nPortInput  Destination port used in the tunnel
+*
+* Returns:    OMX_NOERROR          Successful
+*
+* Note
+*
+**************************************************************************/
+/* OMX_SetupTunnel */
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_SetupTunnel(OMX_IN OMX_HANDLETYPE
+    hOutput, OMX_IN OMX_U32 nPortOutput, OMX_IN OMX_HANDLETYPE hInput,
+    OMX_IN OMX_U32 nPortInput)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNotImplemented;
+	OMX_COMPONENTTYPE *pCompIn, *pCompOut;
+	OMX_TUNNELSETUPTYPE oTunnelSetup;
+
+	if (hOutput == NULL && hInput == NULL)
+		return OMX_ErrorBadParameter;
+
+	oTunnelSetup.nTunnelFlags = 0;
+	oTunnelSetup.eSupplier = OMX_BufferSupplyUnspecified;
+
+	pCompOut = (OMX_COMPONENTTYPE *) hOutput;
+
+	if (hOutput)
+	{
+		eError =
+		    pCompOut->ComponentTunnelRequest(hOutput, nPortOutput,
+		    hInput, nPortInput, &oTunnelSetup);
+	}
+
+
+	if (eError == OMX_ErrorNone && hInput)
+	{
+		pCompIn = (OMX_COMPONENTTYPE *) hInput;
+		eError =
+		    pCompIn->ComponentTunnelRequest(hInput, nPortInput,
+		    hOutput, nPortOutput, &oTunnelSetup);
+		if (eError != OMX_ErrorNone && hOutput)
+		{
+			/* cancel tunnel request on output port since input port failed */
+			pCompOut->ComponentTunnelRequest(hOutput, nPortOutput,
+			    NULL, 0, NULL);
+		}
+	}
+
+	return eError;
+}
+
+/*************************************************************************
+* OMX_ComponentNameEnum()
+*
+* Description: This method will provide the name of the component at the given nIndex
+*
+*Parameters:
+* @param[out] cComponentName       The name of the component at nIndex
+* @param[in] nNameLength                The length of the component name
+* @param[in] nIndex                         The index number of the component
+*
+* Returns:    OMX_NOERROR          Successful
+*
+* Note
+*
+**************************************************************************/
+OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_ComponentNameEnum(OMX_OUT OMX_STRING
+    cComponentName, OMX_IN OMX_U32 nNameLength, OMX_IN OMX_U32 nIndex)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+	CORE_require(cComponentName != NULL, OMX_ErrorBadParameter, NULL);
+	CORE_require(count > 0, OMX_ErrorUndefined,
+	    "OMX_GetHandle called without calling OMX_Init first");
+
+	if (nIndex >= tableCount)
+	{
+		eError = OMX_ErrorNoMore;
+	} else
+	{
+		strcpy(cComponentName, componentTable[nIndex].name);
+	}
+      EXIT:
+	return eError;
+}
+
+
+/*************************************************************************
+* OMX_GetRolesOfComponent()
+*
+* Description: This method will query the component for its supported roles
+*
+*Parameters:
+* @param[in] cComponentName     The name of the component to query
+* @param[in] pNumRoles     The number of roles supported by the component
+* @param[in] roles		The roles of the component
+*
+* Returns:    OMX_NOERROR          Successful
+*                 OMX_ErrorBadParameter		Faliure due to a bad input parameter
+*
+* Note
+*
+**************************************************************************/
+OMX_API OMX_ERRORTYPE OMX_GetRolesOfComponent(OMX_IN OMX_STRING
+    cComponentName, OMX_INOUT OMX_U32 * pNumRoles, OMX_OUT OMX_U8 ** roles)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_U32 i = 0;
+	OMX_U32 j = 0;
+	OMX_BOOL bFound = OMX_FALSE;
+
+	CORE_require(cComponentName != NULL, OMX_ErrorBadParameter, NULL);
+	CORE_require(pNumRoles != NULL, OMX_ErrorBadParameter, NULL);
+	CORE_require(strlen(cComponentName) < MAXNAMESIZE,
+	    OMX_ErrorInvalidComponentName, NULL);
+	CORE_require(count > 0, OMX_ErrorUndefined,
+	    "OMX_GetHandle called without calling OMX_Init first");
+
+	while (!bFound && i < tableCount)
+	{
+		if (strcmp(cComponentName, componentTable[i].name) == 0)
+		{
+			bFound = OMX_TRUE;
+		} else
+		{
+			i++;
+		}
+	}
+	if (roles == NULL)
+	{
+		*pNumRoles = componentTable[i].nRoles;
+		goto EXIT;
+	} else
+	{
+		if (bFound && (*pNumRoles == componentTable[i].nRoles))
+		{
+			for (j = 0; j < componentTable[i].nRoles; j++)
+			{
+				strcpy((OMX_STRING) roles[j],
+				    componentTable[i].pRoleArray[j]);
+			}
+		}
+	}
+      EXIT:
+	return eError;
+}
+
+/*************************************************************************
+* OMX_GetComponentsOfRole()
+*
+* Description: This method will query the component for its supported roles
+*
+*Parameters:
+* @param[in] role     The role name to query for
+* @param[in] pNumComps     The number of components supporting the given role
+* @param[in] compNames      The names of the components supporting the given role
+*
+* Returns:    OMX_NOERROR          Successful
+*
+* Note
+*
+**************************************************************************/
+OMX_API OMX_ERRORTYPE OMX_GetComponentsOfRole(OMX_IN OMX_STRING role,
+    OMX_INOUT OMX_U32 * pNumComps, OMX_INOUT OMX_U8 ** compNames)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_U32 i = 0;
+	OMX_U32 j = 0;
+	OMX_U32 k = 0;
+
+	CORE_require(role != NULL, OMX_ErrorBadParameter, NULL);
+	CORE_require(pNumComps != NULL, OMX_ErrorBadParameter, NULL);
+	CORE_require(count > 0, OMX_ErrorUndefined,
+	    "OMX_GetHandle called without calling OMX_Init first");
+
+	/* This implies that the componentTable is not filled */
+	CORE_assert(componentTable[i].pRoleArray[j] != NULL,
+	    OMX_ErrorBadParameter, NULL);
+
+	for (i = 0; i < tableCount; i++)
+	{
+		for (j = 0; j < componentTable[i].nRoles; j++)
+		{
+			if (strcmp(componentTable[i].pRoleArray[j],
+				role) == 0)
+			{
+				/* the first call to this function should only count the number
+				   of roles so that for the second call compNames can be allocated
+				   with the proper size for that number of roles */
+				if (compNames != NULL)
+				{
+					strncpy((OMX_STRING) (compNames[k]),
+					    (OMX_STRING) componentTable[i].
+					    name, MAXNAMESIZE);
+				}
+				k++;
+			}
+		}
+		*pNumComps = k;
+	}
+
+      EXIT:
+	return eError;
+}
+
+
+/***************************************
+PRINT TABLE FOR DEBUGGING PURPOSES ONLY
+***************************************/
+
+OMX_API OMX_ERRORTYPE OMX_PrintComponentTable()
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	int i = 0;
+	int j = 0;
+
+	TIMM_OSAL_Info
+	    ("--------Component Table:: %d Components found-------------",
+	    tableCount);
+
+	for (i = 0; i < tableCount; i++)
+	{
+		TIMM_OSAL_Info("%i:: %s", i, componentTable[i].name);
+		for (j = 0; j < componentTable[i].nRoles; j++)
+		{
+			TIMM_OSAL_Info("        %s",
+			    componentTable[i].pRoleArray[j]);
+		}
+	}
+
+	TIMM_OSAL_Info
+	    ("-----------------End Component Table ------------------");
+
+	return eError;
+
+}
+
+
+OMX_ERRORTYPE OMX_BuildComponentTable()
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_CALLBACKTYPE sCallbacks;
+#ifndef STATIC_TABLE
+	OMX_HANDLETYPE hComp = 0;
+	OMX_U8 cRole[MAXNAMESIZE];
+	OMX_STRING tempName = NULL;
+	OMX_STRING temp = NULL;
+	static OMX_STRING namePrefix = "OMX";
+	static OMX_STRING filePrefix = "libOMX.";
+	static OMX_STRING suffix = ".so";
+#endif
+	int j = 0;
+	int numFiles = 0;
+	int i, k;
+	int componentfound = 0;
+
+	/* set up dummy call backs */
+	sCallbacks.EventHandler = ComponentTable_EventHandler;
+	sCallbacks.EmptyBufferDone = ComponentTable_EmptyBufferDone;
+	sCallbacks.FillBufferDone = ComponentTable_FillBufferDone;
+
+#ifndef STATIC_TABLE
+	/* allocate the name table */
+	/*
+	   compName = (OMX_STRING *) malloc(MAX_TABLE_SIZE * sizeof(OMX_STRING));
+	   sRoleArray = (OMX_STRING**) malloc(MAX_TABLE_SIZE * sizeof(OMX_STRING));
+	 */
+
+	/* scan the target/lib directory and create a list of files in the directory */
+	numFiles = scandir(libdir, &namelist, 0, 0);
+	tableCount = 0;
+	while (numFiles--)
+	{
+		/*  check if the file is an OMX component */
+		if (strncmp(namelist[numFiles]->d_name, filePrefix,
+			strlen(filePrefix)) == 0)
+		{
+
+			/* if the file is an OMX component, trim the prefix and suffix */
+			tempName = (OMX_STRING) malloc(sizeof(namelist[numFiles]->d_name) + 1);	/* adding one ensures */
+			memset(tempName, 0x00, sizeof(namelist[numFiles]->d_name) + 1);	/*  that a null terminator will */
+			/*  always be present */
+			/* copy only the name without the suffix */
+			strncpy(tempName, namelist[numFiles]->d_name,
+			    strlen(namelist[numFiles]->d_name) -
+			    strlen(suffix));
+			/* set a pointer to be after the lib prefix, i.e the beginning of the component name */
+			temp = strstr(tempName, namePrefix);
+
+			/* then copy the component name to the table */
+			/*
+			   compName[tableCount]= (OMX_STRING) malloc(MAXNAMESIZE);
+			 */
+			strncpy(compName[tableCount], temp, strlen(temp) + 1);
+			componentTable[tableCount].name =
+			    compName[tableCount];
+
+			/* get the handle for the component and query for the roles of each component */
+			eError =
+			    OMX_GetHandle(&hComp,
+			    componentTable[tableCount].name, 0x0,
+			    &sCallbacks);
+			if (eError == OMX_ErrorNone)
+			{
+				j = 0;
+				while (eError != OMX_ErrorNoMore)
+				{
+					eError =
+					    ((OMX_COMPONENTTYPE *) hComp)->
+					    ComponentRoleEnum(hComp, cRole,
+					    j++);
+					if (eError == OMX_ErrorNotImplemented)
+					{
+						j = 1;
+						break;
+					}
+				}
+				nRoles = j - 1;
+				componentTable[tableCount].nRoles = nRoles;
+				/* sRoleArray[tableCount] = (OMX_STRING *) malloc(nRoles * sizeof(OMX_STRING)); */
+				if (nRoles > 0)
+				{
+					/* sRoleArray[tableCount] = (OMX_STRING *) malloc(nRoles * sizeof(OMX_STRING)); */
+					for (j = 0; j < nRoles; j++)
+					{
+						sRoleArray[tableCount][j] =
+						    (OMX_STRING)
+						    malloc(sizeof(OMX_U8) *
+						    MAXNAMESIZE);
+						((OMX_COMPONENTTYPE *)
+						    hComp)->
+						    ComponentRoleEnum(hComp,
+						    (OMX_U8 *)
+						    sRoleArray[tableCount][j],
+						    j);
+						componentTable[tableCount].
+						    pRoleArray[j] =
+						    sRoleArray[tableCount][j];
+					}
+				} else
+				{
+					/* sRoleArray[tableCount] = (OMX_STRING *) malloc(sizeof(OMX_STRING));    */
+					sRoleArray[tableCount][j] =
+					    (OMX_STRING) malloc(sizeof(OMX_U8)
+					    * MAXNAMESIZE);
+					strcpy(sRoleArray[tableCount][j],
+					    EMPTY_STRING);
+					componentTable[tableCount].
+					    pRoleArray[j] =
+					    sRoleArray[tableCount][j];
+				}
+			}
+			if (hComp)
+			{
+				/* free the component handle */
+				eError = OMX_FreeHandle(hComp);
+				if (eError != OMX_ErrorNone)
+				{
+					goto EXIT;
+				}
+			}
+			/* increment the table counter index only if above was successful */
+			tableCount++;
+			if (tempName != NULL)
+			{
+				free(tempName);
+			}
+
+		}
+	}
+
+#endif
+
+	for (i = 0, numFiles = 0; i < MAXCOMP; i++)
+	{
+		if (tComponentName[i][0] == NULL)
+		{
+			break;
+		}
+
+		for (j = 0; j < numFiles; j++)
+		{
+			if (!strcmp(componentTable[j].name,
+				tComponentName[i][0]))
+			{
+				componentfound = 1;
+				break;
+			}
+		}
+		if (componentfound == 1)
+		{
+			continue;
+		}
+
+		if (j == numFiles)
+		{		/* new component */
+			k = 1;
+			while (tComponentName[i][k] != NULL)
+			{
+				componentTable[numFiles].pRoleArray[k - 1] =
+				    tComponentName[i][k];
+				k++;
+			}
+			componentTable[numFiles].nRoles = k - 1;
+			strcpy(compName[numFiles], tComponentName[i][0]);
+			componentTable[numFiles].name = compName[numFiles];
+			numFiles++;
+		}
+	}
+	tableCount = numFiles;
+
+	CORE_assert(eError == OMX_ErrorNone, eError,
+	    "Could not build Component Table");
+      EXIT:
+	return eError;
+}
+
+OMX_ERRORTYPE ComponentTable_EventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_PTR pAppData,
+    OMX_IN OMX_EVENTTYPE eEvent,
+    OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2, OMX_IN OMX_PTR pEventData)
+{
+	return OMX_ErrorNotImplemented;
+}
+
+OMX_ERRORTYPE ComponentTable_EmptyBufferDone(OMX_OUT OMX_HANDLETYPE
+    hComponent, OMX_OUT OMX_PTR pAppData,
+    OMX_OUT OMX_BUFFERHEADERTYPE * pBuffer)
+{
+	return OMX_ErrorNotImplemented;
+}
+
+OMX_ERRORTYPE ComponentTable_FillBufferDone(OMX_OUT OMX_HANDLETYPE hComponent,
+    OMX_OUT OMX_PTR pAppData, OMX_OUT OMX_BUFFERHEADERTYPE * pBuffer)
+{
+	return OMX_ErrorNotImplemented;
+}
+
+
+
+/*===============================================================*/
+/** @fn Core_Setup : This function is called when the the OMX Core library is
+ *                  loaded. It creates a mutex, which is used during OMX_Init()
+ */
+/*===============================================================*/
+void __attribute__ ((constructor)) Core_Setup(void)
+{
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+
+	eError = TIMM_OSAL_MutexCreate(&pCoreInitMutex);
+	if (eError != TIMM_OSAL_ERR_NONE)
+	{
+		TIMM_OSAL_Error("Creation of default mutex failed");
+	}
+}
+
+
+
+/*===============================================================*/
+/** @fn Core_Destroy : This function is called when the the OMX Core library is
+ *                    unloaded. It destroys the mutex which was created by
+ *                    Core_Setup().
+ *
+ */
+/*===============================================================*/
+void __attribute__ ((destructor)) Core_Destroy(void)
+{
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+
+	eError = TIMM_OSAL_MutexDelete(pCoreInitMutex);
+	if (eError != TIMM_OSAL_ERR_NONE)
+	{
+		TIMM_OSAL_Error("Destruction of default mutex failed");
+	}
+}
diff --git a/domx/omx_core/src/OMX_Core_Wrapper.c b/domx/omx_core/src/OMX_Core_Wrapper.c
new file mode 100755
index 0000000..d049ee0
--- /dev/null
+++ b/domx/omx_core/src/OMX_Core_Wrapper.c
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef _Android
+
+/* #include "OMX_RegLib.h" */
+#include "OMX_Component.h"
+#include "OMX_Core.h"
+#include "OMX_ComponentRegistry.h"
+
+#include "OMX_Core_Wrapper.h"
+#include <utils/Log.h>
+#undef LOG_TAG
+#define LOG_TAG "OMX_CORE"
+
+/** determine capabilities of a component before acually using it */
+#if 0
+#include "ti_omx_config_parser.h"
+#else
+extern OMX_BOOL TIOMXConfigParser(OMX_PTR aInputParameters,
+    OMX_PTR aOutputParameters);
+#endif
+
+#endif
+
+
+#ifdef _Android
+#ifdef _FROYO
+OMX_BOOL TIOMXConfigParserRedirect(OMX_PTR aInputParameters,
+    OMX_PTR aOutputParameters)
+{
+	LOGV("OMXConfigParserRedirect +\n");
+	OMX_BOOL Status = OMX_FALSE;
+
+	Status = TIOMXConfigParser(aInputParameters, aOutputParameters);
+
+	LOGV("OMXConfigParserRedirect -\n");
+	return Status;
+}
+#endif
+OMX_ERRORTYPE TIComponentTable_EventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_PTR pAppData,
+    OMX_IN OMX_EVENTTYPE eEvent,
+    OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2, OMX_IN OMX_PTR pEventData)
+{
+	return OMX_ErrorNotImplemented;
+}
+
+OMX_ERRORTYPE TIComponentTable_EmptyBufferDone(OMX_OUT OMX_HANDLETYPE
+    hComponent, OMX_OUT OMX_PTR pAppData,
+    OMX_OUT OMX_BUFFERHEADERTYPE * pBuffer)
+{
+	return OMX_ErrorNotImplemented;
+}
+
+OMX_ERRORTYPE TIComponentTable_FillBufferDone(OMX_OUT OMX_HANDLETYPE
+    hComponent, OMX_OUT OMX_PTR pAppData,
+    OMX_OUT OMX_BUFFERHEADERTYPE * pBuffer)
+{
+	return OMX_ErrorNotImplemented;
+}
+
+
+OMX_API OMX_ERRORTYPE TIOMX_Init(void)
+{
+	LOGV("TIOMX_Init\n");
+
+	return OMX_Init();
+}
+
+OMX_API OMX_ERRORTYPE TIOMX_Deinit(void)
+{
+	LOGV("TIOMX_Deinit\n");
+
+	return OMX_Deinit();
+}
+
+OMX_API OMX_ERRORTYPE TIOMX_ComponentNameEnum(OMX_OUT OMX_STRING
+    cComponentName, OMX_IN OMX_U32 nNameLength, OMX_IN OMX_U32 nIndex)
+{
+
+	LOGV("TIOMX_ComponentNameEnum\n");
+
+	return OMX_ComponentNameEnum(cComponentName, nNameLength, nIndex);
+}
+
+OMX_API OMX_ERRORTYPE TIOMX_GetHandle(OMX_OUT OMX_HANDLETYPE * pHandle,
+    OMX_IN OMX_STRING cComponentName,
+    OMX_IN OMX_PTR pAppData, OMX_IN OMX_CALLBACKTYPE * pCallBacks)
+{
+
+	LOGV("TIOMX_GetHandle\n");
+
+	return OMX_GetHandle(pHandle, cComponentName, pAppData, pCallBacks);
+}
+
+OMX_API OMX_ERRORTYPE TIOMX_FreeHandle(OMX_IN OMX_HANDLETYPE hComponent)
+{
+	LOGV("TIOMX_FreeHandle\n");
+
+	return OMX_FreeHandle(hComponent);
+}
+
+OMX_API OMX_ERRORTYPE TIOMX_GetComponentsOfRole(OMX_IN OMX_STRING role,
+    OMX_INOUT OMX_U32 * pNumComps, OMX_INOUT OMX_U8 ** compNames)
+{
+
+	LOGV("TIOMX_GetComponentsOfRole\n");
+
+	return OMX_GetComponentsOfRole(role, pNumComps, compNames);
+}
+
+OMX_API OMX_ERRORTYPE TIOMX_GetRolesOfComponent(OMX_IN OMX_STRING compName,
+    OMX_INOUT OMX_U32 * pNumRoles, OMX_OUT OMX_U8 ** roles)
+{
+
+	LOGV("TIOMX_GetRolesOfComponent\n");
+
+	return OMX_GetRolesOfComponent(compName, pNumRoles, roles);
+}
+
+OMX_API OMX_ERRORTYPE TIOMX_SetupTunnel(OMX_IN OMX_HANDLETYPE hOutput,
+    OMX_IN OMX_U32 nPortOutput,
+    OMX_IN OMX_HANDLETYPE hInput, OMX_IN OMX_U32 nPortInput)
+{
+
+	LOGV("TIOMX_SetupTunnel\n");
+
+	return OMX_SetupTunnel(hOutput, nPortOutput, hInput, nPortInput);
+}
+
+OMX_API OMX_ERRORTYPE TIOMX_GetContentPipe(OMX_OUT OMX_HANDLETYPE * hPipe,
+    OMX_IN OMX_STRING szURI)
+{
+
+	LOGV("TIOMX_GetContentPipe\n");
+
+	//return OMX_GetContentPipe(
+	//      hPipe,
+	//      szURI);
+	return 0;
+}
+#endif
diff --git a/domx/omx_proxy_component/Android.mk b/domx/omx_proxy_component/Android.mk
new file mode 100644
index 0000000..8a0d150
--- /dev/null
+++ b/domx/omx_proxy_component/Android.mk
@@ -0,0 +1,121 @@
+LOCAL_PATH:= $(call my-dir)
+
+#
+# libOMX.TI.DUCATI1.VIDEO.DECODER
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES += \
+	$(LOCAL_PATH)/../omx_core/inc \
+	$(LOCAL_PATH)/../mm_osal/inc \
+	$(LOCAL_PATH)/../domx \
+	$(LOCAL_PATH)/../domx/omx_rpc/inc \
+	$(HARDWARE_TI_OMAP4_BASE)/../../libhardware/include \
+	$(HARDWARE_TI_OMAP4_BASE)/hwc/
+
+LOCAL_SHARED_LIBRARIES := \
+	libmm_osal \
+	libc \
+	libOMX_Core \
+	liblog \
+	libdomx \
+	libhardware
+
+LOCAL_CFLAGS += -DLINUX -DTMS32060 -D_DB_TIOMAP -DSYSLINK_USE_SYSMGR -DSYSLINK_USE_LOADER
+LOCAL_CFLAGS += -D_Android -DSET_STRIDE_PADDING_FROM_PROXY -DANDROID_QUIRCK_CHANGE_PORT_VALUES -DUSE_ENHANCED_PORTRECONFIG -DANDROID_QUIRK_LOCK_BUFFER
+LOCAL_MODULE_TAGS:= optional
+
+LOCAL_SRC_FILES:= omx_video_dec/src/omx_proxy_videodec.c
+LOCAL_MODULE:= libOMX.TI.DUCATI1.VIDEO.DECODER
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
+#
+# libOMX.TI.DUCATI1.MISC.SAMPLE
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES += \
+	$(LOCAL_PATH)/../omx_core/inc \
+	$(LOCAL_PATH)/../mm_osal/inc \
+	$(LOCAL_PATH)/../domx \
+	$(LOCAL_PATH)/../domx/omx_rpc/inc
+
+LOCAL_SHARED_LIBRARIES := \
+	libmm_osal \
+	libc \
+	libOMX_Core \
+	liblog \
+	libdomx
+
+LOCAL_CFLAGS += -DTMS32060 -D_DB_TIOMAP -DSYSLINK_USE_SYSMGR -DSYSLINK_USE_LOADER
+LOCAL_CFLAGS += -D_Android -DSET_STRIDE_PADDING_FROM_PROXY -DANDROID_QUIRCK_CHANGE_PORT_VALUES -DUSE_ENHANCED_PORTRECONFIG
+LOCAL_MODULE_TAGS:= optional
+
+LOCAL_SRC_FILES:= omx_sample/src/omx_proxy_sample.c
+LOCAL_MODULE:= libOMX.TI.DUCATI1.MISC.SAMPLE
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
+
+#
+# libOMX.TI.DUCATI1.VIDEO.CAMERA
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES += \
+	$(LOCAL_PATH)/../omx_core/inc \
+	$(LOCAL_PATH)/../mm_osal/inc \
+	$(LOCAL_PATH)/../domx \
+	$(LOCAL_PATH)/../../tiler \
+	$(LOCAL_PATH)/../domx/omx_rpc/inc
+
+LOCAL_SHARED_LIBRARIES := \
+	libmm_osal \
+	libc \
+	libOMX_Core \
+	liblog \
+	libtimemmgr \
+	libdomx
+
+LOCAL_CFLAGS += -DTMS32060 -D_DB_TIOMAP -DSYSLINK_USE_SYSMGR -DSYSLINK_USE_LOADER
+LOCAL_CFLAGS += -D_Android -DSET_STRIDE_PADDING_FROM_PROXY -DANDROID_QUIRCK_CHANGE_PORT_VALUES -DUSE_ENHANCED_PORTRECONFIG
+LOCAL_MODULE_TAGS:= optional
+
+LOCAL_SRC_FILES:= omx_camera/src/omx_proxy_camera.c
+LOCAL_MODULE:= libOMX.TI.DUCATI1.VIDEO.CAMERA
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
+#
+# libOMX.TI.DUCATI1.VIDEO.H264E
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES += \
+	$(LOCAL_PATH)/../omx_core/inc \
+	$(LOCAL_PATH)/../mm_osal/inc \
+	$(LOCAL_PATH)/../domx \
+	$(LOCAL_PATH)/../domx/omx_rpc/inc \
+	system/core/include/cutils \
+	$(LOCAL_PATH)/../../hwc \
+	$(HARDWARE_TI_OMAP4_BASE)/camera/inc \
+	frameworks/base/include/media/stagefright
+
+LOCAL_SHARED_LIBRARIES := \
+	libmm_osal \
+	libc \
+	libOMX_Core \
+	liblog \
+	libdomx
+
+
+LOCAL_CFLAGS += -DLINUX -DTMS32060 -D_DB_TIOMAP -DSYSLINK_USE_SYSMGR -DSYSLINK_USE_LOADER
+LOCAL_CFLAGS += -D_Android -DSET_STRIDE_PADDING_FROM_PROXY -DANDROID_QUIRCK_CHANGE_PORT_VALUES -DUSE_ENHANCED_PORTRECONFIG  -DENABLE_GRALLOC_BUFFER
+LOCAL_MODULE_TAGS:= optional
+
+LOCAL_SRC_FILES:= omx_h264_enc/src/omx_proxy_h264enc.c
+LOCAL_MODULE:= libOMX.TI.DUCATI1.VIDEO.H264E
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
diff --git a/domx/omx_proxy_component/Makefile b/domx/omx_proxy_component/Makefile
new file mode 100755
index 0000000..1579866
--- /dev/null
+++ b/domx/omx_proxy_component/Makefile
@@ -0,0 +1,88 @@
+#
+#  Copyright 2001-2008 Texas Instruments - http://www.ti.com/
+# 
+#  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.
+#
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#  SEP xx,2002    REF=ORG			Swamy MC
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+#PROJROOT = $(ROOTDIR)/src
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = DEBUG
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  =
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+#TARGETTYPE  = ST_LIB
+TARGETTYPE  =
+
+# For shared object library, soname is filename.so.maj_ver
+SH_SONAME = 
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+omx_sample \
+omx_video_dec \
+omx_h264_enc \
+ 
+#video/omx_proxy_component/test 
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     =
+
+# Search path for include files
+
+INCLUDES    =
+
+# Libraries needed for linking.
+
+ST_LIBS        =
+SH_LIBS        =
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES =
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
diff --git a/domx/omx_proxy_component/omx_camera/src/omx_proxy_camera.c b/domx/omx_proxy_component/omx_camera/src/omx_proxy_camera.c
new file mode 100755
index 0000000..087bd47
--- /dev/null
+++ b/domx/omx_proxy_component/omx_camera/src/omx_proxy_camera.c
@@ -0,0 +1,637 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_proxy_camera.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework Tunnel Proxy component.
+ ******************************************************************************
+ This is the proxy specific wrapper that passes the component name to the
+ generic proxy init() The proxy wrapper also does some runtime/static time
+ config on per proxy basis This is a thin wrapper that is called when
+ componentiit() of the proxy is called  static OMX_ERRORTYPE PROXY_Wrapper_init
+ (OMX_HANDLETYPE hComponent, OMX_PTR pAppData);
+ this layer gets called first whenever a proxy s get handle is called
+ ******************************************************************************
+ *  @path WTSD_DucatiMMSW\omx\omx_il_1_x\omx_proxy_component\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <stdlib.h>
+
+#include <timm_osal_interfaces.h>
+#include <OMX_TI_IVCommon.h>
+#include <OMX_TI_Index.h>
+#include "omx_proxy_common.h"
+#include "timm_osal_mutex.h"
+
+/* Tiler APIs */
+#include <memmgr.h>
+
+#define COMPONENT_NAME "OMX.TI.DUCATI1.VIDEO.CAMERA"
+/*Needs to be specific for every configuration wrapper*/
+
+#undef LOG_TAG
+#define LOG_TAG "CameraHAL"
+
+#define DEFAULT_DCC 1
+#ifdef _Android
+#define DCC_PATH  "/system/etc/omapcam/"
+#else
+#define DCC_PATH  "/usr/share/omapcam/"
+#endif
+#define LINUX_PAGE_SIZE (4 * 1024)
+
+#define _PROXY_OMX_INIT_PARAM(param,type) do {		\
+	TIMM_OSAL_Memset((param), 0, sizeof (type));	\
+	(param)->nSize = sizeof (type);			\
+	(param)->nVersion.s.nVersionMajor = 1;		\
+	(param)->nVersion.s.nVersionMinor = 1;		\
+	} while(0)
+
+/* Incase of multiple instance, making sure DCC is initialized only for
+   first instance */
+static OMX_S16 numofInstance = 0;
+int dcc_flag = 0;
+TIMM_OSAL_PTR cam_mutex = NULL;
+
+/* To store DCC buffer size */
+OMX_S32 dccbuf_size = 0;
+
+/* Ducati Mapped Addr  */
+MemAllocBlock *MemReqDescTiler;
+OMX_PTR TilerAddr = NULL;
+
+OMX_S32 read_DCCdir(OMX_PTR, OMX_STRING *, OMX_U16);
+OMX_ERRORTYPE DCC_Init(OMX_HANDLETYPE);
+OMX_ERRORTYPE send_DCCBufPtr(OMX_HANDLETYPE hComponent);
+void DCC_DeInit();
+OMX_ERRORTYPE PROXY_ComponentDeInit(OMX_HANDLETYPE);
+OMX_ERRORTYPE __PROXY_SetConfig(OMX_HANDLETYPE, OMX_INDEXTYPE,
+								OMX_PTR, OMX_PTR);
+OMX_ERRORTYPE __PROXY_GetConfig(OMX_HANDLETYPE, OMX_INDEXTYPE,
+								OMX_PTR, OMX_PTR);
+OMX_ERRORTYPE __PROXY_SetParameter(OMX_IN OMX_HANDLETYPE, OMX_INDEXTYPE,
+									OMX_PTR, OMX_PTR);
+OMX_ERRORTYPE __PROXY_GetParameter(OMX_IN OMX_HANDLETYPE, OMX_INDEXTYPE,
+									OMX_PTR, OMX_PTR);
+OMX_ERRORTYPE CameraMaptoTilerDuc(OMX_TI_CONFIG_SHAREDBUFFER *, OMX_PTR *);
+//COREID TARGET_CORE_ID = CORE_APPM3;
+
+static OMX_ERRORTYPE ComponentPrivateDeInit(OMX_IN OMX_HANDLETYPE hComponent)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	TIMM_OSAL_ERRORTYPE eOsalError = TIMM_OSAL_ERR_NONE;
+
+	if (dcc_flag)
+	{
+		eOsalError =
+		    TIMM_OSAL_MutexObtain(cam_mutex, TIMM_OSAL_SUSPEND);
+		if (eOsalError != TIMM_OSAL_ERR_NONE)
+		{
+			TIMM_OSAL_Error("Mutex Obtain failed");
+		}
+
+		numofInstance = numofInstance - 1;
+
+		eOsalError = TIMM_OSAL_MutexRelease(cam_mutex);
+		PROXY_assert(eOsalError == TIMM_OSAL_ERR_NONE,
+		    OMX_ErrorInsufficientResources, "Mutex release failed");
+	}
+
+	eError = PROXY_ComponentDeInit(hComponent);
+
+      EXIT:
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name CameraGetConfig()
+ * @brief For some specific indices, buffer allocated on A9 side
+ *        needs to be mapped and sent to Ducati.
+ * @param
+ * @return OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+
+static OMX_ERRORTYPE CameraGetConfig(OMX_IN OMX_HANDLETYPE
+    hComponent, OMX_IN OMX_INDEXTYPE nParamIndex,
+    OMX_INOUT OMX_PTR pComponentParameterStructure)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_TI_CONFIG_SHAREDBUFFER *pConfigSharedBuffer = NULL;
+	OMX_PTR pTempSharedBuff = NULL;
+	OMX_U32 status = 0;
+
+	switch (nParamIndex)
+	{
+	case OMX_TI_IndexConfigAAAskipBuffer:
+	case OMX_TI_IndexConfigCamCapabilities:
+	case OMX_TI_IndexConfigExifTags:
+		pConfigSharedBuffer =
+			(OMX_TI_CONFIG_SHAREDBUFFER *) pComponentParameterStructure;
+
+		pTempSharedBuff = pConfigSharedBuffer->pSharedBuff;
+
+		// TODO(XXX): Cache API is not yet available. Client needs to
+		// allocate tiler buffer directly and assign to pSharedBuff.
+		// Ptr allocated by MemMgr_Alloc in uncacheable so there
+		// would be no need to cache API
+
+		eError = __PROXY_GetConfig(hComponent,
+								nParamIndex,
+								pConfigSharedBuffer,
+								&(pConfigSharedBuffer->pSharedBuff));
+
+		PROXY_assert((eError == OMX_ErrorNone), eError,
+		    "Error in GetConfig");
+
+		pConfigSharedBuffer->pSharedBuff = pTempSharedBuff;
+
+		goto EXIT;
+		break;
+	default:
+		break;
+	}
+
+	return __PROXY_GetConfig(hComponent,
+							nParamIndex,
+							pComponentParameterStructure,
+							NULL);
+
+ EXIT:
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name CameraSetConfig()
+ * @brief For some specific indices, buffer allocated on A9 side needs to
+ *        be mapped and sent to Ducati.
+ * @param
+ * @return OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+
+
+static OMX_ERRORTYPE CameraSetConfig(OMX_IN OMX_HANDLETYPE
+    hComponent, OMX_IN OMX_INDEXTYPE nParamIndex,
+    OMX_INOUT OMX_PTR pComponentParameterStructure)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_TI_CONFIG_SHAREDBUFFER *pConfigSharedBuffer = NULL;
+	OMX_PTR pTempSharedBuff = NULL;
+	OMX_U32 status = 0;
+
+	switch (nParamIndex)
+	{
+	case OMX_TI_IndexConfigAAAskipBuffer:
+	case OMX_TI_IndexConfigCamCapabilities:
+	case OMX_TI_IndexConfigExifTags:
+		pConfigSharedBuffer =
+			(OMX_TI_CONFIG_SHAREDBUFFER *)
+			pComponentParameterStructure;
+
+		pTempSharedBuff = pConfigSharedBuffer->pSharedBuff;
+
+		// TODO(XXX): Cache API is not yet available. Client needs to
+		// allocate tiler buffer directly and assign to pSharedBuff.
+		// Ptr allocated by MemMgr_Alloc in uncacheable so there
+		// would be no need to cache API
+
+		eError = __PROXY_SetConfig(hComponent,
+								nParamIndex,
+								pConfigSharedBuffer,
+								&(pConfigSharedBuffer->pSharedBuff));
+
+		PROXY_assert((eError == OMX_ErrorNone), eError,
+		    "Error in GetConfig");
+
+		pConfigSharedBuffer->pSharedBuff = pTempSharedBuff;
+
+		goto EXIT;
+		break;
+	default:
+		break;
+	}
+
+	return __PROXY_SetConfig(hComponent,
+							nParamIndex,
+							pComponentParameterStructure,
+							NULL);
+
+ EXIT:
+	return eError;
+}
+
+OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_ERRORTYPE dcc_eError = OMX_ErrorNone;
+	OMX_COMPONENTTYPE *pHandle = NULL;
+	PROXY_COMPONENT_PRIVATE *pComponentPrivate;
+	pHandle = (OMX_COMPONENTTYPE *) hComponent;
+	TIMM_OSAL_ERRORTYPE eOsalError = TIMM_OSAL_ERR_NONE;
+	DOMX_ENTER("_____________________INSIDE CAMERA PROXY"
+	    "WRAPPER__________________________\n");
+	pHandle->pComponentPrivate = (PROXY_COMPONENT_PRIVATE *)
+	    TIMM_OSAL_Malloc(sizeof(PROXY_COMPONENT_PRIVATE),
+	    TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
+
+	pComponentPrivate =
+	    (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
+	if (pHandle->pComponentPrivate == NULL)
+	{
+		DOMX_ERROR(" ERROR IN ALLOCATING PROXY COMPONENT"
+		    "PRIVATE STRUCTURE");
+		eError = OMX_ErrorInsufficientResources;
+		goto EXIT;
+	}
+	TIMM_OSAL_Memset(pComponentPrivate, 0,
+		sizeof(PROXY_COMPONENT_PRIVATE));
+
+	pComponentPrivate->cCompName =
+	    TIMM_OSAL_Malloc(MAX_COMPONENT_NAME_LENGTH * sizeof(OMX_U8),
+	    TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
+	/*Copying component Name - this will be picked up in the proxy common */
+	assert(strlen(COMPONENT_NAME) + 1 < MAX_COMPONENT_NAME_LENGTH);
+	TIMM_OSAL_Memcpy(pComponentPrivate->cCompName, COMPONENT_NAME,
+	    strlen(COMPONENT_NAME) + 1);
+	/*Calling Proxy Common Init() */
+	eError = OMX_ProxyCommonInit(hComponent);
+	if (eError != OMX_ErrorNone)
+	{
+		DOMX_ERROR("\Error in Initializing Proxy");
+		TIMM_OSAL_Free(pComponentPrivate->cCompName);
+		TIMM_OSAL_Free(pComponentPrivate);
+	}
+
+	pHandle->ComponentDeInit = ComponentPrivateDeInit;
+	pHandle->GetConfig = CameraGetConfig;
+	pHandle->SetConfig = CameraSetConfig;
+	char *val = getenv("SET_DCC");
+	dcc_flag = val ? strtol(val, NULL, 0) : DEFAULT_DCC;
+	DOMX_DEBUG(" DCC: 0 - disabled 1 - enabled : val: %d", dcc_flag);
+
+	if (dcc_flag)
+	{
+		eOsalError =
+		    TIMM_OSAL_MutexObtain(cam_mutex, TIMM_OSAL_SUSPEND);
+		PROXY_assert(eOsalError == TIMM_OSAL_ERR_NONE,
+		    OMX_ErrorInsufficientResources, "Mutex lock failed");
+
+		if (numofInstance == 0)
+		{
+			dcc_eError = DCC_Init(hComponent);
+			if (dcc_eError != OMX_ErrorNone)
+			{
+				DOMX_DEBUG(" Error in DCC Init");
+			}
+
+			/* Configure Ducati to use DCC buffer from A9 side
+			*ONLY* if DCC_Init is successful. */
+			if (dcc_eError == OMX_ErrorNone)
+			{
+				dcc_eError = send_DCCBufPtr(hComponent);
+				if (dcc_eError != OMX_ErrorNone)
+				{
+					DOMX_DEBUG(" Error in Sending DCC Buf ptr");
+				}
+				DCC_DeInit();
+			}
+                }
+                numofInstance = numofInstance + 1;
+		eOsalError = TIMM_OSAL_MutexRelease(cam_mutex);
+		PROXY_assert(eOsalError == TIMM_OSAL_ERR_NONE,
+		    OMX_ErrorInsufficientResources, "Mutex release failed");
+	}
+      EXIT:
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name DCC_Init()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE DCC_Init(OMX_HANDLETYPE hComponent)
+{
+	OMX_TI_PARAM_DCCURIINFO param;
+	OMX_PTR ptempbuf;
+	OMX_U16 nIndex = 0;
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+	OMX_S32 status = 0;
+	OMX_STRING dcc_dir[200];
+	OMX_U16 i;
+	_PROXY_OMX_INIT_PARAM(&param, OMX_TI_PARAM_DCCURIINFO);
+
+	DOMX_ENTER("ENTER");
+	/* Read the the DCC URI info */
+	for (nIndex = 0; eError != OMX_ErrorNoMore; nIndex++)
+	{
+		param.nIndex = nIndex;
+		eError =
+			OMX_GetParameter(hComponent,
+			OMX_TI_IndexParamDccUriInfo, &param);
+
+		PROXY_assert((eError == OMX_ErrorNone) ||
+			(eError == OMX_ErrorNoMore), eError,
+			"Error in GetParam for Dcc URI info");
+
+		if (eError == OMX_ErrorNone)
+		{
+			DOMX_DEBUG("DCC URI's %s ", param.sDCCURI);
+			dcc_dir[nIndex] =
+				TIMM_OSAL_Malloc(sizeof(OMX_U8) *
+				(strlen(DCC_PATH) + MAX_URI_LENGTH + 1),
+				TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
+			PROXY_assert(dcc_dir[nIndex] != NULL,
+				OMX_ErrorInsufficientResources, "Malloc failed");
+			strcpy(dcc_dir[nIndex], DCC_PATH);
+			strcat(dcc_dir[nIndex], (OMX_STRING) param.sDCCURI);
+			strcat(dcc_dir[nIndex], "/");
+		}
+	}
+
+	/* setting  back errortype OMX_ErrorNone */
+	if (eError == OMX_ErrorNoMore)
+	{
+		eError = OMX_ErrorNone;
+	}
+
+	dccbuf_size = read_DCCdir(NULL, dcc_dir, nIndex);
+
+	PROXY_assert(dccbuf_size > 0, OMX_ErrorInsufficientResources,
+	    "No DCC files found, switching back to default DCC");
+
+	MemReqDescTiler =
+		(MemAllocBlock *) TIMM_OSAL_Malloc((sizeof(MemAllocBlock) * 2),
+		TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_EXT);
+	PROXY_assert(MemReqDescTiler != NULL,
+	    OMX_ErrorInsufficientResources, "Malloc failed");
+
+	/* Allocate 1D Tiler buffer for 'N'DCC files  */
+	MemReqDescTiler[0].pixelFormat = PIXEL_FMT_PAGE;
+	MemReqDescTiler[0].dim.len = dccbuf_size;
+	MemReqDescTiler[0].stride = 0;
+	TilerAddr = MemMgr_Alloc(MemReqDescTiler, 1);
+	PROXY_assert(TilerAddr != NULL,
+		OMX_ErrorInsufficientResources, "ERROR Allocating 1D TILER BUF");
+
+	ptempbuf = TilerAddr;
+	dccbuf_size = read_DCCdir(ptempbuf, dcc_dir, nIndex);
+
+	PROXY_assert(dccbuf_size > 0, OMX_ErrorInsufficientResources,
+		"ERROR in copy DCC files into buffer");
+
+ EXIT:
+	for (i = 0; i < nIndex - 1; i++)
+	{
+			TIMM_OSAL_Free(dcc_dir[i]);
+	}
+
+	return eError;
+
+}
+
+/* ===========================================================================*/
+/**
+ * @name send_DCCBufPtr()
+ * @brief : Sending the DCC uri buff addr to ducati
+ * @param void
+ * @return return = 0 is successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+
+OMX_ERRORTYPE send_DCCBufPtr(OMX_HANDLETYPE hComponent)
+{
+	OMX_TI_CONFIG_SHAREDBUFFER uribufparam;
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+
+	_PROXY_OMX_INIT_PARAM(&uribufparam, OMX_TI_CONFIG_SHAREDBUFFER);
+	uribufparam.nPortIndex = OMX_ALL;
+
+	DOMX_ENTER("ENTER");
+
+	uribufparam.nSharedBuffSize = dccbuf_size;
+	uribufparam.pSharedBuff = (OMX_U8 *) TilerAddr;
+
+	DOMX_DEBUG("SYSLINK MAPPED ADDR:  0x%x sizeof buffer %d",
+		uribufparam.pSharedBuff, uribufparam.nSharedBuffSize);
+
+	eError = __PROXY_SetParameter(hComponent,
+								OMX_TI_IndexParamDccUriBuffer,
+								&uribufparam,
+								&(uribufparam.pSharedBuff));
+
+	if (eError != OMX_ErrorNone) {
+		DOMX_ERROR(" Error in SetParam for DCC Uri Buffer 0x%x", eError);
+	}
+
+	DOMX_EXIT("EXIT");
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name read_DCCdir()
+ * @brief : copies all the dcc profiles into the allocated 1D-Tiler buffer
+ *          and returns the size of the buffer.
+ * @param void : OMX_PTR is null then returns the size of the DCC directory
+ * @return return = size of the DCC directory or error in case of any failures
+ *		    in file read or open
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_S32 read_DCCdir(OMX_PTR buffer, OMX_STRING * dir_path, OMX_U16 numofURI)
+{
+	FILE *pFile;
+	OMX_S32 lSize;
+	OMX_S32 dcc_buf_size = 0;
+	size_t result;
+	OMX_STRING filename;
+	char temp[200];
+	OMX_STRING dotdot = "..";
+	DIR *d;
+	struct dirent *dir;
+	OMX_U16 i = 0;
+	OMX_S32 ret = 0;
+
+	DOMX_ENTER("ENTER");
+	for (i = 0; i < numofURI - 1; i++)
+	{
+		d = opendir(dir_path[i]);
+		if (d)
+		{
+			/* read each filename */
+			while ((dir = readdir(d)) != NULL)
+			{
+				filename = dir->d_name;
+				strcpy(temp, dir_path[i]);
+				strcat(temp, filename);
+				if ((*filename != *dotdot))
+				{
+					DOMX_DEBUG
+					    ("\n\t DCC Profiles copying into buffer => %s mpu_addr: %p",
+					    temp, buffer);
+					pFile = fopen(temp, "rb");
+					if (pFile == NULL)
+					{
+						DOMX_ERROR("File open error");
+						ret = -1;
+					} else
+					{
+						fseek(pFile, 0, SEEK_END);
+						lSize = ftell(pFile);
+						rewind(pFile);
+						/* buffer is not NULL then copy all the DCC profiles into buffer
+						   else return the size of the DCC directory */
+						if (buffer)
+						{
+							// copy file into the buffer:
+							result =
+							    fread(buffer, 1,
+							    lSize, pFile);
+							if (result != (size_t) lSize)
+							{
+								DOMX_ERROR
+								    ("fread: Reading error");
+								ret = -1;
+							}
+							buffer =
+							    buffer + lSize;
+						}
+						/* getting the size of the total dcc files available in FS */
+						dcc_buf_size =
+						    dcc_buf_size + lSize;
+						// terminate
+						fclose(pFile);
+					}
+				}
+			}
+			closedir(d);
+		}
+	}
+	if (ret == 0)
+		ret = dcc_buf_size;
+
+	DOMX_EXIT("return %d", ret);
+	return ret;
+}
+
+/* ===========================================================================*/
+/**
+ * @name DCC_Deinit()
+ * @brief
+ * @param void
+ * @return void
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+void DCC_DeInit()
+{
+	DOMX_ENTER("ENTER");
+
+	if (TilerAddr)
+		MemMgr_Free(TilerAddr);
+
+	if (MemReqDescTiler)
+		TIMM_OSAL_Free(MemReqDescTiler);
+
+	DOMX_EXIT("EXIT");
+}
+
+
+
+/*===============================================================*/
+/** @fn Cam_Setup : This function is called when the the OMX Camera library is
+ *                  loaded. It creates a mutex, which is used during DCC_Init()
+ */
+/*===============================================================*/
+void __attribute__ ((constructor)) Cam_Setup(void)
+{
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+
+	eError = TIMM_OSAL_MutexCreate(&cam_mutex);
+	if (eError != TIMM_OSAL_ERR_NONE)
+	{
+		TIMM_OSAL_Error("Creation of default mutex failed");
+	}
+}
+
+
+/*===============================================================*/
+/** @fn Cam_Destroy : This function is called when the the OMX Camera library is
+ *                    unloaded. It destroys the mutex which was created by
+ *                    Core_Setup().
+ *
+ */
+/*===============================================================*/
+void __attribute__ ((destructor)) Cam_Destroy(void)
+{
+	TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE;
+
+	eError = TIMM_OSAL_MutexDelete(cam_mutex);
+	if (eError != TIMM_OSAL_ERR_NONE)
+	{
+		TIMM_OSAL_Error("Destruction of default mutex failed");
+	}
+}
diff --git a/domx/omx_proxy_component/omx_h264_enc/Makefile b/domx/omx_proxy_component/omx_h264_enc/Makefile
new file mode 100755
index 0000000..c528740
--- /dev/null
+++ b/domx/omx_proxy_component/omx_h264_enc/Makefile
@@ -0,0 +1,103 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  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.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         =
+CDEFS          =
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG
+endif
+CDEFS          +=
+
+EXEC_ARGS      =
+ST_LIB_ARGS    =
+SH_LIB_ARGS    =
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = libOMX.TI.DUCATI1.VIDEO.H264E.so
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = SH_LIB
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = lib
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = lib
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+src/omx_proxy_h264enc.c \
+
+
+
+# Search path for include files
+
+INCLUDES    = \
+    $(PROJROOT)/omx_core/inc \
+    $(PROJROOT)/mm_osal/inc \
+    $(PROJROOT)/domx \
+    $(PROJROOT)/domx/omx_rpc/inc \
+
+
+# Libraries needed for linking.
+
+ST_LIBS        =
+#mm_osal domx
+SH_LIBS        = domx omx_core mm_osal
+#pthread rt utils procmgr ipc rcm notify
+#SH_LIBS        += sysmgr sysmemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/mm_osal \
+              $(PROJROOT)/domx \
+              $(PROJROOT)/omx_core
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
diff --git a/domx/omx_proxy_component/omx_h264_enc/src/omx_proxy_h264enc.c b/domx/omx_proxy_component/omx_h264_enc/src/omx_proxy_h264enc.c
new file mode 100644
index 0000000..6238f6b
--- /dev/null
+++ b/domx/omx_proxy_component/omx_h264_enc/src/omx_proxy_h264enc.c
@@ -0,0 +1,458 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_proxy_videodecoder.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework Tunnel Proxy component.
+ *********************************************************************************************
+ This is the proxy specific wrapper that passes the component name to the generic proxy init()
+ The proxy wrapper also does some runtime/static time onfig on per proxy basis
+ This is a thin wrapper that is called when componentiit() of the proxy is called
+ static OMX_ERRORTYPE PROXY_Wrapper_init(OMX_HANDLETYPE hComponent, OMX_PTR pAppData);
+ this layer gets called first whenever a proxy's get handle is called
+ ************************************************************************************************
+ *  @path WTSD_DucatiMMSW\omx\omx_il_1_x\omx_proxy_component\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 20-August-2010 Sarthak Aggarwal sarthak@ti.com: Initial Version
+ *================================================================*/
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "omx_proxy_common.h"
+#include <timm_osal_interfaces.h>
+#include "OMX_TI_IVCommon.h"
+#include "OMX_TI_Video.h"
+#include "OMX_TI_Index.h"
+
+#include <MetadataBufferType.h>
+#ifdef  ENABLE_GRALLOC_BUFFER
+#include "native_handle.h"
+#include <hal_public.h>
+#include <VideoMetadata.h>
+#endif
+
+#define COMPONENT_NAME "OMX.TI.DUCATI1.VIDEO.H264E"
+/* needs to be specific for every configuration wrapper */
+
+#define OMX_H264E_INPUT_PORT 0
+#define LINUX_PAGE_SIZE 4096
+
+#ifdef ANDROID_QUIRCK_CHANGE_PORT_VALUES
+
+OMX_ERRORTYPE LOCAL_PROXY_H264E_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct);
+
+OMX_ERRORTYPE LOCAL_PROXY_H264E_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct);
+
+#endif
+
+OMX_ERRORTYPE LOCAL_PROXY_H264E_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_STRING cParameterName, OMX_OUT OMX_INDEXTYPE * pIndexType);
+
+OMX_ERRORTYPE LOCAL_PROXY_H264E_EmptyThisBuffer(OMX_HANDLETYPE hComponent,
+    OMX_BUFFERHEADERTYPE * pBufferHdr);
+
+extern OMX_ERRORTYPE RPC_UTIL_GetStride(OMX_COMPONENTTYPE * hRemoteComp,
+    OMX_U32 nPortIndex, OMX_U32 * nStride);
+extern OMX_ERRORTYPE RPC_UTIL_GetNumLines(OMX_COMPONENTTYPE * hComp,
+    OMX_U32 nPortIndex, OMX_U32 * nNumOfLines);
+
+OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_COMPONENTTYPE *pHandle = NULL;
+	PROXY_COMPONENT_PRIVATE *pComponentPrivate = NULL;
+	pHandle = (OMX_COMPONENTTYPE *) hComponent;
+        OMX_TI_PARAM_ENHANCEDPORTRECONFIG tParamStruct;
+	DOMX_ENTER("");
+
+	DOMX_DEBUG("Component name provided is %s", COMPONENT_NAME);
+
+	pHandle->pComponentPrivate =
+	    (PROXY_COMPONENT_PRIVATE *)
+	    TIMM_OSAL_Malloc(sizeof(PROXY_COMPONENT_PRIVATE), TIMM_OSAL_TRUE,
+	    0, TIMMOSAL_MEM_SEGMENT_INT);
+
+	PROXY_assert(pHandle->pComponentPrivate != NULL,
+	    OMX_ErrorInsufficientResources,
+	    "ERROR IN ALLOCATING PROXY COMPONENT PRIVATE STRUCTURE");
+
+	pComponentPrivate =
+	    (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
+
+	TIMM_OSAL_Memset(pComponentPrivate, 0,
+		sizeof(PROXY_COMPONENT_PRIVATE));
+
+	pComponentPrivate->cCompName =
+	    TIMM_OSAL_Malloc(MAX_COMPONENT_NAME_LENGTH * sizeof(OMX_U8),
+	    TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
+
+	PROXY_assert(pComponentPrivate->cCompName != NULL,
+	    OMX_ErrorInsufficientResources,
+	    " Error in Allocating space for proxy component table");
+
+	// Copying component Name - this will be picked up in the proxy common
+	PROXY_assert(strlen(COMPONENT_NAME) + 1 < MAX_COMPONENT_NAME_LENGTH,
+	    OMX_ErrorInvalidComponentName,
+	    "Length of component name is longer than the max allowed");
+	TIMM_OSAL_Memcpy(pComponentPrivate->cCompName, COMPONENT_NAME,
+	    strlen(COMPONENT_NAME) + 1);
+
+	eError = OMX_ProxyCommonInit(hComponent);	// Calling Proxy Common Init()
+#ifdef ANDROID_QUIRCK_CHANGE_PORT_VALUES
+	pHandle->SetParameter = LOCAL_PROXY_H264E_SetParameter;
+    pHandle->GetParameter = LOCAL_PROXY_H264E_GetParameter;
+#endif
+	pComponentPrivate->IsLoadedState = OMX_TRUE;
+	pHandle->EmptyThisBuffer = LOCAL_PROXY_H264E_EmptyThisBuffer;
+	pHandle->GetExtensionIndex = LOCAL_PROXY_H264E_GetExtensionIndex;
+
+      EXIT:
+	if (eError != OMX_ErrorNone)
+	{
+		DOMX_DEBUG("Error in Initializing Proxy");
+		if (pComponentPrivate->cCompName != NULL)
+		{
+			TIMM_OSAL_Free(pComponentPrivate->cCompName);
+			pComponentPrivate->cCompName = NULL;
+		}
+		if (pComponentPrivate != NULL)
+		{
+			TIMM_OSAL_Free(pComponentPrivate);
+			pComponentPrivate = NULL;
+		}
+	}
+	return eError;
+}
+
+#ifdef  ANDROID_QUIRCK_CHANGE_PORT_VALUES
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_H264E_GetParameter()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE LOCAL_PROXY_H264E_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pParamStruct;
+	OMX_VIDEO_PARAM_PORTFORMATTYPE* pPortParam = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pParamStruct;
+
+	PROXY_require((pParamStruct != NULL), OMX_ErrorBadParameter, NULL);
+	PROXY_assert((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nParamIndex = %d, pParamStruct = %p",
+	    hComponent, pCompPrv, nParamIndex, pParamStruct);
+
+	eError = PROXY_GetParameter(hComponent,nParamIndex, pParamStruct);
+	PROXY_assert(eError == OMX_ErrorNone,
+		    eError," Error in Proxy GetParameter");
+
+	if( nParamIndex == OMX_IndexParamPortDefinition)
+	{
+		if(pPortDef->format.video.eColorFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar)
+		{
+			pPortDef->format.video.eColorFormat = OMX_TI_COLOR_FormatYUV420PackedSemiPlanar;
+		}
+	}
+	else if ( nParamIndex == OMX_IndexParamVideoPortFormat)
+	{
+		if(pPortParam->eColorFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar)
+		{
+			pPortParam->eColorFormat = OMX_TI_COLOR_FormatYUV420PackedSemiPlanar;
+		}
+        }
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_H264E_SetParameter()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE LOCAL_PROXY_H264E_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_IN OMX_PTR pParamStruct)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pParamStruct;
+	OMX_VIDEO_PARAM_PORTFORMATTYPE* pPortParams = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pParamStruct;
+	OMX_VIDEO_STOREMETADATAINBUFFERSPARAMS* pStoreMetaData = (OMX_VIDEO_STOREMETADATAINBUFFERSPARAMS *) pParamStruct;
+	OMX_TI_PARAM_BUFFERPREANNOUNCE tParamSetNPA;
+	OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
+
+	PROXY_require((pParamStruct != NULL), OMX_ErrorBadParameter, NULL);
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nParamIndex = %d, pParamStruct = %p",
+	    hComponent, pCompPrv, nParamIndex, pParamStruct);
+	if(nParamIndex == OMX_IndexParamPortDefinition)
+	{
+		if(pPortDef->format.video.eColorFormat == OMX_TI_COLOR_FormatYUV420PackedSemiPlanar)
+		{
+			pPortDef->format.video.eColorFormat = OMX_COLOR_FormatYUV420PackedSemiPlanar;
+		}
+	}
+	else if(nParamIndex == OMX_IndexParamVideoPortFormat)
+	{
+		if(pPortParams->eColorFormat == OMX_TI_COLOR_FormatYUV420PackedSemiPlanar)
+		{
+			pPortParams->eColorFormat = OMX_COLOR_FormatYUV420PackedSemiPlanar;
+		}
+	}
+	else if(nParamIndex == (OMX_INDEXTYPE) OMX_TI_IndexEncoderStoreMetadatInBuffers)
+	{
+		DOMX_DEBUG("Moving to Metadatamode");
+	    if (pStoreMetaData->nPortIndex == OMX_H264E_INPUT_PORT && pStoreMetaData->bStoreMetaData == OMX_TRUE)
+	    {
+		tParamSetNPA.nSize = sizeof(OMX_TI_PARAM_BUFFERPREANNOUNCE);
+		tParamSetNPA.nVersion.s.nVersionMajor = OMX_VER_MAJOR;
+		tParamSetNPA.nVersion.s.nVersionMinor = OMX_VER_MINOR;
+		tParamSetNPA.nVersion.s.nRevision = 0x0;
+		tParamSetNPA.nVersion.s.nStep = 0x0;
+		tParamSetNPA.nPortIndex = OMX_H264E_INPUT_PORT;
+		tParamSetNPA.bEnabled = OMX_TRUE;
+		//Call NPA on OMX encoder on ducati.
+		PROXY_SetParameter(hComponent,OMX_TI_IndexParamBufferPreAnnouncement, &tParamSetNPA);
+		pCompPrv->proxyPortBuffers[pStoreMetaData->nPortIndex].proxyBufferType = EncoderMetadataPointers;
+		DOMX_DEBUG("Moving to Metadatamode done");
+
+		/*Initializing Structure */
+		sPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
+		sPortDef.nVersion.s.nVersionMajor = OMX_VER_MAJOR;
+		sPortDef.nVersion.s.nVersionMinor = OMX_VER_MINOR;
+		sPortDef.nVersion.s.nRevision = 0x0;
+		sPortDef.nVersion.s.nStep = 0x0;
+		sPortDef.nPortIndex = OMX_H264E_INPUT_PORT;
+
+		eError = PROXY_GetParameter(hComponent,OMX_IndexParamPortDefinition, &sPortDef);
+		PROXY_assert(eError == OMX_ErrorNone, eError," Error in Proxy GetParameter for Port Def");
+
+		sPortDef.format.video.nStride = LINUX_PAGE_SIZE;
+
+		eError = PROXY_SetParameter(hComponent,OMX_IndexParamPortDefinition, &sPortDef);
+
+		PROXY_assert(eError == OMX_ErrorNone, eError," Error in Proxy SetParameter for Port Def");
+	    }
+	    goto EXIT;
+	}
+
+	eError = PROXY_SetParameter(hComponent, nParamIndex, pParamStruct);
+	PROXY_assert(eError == OMX_ErrorNone,
+		    eError," Error in Proxy SetParameter");
+
+	EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+#endif
+
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_GetExtensionIndex()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE LOCAL_PROXY_H264E_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_STRING cParameterName, OMX_OUT OMX_INDEXTYPE * pIndexType)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = hComponent;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+	PROXY_require(cParameterName != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(pIndexType != NULL, OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER("%s hComponent = %p, pCompPrv = %p, cParameterName = %s",
+	    __FUNCTION__,hComponent, pCompPrv, cParameterName);
+
+	// Check for NULL Parameters
+	PROXY_require((cParameterName != NULL && pIndexType != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	// Ensure that String length is not greater than Max allowed length
+	PROXY_require(strlen(cParameterName) <= 127, OMX_ErrorBadParameter, NULL);
+
+	if(strcmp(cParameterName, "OMX.google.android.index.storeMetaDataInBuffers") == 0)
+	{
+		// If Index type is 2D Buffer Allocated Dimension
+		*pIndexType = (OMX_INDEXTYPE) OMX_TI_IndexEncoderStoreMetadatInBuffers;
+		goto EXIT;
+	}
+
+        PROXY_GetExtensionIndex(hComponent, cParameterName, pIndexType);
+
+      EXIT:
+	DOMX_EXIT("%s eError: %d",__FUNCTION__, eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_H264E_EmptyThisBuffer()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE LOCAL_PROXY_H264E_EmptyThisBuffer(OMX_HANDLETYPE hComponent,
+    OMX_BUFFERHEADERTYPE * pBufferHdr)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_PTR pBufferOrig = NULL;
+	OMX_U32 nStride = 0, nNumLines = 0;
+
+	PROXY_require(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter,
+	    NULL);
+	PROXY_CHK_VERSION(pBufferHdr, OMX_BUFFERHEADERTYPE);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_DEBUG
+	    ("%s hComponent=%p, pCompPrv=%p, nFilledLen=%d, nOffset=%d, nFlags=%08x",
+	    __FUNCTION__,hComponent, pCompPrv, pBufferHdr->nFilledLen,
+	    pBufferHdr->nOffset, pBufferHdr->nFlags);
+
+	if( pCompPrv->proxyPortBuffers[OMX_H264E_INPUT_PORT].proxyBufferType == EncoderMetadataPointers)
+	{
+		OMX_U32 *pTempBuffer;
+		OMX_U32 nMetadataBufferType;
+		DOMX_DEBUG("Passing meta data to encoder");
+
+		pBufferOrig = pBufferHdr->pBuffer;
+
+		pTempBuffer = (OMX_U32 *) (pBufferHdr->pBuffer);
+		nMetadataBufferType = *pTempBuffer;
+
+		if(nMetadataBufferType == kMetadataBufferTypeCameraSource)
+		{
+#ifdef ENABLE_GRALLOC_BUFFER
+			IMG_native_handle_t* pGrallocHandle;
+			video_metadata_t* pVideoMetadataBuffer;
+			DOMX_DEBUG("MetadataBufferType is kMetadataBufferTypeCameraSource");
+
+			pVideoMetadataBuffer = (video_metadata_t*) ((OMX_U32 *)(pBufferHdr->pBuffer));
+			pGrallocHandle = (IMG_native_handle_t*) (pVideoMetadataBuffer->handle);
+			DOMX_DEBUG("Grallloc buffer recieved in metadata buffer 0x%x",pGrallocHandle );
+
+			pBufferHdr->pBuffer = (OMX_U8 *)(pGrallocHandle->fd[0]);
+			((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->
+			    pAuxBuf1 = pGrallocHandle->fd[1];
+			DOMX_DEBUG("%s Gralloc=0x%x, Y-fd=%d, UV-fd=%d", __FUNCTION__, pGrallocHandle,
+			            pGrallocHandle->fd[0], pGrallocHandle->fd[1]);
+
+			pBufferHdr->nOffset = pVideoMetadataBuffer->offset;
+#endif
+		}
+		else if(nMetadataBufferType == kMetadataBufferTypeGrallocSource)
+		{
+#ifdef ENABLE_GRALLOC_BUFFER
+			IMG_native_handle_t* pGrallocHandle;
+			DOMX_DEBUG("MetadataBufferType is kMetadataBufferTypeGrallocSource");
+
+			pTempBuffer++;
+			pGrallocHandle = (IMG_native_handle_t*) pTempBuffer;
+			DOMX_DEBUG("Grallloc buffer recieved in metadata buffer 0x%x",pGrallocHandle );
+
+			pBufferHdr->pBuffer = (OMX_U8 *)(pGrallocHandle->fd[0]);
+			((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->
+			    pAuxBuf1 = pGrallocHandle->fd[1];
+			DOMX_DEBUG("%s Gralloc=0x%x, Y-fd=%d, UV-fd=%d", __FUNCTION__, pGrallocHandle,
+			            pGrallocHandle->fd[0], pGrallocHandle->fd[1]);
+#endif
+		}
+		else
+		{
+			return OMX_ErrorBadParameter;
+		}
+	}
+
+	PROXY_EmptyThisBuffer(hComponent, pBufferHdr);
+
+	if( pCompPrv->proxyPortBuffers[pBufferHdr->nInputPortIndex].proxyBufferType == EncoderMetadataPointers)
+		pBufferHdr->pBuffer = pBufferOrig;
+
+	EXIT:
+		return eError;
+}
diff --git a/domx/omx_proxy_component/omx_sample/Makefile b/domx/omx_proxy_component/omx_sample/Makefile
new file mode 100755
index 0000000..499d1a6
--- /dev/null
+++ b/domx/omx_proxy_component/omx_sample/Makefile
@@ -0,0 +1,103 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  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.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = 
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG 
+endif
+CDEFS          +=
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = libOMX.TI.DUCATI1.MISC.SAMPLE.so
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = SH_LIB
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = lib
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = lib
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+src/omx_proxy_sample.c \
+
+
+
+# Search path for include files
+
+INCLUDES    = \
+    $(PROJROOT)/omx_core/inc \
+    $(PROJROOT)/mm_osal/inc \
+    $(PROJROOT)/domx \
+    $(PROJROOT)/domx/omx_rpc/inc \
+
+
+# Libraries needed for linking.
+
+ST_LIBS        = 
+#mm_osal domx
+SH_LIBS        = domx omx_core mm_osal
+#pthread rt utils procmgr ipc rcm notify
+#SH_LIBS        += sysmgr sysmemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/mm_osal \
+              $(PROJROOT)/domx \
+              $(PROJROOT)/omx_core
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
diff --git a/domx/omx_proxy_component/omx_sample/src/omx_proxy_sample.c b/domx/omx_proxy_component/omx_sample/src/omx_proxy_sample.c
new file mode 100755
index 0000000..b270186
--- /dev/null
+++ b/domx/omx_proxy_component/omx_sample/src/omx_proxy_sample.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_proxy_sample.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework Tunnel Proxy component.
+ *********************************************************************************************
+ This is the proxy specific wrapper that passes the component name to the generic proxy init()
+ The proxy wrapper also does some runtime/static time onfig on per proxy basis
+ This is a thin wrapper that is called when componentiit() of the proxy is called
+ static OMX_ERRORTYPE PROXY_Wrapper_init(OMX_HANDLETYPE hComponent, OMX_PTR pAppData);
+ this layer gets called first whenever a proxy s get handle is called
+ ************************************************************************************************
+ *  @path WTSD_DucatiMMSW\omx\omx_il_1_x\omx_proxy_component\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version
+ *================================================================*/
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "omx_proxy_common.h"
+#include <timm_osal_interfaces.h>
+//change to ducati1 later
+#define COMPONENT_NAME "OMX.TI.DUCATI1.MISC.SAMPLE"	// needs to be specific for every configuration wrapper
+
+OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_COMPONENTTYPE *pHandle = NULL;
+	PROXY_COMPONENT_PRIVATE *pComponentPrivate;
+	pHandle = (OMX_COMPONENTTYPE *) hComponent;
+
+	DOMX_DEBUG
+	    ("_____________________INSISDE PROXY WRAPPER__________________________\n");
+
+	pHandle->pComponentPrivate =
+	    (PROXY_COMPONENT_PRIVATE *)
+	    TIMM_OSAL_Malloc(sizeof(PROXY_COMPONENT_PRIVATE), TIMM_OSAL_TRUE,
+	    0, TIMMOSAL_MEM_SEGMENT_INT);
+
+	pComponentPrivate =
+	    (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
+	if (pHandle->pComponentPrivate == NULL)
+	{
+		DOMX_DEBUG
+		    (" ERROR IN ALLOCATING PROXY COMPONENT PRIVATE STRUCTURE");
+		eError = OMX_ErrorInsufficientResources;
+		goto EXIT;
+	}
+	pComponentPrivate->cCompName =
+	    TIMM_OSAL_Malloc(MAX_COMPONENT_NAME_LENGTH * sizeof(OMX_U8),
+	    TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
+	// Copying component Name - this will be picked up in the proxy common
+	assert(strlen(COMPONENT_NAME) + 1 < MAX_COMPONENT_NAME_LENGTH);
+	TIMM_OSAL_Memcpy(pComponentPrivate->cCompName, COMPONENT_NAME,
+	    strlen(COMPONENT_NAME) + 1);
+	eError = OMX_ProxyCommonInit(hComponent);	// Calling Proxy Common Init()
+
+	if (eError != OMX_ErrorNone)
+	{
+		DOMX_DEBUG("\Error in Initializing Proxy");
+		TIMM_OSAL_Free(pComponentPrivate->cCompName);
+		TIMM_OSAL_Free(pComponentPrivate);
+	}
+
+
+      EXIT:
+	return eError;
+}
diff --git a/domx/omx_proxy_component/omx_video_dec/Makefile b/domx/omx_proxy_component/omx_video_dec/Makefile
new file mode 100755
index 0000000..cbe5c56
--- /dev/null
+++ b/domx/omx_proxy_component/omx_video_dec/Makefile
@@ -0,0 +1,103 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  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.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = 
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG 
+endif
+CDEFS          +=
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = libOMX.TI.DUCATI1.VIDEO.DECODER.so
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = SH_LIB
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = lib
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = lib
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+src/omx_proxy_videodec.c \
+
+
+
+# Search path for include files
+
+INCLUDES    = \
+    $(PROJROOT)/omx_core/inc \
+    $(PROJROOT)/mm_osal/inc \
+    $(PROJROOT)/domx \
+    $(PROJROOT)/domx/omx_rpc/inc \
+
+
+# Libraries needed for linking.
+
+ST_LIBS        = 
+#mm_osal domx
+SH_LIBS        = domx omx_core mm_osal
+#pthread rt utils procmgr ipc rcm notify
+#SH_LIBS        += sysmgr sysmemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/mm_osal \
+              $(PROJROOT)/domx \
+              $(PROJROOT)/omx_core
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
diff --git a/domx/omx_proxy_component/omx_video_dec/src/omx_proxy_videodec.c b/domx/omx_proxy_component/omx_video_dec/src/omx_proxy_videodec.c
new file mode 100755
index 0000000..29dd06f
--- /dev/null
+++ b/domx/omx_proxy_component/omx_video_dec/src/omx_proxy_videodec.c
@@ -0,0 +1,629 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ *  @file  omx_proxy_videodecoder.c
+ *         This file contains methods that provides the functionality for
+ *         the OpenMAX1.1 DOMX Framework Tunnel Proxy component.
+ *********************************************************************************************
+ This is the proxy specific wrapper that passes the component name to the generic proxy init()
+ The proxy wrapper also does some runtime/static time onfig on per proxy basis
+ This is a thin wrapper that is called when componentiit() of the proxy is called
+ static OMX_ERRORTYPE PROXY_Wrapper_init(OMX_HANDLETYPE hComponent, OMX_PTR pAppData);
+ this layer gets called first whenever a proxy's get handle is called
+ ************************************************************************************************
+ *  @path WTSD_DucatiMMSW\omx\omx_il_1_x\omx_proxy_component\src
+ *
+ *  @rev 1.0
+ */
+
+/*==============================================================
+ *! Revision History
+ *! ============================
+ *! 20-August-2010 Sarthak Aggarwal sarthak@ti.com: Initial Version
+ *================================================================*/
+
+/******************************************************************
+ *   INCLUDE FILES
+ ******************************************************************/
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "omx_proxy_common.h"
+#include <timm_osal_interfaces.h>
+#include "OMX_TI_IVCommon.h"
+#include "OMX_TI_Video.h"
+#include "OMX_TI_Index.h"
+
+#define COMPONENT_NAME "OMX.TI.DUCATI1.VIDEO.DECODER"
+/* needs to be specific for every configuration wrapper */
+
+#ifdef USE_ENHANCED_PORTRECONFIG
+//Define port indices in video decoder proxy
+#define OMX_VIDEODECODER_INPUT_PORT 0
+#define OMX_VIDEODECODER_OUTPUT_PORT 1
+#endif
+
+#ifdef SET_STRIDE_PADDING_FROM_PROXY
+
+#define LINUX_PAGE_SIZE (4 * 1024)
+#define TOTAL_DEC_PORTS 2
+#define HAL_NV12_PADDED_PIXEL_FORMAT (OMX_TI_COLOR_FormatYUV420PackedSemiPlanar - OMX_COLOR_FormatVendorStartUnused)
+
+static OMX_ERRORTYPE RPC_UTIL_SetStrideAndPadding(OMX_COMPONENTTYPE * hRemoteComp, PROXY_COMPONENT_PRIVATE * pCompPrv);
+
+OMX_ERRORTYPE PROXY_VIDDEC_SendCommand(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_COMMANDTYPE eCmd,
+    OMX_IN OMX_U32 nParam, OMX_IN OMX_PTR pCmdData);
+
+OMX_ERRORTYPE PROXY_VIDDEC_EventHandler(OMX_HANDLETYPE hComponent,
+    OMX_PTR pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2,
+    OMX_PTR pEventData);
+
+#endif //SET_STRIDE_PADDING_FROM_PROXY
+
+#ifdef ANDROID_QUIRCK_CHANGE_PORT_VALUES
+
+OMX_ERRORTYPE PROXY_VIDDEC_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct);
+
+OMX_ERRORTYPE PROXY_VIDDEC_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct);
+
+#endif
+
+#ifdef ANDROID_QUIRK_LOCK_BUFFER
+#include <hardware/gralloc.h>
+#include <hardware/hardware.h>
+#include "hal_public.h"
+
+OMX_ERRORTYPE PROXY_VIDDEC_FillThisBuffer(OMX_HANDLETYPE hComponent, OMX_BUFFERHEADERTYPE * pBufferHdr);
+OMX_ERRORTYPE PROXY_VIDDEC_FillBufferDone(OMX_HANDLETYPE hComponent,
+    OMX_U32 remoteBufHdr, OMX_U32 nfilledLen, OMX_U32 nOffset, OMX_U32 nFlags,
+    OMX_TICKS nTimeStamp, OMX_HANDLETYPE hMarkTargetComponent,
+    OMX_PTR pMarkData);
+
+#endif
+
+OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_COMPONENTTYPE *pHandle = NULL;
+	PROXY_COMPONENT_PRIVATE *pComponentPrivate = NULL;
+	pHandle = (OMX_COMPONENTTYPE *) hComponent;
+        OMX_TI_PARAM_ENHANCEDPORTRECONFIG tParamStruct;
+
+#ifdef ANDROID_QUIRK_LOCK_BUFFER
+	OMX_U32 err;
+	hw_module_t const* module;
+#endif
+	DOMX_ENTER("");
+
+	DOMX_DEBUG("Component name provided is %s", COMPONENT_NAME);
+
+	pHandle->pComponentPrivate =
+	    (PROXY_COMPONENT_PRIVATE *)
+	    TIMM_OSAL_Malloc(sizeof(PROXY_COMPONENT_PRIVATE), TIMM_OSAL_TRUE,
+	    0, TIMMOSAL_MEM_SEGMENT_INT);
+
+	PROXY_assert(pHandle->pComponentPrivate != NULL,
+	    OMX_ErrorInsufficientResources,
+	    "ERROR IN ALLOCATING PROXY COMPONENT PRIVATE STRUCTURE");
+
+	pComponentPrivate =
+	    (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
+
+	TIMM_OSAL_Memset(pComponentPrivate, 0,
+		sizeof(PROXY_COMPONENT_PRIVATE));
+
+	pComponentPrivate->cCompName =
+	    TIMM_OSAL_Malloc(MAX_COMPONENT_NAME_LENGTH * sizeof(OMX_U8),
+	    TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
+
+	PROXY_assert(pComponentPrivate->cCompName != NULL,
+	    OMX_ErrorInsufficientResources,
+	    " Error in Allocating space for proxy component table");
+
+	// Copying component Name - this will be picked up in the proxy common
+	PROXY_assert(strlen(COMPONENT_NAME) + 1 < MAX_COMPONENT_NAME_LENGTH,
+	    OMX_ErrorInvalidComponentName,
+	    "Length of component name is longer than the max allowed");
+	TIMM_OSAL_Memcpy(pComponentPrivate->cCompName, COMPONENT_NAME,
+	    strlen(COMPONENT_NAME) + 1);
+
+	eError = OMX_ProxyCommonInit(hComponent);	// Calling Proxy Common Init()
+#ifdef ANDROID_QUIRCK_CHANGE_PORT_VALUES
+	pHandle->SetParameter = PROXY_VIDDEC_SetParameter;		
+        pHandle->GetParameter = PROXY_VIDDEC_GetParameter;
+#endif
+#ifdef  SET_STRIDE_PADDING_FROM_PROXY
+        pHandle->SendCommand = PROXY_VIDDEC_SendCommand;
+	pComponentPrivate->proxyEventHandler = PROXY_VIDDEC_EventHandler;
+	pComponentPrivate->IsLoadedState = OMX_TRUE;
+#endif
+
+#ifdef ANDROID_QUIRK_LOCK_BUFFER
+        pComponentPrivate->proxyFillBufferDone = PROXY_VIDDEC_FillBufferDone;
+	pHandle->FillThisBuffer = PROXY_VIDDEC_FillThisBuffer;
+
+        err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
+        if (err == 0)
+	{
+                pComponentPrivate->grallocModule = (gralloc_module_t const *)module;
+        }
+	else
+	{
+                DOMX_ERROR("FATAL: gralloc api hw_get_module() returned error: Can't find \
+		 %s module err = %x", GRALLOC_HARDWARE_MODULE_ID, err);
+		eError = OMX_ErrorInsufficientResources;
+		return eError;
+	}
+#endif
+
+#ifdef USE_ENHANCED_PORTRECONFIG
+	/*Initializing Structure */
+	tParamStruct.nSize = sizeof(OMX_TI_PARAM_ENHANCEDPORTRECONFIG);
+	tParamStruct.nVersion.s.nVersionMajor = OMX_VER_MAJOR;
+	tParamStruct.nVersion.s.nVersionMinor = OMX_VER_MINOR;
+	tParamStruct.nVersion.s.nRevision = 0x0;
+	tParamStruct.nVersion.s.nStep = 0x0;
+	tParamStruct.nPortIndex = OMX_VIDEODECODER_OUTPUT_PORT;
+        tParamStruct.bUsePortReconfigForCrop = OMX_TRUE;
+        tParamStruct.bUsePortReconfigForPadding = OMX_TRUE;
+
+	eError = PROXY_SetParameter(hComponent,(OMX_INDEXTYPE)OMX_TI_IndexParamUseEnhancedPortReconfig,
+	   &tParamStruct);
+	PROXY_assert(eError == OMX_ErrorNone,
+	    eError," Error in Proxy SetParameter for Enhanced port reconfig usage");
+#endif
+
+      EXIT:
+	if (eError != OMX_ErrorNone)
+	{
+		DOMX_DEBUG("Error in Initializing Proxy");
+		if (pComponentPrivate->cCompName != NULL)
+		{
+			TIMM_OSAL_Free(pComponentPrivate->cCompName);
+			pComponentPrivate->cCompName = NULL;
+		}
+		if (pComponentPrivate != NULL)
+		{
+			TIMM_OSAL_Free(pComponentPrivate);
+			pComponentPrivate = NULL;
+		}
+	}
+	return eError;
+}
+
+#ifdef  ANDROID_QUIRCK_CHANGE_PORT_VALUES
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_GetParameter()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_VIDDEC_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pParamStruct;
+	OMX_VIDEO_PARAM_PORTFORMATTYPE* pPortParam = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pParamStruct;
+
+	PROXY_require((pParamStruct != NULL), OMX_ErrorBadParameter, NULL);
+	PROXY_assert((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nParamIndex = %d, pParamStruct = %p",
+	    hComponent, pCompPrv, nParamIndex, pParamStruct);
+
+	eError = PROXY_GetParameter(hComponent,nParamIndex, pParamStruct);
+	PROXY_assert(eError == OMX_ErrorNone,
+		    eError," Error in Proxy GetParameter");
+
+	if( nParamIndex == OMX_IndexParamPortDefinition)
+	{
+		if(pPortDef->format.video.eColorFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar)
+		{
+			if(pCompPrv->proxyPortBuffers[pPortDef->nPortIndex].proxyBufferType == GrallocPointers)
+			{
+				pPortDef->format.video.eColorFormat = HAL_NV12_PADDED_PIXEL_FORMAT;
+			}
+			else
+			{
+				pPortDef->format.video.eColorFormat = OMX_TI_COLOR_FormatYUV420PackedSemiPlanar;
+			}
+		}
+	}
+	else if ( nParamIndex == OMX_IndexParamVideoPortFormat)
+	{
+		if(pPortParam->eColorFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar)
+            {
+			if(pCompPrv->proxyPortBuffers[pPortDef->nPortIndex].proxyBufferType == GrallocPointers)
+			{
+				pPortParam->eColorFormat = HAL_NV12_PADDED_PIXEL_FORMAT;
+			}
+			else
+			{
+				pPortParam->eColorFormat = OMX_TI_COLOR_FormatYUV420PackedSemiPlanar;
+			}
+            }
+	}
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_SetParameter()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_VIDDEC_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex, OMX_IN OMX_PTR pParamStruct)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pParamStruct;
+	OMX_VIDEO_PARAM_PORTFORMATTYPE* pPortParams = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pParamStruct;
+
+	PROXY_require((pParamStruct != NULL), OMX_ErrorBadParameter, NULL);
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, nParamIndex = %d, pParamStruct = %p",
+	    hComponent, pCompPrv, nParamIndex, pParamStruct);
+	if(nParamIndex == OMX_IndexParamPortDefinition)
+	{
+		if(pPortDef->format.video.eColorFormat == OMX_TI_COLOR_FormatYUV420PackedSemiPlanar
+			|| pPortDef->format.video.eColorFormat == HAL_NV12_PADDED_PIXEL_FORMAT)
+		{
+			pPortDef->format.video.eColorFormat = OMX_COLOR_FormatYUV420PackedSemiPlanar;
+		}
+	}
+	else if(nParamIndex == OMX_IndexParamVideoPortFormat)
+	{
+		if(pPortParams->eColorFormat == OMX_TI_COLOR_FormatYUV420PackedSemiPlanar
+			|| pPortParams->eColorFormat == HAL_NV12_PADDED_PIXEL_FORMAT)
+		{
+			pPortParams->eColorFormat = OMX_COLOR_FormatYUV420PackedSemiPlanar;
+		}
+	}
+
+	eError = PROXY_SetParameter(hComponent, nParamIndex, pParamStruct);
+	PROXY_assert(eError == OMX_ErrorNone,
+		    eError," Error in Proxy SetParameter");
+
+	EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+#endif
+
+#ifdef SET_STRIDE_PADDING_FROM_PROXY
+/* ===========================================================================*/
+/**
+ * @name PROXY_VIDDEC_SendCommand()
+ * @brief
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_VIDDEC_SendCommand(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_COMMANDTYPE eCmd,
+    OMX_IN OMX_U32 nParam, OMX_IN OMX_PTR pCmdData)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter, NULL);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	DOMX_ENTER
+	    ("hComponent = %p, pCompPrv = %p, eCmd = %d, nParam = %d, pCmdData = %p",
+	    hComponent, pCompPrv, eCmd, nParam, pCmdData);
+
+	if(eCmd == OMX_CommandStateSet)
+	{
+		//Set appropriate stride before Loaded to Idle transition.
+		if((OMX_STATETYPE)nParam == OMX_StateIdle && pCompPrv->IsLoadedState == OMX_TRUE)
+		{
+			eError = RPC_UTIL_SetStrideAndPadding(hComponent, pCompPrv);
+			PROXY_require(eError == OMX_ErrorNone, eError,
+                               "Stride and padding setting from proxy returned");
+			pCompPrv->IsLoadedState = OMX_FALSE;
+		}
+	}
+	else if(eCmd == OMX_CommandPortEnable)
+	{
+		if(nParam == OMX_ALL || nParam == OMX_VIDEODECODER_OUTPUT_PORT)
+		{
+			eError = RPC_UTIL_SetStrideAndPadding(hComponent, pCompPrv);
+			PROXY_require(eError == OMX_ErrorNone, eError,
+                               "Stride and padding setting from proxy returned");
+		}
+	}
+
+	eError =
+	    PROXY_SendCommand(hComponent, eCmd, nParam, pCmdData);
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_EventHandler()
+ * @brief
+ * @param void
+ * @return OMX_ErrorNone = Successful
+ * @sa TBD
+ *
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_VIDDEC_EventHandler(OMX_HANDLETYPE hComponent,
+    OMX_PTR pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2,
+    OMX_PTR pEventData)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+	    OMX_ErrorBadParameter,
+	    "This is fatal error, processing cant proceed - please debug");
+
+	DOMX_ENTER
+	    ("hComponent=%p, pCompPrv=%p, eEvent=%p, nData1=%p, nData2=%p, pEventData=%p",
+	    hComponent, pCompPrv, eEvent, nData1, nData2, pEventData);
+
+	if((eEvent ==  OMX_EventCmdComplete) && ((OMX_COMMANDTYPE)nData1 == OMX_CommandStateSet))
+	{
+		if((OMX_STATETYPE)nData2 == OMX_StateLoaded)
+		{
+			pCompPrv->IsLoadedState = OMX_TRUE;
+		}
+	}
+	eError = PROXY_EventHandler(hComponent, pAppData, eEvent, nData1, nData2, pEventData);
+
+	EXIT:
+		return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name RPC_UTIL_RPC_UTIL_SetStrideAndPadding()
+ * @brief Gets stride on this port. Used to set stride on OMX to tell whether buffer is 1D or 2D
+ * @param hRemoteComp [IN]  : Remote component handle.
+ * @return OMX_ErrorNone = Successful
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE RPC_UTIL_SetStrideAndPadding(OMX_COMPONENTTYPE * hComponent,PROXY_COMPONENT_PRIVATE * pCompPrv)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
+	OMX_CONFIG_RECTTYPE tParamStruct;
+	OMX_U32 nPortIndex = 0;
+
+	for(nPortIndex=0; nPortIndex < TOTAL_DEC_PORTS ;nPortIndex++ )
+	{
+		/*Initializing Structure */
+		sPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
+		sPortDef.nVersion.s.nVersionMajor = OMX_VER_MAJOR;
+		sPortDef.nVersion.s.nVersionMinor = OMX_VER_MINOR;
+		sPortDef.nVersion.s.nRevision = 0x0;
+		sPortDef.nVersion.s.nStep = 0x0;
+		sPortDef.nPortIndex = nPortIndex;
+
+		eError = PROXY_GetParameter(hComponent,OMX_IndexParamPortDefinition,
+			   &sPortDef);
+		PROXY_assert(eError == OMX_ErrorNone,
+			    eError," Error in Proxy GetParameter for Port Def");
+
+		if (sPortDef.eDomain == OMX_PortDomainVideo && sPortDef.format.video.eCompressionFormat == OMX_VIDEO_CodingUnused)
+		{
+			if(pCompPrv->proxyPortBuffers[nPortIndex].IsBuffer2D == OMX_TRUE)
+			{
+				sPortDef.format.video.nStride = LINUX_PAGE_SIZE;
+			}
+			else
+			{
+				tParamStruct.nSize = sizeof(OMX_CONFIG_RECTTYPE);
+				tParamStruct.nVersion.s.nVersionMajor = OMX_VER_MAJOR;
+				tParamStruct.nVersion.s.nVersionMinor = OMX_VER_MINOR;
+				tParamStruct.nVersion.s.nRevision = 0x0;
+				tParamStruct.nVersion.s.nStep = 0x0;
+				tParamStruct.nPortIndex = nPortIndex;
+
+				eError = PROXY_GetParameter(hComponent,(OMX_INDEXTYPE)OMX_TI_IndexParam2DBufferAllocDimension,
+						  &tParamStruct);
+				PROXY_assert(eError == OMX_ErrorNone,
+					    eError," Error in Proxy GetParameter for 2D index");
+
+				sPortDef.format.video.nStride = tParamStruct.nWidth;
+			}
+			eError = PROXY_SetParameter(hComponent,OMX_IndexParamPortDefinition,
+				   &sPortDef);
+			PROXY_assert(eError == OMX_ErrorNone,
+				    eError," Error in Proxy SetParameter for Port Def");
+		}
+	}
+
+      EXIT:
+	return eError;
+}
+
+#endif
+
+#ifdef ANDROID_QUIRK_LOCK_BUFFER
+/* ===========================================================================*/
+/**
+ * @name PROXY_VIDDEC_FillThisBuffer()
+ * @brief Gets stride on this port. Used to set stride on OMX to tell whether buffer is 1D or 2D
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_VIDDEC_FillThisBuffer(OMX_HANDLETYPE hComponent, OMX_BUFFERHEADERTYPE * pBufferHdr)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_U32 count = 0;
+	IMG_native_handle_t*  grallocHandle;
+	OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
+
+	PROXY_require(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL);
+	PROXY_require(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter,
+	    NULL);
+	PROXY_CHK_VERSION(pBufferHdr, OMX_BUFFERHEADERTYPE);
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	if(pCompPrv->proxyPortBuffers[OMX_VIDEODECODER_OUTPUT_PORT].proxyBufferType 
+			== GrallocPointers) 
+	{
+		/* Lock the Gralloc buffer till it gets rendered completely */
+		/* Extract the Gralloc handle from the Header and then call lock on that */
+		/* Note# There is no error check for the pBufferHdr here*/
+		grallocHandle = (IMG_native_handle_t*)pBufferHdr->pBuffer;
+
+		/*Initializing Structure */
+		sPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
+		sPortDef.nVersion.s.nVersionMajor = OMX_VER_MAJOR;
+		sPortDef.nVersion.s.nVersionMinor = OMX_VER_MINOR;
+		sPortDef.nVersion.s.nRevision = 0x0;
+		sPortDef.nVersion.s.nStep = 0x0;
+		sPortDef.nPortIndex = OMX_VIDEODECODER_INPUT_PORT;
+		eError = PROXY_GetParameter(hComponent,OMX_IndexParamPortDefinition,
+				&sPortDef);
+		PROXY_assert(eError == OMX_ErrorNone,
+				eError," Error in Proxy GetParameter for Port Def");
+
+		pCompPrv->grallocModule->lock((gralloc_module_t const *) pCompPrv->grallocModule,
+				(buffer_handle_t)grallocHandle, GRALLOC_USAGE_HW_RENDER,
+				0,0,sPortDef.format.video.nFrameWidth, sPortDef.format.video.nFrameHeight,NULL);
+	}		
+
+        eRPCError = PROXY_FillThisBuffer(hComponent, pBufferHdr);
+
+	PROXY_assert(eError == OMX_ErrorNone,
+	    eError," Error in Proxy SetParameter for Port Def");
+
+      EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+/* ===========================================================================*/
+/**
+ * @name PROXY_VIDDEC_FillBufferDone()
+ * @brief Gets stride on this port. Used to set stride on OMX to tell whether buffer is 1D or 2D
+ */
+/* ===========================================================================*/
+OMX_ERRORTYPE PROXY_VIDDEC_FillBufferDone(OMX_HANDLETYPE hComponent,
+    OMX_U32 remoteBufHdr, OMX_U32 nfilledLen, OMX_U32 nOffset, OMX_U32 nFlags,
+    OMX_TICKS nTimeStamp, OMX_HANDLETYPE hMarkTargetComponent,
+    OMX_PTR pMarkData)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
+	RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
+	PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
+	OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
+	OMX_U32 count = 0;
+	IMG_native_handle_t*  grallocHandle;
+
+	PROXY_require((hComp->pComponentPrivate != NULL),
+			OMX_ErrorBadParameter,
+			"This is fatal error, processing cant proceed - please debug");
+
+	pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate;
+
+	/* Lock the Gralloc buffer till it gets rendered completely */
+	/* Extract the Gralloc handle from the Header and then call lock on that */
+	/* Note# There is no error check for the pBufferHdr here*/
+
+	if(pCompPrv->proxyPortBuffers[OMX_VIDEODECODER_OUTPUT_PORT].proxyBufferType
+			== GrallocPointers) {
+		for (count = 0; count < pCompPrv->nTotalBuffers; ++count) 
+		{
+			if (pCompPrv->tBufList[count].pBufHeaderRemote == remoteBufHdr)
+			{
+				grallocHandle = (IMG_native_handle_t*)(pCompPrv->tBufList[count].pBufHeader)->pBuffer;
+				break;
+			}
+		}
+
+		PROXY_assert((count != pCompPrv->nTotalBuffers),
+				OMX_ErrorBadParameter,
+				"Received invalid-buffer header from OMX component");
+		pCompPrv->grallocModule->unlock((gralloc_module_t const *) pCompPrv->grallocModule, (buffer_handle_t)grallocHandle);
+	} 
+
+	eRPCError = PROXY_FillBufferDone(hComponent,remoteBufHdr, nfilledLen, nOffset, nFlags,
+		nTimeStamp, hMarkTargetComponent, pMarkData);
+
+	PROXY_assert(eError == OMX_ErrorNone,
+			eError," Error in PROXY FillBufferDone for Port Def");
+
+EXIT:
+	DOMX_EXIT("eError: %d", eError);
+	return eError;
+}
+
+#endif
+
diff --git a/domx/test/Makefile b/domx/test/Makefile
new file mode 100644
index 0000000..78c6f31
--- /dev/null
+++ b/domx/test/Makefile
@@ -0,0 +1,95 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  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.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = 
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG 
+endif
+CDEFS          +=
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = 
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = 
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = 
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = 
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = sample_proxy \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+
+
+
+
+# Search path for include files
+
+INCLUDES    = 
+
+# Libraries needed for linking.
+
+#ST_LIBS        = omx_core omx_proxy_component mmplatform mm_osal domx 
+#SH_LIBS        = pthread rt utils procmgr ipc rcm notify
+#SH_LIBS        += sysmgr sysmemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/target/lib 
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
diff --git a/domx/test/sample_proxy/Makefile b/domx/test/sample_proxy/Makefile
new file mode 100644
index 0000000..02a3619
--- /dev/null
+++ b/domx/test/sample_proxy/Makefile
@@ -0,0 +1,98 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  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.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = 
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG 
+endif
+CDEFS          +=
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = sampletest
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = EXEC
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = binaries
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = binaries
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+test_sample_proxy.c
+
+
+
+# Search path for include files
+
+INCLUDES    = \
+    $(PROJROOT)/omx_core/inc \
+    $(PROJROOT)/mm_osal/inc \
+    $(MEMMGRROOT)
+
+# Libraries needed for linking.
+
+ST_LIBS        =
+#omx_core omx_proxy_component domx mm_osal
+SH_LIBS        = pthread dl omx_core OMX.TI.DUCATI1.MISC.SAMPLE domx mm_osal timemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/target/lib 
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
diff --git a/domx/test/sample_proxy/test_sample_proxy.c b/domx/test/sample_proxy/test_sample_proxy.c
new file mode 100755
index 0000000..59830a9
--- /dev/null
+++ b/domx/test/sample_proxy/test_sample_proxy.c
@@ -0,0 +1,1222 @@
+/*
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define COMPONENT_NAME "OMX.TI.DUCATI1.MISC.SAMPLE"	// needs to be specific for every configuration wrapper
+#define OMX_SAMPLE_USEBUF OMX_TRUE
+
+/****************************************************************
+*  INCLUDE FILES
+****************************************************************/
+/* ----- system and platform files ----------------------------*/
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+
+/*-------program files ----------------------------------------*/
+#include <OMX_Core.h>
+#include <OMX_Component.h>
+#include "timm_osal_interfaces.h"
+
+
+#define OMX_SAMPLE_TILER_TEST
+
+#ifdef OMX_SAMPLE_TILER_TEST
+
+#include "memmgr.h"
+
+#endif
+
+
+#define OMX_SAMPLE_INPUT_PORT 0
+#define OMX_SAMPLE_OUTPUT_PORT 1
+
+#ifdef OMX_SAMPLE_TILER_TEST
+
+
+#define OMX_SAMPLE_IN_2DYHEIGHT 4
+#define OMX_SAMPLE_IN_2DYWIDTH 8
+#define OMX_SAMPLE_IN_2DUVHEIGHT 2
+#define OMX_SAMPLE_IN_2DUVWIDTH 4
+/*
+ #define STRIDE_8BIT (16 * 1024)
+ #define STRIDE_16BIT (32 * 1024)
+*/
+#define OMX_SAMPLE_IN_HEIGHT 6
+#define OMX_SAMPLE_IN_WIDTH 8
+
+#define STRIDE_LINUX (4 * 1024)
+
+#define OMX_SAMPLE_BUFFER_SIZE 48
+
+
+void Test_Util_Memcpy_1Dto2D(TIMM_OSAL_PTR pDst2D, TIMM_OSAL_PTR pSrc1D,
+    TIMM_OSAL_U32 nSize1D, TIMM_OSAL_U32 nHeight2D, TIMM_OSAL_U32 nWidth2D,
+    TIMM_OSAL_U32 nStride2D)
+{
+	TIMM_OSAL_U8 *pInBuffer;
+	TIMM_OSAL_U8 *pOutBuffer;
+	TIMM_OSAL_U32 nSizeLeft, i;
+
+	nSizeLeft = nSize1D;
+	pInBuffer = (TIMM_OSAL_U8 *) pSrc1D;
+	pOutBuffer = (TIMM_OSAL_U8 *) pDst2D;
+	//The lower limit is copied. If nSize1D < H*W then 1Dsize is copied else H*W is copied
+	for (i = 0; i < nHeight2D; i++)
+	{
+		if (nSizeLeft >= nWidth2D)
+		{
+			TIMM_OSAL_Memcpy(pOutBuffer, pInBuffer, nWidth2D);
+		} else
+		{
+			TIMM_OSAL_Memcpy(pOutBuffer, pInBuffer, nSizeLeft);
+			break;
+		}
+		nSizeLeft -= nWidth2D;
+		pInBuffer =
+		    (TIMM_OSAL_U8 *) ((TIMM_OSAL_U32) pInBuffer + nWidth2D);
+		pOutBuffer =
+		    (TIMM_OSAL_U8 *) ((TIMM_OSAL_U32) pOutBuffer + nStride2D);
+	}
+}
+
+#endif
+
+
+/****************************************************************
+*  EXTERNAL REFERENCES NOTE : only use if not found in header file
+****************************************************************/
+/*--------data declarations -----------------------------------*/
+/*--------function prototypes ---------------------------------*/
+
+/****************************************************************
+*  PRIVATE DECLARATIONS Defined and used only here
+****************************************************************/
+/*--------function declarations -------------------------------*/
+
+/*--------data declarations -----------------------------------*/
+#define NUM_DOMAINS 0x4
+#define OMX_NOPORT 0xfffffffe
+
+//#define INPUT_FILE "../../omx/omx_il_1_x/omx_base/test/patterns/chikita.mp3"
+#define INPUT_FILE "sample_input.mp3"
+#define NON_TUN_OUTPUT_FILE "nt_output.mp3"
+
+static int gTest = 1;
+
+#define TIMM_OSAL_MallocaBuffer(_size, bContigous, nBlockAlignment) \
+        TIMM_OSAL_Malloc (_size, TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_EXT)
+
+#define OMX_TEST_BUFFERS_OF_TRAFFIC 20
+
+#define OMX_TEST_BAIL_IF_ERROR(_eError)		\
+    if(OMX_ErrorNone != (eError = _eError)){	\
+        goto OMX_TEST_BAIL;		\
+    }
+
+#define OMX_TEST_SET_ERROR_BAIL(_eCode, _desc)	\
+{						\
+    eError = _eCode;				\
+    printf(_desc);\
+    goto OMX_TEST_BAIL;			\
+}
+
+#define OMX_TEST_INIT_STRUCT(_s_, _name_)	\
+    memset(&(_s_), 0x0, sizeof(_name_));	\
+    (_s_).nSize = sizeof(_name_);		\
+    (_s_).nVersion.s.nVersionMajor = 0x1;	\
+    (_s_).nVersion.s.nVersionMinor = 0x1;	\
+    (_s_).nVersion.s.nRevision = 0x0;		\
+    (_s_).nVersion.s.nStep = 0x0
+
+#define BUFFER_LIST_CLEAR_ENTRY(_pL, _pB)\
+    _pB = _pL->pBufHdr;        \
+    _pL->pBufHdr = NULL;    \
+    _pL = _pL->pNextBuf;
+
+#define BUFFER_LIST_SET_ENTRY(_pL, _pB)    \
+{                \
+    BufferList *_pT = _pL;    \
+    while(_pT && _pT->pBufHdr){    \
+        _pT = _pT->pNextBuf;    \
+    }                \
+    if(_pT)            \
+        _pT->pBufHdr = _pB;    \
+}
+
+#define BUFFERLIST_CLEAR_ENTRY(_pL, _pB)\
+    _pB = _pL->pBufHdr;        \
+    _pL->pBufHdr = NULL;    \
+    _pL = _pL->pNextBuf;
+
+typedef struct _BufferList BufferList;
+
+struct _BufferList
+{
+	OMX_BUFFERHEADERTYPE *pBufHdr;
+	OMX_BUFFERHEADERTYPE *pOrigBufHdr;
+	BufferList *pNextBuf;
+};
+
+typedef struct SampleCompTestCtxt
+{
+	OMX_HANDLETYPE hComp;
+	OMX_STATETYPE eState;
+	OMX_U32 nPorts;
+	OMX_HANDLETYPE hStateSetEvent;
+	OMX_HANDLETYPE hPortDisableEvent;
+	OMX_HANDLETYPE hPortEnableEvent;
+	OMX_STRING inFilePath;
+	OMX_STRING outFilePath;
+	FILE *pOutputFile;
+	FILE *pInputfile;
+	OMX_BOOL bEOS;
+	BufferList *pInBufferList;
+	BufferList *pOutBufferList;
+	OMX_BOOL bClientAllocBuf;
+	OMX_U32 nBufDoneCalls;
+	OMX_PORT_PARAM_TYPE sPortParam[NUM_DOMAINS];
+} SampleCompTestCtxt;
+
+//this test compiles only for ducati SYS
+typedef struct TestCtxt
+{
+	OMX_HANDLETYPE hComp;
+	OMX_STATETYPE eState;
+	OMX_U32 nPorts;
+	OMX_HANDLETYPE hStateSetEvent;
+	OMX_HANDLETYPE hPortDisableEvent;
+	OMX_HANDLETYPE hPortEnableEvent;
+	OMX_STRING inFilePath;
+	OMX_STRING outFilePath;
+	FILE *pOutputFile;
+	FILE *pInputfile;
+	OMX_BOOL bEOS;
+	BufferList *pInBufferList;
+	BufferList *pOutBufferList;
+	OMX_BOOL bClientAllocBuf;
+	OMX_U32 nBufDoneCalls;
+	//OMX_PORT_PARAM_TYPE sPortParam[NUM_DOMAINS];
+} TestCtxt;
+
+
+static OMX_U32 nInBufCount = 0;
+static OMX_U32 nOutBufCount = 0;
+
+
+//Semaphore_Handle EBDSem;
+//Semaphore_Params EBDsemParams;
+
+//Semaphore_Handle FBDSem;
+//Semaphore_Params FBDsemParams;
+/*========================================================*/
+/* @ fn OMX_TEST_ErrorToString :: ERROR  to  STRING   */
+/*========================================================*/
+OMX_STRING OMX_TEST_ErrorToString(OMX_ERRORTYPE eError)
+{
+
+	OMX_STRING errorString;
+
+	switch (eError)
+	{
+
+	case OMX_ErrorNone:
+		errorString = "ErrorNone";
+		break;
+	case OMX_ErrorInsufficientResources:
+		errorString = "ErrorInsufficientResources";
+		break;
+	case OMX_ErrorUndefined:
+		errorString = "ErrorUndefined";
+		break;
+	case OMX_ErrorInvalidComponentName:
+		errorString = "ErrorInvalidComponentName";
+		break;
+	case OMX_ErrorComponentNotFound:
+		errorString = "ErrorComponentNotFound";
+		break;
+	case OMX_ErrorInvalidComponent:
+		errorString = "ErrorInvalidComponent";
+		break;
+	case OMX_ErrorBadParameter:
+		errorString = "ErrorBadParameter";
+		break;
+	case OMX_ErrorNotImplemented:
+		errorString = "ErrorNotImplemented";
+		break;
+	case OMX_ErrorUnderflow:
+		errorString = "ErrorUnderflow";
+		break;
+	case OMX_ErrorOverflow:
+		errorString = "ErrorOverflow";
+		break;
+	case OMX_ErrorHardware:
+		errorString = "ErrorHardware";
+		break;
+	case OMX_ErrorInvalidState:
+		errorString = "ErrorInvalidState";
+		break;
+	case OMX_ErrorStreamCorrupt:
+		errorString = "ErrorStreamCorrupt";
+		break;
+	case OMX_ErrorPortsNotCompatible:
+		errorString = "ErrorPortsNotCompatible";
+		break;
+	case OMX_ErrorResourcesLost:
+		errorString = "ErrorResourcesLost";
+		break;
+	case OMX_ErrorNoMore:
+		errorString = "ErrorNoMore";
+		break;
+	case OMX_ErrorVersionMismatch:
+		errorString = "ErrorVersionMismatch";
+		break;
+	case OMX_ErrorNotReady:
+		errorString = "ErrorNotReady";
+		break;
+	case OMX_ErrorTimeout:
+		errorString = "ErrorTimeout";
+		break;
+	case OMX_ErrorSameState:
+		errorString = "ErrorSameState";
+		break;
+	case OMX_ErrorResourcesPreempted:
+		errorString = "ErrorResourcesPreempted";
+		break;
+	case OMX_ErrorPortUnresponsiveDuringAllocation:
+		errorString = "ErrorPortUnresponsiveDuringAllocation";
+		break;
+	case OMX_ErrorPortUnresponsiveDuringDeallocation:
+		errorString = "ErrorPortUnresponsiveDuringDeallocation";
+		break;
+	case OMX_ErrorPortUnresponsiveDuringStop:
+		errorString = "ErrorPortUnresponsiveDuringStop";
+		break;
+	case OMX_ErrorIncorrectStateTransition:
+		errorString = "ErrorIncorrectStateTransition";
+		break;
+	case OMX_ErrorIncorrectStateOperation:
+		errorString = "ErrorIncorrectStateOperation";
+		break;
+	case OMX_ErrorUnsupportedSetting:
+		errorString = "ErrorUnsupportedSetting";
+		break;
+	case OMX_ErrorUnsupportedIndex:
+		errorString = "ErrorUnsupportedIndex";
+		break;
+	case OMX_ErrorBadPortIndex:
+		errorString = "ErrorBadPortIndex";
+		break;
+	case OMX_ErrorPortUnpopulated:
+		errorString = "ErrorPortUnpopulated";
+		break;
+	case OMX_ErrorComponentSuspended:
+		errorString = "ErrorComponentSuspended";
+		break;
+	case OMX_ErrorDynamicResourcesUnavailable:
+		errorString = "ErrorDynamicResourcesUnavailable";
+		break;
+	case OMX_ErrorMbErrorsInFrame:
+		errorString = "ErrorMbErrorsInFrame";
+		break;
+	case OMX_ErrorFormatNotDetected:
+		errorString = "ErrorFormatNotDetected";
+		break;
+	case OMX_ErrorContentPipeOpenFailed:
+		errorString = "ErrorContentPipeOpenFailed";
+		break;
+	case OMX_ErrorContentPipeCreationFailed:
+		errorString = "ErrorContentPipeCreationFailed";
+		break;
+	case OMX_ErrorSeperateTablesUsed:
+		errorString = "ErrorSeperateTablesUsed";
+		break;
+	case OMX_ErrorTunnelingUnsupported:
+		errorString = "ErrorTunnelingUnsupported";
+		break;
+	default:
+		errorString = "<unknown>";
+		break;
+	}
+	return errorString;
+}
+
+/*========================================================*/
+/* @ fn OMX_TEST_StateToString :: STATE  to  STRING   */
+/*========================================================*/
+OMX_STRING OMX_TEST_StateToString(OMX_STATETYPE eState)
+{
+	OMX_STRING StateString;
+
+	switch (eState)
+	{
+	case OMX_StateInvalid:
+		StateString = "Invalid";
+		break;
+	case OMX_StateLoaded:
+		StateString = "Loaded";
+		break;
+	case OMX_StateIdle:
+		StateString = "Idle";
+		break;
+	case OMX_StateExecuting:
+		StateString = "Executing";
+		break;
+	case OMX_StatePause:
+		StateString = "Pause";
+		break;
+	case OMX_StateWaitForResources:
+		StateString = "WaitForResources ";
+		break;
+	default:
+		StateString = "<unknown>";
+		break;
+	}
+
+	return StateString;
+}
+
+/* Application callback Functions */
+/*========================================================*/
+/* @ fn SampleTest_EventHandler :: Application callback   */
+/*========================================================*/
+OMX_ERRORTYPE SampleTest_EventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_PTR pAppData,
+    OMX_IN OMX_EVENTTYPE eEvent,
+    OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2, OMX_IN OMX_PTR pEventData)
+{
+	SampleCompTestCtxt *pContext;
+
+	printf("\n___________ ENTERED CLIENT CALLBACK:%s", __FUNCTION__);
+
+	if (pAppData == NULL)
+		return OMX_ErrorNone;
+
+	pContext = (SampleCompTestCtxt *) pAppData;
+
+	switch (eEvent)
+	{
+	case OMX_EventCmdComplete:
+		printf("\n OMX_EventCmdComplete case: \n");
+		if (OMX_CommandStateSet == nData1)
+		{
+			printf(" Component Transitioned to %s state \n",
+			    OMX_TEST_StateToString((OMX_STATETYPE) nData2));
+			pContext->eState = (OMX_STATETYPE) nData2;
+			TIMM_OSAL_SemaphoreRelease(pContext->hStateSetEvent);
+		} else if (OMX_CommandFlush == nData1)
+		{
+			/* Nothing to do over here */
+		} else if (OMX_CommandPortDisable == nData1)
+		{
+			/* Nothing to do over here */
+			TIMM_OSAL_SemaphoreRelease(pContext->
+			    hPortDisableEvent);
+		} else if (OMX_CommandPortEnable == nData1)
+		{
+			/* Nothing to do over here */
+		} else if (OMX_CommandMarkBuffer == nData1)
+		{
+			/* Nothing to do over here */
+		}
+		break;
+
+	case OMX_EventError:
+		printf("\nOMX EVENT ERROR!!!!!! \n");
+		break;
+
+	case OMX_EventMark:
+		break;
+
+	case OMX_EventPortSettingsChanged:
+		break;
+
+	case OMX_EventBufferFlag:
+		break;
+
+	case OMX_EventResourcesAcquired:
+		break;
+
+	case OMX_EventComponentResumed:
+		break;
+
+	case OMX_EventDynamicResourcesAvailable:
+		break;
+
+	case OMX_EventPortFormatDetected:
+		break;
+
+	default:
+		break;
+	}
+
+	goto OMX_TEST_BAIL;
+      OMX_TEST_BAIL:
+	return OMX_ErrorNone;
+}
+
+/*========================================================*/
+/* @ fn SampleTest_EmptyBufferDone :: Application callback    */
+/*========================================================*/
+OMX_ERRORTYPE SampleTest_EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_PTR pAppData, OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)
+{
+	SampleCompTestCtxt *pContext;
+
+	printf("\n___________ ENTERED CLIENT CALLBACK:%s", __FUNCTION__);
+
+	if (pAppData == NULL)
+		return OMX_ErrorNone;
+
+	pContext = (SampleCompTestCtxt *) pAppData;
+	pContext->nBufDoneCalls++;
+
+	BUFFER_LIST_SET_ENTRY(pContext->pInBufferList, pBuffer);
+	//Semaphore_post(EBDSem);
+
+	goto OMX_TEST_BAIL;
+      OMX_TEST_BAIL:
+	printf("\nEBD done\n");
+	return OMX_ErrorNone;
+}
+
+/*========================================================*/
+/* @ fn SampleTest_FillBufferDone ::   Application callback  */
+/*========================================================*/
+OMX_ERRORTYPE SampleTest_FillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_PTR pAppData, OMX_IN OMX_BUFFERHEADERTYPE * pBuffHeader)
+{
+	SampleCompTestCtxt *pContext;
+
+	printf("\n___________ ENTERED CLIENT CALLBACK:%s", __FUNCTION__);
+
+	if (pAppData == NULL)
+		return OMX_ErrorNone;
+
+	pContext = (SampleCompTestCtxt *) pAppData;
+	pContext->nBufDoneCalls++;
+
+	if (pContext->pOutputFile && gTest)
+	{
+		printf(" writing to output file :: buffer cnt : %d\n",
+		    nOutBufCount);
+		nOutBufCount++;
+		fwrite(pBuffHeader->pBuffer, 1, pBuffHeader->nFilledLen,
+		    pContext->pOutputFile);
+	}
+
+	BUFFER_LIST_SET_ENTRY(pContext->pOutBufferList, pBuffHeader);
+	//Semaphore_post(FBDSem);
+
+	goto OMX_TEST_BAIL;
+      OMX_TEST_BAIL:
+	printf("\nFBD done\n");
+	return OMX_ErrorNone;
+}
+
+
+static void SampleTest_ReadInputFile(SampleCompTestCtxt * pContext,
+    OMX_PTR pData, OMX_U32 nBytes, FILE * fp)
+{
+	OMX_U32 nReadSize = 0;
+
+	printf("\nIn read i/p file\n");
+	if (pData == NULL)
+		printf("\npData is NULL\n");
+	else
+		printf("\npData = %x\n", pData);
+	printf("\nnBytes = %d\n", nBytes);
+	if (fp == NULL)
+		printf("\nfp is NULL\n");
+	else
+		printf("\nfp = %x\n", fp);
+	nReadSize = fread(pData, 1, nBytes, fp);
+	if (nReadSize != nBytes)
+	{
+		pContext->bEOS = OMX_TRUE;
+	}
+
+	printf(" Reading from file :: Buffer cont : %d \n", nInBufCount);
+	nInBufCount++;
+}
+
+/*========================================================*/
+/* @ fn SampleTest_WriteInBuffers ::   Reads a buffer from a file and send to Comp       */
+/*========================================================*/
+OMX_ERRORTYPE SampleTest_WriteInBuffers(SampleCompTestCtxt * pContext)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	BufferList *pList;
+	OMX_BUFFERHEADERTYPE *pBufHeader;
+#ifdef OMX_SAMPLE_TILER_TEST
+	OMX_U8 *pTmpBuffer = NULL, *pOrigTmpBuffer = NULL;
+#endif
+	pList = pContext->pInBufferList;
+	while (pList && pList->pBufHdr)
+	{
+		BUFFERLIST_CLEAR_ENTRY(pList, pBufHeader);
+		printf("\nAbout to read from input file\n");
+#if defined(OMX_SAMPLE_TILER_TEST)
+
+		//OMX_SAMPLE_BUFFER_SIZE is the total amt of data to be sent in the buffer
+		pTmpBuffer =
+		    TIMM_OSAL_Malloc(OMX_SAMPLE_BUFFER_SIZE, 0, 0, 0);
+		if (pTmpBuffer == NULL)
+			OMX_TEST_SET_ERROR_BAIL
+			    (OMX_ErrorInsufficientResources,
+			    "malloc failed \n");
+		pOrigTmpBuffer = pTmpBuffer;
+
+		SampleTest_ReadInputFile(pContext, pTmpBuffer,
+		    OMX_SAMPLE_BUFFER_SIZE, pContext->pInputfile);
+
+		Test_Util_Memcpy_1Dto2D(pBufHeader->pBuffer, pTmpBuffer,
+		    OMX_SAMPLE_BUFFER_SIZE, OMX_SAMPLE_IN_HEIGHT,
+		    OMX_SAMPLE_IN_WIDTH, STRIDE_LINUX);
+		pBufHeader->nFilledLen = OMX_SAMPLE_BUFFER_SIZE;
+
+		printf("\nBefore ETB pBufHeader->nInputPortIndex = %d\n",
+		    pBufHeader->nInputPortIndex);
+
+		TIMM_OSAL_Free(pOrigTmpBuffer);
+
+#else
+		SampleTest_ReadInputFile(pContext, pBufHeader->pBuffer,
+		    pBufHeader->nAllocLen, pContext->pInputfile);
+		pBufHeader->nFilledLen = pBufHeader->nAllocLen;
+
+#endif
+		if (pContext->bEOS == OMX_TRUE)
+		{
+			pBufHeader->nFlags |= OMX_BUFFERFLAG_EOS;
+		}
+
+		eError = OMX_EmptyThisBuffer(pContext->hComp, pBufHeader);
+
+		OMX_TEST_BAIL_IF_ERROR(eError);
+	}
+
+      OMX_TEST_BAIL:
+	return eError;
+
+}
+
+/*========================================================*/
+/* @ fn SampleTest_ReadOutBuffers ::   Send out buffers    */
+/*========================================================*/
+
+OMX_ERRORTYPE SampleTest_ReadOutBuffers(SampleCompTestCtxt * pContext)
+{
+
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	BufferList *pList;
+	OMX_BUFFERHEADERTYPE *pBufHeader;
+
+	pList = pContext->pOutBufferList;
+	while (pList && pList->pBufHdr)
+	{
+		printf("\nAbout to do FTB\n");
+
+		BUFFERLIST_CLEAR_ENTRY(pList, pBufHeader);
+
+		eError = OMX_FillThisBuffer(pContext->hComp, pBufHeader);
+
+		OMX_TEST_BAIL_IF_ERROR(eError);
+		if (pBufHeader->nFlags == OMX_BUFFERFLAG_EOS)
+		{
+			pContext->nBufDoneCalls = OMX_TEST_BUFFERS_OF_TRAFFIC;
+		}
+	}
+
+      OMX_TEST_BAIL:
+	return eError;
+
+}
+
+
+
+/*========================================================*/
+/* @ fn SampleTest_AllocateBuffers ::   Allocates the Resources on the available ports  */
+/*========================================================*/
+OMX_ERRORTYPE SampleTest_AllocateBuffers(SampleCompTestCtxt * pContext,
+    OMX_PARAM_PORTDEFINITIONTYPE * pPortDef)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_U8 *pBuffer = NULL;
+	BufferList *pBufferList;
+	BufferList *pTemp;
+	OMX_BUFFERHEADERTYPE *pBufferHdr;
+	OMX_U32 i = 100;
+	OMX_COMPONENTTYPE *pComp;
+
+#ifdef OMX_SAMPLE_TILER_TEST
+	MemAllocBlock *pBlock = NULL;
+	OMX_U32 nNumBlocks = 1;
+
+/*For i/p port allocate 2D packed buffer, for o/p port allocate 1D buffer.
+Ideally client should get this from GetParams but this is just a sample test so
+values are hardcoded*/
+
+	if (pPortDef->nPortIndex == OMX_SAMPLE_INPUT_PORT)
+	{
+		nNumBlocks = 2;
+		pBlock =
+		    TIMM_OSAL_Malloc(sizeof(MemAllocBlock) * nNumBlocks, 0, 0,
+		    0);
+		TIMM_OSAL_Memset(pBlock, 0, sizeof(MemAllocBlock) * nNumBlocks);
+		pBlock[0].dim.area.width = OMX_SAMPLE_IN_2DYWIDTH;
+		pBlock[0].dim.area.height = OMX_SAMPLE_IN_2DYHEIGHT;
+		pBlock[0].pixelFormat = PIXEL_FMT_8BIT;
+		pBlock[1].dim.area.width = OMX_SAMPLE_IN_2DUVWIDTH;
+		pBlock[1].dim.area.height = OMX_SAMPLE_IN_2DUVHEIGHT;
+		pBlock[1].pixelFormat = PIXEL_FMT_16BIT;
+	} else
+	{
+		nNumBlocks = 1;
+		pBlock =
+		    TIMM_OSAL_Malloc(sizeof(MemAllocBlock) * nNumBlocks, 0, 0,
+		    0);
+		TIMM_OSAL_Memset(pBlock, 0, sizeof(MemAllocBlock) * nNumBlocks);
+		pBlock[0].dim.len = OMX_SAMPLE_BUFFER_SIZE;
+		pBlock[0].pixelFormat = PIXEL_FMT_PAGE;
+	}
+#endif
+
+	for (i = 0; i < pPortDef->nBufferCountActual; i++)
+	{
+		pBufferList =
+		    (BufferList *) TIMM_OSAL_Malloc(sizeof(BufferList),
+		    TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
+		if (!pBufferList)
+		{
+			OMX_TEST_SET_ERROR_BAIL
+			    (OMX_ErrorInsufficientResources,
+			    "malloc failed \n");
+		}
+
+		if (pContext->bClientAllocBuf)
+		{
+
+#ifdef OMX_SAMPLE_TILER_TEST
+/*For i/p port allocate 2D packed buffer, for o/p port allocate 1D buffer.
+Ideally client should get this from GetParams but this is just a sample test so
+values are hardcoded*/
+			pBuffer = MemMgr_Alloc(pBlock, nNumBlocks);
+			printf("\nMemMgr allocated buffer = 0x%x\n", pBuffer);
+#else
+			pBuffer =
+			    (OMX_U8 *) TIMM_OSAL_MallocaBuffer(pPortDef->
+			    nBufferSize, pPortDef->bBuffersContiguous,
+			    pPortDef->nBufferAlignment);
+
+#endif
+
+			if (!pBufferList)
+			{
+				OMX_TEST_SET_ERROR_BAIL
+				    (OMX_ErrorInsufficientResources,
+				    "malloc failed \n");
+			}
+
+			printf("\nCalling UseBuf on port %d\n",
+			    pPortDef->nPortIndex);
+			eError =
+			    OMX_UseBuffer(pContext->hComp, &pBufferHdr,
+			    pPortDef->nPortIndex, 0, pPortDef->nBufferSize,
+			    pBuffer);
+
+			OMX_TEST_BAIL_IF_ERROR(eError);
+
+		} else
+		{
+
+			pComp = (OMX_COMPONENTTYPE *) pContext->hComp;
+			printf("\nCalling allocate buffer\n");
+			eError =
+			    OMX_AllocateBuffer(pContext->hComp, &pBufferHdr,
+			    pPortDef->nPortIndex, 0, pPortDef->nBufferSize);
+
+			OMX_TEST_BAIL_IF_ERROR(eError);
+		}
+		printf("\npBufferHdr->nOutputPortIndex = %d\n",
+		    pBufferHdr->nOutputPortIndex);
+		printf("\npBufferHdr->nInputPortIndex = %d\n",
+		    pBufferHdr->nInputPortIndex);
+		pBufferList->pNextBuf = NULL;
+		pBufferList->pBufHdr = pBufferHdr;
+		pBufferList->pOrigBufHdr = pBufferHdr;
+
+		if (pPortDef->eDir == OMX_DirInput)
+		{
+			printf("\npBufferHdr->nOutputPortIndex = %d\n",
+			    pBufferHdr->nOutputPortIndex);
+			printf("\npBufferHdr->nInputPortIndex = %d\n",
+			    pBufferHdr->nInputPortIndex);
+			pBufferHdr->nOutputPortIndex = OMX_NOPORT;
+			if (pContext->pInBufferList == NULL)
+			{
+				pContext->pInBufferList = pBufferList;
+			} else
+			{
+				pTemp = pContext->pInBufferList;
+				while (pTemp->pNextBuf)
+					pTemp = pTemp->pNextBuf;
+				pTemp->pNextBuf = pBufferList;
+			}
+		} else
+		{
+			pBufferHdr->nInputPortIndex = OMX_NOPORT;
+			printf("\npBufferHdr->nOutputPortIndex = %d\n",
+			    pBufferHdr->nOutputPortIndex);
+			printf("\npBufferHdr->nInputPortIndex = %d\n",
+			    pBufferHdr->nInputPortIndex);
+			if (pContext->pOutBufferList == NULL)
+			{
+				pContext->pOutBufferList = pBufferList;
+			} else
+			{
+				pTemp = pContext->pOutBufferList;
+				while (pTemp->pNextBuf)
+					pTemp = pTemp->pNextBuf;
+				pTemp->pNextBuf = pBufferList;
+			}
+		}
+	}
+
+      OMX_TEST_BAIL:
+#ifdef OMX_SAMPLE_TILER_TEST
+	if (pBlock != NULL)
+		TIMM_OSAL_Free(pBlock);
+#endif
+	if (eError != OMX_ErrorNone)
+	{
+		if (pBufferList)
+		{
+			TIMM_OSAL_Free(pBufferList);
+		}
+	}
+
+	return eError;
+}
+
+/*========================================================*/
+/* @ fn SampleTest_DeInitBuffers ::   Destroy the resources  */
+/*========================================================*/
+OMX_ERRORTYPE SampleTest_DeInitBuffers(SampleCompTestCtxt * pContext)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_U8 *pBuffer;
+	BufferList *pBufferList;
+	BufferList *pTemp;
+
+	OMX_U32 nRetVal = 0;
+
+	pTemp = pContext->pInBufferList;
+
+	while (pTemp)
+	{
+		pBufferList = (BufferList *) pTemp;
+		pBuffer = (OMX_U8 *) pTemp->pOrigBufHdr->pBuffer;
+
+		printf("\nCalling Free Buffer on port no. %d\n",
+		    pTemp->pOrigBufHdr->nInputPortIndex);
+
+		eError =
+		    OMX_FreeBuffer(pContext->hComp,
+		    pTemp->pOrigBufHdr->nInputPortIndex, pTemp->pOrigBufHdr);
+		OMX_TEST_BAIL_IF_ERROR(eError);
+
+                if (pContext->bClientAllocBuf)
+                {
+
+#ifdef OMX_SAMPLE_TILER_TEST
+                        nRetVal = MemMgr_Free(pBuffer);
+                        if (nRetVal)
+                        {
+                                printf("\nError in MemMgr free\n");
+                        }
+#else
+                        TIMM_OSAL_Free(pBuffer);
+#endif
+                }
+
+		pTemp = pTemp->pNextBuf;
+		if (pBufferList)
+			TIMM_OSAL_Free(pBufferList);
+	}
+
+	pContext->pInBufferList = NULL;
+
+	pTemp = pContext->pOutBufferList;
+	while (pTemp)
+	{
+		pBufferList = (BufferList *) pTemp;
+		pBuffer = (OMX_U8 *) pTemp->pOrigBufHdr->pBuffer;
+		printf("\nCalling Free Buffer on port no. %d\n",
+		    pTemp->pOrigBufHdr->nOutputPortIndex);
+
+		eError =
+		    OMX_FreeBuffer(pContext->hComp,
+		    pTemp->pOrigBufHdr->nOutputPortIndex, pTemp->pOrigBufHdr);
+		OMX_TEST_BAIL_IF_ERROR(eError);
+                if (pContext->bClientAllocBuf)
+                {
+#ifdef OMX_SAMPLE_TILER_TEST
+                        nRetVal = MemMgr_Free(pBuffer);
+                        if (nRetVal)
+                        {
+                                printf("\nError in MemMgr free\n");
+                        }
+#else
+                        TIMM_OSAL_Free(pBuffer);
+#endif
+                }
+
+		pTemp = pTemp->pNextBuf;
+		if (pBufferList)
+			TIMM_OSAL_Free(pBufferList);
+
+	}
+
+	pContext->pOutBufferList = NULL;
+
+      OMX_TEST_BAIL:
+	return eError;
+}
+
+/*========================================================*/
+/* @ fn SampleTest_TransitionWait ::   Waits for the transition to be completed ,
+ *  incase of loaded to idle Allocates the Resources and while idle to loaded
+ *  destroys the resources */
+/*========================================================*/
+OMX_ERRORTYPE SampleTest_TransitionWait(OMX_STATETYPE eToState,
+    SampleCompTestCtxt * pContext)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_PARAM_PORTDEFINITIONTYPE tPortDef;
+	OMX_U32 i, j;
+
+	eError = OMX_SendCommand(pContext->hComp, OMX_CommandStateSet,
+	    eToState, NULL);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+
+	if ((eToState == OMX_StateIdle) &&
+	    (pContext->eState == OMX_StateLoaded))
+	{
+		for (i = 0; i < NUM_DOMAINS; i++)
+		{
+			for (j = pContext->sPortParam[i].nStartPortNumber;
+			    j < pContext->sPortParam[i].nStartPortNumber
+			    + pContext->sPortParam[i].nPorts; j++)
+			{
+
+				OMX_TEST_INIT_STRUCT(tPortDef,
+				    OMX_PARAM_PORTDEFINITIONTYPE);
+				tPortDef.nPortIndex = j;
+//printf("\nCalling GetParam before UseBuf on port %d\n",j);
+				eError = OMX_GetParameter(pContext->hComp,
+				    OMX_IndexParamPortDefinition,
+				    (OMX_PTR) & tPortDef);
+				OMX_TEST_BAIL_IF_ERROR(eError);
+
+//                    if(tPortDef.bEnabled)//AD
+				eError =
+				    SampleTest_AllocateBuffers(pContext,
+				    &tPortDef);
+
+				OMX_TEST_BAIL_IF_ERROR(eError);
+			}
+		}
+	} else if ((eToState == OMX_StateLoaded) &&
+	    (pContext->eState == OMX_StateIdle))
+	{
+
+		eError = SampleTest_DeInitBuffers(pContext);
+		OMX_TEST_BAIL_IF_ERROR(eError);
+
+	}
+	printf("\nWaiting for state set event\n");
+	TIMM_OSAL_SemaphoreObtain(pContext->hStateSetEvent,
+	    TIMM_OSAL_SUSPEND);
+	printf("\nState set event recd.\n");
+
+	if (pContext->eState != eToState)
+		OMX_TEST_SET_ERROR_BAIL(OMX_ErrorUndefined,
+		    " InComplete Transition \n");
+
+      OMX_TEST_BAIL:
+	return eError;
+}
+
+
+/*========================================================*/
+/* @ fn OMX_Sample_UT0001 ::  Initializes, move to Idle and then to executing, process
+*    buffers and then destroy the component by moving back to idle, loaded, invalid */
+/*========================================================*/
+void main(void)
+{
+	OMX_ERRORTYPE eError = OMX_ErrorNone;
+	OMX_HANDLETYPE hComp = NULL;
+	OMX_CALLBACKTYPE oCallbacks;
+	SampleCompTestCtxt *pContext;
+	SampleCompTestCtxt oAppData;
+
+	int ch1, ch2;
+	int pass;
+	int while_pass = 0, loc_diff = 0;
+
+
+	pContext = &oAppData;
+	printf(" Entering : %s \n", __FUNCTION__);
+	memset(pContext, 0x0, sizeof(SampleCompTestCtxt));
+
+	oCallbacks.EventHandler = SampleTest_EventHandler;
+	oCallbacks.EmptyBufferDone = SampleTest_EmptyBufferDone;
+	oCallbacks.FillBufferDone = SampleTest_FillBufferDone;
+	printf("\nCalling sem create\n");
+	/* Initialize Events to Track callbacks  */
+	TIMM_OSAL_SemaphoreCreate(&pContext->hStateSetEvent, 0);
+	TIMM_OSAL_SemaphoreCreate(&pContext->hPortDisableEvent, 0);
+	//TIMM_OSAL_MutexObtain(pContext->hStateSetEvent, TIMM_OSAL_SUSPEND);
+	printf("\nSem created\n");
+
+
+	pContext->pInputfile = fopen(INPUT_FILE, "rb");
+	if (NULL == pContext->pInputfile)
+	{
+		eError = OMX_ErrorInsufficientResources;
+		//goto OMX_TEST_BAIL;
+	}
+	printf("\nInput file opened\n");
+	pContext->pOutputFile = fopen(NON_TUN_OUTPUT_FILE, "wb");
+	if (NULL == pContext->pOutputFile)
+	{
+		eError = OMX_ErrorInsufficientResources;
+		//goto OMX_TEST_BAIL;
+	}
+
+
+	/* Initialize OpenMAX */
+	printf("\nInitialize OpenMAX\n");
+	eError = OMX_Init();
+	OMX_TEST_BAIL_IF_ERROR(eError);
+	/* Load a component  */
+	printf("\nLoad a component\n");
+	eError =
+	    OMX_GetHandle(&hComp, (OMX_STRING) "OMX.TI.DUCATI1.MISC.SAMPLE",
+	    pContext, &oCallbacks);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+	pContext->hComp = hComp;
+printf ("\neError = 0x%x\n", eError);
+if(hComp)
+	printf("\nhComp = 0x%x\n", hComp);
+	/* Verify that the component is in Loaded state */
+	printf("\nVerify that the component is in Loaded state\n");
+
+	eError = OMX_GetState(pContext->hComp, &pContext->eState);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+	if (OMX_StateLoaded != pContext->eState)
+	{
+		OMX_TEST_SET_ERROR_BAIL(OMX_ErrorUndefined,
+		    "not in loaded state \n");
+	}
+
+	/* detect all Audio ports on the component */
+	OMX_TEST_INIT_STRUCT(pContext->sPortParam[0], OMX_PORT_PARAM_TYPE);
+	eError = OMX_GetParameter(hComp, OMX_IndexParamAudioInit,
+	    (OMX_PTR) & pContext->sPortParam[0]);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+
+	/* detect all video ports on the component */
+	OMX_TEST_INIT_STRUCT(pContext->sPortParam[1], OMX_PORT_PARAM_TYPE);
+	eError = OMX_GetParameter(hComp, OMX_IndexParamVideoInit,
+	    (OMX_PTR) & pContext->sPortParam[1]);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+
+	/* detect all image ports on the component */
+	OMX_TEST_INIT_STRUCT(pContext->sPortParam[2], OMX_PORT_PARAM_TYPE);
+	eError = OMX_GetParameter(hComp, OMX_IndexParamImageInit,
+	    (OMX_PTR) & pContext->sPortParam[2]);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+
+	/* detect all other ports on the component */
+	OMX_TEST_INIT_STRUCT(pContext->sPortParam[3], OMX_PORT_PARAM_TYPE);
+	eError = OMX_GetParameter(hComp, OMX_IndexParamOtherInit,
+	    (OMX_PTR) & pContext->sPortParam[3]);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+
+	pContext->nPorts = pContext->sPortParam[0].nPorts +
+	    pContext->sPortParam[1].nPorts +
+	    pContext->sPortParam[2].nPorts + pContext->sPortParam[3].nPorts;
+
+
+	pContext->bClientAllocBuf = OMX_SAMPLE_USEBUF;
+	if (pContext->bClientAllocBuf == OMX_TRUE)
+	{
+		printf(" Client does Allocation of buffers \n");
+	} else
+	{
+		printf(" Component does Allocation of buffers \n");
+	}
+
+	/* Transition to Idle state */
+
+	eError = SampleTest_TransitionWait(OMX_StateIdle, pContext);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+	/* Transition to Executing state */
+	eError = SampleTest_TransitionWait(OMX_StateExecuting, pContext);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+	printf("\nAbout to start processing buffers\n");
+
+
+	/*  process buffers   */
+
+	while (pContext->nBufDoneCalls < OMX_TEST_BUFFERS_OF_TRAFFIC)
+	{
+
+		eError = SampleTest_WriteInBuffers(pContext);
+		OMX_TEST_BAIL_IF_ERROR(eError);
+
+		eError = SampleTest_ReadOutBuffers(pContext);
+		OMX_TEST_BAIL_IF_ERROR(eError);
+		while_pass++;
+		//printf("\n WHILE PROCESS LOOP COUNT:  BufDoneCount = %d %d",
+		//    while_pass, pContext->nBufDoneCalls);
+
+		//printf("\n Waiting on Sample component to respond");
+
+	}
+
+
+	gTest = 0;
+
+	/* Transition back to Idle state  */
+	eError = SampleTest_TransitionWait(OMX_StateIdle, pContext);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+
+	/* Trasnition back to Loaded state */
+	eError = SampleTest_TransitionWait(OMX_StateLoaded, pContext);
+	OMX_TEST_BAIL_IF_ERROR(eError);
+
+
+      OMX_TEST_BAIL:
+
+	fclose(pContext->pInputfile);
+	fclose(pContext->pOutputFile);
+
+	if (eError == OMX_ErrorNone)
+	{
+		eError = OMX_FreeHandle(pContext->hComp);
+		eError = OMX_Deinit();
+	} else
+	{
+		SampleTest_TransitionWait(OMX_StateInvalid, pContext);
+		SampleTest_DeInitBuffers(pContext);
+
+		OMX_FreeHandle(pContext->hComp);
+		OMX_Deinit();
+	}
+
+	TIMM_OSAL_SemaphoreDelete(pContext->hStateSetEvent);
+	TIMM_OSAL_SemaphoreDelete(pContext->hPortDisableEvent);
+
+	/* emit the Test Result */
+	if (OMX_ErrorNone != eError)
+	{
+		printf(" TestCase Failed and returned an error:: %s \n",
+		    OMX_TEST_ErrorToString(eError));
+	} else
+	{
+		printf
+		    ("\nTest case has ended, now comparing input and output files\n");
+		pContext->pInputfile = fopen(INPUT_FILE, "rb");
+		if (NULL == pContext->pInputfile)
+		{
+			printf("\n Error in opening INPUT_FILE");
+			eError = OMX_ErrorInsufficientResources;
+		}
+
+		pContext->pOutputFile = fopen(NON_TUN_OUTPUT_FILE, "rb");
+		if (NULL == pContext->pOutputFile)
+		{
+			printf("\n Error in opening NON_TUN_OUTPUT_FILE");
+			eError = OMX_ErrorInsufficientResources;
+		}
+		pass = 1;
+		while (1)
+		{
+			if (eError != OMX_ErrorNone)
+			{
+				pass = 0;
+				break;
+			}
+			ch1 = fgetc(pContext->pInputfile);
+			ch2 = fgetc(pContext->pOutputFile);
+			loc_diff++;
+			if (ch1 == EOF || ch2 == EOF)
+			{
+				break;
+			}
+			if (ch1 != ch2)
+			{
+				pass = 0;
+				printf("\n \n");
+				printf
+				    ("\n FILE SIZE = 320 KB - NUMBER OF ITERATIONS = 20 (10 for INPUT AND 10 FOR OUTPUT buffers\n");
+				printf
+				    ("\n ################### LOCATION OF DIFFERENCE: %d ################### \n",
+				    loc_diff);
+				break;
+			}
+		}
+		fclose(pContext->pInputfile);
+		fclose(pContext->pOutputFile);
+		if (pass == 1)
+			printf(" Test Case has Passed\n");
+		else
+		{
+			printf("\nTest case has failed. (EOF not reached)\n");
+			eError = OMX_ErrorUndefined;
+		}
+	}
+
+	if (eError == OMX_ErrorNone)
+	{
+		printf(" Test Case has Passed :) \n");
+	} else
+	{
+		printf("\nTest case has failed.(OMX Error)\n");
+	}
+}
+
diff --git a/heaptracked-executable.mk b/heaptracked-executable.mk
new file mode 100644
index 0000000..f09f7cf
--- /dev/null
+++ b/heaptracked-executable.mk
@@ -0,0 +1,7 @@
+LOCAL_SRC_FILES += $(OMAP4_DEBUG_SRC)
+LOCAL_SHARED_LIBRARIES += $(OMAP4_DEBUG_SHARED_LIBRARIES)
+LOCAL_STATIC_LIBRARIES:= libheaptracker
+LOCAL_CFLAGS += $(OMAP4_DEBUG_CFLAGS)
+LOCAL_LDFLAGS += $(OMAP4_DEBUG_LDFLAGS)
+
+include $(BUILD_EXECUTABLE)
diff --git a/heaptracked-shared-library.mk b/heaptracked-shared-library.mk
new file mode 100644
index 0000000..7fddc10
--- /dev/null
+++ b/heaptracked-shared-library.mk
@@ -0,0 +1,7 @@
+LOCAL_SRC_FILES += $(OMAP4_DEBUG_SRC)
+LOCAL_SHARED_LIBRARIES += $(OMAP4_DEBUG_SHARED_LIBRARIES)
+LOCAL_WHOLE_STATIC_LIBRARIES:= libheaptracker
+LOCAL_CFLAGS += $(OMAP4_DEBUG_CFLAGS)
+LOCAL_LDFLAGS += $(OMAP4_DEBUG_LDFLAGS)
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/heaptracker.c b/heaptracker.c
new file mode 100644
index 0000000..6f2dcfe
--- /dev/null
+++ b/heaptracker.c
@@ -0,0 +1,576 @@
+/*
+**
+** Copyright (C) 2008-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.
+*/
+
+#include <android/log.h>
+#include <pthread.h>
+#include <time.h>
+#include <stdarg.h>
+
+#include "mapinfo.h"
+
+extern int heaptracker_stacktrace(intptr_t*, size_t);
+extern void *__real_malloc(size_t size);
+extern void *__real_realloc(void *ptr, size_t size);
+extern void *__real_calloc(int nmemb, int size);
+extern void __real_free(void *ptr);
+
+static mapinfo *milist;
+
+#define MAX_BACKTRACE_DEPTH 15
+#define ALLOCATION_TAG      0x1ee7d00d
+#define BACKLOG_TAG         0xbabecafe
+#define FREE_POISON         0xa5
+#define BACKLOG_MAX         50
+#define FRONT_GUARD         0xaa
+#define FRONT_GUARD_LEN     (1<<4)
+#define REAR_GUARD          0xbb
+#define REAR_GUARD_LEN      (1<<4)
+#define SCANNER_SLEEP_S     3
+
+struct hdr {
+    uint32_t tag;
+    struct hdr *prev;
+    struct hdr *next;
+    intptr_t bt[MAX_BACKTRACE_DEPTH];
+    int bt_depth;
+    intptr_t freed_bt[MAX_BACKTRACE_DEPTH];
+    int freed_bt_depth;
+    size_t size;
+    char front_guard[FRONT_GUARD_LEN];
+} __attribute__((packed));
+
+struct ftr {
+    char rear_guard[REAR_GUARD_LEN];
+} __attribute__((packed));
+
+static inline struct ftr * to_ftr(struct hdr *hdr)
+{
+    return (struct ftr *)(((char *)(hdr + 1)) + hdr->size);
+}
+
+static inline void *user(struct hdr *hdr)
+{
+    return hdr + 1;
+}
+
+static inline struct hdr *meta(void *user)
+{
+    return ((struct hdr *)user) - 1;
+}
+
+extern int __android_log_vprint(int prio, const char *tag, const char *fmt, va_list ap);
+static void default_log(const char *fmt, ...)
+{
+    va_list lst;
+    va_start(lst, fmt);
+    __android_log_vprint(ANDROID_LOG_ERROR, "DEBUG", fmt, lst);
+    va_end(lst);
+}
+
+/* Override this for non-printf reporting */
+void (*malloc_log)(const char *fmt, ...) = default_log;
+/* Call this ad dlclose() to get leaked memory */
+void free_leaked_memory(void);
+
+static unsigned num;
+static struct hdr *first;
+static struct hdr *last;
+static pthread_rwlock_t lock = PTHREAD_RWLOCK_INITIALIZER;
+
+static unsigned backlog_num;
+static struct hdr *backlog_first;
+static struct hdr *backlog_last;
+static pthread_rwlock_t backlog_lock = PTHREAD_RWLOCK_INITIALIZER;
+
+static void print_backtrace(const intptr_t *bt, int depth)
+{
+    mapinfo *mi;
+    int cnt, rel_pc;
+    malloc_log("*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
+    for (cnt = 0; cnt < depth && cnt < MAX_BACKTRACE_DEPTH; cnt++) {
+        mi = pc_to_mapinfo(milist, bt[cnt], &rel_pc);
+        malloc_log("\t#%02d  pc %08x  %s\n", cnt,
+                   mi ? rel_pc : bt[cnt],
+                   mi ? mi->name : "(unknown)");
+    }
+}
+
+static inline void init_front_guard(struct hdr *hdr)
+{
+    memset(hdr->front_guard, FRONT_GUARD, FRONT_GUARD_LEN);
+}
+
+static inline int is_front_guard_valid(struct hdr *hdr)
+{
+    unsigned i;
+    for (i = 0; i < FRONT_GUARD_LEN; i++)
+        if (hdr->front_guard[i] != FRONT_GUARD)
+            return 0;
+    return 1;
+}
+
+static inline void init_rear_guard(struct hdr *hdr)
+{
+    struct ftr *ftr = to_ftr(hdr);
+    memset(ftr->rear_guard, REAR_GUARD, REAR_GUARD_LEN);
+}
+
+static inline int is_rear_guard_valid(struct hdr *hdr)
+{
+    unsigned i;
+    int valid = 1;
+    int first_mismatch = -1;
+    struct ftr *ftr = to_ftr(hdr);
+    for (i = 0; i < REAR_GUARD_LEN; i++) {
+        if (ftr->rear_guard[i] != REAR_GUARD) {
+            if (first_mismatch < 0)
+                first_mismatch = i;
+            valid = 0;
+        }
+        else if (first_mismatch >= 0) {
+            malloc_log("+++ REAR GUARD MISMATCH [%d, %d)\n", first_mismatch, i);
+            first_mismatch = -1;
+        }
+    }
+
+    if (first_mismatch >= 0)
+        malloc_log("+++ REAR GUARD MISMATCH [%d, %d)\n", first_mismatch, i);
+    return valid;
+}
+
+static inline void __add(struct hdr *hdr, struct hdr **first, struct hdr **last)
+{
+    hdr->prev = 0;
+    hdr->next = *last;
+    if (*last)
+        (*last)->prev = hdr;
+    else
+        *first = hdr;
+    *last = hdr;
+}
+
+static inline int __del(struct hdr *hdr, struct hdr **first, struct hdr **last)
+{
+    if (hdr->prev)
+        hdr->prev->next = hdr->next;
+    else
+        *last = hdr->next;
+    if (hdr->next)
+        hdr->next->prev = hdr->prev;
+    else
+        *first = hdr->prev;
+    return 0;
+}
+
+static inline void add(struct hdr *hdr, size_t size)
+{
+    pthread_rwlock_wrlock(&lock);
+    hdr->tag = ALLOCATION_TAG;
+    hdr->size = size;
+    init_front_guard(hdr);
+    init_rear_guard(hdr);
+    num++;
+    __add(hdr, &first, &last);
+    pthread_rwlock_unlock(&lock);
+}
+
+static inline int del(struct hdr *hdr)
+{
+    if (hdr->tag != ALLOCATION_TAG)
+        return -1;
+
+    pthread_rwlock_wrlock(&lock);
+    __del(hdr, &first, &last);
+    num--;
+    pthread_rwlock_unlock(&lock);
+    return 0;
+}
+
+static inline void poison(struct hdr *hdr)
+{
+    memset(user(hdr), FREE_POISON, hdr->size);
+}
+
+static int was_used_after_free(struct hdr *hdr)
+{
+    unsigned i;
+    const char *data = (const char *)user(hdr);
+    for (i = 0; i < hdr->size; i++)
+        if (data[i] != FREE_POISON)
+            return 1;
+    return 0;
+}
+
+/* returns 1 if valid, *safe == 1 if safe to dump stack */
+static inline int check_guards(struct hdr *hdr, int *safe)
+{
+    *safe = 1;
+    if (!is_front_guard_valid(hdr)) {
+        if (hdr->front_guard[0] == FRONT_GUARD) {
+            malloc_log("+++ ALLOCATION %p SIZE %d HAS A CORRUPTED FRONT GUARD\n",
+                       user(hdr), hdr->size);
+        } else {
+            malloc_log("+++ ALLOCATION %p HAS A CORRUPTED FRONT GUARD "\
+                      "(NOT DUMPING STACKTRACE)\n", user(hdr));
+            /* Allocation header is probably corrupt, do not print stack trace */
+            *safe = 0;
+        }
+        return 0;
+    }
+
+    if (!is_rear_guard_valid(hdr)) {
+        malloc_log("+++ ALLOCATION %p SIZE %d HAS A CORRUPTED REAR GUARD\n",
+                   user(hdr), hdr->size);
+        return 0;
+    }
+
+    return 1;
+}
+
+/* returns 1 if valid, *safe == 1 if safe to dump stack */
+static inline int __check_allocation(struct hdr *hdr, int *safe)
+{
+    int valid = 1;
+    *safe = 1;
+
+    if (hdr->tag != ALLOCATION_TAG && hdr->tag != BACKLOG_TAG) {
+        malloc_log("+++ ALLOCATION %p HAS INVALID TAG %08x (NOT DUMPING STACKTRACE)\n",
+                   user(hdr), hdr->tag);
+	/* Allocation header is probably corrupt, do not dequeue or dump stack
+         * trace.
+         */
+        *safe = 0;
+        return 0;
+    }
+
+    if (hdr->tag == BACKLOG_TAG && was_used_after_free(hdr)) {
+        malloc_log("+++ ALLOCATION %p SIZE %d WAS USED AFTER BEING FREED\n",
+                   user(hdr), hdr->size);
+        valid = 0;
+	/* check the guards to see if it's safe to dump a stack trace */
+        (void)check_guards(hdr, safe);
+    }
+    else
+        valid = check_guards(hdr, safe);
+
+    if (!valid && *safe) {
+        malloc_log("+++ ALLOCATION %p SIZE %d ALLOCATED HERE:\n",
+                        user(hdr), hdr->size);
+        print_backtrace(hdr->bt, hdr->bt_depth);
+        if (hdr->tag == BACKLOG_TAG) {
+            malloc_log("+++ ALLOCATION %p SIZE %d FREED HERE:\n",
+                       user(hdr), hdr->size);
+            print_backtrace(hdr->freed_bt, hdr->freed_bt_depth);
+        }
+    }
+
+    return valid;
+}
+
+static inline int __del_and_check(struct hdr *hdr,
+                                   struct hdr **first, struct hdr **last, unsigned *cnt,
+                                   int *safe)
+{
+    int valid;
+    valid = __check_allocation(hdr, safe);
+    if (safe) {
+        (*cnt)--;
+        __del(hdr, first, last);
+    }
+    return valid;
+}
+
+static inline void __del_from_backlog(struct hdr *hdr)
+{
+        int safe;
+        (void)__del_and_check(hdr,
+                              &backlog_first, &backlog_last, &backlog_num,
+                              &safe);
+        hdr->tag = 0; /* clear the tag */
+}
+
+static inline void del_from_backlog(struct hdr *hdr)
+{
+    pthread_rwlock_wrlock(&backlog_lock);
+    __del_from_backlog(hdr);
+    pthread_rwlock_unlock(&backlog_lock);
+}
+
+static inline int del_leak(struct hdr *hdr, int *safe)
+{
+    int valid;
+    pthread_rwlock_wrlock(&lock);
+    valid = __del_and_check(hdr,
+                            &first, &last, &num,
+                            safe);
+    pthread_rwlock_unlock(&lock);
+    return valid;
+}
+
+static inline void add_to_backlog(struct hdr *hdr)
+{
+    pthread_rwlock_wrlock(&backlog_lock);
+    hdr->tag = BACKLOG_TAG;
+    backlog_num++;
+    __add(hdr, &backlog_first, &backlog_last);
+    poison(hdr);
+    /* If we've exceeded the maximum backlog, clear it up */
+    while (backlog_num > BACKLOG_MAX) {
+        struct hdr *gone = backlog_first;
+        __del_from_backlog(gone);
+        __real_free(gone);
+    }
+    pthread_rwlock_unlock(&backlog_lock);
+}
+
+void* __wrap_malloc(size_t size)
+{
+//  malloc_tracker_log("%s: %s\n", __FILE__, __FUNCTION__);
+    struct hdr *hdr = __real_malloc(sizeof(struct hdr) + size +
+                                    sizeof(struct ftr));
+    if (hdr) {
+        hdr->bt_depth = heaptracker_stacktrace(
+                            hdr->bt, MAX_BACKTRACE_DEPTH);
+        add(hdr, size);
+        return hdr+1;
+    }
+    return NULL;
+}
+
+void __wrap_free(void *ptr)
+{
+    struct hdr *hdr;
+    if (!ptr) /* ignore free(NULL) */
+        return;
+
+    hdr = meta(ptr);
+
+    if (del(hdr) < 0) {
+        intptr_t bt[MAX_BACKTRACE_DEPTH];
+        int depth;
+        depth = heaptracker_stacktrace(bt, MAX_BACKTRACE_DEPTH);
+        if (hdr->tag == BACKLOG_TAG) {
+            malloc_log("+++ ALLOCATION %p SIZE %d BYTES MULTIPLY FREED!\n",
+                       user(hdr), hdr->size);
+            malloc_log("+++ ALLOCATION %p SIZE %d ALLOCATED HERE:\n",
+                       user(hdr), hdr->size);
+            print_backtrace(hdr->bt, hdr->bt_depth);
+            /* hdr->freed_bt_depth should be nonzero here */
+            malloc_log("+++ ALLOCATION %p SIZE %d FIRST FREED HERE:\n",
+                       user(hdr), hdr->size);
+            print_backtrace(hdr->freed_bt, hdr->freed_bt_depth);
+            malloc_log("+++ ALLOCATION %p SIZE %d NOW BEING FREED HERE:\n",
+                       user(hdr), hdr->size);
+            print_backtrace(bt, depth);
+        }
+        else {
+            malloc_log("+++ ALLOCATION %p IS CORRUPTED OR NOT ALLOCATED VIA TRACKER!\n",
+                       user(hdr));
+            print_backtrace(bt, depth);
+            /* Leak here so that we do not crash */
+            //__real_free(user(hdr));
+        }
+    }
+    else {
+        hdr->freed_bt_depth = heaptracker_stacktrace(hdr->freed_bt,
+                                      MAX_BACKTRACE_DEPTH);
+        add_to_backlog(hdr);
+    }
+}
+
+void *__wrap_realloc(void *ptr, size_t size)
+{
+    struct hdr *hdr;
+
+    if (!size) {
+        __wrap_free(ptr);
+        return NULL;
+    }
+
+    if (!ptr)
+        return __wrap_malloc(size);
+
+    hdr = meta(ptr);
+
+//  malloc_log("%s: %s\n", __FILE__, __FUNCTION__);
+    if (del(hdr) < 0) {
+        intptr_t bt[MAX_BACKTRACE_DEPTH];
+        int depth;
+        depth = heaptracker_stacktrace(bt, MAX_BACKTRACE_DEPTH);
+        if (hdr->tag == BACKLOG_TAG) {
+            malloc_log("+++ REALLOCATION %p SIZE %d OF FREED MEMORY!\n",
+                       user(hdr), size, hdr->size);
+            malloc_log("+++ ALLOCATION %p SIZE %d ALLOCATED HERE:\n",
+                       user(hdr), hdr->size);
+            print_backtrace(hdr->bt, hdr->bt_depth);
+            /* hdr->freed_bt_depth should be nonzero here */
+            malloc_log("+++ ALLOCATION %p SIZE %d FIRST FREED HERE:\n",
+                       user(hdr), hdr->size);
+            print_backtrace(hdr->freed_bt, hdr->freed_bt_depth);
+            malloc_log("+++ ALLOCATION %p SIZE %d NOW BEING REALLOCATED HERE:\n",
+                       user(hdr), hdr->size);
+            print_backtrace(bt, depth);
+
+	    /* We take the memory out of the backlog and fall through so the
+	     * reallocation below succeeds.  Since we didn't really free it, we
+	     * can default to this behavior.
+             */
+            del_from_backlog(hdr);
+        }
+        else {
+            malloc_log("+++ REALLOCATION %p SIZE %d IS CORRUPTED OR NOT ALLOCATED VIA TRACKER!\n",
+                       user(hdr), size);
+            print_backtrace(bt, depth);
+            // just get a whole new allocation and leak the old one
+            return __real_realloc(0, size);
+            // return __real_realloc(user(hdr), size); // assuming it was allocated externally
+        }
+    }
+ 
+    hdr = __real_realloc(hdr, sizeof(struct hdr) + size);
+    if (hdr) {
+        hdr->bt_depth = heaptracker_stacktrace(hdr->bt, MAX_BACKTRACE_DEPTH);
+        add(hdr, size);
+        return user(hdr);
+    }
+
+    return NULL;
+}
+
+void *__wrap_calloc(int nmemb, size_t size)
+{
+//  malloc_tracker_log("%s: %s\n", __FILE__, __FUNCTION__);
+    struct hdr *hdr;
+    size_t __size = nmemb * size;
+    hdr = __real_calloc(1, sizeof(struct hdr) + __size);
+    if (hdr) {
+        hdr->bt_depth = heaptracker_stacktrace(
+                            hdr->bt, MAX_BACKTRACE_DEPTH);
+        add(hdr, __size);
+        return user(hdr);
+    }
+    return NULL;
+}
+
+void heaptracker_free_leaked_memory(void)
+{
+    struct hdr *del; int cnt;
+
+    if (num)
+        malloc_log("+++ THERE ARE %d LEAKED ALLOCATIONS\n", num);
+
+    while (last) {
+        int safe;
+        del = last;
+        malloc_log("+++ DELETING %d BYTES OF LEAKED MEMORY AT %p (%d REMAINING)\n",
+                del->size, user(del), num);
+        if (del_leak(del, &safe)) {
+            /* safe == 1, because the allocation is valid */
+            malloc_log("+++ ALLOCATION %p SIZE %d ALLOCATED HERE:\n",
+                        user(del), del->size);
+            print_backtrace(del->bt, del->bt_depth);
+        }
+        __real_free(del);
+    }
+
+//  malloc_log("+++ DELETING %d BACKLOGGED ALLOCATIONS\n", backlog_num);
+    while (backlog_last) {
+	del = backlog_first;
+        del_from_backlog(del);
+        __real_free(del);
+    }
+}
+
+static int check_list(struct hdr *list, pthread_rwlock_t *rwlock)
+{
+    struct hdr *hdr;
+    int safe, num_checked;
+
+    pthread_rwlock_rdlock(rwlock);
+    num_checked = 0;
+    hdr = list;
+    while (hdr) {
+        (void)__check_allocation(hdr, &safe);
+        hdr = hdr->next;
+        num_checked++;
+    }
+    pthread_rwlock_unlock(rwlock);
+
+    return num_checked;
+}
+
+static pthread_t scanner_thread;
+static pthread_cond_t scanner_cond = PTHREAD_COND_INITIALIZER;
+static int scanner_stop;
+static pthread_mutex_t scanner_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static void* scanner(void *data __attribute__((unused)))
+{
+    struct timespec ts;
+    int num_checked, num_checked_backlog;
+
+    while (1) {
+        num_checked = check_list(last, &lock);
+        num_checked_backlog = check_list(backlog_last, &backlog_lock);
+
+//      malloc_log("@@@ scanned %d/%d allocs and %d/%d freed\n",
+//                 num_checked, num,
+//                 num_checked_backlog, backlog_num);
+
+        pthread_mutex_lock(&scanner_lock);
+        if (!scanner_stop) {
+            clock_gettime(CLOCK_REALTIME, &ts);
+            ts.tv_sec += SCANNER_SLEEP_S;
+            pthread_cond_timedwait(&scanner_cond, &scanner_lock, &ts);
+        }
+        if (scanner_stop) {
+            pthread_mutex_unlock(&scanner_lock);
+            break;
+        }
+        pthread_mutex_unlock(&scanner_lock);
+    }
+
+//  malloc_log("@@@ scanner thread exiting");
+    return NULL;
+}
+
+static void init(void) __attribute__((constructor));
+static void init(void)
+{
+//  malloc_log("@@@ start scanner thread");
+    milist = init_mapinfo(getpid());
+    pthread_create(&scanner_thread,
+                   NULL,
+                   scanner,
+                   NULL);
+}
+
+static void deinit(void) __attribute__((destructor));
+static void deinit(void)
+{
+//  malloc_log("@@@ signal stop to scanner thread");
+    pthread_mutex_lock(&scanner_lock);
+    scanner_stop = 1;
+    pthread_cond_signal(&scanner_cond);
+    pthread_mutex_unlock(&scanner_lock);
+//  malloc_log("@@@ wait for scanner thread to exit");
+    pthread_join(scanner_thread, NULL);
+//  malloc_log("@@@ scanner thread stopped");
+
+    heaptracker_free_leaked_memory();
+    deinit_mapinfo(milist);
+}
diff --git a/hwc/Android.mk b/hwc/Android.mk
new file mode 100644
index 0000000..af72df2
--- /dev/null
+++ b/hwc/Android.mk
@@ -0,0 +1,19 @@
+# HWC under heavy development and should not be included in builds for now
+LOCAL_PATH := $(call my-dir)
+
+# HAL module implementation, not prelinked and stored in
+# hw/<HWCOMPOSE_HARDWARE_MODULE_ID>.<ro.product.board>.so
+include $(CLEAR_VARS)
+LOCAL_PRELINK_MODULE := false
+LOCAL_ARM_MODE := arm
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/../vendor/lib/hw
+LOCAL_SHARED_LIBRARIES := liblog libEGL libcutils libutils libhardware
+LOCAL_SRC_FILES := hwc.c
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_MODULE := hwcomposer.omap4
+LOCAL_CFLAGS := -DLOG_TAG=\"ti_hwc\"
+# LOG_NDEBUG=0 means verbose logging enabled
+# LOCAL_CFLAGS += -DLOG_NDEBUG=0
+include $(BUILD_SHARED_LIBRARY)
diff --git a/hwc/hal_public.h b/hwc/hal_public.h
new file mode 100644
index 0000000..62c7849
--- /dev/null
+++ b/hwc/hal_public.h
@@ -0,0 +1,162 @@
+/* Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef HAL_PUBLIC_H
+#define HAL_PUBLIC_H
+
+/* Authors of third party hardware composer (HWC) modules will need to include
+ * this header to access functionality in the gralloc and framebuffer HALs.
+ */
+
+#include <hardware/gralloc.h>
+
+#define ALIGN(x,a)	(((x) + (a) - 1L) & ~((a) - 1L))
+#define HW_ALIGN	32
+
+/* This can be tuned down as appropriate for the SOC.
+ *
+ * IMG formats are usually a single sub-alloc.
+ * Some OEM video formats are two sub-allocs (Y, UV planes).
+ * Future OEM video formats might be three sub-allocs (Y, U, V planes).
+ */
+#define MAX_SUB_ALLOCS 3
+
+typedef struct
+{
+	native_handle_t base;
+
+	/* These fields can be sent cross process. They are also valid
+	 * to duplicate within the same process.
+	 *
+	 * A table is stored within psPrivateData on gralloc_module_t (this
+	 * is obviously per-process) which maps stamps to a mapped
+	 * PVRSRV_CLIENT_MEM_INFO in that process. Each map entry has a lock
+	 * count associated with it, satisfying the requirements of the
+	 * Android API. This also prevents us from leaking maps/allocations.
+	 *
+	 * This table has entries inserted either by alloc()
+	 * (alloc_device_t) or map() (gralloc_module_t). Entries are removed
+	 * by free() (alloc_device_t) and unmap() (gralloc_module_t).
+	 *
+	 * As a special case for framebuffer_device_t, framebuffer_open()
+	 * will add and framebuffer_close() will remove from this table.
+	 */
+
+#define IMG_NATIVE_HANDLE_NUMFDS MAX_SUB_ALLOCS
+	/* The `fd' field is used to "export" a meminfo to another process.
+	 * Therefore, it is allocated by alloc_device_t, and consumed by
+	 * gralloc_module_t. The framebuffer_device_t does not need a handle,
+	 * and the special value IMG_FRAMEBUFFER_FD is used instead.
+	 */
+	int fd[MAX_SUB_ALLOCS];
+
+#define IMG_NATIVE_HANDLE_NUMINTS ((sizeof(unsigned long long) / sizeof(int)) + 5)
+	/* A KERNEL unique identifier for any exported kernel meminfo. Each
+	 * exported kernel meminfo will have a unique stamp, but note that in
+	 * userspace, several meminfos across multiple processes could have
+	 * the same stamp. As the native_handle can be dup(2)'d, there could be
+	 * multiple handles with the same stamp but different file descriptors.
+	 */
+	unsigned long long ui64Stamp;
+
+	/* This is used for buffer usage validation when locking a buffer,
+	 * and also in WSEGL (for the composition bypass feature).
+	 */
+	int usage;
+
+	/* In order to do efficient cache flushes we need the buffer dimensions
+	 * and format. These are available on the ANativeWindowBuffer,
+	 * but the platform doesn't pass them down to the graphics HAL.
+	 *
+	 * These fields are also used in the composition bypass. In this
+	 * capacity, these are the "real" values for the backing allocation.
+	 */
+	int iWidth;
+	int iHeight;
+	int iFormat;
+	unsigned int uiBpp;
+}
+__attribute__((aligned(sizeof(int)),packed)) IMG_native_handle_t;
+
+typedef struct
+{
+	framebuffer_device_t base;
+
+	/* The HWC was loaded. post() is no longer responsible for presents */
+	int bBypassPost;
+
+	/* Custom-blit components in lieu of overlay hardware */
+	int (*Blit)(framebuffer_device_t *device, buffer_handle_t src,
+				buffer_handle_t dest, int w, int h, int x, int y);
+
+	/* HWC path for present posts */
+	int (*Post2)(framebuffer_device_t *fb, buffer_handle_t *buffers,
+				 int num_buffers, void *data, int data_length);
+}
+IMG_framebuffer_device_public_t;
+
+typedef struct IMG_gralloc_module_public_t
+{
+	gralloc_module_t base;
+
+	/* If the framebuffer has been opened, this will point to the
+	 * framebuffer device data required by the allocator, WSEGL
+	 * modules and composerhal.
+	 */
+	IMG_framebuffer_device_public_t *psFrameBufferDevice;
+
+	int (*GetPhyAddrs)(struct IMG_gralloc_module_public_t const* module,
+					   buffer_handle_t handle,
+					   unsigned int auiPhyAddr[MAX_SUB_ALLOCS]);
+}
+IMG_gralloc_module_public_t;
+
+typedef struct
+{
+	int l, t, w, h;
+}
+IMG_write_lock_rect_t;
+
+typedef struct IMG_buffer_format_public_t
+{
+	/* Buffer formats are returned as a linked list */
+	struct IMG_buffer_format_public_t *psNext;
+
+	/* HAL_PIXEL_FORMAT_... enumerant */
+	int iHalPixelFormat;
+
+	/* WSEGL_PIXELFORMAT_... enumerant */
+	int iWSEGLPixelFormat;
+
+	/* Friendly name for format */
+	const char *const szName;
+
+	/* Bits (not bytes) per pixel */
+	unsigned int uiBpp;
+
+	/* GPU output format (creates EGLConfig for format) */
+	int bGPURenderable;
+}
+IMG_buffer_format_public_t;
+
+#endif /* HAL_PUBLIC_H */
diff --git a/hwc/hwc.c b/hwc/hwc.c
new file mode 100644
index 0000000..5f33764
--- /dev/null
+++ b/hwc/hwc.c
@@ -0,0 +1,693 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+#include <errno.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+#include <cutils/properties.h>
+#include <cutils/log.h>
+#include <cutils/native_handle.h>
+#include <hardware/hardware.h>
+#include <hardware/hwcomposer.h>
+#include <EGL/egl.h>
+#include <utils/Timers.h>
+
+#include <video/dsscomp.h>
+
+#include "hal_public.h"
+
+#define MAX_HW_OVERLAYS 4
+#define MAX_SCALING_OVERLAYS 3
+#define HAL_PIXEL_FORMAT_BGRX_8888		0x1FF
+#define HAL_PIXEL_FORMAT_TI_NV12 0x100
+#define HAL_PIXEL_FORMAT_TI_NV12_PADDED 0x101
+#define MAX_TILER_SLOT (4 << 20)
+
+#define MIN(a,b)		  ((a)<(b)?(a):(b))
+#define MAX(a,b)		  ((a)>(b)?(a):(b))
+#define CLAMP(x,low,high) (((x)>(high))?(high):(((x)<(low))?(low):(x)))
+
+struct omap4_hwc_module {
+    hwc_module_t base;
+
+    IMG_framebuffer_device_public_t *fb_dev;
+};
+typedef struct omap4_hwc_module omap4_hwc_module_t;
+
+struct omap4_hwc_device {
+    hwc_composer_device_t base;
+
+    IMG_framebuffer_device_public_t *fb_dev;
+    struct dsscomp_setup_dispc_data dsscomp_data;
+
+    buffer_handle_t *buffers;
+    int use_sgx;
+
+    int flags_rgb_order;
+    int flags_nv12_only;
+};
+typedef struct omap4_hwc_device omap4_hwc_device_t;
+
+static int debug = 0;
+
+static void dump_layer(hwc_layer_t const* l)
+{
+    LOGD("\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, {%d,%d,%d,%d}, {%d,%d,%d,%d}",
+            l->compositionType, l->flags, l->handle, l->transform, l->blending,
+            l->sourceCrop.left,
+            l->sourceCrop.top,
+            l->sourceCrop.right,
+            l->sourceCrop.bottom,
+            l->displayFrame.left,
+            l->displayFrame.top,
+            l->displayFrame.right,
+            l->displayFrame.bottom);
+}
+
+static void dump_dsscomp(struct dsscomp_setup_dispc_data *d)
+{
+    struct dss2_mgr_info *mi = &d->mgr;
+
+    LOGE("[%08x] set: %c%c%c(dis%d alpha=%d col=%08x ilace=%d n=%d)\n",
+         d->sync_id,
+         (d->mode & DSSCOMP_SETUP_MODE_APPLY) ? 'A' : '-',
+         (d->mode & DSSCOMP_SETUP_MODE_DISPLAY) ? 'D' : '-',
+         (d->mode & DSSCOMP_SETUP_MODE_CAPTURE) ? 'C' : '-',
+         mi->ix,
+         mi->alpha_blending, mi->default_color,
+         mi->interlaced,
+         d->num_ovls);
+
+    unsigned i;
+    for (i = 0; i < d->num_ovls; i++) {
+            struct dss2_ovl_info *oi = d->ovls + i;
+            struct dss2_ovl_cfg *c = &oi->cfg;
+            if (c->zonly)
+                    LOGE("ovl%d(%s z%d)\n",
+                         c->ix, c->enabled ? "ON" : "off", c->zorder);
+            else
+                    LOGE("ovl%d(%s z%d %x%s *%d%% %d*%d:%d,%d+%d,%d rot%d%s => %d,%d+%d,%d %p/%p|%d)\n",
+                         c->ix, c->enabled ? "ON" : "off", c->zorder, c->color_mode,
+                         c->pre_mult_alpha ? " premult" : "",
+                         (c->global_alpha * 100 + 128) / 255,
+                         c->width, c->height, c->crop.x, c->crop.y,
+                         c->crop.w, c->crop.h,
+                         c->rotation, c->mirror ? "+mir" : "",
+                         c->win.x, c->win.y, c->win.w, c->win.h,
+                         (void *) oi->ba, (void *) oi->uv, c->stride);
+    }
+}
+
+static int omap4_hwc_is_valid_format(int format)
+{
+    switch(format) {
+    case HAL_PIXEL_FORMAT_RGB_565:
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+    case HAL_PIXEL_FORMAT_BGRX_8888:
+    case HAL_PIXEL_FORMAT_TI_NV12:
+    case HAL_PIXEL_FORMAT_TI_NV12_PADDED:
+        return 1;
+
+    default:
+        LOGI("invalid format %d", format);
+        return 0;
+    }
+}
+
+static int scaled(hwc_layer_t *layer)
+{
+    int w = layer->sourceCrop.right - layer->sourceCrop.left;
+    int h = layer->sourceCrop.bottom - layer->sourceCrop.top;
+    /* TODO: skip w/h if rotated by 90 */
+    return (layer->displayFrame.right - layer->displayFrame.left != w ||
+            layer->displayFrame.bottom - layer->displayFrame.top != h);
+}
+
+static int sync_id = 0;
+
+#define is_ALPHA(format) ((format) == HAL_PIXEL_FORMAT_BGRA_8888 || (format) == HAL_PIXEL_FORMAT_RGBA_8888)
+#define is_RGB(format) ((format) == HAL_PIXEL_FORMAT_BGRA_8888 || (format) == HAL_PIXEL_FORMAT_RGB_565 || (format) == HAL_PIXEL_FORMAT_BGRX_8888)
+#define is_BGR(format) ((format) == HAL_PIXEL_FORMAT_RGBX_8888 || (format) == HAL_PIXEL_FORMAT_RGBA_8888)
+#define is_NV12(format) ((format) == HAL_PIXEL_FORMAT_TI_NV12 || (format) == HAL_PIXEL_FORMAT_TI_NV12_PADDED)
+
+static void
+omap4_hwc_setup_layer_base(struct dss2_ovl_cfg *oc, int index, int format, int width, int height)
+{
+    unsigned int bits_per_pixel;
+
+    /* YUV2RGB conversion */
+    const struct omap_dss_cconv_coefs ctbl_bt601_5 = {
+        298,  409,    0,  298, -208, -100,  298,    0,  517, 0,
+    };
+
+    /* convert color format */
+    switch (format) {
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+        /* Should be XBGR32, but this isn't supported */
+        oc->color_mode = OMAP_DSS_COLOR_RGB24U;
+        bits_per_pixel = 32;
+        break;
+
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+        /* Should be ABGR32, but this isn't supported */
+        oc->color_mode = OMAP_DSS_COLOR_ARGB32;
+        bits_per_pixel = 32;
+        break;
+
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+        oc->color_mode = OMAP_DSS_COLOR_ARGB32;
+        bits_per_pixel = 32;
+        break;
+
+    case HAL_PIXEL_FORMAT_BGRX_8888:
+        oc->color_mode = OMAP_DSS_COLOR_RGB24U;
+        bits_per_pixel = 32;
+        break;
+
+    case HAL_PIXEL_FORMAT_RGB_565:
+        oc->color_mode = OMAP_DSS_COLOR_RGB16;
+        bits_per_pixel = 16;
+        break;
+
+    case HAL_PIXEL_FORMAT_TI_NV12:
+    case HAL_PIXEL_FORMAT_TI_NV12_PADDED:
+        oc->color_mode = OMAP_DSS_COLOR_NV12;
+        bits_per_pixel = 8;
+        oc->cconv = ctbl_bt601_5;
+        break;
+
+    default:
+        /* Should have been filtered out */
+        LOGV("Unsupported pixel format");
+        return;
+    }
+
+    oc->width = width;
+    oc->height = height;
+    oc->stride = ALIGN(width, HW_ALIGN) * bits_per_pixel / 8;
+
+    oc->enabled = 1;
+    oc->global_alpha = 255;
+    oc->zorder = index;
+    oc->ix = 0;
+
+    /* defaults for SGX framebuffer renders */
+    oc->crop.w = oc->win.w = width;
+    oc->crop.h = oc->win.h = height;
+
+    /* for now interlacing and vc1 info is not supplied */
+    oc->ilace = OMAP_DSS_ILACE_NONE;
+    oc->vc1.enable = 0;
+}
+
+static void
+omap4_hwc_setup_layer(omap4_hwc_device_t *hwc_dev, struct dss2_ovl_info *ovl,
+                      hwc_layer_t *layer, int index,
+                      int format, int width, int height)
+{
+    struct dss2_ovl_cfg *oc = &ovl->cfg;
+
+    //dump_layer(layer);
+
+    omap4_hwc_setup_layer_base(oc, index, format, width, height);
+
+    /* convert transformation - assuming 0-set config */
+    if (layer->transform & HWC_TRANSFORM_FLIP_H)
+        oc->mirror = 1;
+    if (layer->transform & HWC_TRANSFORM_FLIP_V) {
+        oc->rotation = 2;
+	oc->mirror = !oc->mirror;
+    }
+    if (layer->transform & HWC_TRANSFORM_ROT_90) {
+        oc->rotation += oc->mirror ? -1 : 1;
+        oc->rotation &= 3;
+    }
+
+    oc->pre_mult_alpha = layer->blending == HWC_BLENDING_PREMULT;
+
+    /* display position */
+    oc->win.x = layer->displayFrame.left;
+    oc->win.y = layer->displayFrame.top;
+    oc->win.w = layer->displayFrame.right - layer->displayFrame.left;
+    oc->win.h = layer->displayFrame.bottom - layer->displayFrame.top;
+
+    /* crop */
+    oc->crop.x = layer->sourceCrop.left;
+    oc->crop.y = layer->sourceCrop.top;
+    oc->crop.w = layer->sourceCrop.right - layer->sourceCrop.left;
+    oc->crop.h = layer->sourceCrop.bottom - layer->sourceCrop.top;
+}
+
+static int omap4_hwc_is_valid_layer(hwc_layer_t *layer,
+                                    IMG_native_handle_t *handle)
+{
+    /* Skip layers are handled by SF */
+    if ((layer->flags & HWC_SKIP_LAYER) || !handle)
+        return 0;
+
+    if (!omap4_hwc_is_valid_format(handle->iFormat))
+        return 0;
+
+    /* 1D buffers: no transform, must fit in TILER slot */
+    if (!is_NV12(handle->iFormat)) {
+        if (layer->transform)
+            return 0;
+        int bpp = (handle->iFormat == HAL_PIXEL_FORMAT_RGB_565 ? 2 : 4);
+        int stride = ALIGN(handle->iWidth, HW_ALIGN) * bpp;
+        if (stride * handle->iHeight > MAX_TILER_SLOT)
+            return 0;
+    }
+    return 1;
+}
+
+static int omap4_hwc_prepare(struct hwc_composer_device *dev, hwc_layer_list_t* list)
+{
+    omap4_hwc_device_t *hwc_dev = (omap4_hwc_device_t *)dev;
+    struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data;
+    unsigned int num_possible_overlay_layers = 0;
+    unsigned int num_composited_layers = 0;
+    unsigned int num_scaled_layers = 0;
+    unsigned int i;
+    unsigned int num_RGB = 0;
+    unsigned int num_BGR = 0;
+
+    memset(dsscomp, 0x0, sizeof(*dsscomp));
+    dsscomp->sync_id = sync_id++;
+
+    /* Figure out how many layers we can support via DSS */
+    num_composited_layers = list->numHwLayers;
+
+    for (i = 0; i < list->numHwLayers; i++) {
+        hwc_layer_t *layer = &list->hwLayers[i];
+        IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
+
+        layer->compositionType = HWC_FRAMEBUFFER;
+
+        if (omap4_hwc_is_valid_layer(layer, handle)) {
+            num_possible_overlay_layers++;
+
+            if (scaled(layer))
+                num_scaled_layers++;
+
+            if (is_BGR(handle->iFormat))
+                num_BGR++;
+            else if (is_RGB(handle->iFormat))
+                num_RGB++;
+        }
+    }
+
+    /* phase 2 logic: all DSS rendering */
+    if (num_possible_overlay_layers <= MAX_HW_OVERLAYS &&
+        num_possible_overlay_layers == num_composited_layers &&
+        num_scaled_layers <= MAX_SCALING_OVERLAYS &&
+        (num_BGR == 0 || num_RGB == 0 || !hwc_dev->flags_rgb_order) &&
+        num_possible_overlay_layers) {
+        /* All layers can be handled by the DSS -- don't use SGX for composition */
+        hwc_dev->use_sgx = 0;
+        dsscomp->mgr.swap_rb = num_BGR != 0;
+    } else {
+        /* Use SGX for composition plus first 3 layers that are DSS renderable */
+        hwc_dev->use_sgx = 1;
+        dsscomp->mgr.swap_rb = is_BGR(hwc_dev->fb_dev->base.format);
+    }
+    if (debug) {
+        LOGD("prepare (%d) %d layers - %s (poss=%d/%d scaled, comp=%d, rgb=%d,bgr=%d)\n",
+         dsscomp->sync_id, list->numHwLayers,
+         hwc_dev->use_sgx ? "SGX+OVL" : "all-OVL",
+         num_possible_overlay_layers, num_scaled_layers, num_composited_layers, num_RGB, num_BGR);
+    }
+
+    /* setup pipes */
+    dsscomp->num_ovls = hwc_dev->use_sgx;
+    int z = 0;
+    int fb_z = -1, fb_zmax = 0;
+    int scaled_gfx = 0;
+
+    /* set up if DSS layers */
+    for (i = 0; i < list->numHwLayers && dsscomp->num_ovls < MAX_HW_OVERLAYS; i++) {
+        hwc_layer_t *layer = &list->hwLayers[i];
+        IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
+
+        if (handle &&
+            omap4_hwc_is_valid_layer(layer, handle) &&
+            /* can't have a transparent overlay in the middle of the framebuffer stack */
+            !(is_ALPHA(handle->iFormat) && fb_z >= 0) &&
+            /* skip non-NV12 layers if also using SGX (if nv12_only flag is set) */
+            (!hwc_dev->flags_nv12_only || (!hwc_dev->use_sgx || is_NV12(handle->iFormat))) &&
+            /* make sure RGB ordering is consistent (if rgb_order flag is set) */
+            (!(dsscomp->mgr.swap_rb ? is_RGB(handle->iFormat) : is_BGR(handle->iFormat)) ||
+             !hwc_dev->flags_rgb_order)) {
+            /* render via DSS overlay */
+            layer->compositionType = HWC_OVERLAY;
+            /* clear layers above DSS layer areas */
+            layer->hints |= HWC_HINT_CLEAR_FB;
+            hwc_dev->buffers[dsscomp->num_ovls] = layer->handle;
+
+            omap4_hwc_setup_layer(hwc_dev,
+                                  &dsscomp->ovls[dsscomp->num_ovls],
+                                  &list->hwLayers[i],
+                                  z,
+                                  handle->iFormat,
+                                  handle->iWidth,
+                                  handle->iHeight);
+            /* TODO: we need to use gfx for the a layer that is not scaled */
+            dsscomp->ovls[dsscomp->num_ovls].cfg.ix = dsscomp->num_ovls;
+            /* just marking dss layers */
+            dsscomp->ovls[dsscomp->num_ovls].address = (void *) (dsscomp->num_ovls * 4096 + 0xA0000000);
+            dsscomp->ovls[dsscomp->num_ovls].uv = (__u32) hwc_dev->buffers[dsscomp->num_ovls];
+
+            /* ensure GFX layer is never scaled */
+            if (dsscomp->num_ovls == 0) {
+                scaled_gfx = scaled(layer);
+            } else if (scaled_gfx && !scaled(layer)) {
+                /* swap GFX layer with this one */
+                dsscomp->ovls[dsscomp->num_ovls].cfg.ix = 0;
+                dsscomp->ovls[0].cfg.ix = dsscomp->num_ovls;
+                scaled_gfx = 0;
+            }
+
+            dsscomp->num_ovls++;
+            z++;
+        } else if (hwc_dev->use_sgx) {
+            if (fb_z < 0) {
+                /* NOTE: we are not handling transparent cutout for now */
+                fb_z = fb_zmax = z;
+                z++;
+            } else {
+                /* move fb z-order up (by lowering dss layers) */
+                while (fb_zmax < z - 1)
+                    dsscomp->ovls[1 + fb_zmax++].cfg.zorder--;
+            }
+        }
+    }
+
+    /* clear FB above DSS layers */
+    /* FIXME: for now assume full screen layers.  later this can be optimized */
+    int obstructed = 0;
+    if (dsscomp->num_ovls > hwc_dev->use_sgx) {
+        for (i = list->numHwLayers; i > 0;) {
+            i--;
+            hwc_layer_t *layer = &list->hwLayers[i];
+            if ((layer->flags & HWC_SKIP_LAYER) || !layer->handle)
+                continue;
+            if (layer->compositionType != HWC_OVERLAY)
+                obstructed = 1;
+            else if (obstructed)
+                layer->hints |= HWC_HINT_CLEAR_FB;
+        }
+    }
+
+    /* if scaling GFX (e.g. only 1 scaled surface) use a VID pipe */
+    if (scaled_gfx)
+        dsscomp->ovls[0].cfg.ix = 1;
+
+    /* assign a z-layer for fb */
+    if (hwc_dev->use_sgx && fb_z < 0) {
+        fb_z = z;
+        z++;
+    }
+
+    if (z != dsscomp->num_ovls || dsscomp->num_ovls > MAX_HW_OVERLAYS)
+        LOGE("**** used %d z-layers for %d overlays\n", z, dsscomp->num_ovls);
+
+    if (hwc_dev->use_sgx) {
+        hwc_dev->buffers[0] = NULL;
+        omap4_hwc_setup_layer_base(&dsscomp->ovls[0].cfg, fb_z,
+                                   hwc_dev->fb_dev->base.format,
+                                   hwc_dev->fb_dev->base.width,
+                                   hwc_dev->fb_dev->base.height);
+        dsscomp->ovls[0].uv = (__u32) hwc_dev->buffers[0];
+    }
+
+    dsscomp->mode = DSSCOMP_SETUP_DISPLAY;
+    dsscomp->mgr.ix = 0;
+    dsscomp->mgr.alpha_blending = 1;
+
+    return 0;
+}
+
+static int omap4_hwc_set(struct hwc_composer_device *dev, hwc_display_t dpy,
+               hwc_surface_t sur, hwc_layer_list_t* list)
+{
+    omap4_hwc_device_t *hwc_dev = (omap4_hwc_device_t *)dev;
+    struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data;
+    int err;
+    unsigned int i;
+
+    if (!list) {
+        LOGE("list is NULL");
+        return 0;
+    }
+
+    char big_log[1024];
+    int e = sizeof(big_log);
+    char *end = big_log + e;
+    e -= snprintf(end - e, e, "set H{");
+    for (i = 0; i < list->numHwLayers; i++) {
+        if (i)
+            e -= snprintf(end - e, e, " ");
+        hwc_layer_t *layer = &list->hwLayers[i];
+        IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
+        e -= snprintf(end - e, e, "%p:%s,", handle, layer->compositionType == HWC_OVERLAY ? "DSS" : "SGX");
+        if ((layer->flags & HWC_SKIP_LAYER) || !handle) {
+            e -= snprintf(end - e, e, "SKIP");
+            continue;
+        }
+        if (layer->flags & HWC_HINT_CLEAR_FB)
+            e -= snprintf(end - e, e, "CLR,");
+#define FMT(f) ((f) == HAL_PIXEL_FORMAT_TI_NV12 ? "NV12" : \
+                (f) == HAL_PIXEL_FORMAT_BGRX_8888 ? "xRGB32" : \
+                (f) == HAL_PIXEL_FORMAT_RGBX_8888 ? "xBGR32" : \
+                (f) == HAL_PIXEL_FORMAT_BGRA_8888 ? "ARGB32" : \
+                (f) == HAL_PIXEL_FORMAT_RGBA_8888 ? "ABGR32" : \
+                (f) == HAL_PIXEL_FORMAT_RGB_565 ? "RGB565" : "??")
+        e -= snprintf(end - e, e, "%d*%d(%s)", handle->iWidth, handle->iHeight, FMT(handle->iFormat));
+        if (layer->transform)
+            e -= snprintf(end - e, e, "~%d", layer->transform);
+#undef FMT
+    }
+    e -= snprintf(end - e, e, "} D{");
+    for (i = 0; i < dsscomp->num_ovls; i++) {
+        if (i)
+            e -= snprintf(end - e, e, " ");
+        e -= snprintf(end - e, e, "%d=", dsscomp->ovls[i].cfg.ix);
+#define FMT(f) ((f) == OMAP_DSS_COLOR_NV12 ? "NV12" : \
+                (f) == OMAP_DSS_COLOR_RGB24U ? "xRGB32" : \
+                (f) == OMAP_DSS_COLOR_ARGB32 ? "ARGB32" : \
+                (f) == OMAP_DSS_COLOR_RGB16 ? "RGB565" : "??")
+        if (dsscomp->ovls[i].cfg.enabled)
+            e -= snprintf(end - e, e, "%08x:%d*%d,%s",
+                          dsscomp->ovls[i].ba,
+                          dsscomp->ovls[i].cfg.width,
+                          dsscomp->ovls[i].cfg.height,
+                          FMT(dsscomp->ovls[i].cfg.color_mode));
+#undef FMT
+        else
+            e -= snprintf(end - e, e, "-");
+    }
+    e -= snprintf(end - e, e, "} L{");
+    for (i = 0; i < dsscomp->num_ovls; i++) {
+        if (i)
+            e -= snprintf(end - e, e, " ");
+        e -= snprintf(end - e, e, "%p", hwc_dev->buffers[i]);
+    }
+    e -= snprintf(end - e, e, "}%s\n", hwc_dev->use_sgx ? " swap" : "");
+    if (debug) {
+        LOGD("%s", big_log);
+    }
+
+    // LOGD("set %d layers (sgx=%d)\n", dsscomp->num_ovls, hwc_dev->use_sgx);
+
+    if (hwc_dev->use_sgx) {
+        if (!eglSwapBuffers((EGLDisplay)dpy, (EGLSurface)sur)) {
+            LOGE("eglSwapBuffers error");
+            err = HWC_EGL_ERROR;
+            goto err_out;
+        }
+    }
+
+    //dump_dsscomp(dsscomp);
+
+    err = hwc_dev->fb_dev->Post2((framebuffer_device_t *)hwc_dev->fb_dev,
+                                 hwc_dev->buffers,
+                                 dsscomp->num_ovls,
+                                 dsscomp, sizeof(*dsscomp));
+    if (err)
+        LOGE("Post2 error");
+
+err_out:
+    return err;
+}
+
+static int dump_printf(char *buff, int buff_len, int len, const char *fmt, ...)
+{
+    va_list ap;
+
+    int print_len;
+
+    va_start(ap, fmt);
+
+    print_len = vsnprintf(buff + len, buff_len - len, fmt, ap);
+
+    va_end(ap);
+
+    return len + print_len;
+}
+
+static void omap4_hwc_dump(struct hwc_composer_device *dev, char *buff, int buff_len)
+{
+    omap4_hwc_device_t *hwc_dev = (omap4_hwc_device_t *)dev;
+    struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data;
+    int len = 0;
+    int i;
+
+    len = dump_printf(buff, buff_len, len, "omap4_hwc %d:\n", dsscomp->num_ovls);
+
+    for (i = 0; i < dsscomp->num_ovls; i++) {
+        struct dss2_ovl_cfg *cfg = &dsscomp->ovls[i].cfg;
+
+        len = dump_printf(buff, buff_len, len, "  layer %d:\n", i);
+        len = dump_printf(buff, buff_len, len, "     enabled: %s\n",
+                          cfg->enabled ? "true" : "false");
+        len = dump_printf(buff, buff_len, len, "     buff: %dx%d stride: %d:\n",
+                          cfg->width, cfg->height, cfg->stride);
+        len = dump_printf(buff, buff_len, len, "     src: (%d,%d) %dx%d\n",
+                          cfg->crop.x, cfg->crop.y, cfg->crop.w, cfg->crop.h);
+        len = dump_printf(buff, buff_len, len, "     dst: (%d,%d) %dx%d\n",
+                          cfg->win.x, cfg->win.y, cfg->win.w, cfg->win.h);
+        len = dump_printf(buff, buff_len, len, "     ix: %d\n", cfg->ix);
+        len = dump_printf(buff, buff_len, len, "     zorder: %d\n\n", cfg->zorder);
+
+    }
+}
+
+
+static int omap4_hwc_device_close(hw_device_t* device)
+{
+    omap4_hwc_device_t *hwc_dev = (omap4_hwc_device_t *) device;;
+
+    if (hwc_dev)
+        free(hwc_dev);
+
+    return 0;
+}
+
+static int omap4_hwc_open_fb_hal(IMG_framebuffer_device_public_t **fb_dev)
+{
+    IMG_gralloc_module_public_t *psGrallocModule;
+    int err;
+
+    err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
+                        (const hw_module_t**)&psGrallocModule);
+    if(err)
+        goto err_out;
+
+    if(strcmp(psGrallocModule->base.common.author,
+              "Imagination Technologies"))
+    {
+        err = -EINVAL;
+        goto err_out;
+    }
+
+    *fb_dev = psGrallocModule->psFrameBufferDevice;
+
+    return 0;
+
+err_out:
+    LOGE("Composer HAL failed to load compatible Graphics HAL");
+    return err;
+}
+
+static int omap4_hwc_device_open(const hw_module_t* module, const char* name,
+                hw_device_t** device)
+{
+    omap4_hwc_module_t *hwc_mod = (omap4_hwc_module_t *)module;
+    omap4_hwc_device_t *hwc_dev;
+    int err;
+
+    if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
+        return -EINVAL;
+    }
+
+    if (!hwc_mod->fb_dev) {
+        err = omap4_hwc_open_fb_hal(&hwc_mod->fb_dev);
+        if (err)
+            return err;
+
+        if (!hwc_mod->fb_dev) {
+            LOGE("Framebuffer HAL not opened before HWC");
+            return -EFAULT;
+        }
+        hwc_mod->fb_dev->bBypassPost = 1;
+    }
+
+    hwc_dev = (omap4_hwc_device_t *)malloc(sizeof(*hwc_dev));
+    if (hwc_dev == NULL)
+        return -ENOMEM;
+
+    memset(hwc_dev, 0, sizeof(*hwc_dev));
+
+    hwc_dev->base.common.tag = HARDWARE_DEVICE_TAG;
+    hwc_dev->base.common.version = HWC_API_VERSION;
+    hwc_dev->base.common.module = (hw_module_t *)module;
+    hwc_dev->base.common.close = omap4_hwc_device_close;
+    hwc_dev->base.prepare = omap4_hwc_prepare;
+    hwc_dev->base.set = omap4_hwc_set;
+    hwc_dev->base.dump = omap4_hwc_dump;
+    hwc_dev->fb_dev = hwc_mod->fb_dev;
+    *device = &hwc_dev->base.common;
+
+    hwc_dev->buffers = malloc(sizeof(buffer_handle_t) * MAX_HW_OVERLAYS);
+    if (!hwc_dev->buffers) {
+        free(hwc_dev);
+        return -ENOMEM;
+    }
+
+    /* get debug properties */
+
+    /* see if hwc is enabled at all */
+    char value[PROPERTY_VALUE_MAX];
+    property_get("debug.hwc.rgb_order", value, "1");
+    hwc_dev->flags_rgb_order = atoi(value);
+    property_get("debug.hwc.nv12_only", value, "0");
+    hwc_dev->flags_nv12_only = atoi(value);
+    LOGE("omap4_hwc_device_open(rgb_order=%d nv12_only=%d)",
+        hwc_dev->flags_rgb_order, hwc_dev->flags_nv12_only);
+
+    return 0;
+}
+
+static struct hw_module_methods_t omap4_hwc_module_methods = {
+    .open = omap4_hwc_device_open,
+};
+
+omap4_hwc_module_t HAL_MODULE_INFO_SYM = {
+    .base = {
+        .common = {
+            .tag =                  HARDWARE_MODULE_TAG,
+            .version_major =        1,
+            .version_minor =        0,
+            .id =                   HWC_HARDWARE_MODULE_ID,
+            .name =                 "OMAP 44xx Hardware Composer HAL",
+            .author =               "Texas Instruments",
+            .methods =              &omap4_hwc_module_methods,
+        },
+    },
+};
diff --git a/ion/Android.mk b/ion/Android.mk
new file mode 100644
index 0000000..c9bf668
--- /dev/null
+++ b/ion/Android.mk
@@ -0,0 +1,20 @@
+# only include if running on an omap4 platform
+ifeq ($(TARGET_BOARD_PLATFORM),omap4)
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := ion.c
+LOCAL_MODULE := libion
+LOCAL_MODULE_TAGS := optional
+LOCAL_SHARED_LIBRARIES := liblog
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := ion.c ion_test.c
+LOCAL_MODULE := iontest
+LOCAL_MODULE_TAGS := optional tests
+LOCAL_SHARED_LIBRARIES := liblog
+include $(BUILD_HEAPTRACKED_EXECUTABLE)
+
+endif
diff --git a/ion/ion.c b/ion/ion.c
new file mode 100644
index 0000000..08e4570
--- /dev/null
+++ b/ion/ion.c
@@ -0,0 +1,156 @@
+/*
+ *  ion.c
+ *
+ * Memory Allocator functions for ion
+ *
+ *   Copyright 2011 Google, Inc
+ *
+ *  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.
+ */
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+
+#define LOG_TAG "ion"
+#include <cutils/log.h>
+
+#include <linux/ion.h>
+#include <linux/omap_ion.h>
+#include "ion.h"
+
+int ion_open()
+{
+        int fd = open("/dev/ion", O_RDWR);
+        if (fd < 0)
+                LOGE("open /dev/ion failed!\n");
+        return fd;
+}
+
+int ion_close(int fd)
+{
+        return close(fd);
+}
+
+int ion_ioctl(int fd, int req, void *arg)
+{
+        int ret = ioctl(fd, req, arg);
+        if (ret < 0) {
+                LOGE("ioctl %d failed with code %d: %s\n", req,
+                       ret, strerror(errno));
+                return -errno;
+        }
+        return ret;
+}
+
+int ion_alloc(int fd, size_t len, size_t align, unsigned int flags,
+              struct ion_handle **handle)
+{
+        int ret;
+        struct ion_allocation_data data = {
+                .len = len,
+                .align = align,
+                .flags = flags,
+        };
+
+        ret = ion_ioctl(fd, ION_IOC_ALLOC, &data);
+        if (ret < 0)
+                return ret;
+        *handle = data.handle;
+        return ret;
+}
+
+int ion_alloc_tiler(int fd, size_t w, size_t h, int fmt, unsigned int flags,
+            struct ion_handle **handle, size_t *stride)
+{
+        int ret;
+        struct omap_ion_tiler_alloc_data alloc_data = {
+                .w = w,
+                .h = h,
+                .fmt = fmt,
+                .flags = flags,
+        };
+
+        struct ion_custom_data custom_data = {
+                .cmd = OMAP_ION_TILER_ALLOC,
+                .arg = (unsigned long)(&alloc_data),
+        };
+
+        ret = ion_ioctl(fd, ION_IOC_CUSTOM, &custom_data);
+        if (ret < 0)
+                return ret;
+        *stride = alloc_data.stride;
+        *handle = alloc_data.handle;
+        return ret;
+}
+
+int ion_free(int fd, struct ion_handle *handle)
+{
+        struct ion_handle_data data = {
+                .handle = handle,
+        };
+        return ion_ioctl(fd, ION_IOC_FREE, &data);
+}
+
+int ion_map(int fd, struct ion_handle *handle, size_t length, int prot,
+            int flags, off_t offset, unsigned char **ptr, int *map_fd)
+{
+        struct ion_fd_data data = {
+                .handle = handle,
+        };
+        int ret = ion_ioctl(fd, ION_IOC_MAP, &data);
+        if (ret < 0)
+                return ret;
+        *map_fd = data.fd;
+        if (*map_fd < 0) {
+                LOGE("map ioctl returned negative fd\n");
+                return -EINVAL;
+        }
+        *ptr = mmap(NULL, length, prot, flags, *map_fd, offset);
+        if (*ptr == MAP_FAILED) {
+                LOGE("mmap failed: %s\n", strerror(errno));
+                return -errno;
+        }
+        return ret;
+}
+
+int ion_share(int fd, struct ion_handle *handle, int *share_fd)
+{
+        int map_fd;
+        struct ion_fd_data data = {
+                .handle = handle,
+        };
+        int ret = ion_ioctl(fd, ION_IOC_SHARE, &data);
+        if (ret < 0)
+                return ret;
+        *share_fd = data.fd;
+        if (*share_fd < 0) {
+                LOGE("map ioctl returned negative fd\n");
+                return -EINVAL;
+        }
+        return ret;
+}
+
+int ion_import(int fd, int share_fd, struct ion_handle **handle)
+{
+        struct ion_fd_data data = {
+                .fd = share_fd,
+        };
+        int ret = ion_ioctl(fd, ION_IOC_IMPORT, &data);
+        if (ret < 0)
+                return ret;
+        *handle = data.handle;
+        return ret;
+}
diff --git a/ion/ion.h b/ion/ion.h
new file mode 100644
index 0000000..871b9bc
--- /dev/null
+++ b/ion/ion.h
@@ -0,0 +1,35 @@
+/*
+ *  ion.c
+ *
+ * Memory Allocator functions for ion
+ *
+ *   Copyright 2011 Google, Inc
+ *
+ *  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.
+ */
+
+#include <linux/ion.h>
+#include <linux/omap_ion.h>
+
+int ion_open();
+int ion_close(int fd);
+int ion_alloc(int fd, size_t len, size_t align, unsigned int flags,
+              struct ion_handle **handle);
+int ion_alloc_tiler(int fd, size_t w, size_t h, int fmt, unsigned int flags,
+		    struct ion_handle **handle, size_t *stride);
+int ion_free(int fd, struct ion_handle *handle);
+int ion_map(int fd, struct ion_handle *handle, size_t length, int prot,
+            int flags, off_t offset, unsigned char **ptr, int *map_fd);
+int ion_share(int fd, struct ion_handle *handle, int *share_fd);
+int ion_import(int fd, int share_fd, struct ion_handle **handle);
+
diff --git a/ion/ion_test.c b/ion/ion_test.c
new file mode 100644
index 0000000..734caca
--- /dev/null
+++ b/ion/ion_test.c
@@ -0,0 +1,321 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "ion.h"
+#include <linux/ion.h>
+#include <linux/omap_ion.h>
+
+size_t len = 1024*1024, align = 0;
+int prot = PROT_READ | PROT_WRITE;
+int map_flags = MAP_SHARED;
+int alloc_flags = 0;
+int test = -1;
+size_t width = 1024*1024, height = 1024*1024;
+int fmt = TILER_PIXEL_FMT_32BIT;
+int tiler_test = 0;
+size_t stride;
+
+int _ion_alloc_test(int *fd, struct ion_handle **handle)
+{
+	int ret;
+
+	*fd = ion_open();
+	if (*fd < 0)
+		return *fd;
+
+	if (tiler_test)
+		ret = ion_alloc_tiler(*fd, width, height, fmt, alloc_flags,
+					  handle, &stride);
+	else
+		ret = ion_alloc(*fd, len, align, alloc_flags, handle);
+
+	if (ret)
+		printf("%s failed: %s\n", __func__, strerror(ret));
+	return ret;
+}
+
+void ion_alloc_test()
+{
+	int fd, ret;
+	struct ion_handle *handle;
+
+	if(_ion_alloc_test(&fd, &handle))
+			return;
+
+	ret = ion_free(fd, handle);
+	if (ret) {
+		printf("%s failed: %s %p\n", __func__, strerror(ret), handle);
+		return;
+	}
+	ion_close(fd);
+	printf("ion alloc test: passed\n");
+}
+
+void _ion_tiler_map_test(unsigned char *ptr)
+{
+	size_t row, col;
+
+	for (row = 0; row < height; row++)
+		for (col = 0; col < width; col++) {
+			int i = (row * stride) + col;
+			ptr[i] = (unsigned char)i;
+		}
+	for (row = 0; row < height; row++)
+		for (col = 0; col < width; col++) {
+			int i = (row * stride) + col;
+			if (ptr[i] != (unsigned char)i)
+				printf("%s failed wrote %d read %d from mapped "
+					   "memory\n", __func__, i, ptr[i]);
+		}
+}
+
+
+void ion_map_test()
+{
+	int fd, map_fd, ret;
+	size_t i;
+	struct ion_handle *handle;
+	unsigned char *ptr;
+
+	if(_ion_alloc_test(&fd, &handle))
+		return;
+
+	if (tiler_test)
+		len = height * stride;
+	ret = ion_map(fd, handle, len, prot, map_flags, 0, &ptr, &map_fd);
+	if (ret)
+		return;
+
+	if (tiler_test)
+		_ion_tiler_map_test(ptr);
+	else {
+		for (i = 0; i < len; i++) {
+			ptr[i] = (unsigned char)i;
+		}
+		for (i = 0; i < len; i++)
+			if (ptr[i] != (unsigned char)i)
+				printf("%s failed wrote %d read %d from mapped "
+					   "memory\n", __func__, i, ptr[i]);
+	}
+	/* clean up properly */
+	ret = ion_free(fd, handle);
+	ion_close(fd);
+	munmap(ptr, len);
+	close(map_fd);
+
+	_ion_alloc_test(&fd, &handle);
+	close(fd);
+
+#if 0
+	munmap(ptr, len);
+	close(map_fd);
+	ion_close(fd);
+
+	_ion_alloc_test(len, align, flags, &fd, &handle);
+	close(map_fd);
+	ret = ion_map(fd, handle, len, prot, flags, 0, &ptr, &map_fd);
+	/* don't clean up */
+#endif
+}
+
+void ion_share_test()
+
+{
+	struct ion_handle *handle;
+	int sd[2];
+	int num_fd = 1;
+	struct iovec count_vec = {
+		.iov_base = &num_fd,
+		.iov_len = sizeof num_fd,
+	};
+	char buf[CMSG_SPACE(sizeof(int))];
+	socketpair(AF_UNIX, SOCK_STREAM, 0, sd);
+	if (fork()) {
+		struct msghdr msg = {
+			.msg_control = buf,
+			.msg_controllen = sizeof buf,
+			.msg_iov = &count_vec,
+			.msg_iovlen = 1,
+		};
+
+		struct cmsghdr *cmsg;
+		int fd, share_fd, ret;
+		char *ptr;
+		/* parent */
+		if(_ion_alloc_test(&fd, &handle))
+			return;
+		ret = ion_share(fd, handle, &share_fd);
+		if (ret)
+			printf("share failed %s\n", strerror(errno));
+		ptr = mmap(NULL, len, prot, map_flags, share_fd, 0);
+		if (ptr == MAP_FAILED) {
+			return;
+		}
+		strcpy(ptr, "master");
+		cmsg = CMSG_FIRSTHDR(&msg);
+		cmsg->cmsg_level = SOL_SOCKET;
+		cmsg->cmsg_type = SCM_RIGHTS;
+		cmsg->cmsg_len = CMSG_LEN(sizeof(int));
+		*(int *)CMSG_DATA(cmsg) = share_fd;
+		/* send the fd */
+		printf("master? [%10s] should be [master]\n", ptr);
+		printf("master sending msg 1\n");
+		sendmsg(sd[0], &msg, 0);
+		if (recvmsg(sd[0], &msg, 0) < 0)
+			perror("master recv msg 2");
+		printf("master? [%10s] should be [child]\n", ptr);
+
+		/* send ping */
+		sendmsg(sd[0], &msg, 0);
+		printf("master->master? [%10s]\n", ptr);
+		if (recvmsg(sd[0], &msg, 0) < 0)
+			perror("master recv 1");
+	} else {
+		struct msghdr msg;
+		struct cmsghdr *cmsg;
+		char* ptr;
+		int fd, recv_fd;
+		char* child_buf[100];
+		/* child */
+		struct iovec count_vec = {
+			.iov_base = child_buf,
+			.iov_len = sizeof child_buf,
+		};
+
+		struct msghdr child_msg = {
+			.msg_control = buf,
+			.msg_controllen = sizeof buf,
+			.msg_iov = &count_vec,
+			.msg_iovlen = 1,
+		};
+
+		if (recvmsg(sd[1], &child_msg, 0) < 0)
+			perror("child recv msg 1");
+		cmsg = CMSG_FIRSTHDR(&child_msg);
+		if (cmsg == NULL) {
+			printf("no cmsg rcvd in child");
+			return;
+		}
+		recv_fd = *(int*)CMSG_DATA(cmsg);
+		if (recv_fd < 0) {
+			printf("could not get recv_fd from socket");
+			return;
+		}
+		printf("child %d\n", recv_fd);
+		fd = ion_open();
+		ptr = mmap(NULL, len, prot, map_flags, recv_fd, 0);
+		if (ptr == MAP_FAILED) {
+			return;
+		}
+		printf("child? [%10s] should be [master]\n", ptr);
+		strcpy(ptr, "child");
+		printf("child sending msg 2\n");
+		sendmsg(sd[1], &child_msg, 0);
+	}
+}
+
+int main(int argc, char* argv[]) {
+	int c;
+	enum tests {
+		ALLOC_TEST = 0, MAP_TEST, SHARE_TEST,
+	};
+
+	while (1) {
+		static struct option opts[] = {
+			{"alloc", no_argument, 0, 'a'},
+			{"alloc_flags", required_argument, 0, 'f'},
+			{"map", no_argument, 0, 'm'},
+			{"share", no_argument, 0, 's'},
+			{"len", required_argument, 0, 'l'},
+			{"align", required_argument, 0, 'g'},
+			{"map_flags", required_argument, 0, 'z'},
+			{"prot", required_argument, 0, 'p'},
+			{"alloc_tiler", no_argument, 0, 't'},
+			{"width", required_argument, 0, 'w'},
+			{"height", required_argument, 0, 'h'},
+			{"fmt", required_argument, 0, 'r'},
+		};
+		int i = 0;
+		c = getopt_long(argc, argv, "af:h:l:mr:stw:", opts, &i);
+		if (c == -1)
+			break;
+
+		switch (c) {
+		case 'l':
+			len = atol(optarg);
+			break;
+		case 'g':
+			align = atol(optarg);
+			break;
+		case 'z':
+			map_flags = 0;
+			map_flags |= strstr(optarg, "PROT_EXEC") ?
+				PROT_EXEC : 0;
+			map_flags |= strstr(optarg, "PROT_READ") ?
+				PROT_READ: 0;
+			map_flags |= strstr(optarg, "PROT_WRITE") ?
+				PROT_WRITE: 0;
+			map_flags |= strstr(optarg, "PROT_NONE") ?
+				PROT_NONE: 0;
+			break;
+		case 'p':
+			prot = 0;
+			prot |= strstr(optarg, "MAP_PRIVATE") ?
+				MAP_PRIVATE	 : 0;
+			prot |= strstr(optarg, "MAP_SHARED") ?
+				MAP_PRIVATE	 : 0;
+			break;
+		case 'f':
+			alloc_flags = atol(optarg);
+			break;
+		case 'a':
+			test = ALLOC_TEST;
+			break;
+		case 'm':
+			test = MAP_TEST;
+			break;
+		case 'r':
+			fmt = atol(optarg);
+			break;
+		case 's':
+			test = SHARE_TEST;
+			break;
+		case 'w':
+			width = atol(optarg);
+			break;
+		case 'h':
+			height = atol(optarg);
+			break;
+		case 't':
+			tiler_test = 1;
+			break;
+		}
+	}
+	printf("test %d, len %u, width %u, height %u fmt %u align %u, "
+		   "map_flags %d, prot %d, alloc_flags %d\n", test, len, width,
+		   height, fmt, align, map_flags, prot, alloc_flags);
+	switch (test) {
+		case ALLOC_TEST:
+			ion_alloc_test();
+			break;
+		case MAP_TEST:
+			ion_map_test();
+			break;
+		case SHARE_TEST:
+			ion_share_test();
+			break;
+		default:
+			printf("must specify a test (alloc, map, share)\n");
+	}
+	return 0;
+}
diff --git a/libstagefrighthw/Android.mk b/libstagefrighthw/Android.mk
new file mode 100644
index 0000000..c1757f2
--- /dev/null
+++ b/libstagefrighthw/Android.mk
@@ -0,0 +1,23 @@
+ifeq ($(TARGET_BOARD_PLATFORM),omap4)
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+    TIOMXPlugin.cpp
+
+LOCAL_C_INCLUDES:= \
+        $(TOP)/frameworks/base/include/media/stagefright/openmax
+
+LOCAL_SHARED_LIBRARIES :=       \
+        libbinder               \
+        libutils                \
+        libcutils               \
+        libui                   \
+        libdl                   \
+
+LOCAL_MODULE := libstagefrighthw
+
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
+endif
diff --git a/libstagefrighthw/TIOMXPlugin.cpp b/libstagefrighthw/TIOMXPlugin.cpp
new file mode 100644
index 0000000..14c5e91
--- /dev/null
+++ b/libstagefrighthw/TIOMXPlugin.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2009 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.
+ */
+
+#include "TIOMXPlugin.h"
+
+#include <dlfcn.h>
+
+#include <media/stagefright/HardwareAPI.h>
+#include <media/stagefright/MediaDebug.h>
+
+namespace android {
+
+extern "C" OMXPluginBase *createOMXPlugin() {
+    return new TIOMXPlugin;
+}
+
+extern "C" void destroyOMXPlugin(OMXPluginBase *plugin) {
+    delete plugin;
+}
+
+#define LIBOMX "libOMX_Core.so"
+
+TIOMXPlugin::TIOMXPlugin()
+    : mLibHandle(dlopen(LIBOMX, RTLD_NOW)),
+      mInit(NULL),
+      mDeinit(NULL),
+      mComponentNameEnum(NULL),
+      mGetHandle(NULL),
+      mFreeHandle(NULL),
+      mGetRolesOfComponentHandle(NULL) {
+    if (mLibHandle != NULL) {
+        mInit = (InitFunc)dlsym(mLibHandle, "TIOMX_Init");
+        mDeinit = (DeinitFunc)dlsym(mLibHandle, "TIOMX_DeInit");
+
+        mComponentNameEnum =
+            (ComponentNameEnumFunc)dlsym(mLibHandle, "TIOMX_ComponentNameEnum");
+
+        mGetHandle = (GetHandleFunc)dlsym(mLibHandle, "TIOMX_GetHandle");
+        mFreeHandle = (FreeHandleFunc)dlsym(mLibHandle, "TIOMX_FreeHandle");
+
+        mGetRolesOfComponentHandle =
+            (GetRolesOfComponentFunc)dlsym(
+                    mLibHandle, "TIOMX_GetRolesOfComponent");
+
+        (*mInit)();
+    }
+    else
+        LOGE("%s: failed to load %s", __func__, LIBOMX);
+}
+
+TIOMXPlugin::~TIOMXPlugin() {
+    if (mLibHandle != NULL) {
+        (*mDeinit)();
+
+        dlclose(mLibHandle);
+        mLibHandle = NULL;
+    }
+}
+
+OMX_ERRORTYPE TIOMXPlugin::makeComponentInstance(
+        const char *name,
+        const OMX_CALLBACKTYPE *callbacks,
+        OMX_PTR appData,
+        OMX_COMPONENTTYPE **component) {
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mGetHandle)(
+            reinterpret_cast<OMX_HANDLETYPE *>(component),
+            const_cast<char *>(name),
+            appData, const_cast<OMX_CALLBACKTYPE *>(callbacks));
+}
+
+OMX_ERRORTYPE TIOMXPlugin::destroyComponentInstance(
+        OMX_COMPONENTTYPE *component) {
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mFreeHandle)(reinterpret_cast<OMX_HANDLETYPE *>(component));
+}
+
+OMX_ERRORTYPE TIOMXPlugin::enumerateComponents(
+        OMX_STRING name,
+        size_t size,
+        OMX_U32 index) {
+    if (mLibHandle == NULL) {
+	LOGE("mLibHandle is NULL!");
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mComponentNameEnum)(name, size, index);
+}
+
+OMX_ERRORTYPE TIOMXPlugin::getRolesOfComponent(
+        const char *name,
+        Vector<String8> *roles) {
+    roles->clear();
+
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    OMX_U32 numRoles;
+    OMX_ERRORTYPE err = (*mGetRolesOfComponentHandle)(
+            const_cast<OMX_STRING>(name), &numRoles, NULL);
+
+    if (err != OMX_ErrorNone) {
+        return err;
+    }
+
+    if (numRoles > 0) {
+        OMX_U8 **array = new OMX_U8 *[numRoles];
+        for (OMX_U32 i = 0; i < numRoles; ++i) {
+            array[i] = new OMX_U8[OMX_MAX_STRINGNAME_SIZE];
+        }
+
+        err = (*mGetRolesOfComponentHandle)(
+                const_cast<OMX_STRING>(name), &numRoles, array);
+
+        CHECK_EQ(err, OMX_ErrorNone);
+
+        for (OMX_U32 i = 0; i < numRoles; ++i) {
+            String8 s((const char *)array[i]);
+            roles->push(s);
+
+            delete[] array[i];
+            array[i] = NULL;
+        }
+
+        delete[] array;
+        array = NULL;
+    }
+
+    return OMX_ErrorNone;
+}
+
+}  // namespace android
diff --git a/libstagefrighthw/TIOMXPlugin.h b/libstagefrighthw/TIOMXPlugin.h
new file mode 100644
index 0000000..668c5ef
--- /dev/null
+++ b/libstagefrighthw/TIOMXPlugin.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2009 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 TI_OMX_PLUGIN_H_
+
+#define TI_OMX_PLUGIN_H_
+
+#include <media/stagefright/OMXPluginBase.h>
+
+namespace android {
+
+struct TIOMXPlugin : public OMXPluginBase {
+    TIOMXPlugin();
+    virtual ~TIOMXPlugin();
+
+    virtual OMX_ERRORTYPE makeComponentInstance(
+            const char *name,
+            const OMX_CALLBACKTYPE *callbacks,
+            OMX_PTR appData,
+            OMX_COMPONENTTYPE **component);
+
+    virtual OMX_ERRORTYPE destroyComponentInstance(
+            OMX_COMPONENTTYPE *component);
+
+    virtual OMX_ERRORTYPE enumerateComponents(
+            OMX_STRING name,
+            size_t size,
+            OMX_U32 index);
+
+    virtual OMX_ERRORTYPE getRolesOfComponent(
+            const char *name,
+            Vector<String8> *roles);
+
+private:
+    void *mLibHandle;
+
+    typedef OMX_ERRORTYPE (*InitFunc)();
+    typedef OMX_ERRORTYPE (*DeinitFunc)();
+    typedef OMX_ERRORTYPE (*ComponentNameEnumFunc)(
+            OMX_STRING, OMX_U32, OMX_U32);
+
+    typedef OMX_ERRORTYPE (*GetHandleFunc)(
+            OMX_HANDLETYPE *, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE *);
+
+    typedef OMX_ERRORTYPE (*FreeHandleFunc)(OMX_HANDLETYPE *);
+
+    typedef OMX_ERRORTYPE (*GetRolesOfComponentFunc)(
+            OMX_STRING, OMX_U32 *, OMX_U8 **);
+
+    InitFunc mInit;
+    DeinitFunc mDeinit;
+    ComponentNameEnumFunc mComponentNameEnum;
+    GetHandleFunc mGetHandle;
+    FreeHandleFunc mFreeHandle;
+    GetRolesOfComponentFunc mGetRolesOfComponentHandle;
+
+    TIOMXPlugin(const TIOMXPlugin &);
+    TIOMXPlugin &operator=(const TIOMXPlugin &);
+};
+
+}  // namespace android
+
+#endif  // TI_OMX_PLUGIN_H_
diff --git a/libtiutils/Android.mk b/libtiutils/Android.mk
new file mode 100755
index 0000000..7312222
--- /dev/null
+++ b/libtiutils/Android.mk
@@ -0,0 +1,35 @@
+################################################
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_SRC_FILES:= \
+    MessageQueue.cpp \
+    Semaphore.cpp \
+    ErrorUtils.cpp
+    
+LOCAL_SHARED_LIBRARIES:= \
+    libdl \
+    libui \
+    libbinder \
+    libutils \
+    libcutils
+
+LOCAL_C_INCLUDES += \
+        kernel/android-2.6.29/include \
+	frameworks/base/include/utils \
+	bionic/libc/include \
+	hardware/ti/omap4xxx/domx/omx_core/inc \
+	hardware/ti/omap4xxx/domx/mm_osal/inc
+	
+LOCAL_CFLAGS += -fno-short-enums 
+
+# LOCAL_CFLAGS +=
+
+LOCAL_MODULE:= libtiutils
+LOCAL_MODULE_TAGS:= optional
+
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
diff --git a/libtiutils/DebugUtils.h b/libtiutils/DebugUtils.h
new file mode 100644
index 0000000..54edfc7
--- /dev/null
+++ b/libtiutils/DebugUtils.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 DEBUG_UTILS_H
+#define DEBUG_UTILS_H
+
+///Defines for debug statements - Macro LOG_TAG needs to be defined in the respective files
+#define DBGUTILS_LOGVA(str)         LOGV("%s:%d %s - " str,__FILE__, __LINE__,__FUNCTION__);
+#define DBGUTILS_LOGVB(str,...)     LOGV("%s:%d %s - " str,__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__);
+#define DBGUTILS_LOGDA(str)         LOGD("%s:%d %s - " str,__FILE__, __LINE__,__FUNCTION__);
+#define DBGUTILS_LOGDB(str, ...)    LOGD("%s:%d %s - " str,__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__);
+#define DBGUTILS_LOGEA(str)         LOGE("%s:%d %s - " str,__FILE__, __LINE__, __FUNCTION__);
+#define DBGUTILS_LOGEB(str, ...)    LOGE("%s:%d %s - " str,__FILE__, __LINE__,__FUNCTION__, __VA_ARGS__);
+#define LOG_FUNCTION_NAME           LOGV("%d: %s() ENTER", __LINE__, __FUNCTION__);
+#define LOG_FUNCTION_NAME_EXIT      LOGV("%d: %s() EXIT", __LINE__, __FUNCTION__);
+
+
+
+
+#endif //DEBUG_UTILS_H
+
diff --git a/libtiutils/ErrorUtils.cpp b/libtiutils/ErrorUtils.cpp
new file mode 100644
index 0000000..df0e51c
--- /dev/null
+++ b/libtiutils/ErrorUtils.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+
+#include "ErrorUtils.h"
+
+namespace android {
+
+/**
+   @brief Method to convert from POSIX to Android errors
+
+   @param error Any of the standard POSIX error codes (defined in bionic/libc/kernel/common/asm-generic/errno.h)
+   @return Any of the standard Android error code (defined in frameworks/base/include/utils/Errors.h)
+ */
+status_t ErrorUtils::posixToAndroidError(int error)
+{
+    switch(error)
+        {
+        case 0:
+            return NO_ERROR;
+        case EINVAL:
+        case EFBIG:
+        case EMSGSIZE:
+        case E2BIG:
+        case EFAULT:
+        case EILSEQ:
+            return BAD_VALUE;
+        case ENOSYS:
+            return INVALID_OPERATION;
+        case EACCES:
+        case EPERM:
+            return PERMISSION_DENIED;
+        case EADDRINUSE:
+        case EAGAIN:
+        case EALREADY:
+        case EBUSY:
+        case EEXIST:
+        case EINPROGRESS:
+            return ALREADY_EXISTS;
+        case ENOMEM:
+            return NO_MEMORY;
+        default:
+            return UNKNOWN_ERROR;
+        };
+
+    return NO_ERROR;
+}
+
+
+/**
+   @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;
+}
+
+
+};
+
+
+
diff --git a/libtiutils/ErrorUtils.h b/libtiutils/ErrorUtils.h
new file mode 100644
index 0000000..24dd806
--- /dev/null
+++ b/libtiutils/ErrorUtils.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 ERROR_UTILS_H
+#define ERROR_UTILS_H
+
+///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
+class ErrorUtils
+{
+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);
+
+};
+
+};
+
+#endif /// ERROR_UTILS_H
diff --git a/libtiutils/MessageQueue.cpp b/libtiutils/MessageQueue.cpp
new file mode 100755
index 0000000..1a5942a
--- /dev/null
+++ b/libtiutils/MessageQueue.cpp
@@ -0,0 +1,397 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <Errors.h>
+
+
+
+#define LOG_TAG "MessageQueue"
+#include <utils/Log.h>
+
+#include "MessageQueue.h"
+
+namespace TIUTILS {
+
+/**
+   @brief Constructor for the message queue class
+
+   @param none
+   @return none
+ */
+MessageQueue::MessageQueue()
+{
+    LOG_FUNCTION_NAME;
+
+    int fds[2] = {-1,-1};
+    android::status_t stat;
+
+    stat = pipe(fds);
+
+    if ( 0 > stat )
+        {
+        MSGQ_LOGEB("Error while openning pipe: %s", strerror(stat) );
+        this->fd_read = 0;
+        this->fd_write = 0;
+        mHasMsg = false;
+        }
+    else
+        {
+        this->fd_read = fds[0];
+        this->fd_write = fds[1];
+
+        mHasMsg = false;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Destructor for the semaphore class
+
+   @param none
+   @return none
+ */
+MessageQueue::~MessageQueue()
+{
+    LOG_FUNCTION_NAME;
+
+    if(this->fd_read)
+        {
+        close(this->fd_read);
+        }
+
+    if(this->fd_write)
+        {
+        close(this->fd_write);
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Get a message from the queue
+
+   @param msg Message structure to hold the message to be retrieved
+   @return android::NO_ERROR On success
+   @return android::BAD_VALUE if the message pointer is NULL
+   @return android::NO_INIT If the file read descriptor is not set
+   @return android::UNKNOWN_ERROR if the read operation fromthe file read descriptor fails
+ */
+android::status_t MessageQueue::get(Message* msg)
+{
+    LOG_FUNCTION_NAME;
+
+    if(!msg)
+        {
+        MSGQ_LOGEA("msg is NULL");
+        LOG_FUNCTION_NAME_EXIT;
+        return android::BAD_VALUE;
+        }
+
+    if(!this->fd_read)
+        {
+        MSGQ_LOGEA("read descriptor not initialized for message queue");
+        LOG_FUNCTION_NAME_EXIT;
+        return android::NO_INIT;
+        }
+
+    char* p = (char*) msg;
+    size_t read_bytes = 0;
+
+    while( read_bytes  < sizeof(*msg) )
+        {
+        int err = read(this->fd_read, p, sizeof(*msg) - read_bytes);
+
+        if( err < 0 )
+            {
+            MSGQ_LOGEB("read() error: %s", strerror(errno));
+            return android::UNKNOWN_ERROR;
+            }
+        else
+            {
+            read_bytes += err;
+            }
+        }
+
+    MSGQ_LOGDB("MQ.get(%d,%p,%p,%p,%p)", msg->command, msg->arg1,msg->arg2,msg->arg3,msg->arg4);
+
+    mHasMsg = false;
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return 0;
+}
+
+/**
+   @brief Get the input file descriptor of the message queue
+
+   @param none
+   @return file read descriptor
+ */
+
+int MessageQueue::getInFd()
+{
+    return this->fd_read;
+}
+
+/**
+   @brief Constructor for the message queue class
+
+   @param fd file read descriptor
+   @return none
+ */
+
+void MessageQueue::setInFd(int fd)
+{
+    LOG_FUNCTION_NAME;
+
+    if ( -1 != this->fd_read )
+        {
+        close(this->fd_read);
+        }
+
+    this->fd_read = fd;
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+/**
+   @brief Queue a message
+
+   @param msg Message structure to hold the message to be retrieved
+   @return android::NO_ERROR On success
+   @return android::BAD_VALUE if the message pointer is NULL
+   @return android::NO_INIT If the file write descriptor is not set
+   @return android::UNKNOWN_ERROR if the write operation fromthe file write descriptor fails
+ */
+
+android::status_t MessageQueue::put(Message* msg)
+{
+    LOG_FUNCTION_NAME;
+
+    char* p = (char*) msg;
+    size_t bytes = 0;
+
+    if(!msg)
+        {
+        MSGQ_LOGEA("msg is NULL");
+        LOG_FUNCTION_NAME_EXIT;
+        return android::BAD_VALUE;
+        }
+
+    if(!this->fd_write)
+        {
+        MSGQ_LOGEA("write descriptor not initialized for message queue");
+        LOG_FUNCTION_NAME_EXIT;
+        return android::NO_INIT;
+        }
+
+
+    MSGQ_LOGDB("MQ.put(%d,%p,%p,%p,%p)", msg->command, msg->arg1,msg->arg2,msg->arg3,msg->arg4);
+
+    while( bytes  < sizeof(msg) )
+        {
+        int err = write(this->fd_write, p, sizeof(*msg) - bytes);
+
+        if( err < 0 )
+            {
+            MSGQ_LOGEB("write() error: %s", strerror(errno));
+            LOG_FUNCTION_NAME_EXIT;
+            return android::UNKNOWN_ERROR;
+            }
+        else
+            {
+            bytes += err;
+            }
+        }
+
+    MSGQ_LOGDA("MessageQueue::put EXIT");
+
+    LOG_FUNCTION_NAME_EXIT;
+    return 0;
+}
+
+
+/**
+   @brief Returns if the message queue is empty or not
+
+   @param none
+   @return true If the queue is empty
+   @return false If the queue has at least one message
+ */
+bool MessageQueue::isEmpty()
+{
+    LOG_FUNCTION_NAME;
+
+    struct pollfd pfd;
+
+    pfd.fd = this->fd_read;
+    pfd.events = POLLIN;
+    pfd.revents = 0;
+
+    if(!this->fd_read)
+        {
+        MSGQ_LOGEA("read descriptor not initialized for message queue");
+        LOG_FUNCTION_NAME_EXIT;
+        return android::NO_INIT;
+        }
+
+
+    if( -1 == poll(&pfd,1,0) )
+        {
+        MSGQ_LOGEB("poll() error: %s", strerror(errno));
+        LOG_FUNCTION_NAME_EXIT;
+        return false;
+        }
+
+    if(pfd.revents & POLLIN)
+        {
+        mHasMsg = true;
+        }
+    else
+        {
+        mHasMsg = false;
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+    return !mHasMsg;
+}
+
+/**
+   @brief Force whether the message queue has message or not
+
+   @param hasMsg Whether the queue has a message or not
+   @return none
+ */
+void MessageQueue::setMsg(bool hasMsg)
+    {
+    mHasMsg = hasMsg;
+    }
+
+
+/**
+   @briefWait for message in maximum three different queues with a timeout
+
+   @param queue1 First queue. At least this should be set to a valid queue pointer
+   @param queue2 Second queue. Optional.
+   @param queue3 Third queue. Optional.
+   @param timeout The timeout value (in micro secs) to wait for a message in any of the queues
+   @return android::NO_ERROR On success
+   @return android::BAD_VALUE If queue1 is NULL
+   @return android::NO_INIT If the file read descriptor of any of the provided queues is not set
+ */
+android::status_t MessageQueue::waitForMsg(MessageQueue *queue1, MessageQueue *queue2, MessageQueue *queue3, int timeout)
+    {
+    LOG_FUNCTION_NAME;
+
+    int n =1;
+    struct pollfd pfd[3];
+
+    if(!queue1)
+        {
+        MSGQ_LOGEA("queue1 pointer is NULL");
+        LOG_FUNCTION_NAME_EXIT;
+        return android::BAD_VALUE;
+        }
+
+    pfd[0].fd = queue1->getInFd();
+    if(!pfd[0].fd)
+        {
+        MSGQ_LOGEA("read descriptor not initialized for message queue1");
+        LOG_FUNCTION_NAME_EXIT;
+        return android::NO_INIT;
+        }
+    pfd[0].events = POLLIN;
+    pfd[0].revents = 0;
+    if(queue2)
+        {
+        MSGQ_LOGDA("queue2 not-null");
+        pfd[1].fd = queue2->getInFd();
+        if(!pfd[1].fd)
+            {
+            MSGQ_LOGEA("read descriptor not initialized for message queue2");
+            LOG_FUNCTION_NAME_EXIT;
+            return android::NO_INIT;
+            }
+
+        pfd[1].events = POLLIN;
+        pfd[1].revents = 0;
+        n++;
+        }
+
+    if(queue3)
+        {
+        MSGQ_LOGDA("queue3 not-null");
+        pfd[2].fd = queue3->getInFd();
+        if(!pfd[2].fd)
+            {
+            MSGQ_LOGEA("read descriptor not initialized for message queue3");
+            LOG_FUNCTION_NAME_EXIT;
+            return android::NO_INIT;
+            }
+
+        pfd[2].events = POLLIN;
+        pfd[2].revents = 0;
+        n++;
+        }
+
+
+    int ret = poll(pfd, n, timeout);
+    if(ret==0)
+        {
+        LOG_FUNCTION_NAME_EXIT;
+        return ret;
+        }
+
+    if(ret<android::NO_ERROR)
+        {
+        MSGQ_LOGEB("Message queue returned error %d", ret);
+        LOG_FUNCTION_NAME_EXIT;
+        return ret;
+        }
+
+    if (pfd[0].revents & POLLIN)
+        {
+        queue1->setMsg(true);
+        }
+
+    if(queue2)
+        {
+        if (pfd[1].revents & POLLIN)
+            {
+            queue2->setMsg(true);
+            }
+        }
+
+    if(queue3)
+        {
+        if (pfd[2].revents & POLLIN)
+            {
+            queue3->setMsg(true);
+            }
+        }
+
+    LOG_FUNCTION_NAME_EXIT;
+    return ret;
+    }
+
+};
diff --git a/libtiutils/MessageQueue.h b/libtiutils/MessageQueue.h
new file mode 100755
index 0000000..97e11a7
--- /dev/null
+++ b/libtiutils/MessageQueue.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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 __MESSAGEQUEUE_H__
+#define __MESSAGEQUEUE_H__
+
+#include "DebugUtils.h"
+#include <stdint.h>
+
+///Uncomment this macro to debug the message queue implementation
+//#define DEBUG_LOG
+
+///Camera HAL Logging Functions
+#ifndef DEBUG_LOG
+
+#define MSGQ_LOGDA(str)
+#define MSGQ_LOGDB(str, ...)
+
+#undef LOG_FUNCTION_NAME
+#undef LOG_FUNCTION_NAME_EXIT
+#define LOG_FUNCTION_NAME
+#define LOG_FUNCTION_NAME_EXIT
+
+#else
+
+#define MSGQ_LOGDA DBGUTILS_LOGDA
+#define MSGQ_LOGDB DBGUTILS_LOGDB
+
+#endif
+
+#define MSGQ_LOGEA DBGUTILS_LOGEA
+#define MSGQ_LOGEB DBGUTILS_LOGEB
+
+
+namespace TIUTILS {
+
+///Message type
+struct Message
+{
+    unsigned int command;
+    void*        arg1;
+    void*        arg2;
+    void*        arg3;
+    void*        arg4;
+    int64_t     id;
+};
+
+///Message queue implementation
+class MessageQueue
+{
+public:
+
+    MessageQueue();
+    ~MessageQueue();
+
+    ///Get a message from the queue
+    android::status_t get(Message*);
+
+    ///Get the input file descriptor of the message queue
+    int getInFd();
+
+    ///Set the input file descriptor for the message queue
+    void setInFd(int fd);
+
+    ///Queue a message
+    android::status_t put(Message*);
+
+    ///Returns if the message queue is empty or not
+    bool isEmpty();
+
+    ///Force whether the message queue has message or not
+    void setMsg(bool hasMsg=false);
+
+    ///Wait for message in maximum three different queues with a timeout
+    static int waitForMsg(MessageQueue *queue1, MessageQueue *queue2=0, MessageQueue *queue3=0, int timeout = 0);
+
+    bool hasMsg()
+    {
+      return mHasMsg;
+    }
+
+private:
+    int fd_read;
+    int fd_write;
+    bool mHasMsg;
+};
+
+};
+
+#endif
diff --git a/libtiutils/Semaphore.cpp b/libtiutils/Semaphore.cpp
new file mode 100644
index 0000000..1f46dca
--- /dev/null
+++ b/libtiutils/Semaphore.cpp
@@ -0,0 +1,226 @@
+/*

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

+ *

+ * 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.

+ */

+

+

+

+#include "Semaphore.h"

+#include "ErrorUtils.h"

+#include <utils/Log.h>

+#include <time.h>

+

+namespace android {

+

+/**

+   @brief Constructor for the semaphore class

+

+   @param none

+   @return none

+ */

+Semaphore::Semaphore()

+{

+    ///Initialize the semaphore to NULL

+    mSemaphore = NULL;

+}

+

+/**

+   @brief Destructor of the semaphore class

+

+   @param none

+   @return none

+

+ */

+Semaphore::~Semaphore()

+{

+    Release();

+}

+

+/**

+   @brief: Releases semaphore

+

+   @param count >=0

+   @return NO_ERROR On Success

+   @return One of the android error codes based on semaphore de-initialization

+ */

+

+status_t Semaphore::Release()

+{

+    int status = 0;

+

+    ///Destroy only if the semaphore has been created

+    if(mSemaphore)

+        {

+        status = sem_destroy(mSemaphore);

+

+        free(mSemaphore);

+

+        mSemaphore = NULL;

+        }

+

+    ///Initialize the semaphore and return the status

+    return ErrorUtils::posixToAndroidError(status);

+

+}

+

+/**

+   @brief Create the semaphore with initial count value

+

+   @param count >=0

+   @return NO_ERROR On Success

+   @return NO_MEMORY If unable to allocate memory for the semaphore

+   @return BAD_VALUE If an invalid count value is passed (<0)

+   @return One of the android error codes based on semaphore initialization

+ */

+

+status_t Semaphore::Create(int count)

+{

+    status_t ret = NO_ERROR;

+

+    ///count cannot be less than zero

+    if(count<0)

+        {

+        return BAD_VALUE;

+        }

+

+    ret = Release();

+    if ( NO_ERROR != ret )

+        {

+        return ret;

+        }

+

+    ///allocate memory for the semaphore

+    mSemaphore = (sem_t*)malloc(sizeof(sem_t)) ;

+

+    ///if memory is unavailable, return error

+    if(!mSemaphore)

+        {

+        return NO_MEMORY;

+        }

+

+    ///Initialize the semaphore and return the status

+    return ErrorUtils::posixToAndroidError(sem_init(mSemaphore, 0x00, count));

+

+}

+

+/**

+   @brief Wait operation

+

+   @param none

+   @return BAD_VALUE if the semaphore is not initialized

+   @return NO_ERROR On success

+   @return One of the android error codes based on semaphore wait operation

+ */

+status_t Semaphore::Wait()

+{

+    ///semaphore should have been created first

+    if(!mSemaphore)

+        {

+        return BAD_VALUE;

+        }

+

+    ///Wait and return the status after signalling

+    return ErrorUtils::posixToAndroidError(sem_wait(mSemaphore));

+

+

+}

+

+

+/**

+   @brief Signal operation

+

+   @param none

+     @return BAD_VALUE if the semaphore is not initialized

+     @return NO_ERROR On success

+     @return One of the android error codes based on semaphore signal operation

+   */

+

+status_t Semaphore::Signal()

+{

+    ///semaphore should have been created first

+    if(!mSemaphore)

+        {

+        return BAD_VALUE;

+        }

+

+    ///Post to the semaphore

+    return ErrorUtils::posixToAndroidError(sem_post(mSemaphore));

+

+}

+

+/**

+   @brief Current semaphore count

+

+   @param none

+   @return Current count value of the semaphore

+ */

+int Semaphore::Count()

+{

+    int val;

+

+    ///semaphore should have been created first

+    if(!mSemaphore)

+        {

+        return BAD_VALUE;

+        }

+

+    ///get the value of the semaphore

+    sem_getvalue(mSemaphore, &val);

+

+    return val;

+}

+

+/**

+   @brief Wait operation with a timeout

+

+     @param timeoutMicroSecs The timeout period in micro seconds

+     @return BAD_VALUE if the semaphore is not initialized

+     @return NO_ERROR On success

+     @return One of the android error codes based on semaphore wait operation

+   */

+

+status_t Semaphore::WaitTimeout(int timeoutMicroSecs)

+{

+    status_t ret = NO_ERROR;

+

+    struct timespec timeSpec;

+    struct timeval currentTime;

+

+    ///semaphore should have been created first

+    if( NULL == mSemaphore)

+        {

+        ret = BAD_VALUE;

+        }

+

+    if ( NO_ERROR == ret )

+        {

+

+        ///setup the timeout values - timeout is specified in seconds and nanoseconds

+        gettimeofday(&currentTime, NULL);

+        timeSpec.tv_sec = currentTime.tv_sec;

+        timeSpec.tv_nsec = currentTime.tv_usec * 1000;

+        timeSpec.tv_sec += ( timeoutMicroSecs / 1000000 );

+        timeSpec.tv_nsec += ( timeoutMicroSecs % 1000000) * 1000;

+

+        ///Wait for the timeout or signal and return the result based on whichever event occurred first

+        ret = sem_timedwait(mSemaphore, &timeSpec);

+        }

+

+    return ret;

+}

+

+

+};

+

+

diff --git a/libtiutils/Semaphore.h b/libtiutils/Semaphore.h
new file mode 100644
index 0000000..466e709
--- /dev/null
+++ b/libtiutils/Semaphore.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+
+
+#include <Errors.h>
+#include <semaphore.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+namespace android {
+
+class Semaphore
+{
+public:
+
+    Semaphore();
+    ~Semaphore();
+
+    //Release semaphore
+    status_t Release();
+
+    ///Create the semaphore with initial count value
+    status_t Create(int count=0);
+
+    ///Wait operation
+    status_t Wait();
+
+    ///Signal operation
+    status_t Signal();
+
+    ///Current semaphore count
+    int Count();
+
+    ///Wait operation with a timeout
+    status_t WaitTimeout(int timeoutMicroSecs);
+
+private:
+    sem_t *mSemaphore;
+
+};
+
+};
diff --git a/libyv12colorconvert/Android.mk b/libyv12colorconvert/Android.mk
new file mode 100644
index 0000000..6f781f4
--- /dev/null
+++ b/libyv12colorconvert/Android.mk
@@ -0,0 +1,21 @@
+ifeq ($(TARGET_BOARD_PLATFORM),omap4)
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+    ColorConvert.cpp
+
+LOCAL_C_INCLUDES:= \
+        $(TOP)/frameworks/base/include/media/stagefright/openmax \
+        $(TOP)/frameworks/media/libvideoeditor/include
+
+LOCAL_SHARED_LIBRARIES :=       \
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_MODULE := libyv12colorconvert
+
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
+endif
diff --git a/libyv12colorconvert/ColorConvert.cpp b/libyv12colorconvert/ColorConvert.cpp
new file mode 100644
index 0000000..41dcbad
--- /dev/null
+++ b/libyv12colorconvert/ColorConvert.cpp
@@ -0,0 +1,114 @@
+/*
+ * 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.
+ */
+
+#include "IYV12ColorConverter.h"
+#include <OMX_IVCommon.h>
+#include <string.h>
+
+static int getDecoderOutputFormat() {
+    return OMX_TI_COLOR_FormatYUV420PackedSemiPlanar;
+}
+
+static int convertDecoderOutputToYV12(
+    void* srcBits, int srcWidth, int srcHeight, ARect srcRect, void* dstBits) {
+
+    const uint8_t *pSrc_y = (const uint8_t *)srcBits +
+        srcWidth * srcRect.top + srcRect.left;
+    const uint8_t *pSrc_uv = (const uint8_t *)pSrc_y +
+        srcWidth * (srcHeight - srcRect.top / 2);
+
+    int dstWidth = srcRect.right - srcRect.left + 1;
+    int dstHeight = srcRect.bottom - srcRect.top + 1;
+    size_t dst_y_size = dstWidth * dstHeight;
+    size_t dst_uv_stride = dstWidth / 2;
+    size_t dst_uv_size = dstWidth / 2 * dstHeight / 2;
+    uint8_t *pDst_y = (uint8_t *)dstBits;
+    uint8_t *pDst_u = pDst_y + dst_y_size;
+    uint8_t *pDst_v = pDst_u + dst_uv_size;
+
+    for (int y = 0; y < dstHeight; ++y) {
+        memcpy(pDst_y, pSrc_y, dstWidth);
+        pSrc_y += srcWidth;
+        pDst_y += dstWidth;
+    }
+
+    size_t tmp = (dstWidth + 1) / 2;
+    for (int y = 0; y < (dstHeight + 1) / 2; ++y) {
+        for (size_t x = 0; x < tmp; ++x) {
+            pDst_u[x] = pSrc_uv[2 * x];
+            pDst_v[x] = pSrc_uv[2 * x + 1];
+        }
+        pSrc_uv += srcWidth;
+        pDst_u += dst_uv_stride;
+        pDst_v += dst_uv_stride;
+    }
+    return 0;
+}
+
+static int getEncoderInputFormat() {
+    return OMX_TI_COLOR_FormatYUV420PackedSemiPlanar;
+}
+
+static int convertYV12ToEncoderInput(
+    void* srcBits, int srcWidth, int srcHeight,
+    int dstWidth, int dstHeight, ARect dstRect,
+    void* dstBits) {
+    uint8_t *pSrc_y = (uint8_t*) srcBits;
+    uint8_t *pDst_y = (uint8_t*) dstBits;
+    for(int i=0; i < srcHeight; i++) {
+        memcpy(pDst_y, pSrc_y, srcWidth);
+        pSrc_y += srcWidth;
+        pDst_y += dstWidth;
+    }
+    uint8_t* pSrc_u = (uint8_t*)srcBits + (srcWidth * srcHeight);
+    uint8_t* pSrc_v = (uint8_t*)pSrc_u + (srcWidth / 2) * (srcHeight / 2);
+    uint8_t* pDst_uv  = (uint8_t*)dstBits + dstWidth * dstHeight;
+
+    for(int i=0; i < srcHeight / 2; i++) {
+        for(int j=0, k=0; j < srcWidth / 2; j++, k+=2) {
+            pDst_uv[k] = pSrc_u[j];
+            pDst_uv[k+1] = pSrc_v[j];
+        }
+        pDst_uv += dstWidth;
+        pSrc_u += srcWidth / 2;
+        pSrc_v += srcWidth / 2;
+    }
+    return 0;
+}
+
+static int getEncoderInputBufferInfo(
+    int actualWidth, int actualHeight,
+    int* encoderWidth, int* encoderHeight,
+    ARect* encoderRect, int* encoderBufferSize) {
+
+    *encoderWidth = actualWidth;
+    *encoderHeight = actualHeight;
+    encoderRect->left = 0;
+    encoderRect->top = 0;
+    encoderRect->right = actualWidth - 1;
+    encoderRect->bottom = actualHeight - 1;
+    *encoderBufferSize = (actualWidth * actualHeight * 3 / 2);
+
+    return 0;
+}
+
+extern "C" void getYV12ColorConverter(IYV12ColorConverter *converter) {
+    converter->getDecoderOutputFormat = getDecoderOutputFormat;
+    converter->convertDecoderOutputToYV12 = convertDecoderOutputToYV12;
+    converter->getEncoderInputFormat = getEncoderInputFormat;
+    converter->convertYV12ToEncoderInput = convertYV12ToEncoderInput;
+    converter->getEncoderInputBufferInfo = getEncoderInputBufferInfo;
+}
diff --git a/mapinfo.c b/mapinfo.c
new file mode 100644
index 0000000..7f4250f
--- /dev/null
+++ b/mapinfo.c
@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "mapinfo.h"
+
+extern void *__real_malloc(size_t size);
+extern void __real_free(void *ptr);
+
+#if 0
+    while (p <= end) {
+         data = ptrace(PTRACE_PEEKTEXT, pid, (void*)p, NULL);
+         _LOG(tfd, (sp_depth > 2) || only_in_tombstone,
+              "    %08x  %08x  %s\n", p, data,
+              map_to_name(map, data, ""));
+         p += 4;
+    }
+#endif
+
+// 6f000000-6f01e000 rwxp 00000000 00:0c 16389419   /system/lib/libcomposer.so
+// 012345678901234567890123456789012345678901234567890123456789
+// 0         1         2         3         4         5
+
+static mapinfo *parse_maps_line(char *line)
+{
+    mapinfo *mi;
+    int len = strlen(line);
+
+    if(len < 1) return 0;
+    line[--len] = 0;
+
+    if(len < 50) return 0;
+    if(line[20] != 'x') return 0;
+
+    mi = __real_malloc(sizeof(mapinfo) + (len - 47));
+    if(mi == 0) return 0;
+
+    mi->start = strtoul(line, 0, 16);
+    mi->end = strtoul(line + 9, 0, 16);
+    /* To be filled in parse_elf_info if the mapped section starts with
+     * elf_header
+     */
+    mi->next = 0;
+    strcpy(mi->name, line + 49);
+
+    return mi;
+}
+
+mapinfo *init_mapinfo(int pid)
+{
+    struct mapinfo *milist = NULL;
+    char data[1024];
+    sprintf(data, "/proc/%d/maps", pid);
+    FILE *fp = fopen(data, "r");
+    if(fp) {
+        while(fgets(data, sizeof(data), fp)) {
+            mapinfo *mi = parse_maps_line(data);
+            if(mi) {
+                mi->next = milist;
+                milist = mi;
+            }
+        }
+        fclose(fp);
+    }
+
+    return milist;
+}
+
+void deinit_mapinfo(mapinfo *mi)
+{
+   mapinfo *del;
+   while(mi) {
+       del = mi;
+       mi = mi->next;
+       __real_free(del);
+   }
+}
+
+/* Map a pc address to the name of the containing ELF file */
+const char *map_to_name(mapinfo *mi, unsigned pc, const char* def)
+{
+    while(mi) {
+        if((pc >= mi->start) && (pc < mi->end)){
+            return mi->name;
+        }
+        mi = mi->next;
+    }
+    return def;
+}
+
+/* Find the containing map info for the pc */
+const mapinfo *pc_to_mapinfo(mapinfo *mi, unsigned pc, unsigned *rel_pc)
+{
+    *rel_pc = pc;
+    while(mi) {
+        if((pc >= mi->start) && (pc < mi->end)){
+            // Only calculate the relative offset for shared libraries
+            if (strstr(mi->name, ".so")) {
+                *rel_pc -= mi->start;
+            }
+            return mi;
+        }
+        mi = mi->next;
+    }
+    return NULL;
+}
diff --git a/mapinfo.h b/mapinfo.h
new file mode 100644
index 0000000..25adeb4
--- /dev/null
+++ b/mapinfo.h
@@ -0,0 +1,16 @@
+#ifndef MAPINFO_H
+#define MAPINFO_H
+
+typedef struct mapinfo {
+    struct mapinfo *next;
+    unsigned start;
+    unsigned end;
+    char name[];
+} mapinfo;
+
+mapinfo *init_mapinfo(int pid);
+void deinit_mapinfo(mapinfo *mi);
+const char *map_to_name(mapinfo *mi, unsigned pc, const char* def);
+const mapinfo *pc_to_mapinfo(mapinfo *mi, unsigned pc, unsigned *rel_pc);
+
+#endif
diff --git a/omap4.mk b/omap4.mk
new file mode 100644
index 0000000..1d1a877
--- /dev/null
+++ b/omap4.mk
@@ -0,0 +1,33 @@
+# 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.
+
+# This file lists the modules that are specific to OMAP4 but are used by
+# all OMAP4 devices.
+
+PRODUCT_PACKAGES := \
+	libdomx \
+	libOMX_Core \
+	libOMX.TI.DUCATI1.VIDEO.H264E \
+	libOMX.TI.DUCATI1.VIDEO.DECODER \
+	libOMX.TI.DUCATI1.VIDEO.CAMERA \
+	libOMX.TI.DUCATI1.MISC.SAMPLE \
+	libstagefrighthw \
+        libyv12colorconvert \
+	libtimemmgr \
+	libtiutils \
+	libcamera \
+	libion \
+	camera.omap4 \
+	libomxcameraadapter \
+	hwcomposer.omap4
diff --git a/stacktrace.c b/stacktrace.c
new file mode 100644
index 0000000..1e79bfa
--- /dev/null
+++ b/stacktrace.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include <unwind.h>
+#include <sys/types.h>
+
+// =============================================================================
+// stack trace functions
+// =============================================================================
+
+typedef struct
+{
+    size_t count;
+    intptr_t* addrs;
+} stack_crawl_state_t;
+
+
+/* depends how the system includes define this */
+#ifdef HAVE_UNWIND_CONTEXT_STRUCT
+typedef struct _Unwind_Context __unwind_context;
+#else
+typedef _Unwind_Context __unwind_context;
+#endif
+
+static _Unwind_Reason_Code trace_function(__unwind_context *context, void *arg)
+{
+    stack_crawl_state_t* state = (stack_crawl_state_t*)arg;
+    if (state->count) {
+        intptr_t ip = (intptr_t)_Unwind_GetIP(context);
+        if (ip) {
+            state->addrs[0] = ip;
+            state->addrs++;
+            state->count--;
+            return _URC_NO_REASON;
+        }
+    }
+    /*
+     * If we run out of space to record the address or 0 has been seen, stop
+     * unwinding the stack.
+     */
+    return _URC_END_OF_STACK;
+}
+
+int heaptracker_stacktrace(intptr_t* addrs, size_t max_entries)
+{
+    stack_crawl_state_t state;
+    state.count = max_entries;
+    state.addrs = (intptr_t*)addrs;
+    _Unwind_Backtrace(trace_function, (void*)&state);
+    return max_entries - state.count;
+}
diff --git a/test/CameraHal/Android.mk b/test/CameraHal/Android.mk
new file mode 100644
index 0000000..c7da48a
--- /dev/null
+++ b/test/CameraHal/Android.mk
@@ -0,0 +1,38 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	camera_test_menu.cpp \
+	camera_test_script.cpp
+
+LOCAL_SHARED_LIBRARIES:= \
+	libdl \
+	libui \
+	libutils \
+	libcutils \
+	libbinder \
+	libmedia \
+	libui \
+	libgui \
+	libcamera_client
+
+LOCAL_C_INCLUDES += \
+	frameworks/base/include/ui \
+	frameworks/base/include/surfaceflinger \
+	frameworks/base/include/camera \
+	frameworks/base/include/media \
+	$(PV_INCLUDES)
+
+LOCAL_MODULE:= camera_test
+LOCAL_MODULE_TAGS:= tests
+
+LOCAL_CFLAGS += -Wall -fno-short-enums -O0 -g -D___ANDROID___
+
+ifeq ($(TARGET_BOARD_PLATFORM),omap4)
+    LOCAL_CFLAGS += -DTARGET_OMAP4
+endif
+
+include $(BUILD_HEAPTRACKED_EXECUTABLE)
+
+
diff --git a/test/CameraHal/camera_test.h b/test/CameraHal/camera_test.h
new file mode 100644
index 0000000..6ff8eb3
--- /dev/null
+++ b/test/CameraHal/camera_test.h
@@ -0,0 +1,165 @@
+#ifndef CAMERA_TEST_H
+#define CAMERA_TEST_H
+
+#define PRINTOVER(arg...)     LOGD(#arg)
+#define LOG_FUNCTION_NAME         LOGD("%d: %s() ENTER", __LINE__, __FUNCTION__);
+#define LOG_FUNCTION_NAME_EXIT    LOGD("%d: %s() EXIT", __LINE__, __FUNCTION__);
+#define KEY_GBCE   "gbce"
+#define KEY_CAMERA          "camera-index"
+#define KEY_SATURATION      "saturation"
+#define KEY_BRIGHTNESS      "brightness"
+#define KEY_BURST           "burst-capture"
+#define KEY_EXPOSURE        "exposure"
+#define KEY_CONTRAST        "contrast"
+#define KEY_SHARPNESS       "sharpness"
+#define KEY_ISO             "iso"
+#define KEY_CAF             "caf"
+#define KEY_MODE            "mode"
+#define KEY_VNF             "vnf"
+#define KEY_VSTAB           "vstab"
+#define KEY_COMPENSATION    "exposure-compensation"
+
+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+#define KEY_IPP             "ippMode"
+#else
+#define KEY_IPP             "ipp"
+#endif
+
+#define KEY_BUFF_STARV      "buff-starvation"
+#define KEY_METERING_MODE   "meter-mode"
+#define KEY_AUTOCONVERGENCE "auto-convergence"
+#define KEY_MANUALCONVERGENCE_VALUES "manual-convergence-values"
+#define AUTOCONVERGENCE_MODE_MANUAL "mode-manual"
+#define KEY_EXP_BRACKETING_RANGE "exp-bracketing-range"
+#define KEY_TEMP_BRACKETING "temporal-bracketing"
+#define KEY_TEMP_BRACKETING_POS "temporal-bracketing-range-positive"
+#define KEY_TEMP_BRACKETING_NEG "temporal-bracketing-range-negative"
+#define KEY_MEASUREMENT "measurement"
+#define KEY_S3D2D_PREVIEW_MODE "s3d2d-preview"
+#define KEY_STEREO_CAMERA "s3d-supported"
+#define KEY_EXIF_MODEL "exif-model"
+#define KEY_EXIF_MAKE "exif-make"
+
+#define KEY_AUTO_EXPOSURE_LOCK "auto-exposure-lock"
+#define KEY_AUTO_WHITEBALANCE_LOCK "auto-whitebalance-lock"
+
+#define SDCARD_PATH "/sdcard/"
+
+#define MAX_BURST   15
+#define BURST_INC     5
+#define TEMP_BRACKETING_MAX_RANGE 4
+
+#define MEDIASERVER_DUMP "procmem -w $(ps | grep mediaserver | grep -Eo '[0-9]+' | head -n 1) | grep \"\\(Name\\|libcamera.so\\|libOMX\\|libomxcameraadapter.so\\|librcm.so\\|libnotify.so\\|libipcutils.so\\|libipc.so\\|libsysmgr.so\\|TOTAL\\)\""
+#define MEMORY_DUMP "procrank -u"
+#define KEY_METERING_MODE   "meter-mode"
+
+#define TEST_FOCUS_AREA "(0,0,1000,1000,300),(-1000,-1000,1000,1000,300),(0,0,0,0,0)"
+
+#define COMPENSATION_OFFSET 20
+#define DELIMITER           "|"
+
+#define MAX_PREVIEW_SURFACE_WIDTH   800
+#define MAX_PREVIEW_SURFACE_HEIGHT  480
+
+#define MODEL "camera_test"
+#define MAKE "camera_test"
+
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+namespace android {
+    class CameraHandler: public CameraListener {
+        public:
+            virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
+            virtual void postData(int32_t msgType,
+                                  const sp<IMemory>& dataPtr,
+                                  camera_frame_metadata_t *metadata);
+
+            virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
+    };
+
+};
+
+using namespace android;
+
+char * get_cycle_cmd(const char *aSrc);
+int execute_functional_script(char *script);
+status_t dump_mem_status();
+int openCamera();
+int closeCamera();
+void initDefaults();
+int startPreview();
+void stopPreview();
+int startRecording();
+int stopRecording();
+int closeRecorder();
+int openRecorder();
+int configureRecorder();
+void printSupportedParams();
+char *load_script(char *config);
+int start_logging(char *config, int &pid);
+int stop_logging(int &pid);
+int execute_error_script(char *script);
+
+typedef struct pixel_format_t {
+    int32_t pixelFormatDesc;
+    const char *pixformat;
+}pixel_format;
+
+typedef struct output_format_t {
+    output_format type;
+    const char *desc;
+} outformat;
+
+typedef struct preview_size_t {
+    int width, height;
+    const char *desc;
+} preview_size;
+
+typedef struct Vcapture_size_t {
+    int width, height;
+    const char *desc;
+} Vcapture_size;
+
+typedef struct capture_Size_t {
+    int width, height;
+    const char *name;
+} capture_Size;
+
+typedef struct video_Codecs_t {
+    video_encoder type;
+    const char *desc;
+} video_Codecs;
+
+typedef struct audio_Codecs_t {
+    audio_encoder type;
+    const char *desc;
+} audio_Codecs;
+
+typedef struct V_bitRate_t {
+    uint32_t bit_rate;
+    const char *desc;
+} V_bitRate;
+
+typedef struct zoom_t {
+    int idx;
+    const char *zoom_description;
+} Zoom;
+
+typedef struct fps_ranges_t {
+    const char *range;
+    const char *rangeDescription;
+} fps_ranges;
+
+typedef struct fpsConst_Ranges_t {
+    const char *range;
+    const char *rangeDescription;
+    int constFramerate;
+} fpsConst_Ranges;
+
+typedef struct fpsConst_RangesSec_t {
+    const char *range;
+    const char *rangeDescription;
+    int constFramerate;
+} fpsConst_RangesSec;
+
+#endif
diff --git a/test/CameraHal/camera_test_menu.cpp b/test/CameraHal/camera_test_menu.cpp
new file mode 100644
index 0000000..9bbf16a
--- /dev/null
+++ b/test/CameraHal/camera_test_menu.cpp
@@ -0,0 +1,2522 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+#include <semaphore.h>
+#include <pthread.h>
+
+#include <surfaceflinger/Surface.h>
+#include <surfaceflinger/ISurface.h>
+#include <surfaceflinger/ISurfaceComposer.h>
+#include <surfaceflinger/ISurfaceComposerClient.h>
+#include <surfaceflinger/SurfaceComposerClient.h>
+
+#include <camera/Camera.h>
+#include <camera/ICamera.h>
+#include <media/mediarecorder.h>
+
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/IServiceManager.h>
+#include <cutils/properties.h>
+#include <camera/CameraParameters.h>
+#include <system/audio.h>
+#include <system/camera.h>
+
+#include <cutils/memory.h>
+#include <utils/Log.h>
+
+#include <sys/wait.h>
+
+#include "camera_test.h"
+
+using namespace android;
+
+int camera_index = 0;
+int print_menu;
+sp<Camera> camera;
+sp<MediaRecorder> recorder;
+sp<SurfaceComposerClient> client;
+sp<SurfaceControl> surfaceControl;
+sp<Surface> previewSurface;
+CameraParameters params;
+float compensation = 0.0;
+double latitude = 0.0;
+double longitude = 0.0;
+double degree_by_step = 17.5609756;//..0975609756097;
+double altitude = 0.0;
+int awb_mode = 0;
+int effects_mode = 0;
+int scene_mode = 0;
+int caf_mode = 0;
+int vnf_mode = 0;
+int vstab_mode = 0;
+
+int tempBracketRange = 1;
+int tempBracketIdx = 0;
+int measurementIdx = 0;
+int expBracketIdx = 0;
+int AutoConvergenceModeIDX = 0;
+int ManualConvergenceValuesIDX = 0;
+int ManualConvergenceDefaultValueIDX = 2;
+int gbceIDX = 0;
+int rotation = 0;
+bool reSizePreview = true;
+bool hardwareActive = false;
+bool recordingMode = false;
+bool previewRunning = false;
+int saturation = 0;
+int zoomIDX = 0;
+int videoCodecIDX = 0;
+int audioCodecIDX = 0;
+int outputFormatIDX = 0;
+int contrast = 0;
+int brightness = 0;
+unsigned int burst = 0;
+int sharpness = 0;
+int iso_mode = 0;
+int capture_mode = 0;
+int exposure_mode = 0;
+int ippIDX = 0;
+int ippIDX_old = 0;
+int previewFormat = 0;
+int jpegQuality = 85;
+int thumbQuality = 85;
+int flashIdx = 0;
+int fpsRangeIdx = 0;
+timeval autofocus_start, picture_start;
+char script_name[80];
+int prevcnt = 0;
+int videoFd = -1;
+int elockidx = 0;
+int wblockidx = 0;
+
+
+char dir_path[80] = SDCARD_PATH;
+
+const char *cameras[] = {"Primary Camera", "Secondary Camera 1", "Stereo Camera", "USB Camera", "Fake Camera"};
+const char *measurement[] = {"disable", "enable"};
+const char *expBracketing[] = {"disable", "enable"};
+const char *expBracketingRange[] = {"", "-30,0,30,0,-30"};
+const char *tempBracketing[] = {"disable", "enable"};
+const char *faceDetection[] = {"disable", "enable"};
+const char *lock[] = {"false", "true"};
+
+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+const char *ipp_mode[] = { "off", "Chroma Suppression", "Edge Enhancement" };
+#else
+const char *ipp_mode[] = { "off", "ldc", "nsf", "ldc-nsf" };
+#endif
+
+const char *iso [] = { "auto", "100", "200", "400", "800", "1200", "1600"};
+
+const char *effects [] = {
+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+    "none",
+    "mono",
+    "negative",
+    "solarize",
+    "sepia",
+    "whiteboard",
+    "blackboard",
+    "cool",
+    "emboss"
+#else
+    "none",
+    "mono",
+    "negative",
+    "solarize",
+    "sepia",
+    "vivid",
+    "whiteboard",
+    "blackboard",
+    "cool",
+    "emboss",
+    "blackwhite",
+    "aqua",
+    "posterize"
+#endif
+};
+
+const char CameraParameters::FLASH_MODE_OFF[] = "off";
+const char CameraParameters::FLASH_MODE_AUTO[] = "auto";
+const char CameraParameters::FLASH_MODE_ON[] = "on";
+const char CameraParameters::FLASH_MODE_RED_EYE[] = "red-eye";
+const char CameraParameters::FLASH_MODE_TORCH[] = "torch";
+
+const char *flashModes[] = {
+    "off",
+    "auto",
+    "on",
+    "red-eye",
+    "torch",
+    "fill-in",
+};
+
+const char *caf [] = { "Off", "On" };
+const char *vnf [] = { "Off", "On" };
+const char *vstab [] = { "Off", "On" };
+
+
+const char *scene [] = {
+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+    "auto",
+    "portrait",
+    "landscape",
+    "night",
+    "night-portrait",
+    "fireworks",
+    "snow",
+    "action",
+#else
+    "auto",
+    "portrait",
+    "landscape",
+    "night",
+    "night-portrait",
+    "night-indoor",
+    "fireworks",
+    "sport",
+    "cine",
+    "beach",
+    "snow",
+    "mood",
+    "closeup",
+    "underwater",
+    "document",
+    "barcode",
+    "oldfilm",
+    "candlelight",
+    "party",
+    "steadyphoto",
+    "sunset",
+    "action",
+    "theatre"
+#endif
+};
+const char *strawb_mode[] = {
+    "auto",
+    "incandescent",
+    "fluorescent",
+    "daylight",
+    "horizon",
+    "shadow",
+    "tungsten",
+    "shade",
+    "twilight",
+    "warm-fluorescent",
+    "facepriority",
+    "sunset"
+};
+
+size_t length_cam =  ARRAY_SIZE(cameras);
+
+
+preview_size previewSize [] = {
+  { 0,   0,  "NULL"},
+  { 128, 96, "SQCIF" },
+  { 176, 144, "QCIF" },
+  { 352, 288, "CIF" },
+  { 320, 240, "QVGA" },
+  { 352, 288, "CIF" },
+  { 640, 480, "VGA" },
+  { 720, 480, "NTSC" },
+  { 720, 576, "PAL" },
+  { 800, 480, "WVGA" },
+  { 848, 480, "WVGA2"},
+  { 864, 480, "WVGA3"},
+  { 992, 560, "WVGA4"},
+  { 1280, 720, "HD" },
+  { 1920, 1080, "FULLHD"},
+};
+
+size_t length_previewSize =  ARRAY_SIZE(previewSize);
+
+Vcapture_size VcaptureSize [] = {
+  { 128, 96, "SQCIF" },
+  { 176, 144, "QCIF" },
+  { 352, 288, "CIF" },
+  { 320, 240, "QVGA" },
+  { 640, 480, "VGA" },
+  { 704, 480, "TVNTSC" },
+  { 704, 576, "TVPAL" },
+  { 720, 480, "D1NTSC" },
+  { 720, 576, "D1PAL" },
+  { 800, 480, "WVGA" },
+  #if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+  { 848, 480, "WVGA2"},
+  { 864, 480, "WVGA3"},
+  { 992, 560, "WVGA4"},
+  #endif
+  { 1280, 720, "HD" },
+  { 1920, 1080, "FULLHD"},
+};
+
+size_t lenght_Vcapture_size = ARRAY_SIZE(VcaptureSize);
+
+capture_Size captureSize[] = {
+  {  320, 240,  "QVGA" },
+  {  640, 480,  "VGA" },
+  {  800, 600,  "SVGA" },
+  { 1152, 864,  "1MP" },
+  { 1280, 1024, "1.3MP" },
+  { 1600, 1200,  "2MP" },
+  { 2048, 1536,  "3MP" },
+  { 2592, 1944,  "5MP" },
+  { 2608, 1960,  "5MP" },
+  { 3264, 2448,  "8MP" },
+  { 3648, 2736, "10MP"},
+  { 4032, 3024, "12MP"},
+};
+
+size_t length_capture_Size = ARRAY_SIZE(captureSize);
+
+
+outformat outputFormat[] = {
+        { OUTPUT_FORMAT_THREE_GPP, "3gp" },
+        { OUTPUT_FORMAT_MPEG_4, "mp4" },
+    };
+
+size_t length_outformat = ARRAY_SIZE(outputFormat);
+
+video_Codecs videoCodecs[] = {
+  { VIDEO_ENCODER_H263, "H263" },
+  { VIDEO_ENCODER_H264, "H264" },
+  { VIDEO_ENCODER_MPEG_4_SP, "MPEG4"}
+};
+
+size_t length_video_Codecs = ARRAY_SIZE(videoCodecs);
+
+audio_Codecs audioCodecs[] = {
+  { AUDIO_ENCODER_AMR_NB, "AMR_NB" },
+  { AUDIO_ENCODER_AMR_WB, "AMR_WB" },
+  { AUDIO_ENCODER_AAC, "AAC" },
+  { AUDIO_ENCODER_AAC_PLUS, "AAC+" },
+  { AUDIO_ENCODER_EAAC_PLUS, "EAAC+" }
+};
+
+size_t length_audio_Codecs = ARRAY_SIZE(audioCodecs);
+
+V_bitRate VbitRate[] = {
+  {    64000, "64K"  },
+  {   128000, "128K" },
+  {   192000, "192K" },
+  {   240000, "240K" },
+  {   320000, "320K" },
+  {   360000, "360K" },
+  {   384000, "384K" },
+  {   420000, "420K" },
+  {   768000, "768K" },
+  {  1000000, "1M"   },
+  {  1500000, "1.5M" },
+  {  2000000, "2M"   },
+  {  4000000, "4M"   },
+  {  6000000, "6M"   },
+  {  8000000, "8M"   },
+  { 10000000, "10M"  },
+};
+
+size_t length_V_bitRate = ARRAY_SIZE(VbitRate);
+
+Zoom zoom[] = {
+  { 0,  "1x"  },
+  { 12, "1.5x"},
+  { 20, "2x"  },
+  { 27, "2.5x"},
+  { 32, "3x"  },
+  { 36, "3.5x"},
+  { 40, "4x"  },
+  { 60, "8x"  },
+};
+
+size_t length_Zoom = ARRAY_SIZE(zoom);
+
+fps_ranges fpsRanges[] = {
+  { "5000,30000", "[5:30]" },
+  { "5000,10000", "[5:10]" },
+  { "5000,15000", "[5:15]" },
+  { "5000,20000", "[5:20]" },
+};
+
+size_t length_fps_ranges = ARRAY_SIZE(fpsRanges);
+
+fpsConst_Ranges fpsConstRanges[] = {
+  { "5000,5000", "[5:5]", 5 },
+  { "10000,10000", "[10:10]", 10 },
+  { "15000,15000", "[15:15]", 15 },
+  { "20000,20000", "[20:20]", 20 },
+  { "25000,25000", "[25:25]", 25 },
+  { "30000,30000", "[30:30]", 30 },
+};
+
+size_t length_fpsConst_Ranges = ARRAY_SIZE(fpsConstRanges);
+
+fpsConst_RangesSec fpsConstRangesSec[] = {
+  { "5000,5000", "[5:5]", 5 },
+  { "10000,10000", "[10:10]", 10 },
+  { "15000,15000", "[15:15]", 15 },
+  { "20000,20000", "[20:20]", 20 },
+  { "25000,25000", "[25:25]", 25 },
+  { "27000,27000", "[27:27]", 27 },
+};
+
+size_t length_fpsConst_RangesSec = ARRAY_SIZE(fpsConstRangesSec);
+
+const char *antibanding[] = {
+    "off",
+    "auto",
+    "50hz",
+    "60hz",
+};
+int antibanding_mode = 0;
+const char *focus[] = {
+    "auto",
+    "infinity",
+    "macro",
+    "continuous-video",
+    "extended",
+    "portrait",
+};
+int focus_mode = 0;
+pixel_format pixelformat[] = {
+  { HAL_PIXEL_FORMAT_YCbCr_422_I, CameraParameters::PIXEL_FORMAT_YUV422I },
+  { HAL_PIXEL_FORMAT_YCrCb_420_SP, CameraParameters::PIXEL_FORMAT_YUV420SP },
+  { HAL_PIXEL_FORMAT_RGB_565, CameraParameters::PIXEL_FORMAT_RGB565 },
+  { -1, CameraParameters::PIXEL_FORMAT_JPEG },
+  { -1, "raw" },
+  };
+
+const char *codingformat[] = {"yuv422i-yuyv", "yuv420sp", "rgb565", "jpeg", "raw", "jps", "mpo", "raw+jpeg", "raw+mpo"};
+const char *gbce[] = {"disable", "enable"};
+int pictureFormat = 3; // jpeg
+const char *exposure[] = {"auto", "macro", "portrait", "landscape", "sports", "night", "night-portrait", "backlighting", "manual"};
+const char *capture[] = { "high-performance", "high-quality", "video-mode" };
+const char *autoconvergencemode[] = { "mode-disable", "mode-frame", "mode-center", "mode-fft", "mode-manual" };
+const char *manualconvergencevalues[] = { "-100", "-50", "-30", "-25", "0", "25", "50", "100" };
+
+const struct {
+    int fps;
+} frameRate[] = {
+    {0},
+    {5},
+    {10},
+    {15},
+    {20},
+    {25},
+    {30}
+};
+
+int thumbSizeIDX =  3;
+int previewSizeIDX = ARRAY_SIZE(previewSize) - 1;
+int captureSizeIDX = ARRAY_SIZE(captureSize) - 1;
+int frameRateIDX = ARRAY_SIZE(fpsConstRanges) - 1;
+int frameRateIDXSec = ARRAY_SIZE(fpsConstRangesSec) - 1;
+int VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 1;
+int VbitRateIDX = ARRAY_SIZE(VbitRate) - 1;
+
+static unsigned int recording_counter = 1;
+
+int dump_preview = 0;
+int bufferStarvationTest = 0;
+bool showfps = false;
+
+const char *metering[] = {
+    "center",
+    "average",
+};
+int meter_mode = 0;
+bool bLogSysLinkTrace = true;
+bool stressTest = false;
+bool stopScript = false;
+int restartCount = 0;
+
+/** Calculate delay from a reference time */
+unsigned long long timeval_delay(const timeval *ref) {
+    unsigned long long st, end, delay;
+    timeval current_time;
+
+    gettimeofday(&current_time, 0);
+
+    st = ref->tv_sec * 1000000 + ref->tv_usec;
+    end = current_time.tv_sec * 1000000 + current_time.tv_usec;
+    delay = end - st;
+
+    return delay;
+}
+
+/** Callback for takePicture() */
+void my_raw_callback(const sp<IMemory>& mem) {
+
+    static int      counter = 1;
+    unsigned char   *buff = NULL;
+    int             size;
+    int             fd = -1;
+    char            fn[256];
+
+    LOG_FUNCTION_NAME;
+
+    if (mem == NULL)
+        goto out;
+
+    //Start preview after capture.
+    camera->startPreview();
+
+    fn[0] = 0;
+    sprintf(fn, "/sdcard/img%03d.raw", counter);
+    fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777);
+
+    if (fd < 0)
+        goto out;
+
+    size = mem->size();
+
+    if (size <= 0)
+        goto out;
+
+    buff = (unsigned char *)mem->pointer();
+
+    if (!buff)
+        goto out;
+
+    if (size != write(fd, buff, size))
+        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));
+
+    counter++;
+    printf("%s: buffer=%08X, size=%d stored at %s\n",
+           __FUNCTION__, (int)buff, size, fn);
+
+out:
+
+    if (fd >= 0)
+        close(fd);
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void saveFile(const sp<IMemory>& mem) {
+    static int      counter = 1;
+    unsigned char   *buff = NULL;
+    int             size;
+    int             fd = -1;
+    char            fn[256];
+
+    LOG_FUNCTION_NAME;
+
+    if (mem == NULL)
+        goto out;
+
+    fn[0] = 0;
+    sprintf(fn, "/sdcard/preview%03d.yuv", counter);
+    fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777);
+    if(fd < 0) {
+        LOGE("Unable to open file %s: %s", fn, strerror(fd));
+        goto out;
+    }
+
+    size = mem->size();
+    if (size <= 0) {
+        LOGE("IMemory object is of zero size");
+        goto out;
+    }
+
+    buff = (unsigned char *)mem->pointer();
+    if (!buff) {
+        LOGE("Buffer pointer is invalid");
+        goto out;
+    }
+
+    if (size != write(fd, buff, size))
+        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));
+
+    counter++;
+    printf("%s: buffer=%08X, size=%d\n",
+           __FUNCTION__, (int)buff, size);
+
+out:
+
+    if (fd >= 0)
+        close(fd);
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+
+void debugShowFPS()
+{
+    static int mFrameCount = 0;
+    static int mLastFrameCount = 0;
+    static nsecs_t mLastFpsTime = 0;
+    static float mFps = 0;
+    mFrameCount++;
+    if ( ( mFrameCount % 30 ) == 0 ) {
+        nsecs_t now = systemTime();
+        nsecs_t diff = now - mLastFpsTime;
+        mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
+        mLastFpsTime = now;
+        mLastFrameCount = mFrameCount;
+        printf("####### [%d] Frames, %f FPS", mFrameCount, mFps);
+    }
+}
+
+/** Callback for startPreview() */
+void my_preview_callback(const sp<IMemory>& mem) {
+
+    printf("PREVIEW Callback 0x%x", ( unsigned int ) mem->pointer());
+    if (dump_preview) {
+
+        if(prevcnt==50)
+        saveFile(mem);
+
+        prevcnt++;
+
+        uint8_t *ptr = (uint8_t*) mem->pointer();
+
+        printf("PRV_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9]);
+
+    }
+
+    debugShowFPS();
+}
+
+/** Callback for takePicture() */
+void my_jpeg_callback(const sp<IMemory>& mem) {
+    static int  counter = 1;
+    unsigned char   *buff = NULL;
+    int     size;
+    int     fd = -1;
+    char        fn[256];
+
+    LOG_FUNCTION_NAME;
+
+    //Start preview after capture.
+    camera->startPreview();
+
+    if (mem == NULL)
+        goto out;
+
+    fn[0] = 0;
+    sprintf(fn, "%s/img%03d.jpg", dir_path,counter);
+    fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777);
+
+    if(fd < 0) {
+        LOGE("Unable to open file %s: %s", fn, strerror(fd));
+        goto out;
+    }
+
+    size = mem->size();
+    if (size <= 0) {
+        LOGE("IMemory object is of zero size");
+        goto out;
+    }
+
+    buff = (unsigned char *)mem->pointer();
+    if (!buff) {
+        LOGE("Buffer pointer is invalid");
+        goto out;
+    }
+
+    if (size != write(fd, buff, size))
+        printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno));
+
+    counter++;
+    printf("%s: buffer=%08X, size=%d stored at %s\n",
+           __FUNCTION__, (int)buff, size, fn);
+
+out:
+
+    if (fd >= 0)
+        close(fd);
+
+    LOG_FUNCTION_NAME_EXIT;
+}
+
+void my_face_callback(camera_frame_metadata_t *metadata) {
+    int idx;
+
+    if ( NULL == metadata ) {
+        return;
+    }
+
+    for ( idx = 0 ; idx < metadata->number_of_faces ; idx++ ) {
+        printf("Face %d at %d,%d %d,%d \n",
+               idx,
+               metadata->faces[idx].rect[0],
+               metadata->faces[idx].rect[1],
+               metadata->faces[idx].rect[2],
+               metadata->faces[idx].rect[3]);
+    }
+
+}
+
+void CameraHandler::notify(int32_t msgType, int32_t ext1, int32_t ext2) {
+
+    printf("Notify cb: %d %d %d\n", msgType, ext1, ext2);
+
+    if ( msgType & CAMERA_MSG_FOCUS )
+        printf("AutoFocus %s in %llu us\n", (ext1) ? "OK" : "FAIL", timeval_delay(&autofocus_start));
+
+    if ( msgType & CAMERA_MSG_SHUTTER )
+        printf("Shutter done in %llu us\n", timeval_delay(&picture_start));
+
+    if ( msgType & CAMERA_MSG_ERROR && (ext1 == 1))
+      {
+        printf("Camera Test CAMERA_MSG_ERROR.....\n");
+        if (stressTest)
+          {
+            printf("Camera Test Notified of Error Restarting.....\n");
+            stopScript = true;
+          }
+        else
+          {
+            printf("Camera Test Notified of Error Stopping.....\n");
+            stopScript =false;
+            stopPreview();
+
+            if (recordingMode)
+              {
+                stopRecording();
+                closeRecorder();
+                recordingMode = false;
+              }
+          }
+      }
+}
+
+void CameraHandler::postData(int32_t msgType,
+                             const sp<IMemory>& dataPtr,
+                             camera_frame_metadata_t *metadata) {
+    printf("Data cb: %d\n", msgType);
+
+    if ( msgType & CAMERA_MSG_PREVIEW_FRAME )
+        my_preview_callback(dataPtr);
+
+    if ( msgType & CAMERA_MSG_RAW_IMAGE ) {
+        printf("RAW done in %llu us\n", timeval_delay(&picture_start));
+        my_raw_callback(dataPtr);
+    }
+
+    if (msgType & CAMERA_MSG_POSTVIEW_FRAME) {
+        printf("Postview frame %llu us\n", timeval_delay(&picture_start));
+    }
+
+    if (msgType & CAMERA_MSG_COMPRESSED_IMAGE ) {
+        printf("JPEG done in %llu us\n", timeval_delay(&picture_start));
+        my_jpeg_callback(dataPtr);
+    }
+
+    if ( ( msgType & CAMERA_MSG_PREVIEW_METADATA ) &&
+         ( NULL != metadata ) ) {
+        printf("Face detected %d \n", metadata->number_of_faces);
+        my_face_callback(metadata);
+    }
+}
+
+void CameraHandler::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)
+
+{
+    printf("Recording cb: %d %lld %p\n", msgType, timestamp, dataPtr.get());
+
+    static uint32_t count = 0;
+
+    //if(count==100)
+    //saveFile(dataPtr);
+
+    count++;
+
+    uint8_t *ptr = (uint8_t*) dataPtr->pointer();
+
+    printf("VID_CB: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9]);
+
+    camera->releaseRecordingFrame(dataPtr);
+}
+
+int createPreviewSurface(unsigned int width, unsigned int height, int32_t pixFormat) {
+    unsigned int previewWidth, previewHeight;
+
+    if ( MAX_PREVIEW_SURFACE_WIDTH < width ) {
+        previewWidth = MAX_PREVIEW_SURFACE_WIDTH;
+    } else {
+        previewWidth = width;
+    }
+
+    if ( MAX_PREVIEW_SURFACE_HEIGHT < height ) {
+        previewHeight = MAX_PREVIEW_SURFACE_HEIGHT;
+    } else {
+        previewHeight = height;
+    }
+
+    client = new SurfaceComposerClient();
+
+    if ( NULL == client.get() ) {
+        printf("Unable to establish connection to Surface Composer \n");
+
+        return -1;
+    }
+
+    surfaceControl = client->createSurface(0,
+                                           previewWidth,
+                                           previewHeight,
+                                           pixFormat);
+
+    previewSurface = surfaceControl->getSurface();
+
+    client->openGlobalTransaction();
+    surfaceControl->setLayer(100000);
+    surfaceControl->setPosition(0, 0);
+    surfaceControl->setSize(previewWidth, previewHeight);
+    surfaceControl->show();
+    client->closeGlobalTransaction();
+
+    return 0;
+}
+
+void printSupportedParams()
+{
+    printf("\n\r\tSupported Cameras: %s", params.get("camera-indexes"));
+    printf("\n\r\tSupported Picture Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
+    printf("\n\r\tSupported Picture Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS));
+    printf("\n\r\tSupported Preview Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
+    printf("\n\r\tSupported Preview Formats: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS));
+    printf("\n\r\tSupported Preview Frame Rates: %s", params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));
+    printf("\n\r\tSupported Thumbnail Sizes: %s", params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES));
+    printf("\n\r\tSupported Whitebalance Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));
+    printf("\n\r\tSupported Effects: %s", params.get(CameraParameters::KEY_SUPPORTED_EFFECTS));
+    printf("\n\r\tSupported Scene Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));
+    printf("\n\r\tSupported Focus Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));
+    printf("\n\r\tSupported Antibanding Options: %s", params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING));
+    printf("\n\r\tSupported Flash Modes: %s", params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));
+    printf("\n\r\tSupported Focus Areas: %d", params.getInt(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS));
+
+    if ( NULL != params.get(CameraParameters::KEY_FOCUS_DISTANCES) ) {
+        printf("\n\r\tFocus Distances: %s \n", params.get(CameraParameters::KEY_FOCUS_DISTANCES));
+    }
+
+    return;
+}
+
+
+int destroyPreviewSurface() {
+
+    if ( NULL != previewSurface.get() ) {
+        previewSurface.clear();
+    }
+
+    if ( NULL != surfaceControl.get() ) {
+        surfaceControl->clear();
+        surfaceControl.clear();
+    }
+
+    if ( NULL != client.get() ) {
+        client->dispose();
+        client.clear();
+    }
+
+    return 0;
+}
+
+int openRecorder() {
+    recorder = new MediaRecorder();
+
+    if ( NULL == recorder.get() ) {
+        printf("Error while creating MediaRecorder\n");
+
+        return -1;
+    }
+
+    return 0;
+}
+
+int closeRecorder() {
+    if ( NULL == recorder.get() ) {
+        printf("invalid recorder reference\n");
+
+        return -1;
+    }
+
+    if ( recorder->init() < 0 ) {
+        printf("recorder failed to initialize\n");
+
+        return -1;
+    }
+
+    if ( recorder->close() < 0 ) {
+        printf("recorder failed to close\n");
+
+        return -1;
+    }
+
+    if ( recorder->release() < 0 ) {
+        printf("error while releasing recorder\n");
+
+        return -1;
+    }
+
+    recorder.clear();
+
+    return 0;
+}
+
+int configureRecorder() {
+
+    char videoFile[256],vbit_string[50];
+    videoFd = -1;
+
+    if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) {
+        printf("invalid recorder and/or camera references\n");
+
+        return -1;
+    }
+
+    camera->unlock();
+
+    sprintf(vbit_string,"video-param-encoding-bitrate=%u", VbitRate[VbitRateIDX].bit_rate);
+    String8 bit_rate(vbit_string);
+    if ( recorder->setParameters(bit_rate) < 0 ) {
+        printf("error while configuring bit rate\n");
+
+        return -1;
+    }
+
+    if ( recorder->setCamera(camera->remote(), camera->getRecordingProxy()) < 0 ) {
+        printf("error while setting the camera\n");
+
+        return -1;
+    }
+
+    if ( recorder->setVideoSource(VIDEO_SOURCE_CAMERA) < 0 ) {
+        printf("error while configuring camera video source\n");
+
+        return -1;
+    }
+
+
+    if ( recorder->setAudioSource(AUDIO_SOURCE_MIC) < 0 ) {
+        printf("error while configuring camera audio source\n");
+
+        return -1;
+    }
+
+    if ( recorder->setOutputFormat(outputFormat[outputFormatIDX].type) < 0 ) {
+        printf("error while configuring output format\n");
+
+        return -1;
+    }
+
+    if(mkdir("/mnt/sdcard/videos",0777) == -1)
+         printf("\n Directory --videos-- was not created \n");
+    sprintf(videoFile, "/mnt/sdcard/videos/video%d.%s", recording_counter,outputFormat[outputFormatIDX].desc);
+
+    videoFd = open(videoFile, O_CREAT | O_RDWR);
+
+    if(videoFd < 0){
+        printf("Error while creating video filename\n");
+
+        return -1;
+    }
+
+    if ( recorder->setOutputFile(videoFd, 0, 0) < 0 ) {
+        printf("error while configuring video filename\n");
+
+        return -1;
+    }
+
+    recording_counter++;
+
+    if (camera_index == 0) {
+        if ( recorder->setVideoFrameRate(fpsConstRanges[frameRateIDX].constFramerate) < 0 ) {
+            printf("error while configuring video framerate\n");
+            return -1;
+        }
+    }
+    else  {
+        if ( recorder->setVideoFrameRate(fpsConstRangesSec[frameRateIDXSec].constFramerate) < 0 ) {
+            printf("error while configuring video framerate\n");
+            return -1;
+        }
+    }
+
+    if ( recorder->setVideoSize(VcaptureSize[VcaptureSizeIDX].width, VcaptureSize[VcaptureSizeIDX].height) < 0 ) {
+        printf("error while configuring video size\n");
+
+        return -1;
+    }
+
+    if ( recorder->setVideoEncoder(videoCodecs[videoCodecIDX].type) < 0 ) {
+        printf("error while configuring video codec\n");
+
+        return -1;
+    }
+
+    if ( recorder->setAudioEncoder(audioCodecs[audioCodecIDX].type) < 0 ) {
+        printf("error while configuring audio codec\n");
+
+        return -1;
+    }
+
+    if ( recorder->setPreviewSurface( surfaceControl->getSurface() ) < 0 ) {
+        printf("error while configuring preview surface\n");
+
+        return -1;
+    }
+
+    return 0;
+}
+
+int startRecording() {
+    if ( ( NULL == recorder.get() ) || ( NULL == camera.get() ) ) {
+        printf("invalid recorder and/or camera references\n");
+
+        return -1;
+    }
+
+    camera->unlock();
+
+    if ( recorder->prepare() < 0 ) {
+        printf("recorder prepare failed\n");
+
+        return -1;
+    }
+
+    if ( recorder->start() < 0 ) {
+        printf("recorder start failed\n");
+
+        return -1;
+    }
+
+    return 0;
+}
+
+int stopRecording() {
+    if ( NULL == recorder.get() ) {
+        printf("invalid recorder reference\n");
+
+        return -1;
+    }
+
+    if ( recorder->stop() < 0 ) {
+        printf("recorder failed to stop\n");
+
+        return -1;
+    }
+
+    if ( 0 < videoFd ) {
+        close(videoFd);
+    }
+
+    return 0;
+}
+
+int openCamera() {
+    printf("openCamera(camera_index=%d)\n", camera_index);
+    camera = Camera::connect(camera_index);
+
+    if ( NULL == camera.get() ) {
+        printf("Unable to connect to CameraService\n");
+        printf("Retrying... \n");
+        sleep(1);
+        camera = Camera::connect(camera_index);
+
+        if ( NULL == camera.get() ) {
+            printf("Giving up!! \n");
+            return -1;
+        }
+    }
+
+    params = camera->getParameters();
+    camera->setParameters(params.flatten());
+
+    camera->setListener(new CameraHandler());
+
+    hardwareActive = true;
+
+    return 0;
+}
+
+int closeCamera() {
+    if ( NULL == camera.get() ) {
+        printf("invalid camera reference\n");
+
+        return -1;
+    }
+
+    camera->disconnect();
+    camera.clear();
+
+    hardwareActive = false;
+
+    return 0;
+}
+
+//Workaround for an issue seen with ICS SurfaceFlinger.
+//The last surface created is not getting rendered on screen,
+//in our case this is the preview surface. Here we artificially wait
+//for the preview to start and create a new temporary surface, which
+//gets destroyed immediately.
+int surfaceWorkaround(unsigned int width, unsigned int height, int32_t pixFormat) {
+    sleep(1);
+
+    if ( NULL == client.get() ) {
+        return NO_INIT;
+    }
+
+    sp<SurfaceControl> tmpSurface = client->createSurface(0,
+                                                          width,
+                                                          height,
+                                                          pixFormat);
+
+    if ( NULL != tmpSurface.get() ) {
+        tmpSurface->clear();
+        tmpSurface.clear();
+    } else {
+        return -ENOMEM;
+    }
+
+    return NO_ERROR;
+}
+
+int startPreview() {
+    int previewWidth, previewHeight;
+    if (reSizePreview) {
+
+        if(recordingMode)
+        {
+            previewWidth = VcaptureSize[VcaptureSizeIDX].width;
+            previewHeight = VcaptureSize[VcaptureSizeIDX].height;
+        }else
+        {
+            previewWidth = previewSize[previewSizeIDX].width;
+            previewHeight = previewSize[previewSizeIDX].height;
+        }
+
+        if ( createPreviewSurface(previewWidth,
+                                  previewHeight,
+                                  pixelformat[previewFormat].pixelFormatDesc) < 0 ) {
+            printf("Error while creating preview surface\n");
+            return -1;
+        }
+
+        if ( !hardwareActive ) {
+            openCamera();
+        }
+
+        params.setPreviewSize(previewWidth, previewHeight);
+        params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height);
+
+        camera->setParameters(params.flatten());
+        camera->setPreviewDisplay(previewSurface);
+
+        if(!hardwareActive) prevcnt = 0;
+
+        camera->startPreview();
+
+        previewRunning = true;
+        reSizePreview = false;
+
+        surfaceWorkaround( previewWidth, previewHeight, pixelformat[previewFormat].pixelFormatDesc);
+    }
+
+    return 0;
+}
+
+void stopPreview() {
+    if ( hardwareActive ) {
+        camera->stopPreview();
+
+        destroyPreviewSurface();
+
+        previewRunning  = false;
+        reSizePreview = true;
+        closeCamera();
+    }
+}
+
+void initDefaults() {
+    camera_index = 0;
+    antibanding_mode = 0;
+    focus_mode = 0;
+    fpsRangeIdx = 0;
+    previewSizeIDX = 1;  /* Default resolution set to WVGA */
+    captureSizeIDX = 3;  /* Default capture resolution is 8MP */
+    frameRateIDX = ARRAY_SIZE(fpsConstRanges) - 1;      /* Default frame rate is 30 FPS */
+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+    VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 6;/* Default video record is WVGA */
+#else
+    VcaptureSizeIDX = ARRAY_SIZE(VcaptureSize) - 2;/* Default video record is WVGA */
+#endif
+    VbitRateIDX = ARRAY_SIZE(VbitRate) - 4;        /*Default video bit rate is 4M */
+    thumbSizeIDX = 0;
+    compensation = 0.0;
+    awb_mode = 0;
+    effects_mode = 0;
+    scene_mode = 0;
+    caf_mode = 0;
+    vnf_mode = 0;
+    vstab_mode = 0;
+    expBracketIdx = 0;
+    flashIdx = 0;
+    rotation = 0;
+    zoomIDX = 0;
+    videoCodecIDX = 0;
+    gbceIDX = 0;
+#ifdef TARGET_OMAP4
+    ///Temporary fix until OMAP3 and OMAP4 3A values are synced
+    contrast = 90;
+    brightness = 50;
+    sharpness = 0;
+    saturation = 50;
+#else
+    contrast = 100;
+    brightness = 100;
+    sharpness = 0;
+    saturation = 100;
+#endif
+    iso_mode = 0;
+    capture_mode = 0;
+    exposure_mode = 0;
+    ippIDX = 0;//set the ipp to ldc-nsf as the capture mode is set to HQ by default
+    ippIDX_old = ippIDX;
+    jpegQuality = 85;
+    bufferStarvationTest = 0;
+    meter_mode = 0;
+    previewFormat = 1;
+    pictureFormat = 3; // jpeg
+    params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height);
+    params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height);
+    params.set(CameraParameters::KEY_ROTATION, rotation);
+    params.set(KEY_COMPENSATION, (int) (compensation * 10));
+    params.set(params.KEY_WHITE_BALANCE, strawb_mode[awb_mode]);
+    params.set(KEY_MODE, (capture[capture_mode]));
+    params.set(params.KEY_SCENE_MODE, scene[scene_mode]);
+    params.set(KEY_CAF, caf_mode);
+    params.set(KEY_ISO, iso_mode);
+    params.set(KEY_GBCE, gbce[gbceIDX]);
+    params.set(KEY_SHARPNESS, sharpness);
+    params.set(KEY_CONTRAST, contrast);
+    params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
+    params.set(KEY_EXPOSURE, exposure[exposure_mode]);
+    params.set(KEY_BRIGHTNESS, brightness);
+    params.set(KEY_SATURATION, saturation);
+    params.set(params.KEY_EFFECT, effects[effects_mode]);
+    params.setPreviewFrameRate(frameRate[ARRAY_SIZE(frameRate) - 1].fps);
+    params.set(params.KEY_ANTIBANDING, antibanding[antibanding_mode]);
+    params.set(params.KEY_FOCUS_MODE, focus[focus_mode]);
+    params.set(KEY_IPP, ippIDX);
+    params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
+    params.setPreviewFormat(pixelformat[previewFormat].pixformat);
+    params.setPictureFormat(codingformat[pictureFormat]);
+    params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation
+    params.set(KEY_METERING_MODE, metering[meter_mode]);
+    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, previewSize[thumbSizeIDX].width);
+    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, previewSize[thumbSizeIDX].height);
+    ManualConvergenceValuesIDX = ManualConvergenceDefaultValueIDX;
+    params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]);
+    params.set(KEY_S3D2D_PREVIEW_MODE, "off");
+    params.set(KEY_STEREO_CAMERA, "false");
+    params.set(KEY_EXIF_MODEL, MODEL);
+    params.set(KEY_EXIF_MAKE, MAKE);
+}
+
+int menu_gps() {
+    char ch;
+    char coord_str[100];
+
+    if (print_menu) {
+        printf("\n\n== GPS MENU ============================\n\n");
+        printf("   e. Latitude:       %.7lf\n", latitude);
+        printf("   d. Longitude:      %.7lf\n", longitude);
+        printf("   c. Altitude:       %.7lf\n", altitude);
+        printf("\n");
+        printf("   q. Return to main menu\n");
+        printf("\n");
+        printf("   Choice: ");
+    }
+
+    ch = getchar();
+    printf("%c", ch);
+
+    print_menu = 1;
+
+    switch (ch) {
+
+        case 'e':
+            latitude += degree_by_step;
+
+            if (latitude > 90.0) {
+                latitude -= 180.0;
+            }
+
+            snprintf(coord_str, 7, "%.7lf", latitude);
+            params.set(params.KEY_GPS_LATITUDE, coord_str);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'd':
+            longitude += degree_by_step;
+
+            if (longitude > 180.0) {
+                longitude -= 360.0;
+            }
+
+            snprintf(coord_str, 7, "%.7lf", longitude);
+            params.set(params.KEY_GPS_LONGITUDE, coord_str);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'c':
+            altitude += 12345.67890123456789;
+
+            if (altitude > 100000.0) {
+                altitude -= 200000.0;
+            }
+
+            snprintf(coord_str, 100, "%.20lf", altitude);
+            params.set(params.KEY_GPS_ALTITUDE, coord_str);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'Q':
+        case 'q':
+            return -1;
+
+        default:
+            print_menu = 0;
+            break;
+    }
+
+    return 0;
+}
+
+int functional_menu() {
+    char ch;
+
+    if (print_menu) {
+
+        printf("\n\n=========== FUNCTIONAL TEST MENU ===================\n\n");
+
+        printf(" \n\nSTART / STOP / GENERAL SERVICES \n");
+        printf(" -----------------------------\n");
+        printf("   A  Select Camera %s\n", cameras[camera_index]);
+        printf("   [. Resume Preview after capture\n");
+        printf("   0. Reset to defaults\n");
+        printf("   q. Quit\n");
+        printf("   @. Disconnect and Reconnect to CameraService \n");
+        printf("   /. Enable/Disable showfps: %s\n", ((showfps)? "Enabled":"Disabled"));
+        printf("   a. GEO tagging settings menu\n");
+        printf("   E.  Camera Capability Dump");
+
+
+        printf(" \n\n PREVIEW SUB MENU \n");
+        printf(" -----------------------------\n");
+        printf("   1. Start Preview\n");
+        printf("   2. Stop Preview\n");
+        printf("   ~. Preview format %s\n", pixelformat[previewFormat].pixformat);
+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+        printf("   4. Preview size:   %4d x %4d - %s\n",previewSize[previewSizeIDX].width,  previewSize[previewSizeIDX].height, previewSize[previewSizeIDX].desc);
+#else
+        printf("   4. Preview size:   %4d x %4d - %s\n",previewSize[previewSizeIDX].width, camera_index == 2 ? previewSize[previewSizeIDX].height*2 : previewSize[previewSizeIDX].height, previewSize[previewSizeIDX].desc);
+#endif
+        printf("   R. Preview framerate range: %s\n", fpsRanges[fpsRangeIdx].rangeDescription);
+        printf("   &. Dump a preview frame\n");
+        printf("   _. Auto Convergence mode: %s\n", autoconvergencemode[AutoConvergenceModeIDX]);
+        printf("   ^. Manual Convergence Value: %s\n", manualconvergencevalues[ManualConvergenceValuesIDX]);
+        printf("   {. 2D Preview in 3D Stereo Mode: %s\n", params.get(KEY_S3D2D_PREVIEW_MODE));
+
+        printf(" \n\n IMAGE CAPTURE SUB MENU \n");
+        printf(" -----------------------------\n");
+        printf("   p. Take picture/Full Press\n");
+        printf("   H. Exposure Bracketing: %s\n", expBracketing[expBracketIdx]);
+        printf("   U. Temporal Bracketing:   %s\n", tempBracketing[tempBracketIdx]);
+        printf("   W. Temporal Bracketing Range: [-%d;+%d]\n", tempBracketRange, tempBracketRange);
+        printf("   $. Picture Format: %s\n", codingformat[pictureFormat]);
+        printf("   3. Picture Rotation:       %3d degree\n", rotation );
+        printf("   5. Picture size:   %4d x %4d - %s\n",captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height,              captureSize[captureSizeIDX].name);
+        printf("   i. ISO mode:       %s\n", iso[iso_mode]);
+        printf("   u. Capture Mode:   %s\n", capture[capture_mode]);
+        printf("   k. IPP Mode:       %s\n", ipp_mode[ippIDX]);
+        printf("   K. GBCE: %s\n", gbce[gbceIDX]);
+        printf("   o. Jpeg Quality:   %d\n", jpegQuality);
+        printf("   #. Burst Images:  %3d\n", burst);
+        printf("   :. Thumbnail Size:  %4d x %4d - %s\n",previewSize[thumbSizeIDX].width, previewSize[thumbSizeIDX].height, previewSize[thumbSizeIDX].desc);
+        printf("   ': Thumbnail Quality %d\n", thumbQuality);
+
+        printf(" \n\n VIDEO CAPTURE SUB MENU \n");
+        printf(" -----------------------------\n");
+
+        printf("   6. Start Video Recording\n");
+        printf("   2. Stop Recording\n");
+        printf("   l. Video Capture resolution:   %4d x %4d - %s\n",VcaptureSize[VcaptureSizeIDX].width,VcaptureSize[VcaptureSizeIDX].height, VcaptureSize[VcaptureSizeIDX].desc);
+        printf("   ]. Video Bit rate :  %s\n", VbitRate[VbitRateIDX].desc);
+        printf("   9. Video Codec:    %s\n", videoCodecs[videoCodecIDX].desc);
+        printf("   D. Audio Codec:    %s\n", audioCodecs[audioCodecIDX].desc);
+        printf("   v. Output Format:  %s\n", outputFormat[outputFormatIDX].desc);
+
+        if  (camera_index == 1) {
+            printf("   r. Framerate:     %d\n", fpsConstRangesSec[frameRateIDXSec].constFramerate);
+        }
+        else {
+            printf("   r. Framerate:     %d\n", fpsConstRanges[frameRateIDX].constFramerate);
+        }
+        printf("   *. Start Video Recording dump ( 1 raw frame ) \n");
+        printf("   B  VNF              %s \n", vnf[vnf_mode]);
+        printf("   C  VSTAB              %s", vstab[vstab_mode]);
+
+        printf(" \n\n 3A SETTING SUB MENU \n");
+        printf(" -----------------------------\n");
+
+        printf("   M. Measurement Data: %s\n", measurement[measurementIdx]);
+        printf("   F. Start face detection \n");
+        printf("   T. Stop face detection \n");
+        printf("   G. Touch/Focus area AF\n");
+        printf("   f. Auto Focus/Half Press\n");
+        printf("   J.Flash:              %s\n", flashModes[flashIdx]);
+        printf("   7. EV offset:      %4.1f\n", compensation);
+        printf("   8. AWB mode:       %s\n", strawb_mode[awb_mode]);
+        printf("   z. Zoom            %s\n", zoom[zoomIDX].zoom_description);
+        printf("   j. Exposure        %s\n", exposure[exposure_mode]);
+        printf("   e. Effect:         %s\n", effects[effects_mode]);
+        printf("   w. Scene:          %s\n", scene[scene_mode]);
+        printf("   s. Saturation:     %d\n", saturation);
+        printf("   c. Contrast:       %d\n", contrast);
+        printf("   h. Sharpness:      %d\n", sharpness);
+        printf("   b. Brightness:     %d\n", brightness);
+        printf("   x. Antibanding:    %s\n", antibanding[antibanding_mode]);
+        printf("   g. Focus mode:     %s\n", focus[focus_mode]);
+        printf("   m. Metering mode:     %s\n" , metering[meter_mode]);
+        printf("   <. Exposure Lock:     %s\n", lock[elockidx]);
+        printf("   >. WhiteBalance Lock:  %s\n",lock[wblockidx]);
+        printf("\n");
+        printf("   Choice: ");
+    }
+
+    ch = getchar();
+    printf("%c", ch);
+
+    print_menu = 1;
+
+    switch (ch) {
+
+    case '_':
+        AutoConvergenceModeIDX++;
+        AutoConvergenceModeIDX %= ARRAY_SIZE(autoconvergencemode);
+        params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
+        if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) {
+            params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]);
+        }
+        else {
+            params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceDefaultValueIDX]);
+            ManualConvergenceValuesIDX = ManualConvergenceDefaultValueIDX;
+        }
+        camera->setParameters(params.flatten());
+
+        break;
+    case '^':
+        if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) {
+            ManualConvergenceValuesIDX++;
+            ManualConvergenceValuesIDX %= ARRAY_SIZE(manualconvergencevalues);
+            params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceValuesIDX]);
+            camera->setParameters(params.flatten());
+        }
+        break;
+    case 'A':
+        camera_index++;
+        camera_index %= ARRAY_SIZE(cameras);
+        if ( camera_index == 2) {
+            params.set(KEY_STEREO_CAMERA, "true");
+        } else {
+            params.set(KEY_STEREO_CAMERA, "false");
+        }
+        closeCamera();
+
+        openCamera();
+
+        if (camera_index == 0) {
+            params.setPreviewFrameRate(30);
+        } else {
+            params.setPreviewFrameRate(27);
+        }
+
+
+        break;
+    case '[':
+        if ( hardwareActive ) {
+            camera->setParameters(params.flatten());
+            camera->startPreview();
+        }
+        break;
+
+    case '0':
+        initDefaults();
+        break;
+
+        case '1':
+
+            if ( startPreview() < 0 ) {
+                printf("Error while starting preview\n");
+
+                return -1;
+            }
+
+            break;
+
+        case '2':
+            stopPreview();
+
+            if ( recordingMode ) {
+                camera->disconnect();
+                camera.clear();
+                stopRecording();
+                closeRecorder();
+
+                camera = Camera::connect(camera_index);
+                  if ( NULL == camera.get() ) {
+                      sleep(1);
+                      camera = Camera::connect(camera_index);
+                      if ( NULL == camera.get() ) {
+                          return -1;
+                      }
+                  }
+                  camera->setListener(new CameraHandler());
+                  camera->setParameters(params.flatten());
+                  recordingMode = false;
+            }
+
+            break;
+
+        case '3':
+            rotation += 90;
+            rotation %= 360;
+            params.set(CameraParameters::KEY_ROTATION, rotation);
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case '4':
+            previewSizeIDX += 1;
+            previewSizeIDX %= ARRAY_SIZE(previewSize);
+            if ( strcmp(params.get(KEY_STEREO_CAMERA), "false") == 0 ) {
+                params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height);
+            } else {
+                params.setPreviewSize(previewSize[previewSizeIDX].width, previewSize[previewSizeIDX].height*2);
+            }
+            reSizePreview = true;
+
+            if ( hardwareActive && previewRunning ) {
+                camera->stopPreview();
+                camera->setParameters(params.flatten());
+                camera->startPreview();
+            } else if ( hardwareActive ) {
+                camera->setParameters(params.flatten());
+            }
+
+            break;
+
+        case '5':
+            captureSizeIDX += 1;
+            captureSizeIDX %= ARRAY_SIZE(captureSize);
+            params.setPictureSize(captureSize[captureSizeIDX].width, captureSize[captureSizeIDX].height);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'l':
+        case 'L':
+            VcaptureSizeIDX++;
+            VcaptureSizeIDX %= ARRAY_SIZE(VcaptureSize);
+            break;
+
+        case ']':
+            VbitRateIDX++;
+            VbitRateIDX %= ARRAY_SIZE(VbitRate);
+            break;
+
+
+        case '6':
+
+            if ( !recordingMode ) {
+
+                recordingMode = true;
+
+                if ( startPreview() < 0 ) {
+                    printf("Error while starting preview\n");
+
+                    return -1;
+                }
+
+                if ( openRecorder() < 0 ) {
+                    printf("Error while openning video recorder\n");
+
+                    return -1;
+                }
+
+                if ( configureRecorder() < 0 ) {
+                    printf("Error while configuring video recorder\n");
+
+                    return -1;
+                }
+
+                if ( startRecording() < 0 ) {
+                    printf("Error while starting video recording\n");
+
+                    return -1;
+                }
+            }
+
+            break;
+
+        case '7':
+
+            if ( compensation > 2.0) {
+                compensation = -2.0;
+            } else {
+                compensation += 0.1;
+            }
+
+            params.set(KEY_COMPENSATION, (int) (compensation * 10));
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case '8':
+            awb_mode++;
+            awb_mode %= ARRAY_SIZE(strawb_mode);
+            params.set(params.KEY_WHITE_BALANCE, strawb_mode[awb_mode]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case '9':
+            videoCodecIDX++;
+            videoCodecIDX %= ARRAY_SIZE(videoCodecs);
+            break;
+        case '~':
+            previewFormat += 1;
+            previewFormat %= ARRAY_SIZE(pixelformat) - 1;
+            params.setPreviewFormat(pixelformat[previewFormat].pixformat);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+        case '$':
+            pictureFormat += 1;
+            if ( strcmp(params.get(KEY_STEREO_CAMERA), "false") == 0 && pictureFormat > 4 )
+                pictureFormat = 0;
+            pictureFormat %= ARRAY_SIZE(codingformat);
+            params.setPictureFormat(codingformat[pictureFormat]);
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case '?' :
+            ///Set mode=3 to select video mode
+            params.set(KEY_MODE, 3);
+            params.set(KEY_VNF, 1);
+            params.set(KEY_VSTAB, 1);
+            break;
+
+        case ':':
+            thumbSizeIDX += 1;
+            thumbSizeIDX %= ARRAY_SIZE(previewSize);
+            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, previewSize[thumbSizeIDX].width);
+            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, previewSize[thumbSizeIDX].height);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case '\'':
+            if ( thumbQuality >= 100) {
+                thumbQuality = 0;
+            } else {
+                thumbQuality += 5;
+            }
+
+            params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality);
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'B' :
+            vnf_mode++;
+            vnf_mode %= ARRAY_SIZE(vnf);
+            params.set(KEY_VNF, vnf_mode);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'C' :
+            vstab_mode++;
+            vstab_mode %= ARRAY_SIZE(vstab);
+            params.set(KEY_VSTAB, vstab_mode);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'E':
+            if(hardwareActive)
+                params.unflatten(camera->getParameters());
+            printSupportedParams();
+            break;
+
+        case '*':
+            if ( hardwareActive )
+                camera->startRecording();
+            break;
+
+        case 'o':
+            if ( jpegQuality >= 100) {
+                jpegQuality = 0;
+            } else {
+                jpegQuality += 5;
+            }
+
+            params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'M':
+            measurementIdx = (measurementIdx + 1)%ARRAY_SIZE(measurement);
+            params.set(KEY_MEASUREMENT, measurement[measurementIdx]);
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+        case 'm':
+        {
+            meter_mode = (meter_mode + 1)%ARRAY_SIZE(metering);
+            params.set(KEY_METERING_MODE, metering[meter_mode]);
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+        }
+
+        case 'k':
+            ippIDX += 1;
+            ippIDX %= ARRAY_SIZE(ipp_mode);
+            ippIDX_old = ippIDX;
+
+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+            params.set(KEY_IPP, ipp_mode[ippIDX]);
+#else
+            params.set(KEY_IPP, ippIDX);
+#endif
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'K':
+            gbceIDX+= 1;
+            gbceIDX %= ARRAY_SIZE(gbce);
+            params.set(KEY_GBCE, gbce[gbceIDX]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'F':
+            if ( hardwareActive )
+                camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, 0, 0);
+
+            break;
+
+        case 'T':
+
+            if ( hardwareActive )
+                camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0);
+
+            break;
+
+        case '@':
+            if ( hardwareActive ) {
+
+                closeCamera();
+
+                if ( 0 >= openCamera() ) {
+                    printf( "Reconnected to CameraService \n");
+                }
+            }
+
+            break;
+
+        case '#':
+
+            if ( burst >= MAX_BURST ) {
+                burst = 0;
+            } else {
+                burst += BURST_INC;
+            }
+            params.set(KEY_BURST, burst);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'J':
+            flashIdx++;
+            flashIdx %= ARRAY_SIZE(flashModes);
+            params.set(CameraParameters::KEY_FLASH_MODE, (flashModes[flashIdx]));
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'u':
+            capture_mode++;
+            capture_mode %= ARRAY_SIZE(capture);
+
+            // HQ should always be in ldc-nsf
+            // if not HQ, then return the ipp to its previous state
+            if( !strcmp(capture[capture_mode], "high-quality") ) {
+                ippIDX_old = ippIDX;
+                ippIDX = 3;
+                params.set(KEY_IPP, ipp_mode[ippIDX]);
+            } else {
+                ippIDX = ippIDX_old;
+            }
+
+            params.set(KEY_MODE, (capture[capture_mode]));
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'U':
+            tempBracketIdx++;
+            tempBracketIdx %= ARRAY_SIZE(tempBracketing);
+            params.set(KEY_TEMP_BRACKETING, tempBracketing[tempBracketIdx]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'H':
+            expBracketIdx++;
+            expBracketIdx %= ARRAY_SIZE(expBracketing);
+
+            params.set(KEY_EXP_BRACKETING_RANGE, expBracketingRange[expBracketIdx]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'W':
+            tempBracketRange++;
+            tempBracketRange %= TEMP_BRACKETING_MAX_RANGE;
+            if ( 0 == tempBracketRange ) {
+                tempBracketRange = 1;
+            }
+
+            params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange);
+            params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'w':
+            scene_mode++;
+            scene_mode %= ARRAY_SIZE(scene);
+            params.set(params.KEY_SCENE_MODE, scene[scene_mode]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'i':
+            iso_mode++;
+            iso_mode %= ARRAY_SIZE(iso);
+            params.set(KEY_ISO, iso[iso_mode]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'h':
+            if ( sharpness >= 100) {
+                sharpness = 0;
+            } else {
+                sharpness += 10;
+            }
+            params.set(KEY_SHARPNESS, sharpness);
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'D':
+        {
+            audioCodecIDX++;
+            audioCodecIDX %= ARRAY_SIZE(audioCodecs);
+            break;
+        }
+
+        case 'v':
+        {
+            outputFormatIDX++;
+            outputFormatIDX %= ARRAY_SIZE(outputFormat);
+            break;
+        }
+
+        case 'z':
+            zoomIDX++;
+            zoomIDX %= ARRAY_SIZE(zoom);
+            params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'j':
+            exposure_mode++;
+            exposure_mode %= ARRAY_SIZE(exposure);
+            params.set(KEY_EXPOSURE, exposure[exposure_mode]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'c':
+            if( contrast >= 200){
+                contrast = 0;
+            } else {
+                contrast += 10;
+            }
+            params.set(KEY_CONTRAST, contrast);
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+        case 'b':
+            if ( brightness >= 200) {
+                brightness = 0;
+            } else {
+                brightness += 10;
+            }
+
+            params.set(KEY_BRIGHTNESS, brightness);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 's':
+        case 'S':
+            if ( saturation >= 100) {
+                saturation = 0;
+            } else {
+                saturation += 10;
+            }
+
+            params.set(KEY_SATURATION, saturation);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'e':
+            effects_mode++;
+            effects_mode %= ARRAY_SIZE(effects);
+            params.set(params.KEY_EFFECT, effects[effects_mode]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'r':
+
+
+            if (camera_index == 0) {
+                frameRateIDX += 1;
+                frameRateIDX %= ARRAY_SIZE(fpsConstRanges);
+                params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRanges[frameRateIDX].range);
+            } else
+            {
+                frameRateIDXSec += 1;
+                frameRateIDXSec %= ARRAY_SIZE(fpsConstRangesSec);
+                params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRangesSec[frameRateIDXSec].range);
+
+
+            }
+
+            if ( hardwareActive ) {
+                camera->setParameters(params.flatten());
+            }
+
+            break;
+
+        case 'R':
+            fpsRangeIdx += 1;
+            fpsRangeIdx %= ARRAY_SIZE(fpsRanges);
+            params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsRanges[fpsRangeIdx].range);
+
+            if ( hardwareActive ) {
+                camera->setParameters(params.flatten());
+            }
+
+            break;
+
+        case 'x':
+            antibanding_mode++;
+            antibanding_mode %= ARRAY_SIZE(antibanding);
+            params.set(params.KEY_ANTIBANDING, antibanding[antibanding_mode]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'g':
+            focus_mode++;
+            focus_mode %= ARRAY_SIZE(focus);
+            params.set(params.KEY_FOCUS_MODE, focus[focus_mode]);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            break;
+
+        case 'G':
+
+            params.set(CameraParameters::KEY_FOCUS_AREAS, TEST_FOCUS_AREA);
+
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+
+            params.remove(CameraParameters::KEY_FOCUS_AREAS);
+
+        case 'f':
+
+            gettimeofday(&autofocus_start, 0);
+
+            if ( hardwareActive )
+                camera->autoFocus();
+
+            break;
+
+        case 'p':
+
+            gettimeofday(&picture_start, 0);
+
+            if ( hardwareActive )
+                camera->takePicture(CAMERA_MSG_COMPRESSED_IMAGE|CAMERA_MSG_RAW_IMAGE);
+
+            break;
+
+        case '&':
+            printf("Enabling Preview Callback");
+            dump_preview = 1;
+            if ( hardwareActive )
+            camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
+            break;
+
+        case '{':
+            if ( strcmp(params.get(KEY_S3D2D_PREVIEW_MODE), "off") == 0 )
+                {
+                params.set(KEY_S3D2D_PREVIEW_MODE, "on");
+                }
+            else
+                {
+                params.set(KEY_S3D2D_PREVIEW_MODE, "off");
+                }
+            if ( hardwareActive )
+                camera->setParameters(params.flatten());
+            break;
+
+        case 'a':
+
+            while (1) {
+                if ( menu_gps() < 0)
+                    break;
+            };
+
+            break;
+
+        case 'q':
+
+            stopPreview();
+
+            return -1;
+
+        case '/':
+        {
+            if (showfps)
+            {
+                property_set("debug.image.showfps", "0");
+                showfps = false;
+            }
+            else
+            {
+                property_set("debug.image.showfps", "1");
+                showfps = true;
+            }
+            break;
+        }
+
+    case '<':
+      elockidx += 1;
+      elockidx %= ARRAY_SIZE(lock);
+      params.set(KEY_AUTO_EXPOSURE_LOCK, lock[elockidx]);
+      if ( hardwareActive )
+        camera->setParameters(params.flatten());
+      break;
+
+    case '>':
+      wblockidx += 1;
+      wblockidx %= ARRAY_SIZE(lock);
+      params.set(KEY_AUTO_WHITEBALANCE_LOCK, lock[wblockidx]);
+      if ( hardwareActive )
+        camera->setParameters(params.flatten());
+      break;
+
+        default:
+            print_menu = 0;
+
+            break;
+    }
+
+    return 0;
+}
+
+void print_usage() {
+    printf(" USAGE: camera_test  <param>  <script>\n");
+    printf(" <param>\n-----------\n\n");
+    printf(" F or f -> Functional tests \n");
+    printf(" A or a -> API tests \n");
+    printf(" E or e -> Error scenario tests \n");
+    printf(" S or s -> Stress tests; with syslink trace \n");
+    printf(" SN or sn -> Stress tests; No syslink trace \n\n");
+    printf(" <script>\n----------\n");
+    printf("Script name (Only for stress tests)\n\n");
+    return;
+}
+
+int error_scenario() {
+    char ch;
+    status_t stat = NO_ERROR;
+
+    if (print_menu) {
+        printf("   0. Buffer need\n");
+        printf("   1. Not enough memory\n");
+        printf("   2. Media server crash\n");
+        printf("   3. Overlay object request\n");
+        printf("   4. Pass unsupported preview&picture format\n");
+        printf("   5. Pass unsupported preview&picture resolution\n");
+        printf("   6. Pass unsupported preview framerate\n");
+
+        printf("   q. Quit\n");
+        printf("   Choice: ");
+    }
+
+    print_menu = 1;
+    ch = getchar();
+    printf("%c\n", ch);
+
+    switch (ch) {
+        case '0': {
+            printf("Case0:Buffer need\n");
+            bufferStarvationTest = 1;
+            params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation
+
+            if ( !recordingMode ) {
+                recordingMode = true;
+                if ( startPreview() < 0 ) {
+                    printf("Error while starting preview\n");
+
+                    return -1;
+                }
+
+                if ( openRecorder() < 0 ) {
+                    printf("Error while openning video recorder\n");
+
+                    return -1;
+                }
+
+                if ( configureRecorder() < 0 ) {
+                    printf("Error while configuring video recorder\n");
+
+                    return -1;
+                }
+
+                if ( startRecording() < 0 ) {
+                    printf("Error while starting video recording\n");
+
+                    return -1;
+                }
+
+            }
+
+            usleep(1000000);//1s
+
+            stopPreview();
+
+            if ( recordingMode ) {
+                stopRecording();
+                closeRecorder();
+
+                recordingMode = false;
+            }
+
+            break;
+        }
+
+        case '1': {
+            printf("Case1:Not enough memory\n");
+            int* tMemoryEater = new int[999999999];
+
+            if (!tMemoryEater) {
+                printf("Not enough memory\n");
+                return -1;
+            } else {
+                delete tMemoryEater;
+            }
+
+            break;
+        }
+
+        case '2': {
+            printf("Case2:Media server crash\n");
+            //camera = Camera::connect();
+
+            if ( NULL == camera.get() ) {
+                printf("Unable to connect to CameraService\n");
+                return -1;
+            }
+
+            break;
+        }
+
+        case '3': {
+            printf("Case3:Overlay object request\n");
+            int err = 0;
+
+            err = open("/dev/video5", O_RDWR);
+
+            if (err < 0) {
+                printf("Could not open the camera device5: %d\n",  err );
+                return err;
+            }
+
+            if ( startPreview() < 0 ) {
+                printf("Error while starting preview\n");
+                return -1;
+            }
+
+            usleep(1000000);//1s
+
+            stopPreview();
+
+            close(err);
+            break;
+        }
+
+        case '4': {
+
+            if ( hardwareActive ) {
+
+                params.setPictureFormat("invalid-format");
+                params.setPreviewFormat("invalid-format");
+
+                stat = camera->setParameters(params.flatten());
+
+                if ( NO_ERROR != stat ) {
+                    printf("Test passed!\n");
+                } else {
+                    printf("Test failed!\n");
+                }
+
+                initDefaults();
+            }
+
+            break;
+        }
+
+        case '5': {
+
+            if ( hardwareActive ) {
+
+                params.setPictureSize(-1, -1);
+                params.setPreviewSize(-1, -1);
+
+                stat = camera->setParameters(params.flatten());
+
+                if ( NO_ERROR != stat ) {
+                    printf("Test passed!\n");
+                } else {
+                    printf("Test failed!\n");
+                }
+
+                initDefaults();
+            }
+
+            break;
+        }
+
+        case '6': {
+
+            if ( hardwareActive ) {
+
+                params.setPreviewFrameRate(-1);
+
+                stat = camera->setParameters(params.flatten());
+
+                if ( NO_ERROR != stat ) {
+                    printf("Test passed!\n");
+                } else {
+                    printf("Test failed!\n");
+                }
+
+                initDefaults();
+            }
+
+
+            break;
+        }
+
+        case 'q': {
+            return -1;
+        }
+
+        default: {
+            print_menu = 0;
+            break;
+        }
+    }
+
+    return 0;
+}
+
+int restartCamera() {
+
+  const char dir_path_name[80] = SDCARD_PATH;
+
+  printf("+++Restarting Camera After Error+++\n");
+  stopPreview();
+
+  if (recordingMode) {
+    stopRecording();
+    closeRecorder();
+
+    recordingMode = false;
+  }
+
+  sleep(3); //Wait a bit before restarting
+
+  restartCount++;
+
+  if (strcpy(dir_path, dir_path_name) == NULL)
+  {
+    printf("Error reseting dir name");
+    return -1;
+  }
+
+  if ( openCamera() < 0 )
+  {
+    printf("+++Camera Restarted Failed+++\n");
+    system("echo camerahal_test > /sys/power/wake_unlock");
+    return -1;
+  }
+
+  initDefaults();
+
+  stopScript = false;
+
+  printf("+++Camera Restarted Successfully+++\n");
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+    char *cmd;
+    int pid;
+    sp<ProcessState> proc(ProcessState::self());
+
+    unsigned long long st, end, delay;
+    timeval current_time;
+
+    gettimeofday(&current_time, 0);
+
+    st = current_time.tv_sec * 1000000 + current_time.tv_usec;
+
+    cmd = NULL;
+
+    if ( argc < 2 ) {
+        printf(" Please enter atleast 1 argument\n");
+        print_usage();
+
+        return 0;
+    }
+    system("echo camerahal_test > /sys/power/wake_lock");
+    if ( argc < 3 ) {
+        switch (*argv[1]) {
+            case 'S':
+            case 's':
+                printf("This is stress / regression tests \n");
+                printf("Provide script file as 2nd argument\n");
+
+                break;
+
+            case 'F':
+            case 'f':
+                ProcessState::self()->startThreadPool();
+
+                if ( openCamera() < 0 ) {
+                    printf("Camera initialization failed\n");
+                    system("echo camerahal_test > /sys/power/wake_unlock");
+                    return -1;
+                }
+
+                initDefaults();
+                print_menu = 1;
+
+                while ( 1 ) {
+                    if ( functional_menu() < 0 )
+                        break;
+                };
+
+                break;
+
+            case 'A':
+            case 'a':
+                printf("API level test cases coming soon ... \n");
+
+                break;
+
+            case 'E':
+            case 'e': {
+                ProcessState::self()->startThreadPool();
+
+                if ( openCamera() < 0 ) {
+                    printf("Camera initialization failed\n");
+                    system("echo camerahal_test > /sys/power/wake_unlock");
+                    return -1;
+                }
+
+                initDefaults();
+                print_menu = 1;
+
+                while (1) {
+                    if (error_scenario() < 0) {
+                        break;
+                    }
+                }
+
+                break;
+            }
+
+            default:
+                printf("INVALID OPTION USED\n");
+                print_usage();
+
+                break;
+        }
+    } else if ( ( argc == 3) && ( ( *argv[1] == 'S' ) || ( *argv[1] == 's') ) ) {
+
+        if((argv[1][1] == 'N') || (argv[1][1] == 'n')) {
+            bLogSysLinkTrace = false;
+        }
+
+        ProcessState::self()->startThreadPool();
+
+        if ( openCamera() < 0 ) {
+            printf("Camera initialization failed\n");
+            system("echo camerahal_test > /sys/power/wake_unlock");
+            return -1;
+        }
+
+        initDefaults();
+
+        cmd = load_script(argv[2]);
+
+        if ( cmd != NULL) {
+            start_logging(argv[2], pid);
+            stressTest = true;
+
+            while (1)
+              {
+                if ( execute_functional_script(cmd) == 0 )
+                  {
+                    break;
+                  }
+                else
+                  {
+                    printf("CameraTest Restarting Camera...\n");
+
+                    free(cmd);
+                    cmd = NULL;
+
+                    if ( (restartCamera() != 0)  || ((cmd = load_script(argv[2])) == NULL) )
+                      {
+                        printf("ERROR::CameraTest Restarting Camera...\n");
+                        break;
+                      }
+                  }
+              }
+            free(cmd);
+            stop_logging(pid);
+        }
+    } else if ( ( argc == 3) && ( ( *argv[1] == 'E' ) || ( *argv[1] == 'e') ) ) {
+
+        ProcessState::self()->startThreadPool();
+
+        if ( openCamera() < 0 ) {
+            printf("Camera initialization failed\n");
+            system("echo camerahal_test > /sys/power/wake_unlock");
+            return -1;
+        }
+
+        initDefaults();
+
+        cmd = load_script(argv[2]);
+
+        if ( cmd != NULL) {
+            start_logging(argv[2], pid);
+            execute_error_script(cmd);
+            free(cmd);
+            stop_logging(pid);
+        }
+
+    } else {
+        printf("INVALID OPTION USED\n");
+        print_usage();
+    }
+
+    gettimeofday(&current_time, 0);
+    end = current_time.tv_sec * 1000000 + current_time.tv_usec;
+    delay = end - st;
+    printf("Application clossed after: %llu ms\n", delay);
+    system("echo camerahal_test > /sys/power/wake_unlock");
+    return 0;
+}
+
diff --git a/test/CameraHal/camera_test_script.cpp b/test/CameraHal/camera_test_script.cpp
new file mode 100644
index 0000000..15a403c
--- /dev/null
+++ b/test/CameraHal/camera_test_script.cpp
@@ -0,0 +1,1373 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+#include <semaphore.h>
+#include <pthread.h>
+
+#include <surfaceflinger/Surface.h>
+#include <surfaceflinger/ISurface.h>
+#include <surfaceflinger/ISurfaceComposer.h>
+#include <surfaceflinger/ISurfaceComposerClient.h>
+#include <surfaceflinger/SurfaceComposerClient.h>
+
+#include <camera/Camera.h>
+#include <camera/ICamera.h>
+#include <media/mediarecorder.h>
+
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/IServiceManager.h>
+#include <cutils/properties.h>
+#include <camera/CameraParameters.h>
+
+#include <sys/wait.h>
+
+#include "camera_test.h"
+
+using namespace android;
+
+extern bool stopScript;
+extern bool hardwareActive;
+extern sp<Camera> camera;
+extern CameraParameters params;
+extern bool recordingMode;
+extern int camera_index;
+extern int rotation;
+extern const preview_size previewSize [];
+extern const Vcapture_size VcaptureSize [];
+extern const capture_Size captureSize[];
+extern const outformat outputFormat[];
+extern const video_Codecs videoCodecs[];
+extern const audio_Codecs audioCodecs[];
+extern const V_bitRate VbitRate[];
+extern const fps_ranges fpsRanges[];
+extern const fpsConst_Ranges fpsConstRanges[];
+extern const fpsConst_RangesSec fpsConstRangesSec[];
+extern const Zoom zoom [];
+extern int previewSizeIDX;
+extern bool reSizePreview;
+extern bool previewRunning;
+extern int captureSizeIDX;
+extern float compensation;
+extern int videoCodecIDX;
+extern int outputFormatIDX;
+extern int audioCodecIDX;
+extern int VcaptureSizeIDX;
+extern int VbitRateIDX;
+extern int thumbSizeIDX;
+extern int thumbQuality;
+extern int jpegQuality;
+extern int dump_preview;
+extern int ippIDX_old;
+extern const char *capture[];
+extern int capture_mode;
+extern int ippIDX;
+extern const char *ipp_mode[];
+extern int tempBracketRange;
+extern int iso_mode;
+extern int sharpness;
+extern int contrast;
+extern int zoomIDX;
+extern int brightness;
+extern int saturation;
+extern int fpsRangeIdx;
+extern timeval autofocus_start, picture_start;
+extern const char *cameras[];
+extern double latitude;
+extern double degree_by_step;
+extern double longitude;
+extern double altitude;
+extern char dir_path[80];
+extern int AutoConvergenceModeIDX;
+extern const char *autoconvergencemode[];
+extern const char *manualconvergencevalues[];
+extern const int ManualConvergenceDefaultValueIDX;
+extern size_t length_cam;
+extern char script_name[];
+extern int restartCount;
+extern bool bLogSysLinkTrace;
+extern int bufferStarvationTest;
+extern size_t length_previewSize;
+extern size_t lenght_Vcapture_size;
+extern size_t length_outformat;
+extern size_t length_capture_Size;
+extern size_t length_video_Codecs;
+extern size_t length_audio_Codecs;
+extern size_t length_V_bitRate;
+extern size_t length_Zoom;
+extern size_t length_fps_ranges;
+extern size_t length_fpsConst_Ranges;
+extern size_t length_fpsConst_RangesSec;
+
+
+int execute_functional_script(char *script) {
+    char *cmd, *ctx, *cycle_cmd, *temp_cmd;
+    char id;
+    unsigned int i;
+    int dly;
+    int cycleCounter = 1;
+    int tLen = 0;
+    unsigned int iteration = 0;
+    status_t ret = NO_ERROR;
+    int frameR = 20;
+    int frameRateIndex = 0;
+
+    LOG_FUNCTION_NAME;
+
+    dump_mem_status();
+
+    cmd = strtok_r((char *) script, DELIMITER, &ctx);
+
+    while ( NULL != cmd && (stopScript == false)) {
+        id = cmd[0];
+        printf("Full Command: %s \n", cmd);
+        printf("Command: %c \n", cmd[0]);
+
+        switch (id) {
+
+            // Case for Suspend-Resume Feature
+            case '!': {
+                // STEP 1: Mount Debugfs
+                system("mkdir /debug");
+                system("mount -t debugfs debugfs /debug");
+
+                // STEP 2: Set up wake up Timer - wake up happens after 5 seconds
+                system("echo 10 > /debug/pm_debug/wakeup_timer_seconds");
+
+                // STEP 3: Make system ready for Suspend
+                system("echo camerahal_test > /sys/power/wake_unlock");
+                // Release wake lock held by test app
+                printf(" Wake lock released ");
+                system("cat /sys/power/wake_lock");
+                system("sendevent /dev/input/event0 1 60 1");
+                system("sendevent /dev/input/event0 1 60 0");
+                // Simulate F2 key press to make display OFF
+                printf(" F2 event simulation complete ");
+
+                //STEP 4: Wait for system Resume and then simuate F1 key
+                sleep(50);//50s  // This delay is not related to suspend resume timer
+                printf(" After 30 seconds of sleep");
+                system("sendevent /dev/input/event0 1 59 0");
+                system("sendevent /dev/input/event0 1 59 1");
+                // Simulate F1 key press to make display ON
+                system("echo camerahal_test > /sys/power/wake_lock");
+                // Acquire wake lock for test app
+
+                break;
+            }
+
+            case '[':
+                if ( hardwareActive )
+                    {
+
+                    camera->setParameters(params.flatten());
+
+                    printf("starting camera preview..");
+                    status_t ret = camera->startPreview();
+                    if(ret !=NO_ERROR)
+                        {
+                        printf("startPreview failed %d..", ret);
+                        }
+                    }
+                break;
+            case '+': {
+                cycleCounter = atoi(cmd + 1);
+                cycle_cmd = get_cycle_cmd(ctx);
+                tLen = strlen(cycle_cmd);
+                temp_cmd = new char[tLen+1];
+
+                for (int ind = 0; ind < cycleCounter; ind++) {
+                    strcpy(temp_cmd, cycle_cmd);
+                    if ( execute_functional_script(temp_cmd) != 0 )
+                      return -1;
+                    temp_cmd[0] = '\0';
+
+                    //patch for image capture
+                    //[
+                    if (ind < cycleCounter - 1) {
+                        if (hardwareActive == false) {
+                            if ( openCamera() < 0 ) {
+                                printf("Camera initialization failed\n");
+
+                                return -1;
+                            }
+
+                            initDefaults();
+                        }
+                    }
+
+                    //]
+                }
+
+                ctx += tLen + 1;
+
+                if (temp_cmd) {
+                    delete temp_cmd;
+                    temp_cmd = NULL;
+                }
+
+                if (cycle_cmd) {
+                    delete cycle_cmd;
+                    cycle_cmd = NULL;
+                }
+
+                break;
+            }
+
+            case '0':
+            {
+                initDefaults();
+                break;
+            }
+
+            case '1':
+
+                if ( startPreview() < 0 ) {
+                    printf("Error while starting preview\n");
+
+                    return -1;
+                }
+
+                break;
+
+            case '2':
+                stopPreview();
+
+                if ( recordingMode ) {
+
+                    camera->disconnect();
+                    camera.clear();
+                    stopRecording();
+                    closeRecorder();
+
+                    camera = Camera::connect(camera_index);
+                      if ( NULL == camera.get() ) {
+                          sleep(1);
+                          camera = Camera::connect(camera_index);
+
+                          if ( NULL == camera.get() ) {
+                              return -1;
+                          }
+                      }
+                      camera->setListener(new CameraHandler());
+                      camera->setParameters(params.flatten());
+
+                      recordingMode = false;
+                }
+
+                break;
+
+            case '3':
+                rotation = atoi(cmd + 1);
+                params.set(CameraParameters::KEY_ROTATION, rotation);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case '4':
+            {
+                printf("Setting resolution...");
+                int width, height;
+                for(i = 0; i < length_previewSize ; i++)
+                {
+                    if( strcmp((cmd + 1), previewSize[i].desc) == 0)
+                    {
+                        width = previewSize[i].width;
+                        height = previewSize[i].height;
+                        previewSizeIDX = i;
+                        break;
+                    }
+                }
+
+                if (i == length_previewSize )   //if the resolution is not in the supported ones
+                {
+                    char *res = NULL;
+                    res = strtok(cmd + 1, "x");
+                    width = atoi(res);
+                    res = strtok(NULL, "x");
+                    height = atoi(res);
+                }
+
+                if ( strcmp(params.get(KEY_STEREO_CAMERA), "true") == 0 ) {
+                    height *=2;
+                }
+                printf("Resolution: %d x %d\n", width, height);
+                params.setPreviewSize(width, height);
+                reSizePreview = true;
+
+                if ( hardwareActive && previewRunning ) {
+                    camera->stopPreview();
+                    camera->setParameters(params.flatten());
+                    camera->startPreview();
+                } else if ( hardwareActive ) {
+                    camera->setParameters(params.flatten());
+                }
+
+                break;
+            }
+            case '5':
+
+                for (i = 0; i < length_capture_Size; i++) {
+                    if ( strcmp((cmd + 1), captureSize[i].name) == 0)
+                        break;
+                }
+
+                if (  i < length_capture_Size ) {
+                    params.setPictureSize(captureSize[i].width, captureSize[i].height);
+                    captureSizeIDX = i;
+                }
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case '6':
+
+                if ( !recordingMode ) {
+
+                    recordingMode = true;
+
+                    if ( startPreview() < 0 ) {
+                        printf("Error while starting preview\n");
+
+                        return -1;
+                    }
+
+                    if ( openRecorder() < 0 ) {
+                        printf("Error while openning video recorder\n");
+
+                        return -1;
+                    }
+
+                    if ( configureRecorder() < 0 ) {
+                        printf("Error while configuring video recorder\n");
+
+                        return -1;
+                    }
+
+                    if ( startRecording() < 0 ) {
+                        printf("Error while starting video recording\n");
+
+                        return -1;
+                    }
+
+                }
+
+                break;
+
+            case '7':
+                compensation = atof(cmd + 1);
+                params.set(KEY_COMPENSATION, (int) (compensation * 10));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case '8':
+                params.set(params.KEY_WHITE_BALANCE, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case '9':
+                for(i = 0; i < length_video_Codecs; i++)
+                {
+                    if( strcmp((cmd + 1), videoCodecs[i].desc) == 0)
+                    {
+                        videoCodecIDX = i;
+                        printf("Video Codec Selected: %s\n",
+                                videoCodecs[i].desc);
+                        break;
+                    }
+                }
+                break;
+
+            case 'v':
+                for(i = 0; i < length_outformat; i++)
+
+                {
+                    if( strcmp((cmd + 1), outputFormat[i].desc) == 0)
+                    {
+                        outputFormatIDX = i;
+                        printf("Video Codec Selected: %s\n",
+                                videoCodecs[i].desc);
+                        break;
+                    }
+                }
+            break;
+
+            case '~':
+                params.setPreviewFormat(cmd + 1);
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case '$':
+                params.setPictureFormat(cmd + 1);
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+            case '-':
+                for(i = 0; i < length_audio_Codecs; i++)
+                {
+                    if( strcmp((cmd + 1), audioCodecs[i].desc) == 0)
+                    {
+                        audioCodecIDX = i;
+                        printf("Selected Audio: %s\n", audioCodecs[i].desc);
+                        break;
+                    }
+                }
+                break;
+
+            case 'A':
+                camera_index=atoi(cmd+1);
+           //     camera_index %= ARRAY_SIZE(cameras);
+                camera_index %= length_cam;
+                if ( camera_index == 2)
+                    params.set(KEY_STEREO_CAMERA, "true");
+                else
+                    params.set(KEY_STEREO_CAMERA, "false");
+
+                printf("%s selected.\n", cameras[camera_index]);
+
+                if ( hardwareActive ) {
+                    stopPreview();
+                    closeCamera();
+                    openCamera();
+                } else {
+                    closeCamera();
+                    openCamera();
+                }
+
+                if (camera_index == 0) params.setPreviewFrameRate(30);
+                  else params.setPreviewFrameRate(27);
+
+
+                break;
+
+            case 'a':
+                char * temp_str;
+
+                temp_str = strtok(cmd+1,"!");
+                printf("Latitude %s \n",temp_str);
+                params.set(params.KEY_GPS_LATITUDE, temp_str);
+                temp_str=strtok(NULL,"!");
+                printf("Longitude %s \n",temp_str);
+                params.set(params.KEY_GPS_LONGITUDE, temp_str);
+                temp_str=strtok(NULL,"!");
+                printf("Altitude %s \n",temp_str);
+                params.set(params.KEY_GPS_ALTITUDE, temp_str);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+                break;
+
+            case 'l':
+            case 'L':
+                for(i = 0; i < lenght_Vcapture_size; i++)
+                {
+                    if( strcmp((cmd + 1), VcaptureSize[i].desc) == 0)
+                    {
+                        VcaptureSizeIDX = i;
+                        printf("Video Capture Size: %s\n", VcaptureSize[i].desc);
+                        break;
+                    }
+                }
+                break;
+            case ']':
+                for(i = 0; i < length_V_bitRate; i++)
+                {
+                    if( strcmp((cmd + 1), VbitRate[i].desc) == 0)
+                    {
+                        VbitRateIDX = i;
+                        printf("Video Bit Rate: %s\n", VbitRate[i].desc);
+                        break;
+                    }
+                }
+                break;
+            case ':':
+                int width, height;
+                for(i = 0; i < length_previewSize ; i++)
+                {
+                    if( strcmp((cmd + 1), previewSize[i].desc) == 0)
+                    {
+                        width = previewSize[i].width;
+                        height = previewSize[i].height;
+                        thumbSizeIDX = i;
+                        break;
+                    }
+                }
+
+                if (i == length_previewSize )   //if the resolution is not in the supported ones
+                {
+                    char *res = NULL;
+                    res = strtok(cmd + 1, "x");
+                    width = atoi(res);
+                    res = strtok(NULL, "x");
+                    height = atoi(res);
+                }
+
+                params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
+                params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case '\'':
+                thumbQuality = atoi(cmd + 1);
+
+                params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, thumbQuality);
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+                break;
+
+            case '*':
+                if ( hardwareActive )
+                    camera->startRecording();
+                break;
+
+            case 't':
+                params.setPreviewFormat((cmd + 1));
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+                break;
+
+            case 'o':
+                jpegQuality = atoi(cmd + 1);
+                params.set(CameraParameters::KEY_JPEG_QUALITY, jpegQuality);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+
+            case '&':
+                printf("Enabling Preview Callback");
+                dump_preview = 1;
+                camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
+                break;
+
+
+            case 'k':
+                ippIDX_old = atoi(cmd + 1);
+                params.set(KEY_IPP, atoi(cmd + 1));
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'K':
+                params.set(KEY_GBCE, (cmd+1));
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'u':
+                // HQ should always be in ldc-nsf
+                // if not HQ, then return the ipp to its previous state
+                if( !strcmp(capture[capture_mode], "high-quality") ) {
+                    ippIDX_old = ippIDX;
+                    ippIDX = 3;
+                    params.set(KEY_IPP, ipp_mode[ippIDX]);
+                } else {
+                    ippIDX = ippIDX_old;
+                }
+
+                params.set(KEY_MODE, (cmd + 1));
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'U':
+
+                params.set(KEY_TEMP_BRACKETING, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'W':
+
+                tempBracketRange = atoi(cmd + 1);
+                tempBracketRange %= TEMP_BRACKETING_MAX_RANGE;
+                if ( 0 == tempBracketRange ) {
+                    tempBracketRange = 1;
+                }
+
+                params.set(KEY_TEMP_BRACKETING_NEG, tempBracketRange);
+                params.set(KEY_TEMP_BRACKETING_POS, tempBracketRange);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+            break;
+
+            case '#':
+
+                params.set(KEY_BURST, atoi(cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'J':
+                params.set(CameraParameters::KEY_FLASH_MODE, (cmd+1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'w':
+                params.set(params.KEY_SCENE_MODE, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'B' :
+                params.set(KEY_VNF, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+
+            case 'C' :
+                params.set(KEY_VSTAB, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+                break;
+
+            case 'D':
+                if ( hardwareActive )
+                    camera->stopRecording();
+                break;
+
+            case 'E':
+                if(hardwareActive)
+                    params.unflatten(camera->getParameters());
+                printSupportedParams();
+                break;
+
+            case 'i':
+                iso_mode = atoi(cmd + 1);
+                params.set(KEY_ISO, iso_mode);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'h':
+                sharpness = atoi(cmd + 1);
+                params.set(KEY_SHARPNESS, sharpness);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case '@':
+                if ( hardwareActive ) {
+
+                    closeCamera();
+
+                    if ( 0 >= openCamera() ) {
+                        printf( "Reconnected to CameraService \n");
+                    }
+                }
+
+                break;
+
+            case 'c':
+                contrast = atoi(cmd + 1);
+                params.set(KEY_CONTRAST, contrast);
+
+                if ( hardwareActive ) {
+                    camera->setParameters(params.flatten());
+                }
+
+                break;
+
+            case 'z':
+            case 'Z':
+
+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)
+                params.set(CameraParameters::KEY_ZOOM, atoi(cmd + 1));
+#else
+
+                for(i = 0; i < length_Zoom; i++)
+                {
+                    if( strcmp((cmd + 1), zoom[i].zoom_description) == 0)
+                    {
+                        zoomIDX = i;
+                        break;
+                    }
+                }
+
+                params.set(CameraParameters::KEY_ZOOM, zoom[zoomIDX].idx);
+#endif
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'j':
+                params.set(KEY_EXPOSURE, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'b':
+                brightness = atoi(cmd + 1);
+                params.set(KEY_BRIGHTNESS, brightness);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 's':
+                saturation = atoi(cmd + 1);
+                params.set(KEY_SATURATION, saturation);
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'e':
+                params.set(params.KEY_EFFECT, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'r':
+
+                frameR = atoi(cmd + 1);
+
+
+                if (camera_index == 0) {
+                    for (i = 0; i < length_fpsConst_Ranges; i++) {
+                        if (frameR == fpsConstRanges[i].constFramerate)
+                            frameRateIndex = i;
+
+                    }
+                } else {
+                    for (i = 0; i < length_fpsConst_RangesSec; i++) {
+                        if (frameR == fpsConstRangesSec[i].constFramerate)
+                            frameRateIndex = i;
+                    }
+                }
+
+
+                if (camera_index == 0)
+                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRanges[frameRateIndex].range);
+                else
+                    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsConstRangesSec[frameRateIndex].range);
+
+
+                if ( hardwareActive && previewRunning ) {
+                    camera->stopPreview();
+                    camera->setParameters(params.flatten());
+                    camera->startPreview();
+                } else if ( hardwareActive ) {
+                    camera->setParameters(params.flatten());
+                }
+
+                break;
+
+            case 'R':
+                for(i = 0; i < length_fps_ranges; i++)
+                {
+                    if( strcmp((cmd + 1), fpsRanges[i].rangeDescription) == 0)
+                    {
+                        fpsRangeIdx = i;
+                        printf("Selected Framerate range: %s\n", fpsRanges[i].rangeDescription);
+                        if ( hardwareActive ) {
+                            params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, fpsRanges[i].range);
+                            params.remove(CameraParameters::KEY_PREVIEW_FRAME_RATE);
+                            camera->setParameters(params.flatten());
+                        }
+                        break;
+                    }
+                }
+                break;
+
+            case 'x':
+                params.set(params.KEY_ANTIBANDING, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'g':
+                params.set(params.KEY_FOCUS_MODE, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                break;
+
+            case 'G':
+
+                params.set(CameraParameters::KEY_FOCUS_AREAS, (cmd + 1));
+
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+
+                params.remove(CameraParameters::KEY_FOCUS_AREAS);
+
+            case 'f':
+                gettimeofday(&autofocus_start, 0);
+
+                if ( hardwareActive )
+                    camera->autoFocus();
+
+                break;
+
+            case 'p':
+                gettimeofday(&picture_start, 0);
+
+                if ( hardwareActive )
+                    ret = camera->takePicture(CAMERA_MSG_COMPRESSED_IMAGE|CAMERA_MSG_RAW_IMAGE);
+
+                if ( ret != NO_ERROR )
+                    printf("Error returned while taking a picture");
+                break;
+
+            case 'd':
+                dly = atoi(cmd + 1);
+                sleep(dly);
+                break;
+
+            case 'q':
+                dump_mem_status();
+                stopPreview();
+
+                if ( recordingMode ) {
+                    stopRecording();
+                    closeRecorder();
+
+                    recordingMode = false;
+                }
+                goto exit;
+
+            case '\n':
+                printf("Iteration: %d \n", iteration);
+                iteration++;
+                break;
+
+            case '{':
+                if ( atoi(cmd + 1) > 0 )
+                    params.set(KEY_S3D2D_PREVIEW_MODE, "on");
+                else
+                    params.set(KEY_S3D2D_PREVIEW_MODE, "off");
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+                break;
+
+            case 'M':
+                params.set(KEY_MEASUREMENT, (cmd + 1));
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+                break;
+            case 'm':
+            {
+                params.set(KEY_METERING_MODE, (cmd + 1));
+                if ( hardwareActive )
+                {
+                    camera->setParameters(params.flatten());
+                }
+                break;
+            }
+            case '<':
+            {
+                char coord_str[8];
+                latitude += degree_by_step;
+                if (latitude > 90.0)
+                {
+                    latitude -= 180.0;
+                }
+                snprintf(coord_str, 7, "%.7lf", latitude);
+                params.set(params.KEY_GPS_LATITUDE, coord_str);
+                if ( hardwareActive )
+                {
+                    camera->setParameters(params.flatten());
+                }
+                break;
+            }
+
+            case '=':
+            {
+                char coord_str[8];
+                longitude += degree_by_step;
+                if (longitude > 180.0)
+                {
+                    longitude -= 360.0;
+                }
+                snprintf(coord_str, 7, "%.7lf", longitude);
+                params.set(params.KEY_GPS_LONGITUDE, coord_str);
+                if ( hardwareActive )
+                {
+                    camera->setParameters(params.flatten());
+                }
+                break;
+            }
+
+            case '>':
+            {
+                char coord_str[8];
+                altitude += 12345.67890123456789;
+                if (altitude > 100000.0)
+                {
+                    altitude -= 200000.0;
+                }
+                snprintf(coord_str, 7, "%.7lf", altitude);
+                params.set(params.KEY_GPS_ALTITUDE, coord_str);
+                if ( hardwareActive )
+                {
+                    camera->setParameters(params.flatten());
+                }
+                break;
+            }
+
+            case 'X':
+            {
+                char rem_str[50];
+                printf("Deleting images from %s \n", dir_path);
+                if(!sprintf(rem_str,"rm %s/*.jpg",dir_path))
+                    printf("Sprintf Error");
+                if(system(rem_str))
+                    printf("Images were not deleted\n");
+                break;
+            }
+
+            case '_':
+            {
+                AutoConvergenceModeIDX = atoi(cmd + 1);
+                if ( AutoConvergenceModeIDX < 0 || AutoConvergenceModeIDX > 4 )
+                    AutoConvergenceModeIDX = 0;
+                params.set(KEY_AUTOCONVERGENCE, autoconvergencemode[AutoConvergenceModeIDX]);
+                if ( AutoConvergenceModeIDX != 4 )
+                    params.set(KEY_MANUALCONVERGENCE_VALUES, manualconvergencevalues[ManualConvergenceDefaultValueIDX]);
+                if ( hardwareActive )
+                    camera->setParameters(params.flatten());
+                break;
+            }
+
+            case '^':
+            {
+                char strtmpval[7];
+                if ( strcmp (autoconvergencemode[AutoConvergenceModeIDX], AUTOCONVERGENCE_MODE_MANUAL) == 0) {
+                    sprintf(strtmpval,"%d", atoi(cmd + 1));
+                    params.set(KEY_MANUALCONVERGENCE_VALUES, strtmpval);
+                    if ( hardwareActive )
+                        camera->setParameters(params.flatten());
+                }
+                break;
+            }
+
+            default:
+                printf("Unrecognized command!\n");
+                break;
+        }
+
+        cmd = strtok_r(NULL, DELIMITER, &ctx);
+    }
+
+exit:
+    if (stopScript == true)
+      {
+        return -1;
+      }
+    else
+      {
+        return 0;
+      }
+}
+
+
+char * get_cycle_cmd(const char *aSrc) {
+    unsigned ind = 0;
+    char *cycle_cmd = new char[256];
+
+    while ((*aSrc != '+') && (*aSrc != '\0')) {
+        cycle_cmd[ind++] = *aSrc++;
+    }
+    cycle_cmd[ind] = '\0';
+
+    return cycle_cmd;
+}
+
+status_t dump_mem_status() {
+  system(MEDIASERVER_DUMP);
+  return system(MEMORY_DUMP);
+}
+
+char *load_script(char *config) {
+    FILE *infile;
+    size_t fileSize;
+    char *script;
+    size_t nRead = 0;
+    char dir_name[40];
+    size_t count;
+    char rCount [5];
+
+    count = 0;
+
+    infile = fopen(config, "r");
+
+    strcpy(script_name,config);
+
+    // remove just the '.txt' part of the config
+    while((config[count] != '.') && (count < sizeof(dir_name)/sizeof(dir_name[0])))
+        count++;
+
+    printf("\n SCRIPT : <%s> is currently being executed \n",script_name);
+    if(strncpy(dir_name,config,count) == NULL)
+        printf("Strcpy error");
+
+    dir_name[count]=NULL;
+
+    if(strcat(dir_path,dir_name) == NULL)
+        printf("Strcat error");
+
+    if(restartCount)
+    {
+      sprintf(rCount,"_%d",restartCount);
+      if(strcat(dir_path, rCount) == NULL)
+        printf("Strcat error RestartCount");
+    }
+
+    printf("\n COMPLETE FOLDER PATH : %s \n",dir_path);
+    if(mkdir(dir_path,0777) == -1) {
+        printf("\n Directory %s was not created \n",dir_path);
+    } else {
+        printf("\n Directory %s was created \n",dir_path);
+    }
+    printf("\n DIRECTORY CREATED FOR TEST RESULT IMAGES IN MMC CARD : %s \n",dir_name);
+
+    if( (NULL == infile)){
+        printf("Error while opening script file %s!\n", config);
+        return NULL;
+    }
+
+    fseek(infile, 0, SEEK_END);
+    fileSize = ftell(infile);
+    fseek(infile, 0, SEEK_SET);
+
+    script = (char *) malloc(fileSize);
+
+    if ( NULL == script ) {
+        printf("Unable to allocate buffer for the script\n");
+
+        return NULL;
+    }
+
+    if ((nRead = fread(script, 1, fileSize, infile)) != fileSize) {
+        printf("Error while reading script file!\n");
+
+        free(script);
+        fclose(infile);
+        return NULL;
+    }
+
+    fclose(infile);
+
+    return script;
+}
+
+int start_logging(char *config, int &pid) {
+    char dir_name[40];
+    size_t count = 0;
+    int status = 0;
+
+    // remove just the '.txt' part of the config
+    while((config[count] != '.') && (count < sizeof(dir_name)/sizeof(dir_name[0])))
+        count++;
+
+    if(strncpy(dir_name,config,count) == NULL)
+        printf("Strcpy error");
+
+    dir_name[count]=NULL;
+
+    pid = fork();
+    if (pid == 0)
+    {
+        char *command_list[] = {"sh", "-c", NULL, NULL};
+        char log_cmd[120];
+        // child process to run logging
+
+        // set group id of this process to itself
+        // we will use this group id to kill the
+        // application logging
+        setpgid(getpid(), getpid());
+
+        /* Start logcat */
+        if(!sprintf(log_cmd,"logcat > /sdcard/%s/log.txt &",dir_name))
+            printf(" Sprintf Error");
+
+        /* Start Syslink Trace */
+        if(bLogSysLinkTrace) {
+            if(!sprintf(log_cmd,"%s /system/bin/syslink_trace_daemon.out -l /sdcard/%s/syslink_trace.txt -f &",log_cmd, dir_name))
+                printf(" Sprintf Error");
+        }
+
+        command_list[2] = (char *)log_cmd;
+        execvp("/system/bin/sh", command_list);
+    } if(pid < 0)
+    {
+        printf("failed to fork logcat\n");
+        return -1;
+    }
+
+    //wait for logging to start
+    if(waitpid(pid, &status, 0) != pid)
+    {
+        printf("waitpid failed in log fork\n");
+        return -1;
+    }else
+        printf("logging started... status=%d\n", status);
+
+    return 0;
+}
+
+int stop_logging(int &pid)
+{
+    if(pid > 0)
+    {
+        if(killpg(pid, SIGKILL))
+        {
+            printf("Exit command failed");
+            return -1;
+        } else {
+            printf("\nlogging for script %s is complete\n   logcat saved @ location: %s\n",script_name,dir_path);
+            if (bLogSysLinkTrace)
+                printf("   syslink_trace is saved @ location: %s\n\n",dir_path);
+        }
+    }
+    return 0;
+}
+
+int execute_error_script(char *script) {
+    char *cmd, *ctx;
+    char id;
+    status_t stat = NO_ERROR;
+
+    LOG_FUNCTION_NAME;
+
+    cmd = strtok_r((char *) script, DELIMITER, &ctx);
+
+    while ( NULL != cmd ) {
+        id = cmd[0];
+
+        switch (id) {
+
+            case '0': {
+                bufferStarvationTest = 1;
+                params.set(KEY_BUFF_STARV, bufferStarvationTest); //enable buffer starvation
+
+                if ( !recordingMode ) {
+
+                    recordingMode = true;
+
+                    if ( startPreview() < 0 ) {
+                        printf("Error while starting preview\n");
+
+                        return -1;
+                    }
+
+                    if ( openRecorder() < 0 ) {
+                        printf("Error while openning video recorder\n");
+
+                        return -1;
+                    }
+
+                    if ( configureRecorder() < 0 ) {
+                        printf("Error while configuring video recorder\n");
+
+                        return -1;
+                    }
+
+                    if ( startRecording() < 0 ) {
+                        printf("Error while starting video recording\n");
+
+                        return -1;
+                    }
+
+                }
+
+                usleep(1000000);//1s
+
+                stopPreview();
+
+                if ( recordingMode ) {
+                    stopRecording();
+                    closeRecorder();
+
+                    recordingMode = false;
+                }
+
+                break;
+            }
+
+            case '1': {
+                int* tMemoryEater = new int[999999999];
+
+                if (!tMemoryEater) {
+                    printf("Not enough memory\n");
+                    return -1;
+                } else {
+                    delete tMemoryEater;
+                }
+
+                break;
+            }
+
+            case '2': {
+                //camera = Camera::connect();
+
+                if ( NULL == camera.get() ) {
+                    printf("Unable to connect to CameraService\n");
+                    return -1;
+                }
+
+                break;
+            }
+
+            case '3': {
+                int err = 0;
+
+                err = open("/dev/video5", O_RDWR);
+
+                if (err < 0) {
+                    printf("Could not open the camera device5: %d\n",  err );
+                    return err;
+                }
+
+                if ( startPreview() < 0 ) {
+                    printf("Error while starting preview\n");
+                    return -1;
+                }
+
+                usleep(1000000);//1s
+
+                stopPreview();
+
+                close(err);
+                break;
+            }
+
+            case '4': {
+
+                if ( hardwareActive ) {
+
+                    params.setPictureFormat("invalid-format");
+                    params.setPreviewFormat("invalid-format");
+
+                    stat = camera->setParameters(params.flatten());
+
+                    if ( NO_ERROR != stat ) {
+                        printf("Test passed!\n");
+                    } else {
+                        printf("Test failed!\n");
+                    }
+
+                    initDefaults();
+                }
+
+                break;
+            }
+
+            case '5': {
+
+                if ( hardwareActive ) {
+
+                    params.setPictureSize(-1, -1);
+                    params.setPreviewSize(-1, -1);
+
+                    stat = camera->setParameters(params.flatten());
+
+                    if ( NO_ERROR != stat ) {
+                        printf("Test passed!\n");
+                    } else {
+                        printf("Test failed!\n");
+                    }
+
+                    initDefaults();
+                }
+
+                break;
+            }
+
+            case '6': {
+
+                if ( hardwareActive ) {
+
+                    params.setPreviewFrameRate(-1);
+
+                    stat = camera->setParameters(params.flatten());
+
+                    if ( NO_ERROR != stat ) {
+                        printf("Test passed!\n");
+                    } else {
+                        printf("Test failed!\n");
+                    }
+
+                    initDefaults();
+                }
+
+
+                break;
+            }
+
+            case 'q': {
+                goto exit;
+
+                break;
+            }
+
+            default: {
+                printf("Unrecognized command!\n");
+
+                break;
+            }
+        }
+
+        cmd = strtok_r(NULL, DELIMITER, &ctx);
+    }
+
+exit:
+
+    return 0;
+}
+
+
+
diff --git a/tiler/.gitignore b/tiler/.gitignore
new file mode 100644
index 0000000..c23ec1a
--- /dev/null
+++ b/tiler/.gitignore
@@ -0,0 +1,27 @@
+aclocal.m4
+autom4te.cache
+Makefile.in
+Makefile
+ltmain.sh
+stamp-h1
+.deps
+.libs
+*.o
+*.lo
+*.la
+libtool
+*.pc
+config.log
+config.status
+config.guess
+config.h
+config.h.in
+config.sub
+config
+configure
+m4
+build
+*~
+tests/testlib.c
+*_test
+*_ptest
\ No newline at end of file
diff --git a/tiler/Android.mk b/tiler/Android.mk
new file mode 100644
index 0000000..60c8699
--- /dev/null
+++ b/tiler/Android.mk
@@ -0,0 +1,33 @@
+# only include if running on an omap4 platform
+ifeq ($(TARGET_BOARD_PLATFORM),omap4)
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := memmgr.c tilermgr.c
+LOCAL_MODULE := libtimemmgr
+LOCAL_MODULE_TAGS := optional tests
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := memmgr_test.c testlib.c
+LOCAL_SHARED_LIBRARIES := libtimemmgr
+LOCAL_MODULE := memmgr_test
+LOCAL_MODULE_TAGS := tests
+include $(BUILD_HEAPTRACKED_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := utils_test.c testlib.c
+LOCAL_SHARED_LIBRARIES := libtimemmgr
+LOCAL_MODULE := utils_test
+LOCAL_MODULE_TAGS := tests
+include $(BUILD_HEAPTRCKED_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := tiler_ptest.c
+LOCAL_SHARED_LIBRARIES := libtimemmgr
+LOCAL_MODULE    := tiler_ptest
+LOCAL_MODULE_TAGS:= tests
+include $(BUILD_HEAPTRACKED_EXECUTABLE)
+
+endif
diff --git a/tiler/Makefile.am b/tiler/Makefile.am
new file mode 100644
index 0000000..9f9e70b
--- /dev/null
+++ b/tiler/Makefile.am
@@ -0,0 +1,80 @@
+#
+#  Makefile.am
+#
+#  TI OMAP Processor Memory Allocator Interface functions makefile.
+#
+#  Copyright (C) 2009-2011 Texas Instruments, Inc.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#
+#  *  Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#
+#  *  Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  *  Neither the name of Texas Instruments Incorporated nor the names of
+#     its contributors may be used to endorse or promote products derived
+#     from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+#  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+#  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+#  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+#  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+#  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+AUTOMAKE_OPTIONS = foreign
+
+## sources
+
+h_sources = memmgr.h tilermem.h mem_types.h tiler.h tilermem_utils.h
+if STUB_TILER
+c_sources = memmgr.c
+else
+c_sources = memmgr.c tilermgr.c
+endif
+
+if TILERMGR
+library_include_HEADERS = $(h_sources) tilermgr.h
+else
+library_include_HEADERS = $(h_sources)
+noinst_HEADERS = tilermgr.h
+endif
+
+#Install the headers in library directory - e.g. examplelib-1.0:
+library_includedir=$(includedir)/timemmgr
+
+# library sources
+lib_LTLIBRARIES= libtimemmgr.la
+libtimemmgr_la_SOURCES = $(h_sources) $(c_sources)
+libtimemmgr_la_CFLAGS  = $(MEMMGR_CFLAGS) -fpic -ansi
+libtimemmgr_la_LIBTOOLFLAGS = --tag=disable-static
+libtimemmgr_la_LDFLAGS = -version-info 2:0:0
+
+if UNIT_TESTS
+bin_PROGRAMS = utils_test memmgr_test tiler_ptest
+
+utils_testdir = .
+utils_test_SOURCES = utils_test.c testlib.c
+
+memmgr_testdir = .
+memmgr_test_SOURCES = memmgr_test.c testlib.c
+memmgr_test_LDADD = libtimemmgr.la
+
+tiler_ptest_SOURCES = tiler_ptest.c
+tiler_ptest_LDADD = libtimemmgr.la
+endif
+
+pkgconfig_DATA = libtimemmgr.pc
+pkgconfigdir   = $(libdir)/pkgconfig
+
diff --git a/tiler/README b/tiler/README
new file mode 100644
index 0000000..e531b09
--- /dev/null
+++ b/tiler/README
@@ -0,0 +1,136 @@
+Validating MemMgr
+
+    MemMgr tests are not persistently enumerated, so the test # in
+    memmgr test may vary from release to release.
+
+    You need to run the test with the "list" argument to list all the test
+    descriptions and the corresponding test numbers.
+
+        E.g. "memmgr_test list"
+
+    If you have access to the official test report, the details column lists
+    the test description (in the last line).  Match the test case description
+    to the last line of the cells in the Details column.
+
+    Negative MemMgr tests run multiple test cases, so they map to multiple rows
+    in the official test report.  Some of the test cases may not be available,
+    or may succeed even if the whole test failed/succeeded.
+
+    To ease the generation of the test report, a python script is provided that
+    will populate most of the test report:
+
+        run memmgr_test and pipe the output of the tests into a
+        file, e.g.:
+
+            memmgr_test > test.log
+
+        open UTR and select Tiler User Space worksheet
+        run this script by piping the test logs into the script, e.g. (you may
+        have to copy the log file from the target to a location that you can
+        access from the machine that has the UTR open.)
+
+            python fill_utr.py < test.log
+
+Latest List of test cases
+
+memmgr_test
+
+TEST #  1 - alloc_1D_test(4096, 0)
+TEST #  2 - alloc_2D_test(64, 64, PIXEL_FMT_8BIT)
+TEST #  3 - alloc_2D_test(64, 64, PIXEL_FMT_16BIT)
+TEST #  4 - alloc_2D_test(64, 64, PIXEL_FMT_32BIT)
+TEST #  5 - alloc_NV12_test(64, 64)
+TEST #  6 - map_1D_test(4096, 0)
+TEST #  7 - alloc_1D_test(176 * 144 * 2, 512)
+TEST #  8 - alloc_2D_test(176, 144, PIXEL_FMT_8BIT)
+TEST #  9 - alloc_2D_test(176, 144, PIXEL_FMT_16BIT)
+TEST # 10 - alloc_2D_test(176, 144, PIXEL_FMT_32BIT)
+TEST # 11 - alloc_NV12_test(176, 144)
+TEST # 12 - map_1D_test(176 * 144 * 2, 2048)
+TEST # 13 - alloc_1D_test(640 * 480 * 2, 0)
+TEST # 14 - alloc_2D_test(640, 480, PIXEL_FMT_8BIT)
+TEST # 15 - alloc_2D_test(640, 480, PIXEL_FMT_16BIT)
+TEST # 16 - alloc_2D_test(640, 480, PIXEL_FMT_32BIT)
+TEST # 17 - alloc_NV12_test(640, 480)
+TEST # 18 - map_1D_test(640 * 480 * 2, 0)
+TEST # 19 - alloc_1D_test(848 * 480 * 2, 0)
+TEST # 20 - alloc_2D_test(848, 480, PIXEL_FMT_8BIT)
+TEST # 21 - alloc_2D_test(848, 480, PIXEL_FMT_16BIT)
+TEST # 22 - alloc_2D_test(848, 480, PIXEL_FMT_32BIT)
+TEST # 23 - alloc_NV12_test(848, 480)
+TEST # 24 - map_1D_test(848 * 480 * 2, 0)
+TEST # 25 - alloc_1D_test(1280 * 720 * 2, 0)
+TEST # 26 - alloc_2D_test(1280, 720, PIXEL_FMT_8BIT)
+TEST # 27 - alloc_2D_test(1280, 720, PIXEL_FMT_16BIT)
+TEST # 28 - alloc_2D_test(1280, 720, PIXEL_FMT_32BIT)
+TEST # 29 - alloc_NV12_test(1280, 720)
+TEST # 30 - map_1D_test(1280 * 720 * 2, 0)
+TEST # 31 - alloc_1D_test(1920 * 1080 * 2, 0)
+TEST # 32 - alloc_2D_test(1920, 1080, PIXEL_FMT_8BIT)
+TEST # 33 - alloc_2D_test(1920, 1080, PIXEL_FMT_16BIT)
+TEST # 34 - alloc_2D_test(1920, 1080, PIXEL_FMT_32BIT)
+TEST # 35 - alloc_NV12_test(1920, 1080)
+TEST # 36 - map_1D_test(1920 * 1080 * 2, 0)
+TEST # 37 - neg_alloc_tests()
+TEST # 38 - neg_free_tests()
+TEST # 39 - neg_map_tests()
+TEST # 40 - neg_unmap_tests()
+TEST # 41 - neg_check_tests()
+TEST # 42 - page_size_test()
+TEST # 43 - maxalloc_2D_test(2500, 32, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 44 - maxalloc_2D_test(2500, 16, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 45 - maxalloc_2D_test(1250, 16, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 46 - maxalloc_2D_test(5000, 32, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 47 - maxalloc_2D_test(5000, 16, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 48 - maxalloc_2D_test(2500, 16, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 49 - alloc_2D_test(8193, 16, PIXEL_FMT_8BIT)
+TEST # 50 - alloc_2D_test(8193, 16, PIXEL_FMT_16BIT)
+TEST # 51 - alloc_2D_test(4097, 16, PIXEL_FMT_32BIT)
+TEST # 52 - alloc_2D_test(16384, 16, PIXEL_FMT_8BIT)
+TEST # 53 - alloc_2D_test(16384, 16, PIXEL_FMT_16BIT)
+TEST # 54 - alloc_2D_test(8192, 16, PIXEL_FMT_32BIT)
+TEST # 55 - !alloc_2D_test(16385, 16, PIXEL_FMT_8BIT)
+TEST # 56 - !alloc_2D_test(16385, 16, PIXEL_FMT_16BIT)
+TEST # 57 - !alloc_2D_test(8193, 16, PIXEL_FMT_32BIT)
+TEST # 58 - maxalloc_1D_test(4096, MAX_ALLOCS)
+TEST # 59 - maxalloc_2D_test(64, 64, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 60 - maxalloc_2D_test(64, 64, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 61 - maxalloc_2D_test(64, 64, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 62 - maxalloc_NV12_test(64, 64, MAX_ALLOCS)
+TEST # 63 - maxmap_1D_test(4096, MAX_ALLOCS)
+TEST # 64 - maxalloc_1D_test(176 * 144 * 2, MAX_ALLOCS)
+TEST # 65 - maxalloc_2D_test(176, 144, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 66 - maxalloc_2D_test(176, 144, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 67 - maxalloc_2D_test(176, 144, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 68 - maxalloc_NV12_test(176, 144, MAX_ALLOCS)
+TEST # 69 - maxmap_1D_test(176 * 144 * 2, MAX_ALLOCS)
+TEST # 70 - maxalloc_1D_test(640 * 480 * 2, MAX_ALLOCS)
+TEST # 71 - maxalloc_2D_test(640, 480, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 72 - maxalloc_2D_test(640, 480, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 73 - maxalloc_2D_test(640, 480, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 74 - maxalloc_NV12_test(640, 480, MAX_ALLOCS)
+TEST # 75 - maxmap_1D_test(640 * 480 * 2, MAX_ALLOCS)
+TEST # 76 - maxalloc_1D_test(848 * 480 * 2, MAX_ALLOCS)
+TEST # 77 - maxalloc_2D_test(848, 480, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 78 - maxalloc_2D_test(848, 480, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 79 - maxalloc_2D_test(848, 480, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 80 - maxalloc_NV12_test(848, 480, MAX_ALLOCS)
+TEST # 81 - maxmap_1D_test(848 * 480 * 2, MAX_ALLOCS)
+TEST # 82 - maxalloc_1D_test(1280 * 720 * 2, MAX_ALLOCS)
+TEST # 83 - maxalloc_2D_test(1280, 720, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 84 - maxalloc_2D_test(1280, 720, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 85 - maxalloc_2D_test(1280, 720, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 86 - maxalloc_NV12_test(1280, 720, MAX_ALLOCS)
+TEST # 87 - maxmap_1D_test(1280 * 720 * 2, MAX_ALLOCS)
+TEST # 88 - maxalloc_1D_test(1920 * 1080 * 2, MAX_ALLOCS)
+TEST # 89 - maxalloc_2D_test(1920, 1080, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 90 - maxalloc_2D_test(1920, 1080, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 91 - maxalloc_2D_test(1920, 1080, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 92 - maxalloc_NV12_test(1920, 1080, 2)
+TEST # 93 - maxalloc_NV12_test(1920, 1080, MAX_ALLOCS)
+TEST # 94 - maxmap_1D_test(1920 * 1080 * 2, MAX_ALLOCS)
+TEST # 95 - star_tiler_test(1000, 10)
+TEST # 96 - star_tiler_test(1000, 30)
+TEST # 97 - star_test(100, 10)
+TEST # 98 - star_test(1000, 10)
+
diff --git a/tiler/bootstrap.sh b/tiler/bootstrap.sh
new file mode 100755
index 0000000..6170918
--- /dev/null
+++ b/tiler/bootstrap.sh
@@ -0,0 +1,18 @@
+#! /bin/sh
+
+cd `dirname $0`
+
+# on some platforms, you have "g" versions of some of these tools instead,
+# ie glibtoolize instead of libtoolize..
+find_tool() {
+   which $1 2> /dev/null || which g$1 2> /dev/null
+}
+
+aclocal=`find_tool aclocal`
+libtoolize=`find_tool libtoolize`
+automake=`find_tool automake`
+autoconf=`find_tool autoconf`
+autoheader=`find_tool autoheader`
+
+mkdir -p config && $autoheader && $aclocal && $libtoolize --copy --force && $automake --copy --add-missing --foreign && $autoconf
+
diff --git a/tiler/configure.ac b/tiler/configure.ac
new file mode 100755
index 0000000..30d131c
--- /dev/null
+++ b/tiler/configure.ac
@@ -0,0 +1,75 @@
+#                                               -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ(2.61)
+AC_INIT(timemmgr, 2.00, http://www.ti.com)
+AC_CONFIG_SRCDIR([memmgr.c])
+AC_CONFIG_HEADER([config.h])
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_AUX_DIR([config])
+AC_CANONICAL_SYSTEM
+AM_INIT_AUTOMAKE([timemmgr], [2.00])
+LT_INIT
+
+# Checks for programs.
+AC_PROG_CC
+AM_PROG_LIBTOOL
+
+# Checks for libraries.
+
+# Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([fcntl.h stdint.h stdlib.h string.h sys/ioctl.h unistd.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_HEADER_STDBOOL
+AC_TYPE_UINT16_T
+AC_TYPE_UINT32_T
+
+# Checks for library functions.
+AC_PROG_GCC_TRADITIONAL
+#AC_FUNC_MALLOC
+#AC_FUNC_MMAP
+AC_CHECK_FUNCS([munmap strerror])
+
+AC_ARG_ENABLE(tilermgr,
+[  --enable-tilermgr    Include TilerMgr headers],
+[case "${enableval}" in
+  yes) tilermgr=true ;;
+  no)  tilermgr=false ;;
+  *) AC_MSG_ERROR(bad value ${enableval} for --enable-tilermgr) ;;
+esac],[tilermgr=true])
+
+AC_ARG_ENABLE(tests,
+[  --enable-tests    Build unit tests],
+[case "${enableval}" in
+  yes) tests=true ;;
+  no)  tests=false ;;
+  *) AC_MSG_ERROR(bad value ${enableval} for --enable-tests) ;;
+esac],[tests=false])
+
+AM_CONDITIONAL(UNIT_TESTS, test x$tests = xtrue)
+
+AM_CONDITIONAL(TILERMGR, test x$tilermgr != xfalse)
+
+AC_ARG_ENABLE(stub,
+[  --enable-stub    Stubbing tiler and syslink on none-arm system],
+[case "${enableval}" in
+  yes) stub_tiler=true ;;
+  no)  stub_tiler=false ;;
+  *) AC_MSG_ERROR(bad value ${enableval} for --enable-stub) ;;
+esac],[stub_tiler=false])
+
+AM_CONDITIONAL(STUB_TILER, test x$stub_tiler = xtrue)
+
+if test x$stub_tiler = xtrue; then
+AC_DEFINE([STUB_TILER],[1],[Use tiler stub])
+fi
+
+# Project build flags
+MEMMGR_CFLAGS="-Werror -Wall -pipe -ansi"
+AC_SUBST(MEMMGR_CFLAGS)
+
+AC_CONFIG_FILES([libtimemmgr.pc Makefile])
+AC_OUTPUT
+
diff --git a/tiler/debug_utils.h b/tiler/debug_utils.h
new file mode 100644
index 0000000..316e80e
--- /dev/null
+++ b/tiler/debug_utils.h
@@ -0,0 +1,211 @@
+/*
+ *  debug_utils.h
+ *
+ *  Debug Utility definitions.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _DEBUG_UTILS_H_
+#define _DEBUG_UTILS_H_
+
+#include <stdio.h>
+
+/*#define __DEBUG__*/
+/*#define __DEBUG_ENTRY__*/
+/*#define __DEBUG_ASSERT__*/
+
+/* ---------- Generic Debug Print Macros ---------- */
+
+/**
+ * Use as:
+ *    P("val is %d", 5);
+ *    ==> val is 5
+ *    DP("val is %d", 15);
+ *    ==> val is 5 at test.c:56:main()
+ */
+/* debug print (fmt must be a literal); adds new-line. */
+#define __DEBUG_PRINT(fmt, ...) do { fprintf(stdout, fmt "\n", ##__VA_ARGS__); fflush(stdout); } while(0)
+
+/* debug print with context information (fmt must be a literal) */
+#define __DEBUG_DPRINT(fmt, ...) __DEBUG_PRINT(fmt " at %s(" __FILE__ ":%d)", ##__VA_ARGS__, __FUNCTION__, __LINE__)
+
+#ifdef __DEBUG__
+#define P(fmt, ...) __DEBUG_PRINT(fmt, ##__VA_ARGS__)
+#define DP(fmt, ...) __DEBUG_DPRINT(fmt, ##__VA_ARGS__)
+#else
+#define P(fmt, ...)
+#define DP(fmt, ...)
+#endif
+
+/* ---------- Program Flow Debug Macros ---------- */
+
+/**
+ * Use as:
+ *    int get5() {
+ *      IN;
+ *      return R_I(5);
+ *    }
+ *    void check(int i) {
+ *      IN;
+ *      if (i == 5) { RET; return; }
+ *      OUT;
+ *    }
+ *    void main() {
+ *      IN;
+ *      check(get5());
+ *      check(2);
+ *      OUT;
+ *    }
+ *    ==>
+ *    in main(test.c:11)
+ *    in get5(test.c:2)
+ *    out(5) at get5(test.c:3)
+ *    in check(test.c:6)
+ *    out() at check(test.c:7)
+ *    in check(test.c:6)
+ *    out check(test.c:8)
+ *    out main(test.c:14)
+ */
+
+#ifdef __DEBUG_ENTRY__
+/* function entry */
+#define IN __DEBUG_PRINT("in %s(" __FILE__ ":%d)", __FUNCTION__, __LINE__)
+/* function exit */
+#define OUT __DEBUG_PRINT("out %s(" __FILE__ ":%d)", __FUNCTION__, __LINE__)
+/* function abort (return;)  Use as { RET; return; } */
+#define RET __DEBUG_DPRINT("out() ")
+/* generic function return */
+#define R(val,type,fmt) ({ type __val__ = (type) val; __DEBUG_DPRINT("out(" fmt ")", __val__); __val__; })
+#else
+#define IN
+#define OUT
+#define RET
+#define R(val,type,fmt) (val)
+#endif
+
+/* integer return */
+#define R_I(val) R(val,int,"%d")
+/* pointer return */
+#define R_P(val) R(val,void *,"%p")
+/* long return */
+#define R_UP(val) R(val,long,"0x%lx")
+
+/* ---------- Assertion Debug Macros ---------- */
+
+/**
+ * Use as:
+ *     int i = 5;
+ *     // int j = i * 5;
+ *     int j = A_I(i,==,3) * 5;
+ *     // if (i > 3) P("bad")
+ *     if (NOT_I(i,<=,3)) P("bad")
+ *     P("j is %d", j);
+ *     ==> assert: i (=5) !== 3 at test.c:56:main()
+ *     assert: i (=5) !<= 3 at test.c:58:main()
+ *     j is 25
+ *
+ */
+/* generic assertion check, A returns the value of exp, CHK return void */
+#ifdef __DEBUG_ASSERT__
+#define A(exp,cmp,val,type,fmt) ({ \
+    type __exp__ = (type) (exp); type __val__ = (type) (val); \
+    if (!(__exp__ cmp __val__)) __DEBUG_DPRINT("assert: %s (=" fmt ") !" #cmp " " fmt, #exp, __exp__, __val__); \
+    __exp__; \
+})
+#define CHK(exp,cmp,val,type,fmt) do { \
+    type __exp__ = (type) (exp); type __val__ = (type) (val); \
+    if (!(__exp__ cmp __val__)) __DEBUG_DPRINT("assert: %s (=" fmt ") !" #cmp " " fmt, #exp, __exp__, __val__); \
+} while(0)
+#else
+#define A(exp,cmp,val,type,fmt) (exp)
+#define CHK(exp,cmp,val,type,fmt)
+#endif
+
+/* typed assertions */
+#define A_I(exp,cmp,val) A(exp,cmp,val,int,"%d")
+#define A_L(exp,cmp,val) A(exp,cmp,val,long,"%ld")
+#define A_P(exp,cmp,val) A(exp,cmp,val,void *,"%p")
+#define CHK_I(exp,cmp,val) CHK(exp,cmp,val,int,"%d")
+#define CHK_L(exp,cmp,val) CHK(exp,cmp,val,long,"%ld")
+#define CHK_P(exp,cmp,val) CHK(exp,cmp,val,void *,"%p")
+
+/* generic assertion check, returns true iff assertion fails */
+#ifdef __DEBUG_ASSERT__
+#define NOT(exp,cmp,val,type,fmt) ({ \
+    type __exp__ = (type) (exp); type __val__ = (type) (val); \
+    if (!(__exp__ cmp __val__)) __DEBUG_DPRINT("assert: %s (=" fmt ") !" #cmp " " fmt, #exp, __exp__, __val__); \
+    !(__exp__ cmp __val__); \
+})
+#else
+#define NOT(exp,cmp,val,type,fmt) (!((exp) cmp (val)))
+#endif
+
+/* typed assertion checks */
+#define NOT_I(exp,cmp,val) NOT(exp,cmp,val,int,"%d")
+#define NOT_L(exp,cmp,val) NOT(exp,cmp,val,long,"%ld")
+#define NOT_P(exp,cmp,val) NOT(exp,cmp,val,void *,"%p")
+
+
+/* system assertions - will use perror to give external error information */
+#ifdef __DEBUG_ASSERT__
+#define ERR_S(fmt, ...) do { fprintf(stderr, fmt " at %s(" __FILE__ ":%d", ##__VA_ARGS__, __FUNCTION__, __LINE__); perror(")"); fflush(stderr); } while(0)
+#define A_S(exp,cmp,val) ({ \
+    int __exp__ = (int) (exp); int __val__ = (int) (val); \
+    if (!(__exp__ cmp __val__)) ERR_S("assert: %s (=%d) !" #cmp " %d", #exp, __exp__, __val__); \
+    __exp__; \
+})
+#define CHK_S(exp,cmp,val) do { \
+    int __exp__ = (int) (exp); int __val__ = (int) (val); \
+    if (!(__exp__ cmp __val__)) ERR_S("assert: %s (=%d) !" #cmp " %d", #exp, __exp__, __val__); \
+} while(0)
+#define NOT_S(exp,cmp,val) ({ \
+    int __exp__ = (int) (exp); int __val__ = (int) (val); \
+    if (!(__exp__ cmp __val__)) ERR_S("assert: %s (=%d) !" #cmp " %d", #exp, __exp__, __val__); \
+    !(__exp__ cmp __val__); \
+})
+#else
+#define A_S(exp,cmp,val) (exp)
+#define CHK_S(exp,cmp,val)
+#define NOT_S(exp,cmp,val) (!((exp) cmp (val)))
+#endif
+
+/* error propagation macros - these macros ensure evaluation of the expression
+   even if there was a prior error */
+
+/* new error is accumulated into error */
+#define ERR_ADD(err, exp) do { int __error__ = A_I(exp,==,0); err = err ? err : __error__; } while(0)
+#define ERR_ADD_S(err, exp) do { int __error__ = A_S(exp,==,0); err = err ? err : __error__; } while(0)
+/* new error overwrites old error */
+#define ERR_OVW(err, exp) do { int __error__ = A_I(exp,==,0); err = __error__ ? __error__ : err; } while(0)
+#define ERR_OVW_S(err, exp) do { int __error__ = A_S(exp,==,0); err = __error__ ? __error__ : err; } while(0)
+
+#endif
+
diff --git a/tiler/fill_utr.py b/tiler/fill_utr.py
new file mode 100755
index 0000000..d006298
--- /dev/null
+++ b/tiler/fill_utr.py
@@ -0,0 +1,92 @@
+# Use this script to fill out the UTR for MemMgr/D2C tests.  You can use

+# either Python 2.6 or 3.1

+#

+# Limitations:

+#   - only basic tests run by memmgr_test and d2c_test are filled out

+#   - negative memmgr_tests are performed in one step and this script will

+#     not separate which part of the test failed.  If your negative memmgr

+#     tests fail, you want to manually check which test case failed.

+

+# Usage:

+#  1. run memmgr_test and d2c_test, and pipe the output of the tests into a

+#     file.

+# 

+#     memmgr_test > test.log

+#     d2c_test >> test.log

+# 

+#  2. open UTR and select Tiler/D2C User Space worksheet

+#  3. run this script by piping the test logs into the script, e.g.

+#     python fill_utr.py < test.log

+

+import sys, re, win32com.client

+

+TCs, results = [], {}

+

+# gather test results from the log

+for line in sys.stdin:

+    # check for test description

+    desc = re.search("TEST #... - (.*)", line.strip())

+    if desc:

+        TCs.append(desc.group(1))

+

+    # check for any test result

+    result = re.search("==> TEST (.*)", line.strip())

+    if result:

+        result = result.group(1)

+        if result == 'OK':

+            result = 'P', ''

+        elif result == 'NOT AVAILABLE':

+            result = 'D', ''

+        else:

+            result = 'F', 'failed with error #' + result[5:-1]

+

+        results[TCs.pop(0)] = result

+

+assert "test_d2c(1920, 1080, 2)" in results

+

+# populate test results

+excel = win32com.client.Dispatch('Excel.Application')

+if not excel:

+    print('Could not find Excel application.  The UTR is probably not open in Excel.')

+    sys.exit(1)

+

+sheet = excel.ActiveSheet

+if sheet.Name != 'Tiler' or sheet.Cells(1,1).Text != 'Test Metrics':

+    print('Active worksheet does not seem to be the Tiler UTR')

+    sys.exit(1)

+

+# find Header

+for r in range(1, 100):

+    if sheet.Cells(r, 1).Text == 'Test Case\nID':

+        break

+else:

+    print('Could not find header row starting with "Test Case\\nID"')

+    sys.exit(1)

+

+# find Status, Details and Comments columns

+heads = t_status, t_details, t_comments, t_desc = 'Status', 'Details', 'Comments', 'Test Case\nDescription'

+heads = set(heads)

+cols = {}

+for c in range(1, 100):

+    if sheet.Cells(r, c).Text in heads:

+        cols[sheet.Cells(r, c).Text] = c

+        heads.remove(sheet.Cells(r, c).Text)

+if heads:

+    print('Could not find columns', heads)

+    sys.exit(1)

+

+# populate sheet, quit after 20 empty Details/Description cells

+empties = 0

+while empties < 20:

+    r += 1

+    details = sheet.Cells(r, cols[t_details]).Text

+    if details:

+        empties = 0

+        # get test case description

+        desc = details.split('\n')[-1]

+        if not desc in results:

+            results[desc] = 'U', ''

+        sheet.Cells(r, cols[t_status]).Value, sheet.Cells(r, cols[t_comments]).Value = results[desc]

+    elif not sheet.Cells(r, cols[t_desc]).Text:

+        empties += 1

+

diff --git a/tiler/libtimemmgr.pc.in b/tiler/libtimemmgr.pc.in
new file mode 100644
index 0000000..7ecd886
--- /dev/null
+++ b/tiler/libtimemmgr.pc.in
@@ -0,0 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: timemmgr
+Description: TI memory manager
+Version: @VERSION@
+Requires:
+Libs: -L${libdir} -ltimemmgr
+Cflags: -I${includedir}/timemmgr
+
+
diff --git a/tiler/list_utils.h b/tiler/list_utils.h
new file mode 100644
index 0000000..1643cf0
--- /dev/null
+++ b/tiler/list_utils.h
@@ -0,0 +1,511 @@
+/*
+ *  list_utils.h
+ *
+ *  Utility definitions for the Memory Interface for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LIST_UTILS_H_
+#define _LIST_UTILS_H_
+
+/*
+
+    DLIST macros facilitate double-linked lists in a generic fashion.
+
+    - Double-linked lists simplify list manipulations, so they are preferred to
+      single-linked lists.
+
+    - Having a double-linked list with a separate header allow accessing the
+      last element of the list easily, so this is also preferred to a double
+      linked list that uses NULL pointers at its ends.
+
+    Therefore, the following is required:  a list info structure (separate from
+    the element structure, although the info structure can be a member of the
+    element structure).  The info structure must contain (at least) the
+    following 3 members:
+
+    *next, *last: as pointers to the info structure.  These are the next and
+                  previous elements in the list.
+    *me: as a pointer to the element structure.  This is how we get to the
+         element itself, as next and last points to another info structure.
+
+    The list element structure __MAY__ contain the info structure as a member,
+    or a pointer to the info structure if it is desired to be kept separately.
+    In such cases macros are provided to add the elements directly to the list,
+    and automatically set up the info structure fields correctly.  You can also
+    iterate through the elements of the list using a pointer to the elements
+    itself, as the list structure can be obtained for each element.
+
+    Otherwise, macros are provided to manipulate list info structures and
+    link them in any shape or form into double linked lists.  This allows
+    having NULL values as members of such lists.
+
+   :NOTE: If you use a macro with a field argument, you must not have NULL
+   elements because the field of any element must be/point to the list
+   info structure
+
+    DZLIST macros
+
+    Having the list info structure separate from the element structure also
+    allows to link elements into many separate lists (with separate info
+    structure fields/pointers).  However, for cases where only a single list
+    is desired, a set of easy macros are also provided.
+
+    These macros combine the element and list structures.  These macros
+    require the following 2 members in each element structure:
+
+    *next, *last: as pointers to the element structure.  These are the next and
+                  previous elements in the list.
+
+    :NOTE: In case of the DZLIST-s, the head of the list must be an element
+    structure, where only the next and last members are used. */
+
+/*
+  Usage:
+
+  DLIST macros are designed for preallocating the list info structures, e.g. in
+  an array.  This is why most macros take a list info structure, and not a
+  pointer to a list info structure.
+
+  Basic linked list consists of element structure and list info structure
+
+    struct elem {
+        int data;
+    } *elA, *elB;
+    struct list {
+        struct elem *me;
+        struct list *last, *next;
+    } head, *inA, *inB, *in;
+
+    DLIST_INIT(head);              // initialization -> ()
+    DLIST_IS_EMPTY(head) == TRUE;  // emptiness check
+
+    // add element at beginning of list -> (1)
+    elA = NEW(struct elem);
+    elA->data = 1;
+    inA = NEW(struct list);
+    DLIST_ADD_AFTER(head, elA, *inA);
+
+    // add before an element -> (2, 1)
+    elB = NEW(struct elem);
+    elB->data = 2;
+    inB = NEW(struct list);
+    DLIST_ADD_BEFORE(*inA, elB, *inB);
+
+    // move an element to another position or another list -> (1, 2)
+    DLIST_MOVE_BEFORE(head, *inB);
+
+    // works even if the position is the same -> (1, 2)
+    DLIST_MOVE_BEFORE(head, *inB);
+
+    // get first and last elements
+    DLIST_FIRST(head) == elA;
+    DLIST_LAST(head) == elB;
+
+    // loop through elements
+    DLIST_LOOP(head, in) {
+        P("%d", in->me->data);
+    }
+
+    // remove element -> (2)
+    DLIST_REMOVE(*inA);
+    FREE(elA);
+    FREE(inA);
+
+    // delete list
+    DLIST_SAFE_LOOP(head, in, inA) {
+        DLIST_REMOVE(*in);
+        FREE(in->me);
+        FREE(in);
+    }
+
+  You can combine the element and list info structures to create an easy list,
+  but you still need to specify both element and info structure while adding
+  elements.
+
+    struct elem {
+        int data;
+        struct elem *me, *last, *next;
+    } head, *el, *elA, *elB;
+
+    DLIST_INIT(head);              // initialization -> ()
+    DLIST_IS_EMPTY(head) == TRUE;  // emptiness check
+
+    // add element at beginning of list -> (1)
+    elA = NEW(struct elem);
+    elA->data = 1;
+    DLIST_ADD_AFTER(head, elA, *elA);
+
+    // add before an element -> (2, 1)
+    elB = NEW(struct elem);
+    elB->data = 2;
+    DLIST_ADD_BEFORE(*elA, elB, *elB);
+
+    // move an element to another position or another list -> (1, 2)
+    DLIST_MOVE_BEFORE(head, *elB);
+
+    // works even if the position is the same -> (1, 2)
+    DLIST_MOVE_BEFORE(head, *elB);
+
+    // get first and last elements
+    DLIST_FIRST(head) == elA;
+    DLIST_LAST(head) == elB;
+
+    // loop through elements
+    DLIST_LOOP(head, el) {
+        P("%d", el->data);
+    }
+
+    // remove element -> (2)
+    DLIST_REMOVE(*elA);
+    FREE(elA);
+
+    // delete list
+    DLIST_SAFE_LOOP(head, el, elA) {
+        DLIST_REMOVE(*el);
+        FREE(el);
+    }
+
+  Or, you can use a DZLIST.
+
+    struct elem {
+        int data;
+        struct elem *last, *next;
+    } head, *el, *elA, *elB;
+
+    DZLIST_INIT(head);              // initialization -> ()
+    DZLIST_IS_EMPTY(head) == TRUE;  // emptiness check
+
+    // add element at beginning of list -> (1)
+    elA = NEW(struct elem);
+    elA->data = 1;
+    DZLIST_ADD_AFTER(head, *elA);
+
+    // add before an element -> (2, 1)
+    elB = NEW(struct elem);
+    elB->data = 2;
+    DZLIST_ADD_BEFORE(*elA, *elB);
+
+    // move an element to another position or another list -> (1, 2)
+    DZLIST_MOVE_BEFORE(head, *elB);
+
+    // works even if the position is the same -> (1, 2)
+    DZLIST_MOVE_BEFORE(head, *elB);
+
+    // get first and last elements
+    DZLIST_FIRST(head) == elA;
+    DZLIST_LAST(head) == elB;
+
+    // loop through elements
+    DZLIST_LOOP(head, el) {
+        P("%d", el->data);
+    }
+
+    // remove element -> (2)
+    DZLIST_REMOVE(*elA);
+    FREE(elA);
+
+    // delete list
+    DZLIST_SAFE_LOOP(head, el, elA) {
+        DZLIST_REMOVE(*el);
+        FREE(el);
+    }
+
+  A better way to get to the list structure from the element structure is to
+  enclose a pointer the list structure in the element structure.  This allows
+  getting to the next/previous element from the element itself.
+
+    struct elem;
+    struct list {
+        struct elem *me;
+        struct list *last, *next;
+    } head, *inA, *inB, *in;
+    struct elem {
+        int data;
+        struct list *list_data;
+    } *elA, *elB, *el;
+
+    // or
+
+    struct elem {
+        int data;
+        struct list {
+            struct elem *me;
+            struct list *last, *next;
+        } *list_data;
+    } *elA, *elB, *el;
+    struct list head, *inA, *inB, *in;
+
+    DLIST_INIT(head);              // initialization -> ()
+    DLIST_IS_EMPTY(head) == TRUE;  // emptiness check
+
+    // add element at beginning of list -> (1)
+    elA = NEW(struct elem);
+    elA->data = 1;
+    inA = NEW(struct list);
+    DLIST_PADD_AFTER(head, elA, inA, list_data);
+
+    // add before an element -> (2, 1)
+    elB = NEW(struct elem);
+    elB->data = 2;
+    inB = NEW(struct list);
+    DLIST_PADD_BEFORE(*elA, elB, inB, list_data);
+
+    // move an element to another position or another list -> (1, 2)
+    DLIST_MOVE_BEFORE(head, *inB);
+
+    // works even if the position is the same -> (1, 2)
+    DLIST_MOVE_BEFORE(head, *inB);
+
+    // get first and last elements
+    DLIST_FIRST(head) == elA;
+    DLIST_LAST(head) == elB;
+
+    // loop through elements
+    DLIST_LOOP(head, in) {
+        P("%d", in->me->data);
+    }
+    DLIST_PLOOP(head, el, list_data) {
+        P("%d", el->data);
+    }
+
+    // remove element
+    DLIST_REMOVE(*inA);
+    FREE(inA);
+    FREE(elA);
+
+    // delete list
+    DLIST_SAFE_PLOOP(head, el, elA, list_data) {
+        DLIST_REMOVE(*el->list_data);
+        FREE(el->list_data);
+        FREE(el);
+    }
+
+  Lastly, you can include the list data in the element structure itself.
+
+    struct elem {
+        int data;
+        struct list {
+            struct list *last, *next;
+            struct elem *me;
+        } list_data;
+    } *elA, *elB, *el;
+    struct list head, *in;
+
+    DLIST_INIT(head);              // initialization -> ()
+    DLIST_IS_EMPTY(head) == TRUE;  // emptiness check
+
+    // add element at beginning of list -> (1)
+    elA = NEW(struct elem);
+    elA->data = 1;
+    DLIST_MADD_AFTER(head, elA, list_data);
+
+    // add before an element -> (2, 1)
+    elB = NEW(struct elem);
+    elB->data = 2;
+    DLIST_PADD_BEFORE(elA->list_data, elB, list_data);
+
+    // move an element to another position or another list -> (1, 2)
+    DLIST_MOVE_BEFORE(head, elB->list_data);
+
+    // works even if the position is the same -> (1, 2)
+    DLIST_MOVE_BEFORE(head, elB->list_data);
+
+    // get first and last elements
+    DLIST_FIRST(head) == elA;
+    DLIST_LAST(head) == elB;
+
+    // loop through elements
+    DLIST_LOOP(head, in) {
+        P("%d", in->me->data);
+    }
+    DLIST_MLOOP(head, el, list_data) {
+        P("%d", el->data);
+    }
+
+    // remove element
+    DLIST_REMOVE(elA->list_data);
+    FREE(elA);
+
+    // delete list
+    DLIST_SAFE_MLOOP(head, el, elA, list_data) {
+        DLIST_REMOVE(el->list_data);
+        FREE(el);
+    }
+
+ */
+
+/* -- internal (generic direction) macros -- */
+#define DLIST_move__(base, info, next, last) \
+    ((info).last = &base)->next = ((info).next = (base).next)->last = &(info)
+#define DLIST_padd__(base, pInfo, pElem, pField, next, last) \
+    ((pInfo)->last = &base)->next = ((pInfo)->next = (base).next)->last = \
+    pElem->pField = pInfo
+#define DLIST_loop__(head, pInfo, next) \
+    for (pInfo=(head).next; pInfo != &(head); pInfo = (pInfo)->next)
+#define DLIST_ploop__(head, pElem, pField, next) \
+    for (pElem=(head).next->me; pElem; pElem = (pElem)->pField->next->me)
+#define DLIST_mloop__(head, pElem, mField, next) \
+    for (pElem=(head).next->me; pElem; pElem = (pElem)->mField.next->me)
+#define DLIST_safe_loop__(head, pInfo, pInfo_safe, next) \
+    for (pInfo=(head).next; pInfo != &(head); pInfo = pInfo_safe) \
+        if ((pInfo_safe = (pInfo)->next) || 1)
+#define DLIST_safe_ploop__(head, pElem, pElem_safe, pField, next) \
+    for (pElem=(head).next->me; pElem; pElem = pElem_safe) \
+        if ((pElem_safe = (pElem)->pField->next->me) || 1)
+#define DLIST_safe_mloop__(head, pElem, pElem_safe, mField, next) \
+    for (pElem=(head).next->me; pElem; pElem = pElem_safe) \
+        if ((pElem_safe = (pElem)->mField.next->me) || 1)
+
+#define DLIST_IS_EMPTY(head) ((head).next == &(head))
+
+/* Adds the element (referred to by the info structure) before/or after another
+   element (or list header) (base). */
+
+#define DLIST_ADD_AFTER(base, pElem, info) \
+    (DLIST_move__(base, info, next, last))->me = pElem
+#define DLIST_ADD_BEFORE(base, pElem, info) \
+    (DLIST_move__(base, info, last, next))->me = pElem
+
+/* Adds the element (referred to by pElem pointer) along with its info
+   structure (referred to by pInfo pointer) before/or after an element or
+   list header (base).  It also sets up the list structure header to point to
+   the element as well as the element's field to point back to the list info
+   structure. */
+#define DLIST_PADD_BEFORE(base, pElem, pInfo, pField) \
+    (DLIST_padd__(base, pInfo, pElem, pField, last, next))->me = pElem
+#define DLIST_PADD_AFTER(base, pElem, pInfo, pField) \
+    (DLIST_padd__(base, pInfo, pElem, pField, next, last))->me = pElem
+
+/* Adds the element (referred to by pElem pointer) before/or after an element or
+   list header (base).  It also sets up the list structure header (which is a
+   member of the element's structure) to point to the element. */
+#define DLIST_MADD_BEFORE(base, pElem, mField) \
+    (DLIST_move__(base, pElem->mField, last, next))->me = pElem
+#define DLIST_MADD_AFTER(base, pElem, mField) \
+    (DLIST_move__(base, pElem->mField, next, last))->me = pElem
+
+/* Removes the element (referred to by the info structure) from its current
+   list.  This requires that the element is a part of a list.
+
+   :NOTE: the info structure will still think that it belongs to the list it
+   used to belong to. However, the old list will not contain this element any
+   longer. You want to discard the info/element after this call.  Otherwise,
+   you can use one of the MOVE macros to also add the item to another list,
+   or another place in the same list. */
+#define DLIST_REMOVE(info) ((info).last->next = (info).next)->last = (info).last
+
+/* Initializes the list header (to an empty list) */
+#define DLIST_INIT(head) \
+    do { (head).me = NULL; (head).next = (head).last = &(head); } while(0)
+
+/* These functions move an element (referred to by the info structure) before
+   or after another element (or the list head).
+   :NOTE: This logic also works for moving an element after/before itself. */
+#define DLIST_MOVE_AFTER(base, info) \
+    do { DLIST_REMOVE(info); DLIST_move__(base, info, next, last); } while(0)
+#define DLIST_MOVE_BEFORE(base, info) \
+    do { DLIST_REMOVE(info); DLIST_move__(base, info, last, next); } while(0)
+
+/* Loops behave syntactically as a for() statement.  They traverse the loop
+   variable from the 1st to the last element (or in the opposite direction in
+   case of RLOOP). There are 3 flavors of loops depending on the type of the
+   loop variable.
+
+   DLIST_LOOP's loop variable is a pointer to the list info structure.  You can
+   get to the element by using the 'me' member.  Nonetheless, this loop
+   construct allows having NULL elements in the list.
+
+   DLIST_MLOOP's loop variable is a pointer to a list element.  mField is the
+   field of the element containing the list info structure.  Naturally, this
+   list cannot have NULL elements.
+
+   DLIST_PLOOP's loop variable is also a pointer to a list element.  Use this
+   construct if the element contains a pointer to the list info structure
+   instead of embedding it directly into the element structure.
+
+*/
+#define DLIST_LOOP(head, pInfo)           DLIST_loop__(head, pInfo, next)
+#define DLIST_RLOOP(head, pInfo)          DLIST_loop__(head, pInfo, last)
+#define DLIST_MLOOP(head, pElem, mField) \
+    DLIST_mloop__(head, pElem, mField, next)
+#define DLIST_RMLOOP(head, pElem, mField) \
+    DLIST_mloop__(head, pElem, mField, last)
+#define DLIST_PLOOP(head, pElem, pField) \
+    DLIST_ploop__(head, pElem, pField, next)
+#define DLIST_RPLOOP(head, pElem, pField) \
+    DLIST_ploop__(head, pElem, pField, last)
+
+/* Safe loops are like ordinary loops, but they allow removal of the current
+   element from the list. They require an extra loop variable that holds the
+   value of the next element in case the current element is moved/removed. */
+#define DLIST_SAFE_LOOP(head, pInfo, pInfo_safe) \
+    DLIST_safe_loop__(head, pInfo, pInfo_safe, next)
+#define DLIST_SAFE_RLOOP(head, pInfo, pInfo_safe) \
+    DLIST_safe_loop__(head, pInfo, pInfo_safe, last)
+#define DLIST_SAFE_MLOOP(head, pElem, pElem_safe, mField) \
+    DLIST_safe_mloop__(head, pElem, pElem_safe, mField, next)
+#define DLIST_SAFE_RMLOOP(head, pElem, pElem_safe, mField) \
+    DLIST_safe_mloop__(head, pElem, pElem_safe, mField, last)
+#define DLIST_SAFE_PLOOP(head, pElem, pElem_safe, pField) \
+    DLIST_safe_ploop__(head, pElem, pElem_safe, pField, next)
+#define DLIST_SAFE_RPLOOP(head, pElem, pElem_safe, pField) \
+    DLIST_safe_ploop__(head, pElem, pElem_safe, pField, last)
+
+/* returns the first element of a list */
+#define DLIST_FIRST(head) (head).next->me
+/* returns the last element of a list */
+#define DLIST_LAST(head) (head).last->me
+
+
+/* DZLIST equivalent API - provided so arguments are specified */
+#define DZLIST_INIT(head)        do { (head).next = (head).last = &(head); } while(0)
+#define DZLIST_IS_EMPTY(head)          DLIST_IS_EMPTY(head)
+#define DZLIST_FIRST(head)             (head).next
+#define DZLIST_LAST(head)              (head).last
+
+#define DZLIST_ADD_AFTER(base, elem)   DLIST_move__(base, elem, next, last)
+#define DZLIST_ADD_BEFORE(base, elem)  DLIST_move__(base, elem, last, next)
+
+#define DZLIST_REMOVE(elem)            DLIST_REMOVE(elem)
+
+#define DZLIST_MOVE_AFTER(base, elem)  DLIST_MOVE_AFTER(base, elem)
+#define DZLIST_MOVE_BEFORE(base, elem) DLIST_MOVE_BEFORE(base, elem)
+
+#define DZLIST_LOOP(head, pElem)       DLIST_LOOP(head, pElem)
+#define DZLIST_RLOOP(head, pElem)      DLIST_RLOOP(head, pElem)
+#define DZLIST_SAFE_LOOP(head, pElem, pElem_safe)   \
+                                       DLIST_SAFE_LOOP(head, pElem, pElem_safe)
+#define DZLIST_SAFE_RLOOP(head, pElem, pElem_safe)  \
+                                       DLIST_SAFE_RLOOP(head, pElem, pElem_safe)
+
+#endif
+
diff --git a/tiler/mem_types.h b/tiler/mem_types.h
new file mode 100644
index 0000000..18453bb
--- /dev/null
+++ b/tiler/mem_types.h
@@ -0,0 +1,101 @@
+/*
+ *  types.h
+ *
+ *  Type definitions for the Memory Interface for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _MEM_TYPES_H_
+#define _MEM_TYPES_H_
+
+/* for bool definition */
+#include <stdbool.h>
+#include <stdint.h>
+
+/** ---------------------------------------------------------------------------
+ * Type definitions
+ */
+
+/**
+ * Buffer length in bytes
+ */
+typedef uint32_t bytes_t;
+
+/**
+ * Length in pixels
+ */
+typedef uint16_t pixels_t;
+
+
+/**
+ * Pixel format
+ *
+ * Page mode is encoded in the pixel format to handle different
+ * set of buffers uniformly
+ */
+enum pixel_fmt_t {
+    PIXEL_FMT_MIN   = 0,
+    PIXEL_FMT_8BIT  = 0,
+    PIXEL_FMT_16BIT = 1,
+    PIXEL_FMT_32BIT = 2,
+    PIXEL_FMT_PAGE  = 3,
+    PIXEL_FMT_MAX   = 3
+};
+
+typedef enum pixel_fmt_t pixel_fmt_t;
+
+/**
+ * Ducati Space Virtual Address Pointer
+ *
+ * This is handled as a unsigned long so that no dereferencing
+ * is allowed by user space components.
+ */
+typedef uint32_t DSPtr;
+
+/**
+ * System Space Pointer
+ *
+ * This is handled as a unsigned long so that no dereferencing
+ * is allowed by user space components.
+ */
+typedef uint32_t SSPtr;
+
+/**
+ * Error values
+ *
+ * Page mode is encoded in the pixel format to handle different
+ * set of buffers uniformly
+ */
+#define MEMMGR_ERR_NONE    0
+#define MEMMGR_ERR_GENERIC 1
+
+#endif
+
diff --git a/tiler/memmgr.c b/tiler/memmgr.c
new file mode 100644
index 0000000..1f780cc
--- /dev/null
+++ b/tiler/memmgr.c
@@ -0,0 +1,1078 @@
+/*
+ *  memmgr.c
+ *
+ *  Memory Allocator Interface functions for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <pthread.h>
+#include <errno.h>
+
+#define BUF_ALLOCED 1
+#define BUF_MAPPED  2
+#define BUF_ANY     ~0
+
+#include <tiler.h>
+
+typedef struct tiler_block_info tiler_block_info;
+
+#define __DEBUG__
+#undef  __DEBUG_ENTRY__
+#define __DEBUG_ASSERT__
+
+#ifdef HAVE_CONFIG_H
+    #include "config.h"
+#endif
+#include "utils.h"
+#include "list_utils.h"
+#include "debug_utils.h"
+#include "tilermem.h"
+#include "tilermem_utils.h"
+#include "memmgr.h"
+
+/* list of allocations */
+struct _AllocData {
+    struct tiler_buf_info buf;
+    int       buf_type;
+    struct _AllocList {
+        struct _AllocList *next, *last;
+        struct _AllocData *me;
+    } link;
+};
+static struct _AllocList bufs = {0};
+static int bufs_inited = 0;
+
+typedef struct _AllocList _AllocList;
+typedef struct _AllocData _AllocData;
+
+static int refCnt = 0;
+static int td = -1;
+static pthread_mutex_t ref_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t che_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/**
+ * Initializes the static structures
+ *
+ * @author a0194118 (9/8/2009)
+ */
+static void init()
+{
+    if (!bufs_inited)
+    {
+        DLIST_INIT(bufs);
+        bufs_inited = 1;
+    }
+}
+
+/**
+ * Increases the reference count.  Initialized tiler if this was
+ * the first reference
+ *
+ * @author a0194118 (9/2/2009)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int inc_ref()
+{
+    /* initialize tiler on first call */
+    pthread_mutex_lock(&ref_mutex);
+
+    int res = MEMMGR_ERR_NONE;
+
+    if (!refCnt++) {
+        /* initialize lists */
+        init();
+#ifndef STUB_TILER
+        td = open("/dev/tiler", O_RDWR | O_SYNC);
+        if (NOT_I(td,>=,0)) res = MEMMGR_ERR_GENERIC;
+#else
+        td = 2;
+        res = MEMMGR_ERR_NONE;
+#endif
+    }
+    if (res)
+    {
+        refCnt--;
+    }
+
+    pthread_mutex_unlock(&ref_mutex);
+    return res;
+}
+
+/**
+ * Decreases the reference count.  Deinitialized tiler if this
+ * was the last reference
+ *
+ * @author a0194118 (9/2/2009)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int dec_ref()
+{
+    pthread_mutex_lock(&ref_mutex);
+
+    int res = MEMMGR_ERR_NONE;;
+
+    if (refCnt <= 0) res = MEMMGR_ERR_GENERIC;
+    else if (!--refCnt) {
+#ifndef STUB_TILER
+        close(td);
+        td = -1;
+#endif
+    }
+
+    pthread_mutex_unlock(&ref_mutex);
+    return res;
+}
+
+/**
+ * Returns the default page stride for this block
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param width  Width of 2D container in bytes
+ *
+ * @return Stride
+ */
+static bytes_t def_stride(bytes_t width)
+{
+    return ROUND_UP_TO2POW(width, PAGE_SIZE);
+}
+
+/**
+ * Returns the bytes per pixel for the pixel format.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param pixelFormat   Pixelformat
+ *
+ * @return Bytes per pixel
+ */
+static bytes_t def_bpp(pixel_fmt_t pixelFormat)
+{
+    return (pixelFormat == PIXEL_FMT_32BIT ? 4 :
+            pixelFormat == PIXEL_FMT_16BIT ? 2 : 1);
+}
+
+/**
+ * Returns the size of the supplied block
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param blk    Pointer to the tiler_block_info struct
+ *
+ * @return size of the block in bytes
+ */
+static bytes_t def_size(tiler_block_info *blk)
+{
+    return (blk->fmt == PIXEL_FMT_PAGE ?
+            def_stride(blk->dim.len) :
+            blk->dim.area.height * def_stride(blk->dim.area.width * def_bpp(blk->fmt)));
+}
+
+/**
+ * Returns the map size based on an offset and buffer size
+ *
+ * @author a0194118 (7/8/2010)
+ *
+ * @param size   Size of buffer
+ * @param offs   Buffer offset
+ *
+ * @return (page aligned) size for mapping
+ */
+static bytes_t map_size(bytes_t size, bytes_t offs)
+{
+    return def_stride(size + (offs & (PAGE_SIZE - 1)));
+}
+
+/**
+ * Records a buffer-pointer -- tiler-ID mapping for a specific
+ * buffer type.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param bufPtr    Buffer pointer
+ * @param tiler_id  Tiler ID
+ * @param buf_type  Buffer type: BUF_ALLOCED or BUF_MAPPED
+ *
+ * @return 0 on success, -ENOMEM on memory allocation failure
+ */
+static int buf_cache_add(struct tiler_buf_info *buf, int buf_type)
+{
+    pthread_mutex_lock(&che_mutex);
+    _AllocData *ad = NEW(_AllocData);
+    if (ad)
+    {
+        memcpy(&ad->buf, buf, sizeof(ad->buf));
+        ad->buf_type = buf_type;
+        DLIST_MADD_BEFORE(bufs, ad, link);
+    }
+    pthread_mutex_unlock(&che_mutex);
+    return ad == NULL ? -ENOMEM : 0;
+}
+
+/**
+ * Retrieves the tiler ID for given pointer and buffer type from
+ * the records.  If the pointer lies within a tracked buffer,
+ * the tiler ID is returned.  Otherwise 0 is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param bufPtr    Buffer pointer
+ * @param buf_type  Buffer type: BUF_ALLOCED or BUF_MAPPED
+ *
+ * @return Tiler ID on success, 0 on failure.
+ */
+static void buf_cache_query(void *ptr, struct tiler_buf_info *buf,
+                            int buf_type_mask)
+{
+    IN;
+    if(0) DP("in(p=%p,t=%d,bp*=%p)", ptr, buf_type_mask, buf->blocks[0].ptr);
+    _AllocData *ad;
+    pthread_mutex_lock(&che_mutex);
+    DLIST_MLOOP(bufs, ad, link) {
+        if(0) {
+            DP("got(%p-%p,%d)", ad->buf.blocks->ptr, ad->buf.blocks->ptr + ad->buf.length, ad->buf_type);
+            CHK_P(ad->buf.blocks->ptr,<=,ptr);
+            CHK_P(ptr,<,ad->buf.blocks->ptr + ad->buf.length);
+            CHK_I(ad->buf_type & buf_type_mask,!=,0);
+            CHK_P(buf->blocks->ptr,!=,0);
+        }
+        if ((ad->buf_type & buf_type_mask) &&
+            ad->buf.blocks->ptr <= ptr && ptr < ad->buf.blocks->ptr + ad->buf.length) {
+            memcpy(buf, &ad->buf, sizeof(*buf));
+            pthread_mutex_unlock(&che_mutex);
+            return;
+        }
+    }
+    pthread_mutex_unlock(&che_mutex);
+    ZERO(*buf);
+    OUT;
+}
+
+/**
+ * Retrieves the tiler ID for given buffer pointer and buffer
+ * type from the records.  If the tiler ID is found, it is
+ * removed from the records as well.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param bufPtr    Buffer pointer
+ * @param buf_type  Buffer type: BUF_ALLOCED or BUF_MAPPED
+ *
+ * @return Tiler ID on success, 0 on failure.
+ */
+static void buf_cache_del(void *bufPtr, struct tiler_buf_info *buf,
+                          int buf_type)
+{
+    _AllocData *ad;
+    pthread_mutex_lock(&che_mutex);
+    DLIST_MLOOP(bufs, ad, link) {
+        if (ad->buf.blocks->ptr == bufPtr && ad->buf_type == buf_type) {
+            memcpy(buf, &ad->buf, sizeof(*buf));
+            DLIST_REMOVE(ad->link);
+            FREE(ad);
+            pthread_mutex_unlock(&che_mutex);
+            return;
+        }
+    }
+    pthread_mutex_unlock(&che_mutex);
+    OUT;
+    return;
+}
+
+/**
+ * Checks the consistency of the internal record cache.  The
+ * number of elements in the cache should equal to the number of
+ * references.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int cache_check()
+{
+    int num_bufs = 0;
+    pthread_mutex_lock(&che_mutex);
+
+    init();
+
+    _AllocData *ad;
+    DLIST_MLOOP(bufs, ad, link) { num_bufs++; }
+
+    pthread_mutex_unlock(&che_mutex);
+    return (num_bufs == refCnt) ? MEMMGR_ERR_NONE : MEMMGR_ERR_GENERIC;
+}
+
+static void dump_block(struct tiler_block_info *blk, char *prefix, char *suffix)
+{
+#if 0
+    switch (blk->fmt)
+    {
+    case TILFMT_PAGE:
+        P("%s [%d:(%d,%08x), p=%p(0x%x),l=0x%x,s=%d,%d+%d]%s", prefix, blk->group_id, blk->key, blk->id, blk->ptr, blk->ssptr,
+          blk->dim.len, blk->stride, blk->align, blk->offs, suffix);
+        break;
+    case TILFMT_8BIT:
+    case TILFMT_16BIT:
+    case TILFMT_32BIT:
+        P("%s [%d:(%d,%08x), p=%p(0x%x),%d*%d*%d,s=%d,%d+%d]%s", prefix, blk->group_id, blk->key, blk->id, blk->ptr, blk->ssptr,
+          blk->dim.area.width, blk->dim.area.height, def_bpp(blk->fmt) * 8,
+          blk->stride, blk->align, blk->offs, suffix);
+        break;
+    default:
+        P("%s*[%d:(%d,%08x), p=%p(0x%x),l=0x%x,s=%d,%d+%d,fmt=0x%x]%s", prefix, blk->group_id, blk->key, blk->id, blk->ptr,
+          blk->ssptr, blk->dim.len, blk->stride, blk->align, blk->offs, blk->fmt, suffix);
+    }
+#endif
+}
+
+static void dump_buf(struct tiler_buf_info* buf, char* prefix)
+{
+#if 0
+    P("%sbuf={n=%d,id=0x%x,len=0x%x", prefix, buf->num_blocks, buf->offset, buf->length);
+    int ix = 0;
+    for (ix = 0; ix < buf->num_blocks; ix++)
+    {
+        dump_block(buf->blocks + ix, "", ix + 1 == buf->num_blocks ? "}" : "");
+    }
+#endif
+}
+
+/**
+ * Returns the tiler format for an address
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param ssptr   Address
+ *
+ * @return The tiler format
+ */
+static enum tiler_fmt tiler_get_fmt(SSPtr ssptr)
+{
+#ifndef STUB_TILER
+    return (ssptr == 0              ? TILFMT_INVALID :
+            ssptr < TILER_MEM_8BIT  ? TILFMT_NONE :
+            ssptr < TILER_MEM_16BIT ? TILFMT_8BIT :
+            ssptr < TILER_MEM_32BIT ? TILFMT_16BIT :
+            ssptr < TILER_MEM_PAGED ? TILFMT_32BIT :
+            ssptr < TILER_MEM_END   ? TILFMT_PAGE : TILFMT_NONE);
+#else
+    /* if emulating, we need to get through all allocated memory segments */
+    pthread_mutex_lock(&che_mutex);
+    init();
+    _AllocData *ad;
+    void *ptr = (void *) ssptr;
+    if (!ptr) return TILFMT_INVALID;
+    /* P("?%p", (void *)ssptr); */
+    DLIST_MLOOP(bufs, ad, link) {
+        int ix;
+        struct tiler_buf_info *buf = (struct tiler_buf_info *) ad->buf.offset;
+        /* P("buf[%d]", buf->num_blocks); */
+        for (ix = 0; ix < buf->num_blocks; ix++)
+        {
+            /* P("block[%p-%p]", buf->blocks[ix].ptr, buf->blocks[ix].ptr + def_size(buf->blocks + ix)); */
+            if (ptr >= buf->blocks[ix].ptr &&
+                ptr < buf->blocks[ix].ptr + def_size(buf->blocks + ix)) {
+                enum tiler_fmt fmt = buf->blocks[ix].fmt;
+                pthread_mutex_unlock(&che_mutex);
+                return fmt;
+            }
+        }
+    }
+    pthread_mutex_unlock(&che_mutex);
+    return TILFMT_NONE;
+#endif
+}
+
+
+/**
+ * Allocates a memory block using tiler
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blk    Pointer to the block info
+ *
+ * @return ssptr of block allocated, or 0 on error
+ */
+static int tiler_alloc(struct tiler_block_info *blk)
+{
+    dump_block(blk, "=(ta)=>", "");
+    blk->ptr = NULL;
+    int ret = A_S(ioctl(td, TILIOC_GBLK, blk),==,0);
+    dump_block(blk, "alloced: ", "");
+    return R_I(ret);
+}
+
+/**
+ * Frees a memory block using tiler
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blk    Pointer to the block info
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int tiler_free(struct tiler_block_info *blk)
+{
+    return R_I(ioctl(td, TILIOC_FBLK, blk));
+}
+
+/**
+ * Maps a memory block into tiler using tiler
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blk    Pointer to the block info
+ *
+ * @return ssptr of block mapped, or 0 on error
+ */
+static int tiler_map(struct tiler_block_info *blk)
+{
+    dump_block(blk, "=(tm)=>", "");
+    int ret = A_S(ioctl(td, TILIOC_MBLK, blk),==,0);
+    dump_block(blk, "mapped: ", "");
+    return R_I(ret);
+}
+
+/**
+ * Unmaps a memory block from tiler using tiler
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blk    Pointer to the block info
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int tiler_unmap(struct tiler_block_info *blk)
+{
+    return ioctl(td, TILIOC_UMBLK, blk);
+}
+
+/**
+ * Registers a buffer structure with tiler, and maps the buffer
+ * into memory using tiler. On success, it writes the tiler ID
+ * of the buffer into the area pointed by tiler ID.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blks        Pointer to array of block info structures
+ * @param num_blocks  Number of blocks
+ * @param tiler_id      Pointer to tiler ID.
+ *
+ * @return pointer to the mapped buffer.
+ */
+static void *tiler_mmap(struct tiler_block_info *blks, int num_blocks,
+                        int buf_type)
+{
+    IN;
+
+    /* get size */
+    int ix;
+    bytes_t size;
+
+    /* register buffer with tiler */
+    struct tiler_buf_info buf;
+    buf.num_blocks = num_blocks;
+    /* work on copy in buf */
+    memcpy(buf.blocks, blks, sizeof(tiler_block_info) * num_blocks);
+#ifndef STUB_TILER
+    dump_buf(&buf, "==(RBUF)=>");
+    int ret = ioctl(td, TILIOC_RBUF, &buf);
+    dump_buf(&buf, "<=(RBUF)==");
+    if (NOT_I(ret,==,0)) return NULL;
+    size = buf.length;
+#else
+    /* save buffer in stub */
+    struct tiler_buf_info *buf_c = NEWN(struct tiler_buf_info,2);
+    buf.offset = (uint32_t) buf_c;
+#endif
+    if (NOT_P(buf.offset,!=,0)) return NULL;
+
+    /* map blocks to process space */
+#ifndef STUB_TILER
+    void *bufPtr = mmap(0, map_size(size, buf.offset),
+                        PROT_READ | PROT_WRITE, MAP_SHARED,
+                        td, buf.offset & ~(PAGE_SIZE - 1));
+    if (bufPtr == MAP_FAILED){
+        bufPtr = NULL;
+    } else {
+        bufPtr += buf.offset & (PAGE_SIZE - 1);
+    }
+    if(0) DP("ptr=%p", bufPtr);
+#else
+    void *bufPtr = malloc(size + PAGE_SIZE - 1);
+    buf_c[1].blocks[0].ptr = bufPtr;
+    bufPtr = ROUND_UP_TO2POW(bufPtr, PAGE_SIZE);
+    /* P("<= [0x%x]", size); */
+
+    /* fill out pointers - this is needed for caching 1D/2D type */
+    for (size = ix = 0; ix < num_blocks; ix++)
+    {
+        buf.blocks[ix].ptr = bufPtr ? bufPtr + size : bufPtr;
+        size += def_size(blks + ix);
+    }
+
+    memcpy(buf_c, &buf, sizeof(struct tiler_buf_info));
+#endif
+
+    if (bufPtr != NULL)
+    {
+        /* fill out pointers */
+        for (size = ix = 0; ix < num_blocks; ix++)
+        {
+            buf.blocks[ix].ptr = bufPtr + size;
+            /* P("   [0x%p]", buf.blocks[ix].ptr); */
+            size += def_size(blks + ix);
+#ifdef STUB_TILER
+            buf.blocks[ix].ssptr = (uint32_t) buf.blocks[ix].ptr;
+#else
+            CHK_I((buf.blocks[ix].ssptr & (PAGE_SIZE - 1)),==,((uint32_t) buf.blocks[ix].ptr & (PAGE_SIZE - 1)));
+#endif
+        }
+    }
+    /* if failed to map: unregister buffer */
+    if (NOT_P(bufPtr,!=,NULL) ||
+        /* or failed to cache tiler buffer */
+        NOT_I(buf_cache_add(&buf, buf_type),==,0))
+    {
+#ifndef STUB_TILER
+        A_I(ioctl(td, TILIOC_URBUF, &buf),==,0);
+#else
+        FREE(buf_c);
+        buf.offset = 0;
+#endif
+    } else {
+        /* update original from local copy */
+        memcpy(blks, buf.blocks, sizeof(tiler_block_info) * num_blocks);
+    }
+
+    return R_P(bufPtr);
+}
+
+/**
+ * Checks whether the tiler_block_info is filled in correctly.
+ * Verifies the pixel format, correct length, width and or
+ * height, the length/stride relationship for 1D buffers, and
+ * the correct stride for 2D buffers.  Also verifies block size
+ * to be page sized if desired.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param blk            Pointer to the tiler_block_info struct
+ * @param is_page_sized  Whether the block needs to be page
+ *                       sized (fit on whole pages).
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int check_block(tiler_block_info *blk, bool is_page_sized)
+{
+    /* check pixelformat */
+    if (NOT_I(blk->fmt,>=,PIXEL_FMT_MIN) ||
+        NOT_I(blk->fmt,<=,PIXEL_FMT_MAX)) return MEMMGR_ERR_GENERIC;
+
+
+    if (blk->fmt == PIXEL_FMT_PAGE)
+    {   /* check 1D buffers */
+
+        /* length must be multiple of stride if stride > 0 */
+        if (NOT_I(blk->dim.len,>,0) ||
+            (blk->stride && NOT_I(blk->dim.len % blk->stride,==,0)))
+            return MEMMGR_ERR_GENERIC;
+    }
+    else
+    {   /* check 2D buffers */
+
+        /* check width, height and stride (must be the default stride or 0) */
+        bytes_t stride = def_stride(blk->dim.area.width * def_bpp(blk->fmt));
+        if (NOT_I(blk->dim.area.width,>,0) ||
+            NOT_I(blk->dim.area.height,>,0) ||
+            (blk->stride && NOT_I(blk->stride,==,stride)))
+            return MEMMGR_ERR_GENERIC;
+    }
+
+    if (is_page_sized && NOT_I(def_size(blk) & (PAGE_SIZE - 1),==,0))
+        return MEMMGR_ERR_GENERIC;
+
+    return MEMMGR_ERR_NONE;
+}
+
+/**
+ * Checks whether the block information is correct for map and
+ * alloc operations.  Checks the number of blocks, and validity
+ * of each block.  Warns if reserved member is not 0.  Also
+ * checks if the alignment/offset requirements are consistent
+ * across the buffer
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blks                 Pointer to the block info array.
+ * @param num_blocks           Number of blocks.
+ * @param num_pagesize_blocks  Number of blocks that must be
+ *                             page sized (these must be in
+ *                             front)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int check_blocks(struct tiler_block_info *blks, int num_blocks,
+                 int num_pagesize_blocks)
+{
+    /* check arguments */
+    if (NOT_I(num_blocks,>,0) ||
+        NOT_I(num_blocks,<=,TILER_MAX_NUM_BLOCKS)) return MEMMGR_ERR_GENERIC;
+
+    /* check block allocation params */
+    int ix;
+    for (ix = 0; ix < num_blocks; ix++)
+    {
+        struct tiler_block_info *blk = blks + ix;
+        CHK_I(blk->ssptr,==,0);
+        CHK_I(blk->id,==,0);
+        int ret = check_block(blk, ix < num_pagesize_blocks);
+
+        /* check alignment */
+        if (!ret)
+        {
+        }
+        if (ret)
+        {
+            DP("for block[%d]", ix);
+            return ret;
+        }
+
+
+    }
+
+    /* set alignment parameters */
+    return MEMMGR_ERR_NONE;
+}
+
+/**
+ * Resets the ptr and reserved fields of the block info
+ * structures.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blks                 Pointer to the block info array.
+ * @param num_blocks           Number of blocks.
+ */
+static void reset_blocks(struct tiler_block_info *blks, int num_blocks)
+{
+    int ix;
+    for (ix = 0; ix < num_blocks; ix++)
+    {
+        blks[ix].ssptr = 0;
+        blks[ix].id = 0;
+        blks[ix].ptr = NULL;
+    }
+
+}
+
+bytes_t MemMgr_PageSize()
+{
+    return PAGE_SIZE;
+}
+
+void *MemMgr_Alloc(MemAllocBlock blocks[], int num_blocks)
+{
+    IN;
+    void *bufPtr = NULL;
+
+    /* need to access ssptrs */
+    struct tiler_block_info *blks = (tiler_block_info *) blocks;
+
+    /* check block allocation params, and state */
+    if (NOT_I(check_blocks(blks, num_blocks, num_blocks - 1),==,0) ||
+        NOT_I(inc_ref(),==,0)) goto DONE;
+
+    /* ----- begin recoverable portion ----- */
+    int ix;
+
+    /* allocate each buffer using tiler driver and initialize block info */
+    for (ix = 0; ix < num_blocks; ix++)
+    {
+        if (ix)
+        {
+            /* continue offset between pages */
+        }
+        CHK_I(blks[ix].ptr,==,NULL);
+        if (NOT_I(tiler_alloc(blks + ix),==,0)) goto FAIL_ALLOC;
+    }
+
+    bufPtr = tiler_mmap(blks, num_blocks, BUF_ALLOCED);
+    if (A_P(bufPtr,!=,0)) goto DONE;
+
+    /* ------ error handling ------ */
+FAIL_ALLOC:
+    while (ix)
+    {
+        tiler_free(blks + --ix);
+    }
+
+    /* clear ssptr and ptr fields for all blocks */
+    reset_blocks(blks, num_blocks);
+
+    A_I(dec_ref(),==,0);
+DONE:
+    CHK_I(cache_check(),==,0);
+    return R_P(bufPtr);
+}
+
+int MemMgr_Free(void *bufPtr)
+{
+    IN;
+
+    int ret = MEMMGR_ERR_GENERIC;
+    struct tiler_buf_info buf;
+    ZERO(buf);
+
+    /* retrieve registered buffers from vsptr */
+    /* :NOTE: if this succeeds, Memory Allocator stops tracking this buffer */
+    buf_cache_del(bufPtr, &buf, BUF_ALLOCED);
+
+    if (A_L(buf.offset,!=,0))
+    {
+#ifndef STUB_TILER
+        dump_buf(&buf, "==(URBUF)=>");
+        ret = A_I(ioctl(td, TILIOC_URBUF, &buf),==,0);
+        dump_buf(&buf, "<=(URBUF)==");
+
+        /* free each block */
+        int ix;
+        for (ix = 0; ix < buf.num_blocks; ix++)
+        {
+            ERR_ADD(ret, tiler_free(buf.blocks + ix));
+        }
+
+        /* unmap buffer */
+        bufPtr = (void *)((uint32_t)bufPtr & ~(PAGE_SIZE - 1));
+        ERR_ADD(ret, munmap(bufPtr, map_size(buf.length, buf.offset)));
+#else
+        void *ptr = (void *) buf.offset;
+        FREE(ptr);
+        ret = MEMMGR_ERR_NONE;
+#endif
+        ERR_ADD(ret, dec_ref());
+    }
+
+    CHK_I(cache_check(),==,0);
+    return R_I(ret);
+}
+
+void *MemMgr_Map(MemAllocBlock blocks[], int num_blocks)
+{
+    IN;
+    void *bufPtr = NULL;
+
+    /* need to access ssptrs */
+    struct tiler_block_info *blks = (tiler_block_info *) blocks;
+
+    /* check block params, and state */
+    if (check_blocks(blks, num_blocks, num_blocks) ||
+        NOT_I(inc_ref(),==,0)) goto DONE;
+
+    /* we only map 1 page aligned 1D buffer for now */
+    if (NOT_I(num_blocks,==,1) ||
+        NOT_I(blocks[0].pixelFormat,==,PIXEL_FMT_PAGE) ||
+        NOT_I(blocks[0].dim.len & (PAGE_SIZE - 1),==,0) ||
+#ifdef STUB_TILER
+        NOT_I(MemMgr_IsMapped(blocks[0].ptr),==,0) ||
+#endif
+        NOT_I((uint32_t)blocks[0].ptr & (PAGE_SIZE - 1),==,0))
+        goto FAIL;
+
+    /* ----- begin recoverable portion ----- */
+    int ix;
+
+    /* allocate each buffer using tiler driver */
+    for (ix = 0; ix < num_blocks; ix++)
+    {
+        if (ix)
+        {
+            /* continue offset between pages */
+        }
+        if (NOT_I(blks[ix].ptr,!=,NULL) ||
+            NOT_I(tiler_map(blks + ix),==,0)) goto FAIL_MAP;
+    }
+
+    /* map bufer into tiler space and register with tiler manager */
+    bufPtr = tiler_mmap(blks, num_blocks, BUF_MAPPED);
+    if (A_P(bufPtr,!=,0)) goto DONE;
+
+    /* ------ error handling ------ */
+FAIL_MAP:
+    while (ix)
+    {
+        tiler_unmap(blks + --ix);
+    }
+
+FAIL:
+    /* clear ssptr and ptr fields for all blocks */
+    reset_blocks(blks, num_blocks);
+
+    A_I(dec_ref(),==,0);
+DONE:
+    CHK_I(cache_check(),==,0);
+    return R_P(bufPtr);
+}
+
+int MemMgr_UnMap(void *bufPtr)
+{
+    IN;
+
+    int ret = MEMMGR_ERR_GENERIC;
+    struct tiler_buf_info buf;
+    ZERO(buf);
+
+    /* retrieve registered buffers from vsptr */
+    /* :NOTE: if this succeeds, Memory Allocator stops tracking this buffer */
+    buf_cache_del(bufPtr, &buf, BUF_MAPPED);
+
+    if (A_L(buf.offset,!=,0))
+    {
+#ifndef STUB_TILER
+        dump_buf(&buf, "==(URBUF)=>");
+        ret = A_I(ioctl(td, TILIOC_URBUF, &buf),==,0);
+        dump_buf(&buf, "<=(URBUF)==");
+
+        /* unmap each block */
+        int ix;
+        for (ix = 0; ix < buf.num_blocks; ix++)
+        {
+            ERR_ADD(ret, tiler_unmap(buf.blocks + ix));
+        }
+
+        /* unmap buffer */
+        bufPtr = (void *)((uint32_t)bufPtr & ~(PAGE_SIZE - 1));
+        ERR_ADD(ret, munmap(bufPtr, map_size(buf.length, buf.offset)));
+#else
+        struct tiler_buf_info *ptr = (struct tiler_buf_info *) buf.offset;
+        FREE(ptr[1].blocks[0].ptr);
+        FREE(ptr);
+        ret = MEMMGR_ERR_NONE;
+#endif
+        ERR_ADD(ret, dec_ref());
+    }
+
+    CHK_I(cache_check(),==,0);
+    return R_I(ret);
+}
+
+bool MemMgr_Is1DBlock(void *ptr)
+{
+    IN;
+
+    SSPtr ssptr = TilerMem_VirtToPhys(ptr);
+    enum tiler_fmt fmt = tiler_get_fmt(ssptr);
+    return R_I(fmt == TILFMT_PAGE);
+}
+
+bool MemMgr_Is2DBlock(void *ptr)
+{
+    IN;
+
+    SSPtr ssptr = TilerMem_VirtToPhys(ptr);
+    enum tiler_fmt fmt = tiler_get_fmt(ssptr);
+    return R_I(fmt == TILFMT_8BIT || fmt == TILFMT_16BIT ||
+               fmt == TILFMT_32BIT);
+}
+
+bool MemMgr_IsMapped(void *ptr)
+{
+    IN;
+    SSPtr ssptr = TilerMem_VirtToPhys(ptr);
+    enum tiler_fmt fmt = tiler_get_fmt(ssptr);
+    return R_I(fmt == TILFMT_8BIT || fmt == TILFMT_16BIT ||
+               fmt == TILFMT_32BIT || fmt == TILFMT_PAGE);
+}
+
+bytes_t MemMgr_GetStride(void *ptr)
+{
+    IN;
+#ifndef STUB_TILER
+    struct tiler_buf_info buf;
+    ZERO(buf);
+
+    /* find block that this buffer belongs to */
+    buf_cache_query(ptr, &buf, BUF_ALLOCED | BUF_MAPPED);
+    void *bufPtr = buf.blocks[0].ptr;
+
+    A_I(inc_ref(),==,0);
+
+    /* for tiler mapped buffers, get saved stride information */
+    if (buf.offset)
+    {
+        /* walk through block to determine which stride we need */
+        int ix;
+        for (ix = 0; ix < buf.num_blocks; ix++)
+        {
+            bytes_t size = def_size(buf.blocks + ix);
+            if (bufPtr <= ptr && ptr < bufPtr + size) {
+                A_I(dec_ref(),==,0);
+                return R_UP(buf.blocks[ix].stride);
+            }
+            bufPtr += size;
+        }
+        A_I(dec_ref(),==,0);
+        DP("assert: should not ever get here");
+        return R_UP(0);
+    }
+    /* see if pointer is valid */
+    else if (TilerMem_VirtToPhys(ptr) == 0)
+    {
+        A_I(dec_ref(),==,0);
+        return R_UP(0);
+    }
+    A_I(dec_ref(),==,0);
+#else
+    /* if emulating, we need to get through all allocated memory segments */
+    pthread_mutex_lock(&che_mutex);
+    init();
+
+    _AllocData *ad;
+    if (!ptr) return R_UP(0);
+    DLIST_MLOOP(bufs, ad, link) {
+        int ix;
+        struct tiler_buf_info *buf = (struct tiler_buf_info *) ad->buf.offset;
+        for (ix = 0; ix < buf->num_blocks; ix++)
+        {
+            if (ptr >= buf->blocks[ix].ptr &&
+                ptr < buf->blocks[ix].ptr + def_size(buf->blocks + ix))
+            {
+                bytes_t stride = buf->blocks[ix].stride;
+                pthread_mutex_unlock(&che_mutex);
+                return R_UP(stride);
+            }
+        }
+    }
+    pthread_mutex_unlock(&che_mutex);
+#endif
+    return R_UP(PAGE_SIZE);
+}
+
+bytes_t TilerMem_GetStride(SSPtr ssptr)
+{
+    IN;
+    switch(tiler_get_fmt(ssptr))
+    {
+    case TILFMT_8BIT:  return R_UP(TILER_STRIDE_8BIT);
+    case TILFMT_16BIT: return R_UP(TILER_STRIDE_16BIT);
+    case TILFMT_32BIT: return R_UP(TILER_STRIDE_32BIT);
+    case TILFMT_PAGE:  return R_UP(PAGE_SIZE);
+    default:           return R_UP(0);
+    }
+}
+
+SSPtr TilerMem_VirtToPhys(void *ptr)
+{
+#ifndef STUB_TILER
+    SSPtr ssptr = 0;
+    if(!NOT_I(inc_ref(),==,0))
+    {
+        ssptr = ioctl(td, TILIOC_GSSP, (unsigned long) ptr);
+        A_I(dec_ref(),==,0);
+    }
+    return (SSPtr)R_P(ssptr);
+#else
+    return (SSPtr)ptr;
+#endif
+}
+
+/**
+ * Internal Unit Test.  Tests the static methods of this
+ * library.  Assumes an unitialized state as well.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @return 0 for success, non-0 error value for failure.
+ */
+int __test__MemMgr()
+{
+    int ret = 0;
+
+    /* state check */
+    ret |= NOT_I(TILER_PAGE_WIDTH * TILER_PAGE_HEIGHT,==,PAGE_SIZE);
+    ret |= NOT_I(refCnt,==,0);
+    ret |= NOT_I(inc_ref(),==,0);
+    ret |= NOT_I(refCnt,==,1);
+    ret |= NOT_I(dec_ref(),==,0);
+    ret |= NOT_I(refCnt,==,0);
+
+    /* enumeration check */
+    ret |= NOT_I(PIXEL_FMT_8BIT,==,TILFMT_8BIT);
+    ret |= NOT_I(PIXEL_FMT_16BIT,==,TILFMT_16BIT);
+    ret |= NOT_I(PIXEL_FMT_32BIT,==,TILFMT_32BIT);
+    ret |= NOT_I(PIXEL_FMT_PAGE,==,TILFMT_PAGE);
+    ret |= NOT_I(sizeof(MemAllocBlock),==,sizeof(struct tiler_block_info));
+
+    /* void * arithmetic */
+    void *a = (void *)1000, *b = a + 2000, *c = (void *)3000;
+    ret |= NOT_P(b,==,c);
+
+    /* def_stride */
+    ret |= NOT_I(def_stride(0),==,0);
+    ret |= NOT_I(def_stride(1),==,PAGE_SIZE);
+    ret |= NOT_I(def_stride(PAGE_SIZE),==,PAGE_SIZE);
+    ret |= NOT_I(def_stride(PAGE_SIZE + 1),==,2 * PAGE_SIZE);
+
+    /* def_bpp */
+    ret |= NOT_I(def_bpp(PIXEL_FMT_32BIT),==,4);
+    ret |= NOT_I(def_bpp(PIXEL_FMT_16BIT),==,2);
+    ret |= NOT_I(def_bpp(PIXEL_FMT_8BIT),==,1);
+
+    /* def_size */
+    tiler_block_info blk = {0};
+    blk.fmt = TILFMT_8BIT;
+    blk.dim.area.width = PAGE_SIZE * 8 / 10;
+    blk.dim.area.height = 10;
+    ret |= NOT_I(def_size(&blk),==,10 * PAGE_SIZE);
+
+    blk.fmt = TILFMT_16BIT;
+    blk.dim.area.width = PAGE_SIZE * 7 / 10;
+    ret |= NOT_I(def_size(&blk),==,20 * PAGE_SIZE);
+    blk.dim.area.width = PAGE_SIZE * 4 / 10;
+    ret |= NOT_I(def_size(&blk),==,10 * PAGE_SIZE);
+
+    blk.fmt = TILFMT_32BIT;
+    ret |= NOT_I(def_size(&blk),==,20 * PAGE_SIZE);
+    blk.dim.area.width = PAGE_SIZE * 6 / 10;
+    ret |= NOT_I(def_size(&blk),==,30 * PAGE_SIZE);
+
+    return ret;
+}
+
diff --git a/tiler/memmgr.h b/tiler/memmgr.h
new file mode 100644
index 0000000..8f99904
--- /dev/null
+++ b/tiler/memmgr.h
@@ -0,0 +1,311 @@
+/*
+ *  memmgr.h
+ *
+ *  Memory Allocator Interface functions for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _MEMMGR_H_
+#define _MEMMGR_H_
+
+/* retrieve type definitions */
+#include "mem_types.h"
+
+/**
+ * Memory Allocator is responsible for:
+ * <ol>
+ * <li>Allocate 1D and 2D blocks and pack them into a buffer.
+ * <li>Free such allocated blocks
+ * <li>Map 1D buffers into tiler space
+ * <li>Unmap 1D buffers from tiler space
+ * <li>Verify if an address lies in 1D or 2D space, whether it
+ * is mapped (to tiler space)
+ * <li>Mapping Ducati memory blocks to host processor and vice
+ * versa.
+ * </ol>
+ *
+ * The allocator distinguishes between:
+ * <ul>
+ * <li>1D and 2D blocks
+ * <li>2D blocks allocated by MemAlloc are non-cacheable.  All
+ * other blocks are cacheable (e.g. 1D blocks).  Preallocated
+ * may or may not be cacheable, depending on how they've been
+ * allocated, but are assumed to be cacheable.
+ * <li>buffers (an ordered collection of one or more blocks
+ * mapped consecutively)
+ * </ul>
+ *
+ * The allocator tracks each buffer based on (addr, size).
+ *
+ * Also, via the tiler manager, it tracks each block.  The tiler
+ * manager itself also tracks each buffer.
+ *
+ */
+
+/**
+ * Memory Allocator block specification
+ *
+ * Size of a 2D buffer is calculated as height * stride.  stride
+ * is the smallest multiple of page size that is at least
+ * the width, and is set by MemMgr_Alloc.
+ *
+ * Size of a 1D buffer is calculated as length.  stride is not
+ * set by MemMgr_Alloc, but it can be set by the user.  length
+ * must be a multiple of stride unless stride is 0.
+ *
+ * @author a0194118 (9/1/2009)
+ */
+struct MemAllocBlock {
+    pixel_fmt_t pixelFormat; /* pixel format */
+    union {
+        struct {
+            pixels_t width;  /* width of 2D buffer */
+            pixels_t height; /* height of 2D buffer */
+        } area;
+        bytes_t  len;        /* length of 1D buffer.  Must be multiple of
+                                stride if stride is not 0. */
+    } dim;
+    uint32_t stride;    /* must be multiple of page size.  Can be 0 only
+                           if pixelFormat is PIXEL_FMT_PAGE. */
+    void    *ptr;       /* pointer to beginning of buffer */
+    uint32_t id;        /* buffer ID - received at allocation */
+    uint32_t key;       /* buffer key - given at allocation */
+    uint32_t group_id;  /* group ID */
+    /* alignment requirements for ssptr: ssptr & (align - 1) == offs */
+    uint32_t reserved;  /* system space address (used internally) */
+};
+
+typedef struct MemAllocBlock MemAllocBlock;
+
+/**
+ * Returns the page size.  This is required for allocating 1D
+ * blocks that stack under any other blocks.
+ *
+ * @author a0194118 (9/3/2009)
+ *
+ * @return Page size.
+ */
+bytes_t MemMgr_PageSize();
+
+/**
+ * Allocates a buffer as a list of blocks (1D or 2D), and maps
+ * them so that they are packaged consecutively. Returns the
+ * pointer to the first block, or NULL on failure.
+ * <p>
+ * The size of each block other than the last must be a multiple
+ * of the page size.  This ensures that the blocks stack
+ * correctly.  Set stride to 0 to avoid stride/length alignment
+ * constraints.  Stride of 2D blocks will be updated by this
+ * method.
+ * <p>
+ * 2D blocks will be non-cacheable, while 1D blocks will be
+ * cacheable.
+ * <p>
+ * On success, the buffer is registered with the memory
+ * allocator.
+ * <p>
+ * As a side effect, if the operation was successful, the ssptr
+ * fields of the block specification will be filled with the
+ * system-space addresses, while the ptr fields will be set to
+ * the individual blocks.  The stride information is set for 2D
+ * blocks.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param blocks     Block specification information.  This
+ *                   should be an array of at least num_blocks
+ *                   elements.
+ * @param num_blocks Number of blocks to be included in the
+ *                   allocated memory segment
+ *
+ * @return Pointer to the buffer, which is also the pointer to
+ *         the first allocated block. NULL if allocation failed.
+ */
+void *MemMgr_Alloc(MemAllocBlock blocks[], int num_blocks);
+
+/**
+ * Frees a buffer allocated by MemMgr_Alloc(). It fails for
+ * any buffer not allocated by MemMgr_Alloc() or one that has
+ * been already freed.
+ * <p>
+ * It also unregisters the buffer with the memory allocator.
+ * <p>
+ * This function unmaps the processor's virtual address to the
+ * tiler address for all blocks allocated, unregisters the
+ * buffer, and frees all of its tiler blocks.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param bufPtr     Pointer to the buffer allocated (returned)
+ *                   by MemMgr_Alloc()
+ *
+ * @return 0 on success.  Non-0 error value on failure.
+ */
+int MemMgr_Free(void *bufPtr);
+
+/**
+ * This function maps the user provided data buffer to the tiler
+ * space as blocks, and maps that area into the process space
+ * consecutively. You can map a data buffer multiple times,
+ * resulting in multiple mapping for the same buffer. However,
+ * you cannot map a buffer that is already mapped to tiler, e.g.
+ * a buffer pointer returned by this method.
+ *
+ * In phase 1 and 2, the supported configurations are:
+ * <ol>
+ * <li> Mapping exactly one 1D block to tiler space (e.g.
+ * MapIn1DMode).
+ * </ol>
+ *
+ * @author a0194118 (9/3/2009)
+ *
+ * @param blocks     Block specification information.  This
+ *                   should be an array of at least num_blocks
+ *                   elements.  The ptr fields must contain the
+ *                   user allocated buffers for the block.
+ *                   These will be updated with the mapped
+ *                   addresses of these blocks on success.
+ *
+ *                   Each block must be page aligned.  Length of
+ *                   each block also must be page aligned.
+ *
+ * @param num_blocks Number of blocks to be included in the
+ *                   mapped memory segment
+ *
+ * @return Pointer to the buffer, which is also the pointer to
+ *         the first mapped block. NULL if allocation failed.
+ */
+void *MemMgr_Map(MemAllocBlock blocks[], int num_blocks);
+
+/**
+ * This function unmaps the user provided data buffer from tiler
+ * space that was mapped to the tiler space in paged mode using
+ * MemMgr_Map().  It also unmaps the buffer itself from the
+ * process space.  Trying to unmap a previously unmapped buffer
+ * will fail.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param bufPtr    Pointer to the buffer as returned by a
+ *                  previous call to MemMgr_MapIn1DMode()
+ *
+ * @return 0 on success.  Non-0 error value on failure.
+ */
+int MemMgr_UnMap(void *bufPtr);
+
+/**
+ * Checks if a given virtual address is mapped by tiler manager
+ * to tiler space.
+ * <p>
+ * This function is equivalent to MemMgr_Is1DBuffer(ptr) ||
+ * MemMgr_Is2DBuffer(ptr).  It retrieves the system space
+ * address that the virtual address maps to. If this system
+ * space address lies within the tiler area, the function
+ * returns TRUE.
+ *
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr   Pointer to a virtual address
+ *
+ * @return TRUE (non-0) if the virtual address is within a
+ *         buffer that was mapped into tiler space, e.g. by
+ *         calling MemMgr_MapIn1DMode() or MemMgr_MapIn2DMode()
+ */
+bool MemMgr_IsMapped(void *ptr);
+
+/**
+ * Checks if a given virtual address lies in a tiler 1D buffer.
+ * <p>
+ * This function retrieves the system space address that the
+ * virtual address maps to.  If this system space address is
+ * within the 1D tiler area, it is considered lying within a 1D
+ * buffer.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr   Pointer to a virtual address
+ *
+ * @return TRUE (non-0) if the virtual address is within a
+ *         mapped 1D tiler buffer.  FALSE (0) if the virtual
+ *         address is not mapped, invalid, or is mapped to an
+ *         area other than a 1D tiler buffer.  In phase 1,
+ *         however, it is TRUE it the virtual address is mapped
+ *         to the page-mode area of the tiler space.
+ */
+bool MemMgr_Is1DBlock(void *ptr);
+
+/**
+ * Checks if a given virtual address lies in a 2D buffer.
+ * <p>
+ * This function retrieves the system space address that the
+ * virtual address maps to.  If this system space address is
+ * within the 2D tiler area, it is considered lying within a 2D
+ * buffer.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr   Pointer to a virtual address
+ *
+ * @return TRUE (non-0) if the virtual address is within a
+ *         mapped 2D buffer.  FALSE (0) if the virtual address
+ *         is not mapped, invalid, or is mapped to an area other
+ *         than a 2D buffer.  In phase 1, however, it is TRUE it
+ *         the virtual address is mapped to any area of the
+ *         tiler space other than page mode.
+ */
+bool MemMgr_Is2DBlock(void *ptr);
+
+/**
+ * Returns the stride corresponding to a virtual address.  For
+ * 1D and 2D buffers it returns the stride supplied
+ * with/acquired during the allocation/mapping.  For non-tiler
+ * buffers it returns the page size.
+ * <p>
+ * NOTE: on Ducati phase 1, stride should return 16K for 8-bit
+ * 2D buffers, 32K for 16-bit and 32-bit 2D buffers, the stride
+ * used for alloc/map for 1D buffers, and the page size for
+ * non-tiler buffers.
+ *
+ * For unmapped addresses it returns 0.  However, this cannot be
+ * used to determine if an address is unmapped as 1D buffers
+ * could also have 0 stride (e.g. compressed buffers).
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr    pointer to a virtual address
+ *
+ * @return The virtual stride of the block that contains the
+ *         address.
+ */
+bytes_t MemMgr_GetStride(void *ptr);
+
+#endif
diff --git a/tiler/memmgr_test.c b/tiler/memmgr_test.c
new file mode 100644
index 0000000..2bb76b6
--- /dev/null
+++ b/tiler/memmgr_test.c
@@ -0,0 +1,1693 @@
+/*
+ *  memmgr_test.c
+ *
+ *  Memory Allocator Interface tests.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* retrieve type definitions */
+#define __DEBUG__
+#undef __DEBUG_ENTRY__
+#define __DEBUG_ASSERT__
+
+#define __MAP_OK__
+#undef __WRITE_IN_STRIDE__
+#undef STAR_TRACE_MEM
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef HAVE_CONFIG_H
+    #include "config.h"
+#endif
+#include <utils.h>
+#include <list_utils.h>
+#include <debug_utils.h>
+#include <memmgr.h>
+#include <tilermem.h>
+#include <tilermem_utils.h>
+#include <testlib.h>
+
+/* for star_tiler_test */
+#include <fcntl.h>     /* open() */
+#include <unistd.h>    /* close() */
+#include <sys/ioctl.h> /* ioctl() */
+
+#define FALSE 0
+#define TESTERR_NOTIMPLEMENTED -65378
+
+#define MAX_ALLOCS 512
+
+#define TESTS\
+    T(alloc_1D_test(4096, 0))\
+    T(alloc_2D_test(64, 64, PIXEL_FMT_8BIT))\
+    T(alloc_2D_test(64, 64, PIXEL_FMT_16BIT))\
+    T(alloc_2D_test(64, 64, PIXEL_FMT_32BIT))\
+    T(alloc_NV12_test(64, 64))\
+    T(map_1D_test(4096, 0))\
+    T(alloc_1D_test(176 * 144 * 2, 0))\
+    T(alloc_2D_test(176, 144, PIXEL_FMT_8BIT))\
+    T(alloc_2D_test(176, 144, PIXEL_FMT_16BIT))\
+    T(alloc_2D_test(176, 144, PIXEL_FMT_32BIT))\
+    T(alloc_NV12_test(176, 144))\
+    T(map_1D_test(176 * 144 * 2, 0))\
+    T(alloc_1D_test(640 * 480 * 2, 0))\
+    T(alloc_2D_test(640, 480, PIXEL_FMT_8BIT))\
+    T(alloc_2D_test(640, 480, PIXEL_FMT_16BIT))\
+    T(alloc_2D_test(640, 480, PIXEL_FMT_32BIT))\
+    T(alloc_NV12_test(640, 480))\
+    T(map_1D_test(640 * 480 * 2, 0))\
+    T(alloc_1D_test(848 * 480 * 2, 0))\
+    T(alloc_2D_test(848, 480, PIXEL_FMT_8BIT))\
+    T(alloc_2D_test(848, 480, PIXEL_FMT_16BIT))\
+    T(alloc_2D_test(848, 480, PIXEL_FMT_32BIT))\
+    T(alloc_NV12_test(848, 480))\
+    T(map_1D_test(848 * 480 * 2, 0))\
+    T(alloc_1D_test(1280 * 720 * 2, 0))\
+    T(alloc_2D_test(1280, 720, PIXEL_FMT_8BIT))\
+    T(alloc_2D_test(1280, 720, PIXEL_FMT_16BIT))\
+    T(alloc_2D_test(1280, 720, PIXEL_FMT_32BIT))\
+    T(alloc_NV12_test(1280, 720))\
+    T(map_1D_test(1280 * 720 * 2, 0))\
+    T(alloc_1D_test(1920 * 1080 * 2, 0))\
+    T(alloc_2D_test(1920, 1080, PIXEL_FMT_8BIT))\
+    T(alloc_2D_test(1920, 1080, PIXEL_FMT_16BIT))\
+    T(alloc_2D_test(1920, 1080, PIXEL_FMT_32BIT))\
+    T(alloc_NV12_test(1920, 1080))\
+    T(map_1D_test(1920 * 1080 * 2, 0))\
+    T(map_1D_test(4096, 0))\
+    T(map_1D_test(8192, 0))\
+    T(map_1D_test(16384, 0))\
+    T(map_1D_test(32768, 0))\
+    T(map_1D_test(65536, 0))\
+    T(neg_alloc_tests())\
+    T(neg_free_tests())\
+    T(neg_map_tests())\
+    T(neg_unmap_tests())\
+    T(neg_check_tests())\
+    T(page_size_test())\
+    T(maxalloc_2D_test(2500, 32, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(2500, 16, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(1250, 16, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(5000, 32, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(5000, 16, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(2500, 16, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+    T(alloc_2D_test(8193, 16, PIXEL_FMT_8BIT))\
+    T(alloc_2D_test(8193, 16, PIXEL_FMT_16BIT))\
+    T(alloc_2D_test(4097, 16, PIXEL_FMT_32BIT))\
+    T(alloc_2D_test(16384, 16, PIXEL_FMT_8BIT))\
+    T(alloc_2D_test(16384, 16, PIXEL_FMT_16BIT))\
+    T(alloc_2D_test(8192, 16, PIXEL_FMT_32BIT))\
+    T(!alloc_2D_test(16385, 16, PIXEL_FMT_8BIT))\
+    T(!alloc_2D_test(16385, 16, PIXEL_FMT_16BIT))\
+    T(!alloc_2D_test(8193, 16, PIXEL_FMT_32BIT))\
+    T(maxalloc_1D_test(4096, MAX_ALLOCS))\
+    T(maxalloc_2D_test(64, 64, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(64, 64, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(64, 64, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+    T(maxalloc_NV12_test(64, 64, MAX_ALLOCS))\
+    T(maxmap_1D_test(4096, MAX_ALLOCS))\
+    T(maxalloc_1D_test(176 * 144 * 2, MAX_ALLOCS))\
+    T(maxalloc_2D_test(176, 144, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(176, 144, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(176, 144, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+    T(maxalloc_NV12_test(176, 144, MAX_ALLOCS))\
+    T(maxmap_1D_test(176 * 144 * 2, MAX_ALLOCS))\
+    T(maxalloc_1D_test(640 * 480 * 2, MAX_ALLOCS))\
+    T(maxalloc_2D_test(640, 480, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(640, 480, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(640, 480, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+    T(maxalloc_NV12_test(640, 480, MAX_ALLOCS))\
+    T(maxmap_1D_test(640 * 480 * 2, MAX_ALLOCS))\
+    T(maxalloc_1D_test(848 * 480 * 2, MAX_ALLOCS))\
+    T(maxalloc_2D_test(848, 480, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(848, 480, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(848, 480, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+    T(maxalloc_NV12_test(848, 480, MAX_ALLOCS))\
+    T(maxmap_1D_test(848 * 480 * 2, MAX_ALLOCS))\
+    T(maxalloc_1D_test(1280 * 720 * 2, MAX_ALLOCS))\
+    T(maxalloc_2D_test(1280, 720, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(1280, 720, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(1280, 720, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+    T(maxalloc_NV12_test(1280, 720, MAX_ALLOCS))\
+    T(maxmap_1D_test(1280 * 720 * 2, MAX_ALLOCS))\
+    T(maxalloc_1D_test(1920 * 1080 * 2, MAX_ALLOCS))\
+    T(maxalloc_2D_test(1920, 1080, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(1920, 1080, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+    T(maxalloc_2D_test(1920, 1080, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+    T(maxalloc_NV12_test(1920, 1080, 2))\
+    T(maxalloc_NV12_test(1920, 1080, MAX_ALLOCS))\
+    T(maxmap_1D_test(1920 * 1080 * 2, MAX_ALLOCS))\
+    T(star_tiler_test(1000, 10))\
+    T(star_tiler_test(1000, 30))\
+    T(star_test(100, 10))\
+    T(star_test(1000, 10))\
+
+/* this is defined in memmgr.c, but not exported as it is for internal
+   use only */
+extern int __test__MemMgr();
+
+/**
+ * Returns the default page stride for this block
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param width  Width of 2D container
+ *
+ * @return Stride
+ */
+static bytes_t def_stride(bytes_t width)
+{
+    return ROUND_UP_TO2POW(width, PAGE_SIZE);
+}
+
+/**
+ * Returns the bytes per pixel for the pixel format.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param pixelFormat   Pixelformat
+ *
+ * @return Bytes per pixel
+ */
+static bytes_t def_bpp(pixel_fmt_t pixelFormat)
+{
+    return (pixelFormat == PIXEL_FMT_32BIT ? 4 :
+            pixelFormat == PIXEL_FMT_16BIT ? 2 : 1);
+}
+
+/**
+ * This method fills up a range of memory using a start address
+ * and start value.  The method of filling ensures that
+ * accidentally overlapping regions have minimal chances of
+ * matching, even if the same starting value is used.  This is
+ * because the difference between successive values varies as
+ * such.  This series only repeats after 704189 values, so the
+ * probability of a match for a range of at least 2 values is
+ * less than 2*10^-11.
+ *
+ * V(i + 1) - V(i) = { 1, 2, 3, ..., 65535, 2, 4, 6, 8 ...,
+ * 65534, 3, 6, 9, 12, ..., 4, 8, 12, 16, ... }
+ *
+ * @author a0194118 (9/6/2009)
+ *
+ * @param start   start value
+ * @param block   pointer to block info strucure
+ */
+void fill_mem(uint16_t start, MemAllocBlock *block)
+{
+    IN;
+    uint16_t *ptr = (uint16_t *)block->ptr, delta = 1, step = 1;
+    bytes_t height, width, stride, i;
+    if (block->pixelFormat == PIXEL_FMT_PAGE)
+    {
+        height = 1;
+        stride = width = block->dim.len;
+    }
+    else
+    {
+        height = block->dim.area.height;
+        width = block->dim.area.width;
+        stride = block->stride;
+    }
+    width *= def_bpp(block->pixelFormat);
+    bytes_t size = height * stride;
+
+    P("(%p,0x%x*0x%x,s=0x%x)=0x%x", block->ptr, width, height, stride, start);
+
+    CHK_I(width,<=,stride);
+    uint32_t *ptr32 = (uint32_t *)ptr;
+    while (height--)
+    {
+        if (block->pixelFormat == PIXEL_FMT_32BIT)
+        {
+            for (i = 0; i < width; i += sizeof(uint32_t))
+            {
+                uint32_t val = (start & 0xFFFF) | (((uint32_t)(start + delta) & 0xFFFF) << 16);
+                *ptr32++ = val;
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+            }
+#ifdef __WRITE_IN_STRIDE__
+            while (i < stride && (height || ((PAGE_SIZE - 1) & (uint32_t)ptr32)))
+            {
+                *ptr32++ = 0;
+                i += sizeof(uint32_t);
+            }
+#else
+            ptr32 += (stride - i) / sizeof(uint32_t);
+#endif
+        }
+        else
+        {
+            for (i = 0; i < width; i += sizeof(uint16_t))
+            {
+                *ptr++ = start;
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+            }
+#ifdef __WRITE_IN_STRIDE__
+            while (i < stride && (height || ((PAGE_SIZE - 1) & (uint32_t)ptr)))
+            {
+                *ptr++ = 0;
+                i += sizeof(uint16_t);
+            }
+#else
+            ptr += (stride - i) / sizeof(uint16_t);
+#endif
+
+        }
+    }
+    CHK_P((block->pixelFormat == PIXEL_FMT_32BIT ? (void *)ptr32 : (void *)ptr),==,
+          (block->ptr + size));
+    OUT;
+}
+
+/**
+ * This verifies if a range of memory at a given address was
+ * filled up using the start value.
+ *
+ * @author a0194118 (9/6/2009)
+ *
+ * @param start   start value
+ * @param block   pointer to block info strucure
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int check_mem(uint16_t start, MemAllocBlock *block)
+{
+    IN;
+    uint16_t *ptr = (uint16_t *)block->ptr, delta = 1, step = 1;
+    bytes_t height, width, stride, r, i;
+    if (block->pixelFormat == PIXEL_FMT_PAGE)
+    {
+        height = 1;
+        stride = width = block->dim.len;
+    }
+    else
+    {
+        height = block->dim.area.height;
+        width = block->dim.area.width;
+        stride = block->stride;
+    }
+    width *= def_bpp(block->pixelFormat);
+
+    CHK_I(width,<=,stride);
+    uint32_t *ptr32 = (uint32_t *)ptr;
+    for (r = 0; r < height; r++)
+    {
+        if (block->pixelFormat == PIXEL_FMT_32BIT)
+        {
+            for (i = 0; i < width; i += sizeof(uint32_t))
+            {
+                uint32_t val = (start & 0xFFFF) | (((uint32_t)(start + delta) & 0xFFFF) << 16);
+                if (*ptr32++ != val) {
+                    DP("assert: val[%u,%u] (=0x%x) != 0x%x", r, i, *--ptr32, val);
+                    return R_I(MEMMGR_ERR_GENERIC);
+                }
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+            }
+#ifdef __WRITE_IN_STRIDE__
+            while (i < stride && ((r < height - 1) || ((PAGE_SIZE - 1) & (uint32_t)ptr32)))
+            {
+                if (*ptr32++) {
+                    DP("assert: val[%u,%u] (=0x%x) != 0", r, i, *--ptr32);
+                    return R_I(MEMMGR_ERR_GENERIC);
+                }
+                i += sizeof(uint32_t);
+            }
+#else
+            ptr32 += (stride - i) / sizeof(uint32_t);
+#endif
+        }
+        else
+        {
+            for (i = 0; i < width; i += sizeof(uint16_t))
+            {
+                if (*ptr++ != start) {
+                    DP("assert: val[%u,%u] (=0x%x) != 0x%x", r, i, *--ptr, start);
+                    return R_I(MEMMGR_ERR_GENERIC);
+                }
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+            }
+#ifdef __WRITE_IN_STRIDE__
+            while (i < stride && ((r < height - 1) || ((PAGE_SIZE - 1) & (uint32_t)ptr)))
+            {
+                if (*ptr++) {
+                    DP("assert: val[%u,%u] (=0x%x) != 0", r, i, *--ptr);
+                    return R_I(MEMMGR_ERR_GENERIC);
+                }
+                i += sizeof(uint16_t);
+            }
+#else
+            ptr += (stride - i) / sizeof(uint16_t);
+#endif
+        }
+    }
+    return R_I(MEMMGR_ERR_NONE);
+}
+
+/**
+ * This method allocates a 1D tiled buffer of the given length
+ * and stride using MemMgr_Alloc.  If successful, it checks
+ * that the block information was updated with the pointer to
+ * the block.  Additionally, it verifies the correct return
+ * values for MemMgr_IsMapped, MemMgr_Is1DBlock,
+ * MemMgr_Is2DBlock, MemMgr_GetStride, TilerMem_GetStride.  It
+ * also verifies TilerMem_VirtToPhys using an internally stored
+ * value of the ssptr. If any of these verifications fail, the
+ * buffer is freed.  Otherwise, it is filled using the given
+ * start value.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length   Buffer length
+ * @param stride   Buffer stride
+ * @param val      Fill start value
+ *
+ * @return pointer to the allocated buffer, or NULL on failure
+ */
+void *alloc_1D(bytes_t length, bytes_t stride, uint16_t val)
+{
+    MemAllocBlock block;
+    memset(&block, 0, sizeof(block));
+
+    block.pixelFormat = PIXEL_FMT_PAGE;
+    block.dim.len = length;
+    block.stride = stride;
+
+    void *bufPtr = MemMgr_Alloc(&block, 1);
+    CHK_P(bufPtr,==,block.ptr);
+    if (bufPtr) {
+        if (NOT_I(MemMgr_IsMapped(bufPtr),!=,0) ||
+            NOT_I(MemMgr_Is1DBlock(bufPtr),!=,0) ||
+            NOT_I(MemMgr_Is2DBlock(bufPtr),==,0) ||
+            NOT_I(MemMgr_GetStride(bufPtr),==,block.stride) ||
+            NOT_P(TilerMem_VirtToPhys(bufPtr),==,block.reserved) ||
+            NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(bufPtr)),==,PAGE_SIZE) ||
+            NOT_L((PAGE_SIZE - 1) & (long)bufPtr,==,(PAGE_SIZE - 1) & block.reserved))
+        {
+            MemMgr_Free(bufPtr);
+            return NULL;
+        }
+        fill_mem(val, &block);
+    }
+    return bufPtr;
+}
+
+/**
+ * This method frees a 1D tiled buffer.  The given length,
+ * stride and start values are used to verify that the buffer is
+ * still correctly filled.  In the event of any errors, the
+ * error value is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length   Buffer length
+ * @param stride   Buffer stride
+ * @param val      Fill start value
+ * @param bufPtr   Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int free_1D(bytes_t length, bytes_t stride, uint16_t val, void *bufPtr)
+{
+    MemAllocBlock block;
+    memset(&block, 0, sizeof(block));
+
+    block.pixelFormat = PIXEL_FMT_PAGE;
+    block.dim.len = length;
+    block.stride = stride;
+    block.ptr = bufPtr;
+
+    int ret = A_I(check_mem(val, &block),==,0);
+    ERR_ADD(ret, MemMgr_Free(bufPtr));
+    return ret;
+}
+
+/**
+ * This method allocates a 2D tiled buffer of the given width,
+ * height, stride and pixel format using
+ * MemMgr_Alloc. If successful, it checks that the block
+ * information was updated with the pointer to the block.
+ * Additionally, it verifies the correct return values for
+ * MemMgr_IsMapped, MemMgr_Is1DBlock, MemMgr_Is2DBlock,
+ * MemMgr_GetStride, TilerMem_GetStride.  It also verifies
+ * TilerMem_VirtToPhys using an internally stored value of the
+ * ssptr. If any of these verifications fail, the buffer is
+ * freed.  Otherwise, it is filled using the given start value.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width    Buffer width
+ * @param height   Buffer height
+ * @param fmt      Pixel format
+ * @param stride   Buffer stride
+ * @param val      Fill start value
+ *
+ * @return pointer to the allocated buffer, or NULL on failure
+ */
+void *alloc_2D(pixels_t width, pixels_t height, pixel_fmt_t fmt, bytes_t stride,
+               uint16_t val)
+{
+    MemAllocBlock block;
+    memset(&block, 0, sizeof(block));
+
+    block.pixelFormat = fmt;
+    block.dim.area.width  = width;
+    block.dim.area.height = height;
+    block.stride = stride;
+
+    void *bufPtr = MemMgr_Alloc(&block, 1);
+    CHK_P(bufPtr,==,block.ptr);
+    if (bufPtr) {
+        bytes_t cstride = (fmt == PIXEL_FMT_8BIT  ? TILER_STRIDE_8BIT :
+                           fmt == PIXEL_FMT_16BIT ? TILER_STRIDE_16BIT :
+                           TILER_STRIDE_32BIT);
+
+        if (NOT_I(MemMgr_IsMapped(bufPtr),!=,0) ||
+            NOT_I(MemMgr_Is1DBlock(bufPtr),==,0) ||
+            NOT_I(MemMgr_Is2DBlock(bufPtr),!=,0) ||
+            NOT_I(block.stride,!=,0) ||
+            NOT_I(MemMgr_GetStride(bufPtr),==,block.stride) ||
+            NOT_P(TilerMem_VirtToPhys(bufPtr),==,block.reserved) ||
+            NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(bufPtr)),==,cstride) ||
+            NOT_L((PAGE_SIZE - 1) & (long)bufPtr,==,(PAGE_SIZE - 1) & block.reserved))
+        {
+            MemMgr_Free(bufPtr);
+            return NULL;
+        }
+        fill_mem(val, &block);
+    }
+    return bufPtr;
+}
+
+/**
+ * This method frees a 2D tiled buffer.  The given width,
+ * height, pixel format, stride and start values are used to
+ * verify that the buffer is still correctly filled.  In the
+ * event of any errors, the error value is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width    Buffer width
+ * @param height   Buffer height
+ * @param fmt      Pixel format
+ * @param stride   Buffer stride
+ * @param val      Fill start value
+ * @param bufPtr   Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int free_2D(pixels_t width, pixels_t height, pixel_fmt_t fmt, bytes_t stride,
+            uint16_t val, void *bufPtr)
+{
+    MemAllocBlock block;
+    memset(&block, 0, sizeof(block));
+
+    block.pixelFormat = fmt;
+    block.dim.area.width  = width;
+    block.dim.area.height = height;
+    block.stride = def_stride(width * def_bpp(fmt));
+    block.ptr = bufPtr;
+
+    int ret = A_I(check_mem(val, &block),==,0);
+    ERR_ADD(ret, MemMgr_Free(bufPtr));
+    return ret;
+}
+
+/**
+ * This method allocates an NV12 tiled buffer of the given width
+ * and height using MemMgr_Alloc. If successful, it checks that
+ * the block informations were updated with the pointers to the
+ * individual blocks. Additionally, it verifies the correct
+ * return values for MemMgr_IsMapped, MemMgr_Is1DBlock,
+ * MemMgr_Is2DBlock, MemMgr_GetStride, TilerMem_GetStride for
+ * both blocks. It also verifies TilerMem_VirtToPhys using an
+ * internally stored values of the ssptr. If any of these
+ * verifications fail, the buffer is freed.  Otherwise, it is
+ * filled using the given start value.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width    Buffer width
+ * @param height   Buffer height
+ * @param val      Fill start value
+ *
+ * @return pointer to the allocated buffer, or NULL on failure
+ */
+void *alloc_NV12(pixels_t width, pixels_t height, uint16_t val)
+{
+    MemAllocBlock blocks[2];
+    ZERO(blocks);
+
+    blocks[0].pixelFormat = PIXEL_FMT_8BIT;
+    blocks[0].dim.area.width  = width;
+    blocks[0].dim.area.height = height;
+    blocks[1].pixelFormat = PIXEL_FMT_16BIT;
+    blocks[1].dim.area.width  = width >> 1;
+    blocks[1].dim.area.height = height >> 1;
+
+    void *bufPtr = MemMgr_Alloc(blocks, 2);
+    CHK_P(blocks[0].ptr,==,bufPtr);
+    if (bufPtr) {
+        void *buf2 = bufPtr + blocks[0].stride * height;
+        if (NOT_P(blocks[1].ptr,==,buf2) ||
+            NOT_I(MemMgr_IsMapped(bufPtr),!=,0) ||
+            NOT_I(MemMgr_IsMapped(buf2),!=,0) ||
+            NOT_I(MemMgr_Is1DBlock(bufPtr),==,0) ||
+            NOT_I(MemMgr_Is1DBlock(buf2),==,0) ||
+            NOT_I(MemMgr_Is2DBlock(bufPtr),!=,0) ||
+            NOT_I(MemMgr_Is2DBlock(buf2),!=,0) ||
+            NOT_I(blocks[0].stride,!=,0) ||
+            NOT_I(blocks[1].stride,!=,0) ||
+            NOT_I(MemMgr_GetStride(bufPtr),==,blocks[0].stride) ||
+            NOT_I(MemMgr_GetStride(buf2),==,blocks[1].stride) ||
+            NOT_P(TilerMem_VirtToPhys(bufPtr),==,blocks[0].reserved) ||
+            NOT_P(TilerMem_VirtToPhys(buf2),==,blocks[1].reserved) ||
+            NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(bufPtr)),==,TILER_STRIDE_8BIT) ||
+            NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(buf2)),==,TILER_STRIDE_16BIT) ||
+            NOT_L((PAGE_SIZE - 1) & (long)blocks[0].ptr,==,(PAGE_SIZE - 1) & blocks[0].reserved) ||
+            NOT_L((PAGE_SIZE - 1) & (long)blocks[1].ptr,==,(PAGE_SIZE - 1) & blocks[1].reserved))
+        {
+            MemMgr_Free(bufPtr);
+            return NULL;
+        }
+
+        fill_mem(val, blocks);
+        fill_mem(val, blocks + 1);
+    } else {
+        CHK_P(blocks[1].ptr,==,NULL);
+    }
+
+    return bufPtr;
+}
+
+/**
+ * This method frees an NV12 tiled buffer.  The given width,
+ * height and start values are used to verify that the buffer is
+ * still correctly filled.  In the event of any errors, the
+ * error value is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width    Buffer width
+ * @param height   Buffer height
+ * @param val      Fill start value
+ * @param bufPtr   Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int free_NV12(pixels_t width, pixels_t height, uint16_t val, void *bufPtr)
+{
+    MemAllocBlock blocks[2];
+    memset(blocks, 0, sizeof(blocks));
+
+    blocks[0].pixelFormat = PIXEL_FMT_8BIT;
+    blocks[0].dim.area.width  = width;
+    blocks[0].dim.area.height = height;
+    blocks[0].stride = def_stride(width);
+    blocks[0].ptr = bufPtr;
+    blocks[1].pixelFormat = PIXEL_FMT_16BIT;
+    blocks[1].dim.area.width  = width >> 1;
+    blocks[1].dim.area.height = height >> 1;
+    blocks[1].stride = def_stride(width);
+    blocks[1].ptr = bufPtr + blocks[0].stride * height;
+
+    int ret = A_I(check_mem(val, blocks),==,0);
+    ERR_ADD(ret, check_mem(val, blocks + 1));
+    ERR_ADD(ret, MemMgr_Free(bufPtr));
+    return ret;
+}
+
+/**
+ * This method maps a preallocated 1D buffer of the given length
+ * and stride into tiler space using MemMgr_Map.  The mapped
+ * address must differ from the supplied address is successful.
+ * Moreover, it checks that the block information was
+ * updated with the pointer to the block. Additionally, it
+ * verifies the correct return values for MemMgr_IsMapped,
+ * MemMgr_Is1DBlock, MemMgr_Is2DBlock, MemMgr_GetStride,
+ * TilerMem_GetStride.  It also verifies TilerMem_VirtToPhys
+ * using an internally stored value of the ssptr. If any of
+ * these verifications fail, the buffer is unmapped. Otherwise,
+ * the original buffer is filled using the given start value.
+ *
+ * :TODO: how do we verify the mapping?
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param dataPtr  Pointer to the allocated buffer
+ * @param length   Buffer length
+ * @param stride   Buffer stride
+ * @param val      Fill start value
+ *
+ * @return pointer to the mapped buffer, or NULL on failure
+ */
+void *map_1D(void *dataPtr, bytes_t length, bytes_t stride, uint16_t val)
+{
+    MemAllocBlock block;
+    memset(&block, 0, sizeof(block));
+
+    block.pixelFormat = PIXEL_FMT_PAGE;
+    block.dim.len = length;
+    block.stride = stride;
+    block.ptr    = dataPtr;
+
+    void *bufPtr = MemMgr_Map(&block, 1);
+    CHK_P(bufPtr,==,block.ptr);
+    if (bufPtr) {
+        if (NOT_P(bufPtr,!=,dataPtr) ||
+            NOT_I(MemMgr_IsMapped(bufPtr),!=,0) ||
+            NOT_I(MemMgr_Is1DBlock(bufPtr),!=,0) ||
+            NOT_I(MemMgr_Is2DBlock(bufPtr),==,0) ||
+            NOT_I(MemMgr_GetStride(bufPtr),==,block.stride) ||
+            NOT_P(TilerMem_VirtToPhys(bufPtr),==,block.reserved) ||
+            NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(bufPtr)),==,PAGE_SIZE) ||
+            NOT_L((PAGE_SIZE - 1) & (long)bufPtr,==,0) ||
+            NOT_L((PAGE_SIZE - 1) & block.reserved,==,0))
+        {
+            MemMgr_UnMap(bufPtr);
+            return NULL;
+        }
+        block.ptr = dataPtr;
+        fill_mem(val, &block);
+    }
+    return bufPtr;
+}
+
+/**
+ * This method unmaps a 1D tiled buffer.  The given data
+ * pointer, length, stride and start values are used to verify
+ * that the buffer is still correctly filled.  In the event of
+ * any errors, the error value is returned.
+ *
+ * :TODO: how do we verify the mapping?
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param dataPtr  Pointer to the preallocated buffer
+ * @param length   Buffer length
+ * @param stride   Buffer stride
+ * @param val      Fill start value
+ * @param bufPtr   Pointer to the mapped buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int unmap_1D(void *dataPtr, bytes_t length, bytes_t stride, uint16_t val, void *bufPtr)
+{
+    MemAllocBlock block;
+    memset(&block, 0, sizeof(block));
+
+    block.pixelFormat = PIXEL_FMT_PAGE;
+    block.dim.len = length;
+    block.stride = stride;
+    block.ptr = dataPtr;
+    int ret = A_I(check_mem(val, &block),==,0);
+    ERR_ADD(ret, MemMgr_UnMap(bufPtr));
+    return ret;
+}
+
+/**
+ * Tests the MemMgr_PageSize method.
+ *
+ * @author a0194118 (9/15/2009)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+int page_size_test()
+{
+    return NOT_I(MemMgr_PageSize(),==,PAGE_SIZE);
+}
+
+/**
+ * This method tests the allocation and freeing of a 1D tiled
+ * buffer.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length   Buffer length
+ * @param stride   Buffer stride
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int alloc_1D_test(bytes_t length, bytes_t stride)
+{
+    printf("Allocate & Free %ub 1D buffer\n", length);
+
+    uint16_t val = (uint16_t) rand();
+    void *ptr = alloc_1D(length, stride, val);
+    if (!ptr) return 1;
+    int res = free_1D(length, stride, val, ptr);
+    return res;
+}
+
+/**
+ * This method tests the allocation and freeing of a 2D tiled
+ * buffer.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width    Buffer width
+ * @param height   Buffer height
+ * @param fmt      Pixel format
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int alloc_2D_test(pixels_t width, pixels_t height, pixel_fmt_t fmt)
+{
+    printf("Allocate & Free %ux%ux%ub 1D buffer\n", width, height, def_bpp(fmt));
+
+    uint16_t val = (uint16_t) rand();
+    void *ptr = alloc_2D(width, height, fmt, 0, val);
+    if (!ptr) return 1;
+    int res = free_2D(width, height, fmt, 0, val, ptr);
+    return res;
+}
+
+/**
+ * This method tests the allocation and freeing of an NV12 tiled
+ * buffer.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width    Buffer width
+ * @param height   Buffer height
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int alloc_NV12_test(pixels_t width, pixels_t height)
+{
+    printf("Allocate & Free %ux%u NV12 buffer\n", width, height);
+
+    uint16_t val = (uint16_t) rand();
+    void *ptr = alloc_NV12(width, height, val);
+    if (!ptr) return 1;
+    int res = free_NV12(width, height, val, ptr);
+    return res;
+}
+
+/**
+ * This method tests the mapping and unmapping of a 1D buffer.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length   Buffer length
+ * @param stride   Buffer stride
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int map_1D_test(bytes_t length, bytes_t stride)
+{
+    length = (length + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1);
+    printf("Mapping and UnMapping 0x%xb 1D buffer\n", length);
+
+#ifdef __MAP_OK__
+    /* allocate aligned buffer */
+    void *buffer = malloc(length + PAGE_SIZE - 1);
+    void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+    uint16_t val = (uint16_t) rand();
+    void *ptr = map_1D(dataPtr, length, stride, val);
+    if (!ptr) return 1;
+    int res = unmap_1D(dataPtr, length, stride, val, ptr);
+    FREE(buffer);
+#else
+    int res = TESTERR_NOTIMPLEMENTED;
+#endif
+    return res;
+}
+
+/**
+ * This method tests the allocation and freeing of a number of
+ * 1D tiled buffers (up to MAX_ALLOCS)
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length   Buffer length
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int maxalloc_1D_test(bytes_t length, int max_allocs)
+{
+    printf("Allocate & Free max # of %ub 1D buffers\n", length);
+
+    struct data {
+        uint16_t val;
+        void    *bufPtr;
+    } *mem;
+
+    /* allocate as many buffers as we can */
+    mem = NEWN(struct data, max_allocs);
+    void *ptr = (void *)mem;
+    int ix, res = 0;
+    for (ix = 0; ptr && ix < max_allocs;)
+    {
+        uint16_t val = (uint16_t) rand();
+        ptr = alloc_1D(length, 0, val);
+        if (ptr)
+        {
+            mem[ix].val = val;
+            mem[ix].bufPtr = ptr;
+            ix++;
+        }
+    }
+
+    P(":: Allocated %d buffers", ix);
+
+    while (ix--)
+    {
+        ERR_ADD(res, free_1D(length, 0, mem[ix].val, mem[ix].bufPtr));
+    }
+    FREE(mem);
+    return res;
+}
+
+/**
+ * This method tests the allocation and freeing of a number of
+ * 2D tiled buffers (up to MAX_ALLOCS)
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width    Buffer width
+ * @param height   Buffer height
+ * @param fmt      Pixel format
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int maxalloc_2D_test(pixels_t width, pixels_t height, pixel_fmt_t fmt, int max_allocs)
+{
+    printf("Allocate & Free max # of %ux%ux%ub 1D buffers\n", width, height, def_bpp(fmt));
+
+    struct data {
+        uint16_t  val;
+        void     *bufPtr;
+    } *mem;
+
+    /* allocate as many buffers as we can */
+    mem = NEWN(struct data, max_allocs);
+    void *ptr = (void *)mem;
+    int ix, res = 0;
+    for (ix = 0; ptr && ix < max_allocs;)
+    {
+        uint16_t val = (uint16_t) rand();
+        ptr = alloc_2D(width, height, fmt, 0, val);
+        if (ptr)
+        {
+            mem[ix].val = val;
+            mem[ix].bufPtr = ptr;
+            ix++;
+        }
+    }
+
+    P(":: Allocated %d buffers", ix);
+
+    while (ix--)
+    {
+        ERR_ADD(res, free_2D(width, height, fmt, 0, mem[ix].val, mem[ix].bufPtr));
+    }
+    FREE(mem);
+    return res;
+}
+
+/**
+ * This method tests the allocation and freeing of a number of
+ * NV12 tiled buffers (up to MAX_ALLOCS)
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width    Buffer width
+ * @param height   Buffer height
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int maxalloc_NV12_test(pixels_t width, pixels_t height, int max_allocs)
+{
+    printf("Allocate & Free max # of %ux%u NV12 buffers\n", width, height);
+
+    struct data {
+        uint16_t     val;
+        void        *bufPtr;
+    } *mem;
+
+    /* allocate as many buffers as we can */
+    mem = NEWN(struct data, max_allocs);
+    void *ptr = (void *)mem;
+    int ix, res = 0;
+    for (ix = 0; ptr && ix < max_allocs;)
+    {
+        uint16_t val = (uint16_t) rand();
+        ptr = alloc_NV12(width, height, val);
+        if (ptr)
+        {
+            mem[ix].val = val;
+            mem[ix].bufPtr = ptr;
+            ix++;
+        }
+    }
+
+    P(":: Allocated %d buffers", ix);
+
+    while (ix--)
+    {
+        ERR_ADD(res, free_NV12(width, height, mem[ix].val, mem[ix].bufPtr));
+    }
+    FREE(mem);
+    return res;
+}
+
+/**
+ * This method tests the mapping and unnapping of a number of
+ * 1D buffers (up to MAX_ALLOCS)
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length   Buffer length
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int maxmap_1D_test(bytes_t length, int max_maps)
+{
+    length = (length + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1);
+    printf("Map & UnMap max # of %xb 1D buffers\n", length);
+
+#ifdef __MAP_OK__
+    struct data {
+        uint16_t val;
+        void    *bufPtr, *buffer, *dataPtr;
+    } *mem;
+
+    /* map as many buffers as we can */
+    mem = NEWN(struct data, max_maps);
+    void *ptr = (void *)mem;
+    int ix, res = 0;
+    for (ix = 0; ptr && ix < max_maps;)
+    {
+        /* allocate aligned buffer */
+        ptr = malloc(length + PAGE_SIZE - 1);
+        if (ptr)
+        {
+            void *buffer = ptr;
+            void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+            uint16_t val = (uint16_t) rand();
+            ptr = map_1D(dataPtr, length, 0, val);
+            if (ptr)
+            {
+                mem[ix].val = val;
+                mem[ix].bufPtr = ptr;
+                mem[ix].buffer = buffer;
+                mem[ix].dataPtr = dataPtr;
+                ix++;
+            }
+            else
+            {
+                FREE(buffer);
+                break;
+            }
+        }
+    }
+
+    P(":: Mapped %d buffers", ix);
+
+    while (ix--)
+    {
+        ERR_ADD(res, unmap_1D(mem[ix].dataPtr, length, 0, mem[ix].val, mem[ix].bufPtr));
+        FREE(mem[ix].buffer);
+    }
+#else
+    int res = TESTERR_NOTIMPLEMENTED;
+#endif
+    return res;
+}
+
+/**
+ * This stress tests allocates/maps/frees/unmaps buffers at
+ * least num_ops times.  The test maintains a set of slots that
+ * are initially NULL.  For each operation, a slot is randomly
+ * selected.  If the slot is not used, it is filled randomly
+ * with a 1D, 2D, NV12 or mapped buffer.  If it is used, the
+ * slot is cleared by freeing/unmapping the buffer already
+ * there.  The buffers are filled on alloc/map and this is
+ * checked on free/unmap to verify that there was no memory
+ * corruption.  Failed allocation and maps are ignored as we may
+ * run out of memory.  The return value is the first error code
+ * encountered, or 0 on success.
+ *
+ * This test sets the seed so that it produces reproducible
+ * results.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param num_ops    Number of operations to perform
+ * @param num_slots  Number of slots to maintain
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int star_test(uint32_t num_ops, uint16_t num_slots)
+{
+    printf("Random set of %d Allocs/Maps and Frees/UnMaps for %d slots\n", num_ops, num_slots);
+    srand(0x4B72316A);
+    struct data {
+        int      op;
+        uint16_t val;
+        pixels_t width, height;
+        bytes_t  length;
+        void    *bufPtr;
+        void    *buffer;
+        void    *dataPtr;
+    } *mem;
+
+    /* allocate memory state */
+    mem = NEWN(struct data, num_slots);
+    if (!mem) return NOT_P(mem,!=,NULL);
+
+    /* perform alloc/free/unmaps */
+    int res = 0, ix;
+    while (!res && num_ops--)
+    {
+        ix = rand() % num_slots;
+        /* see if we need to free/unmap data */
+        if (mem[ix].bufPtr)
+        {
+            /* check memory fill */
+            switch (mem[ix].op)
+            {
+            case 0: res = unmap_1D(mem[ix].dataPtr, mem[ix].length, 0, mem[ix].val, mem[ix].bufPtr);
+                FREE(mem[ix].buffer);
+                break;
+            case 1: res = free_1D(mem[ix].length, 0, mem[ix].val, mem[ix].bufPtr); break;
+            case 2: res = free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_8BIT, 0, mem[ix].val, mem[ix].bufPtr); break;
+            case 3: res = free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_16BIT, 0, mem[ix].val, mem[ix].bufPtr); break;
+            case 4: res = free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_32BIT, 0, mem[ix].val, mem[ix].bufPtr); break;
+            case 5: res = free_NV12(mem[ix].width, mem[ix].height, mem[ix].val, mem[ix].bufPtr); break;
+            }
+            P("%s[%p]", mem[ix].op ? "free" : "unmap", mem[ix].bufPtr);
+            ZERO(mem[ix]);
+        }
+        /* we need to allocate/map data */
+        else
+        {
+            int op = rand();
+            /* set width */
+            pixels_t width, height;
+            switch ("AAAABBBBCCCDDEEF"[op & 15]) {
+            case 'F': width = 1920; height = 1080; break;
+            case 'E': width = 1280; height = 720; break;
+            case 'D': width = 640; height = 480; break;
+            case 'C': width = 848; height = 480; break;
+            case 'B': width = 176; height = 144; break;
+            case 'A': width = height = 64; break;
+            }
+            mem[ix].length = (bytes_t)width * height;
+            mem[ix].width = width;
+            mem[ix].height = height;
+            mem[ix].val = ((uint16_t)rand());
+
+            /* perform operation */
+            mem[ix].op = "AAABBBBCCCCDDDDE"[(op >> 4) & 15] - 'A';
+            switch (mem[ix].op)
+            {
+            case 0: /* map 1D buffer */
+#ifdef __MAP_OK__
+                /* allocate aligned buffer */
+                mem[ix].length = (mem[ix].length + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1);
+                mem[ix].buffer = malloc(mem[ix].length + PAGE_SIZE - 1);
+                if (mem[ix].buffer)
+                {
+                    mem[ix].dataPtr = (void *)(((uint32_t)mem[ix].buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+                    mem[ix].bufPtr = map_1D(mem[ix].dataPtr, mem[ix].length, 0, mem[ix].val);
+                    if (!mem[ix].bufPtr) FREE(mem[ix].buffer);
+                }
+                P("map[l=0x%x] = %p", mem[ix].length, mem[ix].bufPtr);
+                break;
+#else
+                mem[ix].op = 1;
+#endif
+            case 1:
+                mem[ix].bufPtr = alloc_1D(mem[ix].length, 0, mem[ix].val);
+                P("alloc[l=0x%x] = %p", mem[ix].length, mem[ix].bufPtr);
+                break;
+            case 2:
+                mem[ix].bufPtr = alloc_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_8BIT, 0, mem[ix].val);
+                P("alloc[%d*%d*8] = %p", mem[ix].width, mem[ix].height, mem[ix].bufPtr);
+                break;
+            case 3:
+                mem[ix].bufPtr = alloc_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_16BIT, 0, mem[ix].val);
+                P("alloc[%d*%d*16] = %p", mem[ix].width, mem[ix].height, mem[ix].bufPtr);
+                break;
+            case 4:
+                mem[ix].bufPtr = alloc_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_32BIT, 0, mem[ix].val);
+                P("alloc[%d*%d*32] = %p", mem[ix].width, mem[ix].height, mem[ix].bufPtr);
+                break;
+            case 5:
+                mem[ix].bufPtr = alloc_NV12(mem[ix].width, mem[ix].height, mem[ix].val);
+                P("alloc[%d*%d*NV12] = %p", mem[ix].width, mem[ix].height, mem[ix].bufPtr);
+                break;
+            }
+
+            /* check all previous buffers */
+#ifdef STAR_TRACE_MEM
+            for (ix = 0; ix < num_slots; ix++)
+            {
+                MemAllocBlock blk;
+                if (mem[ix].bufPtr)
+                {
+                    if(0) P("ptr=%p, op=%d, w=%d, h=%d, l=%x, val=%x",
+                      mem[ix].bufPtr, mem[ix].op, mem[ix].width, mem[ix].height,
+                      mem[ix].length, mem[ix].val);
+                    switch (mem[ix].op)
+                    {
+                    case 0: case 1:
+                        blk.pixelFormat = PIXEL_FMT_PAGE;
+                        blk.dim.len = mem[ix].length;
+                        break;
+                    case 5:
+                        blk.pixelFormat = PIXEL_FMT_16BIT;
+                        blk.dim.area.width = mem[ix].width >> 1;
+                        blk.dim.area.height = mem[ix].height >> 1;
+                        blk.stride = def_stride(mem[ix].width);  /* same for Y and UV */
+                        blk.ptr = mem[ix].bufPtr + mem[ix].height * blk.stride;
+                        check_mem(mem[ix].val, &blk);
+                    case 2:
+                        blk.pixelFormat = PIXEL_FMT_8BIT;
+                        blk.dim.area.width = mem[ix].width;
+                        blk.dim.area.height = mem[ix].height;
+                        blk.stride = def_stride(mem[ix].width);
+                        break;
+                    case 3:
+                        blk.pixelFormat = PIXEL_FMT_16BIT;
+                        blk.dim.area.width = mem[ix].width;
+                        blk.dim.area.height = mem[ix].height;
+                        blk.stride = def_stride(mem[ix].width * 2);
+                        break;
+                    case 4:
+                        blk.pixelFormat = PIXEL_FMT_32BIT;
+                        blk.dim.area.width = mem[ix].width;
+                        blk.dim.area.height = mem[ix].height;
+                        blk.stride = def_stride(mem[ix].width * 4);
+                        break;
+                    }
+                    blk.ptr = mem[ix].bufPtr;
+                    check_mem(mem[ix].val, &blk);
+                }
+            }
+#endif
+        }
+    }
+
+    /* unmap and free everything */
+    for (ix = 0; ix < num_slots; ix++)
+    {
+        if (mem[ix].bufPtr)
+        {
+            /* check memory fill */
+            switch (mem[ix].op)
+            {
+            case 0: ERR_ADD(res, unmap_1D(mem[ix].dataPtr, mem[ix].length, 0, mem[ix].val, mem[ix].bufPtr));
+                FREE(mem[ix].buffer);
+                break;
+            case 1: ERR_ADD(res, free_1D(mem[ix].length, 0, mem[ix].val, mem[ix].bufPtr)); break;
+            case 2: ERR_ADD(res, free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_8BIT, 0, mem[ix].val, mem[ix].bufPtr)); break;
+            case 3: ERR_ADD(res, free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_16BIT, 0, mem[ix].val, mem[ix].bufPtr)); break;
+            case 4: ERR_ADD(res, free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_32BIT, 0, mem[ix].val, mem[ix].bufPtr)); break;
+            case 5: ERR_ADD(res, free_NV12(mem[ix].width, mem[ix].height, mem[ix].val, mem[ix].bufPtr)); break;
+            }
+        }
+    }
+    FREE(mem);
+
+    return res;
+}
+
+/**
+ * This stress tests allocates/maps/frees/unmaps buffers at
+ * least num_ops times.  The test maintains a set of slots that
+ * are initially NULL.  For each operation, a slot is randomly
+ * selected.  If the slot is not used, it is filled randomly
+ * with a 1D, 2D, NV12 or mapped buffer.  If it is used, the
+ * slot is cleared by freeing/unmapping the buffer already
+ * there.  The buffers are filled on alloc/map and this is
+ * checked on free/unmap to verify that there was no memory
+ * corruption.  Failed allocation and maps are ignored as we may
+ * run out of memory.  The return value is the first error code
+ * encountered, or 0 on success.
+ *
+ * This test sets the seed so that it produces reproducible
+ * results.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param num_ops    Number of operations to perform
+ * @param num_slots  Number of slots to maintain
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int star_tiler_test(uint32_t num_ops, uint16_t num_slots)
+{
+    printf("Random set of %d tiler Allocs/Maps and Frees/UnMaps for %d slots\n", num_ops, num_slots);
+    srand(0x4B72316A);
+    struct data {
+        int      op;
+        struct tiler_block_info blk;
+        void    *buffer;
+    } *mem;
+
+    /* allocate memory state */
+    mem = NEWN(struct data, num_slots);
+    if (!mem) return NOT_P(mem,!=,NULL);
+
+    /* perform alloc/free/unmaps */
+    int ix, td = A_S(open("/dev/tiler", O_RDWR),>=,0), res = td < 0 ? td : 0;
+    while (!res && num_ops--)
+    {
+        ix = rand() % num_slots;
+        /* see if we need to free/unmap data */
+        if (mem[ix].blk.id)
+        {
+            P("free [0x%x(0x%x)]", mem[ix].blk.id, mem[ix].blk.ssptr);
+            res = A_S(ioctl(td, TILIOC_FBLK, &mem[ix].blk),==,0);
+            FREE(mem[ix].buffer);
+            ZERO(mem[ix]);
+        }
+        /* we need to allocate/map data */
+        else
+        {
+            int op = rand();
+            /* set width */
+            pixels_t width, height;
+            switch ("AAAABBBBCCCDDEEF"[op & 15]) {
+            case 'F': width = 1920; height = 1080; break;
+            case 'E': width = 1280; height = 720; break;
+            case 'D': width = 640; height = 480; break;
+            case 'C': width = 848; height = 480; break;
+            case 'B': width = 176; height = 144; break;
+            case 'A': width = height = 64; break;
+            }
+            bytes_t length = (bytes_t)width * height;
+
+            /* perform operation */
+            mem[ix].op = "AAABBBBCCCCDDDDE"[(op >> 4) & 15] - 'A';
+            switch (mem[ix].op)
+            {
+            case 0: /* map 1D buffer */
+                /* allocate aligned buffer */
+                length = (length + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1);
+                mem[ix].buffer = malloc(length + PAGE_SIZE - 1);
+                if (mem[ix].buffer)
+                {
+                    mem[ix].blk.dim.len = length;
+                    mem[ix].blk.fmt = TILFMT_PAGE;
+                    mem[ix].blk.ptr = (void *)(((uint32_t)mem[ix].buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+                    res = A_S(ioctl(td, TILIOC_MBLK, &mem[ix].blk),==,0);
+                    if (res)
+                        FREE(mem[ix].buffer);
+                }
+                P("map[l=0x%x] = 0x%x(0x%x)", length, mem[ix].blk.id, mem[ix].blk.ssptr);
+                break;
+            case 1:
+                mem[ix].blk.dim.len = length;
+                mem[ix].blk.fmt = TILFMT_PAGE;
+                res = A_S(ioctl(td, TILIOC_GBLK, &mem[ix].blk),==,0);
+                P("alloc[l=0x%x] = 0x%x(0x%x)", length, mem[ix].blk.id, mem[ix].blk.ssptr);
+                break;
+            case 2: case 3: case 4:
+                mem[ix].blk.dim.area.width = width;
+                mem[ix].blk.dim.area.height = height;
+                mem[ix].blk.fmt = TILFMT_8BIT + mem[ix].op - 2;
+                res = A_S(ioctl(td, TILIOC_GBLK, &mem[ix].blk),==,0);
+                P("alloc[%d*%d*%d] = 0x%x(0x%x)", width, height, 8 << (mem[ix].op -2), mem[ix].blk.id, mem[ix].blk.ssptr);
+                break;
+            }
+        }
+    }
+
+    /* unmap and free everything */
+    for (ix = 0; ix < num_slots; ix++)
+    {
+        if (mem[ix].blk.id)
+        {
+            res = A_S(ioctl(td, TILIOC_FBLK, &mem[ix].blk),==,0);
+            FREE(mem[ix].buffer);
+        }
+    }
+    ERR_ADD_S(res, close(td));
+    FREE(mem);
+
+    return res;
+}
+
+#define NEGA(exp) ({ void *__ptr__ = A_P(exp,==,NULL); if (__ptr__) MemMgr_Free(__ptr__); __ptr__ != NULL; })
+
+/**
+ * Performs negative tests for MemMgr_Alloc.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_alloc_tests()
+{
+    printf("Negative Alloc tests\n");
+
+    MemAllocBlock block[2], *blk;
+    memset(&block, 0, sizeof(block));
+
+    int ret = 0, num_blocks;
+
+    for (num_blocks = 1; num_blocks < 3; num_blocks++)
+    {
+        blk = block + num_blocks - 1;
+
+        P("/* bad pixel format */");
+        blk->pixelFormat = PIXEL_FMT_MIN - 1;
+        blk->dim.len = PAGE_SIZE;
+        ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+        blk->pixelFormat = PIXEL_FMT_MAX + 1;
+        ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+        P("/* bad 1D stride */");
+        blk->pixelFormat = PIXEL_FMT_PAGE;
+        blk->stride = PAGE_SIZE - 1;
+        ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+        P("/* 0 1D length */");
+        blk->dim.len = blk->stride = 0;
+        ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+        P("/* bad 2D stride */");
+        blk->pixelFormat = PIXEL_FMT_8BIT;
+        blk->dim.area.width = PAGE_SIZE - 1;
+        blk->stride = PAGE_SIZE - 1;
+        blk->dim.area.height = 16;
+        ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+        P("/* bad 2D width */");
+        blk->stride = blk->dim.area.width = 0;
+        ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+        P("/* bad 2D height */");
+        blk->dim.area.height = 0;
+        blk->dim.area.width = 16;
+        ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+        /* good 2D block */
+        blk->dim.area.height = 16;
+    }
+
+    block[0].pixelFormat = block[1].pixelFormat = PIXEL_FMT_8BIT;
+    block[0].dim.area.width = 16384;
+    block[0].dim.area.height = block[1].dim.area.width = 16;
+    block[1].dim.area.height = 8192;
+    ret |= NEGA(MemMgr_Alloc(block, 2));
+
+    return ret;
+}
+
+/**
+ * Performs negative tests for MemMgr_Free.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_free_tests()
+{
+    printf("Negative Free tests\n");
+
+    void *ptr = alloc_2D(2500, 10, PIXEL_FMT_16BIT, 2 * PAGE_SIZE, 0);
+    int ret = 0;
+
+    MemMgr_Free(ptr);
+
+    P("/* free something twice */");
+    ret |= NOT_I(MemMgr_Free(ptr),!=,0);
+
+    P("/* free NULL */");
+    ret |= NOT_I(MemMgr_Free(NULL),!=,0);
+
+    P("/* free arbitrary value */");
+    ret |= NOT_I(MemMgr_Free((void *)0x12345678),!=,0);
+
+    P("/* free mapped buffer */");
+    void *buffer = malloc(PAGE_SIZE * 2);
+    void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+    ptr = map_1D(dataPtr, PAGE_SIZE, 0, 0);
+    ret |= NOT_I(MemMgr_Free(ptr),!=,0);
+
+    MemMgr_UnMap(ptr);
+
+    return ret;
+}
+
+#define NEGM(exp) ({ void *__ptr__ = A_P(exp,==,NULL); if (__ptr__) MemMgr_UnMap(__ptr__); __ptr__ != NULL; })
+
+/**
+ * Performs negative tests for MemMgr_Map.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_map_tests()
+{
+    printf("Negative Map tests\n");
+
+    MemAllocBlock block[2], *blk;
+    memset(&block, 0, sizeof(block));
+
+    int ret = 0, num_blocks;
+
+    for (num_blocks = 1; num_blocks < 3; num_blocks++)
+    {
+        blk = block + num_blocks - 1;
+
+        P("/* bad pixel format */");
+        blk->pixelFormat = PIXEL_FMT_MIN - 1;
+        blk->dim.len = PAGE_SIZE;
+        ret |= NEGM(MemMgr_Map(block, num_blocks));
+        blk->pixelFormat = PIXEL_FMT_MAX + 1;
+        ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+        P("/* bad 1D stride */");
+        blk->pixelFormat = PIXEL_FMT_PAGE;
+        blk->stride = PAGE_SIZE - 1;
+        ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+        P("/* 0 1D length */");
+        blk->dim.len = blk->stride = 0;
+        ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+        P("/* bad 2D stride */");
+        blk->pixelFormat = PIXEL_FMT_8BIT;
+        blk->dim.area.width = PAGE_SIZE - 1;
+        blk->stride = PAGE_SIZE - 1;
+        blk->dim.area.height = 16;
+        ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+        P("/* bad 2D width */");
+        blk->stride = blk->dim.area.width = 0;
+        ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+        P("/* bad 2D height */");
+        blk->dim.area.height = 0;
+        blk->dim.area.width = 16;
+        ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+        /* good 2D block */
+        blk->dim.area.height = 16;
+    }
+
+    P("/* 2 buffers */");
+    ret |= NEGM(MemMgr_Map(block, 2));
+
+    P("/* 1 2D buffer */");
+    ret |= NEGM(MemMgr_Map(block, 1));
+
+    P("/* 1 1D buffer with no address */");
+    block[0].pixelFormat = PIXEL_FMT_PAGE;
+    block[0].dim.len = 2 * PAGE_SIZE;
+    block[0].ptr = NULL;
+    ret |= NEGM(MemMgr_Map(block, 1));
+
+    P("/* 1 1D buffer with not aligned start address */");
+    void *buffer = malloc(3 * PAGE_SIZE);
+    void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+    block[0].ptr = dataPtr + 3;
+    ret |= NEGM(MemMgr_Map(block, 1));
+
+    P("/* 1 1D buffer with not aligned length */");
+    block[0].ptr = dataPtr;
+    block[0].dim.len -= 5;
+    ret |= NEGM(MemMgr_Map(block, 1));
+
+#if 0 /* TODO: it's possible that our va falls within the TILER addr range */
+    P("/* Mapping a tiled 1D buffer */");
+    void *ptr = alloc_1D(PAGE_SIZE * 2, 0, 0);
+    dataPtr = (void *)(((uint32_t)ptr + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+    block[0].ptr = dataPtr;
+    block[0].dim.len = PAGE_SIZE;
+    ret |= NEGM(MemMgr_Map(block, 1));
+
+    MemMgr_Free(ptr);
+#endif
+
+    return ret;
+}
+
+/**
+ * Performs negative tests for MemMgr_UnMap.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_unmap_tests()
+{
+    printf("Negative Unmap tests\n");
+
+    void *ptr = alloc_1D(PAGE_SIZE, 0, 0);
+    int ret = 0;
+
+    P("/* unmap alloced buffer */");
+    ret |= NOT_I(MemMgr_UnMap(ptr),!=,0);
+
+    MemMgr_Free(ptr);
+
+    void *buffer = malloc(PAGE_SIZE * 2);
+    void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+    ptr = map_1D(dataPtr, PAGE_SIZE, 0, 0);
+    MemMgr_UnMap(ptr);
+
+    P("/* unmap something twice */");
+    ret |= NOT_I(MemMgr_UnMap(ptr),!=,0);
+
+    P("/* unmap NULL */");
+    ret |= NOT_I(MemMgr_UnMap(NULL),!=,0);
+
+    P("/* unmap arbitrary value */");
+    ret |= NOT_I(MemMgr_UnMap((void *)0x12345678),!=,0);
+
+    return ret;
+}
+
+/**
+ * Performs negative tests for MemMgr_Is.. functions.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_check_tests()
+{
+    printf("Negative Is... tests\n");
+    void *ptr = malloc(32);
+
+    int ret = 0;
+
+    ret |= NOT_I(MemMgr_Is1DBlock(NULL),==,FALSE);
+    ret |= NOT_I(MemMgr_Is1DBlock((void *)0x12345678),==,FALSE);
+    ret |= NOT_I(MemMgr_Is1DBlock(ptr),==,FALSE);
+    ret |= NOT_I(MemMgr_Is2DBlock(NULL),==,FALSE);
+    ret |= NOT_I(MemMgr_Is2DBlock((void *)0x12345678),==,FALSE);
+    ret |= NOT_I(MemMgr_Is2DBlock(ptr),==,FALSE);
+    ret |= NOT_I(MemMgr_IsMapped(NULL),==,FALSE);
+    ret |= NOT_I(MemMgr_IsMapped((void *)0x12345678),==,FALSE);
+    ret |= NOT_I(MemMgr_IsMapped(ptr),==,FALSE);
+
+    ret |= NOT_I(MemMgr_GetStride(NULL),==,0);
+    ret |= NOT_I(MemMgr_GetStride((void *)0x12345678),==,0);
+    ret |= NOT_I(MemMgr_GetStride(ptr),==,PAGE_SIZE);
+
+    ret |= NOT_P(TilerMem_VirtToPhys(NULL),==,0);
+    ret |= NOT_P(TilerMem_VirtToPhys((void *)0x12345678),==,0);
+    ret |= NOT_P(TilerMem_VirtToPhys(ptr),!=,0);
+
+    ret |= NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(NULL)),==,0);
+    ret |= NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys((void *)0x12345678)),==,0);
+    ret |= NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(ptr)),==,0);
+
+    FREE(ptr);
+
+    return ret;
+}
+
+DEFINE_TESTS(TESTS)
+
+/**
+ * We run the same identity check before and after running the
+ * tests.
+ *
+ * @author a0194118 (9/12/2009)
+ */
+void memmgr_identity_test(void *ptr)
+{
+    /* also execute internal unit tests - this also verifies that we did not
+       keep any references */
+    __test__MemMgr();
+}
+
+/**
+ * Main test function. Checks arguments for test case ranges,
+ * runs tests and prints usage or test list if required.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param argc   Number of arguments
+ * @param argv   Arguments
+ *
+ * @return -1 on usage or test list, otherwise # of failed
+ *         tests.
+ */
+int main(int argc, char **argv)
+{
+    return TestLib_Run(argc, argv,
+                       memmgr_identity_test, memmgr_identity_test, NULL);
+}
+
diff --git a/tiler/testlib.c b/tiler/testlib.c
new file mode 100644
index 0000000..63d1298
--- /dev/null
+++ b/tiler/testlib.c
@@ -0,0 +1,163 @@
+/*
+ *  testlib.c
+ *
+ *  Unit test interface.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* retrieve type definitions */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "testlib.h"
+
+#include <utils.h>
+#include <debug_utils.h>
+
+#define TESTLIB_OK          0
+#define TESTLIB_FAIL        1
+
+/** Returns TRUE iff str is a whole unsigned int */
+#define is_uint(str) \
+    ({ unsigned i; char c; sscanf(str, "%u%c", &i, &c) == 1; })
+
+extern int __internal__TestLib_DoList(int id);
+
+/**
+ * Prints test result and returns summary result
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param res    Test result
+ *
+ * @return TEST_RESULT_OK on success, TEST_RESULT_FAIL on
+ *         failure, TEST_RESULT_UNAVAILABLE if test is not
+ *         available
+ */
+int __internal__TestLib_Report(int res)
+{
+    switch (res)
+    {
+        case TESTLIB_UNAVAILABLE:
+            printf("==> TEST NOT AVAILABLE\n");
+            fflush(stdout);
+            return TESTLIB_UNAVAILABLE;
+        case 0:
+            printf("==> TEST OK\n");
+            fflush(stdout);
+            return TESTLIB_OK;
+        default:
+            printf("==> TEST FAIL(%d)\n", res);
+            fflush(stdout);
+            return TESTLIB_FAIL;
+    }
+}
+
+void __internal__TestLib_NullFn(void *ptr)
+{
+}
+
+int TestLib_Run(int argc, char **argv, void(*init_fn)(void *),
+                void(*exit_fn)(void *), void *ptr)
+{
+    int start, end, res, failed = 0, succeeded = 0, unavailable = 0;
+
+    /* all tests */
+    if (argc == 1)
+    {
+        start = 1; end = -1;
+    }
+    /* test list */
+    else if (argc == 2 && !strcmp(argv[1], "list"))
+    {
+        __internal__TestLib_DoList(0);
+        return -1;
+    }
+    /* single test */
+    else if (argc == 2 && is_uint(argv[1]))
+    {
+        start = end = atoi(argv[1]);
+    }
+    /* open range .. b */
+    else if (argc == 3 && !strcmp(argv[1], "..") && is_uint(argv[2]))
+    {
+        start = 1;
+        end = atoi(argv[2]);
+    }
+    /* open range a .. */
+    else if (argc == 3 && !strcmp(argv[2], "..") && is_uint(argv[1]))
+    {
+        start = atoi(argv[1]);
+        end = -1;
+    }
+    else if (argc == 4 && !strcmp(argv[2], "..") && is_uint(argv[1]) && is_uint(argv[3]))
+    {
+        start = atoi(argv[1]);
+        end = atoi(argv[3]);
+    }
+    else
+    {
+        fprintf(stderr, "Usage: %s [<range>], where <range> is\n"
+          "   empty:   run all tests\n"
+          "   list:    list tests\n"
+          "   ix:      run test #ix\n"
+          "   a ..:    run tests #a, #a+1, ...\n"
+          "   .. b:    run tests #1, #2, .. #b\n"
+          "   a .. b:  run tests #a, #a+1, .. #b\n", argv[0]);
+        fflush(stderr);
+        return -1;
+    }
+
+    /* execute tests  */
+    init_fn(ptr);
+
+    do
+    {
+        res = __internal__TestLib_DoList(start++);
+        if (res == TESTLIB_FAIL) failed++;
+        else if (res == TESTLIB_OK) succeeded++;
+        else if (res == TESTLIB_UNAVAILABLE) unavailable++;
+        printf("so far FAILED: %d, SUCCEEDED: %d, UNAVAILABLE: %d\n", failed, succeeded,
+           unavailable);
+        fflush(stdout);
+    } while (res != TESTLIB_INVALID && (end < 0 || start <= end));
+
+    printf("FAILED: %d, SUCCEEDED: %d, UNAVAILABLE: %d\n", failed, succeeded,
+           unavailable);
+    fflush(stdout);
+
+    /* also execute internal unit tests - this also verifies that we did not
+       keep any references */
+    exit_fn(ptr);
+
+    return failed;
+}
+
diff --git a/tiler/testlib.h b/tiler/testlib.h
new file mode 100644
index 0000000..bc1a799
--- /dev/null
+++ b/tiler/testlib.h
@@ -0,0 +1,101 @@
+/*
+ *  testlib.h
+ *
+ *  Unit test interface API.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TESTLIB_H_
+#define _TESTLIB_H_
+
+/* error type definitions */
+#define TESTLIB_UNAVAILABLE -65378
+#define TESTLIB_INVALID        -1
+
+#define T(test) ++i; \
+    if (!id || i == id) printf("TEST #% 3d - %s\n", i, #test); \
+    if (i == id) { \
+        printf("TEST_DESC - "); \
+        fflush(stdout); \
+        return __internal__TestLib_Report(test); \
+    }
+
+/* test run function that must be defined from the test app */
+
+/**
+ * Runs a specified test by id, or lists all test cases.  This
+ * function uses the TESTS macros, and defines each T(test) to
+ * run a test starting from id == 1, and then return the result.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param id   Test case id, or 0 if only listing test cases
+ *
+ * @return Summary result: TEST_RESULT_OK, FAIL, INVALID or
+ *         UNAVAILABLE.
+ */
+#define TESTS_ \
+    int __internal__TestLib_DoList(int id) { int i = 0;
+
+#define _TESTS \
+    return TESTLIB_INVALID; }
+
+#define DEFINE_TESTS(TESTS) TESTS_ TESTS _TESTS
+
+/* internal function prototypes and defines */
+extern int __internal__TestLib_Report(int res);
+extern void __internal__TestLib_NullFn(void *ptr);
+
+#define nullfn __internal__TestLib_NullFn
+
+/**
+ * Parses argument list, prints usage on error, lists test
+ * cases, runs tests and reports results.
+ *
+ * @author a0194118 (9/12/2009)
+ *
+ * @param argc      Number of test arguments
+ * @param argv      Test argument array
+ * @param init_fn   Initialization function of void fn(void *).
+ *                  This is called before the testing.
+ * @param exit_fn   Deinit function of void fn(void *).  This is
+ *                  done after the testing concludes.
+ * @param ptr       Custom pointer that is passed into the
+ *                  initialization functions.
+ *
+ * @return # of test cases failed, 0 on success, -1 if no tests
+ *         were run because of an error or a list request.
+ */
+int TestLib_Run(int argc, char **argv, void(*init_fn)(void *),
+                void(*exit_fn)(void *), void *ptr);
+
+#endif
+
diff --git a/tiler/tiler.h b/tiler/tiler.h
new file mode 100644
index 0000000..8358f8d
--- /dev/null
+++ b/tiler/tiler.h
@@ -0,0 +1,105 @@
+/*
+ *  tiler.h
+ *
+ *  TILER driver support functions for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TILER_H_
+#define _TILER_H_
+
+#define TILER_MEM_8BIT  0x60000000
+#define TILER_MEM_16BIT 0x68000000
+#define TILER_MEM_32BIT 0x70000000
+#define TILER_MEM_PAGED 0x78000000
+#define TILER_MEM_END   0x80000000
+
+#define TILER_PAGE 0x1000
+#define TILER_WIDTH    256
+#define TILER_HEIGHT   128
+#define TILER_BLOCK_WIDTH  64
+#define TILER_BLOCK_HEIGHT 64
+#define TILER_LENGTH (TILER_WIDTH * TILER_HEIGHT * TILER_PAGE)
+
+#define TILER_DEVICE_PATH "/dev/tiler"
+#define TILER_MAX_NUM_BLOCKS 16
+
+enum tiler_fmt {
+	TILFMT_MIN     = -2,
+	TILFMT_INVALID = -2,
+	TILFMT_NONE    = -1,
+	TILFMT_8BIT    = 0,
+	TILFMT_16BIT   = 1,
+	TILFMT_32BIT   = 2,
+	TILFMT_PAGE    = 3,
+	TILFMT_MAX     = 3,
+	TILFMT_8AND16  = 4,
+};
+
+struct area {
+	uint16_t width;
+	uint16_t height;
+};
+
+struct tiler_block_info {
+	enum tiler_fmt fmt;
+	union {
+		struct area area;
+		uint32_t len;
+	} dim;
+	uint32_t stride;
+	void *ptr;
+	uint32_t id;
+	uint32_t key;
+	uint32_t group_id;
+	uint32_t ssptr;
+};
+
+struct tiler_buf_info {
+	uint32_t num_blocks;
+	struct tiler_block_info blocks[TILER_MAX_NUM_BLOCKS];
+	uint32_t offset;
+	uint32_t length;
+};
+
+#define TILIOC_GBLK  _IOWR('z', 100, struct tiler_block_info)
+#define TILIOC_FBLK   _IOW('z', 101, struct tiler_block_info)
+#define TILIOC_GSSP  _IOWR('z', 102, uint32_t)
+#define TILIOC_MBLK  _IOWR('z', 103, struct tiler_block_info)
+#define TILIOC_UMBLK  _IOW('z', 104, struct tiler_block_info)
+#define TILIOC_QBUF  _IOWR('z', 105, struct tiler_buf_info)
+#define TILIOC_RBUF  _IOWR('z', 106, struct tiler_buf_info)
+#define TILIOC_URBUF _IOWR('z', 107, struct tiler_buf_info)
+#define TILIOC_QBLK  _IOWR('z', 108, struct tiler_block_info)
+#define TILIOC_PRBLK  _IOW('z', 109, struct tiler_block_info)
+#define TILIOC_URBLK  _IOW('z', 110, uint32_t)
+
+#endif
diff --git a/tiler/tiler_ptest.c b/tiler/tiler_ptest.c
new file mode 100644
index 0000000..7f06940
--- /dev/null
+++ b/tiler/tiler_ptest.c
@@ -0,0 +1,729 @@
+/*
+ *  tiler_ptest.c
+ *
+ *  Memory Allocator Interface tests.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* retrieve type definitions */
+#define __DEBUG__
+#undef __DEBUG_ENTRY__
+#define __DEBUG_ASSERT__
+
+#undef __WRITE_IN_STRIDE__
+#undef STAR_TRACE_MEM
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <stdint.h>
+#include <ctype.h>
+
+#ifdef HAVE_CONFIG_H
+    #include "config.h"
+#endif
+#include <utils.h>
+#include <list_utils.h>
+#include <debug_utils.h>
+#include <memmgr.h>
+#include <tilermem.h>
+#include <tilermem_utils.h>
+#include <testlib.h>
+
+#define FALSE 0
+
+/**
+ * Returns the default page stride for this block
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param width  Width of 2D container
+ *
+ * @return Stride
+ */
+static bytes_t def_stride(pixels_t width)
+{
+    return (PAGE_SIZE - 1 + (bytes_t)width) & ~(PAGE_SIZE - 1);
+}
+
+/**
+ * Returns the bytes per pixel for the pixel format.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param pixelFormat   Pixelformat
+ *
+ * @return Bytes per pixel
+ */
+static bytes_t def_bpp(pixel_fmt_t pixelFormat)
+{
+    return (pixelFormat == PIXEL_FMT_32BIT ? 4 :
+            pixelFormat == PIXEL_FMT_16BIT ? 2 : 1);
+}
+
+enum ptr_type {
+    ptr_empty = 0,
+    ptr_alloced,
+    ptr_tiler_alloced,
+};
+
+struct ptr_info {
+	int num_blocks;
+	struct tiler_block_info blocks[TILER_MAX_NUM_BLOCKS];
+	int ptr;
+    short type;
+    uint16_t val;
+};
+
+static void dump_block(struct tiler_block_info *blk, char *prefix, char *suffix)
+{
+    switch (blk->fmt)
+    {
+    case PIXEL_FMT_PAGE:
+        P("%s [p=%p(0x%x),l=0x%x,s=%d]%s", prefix, blk->ptr, blk->ssptr,
+          blk->dim.len, blk->stride, suffix);
+        break;
+    case PIXEL_FMT_8BIT:
+    case PIXEL_FMT_16BIT:
+    case PIXEL_FMT_32BIT:
+        P("%s [p=%p(0x%x),%d*%d*%d,s=%d]%s", prefix, blk->ptr, blk->ssptr,
+          blk->dim.area.width, blk->dim.area.height, def_bpp(blk->fmt) * 8,
+          blk->stride, suffix);
+        break;
+    default:
+        P("%s*[p=%p(0x%x),l=0x%x,s=%d,fmt=0x%x]%s", prefix, blk->ptr,
+          blk->ssptr, blk->dim.len, blk->stride, blk->fmt, suffix);
+    }
+}
+
+static void dump_slot(struct ptr_info* buf, char* prefix)
+{
+    P("%sbuf={n=%d,ptr=0x%x,type=%d,", prefix, buf->num_blocks, buf->ptr,
+      buf->type);
+    int ix = 0;
+    for (ix = 0; ix < buf->num_blocks; ix++)
+    {
+        dump_block(buf->blocks + ix, "", ix + 1 == buf->num_blocks ? "}" : "");
+    }
+}
+
+/**
+ * This method fills up a range of memory using a start address
+ * and start value.  The method of filling ensures that
+ * accidentally overlapping regions have minimal chances of
+ * matching, even if the same starting value is used.  This is
+ * because the difference between successive values varies as
+ * such.  This series only repeats after 704189 values, so the
+ * probability of a match for a range of at least 2 values is
+ * less than 2*10^-11.
+ *
+ * V(i + 1) - V(i) = { 1, 2, 3, ..., 65535, 2, 4, 6, 8 ...,
+ * 65534, 3, 6, 9, 12, ..., 4, 8, 12, 16, ... }
+ *
+ * @author a0194118 (9/6/2009)
+ *
+ * @param start   start value
+ * @param block   pointer to block info strucure
+ */
+void fill_mem(uint16_t start, MemAllocBlock *block)
+{
+    IN;
+    uint16_t *ptr = (uint16_t *)block->ptr, delta = 1, step = 1;
+    bytes_t height, width, stride, i;
+    if (block->pixelFormat == PIXEL_FMT_PAGE)
+    {
+        height = 1;
+        stride = width = block->dim.len;
+    }
+    else
+    {
+        height = block->dim.area.height;
+        width = block->dim.area.width;
+        stride = block->stride;
+    }
+    width *= def_bpp(block->pixelFormat);
+    bytes_t size = height * stride;
+
+    P("(%p,0x%x*0x%x,s=0x%x)=0x%x", block->ptr, width, height, stride, start);
+
+    CHK_I(width,<=,stride);
+    uint32_t *ptr32 = (uint32_t *)ptr;
+    while (height--)
+    {
+        if (block->pixelFormat == PIXEL_FMT_32BIT)
+        {
+            for (i = 0; i < width; i += sizeof(uint32_t))
+            {
+                uint32_t val = (start & 0xFFFF) | (((uint32_t)(start + delta) & 0xFFFF) << 16);
+                *ptr32++ = val;
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+            }
+#ifdef __WRITE_IN_STRIDE__
+            while (i < stride && (height || ((PAGE_SIZE - 1) & (uint32_t)ptr32)))
+            {
+                *ptr32++ = 0;
+                i += sizeof(uint32_t);
+            }
+#else
+            ptr32 += (stride - i) / sizeof(uint32_t);
+#endif
+        }
+        else
+        {
+            for (i = 0; i < width; i += sizeof(uint16_t))
+            {
+                *ptr++ = start;
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+            }
+#ifdef __WRITE_IN_STRIDE__
+            while (i < stride && (height || ((PAGE_SIZE - 1) & (uint32_t)ptr)))
+            {
+                *ptr++ = 0;
+                i += sizeof(uint16_t);
+            }
+#else
+            ptr += (stride - i) / sizeof(uint16_t);
+#endif
+
+        }
+    }
+    CHK_P((block->pixelFormat == PIXEL_FMT_32BIT ? (void *)ptr32 : (void *)ptr),==,
+          (block->ptr + size));
+    OUT;
+}
+
+/**
+ * This verifies if a range of memory at a given address was
+ * filled up using the start value.
+ *
+ * @author a0194118 (9/6/2009)
+ *
+ * @param start   start value
+ * @param block   pointer to block info strucure
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int check_mem(uint16_t start, MemAllocBlock *block)
+{
+    IN;
+    uint16_t *ptr = (uint16_t *)block->ptr, delta = 1, step = 1;
+    bytes_t height, width, stride, r, i;
+    if (block->pixelFormat == PIXEL_FMT_PAGE)
+    {
+        height = 1;
+        stride = width = block->dim.len;
+    }
+    else
+    {
+        height = block->dim.area.height;
+        width = block->dim.area.width;
+        stride = block->stride;
+    }
+    width *= def_bpp(block->pixelFormat);
+
+    CHK_I(width,<=,stride);
+    uint32_t *ptr32 = (uint32_t *)ptr;
+    for (r = 0; r < height; r++)
+    {
+        if (block->pixelFormat == PIXEL_FMT_32BIT)
+        {
+            for (i = 0; i < width; i += sizeof(uint32_t))
+            {
+                uint32_t val = (start & 0xFFFF) | (((uint32_t)(start + delta) & 0xFFFF) << 16);
+                if (*ptr32++ != val) {
+                    DP("assert: val[%u,%u] (=0x%x) != 0x%x", r, i, *--ptr32, val);
+                    return R_I(MEMMGR_ERR_GENERIC);
+                }
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+            }
+#ifdef __WRITE_IN_STRIDE__
+            while (i < stride && ((r < height - 1) || ((PAGE_SIZE - 1) & (uint32_t)ptr32)))
+            {
+                if (*ptr32++) {
+                    DP("assert: val[%u,%u] (=0x%x) != 0", r, i, *--ptr32);
+                    return R_I(MEMMGR_ERR_GENERIC);
+                }
+                i += sizeof(uint32_t);
+            }
+#else
+            ptr32 += (stride - i) / sizeof(uint32_t);
+#endif
+        }
+        else
+        {
+            for (i = 0; i < width; i += sizeof(uint16_t))
+            {
+                if (*ptr++ != start) {
+                    DP("assert: val[%u,%u] (=0x%x) != 0x%x", r, i, *--ptr, start);
+                    return R_I(MEMMGR_ERR_GENERIC);
+                }
+                start += delta;
+                delta += step;
+                /* increase step if overflown */
+                if (delta < step) delta = ++step;
+            }
+#ifdef __WRITE_IN_STRIDE__
+            while (i < stride && ((r < height - 1) || ((PAGE_SIZE - 1) & (uint32_t)ptr)))
+            {
+                if (*ptr++) {
+                    DP("assert: val[%u,%u] (=0x%x) != 0", r, i, *--ptr);
+                    return R_I(MEMMGR_ERR_GENERIC);
+                }
+                i += sizeof(uint16_t);
+            }
+#else
+            ptr += (stride - i) / sizeof(uint16_t);
+#endif
+        }
+    }
+    return R_I(MEMMGR_ERR_NONE);
+}
+
+/**
+ * This method allocates a tiled buffer composed of an arbitrary
+ * set of tiled blocks. If successful, it checks
+ * that the block information was updated with the pointer to
+ * the block.  Additionally, it verifies the correct return
+ * values for MemMgr_IsMapped, MemMgr_Is1DBlock,
+ * MemMgr_Is2DBlock, MemMgr_GetStride, TilerMem_GetStride.  It
+ * also verifies TilerMem_VirtToPhys using an internally stored
+ * value of the ssptr. If any of these verifications fail, the
+ * buffer is freed.  Otherwise, it is filled using the given
+ * start value.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param num_blocks  Number of blocks in the buffer
+ * @param blocks      Block information
+ * @param val         Fill start value
+ * @param bufPtr      Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+void *alloc_buf(int num_blocks, MemAllocBlock blocks[], uint16_t val)
+{
+    void *bufPtr = MemMgr_Alloc(blocks, num_blocks);
+    void *ptr = bufPtr;
+    int i;
+
+    for (i = 0; i < num_blocks; i++)
+    {
+        if (bufPtr)
+        {
+            pixel_fmt_t fmt = blocks[i].pixelFormat;
+            bytes_t cstride = (fmt == PIXEL_FMT_PAGE  ? PAGE_SIZE :
+                               fmt == PIXEL_FMT_8BIT  ? TILER_STRIDE_8BIT :
+                               fmt == PIXEL_FMT_16BIT ? TILER_STRIDE_16BIT :
+                               TILER_STRIDE_32BIT);
+            if (NOT_P(blocks[i].ptr,==,ptr) ||
+                NOT_I(MemMgr_IsMapped(ptr),!=,0) ||
+                NOT_I(MemMgr_Is1DBlock(ptr),==,fmt == PIXEL_FMT_PAGE ? 1 : 0) ||
+                NOT_I(MemMgr_Is2DBlock(ptr),==,fmt == PIXEL_FMT_PAGE ? 0 : 1) ||
+                NOT_I(MemMgr_GetStride(bufPtr),==,blocks[i].stride) ||
+                NOT_P(TilerMem_VirtToPhys(ptr),==,blocks[i].reserved) ||
+                NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(ptr)),==,cstride) ||
+                NOT_L((PAGE_SIZE - 1) & (long)ptr,==,(PAGE_SIZE - 1) & blocks[i].reserved) ||
+                (fmt == PIXEL_FMT_PAGE || NOT_I(blocks[i].stride,!=,0)))
+            {
+                P("  for block %d", i);
+                MemMgr_Free(bufPtr);
+                return NULL;
+            }
+            fill_mem(val, blocks + i);
+            if (blocks[i].pixelFormat != PIXEL_FMT_PAGE)
+            {
+                ptr += def_stride(blocks[i].dim.area.width *
+                                  def_bpp(blocks[i].pixelFormat)) * blocks[i].dim.area.height;
+            }
+            else
+            {
+                ptr += def_stride(blocks[i].dim.len);
+            }
+        }
+        else
+        {
+            A_P(blocks[i].ptr,==,ptr);
+            A_I(blocks[i].reserved,==,0);
+        }
+    }
+    return bufPtr;
+}
+
+/**
+ * This method frees a tiled buffer composed of an arbitrary set
+ * of tiled blocks. The given start value is used to verify that
+ * the buffer is still correctly filled.  In the event of any
+ * errors, the error value is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param num_blocks  Number of blocks in the buffer
+ * @param blocks      Block information
+ * @param val         Fill start value
+ * @param bufPtr      Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int free_buf(int num_blocks, MemAllocBlock blocks[], uint16_t val, void *bufPtr)
+{
+    MemAllocBlock blk;
+    void *ptr = bufPtr;
+    int ret = 0, i;
+    for (i = 0; i < num_blocks; i++)
+    {
+        blk = blocks[i];
+        blk.ptr = ptr;
+        ERR_ADD(ret, check_mem(val, &blk));
+        if (blk.pixelFormat != PIXEL_FMT_PAGE)
+        {
+            ptr += def_stride(blk.dim.area.width *
+                              def_bpp(blk.pixelFormat)) * blk.dim.area.height;
+        }
+        else
+        {
+            ptr += def_stride(blk.dim.len);
+        }
+        blk.reserved = 0;
+    }
+
+    ERR_ADD(ret, MemMgr_Free(bufPtr));
+    return ret;
+}
+
+#if 0
+struct slot {
+    int      op;
+    SSPtr    ssptr;
+    void    *buffer;
+    void    *dataPtr;
+} *slots = NULL;
+
+enum op_enum {
+    op_map_1d,
+    op_alloc_1d,
+    op_alloc_8,
+    op_alloc_16,
+    op_alloc_32,
+    op_alloc_nv12,
+    op_alloc_gen,
+};
+
+static int free_slot(int ix)
+{
+    if (slots[ix].bufPtr)
+    {
+        /* check memory fill */
+        switch (slots[ix].op)
+        {
+        case op_map_1d:
+            res = unmap_1D(slot[ix].dataPtr, slot[ix].length, 0, slot[ix].val, slot[ix].bufPtr);
+            FREE(mem[ix].buffer);
+            break;
+        case op_alloc_1d:
+            res = free_1D(slot[ix].length, 0, slot[ix].val, mem[ix].bufPtr);
+            break;
+        case op_alloc_8:
+            res = free_2D(slot[ix].width, slot[ix].height, PIXEL_FMT_8BIT, 0, slot[ix].val, slot[ix].bufPtr);
+            break;
+        case op_alloc_16:
+            res = free_2D(slot[ix].width, slot[ix].height, PIXEL_FMT_16BIT, 0, slot[ix].val, slot[ix].bufPtr);
+            break;
+        case op_alloc_32:
+            res = free_2D(slot[ix].width, slot[ix].height, PIXEL_FMT_32BIT, 0, slot[ix].val, slot[ix].bufPtr);
+            break;
+        case op_alloc_nv12:
+            res = free_NV12(slot[ix].width, slot[ix].height, slot[ix].val, slot[ix].bufPtr);
+            break;
+        }
+        P("%s[%p]", mem[ix].op ? "free" : "unmap", mem[ix].bufPtr);
+        ZERO(slot[ix]);
+    }
+}
+#endif
+
+#include <tilermgr.h>
+
+char *parse_num(char *p, int *tgt)
+{
+	int len;
+	if (!strncmp(p, "0x", 2)) { /* hex number */
+		if (NOT_I(sscanf(p, "0x%x%n", tgt, &len),==,1))
+			return NULL;
+		return p + len;
+	} else {
+		if (NOT_I(sscanf(p, "%d%n", tgt, &len),==,1))
+			return NULL;
+		return p + len;
+	}
+}
+
+/**
+ * Parametric memmgr test.  This is similar to the star test
+ * except the operations are read from the command line:
+ *
+ * [#=]a:w*h*bits[,w*h*bits...] allocates a list of blocks as
+ * buffer # (it frees any previously allocated/mapped buffer
+ * f:# frees a buffer
+ *
+ *
+ * @author a0194118 (11/4/2009)
+ *
+ * @param argc
+ * @param argv
+ */
+int param_test(int argc, char **argv)
+{
+    int delta_slots = 16;
+	int ix, i, n, t, type, max_n, num_slots = delta_slots;
+    struct ptr_info *slots;
+    ALLOCN(slots, num_slots);
+    if (NOT_P(slots,!=,NULL)) return 1;
+
+    int res = TilerMgr_Open();
+    for (i = 1; i < argc && !res; i++)
+	{
+        uint16_t val = (uint16_t) rand();
+
+		char *p = argv[i], *q;
+        struct ptr_info buf;
+        ZERO(buf);
+
+		/* read slot */
+        ix = -1;
+        if (isdigit(*p))
+        {
+            res = 1;
+            q = parse_num(p, &ix);
+            if (NOT_P(q,!=,NULL) || NOT_I(ix,>,0)) break;
+            p = q;
+            if (NOT_I(*p++,==,'.')) break;
+            res = 0;
+            ix--;
+        }
+
+        type = *p++;
+        /* get default slot */
+        if (ix < 0)
+        {
+            switch (type)
+            {
+            /* allocation defaults to the 1st free slot */
+            case 'a':
+            case 'A':
+                for (ix = 0; ix < num_slots && slots[ix].type; ix++);
+                break;
+
+            /* frees default to the 1st used block */
+            case 'f':
+            case 'F':
+                for (ix = 0; ix < num_slots && !slots[ix].type; ix++);
+                if (NOT_I(ix,<,num_slots)) res = 1;
+                break;
+            }
+        }
+        if (res) break;
+
+        /* allocate more slots if needed */
+        if (ix >= num_slots)
+        {
+            int more_slots = ROUND_UP_TO(ix + 1, delta_slots);
+            struct ptr_info *new_slots;
+            ALLOCN(new_slots, more_slots);
+            if (NOT_P(new_slots,!=,NULL)) break;
+            memcpy(new_slots, slots, sizeof(*slots) * num_slots);
+            FREE(slots);
+            slots = new_slots;
+            num_slots = more_slots;
+        }
+
+        /* perform opertaion */
+        res = 1;  /* assume failure */
+		switch (type)
+		{
+        case 'a': /* allocate */
+        case 'A': /* tiler-allocate */
+            switch (type)
+            {
+            case 'a': buf.type = ptr_alloced; max_n = TILER_MAX_NUM_BLOCKS; break;
+            case 'A': buf.type = ptr_tiler_alloced; max_n = 1; break;
+            }
+            if (ix < num_slots && NOT_I(slots[ix].type,==,ptr_empty)) break;
+			if (NOT_I(*p++,==,':')) break;
+            for (n = 0; *p && n < max_n; n++) {
+                /* read length or width */
+                p = parse_num(p, (int *) &buf.blocks[n].dim.len);
+                if (NOT_P(p,!=,NULL)) break;
+                if (*p == '*') { /* 2d block */
+                    buf.blocks[n].dim.area.width = (uint16_t) buf.blocks[n].dim.len;
+                    /* read height */
+                    p = parse_num(++p, &t);
+                    if (NOT_P(p,!=,NULL) || NOT_I(*p++,==,'*')) break;
+                    buf.blocks[n].dim.area.height = (uint16_t) t;
+                    /* read bits */
+                    p = parse_num(p, &t);
+                    if (NOT_P(p,!=,NULL)) break;
+                    /* handle nv12 */
+                    if (t == 12 && n + 1 < max_n) {
+                        buf.blocks[n + 1].dim.area.width = buf.blocks[n].dim.area.width >> 1;
+                        buf.blocks[n + 1].dim.area.height = buf.blocks[n].dim.area.height >> 1;
+                        buf.blocks[n].fmt = TILFMT_8BIT;
+                        t = 16;
+                        n++;
+                    }
+
+                    buf.blocks[n].fmt = (t == 8 ? TILFMT_8BIT :
+                                         t == 16 ? TILFMT_16BIT :
+                                         t == 32 ? TILFMT_32BIT : TILFMT_INVALID);
+                    if (NOT_I(buf.blocks[n].fmt,!=,TILFMT_INVALID)) break;
+                } else { /* 1d block */
+                    buf.blocks[n].fmt = TILFMT_PAGE;
+                }
+                if (*p && NOT_I(*p++,==,',')) break;
+                /* we're OK */
+                res = 0;
+            }
+            if (res || *p) break;
+            /* allocate buffer */
+
+            buf.num_blocks = n;
+            buf.val = val;
+            if (buf.type == ptr_alloced)
+            {
+                dump_slot(&buf, "==(alloc)=>");
+                buf.ptr = (int) alloc_buf(n, (MemAllocBlock *) buf.blocks, val);
+                dump_slot(&buf, "<=(alloc)==");
+            }
+            else
+            {
+                dump_slot(&buf, "==(tiler_alloc)=>");
+                if (buf.blocks[0].fmt == TILFMT_PAGE)
+                {
+                    buf.ptr = (int) TilerMgr_PageModeAlloc(buf.blocks[0].dim.len);
+                }
+                else
+                {
+                    buf.ptr =(int)  TilerMgr_Alloc(buf.blocks[0].fmt,
+                                                   buf.blocks[0].dim.area.width,
+                                                   buf.blocks[0].dim.area.height);
+                }
+                buf.blocks[0].ssptr = (unsigned long) buf.ptr;
+                dump_slot(&buf, "<=(tiler_alloc)==");
+            }
+            if (NOT_I(buf.ptr,!=,0)) res = 1;
+            else memcpy(slots + ix, &buf, sizeof(buf));
+			break;
+
+        case 'f': /* free */
+        case 'F': /* tiler-free */
+            memcpy(&buf, slots + ix, sizeof(buf));
+            switch (type)
+            {
+            case 'f':
+                if (NOT_I(buf.type,==,ptr_alloced)) break;
+                dump_slot(&buf, "==(free)=>");
+                res = free_buf(buf.num_blocks, (MemAllocBlock *) buf.blocks,
+                         buf.val, (void *) buf.ptr);
+                P("<=(free)==: %d", res);
+                break;
+            case 'F':
+                if (NOT_I(buf.type,==,ptr_tiler_alloced)) break;
+                dump_slot(&buf, "==(tiler_free)=>");
+                if (buf.blocks[0].fmt == TILFMT_PAGE)
+                {
+                    res = TilerMgr_PageModeFree((SSPtr) buf.ptr);
+                }
+                else
+                {
+                    res = TilerMgr_Free((SSPtr) buf.ptr);
+                }
+                P("<=(tiler_free)==: %d", res);
+                break;
+            }
+            ZERO(slots[ix]);
+            break;
+        }
+    }
+
+    /* free any memmgr allocated blocks */
+    for (ix = 0; ix < num_slots; ix++)
+    {
+        if (slots[ix].type == ptr_alloced)
+        {
+            dump_slot(slots + ix, "==(free)=>");
+            int res_free = free_buf(slots[ix].num_blocks, (MemAllocBlock *) slots[ix].blocks,
+                                    slots[ix].val, (void *) slots[ix].ptr);
+            P("<=(free)==: %d", res_free);
+            ERR_ADD(res, res_free);
+        }
+    }
+    ERR_ADD(res, TilerMgr_Close());
+
+    FREE(slots);
+	return res;
+}
+
+/**
+ * Main test function. Checks arguments for test case ranges,
+ * runs tests and prints usage or test list if required.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param argc   Number of arguments
+ * @param argv   Arguments
+ *
+ * @return -1 on usage or test list, otherwise # of failed
+ *         tests.
+ */
+int main(int argc, char **argv)
+{
+    int res = param_test(argc, argv);
+    P(res ? "FAILURE: %d" : "SUCCESS", res);
+    return res;
+}
+
diff --git a/tiler/tilermem.h b/tiler/tilermem.h
new file mode 100644
index 0000000..2c89d84
--- /dev/null
+++ b/tiler/tilermem.h
@@ -0,0 +1,79 @@
+/*
+ *  tilermem.h
+ *
+ *  Tiler Memory Interface functions for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TILERMEM_H_
+#define _TILERMEM_H_
+
+/* retrieve type definitions */
+#include "mem_types.h"
+
+/**
+ * Tiler Memory Allocator is responsible for:
+ * <ol>
+ * <li>Getting the stride information for containers(???) or
+ * buffers
+ * <li>Converting virtual addresses to physical addresses.
+ * </ol>
+ */
+
+/**
+ * Returns the tiler stride corresponding to the system space
+ * address.  For 2D buffers it returns the container stride. For
+ * 1D buffers it returns the page size.  For non-tiler buffers
+ * it returns 0.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr    pointer to a virtual address
+ *
+ * @return The stride of the block that contains the address.
+ */
+bytes_t TilerMem_GetStride(SSPtr ssptr);
+
+/**
+ * Retrieves the physical system-space address that corresponds
+ * to the virtual address.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr    pointer to a virtual address
+ *
+ * @return The physical system-space address that the virtual
+ *         address refers to.  If the virtual address is invalid
+ *         or unmapped, it returns 0.
+ */
+SSPtr TilerMem_VirtToPhys(void *ptr);
+
+#endif
diff --git a/tiler/tilermem_utils.h b/tiler/tilermem_utils.h
new file mode 100644
index 0000000..1d6210d
--- /dev/null
+++ b/tiler/tilermem_utils.h
@@ -0,0 +1,52 @@
+/*
+ *  tilermem_utils.h
+ *
+ *  Memory Allocator Interface internal definitions and functions needed for
+ *  unit testing.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TILERMEM_UTILS_H_
+#define _TILERMEM_UTILS_H_
+
+#include <tiler.h>
+
+#define TILER_PAGE_WIDTH   64
+#define TILER_PAGE_HEIGHT  64
+
+#define TILER_STRIDE_8BIT  (TILER_WIDTH * TILER_PAGE_WIDTH)
+#define TILER_STRIDE_16BIT (TILER_WIDTH * TILER_PAGE_WIDTH * 2)
+#define TILER_STRIDE_32BIT (TILER_WIDTH * TILER_PAGE_WIDTH * 2)
+
+#define PAGE_SIZE           TILER_PAGE
+
+#endif
+
diff --git a/tiler/tilermgr.c b/tiler/tilermgr.c
new file mode 100644
index 0000000..470de5c
--- /dev/null
+++ b/tiler/tilermgr.c
@@ -0,0 +1,203 @@
+/*
+ *  tilermgr.c
+ *
+ *  TILER library support functions for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>   /* strerror() */
+#include <fcntl.h>    /* open() */
+#include <unistd.h>   /* close() */
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <tiler.h>
+#include "tilermgr.h"
+#include "mem_types.h"
+
+
+#define TILERMGR_ERROR() \
+	fprintf(stderr, "%s()::%d: errno(%d) - \"%s\"\n", \
+			__FUNCTION__, __LINE__, errno, strerror(errno)); \
+	fflush(stderr);
+
+static int fd;
+
+int TilerMgr_Close()
+{
+    close(fd);
+    return TILERMGR_ERR_NONE;
+}
+
+int TilerMgr_Open()
+{
+    fd = open(TILER_DEVICE_PATH, O_RDWR);
+    if (fd < 0) {
+        TILERMGR_ERROR();
+        return TILERMGR_ERR_GENERIC;
+    }
+
+    return TILERMGR_ERR_NONE;
+}
+
+SSPtr TilerMgr_Alloc(enum pixel_fmt_t pixfmt, pixels_t width, pixels_t height)
+{
+    int ret = -1;
+    struct tiler_block_info block = {0};
+
+    if (pixfmt < PIXEL_FMT_8BIT || pixfmt > PIXEL_FMT_32BIT)
+        return 0x0;
+    if (width <= 0 || width > TILER_WIDTH * 64)
+        return 0x0;
+    if (height <= 0 || height > TILER_HEIGHT * 64)
+        return 0x0;
+
+    block.fmt = pixfmt;
+    block.dim.area.width = width;
+    block.dim.area.height = height;
+
+    ret = ioctl(fd, TILIOC_GBLK, (unsigned long)(&block));
+    if (ret < 0) {
+        TILERMGR_ERROR();
+        return 0x0;
+    }
+    return block.ssptr;
+}
+
+int TilerMgr_Free(SSPtr addr)
+{
+    int ret = -1;
+    struct tiler_block_info block = {0};
+
+    if (addr < TILER_MEM_8BIT || addr >= TILER_MEM_PAGED)
+        return TILERMGR_ERR_GENERIC;
+
+    block.ssptr = addr;
+
+    ret = ioctl(fd, TILIOC_FBLK, (unsigned long)(&block));
+    if (ret < 0) {
+        TILERMGR_ERROR();
+        return TILERMGR_ERR_GENERIC;
+    }
+    return TILERMGR_ERR_NONE;
+}
+
+SSPtr TilerMgr_PageModeAlloc(bytes_t len)
+{
+    int ret = -1;
+    struct tiler_block_info block = {0};
+
+    if(len < 0 || len > TILER_LENGTH)
+        return 0x0;
+
+    block.fmt = TILFMT_PAGE;
+    block.dim.len = len;
+
+    ret = ioctl(fd, TILIOC_GBLK, (unsigned long)(&block));
+    if (ret < 0) {
+        TILERMGR_ERROR();
+        return 0x0;
+    }
+    return block.ssptr;
+}
+
+int TilerMgr_PageModeFree(SSPtr addr)
+{
+    int ret = -1;
+    struct tiler_block_info block = {0};
+
+    if (addr < TILER_MEM_PAGED || addr >= TILER_MEM_END)
+        return TILERMGR_ERR_GENERIC;
+
+    block.ssptr = addr;
+
+    ret = ioctl(fd, TILIOC_FBLK, (unsigned long)(&block));
+    if (ret < 0) {
+        TILERMGR_ERROR();
+        return TILERMGR_ERR_GENERIC;
+    }
+    return TILERMGR_ERR_NONE;
+}
+
+SSPtr TilerMgr_VirtToPhys(void *ptr)
+{
+    int ret = -1;
+    unsigned long tmp = 0x0;
+
+    if(ptr == NULL)
+        return 0x0;
+
+    tmp = (unsigned long)ptr;
+    ret = ioctl(fd, TILIOC_GSSP, tmp);
+
+    return (SSPtr)ret;
+}
+
+SSPtr TilerMgr_Map(void *ptr, bytes_t len)
+{
+    int ret = -1;
+    struct tiler_block_info block = {0};
+
+    if (len < 0 || len > TILER_LENGTH)
+        return 0x0;
+
+    block.fmt = TILFMT_PAGE;
+    block.dim.len = len;
+    block.ptr = ptr;
+
+    ret = ioctl(fd, TILIOC_MBLK, (unsigned long)(&block));
+    if (ret < 0) {
+        TILERMGR_ERROR();
+        return 0x0;
+    }
+    return block.ssptr;
+}
+
+int TilerMgr_Unmap(SSPtr addr)
+{
+    int ret = -1;
+    struct tiler_block_info block = {0};
+
+    if (addr < TILER_MEM_PAGED || addr >= TILER_MEM_END)
+        return TILERMGR_ERR_GENERIC;
+
+    block.ssptr = addr;
+
+    ret = ioctl(fd, TILIOC_UMBLK, (unsigned long)(&block));
+    if (ret < 0) {
+        TILERMGR_ERROR();
+        return TILERMGR_ERR_GENERIC;
+    }
+    return TILERMGR_ERR_NONE;
+}
+
diff --git a/tiler/tilermgr.h b/tiler/tilermgr.h
new file mode 100644
index 0000000..cd76822
--- /dev/null
+++ b/tiler/tilermgr.h
@@ -0,0 +1,54 @@
+/*
+ *  tilermgr.h
+ *
+ *  TILER library support functions for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TILERMGR_H_
+#define _TILERMGR_H_
+
+#include "mem_types.h"
+
+#define TILERMGR_ERR_NONE (0)
+#define TILERMGR_ERR_GENERIC (-1)
+
+int TilerMgr_Open();
+int TilerMgr_Close();
+SSPtr TilerMgr_Alloc(enum pixel_fmt_t pixfmt, pixels_t width, pixels_t height);
+int TilerMgr_Free(SSPtr ssptr);
+SSPtr TilerMgr_PageModeAlloc(bytes_t length);
+int TilerMgr_PageModeFree(SSPtr ssptr);
+SSPtr TilerMgr_Map(void *ptr, bytes_t length);
+int TilerMgr_Unmap(SSPtr ssptr);
+SSPtr TilerMgr_VirtToPhys(void *ptr);
+
+#endif
diff --git a/tiler/utils.h b/tiler/utils.h
new file mode 100644
index 0000000..d194a43
--- /dev/null
+++ b/tiler/utils.h
@@ -0,0 +1,63 @@
+/*
+ *  utils.h
+ *
+ *  Utility definitions for the Memory Interface for TI OMAP processors.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _UTILS_H_
+#define _UTILS_H_
+
+/* ---------- Generic Macros Used in Macros ---------- */
+
+/* allocation macro */
+#define NEW(type)    (type*)calloc(1, sizeof(type))
+#define NEWN(type,n) (type*)calloc(n, sizeof(type))
+#define ALLOC(var)    var = calloc(1, sizeof(*var))
+#define ALLOCN(var,n) var = calloc(n, sizeof(*var))
+
+
+/* free variable and set it to NULL */
+#define FREE(var)    do { free(var); var = NULL; } while(0)
+
+/* clear variable */
+#define ZERO(var)    memset(&(var), 0, sizeof(var))
+
+/* binary round methods */
+#define ROUND_DOWN_TO2POW(x, N) ((x) & ~((N)-1))
+#define ROUND_UP_TO2POW(x, N) ROUND_DOWN_TO2POW((x) + (N) - 1, N)
+
+/* regulare round methods */
+#define ROUND_DOWN_TO(x, N) ((x) / (N) * (N))
+#define ROUND_UP_TO(x, N) ROUND_DOWN_TO((x) + (N) - 1, N)
+
+#endif
+
diff --git a/tiler/utils_test.c b/tiler/utils_test.c
new file mode 100644
index 0000000..c152125
--- /dev/null
+++ b/tiler/utils_test.c
@@ -0,0 +1,489 @@
+/*
+ *  utils_test.c
+ *
+ *  Memory Allocator Utility tests.
+ *
+ *  Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  *  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *  *  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  *  Neither the name of Texas Instruments Incorporated nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define __DEBUG__
+#define __DEBUG_ASSERT__
+#define __DEBUG_ENTRY__
+
+#include <utils.h>
+#include <list_utils.h>
+#include <debug_utils.h>
+#include "testlib.h"
+
+#define TESTS\
+    T(test_new())\
+    T(test_list())\
+    T(test_ezlist())\
+    T(test_dzlist())\
+    T(test_plist())\
+    T(test_mlist())\
+    T(test_math())
+
+#define F() in = head.next;
+#define N(a) res |= NOT_P(in,!=,&head); \
+    res |= NOT_P(in->me,!=,NULL) || NOT_I(in->me->data,==,a); in = in->next;
+#define Z(a) res |= NOT_P(in,!=,&head); \
+    res |= NOT_I(in->data,==,a); in = in->next;
+#define L() res |= NOT_P(in,==,&head);
+
+int all_zero(int *p, int len)
+{
+    IN;
+    int ix = 0;
+    for (ix = 0; ix < len; ix ++)
+    {
+        if (p[ix])
+        {
+            P("[%d]=%d\n", ix, p[ix]);
+            return R_I(1);
+        }
+    }
+    return R_I(0);
+}
+
+int test_new() {
+    IN;
+    int *p;
+    p = NEW(int);
+    int res = NOT_I(all_zero(p, 1),==,0);
+    FREE(p);
+    res |= NOT_I(p,==,NULL);
+    p = NEWN(int, 8000);
+    res |= NOT_I(all_zero(p, 8000),==,0);
+    FREE(p);
+    p = NEWN(int, 1000000);
+    res |= NOT_I(all_zero(p, 1000000),==,0);
+    FREE(p);
+    return R_I(res);
+}
+
+int test_list() {
+    IN;
+
+    struct elem {
+        int data;
+    } *elA, *elB;
+    struct list {
+        struct elem *me;
+        struct list *last, *next;
+    } head, *inA, *inB, *in, *in_safe;
+
+    /* initialization */
+    DLIST_INIT(head);
+    int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+    /* add element at beginning of list */
+    elA = NEW(struct elem);
+    elA->data = 1;
+    inA = NEW(struct list);
+    DLIST_ADD_AFTER(head, elA, *inA);
+    F()N(1)L();
+
+    /* add element after an element */
+    elB = NEW(struct elem);
+    elB->data = 2;
+    inB = NEW(struct list);
+    DLIST_ADD_AFTER(*inA, elB, *inB);
+    F()N(1)N(2)L();
+
+    /* add element at the end of the list */
+    elB = NEW(struct elem);
+    inB = NEW(struct list);
+    (DLIST_ADD_BEFORE(head, elB, *inB))->data = 3;
+    F()N(1)N(2)N(3)L();
+
+    /* move an element to another position or another list */
+    DLIST_MOVE_AFTER(head, *inB);
+    F()N(3)N(1)N(2)L();
+
+    DLIST_MOVE_BEFORE(head, *inB);
+    F()N(1)N(2)N(3)L();
+
+    /* works even if the position is the same */
+    DLIST_MOVE_BEFORE(head, *inB);
+    F()N(1)N(2)N(3)L();
+
+    res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+    res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+    DLIST_LOOP(head, in) {
+        P("%d", in->me->data);
+    }
+    P(".");
+
+    /* remove elements */
+    DLIST_SAFE_LOOP(head, in, in_safe) {
+        if (in->me->data > 1)
+        {
+            DLIST_REMOVE(*in);
+            FREE(in->me);
+            FREE(in);
+        }
+    }
+    F()N(1)L();
+
+    /* delete list */
+    DLIST_SAFE_LOOP(head, in, in_safe) {
+        DLIST_REMOVE(*in);
+        FREE(in->me);
+        FREE(in);
+    }
+    F()L();
+
+    return R_I(res);
+}
+
+int test_ezlist() {
+    IN;
+
+    struct elem {
+        int data;
+        struct elem *me, *last, *next;
+    } *elA, *elB, head, *el, *el_safe, *in;
+
+    /* initialization */
+    DLIST_INIT(head);
+    int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+    /* add element at beginning of list */
+    elA = NEW(struct elem);
+    elA->data = 1;
+    DLIST_ADD_AFTER(head, elA, *elA);
+    F()N(1)L();
+
+    /* add element after an element */
+    elB = NEW(struct elem);
+    elB->data = 2;
+    DLIST_ADD_AFTER(*elA, elB, *elB);
+    F()N(1)N(2)L();
+
+    /* add element at the end of the list */
+    elB = NEW(struct elem);
+    (DLIST_ADD_BEFORE(head, elB, *elB))->data = 3;
+    F()N(1)N(2)N(3)L();
+
+    /* move an element to another position or another list */
+    DLIST_MOVE_AFTER(head, *elB);
+    F()N(3)N(1)N(2)L();
+
+    DLIST_MOVE_BEFORE(head, *elB);
+    F()N(1)N(2)N(3)L();
+
+    /* works even if the position is the same */
+    DLIST_MOVE_BEFORE(head, *elB);
+    F()N(1)N(2)N(3)L();
+
+    res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+    res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+    DLIST_LOOP(head, el) {
+        P("%d", el->data);
+    }
+    P(".");
+
+    /* remove elements */
+    DLIST_SAFE_RLOOP(head, el, el_safe) {
+        if (el->me->data == 1)
+        {
+            DLIST_REMOVE(*el);
+            FREE(el);
+        }
+    }
+    F()N(2)N(3)L();
+
+    /* delete list */
+    DLIST_SAFE_LOOP(head, el, el_safe) {
+        DLIST_REMOVE(*el);
+        FREE(el);
+    }
+    F()L();
+
+    return R_I(res);
+}
+
+int test_dzlist() {
+    IN;
+
+    struct elem {
+        int data;
+        struct elem *last, *next;
+    } *elA, *elB, head, *el, *el_safe, *in;
+
+    /* initialization */
+    DZLIST_INIT(head);
+    int res = NOT_I(DZLIST_IS_EMPTY(head),!=,0);
+
+    /* add element at beginning of list */
+    elA = NEW(struct elem);
+    elA->data = 1;
+    DZLIST_ADD_AFTER(head, *elA);
+    F()Z(1)L();
+
+    /* add element after an element */
+    elB = NEW(struct elem);
+    elB->data = 2;
+    DZLIST_ADD_AFTER(*elA, *elB);
+    F()Z(1)Z(2)L();
+
+    /* add element at the end of the list */
+    elB = NEW(struct elem);
+    (DZLIST_ADD_BEFORE(head, *elB))->data = 3;
+    F()Z(1)Z(2)Z(3)L();
+
+    /* move an element to another position or another list */
+    DZLIST_MOVE_AFTER(head, *elB);
+    F()Z(3)Z(1)Z(2)L();
+
+    DZLIST_MOVE_BEFORE(head, *elB);
+    F()Z(1)Z(2)Z(3)L();
+
+    /* works even if the position is the same */
+    DZLIST_MOVE_BEFORE(head, *elB);
+    F()Z(1)Z(2)Z(3)L();
+
+    res |= NOT_I(DZLIST_FIRST(head)->data,==,1);
+    res |= NOT_I(DZLIST_LAST(head)->data,==,3);
+
+    DZLIST_LOOP(head, el) {
+        P("%d", el->data);
+    }
+    P(".");
+
+    /* remove elements */
+    DZLIST_SAFE_RLOOP(head, el, el_safe) {
+        if (el->data == 1)
+        {
+            DZLIST_REMOVE(*el);
+            FREE(el);
+        }
+    }
+    F()Z(2)Z(3)L();
+
+    /* delete list */
+    DZLIST_SAFE_LOOP(head, el, el_safe) {
+        DZLIST_REMOVE(*el);
+        FREE(el);
+    }
+    F()L();
+
+    return R_I(res);
+}
+
+int test_plist() {
+    IN;
+
+    struct elem;
+    struct list {
+        struct elem *me;
+        struct list *last, *next;
+    } head, *inA, *inB, *in;
+    struct elem {
+        int data;
+        struct list *list_data;
+    } *elA, *elB, *el, *el_safe;
+
+    /* initialization */
+    DLIST_INIT(head);
+    int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+    /* add element at beginning of list */
+    elA = NEW(struct elem);
+    elA->data = 1;
+    inA = NEW(struct list);
+    DLIST_PADD_AFTER(head, elA, inA, list_data);
+    F()N(1)L();
+
+    /* add element after an element */
+    elB = NEW(struct elem);
+    elB->data = 2;
+    inB = NEW(struct list);
+    DLIST_PADD_AFTER(*inA, elB, inB, list_data);
+    F()N(1)N(2)L();
+
+    /* add element at the end of the list */
+    elB = NEW(struct elem);
+    inB = NEW(struct list);
+    (DLIST_PADD_BEFORE(head, elB, inB, list_data))->data = 3;
+    F()N(1)N(2)N(3)L();
+
+    /* move an element to another position or another list */
+    DLIST_MOVE_AFTER(head, *inB);
+    F()N(3)N(1)N(2)L();
+
+    DLIST_MOVE_BEFORE(head, *inB);
+    F()N(1)N(2)N(3)L();
+
+    /* works even if the position is the same */
+    DLIST_MOVE_BEFORE(head, *inB);
+    F()N(1)N(2)N(3)L();
+
+    res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+    res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+    DLIST_LOOP(head, in) {
+        P("%d", in->me->data);
+    }
+    P(".");
+    DLIST_PLOOP(head, el, list_data) {
+        P("%d", el->data);
+    }
+    P(".");
+
+    /* remove elements */
+    DLIST_SAFE_PLOOP(head, el, el_safe, list_data) {
+        if (el->data == 2)
+        {
+            DLIST_REMOVE(*el->list_data);
+            FREE(el->list_data);
+            FREE(el);
+        }
+    }
+    F()N(1)N(3)L();
+
+    /* delete list */
+    DLIST_SAFE_PLOOP(head, el, el_safe, list_data) {
+        DLIST_REMOVE(*el->list_data);
+        FREE(el->list_data);
+        FREE(el);
+    }
+    F()L();
+
+    return R_I(res);
+}
+
+int test_mlist() {
+    IN;
+
+    struct elem {
+        int data;
+        struct list {
+            struct list *last, *next;
+            struct elem *me;
+        } list_data;
+    } *elA, *elB, *el, *el_safe;
+    struct list head, *in;
+
+    /* initialization */
+    DLIST_INIT(head);
+    int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+    /* add element at beginning of list */
+    elA = NEW(struct elem);
+    elA->data = 1;
+    DLIST_MADD_AFTER(head, elA, list_data);
+    F()N(1)L();
+
+    /* add element after an element */
+    elB = NEW(struct elem);
+    elB->data = 2;
+    DLIST_MADD_AFTER(elA->list_data, elB, list_data);
+    F()N(1)N(2)L();
+
+    /* add element at the end of the list */
+    elB = NEW(struct elem);
+    (DLIST_MADD_BEFORE(head, elB, list_data))->data = 3;
+    F()N(1)N(2)N(3)L();
+
+    /* move an element to another position or another list */
+    DLIST_MOVE_AFTER(head, elB->list_data);
+    F()N(3)N(1)N(2)L();
+
+    DLIST_MOVE_BEFORE(head, elB->list_data);
+    F()N(1)N(2)N(3)L();
+
+    /* works even if the position is the same */
+    DLIST_MOVE_BEFORE(head, elB->list_data);
+    F()N(1)N(2)N(3)L();
+
+    res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+    res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+    DLIST_LOOP(head, in) {
+        P("%d", in->me->data);
+    }
+    P(".");
+    DLIST_MLOOP(head, el, list_data) {
+        P("%d", el->data);
+    }
+    P(".");
+
+    /* remove elements */
+    DLIST_SAFE_MLOOP(head, el, el_safe, list_data) {
+        if (el->data != 2)
+        {
+            DLIST_REMOVE(el->list_data);
+            FREE(el);
+        }
+    }
+    F()N(2)L();
+
+    /* delete list */
+    DLIST_SAFE_MLOOP(head, el, el_safe, list_data) {
+        DLIST_REMOVE(el->list_data);
+        FREE(el);
+    }
+    F()L();
+
+    return R_I(res);
+}
+
+int test_math()
+{
+    IN;
+    int res = 0;
+    res |= NOT_I(ROUND_UP_TO2POW(0, 4096),==,0);
+    res |= NOT_I(ROUND_UP_TO2POW(1, 4096),==,4096);
+    res |= NOT_I(ROUND_UP_TO2POW(4095, 4096),==,4096);
+    res |= NOT_I(ROUND_UP_TO2POW(4096, 4096),==,4096);
+    res |= NOT_I(ROUND_UP_TO2POW(4097, 4096),==,8192);
+    res |= NOT_I(ROUND_DOWN_TO2POW(0, 4096),==,0);
+    res |= NOT_I(ROUND_DOWN_TO2POW(1, 4096),==,0);
+    res |= NOT_I(ROUND_DOWN_TO2POW(4095, 4096),==,0);
+    res |= NOT_I(ROUND_DOWN_TO2POW(4096, 4096),==,4096);
+    res |= NOT_I(ROUND_DOWN_TO2POW(4097, 4096),==,4096);
+    return R_I(res);
+}
+
+DEFINE_TESTS(TESTS)
+
+int main(int argc, char **argv)
+{
+    return TestLib_Run(argc, argv, nullfn, nullfn, NULL);
+}
+
diff --git a/tm.c b/tm.c
new file mode 100644
index 0000000..c29a190
--- /dev/null
+++ b/tm.c
@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+static void printf_log(const char *fmt, ...)
+{
+    va_list lst;
+    va_start(lst, fmt);
+    vprintf(fmt, lst);
+    va_end(lst);
+}
+
+/* Override this for non-printf reporting */
+extern void (*malloc_log)(const char *fmt, ...);
+static void ctor(void) __attribute__((constructor));
+static void ctor(void)
+{
+    malloc_log = printf_log;
+}
+
+int main(void)
+{
+	char *ptr[6];
+	char *uaf;
+	char *cf, *cb;
+
+	ptr[0] = malloc(10);
+	ptr[1] = calloc(1,20);
+	ptr[2] = malloc(30);
+	ptr[3] = malloc(40);
+        ptr[4] = malloc(50);
+        ptr[5] = malloc(60);
+
+	free(ptr[1]);
+	free(ptr[1]);
+	free(ptr[2]);
+        ptr[2] = realloc(ptr[2], 300);
+//      free(ptr[2]);
+//      free(ptr[2]);
+
+	uaf = ptr[3];
+	free(uaf);
+	uaf[5] = 'a';
+
+        cf = ptr[4];
+        cf[-1] = 'a'; 
+
+        cb = ptr[5];
+        cb[60] = 'a';
+
+	sleep(10);
+
+	return 0;
+}