camera: remove old HAL

Change-Id: Ie603ea384b96131492d5b9373782ef5248486e0e
Signed-off-by: Iliyan Malchev <malchev@google.com>
diff --git a/camera/QCamera/Android.mk b/camera/QCamera/Android.mk
deleted file mode 100755
index e45365e..0000000
--- a/camera/QCamera/Android.mk
+++ /dev/null
@@ -1,3 +0,0 @@
-ifeq ($(TARGET_ARCH),arm)
-#  include $(call all-subdir-makefiles)
-endif
diff --git a/camera/QCamera/HAL/Android.mk b/camera/QCamera/HAL/Android.mk
deleted file mode 100755
index 5097dae..0000000
--- a/camera/QCamera/HAL/Android.mk
+++ /dev/null
@@ -1,3 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(LOCAL_PATH)/core/Android.mk
-#include $(LOCAL_PATH)/test/Android.mk
diff --git a/camera/QCamera/HAL/core/Android.mk b/camera/QCamera/HAL/core/Android.mk
deleted file mode 100755
index df81ed4..0000000
--- a/camera/QCamera/HAL/core/Android.mk
+++ /dev/null
@@ -1,118 +0,0 @@
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-DLOPEN_LIBMMCAMERA:=0
-
-LOCAL_CFLAGS:= -DDLOPEN_LIBMMCAMERA=$(DLOPEN_LIBMMCAMERA)
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
-        LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_CFLAGS += -DCAMERA_ION_HEAP_ID=ION_CP_MM_HEAP_ID # 8660=SMI, Rest=EBI
-LOCAL_CFLAGS += -DCAMERA_ZSL_ION_HEAP_ID=ION_CP_MM_HEAP_ID
-
-LOCAL_CFLAGS+= -DHW_ENCODE
-LOCAL_CFLAGS+= -DUSE_NEON_CONVERSION
-
-ifeq ($(call is-board-platform,msm8974),true)
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_MM_HEAP
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP
-        LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
-        LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=9
-else ifeq ($(call is-board-platform,msm8226),true)
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_MM_HEAP
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP
-        LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
-        LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=9
-else ifeq ($(call is-board-platform,msm8960),true)
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_MM_HEAP
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP
-        LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
-        LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=5
-else ifeq ($(call is-chipset-prefix-in-board-platform,msm8660),true)
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP # Don't Care
-        LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID # EBI
-        LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
-        LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=5
-else
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP # Don't Care
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=GRALLOC_USAGE_PRIVATE_UNCACHED #uncached
-        LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_CAMERA_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_CAMERA_HEAP_ID
-        LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=5
-endif
-
-LOCAL_HAL_FILES := \
-        src/QCameraHAL.cpp \
-        src/QCameraHWI_Parm.cpp \
-        src/QCameraHWI.cpp \
-        src/QCameraHWI_Preview.cpp \
-        src/QCameraHWI_Record.cpp \
-        src/QCameraHWI_Still.cpp \
-        src/QCameraHWI_Rdi.cpp \
-        src/QCameraHWI_Mem.cpp \
-        src/QCameraParameters.cpp\
-        src/QCameraStream.cpp\
-        ../usbcamcore/src/QualcommUsbCamera.cpp\
-        ../usbcamcore/src/QCameraMjpegDecode.cpp\
-        ../usbcamcore/src/QCameraUsbParm.cpp
-
-LOCAL_HAL_WRAPPER_FILES := ../wrapper/QualcommCamera.cpp
-
-LOCAL_C_INCLUDES := \
-        $(LOCAL_PATH)/../wrapper \
-        $(LOCAL_PATH)/inc \
-        $(LOCAL_PATH)/../usbcamcore/inc\
-        $(LOCAL_PATH)/../../stack/mm-camera-interface/inc \
-        $(LOCAL_PATH)/../../stack/mm-jpeg-interface/inc \
-        $(LOCAL_PATH)/../../../ \
-        $(TARGET_OUT_INTERMEDIATES)/include/mm-camera-interface \
-#       $(TARGET_OUT_INTERMEDIATES)/include/mm-jpeg-interface\
-
-# may need remove this includes
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-camera
-#LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-still
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-still/jpeg
-#end
-
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/media
-LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
-
-LOCAL_C_INCLUDES += hardware/qcom/display/libgralloc \
-        hardware/qcom/display/libgenlock \
-        hardware/qcom/media/libstagefrighthw
-
-# if debug service layer and up , use stub camera!
-LOCAL_C_INCLUDES += \
-        frameworks/base/services/camera/libcameraservice
-
-LOCAL_SRC_FILES := \
-        $(LOCAL_HAL_WRAPPER_FILES) \
-        $(LOCAL_HAL_FILES)
-
-LOCAL_SHARED_LIBRARIES := libutils libui libcamera_client liblog libcutils libmmjpeg
-LOCAL_SHARED_LIBRARIES += libmmcamera_interface
-LOCAL_SHARED_LIBRARIES += libgenlock libbinder libmmjpeg_interface libhardware
-
-LOCAL_CFLAGS += -include bionic/libc/kernel/common/linux/socket.h
-
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-LOCAL_MODULE:= camera.$(TARGET_BOARD_PLATFORM)
-LOCAL_MODULE_TAGS := optional
-include $(BUILD_SHARED_LIBRARY)
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
-
diff --git a/camera/QCamera/HAL/core/inc/QCameraHAL.h b/camera/QCamera/HAL/core/inc/QCameraHAL.h
deleted file mode 100755
index 45cb084..0000000
--- a/camera/QCamera/HAL/core/inc/QCameraHAL.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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_QCAMERA_HAL_H
-#define ANDROID_HARDWARE_QCAMERA_HAL_H
-
-
-#include "QCameraHWI.h"
-
-extern "C" {
-#include <mm_camera_interface.h>
-}
-namespace android {
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" void *
-       QCameraHAL_openCameraHardware(int  cameraId, int mode);
-extern "C" int HAL_getNumberOfCameras();
-extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo);
-
-}; // namespace android
-
-#endif
-
diff --git a/camera/QCamera/HAL/core/inc/QCameraHWI.h b/camera/QCamera/HAL/core/inc/QCameraHWI.h
deleted file mode 100755
index ff43244..0000000
--- a/camera/QCamera/HAL/core/inc/QCameraHWI.h
+++ /dev/null
@@ -1,966 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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_QCAMERA_HARDWARE_INTERFACE_H
-#define ANDROID_HARDWARE_QCAMERA_HARDWARE_INTERFACE_H
-
-
-#include <utils/threads.h>
-#include <hardware/camera.h>
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <camera/Camera.h>
-#include <camera/QCameraParameters.h>
-#include <system/window.h>
-#include <system/camera.h>
-#include <hardware/camera.h>
-#include <gralloc_priv.h>
-#include <QComOMXMetadata.h>
-#include <hardware/power.h>
-
-extern "C" {
-#include <linux/android_pmem.h>
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include <camera_defs_i.h>
-#include <mm_camera_interface.h>
-#include "mm_jpeg_interface.h"
-} //extern C
-
-#include "QCameraHWI_Mem.h"
-#include "QCameraStream.h"
-
-//Error codes
-#define  NOT_FOUND -1
-#define MAX_ZOOM_RATIOS 62
-
-#ifdef Q12
-#undef Q12
-#endif
-
-#define Q12 4096
-#define QCAMERA_PARM_ENABLE   1
-#define QCAMERA_PARM_DISABLE  0
-#define PREVIEW_TBL_MAX_SIZE  14
-#define VIDEO_TBL_MAX_SIZE    14
-#define THUMB_TBL_MAX_SIZE    16
-#define HFR_TBL_MAX_SIZE      2
-
-#define DEFAULT_STREAM_WIDTH 320
-#define DEFAULT_STREAM_HEIGHT 240
-#define DEFAULT_LIVESHOT_WIDTH 2592
-#define DEFAULT_LIVESHOT_HEIGHT 1944
-
-//for histogram stats
-#define HISTOGRAM_STATS_SIZE 257
-#define NUM_HISTOGRAM_BUFFERS 3
-
-struct str_map {
-    const char *const desc;
-    int val;
-};
-
-struct preview_format_info_t {
-   int Hal_format;
-   cam_format_t mm_cam_format;
-   cam_pad_format_t padding;
-   int num_planar;
-};
-
-
-typedef enum {
-  CAMERA_STATE_UNINITED,
-  CAMERA_STATE_READY,
-  CAMERA_STATE_MAX
-} HAL_camera_state_type_t;
-
-enum {
-  BUFFER_NOT_OWNED,
-  BUFFER_UNLOCKED,
-  BUFFER_LOCKED,
-};
-
-typedef enum {
-  HAL_DUMP_FRM_PREVIEW = 1,
-  HAL_DUMP_FRM_VIDEO = 1<<1,
-  HAL_DUMP_FRM_MAIN = 1<<2,
-  HAL_DUMP_FRM_THUMBNAIL = 1<<3,
-  HAL_DUMP_FRM_RDI = 1<<4,
-
-  /*8 bits mask*/
-  HAL_DUMP_FRM_MAX = 1 << 8
-} HAL_cam_dump_frm_type_t;
-
-
-typedef enum {
-  HAL_CAM_MODE_ZSL = 1,
-
-  /*add new entry before and update the max entry*/
-  HAL_CAM_MODE_MAX = HAL_CAM_MODE_ZSL << 1,
-} qQamera_mode_t;
-
-
-typedef enum {
-    MM_CAMERA_OK,
-    MM_CAMERA_E_GENERAL,
-    MM_CAMERA_E_NO_MEMORY,
-    MM_CAMERA_E_NOT_SUPPORTED,
-    MM_CAMERA_E_INVALID_INPUT,
-    MM_CAMERA_E_INVALID_OPERATION, /* 5 */
-    MM_CAMERA_E_ENCODE,
-    MM_CAMERA_E_BUFFER_REG,
-    MM_CAMERA_E_PMEM_ALLOC,
-    MM_CAMERA_E_CAPTURE_FAILED,
-    MM_CAMERA_E_CAPTURE_TIMEOUT, /* 10 */
-}mm_camera_status_type_t;
-
-
-
-#define HAL_DUMP_FRM_MASK_ALL ( HAL_DUMP_FRM_PREVIEW + HAL_DUMP_FRM_VIDEO + \
-    HAL_DUMP_FRM_MAIN + HAL_DUMP_FRM_THUMBNAIL)
-#define QCAMERA_HAL_PREVIEW_STOPPED    0
-#define QCAMERA_HAL_PREVIEW_START      1
-#define QCAMERA_HAL_PREVIEW_STARTED    2
-#define QCAMERA_HAL_RECORDING_STARTED  3
-#define QCAMERA_HAL_TAKE_PICTURE       4
-
-typedef struct {
-    int                     fd;
-    int                     main_ion_fd;
-    struct ion_handle *     handle;
-    uint32_t                size;
-} QCameraHalMemInfo_t;
-
-typedef struct {
-     int                     buffer_count;
-	 buffer_handle_t        *buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
-	 struct private_handle_t *private_buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
-	 int                     stride[MM_CAMERA_MAX_NUM_FRAMES];
-	 uint32_t                addr_offset[MM_CAMERA_MAX_NUM_FRAMES];
-	 uint8_t                 local_flag[MM_CAMERA_MAX_NUM_FRAMES];
-     camera_memory_t        *camera_memory[MM_CAMERA_MAX_NUM_FRAMES];
-     QCameraHalMemInfo_t     mem_info[MM_CAMERA_MAX_NUM_FRAMES];
-} QCameraHalMemory_t;
-
-
-typedef struct {
-     int                     buffer_count;
-	 int                     local_flag[MM_CAMERA_MAX_NUM_FRAMES];
-     camera_memory_t *       camera_memory[MM_CAMERA_MAX_NUM_FRAMES];
-     camera_memory_t *       metadata_memory[MM_CAMERA_MAX_NUM_FRAMES];
-     QCameraHalMemInfo_t     mem_info[MM_CAMERA_MAX_NUM_FRAMES];
-} QCameraHalHeap_t;
-
-typedef struct {
-     camera_memory_t *       camera_memory[NUM_HISTOGRAM_BUFFERS];
-     QCameraHalMemInfo_t     mem_info[NUM_HISTOGRAM_BUFFERS];
-     int active;
-} QCameraStatHeap_t;
-
-typedef struct {
-  int32_t msg_type;
-  int32_t ext1;
-  int32_t ext2;
-  void    *cookie;
-} argm_notify_t;
-
-typedef struct {
-  int32_t                  msg_type;
-  camera_memory_t         *data;
-  unsigned int             index;
-  camera_frame_metadata_t *metadata;
-  void                    *cookie;
-  void                    *user_data;
-} argm_data_cb_t;
-
-typedef struct {
-  camera_notify_callback notifyCb;
-  camera_data_callback   dataCb;
-  argm_notify_t argm_notify;
-  argm_data_cb_t        argm_data_cb;
-} app_notify_cb_t;
-
-/* camera_area_t
- * rectangle with weight to store the focus and metering areas.
- * x1, y1, x2, y2: from -1000 to 1000
- * weight: 0 to 1000
- */
-typedef struct {
-    int x1, y1, x2, y2;
-    int weight;
-} camera_area_t;
-
-//EXIF globals
-static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };          // "ASCII\0\0\0"
-static const char ExifUndefinedPrefix[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };   // "\0\0\0\0\0\0\0\0"
-
-//EXIF detfines
-#define MAX_EXIF_TABLE_ENTRIES           14
-#define GPS_PROCESSING_METHOD_SIZE       101
-#define FOCAL_LENGTH_DECIMAL_PRECISION   100
-#define EXIF_ASCII_PREFIX_SIZE           8   //(sizeof(ExifAsciiPrefix))
-
-typedef struct{
-    //GPS tags
-    rat_t       latitude[3];
-    rat_t       longitude[3];
-    char        lonRef[2];
-    char        latRef[2];
-    rat_t       altitude;
-    rat_t       gpsTimeStamp[3];
-    char        gpsDateStamp[20];
-    char        gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE+GPS_PROCESSING_METHOD_SIZE];
-    //Other tags
-    char        dateTime[20];
-    rat_t       focalLength;
-    uint16_t    flashMode;
-    uint16_t    isoSpeed;
-
-    bool        mAltitude;
-    bool        mLongitude;
-    bool        mLatitude;
-    bool        mTimeStamp;
-    bool        mGpsProcess;
-
-    int         mAltitude_ref;
-    long        mGPSTimestamp;
-
-} exif_values_t;
-
-typedef struct {
-    jpeg_job_status_t status;
-    uint8_t thumbnailDroppedFlag;
-    uint32_t client_hdl;
-    uint32_t jobId;
-    uint8_t* out_data;
-    uint32_t data_size;
-    mm_camera_super_buf_t* src_frame;
-} camera_jpeg_data_t;
-
-typedef struct {
-    mm_camera_super_buf_t* src_frame;
-    void* userdata;
-} camera_jpeg_encode_cookie_t;
-
-namespace android {
-
-class QCameraStream;
-
-typedef void (*release_data_fn)(void* data, void *user_data);
-
-class QCameraQueue {
-public:
-    QCameraQueue();
-    QCameraQueue(release_data_fn data_rel_fn, void *user_data);
-    virtual ~QCameraQueue();
-    bool enqueue(void *data);
-    bool pri_enqueue(void *data);
-    void flush();
-    void* dequeue();
-    bool is_empty();
-private:
-    typedef struct {
-        struct cam_list list;
-        void* data;
-    } camera_q_node;
-
-    camera_q_node mhead; /* dummy head */
-    uint32_t msize;
-    pthread_mutex_t mlock;
-    release_data_fn mdata_rel_fn;
-    void * muser_data;
-};
-
-typedef enum
-{
-    CAMERA_CMD_TYPE_NONE,
-    CAMERA_CMD_TYPE_START_DATA_PROC,
-    CAMERA_CMD_TYPE_STOP_DATA_PROC,
-    CAMERA_CMD_TYPE_DO_NEXT_JOB,
-    CAMERA_CMD_TYPE_EXIT,
-    CAMERA_CMD_TYPE_MAX
-} camera_cmd_type_t;
-
-typedef struct snap_hdr_record_t_ {
-    bool hdr_on;
-    int num_frame;
-    int num_raw_received;
-    /*in terms of 2^*(n/6), e.g 6 means (1/2)x, whole 12 means 4x*/
-    int exp[MAX_HDR_EXP_FRAME_NUM];
-    mm_camera_super_buf_t *recvd_frame[MAX_HDR_EXP_FRAME_NUM];
-} snap_hdr_record_t;
-
-typedef struct {
-    camera_cmd_type_t cmd;
-} camera_cmd_t;
-
-class QCameraCmdThread {
-public:
-    QCameraCmdThread();
-    ~QCameraCmdThread();
-
-    int32_t launch(void *(*start_routine)(void *), void* user_data);
-    int32_t exit();
-    int32_t sendCmd(camera_cmd_type_t cmd, uint8_t sync_cmd, uint8_t priority);
-    camera_cmd_type_t getCmd();
-
-    QCameraQueue cmd_queue;      /* cmd queue */
-    pthread_t cmd_pid;           /* cmd thread ID */
-    sem_t cmd_sem;               /* semaphore for cmd thread */
-    sem_t sync_sem;              /* semaphore for synchronized call signal */
-};
-
-class QCameraHardwareInterface : public virtual RefBase {
-public:
-
-    QCameraHardwareInterface(int  cameraId, int mode);
-
-    /** Set the ANativeWindow to which preview frames are sent */
-    int setPreviewWindow(preview_stream_ops_t* window);
-
-    /** 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);
-
-    /**
-     * The following three functions all take a msg_type, which is a bitmask of
-     * the messages defined in include/ui/Camera.h
-     */
-
-    /**
-     * Enable a message, or set of messages.
-     */
-    void enableMsgType(int32_t msg_type);
-
-    /**
-     * Disable a message, or a set of messages.
-     *
-     * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
-     * HAL should not rely on its client to call releaseRecordingFrame() to
-     * release video recording frames sent out by the cameral HAL before and
-     * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
-     * clients must not modify/access any video recording frame after calling
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
-     */
-    void disableMsgType(int32_t msg_type);
-
-    /**
-     * 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 msg_type);
-
-    /**
-     * Start preview mode.
-     */
-    int startPreview();
-    int startPreview2();
-
-    /**
-     * Stop a previously started preview.
-     */
-    void stopPreview();
-
-    /**
-     * Returns true if preview is enabled.
-     */
-    int previewEnabled();
-
-
-    /**
-     * Request the camera HAL to store meta data or real YUV data in the video
-     * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
-     * it is not called, the default camera HAL behavior is to store real YUV
-     * data in the video buffers.
-     *
-     * This method should be called before startRecording() in order to be
-     * effective.
-     *
-     * If meta data is stored in the video buffers, it is up to the receiver of
-     * the video buffers to interpret the contents and to find the actual frame
-     * data with the help of the meta data in the buffer. How this is done is
-     * outside of the scope of this method.
-     *
-     * Some camera HALs may not support storing meta data in the video buffers,
-     * but all camera HALs should support storing real YUV data in the video
-     * buffers. If the camera HAL does not support storing the meta data in the
-     * video buffers when it is requested to do do, INVALID_OPERATION must be
-     * returned. It is very useful for the camera HAL to pass meta data rather
-     * than the actual frame data directly to the video encoder, since the
-     * amount of the uncompressed frame data can be very large if video size is
-     * large.
-     *
-     * @param enable if true to instruct the camera HAL to store
-     *        meta data in the video buffers; false to instruct
-     *        the camera HAL to store real YUV data in the video
-     *        buffers.
-     *
-     * @return OK on success.
-     */
-    int storeMetaDataInBuffers(int enable);
-
-    /**
-     * 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 a camera HAL client via
-     * releaseRecordingFrame() before the client calls
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
-     * responsibility to manage the life-cycle of the video recording frames,
-     * and the client must not modify/access any video recording frames.
-     */
-    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.
-     *
-     * It is camera HAL client's responsibility to release video recording
-     * frames sent out by the camera HAL before the camera HAL receives a call
-     * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
-     * responsibility to manage the life-cycle of the video recording frames.
-     */
-    void releaseRecordingFrame(const void *opaque);
-
-    /**
-     * 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. This returns BAD_VALUE if any parameter is
-     * invalid or not supported.
-     */
-    int setParameters(const char *parms);
-
-    //status_t setParameters(const QCameraParameters& params);
-    /** Retrieve the camera parameters.  The buffer returned by the camera HAL
-        must be returned back to it with put_parameters, if put_parameters
-        is not NULL.
-     */
-    int getParameters(char **parms);
-
-    /** The camera HAL uses its own memory to pass us the parameters when we
-        call get_parameters.  Use this function to return the memory back to
-        the camera HAL, if put_parameters is not NULL.  If put_parameters
-        is NULL, then you have to use free() to release the memory.
-    */
-    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);
-    void         getPictureSize(int *picture_width, int *picture_height) const;
-    void         getPreviewSize(int *preview_width, int *preview_height) const;
-	void         getVideoSize(int *video_width,int *video_height) const;
-	void         getThumbnailSize(int *thumb_width, int *thumb_height) const;
-    cam_format_t getPreviewFormat() const;
-    cam_pad_format_t getPreviewPadding() const;
-    void processEvent(mm_camera_event_t *);
-    int  getJpegQuality() const;
-    int  getNumOfSnapshots(void) const;
-    int  getNumOfSnapshots(const QCameraParameters& params);
-    int  getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
-                                     int *picture_width,
-                                     int *picture_height);
-    bool isRawSnapshot();
-    bool mShutterSoundPlayed;
-    void dumpFrameToFile(mm_camera_buf_def_t*, HAL_cam_dump_frm_type_t);
-
-    static QCameraHardwareInterface *createInstance(int, int);
-    status_t setZSLBurstLookBack(const QCameraParameters& params);
-    status_t setZSLBurstInterval(const QCameraParameters& params);
-    int getZSLBurstInterval(void);
-    int getZSLQueueDepth(void) const;
-    int getZSLBackLookCount(void) const;
-
-    ~QCameraHardwareInterface();
-    int initHeapMem(QCameraHalHeap_t *heap,
-                    int num_of_buf,
-                    uint32_t buf_len,
-                    int pmem_type,
-                    mm_camera_frame_len_offset* offset,
-                    mm_camera_buf_def_t *buf_def);
-    int releaseHeapMem( QCameraHalHeap_t *heap);
-    int allocate_ion_memory(QCameraHalMemInfo_t * mem_info, int ion_type);
-    int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info);
-
-    int cache_ops(QCameraHalMemInfo_t *mem_info,
-                  void *buf_ptr,
-                  unsigned int cmd);
-
-    void dumpFrameToFile(const void * data, uint32_t size, char* name,
-      char* ext, int index);
-    preview_format_info_t getPreviewFormatInfo( );
-    bool isCameraReady();
-    bool isNoDisplayMode();
-
-    int getBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data,
-                        mm_camera_frame_len_offset *frame_offset_info,
-                        uint8_t num_bufs,
-                        uint8_t *initial_reg_flag,
-                        mm_camera_buf_def_t  *bufs);
-    int putBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data, uint8_t num_bufs,
-                        mm_camera_buf_def_t *bufs);
-
-    mm_camera_vtbl_t *mCameraHandle;
-    uint32_t mChannelId;
-
-private:
-    int16_t  zoomRatios[MAX_ZOOM_RATIOS];
-    struct camera_size_type default_preview_sizes[PREVIEW_TBL_MAX_SIZE];
-    struct camera_size_type default_video_sizes[VIDEO_TBL_MAX_SIZE];
-    struct camera_size_type default_hfr_sizes[HFR_TBL_MAX_SIZE];
-    struct camera_size_type default_thumbnail_sizes[THUMB_TBL_MAX_SIZE];
-    unsigned int preview_sizes_count;
-    unsigned int video_sizes_count;
-    unsigned int thumbnail_sizes_count;
-    unsigned int hfr_sizes_count;
-
-
-    bool mUseOverlay;
-
-    void loadTables();
-    void initDefaultParameters();
-    bool getMaxPictureDimension(mm_camera_dimension_t *dim);
-
-    status_t updateFocusDistances();
-
-    bool native_set_parms(mm_camera_parm_type_t type, uint16_t length, void *value);
-    bool native_set_parms( mm_camera_parm_type_t type, uint16_t length, void *value, int *result);
-
-    void hasAutoFocusSupport();
-    void debugShowPreviewFPS() const;
-    //void prepareSnapshotAndWait();
-
-    bool isPreviewRunning();
-    bool isRecordingRunning();
-    bool isSnapshotRunning();
-
-    void processChannelEvent(mm_camera_ch_event_t *, app_notify_cb_t *);
-    void processRdiChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
-    void processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
-    void processRecordChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
-    void processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
-    void processCtrlEvent(mm_camera_ctrl_event_t *, app_notify_cb_t *);
-    void processStatsEvent(mm_camera_stats_event_t *, app_notify_cb_t *);
-    void processInfoEvent(mm_camera_info_event_t *event, app_notify_cb_t *);
-    void processprepareSnapshotEvent(cam_ctrl_status_t *);
-    void roiEvent(fd_roi_t roi, app_notify_cb_t *);
-    void zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *);
-    void autofocusevent(cam_ctrl_status_t *status, app_notify_cb_t *);
-    void handleZoomEventForPreview(app_notify_cb_t *);
-    void handleZoomEventForSnapshot(void);
-    status_t autoFocusEvent(cam_ctrl_status_t *, app_notify_cb_t *);
-
-    void filterPictureSizes();
-    bool supportsSceneDetection();
-    bool supportsSelectableZoneAf();
-    bool supportsFaceDetection();
-    bool supportsRedEyeReduction();
-
-    void stopPreviewInternal();
-    void stopRecordingInternal();
-    status_t cancelPictureInternal();
-    void pausePreviewForSnapshot();
-    void restartPreview();
-
-    status_t runFaceDetection();
-
-    status_t           setParameters(const QCameraParameters& params);
-    QCameraParameters&  getParameters() ;
-
-    status_t setCameraMode(const QCameraParameters& params);
-    status_t setPictureSizeTable(void);
-    status_t setPreviewSizeTable(void);
-    status_t setVideoSizeTable(void);
-    status_t setPreviewSize(const QCameraParameters& params);
-    status_t setJpegThumbnailSize(const QCameraParameters& params);
-    status_t setPreviewFpsRange(const QCameraParameters& params);
-    status_t setPreviewFrameRate(const QCameraParameters& params);
-    status_t setPreviewFrameRateMode(const QCameraParameters& params);
-    status_t setVideoSize(const QCameraParameters& params);
-    status_t setPictureSize(const QCameraParameters& params);
-    status_t setJpegQuality(const QCameraParameters& params);
-    status_t setNumOfSnapshot(const QCameraParameters& params);
-    status_t setJpegRotation(int isZSL);
-    int getJpegRotation(void);
-    int getISOSpeedValue();
-    int getAutoFlickerMode();
-    status_t setAntibanding(const QCameraParameters& params);
-    status_t setEffect(const QCameraParameters& params);
-    status_t setExposureCompensation(const QCameraParameters &params);
-    status_t setAutoExposure(const QCameraParameters& params);
-    status_t setWhiteBalance(const QCameraParameters& params);
-    status_t setFlash(const QCameraParameters& params);
-    status_t setGpsLocation(const QCameraParameters& params);
-    status_t setRotation(const QCameraParameters& params);
-    status_t setZoom(const QCameraParameters& params);
-    status_t setFocusMode(const QCameraParameters& params);
-    status_t setBrightness(const QCameraParameters& params);
-    status_t setSkinToneEnhancement(const QCameraParameters& params);
-    status_t setOrientation(const QCameraParameters& params);
-    status_t setLensshadeValue(const QCameraParameters& params);
-    status_t setMCEValue(const QCameraParameters& params);
-    status_t setISOValue(const QCameraParameters& params);
-    status_t setPictureFormat(const QCameraParameters& params);
-    status_t setSharpness(const QCameraParameters& params);
-    status_t setContrast(const QCameraParameters& params);
-    status_t setSaturation(const QCameraParameters& params);
-    status_t setWaveletDenoise(const QCameraParameters& params);
-    status_t setSceneMode(const QCameraParameters& params);
-    status_t setContinuousAf(const QCameraParameters& params);
-    status_t setFaceDetection(const char *str);
-    status_t setSceneDetect(const QCameraParameters& params);
-    status_t setStrTextures(const QCameraParameters& params);
-    status_t setPreviewFormat(const QCameraParameters& params);
-    status_t setSelectableZoneAf(const QCameraParameters& params);
-    status_t setOverlayFormats(const QCameraParameters& params);
-    status_t setHighFrameRate(const QCameraParameters& params);
-    status_t setRedeyeReduction(const QCameraParameters& params);
-    status_t setAEBracket(const QCameraParameters& params);
-    status_t setFaceDetect(const QCameraParameters& params);
-    status_t setDenoise(const QCameraParameters& params);
-    status_t setAecAwbLock(const QCameraParameters & params);
-    status_t setHistogram(int histogram_en);
-    status_t setRecordingHint(const QCameraParameters& params);
-    status_t setRecordingHintValue(const int32_t value);
-    status_t setFocusAreas(const QCameraParameters& params);
-    status_t setMeteringAreas(const QCameraParameters& params);
-    status_t setFullLiveshot(void);
-    status_t setDISMode(void);
-    status_t setCaptureBurstExp(void);
-    status_t setPowerMode(const QCameraParameters& params);
-    void takePicturePrepareHardware( );
-    status_t setNoDisplayMode(const QCameraParameters& params);
-    status_t setDimension();
-    status_t setRDIMode(const QCameraParameters& params);
-    status_t setMobiCat(const QCameraParameters& params);
-
-    isp3a_af_mode_t getAutoFocusMode(const QCameraParameters& params);
-    bool isValidDimension(int w, int h);
-
-    String8 create_values_str(const str_map *values, int len);
-
-    void setMyMode(int mode);
-    bool isZSLMode();
-    bool isWDenoiseEnabled();
-    void wdenoiseEvent(cam_ctrl_status_t status, void *cookie);
-    bool isLowPowerCamcorder();
-    void freePictureTable(void);
-    void freeVideoSizeTable(void);
-
-    int32_t createPreview();
-    int32_t createRecord();
-    int32_t createSnapshot();
-    int32_t createRdi();
-
-    int getHDRMode();
-    //EXIF
-    void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
-                        uint32_t count, uint8_t copy, void *data);
-    void setExifTags();
-    void initExifData();
-    void deinitExifData();
-    void setExifTagsGPS();
-    exif_tags_info_t* getExifData(){ return mExifData; }
-    int getExifTableNumEntries() { return mExifTableNumEntries; }
-    void parseGPSCoordinate(const char *latlonString, rat_t* coord);
-    //added to support hdr
-    bool getHdrInfoAndSetExp(int max_num_frm, int *num_frame, int *exp);
-    status_t initHistogramBuffers();
-    status_t deInitHistogramBuffers();
-    mm_jpeg_color_format getColorfmtFromImgFmt(uint32_t img_fmt);
-
-    void notifyHdrEvent(cam_ctrl_status_t status, void * cookie);
-    void initHdrInfoForSnapshot(bool Hdr_on, int number_frames, int *exp );
-    void doHdrProcessing();
-
-    int           mCameraId;
-    camera_mode_t myMode;
-
-    mm_camear_mem_vtbl_t mem_hooks;
-
-    QCameraParameters    mParameters;
-    int32_t             mMsgEnabled;
-
-    camera_notify_callback         mNotifyCb;
-    camera_data_callback           mDataCb;
-    camera_data_timestamp_callback mDataCbTimestamp;
-    camera_request_memory          mGetMemory;
-    void                           *mCallbackCookie;
-
-    mutable Mutex       mLock;
-    Mutex         mPreviewMemoryLock;
-    Mutex         mAutofocusLock;
-    Mutex         mRecordFrameLock;
-    Condition     mRecordWait;
-    pthread_mutex_t     mAsyncCmdMutex;
-    pthread_cond_t      mAsyncCmdWait;
-
-    QCameraStream *     mStreams[MM_CAMERA_IMG_MODE_MAX];
-    cam_ctrl_dimension_t mDimension;
-    int  mPreviewWidth, mPreviewHeight;
-    int  mPictureWidth, mPictureHeight;
-    int  videoWidth, videoHeight;
-    int  thumbnailWidth, thumbnailHeight;
-    int  maxSnapshotWidth, maxSnapshotHeight;
-    int  mRdiWidth,mRdiHeight;
-    int  mPreviewFormat;
-    int  mFps;
-    int  mDebugFps;
-    int  mBrightness;
-    int  mContrast;
-    int  mBestShotMode;
-    int  mEffects;
-    int  mColorEffects;
-    int  mSkinToneEnhancement;
-    int  mDenoiseValue;
-    int  mHJR;
-    int  mRotation;
-    int  mJpegQuality;
-    int  mThumbnailQuality;
-    int  mTargetSmoothZoom;
-    int  mSmoothZoomStep;
-    int  mMaxZoom;
-    int  mCurrentZoom;
-    int  mSupportedPictureSizesCount;
-    int  mFaceDetectOn;
-    int  mDumpFrmCnt;
-    int  mDumpSkipCnt;
-    int  mFocusMode;
-    int  rdiMode;
-
-    unsigned int mPictureSizeCount;
-    unsigned int mPreviewSizeCount;
-    int mPowerMode;
-    unsigned int mVideoSizeCount;
-
-    bool mAutoFocusRunning;
-    bool mNeedToUnlockCaf;
-    bool mMultiTouch;
-    bool mHasAutoFocusSupport;
-    bool mInitialized;
-    bool mDisEnabled;
-    bool strTexturesOn;
-    bool mIs3DModeOn;
-    bool mSmoothZoomRunning;
-    bool mPreparingSnapshot;
-    bool mParamStringInitialized;
-    bool mZoomSupported;
-    bool mSendMetaData;
-    bool mFullLiveshotEnabled;
-    bool mRecordingHint;
-    bool mStartRecording;
-    bool mReleasedRecordingFrame;
-    int mHdrMode;
-    int mSnapshotFormat;
-    int mZslInterval;
-    bool mRestartPreview;
-    bool mMobiCatEnabled;
-    /*for histogram*/
-    int            mStatsOn;
-    int            mCurrentHisto;
-    bool           mSendData;
-    sp<AshmemPool> mStatHeap;
-    camera_memory_t *mStatsMapped[3];
-    QCameraStatHeap_t mHistServer;
-    int32_t        mStatSize;
-
-    bool mZslLookBackMode;
-    int mZslLookBackValue;
-	int mHFRLevel;
-    bool mZslEmptyQueueFlag;
-    String8 mEffectValues;
-    String8 mIsoValues;
-    String8 mSceneModeValues;
-    String8 mSceneDetectValues;
-    String8 mFocusModeValues;
-    String8 mSelectableZoneAfValues;
-    String8 mAutoExposureValues;
-    String8 mWhitebalanceValues;
-    String8 mAntibandingValues;
-    String8 mFrameRateModeValues;
-    String8 mTouchAfAecValues;
-    String8 mPreviewSizeValues;
-    String8 mPictureSizeValues;
-    String8 mVideoSizeValues;
-    String8 mFlashValues;
-    String8 mLensShadeValues;
-    String8 mMceValues;
-    String8 mHistogramValues;
-    String8 mSkinToneEnhancementValues;
-    String8 mPictureFormatValues;
-    String8 mDenoiseValues;
-    String8 mZoomRatioValues;
-    String8 mPreviewFrameRateValues;
-    String8 mPreviewFormatValues;
-    String8 mFaceDetectionValues;
-    String8 mHfrValues;
-    String8 mHfrSizeValues;
-    String8 mRedeyeReductionValues;
-    String8 denoise_value;
-    String8 mFpsRangesSupportedValues;
-    String8 mZslValues;
-    String8 mFocusDistance;
-
-    friend class QCameraStream;
-    friend class QCameraStream_record;
-    friend class QCameraStream_preview;
-    friend class QCameraStream_SnapshotMain;
-    friend class QCameraStream_SnapshotThumbnail;
-    friend class QCameraStream_Rdi;
-
-    android :: FPSRange* mSupportedFpsRanges;
-    int mSupportedFpsRangesCount;
-
-    camera_size_type* mPictureSizes;
-    camera_size_type* mPreviewSizes;
-    camera_size_type* mVideoSizes;
-    const camera_size_type * mPictureSizesPtr;
-    HAL_camera_state_type_t mCameraState;
-
-     int mStoreMetaDataInFrame;
-     preview_stream_ops_t *mPreviewWindow;
-     Mutex                mStateLock;
-     int                  mPreviewState;
-     /*preview memory with display case: memory is allocated and freed via
-     gralloc */
-     QCameraHalMemory_t   mPreviewMemory;
-
-     /*preview memory without display case: memory is allocated
-      directly by camera */
-     QCameraHalHeap_t     mNoDispPreviewMemory;
-     QCameraHalHeap_t     mRdiMemory;
-     QCameraHalHeap_t     mSnapshotMemory;
-     QCameraHalHeap_t     mThumbnailMemory;
-     QCameraHalHeap_t     mRecordingMemory;
-     QCameraHalHeap_t     mJpegMemory;
-     QCameraHalHeap_t     mRawMemory;
-     camera_frame_metadata_t mMetadata;
-     camera_face_t           mFace[MAX_ROI];
-     preview_format_info_t  mPreviewFormatInfo;
-     friend void stream_cb_routine(mm_camera_super_buf_t *bufs, void *userdata);
-     //EXIF
-     exif_tags_info_t       mExifData[MAX_EXIF_TABLE_ENTRIES];  //Exif tags for JPEG encoder
-     exif_values_t          mExifValues;                        //Exif values in usable format
-     int                    mExifTableNumEntries;            //NUmber of entries in mExifData
-     int                 mNoDisplayMode;
-     QCameraQueue mSuperBufQueue;     /* queue for raw super buf */
-     QCameraQueue mNotifyDataQueue;   /* queue for data notify */
-     QCameraCmdThread *mNotifyTh;     /* thread for data notify */
-     QCameraCmdThread *mDataProcTh;   /* thread for data process (jpeg encoding) */
-     mm_jpeg_ops_t mJpegHandle;
-     uint32_t mJpegClientHandle;
-     snap_hdr_record_t    mHdrInfo;
-     power_module_t*   mPowerModule;
-     cam_sensor_fps_range_t mSensorFpsRange;
-
-     static void *dataNotifyRoutine(void *data);
-     static void *dataProcessRoutine(void *data);
-     static void snapshot_jpeg_cb(jpeg_job_status_t status,
-                             uint8_t thumbnailDroppedFlag,
-                             uint32_t client_hdl,
-                             uint32_t jobId,
-                             uint8_t* out_data,
-                             uint32_t data_size,
-                             void *userdata);
-     static void receiveCompleteJpegPicture(jpeg_job_status_t status,
-                                            uint8_t thumbnailDroppedFlag,
-                                            uint32_t client_hdl,
-                                            uint32_t jobId,
-                                            uint8_t* out_data,
-                                            uint32_t data_size,
-                                            QCameraHardwareInterface* pme);
-     static void superbuf_cb_routine(mm_camera_super_buf_t *recvd_frame,
-                                     void *userdata);
-     static void receiveRawPicture(mm_camera_super_buf_t* recvd_frame,
-                                   QCameraHardwareInterface *pme);
-     status_t encodeData(mm_camera_super_buf_t* recvd_frame,
-                         uint32_t *jobId);
-     void notifyShutter(bool play_shutter_sound);
-     status_t sendDataNotify(int32_t msg_type,
-                             camera_memory_t *data,
-                             uint8_t index,
-                             camera_frame_metadata_t *metadata,
-                             QCameraHalHeap_t *heap);
-
-     void releaseSuperBuf(mm_camera_super_buf_t *super_buf);
-     void releaseAppCBData(app_notify_cb_t *app_cb);
-     static void releaseNofityData(void *data, void *user_data);
-     static void releaseProcData(void *data, void *user_data);
-     uint8_t canTakeFullSizeLiveshot();
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL/core/inc/QCameraHWI_Mem.h b/camera/QCamera/HAL/core/inc/QCameraHWI_Mem.h
deleted file mode 100755
index 11e4416..0000000
--- a/camera/QCamera/HAL/core/inc/QCameraHWI_Mem.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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 __QCAMERAHWI_MEM_H
-#define __QCAMERAHWI_MEM_H
-
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-#include <stdint.h>
-
-extern "C" {
-#include <linux/android_pmem.h>
-#include <linux/msm_ion.h>
-}
-
-#define VIDEO_BUFFER_COUNT NUM_RECORDING_BUFFERS
-#define VIDEO_BUFFER_COUNT_LOW_POWER_CAMCORDER 9
-
-#define PREVIEW_BUFFER_COUNT 5
-
-namespace android {
-
-// This class represents a heap which maintains several contiguous
-// buffers.  The heap may be backed by pmem (when pmem_pool contains
-// the name of a /dev/pmem* file), or by ashmem (when pmem_pool == NULL).
-
-struct MemPool : public RefBase {
-    MemPool(int buffer_size, int num_buffers,
-            int frame_size,
-            const char *name);
-
-    virtual ~MemPool() = 0;
-
-    void completeInitialization();
-    bool initialized() const {
-        return mHeap != NULL && mHeap->base() != MAP_FAILED;
-    }
-
-    virtual status_t dump(int fd, const Vector<String16>& args) const;
-
-    int mBufferSize;
-    int mAlignedBufferSize;
-    int mNumBuffers;
-    int mFrameSize;
-    sp<MemoryHeapBase> mHeap;
-    sp<MemoryBase> *mBuffers;
-
-    const char *mName;
-};
-
-class AshmemPool : public MemPool {
-public:
-    AshmemPool(int buffer_size, int num_buffers,
-               int frame_size,
-               const char *name);
-};
-
-class PmemPool : public MemPool {
-public:
-    PmemPool(const char *pmem_pool,
-             int flags, int pmem_type,
-             int buffer_size, int num_buffers,
-             int frame_size, int cbcr_offset,
-             int yoffset, const char *name);
-    virtual ~PmemPool();
-    int mFd;
-    int mPmemType;
-    int mCbCrOffset;
-    int myOffset;
-    int mCameraControlFd;
-    uint32_t mAlignedSize;
-    struct pmem_region mSize;
-};
-
-class IonPool : public MemPool {
-public:
-    IonPool( int flags,
-             int buffer_size, int num_buffers,
-             int frame_size, int cbcr_offset,
-             int yoffset, const char *name);
-    virtual ~IonPool();
-    int mFd;
-    int mCbCrOffset;
-    int myOffset;
-    int mCameraControlFd;
-    uint32_t mAlignedSize;
-private:
-    static const char mIonDevName[];
-};
-
-};
-#endif
diff --git a/camera/QCamera/HAL/core/inc/QCameraStream.h b/camera/QCamera/HAL/core/inc/QCameraStream.h
deleted file mode 100755
index 74afc8f..0000000
--- a/camera/QCamera/HAL/core/inc/QCameraStream.h
+++ /dev/null
@@ -1,316 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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_QCAMERA_STREAM_H
-#define ANDROID_HARDWARE_QCAMERA_STREAM_H
-
-
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <pthread.h>
-#include <semaphore.h>
-
-
-#include "QCameraHWI.h"
-#include "QCameraHWI_Mem.h"
-#include "mm_camera_interface.h"
-#include "mm_jpeg_interface.h"
-
-extern "C" {
-#define DEFAULT_STREAM_WIDTH 320
-#define DEFAULT_STREAM_HEIGHT 240
-#define DEFAULT_LIVESHOT_WIDTH 2592
-#define DEFAULT_LIVESHOT_HEIGHT 1944
-
-#define MM_CAMERA_CH_PREVIEW_MASK    (0x01 << MM_CAMERA_CH_PREVIEW)
-#define MM_CAMERA_CH_VIDEO_MASK      (0x01 << MM_CAMERA_CH_VIDEO)
-#define MM_CAMERA_CH_SNAPSHOT_MASK   (0x01 << MM_CAMERA_CH_SNAPSHOT)
-#define MM_CAMERA_CH_RDI_MASK        (0x01 << MM_CAMERA_CH_RDI)
-
-} /* extern C*/
-
-namespace android {
-
-class QCameraHardwareInterface;
-
-class QCameraStream { //: public virtual RefBase
-
-public:
-    bool mInit;
-    bool mActive;
-
-    uint32_t mCameraHandle;
-    uint32_t mChannelId;
-    uint32_t mStreamId;
-    uint32_t mWidth;
-    uint32_t mHeight;
-    uint32_t mFormat;
-    uint8_t mNumBuffers;
-    mm_camera_frame_len_offset mFrameOffsetInfo;
-    mm_camera_vtbl_t *p_mm_ops;
-    mm_camera_img_mode mExtImgMode;
-    uint8_t m_flag_no_cb;
-    uint8_t m_flag_stream_on;
-    image_crop_t mCrop;
-    QCameraHardwareInterface*  mHalCamCtrl;
-
-    void setResolution(mm_camera_dimension_t *res);
-    bool isResolutionSame(mm_camera_dimension_t *res);
-    void getResolution(mm_camera_dimension_t *res);
-    virtual void        release();
-
-    status_t setFormat();
-
-    //static status_t     openChannel(mm_camera_t *, mm_camera_channel_type_t ch_type);
-    void dataCallback(mm_camera_super_buf_t *bufs);
-    virtual int32_t streamOn();
-    virtual int32_t streamOff(bool aSync);
-    virtual status_t    initStream(uint8_t no_cb_needed, uint8_t stream_on);
-    virtual status_t    deinitStream();
-    virtual void releaseRecordingFrame(const void *opaque)
-    {
-      ;
-    }
-    virtual sp<IMemoryHeap> getHeap() const{return NULL;}
-    virtual sp<IMemoryHeap> getRawHeap() const {return NULL;}
-    virtual void *getLastQueuedFrame(void){return NULL;}
-    virtual void notifyROIEvent(fd_roi_t roi) {;}
-    virtual void notifyWDenoiseEvent(cam_ctrl_status_t status, void * cookie) {;}
-    virtual void notifyHdrEvent(cam_ctrl_status_t status, void * cookie){};
-    virtual int32_t setCrop();
-    virtual int getBuf(mm_camera_frame_len_offset *frame_offset_info,
-                       uint8_t num_bufs,
-                       uint8_t *initial_reg_flag,
-                       mm_camera_buf_def_t  *bufs) = 0;
-    virtual int putBuf(uint8_t num_bufs,
-                       mm_camera_buf_def_t *bufs) = 0;
-
-    QCameraStream();
-    QCameraStream(uint32_t CameraHandle,
-                  uint32_t ChannelId,
-                  uint32_t Width,
-                  uint32_t Height,
-                  uint32_t Format,
-                  uint8_t NumBuffers,
-                  mm_camera_vtbl_t *mm_ops,
-                  mm_camera_img_mode imgmode,
-                  camera_mode_t mode,
-                  QCameraHardwareInterface* camCtrl);
-    virtual ~QCameraStream();
-
-};
-/*
-*   Record Class
-*/
-class QCameraStream_record : public QCameraStream {
-public:
-  void        release() ;
-
-  QCameraStream_record(uint32_t CameraHandle,
-                       uint32_t ChannelId,
-                       uint32_t Width,
-                       uint32_t Height,
-                       uint32_t Format,
-                       uint8_t NumBuffers,
-                       mm_camera_vtbl_t *mm_ops,
-                       mm_camera_img_mode imgmode,
-                       camera_mode_t mode,
-                       QCameraHardwareInterface* camCtrl);
-  virtual             ~QCameraStream_record();
-
-  status_t processRecordFrame(mm_camera_super_buf_t *data);
-  status_t initEncodeBuffers();
-  status_t getBufferInfo(sp<IMemory>& Frame, size_t *alignedSize);
-
-  void releaseRecordingFrame(const void *opaque);
-  void debugShowVideoFPS() const;
-
-  void releaseEncodeBuffer();
-
-  int getBuf(mm_camera_frame_len_offset *frame_offset_info,
-             uint8_t num_bufs,
-             uint8_t *initial_reg_flag,
-             mm_camera_buf_def_t  *bufs);
-  int putBuf(uint8_t num_bufs,
-             mm_camera_buf_def_t *bufs);
-  status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
-
-private:
-  bool mDebugFps;
-  mm_camera_super_buf_t          mRecordedFrames[MM_CAMERA_MAX_NUM_FRAMES];
-  mm_camera_buf_def_t            mRecordBuf[2*VIDEO_BUFFER_COUNT];
-  int mJpegMaxSize;
-  QCameraStream *mStreamSnap;
-};
-
-class QCameraStream_preview : public QCameraStream {
-public:
-    QCameraStream_preview(uint32_t CameraHandle,
-                          uint32_t ChannelId,
-                          uint32_t Width,
-                          uint32_t Height,
-                          uint32_t Format,
-                          uint8_t NumBuffers,
-                          mm_camera_vtbl_t *mm_ops,
-                          mm_camera_img_mode imgmode,
-                          camera_mode_t mode,
-                          QCameraHardwareInterface* camCtrl);
-    virtual             ~QCameraStream_preview();
-    void        release() ;
-    void *getLastQueuedFrame(void);
-    /*init preview buffers with display case*/
-    status_t initDisplayBuffers();
-    /*init preview buffers without display case*/
-    status_t initPreviewOnlyBuffers();
-    status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
-    status_t processPreviewFrame(mm_camera_super_buf_t *frame);
-    /*init preview buffers with display case*/
-    status_t processPreviewFrameWithDisplay(mm_camera_super_buf_t *frame);
-    /*init preview buffers without display case*/
-    status_t processPreviewFrameWithOutDisplay(mm_camera_super_buf_t *frame);
-
-    void notifyROIEvent(fd_roi_t roi);
-    int32_t setCrop();
-    int getBuf(mm_camera_frame_len_offset *frame_offset_info,
-               uint8_t num_bufs,
-               uint8_t *initial_reg_flag,
-               mm_camera_buf_def_t  *bufs);
-    int putBuf(uint8_t num_bufs,
-               mm_camera_buf_def_t *bufs);
-
-    friend class QCameraHardwareInterface;
-
-private:
-    /*allocate and free buffers with display case*/
-    status_t                 getBufferFromSurface();
-    status_t                 putBufferToSurface();
-
-    /*allocate and free buffers without display case*/
-    status_t                 getBufferNoDisplay();
-    status_t                 freeBufferNoDisplay();
-
-    void                     dumpFrameToFile(mm_camera_buf_def_t* newFrame);
-    bool                     mFirstFrameRcvd;
-
-    int8_t                   my_id;
-    mm_camera_op_mode_type_t op_mode;
-    mm_camera_buf_def_t    *mLastQueuedFrame;
-    mm_camera_buf_def_t     mDisplayBuf[2*PREVIEW_BUFFER_COUNT];
-    Mutex                   mDisplayLock;
-    preview_stream_ops_t   *mPreviewWindow;
-    mm_camera_super_buf_t   mNotifyBuffer[2*PREVIEW_BUFFER_COUNT];
-    int8_t                  mNumFDRcvd;
-    int                     mVFEOutputs;
-    int                     mHFRFrameCnt;
-    int                     mHFRFrameSkip;
-};
-
-class QCameraStream_SnapshotMain : public QCameraStream {
-public:
-    void        release();
-    status_t    initStream(uint8_t no_cb_needed, uint8_t stream_on);
-    status_t    initMainBuffers();
-    void        deInitMainBuffers();
-    mm_camera_buf_def_t mSnapshotStreamBuf[MM_CAMERA_MAX_NUM_FRAMES];
-    QCameraStream_SnapshotMain(uint32_t CameraHandle,
-                               uint32_t ChannelId,
-                               uint32_t Width,
-                               uint32_t Height,
-                               uint32_t Format,
-                               uint8_t NumBuffers,
-                               mm_camera_vtbl_t *mm_ops,
-                               mm_camera_img_mode imgmode,
-                               camera_mode_t mode,
-                               QCameraHardwareInterface* camCtrl);
-    ~QCameraStream_SnapshotMain();
-    int getBuf(mm_camera_frame_len_offset *frame_offset_info,
-               uint8_t num_bufs,
-               uint8_t *initial_reg_flag,
-               mm_camera_buf_def_t  *bufs);
-    int putBuf(uint8_t num_bufs,
-               mm_camera_buf_def_t *bufs);
-
-private:
-    /*Member variables*/
-    int mSnapshotState;
-};
-
-class QCameraStream_SnapshotThumbnail : public QCameraStream {
-public:
-    void        release();
-    QCameraStream_SnapshotThumbnail(uint32_t CameraHandle,
-                                    uint32_t ChannelId,
-                                    uint32_t Width,
-                                    uint32_t Height,
-                                    uint32_t Format,
-                                    uint8_t NumBuffers,
-                                    mm_camera_vtbl_t *mm_ops,
-                                    mm_camera_img_mode imgmode,
-                                    camera_mode_t mode,
-                                    QCameraHardwareInterface* camCtrl);
-    ~QCameraStream_SnapshotThumbnail();
-    int getBuf(mm_camera_frame_len_offset *frame_offset_info,
-               uint8_t num_bufs,
-               uint8_t *initial_reg_flag,
-               mm_camera_buf_def_t  *bufs);
-    int putBuf(uint8_t num_bufs,
-               mm_camera_buf_def_t *bufs);
-    status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
-
-private:
-    mm_camera_buf_def_t mPostviewStreamBuf[MM_CAMERA_MAX_NUM_FRAMES];
-};
-
-class QCameraStream_Rdi : public QCameraStream {
-public:
-    void release() ;
-
-    QCameraStream_Rdi(uint32_t CameraHandle,
-                      uint32_t ChannelId,
-                      uint32_t Width,
-                      uint32_t Height,
-                      uint32_t Format,
-                      uint8_t NumBuffers,
-                      mm_camera_vtbl_t *mm_ops,
-                      mm_camera_img_mode imgmode,
-                      camera_mode_t mode,
-                      QCameraHardwareInterface* camCtrl);
-    virtual ~QCameraStream_Rdi();
-    status_t processRdiFrame (mm_camera_super_buf_t *data);
-    int getBuf(mm_camera_frame_len_offset *frame_offset_info,
-               uint8_t num_bufs,
-               uint8_t *initial_reg_flag,
-               mm_camera_buf_def_t  *bufs);
-    int putBuf(uint8_t num_bufs,
-               mm_camera_buf_def_t *bufs);
-    status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
-
-    friend class QCameraHardwareInterface;
-
-private:
-    void dumpFrameToFile(mm_camera_buf_def_t* newFrame);
-
-    int8_t my_id;
-    mm_camera_op_mode_type_t op_mode;
-    mm_camera_buf_def_t mRdiBuf[PREVIEW_BUFFER_COUNT];
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL/core/src/QCameraHAL.cpp b/camera/QCamera/HAL/core/src/QCameraHAL.cpp
deleted file mode 100755
index 858385b..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHAL.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHAL"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-
-/* include QCamera Hardware Interface Header*/
-#include "QCameraHAL.h"
-
-int HAL_numOfCameras = 0;
-mm_camera_info_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS];
-int HAL_currentCameraMode;
-
-namespace android {
-/* HAL function implementation goes here*/
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-extern "C" int HAL_getNumberOfCameras()
-{
-    /* try to query every time we get the call!*/
-    uint8_t num_camera = 0;
-    mm_camera_info_t * handle_base = 0;
-    ALOGV("%s: E", __func__);
-
-    handle_base= camera_query(&num_camera);
-
-    if (!handle_base) {
-        HAL_numOfCameras = 0;
-    }
-    else
-    {
-        camera_info_t* p_camera_info = NULL;
-        HAL_numOfCameras=num_camera;
-
-        ALOGI("Handle base =0x%p",handle_base);
-        ALOGI("getCameraInfo: numOfCameras = %d", HAL_numOfCameras);
-        for(int i = 0; i < HAL_numOfCameras; i++) {
-            ALOGI("Handle [%d]=0x%p",i,handle_base+i);
-            HAL_camerahandle[i]=handle_base + i;
-            p_camera_info = &(HAL_camerahandle[i]->camera_info);
-            if (p_camera_info) {
-                ALOGI("Camera sensor %d info:", i);
-                ALOGI("camera_id: %d", p_camera_info->camera_id);
-                ALOGI("modes_supported: %x", p_camera_info->modes_supported);
-                ALOGI("position: %d", p_camera_info->position);
-                ALOGI("sensor_mount_angle: %d", p_camera_info->sensor_mount_angle);
-            }
-        }
-    }
-
-    ALOGV("%s: X", __func__);
-
-    return HAL_numOfCameras;
-}
-
-extern "C" int HAL_isIn3DMode()
-{
-    return HAL_currentCameraMode == CAMERA_MODE_3D;
-}
-
-extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo)
-{
-    mm_camera_info_t *mm_camer_obj = 0;
-    ALOGV("%s: E", __func__);
-
-    if (!HAL_numOfCameras || HAL_numOfCameras < cameraId || !cameraInfo)
-        return;
-    else
-        mm_camer_obj = HAL_camerahandle[cameraId];
-
-    if (!mm_camer_obj)
-        return;
-    else {
-        cameraInfo->facing =
-            (FRONT_CAMERA == mm_camer_obj->camera_info.position)?
-            CAMERA_FACING_FRONT : CAMERA_FACING_BACK;
-        cameraInfo->orientation = mm_camer_obj->camera_info.sensor_mount_angle;
-    }
-   ALOGV("%s: X", __func__);
-   return;
-}
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" void * HAL_openCameraHardware(int cameraId, int mode)
-{
-    ALOGV("%s: E", __func__);
-    if (!HAL_numOfCameras || HAL_numOfCameras < cameraId ||cameraId < 0) {
-      return NULL;
-    }
-    return QCameraHAL_openCameraHardware(cameraId, mode);
-}
-
-
-}; // namespace android
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI.cpp b/camera/QCamera/HAL/core/src/QCameraHWI.cpp
deleted file mode 100755
index e3fb369..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI.cpp
+++ /dev/null
@@ -1,3619 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_NIDEBUG 0
-
-#define LOG_TAG "QCameraHWI"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-
-/* QCameraHardwareInterface class implementation goes here*/
-/* following code implement the contol logic of this class*/
-
-namespace android {
-
-extern void stream_cb_routine(mm_camera_super_buf_t *bufs,
-                       void *userdata);
-
-void QCameraHardwareInterface::superbuf_cb_routine(mm_camera_super_buf_t *recvd_frame, void *userdata)
-{
-    ALOGE("%s: E",__func__);
-    QCameraHardwareInterface *pme = (QCameraHardwareInterface *)userdata;
-    if(pme == NULL){
-       ALOGE("%s: pme is null", __func__);
-       return;
-    }
-
-    mm_camera_super_buf_t* frame =
-           (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
-    if (frame == NULL) {
-        ALOGE("%s: Error allocating memory to save received_frame structure.", __func__);
-        for (int i=0; i<recvd_frame->num_bufs; i++) {
-             if (recvd_frame->bufs[i] != NULL) {
-                 if (recvd_frame->bufs[i]->p_mobicat_info) {
-                    free(recvd_frame->bufs[i]->p_mobicat_info);
-                    recvd_frame->bufs[i]->p_mobicat_info = NULL;
-                 }
-                 pme->mCameraHandle->ops->qbuf(recvd_frame->camera_handle,
-                                               recvd_frame->ch_id,
-                                               recvd_frame->bufs[i]);
-                 pme->cache_ops((QCameraHalMemInfo_t *)(recvd_frame->bufs[i]->mem_info),
-                                recvd_frame->bufs[i]->buffer,
-                                ION_IOC_INV_CACHES);
-             }
-        }
-        return;
-    }
-    memcpy(frame, recvd_frame, sizeof(mm_camera_super_buf_t));
-    if(pme->mHdrInfo.hdr_on) {
-        pme->mHdrInfo.recvd_frame[pme->mHdrInfo.num_raw_received] = frame;
-
-        ALOGE("hdl %d, ch_id %d, buf_num %d, bufidx0 %d, bufidx1 %d",
-              pme->mHdrInfo.recvd_frame[pme->mHdrInfo.num_raw_received]->
-              camera_handle, pme->mHdrInfo.recvd_frame[pme->mHdrInfo.
-              num_raw_received]->ch_id, pme->mHdrInfo.recvd_frame[pme->
-              mHdrInfo.num_raw_received]->num_bufs, pme->mHdrInfo.
-              recvd_frame[pme->mHdrInfo.num_raw_received]->bufs[0]->buf_idx,
-              pme->mHdrInfo.recvd_frame[pme->mHdrInfo.num_raw_received]->
-              bufs[1]->buf_idx);
-
-        pme->mHdrInfo.num_raw_received++;
-
-        ALOGE("%s Total %d Received %d frames, still need to receive %d frames",
-              __func__, pme->mHdrInfo.num_frame, pme->mHdrInfo.num_raw_received,
-              (pme->mHdrInfo.num_frame - pme->mHdrInfo.num_raw_received));
-
-        if (pme->mHdrInfo.num_raw_received == pme->mHdrInfo.num_frame) {
-            ALOGE(" Received all %d YUV frames, Invoke HDR",
-                  pme->mHdrInfo.num_raw_received);
-            pme->doHdrProcessing();
-        }
-    } else {
-        /* enqueu to superbuf queue */
-        pme->mSuperBufQueue.enqueue(frame);
-
-        /* notify dataNotify thread that new super buf is avail
-         * check if it's done with current JPEG notification and
-         * a new encoding job could be conducted*/
-        pme->mNotifyTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
-    }
-   ALOGE("%s: X", __func__);
-
-}
-
-void QCameraHardwareInterface::snapshot_jpeg_cb(jpeg_job_status_t status,
-                             uint8_t thumbnailDroppedFlag,
-                             uint32_t client_hdl,
-                             uint32_t jobId,
-                             uint8_t* out_data,
-                             uint32_t data_size,
-                             void *userdata)
-{
-    ALOGE("%s: E", __func__);
-    camera_jpeg_encode_cookie_t *cookie =
-        (camera_jpeg_encode_cookie_t *)userdata;
-    if(cookie == NULL){
-       ALOGE("%s: userdata is null", __func__);
-       return;
-    }
-    QCameraHardwareInterface *pme = (QCameraHardwareInterface *)cookie->userdata;
-    if(pme == NULL){
-       ALOGE("%s: pme is null", __func__);
-       return;
-    }
-
-    /* no use of src frames, return them to kernel */
-    for(int i = 0; i< cookie->src_frame->num_bufs; i++) {
-        if (cookie->src_frame->bufs[i]->p_mobicat_info) {
-            free(cookie->src_frame->bufs[i]->p_mobicat_info);
-            cookie->src_frame->bufs[i]->p_mobicat_info = NULL;
-        }
-        pme->mCameraHandle->ops->qbuf(cookie->src_frame->camera_handle,
-                                      cookie->src_frame->ch_id,
-                                      cookie->src_frame->bufs[i]);
-        pme->cache_ops((QCameraHalMemInfo_t *)(cookie->src_frame->bufs[i]->mem_info),
-                      cookie->src_frame->bufs[i]->buffer,
-                      ION_IOC_INV_CACHES);
-    }
-    free(cookie->src_frame);
-    cookie->src_frame = NULL;
-
-    receiveCompleteJpegPicture(status,
-                               thumbnailDroppedFlag,
-                               client_hdl,
-                               jobId,
-                               out_data,
-                               data_size,
-                               pme);
-
-    /* free sink frame */
-    free(out_data);
-    /* free cookie */
-    free(cookie);
-
-    ALOGE("%s: X", __func__);
-}
-
-void QCameraHardwareInterface::releaseAppCBData(app_notify_cb_t *app_cb)
-{
-    if (app_cb->argm_data_cb.user_data != NULL) {
-        QCameraHalHeap_t *heap = (QCameraHalHeap_t *)app_cb->argm_data_cb.user_data;
-        releaseHeapMem(heap);
-    }
-}
-
-void QCameraHardwareInterface::releaseNofityData(void *data, void *user_data)
-{
-    QCameraHardwareInterface *pme = (QCameraHardwareInterface *)user_data;
-    if (NULL != pme) {
-        pme->releaseAppCBData((app_notify_cb_t *)data);
-    }
-}
-
-void QCameraHardwareInterface::releaseSuperBuf(mm_camera_super_buf_t *super_buf)
-{
-    if (NULL != super_buf) {
-        for(int i = 0; i< super_buf->num_bufs; i++) {
-            if (super_buf->bufs[i]->p_mobicat_info) {
-                free(super_buf->bufs[i]->p_mobicat_info);
-                super_buf->bufs[i]->p_mobicat_info = NULL;
-            }
-            mCameraHandle->ops->qbuf(super_buf->camera_handle,
-                                     super_buf->ch_id,
-                                     super_buf->bufs[i]);
-            cache_ops((QCameraHalMemInfo_t *)(super_buf->bufs[i]->mem_info),
-                      super_buf->bufs[i]->buffer,
-                      ION_IOC_INV_CACHES);
-        }
-    }
-}
-
-void QCameraHardwareInterface::releaseProcData(void *data, void *user_data)
-{
-    QCameraHardwareInterface *pme = (QCameraHardwareInterface *)user_data;
-    if (NULL != pme) {
-        pme->releaseSuperBuf((mm_camera_super_buf_t *)data);
-    }
-}
-
-void *QCameraHardwareInterface::dataNotifyRoutine(void *data)
-{
-    int running = 1;
-    int ret;
-    QCameraHardwareInterface *pme = (QCameraHardwareInterface *)data;
-    QCameraCmdThread *cmdThread = pme->mNotifyTh;
-    uint8_t isEncoding = FALSE;
-    uint8_t isActive = FALSE;
-    uint32_t numOfSnapshotExpected = 0;
-    uint32_t numOfSnapshotRcvd = 0;
-
-    ALOGD("%s: E", __func__);
-    do {
-        do {
-            ret = sem_wait(&cmdThread->cmd_sem);
-            if (ret != 0 && errno != EINVAL) {
-                ALOGE("%s: sem_wait error (%s)",
-                           __func__, strerror(errno));
-                return NULL;
-            }
-        } while (ret != 0);
-
-        /* we got notified about new cmd avail in cmd queue */
-        camera_cmd_type_t cmd = cmdThread->getCmd();
-        ALOGD("%s: get cmd %d", __func__, cmd);
-        switch (cmd) {
-        case CAMERA_CMD_TYPE_START_DATA_PROC:
-            isActive = TRUE;
-            /* init flag to FALSE */
-            isEncoding = FALSE;
-            numOfSnapshotExpected = pme->getNumOfSnapshots();
-            numOfSnapshotRcvd = 0;
-            break;
-        case CAMERA_CMD_TYPE_STOP_DATA_PROC:
-            /* flush jpeg data queue */
-            pme->mNotifyDataQueue.flush();
-
-            isActive = FALSE;
-            /* set flag to FALSE */
-            isEncoding = FALSE;
-            numOfSnapshotExpected = 0;
-            numOfSnapshotRcvd = 0;
-            break;
-        case CAMERA_CMD_TYPE_DO_NEXT_JOB:
-            {
-                if (TRUE == isActive) {
-                    /* first check if there is any pending jpeg notify */
-                    app_notify_cb_t *app_cb =
-                        (app_notify_cb_t *)pme->mNotifyDataQueue.dequeue();
-                    if (NULL != app_cb) {
-                        /* send notify to upper layer */
-                        if (app_cb->notifyCb) {
-                            ALOGE("%s: evt notify cb", __func__);
-                            app_cb->notifyCb(app_cb->argm_notify.msg_type,
-                                             app_cb->argm_notify.ext1,
-                                             app_cb->argm_notify.ext2,
-                                             app_cb->argm_notify.cookie);
-                        }
-                        if (app_cb->dataCb) {
-                            ALOGE("%s: data notify cb", __func__);
-                            app_cb->dataCb(app_cb->argm_data_cb.msg_type,
-                                           app_cb->argm_data_cb.data,
-                                           app_cb->argm_data_cb.index,
-                                           app_cb->argm_data_cb.metadata,
-                                           app_cb->argm_data_cb.cookie);
-                            if (CAMERA_MSG_COMPRESSED_IMAGE == app_cb->argm_data_cb.msg_type) {
-                                numOfSnapshotRcvd++;
-                                isEncoding = FALSE;
-                            }
-                        }
-
-                        /* free app_cb */
-                        pme->releaseAppCBData(app_cb);
-                        free(app_cb);
-                    }
-
-                    if ((FALSE == isEncoding) && !pme->mSuperBufQueue.is_empty()) {
-                        isEncoding = TRUE;
-                        /* notify processData thread to do next encoding job */
-                        pme->mDataProcTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
-                    }
-
-                    if (numOfSnapshotExpected > 0 &&
-                        numOfSnapshotExpected == numOfSnapshotRcvd) {
-                        pme->cancelPictureInternal();
-                    }
-                } else {
-                    /* do no op if not active */
-                    app_notify_cb_t *app_cb =
-                        (app_notify_cb_t *)pme->mNotifyDataQueue.dequeue();
-                    if (NULL != app_cb) {
-                        /* free app_cb */
-                        pme->releaseAppCBData(app_cb);
-                        free(app_cb);
-                    }
-                }
-            }
-            break;
-        case CAMERA_CMD_TYPE_EXIT:
-            {
-                /* flush jpeg data queue */
-                pme->mNotifyDataQueue.flush();
-                running = 0;
-            }
-            break;
-        default:
-            break;
-        }
-    } while (running);
-    ALOGD("%s: X", __func__);
-    return NULL;
-}
-
-void *QCameraHardwareInterface::dataProcessRoutine(void *data)
-{
-    int running = 1;
-    int ret;
-    uint8_t is_active = FALSE;
-    QCameraHardwareInterface *pme = (QCameraHardwareInterface *)data;
-    QCameraCmdThread *cmdThread = pme->mDataProcTh;
-    uint32_t current_jobId = 0;
-
-    ALOGD("%s: E", __func__);
-    do {
-        do {
-            ret = sem_wait(&cmdThread->cmd_sem);
-            if (ret != 0 && errno != EINVAL) {
-                ALOGE("%s: sem_wait error (%s)",
-                           __func__, strerror(errno));
-                return NULL;
-            }
-        } while (ret != 0);
-
-        /* we got notified about new cmd avail in cmd queue */
-        camera_cmd_type_t cmd = cmdThread->getCmd();
-        ALOGD("%s: get cmd %d", __func__, cmd);
-        switch (cmd) {
-        case CAMERA_CMD_TYPE_START_DATA_PROC:
-            is_active = TRUE;
-            break;
-        case CAMERA_CMD_TYPE_STOP_DATA_PROC:
-            {
-                is_active = FALSE;
-                /* abort current job if it's running */
-                if (current_jobId > 0) {
-                    pme->mJpegHandle.abort_job(pme->mJpegClientHandle, current_jobId);
-                    current_jobId = 0;
-                }
-                /* flush superBufQueue */
-                pme->mSuperBufQueue.flush();
-                /* signal cmd is completed */
-                sem_post(&cmdThread->sync_sem);
-            }
-            break;
-        case CAMERA_CMD_TYPE_DO_NEXT_JOB:
-            {
-                ALOGD("%s: active is %d", __func__, is_active);
-                if (is_active == TRUE) {
-                    /* first check if there is any pending jpeg notify */
-                    mm_camera_super_buf_t *super_buf =
-                        (mm_camera_super_buf_t *)pme->mSuperBufQueue.dequeue();
-                    if (NULL != super_buf) {
-                        //play shutter sound
-                        if(!pme->mShutterSoundPlayed){
-                            pme->notifyShutter(true);
-                        }
-                        pme->notifyShutter(false);
-                        pme->mShutterSoundPlayed = false;
-
-                        if (pme->isRawSnapshot()) {
-                            receiveRawPicture(super_buf, pme);
-
-                            /*free superbuf*/
-                            pme->releaseSuperBuf(super_buf);
-                            free(super_buf);
-                        } else{
-                            ret = pme->encodeData(super_buf, &current_jobId);
-
-                             if (NO_ERROR != ret) {
-                                 pme->releaseSuperBuf(super_buf);
-                                 free(super_buf);
-                                 pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
-                                                     NULL,
-                                                     0,
-                                                     NULL,
-                                                     NULL);
-                             }
-                        }
-                    }
-                } else {
-                    /* not active, simply return buf and do no op */
-                    mm_camera_super_buf_t *super_buf =
-                        (mm_camera_super_buf_t *)pme->mSuperBufQueue.dequeue();
-                    if (NULL != super_buf) {
-                        pme->releaseSuperBuf(super_buf);
-                        free(super_buf);
-                    }
-                }
-            }
-            break;
-        case CAMERA_CMD_TYPE_EXIT:
-            /* abort current job if it's running */
-            if (current_jobId > 0) {
-                pme->mJpegHandle.abort_job(pme->mJpegClientHandle, current_jobId);
-                current_jobId = 0;
-            }
-            /* flush super buf queue */
-            pme->mSuperBufQueue.flush();
-            running = 0;
-            break;
-        default:
-            break;
-        }
-    } while (running);
-    ALOGD("%s: X", __func__);
-    return NULL;
-}
-
-void QCameraHardwareInterface::notifyShutter(bool play_shutter_sound){
-     ALOGV("%s : E", __func__);
-     if(mNotifyCb){
-         mNotifyCb(CAMERA_MSG_SHUTTER, 0, play_shutter_sound, mCallbackCookie);
-     }
-     ALOGV("%s : X", __func__);
-}
-
-status_t QCameraHardwareInterface::encodeData(mm_camera_super_buf_t* recvd_frame,
-                                              uint32_t *jobId)
-{
-    ALOGV("%s : E", __func__);
-    int32_t ret = NO_ERROR;
-    mm_jpeg_job jpg_job;
-    mm_camera_buf_def_t *main_frame = NULL;
-    mm_camera_buf_def_t *thumb_frame = NULL;
-    src_image_buffer_info *main_buf_info = NULL;
-    src_image_buffer_info *thumb_buf_info = NULL;
-    QCameraHalMemInfo_t *main_mem_info = NULL;
-    QCameraHalMemInfo_t *thumb_mem_info = NULL;
-
-    uint8_t src_img_num = recvd_frame->num_bufs;
-    int i;
-
-    *jobId = 0;
-
-    QCameraStream *main_stream = mStreams[MM_CAMERA_SNAPSHOT_MAIN];
-    for (i = 0; i < recvd_frame->num_bufs; i++) {
-        if (main_stream->mStreamId == recvd_frame->bufs[i]->stream_id) {
-            main_frame = recvd_frame->bufs[i];
-            break;
-        }
-    }
-    if(main_frame == NULL){
-       ALOGE("%s : Main frame is NULL", __func__);
-       return ret;
-    }
-    main_mem_info = &mSnapshotMemory.mem_info[main_frame->buf_idx];
-
-    // send upperlayer callback for raw image (data or notify, not both)
-    app_notify_cb_t *app_cb = (app_notify_cb_t *)malloc(sizeof(app_notify_cb_t));
-    if (app_cb != NULL) {
-        memset(app_cb, 0, sizeof(app_notify_cb_t));
-
-        if((mDataCb) && (mMsgEnabled & CAMERA_MSG_RAW_IMAGE)){
-            app_cb->dataCb = mDataCb;
-            app_cb->argm_data_cb.msg_type = CAMERA_MSG_RAW_IMAGE;
-            app_cb->argm_data_cb.cookie = mCallbackCookie;
-            app_cb->argm_data_cb.data = mSnapshotMemory.camera_memory[main_frame->buf_idx];
-            app_cb->argm_data_cb.index = 1;
-            app_cb->argm_data_cb.metadata = NULL;
-            app_cb->argm_data_cb.user_data = NULL;
-        }
-        if((mNotifyCb) && (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY)){
-            app_cb->notifyCb = mNotifyCb;
-            app_cb->argm_notify.msg_type = CAMERA_MSG_RAW_IMAGE_NOTIFY;
-            app_cb->argm_notify.cookie = mCallbackCookie;
-            app_cb->argm_notify.ext1 = 0;
-            app_cb->argm_notify.ext2 = 0;
-        }
-
-        /* enqueue jpeg_data into jpeg data queue */
-        if ((app_cb->dataCb || app_cb->notifyCb) && mNotifyDataQueue.enqueue((void *)app_cb)) {
-            mNotifyTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
-        } else {
-            free(app_cb);
-        }
-    } else {
-        ALOGE("%s: No mem for app_notify_cb_t", __func__);
-    }
-
-    camera_jpeg_encode_cookie_t *cookie =
-        (camera_jpeg_encode_cookie_t *)malloc(sizeof(camera_jpeg_encode_cookie_t));
-    if (NULL == cookie) {
-        ALOGE("%s : no mem for cookie", __func__);
-        return -1;
-    }
-    cookie->src_frame = recvd_frame;
-    cookie->userdata = this;
-
-    dumpFrameToFile(main_frame, HAL_DUMP_FRM_MAIN);
-
-    QCameraStream *thumb_stream = NULL;
-    if (recvd_frame->num_bufs > 1) {
-        /* has thumbnail */
-        if(!isZSLMode()) {
-            thumb_stream = mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]; //mStreamSnapThumb;
-        } else {
-            thumb_stream = mStreams[MM_CAMERA_PREVIEW]; //mStreamDisplay;
-        }
-        for (i = 0; i < recvd_frame->num_bufs; i++) {
-            if (thumb_stream->mStreamId == recvd_frame->bufs[i]->stream_id) {
-                thumb_frame = recvd_frame->bufs[i];
-                break;
-            }
-        }
-        if (NULL != thumb_frame) {
-            if(thumb_stream == mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]) {
-                thumb_mem_info = &mThumbnailMemory.mem_info[thumb_frame->buf_idx];
-            } else {
-                if (isNoDisplayMode()) {
-                    thumb_mem_info = &mNoDispPreviewMemory.mem_info[thumb_frame->buf_idx];
-                } else {
-                    thumb_mem_info = &mPreviewMemory.mem_info[thumb_frame->buf_idx];
-                }
-            }
-        }
-    }  else if(mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mWidth &&
-               mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mHeight) {
-        /*thumbnail is required, not YUV thumbnail, borrow main image*/
-        thumb_stream = main_stream;
-        thumb_frame = main_frame;
-        src_img_num++;
-    }
-
-    if (thumb_stream) {
-        dumpFrameToFile(thumb_frame, HAL_DUMP_FRM_THUMBNAIL);
-    }
-
-    int jpeg_quality = getJpegQuality();
-    if (jpeg_quality <= 0) {
-        jpeg_quality = 85;
-    }
-
-    memset(&jpg_job, 0, sizeof(mm_jpeg_job));
-    jpg_job.job_type = JPEG_JOB_TYPE_ENCODE;
-    jpg_job.encode_job.userdata = cookie;
-    jpg_job.encode_job.jpeg_cb = QCameraHardwareInterface::snapshot_jpeg_cb;
-    jpg_job.encode_job.encode_parm.exif_data = getExifData();
-    jpg_job.encode_job.encode_parm.exif_numEntries = getExifTableNumEntries();
-    jpg_job.encode_job.encode_parm.rotation = getJpegRotation();
-    ALOGV("%s: jpeg rotation is set to %d", __func__, jpg_job.encode_job.encode_parm.rotation);
-    jpg_job.encode_job.encode_parm.buf_info.src_imgs.src_img_num = src_img_num;
-    jpg_job.encode_job.encode_parm.buf_info.src_imgs.is_video_frame = FALSE;
-
-    if (mMobiCatEnabled) {
-        main_frame->p_mobicat_info = (cam_exif_tags_t*)malloc(sizeof(cam_exif_tags_t));
-        if ((main_frame->p_mobicat_info != NULL) &&
-             mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_MOBICAT,
-                 main_frame->p_mobicat_info)
-                 == MM_CAMERA_OK) {
-                 ALOGV("%s:%d] Mobicat enabled %p %d", __func__, __LINE__,
-                       main_frame->p_mobicat_info->tags,
-                       main_frame->p_mobicat_info->data_len);
-        } else {
-              ALOGE("MM_CAMERA_PARM_MOBICAT get failed");
-        }
-    }
-    if (mMobiCatEnabled && main_frame->p_mobicat_info) {
-        jpg_job.encode_job.encode_parm.hasmobicat = 1;
-        jpg_job.encode_job.encode_parm.mobicat_data = (uint8_t *)main_frame->p_mobicat_info->tags;
-        jpg_job.encode_job.encode_parm.mobicat_data_length = main_frame->p_mobicat_info->data_len;
-     } else {
-        jpg_job.encode_job.encode_parm.hasmobicat = 0;
-     }
-
-     // fill in the src_img info
-    //main img
-    main_buf_info = &jpg_job.encode_job.encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN];
-    main_buf_info->type = JPEG_SRC_IMAGE_TYPE_MAIN;
-    main_buf_info->color_format = getColorfmtFromImgFmt(main_stream->mFormat);
-    main_buf_info->quality = jpeg_quality;
-    main_buf_info->src_image[0].fd = main_frame->fd;
-    main_buf_info->src_image[0].buf_vaddr = (uint8_t*) main_frame->buffer;
-    main_buf_info->src_dim.width = main_stream->mWidth;
-    main_buf_info->src_dim.height = main_stream->mHeight;
-    main_buf_info->out_dim.width = mPictureWidth;
-    main_buf_info->out_dim.height = mPictureHeight;
-    memcpy(&main_buf_info->crop, &main_stream->mCrop, sizeof(image_crop_t));
-
-    ALOGD("%s : Main Image :Input Dimension %d x %d output Dimension = %d X %d",
-          __func__, main_buf_info->src_dim.width, main_buf_info->src_dim.height,
-          main_buf_info->out_dim.width, main_buf_info->out_dim.height);
-    ALOGD("%s : Main Image :Crop %d x %d, offset = (%d, %d)",
-          __func__, main_buf_info->crop.width, main_buf_info->crop.height,
-          main_buf_info->crop.offset_x, main_buf_info->crop.offset_y);
-    main_buf_info->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
-    main_buf_info->num_bufs = 1;
-    main_buf_info->src_image[0].offset = main_stream->mFrameOffsetInfo;
-    ALOGD("%s : setting main image offset info, len = %d, offset = %d",
-          __func__, main_stream->mFrameOffsetInfo.mp[0].len,
-          main_stream->mFrameOffsetInfo.mp[0].offset);
-
-    cache_ops(main_mem_info, main_frame->buffer, ION_IOC_CLEAN_INV_CACHES);
-
-    if (thumb_frame && thumb_stream) {
-        /* fill in thumbnail src img encode param */
-        thumb_buf_info = &jpg_job.encode_job.encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB];
-        thumb_buf_info->type = JPEG_SRC_IMAGE_TYPE_THUMB;
-        thumb_buf_info->color_format = getColorfmtFromImgFmt(thumb_stream->mFormat);
-        //thumb_buf_info->quality = jpeg_quality;
-        thumb_buf_info->quality = 75; //hardcoded for now, will be calculated in encoder code later
-        thumb_buf_info->src_dim.width = thumb_stream->mWidth;
-        thumb_buf_info->src_dim.height = thumb_stream->mHeight;
-        thumb_buf_info->out_dim.width = thumbnailWidth;
-        thumb_buf_info->out_dim.height = thumbnailHeight;
-        memcpy(&thumb_buf_info->crop, &thumb_stream->mCrop, sizeof(image_crop_t));
-        ALOGD("%s : Thumanail :Input Dimension %d x %d output Dimension = %d X %d",
-          __func__, thumb_buf_info->src_dim.width, thumb_buf_info->src_dim.height,
-              thumb_buf_info->out_dim.width,thumb_buf_info->out_dim.height);
-        thumb_buf_info->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
-        thumb_buf_info->num_bufs = 1;
-        thumb_buf_info->src_image[0].fd = thumb_frame->fd;
-        thumb_buf_info->src_image[0].buf_vaddr = (uint8_t*) thumb_frame->buffer;
-        thumb_buf_info->src_image[0].offset = thumb_stream->mFrameOffsetInfo;
-        ALOGD("%s : setting thumb image offset info, len = %d, offset = %d",
-              __func__, thumb_stream->mFrameOffsetInfo.mp[0].len, thumb_stream->mFrameOffsetInfo.mp[0].offset);
-
-        cache_ops(thumb_mem_info, thumb_frame->buffer, ION_IOC_CLEAN_INV_CACHES);
-    }
-
-    uint32_t buf_len = main_stream->mFrameOffsetInfo.frame_len;
-    if (main_stream->m_flag_stream_on == FALSE) {
-        //if video-sized livesnapshot
-        jpg_job.encode_job.encode_parm.buf_info.src_imgs.is_video_frame = TRUE;
-
-        //use the same output resolution as input
-        main_buf_info->out_dim.width = main_buf_info->src_dim.width;
-        main_buf_info->out_dim.height = main_buf_info->src_dim.height;
-
-        if (thumb_buf_info->out_dim.width > thumb_buf_info->src_dim.width ||
-            thumb_buf_info->out_dim.height > thumb_buf_info->src_dim.height ) {
-            thumb_buf_info->out_dim.width = thumb_buf_info->src_dim.width;
-            thumb_buf_info->out_dim.height = thumb_buf_info->src_dim.height;
-        }
-
-        uint32_t len = main_buf_info->out_dim.width * main_buf_info->out_dim.height * 1.5;
-        if (len > buf_len) {
-            buf_len = len;
-        }
-    }
-
-    //fill in the sink img info
-    jpg_job.encode_job.encode_parm.buf_info.sink_img.buf_len = buf_len;
-    jpg_job.encode_job.encode_parm.buf_info.sink_img.buf_vaddr = (uint8_t *)malloc(buf_len);
-    if (NULL == jpg_job.encode_job.encode_parm.buf_info.sink_img.buf_vaddr) {
-        ALOGE("%s: ERROR: no memory for sink_img buf", __func__);
-        free(cookie);
-        cookie = NULL;
-        return -1;
-    }
-
-    if (mJpegClientHandle > 0) {
-        ret = mJpegHandle.start_job(mJpegClientHandle, &jpg_job, jobId);
-    } else {
-        ALOGE("%s: Error: bug here, mJpegClientHandle is 0", __func__);
-        free(cookie);
-        cookie = NULL;
-        return -1;
-    }
-
-    ALOGV("%s : X", __func__);
-    return ret;
-
-}
-
-status_t QCameraHardwareInterface::sendDataNotify(int32_t msg_type,
-                                                 camera_memory_t *data,
-                                                 uint8_t index,
-                                                 camera_frame_metadata_t *metadata,
-                                                 QCameraHalHeap_t *heap)
-{
-    app_notify_cb_t *app_cb = (app_notify_cb_t *)malloc(sizeof(app_notify_cb_t));
-    if (NULL == app_cb) {
-        ALOGE("%s: no mem for app_notify_cb_t", __func__);
-        return BAD_VALUE;
-    }
-    memset(app_cb, 0, sizeof(app_notify_cb_t));
-    app_cb->dataCb = mDataCb;
-    app_cb->argm_data_cb.msg_type = msg_type;
-    app_cb->argm_data_cb.cookie = mCallbackCookie;
-    app_cb->argm_data_cb.data = data;
-    app_cb->argm_data_cb.index = index;
-    app_cb->argm_data_cb.metadata = metadata;
-    app_cb->argm_data_cb.user_data = (void *)heap;
-
-    /* enqueue jpeg_data into jpeg data queue */
-    if (mNotifyDataQueue.enqueue((void *)app_cb)) {
-        mNotifyTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
-    } else {
-        free(app_cb);
-        return BAD_VALUE;
-    }
-    return NO_ERROR;
-}
-
-void QCameraHardwareInterface::receiveRawPicture(mm_camera_super_buf_t* recvd_frame,
-                                                 QCameraHardwareInterface *pme)
-{
-     ALOGV("%s : E", __func__);
-     status_t rc = NO_ERROR;
-     int buf_index = 0;
-
-     ALOGV("%s: is a raw snapshot", __func__);
-     /*RAW snapshot*/
-     if (recvd_frame->bufs[0] == NULL) {
-         ALOGE("%s: The main frame buffer is null", __func__);
-         return;
-     }
-
-     if (pme->mDataCb && (pme->mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)) {
-         if (pme->initHeapMem(&pme->mRawMemory,
-                              1,
-                              recvd_frame->bufs[0]->frame_len,
-                              MSM_PMEM_RAW_MAINIMG,
-                              NULL,
-                              NULL) < 0) {
-             ALOGE("%s : initHeapMem for raw, ret = NO_MEMORY", __func__);
-             return;
-         }
-
-         buf_index = recvd_frame->bufs[0]->buf_idx;
-         memcpy(pme->mRawMemory.camera_memory[0]->data,
-                pme->mSnapshotMemory.camera_memory[buf_index]->data,
-                recvd_frame->bufs[0]->frame_len);
-
-         rc = pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
-                                  pme->mRawMemory.camera_memory[0],
-                                  0,
-                                  NULL,
-                                  &pme->mRawMemory);
-         if (rc != NO_ERROR) {
-             pme->releaseHeapMem(&pme->mRawMemory);
-         }
-     }
-     ALOGV("%s : X", __func__);
-}
-
-void QCameraHardwareInterface::receiveCompleteJpegPicture(jpeg_job_status_t status,
-                                                          uint8_t thumbnailDroppedFlag,
-                                                          uint32_t client_hdl,
-                                                          uint32_t jobId,
-                                                          uint8_t* out_data,
-                                                          uint32_t data_size,
-                                                          QCameraHardwareInterface *pme)
-{
-    status_t rc = NO_ERROR;
-    ALOGE("%s: E", __func__);
-
-    pme->deinitExifData();
-
-    if(status == JPEG_JOB_STATUS_ERROR) {
-        ALOGE("Error event handled from jpeg");
-        if(pme->mDataCb && (pme->mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)){
-            pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
-                                NULL,
-                                0,
-                                NULL,
-                                NULL);
-        }
-        return;
-    }
-
-    if(thumbnailDroppedFlag) {
-        ALOGE("%s : Error in thumbnail encoding, no ops here", __func__);
-    }
-
-    pme->dumpFrameToFile(out_data,
-                         data_size,
-                         (char *)"debug",
-                         (char *)"jpg",
-                         jobId);
-
-    ALOGE("%s: jpeg_size=%d", __func__, data_size);
-
-    if(pme->mDataCb && (pme->mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)){
-        if (pme->initHeapMem(&pme->mJpegMemory,
-                             1,
-                             data_size,
-                             MSM_PMEM_MAX,
-                             NULL,
-                             NULL) < 0) {
-            ALOGE("%s : initHeapMem for jpeg, ret = NO_MEMORY", __func__);
-            if(pme->mDataCb && (pme->mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)){
-                pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
-                                    NULL,
-                                    0,
-                                    NULL,
-                                    NULL);
-            }
-            return;
-        }
-
-        memcpy(pme->mJpegMemory.camera_memory[0]->data, out_data, data_size);
-
-        ALOGE("%s : Calling upperlayer callback to store JPEG image", __func__);
-        rc = pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
-                                 pme->mJpegMemory.camera_memory[0],
-                                 0,
-                                 NULL,
-                                 &pme->mJpegMemory);
-        if (rc != NO_ERROR) {
-            pme->releaseHeapMem(&pme->mJpegMemory);
-        }
-    }
-
-    ALOGE("%s: X", __func__);
-}
-
-static void HAL_event_cb(uint32_t camera_handle, mm_camera_event_t *evt, void *user_data)
-{
-  QCameraHardwareInterface *obj = (QCameraHardwareInterface *)user_data;
-  if (obj) {
-    obj->processEvent(evt);
-  } else {
-    ALOGE("%s: NULL user_data", __func__);
-  }
-}
-
-int32_t QCameraHardwareInterface::createRdi()
-{
-    int32_t ret = MM_CAMERA_OK;
-    ALOGV("%s : BEGIN",__func__);
-    mStreams[MM_CAMERA_RDI] = new QCameraStream_Rdi(mCameraHandle->camera_handle,
-                                                    mChannelId,
-                                                    640/*Width*/,
-                                                    480/*Height*/,
-                                                    CAMERA_BAYER_SBGGR10/*Format*/,
-                                                    PREVIEW_BUFFER_COUNT/*NumBuffers*/,
-                                                    mCameraHandle,
-                                                    MM_CAMERA_RDI,
-                                                    myMode,
-                                                    this);
-    if (!mStreams[MM_CAMERA_RDI]) {
-        ALOGE("%s: error - can't creat RDI stream!", __func__);
-        return BAD_VALUE;
-    }
-
-    ALOGV("%s : END",__func__);
-    return ret;
-}
-
-int32_t QCameraHardwareInterface::createRecord()
-{
-    int32_t ret = MM_CAMERA_OK;
-    ALOGV("%s : BEGIN",__func__);
-
-    /*
-    * Creating Instance of record stream.
-    */
-    ALOGE("Mymode Record = %d",myMode);
-    mStreams[MM_CAMERA_VIDEO] = new QCameraStream_record(
-                                        mCameraHandle->camera_handle,
-                                        mChannelId,
-                                        640/*Width*/,
-                                        480/*Height*/,
-                                        0/*Format*/,
-                                        VIDEO_BUFFER_COUNT/*NumBuffers*/,
-                                        mCameraHandle,
-                                        MM_CAMERA_VIDEO,
-                                        myMode,
-                                        this);
-
-    if (!mStreams[MM_CAMERA_VIDEO]) {
-        ALOGE("%s: error - can't creat record stream!", __func__);
-        return BAD_VALUE;
-    }
-
-    /*Init Channel */
-    ALOGV("%s : END",__func__);
-    return ret;
-}
-int32_t QCameraHardwareInterface::createSnapshot()
-{
-    int32_t ret = MM_CAMERA_OK;
-    ALOGE("%s : BEGIN",__func__);
-    uint8_t NumBuffers = 1;
-
-    if(mHdrMode) {
-        ALOGE("%s mHdrMode = %d, setting NumBuffers to 3", __func__, mHdrMode);
-        NumBuffers = 3;
-    }
-
-    /*
-    * Creating Instance of Snapshot Main stream.
-    */
-    ALOGE("Mymode Snap = %d",myMode);
-    ALOGE("%s : before creating an instance of SnapshotMain, num buffers = %d", __func__, NumBuffers);
-    mStreams[MM_CAMERA_SNAPSHOT_MAIN] = new QCameraStream_SnapshotMain(
-                                                mCameraHandle->camera_handle,
-                                                mChannelId,
-                                                640,
-                                                480,
-                                                CAMERA_YUV_420_NV21,
-                                                NumBuffers,
-                                                mCameraHandle,
-                                                MM_CAMERA_SNAPSHOT_MAIN,
-                                                myMode,
-                                                this);
-    if (!mStreams[MM_CAMERA_SNAPSHOT_MAIN]) {
-        ALOGE("%s: error - can't creat snapshot stream!", __func__);
-        return BAD_VALUE;
-    }
-
-    /*
-     * Creating Instance of Snapshot Thumb stream.
-    */
-    ALOGE("Mymode Snap = %d",myMode);
-    mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL] = new QCameraStream_SnapshotThumbnail(
-                                                    mCameraHandle->camera_handle,
-                                                    mChannelId,
-                                                    512,
-                                                    384,
-                                                    CAMERA_YUV_420_NV21,
-                                                    NumBuffers,
-                                                    mCameraHandle,
-                                                    MM_CAMERA_SNAPSHOT_THUMBNAIL,
-                                                    myMode,
-                                                    this);
-    if (!mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]) {
-        ALOGE("%s: error - can't creat snapshot stream!", __func__);
-        return BAD_VALUE;
-    }
-
-    ALOGV("%s : END",__func__);
-    return ret;
-}
-int32_t QCameraHardwareInterface::createPreview()
-{
-    int32_t ret = MM_CAMERA_OK;
-    ALOGV("%s : BEGIN",__func__);
-
-    ALOGE("Mymode Preview = %d",myMode);
-    mStreams[MM_CAMERA_PREVIEW] = new QCameraStream_preview(
-                                        mCameraHandle->camera_handle,
-                                        mChannelId,
-                                        640/*Width*/,
-                                        480/*Height*/,
-                                        0/*Format*/,
-                                        7/*NumBuffers*/,
-                                        mCameraHandle,
-                                        MM_CAMERA_PREVIEW,
-                                        myMode,
-                                        this);
-    if (!mStreams[MM_CAMERA_PREVIEW]) {
-        ALOGE("%s: error - can't creat preview stream!", __func__);
-        return BAD_VALUE;
-    }
-
-    ALOGV("%s : END",__func__);
-    return ret;
-}
-
-/*Mem Hooks*/
-int32_t get_buffer_hook(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data,
-                        mm_camera_frame_len_offset *frame_offset_info,
-                        uint8_t num_bufs,
-                        uint8_t *initial_reg_flag,
-                        mm_camera_buf_def_t  *bufs)
-{
-    QCameraHardwareInterface *pme=(QCameraHardwareInterface *)user_data;
-    pme->getBuf(camera_handle, ch_id, stream_id,
-                user_data, frame_offset_info,
-                num_bufs,initial_reg_flag,
-                bufs);
-
-    return 0;
-}
-
-int32_t put_buffer_hook(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data, uint8_t num_bufs,
-                        mm_camera_buf_def_t *bufs)
-{
-    QCameraHardwareInterface *pme=(QCameraHardwareInterface *)user_data;
-    pme->putBuf(camera_handle, ch_id, stream_id,
-                user_data, num_bufs, bufs);
-
-    return 0;
-}
-
-int QCameraHardwareInterface::getBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data,
-                        mm_camera_frame_len_offset *frame_offset_info,
-                        uint8_t num_bufs,
-                        uint8_t *initial_reg_flag,
-                        mm_camera_buf_def_t *bufs)
-{
-    int ret = BAD_VALUE;
-    ALOGE("%s: len:%d, y_off:%d, cbcr:%d num buffers: %d planes:%d streamid:%d",
-          __func__,
-          frame_offset_info->frame_len,
-          frame_offset_info->mp[0].len,
-          frame_offset_info->mp[1].len,
-          num_bufs,frame_offset_info->num_planes,
-          stream_id);
-
-    for (int i = 0; i < MM_CAMERA_IMG_MODE_MAX; i++) {
-        if (mStreams[i] != NULL && mStreams[i]->mStreamId == stream_id) {
-            ret = mStreams[i]->getBuf(frame_offset_info, num_bufs, initial_reg_flag, bufs);
-            break;
-        }
-    }
-
-    return ret;
-}
-
-int QCameraHardwareInterface::putBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data, uint8_t num_bufs,
-                        mm_camera_buf_def_t *bufs)
-{
-    int ret = BAD_VALUE;
-    ALOGE("%s:E",__func__);
-    for (int i = 0; i < MM_CAMERA_IMG_MODE_MAX; i++) {
-        if (mStreams[i] && (mStreams[i]->mStreamId == stream_id)) {
-            ret = mStreams[i]->putBuf(num_bufs, bufs);
-            break;
-        }
-    }
-    return ret;
-}
-
-
-/* constructor */
-QCameraHardwareInterface::
-QCameraHardwareInterface(int cameraId, int mode)
-                  : mCameraId(cameraId),
-                    mParameters(),
-                    mMsgEnabled(0),
-                    mNotifyCb(0),
-                    mDataCb(0),
-                    mDataCbTimestamp(0),
-                    mCallbackCookie(0),
-                    mPreviewFormat(CAMERA_YUV_420_NV21),
-                    mFps(0),
-                    mDebugFps(0),
-    mBrightness(0),
-    mContrast(0),
-    mBestShotMode(0),
-    mEffects(0),
-    mSkinToneEnhancement(0),
-    mDenoiseValue(0),
-    mHJR(0),
-    mRotation(0),
-    mMaxZoom(0),
-    mCurrentZoom(0),
-    mSupportedPictureSizesCount(15),
-    mFaceDetectOn(0),
-    mDumpFrmCnt(0), mDumpSkipCnt(0),
-    mFocusMode(AF_MODE_MAX),
-    mPictureSizeCount(15),
-    mPreviewSizeCount(13),
-    mVideoSizeCount(0),
-    mAutoFocusRunning(false),
-    mHasAutoFocusSupport(false),
-    mInitialized(false),
-    mDisEnabled(0),
-    mIs3DModeOn(0),
-    mSmoothZoomRunning(false),
-    mParamStringInitialized(false),
-    mZoomSupported(false),
-    mFullLiveshotEnabled(true),
-    mRecordingHint(0),
-    mStartRecording(0),
-    mReleasedRecordingFrame(false),
-    mHdrMode(HDR_BRACKETING_OFF),
-    mSnapshotFormat(0),
-    mZslInterval(1),
-    mRestartPreview(false),
-    mStatsOn(0), mCurrentHisto(-1), mSendData(false), mStatHeap(NULL),
-    mZslLookBackMode(0),
-    mZslLookBackValue(0),
-    mZslEmptyQueueFlag(FALSE),
-    mPictureSizes(NULL),
-    mVideoSizes(NULL),
-    mCameraState(CAMERA_STATE_UNINITED),
-    mExifTableNumEntries(0),
-    mNoDisplayMode(0),
-    rdiMode(STREAM_IMAGE),
-    mSupportedFpsRanges(NULL),
-    mSupportedFpsRangesCount(0),
-    mPowerModule(0),
-    mNeedToUnlockCaf(false),
-    mSuperBufQueue(releaseProcData, this),
-    mNotifyDataQueue(releaseNofityData, this)
-{
-    ALOGI("QCameraHardwareInterface: E");
-    int32_t result = MM_CAMERA_E_GENERAL;
-    mMobiCatEnabled = false;
-    char value[PROPERTY_VALUE_MAX];
-
-    pthread_mutex_init(&mAsyncCmdMutex, NULL);
-    pthread_cond_init(&mAsyncCmdWait, NULL);
-
-    property_get("persist.debug.sf.showfps", value, "0");
-    mDebugFps = atoi(value);
-    mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-    mPreviewWindow = NULL;
-    property_get("camera.hal.fps", value, "0");
-    mFps = atoi(value);
-
-    ALOGI("Init mPreviewState = %d", mPreviewState);
-
-    property_get("persist.camera.hal.multitouchaf", value, "0");
-    mMultiTouch = atoi(value);
-
-    property_get("persist.camera.full.liveshot", value, "1");
-    mFullLiveshotEnabled = atoi(value);
-
-    property_get("persist.camera.hal.dis", value, "0");
-    mDisEnabled = atoi(value);
-
-    memset(&mem_hooks,0,sizeof(mm_camear_mem_vtbl_t));
-
-    mem_hooks.user_data=this;
-    mem_hooks.get_buf=get_buffer_hook;
-    mem_hooks.put_buf=put_buffer_hook;
-
-    /* Open camera stack! */
-    mCameraHandle=camera_open(mCameraId, &mem_hooks);
-    ALOGV("Cam open returned %p",mCameraHandle);
-    if(mCameraHandle == NULL) {
-          ALOGE("startCamera: cam_ops_open failed: id = %d", mCameraId);
-          return;
-    }
-    //sync API for mm-camera-interface
-    mCameraHandle->ops->sync(mCameraHandle->camera_handle);
-
-    mChannelId=mCameraHandle->ops->ch_acquire(mCameraHandle->camera_handle);
-    if(mChannelId<=0)
-    {
-        mCameraHandle->ops->camera_close(mCameraHandle->camera_handle);
-        return;
-    }
-    mm_camera_event_type_t evt;
-    for (int i = 0; i < MM_CAMERA_EVT_TYPE_MAX; i++) {
-        if(mCameraHandle->ops->is_event_supported(mCameraHandle->camera_handle,
-                                 (mm_camera_event_type_t )i )){
-            mCameraHandle->ops->register_event_notify(mCameraHandle->camera_handle,
-					   HAL_event_cb,
-					   (void *) this,
-					   (mm_camera_event_type_t) i);
-        }
-    }
-
-    loadTables();
-    /* Setup Picture Size and Preview size tables */
-    setPictureSizeTable();
-    ALOGD("%s: Picture table size: %d", __func__, mPictureSizeCount);
-    ALOGD("%s: Picture table: ", __func__);
-    for(unsigned int i=0; i < mPictureSizeCount;i++) {
-      ALOGD(" %d  %d", mPictureSizes[i].width, mPictureSizes[i].height);
-    }
-
-    setPreviewSizeTable();
-    ALOGD("%s: Preview table size: %d", __func__, mPreviewSizeCount);
-    ALOGD("%s: Preview table: ", __func__);
-    for(unsigned int i=0; i < mPreviewSizeCount;i++) {
-      ALOGD(" %d  %d", mPreviewSizes[i].width, mPreviewSizes[i].height);
-    }
-
-    setVideoSizeTable();
-    ALOGD("%s: Video table size: %d", __func__, mVideoSizeCount);
-    ALOGD("%s: Video table: ", __func__);
-    for(unsigned int i=0; i < mVideoSizeCount;i++) {
-      ALOGD(" %d  %d", mVideoSizes[i].width, mVideoSizes[i].height);
-    }
-    memset(&mHistServer, 0, sizeof(mHistServer));
-
-    /* set my mode - update myMode member variable due to difference in
-     enum definition between upper and lower layer*/
-    setMyMode(mode);
-    initDefaultParameters();
-
-    //Create Stream Objects
-    memset(mStreams, 0, sizeof(mStreams));
-
-    //Preview
-    result = createPreview();
-    if(result != MM_CAMERA_OK) {
-        ALOGE("%s X: Failed to create Preview Object",__func__);
-        return;
-    }
-
-    //Record
-    result = createRecord();
-    if(result != MM_CAMERA_OK) {
-        ALOGE("%s X: Failed to create Record Object",__func__);
-        return;
-    }
-    //Snapshot
-    result = createSnapshot();
-    if(result != MM_CAMERA_OK) {
-        ALOGE("%s X: Failed to create Record Object",__func__);
-        return;
-    }
-
-    memset(&mJpegHandle, 0, sizeof(mJpegHandle));
-    mJpegClientHandle = jpeg_open(&mJpegHandle);
-    if(!mJpegClientHandle) {
-        ALOGE("%s : jpeg_open did not work", __func__);
-        return;
-    }
-
-    /* launch jpeg notify thread and raw data proc thread */
-    mNotifyTh = new QCameraCmdThread();
-    if (mNotifyTh != NULL) {
-        mNotifyTh->launch(dataNotifyRoutine, this);
-    } else {
-        ALOGE("%s : no mem for mNotifyTh", __func__);
-        return;
-    }
-    mDataProcTh = new QCameraCmdThread();
-    if (mDataProcTh != NULL) {
-        mDataProcTh->launch(dataProcessRoutine, this);
-    } else {
-        ALOGE("%s : no mem for mDataProcTh", __func__);
-        return;
-    }
-
-    memset(&mHdrInfo, 0, sizeof(snap_hdr_record_t));
-    // initialize the mMetadata to set num_of_faces to 0
-    memset(&mMetadata, 0, sizeof(mMetadata));
-
-    if (hw_get_module(POWER_HARDWARE_MODULE_ID, (const hw_module_t **)&mPowerModule)) {
-        ALOGE("%s module not found", POWER_HARDWARE_MODULE_ID);
-    }
-
-    mCameraState = CAMERA_STATE_READY;
-    ALOGI("QCameraHardwareInterface: X");
-}
-
-QCameraHardwareInterface::~QCameraHardwareInterface()
-{
-    ALOGI("~QCameraHardwareInterface: E");
-
-    if (CAMERA_STATE_READY == mCameraState) {
-        stopPreview();
-        mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-    }
-
-    if(mSupportedFpsRanges != NULL) {
-        delete mSupportedFpsRanges;
-        mSupportedFpsRanges = NULL;
-    }
-
-    freePictureTable();
-    freeVideoSizeTable();
-
-    deInitHistogramBuffers();
-    if(mStatHeap != NULL) {
-      mStatHeap.clear( );
-      mStatHeap = NULL;
-    }
-
-    for (int i = 0; i < MM_CAMERA_IMG_MODE_MAX; i++) {
-        if (mStreams[i] != NULL) {
-            delete mStreams[i];
-            mStreams[i] = NULL;
-        }
-    }
-
-    for (int i = 0; i < MAX_HDR_EXP_FRAME_NUM; i++) {
-        if (mHdrInfo.recvd_frame[i] != NULL) {
-            free(mHdrInfo.recvd_frame[i]);
-            mHdrInfo.recvd_frame[i] = NULL;
-        }
-    }
-
-    if (mNotifyTh != NULL) {
-        mNotifyTh->exit();
-        delete mNotifyTh;
-        mNotifyTh = NULL;
-    }
-    if (mDataProcTh != NULL) {
-        mDataProcTh->exit();
-        delete mDataProcTh;
-        mDataProcTh = NULL;
-    }
-    if(mJpegClientHandle > 0) {
-        int rc = mJpegHandle.close(mJpegClientHandle);
-        ALOGE("%s: Jpeg closed, rc = %d, mJpegClientHandle = %x",
-              __func__, rc, mJpegClientHandle);
-        mJpegClientHandle = 0;
-        memset(&mJpegHandle, 0, sizeof(mJpegHandle));
-    }
-
-    if (NULL != mCameraHandle) {
-        mCameraHandle->ops->ch_release(mCameraHandle->camera_handle,
-                                       mChannelId);
-
-        mCameraHandle->ops->camera_close(mCameraHandle->camera_handle);
-    }
-
-    pthread_mutex_destroy(&mAsyncCmdMutex);
-    pthread_cond_destroy(&mAsyncCmdWait);
-
-    ALOGE("~QCameraHardwareInterface: X");
-}
-
-bool QCameraHardwareInterface::isCameraReady()
-{
-    ALOGE("isCameraReady mCameraState %d", mCameraState);
-    return (mCameraState == CAMERA_STATE_READY);
-}
-
-void QCameraHardwareInterface::release()
-{
-    ALOGI("release: E");
-    Mutex::Autolock l(&mLock);
-
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-        break;
-    case QCAMERA_HAL_PREVIEW_START:
-        break;
-    case QCAMERA_HAL_PREVIEW_STARTED:
-        stopPreviewInternal();
-    break;
-    case QCAMERA_HAL_RECORDING_STARTED:
-        stopRecordingInternal();
-        stopPreviewInternal();
-        break;
-    case QCAMERA_HAL_TAKE_PICTURE:
-        cancelPictureInternal();
-        break;
-    default:
-        break;
-    }
-    mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-    ALOGI("release: X");
-}
-
-void QCameraHardwareInterface::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)
-{
-    ALOGE("setCallbacks: E");
-    Mutex::Autolock lock(mLock);
-    mNotifyCb        = notify_cb;
-    mDataCb          = data_cb;
-    mDataCbTimestamp = data_cb_timestamp;
-    mGetMemory       = get_memory;
-    mCallbackCookie  = user;
-    ALOGI("setCallbacks: X");
-}
-
-void QCameraHardwareInterface::enableMsgType(int32_t msgType)
-{
-    ALOGI("enableMsgType: E, msgType =0x%x", msgType);
-    Mutex::Autolock lock(mLock);
-    mMsgEnabled |= msgType;
-    ALOGI("enableMsgType: X, msgType =0x%x, mMsgEnabled=0x%x", msgType, mMsgEnabled);
-}
-
-void QCameraHardwareInterface::disableMsgType(int32_t msgType)
-{
-    ALOGI("disableMsgType: E");
-    Mutex::Autolock lock(mLock);
-    mMsgEnabled &= ~msgType;
-    ALOGI("disableMsgType: X, msgType =0x%x, mMsgEnabled=0x%x", msgType, mMsgEnabled);
-}
-
-int QCameraHardwareInterface::msgTypeEnabled(int32_t msgType)
-{
-    ALOGI("msgTypeEnabled: E");
-    Mutex::Autolock lock(mLock);
-    return (mMsgEnabled & msgType);
-    ALOGI("msgTypeEnabled: X");
-}
-
-int QCameraHardwareInterface::dump(int fd)
-{
-    ALOGE("%s: not supported yet", __func__);
-    return -1;
-}
-
-status_t QCameraHardwareInterface::sendCommand(int32_t command, int32_t arg1,
-                                         int32_t arg2)
-{
-    ALOGI("sendCommand: E");
-    status_t rc = NO_ERROR;
-    Mutex::Autolock l(&mLock);
-
-    switch (command) {
-        case CAMERA_CMD_HISTOGRAM_ON:
-            ALOGE("histogram set to on");
-            rc = setHistogram(1);
-            break;
-        case CAMERA_CMD_HISTOGRAM_OFF:
-            ALOGE("histogram set to off");
-            rc = setHistogram(0);
-            break;
-        case CAMERA_CMD_HISTOGRAM_SEND_DATA:
-            ALOGE("histogram send data");
-            mSendData = true;
-            rc = NO_ERROR;
-            break;
-        case CAMERA_CMD_START_FACE_DETECTION:
-           if(supportsFaceDetection() == false){
-                ALOGE("Face detection support is not available");
-                return NO_ERROR;
-           }
-           setFaceDetection("on");
-           return runFaceDetection();
-        case CAMERA_CMD_STOP_FACE_DETECTION:
-           if(supportsFaceDetection() == false){
-                ALOGE("Face detection support is not available");
-                return NO_ERROR;
-           }
-           setFaceDetection("off");
-           return runFaceDetection();
-        default:
-            break;
-    }
-    ALOGI("sendCommand: X");
-    return rc;
-}
-
-void QCameraHardwareInterface::setMyMode(int mode)
-{
-    ALOGI("setMyMode: E");
-    if (mode & CAMERA_SUPPORT_MODE_3D) {
-        myMode = CAMERA_MODE_3D;
-    }else {
-        /* default mode is 2D */
-        myMode = CAMERA_MODE_2D;
-    }
-
-    if (mode & CAMERA_SUPPORT_MODE_ZSL) {
-        myMode = (camera_mode_t)(myMode |CAMERA_ZSL_MODE);
-    }else {
-       myMode = (camera_mode_t) (myMode | CAMERA_NONZSL_MODE);
-    }
-    ALOGI("setMyMode: Set mode to %d (passed mode: %d)", myMode, mode);
-    ALOGI("setMyMode: X");
-}
-/* static factory function */
-QCameraHardwareInterface *QCameraHardwareInterface::createInstance(int cameraId, int mode)
-{
-    ALOGI("createInstance: E");
-    QCameraHardwareInterface *cam = new QCameraHardwareInterface(cameraId, mode);
-    if (cam ) {
-      if (cam->mCameraState != CAMERA_STATE_READY) {
-        ALOGE("createInstance: Failed");
-        delete cam;
-        cam = NULL;
-      }
-    }
-
-    if (cam) {
-      ALOGI("createInstance: X");
-      return cam;
-    } else {
-      return NULL;
-    }
-}
-/* external plug in function */
-extern "C" void *
-QCameraHAL_openCameraHardware(int  cameraId, int mode)
-{
-    ALOGI("QCameraHAL_openCameraHardware: E");
-    return (void *) QCameraHardwareInterface::createInstance(cameraId, mode);
-}
-
-bool QCameraHardwareInterface::isPreviewRunning() {
-    ALOGI("isPreviewRunning: E");
-    bool ret = false;
-
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_START:
-    case QCAMERA_HAL_PREVIEW_STARTED:
-    case QCAMERA_HAL_RECORDING_STARTED:
-        ret = true;
-        break;
-    default:
-        break;
-    }
-    ALOGI("isPreviewRunning: X");
-    return ret;
-}
-
-bool QCameraHardwareInterface::isRecordingRunning() {
-    ALOGE("isRecordingRunning: E");
-    bool ret = false;
-    if(QCAMERA_HAL_RECORDING_STARTED == mPreviewState)
-      ret = true;
-    ALOGE("isRecordingRunning: X");
-    return ret;
-}
-
-bool QCameraHardwareInterface::isSnapshotRunning() {
-    ALOGE("isSnapshotRunning: E");
-    bool ret = false;
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-    case QCAMERA_HAL_PREVIEW_START:
-    case QCAMERA_HAL_PREVIEW_STARTED:
-    case QCAMERA_HAL_RECORDING_STARTED:
-    default:
-        break;
-    case QCAMERA_HAL_TAKE_PICTURE:
-        ret = true;
-        break;
-    }
-    ALOGI("isSnapshotRunning: X");
-    return ret;
-}
-
-bool QCameraHardwareInterface::isZSLMode() {
-    return (myMode & CAMERA_ZSL_MODE);
-}
-
-int QCameraHardwareInterface::getHDRMode() {
-    ALOGE("%s, mHdrMode = %d", __func__, mHdrMode);
-    return mHdrMode;
-}
-
-void QCameraHardwareInterface::debugShowPreviewFPS() const
-{
-    static int mFrameCount;
-    static int mLastFrameCount = 0;
-    static nsecs_t mLastFpsTime = 0;
-    static float mFps = 0;
-    mFrameCount++;
-    nsecs_t now = systemTime();
-    nsecs_t diff = now - mLastFpsTime;
-    if (diff > ms2ns(250)) {
-        mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
-        ALOGE("Preview Frames Per Second: %.4f", mFps);
-        mLastFpsTime = now;
-        mLastFrameCount = mFrameCount;
-    }
-}
-
-
-void QCameraHardwareInterface::
-processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) {
-    ALOGI("processPreviewChannelEvent: E");
-    switch(channelEvent) {
-        case MM_CAMERA_CH_EVT_STREAMING_ON:
-            break;
-        case MM_CAMERA_CH_EVT_STREAMING_OFF:
-            break;
-        case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE:
-            break;
-        default:
-            break;
-    }
-    ALOGI("processPreviewChannelEvent: X");
-    return;
-}
-
-void QCameraHardwareInterface::processRecordChannelEvent(
-  mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) {
-    ALOGI("processRecordChannelEvent: E");
-    switch(channelEvent) {
-        case MM_CAMERA_CH_EVT_STREAMING_ON:
-            break;
-        case MM_CAMERA_CH_EVT_STREAMING_OFF:
-            break;
-        case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE:
-            break;
-        default:
-            break;
-    }
-    ALOGI("processRecordChannelEvent: X");
-    return;
-}
-
-void QCameraHardwareInterface::
-processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) {
-    ALOGI("processSnapshotChannelEvent: E evt=%d state=%d", channelEvent,
-      mCameraState);
-    switch(channelEvent) {
-        case MM_CAMERA_CH_EVT_STREAMING_ON:
-            break;
-        case MM_CAMERA_CH_EVT_STREAMING_OFF:
-            break;
-        case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE:
-            break;
-        case MM_CAMERA_CH_EVT_DATA_REQUEST_MORE:
-            break;
-        default:
-            break;
-    }
-    ALOGI("processSnapshotChannelEvent: X");
-    return;
-}
-
-void QCameraHardwareInterface::
-processRdiChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) {
-    ALOGI("processRdiChannelEvent: E evt=%d state=%d", channelEvent,
-      mCameraState);
-    switch(channelEvent) {
-        case MM_CAMERA_CH_EVT_STREAMING_ON:
-            break;
-        case MM_CAMERA_CH_EVT_STREAMING_OFF:
-            break;
-        case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE:
-            break;
-        case MM_CAMERA_CH_EVT_DATA_REQUEST_MORE:
-            break;
-        default:
-            break;
-    }
-    ALOGI("processRdiChannelEvent: X");
-    return;
-}
-
-void QCameraHardwareInterface::processChannelEvent(
-  mm_camera_ch_event_t *event, app_notify_cb_t *app_cb)
-{
-    ALOGI("processChannelEvent: E");
-    Mutex::Autolock lock(mLock);
-    switch(event->ch) {
-        case MM_CAMERA_PREVIEW:
-            processPreviewChannelEvent(event->evt, app_cb);
-            break;
-        case MM_CAMERA_RDI:
-            processRdiChannelEvent(event->evt, app_cb);
-            break;
-        case MM_CAMERA_VIDEO:
-            processRecordChannelEvent(event->evt, app_cb);
-            break;
-        case MM_CAMERA_SNAPSHOT_MAIN:
-        case MM_CAMERA_SNAPSHOT_THUMBNAIL:
-            processSnapshotChannelEvent(event->evt, app_cb);
-            break;
-        default:
-            break;
-    }
-    ALOGI("processChannelEvent: X");
-    return;
-}
-
-void QCameraHardwareInterface::processCtrlEvent(mm_camera_ctrl_event_t *event, app_notify_cb_t *app_cb)
-{
-    ALOGI("processCtrlEvent: %d, E",event->evt);
-    ALOGE("processCtrlEvent: MM_CAMERA_CTRL_EVT_HDR_DONE is %d", MM_CAMERA_CTRL_EVT_HDR_DONE);
-    if(rdiMode == STREAM_RAW) {
-        return;
-    }
-    Mutex::Autolock lock(mLock);
-    switch(event->evt)
-    {
-        case MM_CAMERA_CTRL_EVT_ZOOM_DONE:
-            ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_ZOOM_DONE");
-            zoomEvent(&event->status, app_cb);
-            break;
-        case MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE:
-            ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE");
-            autoFocusEvent(&event->status, app_cb);
-            break;
-        case MM_CAMERA_CTRL_EVT_PREP_SNAPSHOT:
-            ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_ZOOM_DONE");
-            break;
-        case MM_CAMERA_CTRL_EVT_WDN_DONE:
-            ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_WDN_DONE");
-            wdenoiseEvent(event->status, (void *)(event->cookie));
-            break;
-        case MM_CAMERA_CTRL_EVT_HDR_DONE:
-            ALOGI("processCtrlEvent:MM_CAMERA_CTRL_EVT_HDR_DONE");
-            notifyHdrEvent(event->status, (void*)(event->cookie));
-            break;
-        case MM_CAMERA_CTRL_EVT_ERROR:
-            ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_ERROR");
-            app_cb->notifyCb  = mNotifyCb;
-            app_cb->argm_notify.msg_type = CAMERA_MSG_ERROR;
-            app_cb->argm_notify.ext1 = CAMERA_ERROR_UNKNOWN;
-            app_cb->argm_notify.cookie =  mCallbackCookie;
-            break;
-        case MM_CAMERA_CTRL_EVT_SNAPSHOT_CONFIG_DONE:
-            ALOGV("%s: MM_CAMERA_CTRL_EVT_SNAPSHOT_CONFIG_DONE", __func__);
-            app_cb->notifyCb  = mNotifyCb;
-            app_cb->argm_notify.msg_type = CAMERA_MSG_SHUTTER;
-            app_cb->argm_notify.ext1 = 0;
-            app_cb->argm_notify.ext2 = TRUE;
-            app_cb->argm_notify.cookie =  mCallbackCookie;
-            mShutterSoundPlayed = TRUE;
-       default:
-            break;
-    }
-    ALOGI("processCtrlEvent: X");
-    return;
-}
-
-void  QCameraHardwareInterface::processStatsEvent(
-  mm_camera_stats_event_t *event, app_notify_cb_t *app_cb)
-{
-    ALOGI("processStatsEvent: E");
-    if (!isPreviewRunning( )) {
-        ALOGE("preview is not running");
-        return;
-    }
-
-    switch (event->event_id) {
-
-        case MM_CAMERA_STATS_EVT_HISTO:
-        {
-            ALOGE("HAL process Histo: mMsgEnabled=0x%x, mStatsOn=%d, mSendData=%d, mDataCb=%p ",
-                  (mMsgEnabled & CAMERA_MSG_STATS_DATA), mStatsOn, mSendData, mDataCb);
-            int msgEnabled = mMsgEnabled;
-            /*get stats buffer based on index*/
-            camera_preview_histogram_info* hist_info =
-                (camera_preview_histogram_info*) mHistServer.camera_memory[event->e.stats_histo.index]->data;
-
-            if(mStatsOn == QCAMERA_PARM_ENABLE && mSendData &&
-                            mDataCb && (msgEnabled & CAMERA_MSG_STATS_DATA) ) {
-                uint32_t *dest;
-                mSendData = false;
-                mCurrentHisto = (mCurrentHisto + 1) % 3;
-                // The first element of the array will contain the maximum hist value provided by driver.
-                *(uint32_t *)((unsigned int)(mStatsMapped[mCurrentHisto]->data)) = hist_info->max_value;
-                memcpy((uint32_t *)((unsigned int)mStatsMapped[mCurrentHisto]->data + sizeof(int32_t)),
-                                                    (uint32_t *)hist_info->buffer,(sizeof(int32_t) * 256));
-
-                app_cb->dataCb  = mDataCb;
-                app_cb->argm_data_cb.msg_type = CAMERA_MSG_STATS_DATA;
-                app_cb->argm_data_cb.data = mStatsMapped[mCurrentHisto];
-                app_cb->argm_data_cb.index = 0;
-                app_cb->argm_data_cb.metadata = NULL;
-                app_cb->argm_data_cb.cookie =  mCallbackCookie;
-            }
-            break;
-
-        }
-        default:
-        break;
-    }
-  ALOGV("receiveCameraStats X");
-}
-
-void  QCameraHardwareInterface::processInfoEvent(
-  mm_camera_info_event_t *event, app_notify_cb_t *app_cb) {
-    ALOGI("processInfoEvent: %d, E",event->event_id);
-    switch(event->event_id)
-    {
-        case MM_CAMERA_INFO_EVT_ROI:
-            roiEvent(event->e.roi, app_cb);
-            break;
-        default:
-            break;
-    }
-    ALOGI("processInfoEvent: X");
-    return;
-}
-
-void  QCameraHardwareInterface::processEvent(mm_camera_event_t *event)
-{
-    app_notify_cb_t app_cb;
-    ALOGE("processEvent: type :%d E",event->event_type);
-    if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED){
-	ALOGE("Stop recording issued. Return from process Event");
-        return;
-    }
-    memset(&app_cb, 0, sizeof(app_notify_cb_t));
-    switch(event->event_type)
-    {
-        case MM_CAMERA_EVT_TYPE_CH:
-            processChannelEvent(&event->e.ch, &app_cb);
-            break;
-        case MM_CAMERA_EVT_TYPE_CTRL:
-            processCtrlEvent(&event->e.ctrl, &app_cb);
-            break;
-        case MM_CAMERA_EVT_TYPE_STATS:
-            processStatsEvent(&event->e.stats, &app_cb);
-            break;
-        case MM_CAMERA_EVT_TYPE_INFO:
-            processInfoEvent(&event->e.info, &app_cb);
-            break;
-        default:
-            break;
-    }
-    ALOGE(" App_cb Notify %p, datacb=%p", app_cb.notifyCb, app_cb.dataCb);
-    if (app_cb.notifyCb) {
-      app_cb.notifyCb(app_cb.argm_notify.msg_type,
-        app_cb.argm_notify.ext1, app_cb.argm_notify.ext2,
-        app_cb.argm_notify.cookie);
-    }
-    if (app_cb.dataCb) {
-      app_cb.dataCb(app_cb.argm_data_cb.msg_type,
-        app_cb.argm_data_cb.data, app_cb.argm_data_cb.index,
-        app_cb.argm_data_cb.metadata, app_cb.argm_data_cb.cookie);
-    }
-    ALOGI("processEvent: X");
-    return;
-}
-
-status_t QCameraHardwareInterface::startPreview()
-{
-    status_t retVal = NO_ERROR;
-
-    ALOGE("%s: mPreviewState =%d", __func__, mPreviewState);
-    Mutex::Autolock lock(mLock);
-
-    switch(mPreviewState) {
-    case QCAMERA_HAL_TAKE_PICTURE:
-        /* cancel pic internally */
-        cancelPictureInternal();
-        mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-        /* then continue with start preview */
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-        mPreviewState = QCAMERA_HAL_PREVIEW_START;
-        ALOGE("%s:  HAL::startPreview begin", __func__);
-
-        if(QCAMERA_HAL_PREVIEW_START == mPreviewState &&
-           (mPreviewWindow || isNoDisplayMode())) {
-            ALOGE("%s:  start preview now", __func__);
-            retVal = startPreview2();
-            if(retVal == NO_ERROR)
-                mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
-        } else {
-            ALOGE("%s:  received startPreview, but preview window = null", __func__);
-        }
-        break;
-    case QCAMERA_HAL_PREVIEW_START:
-    case QCAMERA_HAL_PREVIEW_STARTED:
-    break;
-    case QCAMERA_HAL_RECORDING_STARTED:
-        ALOGE("%s: cannot start preview in recording state", __func__);
-        break;
-    default:
-        ALOGE("%s: unknow state %d received", __func__, mPreviewState);
-        retVal = UNKNOWN_ERROR;
-        break;
-    }
-    return retVal;
-}
-
-status_t QCameraHardwareInterface::startPreview2()
-{
-    ALOGV("startPreview2: E");
-    status_t ret = NO_ERROR;
-
-    cam_ctrl_dimension_t dim;
-    mm_camera_dimension_t maxDim;
-    uint32_t stream[2];
-    mm_camera_bundle_attr_t attr;
-
-    if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED) { //isPreviewRunning()){
-        ALOGE("%s:Preview already started  mPreviewState = %d!", __func__, mPreviewState);
-        ALOGE("%s: X", __func__);
-        return NO_ERROR;
-    }
-
-    /* config the parmeters and see if we need to re-init the stream*/
-    ret = setDimension();
-    if (MM_CAMERA_OK != ret) {
-      ALOGE("%s: error - can't Set Dimensions!", __func__);
-      return BAD_VALUE;
-    }
-
-    memset(&mHdrInfo, 0, sizeof(snap_hdr_record_t));
-
-    if(isZSLMode()) {
-        ALOGE("<DEBUGMODE>In ZSL mode");
-        ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO");
-        mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_ZSL;
-        ret = mCameraHandle->ops->set_parm(
-                             mCameraHandle->camera_handle,
-                             MM_CAMERA_PARM_OP_MODE,
-                             &op_mode);
-        ALOGE("OP Mode Set");
-        /* Start preview streaming */
-        /*now init all the buffers and send to steam object*/
-        ret = mStreams[MM_CAMERA_PREVIEW]->initStream(FALSE, TRUE);
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't init Preview channel!", __func__);
-            return BAD_VALUE;
-        }
-
-        /* Start ZSL stream */
-        ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->initStream(TRUE, TRUE);
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't init Snapshot stream!", __func__);
-            mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-            return BAD_VALUE;
-        }
-
-        stream[0] = mStreams[MM_CAMERA_PREVIEW]->mStreamId;
-        stream[1] = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mStreamId;
-
-        attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
-        attr.burst_num = getNumOfSnapshots();
-        attr.look_back = getZSLBackLookCount();
-        attr.post_frame_skip = getZSLBurstInterval();
-        attr.water_mark = getZSLQueueDepth();
-        ALOGE("%s: burst_num=%d, look_back=%d, frame_skip=%d, water_mark=%d",
-              __func__, attr.burst_num, attr.look_back,
-              attr.post_frame_skip, attr.water_mark);
-
-        ret = mCameraHandle->ops->init_stream_bundle(
-                  mCameraHandle->camera_handle,
-                  mChannelId,
-                  superbuf_cb_routine,
-                  this,
-                  &attr,
-                  2,
-                  stream);
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't init zsl preview streams!", __func__);
-            mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-            mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
-            return BAD_VALUE;
-        }
-
-        ret = mStreams[MM_CAMERA_PREVIEW]->streamOn();
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't start preview stream!", __func__);
-            mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-            mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
-            return BAD_VALUE;
-        }
-
-        ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOn();
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't start snapshot stream!", __func__);
-            mStreams[MM_CAMERA_PREVIEW]->streamOff(0);
-            mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-            mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
-            return BAD_VALUE;
-        }
-    }else{
-        /*now init all the buffers and send to steam object*/
-        ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO");
-        mm_camera_op_mode_type_t op_mode = MM_CAMERA_OP_MODE_VIDEO;
-        ret = mCameraHandle->ops->set_parm(
-                         mCameraHandle->camera_handle,
-                         MM_CAMERA_PARM_OP_MODE,
-                         &op_mode);
-        ALOGE("OP Mode Set");
-
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_VIDEO err=%d\n", __func__, ret);
-            return BAD_VALUE;
-        }
-        if(rdiMode == STREAM_RAW) {
-            if(mStreams[MM_CAMERA_RDI] == NULL) {
-                createRdi();
-            }
-            mStreams[MM_CAMERA_RDI]->initStream(FALSE, TRUE);
-            ret = mStreams[MM_CAMERA_RDI]->streamOn();
-            return ret;
-        }
-        /*now init all the buffers and send to steam object*/
-        ret = mStreams[MM_CAMERA_PREVIEW]->initStream(FALSE, TRUE);
-        ALOGE("%s : called initStream from Preview and ret = %d", __func__, ret);
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't init Preview channel!", __func__);
-            return BAD_VALUE;
-        }
-        if(mRecordingHint == true) {
-            ret = mStreams[MM_CAMERA_VIDEO]->initStream(FALSE, TRUE);
-            if (MM_CAMERA_OK != ret){
-                 ALOGE("%s: error - can't init Record channel!", __func__);
-                 mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-                 return BAD_VALUE;
-            }
-            if (!canTakeFullSizeLiveshot()) {
-                // video-size live snapshot, config same as video
-                mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mFormat = mStreams[MM_CAMERA_VIDEO]->mFormat;
-                mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mWidth = mStreams[MM_CAMERA_VIDEO]->mWidth;
-                mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mHeight = mStreams[MM_CAMERA_VIDEO]->mHeight;
-                ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->initStream(FALSE, FALSE);
-            } else {
-                ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->initStream(FALSE, TRUE);
-            }
-            if (MM_CAMERA_OK != ret){
-                 ALOGE("%s: error - can't init Snapshot Main!", __func__);
-                 mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-                 mStreams[MM_CAMERA_VIDEO]->deinitStream();
-                 return BAD_VALUE;
-            }
-
-        }
-        ret = mStreams[MM_CAMERA_PREVIEW]->streamOn();
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't start preview stream!", __func__);
-            if (mRecordingHint == true) {
-                mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
-                mStreams[MM_CAMERA_VIDEO]->deinitStream();
-                mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-            }
-            return BAD_VALUE;
-        }
-    }
-
-    ALOGV("startPreview: X");
-    return ret;
-}
-
-void QCameraHardwareInterface::stopPreview()
-{
-    ALOGI("%s: stopPreview: E", __func__);
-    Mutex::Autolock lock(mLock);
-    //mm_camera_util_profile("HAL: stopPreview(): E");
-    mFaceDetectOn = false;
-
-    // reset recording hint to the value passed from Apps
-    const char * str = mParameters.get(QCameraParameters::KEY_RECORDING_HINT);
-    if((str != NULL) && !strcmp(str, "true")){
-        mRecordingHint = TRUE;
-    } else {
-        mRecordingHint = FALSE;
-    }
-
-    switch(mPreviewState) {
-        case QCAMERA_HAL_PREVIEW_START:
-            //mPreviewWindow = NULL;
-            mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-            break;
-        case QCAMERA_HAL_PREVIEW_STARTED:
-            cancelPictureInternal();
-            stopPreviewInternal();
-            mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-            break;
-        case QCAMERA_HAL_RECORDING_STARTED:
-            cancelPictureInternal();
-            stopRecordingInternal();
-            stopPreviewInternal();
-            mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-            break;
-        case QCAMERA_HAL_TAKE_PICTURE:
-            cancelPictureInternal();
-            mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-            break;
-        case QCAMERA_HAL_PREVIEW_STOPPED:
-        default:
-            break;
-    }
-    ALOGI("stopPreview: X, mPreviewState = %d", mPreviewState);
-}
-
-void QCameraHardwareInterface::stopPreviewInternal()
-{
-    ALOGI("stopPreviewInternal: E");
-    status_t ret = NO_ERROR;
-
-    if(!mStreams[MM_CAMERA_PREVIEW]) {
-        ALOGE("mStreamDisplay is null");
-        return;
-    }
-
-    if(isZSLMode()) {
-        mStreams[MM_CAMERA_PREVIEW]->streamOff(0);
-        mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOff(0);
-        ret = mCameraHandle->ops->destroy_stream_bundle(mCameraHandle->camera_handle,mChannelId);
-        if(ret != MM_CAMERA_OK) {
-            ALOGE("%s : ZSL destroy_stream_bundle Error",__func__);
-        }
-    }else{
-        if(rdiMode == STREAM_RAW) {
-            mStreams[MM_CAMERA_RDI]->streamOff(0);
-            mStreams[MM_CAMERA_RDI]->deinitStream();
-            return;
-        }
-        mStreams[MM_CAMERA_PREVIEW]->streamOff(0);
-    }
-    if (mStreams[MM_CAMERA_VIDEO])
-        mStreams[MM_CAMERA_VIDEO]->deinitStream();
-    if (mStreams[MM_CAMERA_SNAPSHOT_MAIN])
-        mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
-    mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-
-    ALOGI("stopPreviewInternal: X");
-}
-
-int QCameraHardwareInterface::previewEnabled()
-{
-    ALOGI("previewEnabled: E");
-    Mutex::Autolock lock(mLock);
-    ALOGE("%s: mPreviewState = %d", __func__, mPreviewState);
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_START:
-    case QCAMERA_HAL_PREVIEW_STARTED:
-    case QCAMERA_HAL_RECORDING_STARTED:
-        return true;
-    default:
-        return false;
-    }
-}
-
-status_t QCameraHardwareInterface::startRecording()
-{
-    ALOGI("startRecording: E");
-    status_t ret = NO_ERROR;
-    Mutex::Autolock lock(mLock);
-
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-        ALOGE("%s: preview has not been started", __func__);
-        ret = UNKNOWN_ERROR;
-        break;
-    case QCAMERA_HAL_PREVIEW_START:
-        ALOGE("%s: no preview native window", __func__);
-        ret = UNKNOWN_ERROR;
-        break;
-    case QCAMERA_HAL_PREVIEW_STARTED:
-        if (mRecordingHint == FALSE) {
-            ALOGE("%s: start recording when hint is false, stop preview first", __func__);
-            stopPreviewInternal();
-            mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-
-            // Set recording hint to TRUE
-            mRecordingHint = TRUE;
-            setRecordingHintValue(mRecordingHint);
-
-            // start preview again
-            mPreviewState = QCAMERA_HAL_PREVIEW_START;
-            if (startPreview2() == NO_ERROR)
-                mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
-        }
-        ret =  mStreams[MM_CAMERA_VIDEO]->streamOn();
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - mStreamRecord->start!", __func__);
-            ret = BAD_VALUE;
-            break;
-        }
-        mPreviewState = QCAMERA_HAL_RECORDING_STARTED;
-
-        if (mPowerModule) {
-            if (mPowerModule->powerHint) {
-                mPowerModule->powerHint(mPowerModule, POWER_HINT_VIDEO_ENCODE, (void *)"state=1");
-            }
-        }
-        break;
-    case QCAMERA_HAL_RECORDING_STARTED:
-        ALOGE("%s: ", __func__);
-        break;
-    case QCAMERA_HAL_TAKE_PICTURE:
-    default:
-       ret = BAD_VALUE;
-       break;
-    }
-    ALOGI("startRecording: X");
-    return ret;
-}
-
-void QCameraHardwareInterface::stopRecording()
-{
-    ALOGI("stopRecording: E");
-    Mutex::Autolock lock(mLock);
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-    case QCAMERA_HAL_PREVIEW_START:
-    case QCAMERA_HAL_PREVIEW_STARTED:
-        break;
-    case QCAMERA_HAL_RECORDING_STARTED:
-        cancelPictureInternal();
-        stopRecordingInternal();
-        mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
-
-        if (mPowerModule) {
-            if (mPowerModule->powerHint) {
-	            mPowerModule->powerHint(mPowerModule, POWER_HINT_VIDEO_ENCODE, (void *)"state=0");
-            }
-        }
-        break;
-    case QCAMERA_HAL_TAKE_PICTURE:
-    default:
-        break;
-    }
-    ALOGI("stopRecording: X");
-
-}
-void QCameraHardwareInterface::stopRecordingInternal()
-{
-    ALOGI("stopRecordingInternal: E");
-    status_t ret = NO_ERROR;
-
-    if(!mStreams[MM_CAMERA_VIDEO]) {
-        ALOGE("mStreamRecord is null");
-        return;
-    }
-
-    /*
-    * call QCameraStream_record::stop()
-    * Unregister Callback, action stop
-    */
-    mStreams[MM_CAMERA_VIDEO]->streamOff(0);
-    mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
-    ALOGI("stopRecordingInternal: X");
-    return;
-}
-
-int QCameraHardwareInterface::recordingEnabled()
-{
-    int ret = 0;
-    Mutex::Autolock lock(mLock);
-    ALOGV("%s: E", __func__);
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-    case QCAMERA_HAL_PREVIEW_START:
-    case QCAMERA_HAL_PREVIEW_STARTED:
-        break;
-    case QCAMERA_HAL_RECORDING_STARTED:
-        ret = 1;
-        break;
-    case QCAMERA_HAL_TAKE_PICTURE:
-    default:
-        break;
-    }
-    ALOGV("%s: X, ret = %d", __func__, ret);
-    return ret;   //isRecordingRunning();
-}
-
-/**
-* Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
-*/
-void QCameraHardwareInterface::releaseRecordingFrame(const void *opaque)
-{
-    ALOGV("%s : BEGIN",__func__);
-    if(mStreams[MM_CAMERA_VIDEO] == NULL) {
-        ALOGE("Record stream Not Initialized");
-        return;
-    }
-    mStreams[MM_CAMERA_VIDEO]->releaseRecordingFrame(opaque);
-    ALOGV("%s : END",__func__);
-    return;
-}
-
-status_t QCameraHardwareInterface::autoFocusEvent(cam_ctrl_status_t *status, app_notify_cb_t *app_cb)
-{
-    ALOGE("autoFocusEvent: E");
-    int ret = NO_ERROR;
-/************************************************************
-  BEGIN MUTEX CODE
-*************************************************************/
-
-    ALOGE("%s:%d: Trying to acquire AF bit lock",__func__,__LINE__);
-    mAutofocusLock.lock();
-    ALOGE("%s:%d: Acquired AF bit lock",__func__,__LINE__);
-
-    if(mAutoFocusRunning==false) {
-      ALOGE("%s:AF not running, discarding stale event",__func__);
-      mAutofocusLock.unlock();
-      return ret;
-    }
-
-    /* If autofocus call has been made during CAF, CAF will be locked.
-	* We specifically need to call cancelAutoFocus to unlock CAF.
-    * In that sense, AF is still running.*/
-    isp3a_af_mode_t afMode = getAutoFocusMode(mParameters);
-    if (afMode == AF_MODE_CAF) {
-       mNeedToUnlockCaf = true;
-    }
-    mAutoFocusRunning = false;
-    mAutofocusLock.unlock();
-
-/************************************************************
-  END MUTEX CODE
-*************************************************************/
-    if(status==NULL) {
-      ALOGE("%s:NULL ptr received for status",__func__);
-      return BAD_VALUE;
-    }
-
-    /* update focus distances after autofocus is done */
-    if(updateFocusDistances() != NO_ERROR) {
-       ALOGE("%s: updateFocusDistances failed for %d", __FUNCTION__, mFocusMode);
-    }
-
-    /*(Do?) we need to make sure that the call back is the
-      last possible step in the execution flow since the same
-      context might be used if a fail triggers another round
-      of AF then the mAutoFocusRunning flag and other state
-      variables' validity will be under question*/
-
-    if (mNotifyCb && ( mMsgEnabled & CAMERA_MSG_FOCUS)){
-      ALOGE("%s:Issuing callback to service",__func__);
-
-      /* "Accepted" status is not appropriate it should be used for
-        initial cmd, event reporting should only give use SUCCESS/FAIL
-        */
-
-      app_cb->notifyCb  = mNotifyCb;
-      app_cb->argm_notify.msg_type = CAMERA_MSG_FOCUS;
-      app_cb->argm_notify.ext2 = 0;
-      app_cb->argm_notify.cookie =  mCallbackCookie;
-
-      ALOGE("Auto foucs state =%d", *status);
-      if(*status==CAM_CTRL_SUCCESS) {
-        app_cb->argm_notify.ext1 = true;
-      }
-      else if(*status==CAM_CTRL_FAILED){
-        app_cb->argm_notify.ext1 = false;
-      }
-      else{
-        app_cb->notifyCb  = NULL;
-        ALOGE("%s:Unknown AF status (%d) received",__func__,*status);
-      }
-
-    }/*(mNotifyCb && ( mMsgEnabled & CAMERA_MSG_FOCUS))*/
-    else{
-      ALOGE("%s:Call back not enabled",__func__);
-    }
-
-    ALOGE("autoFocusEvent: X");
-    return ret;
-
-}
-
-status_t QCameraHardwareInterface::cancelPicture()
-{
-    ALOGI("cancelPicture: E, mPreviewState = %d", mPreviewState);
-    status_t ret = MM_CAMERA_OK;
-    Mutex::Autolock lock(mLock);
-
-    switch(mPreviewState) {
-        case QCAMERA_HAL_PREVIEW_STOPPED:
-        case QCAMERA_HAL_PREVIEW_START:
-        case QCAMERA_HAL_PREVIEW_STARTED:
-        default:
-            break;
-        case QCAMERA_HAL_TAKE_PICTURE:
-            ret = cancelPictureInternal();
-            mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-            break;
-        case QCAMERA_HAL_RECORDING_STARTED:
-            ret = cancelPictureInternal();
-            break;
-    }
-    ALOGI("cancelPicture: X");
-    return ret;
-}
-
-status_t QCameraHardwareInterface::cancelPictureInternal()
-{
-    ALOGI("%s: E mPreviewState=%d", __func__ , mPreviewState);
-    status_t ret = MM_CAMERA_OK;
-
-    /* set rawdata proc thread and jpeg notify thread to inactive state */
-    /* no need for notify thread as a sync call for stop cmd */
-    mNotifyTh->sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC, FALSE, TRUE);
-    /* dataProc Thread need to process "stop" as sync call because abort jpeg job should be a sync call*/
-    mDataProcTh->sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC, TRUE, TRUE);
-
-    if (isZSLMode()) {
-        ret = mCameraHandle->ops->cancel_super_buf_request(mCameraHandle->camera_handle, mChannelId);
-    } else {
-        mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOff(0);
-        mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->streamOff(0);
-        ret = mCameraHandle->ops->destroy_stream_bundle(mCameraHandle->camera_handle, mChannelId);
-        if(ret != MM_CAMERA_OK) {
-            ALOGE("%s : destroy_stream_bundle Error",__func__);
-        }
-        if(mPreviewState != QCAMERA_HAL_RECORDING_STARTED) {
-            mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
-            mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->deinitStream();
-        }
-    }
-    ALOGI("cancelPictureInternal: X");
-    return ret;
-}
-
-status_t  QCameraHardwareInterface::takePicture()
-{
-    ALOGE("takePicture: E");
-    status_t ret = MM_CAMERA_OK;
-    uint32_t stream_info;
-    uint32_t stream[2];
-    mm_camera_bundle_attr_t attr;
-    mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_CAPTURE;
-    int num_streams = 0;
-    Mutex::Autolock lock(mLock);
-
-    /* set rawdata proc thread and jpeg notify thread to active state */
-    mNotifyTh->sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, FALSE, FALSE);
-    mDataProcTh->sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, FALSE, FALSE);
-
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_STARTED:
-        {
-            if (isZSLMode()) {
-                ALOGE("ZSL: takePicture");
-
-                ret = mCameraHandle->ops->request_super_buf(
-                          mCameraHandle->camera_handle,
-                          mChannelId,
-                          getNumOfSnapshots());
-                if (MM_CAMERA_OK != ret){
-                    ALOGE("%s: error - can't start Snapshot streams!", __func__);
-                    return BAD_VALUE;
-                }
-                return ret;
-            }
-
-            /*prepare snapshot, e.g LED*/
-            takePicturePrepareHardware( );
-
-            /* stop preview */
-            stopPreviewInternal();
-            /*Currently concurrent streaming is not enabled for snapshot
-            So in snapshot mode, we turn of the RDI channel and configure backend
-            for only pixel stream*/
-
-            if (!isRawSnapshot()) {
-                op_mode=MM_CAMERA_OP_MODE_CAPTURE;
-            } else {
-                ALOGV("%s: Raw snapshot so setting op mode to raw", __func__);
-                op_mode=MM_CAMERA_OP_MODE_RAW;
-            }
-            ret = mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_OP_MODE, &op_mode);
-
-            if(MM_CAMERA_OK != ret) {
-                ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_CAPTURE err=%d\n", __func__, ret);
-                return BAD_VALUE;
-            }
-
-            ret = setDimension();
-            if (MM_CAMERA_OK != ret) {
-                ALOGE("%s: error - can't Set Dimensions!", __func__);
-                return BAD_VALUE;
-            }
-
-            //added to support hdr
-            bool hdr;
-            int frm_num = 1;
-            int exp[MAX_HDR_EXP_FRAME_NUM];
-            hdr = getHdrInfoAndSetExp(MAX_HDR_EXP_FRAME_NUM, &frm_num, exp);
-            initHdrInfoForSnapshot(hdr, frm_num, exp); // - for hdr figure out equivalent of mStreamSnap
-            memset(&attr, 0, sizeof(mm_camera_bundle_attr_t));
-            attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
-
-            num_streams = 0;
-            mStreams[MM_CAMERA_SNAPSHOT_MAIN]->initStream(TRUE, TRUE);
-            if (NO_ERROR!=ret) {
-                ALOGE("%s E: can't init native camera snapshot main ch\n",__func__);
-                return ret;
-            }
-            stream[num_streams++] = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mStreamId;
-
-            if (!isRawSnapshot()) {
-                mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->initStream(TRUE, TRUE);
-                if (NO_ERROR!=ret) {
-                   ALOGE("%s E: can't init native camera snapshot thumb ch\n",__func__);
-                   return ret;
-                }
-                stream[num_streams++] = mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mStreamId;
-            }
-            ret = mCameraHandle->ops->init_stream_bundle(
-                      mCameraHandle->camera_handle,
-                      mChannelId,
-                      superbuf_cb_routine,
-                      this,
-                      &attr,
-                      num_streams,
-                      stream);
-            if (MM_CAMERA_OK != ret){
-                ALOGE("%s: error - can't init Snapshot streams!", __func__);
-                return BAD_VALUE;
-            }
-            ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOn();
-            if (MM_CAMERA_OK != ret){
-                ALOGE("%s: error - can't start Snapshot streams!", __func__);
-                mCameraHandle->ops->destroy_stream_bundle(
-                   mCameraHandle->camera_handle,
-                   mChannelId);
-                mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
-                mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->deinitStream();
-                return BAD_VALUE;
-            }
-            if (!isRawSnapshot()) {
-                ret = mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->streamOn();
-                if (MM_CAMERA_OK != ret){
-                    ALOGE("%s: error - can't start Thumbnail streams!", __func__);
-                    mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOff(0);
-                    mCameraHandle->ops->destroy_stream_bundle(
-                       mCameraHandle->camera_handle,
-                       mChannelId);
-                    mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
-                    mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->deinitStream();
-                    return BAD_VALUE;
-                }
-            }
-            mPreviewState = QCAMERA_HAL_TAKE_PICTURE;
-        }
-        break;
-    case QCAMERA_HAL_TAKE_PICTURE:
-          break;
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-    case QCAMERA_HAL_PREVIEW_START:
-        ret = UNKNOWN_ERROR;
-        break;
-    case QCAMERA_HAL_RECORDING_STARTED:
-        stream[0] = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mStreamId;
-        memset(&attr, 0, sizeof(mm_camera_bundle_attr_t));
-        attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
-        ret = mCameraHandle->ops->init_stream_bundle(
-                  mCameraHandle->camera_handle,
-                  mChannelId,
-                  superbuf_cb_routine,
-                  this,
-                  &attr,
-                  1,
-                  stream);
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't init Snapshot streams!", __func__);
-            return BAD_VALUE;
-        }
-        ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOn();
-        if (MM_CAMERA_OK != ret){
-            ALOGE("%s: error - can't start Snapshot streams!", __func__);
-            mCameraHandle->ops->destroy_stream_bundle(
-               mCameraHandle->camera_handle,
-               mChannelId);
-            return BAD_VALUE;
-        }
-        break;
-    default:
-        ret = UNKNOWN_ERROR;
-        break;
-    }
-    ALOGI("takePicture: X");
-    return ret;
-}
-
-status_t QCameraHardwareInterface::autoFocus()
-{
-    ALOGI("autoFocus: E");
-    status_t ret = NO_ERROR;
-
-    Mutex::Autolock lock(mLock);
-    ALOGI("autoFocus: Got lock");
-    bool status = true;
-    isp3a_af_mode_t afMode = getAutoFocusMode(mParameters);
-
-    if(mAutoFocusRunning==true){
-      ALOGE("%s:AF already running should not have got this call",__func__);
-      return NO_ERROR;
-    }
-
-    if (afMode == AF_MODE_MAX) {
-      /* This should never happen. We cannot send a
-       * callback notifying error from this place because
-       * the CameraService has called this function after
-       * acquiring the lock. So if we try to issue a callback
-       * from this place, the callback will try to acquire
-       * the same lock in CameraService and it will result
-       * in deadlock. So, let the call go in to the lower
-       * layer. The lower layer will anyway return error if
-       * the autofocus is not supported or if the focus
-       * value is invalid.
-       * Just print out the error. */
-      ALOGE("%s:Invalid AF mode (%d)", __func__, afMode);
-    }
-
-    ALOGI("%s:AF start (mode %d)", __func__, afMode);
-    if(MM_CAMERA_OK != mCameraHandle->ops->start_focus(mCameraHandle->camera_handle,
-               mChannelId,0,(uint32_t)&afMode)){
-      ALOGE("%s: AF command failed err:%d error %s",
-           __func__, errno, strerror(errno));
-      return UNKNOWN_ERROR;
-    }
-
-    mAutoFocusRunning = true;
-    ALOGE("autoFocus: X");
-    return ret;
-}
-
-status_t QCameraHardwareInterface::cancelAutoFocus()
-{
-    ALOGE("cancelAutoFocus: E");
-    status_t ret = NO_ERROR;
-    Mutex::Autolock lock(mLock);
-
-/**************************************************************
-  BEGIN MUTEX CODE
-*************************************************************/
-
-    mAutofocusLock.lock();
-    if(mAutoFocusRunning || mNeedToUnlockCaf) {
-
-      mAutoFocusRunning = false;
-      mNeedToUnlockCaf = false;
-      mAutofocusLock.unlock();
-
-    }else/*(!mAutoFocusRunning)*/{
-
-      mAutofocusLock.unlock();
-      ALOGE("%s:Af not running",__func__);
-      return NO_ERROR;
-    }
-/**************************************************************
-  END MUTEX CODE
-*************************************************************/
-
-    if(MM_CAMERA_OK!= mCameraHandle->ops->abort_focus(mCameraHandle->camera_handle,
-               mChannelId,0)){
-        ALOGE("%s: AF command failed err:%d error %s",__func__, errno,strerror(errno));
-    }
-    ALOGE("cancelAutoFocus: X");
-    return NO_ERROR;
-}
-
-/*==========================================================================
- * FUNCTION    - processprepareSnapshotEvent -
- *
- * DESCRIPTION:  Process the event of preparesnapshot done msg
-                 unblock prepareSnapshotAndWait( )
- *=========================================================================*/
-void QCameraHardwareInterface::processprepareSnapshotEvent(cam_ctrl_status_t *status)
-{
-    ALOGI("processprepareSnapshotEvent: E");
-    pthread_mutex_lock(&mAsyncCmdMutex);
-    pthread_cond_signal(&mAsyncCmdWait);
-    pthread_mutex_unlock(&mAsyncCmdMutex);
-    ALOGI("processprepareSnapshotEvent: X");
-}
-
-void QCameraHardwareInterface::roiEvent(fd_roi_t roi,app_notify_cb_t *app_cb)
-{
-    ALOGE("roiEvent: E");
-
-    if(mStreams[MM_CAMERA_PREVIEW]) {
-        mStreams[MM_CAMERA_PREVIEW]->notifyROIEvent(roi);
-    }
-    ALOGE("roiEvent: X");
-}
-
-
-void QCameraHardwareInterface::handleZoomEventForSnapshot(void)
-{
-    ALOGI("%s: E", __func__);
-
-    if (mStreams[MM_CAMERA_SNAPSHOT_MAIN] != NULL) {
-        mStreams[MM_CAMERA_SNAPSHOT_MAIN]->setCrop();
-    }
-    if (mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL] != NULL) {
-        mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->setCrop();
-    }
-    ALOGI("%s: X", __func__);
-}
-
-void QCameraHardwareInterface::handleZoomEventForPreview(app_notify_cb_t *app_cb)
-{
-    ALOGI("%s: E", __func__);
-
-    /*regular zooming or smooth zoom stopped*/
-    if (mStreams[MM_CAMERA_PREVIEW] != NULL) {
-        ALOGI("%s: Fetching crop info", __func__);
-        mStreams[MM_CAMERA_PREVIEW]->setCrop();
-        ALOGI("%s: Currrent zoom :%d",__func__, mCurrentZoom);
-    }
-
-    ALOGI("%s: X", __func__);
-}
-
-void QCameraHardwareInterface::zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *app_cb)
-{
-    ALOGI("zoomEvent: state:%d E",mPreviewState);
-    switch (mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-        break;
-    case QCAMERA_HAL_PREVIEW_START:
-        break;
-    case QCAMERA_HAL_PREVIEW_STARTED:
-        handleZoomEventForPreview(app_cb);
-        if (isZSLMode())
-          handleZoomEventForSnapshot();
-        break;
-    case QCAMERA_HAL_RECORDING_STARTED:
-        handleZoomEventForPreview(app_cb);
-        if (mFullLiveshotEnabled)
-            handleZoomEventForSnapshot();
-        break;
-    case QCAMERA_HAL_TAKE_PICTURE:
-        if(isZSLMode())
-            handleZoomEventForPreview(app_cb);
-        handleZoomEventForSnapshot();
-        break;
-    default:
-        break;
-    }
-    ALOGI("zoomEvent: X");
-}
-
-void QCameraHardwareInterface::dumpFrameToFile(const void * data, uint32_t size, char* name, char* ext, int index)
-{
-    char buf[32];
-    int file_fd;
-    if ( data != NULL) {
-        char * str;
-        snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name, index, ext);
-        ALOGE("marvin, %s size =%d", buf, size);
-        file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-        write(file_fd, data, size);
-        close(file_fd);
-    }
-}
-
-void QCameraHardwareInterface::dumpFrameToFile(mm_camera_buf_def_t* newFrame,
-  HAL_cam_dump_frm_type_t frm_type)
-{
-  ALOGV("%s: E", __func__);
-  int32_t enabled = 0;
-  int frm_num;
-  uint32_t  skip_mode;
-  char value[PROPERTY_VALUE_MAX];
-  char buf[32];
-  int main_422 = 1;
-  property_get("persist.camera.dumpimg", value, "0");
-  enabled = atoi(value);
-
-  ALOGV(" newFrame =%p, frm_type = %x, enabled=%x", newFrame, frm_type, enabled);
-  if(enabled & HAL_DUMP_FRM_MASK_ALL) {
-    if((enabled & frm_type) && newFrame) {
-      frm_num = ((enabled & 0xffff0000) >> 16);
-      if(frm_num == 0) frm_num = 10; /*default 10 frames*/
-      if(frm_num > 256) frm_num = 256; /*256 buffers cycle around*/
-      skip_mode = ((enabled & 0x0000ff00) >> 8);
-      if(skip_mode == 0) skip_mode = 1; /*no -skip */
-
-      if( mDumpSkipCnt % skip_mode == 0) {
-        if (mDumpFrmCnt >= 0 && mDumpFrmCnt <= frm_num) {
-          int w, h;
-          int file_fd;
-          switch (frm_type) {
-          case  HAL_DUMP_FRM_PREVIEW:
-            w = mDimension.display_width;
-            h = mDimension.display_height;
-            snprintf(buf, sizeof(buf), "/data/%dp_%dx%d_%d.yuv", mDumpFrmCnt, w, h, newFrame->frame_idx);
-            file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-            break;
-          case HAL_DUMP_FRM_VIDEO:
-            w = mDimension.video_width;
-            h = mDimension.video_height;
-            snprintf(buf, sizeof(buf),"/data/%dv_%dx%d_%d.yuv", mDumpFrmCnt, w, h, newFrame->frame_idx);
-            file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-            break;
-          case HAL_DUMP_FRM_MAIN:
-            w = mDimension.picture_width;
-            h = mDimension.picture_height;
-            snprintf(buf, sizeof(buf), "/data/%dm_%dx%d_%d.yuv", mDumpFrmCnt, w, h, newFrame->frame_idx);
-            file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-            if (mDimension.main_img_format == CAMERA_YUV_422_NV16 ||
-                mDimension.main_img_format == CAMERA_YUV_422_NV61)
-              main_422 = 2;
-            break;
-          case HAL_DUMP_FRM_THUMBNAIL:
-            w = mDimension.ui_thumbnail_width;
-            h = mDimension.ui_thumbnail_height;
-            snprintf(buf, sizeof(buf),"/data/%dt_%dx%d_%d.yuv", mDumpFrmCnt, w, h, newFrame->frame_idx);
-            file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-            break;
-          case HAL_DUMP_FRM_RDI:
-              w = mRdiWidth;
-              h = mRdiHeight;
-              snprintf(buf, sizeof(buf),"/data/%dr_%dx%d.raw", mDumpFrmCnt, w, h);
-              file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-              break;
-          default:
-            w = h = 0;
-            file_fd = -1;
-            break;
-          }
-
-          if (file_fd < 0) {
-            ALOGE("%s: cannot open file:type=%d\n", __func__, frm_type);
-          } else {
-            write(file_fd, (const void *)(newFrame->buffer), w * h);
-            write(file_fd, (const void *)
-              (newFrame->buffer), w * h / 2 * main_422);
-            close(file_fd);
-            ALOGE("dump %s", buf);
-          }
-        } else if(frm_num == 256){
-          mDumpFrmCnt = 0;
-        }
-        mDumpFrmCnt++;
-      }
-      mDumpSkipCnt++;
-    }
-  }  else {
-    mDumpFrmCnt = 0;
-  }
-  ALOGV("%s: X", __func__);
-}
-
-status_t QCameraHardwareInterface::setPreviewWindow(preview_stream_ops_t* window)
-{
-    status_t retVal = NO_ERROR;
-    ALOGE(" %s: E mPreviewState = %d, mStreamDisplay = %p",
-          __func__, mPreviewState, mStreams[MM_CAMERA_PREVIEW]);
-    if( window == NULL) {
-        ALOGE("%s:Received Setting NULL preview window", __func__);
-    }
-    Mutex::Autolock lock(mLock);
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_START:
-        mPreviewWindow = window;
-        if(mPreviewWindow) {
-            /* we have valid surface now, start preview */
-            ALOGE("%s:  calling startPreview2", __func__);
-            retVal = startPreview2();
-            if(retVal == NO_ERROR)
-                mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
-            ALOGE("%s:  startPreview2 done, mPreviewState = %d", __func__, mPreviewState);
-        } else
-            ALOGE("%s: null window received, mPreviewState = %d", __func__, mPreviewState);
-        break;
-    case QCAMERA_HAL_PREVIEW_STARTED:
-        /* new window comes */
-        ALOGE("%s: bug, cannot handle new window in started state", __func__);
-        //retVal = UNKNOWN_ERROR;
-        break;
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-    case QCAMERA_HAL_TAKE_PICTURE:
-        mPreviewWindow = window;
-        ALOGE("%s: mPreviewWindow = 0x%p, mStreamDisplay = 0x%p",
-                                    __func__, mPreviewWindow, mStreams[MM_CAMERA_PREVIEW]);
-        break;
-    default:
-        ALOGE("%s: bug, cannot handle new window in state %d", __func__, mPreviewState);
-        retVal = UNKNOWN_ERROR;
-        break;
-    }
-    ALOGE(" %s : X, mPreviewState = %d", __FUNCTION__, mPreviewState);
-    return retVal;
-}
-
-int QCameraHardwareInterface::storeMetaDataInBuffers(int enable)
-{
-    /* this is a dummy func now. fix me later */
-    mStoreMetaDataInFrame = enable;
-    return 0;
-}
-
-int QCameraHardwareInterface::allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type)
-{
-    int rc = 0;
-    struct ion_handle_data handle_data;
-    struct ion_allocation_data alloc;
-    struct ion_fd_data ion_info_fd;
-    int main_ion_fd = 0;
-
-    main_ion_fd = open("/dev/ion", O_RDONLY);
-    if (main_ion_fd <= 0) {
-        ALOGE("Ion dev open failed %s\n", strerror(errno));
-        goto ION_OPEN_FAILED;
-    }
-
-    memset(&alloc, 0, sizeof(alloc));
-    alloc.len = mem_info->size;
-    /* to make it page size aligned */
-    alloc.len = (alloc.len + 4095) & (~4095);
-    alloc.align = 4096;
-    alloc.flags = ION_FLAG_CACHED;
-    alloc.heap_mask = ion_type;
-    rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &alloc);
-    if (rc < 0) {
-        ALOGE("ION allocation failed\n");
-        goto ION_ALLOC_FAILED;
-    }
-
-    memset(&ion_info_fd, 0, sizeof(ion_info_fd));
-    ion_info_fd.handle = alloc.handle;
-    rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd);
-    if (rc < 0) {
-        ALOGE("ION map failed %s\n", strerror(errno));
-        goto ION_MAP_FAILED;
-    }
-
-    mem_info->main_ion_fd = main_ion_fd;
-    mem_info->fd = ion_info_fd.fd;
-    mem_info->handle = ion_info_fd.handle;
-    mem_info->size = alloc.len;
-    return 0;
-
-ION_MAP_FAILED:
-    memset(&handle_data, 0, sizeof(handle_data));
-    handle_data.handle = ion_info_fd.handle;
-    ioctl(main_ion_fd, ION_IOC_FREE, &handle_data);
-ION_ALLOC_FAILED:
-    close(main_ion_fd);
-ION_OPEN_FAILED:
-    return -1;
-}
-
-int QCameraHardwareInterface::deallocate_ion_memory(QCameraHalMemInfo_t *mem_info)
-{
-  struct ion_handle_data handle_data;
-  int rc = 0;
-
-  if (mem_info->fd > 0) {
-      close(mem_info->fd);
-      mem_info->fd = 0;
-  }
-
-  if (mem_info->main_ion_fd > 0) {
-      memset(&handle_data, 0, sizeof(handle_data));
-      handle_data.handle = mem_info->handle;
-      ioctl(mem_info->main_ion_fd, ION_IOC_FREE, &handle_data);
-      close(mem_info->main_ion_fd);
-      mem_info->main_ion_fd = 0;
-  }
-  return rc;
-}
-
-int QCameraHardwareInterface::initHeapMem( QCameraHalHeap_t *heap,
-                                           int num_of_buf,
-                                           uint32_t buf_len,
-                                           int pmem_type,
-                                           mm_camera_frame_len_offset* offset,
-                                           mm_camera_buf_def_t *buf_def)
-{
-    int rc = 0;
-    int i;
-    int path;
-    ALOGE("Init Heap =%p. pmem_type =%d, num_of_buf=%d. buf_len=%d",
-         heap,  pmem_type, num_of_buf, buf_len);
-    if(num_of_buf > MM_CAMERA_MAX_NUM_FRAMES || heap == NULL ||
-       mGetMemory == NULL ) {
-        ALOGE("Init Heap error");
-        rc = -1;
-        return rc;
-    }
-
-    memset(heap, 0, sizeof(QCameraHalHeap_t));
-    heap->buffer_count = num_of_buf;
-    for(i = 0; i < num_of_buf; i++) {
-        heap->mem_info[i].size = buf_len;
-#ifdef USE_ION
-        if (isZSLMode()) {
-            rc = allocate_ion_memory(&heap->mem_info[i],
-                                     ((0x1 << CAMERA_ZSL_ION_HEAP_ID) | (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
-        }
-        else {
-            rc = allocate_ion_memory(&heap->mem_info[i],
-                                     ((0x1 << CAMERA_ION_HEAP_ID) | (0x1 << CAMERA_ION_FALLBACK_HEAP_ID)));
-        }
-
-        if (rc < 0) {
-            ALOGE("%s: ION allocation failed\n", __func__);
-            break;
-        }
-#else
-        if (pmem_type == MSM_PMEM_MAX){
-            ALOGE("%s : USE_ION not defined, pmemtype == MSM_PMEM_MAX, so ret -1", __func__);
-            rc = -1;
-            break;
-        }
-        else {
-            heap->mem_info[i].fd = open("/dev/pmem_adsp", O_RDWR|O_SYNC);
-            if ( heap->mem_info[i].fd <= 0) {
-                ALOGE("Open fail: heap->fd[%d] =%d", i, heap->mem_info[i].fd);
-                rc = -1;
-                break;
-            }
-        }
-#endif
-        heap->camera_memory[i] = mGetMemory(heap->mem_info[i].fd,
-                                            heap->mem_info[i].size,
-                                            1,
-                                            (void *)this);
-
-        if (heap->camera_memory[i] == NULL ) {
-            ALOGE("Getmem fail %d: ", i);
-            rc = -1;
-            break;
-        }
-
-        if(buf_def != NULL && offset != NULL) {
-            buf_def[i].fd = heap->mem_info[i].fd;
-            buf_def[i].frame_len = heap->mem_info[i].size;
-            buf_def[i].buffer = heap->camera_memory[i]->data;
-            buf_def[i].mem_info = (void *)&heap->mem_info[i];
-            buf_def[i].num_planes = offset->num_planes;
-            /* Plane 0 needs to be set seperately. Set other planes
-             * in a loop. */
-            buf_def[i].planes[0].length = offset->mp[0].len;
-            buf_def[i].planes[0].m.userptr = heap->mem_info[i].fd;
-            buf_def[i].planes[0].data_offset = offset->mp[0].offset;
-            buf_def[i].planes[0].reserved[0] = 0;
-            for (int j = 1; j < buf_def[i].num_planes; j++) {
-                 buf_def[i].planes[j].length = offset->mp[j].len;
-                 buf_def[i].planes[j].m.userptr = heap->mem_info[i].fd;
-                 buf_def[i].planes[j].data_offset = offset->mp[j].offset;
-                 buf_def[i].planes[j].reserved[0] =
-                     buf_def[i].planes[j-1].reserved[0] +
-                     buf_def[i].planes[j-1].length;
-            }
-        }
-
-        ALOGE("heap->fd[%d] =%d, camera_memory=%p", i,
-              heap->mem_info[i].fd, heap->camera_memory[i]);
-        heap->local_flag[i] = 1;
-    }
-    if( rc < 0) {
-        releaseHeapMem(heap);
-    }
-    return rc;
-}
-
-int QCameraHardwareInterface::releaseHeapMem(QCameraHalHeap_t *heap)
-{
-	int rc = 0;
-	ALOGE("Release %p", heap);
-	if (heap != NULL) {
-		for (int i = 0; i < heap->buffer_count; i++) {
-			if(heap->camera_memory[i] != NULL) {
-				heap->camera_memory[i]->release( heap->camera_memory[i] );
-				heap->camera_memory[i] = NULL;
-			} else if (heap->mem_info[i].fd <= 0) {
-				ALOGE("impossible: camera_memory[%d] = %p, fd = %d",
-				i, heap->camera_memory[i], heap->mem_info[i].fd);
-			}
-
-#ifdef USE_ION
-            deallocate_ion_memory(&heap->mem_info[i]);
-#endif
-		}
-        memset(heap, 0, sizeof(QCameraHalHeap_t));
-	}
-	return rc;
-}
-
-preview_format_info_t  QCameraHardwareInterface::getPreviewFormatInfo( )
-{
-  return mPreviewFormatInfo;
-}
-
-void QCameraHardwareInterface::wdenoiseEvent(cam_ctrl_status_t status, void *cookie)
-{
-
-}
-
-bool QCameraHardwareInterface::isWDenoiseEnabled()
-{
-    return mDenoiseValue;
-}
-
-void QCameraHardwareInterface::takePicturePrepareHardware()
-{
-    ALOGV("%s: E", __func__);
-
-    /* Prepare snapshot*/
-    mCameraHandle->ops->prepare_snapshot(mCameraHandle->camera_handle,
-                  mChannelId,
-                  0);
-    ALOGV("%s: X", __func__);
-}
-
-bool QCameraHardwareInterface::isNoDisplayMode()
-{
-  return (mNoDisplayMode != 0);
-}
-
-void QCameraHardwareInterface::restartPreview()
-{
-    if (QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) {
-        stopPreviewInternal();
-        mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-    }
-    startPreview2();
-    mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
-}
-
-// added to support hdr
-bool QCameraHardwareInterface::getHdrInfoAndSetExp(int max_num_frm, int *num_frame, int *exp)
-{
-    bool rc = FALSE;
-    ALOGE("%s, mHdrMode = %d, HDR_MODE = %d", __func__, mHdrMode, HDR_MODE);
-    if (mHdrMode == HDR_MODE && num_frame != NULL && exp != NULL &&
-        mRecordingHint != TRUE &&
-        mPreviewState != QCAMERA_HAL_RECORDING_STARTED ) {
-        ALOGE("%s : mHdrMode == HDR_MODE", __func__);
-        int ret = 0;
-        *num_frame = 1;
-        exp_bracketing_t temp;
-        memset(&temp, 0, sizeof(exp_bracketing_t));
-        ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_HDR, (void *)&temp );
-        ALOGE("hdr - %s : ret = %d", __func__, ret);
-        if (ret == NO_ERROR && max_num_frm > 0) {
-            ALOGE("%s ret == NO_ERROR and max_num_frm = %d", __func__, max_num_frm);
-            /*set as AE Bracketing mode*/
-            temp.hdr_enable = FALSE;
-            temp.mode = HDR_MODE;
-            temp.total_hal_frames = temp.total_frames;
-            ret = native_set_parms(MM_CAMERA_PARM_HDR,
-                                   sizeof(exp_bracketing_t), (void *)&temp);
-            ALOGE("%s, ret from set_parm = %d", __func__, ret);
-            if (ret) {
-                char *val, *exp_value, *prev_value;
-                int i;
-                exp_value = (char *) temp.values;
-                i = 0;
-                val = strtok_r(exp_value,",", &prev_value);
-                while (val != NULL ){
-                    exp[i++] = atoi(val);
-                    if(i >= max_num_frm )
-                        break;
-                    val = strtok_r(NULL, ",", &prev_value);
-                }
-                *num_frame =temp.total_frames;
-                rc = TRUE;
-            }
-        } else {
-            temp.total_frames = 1;
-        }
-        /* Application waits until this many snapshots before restarting preview */
-        mParameters.set("num-snaps-per-shutter", 2);
-    }
-    ALOGE("%s, hdr - rc = %d, num_frame = %d", __func__, rc, *num_frame);
-    return rc;
-}
-
-status_t QCameraHardwareInterface::initHistogramBuffers()
-{
-    int page_size_minus_1 = getpagesize() - 1;
-    int statSize = sizeof (camera_preview_histogram_info );
-    int32_t mAlignedStatSize = ((statSize + page_size_minus_1)
-                                & (~page_size_minus_1));
-    mm_camera_frame_map_type map_buf;
-    ALOGI("%s E ", __func__);
-
-    if (mHistServer.active) {
-        ALOGI("%s Previous buffers not deallocated yet. ", __func__);
-        return BAD_VALUE;
-    }
-
-    mStatSize = sizeof(uint32_t) * HISTOGRAM_STATS_SIZE;
-    mCurrentHisto = -1;
-
-    memset(&map_buf, 0, sizeof(map_buf));
-    for(int cnt = 0; cnt < NUM_HISTOGRAM_BUFFERS; cnt++) {
-        mStatsMapped[cnt] = mGetMemory(-1, mStatSize, 1, mCallbackCookie);
-        if(mStatsMapped[cnt] == NULL) {
-            ALOGE("Failed to get camera memory for stats heap index: %d", cnt);
-            return NO_MEMORY;
-        } else {
-           ALOGI("Received following info for stats mapped data:%p,handle:%p,"
-                 " size:%d,release:%p", mStatsMapped[cnt]->data,
-                 mStatsMapped[cnt]->handle, mStatsMapped[cnt]->size,
-                 mStatsMapped[cnt]->release);
-        }
-        mHistServer.mem_info[cnt].size = sizeof(camera_preview_histogram_info);
-#ifdef USE_ION
-        int flag = (0x1 << ION_CP_MM_HEAP_ID | 0x1 << ION_IOMMU_HEAP_ID);
-        if(allocate_ion_memory(&mHistServer.mem_info[cnt], flag) < 0) {
-            ALOGE("%s ION alloc failed for %d\n", __func__, cnt);
-            return NO_MEMORY;
-        }
-#else
-        mHistServer.mem_info[cnt].fd = open("/dev/pmem_adsp", O_RDWR|O_SYNC);
-        if(mHistServer.mem_info[cnt].fd <= 0) {
-            ALOGE("%s: no pmem for frame %d", __func__, cnt);
-            return NO_INIT;
-        }
-#endif
-        mHistServer.camera_memory[cnt] = mGetMemory(mHistServer.mem_info[cnt].fd,
-                                                    mHistServer.mem_info[cnt].size,
-                                                    1,
-                                                    mCallbackCookie);
-        if(mHistServer.camera_memory[cnt] == NULL) {
-            ALOGE("Failed to get camera memory for server side "
-                  "histogram index: %d", cnt);
-            return NO_MEMORY;
-        } else {
-            ALOGE("Received following info for server side histogram data:%p,"
-                  " handle:%p, size:%d,release:%p",
-                  mHistServer.camera_memory[cnt]->data,
-                  mHistServer.camera_memory[cnt]->handle,
-                  mHistServer.camera_memory[cnt]->size,
-                  mHistServer.camera_memory[cnt]->release);
-        }
-        /*Register buffer at back-end*/
-        map_buf.fd = mHistServer.mem_info[cnt].fd;
-        map_buf.frame_idx = cnt;
-        map_buf.size = mHistServer.mem_info[cnt].size;
-        map_buf.ext_mode = 0;
-        map_buf.is_hist = TRUE;
-        mCameraHandle->ops->send_command(mCameraHandle->camera_handle,
-                                         MM_CAMERA_CMD_TYPE_NATIVE,
-                                         NATIVE_CMD_ID_SOCKET_MAP,
-                                         sizeof(map_buf), &map_buf);
-    }
-    mHistServer.active = TRUE;
-    ALOGI("%s X", __func__);
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::deInitHistogramBuffers()
-{
-    mm_camera_frame_unmap_type unmap_buf;
-    memset(&unmap_buf, 0, sizeof(unmap_buf));
-
-    ALOGI("%s E", __func__);
-
-    if (!mHistServer.active) {
-        ALOGI("%s Histogram buffers not active. return. ", __func__);
-        return NO_ERROR;
-    }
-
-    //release memory
-    for(int i = 0; i < NUM_HISTOGRAM_BUFFERS; i++) {
-        if(mStatsMapped[i] != NULL) {
-            mStatsMapped[i]->release(mStatsMapped[i]);
-        }
-
-        unmap_buf.ext_mode = 0;
-        unmap_buf.frame_idx = i;
-        unmap_buf.is_hist = TRUE;
-        mCameraHandle->ops->send_command(mCameraHandle->camera_handle,
-                                         MM_CAMERA_CMD_TYPE_NATIVE,
-                                         NATIVE_CMD_ID_SOCKET_UNMAP,
-                                         sizeof(unmap_buf), &unmap_buf);
-
-        if(mHistServer.camera_memory[i] != NULL) {
-            mHistServer.camera_memory[i]->release(mHistServer.camera_memory[i]);
-        }
-#ifdef USE_ION
-        deallocate_ion_memory(&mHistServer.mem_info[i]);
-#endif
-    }
-    mHistServer.active = FALSE;
-    ALOGI("%s X", __func__);
-    return NO_ERROR;
-}
-
-mm_jpeg_color_format QCameraHardwareInterface::getColorfmtFromImgFmt(uint32_t img_fmt)
-{
-    switch (img_fmt) {
-    case CAMERA_YUV_420_NV21:
-        return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
-    case CAMERA_YUV_420_NV21_ADRENO:
-        return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
-    case CAMERA_YUV_420_NV12:
-        return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2;
-    case CAMERA_YUV_420_YV12:
-        return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2;
-    case CAMERA_YUV_422_NV61:
-        return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1;
-    case CAMERA_YUV_422_NV16:
-        return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1;
-    default:
-        return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
-    }
-}
-
-void QCameraHardwareInterface::doHdrProcessing()
-{
-    cam_sock_packet_t packet;
-    int i;
-    memset(&packet, 0, sizeof(cam_sock_packet_t));
-    packet.msg_type = CAM_SOCK_MSG_TYPE_HDR_START;
-
-    packet.payload.hdr_pkg.cookie = (long unsigned int) this;
-    packet.payload.hdr_pkg.num_hdr_frames = mHdrInfo.num_frame;
-    ALOGI("%s num frames = %d ", __func__, mHdrInfo.num_frame);
-    for (i = 0; i < mHdrInfo.num_frame; i++) {
-        packet.payload.hdr_pkg.hdr_main_idx[i] =
-            mHdrInfo.recvd_frame[i]->bufs[0]->buf_idx;
-        packet.payload.hdr_pkg.hdr_thm_idx[i] =
-            mHdrInfo.recvd_frame[i]->bufs[1]->buf_idx;
-        packet.payload.hdr_pkg.exp[i] = mHdrInfo.exp[i];
-        ALOGI("%s Adding buffer M %d T %d Exp %d into hdr pkg ", __func__,
-              packet.payload.hdr_pkg.hdr_main_idx[i],
-              packet.payload.hdr_pkg.hdr_thm_idx[i],
-              packet.payload.hdr_pkg.exp[i]);
-    }
-    mCameraHandle->ops->send_command(mCameraHandle->camera_handle,
-                                  MM_CAMERA_CMD_TYPE_NATIVE,
-                                  NATIVE_CMD_ID_IOCTL_CTRL,
-                                  sizeof(cam_sock_packet_t), &packet);
-}
-
-void QCameraHardwareInterface::initHdrInfoForSnapshot(bool Hdr_on, int number_frames, int *exp )
-{
-    ALOGE("%s E hdr_on = %d", __func__, Hdr_on);
-    mHdrInfo.hdr_on = Hdr_on;
-    mHdrInfo.num_frame = number_frames;
-    mHdrInfo.num_raw_received = 0;
-    if(number_frames) {
-        memcpy(mHdrInfo.exp, exp, sizeof(int)*number_frames);
-    }
-    memset(mHdrInfo.recvd_frame, 0,
-           sizeof(mm_camera_super_buf_t *)*MAX_HDR_EXP_FRAME_NUM);
-    ALOGE("%s X", __func__);
-}
-
-void QCameraHardwareInterface::notifyHdrEvent(cam_ctrl_status_t status, void * cookie)
-{
-    ALOGE("%s E", __func__);
-    mm_camera_super_buf_t *frame;
-    int i;
-    ALOGI("%s: HDR Done status (%d) received",__func__,status);
-    for (i = 0; i < 2; i++) {
-        frame = mHdrInfo.recvd_frame[i];
-        mSuperBufQueue.enqueue(frame);
-        /* notify dataNotify thread that new super buf is avail
-        * check if it's done with current JPEG notification and
-        * a new encoding job could be conducted */
-        mNotifyTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
-        mHdrInfo.recvd_frame[i] = NULL;
-    }
-    /* qbuf the third frame */
-    frame = mHdrInfo.recvd_frame[2];
-    for(i = 0; i < frame->num_bufs; i++) {
-        mCameraHandle->ops->qbuf(frame->camera_handle,
-                                 frame->ch_id,
-                                 frame->bufs[i]);
-        cache_ops((QCameraHalMemInfo_t *)(frame->bufs[i]->mem_info),
-                  frame->bufs[i]->buffer,
-                  ION_IOC_INV_CACHES);
-    }
-    free(frame);
-    mHdrInfo.recvd_frame[2] = NULL;
-
-    ALOGE("%s X", __func__);
-}
-
-int QCameraHardwareInterface::cache_ops(QCameraHalMemInfo_t *mem_info,
-                                        void *buf_ptr,
-                                        unsigned int cmd)
-{
-    struct ion_flush_data cache_inv_data;
-    struct ion_custom_data custom_data;
-    int ret = MM_CAMERA_OK;
-
-#ifdef USE_ION
-    if (NULL == mem_info) {
-        ALOGE("%s: mem_info is NULL, return here", __func__);
-        return -1;
-    }
-
-    memset(&cache_inv_data, 0, sizeof(cache_inv_data));
-    memset(&custom_data, 0, sizeof(custom_data));
-    cache_inv_data.vaddr = buf_ptr;
-    cache_inv_data.fd = mem_info->fd;
-    cache_inv_data.handle = mem_info->handle;
-    cache_inv_data.length = mem_info->size;
-    custom_data.cmd = cmd;
-    custom_data.arg = (unsigned long)&cache_inv_data;
-
-    ALOGD("addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d",
-         cache_inv_data.vaddr, cache_inv_data.fd,
-         cache_inv_data.handle, cache_inv_data.length,
-         mem_info->main_ion_fd);
-    if(mem_info->main_ion_fd > 0) {
-        if(ioctl(mem_info->main_ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
-            ALOGE("%s: Cache Invalidate failed\n", __func__);
-            ret = -1;
-        }
-    }
-#endif
-
-    return ret;
-}
-
-uint8_t QCameraHardwareInterface::canTakeFullSizeLiveshot() {
-    if (mFullLiveshotEnabled && !isLowPowerCamcorder()) {
-        /* Full size liveshot enabled. */
-
-        /* If Picture size is same as video size, switch to Video size
-         * live snapshot */
-        if ((mDimension.picture_width == mDimension.video_width) &&
-            (mDimension.picture_height == mDimension.video_height)) {
-            return FALSE;
-        }
-
-        if (mDisEnabled) {
-            /* If DIS is enabled and Picture size is
-             * less than (video size + 10% DIS Margin)
-             * then fall back to Video size liveshot. */
-            if ((mDimension.picture_width <
-                 (int)(mDimension.video_width * 1.1)) ||
-                (mDimension.picture_height <
-                 (int)(mDimension.video_height * 1.1))) {
-                return FALSE;
-            } else {
-                /* Go with Full size live snapshot. */
-                return TRUE;
-            }
-        } else {
-            /* DIS Disabled. Go with Full size live snapshot */
-            return TRUE;
-        }
-    } else {
-        /* Full size liveshot disabled. Fallback to Video size liveshot. */
-        return FALSE;
-    }
-}
-
-QCameraQueue::QCameraQueue()
-{
-    pthread_mutex_init(&mlock, NULL);
-    cam_list_init(&mhead.list);
-    msize = 0;
-    mdata_rel_fn = NULL;
-    muser_data = NULL;
-}
-
-QCameraQueue::QCameraQueue(release_data_fn data_rel_fn, void *user_data)
-{
-    pthread_mutex_init(&mlock, NULL);
-    cam_list_init(&mhead.list);
-    msize = 0;
-    mdata_rel_fn = data_rel_fn;
-    muser_data = user_data;
-}
-
-QCameraQueue::~QCameraQueue()
-{
-    flush();
-    pthread_mutex_destroy(&mlock);
-}
-
-bool QCameraQueue::is_empty()
-{
-    bool isEmpty = true;
-    pthread_mutex_lock(&mlock);
-    if (msize > 0) {
-        isEmpty = false;
-    }
-    pthread_mutex_unlock(&mlock);
-    return isEmpty;
-}
-
-bool QCameraQueue::enqueue(void *data)
-{
-    camera_q_node *node =
-        (camera_q_node *)malloc(sizeof(camera_q_node));
-    if (NULL == node) {
-        ALOGE("%s: No memory for camera_q_node", __func__);
-        return false;
-    }
-
-    memset(node, 0, sizeof(camera_q_node));
-    node->data = data;
-
-    pthread_mutex_lock(&mlock);
-    cam_list_add_tail_node(&node->list, &mhead.list);
-    msize++;
-    pthread_mutex_unlock(&mlock);
-    return true;
-}
-
-/* priority queue, will insert into the head of the queue */
-bool QCameraQueue::pri_enqueue(void *data)
-{
-    camera_q_node *node =
-        (camera_q_node *)malloc(sizeof(camera_q_node));
-    if (NULL == node) {
-        ALOGE("%s: No memory for camera_q_node", __func__);
-        return false;
-    }
-
-    memset(node, 0, sizeof(camera_q_node));
-    node->data = data;
-
-    pthread_mutex_lock(&mlock);
-    struct cam_list *p_next = mhead.list.next;
-
-    mhead.list.next = &node->list;
-    p_next->prev = &node->list;
-    node->list.next = p_next;
-    node->list.prev = &mhead.list;
-
-    msize++;
-    pthread_mutex_unlock(&mlock);
-    return true;
-}
-
-void* QCameraQueue::dequeue()
-{
-    camera_q_node* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&mlock);
-    head = &mhead.list;
-    pos = head->next;
-    if (pos != head) {
-        node = member_of(pos, camera_q_node, list);
-        cam_list_del_node(&node->list);
-        msize--;
-    }
-    pthread_mutex_unlock(&mlock);
-
-    if (NULL != node) {
-        data = node->data;
-        free(node);
-    }
-
-    return data;
-}
-
-void QCameraQueue::flush(){
-    camera_q_node* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&mlock);
-    head = &mhead.list;
-    pos = head->next;
-
-    while(pos != head) {
-        node = member_of(pos, camera_q_node, list);
-        pos = pos->next;
-        cam_list_del_node(&node->list);
-        msize--;
-
-        if (NULL != node->data) {
-            if (mdata_rel_fn) {
-                mdata_rel_fn(node->data, muser_data);
-            }
-            free(node->data);
-        }
-        free(node);
-
-    }
-    msize = 0;
-    pthread_mutex_unlock(&mlock);
-}
-
-QCameraCmdThread::QCameraCmdThread() :
-    cmd_queue()
-{
-    sem_init(&sync_sem, 0, 0);
-    sem_init(&cmd_sem, 0, 0);
-}
-
-QCameraCmdThread::~QCameraCmdThread()
-{
-    sem_destroy(&sync_sem);
-    sem_destroy(&cmd_sem);
-}
-
-int32_t QCameraCmdThread::launch(void *(*start_routine)(void *),
-                                 void* user_data)
-{
-    /* launch the thread */
-    pthread_create(&cmd_pid,
-                   NULL,
-                   start_routine,
-                   user_data);
-    return 0;
-}
-
-int32_t QCameraCmdThread::sendCmd(camera_cmd_type_t cmd, uint8_t sync_cmd, uint8_t priority)
-{
-    camera_cmd_t *node = (camera_cmd_t *)malloc(sizeof(camera_cmd_t));
-    if (NULL == node) {
-        ALOGE("%s: No memory for camera_cmd_t", __func__);
-        return -1;
-    }
-    memset(node, 0, sizeof(camera_cmd_t));
-    node->cmd = cmd;
-
-    ALOGD("%s: enqueue cmd %d", __func__, cmd);
-    if (TRUE == priority) {
-        cmd_queue.pri_enqueue((void *)node);
-    } else {
-        cmd_queue.enqueue((void *)node);
-    }
-    sem_post(&cmd_sem);
-
-    /* if is a sync call, need to wait until it returns */
-    if (sync_cmd) {
-        sem_wait(&sync_sem);
-    }
-    return 0;
-}
-
-camera_cmd_type_t QCameraCmdThread::getCmd()
-{
-    camera_cmd_type_t cmd = CAMERA_CMD_TYPE_NONE;
-    camera_cmd_t *node = (camera_cmd_t *)cmd_queue.dequeue();
-    if (NULL == node) {
-        ALOGD("%s: No notify avail", __func__);
-        return CAMERA_CMD_TYPE_NONE;
-    } else {
-        cmd = node->cmd;
-        free(node);
-    }
-    return cmd;
-}
-
-int32_t QCameraCmdThread::exit()
-{
-    int32_t rc = 0;
-
-    rc = sendCmd(CAMERA_CMD_TYPE_EXIT, FALSE, TRUE);
-    if (0 != rc) {
-        ALOGE("%s: Error during exit, rc = %d", __func__, rc);
-        return rc;
-    }
-
-    /* wait until cmd thread exits */
-    if (pthread_join(cmd_pid, NULL) != 0) {
-        ALOGD("%s: pthread dead already\n", __func__);
-    }
-    cmd_pid = 0;
-    return rc;
-}
-
-}; // namespace android
-
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Mem.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Mem.cpp
deleted file mode 100755
index 37b0e07..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Mem.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHWI_Mem"
-#include <utils/Log.h>
-
-#include <utils/Errors.h>
-#include <utils/threads.h>
-#include <utils/String16.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <cutils/properties.h>
-#include <math.h>
-#if HAVE_ANDROID_OS
-#include <linux/android_pmem.h>
-#endif
-#include <linux/ioctl.h>
-#include <camera/QCameraParameters.h>
-#include <media/mediarecorder.h>
-#include <gralloc_priv.h>
-
-#include "QCameraHWI_Mem.h"
-
-#define CAMERA_HAL_UNUSED(expr) do { (void)(expr); } while (0)
-
-/* QCameraHardwareInterface class implementation goes here*/
-/* following code implement the contol logic of this class*/
-
-namespace android {
-
-
-static bool register_buf(int size,
-                         int frame_size,
-                         int cbcr_offset,
-                         int yoffset,
-                         int pmempreviewfd,
-                         uint32_t offset,
-                         uint8_t *buf,
-                         int pmem_type,
-                         bool vfe_can_write,
-                         bool register_buffer = true);
-
-MemPool::MemPool(int buffer_size, int num_buffers,
-                                         int frame_size,
-                                         const char *name) :
-    mBufferSize(buffer_size),
-    mNumBuffers(num_buffers),
-    mFrameSize(frame_size),
-    mBuffers(NULL), mName(name)
-{
-    int page_size_minus_1 = getpagesize() - 1;
-    mAlignedBufferSize = (buffer_size + page_size_minus_1) & (~page_size_minus_1);
-}
-
-void MemPool::completeInitialization()
-{
-    // If we do not know how big the frame will be, we wait to allocate
-    // the buffers describing the individual frames until we do know their
-    // size.
-
-    if (mFrameSize > 0) {
-        mBuffers = new sp<MemoryBase>[mNumBuffers];
-        for (int i = 0; i < mNumBuffers; i++) {
-            mBuffers[i] = new
-                MemoryBase(mHeap,
-                           i * mAlignedBufferSize,
-                           mFrameSize);
-        }
-    }
-}
-
-AshmemPool::AshmemPool(int buffer_size, int num_buffers,
-                                               int frame_size,
-                                               const char *name) :
-    MemPool(buffer_size,
-                                    num_buffers,
-                                    frame_size,
-                                    name)
-{
-    ALOGV("constructing MemPool %s backed by ashmem: "
-         "%d frames @ %d uint8_ts, "
-         "buffer size %d",
-         mName,
-         num_buffers, frame_size, buffer_size);
-
-    int page_mask = getpagesize() - 1;
-    int ashmem_size = buffer_size * num_buffers;
-    ashmem_size += page_mask;
-    ashmem_size &= ~page_mask;
-
-    mHeap = new MemoryHeapBase(ashmem_size);
-
-    completeInitialization();
-}
-
-static bool register_buf(int size,
-                         int frame_size,
-                         int cbcr_offset,
-                         int yoffset,
-                         int pmempreviewfd,
-                         uint32_t offset,
-                         uint8_t *buf,
-                         int pmem_type,
-                         bool vfe_can_write,
-                         bool register_buffer)
-{
-    return true;
-
-}
-
-PmemPool::~PmemPool()
-{
-    ALOGI("%s: %s E", __FUNCTION__, mName);
-
-    ALOGI("%s: %s X", __FUNCTION__, mName);
-}
-MemPool::~MemPool()
-{
-    ALOGV("destroying MemPool %s", mName);
-    if (mFrameSize > 0)
-        delete [] mBuffers;
-    mHeap.clear();
-    ALOGV("destroying MemPool %s completed", mName);
-}
-
-
-status_t MemPool::dump(int fd, const Vector<String16>& args) const
-{
-    const size_t SIZE = 256;
-    char buffer[SIZE];
-    String8 result;
-    CAMERA_HAL_UNUSED(args);
-    snprintf(buffer, 255, "QualcommCameraHardware::AshmemPool::dump\n");
-    result.append(buffer);
-    if (mName) {
-        snprintf(buffer, 255, "mem pool name (%s)\n", mName);
-        result.append(buffer);
-    }
-    if (mHeap != 0) {
-        snprintf(buffer, 255, "heap base(%p), size(%d), flags(%d), device(%s)\n",
-                 mHeap->getBase(), mHeap->getSize(),
-                 mHeap->getFlags(), mHeap->getDevice());
-        result.append(buffer);
-    }
-    snprintf(buffer, 255,
-             "buffer size (%d), number of buffers (%d), frame size(%d)",
-             mBufferSize, mNumBuffers, mFrameSize);
-    result.append(buffer);
-    write(fd, result.string(), result.size());
-    return NO_ERROR;
-}
-
-};
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Parm.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Parm.cpp
deleted file mode 100755
index c37e341..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Parm.cpp
+++ /dev/null
@@ -1,4277 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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 ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHWI_Parm"
-#include <utils/Log.h>
-
-#include <utils/Errors.h>
-#include <utils/threads.h>
-#include <utils/String16.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <cutils/properties.h>
-#include <math.h>
-#if HAVE_ANDROID_OS
-#include <linux/android_pmem.h>
-#endif
-#include <linux/ioctl.h>
-#include <camera/QCameraParameters.h>
-#include <media/mediarecorder.h>
-#include <gralloc_priv.h>
-
-#include "linux/msm_mdp.h"
-#include <linux/fb.h>
-#include <limits.h>
-
-
-extern "C" {
-#include <fcntl.h>
-#include <time.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <termios.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <signal.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/system_properties.h>
-#include <sys/time.h>
-#include <stdlib.h>
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include <cam_fifo.h>
-#include <jpege.h>
-
-} // extern "C"
-
-#include "QCameraHWI.h"
-
-/* QCameraHardwareInterface class implementation goes here*/
-/* following code implements the parameter logic of this class*/
-#define EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR 12
-#define EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR -12
-#define EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR 0
-#define EXPOSURE_COMPENSATION_DENOMINATOR 6
-#define EXPOSURE_COMPENSATION_STEP ((float (1))/EXPOSURE_COMPENSATION_DENOMINATOR)
-#define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)"
-
-#define HDR_HAL_FRAME 2
-
-#define BURST_INTREVAL_MIN 1
-#define BURST_INTREVAL_MAX 10
-#define BURST_INTREVAL_DEFAULT 1
-
-//Default FPS
-#define MINIMUM_FPS 5
-#define MAXIMUM_FPS 120
-#define DEFAULT_FIXED_FPS 30
-#define DEFAULT_FPS MAXIMUM_FPS
-
-//Default Picture Width
-#define DEFAULT_PICTURE_WIDTH  640
-#define DEFAULT_PICTURE_HEIGHT 480
-
-//Default Video Width
-#define DEFAULT_VIDEO_WIDTH 1920
-#define DEFAULT_VIDEO_HEIGHT 1080
-
-#define THUMBNAIL_SIZE_COUNT (sizeof(thumbnail_sizes)/sizeof(thumbnail_size_type))
-#define DEFAULT_THUMBNAIL_SETTING 4
-#define THUMBNAIL_WIDTH_STR "512"
-#define THUMBNAIL_HEIGHT_STR "384"
-#define THUMBNAIL_SMALL_HEIGHT 144
-
-#define DONT_CARE_COORDINATE -1
-
-// All fps ranges which can be supported. This list will be filtered according
-// to the min and max fps supported by hardware
-// this list must be sorted first by max_fps and then min_fps
-// fps values are multiplied by 1000
-static android::FPSRange allFpsRanges[] = {
-            android::FPSRange(7500, 7500),
-            android::FPSRange(10000, 10000),
-            android::FPSRange(7500, 15000),
-            android::FPSRange(15000, 15000),
-            android::FPSRange(7500, 20000),
-            android::FPSRange(20000, 20000),
-            android::FPSRange(7500, 30000),
-            android::FPSRange(10000, 30000),
-            android::FPSRange(15000, 30000),
-            android::FPSRange(30000, 30000)
-};
-#define ALL_FPS_RANGES_COUNT (sizeof(allFpsRanges)/sizeof(android::FPSRange))
-
-typedef struct {
-    uint32_t aspect_ratio;
-    uint32_t width;
-    uint32_t height;
-} thumbnail_size_type;
-
-static thumbnail_size_type thumbnail_sizes[] = {
-{ 7281, 512, 288 }, //1.777778
-{ 6826, 480, 288 }, //1.666667
-{ 6808, 256, 154 }, //1.66233
-{ 6144, 432, 288 }, //1.5
-{ 5461, 512, 384 }, //1.333333
-{ 5006, 352, 288 }, //1.222222
-{ 5461, 320, 240 }, //1.33333
-{ 5006, 176, 144 }, //1.222222
-
-};
-
-static struct camera_size_type zsl_picture_sizes[] = {
-  { 1024, 768}, // 1MP XGA
-  { 800, 600}, //SVGA
-  { 800, 480}, // WVGA
-  { 640, 480}, // VGA
-  { 352, 288}, //CIF
-  { 320, 240}, // QVGA
-  { 176, 144} // QCIF
-};
-
-static camera_size_type default_picture_sizes[] = {
-  { 4000, 3000}, // 12MP
-  { 3200, 2400}, // 8MP
-  { 2592, 1944}, // 5MP
-  { 2048, 1536}, // 3MP QXGA
-  { 1920, 1080}, //HD1080
-  { 1600, 1200}, // 2MP UXGA
-  { 1280, 768}, //WXGA
-  { 1280, 720}, //HD720
-  { 1024, 768}, // 1MP XGA
-  { 800, 600}, //SVGA
-  { 800, 480}, // WVGA
-  { 720, 480},
-  { 640, 480}, // VGA
-  { 352, 288}, //CIF
-  { 320, 240}, // QVGA
-  { 176, 144} // QCIF
-};
-
-static int iso_speed_values[] = {
-    0, 1, 100, 200, 400, 800, 1600
-};
-
-extern int HAL_numOfCameras;
-extern camera_info_t HAL_cameraInfo[MSM_MAX_CAMERA_SENSORS];
-extern mm_camera_info_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS];
-
-namespace android {
-
-static uint32_t  HFR_SIZE_COUNT=2;
-static const int PICTURE_FORMAT_JPEG = 1;
-static const int PICTURE_FORMAT_RAW = 2;
-
-/********************************************************************/
-static const str_map effects[] = {
-    { QCameraParameters::EFFECT_NONE,       CAMERA_EFFECT_OFF },
-    { QCameraParameters::EFFECT_MONO,       CAMERA_EFFECT_MONO },
-    { QCameraParameters::EFFECT_NEGATIVE,   CAMERA_EFFECT_NEGATIVE },
-    { QCameraParameters::EFFECT_SOLARIZE,   CAMERA_EFFECT_SOLARIZE },
-    { QCameraParameters::EFFECT_SEPIA,      CAMERA_EFFECT_SEPIA },
-    { QCameraParameters::EFFECT_POSTERIZE,  CAMERA_EFFECT_POSTERIZE },
-    { QCameraParameters::EFFECT_WHITEBOARD, CAMERA_EFFECT_WHITEBOARD },
-    { QCameraParameters::EFFECT_BLACKBOARD, CAMERA_EFFECT_BLACKBOARD },
-    { QCameraParameters::EFFECT_AQUA,       CAMERA_EFFECT_AQUA },
-    { QCameraParameters::EFFECT_EMBOSS,     CAMERA_EFFECT_EMBOSS },
-    { QCameraParameters::EFFECT_SKETCH,     CAMERA_EFFECT_SKETCH },
-    { QCameraParameters::EFFECT_NEON,       CAMERA_EFFECT_NEON }
-};
-
-static const str_map iso[] = {
-    { QCameraParameters::ISO_AUTO,  CAMERA_ISO_AUTO},
-    { QCameraParameters::ISO_HJR,   CAMERA_ISO_DEBLUR},
-    { QCameraParameters::ISO_100,   CAMERA_ISO_100},
-    { QCameraParameters::ISO_200,   CAMERA_ISO_200},
-    { QCameraParameters::ISO_400,   CAMERA_ISO_400},
-    { QCameraParameters::ISO_800,   CAMERA_ISO_800 },
-    { QCameraParameters::ISO_1600,  CAMERA_ISO_1600 }
-};
-
-static const str_map scenemode[] = {
-    { QCameraParameters::SCENE_MODE_AUTO,           CAMERA_BESTSHOT_OFF },
-    { QCameraParameters::SCENE_MODE_ASD,            CAMERA_BESTSHOT_AUTO },
-    { QCameraParameters::SCENE_MODE_ACTION,         CAMERA_BESTSHOT_ACTION },
-    { QCameraParameters::SCENE_MODE_PORTRAIT,       CAMERA_BESTSHOT_PORTRAIT },
-    { QCameraParameters::SCENE_MODE_LANDSCAPE,      CAMERA_BESTSHOT_LANDSCAPE },
-    { QCameraParameters::SCENE_MODE_NIGHT,          CAMERA_BESTSHOT_NIGHT },
-    { QCameraParameters::SCENE_MODE_NIGHT_PORTRAIT, CAMERA_BESTSHOT_NIGHT_PORTRAIT },
-    { QCameraParameters::SCENE_MODE_THEATRE,        CAMERA_BESTSHOT_THEATRE },
-    { QCameraParameters::SCENE_MODE_BEACH,          CAMERA_BESTSHOT_BEACH },
-    { QCameraParameters::SCENE_MODE_SNOW,           CAMERA_BESTSHOT_SNOW },
-    { QCameraParameters::SCENE_MODE_SUNSET,         CAMERA_BESTSHOT_SUNSET },
-    { QCameraParameters::SCENE_MODE_STEADYPHOTO,    CAMERA_BESTSHOT_ANTISHAKE },
-    { QCameraParameters::SCENE_MODE_FIREWORKS ,     CAMERA_BESTSHOT_FIREWORKS },
-    { QCameraParameters::SCENE_MODE_SPORTS ,        CAMERA_BESTSHOT_SPORTS },
-    { QCameraParameters::SCENE_MODE_PARTY,          CAMERA_BESTSHOT_PARTY },
-    { QCameraParameters::SCENE_MODE_CANDLELIGHT,    CAMERA_BESTSHOT_CANDLELIGHT },
-    { QCameraParameters::SCENE_MODE_BACKLIGHT,      CAMERA_BESTSHOT_BACKLIGHT },
-    { QCameraParameters::SCENE_MODE_FLOWERS,        CAMERA_BESTSHOT_FLOWERS },
-    { QCameraParameters::SCENE_MODE_AR,             CAMERA_BESTSHOT_AR },
-};
-
-static const str_map scenedetect[] = {
-    { QCameraParameters::SCENE_DETECT_OFF, FALSE  },
-    { QCameraParameters::SCENE_DETECT_ON, TRUE },
-};
-
-#define DONT_CARE AF_MODE_MAX
-static const str_map focus_modes[] = {
-    { QCameraParameters::FOCUS_MODE_AUTO,     AF_MODE_AUTO},
-    { QCameraParameters::FOCUS_MODE_INFINITY, AF_MODE_INFINITY },
-    { QCameraParameters::FOCUS_MODE_NORMAL,   AF_MODE_NORMAL },
-    { QCameraParameters::FOCUS_MODE_MACRO,    AF_MODE_MACRO },
-    { QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE, AF_MODE_CAF},
-    { QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO, AF_MODE_CAF }
-};
-
-static const str_map selectable_zone_af[] = {
-    { QCameraParameters::SELECTABLE_ZONE_AF_AUTO,  AUTO },
-    { QCameraParameters::SELECTABLE_ZONE_AF_SPOT_METERING, SPOT },
-    { QCameraParameters::SELECTABLE_ZONE_AF_CENTER_WEIGHTED, CENTER_WEIGHTED },
-    { QCameraParameters::SELECTABLE_ZONE_AF_FRAME_AVERAGE, AVERAGE }
-};
-
-// from qcamera/common/camera.h
-static const str_map autoexposure[] = {
-    { QCameraParameters::AUTO_EXPOSURE_FRAME_AVG,  CAMERA_AEC_FRAME_AVERAGE },
-    { QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED, CAMERA_AEC_CENTER_WEIGHTED },
-    { QCameraParameters::AUTO_EXPOSURE_SPOT_METERING, CAMERA_AEC_SPOT_METERING }
-};
-
-// from aeecamera.h
-static const str_map whitebalance[] = {
-    { QCameraParameters::WHITE_BALANCE_AUTO,            CAMERA_WB_AUTO },
-    { QCameraParameters::WHITE_BALANCE_INCANDESCENT,    CAMERA_WB_INCANDESCENT },
-    { QCameraParameters::WHITE_BALANCE_FLUORESCENT,     CAMERA_WB_FLUORESCENT },
-    { QCameraParameters::WHITE_BALANCE_DAYLIGHT,        CAMERA_WB_DAYLIGHT },
-    { QCameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT, CAMERA_WB_CLOUDY_DAYLIGHT }
-};
-
-static const str_map antibanding[] = {
-    { QCameraParameters::ANTIBANDING_OFF,  CAMERA_ANTIBANDING_OFF },
-    { QCameraParameters::ANTIBANDING_50HZ, CAMERA_ANTIBANDING_50HZ },
-    { QCameraParameters::ANTIBANDING_60HZ, CAMERA_ANTIBANDING_60HZ },
-    { QCameraParameters::ANTIBANDING_AUTO, CAMERA_ANTIBANDING_AUTO }
-};
-
-static const str_map frame_rate_modes[] = {
-        {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO},
-        {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED}
-};
-
-static const str_map touchafaec[] = {
-    { QCameraParameters::TOUCH_AF_AEC_OFF, FALSE },
-    { QCameraParameters::TOUCH_AF_AEC_ON, TRUE }
-};
-
-static const str_map hfr[] = {
-    { QCameraParameters::VIDEO_HFR_OFF, CAMERA_HFR_MODE_OFF },
-    { QCameraParameters::VIDEO_HFR_2X, CAMERA_HFR_MODE_60FPS },
-    { QCameraParameters::VIDEO_HFR_3X, CAMERA_HFR_MODE_90FPS },
-    { QCameraParameters::VIDEO_HFR_4X, CAMERA_HFR_MODE_120FPS },
-};
-static const int HFR_VALUES_COUNT = (sizeof(hfr)/sizeof(str_map));
-
-static const str_map flash[] = {
-    { QCameraParameters::FLASH_MODE_OFF,  LED_MODE_OFF },
-    { QCameraParameters::FLASH_MODE_AUTO, LED_MODE_AUTO },
-    { QCameraParameters::FLASH_MODE_ON, LED_MODE_ON },
-    { QCameraParameters::FLASH_MODE_TORCH, LED_MODE_TORCH}
-};
-
-static const str_map lensshade[] = {
-    { QCameraParameters::LENSSHADE_ENABLE, TRUE },
-    { QCameraParameters::LENSSHADE_DISABLE, FALSE }
-};
-
-static const str_map mce[] = {
-    { QCameraParameters::MCE_ENABLE, TRUE },
-    { QCameraParameters::MCE_DISABLE, FALSE }
-};
-
-static const str_map histogram[] = {
-    { QCameraParameters::HISTOGRAM_ENABLE, TRUE },
-    { QCameraParameters::HISTOGRAM_DISABLE, FALSE }
-};
-
-static const str_map skinToneEnhancement[] = {
-    { QCameraParameters::SKIN_TONE_ENHANCEMENT_ENABLE, TRUE },
-    { QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE, FALSE }
-};
-
-static const str_map denoise[] = {
-    { QCameraParameters::DENOISE_OFF, FALSE },
-    { QCameraParameters::DENOISE_ON, TRUE }
-};
-
-static const str_map facedetection[] = {
-    { QCameraParameters::FACE_DETECTION_OFF, FALSE },
-    { QCameraParameters::FACE_DETECTION_ON, TRUE }
-};
-
-static const str_map redeye_reduction[] = {
-    { QCameraParameters::REDEYE_REDUCTION_ENABLE, TRUE },
-    { QCameraParameters::REDEYE_REDUCTION_DISABLE, FALSE }
-};
-
-static const str_map picture_formats[] = {
-        {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG},
-        {QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW}
-};
-
-static const str_map recording_Hints[] = {
-        {"false", FALSE},
-        {"true",  TRUE}
-};
-
-static const str_map preview_formats[] = {
-        {QCameraParameters::PIXEL_FORMAT_YUV420SP,   HAL_PIXEL_FORMAT_YCrCb_420_SP},
-        {QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO, HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO},
-        {QCameraParameters::PIXEL_FORMAT_YV12, HAL_PIXEL_FORMAT_YV12},
-        {QCameraParameters::PIXEL_FORMAT_YUV420P,HAL_PIXEL_FORMAT_YV12},
-        {QCameraParameters::PIXEL_FORMAT_NV12, HAL_PIXEL_FORMAT_YCbCr_420_SP}
-};
-
-static const preview_format_info_t preview_format_info_list[] = {
-  {HAL_PIXEL_FORMAT_YCrCb_420_SP, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_WORD, 2},
-  {HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_4K, 2},
-  {HAL_PIXEL_FORMAT_YCbCr_420_SP, CAMERA_YUV_420_NV12, CAMERA_PAD_TO_WORD, 2},
-  {HAL_PIXEL_FORMAT_YV12,         CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3}
-};
-
-static const str_map zsl_modes[] = {
-    { QCameraParameters::ZSL_OFF, FALSE },
-    { QCameraParameters::ZSL_ON, TRUE },
-};
-
-
-static const str_map hdr_bracket[] = {
-    { QCameraParameters::AE_BRACKET_HDR_OFF,HDR_BRACKETING_OFF},
-    { QCameraParameters::AE_BRACKET_HDR,HDR_MODE },
-    { QCameraParameters::AE_BRACKET,EXP_BRACKETING_MODE }
-};
-
-typedef enum {
-    NORMAL_POWER,
-    LOW_POWER
-} power_mode;
-
-static const str_map power_modes[] = {
-    { QCameraParameters::NORMAL_POWER,NORMAL_POWER },
-    { QCameraParameters::LOW_POWER,LOW_POWER }
-};
-
-/**************************************************************************/
-static int attr_lookup(const str_map arr[], int len, const char *name)
-{
-    if (name) {
-        for (int i = 0; i < len; i++) {
-            if (!strcmp(arr[i].desc, name))
-                return arr[i].val;
-        }
-    }
-    return NOT_FOUND;
-}
-
-bool QCameraHardwareInterface::native_set_parms(
-    mm_camera_parm_type_t type, uint16_t length, void *value)
-{
-    ALOGV("%s : type : %d Value : %d",__func__,type,*((int *)value));
-    if(mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, type,value ) < 0) {
-        ALOGE("native_set_parms failed: type %d length %d error %s",
-            type, length, strerror(errno));
-        return false;
-    }
-
-    return true;
-
-}
-
-bool QCameraHardwareInterface::native_set_parms(
-    mm_camera_parm_type_t type, uint16_t length, void *value, int *result)
-{
-    *result= mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, type,value );
-    if( *result >=0 ) {
-        ALOGE("native_set_parms: succeeded : %d", *result);
-        return true;
-    }
-
-    ALOGV("native_set_parms failed: type %d length %d error str %s error# %d",
-        type, length, strerror(errno), errno);
-    return false;
-}
-
-//Filter Picture sizes based on max width and height
-/* TBD: do we still need this - except for ZSL? */
-void QCameraHardwareInterface::filterPictureSizes(){
-    unsigned int i;
-    if(mPictureSizeCount <= 0)
-        return;
-    maxSnapshotWidth = mPictureSizes[0].width;
-    maxSnapshotHeight = mPictureSizes[0].height;
-   // Iterate through all the width and height to find the max value
-    for(i =0; i<mPictureSizeCount;i++){
-        if(((maxSnapshotWidth < mPictureSizes[i].width) &&
-            (maxSnapshotHeight <= mPictureSizes[i].height))){
-            maxSnapshotWidth = mPictureSizes[i].width;
-            maxSnapshotHeight = mPictureSizes[i].height;
-        }
-    }
-    if(myMode & CAMERA_ZSL_MODE){
-        // due to lack of PMEM we restrict to lower resolution
-        mPictureSizesPtr = zsl_picture_sizes;
-        mSupportedPictureSizesCount = 7;
-    }else{
-        mPictureSizesPtr = mPictureSizes;
-        mSupportedPictureSizesCount = mPictureSizeCount;
-    }
-}
-
-static String8 create_sizes_str(const camera_size_type *sizes, int len) {
-    String8 str;
-    char buffer[32];
-
-    if (len > 0) {
-        snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
-        str.append(buffer);
-    }
-    for (int i = 1; i < len; i++) {
-        snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height);
-        str.append(buffer);
-    }
-    return str;
-}
-
-String8 QCameraHardwareInterface::create_values_str(const str_map *values, int len) {
-    String8 str;
-
-    if (len > 0) {
-        str.append(values[0].desc);
-    }
-    for (int i = 1; i < len; i++) {
-        str.append(",");
-        str.append(values[i].desc);
-    }
-    return str;
-}
-
-static String8 create_fps_str(const android:: FPSRange* fps, int len) {
-    String8 str;
-    char buffer[32];
-
-    if (len > 0) {
-        snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS);
-        str.append(buffer);
-    }
-    for (int i = 1; i < len; i++) {
-        snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS);
-        str.append(buffer);
-    }
-    return str;
-}
-
-static String8 create_values_range_str(int min, int max){
-    String8 str;
-    char buffer[32];
-
-    if(min <= max){
-        snprintf(buffer, sizeof(buffer), "%d", min);
-        str.append(buffer);
-
-        for (int i = min + 1; i <= max; i++) {
-            snprintf(buffer, sizeof(buffer), ",%d", i);
-            str.append(buffer);
-        }
-    }
-    return str;
-}
-
-static int parse_size(const char *str, int &width, int &height)
-{
-    // Find the width.
-    char *end;
-    int w = (int)strtol(str, &end, 10);
-    // If an 'x' or 'X' does not immediately follow, give up.
-    if ( (*end != 'x') && (*end != 'X') )
-        return -1;
-
-    // Find the height, immediately after the 'x'.
-    int h = (int)strtol(end+1, 0, 10);
-
-    width = w;
-    height = h;
-
-    return 0;
-}
-
-bool QCameraHardwareInterface::isValidDimension(int width, int height) {
-    bool retVal = FALSE;
-    /* This function checks if a given resolution is valid or not.
-     * A particular resolution is considered valid if it satisfies
-     * the following conditions:
-     * 1. width & height should be multiple of 16.
-     * 2. width & height should be less than/equal to the dimensions
-     *    supported by the camera sensor.
-     * 3. the aspect ratio is a valid aspect ratio and is among the
-     *    commonly used aspect ratio as determined by the thumbnail_sizes
-     *    data structure.
-     */
-
-    if( (width == CEILING16(width)) && (height == CEILING16(height))
-     && (width <= maxSnapshotWidth)
-    && (height <= maxSnapshotHeight) )
-    {
-        uint32_t pictureAspectRatio = (uint32_t)((width * Q12)/height);
-        for(uint32_t i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ) {
-            if(thumbnail_sizes[i].aspect_ratio == pictureAspectRatio) {
-                retVal = TRUE;
-                break;
-            }
-        }
-    }
-    return retVal;
-}
-
-void QCameraHardwareInterface::hasAutoFocusSupport(){
-
-    ALOGV("%s",__func__);
-    mHasAutoFocusSupport = false;
-
-    if(isZSLMode()){
-        mHasAutoFocusSupport = false;
-        return;
-    }
-
-    if(mCameraHandle->ops->is_op_supported(mCameraHandle->camera_handle, MM_CAMERA_OPS_FOCUS)) {
-        mHasAutoFocusSupport = true;
-    }
-    else {
-        ALOGE("AutoFocus is not supported");
-        mHasAutoFocusSupport = false;
-    }
-    ALOGV("%s:rc= %d",__func__, mHasAutoFocusSupport);
-
-}
-
-bool QCameraHardwareInterface::supportsSceneDetection() {
-   bool rc ;
-   mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_ASD_ENABLE,(uint8_t*)&rc,(uint8_t*)&rc);
-   return rc;
-}
-
-bool QCameraHardwareInterface::supportsFaceDetection() {
-    bool rc ;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_FD,(uint8_t*)&rc,(uint8_t*)&rc);
-    return rc;
-}
-
-bool QCameraHardwareInterface::supportsSelectableZoneAf() {
-   bool rc ;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_FOCUS_RECT,(uint8_t*)&rc,(uint8_t*)&rc);
-   return rc;
-}
-
-bool QCameraHardwareInterface::supportsRedEyeReduction() {
-   bool rc ;
-   mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_REDEYE_REDUCTION,(uint8_t*)&rc,(uint8_t*)&rc);
-   return rc;
-}
-
-static String8 create_str(int16_t *arr, int length){
-    String8 str;
-    char buffer[32] = {0};
-
-    if(length > 0){
-        snprintf(buffer, sizeof(buffer), "%d", arr[0]);
-        str.append(buffer);
-    }
-
-    for (int i =1;i<length;i++){
-        snprintf(buffer, sizeof(buffer), ",%d",arr[i]);
-        str.append(buffer);
-    }
-    return str;
-}
-
-bool QCameraHardwareInterface::getMaxPictureDimension(mm_camera_dimension_t *maxDim)
-{
-    bool ret = NO_ERROR;
-    mm_camera_dimension_t dim;
-
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                              MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim);
-    if (ret != NO_ERROR)
-        return ret;
-
-    /* Find the first dimension in the mPictureSizes
-     * array which is smaller than the max dimension.
-     * This will be the valid max picture resolution */
-    for (unsigned int i = 0; i < mPictureSizeCount; i++) {
-        if ((mPictureSizes[i].width <= dim.width) &&
-            (mPictureSizes[i].height <= dim.height)) {
-            maxDim->height = mPictureSizes[i].height;
-            maxDim->width  = mPictureSizes[i].width;
-            break;
-        }
-    }
-    ALOGD("%s: Found Max Picture dimension: %d x %d", __func__,
-          maxDim->width, maxDim->height);
-    return ret;
-}
-void QCameraHardwareInterface::loadTables()
-{
-
-    bool ret = NO_ERROR;
-    ALOGV("%s: E", __func__);
-
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-            MM_CAMERA_PARM_PREVIEW_SIZES_CNT, &preview_sizes_count);
-
-    default_sizes_tbl_t preview_sizes_tbl;
-    preview_sizes_tbl.tbl_size=preview_sizes_count;
-    preview_sizes_tbl.sizes_tbl=&default_preview_sizes[0];
-    if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                            MM_CAMERA_PARM_DEF_PREVIEW_SIZES, &preview_sizes_tbl)<0){
-        ALOGE("%s:Failed to get default preview sizes",__func__);
-    }
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                MM_CAMERA_PARM_VIDEO_SIZES_CNT, &video_sizes_count);
-
-    default_sizes_tbl_t video_sizes_tbl;
-    video_sizes_tbl.tbl_size=video_sizes_count;
-    video_sizes_tbl.sizes_tbl=&default_video_sizes[0];
-    if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                            MM_CAMERA_PARM_DEF_VIDEO_SIZES, &video_sizes_tbl)<0){
-        ALOGE("%s:Failed to get default video sizes",__func__);
-    }
-
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                MM_CAMERA_PARM_THUMB_SIZES_CNT, &thumbnail_sizes_count);
-
-    default_sizes_tbl_t thumbnail_sizes_tbl;
-    thumbnail_sizes_tbl.tbl_size=thumbnail_sizes_count;
-    thumbnail_sizes_tbl.sizes_tbl=&default_thumbnail_sizes[0];
-    if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                            MM_CAMERA_PARM_DEF_THUMB_SIZES, &thumbnail_sizes_tbl)<0){
-        ALOGE("%s:Failed to get default thumbnail sizes",__func__);
-    }
-
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                MM_CAMERA_PARM_HFR_SIZES_CNT, &hfr_sizes_count);
-
-    default_sizes_tbl_t hfr_sizes_tbl;
-    hfr_sizes_tbl.tbl_size=hfr_sizes_count;
-    hfr_sizes_tbl.sizes_tbl=&default_hfr_sizes[0];
-    if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                            MM_CAMERA_PARM_DEF_HFR_SIZES, &hfr_sizes_tbl)<0){
-        ALOGE("%s:Failed to get default HFR  sizes",__func__);
-    }
-    ALOGE("%s: X", __func__);
-}
-void QCameraHardwareInterface::initDefaultParameters()
-{
-    bool ret;
-    char prop[PROPERTY_VALUE_MAX];
-    mm_camera_dimension_t maxDim;
-    int rc = 0;
-    ALOGI("%s: E", __func__);
-    uint8_t supported;
-
-    memset(&maxDim, 0, sizeof(mm_camera_dimension_t));
-    ret = getMaxPictureDimension(&maxDim);
-
-    if (ret != NO_ERROR) {
-        ALOGE("%s: Cannot get Max picture size supported", __func__);
-        return;
-    }
-    if (!maxDim.width || !maxDim.height) {
-        maxDim.width = DEFAULT_LIVESHOT_WIDTH;
-        maxDim.height = DEFAULT_LIVESHOT_HEIGHT;
-    }
-
-    memset(prop, 0, sizeof(prop));
-    property_get("persist.camera.snap.format", prop, "0");
-    mSnapshotFormat = atoi(prop);
-    ALOGV("%s: prop =(%s), snap_format=%d", __func__, prop, mSnapshotFormat);
-
-    //cam_ctrl_dimension_t dim;
-    mHFRLevel = 0;
-    memset(&mDimension, 0, sizeof(cam_ctrl_dimension_t));
-    memset(&mPreviewFormatInfo, 0, sizeof(preview_format_info_t));
-    mDimension.video_width     = DEFAULT_VIDEO_WIDTH;
-    mDimension.video_height    = DEFAULT_VIDEO_HEIGHT;
-    mDimension.picture_width   = maxDim.width;
-    mDimension.picture_height  = maxDim.height;
-    mDimension.display_width   = DEFAULT_STREAM_WIDTH;
-    mDimension.display_height  = DEFAULT_STREAM_HEIGHT;
-    mDimension.orig_picture_dx = mDimension.picture_width;
-    mDimension.orig_picture_dy = mDimension.picture_height;
-    mDimension.ui_thumbnail_width = DEFAULT_STREAM_WIDTH;
-    mDimension.ui_thumbnail_height = DEFAULT_STREAM_HEIGHT;
-    mDimension.orig_video_width = DEFAULT_STREAM_WIDTH;
-    mDimension.orig_video_height = DEFAULT_STREAM_HEIGHT;
-
-    mDimension.prev_format     = CAMERA_YUV_420_NV21;
-    mDimension.enc_format      = CAMERA_YUV_420_NV12;
-    if (mSnapshotFormat == 1) {
-      mDimension.main_img_format = CAMERA_YUV_422_NV61;
-    } else {
-      mDimension.main_img_format = CAMERA_YUV_420_NV21;
-    }
-    mDimension.thumb_format    = CAMERA_YUV_420_NV21;
-    ALOGV("%s: main_img_format =%d, thumb_format=%d", __func__,
-         mDimension.main_img_format, mDimension.thumb_format);
-    mDimension.prev_padding_format = CAMERA_PAD_TO_WORD;
-
-    ret = native_set_parms(MM_CAMERA_PARM_DIMENSION,
-                              sizeof(cam_ctrl_dimension_t), (void *) &mDimension);
-    if(!ret) {
-      ALOGE("MM_CAMERA_PARM_DIMENSION Failed.");
-      return;
-    }
-
-    hasAutoFocusSupport();
-
-    // Initialize constant parameter strings. This will happen only once in the
-    // lifetime of the mediaserver process.
-    if (true/*!mParamStringInitialized*/) {
-        //filter picture sizes
-        filterPictureSizes();
-        mPictureSizeValues = create_sizes_str(
-                mPictureSizesPtr, mSupportedPictureSizesCount);
-        mPreviewSizeValues = create_sizes_str(
-                mPreviewSizes,  mPreviewSizeCount);
-        mVideoSizeValues = create_sizes_str(
-                mVideoSizes,  mVideoSizeCount);
-
-        //Query for max HFR value
-        camera_hfr_mode_t maxHFR;
-        mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_MAX_HFR_MODE, (void *)&maxHFR);
-        //Filter HFR values and build parameter string
-        String8 str;
-        for(int i=0; i<HFR_VALUES_COUNT; i++){
-            if(hfr[i].val <= maxHFR){
-                if(i>0)	str.append(",");
-                str.append(hfr[i].desc);
-            }
-        }
-        mHfrValues = str;
-        mHfrSizeValues = create_sizes_str(
-                default_hfr_sizes, hfr_sizes_count);
-
-        //Query for min and max fps values from lower layer
-        if(MM_CAMERA_OK != mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                                     MM_CAMERA_PARM_FPS_RANGE, (void *)&mSensorFpsRange)){
-            ALOGE("error: failed to get fps range from sensor");
-            return;
-        } else {
-            ALOGD("sensor fps range = (%f, %f)", mSensorFpsRange.min_fps,
-                            mSensorFpsRange.max_fps);
-
-            mSupportedFpsRanges = new android::FPSRange[ALL_FPS_RANGES_COUNT+1];
-
-            //min and max fps in android format
-            int minFps = (int)(mSensorFpsRange.min_fps * 1000);
-            int maxFps = (int)(mSensorFpsRange.max_fps * 1000);
-            int idx=0;
-            //filter supported fps ranges according to sensor fps range
-            for(int i=0; i<(int)ALL_FPS_RANGES_COUNT; i++) {
-                if(allFpsRanges[i].maxFPS <= maxFps && allFpsRanges[i].minFPS >= minFps) {
-                    memcpy(&mSupportedFpsRanges[idx], &allFpsRanges[i], sizeof(android::FPSRange));
-                    idx++;
-                }
-            }
-            mSupportedFpsRangesCount = idx;
-            //insert sensor absolute fps range as one entry, if
-            //its not already there in table
-            //find insertion point
-            int insertIndex = mSupportedFpsRangesCount;
-            for(int i=0; i<mSupportedFpsRangesCount; i++) {
-                if(mSupportedFpsRanges[i].maxFPS < maxFps) {
-                   continue;
-                } else if (mSupportedFpsRanges[i].maxFPS == maxFps) {
-                    if(mSupportedFpsRanges[i].minFPS > minFps) {
-                        insertIndex = i;
-                        break;
-                    } else if (mSupportedFpsRanges[i].minFPS == minFps) {
-                        //entry already exists, no need to insert
-                        insertIndex = -1;
-                        break;
-                    }
-                }
-            }
-            if(insertIndex != -1) {
-                for(int i=mSupportedFpsRangesCount; i>=0; i--) {
-                    if(insertIndex == i) {
-                        mSupportedFpsRanges[i].maxFPS = maxFps;
-                        mSupportedFpsRanges[i].minFPS = minFps;
-                        mSupportedFpsRangesCount++;
-                        break;
-                    }
-                    mSupportedFpsRanges[i].maxFPS = mSupportedFpsRanges[i-1].maxFPS;
-                    mSupportedFpsRanges[i].minFPS = mSupportedFpsRanges[i-1].minFPS;
-                }
-            }
-            mFpsRangesSupportedValues = create_fps_str(mSupportedFpsRanges, mSupportedFpsRangesCount);
-
-            ALOGD("supported fps ranges = %s", mFpsRangesSupportedValues.string());
-            mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
-                mFpsRangesSupportedValues);
-            mParameters.setPreviewFpsRange(minFps, maxFps);
-        }
-
-        mFlashValues = create_values_str(
-            flash, sizeof(flash) / sizeof(str_map));
-        mLensShadeValues = create_values_str(
-            lensshade,sizeof(lensshade)/sizeof(str_map));
-        mMceValues = create_values_str(
-            mce,sizeof(mce)/sizeof(str_map));
-        mEffectValues = create_values_str(effects, sizeof(effects) / sizeof(str_map));
-        mAntibandingValues = create_values_str(
-            antibanding, sizeof(antibanding) / sizeof(str_map));
-        mIsoValues = create_values_str(iso,sizeof(iso)/sizeof(str_map));
-        mAutoExposureValues = create_values_str(
-            autoexposure, sizeof(autoexposure) / sizeof(str_map));
-        mWhitebalanceValues = create_values_str(
-            whitebalance, sizeof(whitebalance) / sizeof(str_map));
-
-        if(mHasAutoFocusSupport){
-            mFocusModeValues = create_values_str(
-                    focus_modes, sizeof(focus_modes) / sizeof(str_map));
-        }
-
-        mSceneModeValues = create_values_str(scenemode, sizeof(scenemode) / sizeof(str_map));
-
-        if(mHasAutoFocusSupport){
-            mTouchAfAecValues = create_values_str(
-                touchafaec,sizeof(touchafaec)/sizeof(str_map));
-        }
-        //Currently Enabling Histogram for 8x60
-        mHistogramValues = create_values_str(
-            histogram,sizeof(histogram)/sizeof(str_map));
-
-        mSkinToneEnhancementValues = create_values_str(
-            skinToneEnhancement,sizeof(skinToneEnhancement)/sizeof(str_map));
-
-        mPictureFormatValues = create_values_str(
-            picture_formats, sizeof(picture_formats)/sizeof(str_map));
-
-        mZoomSupported=false;
-        mMaxZoom=0;
-        mm_camera_zoom_tbl_t zmt;
-        if( mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                             MM_CAMERA_PARM_MAXZOOM, &mMaxZoom)<0){
-            ALOGE("%s:Failed to get max zoom",__func__);
-        }else{
-
-            ALOGE("Max Zoom:%d",mMaxZoom);
-            /* Kernel driver limits the max amount of data that can be retreived through a control
-            command to 260 bytes hence we conservatively limit to 110 zoom ratios */
-            if(mMaxZoom>MAX_ZOOM_RATIOS) {
-                ALOGE("%s:max zoom is larger than sizeof zoomRatios table",__func__);
-                mMaxZoom=MAX_ZOOM_RATIOS-1;
-            }
-            zmt.size=mMaxZoom;
-            zmt.zoom_ratio_tbl=&zoomRatios[0];
-            if( mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                                 MM_CAMERA_PARM_ZOOM_RATIO, &zmt)<0){
-                ALOGE("%s:Failed to get max zoom ratios",__func__);
-            }else{
-                mZoomSupported=true;
-                mZoomRatioValues =  create_str(zoomRatios, mMaxZoom);
-            }
-        }
-
-        ALOGE("Zoom supported:%d",mZoomSupported);
-
-        denoise_value = create_values_str(
-            denoise, sizeof(denoise) / sizeof(str_map));
-
-       if(supportsFaceDetection()) {
-            mFaceDetectionValues = create_values_str(
-                facedetection, sizeof(facedetection) / sizeof(str_map));
-        }
-
-        if(mHasAutoFocusSupport){
-            mSelectableZoneAfValues = create_values_str(
-                selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map));
-        }
-
-        mSceneDetectValues = create_values_str(scenedetect, sizeof(scenedetect) / sizeof(str_map));
-
-        mRedeyeReductionValues = create_values_str(
-            redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map));
-
-        mZslValues = create_values_str(
-            zsl_modes,sizeof(zsl_modes)/sizeof(str_map));
-
-        mParamStringInitialized = true;
-    }
-
-    //set supported video sizes
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_VIDEO_SIZES, mVideoSizeValues.string());
-
-    //set default video size to first one in supported table
-    String8 vSize = create_sizes_str(&mVideoSizes[0], 1);
-    mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, vSize.string());
-
-    //Set Preview size
-    int default_preview_width, default_preview_height;
-    mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH,
-            &default_preview_width);
-    mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT,
-            &default_preview_height);
-    mParameters.setPreviewSize(default_preview_width, default_preview_height);
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
-                    mPreviewSizeValues.string());
-    mDimension.display_width = default_preview_width;
-    mDimension.display_height = default_preview_height;
-
-    mPreviewFrameRateValues = create_values_range_str(
-        MINIMUM_FPS, MAXIMUM_FPS);
-
-
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle, MM_CAMERA_PARM_FPS,&supported,&supported);
-    if (supported) {
-        mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
-                        mPreviewFrameRateValues.string());
-     } else {
-        mParameters.set(
-            QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
-            DEFAULT_FIXED_FPS);
-    }
-    //Set Preview Format
-    //mParameters.setPreviewFormat("yuv420sp"); // informative
-    mParameters.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP);
-
-    mPreviewFormatValues = create_values_str(
-        preview_formats, sizeof(preview_formats) / sizeof(str_map));
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
-            mPreviewFormatValues.string());
-
-    //Set Overlay Format
-    mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP);
-    mParameters.set("max-num-detected-faces-hw", "2");
-
-    // Set supported max faces
-    int maxNumFaces = 0;
-    if (supportsFaceDetection()) {
-        //Query the maximum number of faces supported by hardware.
-        if(MM_CAMERA_OK != mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                               MM_CAMERA_PARM_MAX_NUM_FACES_DECT, &maxNumFaces)){
-            ALOGE("%s:Failed to get max number of faces supported",__func__);
-        }
-    }
-    mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, maxNumFaces);
-    //This paramtere is set to default here. This will be changed by application
-    //if it needs to support specific number of faces. See also setParameters.
-    mParameters.set(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES, 2);
-
-    // Set camera features supported flag
-    int32_t featureFlag = 0;
-    if (supportsFaceDetection()) {
-        featureFlag |= 0x00000001; // bit 0 indicate faciral feature
-    }
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES, featureFlag);
-
-    //Set Picture Size
-    mParameters.setPictureSize(DEFAULT_PICTURE_WIDTH, DEFAULT_PICTURE_HEIGHT);
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
-                    mPictureSizeValues.string());
-
-    //Set Preview Frame Rate
-    if(mFps >= MINIMUM_FPS && mFps <= MAXIMUM_FPS) {
-        mParameters.setPreviewFrameRate(mFps);
-    }else{
-        mParameters.setPreviewFrameRate(DEFAULT_FIXED_FPS);
-    }
-
-    //Set Picture Format
-    mParameters.setPictureFormat("jpeg"); // informative
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
-                    mPictureFormatValues);
-
-    mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, "85"); // max quality
-    mJpegQuality = 85;
-    //Set Video Format
-    mParameters.set(QCameraParameters::KEY_VIDEO_FRAME_FORMAT, "yuv420sp");
-
-    //Set Thumbnail parameters
-    mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
-                    THUMBNAIL_WIDTH_STR); // informative
-    mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
-                    THUMBNAIL_HEIGHT_STR); // informative
-    mDimension.ui_thumbnail_width =
-            thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].width;
-    mDimension.ui_thumbnail_height =
-            thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].height;
-    mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "90");
-    String8 valuesStr = create_sizes_str(default_thumbnail_sizes, thumbnail_sizes_count);
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
-                valuesStr.string());
-    // Define CAMERA_SMOOTH_ZOOM in Android.mk file , to enable smoothzoom
-#ifdef CAMERA_SMOOTH_ZOOM
-    mParameters.set(QCameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, "true");
-#endif
-    if(mZoomSupported){
-        mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "true");
-        ALOGE("max zoom is %d", mMaxZoom-1);
-        /* mMaxZoom value that the query interface returns is the size
-        ALOGV("max zoom is %d", mMaxZoom-1);
-        * mMaxZoom value that the query interface returns is the size
-         * of zoom table. So the actual max zoom value will be one
-         * less than that value.          */
-
-        mParameters.set("max-zoom",mMaxZoom-1);
-        mParameters.set(QCameraParameters::KEY_ZOOM_RATIOS,
-                            mZoomRatioValues);
-    } else
-        {
-        mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "false");
-    }
-
-    /* Enable zoom support for video application if VPE enabled */
-    if(mZoomSupported) {
-        mParameters.set("video-zoom-support", "true");
-    } else {
-        mParameters.set("video-zoom-support", "false");
-    }
-
-    //8960 supports Power modes : Low power, Normal Power.
-    mParameters.set("power-mode-supported", "true");
-    //Set Live shot support
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_LIVESHOT_MAIN,
-                                          &supported,&supported);
-    if(!supported) {
-        ALOGE("%s:LIVESHOT is  not supported", __func__);
-        mParameters.set("video-snapshot-supported", "false");
-        mFullLiveshotEnabled = rc;
-    } else {
-        mParameters.set("video-snapshot-supported", "true");
-    }
-
-    //Set default power mode
-    mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Normal_Power");
-
-    //Set Camera Mode
-    mParameters.set(QCameraParameters::KEY_QC_CAMERA_MODE,0);
-    mParameters.set(QCameraParameters::KEY_QC_AE_BRACKET_HDR,"Off");
-
-    //Set Antibanding
-    mParameters.set(QCameraParameters::KEY_ANTIBANDING,
-                    QCameraParameters::ANTIBANDING_OFF);
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_ANTIBANDING,
-                    mAntibandingValues);
-
-    //Set Effect
-    mParameters.set(QCameraParameters::KEY_EFFECT,
-                    QCameraParameters::EFFECT_NONE);
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_EFFECTS, mEffectValues);
-
-    //Set Auto Exposure
-    mParameters.set(QCameraParameters::KEY_QC_AUTO_EXPOSURE,
-                    QCameraParameters::AUTO_EXPOSURE_FRAME_AVG);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE, mAutoExposureValues);
-
-    //Set WhiteBalance
-    mParameters.set(QCameraParameters::KEY_WHITE_BALANCE,
-                    QCameraParameters::WHITE_BALANCE_AUTO);
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_WHITE_BALANCE,mWhitebalanceValues);
-
-    //Set AEC_LOCK
-    mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, "false");
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_AEC_LOCK,&supported,&supported);
-    if(supported){
-        mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true");
-    } else {
-        mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "false");
-    }
-    //Set AWB_LOCK
-    mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, "false");
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_AWB_LOCK,&supported,&supported);
-    if(supported)
-        mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true");
-    else
-        mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "false");
-
-    //Set Focus Mode
-    if(mHasAutoFocusSupport){
-       mParameters.set(QCameraParameters::KEY_FOCUS_MODE,
-                          QCameraParameters::FOCUS_MODE_AUTO);
-       mFocusMode = AF_MODE_AUTO;
-       mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES,
-                          mFocusModeValues);
-       mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "1");
-       mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "1");
-   } else {
-       mParameters.set(QCameraParameters::KEY_FOCUS_MODE,
-       QCameraParameters::FOCUS_MODE_INFINITY);
-       mFocusMode = DONT_CARE;
-       mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES,
-       QCameraParameters::FOCUS_MODE_INFINITY);
-       mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "0");
-       mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "0");
-   }
-
-    mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, DEFAULT_CAMERA_AREA);
-    mParameters.set(QCameraParameters::KEY_METERING_AREAS, DEFAULT_CAMERA_AREA);
-
-    //Set Flash
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_LED_MODE,&supported,&supported);
-    if(supported){
-        mParameters.set(CameraParameters::KEY_FLASH_MODE,
-                        CameraParameters::FLASH_MODE_OFF);
-        mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
-                        mFlashValues);
-    }
-
-    //Set Sharpness
-    mParameters.set(QCameraParameters::KEY_QC_MAX_SHARPNESS,
-            CAMERA_MAX_SHARPNESS);
-    mParameters.set(QCameraParameters::KEY_QC_SHARPNESS,
-                    CAMERA_DEF_SHARPNESS);
-
-    //Set Contrast
-    mParameters.set(QCameraParameters::KEY_QC_MAX_CONTRAST,
-            CAMERA_MAX_CONTRAST);
-    mParameters.set(QCameraParameters::KEY_QC_CONTRAST,
-                    CAMERA_DEF_CONTRAST);
-
-    //Set Saturation
-    mParameters.set(QCameraParameters::KEY_QC_MAX_SATURATION,
-            CAMERA_MAX_SATURATION);
-    mParameters.set(QCameraParameters::KEY_QC_SATURATION,
-                    CAMERA_DEF_SATURATION);
-
-    //Set Brightness/luma-adaptaion
-    mParameters.set("luma-adaptation", "3");
-
-    mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT,
-                    QCameraParameters::PIXEL_FORMAT_JPEG);
-
-    //Set Lensshading
-    mParameters.set(QCameraParameters::KEY_QC_LENSSHADE,
-                    QCameraParameters::LENSSHADE_ENABLE);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES,
-                    mLensShadeValues);
-
-    //Set ISO Mode
-    mParameters.set(QCameraParameters::KEY_QC_ISO_MODE,
-                    QCameraParameters::ISO_AUTO);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES,
-                    mIsoValues);
-
-    //Set MCE
-    mParameters.set(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT,
-                    QCameraParameters::MCE_ENABLE);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES,
-                    mMceValues);
-
-    //Set HFR
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_HFR,&supported,&supported);
-    if(supported){
-        mParameters.set(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE,
-                    QCameraParameters::VIDEO_HFR_OFF);
-        mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES,
-                    mHfrSizeValues.string());
-        mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES,
-                    mHfrValues);
-    } else{
-        mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES,"");
-    }
-
-    //Set Histogram
-    mParameters.set(QCameraParameters::KEY_QC_HISTOGRAM,
-                    QCameraParameters::HISTOGRAM_DISABLE);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES,
-                    mHistogramValues);
-
-    //Set SkinTone Enhancement
-    mParameters.set(QCameraParameters::KEY_QC_SKIN_TONE_ENHANCEMENT,
-                    QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE);
-    mParameters.set("skinToneEnhancement", "0");
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES,
-                    mSkinToneEnhancementValues);
-
-    //Set Scene Mode
-    mParameters.set(QCameraParameters::KEY_SCENE_MODE,
-                    QCameraParameters::SCENE_MODE_AUTO);
-    mParameters.set(QCameraParameters::KEY_SUPPORTED_SCENE_MODES,
-                    mSceneModeValues);
-
-    //Set Streaming Textures
-    mParameters.set("strtextures", "OFF");
-
-    //Set Denoise
-    mParameters.set(QCameraParameters::KEY_QC_DENOISE,
-                    QCameraParameters::DENOISE_OFF);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_DENOISE,
-                        denoise_value);
-    //Set Touch AF/AEC
-    mParameters.set(QCameraParameters::KEY_QC_TOUCH_AF_AEC,
-                    QCameraParameters::TOUCH_AF_AEC_OFF);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC,
-                    mTouchAfAecValues);
-    mParameters.set("touchAfAec-dx","100");
-    mParameters.set("touchAfAec-dy","100");
-
-    //Set Scene Detection
-    mParameters.set(QCameraParameters::KEY_QC_SCENE_DETECT,
-                   QCameraParameters::SCENE_DETECT_OFF);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT,
-                    mSceneDetectValues);
-
-    //Set Selectable Zone AF
-    mParameters.set(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF,
-                    QCameraParameters::SELECTABLE_ZONE_AF_AUTO);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SELECTABLE_ZONE_AF,
-                    mSelectableZoneAfValues);
-
-    //Set Face Detection
-    mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION,
-                    QCameraParameters::FACE_DETECTION_OFF);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION,
-                    mFaceDetectionValues);
-
-    //Set Red Eye Reduction
-    mParameters.set(QCameraParameters::KEY_QC_REDEYE_REDUCTION,
-                    QCameraParameters::REDEYE_REDUCTION_DISABLE);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION,
-                    mRedeyeReductionValues);
-
-    //Set ZSL
-    mParameters.set(QCameraParameters::KEY_QC_ZSL,
-                    QCameraParameters::ZSL_OFF);
-    mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES,
-                    mZslValues);
-
-    //Set Focal length, horizontal and vertical view angles
-    float focalLength = 0.0f;
-    float horizontalViewAngle = 0.0f;
-    float verticalViewAngle = 0.0f;
-    mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_FOCAL_LENGTH,
-            (void *)&focalLength);
-    mParameters.setFloat(QCameraParameters::KEY_FOCAL_LENGTH,
-                    focalLength);
-    mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE,
-            (void *)&horizontalViewAngle);
-    mParameters.setFloat(QCameraParameters::KEY_HORIZONTAL_VIEW_ANGLE,
-                    horizontalViewAngle);
-    mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE,
-            (void *)&verticalViewAngle);
-    mParameters.setFloat(QCameraParameters::KEY_VERTICAL_VIEW_ANGLE,
-                    verticalViewAngle);
-
-    //Set Exposure Compensation
-    mParameters.set(
-            QCameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
-            EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR);
-    mParameters.set(
-            QCameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
-            EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR);
-    mParameters.set(
-            QCameraParameters::KEY_EXPOSURE_COMPENSATION,
-            EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR);
-    mParameters.setFloat(
-            QCameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
-            EXPOSURE_COMPENSATION_STEP);
-
-    mParameters.set("num-snaps-per-shutter", 1);
-
-    mParameters.set("capture-burst-captures-values", getZSLQueueDepth());
-    mParameters.set("capture-burst-interval-supported", "true");
-    mParameters.set("capture-burst-interval-max", BURST_INTREVAL_MAX); /*skip frames*/
-    mParameters.set("capture-burst-interval-min", BURST_INTREVAL_MIN); /*skip frames*/
-    mParameters.set("capture-burst-interval", BURST_INTREVAL_DEFAULT); /*skip frames*/
-    mParameters.set("capture-burst-retroactive", 0);
-    mParameters.set("capture-burst-retroactive-max", getZSLQueueDepth());
-    mParameters.set("capture-burst-exposures", "");
-    mParameters.set("capture-burst-exposures-values",
-      "-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12");
-    {
-      String8 CamModeStr;
-      char buffer[32];
-      int flag = 0;
-
-      for (int i = 0; i < HAL_CAM_MODE_MAX; i++) {
-        if ( 0 ) { /*exclude some conflicting case*/
-        } else {
-          if (flag == 0) { /*first item*/
-          snprintf(buffer, sizeof(buffer), "%d", i);
-          } else {
-            snprintf(buffer, sizeof(buffer), ",%d", i);
-          }
-          flag = 1;
-          CamModeStr.append(buffer);
-        }
-      }
-      mParameters.set("camera-mode-values", CamModeStr);
-    }
-
-    mParameters.set("ae-bracket-hdr-values",
-      create_values_str(hdr_bracket, sizeof(hdr_bracket)/sizeof(str_map) ));
-
-    mParameters.set("no-display-mode", 0);
-    mParameters.set("zoom", 0);
-
-    int mNuberOfVFEOutputs;
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                                       MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, &mNuberOfVFEOutputs);
-    if(ret < 0) {
-        ALOGE("get parm MM_CAMERA_PARM_VFE_OUTPUT_ENABLE  failed");
-        ret = BAD_VALUE;
-    }
-    if(mNuberOfVFEOutputs == 1)
-    {
-       mParameters.set(QCameraParameters::KEY_QC_SINGLE_ISP_OUTPUT_ENABLED, "true");
-    } else {
-       mParameters.set(QCameraParameters::KEY_QC_SINGLE_ISP_OUTPUT_ENABLED, "false");
-    }
-
-    if (setParameters(mParameters) != NO_ERROR) {
-        ALOGE("Failed to set default parameters?!");
-    }
-    mInitialized = true;
-    strTexturesOn = false;
-
-    ALOGI("%s: X", __func__);
-    return;
-}
-
-/**
- * Set the camera parameters. This returns BAD_VALUE if any parameter is
- * invalid or not supported.
- */
-
-int QCameraHardwareInterface::setParameters(const char *parms)
-{
-    QCameraParameters param;
-    String8 str = String8(parms);
-    param.unflatten(str);
-    status_t ret = setParameters(param);
-	if(ret == NO_ERROR)
-		return 0;
-	else
-		return -1;
-}
-
-/**
- * Set the camera parameters. This returns BAD_VALUE if any parameter is
- * invalid or not supported. */
-status_t QCameraHardwareInterface::setParameters(const QCameraParameters& params)
-{
-    status_t ret = NO_ERROR;
-
-    ALOGI("%s: E", __func__);
-//    Mutex::Autolock l(&mLock);
-    status_t rc, final_rc = NO_ERROR;
-    mRestartPreview = false;
-
-    if ((rc = setCameraMode(params)))                   final_rc = rc;
-//    if ((rc = setChannelInterfaceMask(params)))         final_rc = rc;
-    if ((rc = setPowerMode(params)))                    final_rc = rc;
-    if ((rc = setPreviewSize(params)))                  final_rc = rc;
-    if ((rc = setVideoSize(params)))                    final_rc = rc;
-    if ((rc = setPictureSize(params)))                  final_rc = rc;
-    if ((rc = setJpegThumbnailSize(params)))            final_rc = rc;
-    if ((rc = setJpegQuality(params)))                  final_rc = rc;
-    if ((rc = setEffect(params)))                       final_rc = rc;
-    if ((rc = setGpsLocation(params)))                  final_rc = rc;
-    if ((rc = setRotation(params)))                     final_rc = rc;
-    if ((rc = setZoom(params)))                         final_rc = rc;
-    if ((rc = setOrientation(params)))                  final_rc = rc;
-    if ((rc = setLensshadeValue(params)))               final_rc = rc;
-    if ((rc = setMCEValue(params)))                     final_rc = rc;
-    if ((rc = setPictureFormat(params)))                final_rc = rc;
-    if ((rc = setSharpness(params)))                    final_rc = rc;
-    if ((rc = setSaturation(params)))                   final_rc = rc;
-    if ((rc = setSceneMode(params)))                    final_rc = rc;
-    if ((rc = setContrast(params)))                     final_rc = rc;
-    if ((rc = setFaceDetect(params)))                   final_rc = rc;
-    if ((rc = setStrTextures(params)))                  final_rc = rc;
-    if ((rc = setPreviewFormat(params)))                final_rc = rc;
-    if ((rc = setSkinToneEnhancement(params)))          final_rc = rc;
-    if ((rc = setWaveletDenoise(params)))               final_rc = rc;
-    if ((rc = setAntibanding(params)))                  final_rc = rc;
-    //    if ((rc = setOverlayFormats(params)))         final_rc = rc;
-    if ((rc = setRedeyeReduction(params)))              final_rc = rc;
-    if ((rc = setCaptureBurstExp()))                    final_rc = rc;
-    if ((rc = setRDIMode(params)))                      final_rc = rc;
-
-    const char *str_val = params.get("capture-burst-exposures");
-    if ( str_val == NULL || strlen(str_val)==0 ) {
-        char burst_exp[PROPERTY_VALUE_MAX];
-        memset(burst_exp, 0, sizeof(burst_exp));
-        property_get("persist.capture.burst.exposures", burst_exp, "");
-        if ( strlen(burst_exp)>0 ) {
-            mParameters.set("capture-burst-exposures", burst_exp);
-        }
-    } else {
-      mParameters.set("capture-burst-exposures", str_val);
-    }
-    mParameters.set("num-snaps-per-shutter", params.get("num-snaps-per-shutter"));
-
-    if ((rc = setAEBracket(params)))              final_rc = rc;
-    //    if ((rc = setDenoise(params)))                final_rc = rc;
-    if ((rc = setPreviewFpsRange(params)))              final_rc = rc;
-    if((rc = setRecordingHint(params)))                 final_rc = rc;
-    if ((rc = setNumOfSnapshot(params)))                final_rc = rc;
-    if ((rc = setAecAwbLock(params)))                   final_rc = rc;
-
-    const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
-    int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
-
-    if((value != NOT_FOUND) && (value == CAMERA_BESTSHOT_OFF )) {
-        //if ((rc = setPreviewFrameRateMode(params)))     final_rc = rc;
-        if ((rc = setPreviewFrameRate(params)))         final_rc = rc;
-        if ((rc = setAutoExposure(params)))             final_rc = rc;
-        if ((rc = setExposureCompensation(params)))     final_rc = rc;
-        if ((rc = setWhiteBalance(params)))             final_rc = rc;
-        if ((rc = setFlash(params)))                    final_rc = rc;
-        if ((rc = setFocusMode(params)))                final_rc = rc;
-        if ((rc = setBrightness(params)))               final_rc = rc;
-        if ((rc = setISOValue(params)))                 final_rc = rc;
-        if ((rc = setFocusAreas(params)))               final_rc = rc;
-        if ((rc = setMeteringAreas(params)))            final_rc = rc;
-    }
-    //selectableZoneAF needs to be invoked after continuous AF
-    if ((rc = setSelectableZoneAf(params)))             final_rc = rc;
-    // setHighFrameRate needs to be done at end, as there can
-    // be a preview restart, and need to use the updated parameters
-    if ((rc = setHighFrameRate(params)))  final_rc = rc;
-    if ((rc = setZSLBurstLookBack(params))) final_rc = rc;
-    if ((rc = setZSLBurstInterval(params))) final_rc = rc;
-    if ((rc = setNoDisplayMode(params))) final_rc = rc;
-    if ((rc = setMobiCat(params)))       final_rc = rc;
-
-    //Update Exiftag values.
-    setExifTags();
-
-    if (mRestartPreview) {
-        ALOGI("%s: need to restart preview", __func__);
-        restartPreview();
-        mRestartPreview = false;
-    }
-
-    ALOGI("%s: X", __func__);
-    return final_rc;
-}
-
-/** Retrieve the camera parameters.  The buffer returned by the camera HAL
-	must be returned back to it with put_parameters, if put_parameters
-	is not NULL.
- */
-int QCameraHardwareInterface::getParameters(char **parms)
-{
-    char* rc = NULL;
-    String8 str;
-    QCameraParameters param = getParameters();
-    //param.dump();
-    str = param.flatten( );
-    rc = (char *)malloc(sizeof(char)*(str.length()+1));
-    if(rc != NULL){
-        memset(rc, 0, sizeof(char)*(str.length()+1));
-        strncpy(rc, str.string(), str.length());
-	rc[str.length()] = 0;
-	*parms = rc;
-    }
-    return 0;
-}
-
-/** The camera HAL uses its own memory to pass us the parameters when we
-	call get_parameters.  Use this function to return the memory back to
-	the camera HAL, if put_parameters is not NULL.  If put_parameters
-	is NULL, then you have to use free() to release the memory.
-*/
-void QCameraHardwareInterface::putParameters(char *rc)
-{
-    free(rc);
-    rc = NULL;
-}
-
-QCameraParameters& QCameraHardwareInterface::getParameters()
-{
-    Mutex::Autolock lock(mLock);
-    mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string());
-    return mParameters;
-}
-
-status_t QCameraHardwareInterface::runFaceDetection()
-{
-    bool ret = true;
-
-    const char *str = mParameters.get(QCameraParameters::KEY_QC_FACE_DETECTION);
-    if (str != NULL) {
-        int value = attr_lookup(facedetection,
-                sizeof(facedetection) / sizeof(str_map), str);
-        fd_set_parm_t fd_set_parm;
-        int requested_faces = mParameters.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
-        fd_set_parm.fd_mode = value;
-        fd_set_parm.num_fd = requested_faces;
-        ret = native_set_parms(MM_CAMERA_PARM_FD, sizeof(int8_t), (void *)&value);
-        return ret ? NO_ERROR : UNKNOWN_ERROR;
-    }
-    ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSharpness(const QCameraParameters& params)
-{
-    bool ret = false;
-    int rc = MM_CAMERA_OK;
-    ALOGV("%s",__func__);
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_SHARPNESS,(uint8_t*)&rc,(uint8_t*)&rc);
-    if(!rc) {
-        ALOGE("%s:CONTRAST not supported", __func__);
-        return NO_ERROR;
-    }
-    int sharpness = params.getInt(QCameraParameters::KEY_QC_SHARPNESS);
-    if((sharpness < CAMERA_MIN_SHARPNESS
-            || sharpness > CAMERA_MAX_SHARPNESS))
-        return UNKNOWN_ERROR;
-
-    ALOGV("setting sharpness %d", sharpness);
-    mParameters.set(QCameraParameters::KEY_QC_SHARPNESS, sharpness);
-    ret = native_set_parms(MM_CAMERA_PARM_SHARPNESS, sizeof(sharpness),
-                               (void *)&sharpness);
-    return ret ? NO_ERROR : UNKNOWN_ERROR;
-}
-
-status_t QCameraHardwareInterface::setSaturation(const QCameraParameters& params)
-{
-    bool ret = false;
-    int rc = MM_CAMERA_OK;
-    ALOGV("%s",__func__);
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_SATURATION,(uint8_t*)&rc,(uint8_t*)&rc);
-    if(!rc) {
-        ALOGE("%s:MM_CAMERA_PARM_SATURATION not supported", __func__);
-        return NO_ERROR;
-    }
-    int result;
-    int saturation = params.getInt(QCameraParameters::KEY_QC_SATURATION);
-
-    if((saturation < CAMERA_MIN_SATURATION)
-        || (saturation > CAMERA_MAX_SATURATION))
-    return UNKNOWN_ERROR;
-
-    ALOGV("Setting saturation %d", saturation);
-    mParameters.set(QCameraParameters::KEY_QC_SATURATION, saturation);
-    ret = native_set_parms(MM_CAMERA_PARM_SATURATION, sizeof(saturation),
-        (void *)&saturation, (int *)&result);
-    if(result != MM_CAMERA_OK)
-        ALOGI("Saturation Value: %d is not set as the selected value is not supported", saturation);
-    return ret ? NO_ERROR : UNKNOWN_ERROR;
-}
-
-status_t QCameraHardwareInterface::setContrast(const QCameraParameters& params)
-{
-   ALOGV("%s E", __func__ );
-   int rc = MM_CAMERA_OK;
-   mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                         MM_CAMERA_PARM_CONTRAST,(uint8_t*)&rc,(uint8_t*)&rc);
-   if(!rc) {
-        ALOGE("%s:CONTRAST not supported", __func__);
-        return NO_ERROR;
-    }
-   const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
-   ALOGE("Contrast : %s",str);
-   int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
-   if(value == CAMERA_BESTSHOT_OFF) {
-        int contrast = params.getInt(QCameraParameters::KEY_QC_CONTRAST);
-        if((contrast < CAMERA_MIN_CONTRAST)
-                || (contrast > CAMERA_MAX_CONTRAST))
-        {
-            ALOGE("Contrast Value not matching");
-            return UNKNOWN_ERROR;
-        }
-        ALOGV("setting contrast %d", contrast);
-        mParameters.set(QCameraParameters::KEY_QC_CONTRAST, contrast);
-        ALOGE("Calling Contrast set on Lower layer");
-        bool ret = native_set_parms(MM_CAMERA_PARM_CONTRAST, sizeof(contrast),
-                                   (void *)&contrast);
-        ALOGE("Lower layer returned %d", ret);
-        int bestshot_reconfigure;
-        mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                                     MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
-                            &bestshot_reconfigure);
-        if(bestshot_reconfigure) {
-             if (mContrast != contrast) {
-                  mContrast = contrast;
-                 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
-                      mRestartPreview = true;
-                  }
-             }
-        }
-        return ret ? NO_ERROR : UNKNOWN_ERROR;
-    } else {
-          ALOGI(" Contrast value will not be set " \
-          "when the scenemode selected is %s", str);
-          return NO_ERROR;
-    }
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSceneDetect(const QCameraParameters& params)
-{
-    ALOGV("%s",__func__);
-    bool retParm;
-    int rc = 0;
-
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_ASD_ENABLE,(uint8_t*)&rc,(uint8_t*)&rc);
-    if(!rc) {
-        ALOGE("%s:MM_CAMERA_PARM_ASD_ENABLE not supported", __func__);
-        return NO_ERROR;
-    }
-
-    const char *str = params.get(QCameraParameters::KEY_QC_SCENE_DETECT);
-    ALOGE("Scene Detect string : %s",str);
-    if (str != NULL) {
-        int32_t value = attr_lookup(scenedetect, sizeof(scenedetect) / sizeof(str_map), str);
-        ALOGE("Scenedetect Value : %d",value);
-        if (value != NOT_FOUND) {
-            mParameters.set(QCameraParameters::KEY_QC_SCENE_DETECT, str);
-
-            retParm = native_set_parms(MM_CAMERA_PARM_ASD_ENABLE, sizeof(value),
-                                       (void *)&value);
-
-            return retParm ? NO_ERROR : UNKNOWN_ERROR;
-        }
-    }
-   return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setZoom(const QCameraParameters& params)
-{
-    status_t rc = NO_ERROR;
-
-    ALOGV("%s: E",__func__);
-    uint8_t supported;
-
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_ZOOM,&supported,&supported);
-    if(!supported){
-        ALOGE("%s:MM_CAMERA_PARM_ZOOM not supported", __func__);
-        return NO_ERROR;
-    }
-    // No matter how many different zoom values the driver can provide, HAL
-    // provides applictations the same number of zoom levels. The maximum driver
-    // zoom value depends on sensor output (VFE input) and preview size (VFE
-    // output) because VFE can only crop and cannot upscale. If the preview size
-    // is bigger, the maximum zoom ratio is smaller. However, we want the
-    // zoom ratio of each zoom level is always the same whatever the preview
-    // size is. Ex: zoom level 1 is always 1.2x, zoom level 2 is 1.44x, etc. So,
-    // we need to have a fixed maximum zoom value and do read it from the
-    // driver.
-    static const int ZOOM_STEP = 1;
-    int32_t zoom_level = params.getInt("zoom");
-    if(zoom_level >= 0 && zoom_level <= mMaxZoom-1) {
-        mParameters.set("zoom", zoom_level);
-        int32_t zoom_value = ZOOM_STEP * zoom_level;
-        bool ret = native_set_parms(MM_CAMERA_PARM_ZOOM,
-            sizeof(zoom_value), (void *)&zoom_value);
-        if(ret) {
-            mCurrentZoom=zoom_level;
-        }
-        rc = ret ? NO_ERROR : UNKNOWN_ERROR;
-    } else {
-        rc = BAD_VALUE;
-    }
-    ALOGV("%s X",__func__);
-    return rc;
-
-}
-
-status_t  QCameraHardwareInterface::setISOValue(const QCameraParameters& params) {
-
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_ISO,&supported,&supported);
-    if(!supported) {
-        ALOGE("%s:MM_CAMERA_PARM_ISO not supported", __func__);
-        return NO_ERROR;
-    }
-    const char *str = params.get(QCameraParameters::KEY_QC_ISO_MODE);
-    ALOGV("ISO string : %s",str);
-    int8_t temp_hjr;
-    if (str != NULL) {
-        int value = (camera_iso_mode_type)attr_lookup(
-          iso, sizeof(iso) / sizeof(str_map), str);
-        ALOGE("ISO Value : %d",value);
-        if (value != NOT_FOUND) {
-            camera_iso_mode_type temp = (camera_iso_mode_type) value;
-            if (value == CAMERA_ISO_DEBLUR) {
-               temp_hjr = true;
-               native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr);
-               mHJR = value;
-            }
-            else {
-               if (mHJR == CAMERA_ISO_DEBLUR) {
-                   temp_hjr = false;
-                   native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr);
-                   mHJR = value;
-               }
-            }
-
-            mParameters.set(QCameraParameters::KEY_QC_ISO_MODE, str);
-            native_set_parms(MM_CAMERA_PARM_ISO, sizeof(camera_iso_mode_type), (void *)&temp);
-            return NO_ERROR;
-        }
-    }
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::updateFocusDistances()
-{
-    ALOGV("%s: IN", __FUNCTION__);
-    focus_distances_info_t focusDistances;
-    if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_FOCUS_DISTANCES,
-      &focusDistances) >= 0) {
-        String8 str;
-        char buffer[32] = {0};
-        //set all distances to infinity if focus mode is infinity
-        if(mFocusMode == AF_MODE_INFINITY) {
-            snprintf(buffer, sizeof(buffer), "Infinity,");
-            str.append(buffer);
-            snprintf(buffer, sizeof(buffer), "Infinity,");
-            str.append(buffer);
-            snprintf(buffer, sizeof(buffer), "Infinity");
-            str.append(buffer);
-        } else {
-            snprintf(buffer, sizeof(buffer), "%f", focusDistances.focus_distance[0]);
-            str.append(buffer);
-            snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[1]);
-            str.append(buffer);
-            snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[2]);
-            str.append(buffer);
-        }
-        ALOGE("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string());
-        mFocusDistance = str;
-        return NO_ERROR;
-    }
-    ALOGV("%s: get CAMERA_PARM_FOCUS_DISTANCES failed!!!", __FUNCTION__);
-    return BAD_VALUE;
-}
-
-// Parse string like "(1, 2, 3, 4, ..., N)"
-// num is pointer to an allocated array of size N
-static int parseNDimVector(const char *str, int *num, int N, char delim = ',')
-{
-    char *start, *end;
-    if(num == NULL) {
-        ALOGE("Invalid output array (num == NULL)");
-        return -1;
-    }
-    //check if string starts and ends with parantheses
-    if(str[0] != '(' || str[strlen(str)-1] != ')') {
-        ALOGE("Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", str);
-        return -1;
-    }
-    start = (char*) str;
-    start++;
-    for(int i=0; i<N; i++) {
-        *(num+i) = (int) strtol(start, &end, 10);
-        if(*end != delim && i < N-1) {
-            ALOGE("Cannot find delimeter '%c' in string \"%s\". end = %c", delim, str, *end);
-            return -1;
-        }
-        start = end+1;
-    }
-    return 0;
-}
-
-// parse string like "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..."
-static int parseCameraAreaString(const char* str, int max_num_areas,
-                                 camera_area_t *pAreas, int *num_areas_found)
-{
-    char area_str[32];
-    const char *start, *end, *p;
-    start = str; end = NULL;
-    int values[5], index=0;
-    *num_areas_found = 0;
-
-    while(start != NULL) {
-       if(*start != '(') {
-            ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
-            return -1;
-       }
-       end = strchr(start, ')');
-       if(end == NULL) {
-            ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
-            return -1;
-       }
-       int i;
-       for (i=0,p=start; p<=end; p++, i++) {
-           area_str[i] = *p;
-       }
-       area_str[i] = '\0';
-       if(parseNDimVector(area_str, values, 5) < 0){
-            ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str);
-            return -1;
-       }
-       // no more areas than max_num_areas are accepted.
-       if(index >= max_num_areas) {
-            ALOGE("%s: error: too many areas specified %s", __func__, str);
-            return -1;
-       }
-       pAreas[index].x1 = values[0];
-       pAreas[index].y1 = values[1];
-       pAreas[index].x2 = values[2];
-       pAreas[index].y2 = values[3];
-       pAreas[index].weight = values[4];
-
-       index++;
-       start = strchr(end, '('); // serach for next '('
-    }
-    (*num_areas_found) = index;
-    return 0;
-}
-static bool validateCameraAreas(camera_area_t *areas, int num_areas)
-{
-    for(int i=0; i<num_areas; i++) {
-
-        // handle special case (0, 0, 0, 0, 0)
-        if((areas[i].x1 == 0) && (areas[i].y1 == 0)
-            && (areas[i].x2 == 0) && (areas[i].y2 == 0) && (areas[i].weight == 0)) {
-            continue;
-        }
-        if(areas[i].x1 < -1000) return false;               // left should be >= -1000
-        if(areas[i].y1 < -1000) return false;               // top  should be >= -1000
-        if(areas[i].x2 > 1000) return false;                // right  should be <= 1000
-        if(areas[i].y2 > 1000) return false;                // bottom should be <= 1000
-        if(areas[i].weight <= 0 || areas[i].weight > 1000)  // weight should be in [1, 1000]
-            return false;
-        if(areas[i].x1 >= areas[i].x2) {                    // left should be < right
-            return false;
-        }
-        if(areas[i].y1 >= areas[i].y2)                      // top should be < bottom
-            return false;
-    }
-    return true;
-}
-
-status_t QCameraHardwareInterface::setFocusAreas(const QCameraParameters& params)
-{
-    ALOGV("%s: E", __func__);
-    status_t rc;
-    int max_num_af_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS);
-    if(max_num_af_areas == 0) {
-        return NO_ERROR;
-    }
-    const char *str = params.get(QCameraParameters::KEY_FOCUS_AREAS);
-    if (str == NULL) {
-        ALOGE("%s: Parameter string is null", __func__);
-        rc = NO_ERROR;
-    } else {
-        camera_area_t *areas = new camera_area_t[max_num_af_areas];
-        int num_areas_found=0;
-        if(parseCameraAreaString(str, max_num_af_areas, areas, &num_areas_found) < 0) {
-            ALOGE("%s: Failed to parse the string: %s", __func__, str);
-            delete areas;
-            return BAD_VALUE;
-        }
-        for(int i=0; i<num_areas_found; i++) {
-            ALOGD("FocusArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1),
-                        (areas[i].x2), (areas[i].y2), (areas[i].weight));
-        }
-        if(validateCameraAreas(areas, num_areas_found) == false) {
-            ALOGE("%s: invalid areas specified : %s", __func__, str);
-            delete areas;
-            return BAD_VALUE;
-        }
-        mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, str);
-        num_areas_found = 1; //temp; need to change after the multi-roi is enabled
-
-        //if the native_set_parms is called when preview is not started, it
-        //crashes in lower layer, so return of preview is not started
-        if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) {
-            delete areas;
-            return NO_ERROR;
-        }
-
-        //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
-        //so no action is takenby the lower layer
-        if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0)
-            && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) {
-            num_areas_found = 0;
-        }
-        roi_info_t af_roi_value;
-        memset(&af_roi_value, 0, sizeof(roi_info_t));
-        uint16_t x1, x2, y1, y2, dx, dy;
-        int previewWidth, previewHeight;
-        this->getPreviewSize(&previewWidth, &previewHeight);
-        //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
-        x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f));
-        y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f));
-        x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f));
-        y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f));
-        dx = x2 - x1;
-        dy = y2 - y1;
-
-        af_roi_value.num_roi = num_areas_found;
-        af_roi_value.roi[0].x = x1;
-        af_roi_value.roi[0].y = y1;
-        af_roi_value.roi[0].dx = dx;
-        af_roi_value.roi[0].dy = dy;
-        af_roi_value.is_multiwindow = 0;
-        if (native_set_parms(MM_CAMERA_PARM_AF_ROI, sizeof(roi_info_t), (void*)&af_roi_value))
-            rc = NO_ERROR;
-        else
-            rc = BAD_VALUE;
-        delete areas;
-    }
-    ALOGE("%s: X", __func__);
-    return rc;
-}
-
-status_t QCameraHardwareInterface::setMeteringAreas(const QCameraParameters& params)
-{
-    ALOGV("%s: E", __func__);
-    status_t rc;
-    int max_num_mtr_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_METERING_AREAS);
-    if(max_num_mtr_areas == 0) {
-        return NO_ERROR;
-    }
-
-    const char *str = params.get(QCameraParameters::KEY_METERING_AREAS);
-    if (str == NULL) {
-        ALOGE("%s: Parameter string is null", __func__);
-        rc = NO_ERROR;
-    } else {
-        camera_area_t *areas = new camera_area_t[max_num_mtr_areas];
-        int num_areas_found=0;
-        if(parseCameraAreaString(str, max_num_mtr_areas, areas, &num_areas_found) < 0) {
-            ALOGE("%s: Failed to parse the string: %s", __func__, str);
-            delete areas;
-            return BAD_VALUE;
-        }
-        for(int i=0; i<num_areas_found; i++) {
-            ALOGD("MeteringArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1),
-                        (areas[i].x2), (areas[i].y2), (areas[i].weight));
-        }
-        if(validateCameraAreas(areas, num_areas_found) == false) {
-            ALOGE("%s: invalid areas specified : %s", __func__, str);
-            delete areas;
-            return BAD_VALUE;
-        }
-        mParameters.set(QCameraParameters::KEY_METERING_AREAS, str);
-
-        //if the native_set_parms is called when preview is not started, it
-        //crashes in lower layer, so return of preview is not started
-        if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) {
-            delete areas;
-            return NO_ERROR;
-        }
-
-        num_areas_found = 1; //temp; need to change after the multi-roi is enabled
-
-        //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
-        //so no action is takenby the lower layer
-        if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0)
-             && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) {
-            num_areas_found = 0;
-        }
-        cam_set_aec_roi_t aec_roi_value;
-        uint16_t x1, x2, y1, y2;
-        int previewWidth, previewHeight;
-        this->getPreviewSize(&previewWidth, &previewHeight);
-        //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
-        x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f));
-        y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f));
-        x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f));
-        y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f));
-        delete areas;
-
-        if(num_areas_found == 1) {
-            aec_roi_value.aec_roi_enable = AEC_ROI_ON;
-            aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE;
-            aec_roi_value.aec_roi_position.coordinate.x = (x1+x2)/2;
-            aec_roi_value.aec_roi_position.coordinate.y = (y1+y2)/2;
-        } else {
-            aec_roi_value.aec_roi_enable = AEC_ROI_OFF;
-            aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE;
-            aec_roi_value.aec_roi_position.coordinate.x = DONT_CARE_COORDINATE;
-            aec_roi_value.aec_roi_position.coordinate.y = DONT_CARE_COORDINATE;
-        }
-
-        if(native_set_parms(MM_CAMERA_PARM_AEC_ROI, sizeof(cam_set_aec_roi_t), (void *)&aec_roi_value))
-            rc = NO_ERROR;
-        else
-            rc = BAD_VALUE;
-    }
-    ALOGV("%s: X", __func__);
-    return rc;
-}
-
-status_t QCameraHardwareInterface::setFocusMode(const QCameraParameters& params)
-{
-    const char *str = params.get(QCameraParameters::KEY_FOCUS_MODE);
-    const char *prev_str = mParameters.get(QCameraParameters::KEY_FOCUS_MODE);
-    ALOGV("%s",__func__);
-    if (str != NULL) {
-        ALOGE("Focus mode %s",str);
-        int32_t value = attr_lookup(focus_modes,
-                                    sizeof(focus_modes) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            mParameters.set(QCameraParameters::KEY_FOCUS_MODE, str);
-            mFocusMode = value;
-
-            if(updateFocusDistances() != NO_ERROR) {
-               ALOGE("%s: updateFocusDistances failed for %s", __FUNCTION__, str);
-               return UNKNOWN_ERROR;
-            }
-            mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string());
-            if(mHasAutoFocusSupport){
-                bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_MODE,
-                                      sizeof(value),
-                                      (void *)&value);
-
-                int cafSupport = FALSE;
-                if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ||
-                   !strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)){
-                    cafSupport = TRUE;
-                }
-                ALOGE("Continuous Auto Focus %d", cafSupport);
-                ret = native_set_parms(MM_CAMERA_PARM_CONTINUOUS_AF, sizeof(cafSupport),
-                                       (void *)&cafSupport);
-            }
-
-            return NO_ERROR;
-        }
-        ALOGE("%s:Could not look up str value",__func__);
-    }
-    ALOGE("Invalid focus mode value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSceneMode(const QCameraParameters& params)
-{
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_BESTSHOT_MODE,&supported,&supported);
-    if(!supported) {
-        ALOGE("%s:Parameter Scenemode is not supported for this sensor", __func__);
-        return NO_ERROR;
-    }
-    const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
-    ALOGE("Scene Mode string : %s",str);
-
-    if (str != NULL) {
-        int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
-        ALOGE("Setting Scenemode value = %d",value );
-        if (value != NOT_FOUND) {
-            if((value != CAMERA_BESTSHOT_OFF ) && (mColorEffects != CAMERA_EFFECT_OFF )) {
-               int result;
-               mColorEffects = CAMERA_EFFECT_OFF;
-               native_set_parms(MM_CAMERA_PARM_EFFECT, sizeof(mColorEffects),
-                                (void *)&mColorEffects,(int *)&result);
-               if(result != MM_CAMERA_OK) {
-                  ALOGI("Camera Effect is not set as the EFFECT_NONE and result is not OK");
-               }
-            }
-            mParameters.set(QCameraParameters::KEY_SCENE_MODE, str);
-            bool ret = native_set_parms(MM_CAMERA_PARM_BESTSHOT_MODE, sizeof(value),
-                                       (void *)&value);
-            int bestshot_reconfigure;
-            mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                                         MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
-                                &bestshot_reconfigure);
-            if(bestshot_reconfigure) {
-                if (mBestShotMode != value) {
-                     mBestShotMode = value;
-                     if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
-                           mRestartPreview = true;
-                      }
-                 }
-            }
-            return ret ? NO_ERROR : UNKNOWN_ERROR;
-        }
-    }
-    ALOGE("Invalid scenemode value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSelectableZoneAf(const QCameraParameters& params)
-{
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    if(mHasAutoFocusSupport) {
-        const char *str = params.get(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF);
-        if (str != NULL) {
-            int32_t value = attr_lookup(selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map), str);
-            if (value != NOT_FOUND) {
-                 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                                       MM_CAMERA_PARM_FOCUS_RECT,&supported,&supported);
-                 if(!supported) {
-                    ALOGE("SelectableZoneAF  is not supported for this sensor");
-                    return NO_ERROR;
-                 }else {
-                    mParameters.set(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF, str);
-                    bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_RECT, sizeof(value),
-                            (void *)&value);
-                    return ret ? NO_ERROR : UNKNOWN_ERROR;
-                 }
-            }
-        }
-        ALOGE("Invalid selectable zone af value: %s", (str == NULL) ? "NULL" : str);
-        return BAD_VALUE;
-
-    }
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setEffect(const QCameraParameters& params)
-{
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    const char *str = params.get(CameraParameters::KEY_EFFECT);
-    int result;
-    mColorEffects = CAMERA_EFFECT_OFF;
-    if (str != NULL) {
-        ALOGE("Setting effect %s",str);
-        int32_t value = attr_lookup(effects, sizeof(effects) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                                  MM_CAMERA_PARM_EFFECT,&supported,&supported);
-           if(!supported) {
-               ALOGE("Camera Effect - %s mode is not supported for this sensor",str);
-               return NO_ERROR;
-           }else {
-               mParameters.set(QCameraParameters::KEY_EFFECT, str);
-               ALOGE("Setting effect to lower HAL : %d",value);
-               mColorEffects = value;
-               bool ret = native_set_parms(MM_CAMERA_PARM_EFFECT, sizeof(value),
-                                           (void *)&value,(int *)&result);
-                if(result != 0) {
-                    ALOGI("Camera Effect: %s is not set as the selected value is not supported ", str);
-                }
-                int bestshot_reconfigure;
-                mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                                             MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
-                                    &bestshot_reconfigure);
-                if(bestshot_reconfigure) {
-                     if (mEffects != value) {
-                         mEffects = value;
-                         if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
-                               mRestartPreview = true;
-                          }
-                   }
-               }
-               return ret ? NO_ERROR : UNKNOWN_ERROR;
-          }
-        }
-    }
-    ALOGE("Invalid effect value: %s", (str == NULL) ? "NULL" : str);
-    ALOGV("setEffect X");
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setBrightness(const QCameraParameters& params) {
-
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_BRIGHTNESS,&supported,&supported);
-   if(!supported) {
-       ALOGE("MM_CAMERA_PARM_BRIGHTNESS mode is not supported for this sensor");
-       return NO_ERROR;
-   }
-   int brightness = params.getInt("luma-adaptation");
-   if (mBrightness !=  brightness) {
-       ALOGV(" new brightness value : %d ", brightness);
-       mBrightness =  brightness;
-       mParameters.set("luma-adaptation", brightness);
-       bool ret = native_set_parms(MM_CAMERA_PARM_BRIGHTNESS, sizeof(mBrightness),
-                                   (void *)&mBrightness);
-        return ret ? NO_ERROR : UNKNOWN_ERROR;
-   }
-
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setAutoExposure(const QCameraParameters& params)
-{
-
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_EXPOSURE,&supported,&supported);
-   if(!supported) {
-       ALOGE("MM_CAMERA_PARM_EXPOSURE mode is not supported for this sensor");
-       return NO_ERROR;
-   }
-   const char *str = params.get(QCameraParameters::KEY_QC_AUTO_EXPOSURE);
-    if (str != NULL) {
-        int32_t value = attr_lookup(autoexposure, sizeof(autoexposure) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            mParameters.set(QCameraParameters::KEY_QC_AUTO_EXPOSURE, str);
-            bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE, sizeof(value),
-                                       (void *)&value);
-            return ret ? NO_ERROR : UNKNOWN_ERROR;
-        }
-    }
-    ALOGE("Invalid auto exposure value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setExposureCompensation(
-        const QCameraParameters & params){
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_EXPOSURE_COMPENSATION,&supported,&supported);
-    if(!supported) {
-       ALOGE("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor");
-       return NO_ERROR;
-    }
-    int numerator = params.getInt(QCameraParameters::KEY_EXPOSURE_COMPENSATION);
-    if(EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR <= numerator &&
-            numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){
-        int16_t  numerator16 = (int16_t)(numerator & 0x0000ffff);
-        uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR;
-        uint32_t  value = 0;
-        value = numerator16 << 16 | denominator16;
-
-        mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION,
-                            numerator);
-       bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE_COMPENSATION,
-                                    sizeof(value), (void *)&value);
-        return ret ? NO_ERROR : UNKNOWN_ERROR;
-    }
-    ALOGE("Invalid Exposure Compensation");
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setWhiteBalance(const QCameraParameters& params)
-{
-
-    ALOGV("%s",__func__);
-    status_t rc = NO_ERROR;
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_WHITE_BALANCE,&supported,&supported);
-    if(!supported) {
-       ALOGE("MM_CAMERA_PARM_WHITE_BALANCE mode is not supported for this sensor");
-       return NO_ERROR;
-    }
-     int result;
-
-    const char *str = params.get(QCameraParameters::KEY_WHITE_BALANCE);
-    if (str != NULL) {
-        int32_t value = attr_lookup(whitebalance, sizeof(whitebalance) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str);
-            bool ret = native_set_parms(MM_CAMERA_PARM_WHITE_BALANCE, sizeof(value),
-                                       (void *)&value, (int *)&result);
-            if(result != MM_CAMERA_OK) {
-                ALOGI("WhiteBalance Value: %s is not set as the selected value is not supported ", str);
-            }
-            return ret ? NO_ERROR : UNKNOWN_ERROR;
-        }
-    }
-    ALOGE("Invalid whitebalance value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-int QCameraHardwareInterface::getAutoFlickerMode()
-{
-    /* Enable Advanced Auto Antibanding where we can set
-       any of the following option
-       ie. CAMERA_ANTIBANDING_AUTO
-           CAMERA_ANTIBANDING_AUTO_50HZ
-           CAMERA_ANTIBANDING_AUTO_60HZ
-      Currently setting it to default    */
-    return CAMERA_ANTIBANDING_AUTO;
-}
-
-status_t QCameraHardwareInterface::setAntibanding(const QCameraParameters& params)
-{
-    int result;
-
-    ALOGV("%s",__func__);
-    status_t rc = NO_ERROR;
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_ANTIBANDING,&supported,&supported);
-    if(!supported) {
-       ALOGE("ANTIBANDING mode is not supported for this sensor");
-       return NO_ERROR;
-    }
-    const char *str = params.get(QCameraParameters::KEY_ANTIBANDING);
-    if (str != NULL) {
-        int value = (camera_antibanding_type)attr_lookup(
-          antibanding, sizeof(antibanding) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            camera_antibanding_type temp = (camera_antibanding_type) value;
-            ALOGE("Antibanding Value : %d",value);
-            mParameters.set(QCameraParameters::KEY_ANTIBANDING, str);
-            if(value == CAMERA_ANTIBANDING_AUTO) {
-                 value = getAutoFlickerMode();
-            }
-            bool ret = native_set_parms(MM_CAMERA_PARM_ANTIBANDING,
-                       sizeof(camera_antibanding_type), (void *)&value ,(int *)&result);
-            if(result != MM_CAMERA_OK) {
-                ALOGI("AntiBanding Value: %s is not supported for the given BestShot Mode", str);
-            }
-            return ret ? NO_ERROR : UNKNOWN_ERROR;
-        }
-    }
-    ALOGE("Invalid antibanding value: %s", (str == NULL) ? "NULL" : str);
-
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setPreviewFrameRate(const QCameraParameters& params)
-{
-    ALOGV("%s: E",__func__);
-    status_t rc = NO_ERROR;
-    uint16_t fps = (uint16_t)params.getPreviewFrameRate();
-    ALOGV("%s: requested preview frame rate  is %d", __func__, fps);
-
-    mParameters.setPreviewFrameRate(fps);
-    ALOGV("%s: X",__func__);
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setPreviewFrameRateMode(const QCameraParameters& params) {
-
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_FPS,&supported,&supported);
-    if(!supported) {
-       ALOGE(" CAMERA FPS mode is not supported for this sensor");
-       return NO_ERROR;
-    }
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_FPS_MODE,&supported,&supported);
-    if(!supported) {
-       ALOGE("CAMERA FPS MODE mode is not supported for this sensor");
-       return NO_ERROR;
-    }
-
-    const char *previousMode = mParameters.getPreviewFrameRateMode();
-    const char *str = params.getPreviewFrameRateMode();
-    if (NULL == previousMode) {
-        ALOGE("Preview Frame Rate Mode is NULL\n");
-        return NO_ERROR;
-    }
-    if (NULL == str) {
-        ALOGE("Preview Frame Rate Mode is NULL\n");
-        return NO_ERROR;
-    }
-    if( mInitialized && !strcmp(previousMode, str)) {
-        ALOGE("frame rate mode same as previous mode %s", previousMode);
-        return NO_ERROR;
-    }
-    int32_t frameRateMode = attr_lookup(frame_rate_modes, sizeof(frame_rate_modes) / sizeof(str_map),str);
-    if(frameRateMode != NOT_FOUND) {
-        ALOGV("setPreviewFrameRateMode: %s ", str);
-        mParameters.setPreviewFrameRateMode(str);
-        bool ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(frameRateMode), (void *)&frameRateMode);
-        if(!ret) return ret;
-        //set the fps value when chaging modes
-        int16_t fps = (uint16_t)params.getPreviewFrameRate();
-        if(MINIMUM_FPS <= fps && fps <=MAXIMUM_FPS){
-            mParameters.setPreviewFrameRate(fps);
-            ret = native_set_parms(MM_CAMERA_PARM_FPS,
-                                        sizeof(fps), (void *)&fps);
-            return ret ? NO_ERROR : UNKNOWN_ERROR;
-        }
-        ALOGE("Invalid preview frame rate value: %d", fps);
-        return BAD_VALUE;
-    }
-    ALOGE("Invalid preview frame rate mode value: %s", (str == NULL) ? "NULL" : str);
-
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSkinToneEnhancement(const QCameraParameters& params) {
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_SCE_FACTOR,&supported,&supported);
-    if(!supported) {
-       ALOGE("SkinToneEnhancement is not supported for this sensor");
-       return NO_ERROR;
-    }
-     int skinToneValue = params.getInt("skinToneEnhancement");
-     if (mSkinToneEnhancement != skinToneValue) {
-          ALOGV(" new skinTone correction value : %d ", skinToneValue);
-          mSkinToneEnhancement = skinToneValue;
-          mParameters.set("skinToneEnhancement", skinToneValue);
-          bool ret = native_set_parms(MM_CAMERA_PARM_SCE_FACTOR, sizeof(mSkinToneEnhancement),
-                        (void *)&mSkinToneEnhancement);
-          return ret ? NO_ERROR : UNKNOWN_ERROR;
-    }
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setWaveletDenoise(const QCameraParameters& params) {
-    ALOGV("%s",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_WAVELET_DENOISE,&supported,&supported);
-    if( !supported ) {
-        ALOGE("Wavelet Denoise is not supported for this sensor");
-        /* TO DO */
-//        return NO_ERROR;
-    }
-    const char *str = params.get(QCameraParameters::KEY_QC_DENOISE);
-    if (str != NULL) {
-        int value = attr_lookup(denoise,
-                sizeof(denoise) / sizeof(str_map), str);
-        if ((value != NOT_FOUND) &&  (mDenoiseValue != value)) {
-            mDenoiseValue =  value;
-            mParameters.set(QCameraParameters::KEY_QC_DENOISE, str);
-
-            char prop[PROPERTY_VALUE_MAX];
-            memset(prop, 0, sizeof(prop));
-            property_get("persist.denoise.process.plates", prop, "0");
-
-            denoise_param_t temp;
-            memset(&temp, 0, sizeof(denoise_param_t));
-            temp.denoise_enable = value;
-            switch(atoi(prop)) {
-                case 0:
-                    temp.process_plates = WAVELET_DENOISE_YCBCR_PLANE;
-                    break;
-                case 1:
-                    temp.process_plates = WAVELET_DENOISE_CBCR_ONLY;
-                    break;
-                case 2:
-                    temp.process_plates = WAVELET_DENOISE_STREAMLINE_YCBCR;
-                    break;
-                case 3:
-                    temp.process_plates = WAVELET_DENOISE_STREAMLINED_CBCR;
-                    break;
-                default:
-                    temp.process_plates = WAVELET_DENOISE_STREAMLINE_YCBCR;
-                    break;
-                }
-            ALOGE("Denoise enable=%d, plates=%d", temp.denoise_enable, temp.process_plates);
-            bool ret = native_set_parms(MM_CAMERA_PARM_WAVELET_DENOISE, sizeof(temp),
-                    (void *)&temp);
-            return ret ? NO_ERROR : UNKNOWN_ERROR;
-        }
-        return NO_ERROR;
-    }
-    ALOGE("Invalid Denoise value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setVideoSize(const QCameraParameters& params)
-{
-    const char *str= NULL;
-    const char *str_t= NULL;
-    int old_vid_w = 0, old_vid_h = 0;
-    ALOGV("%s: E", __func__);
-    str = params.get(QCameraParameters::KEY_VIDEO_SIZE);
-    str_t = mParameters.get(CameraParameters::KEY_VIDEO_SIZE);
-    if(!str) {
-        mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, "");
-        //If application didn't set this parameter string, use the values from
-        //getPreviewSize() as video dimensions.
-        ALOGE("No Record Size requested, use the preview dimensions");
-        videoWidth = mPreviewWidth;
-        videoHeight = mPreviewHeight;
-    } else {
-        //Extract the record witdh and height that application requested.
-        ALOGI("%s: requested record size %s", __func__, str);
-        if(!parse_size(str, videoWidth, videoHeight)) {
-            parse_size(str_t, old_vid_w, old_vid_h);
-            mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, str);
-            if((QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) &&
-               (old_vid_w != videoWidth || old_vid_h != videoHeight)) {
-                ALOGE("%s: Video sizes changes to %s, Restart preview...", __func__, str);
-                mRestartPreview = true;
-            }
-        } else {
-            mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, "");
-            ALOGE("%s: error :failed to parse parameter record-size (%s)", __func__, str);
-            return BAD_VALUE;
-        }
-    }
-    ALOGV("%s: preview dimensions: %dx%d", __func__, mPreviewWidth, mPreviewHeight);
-    ALOGV("%s: video dimensions: %dx%d", __func__, videoWidth, videoHeight);
-    mDimension.orig_video_width = videoWidth;
-    mDimension.orig_video_height = videoHeight;
-    mDimension.video_width = videoWidth;
-    mDimension.video_height = videoHeight;
-
-    ALOGV("%s: X", __func__);
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setCameraMode(const QCameraParameters& params) {
-    int32_t value = params.getInt(QCameraParameters::KEY_QC_CAMERA_MODE);
-    mParameters.set(QCameraParameters::KEY_QC_CAMERA_MODE,value);
-
-    ALOGI("ZSL is enabled  %d", value);
-    if (value == 1) {
-        myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE);
-    } else {
-        myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE);
-    }
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setPowerMode(const QCameraParameters& params) {
-    uint32_t value = NORMAL_POWER;
-    const char *powermode = NULL;
-
-    powermode = params.get(QCameraParameters::KEY_QC_POWER_MODE);
-    if (powermode != NULL) {
-        value = attr_lookup(power_modes,
-                sizeof(power_modes) / sizeof(str_map), powermode);
-        if((value == LOW_POWER) || mHFRLevel > 1) {
-            ALOGI("Enable Low Power Mode");
-            value = LOW_POWER;
-            mPowerMode = value;
-            mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Low_Power");
-        } else {
-            ALOGE("Enable Normal Power Mode");
-            mPowerMode = value;
-            mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Normal_Power");
-        }
-    }
-
-    ALOGI("%s Low power mode %s value = %d", __func__,
-          value ? "Enabled" : "Disabled", value);
-    native_set_parms(MM_CAMERA_PARM_LOW_POWER_MODE, sizeof(value),
-                                               (void *)&value);
-    return NO_ERROR;
-}
-
-
-status_t QCameraHardwareInterface::setPreviewSize(const QCameraParameters& params)
-{
-    int width, height;
-    params.getPreviewSize(&width, &height);
-    ALOGV("################requested preview size %d x %d", width, height);
-
-    // Validate the preview size
-    for (size_t i = 0; i <  mPreviewSizeCount; ++i) {
-        if (width ==  mPreviewSizes[i].width
-           && height ==  mPreviewSizes[i].height) {
-            mParameters.setPreviewSize(width, height);
-            ALOGE("setPreviewSize:  width: %d   heigh: %d", width, height);
-            mPreviewWidth = width;
-            mPreviewHeight = height;
-            mDimension.display_width = width;
-            mDimension.display_height = height;
-            return NO_ERROR;
-        }
-    }
-    ALOGE("Invalid preview size requested: %dx%d", width, height);
-    return BAD_VALUE;
-}
-status_t QCameraHardwareInterface::setPreviewFpsRange(const QCameraParameters& params)
-{
-    ALOGV("%s: E", __func__);
-    int minFps,maxFps;
-    int prevMinFps, prevMaxFps;
-    int rc = NO_ERROR;
-    bool found = false;
-
-    mParameters.getPreviewFpsRange(&prevMinFps, &prevMaxFps);
-    ALOGV("%s: Existing FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps);
-    params.getPreviewFpsRange(&minFps,&maxFps);
-    ALOGV("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps);
-
-    if(mInitialized && (minFps == prevMinFps && maxFps == prevMaxFps)) {
-        ALOGE("%s: No change in FpsRange", __func__);
-        rc = NO_ERROR;
-        goto end;
-    }
-    for(int i=0; i<mSupportedFpsRangesCount; i++) {
-        // if the value is in the supported list
-        if(minFps >= mSupportedFpsRanges[i].minFPS && maxFps <= mSupportedFpsRanges[i].maxFPS) {
-            found = true;
-            ALOGE("FPS: i=%d : minFps = %d, maxFps = %d ", i, minFps, maxFps);
-            mParameters.setPreviewFpsRange(minFps,maxFps);
-            // validate the values
-            bool valid = true;
-            // FPS can not be negative
-            if(minFps < 0 || maxFps < 0) valid = false;
-            // minFps must be >= maxFps
-            if(minFps > maxFps) valid = false;
-
-            if(valid) {
-                //Set the FPS mode
-                const char *str = (minFps == maxFps) ?
-                    QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE:
-                    QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE;
-                ALOGE("%s FPS_MODE = %s", __func__, str);
-                int32_t frameRateMode = attr_lookup(frame_rate_modes,
-                        sizeof(frame_rate_modes) / sizeof(str_map),str);
-                bool ret;
-                ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(int32_t),
-                            (void *)&frameRateMode);
-
-                //set FPS values
-                uint32_t fps;  //lower 2 bytes specify maxFps and higher 2 bytes specify minFps
-                fps = ((uint32_t)(minFps/1000) << 16) + ((uint16_t)(maxFps/1000));
-
-                ret = native_set_parms(MM_CAMERA_PARM_FPS, sizeof(uint32_t), (void *)&fps);
-                mParameters.setPreviewFpsRange(minFps, maxFps);
-                if(ret)
-                    rc = NO_ERROR;
-                else {
-                    rc = BAD_VALUE;
-                    ALOGE("%s: error: native_set_params failed", __func__);
-                }
-            } else {
-                ALOGE("%s: error: invalid FPS range value", __func__);
-                rc = BAD_VALUE;
-            }
-        }
-    }
-    if(found == false){
-            ALOGE("%s: error: FPS range value not supported", __func__);
-            rc = BAD_VALUE;
-    }
-end:
-    ALOGV("%s: X", __func__);
-    return rc;
-}
-
-status_t QCameraHardwareInterface::setJpegThumbnailSize(const QCameraParameters& params){
-    int width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
-    int height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
-
-    ALOGV("requested jpeg thumbnail size %d x %d", width, height);
-
-    // Validate the picture size
-    for (unsigned int i = 0; i < thumbnail_sizes_count; ++i) {
-       if (width == default_thumbnail_sizes[i].width
-         && height == default_thumbnail_sizes[i].height) {
-           thumbnailWidth = width;
-           thumbnailHeight = height;
-           mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
-           mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
-           return NO_ERROR;
-       }
-    }
-    ALOGE("error: setting jpeg thumbnail size");
-    return BAD_VALUE;
-}
-status_t QCameraHardwareInterface::setPictureSize(const QCameraParameters& params)
-{
-    int width, height;
-    ALOGV("QualcommCameraHardware::setPictureSize E");
-    params.getPictureSize(&width, &height);
-    ALOGE("requested picture size %d x %d", width, height);
-
-    // Validate the picture size
-    for (int i = 0; i < mSupportedPictureSizesCount; ++i) {
-        if (width == mPictureSizesPtr[i].width
-          && height == mPictureSizesPtr[i].height) {
-            int old_width, old_height;
-            mParameters.getPictureSize(&old_width,&old_height);
-            mParameters.setPictureSize(width, height);
-            mDimension.picture_width = width;
-            mDimension.picture_height = height;
-            if((QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) &&
-               (width != old_width || height != old_height)) {
-                mRestartPreview = true;
-            }
-            return NO_ERROR;
-        }
-    }
-    /* Dimension not among the ones in the list. Check if
-     * its a valid dimension, if it is, then configure the
-     * camera accordingly. else reject it.
-     */
-    if( isValidDimension(width, height) ) {
-        mParameters.setPictureSize(width, height);
-        mDimension.picture_width = width;
-        mDimension.picture_height = height;
-        return NO_ERROR;
-    } else
-        ALOGE("Invalid picture size requested: %dx%d", width, height);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setJpegRotation(int isZsl) {
-//    return mm_jpeg_encoder_setRotation(mRotation, isZsl);
-      return NO_ERROR;
-}
-
-int QCameraHardwareInterface::getJpegRotation(void) {
-    ALOGE("%s : rotation is %d", __func__, mRotation);
-    return mRotation;
-}
-
-int QCameraHardwareInterface::getISOSpeedValue()
-{
-    const char *iso_str = mParameters.get(QCameraParameters::KEY_QC_ISO_MODE);
-    int iso_index = attr_lookup(iso, sizeof(iso) / sizeof(str_map), iso_str);
-    int iso_value = iso_speed_values[iso_index];
-    return iso_value;
-}
-
-
-status_t QCameraHardwareInterface::setJpegQuality(const QCameraParameters& params) {
-    status_t rc = NO_ERROR;
-    int quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY);
-    ALOGV("setJpegQuality E");
-    if (quality >= 0 && quality <= 100) {
-        mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, quality);
-        mJpegQuality = quality;
-    } else {
-        ALOGE("Invalid jpeg quality=%d", quality);
-        rc = BAD_VALUE;
-    }
-
-    quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
-    if (quality >= 0 && quality <= 100) {
-        mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, quality);
-    } else {
-        ALOGE("Invalid jpeg thumbnail quality=%d", quality);
-        rc = BAD_VALUE;
-    }
-    ALOGV("setJpegQuality X");
-    return rc;
-}
-
-status_t QCameraHardwareInterface::
-setNumOfSnapshot(const QCameraParameters& params) {
-    status_t rc = NO_ERROR;
-
-    int num_of_snapshot = getNumOfSnapshots(params);
-
-    if (num_of_snapshot <= 0) {
-        num_of_snapshot = 1;
-    }
-    ALOGI("number of snapshots = %d", num_of_snapshot);
-    mParameters.set("num-snaps-per-shutter", num_of_snapshot);
-
-    bool result = native_set_parms(MM_CAMERA_PARM_SNAPSHOT_BURST_NUM,
-                                   sizeof(int),
-                                   (void *)&num_of_snapshot);
-    if(!result)
-        ALOGI("%s:Failure setting number of snapshots!!!", __func__);
-    return rc;
-}
-
-status_t QCameraHardwareInterface::setPreviewFormat(const QCameraParameters& params) {
-    const char *str = params.getPreviewFormat();
-    int32_t previewFormat = attr_lookup(preview_formats, sizeof(preview_formats) / sizeof(str_map), str);
-    if(previewFormat != NOT_FOUND) {
-        int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t);
-        int i;
-
-        for (i = 0; i < num; i++) {
-          if (preview_format_info_list[i].Hal_format == previewFormat) {
-            mPreviewFormatInfo = preview_format_info_list[i];
-            break;
-          }
-        }
-
-        if (i == num) {
-          mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
-          mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD;
-          return BAD_VALUE;
-        }
-        bool ret = native_set_parms(MM_CAMERA_PARM_PREVIEW_FORMAT, sizeof(cam_format_t),
-                                   (void *)&mPreviewFormatInfo.mm_cam_format);
-        mParameters.set(QCameraParameters::KEY_PREVIEW_FORMAT, str);
-        mPreviewFormat = mPreviewFormatInfo.mm_cam_format;
-        ALOGI("Setting preview format to %d, i =%d, num=%d, hal_format=%d",
-             mPreviewFormat, i, num, mPreviewFormatInfo.Hal_format);
-        return NO_ERROR;
-    } else if ( strTexturesOn ) {
-      mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
-      mPreviewFormatInfo.padding = CAMERA_PAD_TO_4K;
-    } else {
-      mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
-      mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD;
-    }
-    ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setStrTextures(const QCameraParameters& params) {
-    const char *str = params.get("strtextures");
-    const char *prev_str = mParameters.get("strtextures");
-
-    if(str != NULL) {
-        if(!strcmp(str,prev_str)) {
-            return NO_ERROR;
-        }
-        int str_size = strlen(str);
-        mParameters.set("strtextures", str);
-        if(str_size == 2) {
-            if(!strncmp(str, "on", str_size) || !strncmp(str, "ON", str_size)){
-                ALOGI("Resetting mUseOverlay to false");
-                strTexturesOn = true;
-                mUseOverlay = false;
-            }
-        }else if(str_size == 3){
-            if (!strncmp(str, "off", str_size) || !strncmp(str, "OFF", str_size)) {
-                strTexturesOn = false;
-                mUseOverlay = true;
-            }
-        }
-
-    }
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setFlash(const QCameraParameters& params)
-{
-    ALOGI("%s: E",__func__);
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_LED_MODE,&supported,&supported);
-    if(!supported) {
-        ALOGE("%s:LED FLASH not supported", __func__);
-        return NO_ERROR;
-    }
-
-    const char *str = params.get(QCameraParameters::KEY_FLASH_MODE);
-    if (str != NULL) {
-        int32_t value = attr_lookup(flash, sizeof(flash) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            mParameters.set(QCameraParameters::KEY_FLASH_MODE, str);
-            bool ret = native_set_parms(MM_CAMERA_PARM_LED_MODE,
-                                       sizeof(value), (void *)&value);
-            return ret ? NO_ERROR : UNKNOWN_ERROR;
-        }
-    }
-    ALOGE("Invalid flash mode value: %s", (str == NULL) ? "NULL" : str);
-
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setAecAwbLock(const QCameraParameters & params)
-{
-    ALOGD("%s : E", __func__);
-    status_t rc = NO_ERROR;
-    int32_t value;
-    const char* str;
-
-    //for AEC lock
-    str = params.get(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK);
-    value = (strcmp(str, "true") == 0)? 1 : 0;
-    mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK, str);
-    rc = (native_set_parms(MM_CAMERA_PARM_AEC_LOCK, sizeof(int32_t), (void *)(&value))) ?
-                            NO_ERROR : UNKNOWN_ERROR;
-
-    //for AWB lock
-    str = params.get(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
-    value = (strcmp(str, "true") == 0)? 1 : 0;
-    mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, str);
-    rc = (native_set_parms(MM_CAMERA_PARM_AWB_LOCK, sizeof(int32_t), (void *)(&value))) ?
-                        NO_ERROR : UNKNOWN_ERROR;
-    ALOGD("%s : X", __func__);
-    return rc;
-}
-
-status_t QCameraHardwareInterface::setOverlayFormats(const QCameraParameters& params)
-{
-    mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP);
-    if(mIs3DModeOn == true) {
-       int ovFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP|HAL_3D_IN_SIDE_BY_SIDE_L_R|HAL_3D_OUT_SIDE_BY_SIDE;
-        mParameters.set("overlay-format", ovFormat);
-    }
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setMCEValue(const QCameraParameters& params)
-{
-    ALOGE("%s",__func__);
-    uint8_t supported;
-
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_MCE,&supported,&supported);
-   if(!supported) {
-       ALOGE("MM_CAMERA_PARM_MCE mode is not supported for this sensor");
-       return NO_ERROR;
-   }
-   const char *str = params.get(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT);
-    if (str != NULL) {
-        int value = attr_lookup(mce, sizeof(mce) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            int temp = (int8_t)value;
-            ALOGI("%s: setting MCE value of %s", __FUNCTION__, str);
-            mParameters.set(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT, str);
-
-            native_set_parms(MM_CAMERA_PARM_MCE, sizeof(int8_t), (void *)&temp);
-            return NO_ERROR;
-        }
-    }
-    ALOGE("Invalid MCE value: %s", (str == NULL) ? "NULL" : str);
-
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setHighFrameRate(const QCameraParameters& params)
-{
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_HFR,&supported,&supported);
-    if(!supported) {
-        ALOGE("%s: MM_CAMERA_PARM_HFR not supported", __func__);
-        return NO_ERROR;
-    }
-
-    const char *str = params.get(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE);
-    if (str != NULL) {
-        int value = attr_lookup(hfr, sizeof(hfr) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            mHFRLevel = (int32_t)value;
-            //Check for change in HFR value
-            const char *oldHfr = mParameters.get(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE);
-            if(strcmp(oldHfr, str)){
-                mParameters.set(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE, str);
-                if(QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) {
-                    stopPreviewInternal();
-                    mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-                    native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel);
-                    mRestartPreview = true;
-                    return NO_ERROR;
-                }
-            }
-            native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel);
-            return NO_ERROR;
-        }
-    }
-    ALOGE("Invalid HFR value: %s", (str == NULL) ? "NULL" : str);
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setLensshadeValue(const QCameraParameters& params)
-{
-
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_ROLLOFF,&supported,&supported);
-    if(!supported) {
-        ALOGE("%s:LENS SHADING not supported", __func__);
-        return NO_ERROR;
-    }
-
-    const char *str = params.get(QCameraParameters::KEY_QC_LENSSHADE);
-    if (str != NULL) {
-        int value = attr_lookup(lensshade,
-                                    sizeof(lensshade) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            int8_t temp = (int8_t)value;
-            mParameters.set(QCameraParameters::KEY_QC_LENSSHADE, str);
-            native_set_parms(MM_CAMERA_PARM_ROLLOFF, sizeof(int8_t), (void *)&temp);
-            return NO_ERROR;
-        }
-    }
-    ALOGE("Invalid lensShade value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setFaceDetect(const QCameraParameters& params)
-{
-    int requested_faces = params.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
-    int hardware_supported_faces = mParameters.getInt(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW);
-    if (requested_faces > hardware_supported_faces) {
-        requested_faces = hardware_supported_faces;
-    }
-    mParameters.set(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES, requested_faces);
-    const char *str = params.get(QCameraParameters::KEY_QC_FACE_DETECTION);
-    ALOGE("setFaceDetect: %s", str);
-    if (str != NULL) {
-        fd_set_parm_t fd_set_parm;
-        int value = attr_lookup(facedetection,
-                sizeof(facedetection) / sizeof(str_map), str);
-        mFaceDetectOn = value;
-        fd_set_parm.fd_mode = value;
-        fd_set_parm.num_fd = requested_faces;
-        ALOGE("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces);
-        native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm);
-        mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION, str);
-        return NO_ERROR;
-    }
-    ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-status_t QCameraHardwareInterface::setFaceDetection(const char *str)
-{
-    if(supportsFaceDetection() == false){
-        ALOGE("Face detection is not enabled");
-        return NO_ERROR;
-    }
-    if (str != NULL) {
-        int requested_faces = mParameters.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
-        int value = attr_lookup(facedetection,
-                                    sizeof(facedetection) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            fd_set_parm_t fd_set_parm;
-            mFaceDetectOn = value;
-            fd_set_parm.fd_mode = value;
-            fd_set_parm.num_fd = requested_faces;
-            ALOGE("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces);
-            native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm);
-            mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION, str);
-            return NO_ERROR;
-        }
-    }
-    ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setAEBracket(const QCameraParameters& params)
-{
-    uint8_t supported;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_HDR,&supported,&supported);
-    if(!supported || (myMode & CAMERA_ZSL_MODE)) {
-        ALOGI("Parameter HDR is not supported for this sensor/ ZSL mode");
-
-        if (myMode & CAMERA_ZSL_MODE) {
-            ALOGE("In ZSL mode, reset AEBBracket to HDR_OFF mode");
-            exp_bracketing_t temp;
-            memset(&temp, 0, sizeof(temp));
-            mHdrMode = HDR_BRACKETING_OFF;
-            temp.hdr_enable= FALSE;
-            temp.mode = HDR_BRACKETING_OFF;
-            native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
-        }
-        return NO_ERROR;
-    }
-    const char *str = params.get(QCameraParameters::KEY_QC_AE_BRACKET_HDR);
-
-    if (str != NULL) {
-        int value = attr_lookup(hdr_bracket,
-                                    sizeof(hdr_bracket) / sizeof(str_map), str);
-        exp_bracketing_t temp;
-        memset(&temp, 0, sizeof(temp));
-        switch (value) {
-            case HDR_MODE:
-                {
-                    mHdrMode = HDR_MODE;
-                    ALOGE("%s, mHdrMode == HDR_MODE", __func__);
-                  /*  temp.hdr_enable= TRUE;
-                    temp.mode = HDR_MODE;
-                    temp.total_frames = 3;
-                    temp.total_hal_frames = getNumOfSnapshots();
-                    ALOGI("%s: setting HDR frames (%d)", __FUNCTION__, temp.total_hal_frames);
-                    native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); */
-                }
-                break;
-            case EXP_BRACKETING_MODE:
-                {
-                    ALOGE("%s, mHdrMode == EXP_BRACKETING_MODE", __func__);
-                    int numFrames = getNumOfSnapshots();
-                    const char *str_val = params.get("capture-burst-exposures");
-                    if ((str_val != NULL) && (strlen(str_val)>0)) {
-                        ALOGI("%s: capture-burst-exposures %s", __FUNCTION__, str_val);
-
-                        mHdrMode = EXP_BRACKETING_MODE;
-                        temp.hdr_enable = FALSE;
-                        temp.mode = EXP_BRACKETING_MODE;
-                        temp.total_frames = (numFrames >  MAX_SNAPSHOT_BUFFERS -2) ? MAX_SNAPSHOT_BUFFERS -2 : numFrames;
-                        temp.total_hal_frames = temp.total_frames;
-                        strlcpy(temp.values, str_val, MAX_EXP_BRACKETING_LENGTH);
-                        ALOGI("%s: setting Exposure Bracketing value of %s, frame (%d)", __FUNCTION__, temp.values, temp.total_hal_frames);
-                        native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
-                    }
-                    else {
-                        /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */
-                        ALOGI("%s: capture-burst-exposures not set, back to HDR OFF mode", __FUNCTION__);
-                        mHdrMode = HDR_BRACKETING_OFF;
-                        temp.hdr_enable= FALSE;
-                        temp.mode = HDR_BRACKETING_OFF;
-                        native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
-                    }
-                }
-                break;
-            case HDR_BRACKETING_OFF:
-                ALOGE("%s, mHdrMode == HDR_BRACKETING_OFF", __func__);
-            default:
-                {
-                    ALOGE("%s, mHdrMode == HDR_BRACKETING_OFF", __func__);
-                    mHdrMode = HDR_BRACKETING_OFF;
-                    temp.hdr_enable= FALSE;
-                    temp.mode = HDR_BRACKETING_OFF;
-                    native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
-                }
-                break;
-        }
-
-        /* save the value*/
-        mParameters.set(QCameraParameters::KEY_QC_AE_BRACKET_HDR, str);
-    }
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setCaptureBurstExp()
-{
-    char burst_exp[PROPERTY_VALUE_MAX];
-    memset(burst_exp, 0, sizeof(burst_exp));
-    property_get("persist.capture.burst.exposures", burst_exp, "");
-    if (NULL != burst_exp)
-      mParameters.set("capture-burst-exposures", burst_exp);
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRedeyeReduction(const QCameraParameters& params)
-{
-    if(supportsRedEyeReduction() == false) {
-        ALOGE("Parameter Redeye Reduction is not supported for this sensor");
-        return NO_ERROR;
-    }
-
-    const char *str = params.get(QCameraParameters::KEY_QC_REDEYE_REDUCTION);
-    if (str != NULL) {
-        int value = attr_lookup(redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map), str);
-        if (value != NOT_FOUND) {
-            int8_t temp = (int8_t)value;
-            ALOGI("%s: setting Redeye Reduction value of %s", __FUNCTION__, str);
-            mParameters.set(QCameraParameters::KEY_QC_REDEYE_REDUCTION, str);
-
-            native_set_parms(MM_CAMERA_PARM_REDEYE_REDUCTION, sizeof(int8_t), (void *)&temp);
-            return NO_ERROR;
-        }
-    }
-    ALOGE("Invalid Redeye Reduction value: %s", (str == NULL) ? "NULL" : str);
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setGpsLocation(const QCameraParameters& params)
-{
-    const char *method = params.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
-    if (method) {
-        mParameters.set(QCameraParameters::KEY_GPS_PROCESSING_METHOD, method);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
-    }
-
-    const char *latitude = params.get(QCameraParameters::KEY_GPS_LATITUDE);
-    if (latitude) {
-        ALOGE("latitude %s",latitude);
-        mParameters.set(QCameraParameters::KEY_GPS_LATITUDE, latitude);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_GPS_LATITUDE);
-    }
-
-    const char *latitudeRef = params.get(QCameraParameters::KEY_QC_GPS_LATITUDE_REF);
-    if (latitudeRef) {
-        mParameters.set(QCameraParameters::KEY_QC_GPS_LATITUDE_REF, latitudeRef);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_QC_GPS_LATITUDE_REF);
-    }
-
-    const char *longitude = params.get(QCameraParameters::KEY_GPS_LONGITUDE);
-    if (longitude) {
-        mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE, longitude);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_GPS_LONGITUDE);
-    }
-
-    const char *longitudeRef = params.get(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF);
-    if (longitudeRef) {
-        mParameters.set(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF, longitudeRef);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF);
-    }
-
-    const char *altitudeRef = params.get(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF);
-    if (altitudeRef) {
-        mParameters.set(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF, altitudeRef);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF);
-    }
-
-    const char *altitude = params.get(QCameraParameters::KEY_GPS_ALTITUDE);
-    if (altitude) {
-        mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE, altitude);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_GPS_ALTITUDE);
-    }
-
-    const char *status = params.get(QCameraParameters::KEY_QC_GPS_STATUS);
-    if (status) {
-        mParameters.set(QCameraParameters::KEY_QC_GPS_STATUS, status);
-    }
-
-    const char *dateTime = params.get(QCameraParameters::KEY_QC_EXIF_DATETIME);
-    if (dateTime) {
-        mParameters.set(QCameraParameters::KEY_QC_EXIF_DATETIME, dateTime);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_QC_EXIF_DATETIME);
-    }
-
-    const char *timestamp = params.get(QCameraParameters::KEY_GPS_TIMESTAMP);
-    if (timestamp) {
-        mParameters.set(QCameraParameters::KEY_GPS_TIMESTAMP, timestamp);
-    }else {
-         mParameters.remove(QCameraParameters::KEY_GPS_TIMESTAMP);
-    }
-    ALOGE("setGpsLocation X");
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRotation(const QCameraParameters& params)
-{
-    status_t rc = NO_ERROR;
-    int rotation = params.getInt(QCameraParameters::KEY_ROTATION);
-    if (rotation != NOT_FOUND) {
-        if (rotation == 0 || rotation == 90 || rotation == 180
-            || rotation == 270) {
-          mParameters.set(QCameraParameters::KEY_ROTATION, rotation);
-          mRotation = rotation;
-        } else {
-            ALOGE("Invalid rotation value: %d", rotation);
-            rc = BAD_VALUE;
-        }
-    }
-    ALOGE("setRotation");
-    return rc;
-}
-
-status_t QCameraHardwareInterface::setDenoise(const QCameraParameters& params)
-{
-    return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setOrientation(const QCameraParameters& params)
-{
-    const char *str = params.get("orientation");
-
-    if (str != NULL) {
-        if (strcmp(str, "portrait") == 0 || strcmp(str, "landscape") == 0) {
-            // Camera service needs this to decide if the preview frames and raw
-            // pictures should be rotated.
-            mParameters.set("orientation", str);
-        } else {
-            ALOGE("Invalid orientation value: %s", str);
-            return BAD_VALUE;
-        }
-    }
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setPictureFormat(const QCameraParameters& params)
-{
-    const char * str = params.get(QCameraParameters::KEY_PICTURE_FORMAT);
-    if(str != NULL){
-        int32_t value = attr_lookup(picture_formats,
-                                    sizeof(picture_formats) / sizeof(str_map), str);
-        if(value != NOT_FOUND){
-            if (isZSLMode() && !strcmp(str, "raw")) {
-                mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, "jpeg");
-            } else {
-                mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, str);
-            }
-        } else {
-            ALOGE("Invalid Picture Format value: %s", str);
-            return BAD_VALUE;
-        }
-    }
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRecordingHintValue(const int32_t value)
-{
-    native_set_parms(MM_CAMERA_PARM_RECORDING_HINT, sizeof(value),
-                                           (void *)&value);
-    if (value == TRUE){
-        native_set_parms(MM_CAMERA_PARM_CAF_ENABLE, sizeof(value),
-                                           (void *)&value);
-    }
-    setDISMode();
-    setFullLiveshot();
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRecordingHint(const QCameraParameters& params)
-{
-
-  const char * str = params.get(QCameraParameters::KEY_RECORDING_HINT);
-
-  if(str != NULL){
-      int32_t value = attr_lookup(recording_Hints,
-                                  sizeof(recording_Hints) / sizeof(str_map), str);
-      if(value != NOT_FOUND){
-          mRecordingHint = value;
-          setRecordingHintValue(mRecordingHint);
-          mParameters.set(QCameraParameters::KEY_RECORDING_HINT, str);
-          return NO_ERROR;
-      } else {
-          ALOGE("Invalid Picture Format value: %s", str);
-          setDISMode();
-          setFullLiveshot();
-          return BAD_VALUE;
-      }
-  }
-  setDISMode();
-  setFullLiveshot();
-  return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setDISMode() {
-  /* Enable DIS only if
-   * - Camcorder mode AND
-   * - DIS property is set AND
-   * - Not in Low power mode. */
-  uint32_t value = mRecordingHint && mDisEnabled
-                   && !isLowPowerCamcorder();
-
-  ALOGI("%s DIS is %s value = %d", __func__,
-          value ? "Enabled" : "Disabled", value);
-  native_set_parms(MM_CAMERA_PARM_DIS_ENABLE, sizeof(value),
-                                               (void *)&value);
-  return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setFullLiveshot()
-{
-  /* Enable full size liveshot only if
-   * - Camcorder mode AND
-   * - Full size liveshot is enabled. */
-  uint32_t value = mRecordingHint && mFullLiveshotEnabled
-                   && !isLowPowerCamcorder();
-
-  if (((mDimension.picture_width == mDimension.video_width) &&
-      (mDimension.picture_height == mDimension.video_height))) {
-    /* If video size matches the live snapshot size
-     * turn off full size liveshot to get higher fps. */
-    value = 0;
-  }
-
-  ALOGI("%s Full size liveshot %s value = %d", __func__,
-          value ? "Enabled" : "Disabled", value);
-  native_set_parms(MM_CAMERA_PARM_FULL_LIVESHOT, sizeof(value),
-                                               (void *)&value);
-  return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setMobiCat(const QCameraParameters& params)
-{
-    mm_cam_mobicat_info_t mbc_info;
-    char mbc_prop[PROPERTY_VALUE_MAX];
-    int propval;
-    memset(mbc_prop, 0, sizeof(mbc_prop));
-    property_get("persist.camera.mobicat", mbc_prop, "0");
-    propval = atoi(mbc_prop);
-    mbc_info.enable = (mParameters.getInt("mobicat") == 1) ? 1 : 0;
-    ALOGV("%s:%d] prop %d %d", __func__, __LINE__, mbc_info.enable, propval);
-    mbc_info.enable |= propval;
-
-    if (mbc_info.enable != mMobiCatEnabled) {
-        ALOGV("%s:%d] enable %d", __func__, __LINE__, mbc_info.enable);
-        native_set_parms(MM_CAMERA_PARM_MOBICAT, sizeof(mm_cam_mobicat_info_t),
-                        (void *)&mbc_info);
-         mMobiCatEnabled = mbc_info.enable;
-    }
-    return NO_ERROR;
-}
-
-
-isp3a_af_mode_t QCameraHardwareInterface::getAutoFocusMode(
-  const QCameraParameters& params)
-{
-  isp3a_af_mode_t afMode = AF_MODE_MAX;
-  afMode = (isp3a_af_mode_t)mFocusMode;
-  return afMode;
-}
-
-void QCameraHardwareInterface::getPictureSize(int *picture_width,
-                                              int *picture_height) const
-{
-    mParameters.getPictureSize(picture_width, picture_height);
-}
-
-void QCameraHardwareInterface::getPreviewSize(int *preview_width,
-                                              int *preview_height) const
-{
-    mParameters.getPreviewSize(preview_width, preview_height);
-}
-
-void QCameraHardwareInterface::getVideoSize(int *video_width,
-                                              int *video_height) const
-{
-    mParameters.getVideoSize(video_width, video_height);
-}
-
-void QCameraHardwareInterface::getThumbnailSize(int *thumb_width,
-                                              int *thumb_height) const
-{
-    *thumb_width = mParameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
-    *thumb_height = mParameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
-}
-
-cam_format_t QCameraHardwareInterface::getPreviewFormat() const
-{
-    cam_format_t foramt = CAMERA_YUV_420_NV21;
-    const char *str = mParameters.getPreviewFormat();
-    int32_t value = attr_lookup(preview_formats,
-                                sizeof(preview_formats)/sizeof(str_map),
-                                str);
-
-    if(value != NOT_FOUND) {
-        int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t);
-        int i;
-        for (i = 0; i < num; i++) {
-          if (preview_format_info_list[i].Hal_format == value) {
-            foramt = preview_format_info_list[i].mm_cam_format;
-            break;
-          }
-        }
-    }
-
-    return foramt;
-}
-
-cam_pad_format_t QCameraHardwareInterface::getPreviewPadding() const
-{
-  return mPreviewFormatInfo.padding;
-}
-
-int QCameraHardwareInterface::getJpegQuality() const
-{
-    return mJpegQuality;
-}
-
-int QCameraHardwareInterface::getNumOfSnapshots(void) const
-{
-    char prop[PROPERTY_VALUE_MAX];
-    memset(prop, 0, sizeof(prop));
-    property_get("persist.camera.snapshot.number", prop, "0");
-    ALOGI("%s: prop enable/disable = %d", __func__, atoi(prop));
-    if (atoi(prop)) {
-        ALOGE("%s: Reading maximum no of snapshots = %d"
-             "from properties", __func__, atoi(prop));
-        return atoi(prop);
-    } else {
-        return mParameters.getInt("num-snaps-per-shutter");
-    }
-}
-
-int QCameraHardwareInterface::getNumOfSnapshots(const QCameraParameters& params)
-{
-    char prop[PROPERTY_VALUE_MAX];
-    memset(prop, 0, sizeof(prop));
-    property_get("persist.camera.snapshot.number", prop, "0");
-    ALOGI("%s: prop enable/disable = %d", __func__, atoi(prop));
-    if (atoi(prop)) {
-        ALOGI("%s: Reading maximum no of snapshots = %d"
-             "from properties", __func__, atoi(prop));
-        return atoi(prop);
-    } else {
-        return params.getInt("num-snaps-per-shutter");
-    }
-
-}
-
-int QCameraHardwareInterface::
-getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
-                             int *picture_width,
-                             int *picture_height)
-{
-    for(unsigned int i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ){
-        if(thumbnail_sizes[i].aspect_ratio == aspect_ratio)
-        {
-            *picture_width = thumbnail_sizes[i].width;
-            *picture_height = thumbnail_sizes[i].height;
-            return NO_ERROR;
-        }
-    }
-
-    return BAD_VALUE;
-}
-
-bool QCameraHardwareInterface::isRawSnapshot()
-{
-  const char *format = mParameters.getPictureFormat();
-    if( format!= NULL &&
-       !strcmp(format, QCameraParameters::PIXEL_FORMAT_RAW)){
-        return true;
-    }
-    else{
-        return false;
-    }
-}
-
-status_t QCameraHardwareInterface::setPreviewSizeTable(void)
-{
-    status_t ret = NO_ERROR;
-    mm_camera_dimension_t dim;
-    struct camera_size_type* preview_size_table;
-    int preview_table_size;
-    int i = 0;
-    char str[10] = {0};
-
-    /* Initialize table with default values */
-    preview_size_table = default_preview_sizes;
-    preview_table_size = preview_sizes_count;
-
-
-    /* Get maximum preview size supported by sensor*/
-    memset(&dim, 0, sizeof(mm_camera_dimension_t));
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                              MM_CAMERA_PARM_MAX_PREVIEW_SIZE, &dim);
-    if (ret != NO_ERROR) {
-        ALOGE("%s: Failure getting Max Preview Size supported by camera",
-             __func__);
-        goto end;
-    }
-
-    ALOGD("%s: Max Preview Sizes Supported: %d X %d", __func__,
-         dim.width, dim.height);
-
-    for (i = 0; i < preview_table_size; i++) {
-        if ((preview_size_table->width <= dim.width) &&
-            (preview_size_table->height <= dim.height)) {
-            ALOGD("%s: Camera Preview Size Table "
-                 "Max width: %d height %d table_size: %d",
-                 __func__, preview_size_table->width,
-                 preview_size_table->height, preview_table_size - i);
-            break;
-        }
-        preview_size_table++;
-    }
-    //set preferred preview size to maximum preview size
-    sprintf(str, "%dx%d", preview_size_table->width, preview_size_table->height);
-    mParameters.set(QCameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, str);
-    ALOGD("KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO = %s", str);
-
-end:
-    /* Save the table in global member*/
-    mPreviewSizes = preview_size_table;
-    mPreviewSizeCount = preview_table_size - i;
-
-    return ret;
-}
-
-status_t QCameraHardwareInterface::setPictureSizeTable(void)
-{
-    status_t ret = NO_ERROR;
-    mm_camera_dimension_t dim;
-    struct camera_size_type* picture_size_table;
-    int picture_table_size;
-    int i = 0, count = 0;
-
-    /* Initialize table with default values */
-    picture_table_size = sizeof(default_picture_sizes)/
-        sizeof(default_picture_sizes[0]);
-    picture_size_table = default_picture_sizes;
-    mPictureSizes =
-        ( struct camera_size_type *)malloc(picture_table_size *
-                                           sizeof(struct camera_size_type));
-    if (mPictureSizes == NULL) {
-        ALOGE("%s: Failre allocating memory to store picture size table",__func__);
-        goto end;
-    }
-
-    /* Get maximum picture size supported by sensor*/
-    memset(&dim, 0, sizeof(mm_camera_dimension_t));
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                              MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim);
-    if (ret != NO_ERROR) {
-        ALOGE("%s: Failure getting Max Picture Size supported by camera",
-             __func__);
-        ret = NO_MEMORY;
-        free(mPictureSizes);
-        mPictureSizes = NULL;
-        goto end;
-    }
-
-    ALOGD("%s: Max Picture Sizes Supported: %d X %d", __func__,
-         dim.width, dim.height);
-
-    for (i = 0; i < picture_table_size; i++) {
-        /* We'll store those dimensions whose width AND height
-           are less than or equal to maximum supported */
-        if ((picture_size_table->width <= dim.width) &&
-            (picture_size_table->height <= dim.height)) {
-            ALOGD("%s: Camera Picture Size Table "
-                 "Max width: %d height %d table_size: %d",
-                 __func__, picture_size_table->width,
-                 picture_size_table->height, count+1);
-            mPictureSizes[count].height = picture_size_table->height;
-            mPictureSizes[count].width = picture_size_table->width;
-            count++;
-        }
-        picture_size_table++;
-    }
-    mPictureSizeCount = count;
-
-end:
-     /* In case of error, we use default picture sizes */
-     if (ret != NO_ERROR) {
-        mPictureSizes = default_picture_sizes;
-        mPictureSizeCount = picture_table_size;
-    }
-    return ret;
-}
-
-status_t QCameraHardwareInterface::setVideoSizeTable(void)
-{
-    status_t ret = NO_ERROR;
-    mm_camera_dimension_t dim;
-    struct camera_size_type* video_size_table;
-    int video_table_size;
-    int i = 0, count = 0;
-    ALOGE("%s: E", __func__);
-
-    /* Initialize table with default values */
-    video_table_size = video_sizes_count;
-    video_size_table = default_video_sizes;
-    mVideoSizes =
-        (struct camera_size_type *)malloc(video_table_size *
-                                           sizeof(struct camera_size_type));
-    if(mVideoSizes == NULL) {
-        ALOGE("%s: error allocating memory to store video size table",__func__);
-        ret = BAD_VALUE;
-        goto end;
-    }
-
-    /* Get maximum video size supported by sensor*/
-    memset(&dim, 0, sizeof(mm_camera_dimension_t));
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
-                              MM_CAMERA_PARM_MAX_VIDEO_SIZE, &dim);
-    if(ret != NO_ERROR) {
-        ALOGE("%s: error getting Max Video Size supported by camera",
-             __func__);
-        ret = NO_MEMORY;
-        free(mVideoSizes);
-        mVideoSizes = NULL;
-        ret = BAD_VALUE;
-        goto end;
-    }
-
-    ALOGD("%s: Max Video Size Supported: %d X %d", __func__,
-         dim.width, dim.height);
-
-    for(i=0; i < video_table_size; i++) {
-        /* We'll store those dimensions whose width AND height
-           are less than or equal to maximum supported */
-        if((video_size_table->width <= dim.width) &&
-            (video_size_table->height <= dim.height)) {
-            ALOGD("%s: Supported Video Size [%d] = %dx%d", __func__, count, video_size_table->width,
-                                    video_size_table->height);
-            mVideoSizes[count].height = video_size_table->height;
-            mVideoSizes[count].width = video_size_table->width;
-            count++;
-        }
-        video_size_table++;
-    }
-    mVideoSizeCount = count;
-
-end:
-    ALOGE("%s: X", __func__);
-    return ret;
-}
-
-void QCameraHardwareInterface::freeVideoSizeTable(void)
-{
-    if(mVideoSizes != NULL)
-    {
-        free(mVideoSizes);
-    }
-    mVideoSizeCount = 0;
-}
-
-
-void QCameraHardwareInterface::freePictureTable(void)
-{
-    /* If we couldn't allocate memory to store picture table
-       we use the picture table pointer to point to default
-       picture table array. In that case we cannot free it.*/
-    if ((mPictureSizes != default_picture_sizes) && mPictureSizes) {
-        free(mPictureSizes);
-    }
-}
-
-status_t QCameraHardwareInterface::setHistogram(int histogram_en)
-{
-    status_t ret = NO_ERROR;
-
-    ALOGV("setHistogram: E");
-    if(mStatsOn == histogram_en) {
-        return ret;
-    }
-
-    status_t rc = NO_ERROR;
-    mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
-                                          MM_CAMERA_PARM_HISTOGRAM,
-                                          (uint8_t*)&rc,(uint8_t*)&rc);
-    if(!rc) {
-        ALOGE(" Histogram is not supported for this");
-        return NO_ERROR;
-    }
-    mSendData = histogram_en;
-    mStatsOn = histogram_en;
-
-    if (histogram_en == QCAMERA_PARM_ENABLE) {
-        ret = initHistogramBuffers();
-        if (ret != NO_ERROR) {
-          ALOGE("%s Error initializing Histogram buffers ", __func__);
-          return ret;
-        }
-    }
-    ALOGI(" Histogram -> %s", histogram_en ? "Enabled" : "Disabled");
-    native_set_parms(MM_CAMERA_PARM_HISTOGRAM, sizeof(int), &histogram_en);
-    if(histogram_en == QCAMERA_PARM_DISABLE) {
-        ret = deInitHistogramBuffers();
-        if (ret != NO_ERROR) {
-          ALOGE("%s Error deInitializing Histogram buffers ", __func__);
-          return ret;
-        }
-    }
-    ALOGV("setHistogram: X");
-    return ret;
-}
-
-status_t QCameraHardwareInterface::setZSLBurstLookBack(const QCameraParameters& params)
-{
-  const char *v = params.get("capture-burst-retroactive");
-  if (v) {
-    int look_back = atoi(v);
-    ALOGI("%s: look_back =%d", __func__, look_back);
-    mParameters.set("capture-burst-retroactive", look_back);
-  }
-  return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setZSLBurstInterval(const QCameraParameters& params)
-{
-  mZslInterval = BURST_INTREVAL_DEFAULT;
-  const char *v = params.get("capture-burst-interval");
-  if (v) {
-    int interval = atoi(v);
-    ALOGI("%s: Interval =%d", __func__, interval);
-    if(interval < BURST_INTREVAL_MIN ||interval > BURST_INTREVAL_MAX ) {
-      return BAD_VALUE;
-    }
-    mZslInterval =  interval;
-  }
-  return NO_ERROR;
-}
-
-int QCameraHardwareInterface::getZSLBurstInterval( void )
-{
-  int val;
-
-  if (mZslInterval == BURST_INTREVAL_DEFAULT) {
-    char prop[PROPERTY_VALUE_MAX];
-    memset(prop, 0, sizeof(prop));
-    property_get("persist.camera.zsl.interval", prop, "1");
-    val = atoi(prop);
-    ALOGD("%s: prop interval = %d", __func__, val);
-  } else {
-    val = mZslInterval;
-  }
-  return val;
-}
-
-
-int QCameraHardwareInterface::getZSLQueueDepth(void) const
-{
-    char prop[PROPERTY_VALUE_MAX];
-    memset(prop, 0, sizeof(prop));
-    property_get("persist.camera.zsl.queuedepth", prop, "2");
-    ALOGI("%s: prop = %d", __func__, atoi(prop));
-    return atoi(prop);
-}
-
-int QCameraHardwareInterface::getZSLBackLookCount(void) const
-{
-    int look_back;
-    char prop[PROPERTY_VALUE_MAX];
-    memset(prop, 0, sizeof(prop));
-    property_get("persist.camera.zsl.backlookcnt", prop, "0");
-    ALOGI("%s: prop = %d", __func__, atoi(prop));
-    look_back = atoi(prop);
-    if (look_back == 0 ) {
-      look_back = mParameters.getInt("capture-burst-retroactive");
-      ALOGE("%s: look_back = %d", __func__, look_back);
-    }
-    return look_back;
-}
-
-//EXIF functions
-void QCameraHardwareInterface::deinitExifData()
-{
-    ALOGD("Clearing EXIF data");
-    memset(mExifData, 0, sizeof(exif_tags_info_t) * MAX_EXIF_TABLE_ENTRIES);
-    mExifTableNumEntries = 0;
-}
-
-void QCameraHardwareInterface::addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
-                        uint32_t count, uint8_t copy, void *data) {
-
-    if(mExifTableNumEntries >= MAX_EXIF_TABLE_ENTRIES) {
-        ALOGE("%s: Number of entries exceeded limit", __func__);
-        return;
-    }
-    int index = mExifTableNumEntries;
-    mExifData[index].tag_id = tagid;
-    mExifData[index].tag_entry.type = type;
-    mExifData[index].tag_entry.count = count;
-    mExifData[index].tag_entry.copy = copy;
-    if((type == EXIF_RATIONAL) && (count > 1))
-        mExifData[index].tag_entry.data._rats = (rat_t *)data;
-    if((type == EXIF_RATIONAL) && (count == 1))
-        mExifData[index].tag_entry.data._rat = *(rat_t *)data;
-    else if(type == EXIF_ASCII)
-        mExifData[index].tag_entry.data._ascii = (char *)data;
-    else if(type == EXIF_BYTE)
-        mExifData[index].tag_entry.data._byte = *(uint8_t *)data;
-    else if((type == EXIF_SHORT) && (count > 1))
-        mExifData[index].tag_entry.data._shorts = (uint16_t *)data;
-    else if((type == EXIF_SHORT) && (count == 1))
-        mExifData[index].tag_entry.data._short = *(uint16_t *)data;
-    // Increase number of entries
-    mExifTableNumEntries++;
-}
-
-rat_t getRational(int num, int denom)
-{
-    rat_t temp = {num, denom};
-    return temp;
-}
-
-void QCameraHardwareInterface::initExifData(){
-    if(mExifValues.dateTime) {
-        addExifTag(EXIFTAGID_EXIF_DATE_TIME_ORIGINAL, EXIF_ASCII,
-                  20, 1, (void *)mExifValues.dateTime);
-    }
-    addExifTag(EXIFTAGID_FOCAL_LENGTH, EXIF_RATIONAL, 1, 1, (void *)&(mExifValues.focalLength));
-    addExifTag(EXIFTAGID_ISO_SPEED_RATING,EXIF_SHORT,1,1,(void *)&(mExifValues.isoSpeed));
-
-    if(mExifValues.mGpsProcess) {
-        addExifTag(EXIFTAGID_GPS_PROCESSINGMETHOD, EXIF_ASCII,
-           EXIF_ASCII_PREFIX_SIZE + strlen(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE) + 1,
-           1, (void *)mExifValues.gpsProcessingMethod);
-    }
-
-    if(mExifValues.mLatitude) {
-        addExifTag(EXIFTAGID_GPS_LATITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.latitude);
-
-        if(mExifValues.latRef) {
-            addExifTag(EXIFTAGID_GPS_LATITUDE_REF, EXIF_ASCII, 2,
-                                    1, (void *)mExifValues.latRef);
-        }
-    }
-
-    if(mExifValues.mLongitude) {
-        addExifTag(EXIFTAGID_GPS_LONGITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.longitude);
-
-        if(mExifValues.lonRef) {
-            addExifTag(EXIFTAGID_GPS_LONGITUDE_REF, EXIF_ASCII, 2,
-                                1, (void *)mExifValues.lonRef);
-        }
-    }
-
-    if(mExifValues.mAltitude) {
-        addExifTag(EXIFTAGID_GPS_ALTITUDE, EXIF_RATIONAL, 1,
-                    1, (void *)&(mExifValues.altitude));
-
-        addExifTag(EXIFTAGID_GPS_ALTITUDE_REF, EXIF_BYTE, 1, 1, (void *)&mExifValues.mAltitude_ref);
-    }
-
-    if(mExifValues.mTimeStamp) {
-        time_t unixTime;
-        struct tm *UTCTimestamp;
-
-        unixTime = (time_t)mExifValues.mGPSTimestamp;
-        UTCTimestamp = gmtime(&unixTime);
-
-        strftime(mExifValues.gpsDateStamp, sizeof(mExifValues.gpsDateStamp), "%Y:%m:%d", UTCTimestamp);
-        addExifTag(EXIFTAGID_GPS_DATESTAMP, EXIF_ASCII,
-                          strlen(mExifValues.gpsDateStamp)+1 , 1, (void *)mExifValues.gpsDateStamp);
-
-        mExifValues.gpsTimeStamp[0] = getRational(UTCTimestamp->tm_hour, 1);
-        mExifValues.gpsTimeStamp[1] = getRational(UTCTimestamp->tm_min, 1);
-        mExifValues.gpsTimeStamp[2] = getRational(UTCTimestamp->tm_sec, 1);
-
-        addExifTag(EXIFTAGID_GPS_TIMESTAMP, EXIF_RATIONAL,
-                  3, 1, (void *)mExifValues.gpsTimeStamp);
-        ALOGE("EXIFTAGID_GPS_TIMESTAMP set");
-    }
-
-}
-
-//Add all exif tags in this function
-void QCameraHardwareInterface::setExifTags()
-{
-    const char *str;
-
-    //set TimeStamp
-    str = mParameters.get(QCameraParameters::KEY_QC_EXIF_DATETIME);
-    if(str != NULL) {
-      strncpy(mExifValues.dateTime, str, 19);
-      mExifValues.dateTime[19] = '\0';
-    }
-
-    //Set focal length
-    int focalLengthValue = (int) (mParameters.getFloat(
-                QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION);
-
-    mExifValues.focalLength = getRational(focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION);
-
-    //Set ISO Speed
-    mExifValues.isoSpeed = getISOSpeedValue();
-
-    //get time and date from system
-    time_t rawtime;
-    struct tm * timeinfo;
-    time(&rawtime);
-    timeinfo = localtime (&rawtime);
-    //Write datetime according to EXIF Spec
-    //"YYYY:MM:DD HH:MM:SS" (20 chars including \0)
-    snprintf(mExifValues.dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d",
-                timeinfo->tm_year + 1900, timeinfo->tm_mon + 1,
-                timeinfo->tm_mday, timeinfo->tm_hour,
-                timeinfo->tm_min, timeinfo->tm_sec);
-
-    //set gps tags
-    setExifTagsGPS();
-}
-
-void QCameraHardwareInterface::setExifTagsGPS()
-{
-    const char *str = NULL;
-
-    //Set GPS processing method
-    str = mParameters.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
-    if(str != NULL) {
-       memcpy(mExifValues.gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE);
-       strncpy(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str,
-           GPS_PROCESSING_METHOD_SIZE - 1);
-       mExifValues.gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE + GPS_PROCESSING_METHOD_SIZE-1] = '\0';
-       ALOGE("EXIFTAGID_GPS_PROCESSINGMETHOD = %s %s", mExifValues.gpsProcessingMethod,
-                                                    mExifValues.gpsProcessingMethod+8);
-       mExifValues.mGpsProcess  = true;
-    }else{
-        mExifValues.mGpsProcess = false;
-    }
-    str = NULL;
-
-    //Set Latitude
-    str = mParameters.get(QCameraParameters::KEY_GPS_LATITUDE);
-    if(str != NULL) {
-        parseGPSCoordinate(str, mExifValues.latitude);
-        ALOGE("EXIFTAGID_GPS_LATITUDE = %s", str);
-
-        //set Latitude Ref
-        float latitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LATITUDE);
-        if(latitudeValue < 0.0f) {
-            mExifValues.latRef[0] = 'S';
-        } else {
-            mExifValues.latRef[0] = 'N';
-        }
-        mExifValues.latRef[1] = '\0';
-        mExifValues.mLatitude = true;
-        mParameters.set(QCameraParameters::KEY_QC_GPS_LATITUDE_REF,mExifValues.latRef);
-        ALOGE("EXIFTAGID_GPS_LATITUDE_REF = %s", mExifValues.latRef);
-    }else{
-        mExifValues.mLatitude = false;
-    }
-
-    //set Longitude
-    str = NULL;
-    str = mParameters.get(QCameraParameters::KEY_GPS_LONGITUDE);
-    if(str != NULL) {
-        parseGPSCoordinate(str, mExifValues.longitude);
-        ALOGE("EXIFTAGID_GPS_LONGITUDE = %s", str);
-
-        //set Longitude Ref
-        float longitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LONGITUDE);
-        if(longitudeValue < 0.0f) {
-            mExifValues.lonRef[0] = 'W';
-        } else {
-            mExifValues.lonRef[0] = 'E';
-        }
-        mExifValues.lonRef[1] = '\0';
-        mExifValues.mLongitude = true;
-        ALOGE("EXIFTAGID_GPS_LONGITUDE_REF = %s", mExifValues.lonRef);
-        mParameters.set(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF, mExifValues.lonRef);
-    }else{
-        mExifValues.mLongitude = false;
-    }
-
-    //set Altitude
-    str = mParameters.get(QCameraParameters::KEY_GPS_ALTITUDE);
-    if(str != NULL) {
-        double value = atof(str);
-        mExifValues.mAltitude_ref = 0;
-        if(value < 0){
-            mExifValues.mAltitude_ref = 1;
-            value = -value;
-        }
-        mExifValues.altitude = getRational(value*1000, 1000);
-        mExifValues.mAltitude = true;
-        //set AltitudeRef
-        mParameters.set(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF, mExifValues.mAltitude_ref);
-        ALOGE("EXIFTAGID_GPS_ALTITUDE = %f", value);
-    }else{
-        mExifValues.mAltitude = false;
-    }
-
-    //set Gps TimeStamp
-    str = NULL;
-    str = mParameters.get(QCameraParameters::KEY_GPS_TIMESTAMP);
-    if(str != NULL) {
-      mExifValues.mTimeStamp = true;
-      mExifValues.mGPSTimestamp = atol(str);
-    }else{
-         mExifValues.mTimeStamp = false;
-    }
-}
-
-//latlonString is string formatted coordinate
-//coord is rat_t[3]
-void QCameraHardwareInterface::parseGPSCoordinate(const char *latlonString, rat_t* coord)
-{
-    if(coord == NULL) {
-        ALOGE("%s: error, invalid argument coord == NULL", __func__);
-        return;
-    }
-    float degF = fabs(atof(latlonString));
-    float minF = (degF- (int) degF) * 60;
-    float secF = (minF - (int) minF) * 60;
-
-    coord[0] = getRational((int) degF, 1);
-    coord[1] = getRational((int) minF, 1);
-    coord[2] = getRational((int) (secF * 10000), 10000);
-}
-
-bool QCameraHardwareInterface::isLowPowerCamcorder() {
-
-    if (mPowerMode == LOW_POWER)
-        return true;
-
-    if(mHFRLevel > 1) /* hard code the value now. Need to move tgtcommon to camear.h */
-      return true;
-
-      return false;
-}
-
-status_t QCameraHardwareInterface::setNoDisplayMode(const QCameraParameters& params)
-{
-  char prop[PROPERTY_VALUE_MAX];
-  memset(prop, 0, sizeof(prop));
-  property_get("persist.camera.nodisplay", prop, "0");
-  int prop_val = atoi(prop);
-
-  if (prop_val == 0) {
-    const char *str_val  = params.get("no-display-mode");
-    if(str_val && strlen(str_val) > 0) {
-      mNoDisplayMode = atoi(str_val);
-    } else {
-      mNoDisplayMode = 0;
-    }
-    ALOGD("Param mNoDisplayMode =%d", mNoDisplayMode);
-  } else {
-    mNoDisplayMode = prop_val;
-    ALOGD("prop mNoDisplayMode =%d", mNoDisplayMode);
-  }
-  return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRDIMode(const QCameraParameters& params)
-{
-    char prop[PROPERTY_VALUE_MAX];
-    memset(prop, 0, sizeof(prop));
-    property_get("persist.camera.rdi.mode", prop, "0");
-    int prop_val = atoi(prop);
-    rdiMode = prop_val;
-    ALOGE("RDI Mode = %d",rdiMode);
-    return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setDimension()
-{
-    ALOGV("%s: E", __func__);
-    cam_ctrl_dimension_t dim;
-    int ret = MM_CAMERA_OK;
-    int postviewWidth,postviewHeight;
-
-    memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
-    ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DIMENSION,&dim);
-
-    if (MM_CAMERA_OK != ret) {
-      ALOGE("%s: error - can't get preview dimension!", __func__);
-      ALOGE("%s: X", __func__);
-      return BAD_VALUE;
-    }
-
-    getPreviewSize(&mPreviewWidth,  &mPreviewHeight);
-    dim.display_width  = mPreviewWidth;
-    dim.display_height = mPreviewHeight;
-
-    cam_format_t value = getPreviewFormat();
-    if(value != NOT_FOUND && value != dim.prev_format ) {
-        //Setting to Parameter requested by the Upper layer
-        dim.prev_format = value;
-    }else{
-        //Setting to default Format.
-        dim.prev_format = CAMERA_YUV_420_NV21;
-    }
-    dim.prev_padding_format =  getPreviewPadding( );
-
-    getVideoSize(&videoWidth,  &videoHeight);
-    dim.enc_format = CAMERA_YUV_420_NV12;
-    dim.orig_video_width = videoWidth;
-    dim.orig_video_height = videoHeight;
-    dim.video_width = videoWidth;
-    dim.video_height = videoHeight;
-    dim.video_chroma_width = videoWidth;
-    dim.video_chroma_height  = videoHeight;
-
-    getPictureSize(&mPictureWidth, &mPictureHeight);
-    dim.picture_width = mPictureWidth;
-    dim.picture_height  = mPictureHeight;
-
-    getThumbnailSize(&thumbnailWidth,&thumbnailHeight);
-    dim.ui_thumbnail_width = thumbnailWidth;
-    dim.ui_thumbnail_height = thumbnailHeight;
-
-    /* Reset the Main image and thumbnail formats here,
-     * since they might have been changed when video size
-     * livesnapshot was taken. */
-    if (mSnapshotFormat == 1)
-      dim.main_img_format = CAMERA_YUV_422_NV61;
-    else
-      dim.main_img_format = CAMERA_YUV_420_NV21;
-    dim.thumb_format = CAMERA_YUV_420_NV21;
-
-    //RDI Format
-    dim.rdi0_format = CAMERA_BAYER_SBGGR10;
-
-    /*Code to handle different limitations*/
-    if (mRecordingHint && mFullLiveshotEnabled){
-        dim.ui_thumbnail_height = dim.display_height;
-        dim.ui_thumbnail_width = dim.display_width;
-    }
-    if (isZSLMode()){
-        postviewWidth = mPreviewWidth;
-        postviewHeight = mPreviewHeight;
-    } else {
-        postviewWidth = thumbnailWidth;
-        postviewHeight = thumbnailHeight;
-    }
-    if (mPictureWidth < postviewWidth || mPictureHeight < postviewHeight)
-    {
-        //Changes to handle VFE limitation when primary o/p is main image
-        dim.picture_width = postviewWidth;
-        dim.picture_height = postviewHeight;
-    }
-
-    //VFE output1 shouldn't be greater than VFE output2.
-    if( (dim.display_width > dim.video_width) ||
-        (dim.display_height > dim.video_height)) {
-        //Set preview sizes as record sizes.
-        dim.display_width = dim.video_width;
-        dim.display_height = dim.video_height;
-    }
-    if (mRecordingHint && mFullLiveshotEnabled){
-        if( (dim.picture_width < dim.video_width) ||
-            (dim.picture_height < dim.video_height)) {
-            dim.picture_width = dim.video_width;
-            dim.picture_height = dim.video_height;
-        }
-    }
-
-    if(mIs3DModeOn == true) {
-        /* As preview and video frames are same in 3D mode,
-         * preview size should be same as video size. This
-         * cahnge is needed to take of video resolutions
-         * like 720P and 1080p where the application can
-         * request different preview sizes like 768x432
-         */
-        ALOGE("3D mod is on");
-        dim.display_width = dim.video_width;
-        dim.display_height = dim.video_height;
-    }
-
-    /*End of limitation code*/
-
-    ret = mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DIMENSION,&dim);
-    if (MM_CAMERA_OK != ret) {
-      ALOGE("%s X: error - can't config preview parms!", __func__);
-      return BAD_VALUE;
-    }
-    if(mStreams[MM_CAMERA_PREVIEW]) {
-        mStreams[MM_CAMERA_PREVIEW]->mFormat = dim.prev_format;
-        mStreams[MM_CAMERA_PREVIEW]->mWidth = dim.display_width;
-        mStreams[MM_CAMERA_PREVIEW]->mHeight = dim.display_height;
-    }
-    if(mStreams[MM_CAMERA_VIDEO]) {
-        mStreams[MM_CAMERA_VIDEO]->mFormat = dim.enc_format;
-        mStreams[MM_CAMERA_VIDEO]->mWidth = dim.video_width;
-        mStreams[MM_CAMERA_VIDEO]->mHeight = dim.video_height;
-    }
-    if(mStreams[MM_CAMERA_SNAPSHOT_MAIN]) {
-        mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mFormat = dim.main_img_format;
-        if (!isRawSnapshot()) {
-                mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mWidth = dim.picture_width;
-                mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mHeight = dim.picture_height;
-        } else {
-            cam_frame_resolution_t raw_res;
-
-            /* the raw_picture_width in dimension is for RDI dump.
-             * here, raw snapshot size is from camif. */
-            memset(&raw_res, 0,  sizeof(raw_res));
-            raw_res.image_mode = MSM_V4L2_EXT_CAPTURE_MODE_RAW;
-            raw_res.padding_format = CAMERA_PAD_TO_WORD;
-            ret = mCameraHandle->ops->get_parm(
-               mCameraHandle->camera_handle,
-               MM_CAMERA_PARM_FRAME_RESOLUTION,&raw_res);
-            if (MM_CAMERA_OK != ret) {
-              ALOGE("%s error - config raw snapshot parms, rc = %d",
-                    __func__, ret);
-              return BAD_VALUE;
-            }
-            mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mWidth = raw_res.width;
-            mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mHeight = raw_res.height;
-            mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mFormat = raw_res.format;
-        }
-    }
-    if(mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]) {
-        mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mFormat = dim.thumb_format;
-        mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mWidth = dim.ui_thumbnail_width;
-        mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mHeight = dim.ui_thumbnail_height;
-    }
-
-    memcpy(&mDimension, &dim, sizeof(mDimension));
-    ALOGV("%s: X", __func__);
-    return NO_ERROR;
-}
-}; /*namespace android */
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Preview.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Preview.cpp
deleted file mode 100755
index a63c062..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Preview.cpp
+++ /dev/null
@@ -1,1007 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define LOG_TAG "QCameraHWI_Preview"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-#include <genlock.h>
-#include <gralloc_priv.h>
-
-#define UNLIKELY(exp) __builtin_expect(!!(exp), 0)
-
-/* QCameraHWI_Preview class implementation goes here*/
-/* following code implement the preview mode's image capture & display logic of this class*/
-
-namespace android {
-
-status_t QCameraStream_preview::getBufferFromSurface() {
-    int err = 0;
-    status_t ret = NO_ERROR;
-    int gralloc_usage;
-    struct ion_fd_data ion_info_fd;
-    preview_stream_ops_t *previewWindow = mHalCamCtrl->mPreviewWindow;
-
-    ALOGI(" %s : E ", __FUNCTION__);
-
-    if( previewWindow == NULL) {
-        ALOGE("%s: PreviewWindow = NULL", __func__);
-            return INVALID_OPERATION;
-    }
-
-    mHalCamCtrl->mPreviewMemoryLock.lock();
-    mHalCamCtrl->mPreviewMemory.buffer_count = mNumBuffers;
-    err = previewWindow->set_buffer_count(previewWindow, mHalCamCtrl->mPreviewMemory.buffer_count );
-    if (err != 0) {
-         ALOGE("set_buffer_count failed: %s (%d)",
-                    strerror(-err), -err);
-         ret = UNKNOWN_ERROR;
-         goto end;
-    }
-
-    err = previewWindow->set_buffers_geometry(previewWindow, mWidth, mHeight,
-                                              mHalCamCtrl->getPreviewFormatInfo().Hal_format);
-    if (err != 0) {
-         ALOGE("set_buffers_geometry failed: %s (%d)",
-                    strerror(-err), -err);
-         ret = UNKNOWN_ERROR;
-         goto end;
-    }
-
-    ret = p_mm_ops->ops->get_parm(mCameraHandle, MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, &mVFEOutputs);
-    if(ret != MM_CAMERA_OK) {
-        ALOGE("get parm MM_CAMERA_PARM_VFE_OUTPUT_ENABLE  failed");
-        ret = BAD_VALUE;
-        goto end;
-    }
-
-    //as software encoder is used to encode 720p, to enhance the performance
-    //cashed pmem is used here
-    if(mVFEOutputs == 1)
-        gralloc_usage = CAMERA_GRALLOC_HEAP_ID | CAMERA_GRALLOC_FALLBACK_HEAP_ID;
-    else
-        gralloc_usage = CAMERA_GRALLOC_HEAP_ID | CAMERA_GRALLOC_FALLBACK_HEAP_ID |
-                    CAMERA_GRALLOC_CACHING_ID;
-    err = previewWindow->set_usage(previewWindow, gralloc_usage);
-    if(err != 0) {
-    /* set_usage error out */
-        ALOGE("%s: set_usage rc = %d", __func__, err);
-        ret = UNKNOWN_ERROR;
-        goto end;
-    }
-    ret = p_mm_ops->ops->get_parm(mCameraHandle, MM_CAMERA_PARM_HFR_FRAME_SKIP, &mHFRFrameSkip);
-    if(ret != MM_CAMERA_OK) {
-        ALOGE("get parm MM_CAMERA_PARM_HFR_FRAME_SKIP  failed");
-        ret = BAD_VALUE;
-        goto end;
-    }
-	for (int cnt = 0; cnt < mHalCamCtrl->mPreviewMemory.buffer_count; cnt++) {
-		int stride;
-		err = previewWindow->dequeue_buffer(previewWindow,
-										&mHalCamCtrl->mPreviewMemory.buffer_handle[cnt],
-										&mHalCamCtrl->mPreviewMemory.stride[cnt]);
-		if(!err) {
-            ALOGV("%s: dequeue buf hdl =%p", __func__, *mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
-            err = previewWindow->lock_buffer(previewWindow,
-                                       mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
-            // lock the buffer using genlock
-            ALOGV("%s: camera call genlock_lock, hdl=%p",
-                          __FUNCTION__, (*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]));
-            if (GENLOCK_NO_ERROR != genlock_lock_buffer((native_handle_t *)(*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]),
-                                                      GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT)) {
-                ALOGE("%s: genlock_lock_buffer(WRITE) failed", __func__);
-                mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_UNLOCKED;
-            } else {
-                ALOGV("%s: genlock_lock_buffer hdl =%p", __func__, *mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
-                mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_LOCKED;
-            }
-		} else {
-            mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_NOT_OWNED;
-            ALOGE("%s: dequeue_buffer idx = %d err = %d", __func__, cnt, err);
-        }
-
-		ALOGV("%s: dequeue buf: %p\n", __func__, mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
-
-		if(err != 0) {
-            ALOGE("%s: dequeue_buffer failed: %s (%d)", __func__,
-                    strerror(-err), -err);
-            ret = UNKNOWN_ERROR;
-			for(int i = 0; i < cnt; i++) {
-                if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[i]) {
-                      ALOGD("%s: camera call genlock_unlock", __func__);
-                     if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t *)
-                                                  (*(mHalCamCtrl->mPreviewMemory.buffer_handle[i])))) {
-                        ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__, (*(mHalCamCtrl->mPreviewMemory.buffer_handle[i])) );
-                     } else {
-                       mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_UNLOCKED;
-                     }
-                }
-                if( mHalCamCtrl->mPreviewMemory.local_flag[i] != BUFFER_NOT_OWNED) {
-                  err = previewWindow->cancel_buffer(previewWindow,
-                                          mHalCamCtrl->mPreviewMemory.buffer_handle[i]);
-                }
-                mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_NOT_OWNED;
-                ALOGD("%s: cancel_buffer: hdl =%p", __func__,  (*mHalCamCtrl->mPreviewMemory.buffer_handle[i]));
-				mHalCamCtrl->mPreviewMemory.buffer_handle[i] = NULL;
-			}
-            memset(&mHalCamCtrl->mPreviewMemory, 0, sizeof(mHalCamCtrl->mPreviewMemory));
-			goto end;
-		}
-
-		mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt] =
-		    (struct private_handle_t *)(*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
-#ifdef USE_ION
-        mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd = open("/dev/ion", O_RDONLY);
-        if (mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd < 0) {
-            ALOGE("%s: failed: could not open ion device\n", __func__);
-        } else {
-            memset(&ion_info_fd, 0, sizeof(ion_info_fd));
-            ion_info_fd.fd = mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd;
-            if (ioctl(mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd,
-                      ION_IOC_IMPORT, &ion_info_fd) < 0) {
-                ALOGE("ION import failed\n");
-            }
-        }
-#endif
-		mHalCamCtrl->mPreviewMemory.camera_memory[cnt] =
-		    mHalCamCtrl->mGetMemory(mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd,
-                                    mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->size,
-                                    1,
-                                    (void *)this);
-		ALOGD("%s: idx = %d, fd = %d, size = %d, offset = %d", __func__,
-              cnt, mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd,
-              mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->size,
-              mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->offset);
-
-        mHalCamCtrl->mPreviewMemory.mem_info[cnt].fd =
-            mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd;
-        mHalCamCtrl->mPreviewMemory.mem_info[cnt].size =
-            mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->size;
-        mHalCamCtrl->mPreviewMemory.mem_info[cnt].handle = ion_info_fd.handle;
-    }
-
-    memset(&mHalCamCtrl->mMetadata, 0, sizeof(mHalCamCtrl->mMetadata));
-    memset(mHalCamCtrl->mFace, 0, sizeof(mHalCamCtrl->mFace));
-
-end:
-    mHalCamCtrl->mPreviewMemoryLock.unlock();
-
-    ALOGI(" %s : X ",__func__);
-    return ret;
-}
-
-status_t QCameraStream_preview::putBufferToSurface() {
-    int err = 0;
-    status_t ret = NO_ERROR;
-
-    ALOGI(" %s : E ", __FUNCTION__);
-
-    mHalCamCtrl->mPreviewMemoryLock.lock();
-	for (int cnt = 0; cnt < mHalCamCtrl->mPreviewMemory.buffer_count; cnt++) {
-        mHalCamCtrl->mPreviewMemory.camera_memory[cnt]->release(mHalCamCtrl->mPreviewMemory.camera_memory[cnt]);
-#ifdef USE_ION
-        struct ion_handle_data ion_handle;
-        memset(&ion_handle, 0, sizeof(ion_handle));
-        ion_handle.handle = mHalCamCtrl->mPreviewMemory.mem_info[cnt].handle;
-        if (ioctl(mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) {
-            ALOGE("%s: ion free failed\n", __func__);
-        }
-        close(mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd);
-#endif
-        if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[cnt]) {
-                ALOGD("%s: camera call genlock_unlock", __FUNCTION__);
-	      if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t *)
-                                                    (*(mHalCamCtrl->mPreviewMemory.buffer_handle[cnt])))) {
-            ALOGE("%s: genlock_unlock_buffer failed, handle =%p", __FUNCTION__, (*(mHalCamCtrl->mPreviewMemory.buffer_handle[cnt])));
-              continue;
-          } else {
-
-            ALOGD("%s: genlock_unlock_buffer, handle =%p", __FUNCTION__, (*(mHalCamCtrl->mPreviewMemory.buffer_handle[cnt])));
-              mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_UNLOCKED;
-          }
-        }
-        if( mHalCamCtrl->mPreviewMemory.local_flag[cnt] != BUFFER_NOT_OWNED) {
-            if (mHalCamCtrl->mPreviewWindow) {
-                err = mHalCamCtrl->mPreviewWindow->cancel_buffer(mHalCamCtrl->mPreviewWindow,
-                                                                 mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
-                ALOGD("%s: cancel_buffer: hdl =%p", __func__,  (*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]));
-            } else {
-                ALOGE("%s: Preview window is NULL, cannot cancel_buffer: hdl =%p",
-                      __func__,  (*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]));
-            }
-        }
-        mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_NOT_OWNED;
-		ALOGD(" put buffer %d successfully", cnt);
-	}
-    mHalCamCtrl->mPreviewMemoryLock.unlock();
-	memset(&mHalCamCtrl->mPreviewMemory, 0, sizeof(mHalCamCtrl->mPreviewMemory));
-    ALOGI(" %s : X ",__FUNCTION__);
-    return NO_ERROR;
-}
-
-status_t QCameraStream_preview::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
-    int format = 0;
-    status_t ret = NO_ERROR;
-    int numMinUndequeuedBufs;
-    int err = 0;
-
-    ALOGI(" %s : E ", __FUNCTION__);
-    if (mHalCamCtrl->isNoDisplayMode()) {
-        mNumBuffers = PREVIEW_BUFFER_COUNT;
-        if(mHalCamCtrl->isZSLMode()) {
-            if(mNumBuffers < mHalCamCtrl->getZSLQueueDepth() + 3) {
-                mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
-            }
-        }
-    } else {
-        if( mHalCamCtrl->mPreviewWindow == NULL) {
-            ALOGE("%s: PreviewWindow = NULL", __func__);
-            return INVALID_OPERATION;
-        }
-        numMinUndequeuedBufs = 0;
-        if(mHalCamCtrl->mPreviewWindow->get_min_undequeued_buffer_count) {
-            err = mHalCamCtrl->mPreviewWindow->get_min_undequeued_buffer_count(
-                            mHalCamCtrl->mPreviewWindow, &numMinUndequeuedBufs);
-            if (err != 0) {
-                ALOGE("get_min_undequeued_buffer_count  failed: %s (%d)",
-                      strerror(-err), -err);
-                ret = UNKNOWN_ERROR;
-                goto end;
-            }
-        }
-        mNumBuffers = PREVIEW_BUFFER_COUNT + numMinUndequeuedBufs;
-        if(mHalCamCtrl->isZSLMode()) {
-          if(mHalCamCtrl->getZSLQueueDepth() > numMinUndequeuedBufs)
-            mNumBuffers += mHalCamCtrl->getZSLQueueDepth() - numMinUndequeuedBufs;
-        }
-    }
-    ret = QCameraStream::initStream(no_cb_needed, stream_on);
-end:
-    ALOGI(" %s : X ", __FUNCTION__);
-    return ret;
-}
-
-
-status_t  QCameraStream_preview::getBufferNoDisplay( )
-{
-    status_t ret = NO_ERROR;
-    uint32_t planes[VIDEO_MAX_PLANES];
-
-    ALOGI("%s : E ", __FUNCTION__);
-
-    mHalCamCtrl->mPreviewMemoryLock.lock();
-    memset(mDisplayBuf, 0, sizeof(mDisplayBuf));
-    if (mHalCamCtrl->initHeapMem(&mHalCamCtrl->mNoDispPreviewMemory,
-                                 mNumBuffers,
-                                 mFrameOffsetInfo.frame_len,
-                                 MSM_PMEM_MAINIMG,
-                                 &mFrameOffsetInfo,
-                                 mDisplayBuf) < 0) {
-        ret = NO_MEMORY;
-        goto end;
-    }
-
-    memset(&mHalCamCtrl->mMetadata, 0, sizeof(mHalCamCtrl->mMetadata));
-    memset(mHalCamCtrl->mFace, 0, sizeof(mHalCamCtrl->mFace));
-
-    ALOGI(" %s : X ",__FUNCTION__);
-end:
-    mHalCamCtrl->mPreviewMemoryLock.unlock();
-    return ret;
-}
-
-status_t QCameraStream_preview::freeBufferNoDisplay()
-{
-    ALOGI(" %s : E ", __FUNCTION__);
-    mHalCamCtrl->mPreviewMemoryLock.lock();
-    mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mNoDispPreviewMemory);
-    memset(&mHalCamCtrl->mNoDispPreviewMemory, 0, sizeof(mHalCamCtrl->mNoDispPreviewMemory));
-    mHalCamCtrl->mPreviewMemoryLock.unlock();
-    ALOGI(" %s : X ",__FUNCTION__);
-    return NO_ERROR;
-}
-
-void QCameraStream_preview::notifyROIEvent(fd_roi_t roi)
-{
-    switch (roi.type) {
-    case FD_ROI_TYPE_HEADER:
-        {
-            mDisplayLock.lock();
-            mNumFDRcvd = 0;
-            memset(mHalCamCtrl->mFace, 0, sizeof(mHalCamCtrl->mFace));
-            mHalCamCtrl->mMetadata.faces = mHalCamCtrl->mFace;
-            mHalCamCtrl->mMetadata.number_of_faces = roi.d.hdr.num_face_detected;
-            if(mHalCamCtrl->mMetadata.number_of_faces > MAX_ROI)
-              mHalCamCtrl->mMetadata.number_of_faces = MAX_ROI;
-            mDisplayLock.unlock();
-
-            if (mHalCamCtrl->mMetadata.number_of_faces == 0) {
-                // Clear previous faces
-                if (mHalCamCtrl->mDataCb && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA)){
-                    ALOGE("%s: Face detection RIO callback", __func__);
-                    mHalCamCtrl->mDataCb(CAMERA_MSG_PREVIEW_METADATA, NULL, 0,
-                        &mHalCamCtrl->mMetadata, mHalCamCtrl->mCallbackCookie);
-                }
-            }
-        }
-        break;
-    case FD_ROI_TYPE_DATA:
-        {
-            mDisplayLock.lock();
-            int idx = roi.d.data.idx;
-            if (idx >= mHalCamCtrl->mMetadata.number_of_faces) {
-                mDisplayLock.unlock();
-                ALOGE("%s: idx %d out of boundary %d",
-                      __func__, idx, mHalCamCtrl->mMetadata.number_of_faces);
-                break;
-            }
-
-            mHalCamCtrl->mFace[idx].id = roi.d.data.face.id;
-            mHalCamCtrl->mFace[idx].score = roi.d.data.face.score;
-
-            // top
-            mHalCamCtrl->mFace[idx].rect[0] =
-               roi.d.data.face.face_boundary.x*2000/mHalCamCtrl->mDimension.display_width - 1000;
-            //right
-            mHalCamCtrl->mFace[idx].rect[1] =
-               roi.d.data.face.face_boundary.y*2000/mHalCamCtrl->mDimension.display_height - 1000;
-            //bottom
-            mHalCamCtrl->mFace[idx].rect[2] =  mHalCamCtrl->mFace[idx].rect[0] +
-               roi.d.data.face.face_boundary.dx*2000/mHalCamCtrl->mDimension.display_width;
-            //left
-            mHalCamCtrl->mFace[idx].rect[3] = mHalCamCtrl->mFace[idx].rect[1] +
-               roi.d.data.face.face_boundary.dy*2000/mHalCamCtrl->mDimension.display_height;
-
-            // Center of left eye
-            mHalCamCtrl->mFace[idx].left_eye[0] =
-              roi.d.data.face.left_eye_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000;
-            mHalCamCtrl->mFace[idx].left_eye[1] =
-              roi.d.data.face.left_eye_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000;
-
-            // Center of right eye
-            mHalCamCtrl->mFace[idx].right_eye[0] =
-              roi.d.data.face.right_eye_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000;
-            mHalCamCtrl->mFace[idx].right_eye[1] =
-              roi.d.data.face.right_eye_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000;
-
-            // Center of mouth
-            mHalCamCtrl->mFace[idx].mouth[0] =
-              roi.d.data.face.mouth_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000;
-            mHalCamCtrl->mFace[idx].mouth[1] =
-              roi.d.data.face.mouth_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000;
-
-            mHalCamCtrl->mFace[idx].smile_degree = roi.d.data.face.smile_degree;
-            mHalCamCtrl->mFace[idx].smile_score = roi.d.data.face.smile_confidence;
-            mHalCamCtrl->mFace[idx].blink_detected = roi.d.data.face.blink_detected;
-            mHalCamCtrl->mFace[idx].face_recognised = roi.d.data.face.is_face_recognised;
-            mHalCamCtrl->mFace[idx].gaze_angle = roi.d.data.face.gaze_angle;
-
-            /* newly added */
-            // upscale by 2 to recover from demaen downscaling
-            mHalCamCtrl->mFace[idx].updown_dir = roi.d.data.face.updown_dir * 2;
-            mHalCamCtrl->mFace[idx].leftright_dir = roi.d.data.face.leftright_dir * 2;
-            mHalCamCtrl->mFace[idx].roll_dir = roi.d.data.face.roll_dir * 2;
-
-            mHalCamCtrl->mFace[idx].leye_blink = roi.d.data.face.left_blink;
-            mHalCamCtrl->mFace[idx].reye_blink = roi.d.data.face.right_blink;
-            mHalCamCtrl->mFace[idx].left_right_gaze = roi.d.data.face.left_right_gaze;
-            mHalCamCtrl->mFace[idx].top_bottom_gaze = roi.d.data.face.top_bottom_gaze;
-            ALOGE("%s: Face(%d, %d, %d, %d), leftEye(%d, %d), rightEye(%d, %d), mouth(%d, %d), smile(%d, %d), face_recg(%d)", __func__,
-               mHalCamCtrl->mFace[idx].rect[0],  mHalCamCtrl->mFace[idx].rect[1],
-               mHalCamCtrl->mFace[idx].rect[2],  mHalCamCtrl->mFace[idx].rect[3],
-               mHalCamCtrl->mFace[idx].left_eye[0], mHalCamCtrl->mFace[idx].left_eye[1],
-               mHalCamCtrl->mFace[idx].right_eye[0], mHalCamCtrl->mFace[idx].right_eye[1],
-               mHalCamCtrl->mFace[idx].mouth[0], mHalCamCtrl->mFace[idx].mouth[1],
-               mHalCamCtrl->mFace[idx].smile_degree, mHalCamCtrl->mFace[idx].smile_score,
-               mHalCamCtrl->mFace[idx].face_recognised);
-            ALOGE("%s: gaze(%d, %d, %d), updown(%d), leftright(%d), roll(%d), blink(%d, %d, %d)", __func__,
-               mHalCamCtrl->mFace[idx].gaze_angle,  mHalCamCtrl->mFace[idx].left_right_gaze,
-               mHalCamCtrl->mFace[idx].top_bottom_gaze,  mHalCamCtrl->mFace[idx].updown_dir,
-               mHalCamCtrl->mFace[idx].leftright_dir, mHalCamCtrl->mFace[idx].roll_dir,
-               mHalCamCtrl->mFace[idx].blink_detected,
-               mHalCamCtrl->mFace[idx].leye_blink, mHalCamCtrl->mFace[idx].reye_blink);
-
-             mNumFDRcvd++;
-             mDisplayLock.unlock();
-
-             if (mNumFDRcvd == mHalCamCtrl->mMetadata.number_of_faces) {
-                 if (mHalCamCtrl->mDataCb && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA)){
-                     ALOGE("%s: Face detection RIO callback with %d faces detected (score=%d)", __func__, mNumFDRcvd, mHalCamCtrl->mFace[idx].score);
-                     mHalCamCtrl->mDataCb(CAMERA_MSG_PREVIEW_METADATA, NULL,
-                                          0, &mHalCamCtrl->mMetadata, mHalCamCtrl->mCallbackCookie);
-                 }
-             }
-        }
-        break;
-    }
-}
-
-status_t QCameraStream_preview::initDisplayBuffers()
-{
-  status_t ret = NO_ERROR;
-  uint8_t num_planes = mFrameOffsetInfo.num_planes;
-  uint32_t planes[VIDEO_MAX_PLANES];
-
-  ALOGI("%s:BEGIN",__func__);
-  memset(&mHalCamCtrl->mMetadata, 0, sizeof(camera_frame_metadata_t));
-  mHalCamCtrl->mPreviewMemoryLock.lock();
-  memset(&mHalCamCtrl->mPreviewMemory, 0, sizeof(mHalCamCtrl->mPreviewMemory));
-  mHalCamCtrl->mPreviewMemoryLock.unlock();
-  memset(mNotifyBuffer, 0, sizeof(mNotifyBuffer));
-
-  ret = getBufferFromSurface();
-  if(ret != NO_ERROR) {
-    ALOGE("%s: cannot get memory from surface texture client, ret = %d", __func__, ret);
-    return ret;
-  }
-
-  /* set 4 buffers for display */
-  mHalCamCtrl->mPreviewMemoryLock.lock();
-  for(int i=0; i < num_planes; i++)
-      planes[i] = mFrameOffsetInfo.mp[i].len;
-  memset(mDisplayBuf, 0, sizeof(mm_camera_buf_def_t) * 2 * PREVIEW_BUFFER_COUNT);
-  /*allocate memory for the buffers*/
-  for(int i = 0; i < mNumBuffers; i++){
-	  if (mHalCamCtrl->mPreviewMemory.private_buffer_handle[i] == NULL)
-		  continue;
-	  mHalCamCtrl->mPreviewMemory.addr_offset[i] =
-	      mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->offset;
-    ALOGD("%s: idx = %d, fd = %d, size = %d, cbcr_offset = %d, y_offset = %d, "
-      "offset = %d, vaddr = 0x%lx", __func__, i, mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd,
-      mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->size,
-      planes[0], 0,
-      mHalCamCtrl->mPreviewMemory.addr_offset[i],
-      (long unsigned int)mHalCamCtrl->mPreviewMemory.camera_memory[i]->data);
-    mDisplayBuf[i].num_planes = num_planes;
-
-    /* Plane 0 needs to be set seperately. Set other planes
-     * in a loop. */
-    mDisplayBuf[i].planes[0].length = planes[0];
-    mDisplayBuf[i].planes[0].m.userptr = mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd;
-    mDisplayBuf[i].planes[0].data_offset = mFrameOffsetInfo.mp[0].offset;
-    mDisplayBuf[i].planes[0].reserved[0] =0;// mHalCamCtrl->mPreviewMemory.addr_offset[i]; //     mDisplayBuf.preview.buf.mp[i].frame_offset;
-    for (int j = 1; j < num_planes; j++) {
-      mDisplayBuf[i].planes[j].length = planes[j];
-      mDisplayBuf[i].planes[j].m.userptr = mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd;
-      mDisplayBuf[i].planes[j].data_offset = mFrameOffsetInfo.mp[j].offset;
-      mDisplayBuf[i].planes[j].reserved[0] =
-        mDisplayBuf[i].planes[j-1].reserved[0] +
-        mDisplayBuf[i].planes[j-1].length;
-    }
-
-    for (int j = 0; j < num_planes; j++)
-      ALOGD("Planes: %d length: %d userptr: %lu offset: %d\n", j,
-        mDisplayBuf[i].planes[j].length,
-        mDisplayBuf[i].planes[j].m.userptr,
-        mDisplayBuf[i].planes[j].reserved[0]);
-
-    mDisplayBuf[i].fd = mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd;
-    ALOGD("DEBUG2:Display buf[%d] fd:%d",i,mDisplayBuf[i].fd);
-    mDisplayBuf[i].frame_len = mFrameOffsetInfo.frame_len;
-    mDisplayBuf[i].buffer = (void *)mHalCamCtrl->mPreviewMemory.camera_memory[i]->data;
-    mDisplayBuf[i].mem_info = (void *)&mHalCamCtrl->mPreviewMemory.mem_info[i];
-  }/*end of for loop*/
-
- /* register the streaming buffers for the channel*/
-  mHalCamCtrl->mPreviewMemoryLock.unlock();
-  ALOGI("%s:END",__func__);
-  return NO_ERROR;
-
-error:
-    mHalCamCtrl->mPreviewMemoryLock.unlock();
-    putBufferToSurface();
-
-    ALOGV("%s: X", __func__);
-    return ret;
-}
-
-status_t QCameraStream_preview::initPreviewOnlyBuffers()
-{
-    status_t ret = NO_ERROR;
-    uint8_t num_planes = mFrameOffsetInfo.num_planes;
-    uint32_t planes[VIDEO_MAX_PLANES];
-
-    ALOGI("%s:BEGIN",__func__);
-    memset(&mHalCamCtrl->mMetadata, 0, sizeof(camera_frame_metadata_t));
-    mHalCamCtrl->mPreviewMemoryLock.lock();
-    memset(&mHalCamCtrl->mNoDispPreviewMemory, 0, sizeof(mHalCamCtrl->mNoDispPreviewMemory));
-    mHalCamCtrl->mPreviewMemoryLock.unlock();
-
-    memset(mNotifyBuffer, 0, sizeof(mNotifyBuffer));
-    memset(mDisplayBuf, 0, sizeof(mDisplayBuf));
-
-    ret = getBufferNoDisplay( );
-    if(ret != NO_ERROR) {
-        ALOGE("%s: cannot get memory from surface texture client, ret = %d", __func__, ret);
-        return ret;
-    }
-
-    ALOGI("%s:END",__func__);
-    return NO_ERROR;
-}
-
-
-void QCameraStream_preview::dumpFrameToFile(mm_camera_buf_def_t *newFrame)
-{
-  int32_t enabled = 0;
-  int frm_num;
-  uint32_t  skip_mode;
-  char value[PROPERTY_VALUE_MAX];
-  char buf[32];
-  int w, h;
-  static int count = 0;
-  cam_ctrl_dimension_t dim;
-  int file_fd;
-  int rc = 0;
-  int len;
-  unsigned long addr;
-  unsigned long * tmp = (unsigned long *)newFrame->buffer;
-  addr = *tmp;
-  status_t ret = p_mm_ops->ops->get_parm(mCameraHandle,
-                 MM_CAMERA_PARM_DIMENSION, &dim);
-
-  w = dim.display_width;
-  h = dim.display_height;
-  len = (w * h)*3/2;
-  count++;
-  if(count < 100) {
-    snprintf(buf, sizeof(buf), "/data/mzhu%d.yuv", count);
-    file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-
-    rc = write(file_fd, (const void *)addr, len);
-    ALOGE("%s: file='%s', vaddr_old=0x%x, addr_map = 0x%p, len = %d, rc = %d",
-          __func__, buf, (uint32_t)newFrame->buffer, (void *)addr, len, rc);
-    close(file_fd);
-    ALOGE("%s: dump %s, rc = %d, len = %d", __func__, buf, rc, len);
-  }
-}
-
-status_t QCameraStream_preview::processPreviewFrameWithDisplay(mm_camera_super_buf_t *frame)
-{
-  ALOGV("%s",__func__);
-  int err = 0;
-  int msgType = 0;
-  int i;
-  camera_memory_t *data = NULL;
-  camera_frame_metadata_t *metadata = NULL;
-  int preview_buf_idx = frame->bufs[0]->buf_idx;
-
-  if(!mActive) {
-    ALOGE("Preview Stopped. Returning callback");
-    return NO_ERROR;
-  }
-
-  if(mHalCamCtrl==NULL) {
-    ALOGE("%s: X: HAL control object not set",__func__);
-    /*Call buf done*/
-    return BAD_VALUE;
-  }
-
-  if(mFirstFrameRcvd == false) {
-      mFirstFrameRcvd = true;
-  }
-
-  if (UNLIKELY(mHalCamCtrl->mDebugFps)) {
-      mHalCamCtrl->debugShowPreviewFPS();
-  }
-  mHalCamCtrl->dumpFrameToFile(frame->bufs[0], HAL_DUMP_FRM_PREVIEW);
-
-  mHalCamCtrl->mPreviewMemoryLock.lock();
-  mNotifyBuffer[preview_buf_idx] = *frame;
-
-  ALOGD("<DEBUG2>: Received Frame fd:%d placed in index:%d db[index].fd:%d",
-        frame->bufs[0]->fd, preview_buf_idx,
-        mHalCamCtrl->mPreviewMemory.private_buffer_handle[preview_buf_idx]->fd);
-
-  ALOGI("Enqueue buf handle %p\n",
-  mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
-  ALOGD("%s: camera call genlock_unlock", __FUNCTION__);
-  if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[preview_buf_idx]) {
-    ALOGD("%s: genlock_unlock_buffer hdl =%p", __FUNCTION__, (*mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]));
-      if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t*)
-	            (*mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]))) {
-            ALOGE("%s: genlock_unlock_buffer failed", __FUNCTION__);
-      } else {
-          mHalCamCtrl->mPreviewMemory.local_flag[preview_buf_idx] = BUFFER_UNLOCKED;
-      }
-    } else {
-        ALOGE("%s: buffer to be enqueued is not locked", __FUNCTION__);
-  }
-
-  mHalCamCtrl->cache_ops(&mHalCamCtrl->mPreviewMemory.mem_info[preview_buf_idx],
-                         (void *)mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx]->data,
-                         ION_IOC_CLEAN_CACHES);
-  mHalCamCtrl->cache_ops(&mHalCamCtrl->mPreviewMemory.mem_info[preview_buf_idx],
-                         (void *)mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx]->data,
-                         ION_IOC_CLEAN_INV_CACHES);
-
-  if(mHFRFrameSkip == 1)
-  {
-      ALOGE("In HFR Frame skip");
-      const char *str = mHalCamCtrl->mParameters.get(
-                          QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE);
-      if(str != NULL){
-      int is_hfr_off = 0;
-      mHFRFrameCnt++;
-      if(!strcmp(str, QCameraParameters::VIDEO_HFR_OFF)) {
-          is_hfr_off = 1;
-          err = mHalCamCtrl->mPreviewWindow->enqueue_buffer(mHalCamCtrl->mPreviewWindow,
-            (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
-      } else if (!strcmp(str, QCameraParameters::VIDEO_HFR_2X)) {
-          mHFRFrameCnt %= 2;
-      } else if (!strcmp(str, QCameraParameters::VIDEO_HFR_3X)) {
-          mHFRFrameCnt %= 3;
-      } else if (!strcmp(str, QCameraParameters::VIDEO_HFR_4X)) {
-          mHFRFrameCnt %= 4;
-      }
-      if(mHFRFrameCnt == 0)
-          err = mHalCamCtrl->mPreviewWindow->enqueue_buffer(mHalCamCtrl->mPreviewWindow,
-            (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
-      else if(!is_hfr_off)
-          err = mHalCamCtrl->mPreviewWindow->cancel_buffer(mHalCamCtrl->mPreviewWindow,
-            (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
-      } else
-          err = mHalCamCtrl->mPreviewWindow->enqueue_buffer(mHalCamCtrl->mPreviewWindow,
-            (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
-  } else {
-      err = mHalCamCtrl->mPreviewWindow->enqueue_buffer(mHalCamCtrl->mPreviewWindow,
-          (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
-  }
-  if(err != 0) {
-    ALOGE("%s: enqueue_buffer failed, err = %d", __func__, err);
-  } else {
-   ALOGD("%s: enqueue_buffer hdl=%p", __func__, *mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
-    mHalCamCtrl->mPreviewMemory.local_flag[preview_buf_idx] = BUFFER_NOT_OWNED;
-  }
-  buffer_handle_t *buffer_handle = NULL;
-  int tmp_stride = 0;
-  err = mHalCamCtrl->mPreviewWindow->dequeue_buffer(mHalCamCtrl->mPreviewWindow,
-              &buffer_handle, &tmp_stride);
-  if (err == NO_ERROR && buffer_handle != NULL) {
-
-    ALOGD("%s: dequed buf hdl =%p", __func__, *buffer_handle);
-    for(i = 0; i < mHalCamCtrl->mPreviewMemory.buffer_count; i++) {
-        if(mHalCamCtrl->mPreviewMemory.buffer_handle[i] == buffer_handle) {
-          ALOGE("<DEBUG2>:Found buffer in idx:%d",i);
-          mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_UNLOCKED;
-          break;
-        }
-    }
-     if (i < mHalCamCtrl->mPreviewMemory.buffer_count ) {
-      err = mHalCamCtrl->mPreviewWindow->lock_buffer(mHalCamCtrl->mPreviewWindow, buffer_handle);
-      ALOGD("%s: camera call genlock_lock: hdl =%p", __func__, *buffer_handle);
-      if (GENLOCK_FAILURE == genlock_lock_buffer((native_handle_t*)(*buffer_handle), GENLOCK_WRITE_LOCK,
-                                                 GENLOCK_MAX_TIMEOUT)) {
-            ALOGE("%s: genlock_lock_buffer(WRITE) failed", __func__);
-      } else  {
-        mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_LOCKED;
-
-        if(MM_CAMERA_OK != p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mNotifyBuffer[i].bufs[0])) {
-
-            ALOGE("BUF DONE FAILED");
-        }
-        mHalCamCtrl->cache_ops((QCameraHalMemInfo_t *)(mNotifyBuffer[i].bufs[0]->mem_info),
-                               mNotifyBuffer[i].bufs[0]->buffer,
-                               ION_IOC_INV_CACHES);
-        }
-     }
-  } else
-      ALOGE("%s: enqueue_buffer idx = %d, no free buffer from display now", __func__, frame->bufs[0]->buf_idx);
-  /* Save the last displayed frame. We'll be using it to fill the gap between
-     when preview stops and postview start during snapshot.*/
-  mLastQueuedFrame = &(mDisplayBuf[preview_buf_idx]);
-  mHalCamCtrl->mPreviewMemoryLock.unlock();
-
-  nsecs_t timeStamp = seconds_to_nanoseconds(frame->bufs[0]->ts.tv_sec) ;
-  timeStamp += frame->bufs[0]->ts.tv_nsec;
-  ALOGD("Message enabled = 0x%x", mHalCamCtrl->mMsgEnabled);
-
-  camera_memory_t *previewMem = NULL;
-
-  if (mHalCamCtrl->mDataCb != NULL) {
-       ALOGD("%s: mMsgEnabled =0x%x, preview format =%d", __func__,
-            mHalCamCtrl->mMsgEnabled, mHalCamCtrl->mPreviewFormat);
-      //Sending preview callback if corresponding Msgs are enabled
-      if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
-          ALOGE("Q%s: PCB callback enabled", __func__);
-          msgType |=  CAMERA_MSG_PREVIEW_FRAME;
-          int previewBufSize;
-          /* The preview buffer size sent back in the callback should be (width*height*bytes_per_pixel)
-           * As all preview formats we support, use 12 bits per pixel, buffer size = previewWidth * previewHeight * 3/2.
-           * We need to put a check if some other formats are supported in future. (punits) */
-          if ((mHalCamCtrl->mPreviewFormat == CAMERA_YUV_420_NV21) ||
-              (mHalCamCtrl->mPreviewFormat == CAMERA_YUV_420_NV12) ||
-              (mHalCamCtrl->mPreviewFormat == CAMERA_YUV_420_YV12))
-          {
-              if(mHalCamCtrl->mPreviewFormat == CAMERA_YUV_420_YV12) {
-                  previewBufSize = ((mHalCamCtrl->mPreviewWidth+15)/16) * 16 * mHalCamCtrl->mPreviewHeight +
-                                   ((mHalCamCtrl->mPreviewWidth/2+15)/16) * 16* mHalCamCtrl->mPreviewHeight;
-              } else {
-                  previewBufSize = mHalCamCtrl->mPreviewWidth * mHalCamCtrl->mPreviewHeight * 3/2;
-              }
-              if(previewBufSize != mHalCamCtrl->mPreviewMemory.private_buffer_handle[preview_buf_idx]->size) {
-                  previewMem = mHalCamCtrl->mGetMemory(mHalCamCtrl->mPreviewMemory.private_buffer_handle[preview_buf_idx]->fd,
-                                                       previewBufSize, 1, mHalCamCtrl->mCallbackCookie);
-                  if (!previewMem || !previewMem->data) {
-                      ALOGE("%s: mGetMemory failed.\n", __func__);
-                  } else {
-                      data = previewMem;
-                  }
-              } else
-                    data = mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx];
-          } else {
-                data = mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx];
-                ALOGE("Invalid preview format, buffer size in preview callback may be wrong.");
-          }
-      } else {
-          data = NULL;
-      }
-      if(msgType && mActive) {
-          mHalCamCtrl->mDataCb(msgType, data, 0, metadata, mHalCamCtrl->mCallbackCookie);
-      }
-      if (previewMem) {
-          previewMem->release(previewMem);
-      }
-	  ALOGD("end of cb");
-  } else {
-    ALOGD("%s PCB is not enabled", __func__);
-  }
-  if(mHalCamCtrl->mDataCbTimestamp != NULL && mVFEOutputs == 1)
-  {
-      int flagwait = 1;
-      if(mHalCamCtrl->mStartRecording == true &&
-              ( mHalCamCtrl->mMsgEnabled & CAMERA_MSG_VIDEO_FRAME))
-      {
-        if (mHalCamCtrl->mStoreMetaDataInFrame)
-        {
-          if(mHalCamCtrl->mRecordingMemory.metadata_memory[preview_buf_idx])
-          {
-              flagwait = 1;
-              mHalCamCtrl->mDataCbTimestamp(timeStamp, CAMERA_MSG_VIDEO_FRAME,
-                                            mHalCamCtrl->mRecordingMemory.metadata_memory[preview_buf_idx],
-                                            0, mHalCamCtrl->mCallbackCookie);
-          }else
-              flagwait = 0;
-      }
-      else
-      {
-          mHalCamCtrl->mDataCbTimestamp(timeStamp, CAMERA_MSG_VIDEO_FRAME,
-                                        mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx],
-                                        0, mHalCamCtrl->mCallbackCookie);
-      }
-
-      if(flagwait){
-          Mutex::Autolock rLock(&mHalCamCtrl->mRecordFrameLock);
-          if (mHalCamCtrl->mReleasedRecordingFrame != true) {
-              mHalCamCtrl->mRecordWait.wait(mHalCamCtrl->mRecordFrameLock);
-          }
-          mHalCamCtrl->mReleasedRecordingFrame = false;
-      }
-      }
-  }
-  return NO_ERROR;
-}
-
-
-status_t QCameraStream_preview::processPreviewFrameWithOutDisplay(
-  mm_camera_super_buf_t *frame)
-{
-  ALOGV("%s",__func__);
-  int err = 0;
-  int msgType = 0;
-  int i;
-  camera_memory_t *data = NULL;
-  camera_frame_metadata_t *metadata = NULL;
-  int preview_buf_idx = frame->bufs[0]->buf_idx;
-
-  if(mHalCamCtrl==NULL) {
-    ALOGE("%s: X: HAL control object not set",__func__);
-    /*Call buf done*/
-    return BAD_VALUE;
-  }
-
-  if (UNLIKELY(mHalCamCtrl->mDebugFps)) {
-      mHalCamCtrl->debugShowPreviewFPS();
-  }
-  mHalCamCtrl->dumpFrameToFile(frame->bufs[0], HAL_DUMP_FRM_PREVIEW);
-
-  mHalCamCtrl->mPreviewMemoryLock.lock();
-  mNotifyBuffer[preview_buf_idx] = *frame;
-
-  /* Save the last displayed frame. We'll be using it to fill the gap between
-     when preview stops and postview start during snapshot.*/
-  mLastQueuedFrame = &(mDisplayBuf[frame->bufs[0]->buf_idx]);
-  mHalCamCtrl->mPreviewMemoryLock.unlock();
-
-  ALOGD("Message enabled = 0x%x", mHalCamCtrl->mMsgEnabled);
-
-  mHalCamCtrl->cache_ops(&mHalCamCtrl->mNoDispPreviewMemory.mem_info[preview_buf_idx],
-                         (void *)mHalCamCtrl->mNoDispPreviewMemory.camera_memory[preview_buf_idx]->data,
-                         ION_IOC_CLEAN_CACHES);
-
-  if (mHalCamCtrl->mDataCb != NULL) {
-      //Sending preview callback if corresponding Msgs are enabled
-      if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
-          msgType |=  CAMERA_MSG_PREVIEW_FRAME;
-          int previewBufSize;
-          /* For CTS : Forcing preview memory buffer lenth to be
-             'previewWidth * previewHeight * 3/2'.
-              Needed when gralloc allocated extra memory.*/
-          //Can add this check for other formats as well.
-        data = mHalCamCtrl->mNoDispPreviewMemory.camera_memory[preview_buf_idx];//mPreviewHeap->mBuffers[frame->bufs[0]->buf_idx];
-      } else {
-          data = NULL;
-      }
-
-      if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA){
-          msgType  |= CAMERA_MSG_PREVIEW_METADATA;
-          metadata = &mHalCamCtrl->mMetadata;
-      } else {
-          metadata = NULL;
-      }
-      if(mActive && msgType) {
-          mHalCamCtrl->mDataCb(msgType, data, 0, metadata, mHalCamCtrl->mCallbackCookie);
-      }
-
-      if(MM_CAMERA_OK !=p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mNotifyBuffer[preview_buf_idx].bufs[0])) {
-          ALOGE("BUF DONE FAILED");
-      }
-      mHalCamCtrl->cache_ops((QCameraHalMemInfo_t *)(mNotifyBuffer[preview_buf_idx].bufs[0]->mem_info),
-                             mNotifyBuffer[preview_buf_idx].bufs[0]->buffer,
-                             ION_IOC_INV_CACHES);
-      ALOGD("end of cb");
-  }
-
-  return NO_ERROR;
-}
-
-status_t QCameraStream_preview::processPreviewFrame (
-  mm_camera_super_buf_t *frame)
-{
-  if (mHalCamCtrl->isNoDisplayMode()) {
-    return processPreviewFrameWithOutDisplay(frame);
-  } else {
-    return processPreviewFrameWithDisplay(frame);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-QCameraStream_preview::QCameraStream_preview(uint32_t CameraHandle,
-                                             uint32_t ChannelId,
-                                             uint32_t Width,
-                                             uint32_t Height,
-                                             uint32_t Format,
-                                             uint8_t NumBuffers,
-                                             mm_camera_vtbl_t *mm_ops,
-                                             mm_camera_img_mode imgmode,
-                                             camera_mode_t mode,
-                                             QCameraHardwareInterface* camCtrl)
-  :QCameraStream(CameraHandle,
-                 ChannelId,
-                 Width,
-                 Height,
-                 Format,
-                 NumBuffers,
-                 mm_ops,
-                 imgmode,
-                 mode,
-                 camCtrl),
-    mLastQueuedFrame(NULL),
-    mNumFDRcvd(0)
-  {
-  }
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-QCameraStream_preview::~QCameraStream_preview() {
-    ALOGV("%s: E", __func__);
-    release();
-    ALOGV("%s: X", __func__);
-
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-void QCameraStream_preview::release() {
-    streamOff(0);
-    deinitStream();
-}
-
-void *QCameraStream_preview::getLastQueuedFrame(void)
-{
-    return mLastQueuedFrame;
-}
-
-int32_t QCameraStream_preview::setCrop()
-{
-    int32_t rc = QCameraStream::setCrop();
-    if (0 == rc) {
-        if (!mHalCamCtrl->mSmoothZoomRunning && mHalCamCtrl->mPreviewWindow) {
-            rc = mHalCamCtrl->mPreviewWindow->set_crop(
-                            mHalCamCtrl->mPreviewWindow,
-                            mCrop.offset_x,
-                            mCrop.offset_y,
-                            mCrop.offset_x + mCrop.width,
-                            mCrop.offset_y + mCrop.height);
-        }
-    }
-    return rc;
-}
-
-int QCameraStream_preview::getBuf(mm_camera_frame_len_offset *frame_offset_info,
-                              uint8_t num_bufs,
-                              uint8_t *initial_reg_flag,
-                              mm_camera_buf_def_t  *bufs)
-{
-    int ret = 0;
-    ALOGE("%s:BEGIN",__func__);
-
-    if (num_bufs > mNumBuffers) {
-        mNumBuffers = num_bufs;
-    }
-    if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
-        ALOGE("%s: Invalid number of buffers (=%d) requested!",
-             __func__, mNumBuffers);
-        return BAD_VALUE;
-    }
-
-    memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
-    if (mHalCamCtrl->isNoDisplayMode()) {
-        ret = initPreviewOnlyBuffers();
-    } else {
-        ret = initDisplayBuffers();
-    }
-    ALOGD("Debug : %s : initDisplayBuffers",__func__);
-    for(int i = 0; i < num_bufs; i++) {
-        bufs[i] = mDisplayBuf[i];
-        initial_reg_flag[i] = true;
-    }
-
-    ALOGV("%s: X - ret = %d ", __func__, ret);
-    return ret;
-}
-
-int QCameraStream_preview::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
-    int ret = 0;
-    ALOGE(" %s : E ", __func__);
-    if (mHalCamCtrl->isNoDisplayMode()) {
-        ret = freeBufferNoDisplay();
-    } else {
-        ret = putBufferToSurface();
-    }
-    ALOGI(" %s : X ",__func__);
-    return ret;
-}
-
-// ---------------------------------------------------------------------------
-// No code beyone this line
-// ---------------------------------------------------------------------------
-}; // namespace android
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Rdi.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Rdi.cpp
deleted file mode 100755
index cbbe988..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Rdi.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define LOG_TAG "QCameraHWI_Rdi"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-#include <gralloc_priv.h>
-#include <genlock.h>
-
-#define UNLIKELY(exp) __builtin_expect(!!(exp), 0)
-
-/* QCameraHWI_Raw class implementation goes here*/
-/* following code implement the RDI logic of this class*/
-
-namespace android {
-status_t QCameraStream_Rdi::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
-    status_t ret = NO_ERROR;
-
-    ALOGI(" %s : E ", __FUNCTION__);
-    mNumBuffers = PREVIEW_BUFFER_COUNT;
-    if(mHalCamCtrl->isZSLMode()) {
-        if(mNumBuffers < mHalCamCtrl->getZSLQueueDepth() + 3) {
-            mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
-        }
-    }
-    ret = QCameraStream::initStream(no_cb_needed, stream_on);
-end:
-    ALOGI(" %s : X ", __FUNCTION__);
-    return ret;
-}
-
-int QCameraStream_Rdi::getBuf(mm_camera_frame_len_offset *frame_offset_info,
-                              uint8_t num_bufs,
-                              uint8_t *initial_reg_flag,
-                              mm_camera_buf_def_t  *bufs)
-{
-    int ret = 0;
-    ALOGE("%s:BEGIN",__func__);
-
-    if (num_bufs > mNumBuffers) {
-        mNumBuffers = num_bufs;
-    }
-    if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
-        ALOGE("%s: Invalid number of buffers (=%d) requested!",
-             __func__, mNumBuffers);
-        return BAD_VALUE;
-    }
-
-    memset(mRdiBuf, 0, sizeof(mRdiBuf));
-    memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
-    ret = mHalCamCtrl->initHeapMem(&mHalCamCtrl->mRdiMemory,
-                                   mNumBuffers,
-                                   mFrameOffsetInfo.frame_len,
-                                   MSM_PMEM_MAINIMG,
-                                   &mFrameOffsetInfo,
-                                   mRdiBuf);
-    if(MM_CAMERA_OK == ret) {
-        for(int i = 0; i < num_bufs; i++) {
-            bufs[i] = mRdiBuf[i];
-            initial_reg_flag[i] = true;
-        }
-    }
-
-    ALOGV("%s: X - ret = %d ", __func__, ret);
-    return ret;
-}
-
-int QCameraStream_Rdi::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
-    int ret = 0;
-    ALOGE(" %s : E ", __FUNCTION__);
-    ret = mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mRdiMemory);
-    ALOGI(" %s : X ",__FUNCTION__);
-    return ret;
-}
-
-void QCameraStream_Rdi::dumpFrameToFile(mm_camera_buf_def_t* newFrame)
-{
-    char buf[32];
-    int file_fd;
-    int i;
-    char *ext = "yuv";
-    int w,h,main_422;
-    static int count = 0;
-    char *name = "rdi";
-
-    w = mHalCamCtrl->mRdiWidth;
-    h = mHalCamCtrl->mRdiHeight;
-    main_422 = 1;
-
-    if ( newFrame != NULL) {
-        char * str;
-        snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name,count,ext);
-        file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-        if (file_fd < 0) {
-            ALOGE("%s: cannot open file\n", __func__);
-        } else {
-            void* y_off = newFrame->buffer + newFrame->planes[0].data_offset;
-            void* cbcr_off = newFrame->buffer + newFrame->planes[0].length;
-
-            write(file_fd, (const void *)(y_off), newFrame->planes[0].length);
-            write(file_fd, (const void *)(cbcr_off),
-                  (newFrame->planes[1].length * newFrame->num_planes));
-            close(file_fd);
-        }
-        count++;
-    }
-}
-
-status_t QCameraStream_Rdi::processRdiFrame(
-  mm_camera_super_buf_t *frame)
-{
-    ALOGE("%s",__func__);
-    status_t err = NO_ERROR;
-    int msgType = 0;
-    camera_memory_t *data = NULL;
-
-    if(!mActive) {
-        ALOGE("RDI Streaming Stopped. Returning callback");
-        return NO_ERROR;
-    }
-
-    if(mHalCamCtrl==NULL) {
-        ALOGE("%s: X: HAL control object not set",__func__);
-        /*Call buf done*/
-        return BAD_VALUE;
-    }
-
-    mHalCamCtrl->dumpFrameToFile(frame->bufs[0], HAL_DUMP_FRM_RDI);
-
-    if (mHalCamCtrl->mDataCb != NULL) {
-      //Sending rdi callback if corresponding Msgs are enabled
-      if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
-          msgType |=  CAMERA_MSG_PREVIEW_FRAME;
-          data = mHalCamCtrl->mRdiMemory.camera_memory[frame->bufs[0]->buf_idx];
-      } else {
-          data = NULL;
-      }
-
-      ALOGD("Message enabled = 0x%x", msgType);
-      if(mActive && msgType) {
-          mHalCamCtrl->mDataCb(msgType, data, 0, NULL, mHalCamCtrl->mCallbackCookie);
-      }
-      ALOGD("end of cb");
-    }
-    if (MM_CAMERA_OK != p_mm_ops->ops->qbuf(mCameraHandle, mChannelId,
-                                            frame->bufs[0])) {
-        ALOGE("%s: Failed in Preview Qbuf\n", __func__);
-        err = BAD_VALUE;
-    }
-    mHalCamCtrl->cache_ops((QCameraHalMemInfo_t *)(frame->bufs[0]->mem_info),
-                           frame->bufs[0]->buffer,
-                           ION_IOC_INV_CACHES);
-
-    return err;
-}
-
-
-// ---------------------------------------------------------------------------
-// QCameraStream_Rdi
-// ---------------------------------------------------------------------------
-
-QCameraStream_Rdi::
-QCameraStream_Rdi(uint32_t CameraHandle,
-                  uint32_t ChannelId,
-                  uint32_t Width,
-                  uint32_t Height,
-                  uint32_t Format,
-                  uint8_t NumBuffers,
-                  mm_camera_vtbl_t *mm_ops,
-                  mm_camera_img_mode imgmode,
-                  camera_mode_t mode,
-                  QCameraHardwareInterface* camCtrl)
-  : QCameraStream(CameraHandle,
-                 ChannelId,
-                 Width,
-                 Height,
-                 Format,
-                 NumBuffers,
-                 mm_ops,
-                 imgmode,
-                 mode,
-                  camCtrl)
-{
-    ALOGE("%s: E", __func__);
-    ALOGE("%s: X", __func__);
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_Rdi
-// ---------------------------------------------------------------------------
-
-QCameraStream_Rdi::~QCameraStream_Rdi() {
-    ALOGV("%s: E", __func__);
-    release();
-    ALOGV("%s: X", __func__);
-
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_Rdi
-// ---------------------------------------------------------------------------
-  void QCameraStream_Rdi::release() {
-
-    ALOGE("%s : BEGIN",__func__);
-    streamOff(0);
-    deinitStream();
-    ALOGE("%s: END", __func__);
-  }
-
-// ---------------------------------------------------------------------------
-// No code beyone this line
-// ---------------------------------------------------------------------------
-}; // namespace android
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Record.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Record.cpp
deleted file mode 100755
index 73d26d1..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Record.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHWI_Record"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraStream.h"
-
-
-#define LIKELY(exp)   __builtin_expect(!!(exp), 1)
-#define UNLIKELY(exp) __builtin_expect(!!(exp), 0)
-
-/* QCameraStream_record class implementation goes here*/
-/* following code implement the video streaming capture & encoding logic of this class*/
-// ---------------------------------------------------------------------------
-// QCameraStream_record createInstance()
-// ---------------------------------------------------------------------------
-namespace android {
-
-
-// ---------------------------------------------------------------------------
-// QCameraStream_record Constructor
-// ---------------------------------------------------------------------------
-QCameraStream_record::QCameraStream_record(uint32_t CameraHandle,
-                                           uint32_t ChannelId,
-                                           uint32_t Width,
-                                           uint32_t Height,
-                                           uint32_t Format,
-                                           uint8_t NumBuffers,
-                                           mm_camera_vtbl_t *mm_ops,
-                                           mm_camera_img_mode imgmode,
-                                           camera_mode_t mode,
-                                           QCameraHardwareInterface* camCtrl)
-//  : QCameraStream(cameraId,mode),
-  :QCameraStream(CameraHandle,
-                 ChannelId,
-                 Width,
-                 Height,
-                 Format,
-                 NumBuffers,
-                 mm_ops,
-                 imgmode,
-                 mode,
-                 camCtrl),
-                 mDebugFps(false)
-{
-  char value[PROPERTY_VALUE_MAX];
-  ALOGV("%s: BEGIN", __func__);
-
-  property_get("persist.debug.sf.showfps", value, "0");
-  mDebugFps = atoi(value);
-
-  ALOGV("%s: END", __func__);
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_record Destructor
-// ---------------------------------------------------------------------------
-QCameraStream_record::~QCameraStream_record() {
-    ALOGV("%s: BEGIN", __func__);
-    release();
-    ALOGV("%s: END", __func__);
-}
-
-int QCameraStream_record::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
-    for(int cnt = 0; cnt < mHalCamCtrl->mRecordingMemory.buffer_count; cnt++) {
-        if (mHalCamCtrl->mStoreMetaDataInFrame) {
-            struct encoder_media_buffer_type * packet =
-                (struct encoder_media_buffer_type  *)mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->data;
-            native_handle_delete(const_cast<native_handle_t *>(packet->meta_handle));
-            mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->release(
-               mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]);
-        }
-        mHalCamCtrl->mRecordingMemory.camera_memory[cnt]->release(
-           mHalCamCtrl->mRecordingMemory.camera_memory[cnt]);
-
-#ifdef USE_ION
-        mHalCamCtrl->deallocate_ion_memory(&mHalCamCtrl->mRecordingMemory.mem_info[cnt]);
-#endif
-    }
-    memset(&mHalCamCtrl->mRecordingMemory, 0, sizeof(mHalCamCtrl->mRecordingMemory));
-    return NO_ERROR;
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_record
-// ---------------------------------------------------------------------------
-void QCameraStream_record::release()
-{
-    ALOGV("%s: BEGIN", __func__);
-    streamOff(0);
-    deinitStream();
-    ALOGV("%s: END", __func__);
-}
-
-status_t QCameraStream_record::processRecordFrame(mm_camera_super_buf_t *frame)
-{
-    ALOGV("%s : BEGIN",__func__);
-    int video_buf_idx = frame->bufs[0]->buf_idx;
-
-    if(!mActive) {
-      ALOGE("Recording Stopped. Returning callback");
-      return NO_ERROR;
-    }
-
-    if (UNLIKELY(mDebugFps)) {
-        debugShowVideoFPS();
-    }
-    ALOGE("DEBUG4:%d",frame->bufs[0]->stream_id);
-    ALOGE("<DEBUG4>: Timestamp: %ld %ld",frame->bufs[0]->ts.tv_sec,frame->bufs[0]->ts.tv_nsec);
-    mHalCamCtrl->dumpFrameToFile(frame->bufs[0], HAL_DUMP_FRM_VIDEO);
-    camera_data_timestamp_callback rcb = mHalCamCtrl->mDataCbTimestamp;
-    void *rdata = mHalCamCtrl->mCallbackCookie;
-	  nsecs_t timeStamp = nsecs_t(frame->bufs[0]->ts.tv_sec)*1000000000LL + \
-                      frame->bufs[0]->ts.tv_nsec;
-
-    ALOGE("Send Video frame to services/encoder TimeStamp : %lld",timeStamp);
-    mRecordedFrames[video_buf_idx] = *frame;
-
-    mHalCamCtrl->cache_ops(&mHalCamCtrl->mRecordingMemory.mem_info[video_buf_idx],
-                           (void *)mHalCamCtrl->mRecordingMemory.camera_memory[video_buf_idx]->data,
-                           ION_IOC_CLEAN_CACHES);
-
-    if (mHalCamCtrl->mStoreMetaDataInFrame) {
-        if((rcb != NULL) && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) {
-            ALOGE("Calling video callback:%d", video_buf_idx);
-            rcb(timeStamp, CAMERA_MSG_VIDEO_FRAME,
-                mHalCamCtrl->mRecordingMemory.metadata_memory[video_buf_idx],
-                0, mHalCamCtrl->mCallbackCookie);
-        }
-    } else {
-        if((rcb != NULL) && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) {
-            ALOGE("Calling video callback2");
-            rcb(timeStamp, CAMERA_MSG_VIDEO_FRAME,
-                mHalCamCtrl->mRecordingMemory.camera_memory[video_buf_idx],
-                0, mHalCamCtrl->mCallbackCookie);
-        }
-    }
-
-    ALOGV("%s : END",__func__);
-    return NO_ERROR;
-}
-
-//Record Related Functions
-status_t QCameraStream_record::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
-    status_t ret = NO_ERROR;
-
-    ALOGI(" %s : E ", __FUNCTION__);
-    mNumBuffers = VIDEO_BUFFER_COUNT;
-    if(mHalCamCtrl->isLowPowerCamcorder()) {
-        ALOGE("%s: lower power camcorder selected", __func__);
-        mNumBuffers = VIDEO_BUFFER_COUNT_LOW_POWER_CAMCORDER;
-    }
-    ret = QCameraStream::initStream(no_cb_needed, stream_on);
-end:
-    ALOGI(" %s : X ", __FUNCTION__);
-    return ret;
-}
-
-status_t QCameraStream_record::getBuf(mm_camera_frame_len_offset *frame_offset_info,
-                                      uint8_t num_bufs,
-                                      uint8_t *initial_reg_flag,
-                                      mm_camera_buf_def_t  *bufs)
-{
-    ALOGE("%s : BEGIN",__func__);
-
-    if (num_bufs > mNumBuffers) {
-        mNumBuffers = num_bufs;
-    }
-    if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
-        ALOGE("%s: Invalid number of buffers (=%d) requested!",
-             __func__, mNumBuffers);
-        return BAD_VALUE;
-    }
-
-    memset(mRecordBuf, 0, sizeof(mRecordBuf));
-    memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
-    if (mHalCamCtrl->initHeapMem(&mHalCamCtrl->mRecordingMemory,
-                                 mNumBuffers,
-                                 mFrameOffsetInfo.frame_len,
-                                 MSM_PMEM_VIDEO,
-                                 &mFrameOffsetInfo,
-                                 mRecordBuf) < 0) {
-        ALOGE("%s: Error getting heap mem for recording", __func__);
-        return NO_MEMORY;
-    }
-
-    if (mHalCamCtrl->mStoreMetaDataInFrame) {
-        for (int cnt = 0; cnt < mNumBuffers; cnt++) {
-            mHalCamCtrl->mRecordingMemory.metadata_memory[cnt] =
-                mHalCamCtrl->mGetMemory(-1,
-                                        sizeof(struct encoder_media_buffer_type),
-                                        1,
-                                        (void *)this);
-            struct encoder_media_buffer_type * packet =
-                (struct encoder_media_buffer_type *)mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->data;
-            packet->meta_handle = native_handle_create(1, 2); //1 fd, 1 offset and 1 size
-            packet->buffer_type = kMetadataBufferTypeCameraSource;
-            native_handle_t * nh = const_cast<native_handle_t *>(packet->meta_handle);
-            nh->data[0] = mHalCamCtrl->mRecordingMemory.mem_info[cnt].fd;
-            nh->data[1] = 0;
-            nh->data[2] = mHalCamCtrl->mRecordingMemory.mem_info[cnt].size;
-        }
-    }
-
-    for(int i = 0; i < num_bufs; i++) {
-        bufs[i] = mRecordBuf[i];
-        initial_reg_flag[i] = true;
-    }
-
-    ALOGE("%s : END",__func__);
-    return NO_ERROR;
-}
-
-void QCameraStream_record::releaseRecordingFrame(const void *opaque)
-{
-    ALOGV("%s : BEGIN, opaque = 0x%p",__func__, opaque);
-    if(!mActive)
-    {
-        ALOGE("%s : Recording already stopped!!! Leak???",__func__);
-        return;
-    }
-    for(int cnt = 0; cnt < mHalCamCtrl->mRecordingMemory.buffer_count; cnt++) {
-      if (mHalCamCtrl->mStoreMetaDataInFrame) {
-        if(mHalCamCtrl->mRecordingMemory.metadata_memory[cnt] &&
-                mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->data == opaque) {
-            /* found the match */
-            ALOGE("Releasing video frames:%d",cnt);
-            if(MM_CAMERA_OK != p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mRecordedFrames[cnt].bufs[0]))
-                ALOGE("%s : Buf Done Failed",__func__);
-            mHalCamCtrl->cache_ops(&mHalCamCtrl->mRecordingMemory.mem_info[cnt],
-                                   (void *)mRecordedFrames[cnt].bufs[0]->buffer,
-                                   ION_IOC_INV_CACHES);
-            ALOGV("%s : END",__func__);
-            return;
-        }
-      } else {
-        if(mHalCamCtrl->mRecordingMemory.camera_memory[cnt] &&
-                mHalCamCtrl->mRecordingMemory.camera_memory[cnt]->data == opaque) {
-            /* found the match */
-            ALOGE("Releasing video frames2");
-            if(MM_CAMERA_OK != p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mRecordedFrames[cnt].bufs[0]))
-                ALOGE("%s : Buf Done Failed",__func__);
-            mHalCamCtrl->cache_ops(&mHalCamCtrl->mRecordingMemory.mem_info[cnt],
-                                   (void *)mRecordedFrames[cnt].bufs[0]->buffer,
-                                   ION_IOC_INV_CACHES);
-            ALOGV("%s : END",__func__);
-            return;
-        }
-      }
-    }
-	ALOGE("%s: cannot find the matched frame with opaue = 0x%p", __func__, opaque);
-}
-
-void QCameraStream_record::debugShowVideoFPS() const
-{
-  static int mFrameCount;
-  static int mLastFrameCount = 0;
-  static nsecs_t mLastFpsTime = 0;
-  static float mFps = 0;
-  mFrameCount++;
-  nsecs_t now = systemTime();
-  nsecs_t diff = now - mLastFpsTime;
-  if (diff > ms2ns(250)) {
-    mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
-    ALOGI("Video Frames Per Second: %.4f", mFps);
-    mLastFpsTime = now;
-    mLastFrameCount = mFrameCount;
-  }
-}
-
-}//namespace android
-
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Still.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Still.cpp
deleted file mode 100755
index 091de43..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Still.cpp
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#define LOG_NIDEBUG 0
-#define LOG_TAG "QCameraHWI_Still"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <media/mediarecorder.h>
-#include <math.h>
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-#include "mm_jpeg_interface.h"
-
-
-/* following code implement the still image capture & encoding logic of this class*/
-namespace android {
-
-QCameraStream_SnapshotMain::
-QCameraStream_SnapshotMain(uint32_t CameraHandle,
-                           uint32_t ChannelId,
-                           uint32_t Width,
-                           uint32_t Height,
-                           uint32_t Format,
-                           uint8_t NumBuffers,
-                           mm_camera_vtbl_t *mm_ops,
-                           mm_camera_img_mode imgmode,
-                           camera_mode_t mode,
-                           QCameraHardwareInterface* camCtrl)
-  :QCameraStream(CameraHandle,
-                 ChannelId,
-                 Width,
-                 Height,
-                 Format,
-                 NumBuffers,
-                 mm_ops,
-                 imgmode,
-                 mode,
-                 camCtrl)
-{
-}
-
-QCameraStream_SnapshotMain::~QCameraStream_SnapshotMain()
-{
-    release();
-}
-
-void QCameraStream_SnapshotMain::release()
-{
-    streamOff(0);
-    deinitStream();
-
-}
-
-status_t QCameraStream_SnapshotMain::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
-    status_t ret = NO_ERROR;
-
-    if(mHalCamCtrl->isZSLMode()) {
-        mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
-    } else if (mHalCamCtrl->mHdrInfo.hdr_on) {
-        mNumBuffers = mHalCamCtrl->mHdrInfo.num_frame;
-    } else {
-        mNumBuffers = mHalCamCtrl->getNumOfSnapshots();
-    }
-    ret = QCameraStream::initStream(no_cb_needed, stream_on);
-    return ret;;
-}
-
-int QCameraStream_SnapshotMain::getBuf(mm_camera_frame_len_offset *frame_offset_info,
-                                       uint8_t num_bufs,
-                                       uint8_t *initial_reg_flag,
-                                       mm_camera_buf_def_t  *bufs)
-{
-    int ret = MM_CAMERA_OK;
-    ALOGE("%s : E", __func__);
-
-    if (mNumBuffers < num_bufs) {
-        mNumBuffers = num_bufs;
-    }
-    if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
-        ALOGE("%s: Invalid number of buffers (=%d) requested!",
-             __func__, mNumBuffers);
-        return BAD_VALUE;
-    }
-
-    memset(mSnapshotStreamBuf, 0, sizeof(mSnapshotStreamBuf));
-    memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
-    ret = mHalCamCtrl->initHeapMem(&mHalCamCtrl->mSnapshotMemory,
-                                   mNumBuffers,
-                                   mFrameOffsetInfo.frame_len,
-                                   MSM_PMEM_MAINIMG,
-                                   &mFrameOffsetInfo,
-                                   mSnapshotStreamBuf);
-
-    if(MM_CAMERA_OK == ret) {
-        for(int i = 0; i < num_bufs; i++) {
-            bufs[i] = mSnapshotStreamBuf[i];
-            initial_reg_flag[i] = (TRUE == m_flag_stream_on)? TRUE : FALSE;
-        }
-    }
-
-    /* If we have reached here successfully, we have allocated buffer.
-       Set state machine.*/
-    ALOGD("%s: X", __func__);
-    return ret;
-
-}
-
-int QCameraStream_SnapshotMain::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
-    ALOGE("%s: Release Snapshot main Memory",__func__);
-    return mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mSnapshotMemory);
-}
-
-int QCameraStream_SnapshotThumbnail::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
-     ALOGE("%s: Release Snapshot thumbnail Memory",__func__);
-     return mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mThumbnailMemory);
-}
-
-QCameraStream_SnapshotThumbnail::
-QCameraStream_SnapshotThumbnail(uint32_t CameraHandle,
-                                uint32_t ChannelId,
-                                uint32_t Width,
-                                uint32_t Height,
-                                uint32_t Format,
-                                uint8_t NumBuffers,
-                                mm_camera_vtbl_t *mm_ops,
-                                mm_camera_img_mode imgmode,
-                                camera_mode_t mode,
-                                QCameraHardwareInterface* camCtrl)
-  :QCameraStream(CameraHandle,
-                 ChannelId,
-                 Width,
-                 Height,
-                 Format,
-                 NumBuffers,
-                 mm_ops,
-                 imgmode,
-                 mode,
-                 camCtrl)
-{
-
-}
-
-QCameraStream_SnapshotThumbnail::~QCameraStream_SnapshotThumbnail()
-{
-     release();
-}
-
-void QCameraStream_SnapshotThumbnail::release()
-{
-    streamOff(0);
-    deinitStream();
-}
-
-status_t QCameraStream_SnapshotThumbnail::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
-    status_t ret = NO_ERROR;
-
-    if(mHalCamCtrl->isZSLMode()) {
-        mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
-    } else if (mHalCamCtrl->mHdrInfo.hdr_on) {
-        mNumBuffers = mHalCamCtrl->mHdrInfo.num_frame;
-    } else {
-        mNumBuffers = mHalCamCtrl->getNumOfSnapshots();
-    }
-    ret = QCameraStream::initStream(no_cb_needed, stream_on);
-    return ret;;
-}
-
-status_t QCameraStream_SnapshotThumbnail::getBuf(mm_camera_frame_len_offset *frame_offset_info,
-                                                 uint8_t num_bufs,
-                                                 uint8_t *initial_reg_flag,
-                                                 mm_camera_buf_def_t  *bufs)
-{
-    int ret = MM_CAMERA_OK;
-
-    if (mNumBuffers < num_bufs) {
-        mNumBuffers = num_bufs;
-    }
-    if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
-        ALOGE("%s: Invalid number of buffers (=%d) requested!",
-             __func__, mNumBuffers);
-        return BAD_VALUE;
-    }
-
-    memset(mPostviewStreamBuf, 0, sizeof(mPostviewStreamBuf));
-    memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
-    ret = mHalCamCtrl->initHeapMem(
-                         &mHalCamCtrl->mThumbnailMemory,
-                         mNumBuffers,
-                         mFrameOffsetInfo.frame_len,
-                         MSM_PMEM_THUMBNAIL,
-                         &mFrameOffsetInfo,
-                         mPostviewStreamBuf);
-    if(MM_CAMERA_OK == ret) {
-        for(int i = 0; i < num_bufs; i++) {
-            bufs[i] = mPostviewStreamBuf[i];
-            initial_reg_flag[i] = true;
-        }
-    }
-
-    return ret;
-}
-
-
-}; // namespace android
-
diff --git a/camera/QCamera/HAL/core/src/QCameraParameters.cpp b/camera/QCamera/HAL/core/src/QCameraParameters.cpp
deleted file mode 100755
index db253fa..0000000
--- a/camera/QCamera/HAL/core/src/QCameraParameters.cpp
+++ /dev/null
@@ -1,408 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 LOG_TAG "QCameraParams"
-#include <utils/Log.h>
-#include <string.h>
-#include <stdlib.h>
-#include <camera/QCameraParameters.h>
-
-namespace android {
-// Parameter keys to communicate between camera application and driver.
-const char QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES[] = "hfr-size-values";
-const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_MODE[] = "preview-frame-rate-mode";
-const char QCameraParameters::KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[] = "preview-frame-rate-modes";
-const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[] = "frame-rate-auto";
-const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[] = "frame-rate-fixed";
-const char QCameraParameters::KEY_QC_TOUCH_AF_AEC[] = "touch-af-aec";
-const char QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC[] = "touch-af-aec-values";
-const char QCameraParameters::KEY_QC_TOUCH_INDEX_AEC[] = "touch-index-aec";
-const char QCameraParameters::KEY_QC_TOUCH_INDEX_AF[] = "touch-index-af";
-const char QCameraParameters::KEY_QC_SCENE_DETECT[] = "scene-detect";
-const char QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT[] = "scene-detect-values";
-const char QCameraParameters::KEY_QC_ISO_MODE[] = "iso";
-const char QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES[] = "iso-values";
-const char QCameraParameters::KEY_QC_LENSSHADE[] = "lensshade";
-const char QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES[] = "lensshade-values";
-const char QCameraParameters::KEY_QC_AUTO_EXPOSURE[] = "auto-exposure";
-const char QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE[] = "auto-exposure-values";
-const char QCameraParameters::KEY_QC_DENOISE[] = "denoise";
-const char QCameraParameters::KEY_QC_SUPPORTED_DENOISE[] = "denoise-values";
-const char QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF[] = "selectable-zone-af";
-const char QCameraParameters::KEY_QC_SUPPORTED_SELECTABLE_ZONE_AF[] = "selectable-zone-af-values";
-const char QCameraParameters::KEY_QC_FACE_DETECTION[] = "face-detection";
-const char QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION[] = "face-detection-values";
-const char QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT[] = "mce";
-const char QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[] = "mce-values";
-const char QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE[] = "video-hfr";
-const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[] = "video-hfr-values";
-const char QCameraParameters::KEY_QC_REDEYE_REDUCTION[] = "redeye-reduction";
-const char QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION[] = "redeye-reduction-values";
-const char QCameraParameters::KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[] = "hdr";
-const char QCameraParameters::KEY_QC_SUPPORTED_HDR_IMAGING_MODES[] = "hdr-values";
-const char QCameraParameters::KEY_QC_POWER_MODE_SUPPORTED[] = "power-mode-supported";
-const char QCameraParameters::KEY_QC_ZSL[] = "zsl";
-const char QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES[] = "zsl-values";
-const char QCameraParameters::KEY_QC_CAMERA_MODE[] = "camera-mode";
-const char QCameraParameters::KEY_QC_AE_BRACKET_HDR[] = "ae-bracket-hdr";
-const char QCameraParameters::KEY_QC_POWER_MODE[] = "power-mode";
-/*only effective when KEY_QC_AE_BRACKET_HDR set to ae_bracketing*/
-//const char QCameraParameters::KEY_QC_AE_BRACKET_SETTING_KEY[] = "ae-bracket-setting";
-
-// Values for effect settings.
-const char QCameraParameters::EFFECT_EMBOSS[] = "emboss";
-const char QCameraParameters::EFFECT_SKETCH[] = "sketch";
-const char QCameraParameters::EFFECT_NEON[] = "neon";
-
-// Values for auto exposure settings.
-const char QCameraParameters::TOUCH_AF_AEC_OFF[] = "touch-off";
-const char QCameraParameters::TOUCH_AF_AEC_ON[] = "touch-on";
-
-// Values for scene mode settings.
-const char QCameraParameters::SCENE_MODE_ASD[] = "asd";   // corresponds to CAMERA_BESTSHOT_AUTO in HAL
-const char QCameraParameters::SCENE_MODE_BACKLIGHT[] = "backlight";
-const char QCameraParameters::SCENE_MODE_FLOWERS[] = "flowers";
-const char QCameraParameters::SCENE_MODE_AR[] = "AR";
-
-// Values for auto scene detection settings.
-const char QCameraParameters::SCENE_DETECT_OFF[] = "off";
-const char QCameraParameters::SCENE_DETECT_ON[] = "on";
-
-// Formats for setPreviewFormat and setPictureFormat.
-const char QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO[] = "yuv420sp-adreno";
-const char QCameraParameters::PIXEL_FORMAT_RAW[] = "raw";
-const char QCameraParameters::PIXEL_FORMAT_YV12[] = "yuv420p";
-const char QCameraParameters::PIXEL_FORMAT_NV12[] = "nv12";
-
-// Values for focus mode settings.
-const char QCameraParameters::FOCUS_MODE_NORMAL[] = "normal";
-const char QCameraParameters::KEY_QC_SKIN_TONE_ENHANCEMENT[] = "skinToneEnhancement";
-const char QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] = "skinToneEnhancement-values";
-
-// Values for ISO Settings
-const char QCameraParameters::ISO_AUTO[] = "auto";
-const char QCameraParameters::ISO_HJR[] = "ISO_HJR";
-const char QCameraParameters::ISO_100[] = "ISO100";
-const char QCameraParameters::ISO_200[] = "ISO200";
-const char QCameraParameters::ISO_400[] = "ISO400";
-const char QCameraParameters::ISO_800[] = "ISO800";
-const char QCameraParameters::ISO_1600[] = "ISO1600";
-
- //Values for Lens Shading
-const char QCameraParameters::LENSSHADE_ENABLE[] = "enable";
-const char QCameraParameters::LENSSHADE_DISABLE[] = "disable";
-
-// Values for auto exposure settings.
-const char QCameraParameters::AUTO_EXPOSURE_FRAME_AVG[] = "frame-average";
-const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED[] = "center-weighted";
-const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING[] = "spot-metering";
-
-const char QCameraParameters::KEY_QC_GPS_LATITUDE_REF[] = "gps-latitude-ref";
-const char QCameraParameters::KEY_QC_GPS_LONGITUDE_REF[] = "gps-longitude-ref";
-const char QCameraParameters::KEY_QC_GPS_ALTITUDE_REF[] = "gps-altitude-ref";
-const char QCameraParameters::KEY_QC_GPS_STATUS[] = "gps-status";
-const char QCameraParameters::KEY_QC_EXIF_DATETIME[] = "exif-datetime";
-
-const char QCameraParameters::KEY_QC_HISTOGRAM[] = "histogram";
-const char QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES[] = "histogram-values";
-
-//Values for Histogram Shading
-const char QCameraParameters::HISTOGRAM_ENABLE[] = "enable";
-const char QCameraParameters::HISTOGRAM_DISABLE[] = "disable";
-
-//Values for Skin Tone Enhancement Modes
-const char QCameraParameters::SKIN_TONE_ENHANCEMENT_ENABLE[] = "enable";
-const char QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE[] = "disable";
-
-const char QCameraParameters::KEY_QC_SHARPNESS[] = "sharpness";
-const char QCameraParameters::KEY_QC_MAX_SHARPNESS[] = "max-sharpness";
-const char QCameraParameters::KEY_QC_CONTRAST[] = "contrast";
-const char QCameraParameters::KEY_QC_MAX_CONTRAST[] = "max-contrast";
-const char QCameraParameters::KEY_QC_SATURATION[] = "saturation";
-const char QCameraParameters::KEY_QC_MAX_SATURATION[] = "max-saturation";
-
-const char QCameraParameters::KEY_QC_SINGLE_ISP_OUTPUT_ENABLED[] = "single-isp-output-enabled";
-const char QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES[] = "qc-camera-features";
-const char QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES[] = "qc-max-num-requested-faces";
-
-//Values for DENOISE
-const char QCameraParameters::DENOISE_OFF[] = "denoise-off";
-const char QCameraParameters::DENOISE_ON[] = "denoise-on";
-
-// Values for selectable zone af Settings
-const char QCameraParameters::SELECTABLE_ZONE_AF_AUTO[] = "auto";
-const char QCameraParameters::SELECTABLE_ZONE_AF_SPOT_METERING[] = "spot-metering";
-const char QCameraParameters::SELECTABLE_ZONE_AF_CENTER_WEIGHTED[] = "center-weighted";
-const char QCameraParameters::SELECTABLE_ZONE_AF_FRAME_AVERAGE[] = "frame-average";
-
-// Values for Face Detection settings.
-const char QCameraParameters::FACE_DETECTION_OFF[] = "off";
-const char QCameraParameters::FACE_DETECTION_ON[] = "on";
-
-// Values for MCE settings.
-const char QCameraParameters::MCE_ENABLE[] = "enable";
-const char QCameraParameters::MCE_DISABLE[] = "disable";
-
-// Values for HFR settings.
-const char QCameraParameters::VIDEO_HFR_OFF[] = "off";
-const char QCameraParameters::VIDEO_HFR_2X[] = "60";
-const char QCameraParameters::VIDEO_HFR_3X[] = "90";
-const char QCameraParameters::VIDEO_HFR_4X[] = "120";
-
-// Values for Redeye Reduction settings.
-const char QCameraParameters::REDEYE_REDUCTION_ENABLE[] = "enable";
-const char QCameraParameters::REDEYE_REDUCTION_DISABLE[] = "disable";
-
-// Values for HDR settings.
-const char QCameraParameters::HDR_ENABLE[] = "enable";
-const char QCameraParameters::HDR_DISABLE[] = "disable";
-
-// Values for ZSL settings.
-const char QCameraParameters::ZSL_OFF[] = "off";
-const char QCameraParameters::ZSL_ON[] = "on";
-
-// Values for HDR Bracketing settings.
-const char QCameraParameters::AE_BRACKET_HDR_OFF[] = "Off";
-const char QCameraParameters::AE_BRACKET_HDR[] = "HDR";
-const char QCameraParameters::AE_BRACKET[] = "AE-Bracket";
-
-const char QCameraParameters::LOW_POWER[] = "Low_Power";
-const char QCameraParameters::NORMAL_POWER[] = "Normal_Power";
-
-static const char* portrait = "portrait";
-static const char* landscape = "landscape";
-
-//QCameraParameters::QCameraParameters()
-//                : mMap()
-//{
-//}
-
-QCameraParameters::~QCameraParameters()
-{
-}
-
-int QCameraParameters::getOrientation() const
-{
-    const char* orientation = get("orientation");
-    if (orientation && !strcmp(orientation, portrait))
-        return CAMERA_ORIENTATION_PORTRAIT;
-    return CAMERA_ORIENTATION_LANDSCAPE;
-}
-void QCameraParameters::setOrientation(int orientation)
-{
-    if (orientation == CAMERA_ORIENTATION_PORTRAIT) {
-        set("orientation", portrait);
-    } else {
-         set("orientation", landscape);
-    }
-}
-
-        //XXX ALOGE("Key \"%s\"contains invalid character (= or ;)", key);
-        //XXX ALOGE("Value \"%s\"contains invalid character (= or ;)", value);
-    //snprintf(str, sizeof(str), "%d", value);
-        //ALOGE("Cannot find delimeter (%c) in str=%s", delim, str);
-
-
-// Parse string like "(1, 2, 3, 4, ..., N)"
-// num is pointer to an allocated array of size N
-static int parseNDimVector(const char *str, int *num, int N, char delim = ',')
-{
-    char *start, *end;
-    if(num == NULL) {
-        ALOGE("Invalid output array (num == NULL)");
-        return -1;
-    }
-    //check if string starts and ends with parantheses
-    if(str[0] != '(' || str[strlen(str)-1] != ')') {
-        ALOGE("Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", str);
-        return -1;
-    }
-    start = (char*) str;
-    start++;
-    for(int i=0; i<N; i++) {
-        *(num+i) = (int) strtol(start, &end, 10);
-        if(*end != delim && i < N-1) {
-            ALOGE("Cannot find delimeter '%c' in string \"%s\". end = %c", delim, str, *end);
-            return -1;
-        }
-        start = end+1;
-    }
-    return 0;
-}
-
-
-            //ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
-    //snprintf(str, sizeof(str), "%dx%d", width, height);
-
-
-
-// Parse string like "640x480" or "10000,20000"
-static int parse_pair(const char *str, int *first, int *second, char delim,
-                      char **endptr = NULL)
-{
-    // Find the first integer.
-    char *end;
-    int w = (int)strtol(str, &end, 10);
-    // If a delimeter does not immediately follow, give up.
-    if (*end != delim) {
-        ALOGE("Cannot find delimeter (%c) in str=%s", delim, str);
-        return -1;
-    }
-
-    // Find the second integer, immediately after the delimeter.
-    int h = (int)strtol(end+1, &end, 10);
-
-    *first = w;
-    *second = h;
-
-    if (endptr) {
-        *endptr = end;
-    }
-
-    return 0;
-}
-
-static void parseSizesList(const char *sizesStr, Vector<Size> &sizes)
-{
-    if (sizesStr == 0) {
-        return;
-    }
-
-    char *sizeStartPtr = (char *)sizesStr;
-
-    while (true) {
-        int width, height;
-        int success = parse_pair(sizeStartPtr, &width, &height, 'x',
-                                 &sizeStartPtr);
-        if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) {
-            ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
-            return;
-        }
-        sizes.push(Size(width, height));
-
-        if (*sizeStartPtr == '\0') {
-            return;
-        }
-        sizeStartPtr++;
-    }
-}
-
-
-void QCameraParameters::getSupportedHfrSizes(Vector<Size> &sizes) const
-{
-    const char *hfrSizesStr = get(KEY_QC_SUPPORTED_HFR_SIZES);
-    parseSizesList(hfrSizesStr, sizes);
-}
-
-void QCameraParameters::setPreviewFpsRange(int minFPS, int maxFPS)
-{
-    char str[32];
-    snprintf(str, sizeof(str), "%d,%d",minFPS,maxFPS);
-    set(KEY_PREVIEW_FPS_RANGE,str);
-}
-
-void QCameraParameters::setPreviewFrameRateMode(const char *mode)
-{
-    set(KEY_QC_PREVIEW_FRAME_RATE_MODE, mode);
-}
-
-const char *QCameraParameters::getPreviewFrameRateMode() const
-{
-    return get(KEY_QC_PREVIEW_FRAME_RATE_MODE);
-}
-
-    //ALOGD("dump: mMap.size = %d", mMap.size());
-        //ALOGD("%s: %s\n", k.string(), v.string());
-void QCameraParameters::setTouchIndexAec(int x, int y)
-{
-    char str[32];
-    snprintf(str, sizeof(str), "%dx%d", x, y);
-    set(KEY_QC_TOUCH_INDEX_AEC, str);
-}
-
-void QCameraParameters::getTouchIndexAec(int *x, int *y) const
-{
-    *x = -1;
-    *y = -1;
-
-    // Get the current string, if it doesn't exist, leave the -1x-1
-    const char *p = get(KEY_QC_TOUCH_INDEX_AEC);
-    if (p == 0)
-        return;
-
-    int tempX, tempY;
-    if (parse_pair(p, &tempX, &tempY, 'x') == 0) {
-        *x = tempX;
-        *y = tempY;
-    }
-}
-
-void QCameraParameters::setTouchIndexAf(int x, int y)
-{
-    char str[32];
-    snprintf(str, sizeof(str), "%dx%d", x, y);
-    set(KEY_QC_TOUCH_INDEX_AF, str);
-}
-
-void QCameraParameters::getTouchIndexAf(int *x, int *y) const
-{
-    *x = -1;
-    *y = -1;
-
-    // Get the current string, if it doesn't exist, leave the -1x-1
-    const char *p = get(KEY_QC_TOUCH_INDEX_AF);
-    if (p == 0)
-        return;
-
-    int tempX, tempY;
-    if (parse_pair(p, &tempX, &tempY, 'x') == 0) {
-        *x = tempX;
-        *y = tempY;
-	}
-}
-
-void QCameraParameters::getMeteringAreaCenter(int *x, int *y) const
-{
-    //Default invalid values
-    *x = -2000;
-    *y = -2000;
-
-    const char *p = get(KEY_METERING_AREAS);
-    if(p != NULL) {
-        int arr[5] = {-2000, -2000, -2000, -2000, 0};
-        parseNDimVector(p, arr, 5); //p = "(x1, y1, x2, y2, weight)"
-        *x = (arr[0] + arr[2])/2; //center_x = (x1+x2)/2
-        *y = (arr[1] + arr[3])/2; //center_y = (y1+y2)/2
-    }
-}
-
-
-}; // namespace android
-
diff --git a/camera/QCamera/HAL/core/src/QCameraStream.cpp b/camera/QCamera/HAL/core/src/QCameraStream.cpp
deleted file mode 100755
index 297af3a..0000000
--- a/camera/QCamera/HAL/core/src/QCameraStream.cpp
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG __FILE__
-#include <utils/Log.h>
-
-#include "QCameraHWI.h"
-#include "QCameraStream.h"
-
-/* QCameraStream class implementation goes here*/
-/* following code implement the control logic of this class*/
-
-namespace android {
-
-// ---------------------------------------------------------------------------
-// QCameraStream
-// ---------------------------------------------------------------------------
-
-void stream_cb_routine(mm_camera_super_buf_t *bufs,
-                       void *userdata)
-{
-    ALOGD("%s E ", __func__);
-    QCameraStream *p_obj=(QCameraStream*) userdata;
-    ALOGD("DEBUG4:ExtMode:%d,streamid:%d",p_obj->mExtImgMode,bufs->bufs[0]->stream_id);
-    switch(p_obj->mExtImgMode)
-    {
-        case MM_CAMERA_PREVIEW:
-            ALOGD("%s : callback for MM_CAMERA_PREVIEW", __func__);
-            ((QCameraStream_preview *)p_obj)->processPreviewFrame(bufs);
-            break;
-        case MM_CAMERA_VIDEO:
-            ((QCameraStream_record *)p_obj)->processRecordFrame(bufs);
-            break;
-        case MM_CAMERA_RDI:
-            ((QCameraStream_Rdi *)p_obj)->processRdiFrame(bufs);
-            break;
-        case MM_CAMERA_SNAPSHOT_MAIN:
-            break;
-        case MM_CAMERA_SNAPSHOT_THUMBNAIL:
-            break;
-        default:
-            break;
-
-    }
-    ALOGD("%s X ", __func__);
-}
-
-void QCameraStream::dataCallback(mm_camera_super_buf_t *bufs)
-{
-}
-
-
-void QCameraStream::setResolution(mm_camera_dimension_t *res)
-{
-    mWidth = res->width;
-    mHeight = res->height;
-}
-bool QCameraStream::isResolutionSame(mm_camera_dimension_t *res)
-{
-    if (mWidth != res->width || mHeight != res->height)
-        return false;
-    else
-        return true;
-}
-void QCameraStream::getResolution(mm_camera_dimension_t *res)
-{
-    res->width = mWidth;
-    res->height = mHeight;
-}
-int32_t QCameraStream::streamOn()
-{
-   status_t rc = NO_ERROR;
-   ALOGD("%s: mActive = %d, streamid = %d, image_mode = %d",__func__, mActive, mStreamId, mExtImgMode);
-   if(mActive){
-       ALOGE("%s: Stream:%d is already active",
-            __func__,mStreamId);
-       return rc;
-   }
-
-   if (mInit == true) {
-       /* this is the restart case, for now we need config again */
-       rc = setFormat();
-       ALOGD("%s: config_stream, rc = %d", __func__, rc);
-   }
-   rc = p_mm_ops->ops->start_streams(mCameraHandle,
-                              mChannelId,
-                              1,
-                              &mStreamId);
-   if(rc == NO_ERROR) {
-       mActive = true;
-   }
-   ALOGD("%s: X, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
-         __func__, mActive, mInit, mStreamId, mExtImgMode);
-   return rc;
-}
-
-int32_t QCameraStream::streamOff(bool isAsyncCmd)
-{
-    status_t rc = NO_ERROR;
-    ALOGD("%s: mActive = %d, streamid = %d, image_mode = %d",__func__, mActive, mStreamId, mExtImgMode);
-    if(!mActive) {
-        ALOGE("%s: Stream:%d is not active",
-              __func__,mStreamId);
-        return rc;
-    }
-    mActive = false;
-
-    rc = p_mm_ops->ops->stop_streams(mCameraHandle,
-                              mChannelId,
-                              1,
-                              &mStreamId);
-
-    ALOGD("%s: X, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
-          __func__, mActive, mInit, mStreamId, mExtImgMode);
-    return rc;
-}
-
-/* initialize a streaming channel*/
-status_t QCameraStream::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
-
-    int rc = MM_CAMERA_OK;
-
-    /* save local copy */
-    m_flag_no_cb = no_cb_needed;
-    m_flag_stream_on = stream_on;
-
-    ALOGD("%s: E, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
-          __func__, mActive, mInit, mStreamId, mExtImgMode);
-
-    if(mInit == true) {
-        ALOGE("%s: alraedy initted, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
-              __func__, mActive, mInit, mStreamId, mExtImgMode);
-        return rc;
-    }
-    /***********Allocate Stream**************/
-    mStreamId = p_mm_ops->ops->add_stream(mCameraHandle,
-                        mChannelId,
-                        no_cb_needed? NULL :  stream_cb_routine,
-                        no_cb_needed? NULL : (void *)this,
-                        mExtImgMode,
-                        0/*sensor_idx*/);
-    if (mStreamId == 0) {
-        ALOGE("%s: err in add_stream, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
-              __func__, mActive, mInit, mStreamId, mExtImgMode);
-       return BAD_VALUE;
-    }
-
-    /***********Config Stream*****************/
-    rc = setFormat();
-    if(MM_CAMERA_OK != rc) {
-        ALOGE("%s: err in config_stream, mActive = %d, streamid = %d, image_mode = %d",
-              __func__, mActive, mStreamId, mExtImgMode);
-        p_mm_ops->ops->del_stream(mCameraHandle,
-                                  mChannelId,
-                                  mStreamId);
-        return BAD_VALUE;
-    }
-
-    mInit=true;
-    ALOGE("%s: X, mActive = %d, streamid = %d, image_mode = %d",
-          __func__, mActive, mStreamId, mExtImgMode);
-    return NO_ERROR;
-}
-
-status_t QCameraStream::deinitStream()
-{
-
-    int rc = MM_CAMERA_OK;
-
-    ALOGD("%s: E, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",__func__, mActive, mInit, mStreamId, mExtImgMode);
-
-    if(mInit == false) {
-        /* stream has not been initted. nop */
-        if (mStreamId > 0) {
-            ALOGE("%s: bug. mStreamId = %d, mInit = %d", __func__, mStreamId, mInit);
-            rc = -1;
-        }
-        return rc;
-    }
-    rc= p_mm_ops->ops->del_stream(mCameraHandle,mChannelId,
-                              mStreamId);
-
-    ALOGV("%s: X, Stream = %d\n", __func__, mStreamId);
-    mInit = false;
-    mStreamId = 0;
-    ALOGD("%s: X, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
-          __func__, mActive, mInit, mStreamId, mExtImgMode);
-    return NO_ERROR;
-}
-
-status_t QCameraStream::setFormat()
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_stream_config_t stream_config;
-
-    ALOGV("%s: E, mActive = %d, streamid = %d, image_mode = %d",__func__, mActive, mStreamId, mExtImgMode);
-    memset(&stream_config, 0, sizeof(mm_camera_stream_config_t));
-
-    switch(mExtImgMode)
-    {
-    case MM_CAMERA_PREVIEW:
-            /* Get mFormat */
-            rc = p_mm_ops->ops->get_parm(p_mm_ops->camera_handle,
-                                MM_CAMERA_PARM_PREVIEW_FORMAT,
-                                &mFormat);
-            if (MM_CAMERA_OK != rc) {
-                ALOGE("%s: error - can't get preview format!", __func__);
-                ALOGD("%s: X", __func__);
-                return rc;
-            }
-            break;
-        case MM_CAMERA_VIDEO:
-            break;
-        case MM_CAMERA_SNAPSHOT_MAIN:
-            stream_config.fmt.rotation = mHalCamCtrl->getJpegRotation();
-            break;
-        case MM_CAMERA_SNAPSHOT_THUMBNAIL:
-            stream_config.fmt.rotation = mHalCamCtrl->getJpegRotation();
-            break;
-        case MM_CAMERA_RDI:
-            mWidth = 0;
-            mHeight = 0;
-            mFormat = CAMERA_BAYER_SBGGR10;
-        default:
-            break;
-    }
-
-    stream_config.fmt.fmt = (cam_format_t)mFormat;
-    stream_config.fmt.meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    stream_config.fmt.width = mWidth;
-    stream_config.fmt.height = mHeight;
-    stream_config.num_of_bufs = mNumBuffers;
-    stream_config.need_stream_on = m_flag_stream_on;
-    rc = p_mm_ops->ops->config_stream(mCameraHandle,
-                              mChannelId,
-                              mStreamId,
-                              &stream_config);
-
-    if(mHalCamCtrl->rdiMode != STREAM_IMAGE) {
-        mHalCamCtrl->mRdiWidth = stream_config.fmt.width;
-        mHalCamCtrl->mRdiHeight = stream_config.fmt.height;
-    }
-
-    mWidth = stream_config.fmt.width;
-    mHeight = stream_config.fmt.height;
-    ALOGD("%s: X",__func__);
-    return rc;
-}
-
-QCameraStream::QCameraStream (){
-    mInit = false;
-    mActive = false;
-    /* memset*/
-    memset(&mCrop, 0, sizeof(mm_camera_rect_t));
-    m_flag_no_cb = FALSE;
-    m_flag_stream_on = TRUE;
-}
-
-QCameraStream::QCameraStream(uint32_t CameraHandle,
-                             uint32_t ChannelId,
-                             uint32_t Width,
-                             uint32_t Height,
-                             uint32_t Format,
-                             uint8_t NumBuffers,
-                             mm_camera_vtbl_t *mm_ops,
-                             mm_camera_img_mode imgmode,
-                             camera_mode_t mode,
-                             QCameraHardwareInterface* camCtrl)
-              : mCameraHandle(CameraHandle),
-                mChannelId(ChannelId),
-                mWidth(Width),
-                mHeight(Height),
-                mFormat(Format),
-                mNumBuffers(NumBuffers),
-                p_mm_ops(mm_ops),
-                mExtImgMode(imgmode),
-                mHalCamCtrl(camCtrl)
-{
-    mInit = false;
-    mActive = false;
-
-    mStreamId = 0;
-    m_flag_no_cb = FALSE;
-    m_flag_stream_on = TRUE;
-
-    /* memset*/
-    memset(&mCrop, 0, sizeof(mm_camera_rect_t));
-}
-
-QCameraStream::~QCameraStream ()
-{
-}
-
-void QCameraStream::release() {
-    return;
-}
-
-int32_t QCameraStream::setCrop()
-{
-    mm_camera_rect_t v4l2_crop;
-    int32_t rc = 0;
-    memset(&v4l2_crop,0,sizeof(v4l2_crop));
-
-    if(!mActive) {
-        ALOGE("%s: Stream:%d is not active", __func__, mStreamId);
-        return -1;
-    }
-
-    rc = p_mm_ops->ops->get_stream_parm(mCameraHandle,
-                                   mChannelId,
-                                   mStreamId,
-                                   MM_CAMERA_STREAM_CROP,
-                                   &v4l2_crop);
-    ALOGI("%s: Crop info received: %d, %d, %d, %d ",
-                                 __func__,
-                                 v4l2_crop.left,
-                                 v4l2_crop.top,
-                                 v4l2_crop.width,
-                                 v4l2_crop.height);
-    if (rc == 0) {
-        mCrop.offset_x = v4l2_crop.left;
-        mCrop.offset_y = v4l2_crop.top;
-        mCrop.width = v4l2_crop.width;
-        mCrop.height = v4l2_crop.height;
-    }
-    return rc;
-}
-
-}; // namespace android
diff --git a/camera/QCamera/HAL/test/Android.mk b/camera/QCamera/HAL/test/Android.mk
deleted file mode 100755
index d3f5a12..0000000
--- a/camera/QCamera/HAL/test/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-

diff --git a/camera/QCamera/HAL/usbcamcore/inc/QCameraMjpegDecode.h b/camera/QCamera/HAL/usbcamcore/inc/QCameraMjpegDecode.h
deleted file mode 100755
index b04182b..0000000
--- a/camera/QCamera/HAL/usbcamcore/inc/QCameraMjpegDecode.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 __QCAMERA_MJPEG_DECODE_H
-#define __QCAMERA_MJPEG_DECODE_H
-
-typedef int MJPEGD_ERR;
-#define MJPEGD_NO_ERROR          0
-#define MJPEGD_ERROR            -1
-#define MJPEGD_INSUFFICIENT_MEM -2
-
-MJPEGD_ERR mjpegDecoderInit(void**);
-
-MJPEGD_ERR mjpegDecoderDestroy(void* mjpegd);
-
-MJPEGD_ERR mjpegDecode(
-            void*   mjpegd,
-            char*   mjpegBuffer,
-            int     mjpegBufferSize,
-            char*   outputYptr,
-            char*   outputUVptr,
-            int     outputFormat);
-
-#endif /* __QCAMERA_MJPEG_DECODE_H */
diff --git a/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbParm.h b/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbParm.h
deleted file mode 100755
index 595bf42..0000000
--- a/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbParm.h
+++ /dev/null
@@ -1,178 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 ANDROID_HARDWARE_QCAMERA_USB_PARM_H
-#define ANDROID_HARDWARE_QCAMERA_USB_PARM_H
-
-
-#include <utils/threads.h>
-#include <hardware/camera.h>
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <camera/Camera.h>
-#include <camera/QCameraParameters.h>
-#include <system/window.h>
-#include <system/camera.h>
-#include <hardware/camera.h>
-#include <gralloc_priv.h>
-#include <hardware/power.h>
-
-extern "C" {
-#include <linux/android_pmem.h>
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include <camera_defs_i.h>
-} //extern C
-
-//Error codes
-#define NOT_FOUND       -1
-
-/******************************************************************************
-* Macro definitions
-******************************************************************************/
-/* enum definitions for picture formats */
-static const int PICTURE_FORMAT_JPEG = 1;
-static const int PICTURE_FORMAT_RAW = 2;
-
-/* Default preview width in pixels */
-#define DEFAULT_USBCAM_PRVW_WD  1280//640
-
-/* Default preview height in pixels */
-#define DEFAULT_USBCAM_PRVW_HT  720//480
-
-/* Default picture format */
-#define DEFAULT_USBCAM_PICT_FMT     PICTURE_FORMAT_JPEG
-
-/* Default picture width in pixels */
-#define DEFAULT_USBCAM_PICT_WD  640
-
-/* Default picture height in pixels */
-#define DEFAULT_USBCAM_PICT_HT  480
-
-/* Default picture JPEG quality 0-100 */
-#define DEFAULT_USBCAM_PICT_QLTY  85
-
-/* Default thumbnail width in pixels */
-#define DEFAULT_USBCAM_THUMBNAIL_WD    432
-
-/* Default thumbnail height in pixels */
-#define DEFAULT_USBCAM_THUMBNAIL_HT    288
-
-/* Default thumbnail JPEG quality 0-100 */
-#define DEFAULT_USBCAM_THUMBNAIL_QLTY  85
-
-/* Default preview format */
-#define DEFAULT_USBCAM_PRVW_FMT HAL_PIXEL_FORMAT_YCrCb_420_SP
-
-/* minimum of the default preview fps range in milli-Hz */
-#define MIN_PREV_FPS            5000
-
-/* maximum of the default preview fps range in milli-Hz */
-#define MAX_PREV_FPS            121000
-
-//for histogram stats
-#define HISTOGRAM_STATS_SIZE 257
-#define NUM_HISTOGRAM_BUFFERS 3
-
-namespace android {
-
-/******************************************************************************
-* Structure definitions
-******************************************************************************/
-typedef struct {
-    uint32_t aspect_ratio;
-    uint32_t width;
-    uint32_t height;
-} thumbnail_size_type;
-
-/******************************************************************************
- * Function: usbCamInitDefaultParameters
- * Description: This function sets default parameters to camera HAL context
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *      0   No error
- *      -1  Error
- *
- * Notes: none
- *****************************************************************************/
-int usbCamInitDefaultParameters(camera_hardware_t *camHal);
-
-/******************************************************************************
- * Function: usbCamSetParameters
- * Description: This function parses the parameter string and stores the
- *              parameters in the camera HAL handle
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  params              - pointer to parameter string
- *
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-int usbCamSetParameters(camera_hardware_t *camHal, const char *params);
-
-/******************************************************************************
- * Function: usbCamGetParameters
- * Description: This function allocates memory for parameter string,
- *              composes and returns the parameter string
- *
- * Input parameters:
- *   camHal             - camera HAL handle
- *
- * Return values:
- *      Address to the parameter string
- *
- * Notes: none
- *****************************************************************************/
-char* usbCamGetParameters(camera_hardware_t *camHal);
-
-/******************************************************************************
- * Function: usbCamPutParameters
- * Description: This function frees the memory allocated for parameter string
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  parms               - Parameter string
- *
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-void usbCamPutParameters(camera_hardware_t *camHal, char *parms);
-
-}; // namespace android
-
-#endif /* ANDROID_HARDWARE_QCAMERA_USB_PARM_H */
diff --git a/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbPriv.h b/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbPriv.h
deleted file mode 100755
index 9b60c11..0000000
--- a/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbPriv.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 ANDROID_HARDWARE_QCAMERA_USB_PRIV_H
-#define ANDROID_HARDWARE_QCAMERA_USB_PRIV_H
-
-namespace android {
-
-/* File name length in number of characters */
-#define FILENAME_LENGTH     (256)
-
-/* Number of display buffers (in addition to minimum number of undequed buffers */
-#define PRVW_DISP_BUF_CNT   2
-
-/* Number of V4L2 capture  buffers. */
-#define PRVW_CAP_BUF_CNT    4
-
-/* Maximum buffer size for JPEG output in number of bytes */
-#define MAX_JPEG_BUFFER_SIZE    (1024 * 1024)
-
-/* Preview loop commands */
-#define USB_CAM_PREVIEW_EXIT    (0x100)
-#define USB_CAM_PREVIEW_PAUSE   (0x101)
-#define USB_CAM_PREVIEW_TAKEPIC (0x200)
-
-/******************************************************************************
- * Macro function to input validate device handle
- *****************************************************************************/
-#define VALIDATE_DEVICE_HDL(camHal, device, ret_err_code)     {\
-    if(device && device->priv){\
-        camHal = (camera_hardware_t *)device->priv;\
-    }else{\
-        ALOGE("%s: Null device or device->priv", __func__);\
-        return ret_err_code;\
-    }\
-}\
-
-/******************************************************************************
- * Macro function to check return status of a function, log and exit the thread
- *****************************************************************************/
-#define ERROR_CHECK_EXIT_THREAD(rc, string)    {\
-    if(rc < 0) {\
-        ALOGE("%s: Error %s", __func__, string);\
-        return (void *)-1;\
-    }\
-}
-
-/******************************************************************************
- * Macro function to check return status of a function, log and exit
- *****************************************************************************/
-#define ERROR_CHECK_EXIT(rc, string)    {\
-    if(rc < 0) {\
-        ALOGE("%s: Error %s", __func__, string);\
-        return -1;\
-    }\
-}
-
-/******************************************************************************
-* Macro function to Print the parameter string 1000 characters at a time
-******************************************************************************/
-#define PRINT_PARAM_STR(parms)    {\
-        char temp[1001] = {0};\
-        int n=0;\
-        while(1) {\
-            strlcpy(temp,parms+n,1000);\
-            ALOGD("parms = %s", temp);\
-            if (strlen(temp) < 1000) break;\
-            n += 1000;\
-        }\
-    }\
-
-/******************************************************************************
- * Macro function to open camera
- *****************************************************************************/
-#define USB_CAM_OPEN(camHal)    {\
-        camHal->fd = open(camHal->dev_name, O_RDWR | O_NONBLOCK, 0);\
-        if(!camHal->fd)\
-            ALOGE("%s: Error in open", __func__);\
-        else\
-            ALOGD("%s: Successfully opened", __func__);\
-        }\
-
-/******************************************************************************
- * Macro function to close camera
- *****************************************************************************/
-#define USB_CAM_CLOSE(camHal) {\
-        int rc;\
-        if(camHal->fd){\
-            rc = close(camHal->fd);\
-            if(0 > rc){\
-                ALOGE("%s: close failed ", __func__);\
-            }\
-            else{\
-                camHal->fd = 0;\
-                ALOGD("%s: close successful", __func__);\
-            }\
-        }\
-    }\
-
-struct bufObj {
-    void    *data;
-    int     len;
-};
-
-typedef struct {
-    camera_device                       hw_dev;
-    Mutex                               lock;
-    int                                 previewEnabledFlag;
-    int                                 prvwStoppedForPicture;
-    int                                 msgEnabledFlag;
-    volatile int                        prvwCmdPending;
-    volatile int                        prvwCmd;
-    pthread_t                           previewThread;
-    pthread_t                           takePictureThread;
-
-    camera_notify_callback              notify_cb;
-    camera_data_callback                data_cb;
-    camera_data_timestamp_callback      data_cb_timestamp;
-    camera_request_memory               get_memory;
-    void*                               cb_ctxt;
-
-    /* capture related members */
-    /* prevFormat is pixel format of preview buffers that are exported */
-    int                                 prevFormat;
-    int                                 prevFps;
-    int                                 prevWidth;
-    int                                 prevHeight;
-    /* captureFormat is internal setting for USB camera buffers */
-    int                                 captureFormat;
-    char                                dev_name[FILENAME_LENGTH];
-    int                                 fd;
-    unsigned int                        n_buffers;
-    struct v4l2_buffer                  curCaptureBuf;
-    struct bufObj                       *buffers;
-
-    /* Display related members */
-    preview_stream_ops*                 window;
-    QCameraHalMemory_t                  previewMem;
-    /* dispFormat is preview display format.Same as preview buffer format*/
-    int                                 dispFormat;
-    int                                 dispWidth;
-    int                                 dispHeight;
-
-    /* MJPEG decoder related members */
-    /* MJPEG decoder object */
-    void*                               mjpegd;
-
-    /* JPEG picture and thumbnail related members */
-    int                                 pictFormat;
-    int                                 pictWidth;
-    int                                 pictHeight;
-    int                                 pictJpegQlty;
-    int                                 thumbnailWidth;
-    int                                 thumbnailHeight;
-    int                                 thumbnailJpegQlty;
-    QCameraHalMemory_t                  pictMem;
-    int                                 takePictInProgress;
-    int                                 jpegEncInProgress;
-    pthread_mutex_t                     jpegEncMutex;
-    pthread_cond_t                      jpegEncCond;
-
-    /* */
-    QCameraParameters                   qCamParams;
-    String8                             prevSizeValues;
-    String8                             pictSizeValues;
-    String8                             thumbnailSizeValues;
-    String8                             vidSizeValues;
-    String8                             pictFormatValues;
-    String8                             prevFormatValues;
-    String8                             prevFpsRangesValues;
-
-} camera_hardware_t;
-
-
-}; // namespace android
-
-#endif /* ANDROID_HARDWARE_QCAMERA_USB_PRIV_H */
diff --git a/camera/QCamera/HAL/usbcamcore/inc/QualcommUsbCamera.h b/camera/QCamera/HAL/usbcamcore/inc/QualcommUsbCamera.h
deleted file mode 100755
index e389c76..0000000
--- a/camera/QCamera/HAL/usbcamcore/inc/QualcommUsbCamera.h
+++ /dev/null
@@ -1,243 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 ANDROID_HARDWARE_QUALCOMM_CAMERA_USBCAM_H
-#define ANDROID_HARDWARE_QUALCOMM_CAMERA_USBCAM_H
-
-extern "C" {
-#include <sys/time.h>
-}
-
-#include "QCameraHWI.h"
-
-extern "C" {
-
-/*#include <hardware/camera.h>*/
-
-    int usbcam_get_number_of_cameras();
-    int usbcam_get_camera_info(int camera_id, struct camera_info *info);
-
-    int usbcam_camera_device_open(const struct hw_module_t* module, const char* id,
-          struct hw_device_t** device);
-
-    hw_device_t * usbcam_open_camera_device(int cameraId);
-
-    int usbcam_close_camera_device( hw_device_t *);
-
-namespace android {
-
-    /** Set the ANativeWindow to which preview frames are sent */
-    int usbcam_set_preview_window(struct camera_device *,
-          struct preview_stream_ops *window);
-
-    /** Set the notification and data callbacks */
-    void usbcam_set_CallBacks(struct camera_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);
-
-    /**
-     * The following three functions all take a msg_type, which is a bitmask of
-     * the messages defined in include/ui/Camera.h
-     */
-
-    /**
-     * Enable a message, or set of messages.
-     */
-    void usbcam_enable_msg_type(struct camera_device *, int32_t msg_type);
-
-    /**
-     * Disable a message, or a set of messages.
-     *
-     * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
-     * HAL should not rely on its client to call releaseRecordingFrame() to
-     * release video recording frames sent out by the cameral HAL before and
-     * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
-     * clients must not modify/access any video recording frame after calling
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
-     */
-    void usbcam_disable_msg_type(struct camera_device *, int32_t msg_type);
-
-    /**
-     * 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 usbcam_msg_type_enabled(struct camera_device *, int32_t msg_type);
-
-    /**
-     * Start preview mode.
-     */
-    int usbcam_start_preview(struct camera_device *);
-
-    /**
-     * Stop a previously started preview.
-     */
-    void usbcam_stop_preview(struct camera_device *);
-
-    /**
-     * Returns true if preview is enabled.
-     */
-    int usbcam_preview_enabled(struct camera_device *);
-
-    /**
-     * Request the camera HAL to store meta data or real YUV data in the video
-     * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
-     * it is not called, the default camera HAL behavior is to store real YUV
-     * data in the video buffers.
-     *
-     * This method should be called before startRecording() in order to be
-     * effective.
-     *
-     * If meta data is stored in the video buffers, it is up to the receiver of
-     * the video buffers to interpret the contents and to find the actual frame
-     * data with the help of the meta data in the buffer. How this is done is
-     * outside of the scope of this method.
-     *
-     * Some camera HALs may not support storing meta data in the video buffers,
-     * but all camera HALs should support storing real YUV data in the video
-     * buffers. If the camera HAL does not support storing the meta data in the
-     * video buffers when it is requested to do do, INVALID_OPERATION must be
-     * returned. It is very useful for the camera HAL to pass meta data rather
-     * than the actual frame data directly to the video encoder, since the
-     * amount of the uncompressed frame data can be very large if video size is
-     * large.
-     *
-     * @param enable if true to instruct the camera HAL to store
-     *        meta data in the video buffers; false to instruct
-     *        the camera HAL to store real YUV data in the video
-     *        buffers.
-     *
-     * @return OK on success.
-     */
-    int usbcam_store_meta_data_in_buffers(struct camera_device *, int enable);
-
-    /**
-     * 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 a camera HAL client via
-     * releaseRecordingFrame() before the client calls
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
-     * responsibility to manage the life-cycle of the video recording frames,
-     * and the client must not modify/access any video recording frames.
-     */
-    int usbcam_start_recording(struct camera_device *);
-
-    /**
-     * Stop a previously started recording.
-     */
-    void usbcam_stop_recording(struct camera_device *);
-
-    /**
-     * Returns true if recording is enabled.
-     */
-    int usbcam_recording_enabled(struct camera_device *);
-
-    /**
-     * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
-     *
-     * It is camera HAL client's responsibility to release video recording
-     * frames sent out by the camera HAL before the camera HAL receives a call
-     * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
-     * responsibility to manage the life-cycle of the video recording frames.
-     */
-    void usbcam_release_recording_frame(struct camera_device *,
-                  const void *opaque);
-
-    /**
-     * 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 usbcam_auto_focus(struct camera_device *);
-
-    /**
-     * 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 usbcam_cancel_auto_focus(struct camera_device *);
-
-    /**
-     * Take a picture.
-     */
-    int usbcam_take_picture(struct camera_device *);
-
-    /**
-     * Cancel a picture that was started with takePicture. Calling this method
-     * when no picture is being taken is a no-op.
-     */
-    int usbcam_cancel_picture(struct camera_device *);
-
-    /**
-     * Set the camera parameters. This returns BAD_VALUE if any parameter is
-     * invalid or not supported.
-     */
-    int usbcam_set_parameters(struct camera_device *, const char *parms);
-
-    //status_t setParameters(const QCameraParameters& params);
-    /** Retrieve the camera parameters.  The buffer returned by the camera HAL
-        must be returned back to it with put_parameters, if put_parameters
-        is not NULL.
-     */
-    char* usbcam_get_parameters(struct camera_device *);
-
-    /** The camera HAL uses its own memory to pass us the parameters when we
-        call get_parameters.  Use this function to return the memory back to
-        the camera HAL, if put_parameters is not NULL.  If put_parameters
-        is NULL, then you have to use free() to release the memory.
-    */
-    void usbcam_put_parameters(struct camera_device *, char *);
-
-    /**
-     * Send command to camera driver.
-     */
-    int usbcam_send_command(struct camera_device *,
-              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 usbcam_release(struct camera_device *);
-
-    /**
-     * Dump state of the camera hardware
-     */
-    int usbcam_dump(struct camera_device *, int fd);
-
-}; // namespace android
-
-} //extern "C"
-
-#endif
diff --git a/camera/QCamera/HAL/usbcamcore/src/QCameraMjpegDecode.cpp b/camera/QCamera/HAL/usbcamcore/src/QCameraMjpegDecode.cpp
deleted file mode 100755
index dcf0aa2..0000000
--- a/camera/QCamera/HAL/usbcamcore/src/QCameraMjpegDecode.cpp
+++ /dev/null
@@ -1,701 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraMjpegDecode"
-#include <utils/Log.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-
-extern "C" {
-#include "jpeg_buffer.h"
-#include "jpeg_common.h"
-#include "jpegd.h"
-}
-
-#include "QCameraMjpegDecode.h"
-
-/* TBDJ: Can be removed */
-#define MIN(a,b)  (((a) < (b)) ? (a) : (b))
-
-// Abstract the return type of the function to be run as a thread
-#define OS_THREAD_FUNC_RET_T            void *
-
-// Abstract the argument type to the thread function
-#define OS_THREAD_FUNC_ARG_T            void *
-
-// Helpful constants for return values in the thread functions
-#define OS_THREAD_FUNC_RET_SUCCEEDED    (OS_THREAD_FUNC_RET_T)0
-#define OS_THREAD_FUNC_RET_FAILED       (OS_THREAD_FUNC_RET_T)1
-
-// Abstract the function modifier placed in the beginning of the thread
-// declaration (empty for Linux)
-#define OS_THREAD_FUNC_MODIFIER
-
-#define os_mutex_init(a) pthread_mutex_init(a, NULL)
-#define os_cond_init(a)  pthread_cond_init(a, NULL)
-#define os_mutex_lock    pthread_mutex_lock
-#define os_mutex_unlock  pthread_mutex_unlock
-#define os_cond_wait     pthread_cond_wait
-#define os_cond_signal   pthread_cond_signal
-
-const char event_to_string[4][14] =
-{
-    "EVENT_DONE",
-    "EVENT_WARNING",
-    "EVENT_ERROR",
-};
-
-typedef struct
-{
-    uint32_t   width;
-    uint32_t   height;
-    uint32_t   format;
-    uint32_t   preference;
-    uint32_t   abort_time;
-    uint16_t   back_to_back_count;
-    /* TBDJ: Is this required */
-    int32_t    rotation;
-    /* TBDJ: Is this required */
-    jpeg_rectangle_t region;
-    /* TBDJ: Is this required */
-    jpegd_scale_type_t scale_factor;
-    uint32_t   hw_rotation;
-
-    char*       inputMjpegBuffer;
-    int         inputMjpegBufferSize;
-    char*       outputYptr;
-    char*       outputUVptr;
-
-} test_args_t;
-
-typedef struct
-{
-    int                   tid;
-    pthread_t             thread;
-    jpegd_obj_t           decoder;
-    uint8_t               decoding;
-    uint8_t               decode_success;
-    pthread_mutex_t       mutex;
-    pthread_cond_t        cond;
-    test_args_t           *p_args;
-    jpegd_output_buf_t    *p_whole_output_buf;
-
-} thread_ctrl_blk_t;
-
-OS_THREAD_FUNC_RET_T OS_THREAD_FUNC_MODIFIER decoder_test(OS_THREAD_FUNC_ARG_T p_thread_args);
-void decoder_event_handler(void        *p_user_data,
-                           jpeg_event_t event,
-                           void        *p_arg);
-int decoder_output_handler(void               *p_user_data,
-                           jpegd_output_buf_t *p_output_buffer,
-                           uint32_t            first_row_id,
-                           uint8_t             is_last_buffer);
-uint32_t decoder_input_req_handler(void           *p_user_data,
-                                   jpeg_buffer_t   buffer,
-                                   uint32_t        start_offset,
-                                   uint32_t        length);
-static void* insertHuffmanTable(void *p, int size);
-
-static int mjpegd_timer_start(timespec *p_timer);
-static int mjpegd_timer_get_elapsed(timespec *p_timer, int *elapsed_in_ms, uint8_t reset_start);
-static int mjpegd_cond_timedwait(pthread_cond_t *p_cond, pthread_mutex_t *p_mutex, uint32_t ms);
-
-// Global variables
-/* TBDJ: can be removed */
-thread_ctrl_blk_t *thread_ctrl_blks = NULL;
-
-/*
- * This function initializes the mjpeg decoder and returns the object
- */
-MJPEGD_ERR mjpegDecoderInit(void** mjpegd_obj)
-{
-    test_args_t* mjpegd;
-
-    ALOGD("%s: E", __func__);
-
-    mjpegd = (test_args_t *)malloc(sizeof(test_args_t));
-    if(!mjpegd)
-        return MJPEGD_INSUFFICIENT_MEM;
-
-    memset(mjpegd, 0, sizeof(test_args_t));
-
-    /* Defaults */
-    /* Due to current limitation, s/w decoder is selected always */
-    mjpegd->preference          = JPEG_DECODER_PREF_HW_ACCELERATED_PREFERRED;
-    mjpegd->back_to_back_count  = 1;
-    mjpegd->rotation            = 0;
-    mjpegd->hw_rotation         = 0;
-    mjpegd->scale_factor        = (jpegd_scale_type_t)1;
-
-    /* TBDJ: can be removed */
-    mjpegd->width                 = 640;
-    mjpegd->height                = 480;
-    mjpegd->abort_time            = 0;
-
-    *mjpegd_obj = (void *)mjpegd;
-
-    ALOGD("%s: X", __func__);
-    return  MJPEGD_NO_ERROR;
-}
-
-MJPEGD_ERR mjpegDecode(
-            void*   mjpegd_obj,
-            char*   inputMjpegBuffer,
-            int     inputMjpegBufferSize,
-            char*   outputYptr,
-            char*   outputUVptr,
-            int     outputFormat)
-{
-    int rc, c, i;
-    test_args_t* mjpegd;
-    test_args_t  test_args;
-
-    ALOGD("%s: E", __func__);
-    /* store input arguments in the context */
-    mjpegd = (test_args_t*) mjpegd_obj;
-    mjpegd->inputMjpegBuffer        = inputMjpegBuffer;
-    mjpegd->inputMjpegBufferSize    = inputMjpegBufferSize;
-    mjpegd->outputYptr              = outputYptr;
-    mjpegd->outputUVptr             = outputUVptr;
-    mjpegd->format                  = outputFormat;
-
-    /* TBDJ: can be removed */
-    memcpy(&test_args, mjpegd, sizeof(test_args_t));
-
-    // check the formats
-    if (((test_args.format == YCRCBLP_H1V2) || (test_args.format == YCBCRLP_H1V2) ||
-      (test_args.format == YCRCBLP_H1V1) || (test_args.format == YCBCRLP_H1V1)) &&
-      !(test_args.preference == JPEG_DECODER_PREF_HW_ACCELERATED_ONLY)) {
-        ALOGE("%s:These formats are not supported by SW format %d", __func__, test_args.format);
-        return 1;
-    }
-
-    // Create thread control blocks
-    thread_ctrl_blks = (thread_ctrl_blk_t *)malloc( sizeof(thread_ctrl_blk_t));
-    if (!thread_ctrl_blks)
-    {
-        ALOGE("%s: decoder_test failed: insufficient memory in creating thread control blocks", __func__);
-        return 1;
-    }
-    memset(thread_ctrl_blks, 0, sizeof(thread_ctrl_blk_t));
-    // Initialize the blocks and kick off the threads
-        thread_ctrl_blks[i].tid = i;
-        thread_ctrl_blks[i].p_args = &test_args;
-        os_mutex_init(&thread_ctrl_blks[i].mutex);
-        os_cond_init(&thread_ctrl_blks[i].cond);
-
-    rc = (int)decoder_test(&thread_ctrl_blks[i]);
-
-    if (!rc)
-        ALOGD("%s: decoder_test finished successfully ", __func__);
-    else
-        ALOGE("%s: decoder_test failed",__func__);
-
-    ALOGD("%s: X rc: %d", __func__, rc);
-
-    return rc;
-}
-
-OS_THREAD_FUNC_RET_T OS_THREAD_FUNC_MODIFIER decoder_test(OS_THREAD_FUNC_ARG_T arg)
-{
-    int rc, i;
-    jpegd_obj_t         decoder;
-    jpegd_src_t         source;
-    jpegd_dst_t         dest;
-    jpegd_cfg_t         config;
-    jpeg_hdr_t          header;
-    jpegd_output_buf_t  p_output_buffers;
-    uint32_t            output_buffers_count = 1; // currently only 1 buffer a time is supported
-    uint8_t use_pmem = true;
-    timespec os_timer;
-    thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)arg;
-    test_args_t *p_args = p_thread_arg->p_args;
-    uint32_t            output_width;
-    uint32_t            output_height;
-    uint32_t total_time = 0;
-
-    ALOGD("%s: E", __func__);
-
-    // Determine whether pmem should be used (useful for pc environment testing where
-    // pmem is not available)
-    if ((jpegd_preference_t)p_args->preference == JPEG_DECODER_PREF_SOFTWARE_PREFERRED ||
-        (jpegd_preference_t)p_args->preference == JPEG_DECODER_PREF_SOFTWARE_ONLY) {
-        use_pmem = false;
-    }
-
-    if (((jpegd_preference_t)p_args->preference !=
-      JPEG_DECODER_PREF_HW_ACCELERATED_ONLY) &&
-      ((jpegd_preference_t)p_args->scale_factor > 0)) {
-        ALOGI("%s: Setting scale factor to 1x", __func__);
-    }
-
-    ALOGD("%s: before jpegd_init p_thread_arg: %p", __func__, p_thread_arg);
-
-    // Initialize decoder
-    rc = jpegd_init(&decoder,
-                    &decoder_event_handler,
-                    &decoder_output_handler,
-                    p_thread_arg);
-
-    if (JPEG_FAILED(rc)) {
-        ALOGE("%s: decoder_test: jpegd_init failed", __func__);
-        goto fail;
-    }
-    p_thread_arg->decoder = decoder;
-
-    // Set source information
-    source.p_input_req_handler = &decoder_input_req_handler;
-    source.total_length        = p_args->inputMjpegBufferSize & 0xffffffff;
-
-    rc = jpeg_buffer_init(&source.buffers[0]);
-    if (JPEG_SUCCEEDED(rc)) {
-        /* TBDJ: why buffer [1] */
-        rc = jpeg_buffer_init(&source.buffers[1]);
-    }
-    if (JPEG_SUCCEEDED(rc)) {
-#if 1
-        rc = jpeg_buffer_allocate(source.buffers[0], 0xA000, use_pmem);
-#else
-        rc = jpeg_buffer_use_external_buffer(source.buffers[0],
-                                             (uint8_t *)p_args->inputMjpegBuffer,
-                                             p_args->inputMjpegBufferSize,
-                                             0);
-#endif
-        ALOGD("%s: source.buffers[0]:%p compressed buffer ptr = %p", __func__,
-              source.buffers[0], p_args->inputMjpegBuffer);
-    }
-    if (JPEG_SUCCEEDED(rc)) {
-#if 1
-        rc = jpeg_buffer_allocate(source.buffers[1], 0xA000, use_pmem);
-#else
-         rc = jpeg_buffer_use_external_buffer(source.buffers[1],
-                                             (uint8_t *)p_args->inputMjpegBuffer,
-                                             p_args->inputMjpegBufferSize,
-                                             0);
-#endif
-        ALOGD("%s: source.buffers[1]:%p compressed buffer ptr  = %p", __func__,
-              source.buffers[1], p_args->inputMjpegBuffer);
-   }
-    if (JPEG_FAILED(rc)) {
-        jpeg_buffer_destroy(&source.buffers[0]);
-        jpeg_buffer_destroy(&source.buffers[1]);
-        goto fail;
-    }
-
-   ALOGI("%s: *** Starting back-to-back decoding of %d frame(s)***\n",
-                 __func__, p_args->back_to_back_count);
-
-	 // Loop to perform n back-to-back decoding (to the same output file)
-    for(i = 0; i < p_args->back_to_back_count; i++) {
-        if(mjpegd_timer_start(&os_timer) < 0) {
-            ALOGE("%s: failed to get start time", __func__);
-        }
-
-        /* TBDJ: Every frame? */
-        ALOGD("%s: before jpegd_set_source source.p_arg:%p", __func__, source.p_arg);
-        rc = jpegd_set_source(decoder, &source);
-        if (JPEG_FAILED(rc))
-        {
-            ALOGE("%s: jpegd_set_source failed", __func__);
-            goto fail;
-        }
-
-        rc = jpegd_read_header(decoder, &header);
-        if (JPEG_FAILED(rc))
-        {
-            ALOGE("%s: jpegd_read_header failed", __func__);
-            goto fail;
-        }
-        p_args->width = header.main.width;
-        p_args->height = header.main.height;
-        ALOGD("%s: main dimension: (%dx%d) subsampling: (%d)", __func__,
-                header.main.width, header.main.height, (int)header.main.subsampling);
-
-        // main image decoding:
-        // Set destination information
-        dest.width = (p_args->width) ? (p_args->width) : header.main.width;
-        dest.height = (p_args->height) ? (p_args->height) : header.main.height;
-        dest.output_format = (jpeg_color_format_t) p_args->format;
-        dest.region = p_args->region;
-
-        // if region is defined, re-assign the output width/height
-        output_width  = dest.width;
-        output_height = dest.height;
-
-        if (p_args->region.right || p_args->region.bottom)
-        {
-            if (0 == p_args->rotation || 180 == p_args->rotation)
-            {
-                output_width  = MIN((dest.width),
-                        (uint32_t)(dest.region.right  - dest.region.left + 1));
-                output_height = MIN((dest.height),
-                        (uint32_t)(dest.region.bottom - dest.region.top  + 1));
-            }
-            // Swap output width/height for 90/270 rotation cases
-            else if (90 == p_args->rotation || 270 == p_args->rotation)
-            {
-                output_height  = MIN((dest.height),
-                        (uint32_t)(dest.region.right  - dest.region.left + 1));
-                output_width   = MIN((dest.width),
-                        (uint32_t)(dest.region.bottom - dest.region.top  + 1));
-            }
-            // Unsupported rotation cases
-            else
-            {
-                goto fail;
-            }
-        }
-
-        if (dest.output_format == YCRCBLP_H2V2 || dest.output_format == YCBCRLP_H2V2 ||
-            dest.output_format == YCRCBLP_H2V1 || dest.output_format == YCBCRLP_H2V1 ||
-            dest.output_format == YCRCBLP_H1V2 || dest.output_format == YCBCRLP_H1V2 ||
-            dest.output_format == YCRCBLP_H1V1 || dest.output_format == YCBCRLP_H1V1) {
-            jpeg_buffer_init(&p_output_buffers.data.yuv.luma_buf);
-            jpeg_buffer_init(&p_output_buffers.data.yuv.chroma_buf);
-        } else {
-            jpeg_buffer_init(&p_output_buffers.data.rgb.rgb_buf);
-
-        }
-
-        {
-            // Assign 0 to tile width and height
-            // to indicate that no tiling is requested.
-            p_output_buffers.tile_width  = 0;
-            p_output_buffers.tile_height = 0;
-        }
-        p_output_buffers.is_in_q = 0;
-
-        switch (dest.output_format)
-        {
-        case YCRCBLP_H2V2:
-        case YCBCRLP_H2V2:
-//        case YCRCBLP_H2V1:
-//        case YCBCRLP_H2V1:
-//        case YCRCBLP_H1V2:
-//        case YCBCRLP_H1V2:
-//        case YCRCBLP_H1V1:
-//        case YCBCRLP_H1V1:
-            jpeg_buffer_use_external_buffer(
-               p_output_buffers.data.yuv.luma_buf,
-               (uint8_t*)p_args->outputYptr,
-               p_args->width * p_args->height * SQUARE(p_args->scale_factor),
-               0);
-            jpeg_buffer_use_external_buffer(
-                p_output_buffers.data.yuv.chroma_buf,
-                (uint8_t*)p_args->outputUVptr,
-                p_args->width * p_args->height / 2 * SQUARE(p_args->scale_factor),
-                0);
-            break;
-
-        default:
-            ALOGE("%s: decoder_test: unsupported output format", __func__);
-            goto fail;
-        }
-
-        // Set up configuration
-        memset(&config, 0, sizeof(jpegd_cfg_t));
-        config.preference = (jpegd_preference_t) p_args->preference;
-        config.decode_from = JPEGD_DECODE_FROM_AUTO;
-        config.rotation = p_args->rotation;
-        config.scale_factor = p_args->scale_factor;
-        config.hw_rotation = p_args->hw_rotation;
-        dest.back_to_back_count = p_args->back_to_back_count;
-
-        // Start decoding
-        p_thread_arg->decoding = true;
-
-        rc = jpegd_start(decoder, &config, &dest, &p_output_buffers, output_buffers_count);
-        dest.back_to_back_count--;
-
-        if(JPEG_FAILED(rc)) {
-            ALOGE("%s: decoder_test: jpegd_start failed (rc=%d)\n",
-                    __func__, rc);
-            goto fail;
-        }
-
-        ALOGD("%s: decoder_test: jpegd_start succeeded", __func__);
-
-        // Do abort
-        if (p_args->abort_time) {
-            os_mutex_lock(&p_thread_arg->mutex);
-            while (p_thread_arg->decoding)
-            {
-                rc = mjpegd_cond_timedwait(&p_thread_arg->cond, &p_thread_arg->mutex, p_args->abort_time);
-                if (rc == JPEGERR_ETIMEDOUT)
-                {
-                    // Do abort
-                    os_mutex_unlock(&p_thread_arg->mutex);
-                    rc = jpegd_abort(decoder);
-                    if (rc)
-                    {
-                        ALOGE("%s: decoder_test: jpegd_abort failed: %d", __func__, rc);
-                        goto fail;
-                    }
-                    break;
-                }
-            }
-            if (p_thread_arg->decoding)
-                os_mutex_unlock(&p_thread_arg->mutex);
-        } else {
-            // Wait until decoding is done or stopped due to error
-            os_mutex_lock(&p_thread_arg->mutex);
-            while (p_thread_arg->decoding)
-            {
-                os_cond_wait(&p_thread_arg->cond, &p_thread_arg->mutex);
-            }
-            os_mutex_unlock(&p_thread_arg->mutex);
-        }
-
-        int diff;
-        // Display the time elapsed
-        if (mjpegd_timer_get_elapsed(&os_timer, &diff, 0) < 0) {
-            ALOGE("%s: decoder_test: failed to get elapsed time", __func__);
-        } else {
-            if(p_args->abort_time) {
-                if(p_thread_arg->decoding) {
-                    ALOGI("%s: decoder_test: decoding aborted successfully after %d ms", __func__, diff);
-                    goto buffer_clean_up;
-                }
-                else
-                {
-                    ALOGI("%s: decoder_test: decoding stopped before abort is issued. "
-                                    "decode time: %d ms", __func__, diff);
-                }
-            }
-            else {
-                if(p_thread_arg->decode_success) {
-                    total_time += diff;
-                    ALOGI("%s: decode time: %d ms (%d frame(s), total=%dms, avg=%dms/frame)",
-                            __func__, diff, i+1, total_time, total_time/(i+1));
-                }
-                else
-                {
-                    fprintf(stderr, "decoder_test: decode failed\n");
-                }
-            }
-        }
-    }
-
-    if(p_thread_arg->decode_success) {
-        ALOGD("%s: Frame(s) = %d, Total Time = %dms, Avg. decode time = %dms/frame)\n",
-                 __func__, p_args->back_to_back_count, total_time, total_time/p_args->back_to_back_count);
-    }
-
-buffer_clean_up:
-    // Clean up decoder and allocate buffers
-    jpeg_buffer_destroy(&source.buffers[0]);
-    jpeg_buffer_destroy(&source.buffers[1]);
-    switch (dest.output_format)
-    {
-    case YCRCBLP_H2V2:
-    case YCBCRLP_H2V2:
-    case YCRCBLP_H2V1:
-    case YCBCRLP_H2V1:
-    case YCRCBLP_H1V2:
-    case YCBCRLP_H1V2:
-    case YCRCBLP_H1V1:
-    case YCBCRLP_H1V1:
-        jpeg_buffer_destroy(&p_output_buffers.data.yuv.luma_buf);
-        jpeg_buffer_destroy(&p_output_buffers.data.yuv.chroma_buf);
-        break;
-    default:
-        break;
-    }
-    jpegd_destroy(&decoder);
-
-    if (!p_thread_arg->decode_success)
-    {
-        goto fail;
-    }
-
-    ALOGD("%s: X", __func__);
-    return OS_THREAD_FUNC_RET_SUCCEEDED;
-fail:
-
-    ALOGD("%s: X", __func__);
-    return OS_THREAD_FUNC_RET_FAILED;
-}
-
-void decoder_event_handler(void        *p_user_data,
-                           jpeg_event_t event,
-                           void        *p_arg)
-{
-    thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
-
-    ALOGD("%s: E", __func__);
-
-    ALOGD("%s: Event: %s\n", __func__, event_to_string[event]);
-    if (event == JPEG_EVENT_DONE)
-    {
-        p_thread_arg->decode_success = true;
-        ALOGD("%s: decode_success: %d\n", __func__, p_thread_arg->decode_success);
-    }
-    // If it is not a warning event, decoder has stopped; Signal
-    // main thread to clean up
-    if (event != JPEG_EVENT_WARNING)
-    {
-        os_mutex_lock(&p_thread_arg->mutex);
-        p_thread_arg->decoding = false;
-        os_cond_signal(&p_thread_arg->cond);
-        os_mutex_unlock(&p_thread_arg->mutex);
-    }
-    ALOGD("%s: X", __func__);
-
-}
-
-// consumes the output buffer.
-/*TBDJ: Can be removed. Is this related to tiling */
-int decoder_output_handler(void *p_user_data,
-                           jpegd_output_buf_t *p_output_buffer,
-                           uint32_t first_row_id,
-                           uint8_t is_last_buffer)
-{
-    uint8_t* whole_output_buf_ptr, *tiling_buf_ptr;
-
-    ALOGD("%s: E", __func__);
-
-    thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
-
-    jpeg_buffer_get_addr(p_thread_arg->p_whole_output_buf->data.rgb.rgb_buf, &whole_output_buf_ptr);
-    jpeg_buffer_get_addr(p_output_buffer->data.rgb.rgb_buf, &tiling_buf_ptr);
-
-    if (p_output_buffer->tile_height != 1)
-        return JPEGERR_EUNSUPPORTED;
-
-    // testing purpose only
-    // This is to simulate that the user needs to bail out when error happens
-    // in the middle of decoding
-    //if (first_row_id == 162)
-     //   return JPEGERR_EFAILED;
-
-    // do not enqueue any buffer if it reaches the last buffer
-    if (!is_last_buffer)
-    {
-        jpegd_enqueue_output_buf(p_thread_arg->decoder, p_output_buffer, 1);
-    }
-    ALOGD("%s: X", __func__);
-
-    return JPEGERR_SUCCESS;
-}
-
-//      p_reader->p_input_req_handler(p_reader->decoder,
-//                                    p_reader->p_input_buf,
-//                                    p_reader->next_byte_offset,
-//                                    MAX_BYTES_TO_FETCH);
-
-uint32_t decoder_input_req_handler(void           *p_user_data,
-                                   jpeg_buffer_t   buffer,
-                                   uint32_t        start_offset,
-                                   uint32_t        length)
-{
-    uint32_t buf_size;
-    uint8_t *buf_ptr;
-    int bytes_to_read, bytes_read, rc;
-    thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
-    thread_ctrl_blk_t *thread_ctrl_blk = (thread_ctrl_blk_t *)p_user_data;
-    test_args_t*    mjpegd = (test_args_t*) thread_ctrl_blk->p_args;
-
-    ALOGD("%s: E", __func__);
-
-    jpeg_buffer_get_max_size(buffer, &buf_size);
-    jpeg_buffer_get_addr(buffer, &buf_ptr);
-    bytes_to_read = (length < buf_size) ? length : buf_size;
-    bytes_read = 0;
-
-    ALOGD("%s: buf_ptr = %p, start_offset = %d, length = %d buf_size = %d bytes_to_read = %d", __func__, buf_ptr, start_offset, length, buf_size, bytes_to_read);
-    if (bytes_to_read)
-    {
-        /* TBDJ: Should avoid this Mem copy */
-#if 1
-        memcpy(buf_ptr, (char *)mjpegd->inputMjpegBuffer + start_offset, bytes_to_read);
-#else
-        if(JPEGERR_SUCCESS != jpeg_buffer_set_start_offset(buffer, start_offset))
-            ALOGE("%s: jpeg_buffer_set_start_offset failed", __func__);
-#endif
-        bytes_read = bytes_to_read;
-    }
-
-    ALOGD("%s: X", __func__);
-    return bytes_read;
-}
-
-static int mjpegd_timer_start(timespec *p_timer)
-{
-    if (!p_timer)
-        return JPEGERR_ENULLPTR;
-
-    if (clock_gettime(CLOCK_REALTIME, p_timer))
-        return JPEGERR_EFAILED;
-
-    return JPEGERR_SUCCESS;
-}
-
-static int mjpegd_timer_get_elapsed(timespec *p_timer, int *elapsed_in_ms, uint8_t reset_start)
-{
-    timespec now;
-    long diff;
-    int rc = mjpegd_timer_start(&now);
-
-    if (JPEG_FAILED(rc))
-        return rc;
-
-    diff = (long)(now.tv_sec - p_timer->tv_sec) * 1000;
-    diff += (long)(now.tv_nsec - p_timer->tv_nsec) / 1000000;
-    *elapsed_in_ms = (int)diff;
-
-    if (reset_start)
-        *p_timer = now;
-
-    return JPEGERR_SUCCESS;
-}
-
-int mjpegd_cond_timedwait(pthread_cond_t *p_cond, pthread_mutex_t *p_mutex, uint32_t ms)
-{
-    struct timespec ts;
-    int rc = clock_gettime(CLOCK_REALTIME, &ts);
-    if (rc < 0) return rc;
-
-    if (ms >= 1000) {
-       ts.tv_sec += (ms/1000);
-       ts.tv_nsec += ((ms%1000) * 1000000);
-    } else {
-        ts.tv_nsec += (ms * 1000000);
-    }
-
-    rc = pthread_cond_timedwait(p_cond, p_mutex, &ts);
-    if (rc == ETIMEDOUT)
-    {
-        rc = JPEGERR_ETIMEDOUT;
-    }
-    return rc;
-}
-
diff --git a/camera/QCamera/HAL/usbcamcore/src/QCameraUsbParm.cpp b/camera/QCamera/HAL/usbcamcore/src/QCameraUsbParm.cpp
deleted file mode 100755
index fda6e9d..0000000
--- a/camera/QCamera/HAL/usbcamcore/src/QCameraUsbParm.cpp
+++ /dev/null
@@ -1,683 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraUsbParm"
-#include <utils/Log.h>
-
-#include <utils/Errors.h>
-#include <utils/threads.h>
-#include <utils/String16.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <cutils/properties.h>
-#include <math.h>
-#if HAVE_ANDROID_OS
-#include <linux/android_pmem.h>
-#endif
-#include <linux/ioctl.h>
-#include <camera/QCameraParameters.h>
-#include <media/mediarecorder.h>
-#include <gralloc_priv.h>
-
-#include "linux/msm_mdp.h"
-#include <linux/fb.h>
-#include <limits.h>
-
-
-extern "C" {
-#include <fcntl.h>
-#include <time.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <termios.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <signal.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/system_properties.h>
-#include <sys/time.h>
-#include <stdlib.h>
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include <cam_fifo.h>
-#include <jpege.h>
-
-} // extern "C"
-
-#include "QCameraHWI.h"
-#include "QualcommUsbCamera.h"
-#include "QCameraUsbPriv.h"
-#include "QCameraUsbParm.h"
-
-namespace android {
-
-/********************************************************************/
-static const str_map preview_formats[] = {
-    {QCameraParameters::PIXEL_FORMAT_YUV420SP, HAL_PIXEL_FORMAT_YCrCb_420_SP},
-};
-
-static const preview_format_info_t preview_format_info_list[] = {
-    {HAL_PIXEL_FORMAT_YV12, CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3}
-};
-
-static struct camera_size_type previewSizes[] = {
-    { 1920, 1088}, //1080p
-    { 1280, 720}, // 720P,
-    { 640, 480}, // VGA
-    { 512, 384},
-    { 480, 320},
-    { 320, 240}, // QVGA
-};
-
-// All fps ranges which can be supported. This list will be filtered according
-// to the min and max fps supported by hardware
-// this list must be sorted first by max_fps and then min_fps
-// fps values are multiplied by 1000
-static android::FPSRange prevFpsRanges[] = {
-    android::FPSRange(5000, 121000),
-};
-
-/* TBR: Is frame rate mode mandatory */
-static const str_map frame_rate_modes[] = {
-    {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO},
-    {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED}
-};
-
-static const str_map picture_formats[] = {
-    {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG},
-    //{QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW}
-};
-
-static camera_size_type picture_sizes[] = {
-    { 1920, 1088}, //HD1080
-    { 1280, 720}, //HD720
-    { 640, 480}, // VGA
-    { 320, 240}, // QVGA
-};
-
-/* aspect ratio removed */
-static camera_size_type thumbnail_sizes[] = {
-    { 512, 288 }, //1.777778
-    { 480, 288 }, //1.666667
-    { 256, 154 }, //1.66233
-    { 432, 288 }, //1.5
-    { 512, 384 }, //1.333333
-    { 352, 288 }, //1.222222
-    { 320, 240 }, //1.33333
-    { 176, 144 }, //1.222222
-};
-
-static const str_map recording_Hints[] = {
-    {"false", FALSE},
-    {"true",  TRUE}
-};
-
-/* Static functions list */
-static String8 create_sizes_str(const camera_size_type *sizes, int len);
-static String8 create_values_str(const str_map *values, int len);
-static String8 create_fps_str(const android:: FPSRange* fps, int len);
-static String8 create_values_range_str(int min, int max);
-static int usbCamSetPrvwSize(   camera_hardware_t           *camHal,
-                                const QCameraParameters&    params);
-static int usbCamSetPictSize(   camera_hardware_t           *camHal,
-                                const QCameraParameters&    params);
-static int usbCamSetThumbnailSize(  camera_hardware_t           *camHal,
-                                    const QCameraParameters&    params);
-static int usbCamSetJpegQlty(   camera_hardware_t           *camHal,
-                                const QCameraParameters&    params);
-
-/******************************************************************************
- * Function: usbCamInitDefaultParameters
- * Description: This function sets default parameters to camera HAL context
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *      None
- *
- * Notes: none
- *****************************************************************************/
-int usbCamInitDefaultParameters(camera_hardware_t *camHal)
-{
-    ALOGD("%s: E", __func__);
-    int rc = 0;
-    char tempStr[FILENAME_LENGTH];
-
-    /* Default initializations */
-    camHal->prevFormat          = DEFAULT_USBCAM_PRVW_FMT;
-    camHal->prevWidth           = DEFAULT_USBCAM_PRVW_WD;
-    camHal->prevHeight          = DEFAULT_USBCAM_PRVW_HT;
-    camHal->dispFormat          = camHal->prevFormat;
-    camHal->dispWidth           = camHal->prevWidth;
-    camHal->dispHeight          = camHal->prevHeight;
-    camHal->pictFormat          = DEFAULT_USBCAM_PICT_FMT;
-    camHal->pictWidth           = DEFAULT_USBCAM_PICT_WD;
-    camHal->pictHeight          = DEFAULT_USBCAM_PICT_HT;
-    camHal->pictJpegQlty        = DEFAULT_USBCAM_PICT_QLTY;
-    camHal->thumbnailWidth      = DEFAULT_USBCAM_THUMBNAIL_WD;
-    camHal->thumbnailHeight     = DEFAULT_USBCAM_THUMBNAIL_HT;
-    camHal->thumbnailJpegQlty   = DEFAULT_USBCAM_THUMBNAIL_QLTY;
-    camHal->previewEnabledFlag  = 0;
-    camHal->prvwStoppedForPicture = 0;
-    camHal->prvwCmdPending      = 0;
-    camHal->takePictInProgress  = 0;
-
-    //Set picture size values
-    camHal->pictSizeValues = create_sizes_str(
-        picture_sizes, sizeof(picture_sizes) / sizeof(camera_size_type));
-    camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
-        camHal->pictSizeValues.string());
-    camHal->qCamParams.setPictureSize(camHal->pictWidth, camHal->pictHeight);
-
-    //Set picture format
-    camHal->pictFormatValues = create_values_str(
-        picture_formats, sizeof(picture_formats) / sizeof(str_map));
-    camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
-                    camHal->pictFormatValues.string());
-    if(PICTURE_FORMAT_JPEG == camHal->pictFormat)
-        camHal->qCamParams.setPictureFormat(QCameraParameters::PIXEL_FORMAT_JPEG);
-
-    //Set picture quality
-    sprintf(tempStr, "%d", camHal->pictJpegQlty);
-    camHal->qCamParams.set(QCameraParameters::KEY_JPEG_QUALITY, tempStr);
-
-    //Set Thumbnail size
-    camHal->thumbnailSizeValues = create_sizes_str(
-        thumbnail_sizes, sizeof(thumbnail_sizes) /sizeof(camera_size_type));
-    camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
-                    camHal->thumbnailSizeValues.string());
-    sprintf(tempStr, "%d", camHal->thumbnailWidth);
-    camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
-                                                tempStr);
-    sprintf(tempStr, "%d", camHal->thumbnailHeight);
-    camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
-                                                tempStr);
-
-    //Set Thumbnail quality
-    sprintf(tempStr, "%d", camHal->thumbnailJpegQlty);
-    camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
-                                                tempStr);
-
-    //Set Preview Format
-    camHal->prevFormatValues = create_values_str(
-        preview_formats, sizeof(preview_formats) / sizeof(str_map));
-    camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
-        camHal->prevFormatValues.string());
-    if(HAL_PIXEL_FORMAT_YCrCb_420_SP == camHal->prevFormat)
-        camHal->qCamParams.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP);
-
-    //Set Preview size
-    camHal->prevSizeValues = create_sizes_str(
-        previewSizes,  sizeof(previewSizes) / sizeof(camera_size_type));
-    camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
-                    camHal->prevSizeValues.string());
-    camHal->qCamParams.setPreviewSize(camHal->prevWidth, camHal->prevHeight);
-
-    //Set Preivew fps range
-    camHal->prevFpsRangesValues = create_fps_str(
-        prevFpsRanges, sizeof(prevFpsRanges) / sizeof(android::FPSRange));
-
-    camHal->qCamParams.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
-                        camHal->prevFpsRangesValues);
-    camHal->qCamParams.setPreviewFpsRange(MIN_PREV_FPS, MAX_PREV_FPS);
-
-    ALOGD("%s: X", __func__);
-
-    return rc;
-} /* usbCamInitDefaultParameters */
-
-/******************************************************************************
- * Function: usbCamSetParameters
- * Description: This function parses the parameter string and stores the
- *              parameters in the camera HAL handle
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  params              - pointer to parameter string
- *
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-int usbCamSetParameters(camera_hardware_t *camHal, const char *params)
-{
-    int             rc      = 0;
-    String8         str     = String8(params);
-    QCameraParameters qParam;
-
-    ALOGD("%s: E", __func__);
-
-    if(params)
-        PRINT_PARAM_STR(params);
-
-    qParam.unflatten(str);
-
-    if(usbCamSetPrvwSize(camHal, qParam))
-        rc = -1;
-    if(usbCamSetPictSize(camHal, qParam))
-        rc = -1;
-    if(usbCamSetThumbnailSize(camHal, qParam))
-        rc = -1;
-    if(usbCamSetJpegQlty(camHal, qParam))
-        rc = -1;
-
-    ALOGD("%s: X", __func__);
-    return rc;
-} /* usbCamSetParameters */
-
-/******************************************************************************
- * Function: usbCamGetParameters
- * Description: This function allocates memory for parameter string,
- *              composes and returns the parameter string
- *
- * Input parameters:
- *   camHal             - camera HAL handle
- *
- * Return values:
- *      Address to the parameter string
- *
- * Notes: none
- *****************************************************************************/
-char* usbCamGetParameters(camera_hardware_t *camHal)
-{
-    ALOGD("%s: E", __func__);
-    char *parms = NULL;
-    char* rc = NULL;
-    String8 str;
-
-    QCameraParameters qParam = camHal->qCamParams;
-    //qParam.dump();
-    str = qParam.flatten( );
-    rc = (char *)malloc(sizeof(char)*(str.length()+1));
-    if(rc != NULL){
-        memset(rc, 0, sizeof(char)*(str.length()+1));
-        strncpy(rc, str.string(), str.length());
-    rc[str.length()] = 0;
-    parms = rc;
-    }
-
-    PRINT_PARAM_STR(parms);
-
-    ALOGD("%s: X", __func__);
-    return (parms);
-} /* usbCamGetParameters */
-
-/******************************************************************************
- * Function: usbCamPutParameters
- * Description: This function frees the memory allocated for parameter string
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  parms               - Parameter string
- *
- * Return values:
- *      None
- *
- * Notes: none
- *****************************************************************************/
-void usbCamPutParameters(camera_hardware_t *camHal, char *parms)
-{
-    ALOGD("%s: E", __func__);
-    if(parms)
-        free(parms);
-    parms = NULL;
-    ALOGD("%s: X", __func__);
-} /* usbCamPutParameters */
-
-/******************************************************************************
- * Function: create_sizes_str
- * Description: This function loops through /dev/video entries and probes with
- *              UVCIOC query. If the device responds to the query, then it is
- *              detected as UVC webcam
- * Input parameters:
- *   devname             - String pointer. The function return dev entry
- *                          name in this string
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-static String8 create_sizes_str(const camera_size_type *sizes, int len) {
-    String8 str;
-    char buffer[32];
-
-    if (len > 0) {
-        snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
-        str.append(buffer);
-    }
-    for (int i = 1; i < len; i++) {
-        snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height);
-        str.append(buffer);
-    }
-    return str;
-}
-
-/******************************************************************************
- * Function: create_values_str
- * Description: This function loops through /dev/video entries and probes with
- *              UVCIOC query. If the device responds to the query, then it is
- *              detected as UVC webcam
- * Input parameters:
- *   devname             - String pointer. The function return dev entry
- *                          name in this string
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-static String8 create_values_str(const str_map *values, int len) {
-    String8 str;
-
-    if (len > 0) {
-        str.append(values[0].desc);
-    }
-    for (int i = 1; i < len; i++) {
-        str.append(",");
-        str.append(values[i].desc);
-    }
-    return str;
-}
-
-/******************************************************************************
- * Function: create_fps_str
- * Description: This function loops through /dev/video entries and probes with
- *              UVCIOC query. If the device responds to the query, then it is
- *              detected as UVC webcam
- * Input parameters:
- *   devname             - String pointer. The function return dev entry
- *                          name in this string
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-static String8 create_fps_str(const android:: FPSRange* fps, int len) {
-    String8 str;
-    char buffer[32];
-
-    if (len > 0) {
-        snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS);
-        str.append(buffer);
-    }
-    for (int i = 1; i < len; i++) {
-        snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS);
-        str.append(buffer);
-    }
-    return str;
-}
-
-/******************************************************************************
- * Function: create_values_range_str
- * Description: This function loops through /dev/video entries and probes with
- *              UVCIOC query. If the device responds to the query, then it is
- *              detected as UVC webcam
- * Input parameters:
- *   devname             - String pointer. The function return dev entry
- *                          name in this string
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-static String8 create_values_range_str(int min, int max){
-    String8 str;
-    char buffer[32];
-
-    if(min <= max){
-        snprintf(buffer, sizeof(buffer), "%d", min);
-        str.append(buffer);
-
-        for (int i = min + 1; i <= max; i++) {
-            snprintf(buffer, sizeof(buffer), ",%d", i);
-            str.append(buffer);
-        }
-    }
-    return str;
-}
-
-/******************************************************************************
- * Function: usbCamSetPrvwSize
- * Description: This function parses preview width and height from the input
- *              parameters and stores into the context
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  params              - QCameraParameters reference
- *
- * Return values:
- *      0   If parameters are valid
- *      -1  If parameters are invalid
- *
- * Notes: none
- *****************************************************************************/
-static int usbCamSetPrvwSize(   camera_hardware_t           *camHal,
-                                const QCameraParameters&    params)
-{
-    int rc = 0, width, height, i, numPrvwSizes, validSize;
-    ALOGD("%s: E", __func__);
-
-    params.getPreviewSize(&width, &height);
-    ALOGI("%s: Requested preview size %d x %d", __func__, width, height);
-
-    // Validate the preview size
-    numPrvwSizes = sizeof(previewSizes) / sizeof(camera_size_type);
-    for (i = 0, validSize = 0; i <  numPrvwSizes; i++) {
-        if (width ==  previewSizes[i].width
-           && height ==  previewSizes[i].height) {
-            validSize = 1;
-
-            camHal->qCamParams.setPreviewSize(width, height);
-            ALOGD("%s: setPreviewSize:  width: %d   height: %d",
-                __func__, width, height);
-
-            camHal->prevWidth   = width;
-            camHal->prevHeight  = height;
-            camHal->dispWidth   = width;
-            camHal->dispHeight  = height;
-
-            /* TBD: restrict pictures size and video to preview size */
-        }
-    }
-    if(!validSize)
-        ALOGE("%s: Invalid preview size %dx%d requested", __func__,
-            width, height);
-
-    rc = (validSize == 0)? -1:0;
-    ALOGD("%s: X", __func__);
-
-    return rc;
-} /* usbCamSetPrvwSize */
-
-/******************************************************************************
- * Function: usbCamSetPictSize
- * Description: This function parses picture width and height from the input
- *              parameters and stores into the context
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  params              - QCameraParameters reference
- *
- * Return values:
- *      0   If parameters are valid
- *      -1  If parameters are invalid
- *
- * Notes: none
- *****************************************************************************/
-static int usbCamSetPictSize(   camera_hardware_t           *camHal,
-                                const QCameraParameters&    params)
-{
-    int rc = 0, width, height, i, numPictSizes, validSize;
-    ALOGD("%s: E", __func__);
-
-    /* parse for picture width and height */
-    params.getPictureSize(&width, &height);
-    ALOGI("%s: Requested picture size %d x %d", __func__, width, height);
-
-    // Validate the picture size
-    numPictSizes = sizeof(picture_sizes) / sizeof(camera_size_type);
-    for (i = 0, validSize = 0; i <  numPictSizes; i++) {
-        if (width ==  picture_sizes[i].width
-           && height ==  picture_sizes[i].height) {
-            validSize = 1;
-
-            camHal->qCamParams.setPictureSize(width, height);
-            ALOGD("%s: setPictureSize:  width: %d   height: %d",
-                __func__, width, height);
-
-            /* TBD: If new pictSize is different from old size, restart prvw */
-            camHal->pictWidth   = width;
-            camHal->pictHeight  = height;
-        }
-    }
-    if(!validSize)
-        ALOGE("%s: Invalid picture size %dx%d requested", __func__,
-            width, height);
-    rc = (validSize == 0)? -1:0;
-    ALOGD("%s: X", __func__);
-
-    return rc;
-} /* usbCamSetPictSize */
-
-/******************************************************************************
- * Function: usbCamSetThumbnailSize
- * Description: This function parses picture width and height from the input
- *              parameters and stores into the context
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  params              - QCameraParameters reference
- *
- * Return values:
- *      0   If parameters are valid
- *      -1  If parameters are invalid
- *
- * Notes: none
- *****************************************************************************/
-static int usbCamSetThumbnailSize(  camera_hardware_t           *camHal,
-                                    const QCameraParameters&    params)
-{
-    int rc = 0, width, height, i, numThumbnailSizes, validSize;
-    char tempStr[FILENAME_LENGTH];
-    ALOGD("%s: E", __func__);
-
-    /* parse for thumbnail width and height */
-    width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
-    height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
-    ALOGI("%s: Requested thumbnail size %d x %d", __func__, width, height);
-
-    // Validate the thumbnail size
-    numThumbnailSizes = sizeof(thumbnail_sizes) / sizeof(camera_size_type);
-    for (i = 0, validSize = 0; i <  numThumbnailSizes; i++) {
-        if (width ==  thumbnail_sizes[i].width
-           && height ==  thumbnail_sizes[i].height) {
-            validSize = 1;
-
-            camHal->thumbnailWidth   = width;
-            camHal->thumbnailHeight  = height;
-            sprintf(tempStr, "%d", camHal->thumbnailWidth);
-            camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
-                                                        width);
-            sprintf(tempStr, "%d", camHal->thumbnailHeight);
-            camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
-                                                        height);
-
-        }
-    }
-    if(!validSize)
-        ALOGE("%s: Invalid picture size %dx%d requested", __func__,
-            width, height);
-    rc = (validSize == 0)? -1:0;
-    ALOGD("%s: X", __func__);
-
-    return rc;
-} /* usbCamSetThumbnailSize */
-
-/******************************************************************************
- * Function: usbCamSetJpegQlty
- * Description: This function parses picture and thumbnail JPEG quality and
- *              validates before storing in the context
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  params              - QCameraParameters reference
- *
- * Return values:
- *      0   If parameters are valid
- *      -1  If parameters are invalid
- *
- * Notes: none
- *****************************************************************************/
-static int usbCamSetJpegQlty(   camera_hardware_t           *camHal,
-                                const QCameraParameters&    params)
-{
-    int rc = 0, quality = 0;
-    char tempStr[FILENAME_LENGTH];
-    ALOGD("%s: E", __func__);
-
-    /**/
-    quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY);
-    ALOGI("%s: Requested picture qlty %d", __func__, quality);
-
-    if (quality >= 0 && quality <= 100) {
-        camHal->pictJpegQlty = quality;
-        sprintf(tempStr, "%d", camHal->pictJpegQlty);
-        camHal->qCamParams.set(QCameraParameters::KEY_JPEG_QUALITY, quality);
-    } else {
-        ALOGE("Invalid jpeg quality=%d", quality);
-        rc = -1;
-    }
-
-    quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
-    ALOGI("%s: Requested thumbnail qlty %d", __func__, quality);
-
-    if (quality >= 0 && quality <= 100) {
-        camHal->thumbnailJpegQlty = quality;
-        sprintf(tempStr, "%d", camHal->thumbnailJpegQlty);
-        camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
-                                    tempStr);
-    } else {
-        ALOGE("Invalid jpeg thumbnail quality=%d", quality);
-        rc = -1;
-    }
-
-    ALOGD("%s: X rc:%d", __func__, rc);
-
-    return rc;
-}
-
-}; /*namespace android */
diff --git a/camera/QCamera/HAL/usbcamcore/src/QualcommUsbCamera.cpp b/camera/QCamera/HAL/usbcamcore/src/QualcommUsbCamera.cpp
deleted file mode 100755
index 6f3c3cd..0000000
--- a/camera/QCamera/HAL/usbcamcore/src/QualcommUsbCamera.cpp
+++ /dev/null
@@ -1,2963 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
- /*#error uncomment this for compiler test!*/
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QualcommUsbCamera"
-
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <sys/prctl.h>
-#include <sys/resource.h>
-#include <pthread.h>
-#include <linux/uvcvideo.h>
-
-#include "QCameraHAL.h"
-#include "QualcommUsbCamera.h"
-#include "QCameraUsbPriv.h"
-#include "QCameraMjpegDecode.h"
-#include "QCameraUsbParm.h"
-#include <gralloc_priv.h>
-#include <genlock.h>
-
-extern "C" {
-#include <sys/time.h>
-}
-
-camera_device_ops_t usbcam_camera_ops = {
-  set_preview_window:         android::usbcam_set_preview_window,
-  set_callbacks:              android::usbcam_set_CallBacks,
-  enable_msg_type:            android::usbcam_enable_msg_type,
-  disable_msg_type:           android::usbcam_disable_msg_type,
-  msg_type_enabled:           android::usbcam_msg_type_enabled,
-
-  start_preview:              android::usbcam_start_preview,
-  stop_preview:               android::usbcam_stop_preview,
-  preview_enabled:            android::usbcam_preview_enabled,
-  store_meta_data_in_buffers: android::usbcam_store_meta_data_in_buffers,
-
-  start_recording:            android::usbcam_start_recording,
-  stop_recording:             android::usbcam_stop_recording,
-  recording_enabled:          android::usbcam_recording_enabled,
-  release_recording_frame:    android::usbcam_release_recording_frame,
-
-  auto_focus:                 android::usbcam_auto_focus,
-  cancel_auto_focus:          android::usbcam_cancel_auto_focus,
-
-  take_picture:               android::usbcam_take_picture,
-  cancel_picture:             android::usbcam_cancel_picture,
-
-  set_parameters:             android::usbcam_set_parameters,
-  get_parameters:             android::usbcam_get_parameters,
-  put_parameters:             android::usbcam_put_parameters,
-  send_command:               android::usbcam_send_command,
-
-  release:                    android::usbcam_release,
-  dump:                       android::usbcam_dump,
-};
-
-#define CAPTURE                 1
-#define DISPLAY                 1
-#define CALL_BACK               1
-#define MEMSET                  0
-#define FREAD_JPEG_PICTURE      0
-#define JPEG_ON_USB_CAMERA      1
-#define FILE_DUMP_CAMERA        0
-#define FILE_DUMP_B4_DISP       0
-
-namespace android {
-
-static int initUsbCamera(               camera_hardware_t *camHal,
-                                        int width, int height,
-                                        int pixelFormat);
-static int startUsbCamCapture(          camera_hardware_t *camHal);
-static int stopUsbCamCapture(           camera_hardware_t *camHal);
-static int initV4L2mmap(                camera_hardware_t *camHal);
-static int unInitV4L2mmap(              camera_hardware_t *camHal);
-static int launch_preview_thread(       camera_hardware_t *camHal);
-static int launchTakePictureThread(     camera_hardware_t *camHal);
-static int initDisplayBuffers(          camera_hardware_t *camHal);
-static int deInitDisplayBuffers(        camera_hardware_t *camHal);
-static int stopPreviewInternal(         camera_hardware_t *camHal);
-static int get_buf_from_cam(            camera_hardware_t *camHal);
-static int put_buf_to_cam(              camera_hardware_t *camHal);
-static int prvwThreadTakePictureInternal(camera_hardware_t *camHal);
-static int get_buf_from_display( camera_hardware_t *camHal, int *buffer_id);
-static int put_buf_to_display(   camera_hardware_t *camHal, int buffer_id);
-static int convert_data_frm_cam_to_disp(camera_hardware_t *camHal, int buffer_id);
-static void * previewloop(void *);
-static void * takePictureThread(void *);
-static int convert_YUYV_to_420_NV12(char *in_buf, char *out_buf, int wd, int ht);
-static int get_uvc_device(char *devname);
-static int getPreviewCaptureFmt(camera_hardware_t *camHal);
-static int allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type);
-static int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info);
-static int ioctlLoop(int fd, int ioctlCmd, void *args);
-static int readFromFile(char* fileName, char* buffer, int bufferSize);
-static int fileDump(const char* fileName, char* data, int length, int* frm_cnt);
-static int encodeJpeg(                  camera_hardware_t *camHal);
-void jpegEncodeCb   (jpeg_job_status_t status,
-                       uint8_t thumbnailDroppedFlag,
-                       uint32_t client_hdl,
-                       uint32_t jobId,
-                       uint8_t* out_data,
-                       uint32_t data_size,
-                       void *userData);
-
-/* HAL function implementation goes here*/
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-
-extern "C" int usbcam_get_number_of_cameras()
-{
-    /* TBR: This is hardcoded currently to 1 USB camera */
-    int numCameras = 1;
-    ALOGI("%s: E", __func__);
-    ALOGI("%s: X", __func__);
-
-    return numCameras;
-}
-
-extern "C" int usbcam_get_camera_info(int camera_id, struct camera_info *info)
-{
-    int rc = -1;
-    ALOGI("%s: E", __func__);
-
-    /* TBR: This info is hardcoded currently irrespective of camera_id */
-    if(info) {
-        struct CameraInfo camInfo;
-        memset(&camInfo, -1, sizeof (struct CameraInfo));
-
-        info->facing = CAMERA_FACING_FRONT;//CAMERA_FACING_BACK;
-        info->orientation = 0;
-        rc = 0;
-    }
-    ALOGI("%s: X", __func__);
-    return rc;
-}
-
-/* HAL should return NULL handle if it fails to open camera hardware. */
-extern "C" int  usbcam_camera_device_open(
-  const struct hw_module_t* module, const char* id,
-          struct hw_device_t** hw_device)
-{
-    int rc = -1;
-    camera_device       *device = NULL;
-    camera_hardware_t   *camHal;
-    char                *dev_name;
-
-    ALOGI("%s: E", __func__);
-
-    /* initialize return handle value to NULL */
-    *hw_device = NULL;
-
-    camHal = new camera_hardware_t();
-    if(!camHal) {
-
-            ALOGE("%s:  end in no mem", __func__);
-            return -1;
-    }
-
-    rc = usbCamInitDefaultParameters(camHal);
-    if(0 != rc)
-    {
-        ALOGE("%s: usbCamInitDefaultParameters error", __func__);
-        return rc;
-    }
-#if CAPTURE
-
-    dev_name = camHal->dev_name;
-
-    rc = get_uvc_device(dev_name);
-    if(rc || *dev_name == '\0'){
-        ALOGE("%s: No UVC node found \n", __func__);
-        return -1;
-    }
-
-    camHal->fd = open(dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
-
-    if (camHal->fd <  0) {
-        ALOGE("%s: Cannot open '%s'", __func__, dev_name);
-        free(camHal);
-        rc = -1;
-    }else{
-        rc = 0;
-    }
-
-#else /* CAPTURE */
-    rc = 0;
-#endif /* CAPTURE */
-
-    device                  = &camHal->hw_dev;
-    device->common.close    = usbcam_close_camera_device;
-    device->ops             = &usbcam_camera_ops;
-    device->priv            = (void *)camHal;
-    *hw_device              = &(device->common);
-
-    ALOGD("%s: camHal: %p", __func__, camHal);
-    ALOGI("%s: X %d", __func__, rc);
-
-    return rc;
-}
-
-extern "C"  int usbcam_close_camera_device( hw_device_t *hw_dev)
-{
-    ALOGI("%s: device =%p E", __func__, hw_dev);
-    int rc =  -1;
-    camera_device_t *device     = (camera_device_t *)hw_dev;
-
-    if(device) {
-        camera_hardware_t *camHal   = (camera_hardware_t *)device->priv;
-        if(camHal) {
-            rc = close(camHal->fd);
-            if(rc < 0) {
-                ALOGE("%s: close failed ", __func__);
-            }
-            camHal->fd = 0;
-            delete camHal;
-        }else{
-                ALOGE("%s: camHal is NULL pointer ", __func__);
-        }
-    }
-    ALOGI("%s: X device =%p, rc = %d", __func__, hw_dev, rc);
-    return rc;
-}
-
-int usbcam_set_preview_window(struct camera_device * device,
-        struct preview_stream_ops *window)
-{
-    ALOGI("%s: E", __func__);
-    int rc = 0;
-    camera_hardware_t *camHal;
-
-    VALIDATE_DEVICE_HDL(camHal, device, -1);
-    Mutex::Autolock autoLock(camHal->lock);
-
-    /* if window is already set, then de-init previous buffers */
-    if(camHal->window){
-        rc = deInitDisplayBuffers(camHal);
-        if(rc < 0) {
-            ALOGE("%s: deInitDisplayBuffers returned error", __func__);
-        }
-    }
-    camHal->window = window;
-
-    if(camHal->window){
-        rc = initDisplayBuffers(camHal);
-        if(rc < 0) {
-            ALOGE("%s: initDisplayBuffers returned error", __func__);
-        }
-    }
-    ALOGI("%s: X. rc = %d", __func__, rc);
-    return rc;
-}
-
-void usbcam_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)
-{
-    ALOGI("%s: E", __func__);
-    camera_hardware_t *camHal;
-
-    if(device && device->priv){
-        camHal = (camera_hardware_t *)device->priv;
-    }else{
-        ALOGE("%s: Null device or device->priv", __func__);
-        return;
-    }
-
-    Mutex::Autolock autoLock(camHal->lock);
-
-    camHal->notify_cb           = notify_cb;
-    camHal->data_cb             = data_cb;
-    camHal->data_cb_timestamp   = data_cb_timestamp;
-    camHal->get_memory          = get_memory;
-    camHal->cb_ctxt             = user;
-
-    ALOGI("%s: X", __func__);
-}
-
-void usbcam_enable_msg_type(struct camera_device * device, int32_t msg_type)
-{
-    ALOGI("%s: E", __func__);
-    ALOGI("%s: msg_type: %d", __func__, msg_type);
-
-    camera_hardware_t *camHal;
-
-    if(device && device->priv){
-        camHal = (camera_hardware_t *)device->priv;
-    }else{
-        ALOGE("%s: Null device or device->priv", __func__);
-        return;
-    }
-
-    Mutex::Autolock autoLock(camHal->lock);
-
-    camHal->msgEnabledFlag |= msg_type;
-
-    ALOGI("%s: X", __func__);
-}
-
-void usbcam_disable_msg_type(struct camera_device * device, int32_t msg_type)
-{
-    ALOGI("%s: E", __func__);
-    ALOGI("%s: msg_type: %d", __func__, msg_type);
-
-    camera_hardware_t *camHal;
-    if(device && device->priv){
-        camHal = (camera_hardware_t *)device->priv;
-    }else{
-        ALOGE("%s: Null device or device->priv", __func__);
-        return;
-    }
-
-    Mutex::Autolock autoLock(camHal->lock);
-
-    camHal->msgEnabledFlag &= ~msg_type;
-
-    ALOGI("%s: X", __func__);
-}
-
-int usbcam_msg_type_enabled(struct camera_device * device, int32_t msg_type)
-{
-    ALOGI("%s: E", __func__);
-
-    camera_hardware_t *camHal;
-    if(device && device->priv){
-        camHal = (camera_hardware_t *)device->priv;
-    }else{
-        ALOGE("%s: Null device or device->priv", __func__);
-        return -1;
-    }
-
-    Mutex::Autolock autoLock(camHal->lock);
-
-    ALOGI("%s: X", __func__);
-    return (camHal->msgEnabledFlag & msg_type);
-}
-
-int usbcam_start_preview(struct camera_device * device)
-{
-    ALOGI("%s: E", __func__);
-
-    int rc = -1;
-    camera_hardware_t *camHal = NULL;
-
-    VALIDATE_DEVICE_HDL(camHal, device, -1);
-    Mutex::Autolock autoLock(camHal->lock);
-
-    /* If preivew is already running, nothing to be done */
-    if(camHal->previewEnabledFlag){
-        ALOGI("%s: Preview is already running", __func__);
-        return 0;
-    }
-
-#if CAPTURE
-    rc = initUsbCamera(camHal, camHal->prevWidth,
-                        camHal->prevHeight, getPreviewCaptureFmt(camHal));
-    if(rc < 0) {
-        ALOGE("%s: Failed to intialize the device", __func__);
-    }else{
-        rc = startUsbCamCapture(camHal);
-        if(rc < 0) {
-            ALOGE("%s: Failed to startUsbCamCapture", __func__);
-        }else{
-            rc = launch_preview_thread(camHal);
-            if(rc < 0) {
-                ALOGE("%s: Failed to launch_preview_thread", __func__);
-            }
-        }
-    }
-#else /* CAPTURE */
-    rc = launch_preview_thread(camHal);
-    if(rc < 0) {
-        ALOGE("%s: Failed to launch_preview_thread", __func__);
-    }
-#endif /* CAPTURE */
-    /* if no errors, then set the flag */
-    if(!rc)
-        camHal->previewEnabledFlag = 1;
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-void usbcam_stop_preview(struct camera_device * device)
-{
-    ALOGD("%s: E", __func__);
-
-    int rc = 0;
-    camera_hardware_t *camHal;
-
-    if(device && device->priv){
-        camHal = (camera_hardware_t *)device->priv;
-    }else{
-        ALOGE("%s: Null device or device->priv", __func__);
-        return;
-    }
-
-    Mutex::Autolock autoLock(camHal->lock);
-
-    rc = stopPreviewInternal(camHal);
-    if(rc)
-        ALOGE("%s: stopPreviewInternal returned error", __func__);
-
-    ALOGI("%s: X", __func__);
-    return;
-}
-
-/* This function is equivalent to is_preview_enabled */
-int usbcam_preview_enabled(struct camera_device * device)
-{
-    ALOGI("%s: E", __func__);
-    camera_hardware_t *camHal;
-
-    if(device && device->priv){
-        camHal = (camera_hardware_t *)device->priv;
-    }else{
-        ALOGE("%s: Null device or device->priv", __func__);
-        return -1;
-    }
-    Mutex::Autolock autoLock(camHal->lock);
-
-    ALOGI("%s: X", __func__);
-    return camHal->previewEnabledFlag;
-}
-
-/* TBD */
-int usbcam_store_meta_data_in_buffers(struct camera_device * device, int enable)
-{
-    ALOGI("%s: E", __func__);
-    int rc = 0;
-
-    ALOGI("%s: X", __func__);
-    return rc;
-}
-
-/* TBD */
-int usbcam_start_recording(struct camera_device * device)
-{
-    int rc = 0;
-    ALOGD("%s: E", __func__);
-
-    ALOGD("%s: X", __func__);
-
-    return rc;
-}
-
-/* TBD */
-void usbcam_stop_recording(struct camera_device * device)
-{
-    ALOGD("%s: E", __func__);
-
-    ALOGD("%s: X", __func__);
-}
-
-/* TBD */
-int usbcam_recording_enabled(struct camera_device * device)
-{
-    int rc = 0;
-    ALOGD("%s: E", __func__);
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/* TBD */
-void usbcam_release_recording_frame(struct camera_device * device,
-                const void *opaque)
-{
-    ALOGV("%s: E", __func__);
-
-    ALOGD("%s: X", __func__);
-}
-
-/* TBD */
-int usbcam_auto_focus(struct camera_device * device)
-{
-    ALOGD("%s: E", __func__);
-    int rc = 0;
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/* TBD */
-int usbcam_cancel_auto_focus(struct camera_device * device)
-{
-    int rc = 0;
-    ALOGD("%s: E", __func__);
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-int usbcam_take_picture(struct camera_device * device)
-{
-    ALOGI("%s: E", __func__);
-    int rc = 0;
-    camera_hardware_t *camHal;
-
-    VALIDATE_DEVICE_HDL(camHal, device, -1);
-
-    Mutex::Autolock autoLock(camHal->lock);
-
-    /* If take picture is already in progress, nothing t be done */
-    if(camHal->takePictInProgress){
-        ALOGI("%s: Take picture already in progress", __func__);
-        return 0;
-    }
-
-    if(camHal->previewEnabledFlag)
-    {
-        rc = stopPreviewInternal(camHal);
-        if(rc){
-            ALOGE("%s: stopPreviewInternal returned error", __func__);
-        }
-        USB_CAM_CLOSE(camHal);
-        camHal->prvwStoppedForPicture = 1;
-    }
-    /* TBD: Need to handle any dependencies on video recording state */
-    rc = launchTakePictureThread(camHal);
-    if(rc)
-        ALOGE("%s: launchTakePictureThread error", __func__);
-
-#if 0
-    /* This implementation requests preview thread to take picture */
-    if(camHal->previewEnabledFlag)
-    {
-        camHal->prvwCmdPending++;
-        camHal->prvwCmd         = USB_CAM_PREVIEW_TAKEPIC;
-        ALOGD("%s: Take picture command set ", __func__);
-    }else{
-        ALOGE("%s: Take picture without preview started!", __func__);
-        rc = -1;
-    }
-#endif
-
-    if(!rc)
-        camHal->takePictInProgress = 1;
-
-    ALOGI("%s: X", __func__);
-    return rc;
-}
-
-/* TBD */
-int usbcam_cancel_picture(struct camera_device * device)
-
-{
-    ALOGI("%s: E", __func__);
-    int rc = 0;
-
-    ALOGI("%s: X", __func__);
-    return rc;
-}
-
-int usbcam_set_parameters(struct camera_device * device, const char *params)
-
-{
-    ALOGI("%s: E", __func__);
-    int rc = 0;
-    camera_hardware_t *camHal;
-
-    VALIDATE_DEVICE_HDL(camHal, device, -1);
-
-    Mutex::Autolock autoLock(camHal->lock);
-
-    rc = usbCamSetParameters(camHal, params);
-
-    ALOGI("%s: X", __func__);
-    return rc;
-}
-
-char* usbcam_get_parameters(struct camera_device * device)
-{
-    char *parms;
-    ALOGI("%s: E", __func__);
-
-    camera_hardware_t *camHal;
-    VALIDATE_DEVICE_HDL(camHal, device, NULL);
-
-    Mutex::Autolock autoLock(camHal->lock);
-
-    parms = usbCamGetParameters(camHal);
-
-    ALOGI("%s: X", __func__);
-    return parms;
-}
-
-void usbcam_put_parameters(struct camera_device * device, char *parm)
-
-{
-    ALOGI("%s: E", __func__);
-
-    camera_hardware_t *camHal;
-
-    if(device && device->priv){
-        camHal = (camera_hardware_t *)device->priv;
-    }else{
-        ALOGE("%s: Null device or device->priv", __func__);
-        return;
-    }
-
-    usbCamPutParameters(camHal, parm);
-
-    ALOGI("%s: X", __func__);
-    return;
-}
-
-/* TBD */
-int usbcam_send_command(struct camera_device * device,
-            int32_t cmd, int32_t arg1, int32_t arg2)
-{
-    int rc = 0;
-    ALOGI("%s: E", __func__);
-    ALOGI("%d", cmd);
-
-    ALOGI("%s: X", __func__);
-    return rc;
-}
-
-/* TBD */
-void usbcam_release(struct camera_device * device)
-{
-    ALOGI("%s: E", __func__);
-#if 0
-    Mutex::Autolock l(&mLock);
-
-    switch(mPreviewState) {
-    case QCAMERA_HAL_PREVIEW_STOPPED:
-        break;
-    case QCAMERA_HAL_PREVIEW_START:
-        break;
-    case QCAMERA_HAL_PREVIEW_STARTED:
-        stopPreviewInternal();
-    break;
-    case QCAMERA_HAL_RECORDING_STARTED:
-        stopRecordingInternal();
-        stopPreviewInternal();
-        break;
-    case QCAMERA_HAL_TAKE_PICTURE:
-        cancelPictureInternal();
-        break;
-    default:
-        break;
-    }
-    mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-#endif
-    ALOGI("%s: X", __func__);
-}
-
-/* TBD */
-int usbcam_dump(struct camera_device * device, int fd)
-{
-    ALOGI("%s: E", __func__);
-    int rc = 0;
-
-    ALOGI("%s: X", __func__);
-    return rc;
-}
-/*****************************************************************************
-*  Static function definitions below
-*****************************************************************************/
-
-/******************************************************************************/
-/* No in place conversion supported. Output buffer and input MUST should be   */
-/* different input buffer for a 4x4 pixel video                             ***/
-/******                  YUYVYUYV          00 01 02 03 04 05 06 07 ************/
-/******                  YUYVYUYV          08 09 10 11 12 13 14 15 ************/
-/******                  YUYVYUYV          16 17 18 19 20 21 22 23 ************/
-/******                  YUYVYUYV          24 25 26 27 28 29 30 31 ************/
-/******************************************************************************/
-/* output generated by this function ******************************************/
-/************************** YYYY            00 02 04 06            ************/
-/************************** YYYY            08 10 12 14            ************/
-/************************** YYYY            16 18 20 22            ************/
-/************************** YYYY            24 26 28 30            ************/
-/************************** VUVU            03 01 07 05            ************/
-/************************** VUVU            19 17 23 21            ************/
-/******************************************************************************/
-
-static int convert_YUYV_to_420_NV12(char *in_buf, char *out_buf, int wd, int ht)
-{
-    int rc =0;
-    int row, col, uv_row;
-
-    ALOGD("%s: E", __func__);
-    /* Arrange Y */
-    for(row = 0; row < ht; row++)
-        for(col = 0; col < wd * 2; col += 2)
-        {
-            out_buf[row * wd + col / 2] = in_buf[row * wd * 2 + col];
-        }
-
-    /* Arrange UV */
-    for(row = 0, uv_row = ht; row < ht; row += 2, uv_row++)
-        for(col = 1; col < wd * 2; col += 4)
-        {
-            out_buf[uv_row * wd + col / 2]= in_buf[row * wd * 2 + col + 2];
-            out_buf[uv_row * wd + col / 2 + 1]  = in_buf[row * wd * 2 + col];
-        }
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: initDisplayBuffers
- * Description: This function initializes the preview buffers
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-static int initDisplayBuffers(camera_hardware_t *camHal)
-{
-    preview_stream_ops    *mPreviewWindow;
-    struct ion_fd_data    ion_info_fd;
-    int                   numMinUndequeuedBufs = 0;
-    int                   rc = 0;
-    int                   gralloc_usage = 0;
-    int                   err;
-    int                   color=30;
-
-    ALOGD("%s: E", __func__);
-
-#if DISPLAY
-    if(camHal == NULL) {
-        ALOGE("%s: camHal = NULL", __func__);
-        return -1;
-    }
-
-    mPreviewWindow = camHal->window;
-    if(!mPreviewWindow) {
-        ALOGE("%s: mPreviewWindow = NULL", __func__);
-        return -1;
-    }
-
-    /************************************************************************/
-    /* - get_min_undequeued_buffer_count                                    */
-    /* - set_buffer_count                                                   */
-    /* - set_buffers_geometry                                               */
-    /* - set_usage                                                          */
-    /* - dequeue all the display buffers                                    */
-    /* - cancel buffers: release w/o displaying                             */
-    /************************************************************************/
-
-    /************************************************************************/
-    /* - get_min_undequeued_buffer_count                                    */
-    /************************************************************************/
-    if(mPreviewWindow->get_min_undequeued_buffer_count) {
-        rc = mPreviewWindow->get_min_undequeued_buffer_count(
-            mPreviewWindow, &numMinUndequeuedBufs);
-        if (0 != rc) {
-            ALOGE("%s: get_min_undequeued_buffer_count returned error", __func__);
-        }
-        else
-            ALOGD("%s: get_min_undequeued_buffer_count returned: %d ",
-               __func__, numMinUndequeuedBufs);
-    }
-    else
-        ALOGE("%s: get_min_undequeued_buffer_count is NULL pointer", __func__);
-
-    /************************************************************************/
-    /* - set_buffer_count                                                   */
-    /************************************************************************/
-    if(mPreviewWindow->set_buffer_count) {
-        camHal->previewMem.buffer_count = numMinUndequeuedBufs
-                                            + PRVW_DISP_BUF_CNT;
-        rc = mPreviewWindow->set_buffer_count(
-            mPreviewWindow,
-            camHal->previewMem.buffer_count);
-        if (rc != 0) {
-            ALOGE("%s: set_buffer_count returned error", __func__);
-        }else
-            ALOGD("%s: set_buffer_count returned success", __func__);
-    }else
-        ALOGE("%s: set_buffer_count is NULL pointer", __func__);
-
-    /************************************************************************/
-    /* - set_buffers_geometry                                               */
-    /************************************************************************/
-    if(mPreviewWindow->set_buffers_geometry) {
-        rc = mPreviewWindow->set_buffers_geometry(mPreviewWindow,
-                                                camHal->dispWidth,
-                                                camHal->dispHeight,
-                                                camHal->dispFormat);
-        if (rc != 0) {
-            ALOGE("%s: set_buffers_geometry returned error. %s (%d)",
-               __func__, strerror(-rc), -rc);
-        }else
-            ALOGD("%s: set_buffers_geometry returned success", __func__);
-    }else
-        ALOGE("%s: set_buffers_geometry is NULL pointer", __func__);
-
-    /************************************************************************/
-    /* - set_usage                                                          */
-    /************************************************************************/
-    gralloc_usage = CAMERA_GRALLOC_HEAP_ID | CAMERA_GRALLOC_FALLBACK_HEAP_ID |
-                    GRALLOC_USAGE_PRIVATE_UNCACHED;
-
-    if(mPreviewWindow->set_usage) {
-        rc = mPreviewWindow->set_usage(mPreviewWindow, gralloc_usage);
-        if (rc != 0) {
-            ALOGE("%s: set_usage returned error", __func__);
-        }else
-            ALOGD("%s: set_usage returned success", __func__);
-    }
-    else
-        ALOGE("%s: set_usage is NULL pointer", __func__);
-
-    /************************************************************************/
-    /* - dequeue all the display buffers                                    */
-    /************************************************************************/
-    for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
-        int stride;
-        err = mPreviewWindow->dequeue_buffer(
-                mPreviewWindow,
-                &camHal->previewMem.buffer_handle[cnt],
-                &camHal->previewMem.stride[cnt]);
-        if(!err) {
-            ALOGD("%s: dequeue buf: %p\n",
-                 __func__, camHal->previewMem.buffer_handle[cnt]);
-
-            if(mPreviewWindow->lock_buffer) {
-                err = mPreviewWindow->lock_buffer(
-                    mPreviewWindow,
-                    camHal->previewMem.buffer_handle[cnt]);
-                ALOGD("%s: mPreviewWindow->lock_buffer success",
-                     __func__);
-            }
-
-            // lock the buffer using genlock
-            ALOGD("%s: camera call genlock_lock, hdl=%p",
-                __func__, (*camHal->previewMem.buffer_handle[cnt]));
-
-            if (GENLOCK_NO_ERROR !=
-                genlock_lock_buffer(
-                    (native_handle_t *) (*camHal->previewMem.buffer_handle[cnt]),
-                    GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT))
-            {
-                ALOGE("%s: genlock_lock_buffer(WRITE) failed",
-                    __func__);
-                camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
-            }else {
-                ALOGD("%s: genlock_lock_buffer hdl =%p",
-                  __func__, *camHal->previewMem.buffer_handle[cnt]);
-                camHal->previewMem.local_flag[cnt] = BUFFER_LOCKED;
-            }
-
-            /* Store this buffer details in the context */
-            camHal->previewMem.private_buffer_handle[cnt] =
-                (struct private_handle_t *) (*camHal->previewMem.buffer_handle[cnt]);
-
-            ALOGD("%s: idx = %d, fd = %d, size = %d, offset = %d", __func__,
-                cnt, camHal->previewMem.private_buffer_handle[cnt]->fd,
-                camHal->previewMem.private_buffer_handle[cnt]->size,
-                camHal->previewMem.private_buffer_handle[cnt]->offset);
-
-            camHal->previewMem.camera_memory[cnt] =
-                camHal->get_memory(
-                    camHal->previewMem.private_buffer_handle[cnt]->fd,
-                    camHal->previewMem.private_buffer_handle[cnt]->size,
-                    1, camHal->cb_ctxt);
-
-            ALOGD("%s: data = %p, size = %d, handle = %p", __func__,
-                camHal->previewMem.camera_memory[cnt]->data,
-                camHal->previewMem.camera_memory[cnt]->size,
-                camHal->previewMem.camera_memory[cnt]->handle);
-
-#ifdef USE_ION
-            /* In case of ION usage, open ION fd */
-            camHal->previewMem.mem_info[cnt].main_ion_fd =
-                                                open("/dev/ion", O_RDONLY);
-            if (camHal->previewMem.mem_info[cnt].main_ion_fd < 0) {
-                ALOGE("%s: failed: could not open ion device\n", __func__);
-            }else{
-                memset(&ion_info_fd, 0, sizeof(ion_info_fd));
-                ion_info_fd.fd =
-                    camHal->previewMem.private_buffer_handle[cnt]->fd;
-                if (ioctl(camHal->previewMem.mem_info[cnt].main_ion_fd,
-                          ION_IOC_IMPORT, &ion_info_fd) < 0) {
-                    ALOGE("ION import failed\n");
-                }
-            }
-            camHal->previewMem.mem_info[cnt].fd =
-                camHal->previewMem.private_buffer_handle[cnt]->fd;
-            camHal->previewMem.mem_info[cnt].size =
-                camHal->previewMem.private_buffer_handle[cnt]->size;
-            camHal->previewMem.mem_info[cnt].handle = ion_info_fd.handle;
-
-#endif
-        }
-        else
-            ALOGE("%s: dequeue buf %d failed \n", __func__, cnt);
-    }
-    /************************************************************************/
-    /* - cancel buffers: queue w/o displaying                               */
-    /************************************************************************/
-    for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
-        if (GENLOCK_FAILURE == genlock_unlock_buffer(
-                (native_handle_t *)(*(camHal->previewMem.buffer_handle[cnt])))){
-            ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__,
-                (*(camHal->previewMem.buffer_handle[cnt])) );
-        } else {
-            camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
-            ALOGD("%s: genlock_unlock_buffer success: hdl = %p",
-               __func__, (*(camHal->previewMem.buffer_handle[cnt])));
-        }
-
-        err = mPreviewWindow->cancel_buffer(mPreviewWindow,
-            (buffer_handle_t *)camHal->previewMem.buffer_handle[cnt]);
-        if(!err) {
-            ALOGD("%s: cancel_buffer successful: %p\n",
-                 __func__, camHal->previewMem.buffer_handle[cnt]);
-        }else
-            ALOGE("%s: cancel_buffer failed: %p\n", __func__,
-                 camHal->previewMem.buffer_handle[cnt]);
-    }
-#else
-    rc = 0;
-#endif /* #if DISPLAY */
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: deInitDisplayBuffers
- * Description: This function de-initializes all the display buffers allocated
- *              in initDisplayBuffers
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-static int deInitDisplayBuffers(camera_hardware_t *camHal)
-{
-    int rc = 0;
-    preview_stream_ops    *previewWindow;
-
-    ALOGD("%s: E", __func__);
-
-    if(!camHal || !camHal->window) {
-      ALOGE("%s: camHal = NULL or window = NULL ", __func__);
-      return -1;
-    }
-
-    previewWindow = camHal->window;
-
-    /************************************************************************/
-    /* - Release all buffers that were acquired using get_memory            */
-    /* - If using ION memory, free ION related resources                    */
-    /* - genUnlock if buffer is genLocked                                   */
-    /* - Cancel buffers: queue w/o displaying                               */
-    /************************************************************************/
-
-#if DISPLAY
-    for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
-
-        /* Release all buffers that were acquired using get_memory */
-        camHal->previewMem.camera_memory[cnt]->release(
-                                camHal->previewMem.camera_memory[cnt]);
-
-#ifdef USE_ION
-        /* If using ION memory, free ION related resources */
-        struct ion_handle_data ion_handle;
-        memset(&ion_handle, 0, sizeof(ion_handle));
-        ion_handle.handle = camHal->previewMem.mem_info[cnt].handle;
-        if (ioctl(camHal->previewMem.mem_info[cnt].main_ion_fd,
-            ION_IOC_FREE, &ion_handle) < 0) {
-            ALOGE("%s: ion free failed\n", __func__);
-        }
-        close(camHal->previewMem.mem_info[cnt].main_ion_fd);
-#endif
-
-        /* genUnlock if buffer is genLocked */
-        if(camHal->previewMem.local_flag[cnt] == BUFFER_LOCKED){
-            if (GENLOCK_FAILURE == genlock_unlock_buffer(
-                    (native_handle_t *)(*(camHal->previewMem.buffer_handle[cnt])))){
-                ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__,
-                    (*(camHal->previewMem.buffer_handle[cnt])) );
-            } else {
-                camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
-                ALOGD("%s: genlock_unlock_buffer success: hdl = %p",
-                   __func__, (*(camHal->previewMem.buffer_handle[cnt])));
-            }
-        }
-        /* cancel buffers: enqueue w/o displaying */
-        rc = previewWindow->cancel_buffer(previewWindow,
-            (buffer_handle_t *)camHal->previewMem.buffer_handle[cnt]);
-        if(!rc) {
-            ALOGD("%s: cancel_buffer successful: %p\n",
-                 __func__, camHal->previewMem.buffer_handle[cnt]);
-        }else
-            ALOGE("%s: cancel_buffer failed: %p\n", __func__,
-                 camHal->previewMem.buffer_handle[cnt]);
-    }
-#endif /* #if DISPLAY */
-    memset(&camHal->previewMem, 0, sizeof(camHal->previewMem));
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: getPreviewCaptureFmt
- * Description: This function implements the logic to decide appropriate
- *              capture format from the USB camera
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *      Capture format. Default (V4L2_PIX_FMT_MJPEG)
- *
- * Notes: none
- *****************************************************************************/
-static int getPreviewCaptureFmt(camera_hardware_t *camHal)
-{
-    int     i = 0, mjpegSupported = 0, h264Supported = 0;
-    struct v4l2_fmtdesc fmtdesc;
-
-    memset(&fmtdesc, 0, sizeof(v4l2_fmtdesc));
-
-    /************************************************************************/
-    /* - Query the camera for all supported formats                         */
-    /* - Based on the resolution, pick an apporpriate format                */
-    /************************************************************************/
-
-    /************************************************************************/
-    /* - Query the camera for all supported formats                         */
-    /************************************************************************/
-    for(i = 0; ; i++) {
-        fmtdesc.index = i;
-        fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-        if (-1 == ioctlLoop(camHal->fd, VIDIOC_ENUM_FMT, &fmtdesc)) {
-            if (EINVAL == errno) {
-                ALOGI("%s: Queried all formats till index %d\n", __func__, i);
-                break;
-            } else {
-                ALOGE("%s: VIDIOC_ENUM_FMT failed", __func__);
-            }
-        }
-        if(V4L2_PIX_FMT_MJPEG == fmtdesc.pixelformat){
-            mjpegSupported = 1;
-            ALOGI("%s: V4L2_PIX_FMT_MJPEG is supported", __func__ );
-        }
-        if(V4L2_PIX_FMT_H264 == fmtdesc.pixelformat){
-            h264Supported = 1;
-            ALOGI("%s: V4L2_PIX_FMT_H264 is supported", __func__ );
-        }
-
-    }
-
-    /************************************************************************/
-    /* - Based on the resolution, pick an apporpriate format                */
-    /************************************************************************/
-    //V4L2_PIX_FMT_MJPEG; V4L2_PIX_FMT_YUYV; V4L2_PIX_FMT_H264 = 0x34363248;
-    camHal->captureFormat = V4L2_PIX_FMT_YUYV;
-    if(camHal->prevWidth > 640){
-        if(1 == mjpegSupported)
-            camHal->captureFormat = V4L2_PIX_FMT_MJPEG;
-        else if(1 == h264Supported)
-            camHal->captureFormat = V4L2_PIX_FMT_H264;
-    }
-    ALOGI("%s: Capture format chosen: 0x%x. 0x%x:YUYV. 0x%x:MJPEG. 0x%x: H264",
-        __func__, camHal->captureFormat, V4L2_PIX_FMT_YUYV,
-        V4L2_PIX_FMT_MJPEG, V4L2_PIX_FMT_H264);
-
-    return camHal->captureFormat;
-}
-
-/******************************************************************************
- * Function: getMjpegdOutputFormat
- * Description: This function maps display pixel format enum to JPEG output
- *              format enum
- *
- * Input parameters:
- *   dispFormat              - Display pixel format
- *
- * Return values:
- *      (int)mjpegOutputFormat
- *
- * Notes: none
- *****************************************************************************/
-static int getMjpegdOutputFormat(int dispFormat)
-{
-    int mjpegOutputFormat = YCRCBLP_H2V2;
-
-    if(HAL_PIXEL_FORMAT_YCrCb_420_SP == dispFormat)
-        mjpegOutputFormat = YCRCBLP_H2V2;
-
-    return mjpegOutputFormat;
-}
-
-/******************************************************************************
- * Function: ioctlLoop
- * Description: This function is a blocking call around ioctl
- *
- * Input parameters:
- *   fd             - IOCTL fd
- *   ioctlCmd       - IOCTL command
- *   args           - IOCTL arguments
- *
- * Return values:
- *      (int)mjpegOutputFormat
- *
- * Notes: none
- *****************************************************************************/
-static int ioctlLoop(int fd, int ioctlCmd, void *args)
-{
-    int rc = -1;
-
-    while(1)
-    {
-        rc = ioctl(fd, ioctlCmd, args);
-        if(!((-1 == rc) && (EINTR == errno)))
-            break;
-    }
-    return rc;
-}
-
-/******************************************************************************
- * Function: initV4L2mmap
- * Description: This function requests for V4L2 driver allocated buffers
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int initV4L2mmap(camera_hardware_t *camHal)
-{
-    int rc = -1;
-    struct v4l2_requestbuffers  reqBufs;
-    struct v4l2_buffer          tempBuf;
-
-    ALOGD("%s: E", __func__);
-    memset(&reqBufs, 0, sizeof(v4l2_requestbuffers));
-    reqBufs.type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    reqBufs.memory  = V4L2_MEMORY_MMAP;
-    reqBufs.count   = PRVW_CAP_BUF_CNT;
-
-    if (-1 == ioctlLoop(camHal->fd, VIDIOC_REQBUFS, &reqBufs)) {
-        if (EINVAL == errno) {
-            ALOGE("%s: does not support memory mapping\n", __func__);
-        } else {
-            ALOGE("%s: VIDIOC_REQBUFS failed", __func__);
-        }
-    }
-    ALOGD("%s: VIDIOC_REQBUFS success", __func__);
-
-    if (reqBufs.count < PRVW_CAP_BUF_CNT) {
-        ALOGE("%s: Insufficient buffer memory on\n", __func__);
-    }
-
-    camHal->buffers =
-        ( bufObj* ) calloc(reqBufs.count, sizeof(bufObj));
-
-    if (!camHal->buffers) {
-        ALOGE("%s: Out of memory\n", __func__);
-    }
-
-    /* Store the indexes in the context. Useful during releasing */
-    for (camHal->n_buffers = 0;
-         camHal->n_buffers < reqBufs.count;
-         camHal->n_buffers++) {
-
-        memset(&tempBuf, 0, sizeof(tempBuf));
-
-        tempBuf.index       = camHal->n_buffers;
-        tempBuf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-        tempBuf.memory      = V4L2_MEMORY_MMAP;
-
-        if (-1 == ioctlLoop(camHal->fd, VIDIOC_QUERYBUF, &tempBuf))
-            ALOGE("%s: VIDIOC_QUERYBUF failed", __func__);
-
-        ALOGD("%s: VIDIOC_QUERYBUF success", __func__);
-
-        camHal->buffers[camHal->n_buffers].len = tempBuf.length;
-        camHal->buffers[camHal->n_buffers].data =
-        mmap(NULL /* start anywhere */,
-                  tempBuf.length,
-                  PROT_READ | PROT_WRITE,
-                  MAP_SHARED,
-                  camHal->fd, tempBuf.m.offset);
-
-        if (MAP_FAILED == camHal->buffers[camHal->n_buffers].data)
-            ALOGE("%s: mmap failed", __func__);
-    }
-    ALOGD("%s: X", __func__);
-    return 0;
-}
-
-/******************************************************************************
- * Function: unInitV4L2mmap
- * Description: This function unmaps the V4L2 driver buffers
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int unInitV4L2mmap(camera_hardware_t *camHal)
-{
-    int i, rc = 0;
-    ALOGD("%s: E", __func__);
-
-    for (i = 0; i < camHal->n_buffers; i++)
-        if (-1 == munmap(camHal->buffers[i].data, camHal->buffers[i].len)){
-            ALOGE("%s: munmap failed for buffer: %d", __func__, i);
-            rc = -1;
-        }
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: initUsbCamera
- * Description: This function sets the resolution and pixel format of the
- *              USB camera
- *
- * Input parameters:
- *  camHal              - camera HAL handle
- *  width               - picture width in pixels
- *  height              - picture height in pixels
- *  pixelFormat         - capture format for the camera
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int initUsbCamera(camera_hardware_t *camHal, int width, int height,
-                        int pixelFormat)
-{
-    int     rc = -1;
-    struct  v4l2_capability     cap;
-    struct  v4l2_cropcap        cropcap;
-    struct  v4l2_crop           crop;
-    struct  v4l2_format         v4l2format;
-    unsigned int                min;
-
-    ALOGI("%s: E", __func__);
-
-    if (-1 == ioctlLoop(camHal->fd, VIDIOC_QUERYCAP, &cap)) {
-        if (EINVAL == errno) {
-            ALOGE( "%s: This is not V4L2 device\n", __func__);
-            return -1;
-        } else {
-            ALOGE("%s: VIDIOC_QUERYCAP errno: %d", __func__, errno);
-        }
-    }
-    ALOGD("%s: VIDIOC_QUERYCAP success", __func__);
-
-    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
-        ALOGE("%s: This is not video capture device\n", __func__);
-        return -1;
-    }
-
-    if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
-        ALOGE("%s: This does not support streaming i/o\n", __func__);
-        return -1;
-    }
-
-    /* Select video input, video standard and tune here. */
-    memset(&cropcap, 0, sizeof(cropcap));
-
-    cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-    if (0 == ioctlLoop(camHal->fd, VIDIOC_CROPCAP, &cropcap)) {
-
-        /* reset to default */
-        crop.c = cropcap.defrect;
-        crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-        ALOGD("%s: VIDIOC_CROPCAP success", __func__);
-        if (-1 == ioctlLoop(camHal->fd, VIDIOC_S_CROP, &crop)) {
-        switch (errno) {
-            case EINVAL:
-            /* Cropping not supported. */
-                break;
-            default:
-            /* Errors ignored. */
-                break;
-            }
-        }
-                ALOGD("%s: VIDIOC_S_CROP success", __func__);
-
-    } else {
-        /* Errors ignored. */
-               ALOGE("%s: VIDIOC_S_CROP failed", __func__);
-    }
-
-
-    memset(&v4l2format, 0, sizeof(v4l2format));
-
-    v4l2format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    {
-        v4l2format.fmt.pix.field       = V4L2_FIELD_NONE;
-        v4l2format.fmt.pix.pixelformat = pixelFormat;
-        v4l2format.fmt.pix.width       = width;
-        v4l2format.fmt.pix.height      = height;
-
-        if (-1 == ioctlLoop(camHal->fd, VIDIOC_S_FMT, &v4l2format))
-        {
-            ALOGE("%s: VIDIOC_S_FMT failed", __func__);
-            return -1;
-        }
-        ALOGD("%s: VIDIOC_S_FMT success", __func__);
-
-        /* Note VIDIOC_S_FMT may change width and height. */
-    }
-
-    /* TBR: In case of user pointer buffers, v4l2format.fmt.pix.sizeimage */
-    /* might have to be calculated as per V4L2 sample application due to */
-    /* open source driver bug */
-
-    rc = initV4L2mmap(camHal);
-    ALOGI("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: startUsbCamCapture
- * Description: This function queues buffer objects to the driver and sends
- *              STREAM ON command to the USB camera driver
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int startUsbCamCapture(camera_hardware_t *camHal)
-{
-    int         rc = -1;
-    unsigned    int i;
-    enum        v4l2_buf_type   v4l2BufType;
-    ALOGD("%s: E", __func__);
-
-    for (i = 0; i < camHal->n_buffers; ++i) {
-        struct v4l2_buffer tempBuf;
-
-        memset(&tempBuf, 0, sizeof(tempBuf));
-        tempBuf.type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-        tempBuf.memory  = V4L2_MEMORY_MMAP;
-        tempBuf.index   = i;
-
-        if (-1 == ioctlLoop(camHal->fd, VIDIOC_QBUF, &tempBuf))
-            ALOGE("%s: VIDIOC_QBUF for %d buffer failed", __func__, i);
-        else
-            ALOGD("%s: VIDIOC_QBUF for %d buffer success", __func__, i);
-    }
-
-    v4l2BufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    if (-1 == ioctlLoop(camHal->fd, VIDIOC_STREAMON, &v4l2BufType))
-        ALOGE("%s: VIDIOC_STREAMON failed", __func__);
-    else
-    {
-        ALOGD("%s: VIDIOC_STREAMON success", __func__);
-        rc = 0;
-    }
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: stopUsbCamCapture
- * Description: This function sends STREAM OFF command to the USB camera driver
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int stopUsbCamCapture(camera_hardware_t *camHal)
-{
-    int         rc = -1;
-    unsigned    int i;
-    enum        v4l2_buf_type   v4l2BufType;
-    ALOGD("%s: E", __func__);
-
-    if(!camHal->fd){
-        ALOGE("%s: camHal->fd = NULL ", __func__);
-        return -1;
-    }
-    v4l2BufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    if (-1 == ioctlLoop(camHal->fd, VIDIOC_STREAMOFF, &v4l2BufType)){
-        ALOGE("%s: VIDIOC_STREAMOFF failed", __func__);
-        rc = -1;
-    }else{
-        ALOGD("%s: VIDIOC_STREAMOFF success", __func__);
-        rc = 0;
-    }
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: stopPreviewInternal
- * Description: This function sends EXIT command to prview loop thread,
- *              stops usb camera capture and uninitializes MMAP. This function
- *              assumes that calling function has locked camHal->lock
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int stopPreviewInternal(camera_hardware_t *camHal)
-{
-    int rc = 0;
-    ALOGD("%s: E", __func__);
-
-    if(camHal->previewEnabledFlag)
-    {
-        camHal->prvwCmdPending++;
-        camHal->prvwCmd         = USB_CAM_PREVIEW_EXIT;
-
-        /* yield lock while waiting for the preview thread to exit */
-        camHal->lock.unlock();
-        if(pthread_join(camHal->previewThread, NULL)){
-            ALOGE("%s: Error in pthread_join preview thread", __func__);
-        }
-        camHal->lock.lock();
-
-        if(stopUsbCamCapture(camHal)){
-            ALOGE("%s: Error in stopUsbCamCapture", __func__);
-            rc = -1;
-        }
-        if(unInitV4L2mmap(camHal)){
-            ALOGE("%s: Error in stopUsbCamCapture", __func__);
-            rc = -1;
-        }
-        camHal->previewEnabledFlag = 0;
-    }
-
-    ALOGD("%s: X, rc: %d", __func__, rc);
-    return rc;
-}
-#if 1
-/******************************************************************************
- * Function: prvwThreadTakePictureInternal
- * Description: This function processes one camera frame to get JPEG encoded
- *              picture.
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int prvwThreadTakePictureInternal(camera_hardware_t *camHal)
-{
-    int     rc = 0;
-    QCameraHalMemInfo_t     *mem_info;
-    ALOGD("%s: E", __func__);
-
-    /************************************************************************/
-    /* - If requested for shutter notfication, callback                     */
-    /* - Dequeue capture buffer from USB camera                             */
-    /* - Send capture buffer to JPEG encoder for JPEG compression           */
-    /* - If jpeg frames callback is requested, callback with jpeg buffers   */
-    /* - Enqueue capture buffer back to USB camera                          */
-    /************************************************************************/
-
-    /************************************************************************/
-    /* - If requested for shutter notfication, callback                     */
-    /************************************************************************/
-    if (camHal->msgEnabledFlag & CAMERA_MSG_SHUTTER){
-        camHal->lock.unlock();
-        camHal->notify_cb(CAMERA_MSG_SHUTTER, 0, 0, camHal->cb_ctxt);
-        camHal->lock.lock();
-    }
-
-#if CAPTURE
-    /************************************************************************/
-    /* - Dequeue capture buffer from USB camera                             */
-    /************************************************************************/
-    if (0 == get_buf_from_cam(camHal))
-        ALOGD("%s: get_buf_from_cam success", __func__);
-    else
-        ALOGE("%s: get_buf_from_cam error", __func__);
-#endif
-
-    /************************************************************************/
-    /* - Send capture buffer to JPEG encoder for JPEG compression           */
-    /************************************************************************/
-    /* Optimization: If camera capture is JPEG format, need not compress! */
-    /* instead, just data copy from capture buffer to picture buffer */
-    if(V4L2_PIX_FMT_MJPEG == camHal->captureFormat){
-        /* allocate heap memory for JPEG output */
-        mem_info = &camHal->pictMem.mem_info[0];
-        mem_info->size = camHal->curCaptureBuf.bytesused;
-        /* TBD: allocate_ion_memory
-        rc = QCameraHardwareInterface::allocate_ion_memory(mem_info,
-                            ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
-                            (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
-        */
-        if(rc)
-            ALOGE("%s: ION memory allocation failed", __func__);
-
-        camHal->pictMem.camera_memory[0] = camHal->get_memory(
-                            mem_info->fd, mem_info->size, 1, camHal->cb_ctxt);
-        if(!camHal->pictMem.camera_memory[0])
-            ALOGE("%s: get_mem failed", __func__);
-
-        memcpy( camHal->pictMem.camera_memory[0]->data,
-                (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
-                camHal->curCaptureBuf.bytesused);
-    }
-
-    /************************************************************************/
-    /* - If jpeg frames callback is requested, callback with jpeg buffers   */
-    /************************************************************************/
-    if ((camHal->msgEnabledFlag & CAMERA_MSG_COMPRESSED_IMAGE) &&
-            (camHal->data_cb)){
-        camHal->lock.unlock();
-        camHal->data_cb(CAMERA_MSG_COMPRESSED_IMAGE,
-                        camHal->pictMem.camera_memory[0],
-                        0, NULL, camHal->cb_ctxt);
-        camHal->lock.lock();
-    }
-    /* release heap memory after the call back */
-    if(camHal->pictMem.camera_memory[0])
-        camHal->pictMem.camera_memory[0]->release(
-            camHal->pictMem.camera_memory[0]);
-
-    /* TBD: deallocate_ion_memory */
-    //rc = QCameraHardwareInterface::deallocate_ion_memory(mem_info);
-    if(rc)
-        ALOGE("%s: ION memory de-allocation failed", __func__);
-
-#if CAPTURE
-    /************************************************************************/
-    /* - Enqueue capture buffer back to USB camera                          */
-    /************************************************************************/
-       if(0 == put_buf_to_cam(camHal)) {
-            ALOGD("%s: put_buf_to_cam success", __func__);
-        }
-        else
-            ALOGE("%s: put_buf_to_cam error", __func__);
-#endif
-
-    ALOGD("%s: X, rc: %d", __func__, rc);
-    return rc;
-}
-#endif //#if 0
-/******************************************************************************
- * Function: cache_ops
- * Description: This function calls ION ioctl for cache related operations
- *
- * Input parameters:
- *  mem_info                - QCameraHalMemInfo_t structure with ION info
- *  buf_ptr                 - Buffer pointer that needs to be cache operated
- *  cmd                     - Cache command - clean/invalidate
- *
- * Return values:
- *   MM_CAMERA_OK       No error
- *   -1                 Error
- *
- * Notes: none
- *****************************************************************************/
-int cache_ops(QCameraHalMemInfo_t *mem_info,
-                                    void *buf_ptr,
-                                    unsigned int cmd)
-{
-    struct ion_flush_data cache_inv_data;
-    struct ion_custom_data custom_data;
-    int ret = MM_CAMERA_OK;
-
-#ifdef USE_ION
-    if (NULL == mem_info) {
-        ALOGE("%s: mem_info is NULL, return here", __func__);
-        return -1;
-    }
-
-    memset(&cache_inv_data, 0, sizeof(cache_inv_data));
-    memset(&custom_data, 0, sizeof(custom_data));
-    cache_inv_data.vaddr = buf_ptr;
-    cache_inv_data.fd = mem_info->fd;
-    cache_inv_data.handle = mem_info->handle;
-    cache_inv_data.length = mem_info->size;
-    custom_data.cmd = cmd;
-    custom_data.arg = (unsigned long)&cache_inv_data;
-
-    ALOGD("%s: addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d",
-         __func__, cache_inv_data.vaddr, cache_inv_data.fd,
-         cache_inv_data.handle, cache_inv_data.length,
-         mem_info->main_ion_fd);
-    if(mem_info->main_ion_fd > 0) {
-        if(ioctl(mem_info->main_ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
-            ALOGE("%s: Cache Invalidate failed\n", __func__);
-            ret = -1;
-        }
-    }
-#endif
-
-    return ret;
-}
-
-/******************************************************************************
- * Function: get_buf_from_cam
- * Description: This funtions gets/acquires 1 capture buffer from the camera
- *              driver. The fetched buffer is stored in curCaptureBuf
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int get_buf_from_cam(camera_hardware_t *camHal)
-{
-    int rc = -1;
-
-    ALOGD("%s: E", __func__);
-    {
-        memset(&camHal->curCaptureBuf, 0, sizeof(camHal->curCaptureBuf));
-
-        camHal->curCaptureBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-        camHal->curCaptureBuf.memory = V4L2_MEMORY_MMAP;
-
-        if (-1 == ioctlLoop(camHal->fd, VIDIOC_DQBUF, &camHal->curCaptureBuf)){
-            switch (errno) {
-            case EAGAIN:
-                ALOGE("%s: EAGAIN error", __func__);
-                return 1;
-
-            case EIO:
-            /* Could ignore EIO, see spec. */
-
-            /* fall through */
-
-            default:
-            ALOGE("%s: VIDIOC_DQBUF error", __func__);
-            }
-        }
-        else
-        {
-            rc = 0;
-            ALOGD("%s: VIDIOC_DQBUF: %d successful, %d bytes",
-                 __func__, camHal->curCaptureBuf.index,
-                 camHal->curCaptureBuf.bytesused);
-        }
-    }
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: put_buf_to_cam
- * Description: This funtion puts/releases 1 capture buffer back to the camera
- *              driver
- *
- * Input parameters:
- *   camHal              - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int put_buf_to_cam(camera_hardware_t *camHal)
-{
-    ALOGD("%s: E", __func__);
-
-    camHal->curCaptureBuf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    camHal->curCaptureBuf.memory      = V4L2_MEMORY_MMAP;
-
-
-    if (-1 == ioctlLoop(camHal->fd, VIDIOC_QBUF, &camHal->curCaptureBuf))
-    {
-        ALOGE("%s: VIDIOC_QBUF failed ", __func__);
-        return 1;
-    }
-    ALOGD("%s: X", __func__);
-    return 0;
-}
-
-/******************************************************************************
- * Function: put_buf_to_cam
- * Description: This funtion gets/acquires 1 display buffer from the display
- *              window
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *  buffer_id               - Buffer id pointer. The id of buffer obtained
- *                              by this function is returned in this arg
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int get_buf_from_display(camera_hardware_t *camHal, int *buffer_id)
-{
-    int                     err = 0;
-    preview_stream_ops      *mPreviewWindow = NULL;
-    int                     stride = 0, cnt = 0;
-    buffer_handle_t         *buffer_handle = NULL;
-    struct private_handle_t *private_buffer_handle = NULL;
-
-    ALOGD("%s: E", __func__);
-
-    if (camHal == NULL) {
-        ALOGE("%s: camHal = NULL", __func__);
-        return -1;
-    }
-
-    mPreviewWindow = camHal->window;
-    if( mPreviewWindow == NULL) {
-        ALOGE("%s: mPreviewWindow = NULL", __func__);
-        return -1;
-    }
-    err = mPreviewWindow->dequeue_buffer(mPreviewWindow,
-                                    &buffer_handle,
-                                    &stride);
-    if(!err) {
-        ALOGD("%s: dequeue buf buffer_handle: %p\n", __func__, buffer_handle);
-
-        ALOGD("%s: mPreviewWindow->lock_buffer: %p",
-             __func__, mPreviewWindow->lock_buffer);
-        if(mPreviewWindow->lock_buffer) {
-            err = mPreviewWindow->lock_buffer(mPreviewWindow, buffer_handle);
-            ALOGD("%s: mPreviewWindow->lock_buffer success", __func__);
-        }
-        ALOGD("%s: camera call genlock_lock, hdl=%p",
-             __func__, (*buffer_handle));
-
-        if (GENLOCK_NO_ERROR !=
-            genlock_lock_buffer((native_handle_t *)(*buffer_handle),
-                                GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT)) {
-           ALOGE("%s: genlock_lock_buffer(WRITE) failed", __func__);
-       } else {
-         ALOGD("%s: genlock_lock_buffer hdl =%p", __func__, *buffer_handle);
-       }
-
-        private_buffer_handle = (struct private_handle_t *)(*buffer_handle);
-
-        ALOGD("%s: fd = %d, size = %d, offset = %d, stride = %d",
-             __func__, private_buffer_handle->fd,
-        private_buffer_handle->size, private_buffer_handle->offset, stride);
-
-        for(cnt = 0; cnt < camHal->previewMem.buffer_count + 2; cnt++) {
-            if(private_buffer_handle->fd ==
-               camHal->previewMem.private_buffer_handle[cnt]->fd) {
-                *buffer_id = cnt;
-                ALOGD("%s: deQueued fd = %d, index: %d",
-                     __func__, private_buffer_handle->fd, cnt);
-                break;
-            }
-        }
-    }
-    else
-        ALOGE("%s: dequeue buf failed \n", __func__);
-
-    ALOGD("%s: X", __func__);
-
-    return err;
-}
-
-/******************************************************************************
- * Function: put_buf_to_display
- * Description: This funtion puts/enqueues 1 buffer back to the display window
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *  buffer_id               - id of the buffer that needs to be enqueued
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int put_buf_to_display(camera_hardware_t *camHal, int buffer_id)
-{
-    int err = 0;
-    preview_stream_ops    *mPreviewWindow;
-
-    ALOGD("%s: E", __func__);
-
-    if (camHal == NULL) {
-        ALOGE("%s: camHal = NULL", __func__);
-        return -1;
-    }
-
-    mPreviewWindow = camHal->window;
-    if( mPreviewWindow == NULL) {
-        ALOGE("%s: mPreviewWindow = NULL", __func__);
-        return -1;
-    }
-
-    if (GENLOCK_FAILURE ==
-        genlock_unlock_buffer(
-            (native_handle_t *)
-            (*(camHal->previewMem.buffer_handle[buffer_id])))) {
-       ALOGE("%s: genlock_unlock_buffer failed: hdl =%p",
-            __func__, (*(camHal->previewMem.buffer_handle[buffer_id])) );
-    } else {
-      ALOGD("%s: genlock_unlock_buffer success: hdl =%p",
-           __func__, (*(camHal->previewMem.buffer_handle[buffer_id])) );
-    }
-
-    /* Cache clean the output buffer so that cache is written back */
-    cache_ops(&camHal->previewMem.mem_info[buffer_id],
-                         (void *)camHal->previewMem.camera_memory[buffer_id]->data,
-                         ION_IOC_CLEAN_CACHES);
-                         /*
-    cache_ops(&camHal->previewMem.mem_info[buffer_id],
-                         (void *)camHal->previewMem.camera_memory[buffer_id]->data,
-                         ION_IOC_CLEAN_INV_CACHES);
-*/
-    err = mPreviewWindow->enqueue_buffer(mPreviewWindow,
-      (buffer_handle_t *)camHal->previewMem.buffer_handle[buffer_id]);
-    if(!err) {
-        ALOGD("%s: enqueue buf successful: %p\n",
-             __func__, camHal->previewMem.buffer_handle[buffer_id]);
-    }else
-        ALOGE("%s: enqueue buf failed: %p\n",
-             __func__, camHal->previewMem.buffer_handle[buffer_id]);
-
-    ALOGD("%s: X", __func__);
-
-    return err;
-}
-
-/******************************************************************************
- * Function: put_buf_to_display
- * Description: This funtion transfers the content from capture buffer to
- *              preiew display buffer after appropriate conversion
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *  buffer_id               - id of the buffer that needs to be enqueued
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int convert_data_frm_cam_to_disp(camera_hardware_t *camHal, int buffer_id)
-{
-    int rc = -1;
-
-    if(!camHal) {
-        ALOGE("%s: camHal is NULL", __func__);
-        return -1;
-    }
-    /* If input and output are raw formats, but different color format, */
-    /* call color conversion routine                                    */
-    if( (V4L2_PIX_FMT_YUYV == camHal->captureFormat) &&
-        (HAL_PIXEL_FORMAT_YCrCb_420_SP == camHal->dispFormat))
-    {
-        convert_YUYV_to_420_NV12(
-            (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
-            (char *)camHal->previewMem.camera_memory[buffer_id]->data,
-            camHal->prevWidth,
-            camHal->prevHeight);
-        ALOGD("%s: Copied %d bytes from camera buffer %d to display buffer: %d",
-             __func__, camHal->curCaptureBuf.bytesused,
-             camHal->curCaptureBuf.index, buffer_id);
-        rc = 0;
-    }
-
-    /* If camera buffer is MJPEG encoded, call mjpeg decode call */
-    if(V4L2_PIX_FMT_MJPEG == camHal->captureFormat)
-    {
-        if(NULL == camHal->mjpegd)
-        {
-            rc = mjpegDecoderInit(&camHal->mjpegd);
-            if(rc < 0)
-                ALOGE("%s: mjpegDecoderInit Error: %d", __func__, rc);
-        }
-        if(camHal->mjpegd)
-        {
-            rc = mjpegDecode(
-                (void*)camHal->mjpegd,
-                (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
-                camHal->curCaptureBuf.bytesused,
-                (char *)camHal->previewMem.camera_memory[buffer_id]->data,
-                (char *)camHal->previewMem.camera_memory[buffer_id]->data +
-                    camHal->prevWidth * camHal->prevHeight,
-                getMjpegdOutputFormat(camHal->dispFormat));
-            if(rc < 0)
-                ALOGE("%s: mjpegDecode Error: %d", __func__, rc);
-        }
-    }
-    return rc;
-}
-
-/******************************************************************************
- * Function: launch_preview_thread
- * Description: This is a wrapper function to start preview thread
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int launch_preview_thread(camera_hardware_t *camHal)
-{
-    ALOGD("%s: E", __func__);
-    int rc = 0;
-
-    if(!camHal) {
-        ALOGE("%s: camHal is NULL", __func__);
-        return -1;
-    }
-
-    pthread_attr_t attr;
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-    pthread_create(&camHal->previewThread, &attr, previewloop, camHal);
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: launch_preview_thread
- * Description: This is thread funtion for preivew loop
- *
- * Input parameters:
- *  hcamHal                 - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static void * previewloop(void *hcamHal)
-{
-    int                 rc;
-    int                 buffer_id   = 0;
-    pid_t               tid         = 0;
-    camera_hardware_t   *camHal     = NULL;
-    int                 msgType     = 0;
-    camera_memory_t     *data       = NULL;
-    camera_frame_metadata_t *metadata= NULL;
-    camera_memory_t     *previewMem = NULL;
-
-    camHal = (camera_hardware_t *)hcamHal;
-    ALOGD("%s: E", __func__);
-
-    if(!camHal) {
-        ALOGE("%s: camHal is NULL", __func__);
-        return NULL ;
-    }
-
-    tid  = gettid();
-    /* TBR: Set appropriate thread priority */
-    androidSetThreadPriority(tid, ANDROID_PRIORITY_NORMAL);
-    prctl(PR_SET_NAME, (unsigned long)"Camera HAL preview thread", 0, 0, 0);
-
-    /************************************************************************/
-    /* - Time wait (select) on camera fd for input read buffer              */
-    /* - Check if any preview thread commands are set. If set, process      */
-    /* - Dequeue display buffer from surface                                */
-    /* - Dequeue capture buffer from USB camera                             */
-    /* - Convert capture format to display format                           */
-    /* - If preview frames callback is requested, callback with prvw buffers*/
-    /* - Enqueue display buffer back to surface                             */
-    /* - Enqueue capture buffer back to USB camera                          */
-    /************************************************************************/
-    while(1) {
-        fd_set fds;
-        struct timeval tv;
-        int r = 0;
-
-        FD_ZERO(&fds);
-#if CAPTURE
-        FD_SET(camHal->fd, &fds);
-#endif /* CAPTURE */
-
-    /************************************************************************/
-    /* - Time wait (select) on camera fd for input read buffer              */
-    /************************************************************************/
-        tv.tv_sec = 0;
-        tv.tv_usec = 500000;
-
-        ALOGD("%s: b4 select on camHal->fd + 1,fd: %d", __func__, camHal->fd);
-#if CAPTURE
-        r = select(camHal->fd + 1, &fds, NULL, NULL, &tv);
-#else
-        r = select(1, NULL, NULL, NULL, &tv);
-#endif /* CAPTURE */
-        ALOGD("%s: after select : %d", __func__, camHal->fd);
-
-        if (-1 == r) {
-            if (EINTR == errno)
-                continue;
-            ALOGE("%s: FDSelect error: %d", __func__, errno);
-        }
-
-        if (0 == r) {
-            ALOGD("%s: select timeout\n", __func__);
-        }
-
-        /* Protect the context for one iteration of preview loop */
-        /* this gets unlocked at the end of the while */
-        Mutex::Autolock autoLock(camHal->lock);
-
-    /************************************************************************/
-    /* - Check if any preview thread commands are set. If set, process      */
-    /************************************************************************/
-        if(camHal->prvwCmdPending)
-        {
-            /* command is serviced. Hence command pending = 0  */
-            camHal->prvwCmdPending--;
-            //sempost(ack)
-            if(USB_CAM_PREVIEW_EXIT == camHal->prvwCmd){
-                /* unlock before exiting the thread */
-                camHal->lock.unlock();
-                ALOGI("%s: Exiting coz USB_CAM_PREVIEW_EXIT", __func__);
-                return (void *)0;
-            }else if(USB_CAM_PREVIEW_TAKEPIC == camHal->prvwCmd){
-                rc = prvwThreadTakePictureInternal(camHal);
-                if(rc)
-                    ALOGE("%s: prvwThreadTakePictureInternal returned error",
-                    __func__);
-            }
-        }
-
-        /* Null check on preview window. If null, sleep */
-        if(!camHal->window) {
-            ALOGD("%s: sleeping coz camHal->window = NULL",__func__);
-            camHal->lock.unlock();
-            sleep(2);
-            continue;
-        }
-#if DISPLAY
-    /************************************************************************/
-    /* - Dequeue display buffer from surface                                */
-    /************************************************************************/
-        if(0 == get_buf_from_display(camHal, &buffer_id)) {
-            ALOGD("%s: get_buf_from_display success: %d",
-                 __func__, buffer_id);
-        }else{
-            ALOGE("%s: get_buf_from_display failed. Skipping the loop",
-                 __func__);
-            continue;
-        }
-#endif
-
-#if CAPTURE
-    /************************************************************************/
-    /* - Dequeue capture buffer from USB camera                             */
-    /************************************************************************/
-        if (0 == get_buf_from_cam(camHal))
-            ALOGD("%s: get_buf_from_cam success", __func__);
-        else
-            ALOGE("%s: get_buf_from_cam error", __func__);
-#endif
-
-#if FILE_DUMP_CAMERA
-        /* Debug code to dump frames from camera */
-        {
-            static int frame_cnt = 0;
-            /* currently hardcoded for Bytes-Per-Pixel = 1.5 */
-            fileDump("/data/USBcam.yuv",
-            (char*)camHal->buffers[camHal->curCaptureBuf.index].data,
-            camHal->prevWidth * camHal->prevHeight * 1.5,
-            &frame_cnt);
-        }
-#endif
-
-#if MEMSET
-        static int color = 30;
-        color += 50;
-        if(color > 200) {
-            color = 30;
-        }
-        ALOGE("%s: Setting to the color: %d\n", __func__, color);
-        /* currently hardcoded for format of type Bytes-Per-Pixel = 1.5 */
-        memset(camHal->previewMem.camera_memory[buffer_id]->data,
-               color, camHal->dispWidth * camHal->dispHeight * 1.5 + 2 * 1024);
-#else
-        convert_data_frm_cam_to_disp(camHal, buffer_id);
-        ALOGD("%s: Copied data to buffer_id: %d", __func__, buffer_id);
-#endif
-
-#if FILE_DUMP_B4_DISP
-        /* Debug code to dump display buffers */
-        {
-            static int frame_cnt = 0;
-            /* currently hardcoded for Bytes-Per-Pixel = 1.5 */
-            fileDump("/data/display.yuv",
-                (char*) camHal->previewMem.camera_memory[buffer_id]->data,
-                camHal->dispWidth * camHal->dispHeight * 1.5,
-                &frame_cnt);
-            ALOGD("%s: Written buf_index: %d ", __func__, buffer_id);
-        }
-#endif
-
-#if DISPLAY
-    /************************************************************************/
-    /* - Enqueue display buffer back to surface                             */
-    /************************************************************************/
-       if(0 == put_buf_to_display(camHal, buffer_id)) {
-            ALOGD("%s: put_buf_to_display success: %d", __func__, buffer_id);
-        }
-        else
-            ALOGE("%s: put_buf_to_display error", __func__);
-#endif
-
-#if CAPTURE
-     /************************************************************************/
-    /* - Enqueue capture buffer back to USB camera                          */
-    /************************************************************************/
-       if(0 == put_buf_to_cam(camHal)) {
-            ALOGD("%s: put_buf_to_cam success", __func__);
-        }
-        else
-            ALOGE("%s: put_buf_to_cam error", __func__);
-#endif
-
-#if CALL_BACK
-    /************************************************************************/
-    /* - If preview frames callback is requested, callback with prvw buffers*/
-    /************************************************************************/
-        /* TBD: change the 1.5 hardcoding to Bytes Per Pixel */
-        int previewBufSize = camHal->prevWidth * camHal->prevHeight * 1.5;
-
-        msgType |=  CAMERA_MSG_PREVIEW_FRAME;
-
-        if(previewBufSize !=
-            camHal->previewMem.private_buffer_handle[buffer_id]->size) {
-
-            previewMem = camHal->get_memory(
-                camHal->previewMem.private_buffer_handle[buffer_id]->fd,
-                previewBufSize,
-                1,
-                camHal->cb_ctxt);
-
-              if (!previewMem || !previewMem->data) {
-                  ALOGE("%s: get_memory failed.\n", __func__);
-              }
-              else {
-                  data = previewMem;
-                  ALOGD("%s: GetMemory successful. data = %p",
-                            __func__, data);
-                  ALOGD("%s: previewBufSize = %d, priv_buf_size: %d",
-                    __func__, previewBufSize,
-                    camHal->previewMem.private_buffer_handle[buffer_id]->size);
-              }
-        }
-        else{
-            data =   camHal->previewMem.camera_memory[buffer_id];
-            ALOGD("%s: No GetMemory, no invalid fmt. data = %p, idx=%d",
-                __func__, data, buffer_id);
-        }
-        /* Unlock and lock around the callback. */
-        /* Sometimes 'disable_msg' is issued in the callback context, */
-        /* leading to deadlock */
-        camHal->lock.unlock();
-        if((camHal->msgEnabledFlag & CAMERA_MSG_PREVIEW_FRAME) &&
-            camHal->data_cb){
-            ALOGD("%s: before data callback", __func__);
-            camHal->data_cb(msgType, data, 0,metadata, camHal->cb_ctxt);
-            ALOGD("%s: after data callback: %p", __func__, camHal->data_cb);
-        }
-        camHal->lock.lock();
-        if (previewMem)
-            previewMem->release(previewMem);
-#endif
-
-    }//while(1)
-    ALOGD("%s: X", __func__);
-    return (void *)0;
-}
-
-/******************************************************************************
- * Function: get_uvc_device
- * Description: This function loops through /dev/video entries and probes with
- *              UVCIOC query. If the device responds to the query, then it is
- *              detected as UVC webcam
- * Input parameters:
- *   devname             - String pointer. The function return dev entry
- *                          name in this string
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-static int get_uvc_device(char *devname)
-{
-    char    temp_devname[FILENAME_LENGTH];
-    FILE    *fp = NULL;
-    int     i = 0, ret = 0, fd;
-
-    ALOGD("%s: E", __func__);
-#if 1
-    strncpy(devname, "/dev/video1", FILENAME_LENGTH);
-
-/*
-    struct          stat st;
-
-    strncpy(dev_name, "/dev/video1", FILENAME_LENGTH);
-    if (-1 == stat(dev_name, &st)) {
-        ALOGE("%s: Cannot identify '%s': %d, %s\n",
-             __func__, dev_name, errno, strerror(errno));
-    }
-
-    if (!S_ISCHR(st.st_mode)) {
-        ALOGE("%s: %s is no device\n", __func__, dev_name);
-        rc = -1;
-    }
-*/
-
-#else
-
-    *devname = '\0';
-    /************************************************************************/
-    /* - List all /dev/video* entries to a file                             */
-    /* - Open the video list file and loop through the list                 */
-    /* - Send UVC specific control query and check the response             */
-    /* - If device responds to the query as success, device is UVC webcam   */
-    /************************************************************************/
-
-    /************************************************************************/
-    /* - List all /dev/video* entries to a file                             */
-    /************************************************************************/
-    /* Temporarily commented out. This logic doesnt seem to be working */
-    //system("ls > /data/video_dev_list");
-
-    /************************************************************************/
-    /* - Open the video list file and loop through the list                 */
-    /************************************************************************/
-
-    /* Temporarily commented out. This logic doesnt seem to be working */
-    /*
-    fp = fopen("/data/video_dev_list", "rb");
-    if(!fp) {
-        ALOGE("%s: Error in opening /data/video_dev_list ", __func__);
-        return -1;
-    }
-    */
-
-    /* Temporarily commented out. Looping logic changed due to issue in */
-    /* executing system("ls > /data/video_dev_list") */
-    //while(EOF != fscanf(fp, "%s", devname)){
-    while(1){
-        uvc_xu_control_query    xqry;
-
-        sprintf(temp_devname, "/dev/video%d", i);
-        ALOGD("%s: Probing %s \n", __func__, temp_devname);
-
-        fd = open(temp_devname, O_RDWR /* required */ | O_NONBLOCK, 0);
-        if(-1 != fd){
-            memset(&xqry, 0, sizeof(uvc_xu_control_query));
-            ret = ioctl(fd, UVCIOC_CTRL_QUERY, &xqry);
-            ALOGD("%s: UVCIOC ret: %d, errno: %d", __func__, ret, errno);
-            /****************************************************************/
-            /* if UVCIOC is executed successfully, ret = 0                  */
-            /* if UVCIOC is executed but Control Unit = 0 does not exist,   */
-            /*      ret = -1 and errno = ENOENT                             */
-            /* if UVCIOC doesnot execute, ret = -1 and errno = EINVAL       */
-            /****************************************************************/
-            if((0 == ret) || (ret && (ENOENT == errno))){
-                ALOGD("%s: Found UVC node: %s\n", __func__, temp_devname);
-                strncpy(devname, temp_devname, FILENAME_LENGTH);
-                /* Exit the loop at the first UVC node detection */
-                break;
-            }
-            close(fd);
-        }
-        /* Temporarily logic to probe video0 to video10 nodes */
-        if(i++ > 10)
-        {
-            if(fp)
-                fclose(fp);
-            break;
-        }
-    }
-#endif /* #if 0 */
-    ALOGD("%s: X", __func__);
-    return 0;
-} /* get_uvc_device */
-
-/******************************************************************************
- * Function: fileDump
- * Description: This is a utility function to dump buffers into a file
- *
- * Input parameters:
- *  fn              - File name string
- *  data            - pointer to character buffer that needs to be dumped
- *  length          - Length of the buffer to be dumped
- *  frm_cnt         - Pointer to frame count. This count is incremented by this
- *                      function on successful file write
- * Return values:
- *      0   Success
- *      -1  Error
- * Notes: none
- *****************************************************************************/
-static int fileDump(const char* fn, char* data, int length, int* frm_cnt)
-{
-
-    FILE *fp = NULL;
-    if (0 == *frm_cnt) {
-        fp = fopen(fn, "wb");
-        if (NULL == fp) {
-            ALOGE("%s: Error in opening %s", __func__, fn);
-        }
-        fclose(fp);
-    }
-    fp = fopen(fn, "ab");
-    if (NULL == fp) {
-        ALOGE("%s: Error in opening %s", __func__, fn);
-    }
-    fwrite(data, 1, length, fp);
-    fclose(fp);
-    (*frm_cnt)++;
-    ALOGD("%s: Written %d bytes for frame:%d, in %s",
-        __func__, length, *frm_cnt, fn);
-
-    return 0;
-}
-
-/******************************************************************************
- * Function: launchTakePictureThread
- * Description: This is a wrapper function to start take picture thread
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int launchTakePictureThread(camera_hardware_t *camHal)
-{
-    ALOGD("%s: E", __func__);
-    int rc = 0;
-
-    if(!camHal) {
-        ALOGE("%s: camHal is NULL", __func__);
-        return -1;
-    }
-
-    pthread_attr_t attr;
-    pthread_attr_init(&attr);
-    /* create the thread in detatched state, when the thread exits all */
-    /* memory resources are freed up */
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-    pthread_create(&camHal->takePictureThread, &attr, takePictureThread, camHal);
-
-    ALOGD("%s: X", __func__);
-    return rc;
-}
-
-/******************************************************************************
- * Function: takePictureThread
- * Description: This function is associated with take picture thread
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static void * takePictureThread(void *hcamHal)
-{
-    int                 rc = 0;
-    int                 buffer_id   = 0;
-    pid_t               tid         = 0;
-    camera_hardware_t   *camHal     = NULL;
-    int                 msgType     = 0;
-    int                 jpegLength  = 0;
-    QCameraHalMemInfo_t *mem_info   = NULL;
-
-    camHal = (camera_hardware_t *)hcamHal;
-    ALOGI("%s: E", __func__);
-
-    if(!camHal) {
-        ALOGE("%s: camHal is NULL", __func__);
-        return NULL ;
-    }
-
-    tid  = gettid();
-    /* TBR: Set appropriate thread priority */
-    androidSetThreadPriority(tid, ANDROID_PRIORITY_NORMAL);
-    prctl(PR_SET_NAME, (unsigned long)"Camera HAL preview thread", 0, 0, 0);
-
-    /************************************************************************/
-    /* - If requested for shutter notfication, notify                       */
-    /* - Initialize USB camera with snapshot parameters                     */
-    /* - Time wait (select) on camera fd for camera frame availability      */
-    /* - Dequeue capture buffer from USB camera                             */
-    /* - Send capture buffer to JPEG encoder for JPEG compression           */
-    /* - If jpeg frames callback is requested, callback with jpeg buffers   */
-    /* - Enqueue capture buffer back to USB camera                          */
-    /* - Free USB camera resources and close camera                         */
-    /* - If preview was stopped for taking picture, restart the preview     */
-    /************************************************************************/
-
-    Mutex::Autolock autoLock(camHal->lock);
-    /************************************************************************/
-    /* - If requested for shutter notfication, notify                       */
-    /************************************************************************/
-#if 0 /* TBD: Temporarily commented out due to an issue. Sometimes it takes */
-    /* long time to get back the lock once unlocked and notify callback */
-    if (camHal->msgEnabledFlag & CAMERA_MSG_SHUTTER){
-        camHal->lock.unlock();
-        camHal->notify_cb(CAMERA_MSG_SHUTTER, 0, 0, camHal->cb_ctxt);
-        camHal->lock.lock();
-    }
-#endif
-    /************************************************************************/
-    /* - Initialize USB camera with snapshot parameters                     */
-    /************************************************************************/
-    USB_CAM_OPEN(camHal);
-
-#if JPEG_ON_USB_CAMERA
-    rc = initUsbCamera(camHal, camHal->pictWidth, camHal->pictHeight,
-                        V4L2_PIX_FMT_MJPEG);
-#else
-    rc = initUsbCamera(camHal, camHal->pictWidth, camHal->pictHeight,
-                        V4L2_PIX_FMT_YUYV);
-#endif
-    ERROR_CHECK_EXIT_THREAD(rc, "initUsbCamera");
-
-    rc = startUsbCamCapture(camHal);
-    ERROR_CHECK_EXIT_THREAD(rc, "startUsbCamCapture");
-
-    /************************************************************************/
-    /* - Time wait (select) on camera fd for camera frame availability      */
-    /************************************************************************/
-    {
-        fd_set fds;
-        struct timeval tv;
-        int r = 0;
-
-        FD_ZERO(&fds);
-        FD_SET(camHal->fd, &fds);
-
-        tv.tv_sec = 1;
-        tv.tv_usec = 0;
-
-        do{
-            ALOGD("%s: b4 select on camHal->fd : %d", __func__, camHal->fd);
-            r = select(camHal->fd + 1, &fds, NULL, NULL, &tv);
-            ALOGD("%s: after select", __func__);
-        }while((0 == r) || ((-1 == r) && (EINTR == errno)));
-
-        if ((-1 == r) && (EINTR != errno)){
-            ALOGE("%s: FDSelect ret = %d error: %d", __func__, r, errno);
-            return (void *)-1;
-        }
-
-    }
-    /************************************************************************/
-    /* - Dequeue capture buffer from USB camera                             */
-    /************************************************************************/
-    if (0 == get_buf_from_cam(camHal))
-        ALOGD("%s: get_buf_from_cam success", __func__);
-    else
-        ALOGE("%s: get_buf_from_cam error", __func__);
-
-    /************************************************************************/
-    /* - Send capture buffer to JPEG encoder for JPEG compression           */
-    /************************************************************************/
-    mem_info = &camHal->pictMem.mem_info[0];
-    mem_info->size = MAX_JPEG_BUFFER_SIZE;
-
-    rc = allocate_ion_memory(mem_info,
-                        ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
-                        (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
-    if(rc)
-        ALOGE("%s: ION memory allocation failed", __func__);
-
-    camHal->pictMem.camera_memory[0] = camHal->get_memory(
-                        mem_info->fd, mem_info->size, 1, camHal->cb_ctxt);
-    if(!camHal->pictMem.camera_memory[0])
-        ALOGE("%s: get_mem failed", __func__);
-
-#if FREAD_JPEG_PICTURE
-    jpegLength = readFromFile("/data/tempVGA.jpeg",
-                    (char*)camHal->pictMem.camera_memory[0]->data,
-                    camHal->pictMem.camera_memory[0]->size);
-    camHal->pictMem.camera_memory[0]->size = jpegLength;
-
-#elif JPEG_ON_USB_CAMERA
-    memcpy((char*)camHal->pictMem.camera_memory[0]->data,
-            (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
-            camHal->curCaptureBuf.bytesused);
-    camHal->pictMem.camera_memory[0]->size = camHal->curCaptureBuf.bytesused;
-    jpegLength = camHal->curCaptureBuf.bytesused;
-
-#else
-    rc = encodeJpeg(camHal);
-    ERROR_CHECK_EXIT_THREAD(rc, "jpeg_encode");
-#endif
-    if(jpegLength <= 0)
-        ALOGI("%s: jpegLength : %d", __func__, jpegLength);
-
-     ALOGD("%s: jpegLength : %d", __func__, jpegLength);
-    /************************************************************************/
-    /* - If jpeg frames callback is requested, callback with jpeg buffers   */
-    /************************************************************************/
-    /* TBD: CAMERA_MSG_RAW_IMAGE data call back */
-
-    if ((camHal->msgEnabledFlag & CAMERA_MSG_COMPRESSED_IMAGE) &&
-            (camHal->data_cb)){
-        /* Unlock temporarily, callback might call HAL api in turn */
-        camHal->lock.unlock();
-
-        camHal->data_cb(CAMERA_MSG_COMPRESSED_IMAGE,
-                        camHal->pictMem.camera_memory[0],
-                        0, NULL, camHal->cb_ctxt);
-        camHal->lock.lock();
-    }
-
-    /* release heap memory after the call back */
-    if(camHal->pictMem.camera_memory[0])
-        camHal->pictMem.camera_memory[0]->release(
-            camHal->pictMem.camera_memory[0]);
-
-    rc = deallocate_ion_memory(mem_info);
-    if(rc)
-        ALOGE("%s: ION memory de-allocation failed", __func__);
-
-    /************************************************************************/
-    /* - Enqueue capture buffer back to USB camera                          */
-    /************************************************************************/
-    if(0 == put_buf_to_cam(camHal)) {
-        ALOGD("%s: put_buf_to_cam success", __func__);
-    }
-    else
-        ALOGE("%s: put_buf_to_cam error", __func__);
-
-    /************************************************************************/
-    /* - Free USB camera resources and close camera                         */
-    /************************************************************************/
-    rc = stopUsbCamCapture(camHal);
-    ERROR_CHECK_EXIT_THREAD(rc, "stopUsbCamCapture");
-
-    rc = unInitV4L2mmap(camHal);
-    ERROR_CHECK_EXIT_THREAD(rc, "unInitV4L2mmap");
-
-    USB_CAM_CLOSE(camHal);
-    /************************************************************************/
-    /* - If preview was stopped for taking picture, restart the preview     */
-    /************************************************************************/
-    if(camHal->prvwStoppedForPicture)
-    {
-        struct camera_device    device;
-        device.priv = (void *)camHal;
-
-        USB_CAM_OPEN(camHal);
-        /* Unlock temporarily coz usbcam_start_preview has a lock */
-        camHal->lock.unlock();
-        rc = usbcam_start_preview(&device);
-        if(rc)
-            ALOGE("%s: start_preview error after take picture", __func__);
-        camHal->lock.lock();
-        camHal->prvwStoppedForPicture = 0;
-    }
-
-    /* take picture activity is done */
-    camHal->takePictInProgress = 0;
-
-    ALOGI("%s: X", __func__);
-    return (void *)0;
-}
-
-/******************************************************************************
- * Function: allocate_ion_memory
- * Description: This function is allocates ION memory
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type)
-{
-    int                         rc = 0;
-    struct ion_handle_data      handle_data;
-    struct ion_allocation_data  alloc;
-    struct ion_fd_data          ion_info_fd;
-    int                         main_ion_fd = 0;
-
-    main_ion_fd = open("/dev/ion", O_RDONLY);
-    if (main_ion_fd <= 0) {
-        ALOGE("Ion dev open failed %s\n", strerror(errno));
-        goto ION_OPEN_FAILED;
-    }
-
-    memset(&alloc, 0, sizeof(alloc));
-    alloc.len = mem_info->size;
-    /* to make it page size aligned */
-    alloc.len = (alloc.len + 4095) & (~4095);
-    alloc.align = 4096;
-    alloc.flags = ION_FLAG_CACHED;
-    alloc.heap_mask = ion_type;
-    rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &alloc);
-    if (rc < 0) {
-        ALOGE("ION allocation failed\n");
-        goto ION_ALLOC_FAILED;
-    }
-
-    memset(&ion_info_fd, 0, sizeof(ion_info_fd));
-    ion_info_fd.handle = alloc.handle;
-    rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd);
-    if (rc < 0) {
-        ALOGE("ION map failed %s\n", strerror(errno));
-        goto ION_MAP_FAILED;
-    }
-
-    mem_info->main_ion_fd = main_ion_fd;
-    mem_info->fd = ion_info_fd.fd;
-    mem_info->handle = ion_info_fd.handle;
-    mem_info->size = alloc.len;
-    return 0;
-
-ION_MAP_FAILED:
-    memset(&handle_data, 0, sizeof(handle_data));
-    handle_data.handle = ion_info_fd.handle;
-    ioctl(main_ion_fd, ION_IOC_FREE, &handle_data);
-ION_ALLOC_FAILED:
-    close(main_ion_fd);
-ION_OPEN_FAILED:
-    return -1;
-}
-
-/******************************************************************************
- * Function: deallocate_ion_memory
- * Description: This function de allocates ION memory
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *
- * Return values:
- *   0      No error
- *   -1     Error
- *
- * Notes: none
- *****************************************************************************/
-static int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info)
-{
-  struct ion_handle_data handle_data;
-  int rc = 0;
-
-  if (mem_info->fd > 0) {
-      close(mem_info->fd);
-      mem_info->fd = 0;
-  }
-
-  if (mem_info->main_ion_fd > 0) {
-      memset(&handle_data, 0, sizeof(handle_data));
-      handle_data.handle = mem_info->handle;
-      ioctl(mem_info->main_ion_fd, ION_IOC_FREE, &handle_data);
-      close(mem_info->main_ion_fd);
-      mem_info->main_ion_fd = 0;
-  }
-  return rc;
-}
-
-/******************************************************************************
- * Function: readFromFile
- * Description: This function reads data from the given file into given buffer
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *
- * Return values:
- *   int    bytesRead
- *
- * Notes: none
- *****************************************************************************/
-static int readFromFile(char* fileName, char* buffer, int bufferSize)
-{
-    int bytesRead = 0, fileSize = 0;
-    FILE *fp;
-
-    fp = fopen(fileName, "rb");
-    if(!fp){
-        ALOGE("%s: Error in opening %s ", __func__, fileName);
-        return bytesRead;
-    }
-
-    /* If file is bigger for given buffer, exit */
-    if (fileSize > bufferSize){
-        ALOGE("%s: Error %d > %d", __func__, fileSize, bufferSize);
-        return bytesRead;
-    }
-
-    bytesRead = fread(buffer, 1, bufferSize, fp);
-    ALOGD(" %s: bytesRead: %d", __func__, bytesRead);
-
-    return bytesRead;
-}
-
-/******************************************************************************
- * Function: encodeJpeg
- * Description: This function initializes Jpeg encoder and calls jpeg encoder
- *              call and waits for the encode to complete
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *
- * Return values:
- *   0  No Error
- *  -1  Error
- *
- * Notes: none
- *****************************************************************************/
-int encodeJpeg(camera_hardware_t *camHal)
-{
-    int                 rc = 0;
-    mm_jpeg_ops_t       mmJpegOps;
-    int                 jpegEncHdl  = 0;
-    mm_jpeg_job         mmJpegJob;
-    src_image_buffer_info   *srcBuf = NULL;
-    QCameraHalMemInfo_t jpegInMemInfo;
-    camera_memory_t*    jpegInMem;
-    uint32_t            jobId;
-
-    ALOGI("%s: E", __func__);
-
-    /************************************************************************/
-    /* - Allocate Jpeg input buffer from ION memory                         */
-    /************************************************************************/
-    jpegInMemInfo.size = camHal->pictWidth * camHal->pictHeight * 2;
-    rc = allocate_ion_memory(&jpegInMemInfo,
-                        ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
-                        (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
-    ERROR_CHECK_EXIT(rc, "allocate_ion_memory");
-
-    jpegInMem = camHal->get_memory(
-                        jpegInMemInfo.fd, jpegInMemInfo.size, 1, camHal->cb_ctxt);
-    if(!jpegInMem){
-        ALOGE("%s: get_mem failed", __func__);
-        return -1;
-    }
-
-    rc = convert_YUYV_to_420_NV12(
-        (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
-        (char *)jpegInMem->data, camHal->pictWidth, camHal->pictHeight);
-    ERROR_CHECK_EXIT(rc, "convert_YUYV_to_420_NV12");
-    /************************************************************************/
-    /* - Populate JPEG encoding parameters from the camHal context          */
-    /************************************************************************/
-    memset(&mmJpegJob, 0, sizeof(mmJpegJob));
-
-    mmJpegJob.job_type              = JPEG_JOB_TYPE_ENCODE;
-    mmJpegJob.encode_job.jpeg_cb    = jpegEncodeCb;
-    mmJpegJob.encode_job.userdata   = (void *)camHal;
-    /* TBD: Rotation to be set from settings sent from app */
-    mmJpegJob.encode_job.encode_parm.rotation           = 0;
-    mmJpegJob.encode_job.encode_parm.exif_numEntries    = 0;
-    mmJpegJob.encode_job.encode_parm.exif_data          = NULL;
-
-    /* TBD: Add thumbnail support */
-    mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.src_img_num = 1;
-    mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.is_video_frame = 0;
-
-    /* Fill main image information */
-    srcBuf = &mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.src_img[0];
-    srcBuf->type                = JPEG_SRC_IMAGE_TYPE_MAIN;
-    srcBuf->img_fmt             = JPEG_SRC_IMAGE_FMT_YUV;
-    /* TBD: convert from YUYV to CRCBH2V2 */
-    srcBuf->color_format        = MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
-    srcBuf->num_bufs            = 1;
-    srcBuf->src_image[0].fd        = jpegInMemInfo.fd;
-    srcBuf->src_image[0].buf_vaddr = (uint8_t*)jpegInMem->data;
-    //srcBuf->src_image[0].offset    = 0;
-    srcBuf->src_dim.width       = camHal->pictWidth;
-    srcBuf->src_dim.height      = camHal->pictHeight;
-    srcBuf->out_dim.width       = camHal->pictWidth;
-    srcBuf->out_dim.height      = camHal->pictHeight;
-    srcBuf->crop.offset_x       = 0;
-    srcBuf->crop.offset_y       = 0;
-    srcBuf->crop.width          = srcBuf->src_dim.width;
-    srcBuf->crop.height         = srcBuf->src_dim.height;
-    srcBuf->quality             = camHal->pictJpegQlty;
-
-    /* TBD:Fill thumbnail image information */
-
-    /* Fill out buf information */
-    mmJpegJob.encode_job.encode_parm.buf_info.sink_img.buf_vaddr =
-                            (uint8_t*)camHal->pictMem.camera_memory[0]->data;
-    mmJpegJob.encode_job.encode_parm.buf_info.sink_img.fd = 0;
-    /* TBD: hard coded for 1.5 bytes per pixel */
-    mmJpegJob.encode_job.encode_parm.buf_info.sink_img.buf_len =
-                            camHal->pictWidth * camHal->pictHeight * 1.5;
-
-    /************************************************************************/
-    /* - Initialize jpeg encoder and call Jpeg encoder start                */
-    /************************************************************************/
-    memset(&mmJpegOps, 0, sizeof(mm_jpeg_ops_t));
-    jpegEncHdl = jpeg_open(&mmJpegOps);
-    if(!jpegEncHdl){
-        ALOGE("%s: Failed to open Jpeg Encoder instance", __func__);
-    }else
-        ALOGD("%s: jpegEncHdl = %d", __func__, jpegEncHdl);
-
-    camHal->jpegEncInProgress = 1;
-    rc = mmJpegOps.start_job(jpegEncHdl, &mmJpegJob, &jobId);
-
-    /************************************************************************/
-    /* - Wait for JPEG encoder to complete encoding                         */
-    /************************************************************************/
-    pthread_mutex_init(&camHal->jpegEncMutex, NULL);
-    pthread_cond_init(&camHal->jpegEncCond, NULL);
-
-    pthread_mutex_lock(&camHal->jpegEncMutex);
-    while(camHal->jpegEncInProgress)
-        pthread_cond_wait(&camHal->jpegEncCond, &camHal->jpegEncMutex);
-    pthread_mutex_unlock(&camHal->jpegEncMutex);
-
-    /************************************************************************/
-    /* - De-allocate Jpeg input buffer from ION memory                      */
-    /************************************************************************/
-    if(jpegInMem)
-        jpegInMem->release(jpegInMem);
-
-    rc = deallocate_ion_memory(&jpegInMemInfo);
-    if(rc)
-        ALOGE("%s: ION memory de-allocation failed", __func__);
-
-    ALOGI("%s: X rc = %d", __func__, rc);
-    return rc;
-}
-
-/******************************************************************************
- * Function: jpegEncodeCb
- * Description: This is a call back function registered with JPEG encoder.
- *              Jpeg encoder calls this function on completion of encoding
- *
- * Input parameters:
- *  camHal                  - camera HAL handle
- *
- * Return values:
- *   0  No Error
- *  -1  Error
- *
- * Notes: none
- *****************************************************************************/
-void jpegEncodeCb   (jpeg_job_status_t status,
-                       uint8_t thumbnailDroppedFlag,
-                       uint32_t client_hdl,
-                       uint32_t jobId,
-                       uint8_t* out_data,
-                       uint32_t data_size,
-                       void *userData)
-{
-    int rc = 0;
-    camera_hardware_t *camHal = NULL;
-
-    ALOGI("%s: E status = %d", __func__, status);
-
-    camHal = (camera_hardware_t*) userData;
-
-    if(JPEG_JOB_STATUS_DONE == status){
-        ALOGD("%s: JPEG encode successful. out_data:%p, size: %d", __func__,
-            out_data, data_size);
-        camHal->jpegEncInProgress = 0;
-    }
-
-    pthread_mutex_lock(&camHal->jpegEncMutex);
-    pthread_cond_signal(&camHal->jpegEncCond);
-    pthread_mutex_unlock(&camHal->jpegEncMutex);
-
-    ALOGI("%s: X", __func__);
-    return;
-}
-
-/******************************************************************************/
-}; // namespace android
diff --git a/camera/QCamera/HAL/wrapper/QualcommCamera.cpp b/camera/QCamera/HAL/wrapper/QualcommCamera.cpp
deleted file mode 100755
index 7a809ea..0000000
--- a/camera/QCamera/HAL/wrapper/QualcommCamera.cpp
+++ /dev/null
@@ -1,529 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- *
- */
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QualcommCamera"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraHAL.h"
-/* include QCamera Hardware Interface Header*/
-#include "QualcommCamera.h"
-#include "QualcommUsbCamera.h"
-//#include "QualcommCameraHardware.h"
-//#include <camera/CameraHardwareInterface.h>
-
-extern "C" {
-#include <sys/time.h>
-}
-
-/* HAL function implementation goes here*/
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-
-static hw_module_methods_t camera_module_methods = {
-    open: camera_device_open,
-};
-
-static hw_module_t camera_common  = {
-  tag: HARDWARE_MODULE_TAG,
-  version_major: 0,
-  version_minor: 01,
-  id: CAMERA_HARDWARE_MODULE_ID,
-  name: "Qcamera",
-  author:"Qcom",
-  methods: &camera_module_methods,
-  dso: NULL,
-  reserved:  {0},
-};
-camera_module_t HAL_MODULE_INFO_SYM = {
-  common: camera_common,
-  get_number_of_cameras: get_number_of_cameras,
-  get_camera_info: get_camera_info,
-};
-
-camera_device_ops_t camera_ops = {
-  set_preview_window:         android::set_preview_window,
-  set_callbacks:              android::set_CallBacks,
-  enable_msg_type:            android::enable_msg_type,
-  disable_msg_type:           android::disable_msg_type,
-  msg_type_enabled:           android::msg_type_enabled,
-
-  start_preview:              android::start_preview,
-  stop_preview:               android::stop_preview,
-  preview_enabled:            android::preview_enabled,
-  store_meta_data_in_buffers: android::store_meta_data_in_buffers,
-
-  start_recording:            android::start_recording,
-  stop_recording:             android::stop_recording,
-  recording_enabled:          android::recording_enabled,
-  release_recording_frame:    android::release_recording_frame,
-
-  auto_focus:                 android::auto_focus,
-  cancel_auto_focus:          android::cancel_auto_focus,
-
-  take_picture:               android::take_picture,
-  cancel_picture:             android::cancel_picture,
-
-  set_parameters:             android::set_parameters,
-  get_parameters:             android::get_parameters,
-  put_parameters:             android::put_parameters,
-  send_command:               android::send_command,
-
-  release:                    android::release,
-  dump:                       android::dump,
-};
-
-namespace android {
-
-typedef struct {
-  camera_device hw_dev;
-  //sp<CameraHardwareInterface> hardware;
-  QCameraHardwareInterface *hardware;
-  int camera_released;
-  int cameraId;
-  //QCameraParameters parameters;
-} camera_hardware_t;
-
-typedef struct {
-  camera_memory_t mem;
-  int32_t msgType;
-  sp<IMemory> dataPtr;
-  void* user;
-  unsigned int index;
-} q_cam_memory_t;
-
-QCameraHardwareInterface *util_get_Hal_obj( struct camera_device * device)
-{
-    QCameraHardwareInterface *hardware = NULL;
-    if(device && device->priv){
-        camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
-        hardware = camHal->hardware;
-    }
-    return hardware;
-}
-
-#if 0 //mzhu
-QCameraParameters* util_get_HAL_parameter( struct camera_device * device)
-{
-    QCameraParameters *param = NULL;
-    if(device && device->priv){
-        camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
-        param = &(camHal->parameters);
-    }
-    return param;
-}
-#endif //mzhu
-
-extern "C" int get_number_of_cameras()
-{
-    /* try to query every time we get the call!*/
-
-    ALOGE("Q%s: E", __func__);
-    int is_mpq = 0;
-    IS_TARGET_MPQ(is_mpq);
-
-    if(is_mpq)
-        return usbcam_get_number_of_cameras();
-
-    /* if(!is_mpq) */
-    return android::HAL_getNumberOfCameras( );
-}
-
-extern "C" int get_camera_info(int camera_id, struct camera_info *info)
-{
-    int rc = -1;
-    ALOGE("Q%s: E", __func__);
-
-    int is_mpq = 0;
-    IS_TARGET_MPQ(is_mpq);
-
-    if(is_mpq)
-        return usbcam_get_camera_info(camera_id, info);
-
-    /* if(!is_mpq) */
-    if(info) {
-        struct CameraInfo camInfo;
-        memset(&camInfo, -1, sizeof (struct CameraInfo));
-        android::HAL_getCameraInfo(camera_id, &camInfo);
-        if (camInfo.facing >= 0) {
-            rc = 0;
-            info->facing = camInfo.facing;
-            info->orientation = camInfo.orientation;
-        }
-    }
-    ALOGV("Q%s: X", __func__);
-    return rc;
-}
-
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" int  camera_device_open(
-  const struct hw_module_t* module, const char* id,
-          struct hw_device_t** hw_device)
-{
-    int rc = -1;
-	int mode = 0; // TODO: need to add 3d/2d mode, etc
-    camera_device *device = NULL;
-    int is_mpq = 0;
-    IS_TARGET_MPQ(is_mpq);
-
-    if(is_mpq && module && id && hw_device)
-        return usbcam_camera_device_open(module, id, hw_device);
-
-    /* if(!is_mpq) */
-    if(module && id && hw_device) {
-        int cameraId = atoi(id);
-
-        if (!strcmp(module->name, camera_common.name)) {
-            camera_hardware_t *camHal =
-                (camera_hardware_t *) malloc(sizeof (camera_hardware_t));
-            if(!camHal) {
-                *hw_device = NULL;
-				    ALOGE("%s:  end in no mem", __func__);
-				    return rc;
-		    }
-            /* we have the camera_hardware obj malloced */
-            memset(camHal, 0, sizeof (camera_hardware_t));
-            camHal->hardware = new QCameraHardwareInterface(cameraId, mode); //HAL_openCameraHardware(cameraId);
-            if (camHal->hardware && camHal->hardware->isCameraReady()) {
-				camHal->cameraId = cameraId;
-		        device = &camHal->hw_dev;
-                device->common.close = close_camera_device;
-                device->ops = &camera_ops;
-                device->priv = (void *)camHal;
-                rc =  0;
-            } else {
-                if (camHal->hardware) {
-                    delete camHal->hardware;
-                    camHal->hardware = NULL;
-                }
-                free(camHal);
-                device = NULL;
-            }
-        }
-    }
-	/* pass actual hw_device ptr to framework. This amkes that we actally be use memberof() macro */
-    *hw_device = (hw_device_t*)&device->common;
-    ALOGE("%s:  end rc %d", __func__, rc);
-    return rc;
-}
-
-extern "C"  int close_camera_device( hw_device_t *hw_dev)
-{
-    ALOGE("Q%s: device =%p E", __func__, hw_dev);
-    int rc =  -1;
-    camera_device_t *device = (camera_device_t *)hw_dev;
-
-    if(device) {
-        camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
-        if(camHal ) {
-            QCameraHardwareInterface *hardware = util_get_Hal_obj( device);
-            if(!camHal->camera_released) {
-                if(hardware != NULL) {
-                    hardware->release( );
-                }
-            }
-            if(hardware != NULL)
-                delete hardware;
-            free(camHal);
-        }
-        rc = 0;
-    }
-    return rc;
-}
-
-
-int set_preview_window(struct camera_device * device,
-        struct preview_stream_ops *window)
-{
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
-    if(hardware != NULL) {
-        rc = hardware->setPreviewWindow(window);
-    }
-    return rc;
-}
-
-void 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)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->setCallbacks(notify_cb,data_cb, data_cb_timestamp, get_memory, user);
-    }
-}
-
-void enable_msg_type(struct camera_device * device, int32_t msg_type)
-{
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->enableMsgType(msg_type);
-    }
-}
-
-void disable_msg_type(struct camera_device * device, int32_t msg_type)
-{
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    ALOGE("Q%s: E", __func__);
-    if(hardware != NULL){
-        hardware->disableMsgType(msg_type);
-    }
-}
-
-int msg_type_enabled(struct camera_device * device, int32_t msg_type)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->msgTypeEnabled(msg_type);
-    }
-    return rc;
-}
-
-int start_preview(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->startPreview( );
-    }
-    ALOGE("Q%s: X", __func__);
-    return rc;
-}
-
-void stop_preview(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->stopPreview( );
-    }
-}
-
-int preview_enabled(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->previewEnabled( );
-    }
-    return rc;
-}
-
-int store_meta_data_in_buffers(struct camera_device * device, int enable)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-      rc = hardware->storeMetaDataInBuffers(enable);
-    }
-    return rc;
-}
-
-int start_recording(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->startRecording( );
-    }
-    return rc;
-}
-
-void stop_recording(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->stopRecording( );
-    }
-}
-
-int recording_enabled(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->recordingEnabled( );
-    }
-    return rc;
-}
-
-void release_recording_frame(struct camera_device * device,
-                const void *opaque)
-{
-    ALOGV("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->releaseRecordingFrame(opaque);
-    }
-}
-
-int auto_focus(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->autoFocus( );
-    }
-    return rc;
-}
-
-int cancel_auto_focus(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->cancelAutoFocus( );
-    }
-    return rc;
-}
-
-int take_picture(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->takePicture( );
-    }
-    return rc;
-}
-
-int cancel_picture(struct camera_device * device)
-
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->cancelPicture( );
-    }
-    return rc;
-}
-
-int set_parameters(struct camera_device * device, const char *parms)
-
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL && parms){
-        //QCameraParameters param;// = util_get_HAL_parameter(device);
-        //String8 str = String8(parms);
-
-        //param.unflatten(str);
-        rc = hardware->setParameters(parms);
-        //rc = 0;
-  }
-  return rc;
-}
-
-char* get_parameters(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-		char *parms = NULL;
-        hardware->getParameters(&parms);
-		return parms;
-    }
-    return NULL;
-}
-
-void put_parameters(struct camera_device * device, char *parm)
-
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-      hardware->putParameters(parm);
-    }
-}
-
-int send_command(struct camera_device * device,
-            int32_t cmd, int32_t arg1, int32_t arg2)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->sendCommand( cmd, arg1, arg2);
-    }
-    return rc;
-}
-
-void release(struct camera_device * device)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
-        hardware->release( );
-        camHal->camera_released = true;
-    }
-}
-
-int dump(struct camera_device * device, int fd)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->dump( fd );
-      //rc = 0;
-    }
-    return rc;
-}
-
-}; // namespace android
diff --git a/camera/QCamera/HAL/wrapper/QualcommCamera.h b/camera/QCamera/HAL/wrapper/QualcommCamera.h
deleted file mode 100755
index 8142689..0000000
--- a/camera/QCamera/HAL/wrapper/QualcommCamera.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 ANDROID_HARDWARE_QUALCOMM_CAMERA_H
-#define ANDROID_HARDWARE_QUALCOMM_CAMERA_H
-
-
-#include "QCameraHWI.h"
-
-extern "C" {
-/*#include <hardware/camera.h>*/
-
-  int get_number_of_cameras();
-  int get_camera_info(int camera_id, struct camera_info *info);
-
-  int camera_device_open(const struct hw_module_t* module, const char* id,
-          struct hw_device_t** device);
-
-  hw_device_t * open_camera_device(int cameraId);
-
-  int close_camera_device( hw_device_t *);
-
-namespace android {
-  int set_preview_window(struct camera_device *,
-          struct preview_stream_ops *window);
-  void set_CallBacks(struct camera_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);
-
-  void enable_msg_type(struct camera_device *, int32_t msg_type);
-
-  void disable_msg_type(struct camera_device *, int32_t msg_type);
-  int msg_type_enabled(struct camera_device *, int32_t msg_type);
-
-  int start_preview(struct camera_device *);
-
-  void stop_preview(struct camera_device *);
-
-  int preview_enabled(struct camera_device *);
-  int store_meta_data_in_buffers(struct camera_device *, int enable);
-
-  int start_recording(struct camera_device *);
-
-  void stop_recording(struct camera_device *);
-
-  int recording_enabled(struct camera_device *);
-
-  void release_recording_frame(struct camera_device *,
-                  const void *opaque);
-
-  int auto_focus(struct camera_device *);
-
-  int cancel_auto_focus(struct camera_device *);
-
-  int take_picture(struct camera_device *);
-
-  int cancel_picture(struct camera_device *);
-
-  int set_parameters(struct camera_device *, const char *parms);
-
-  char* get_parameters(struct camera_device *);
-
-  void put_parameters(struct camera_device *, char *);
-
-  int send_command(struct camera_device *,
-              int32_t cmd, int32_t arg1, int32_t arg2);
-
-  void release(struct camera_device *);
-
-  int dump(struct camera_device *, int fd);
-
-
-
-}; // namespace android
-
-} //extern "C"
-
-#endif
-
diff --git a/camera/QCamera/HAL2/Android.mk b/camera/QCamera/HAL2/Android.mk
deleted file mode 100644
index 5097dae..0000000
--- a/camera/QCamera/HAL2/Android.mk
+++ /dev/null
@@ -1,3 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(LOCAL_PATH)/core/Android.mk
-#include $(LOCAL_PATH)/test/Android.mk
diff --git a/camera/QCamera/HAL2/core/Android.mk b/camera/QCamera/HAL2/core/Android.mk
deleted file mode 100644
index 6491691..0000000
--- a/camera/QCamera/HAL2/core/Android.mk
+++ /dev/null
@@ -1,81 +0,0 @@
-
-#ifeq ($(call is-board-platform,msm8960),true)
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-DLOPEN_LIBMMCAMERA:=0
-
-LOCAL_CFLAGS:= -DDLOPEN_LIBMMCAMERA=$(DLOPEN_LIBMMCAMERA)
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
-        LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_CFLAGS += -DCAMERA_ION_HEAP_ID=ION_CP_MM_HEAP_ID # 8660=SMI, Rest=EBI
-LOCAL_CFLAGS += -DCAMERA_ZSL_ION_HEAP_ID=ION_CP_MM_HEAP_ID
-
-LOCAL_CFLAGS+= -DHW_ENCODE
-LOCAL_CFLAGS+= -DUSE_NEON_CONVERSION
-
-ifeq ($(TARGET_BOARD_PLATFORM),msm8960)
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_MM_HEAP
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP
-        LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
-else ifeq ($(TARGET_BOARD_PLATFORM),msm8660)
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP # Don't Care
-        LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_CAMERA_HEAP_ID # EBI
-        LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_CAMERA_HEAP_ID
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
-else
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_ADSP_HEAP
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_ADSP_HEAP # Don't Care
-        LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=GRALLOC_USAGE_PRIVATE_UNCACHED #uncached
-endif
-
-LOCAL_HAL_FILES := \
-        src/QCameraHAL.cpp \
-        src/QCameraHWI.cpp \
-        src/QCameraStream.cpp \
-        src/QCameraHWI_Metatags.cpp \
-       src/QCameraStream_Preview.cpp
-
-LOCAL_HAL_WRAPPER_FILES := ../wrapper/QualcommCamera.cpp
-
-LOCAL_C_INCLUDES := \
-        $(LOCAL_PATH)/../wrapper \
-        $(LOCAL_PATH)/inc \
-        $(LOCAL_PATH)/../../stack/mm-camera-interface/inc\
-        $(LOCAL_PATH)/../../stack/mm-jpeg-interface/inc\
-        $(TARGET_OUT_INTERMEDIATES)/include/mm-camera-interface_badger \
-
-LOCAL_C_INCLUDES += hardware/qcom/display/libgralloc \
-        hardware/qcom/display/libgenlock \
-        hardware/qcom/media/libstagefrighthw \
-	system/media/camera/include
-
-# if debug service layer and up , use stub camera!
-LOCAL_C_INCLUDES += \
-        frameworks/base/services/camera/libcameraservice
-
-LOCAL_SRC_FILES := \
-        $(LOCAL_HAL_WRAPPER_FILES) \
-        $(LOCAL_HAL_FILES)
-
-LOCAL_SHARED_LIBRARIES := libutils libui libcamera_client liblog libcutils
-LOCAL_SHARED_LIBRARIES += libmmcamera_interface
-LOCAL_SHARED_LIBRARIES+= libgenlock libbinder libcamera_metadata
-
-LOCAL_CFLAGS += -include bionic/libc/include/sys/socket.h
-
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-LOCAL_MODULE:= camera.$(TARGET_BOARD_PLATFORM)
-LOCAL_MODULE_TAGS := optional
-include $(BUILD_SHARED_LIBRARY)
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
-
diff --git a/camera/QCamera/HAL2/core/inc/QCameraHAL.h b/camera/QCamera/HAL2/core/inc/QCameraHAL.h
deleted file mode 100644
index 7f7533d..0000000
--- a/camera/QCamera/HAL2/core/inc/QCameraHAL.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-** Copyright (c) 2011 The Linux Foundation. All rights reserved.
-**
-** 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_QCAMERA_HAL_H
-#define ANDROID_HARDWARE_QCAMERA_HAL_H
-
-
-#include "QCameraHWI.h"
-
-extern "C" {
-#include <mm_camera_interface.h>
-}
-namespace android {
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" void *
-       QCameraHAL_openCameraHardware(int  cameraId, int mode);
-extern "C" int HAL_getNumberOfCameras();
-extern "C" int HAL_getCameraInfo(int cameraId, struct camera_info* cameraInfo);
-extern "C" status_t getStaticInfo(camera_metadata_t **info,
-        mm_camera_vtbl_t *camera_vtbl, bool sizeRequest);
-extern "C" status_t constructDefaultRequest(int request_template,
-        camera_metadata_t **info, bool sizeRequest);
-
-}; // namespace android
-
-#endif
-
diff --git a/camera/QCamera/HAL2/core/inc/QCameraHWI.h b/camera/QCamera/HAL2/core/inc/QCameraHWI.h
deleted file mode 100644
index 220e8e5..0000000
--- a/camera/QCamera/HAL2/core/inc/QCameraHWI.h
+++ /dev/null
@@ -1,883 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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_QCAMERA_HARDWARE_INTERFACE_H
-#define ANDROID_HARDWARE_QCAMERA_HARDWARE_INTERFACE_H
-
-
-#include <utils/threads.h>
-#include <hardware/camera2.h>
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <camera/Camera.h>
-//#include <QCameraParameters.h>
-#include <system/window.h>
-#include <system/camera.h>
-#include <gralloc_priv.h>
-//#include <QComOMXMetadata.h>
-
-extern "C" {
-#include <linux/android_pmem.h>
-#include <linux/msm_ion.h>
-#include <mm_camera_interface.h>
-#include "mm_jpeg_interface.h"
-} //extern C
-
-#include "QCameraStream.h"
-#include "QCamera_Intf.h"
-
-//Error codes
-#define  NOT_FOUND -1
-#define MAX_ZOOM_RATIOS 62
-
-#ifdef Q12
-#undef Q12
-#endif
-
-#define Q12 4096
-#define QCAMERA_PARM_ENABLE   1
-#define QCAMERA_PARM_DISABLE  0
-#define PREVIEW_TBL_MAX_SIZE  14
-#define VIDEO_TBL_MAX_SIZE    14
-#define THUMB_TBL_MAX_SIZE    16
-#define HFR_TBL_MAX_SIZE      2
-//Default Video Width
-#define DEFAULT_VIDEO_WIDTH 1920
-#define DEFAULT_VIDEO_HEIGHT 1088
-
-#define DEFAULT_STREAM_WIDTH 640
-#define DEFAULT_STREAM_HEIGHT 480
-#define DEFAULT_LIVESHOT_WIDTH 2592
-#define DEFAULT_LIVESHOT_HEIGHT 1944
-
-struct str_map {
-    const char *const desc;
-    int val;
-};
-
-struct preview_format_info_t {
-   int Hal_format;
-   cam_format_t mm_cam_format;
-   cam_pad_format_t padding;
-   int num_planar;
-};
-
-
-typedef enum {
-  CAMERA_STATE_UNINITED,
-  CAMERA_STATE_READY,
-  CAMERA_STATE_PREVIEW_START_CMD_SENT,
-  CAMERA_STATE_PREVIEW_STOP_CMD_SENT,
-  CAMERA_STATE_PREVIEW,
-  CAMERA_STATE_RECORD_START_CMD_SENT,  /*5*/
-  CAMERA_STATE_RECORD_STOP_CMD_SENT,
-  CAMERA_STATE_RECORD,
-  CAMERA_STATE_SNAP_START_CMD_SENT,
-  CAMERA_STATE_SNAP_STOP_CMD_SENT,
-  CAMERA_STATE_SNAP_CMD_ACKED,  /*10 - snapshot comd acked, snapshot not done yet*/
-  CAMERA_STATE_ZSL_START_CMD_SENT,
-  CAMERA_STATE_ZSL,
-  CAMERA_STATE_AF_START_CMD_SENT,
-  CAMERA_STATE_AF_STOP_CMD_SENT,
-  CAMERA_STATE_ERROR, /*15*/
-
-  /*Add any new state above*/
-  CAMERA_STATE_MAX
-} HAL_camera_state_type_t;
-
-enum {
-  BUFFER_NOT_REGGED,
-  BUFFER_NOT_OWNED,
-  BUFFER_OWNED,
-  BUFFER_UNLOCKED,
-  BUFFER_LOCKED,
-};
-
-typedef enum {
-  HAL_DUMP_FRM_PREVIEW = 1,
-  HAL_DUMP_FRM_VIDEO = 1<<1,
-  HAL_DUMP_FRM_MAIN = 1<<2,
-  HAL_DUMP_FRM_THUMBNAIL = 1<<3,
-
-  /*8 bits mask*/
-  HAL_DUMP_FRM_MAX = 1 << 8
-} HAL_cam_dump_frm_type_t;
-
-
-typedef enum {
-  HAL_CAM_MODE_ZSL = 1,
-
-  /*add new entry before and update the max entry*/
-  HAL_CAM_MODE_MAX = HAL_CAM_MODE_ZSL << 1,
-} qQamera_mode_t;
-
-
-typedef enum {
-    MM_CAMERA_OK,
-    MM_CAMERA_E_GENERAL,
-    MM_CAMERA_E_NO_MEMORY,
-    MM_CAMERA_E_NOT_SUPPORTED,
-    MM_CAMERA_E_INVALID_INPUT,
-    MM_CAMERA_E_INVALID_OPERATION, /* 5 */
-    MM_CAMERA_E_ENCODE,
-    MM_CAMERA_E_BUFFER_REG,
-    MM_CAMERA_E_PMEM_ALLOC,
-    MM_CAMERA_E_CAPTURE_FAILED,
-    MM_CAMERA_E_CAPTURE_TIMEOUT, /* 10 */
-}mm_camera_status_type_t;
-
-
-
-#define HAL_DUMP_FRM_MASK_ALL ( HAL_DUMP_FRM_PREVIEW + HAL_DUMP_FRM_VIDEO + \
-    HAL_DUMP_FRM_MAIN + HAL_DUMP_FRM_THUMBNAIL)
-#define QCAMERA_HAL_PREVIEW_STOPPED    0
-#define QCAMERA_HAL_PREVIEW_START      1
-#define QCAMERA_HAL_PREVIEW_STARTED    2
-#define QCAMERA_HAL_RECORDING_STARTED  3
-#define QCAMERA_HAL_TAKE_PICTURE       4
-
-//EXIF globals
-static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };          // "ASCII\0\0\0"
-static const char ExifUndefinedPrefix[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };   // "\0\0\0\0\0\0\0\0"
-
-//EXIF detfines
-#define MAX_EXIF_TABLE_ENTRIES           14
-#define GPS_PROCESSING_METHOD_SIZE       101
-#define FOCAL_LENGTH_DECIMAL_PRECISION   100
-#define EXIF_ASCII_PREFIX_SIZE           8   //(sizeof(ExifAsciiPrefix))
-
-typedef struct{
-    //GPS tags
-    rat_t       latitude[3];
-    rat_t       longitude[3];
-    char        lonRef[2];
-    char        latRef[2];
-    rat_t       altitude;
-    rat_t       gpsTimeStamp[3];
-    char        gpsDateStamp[20];
-    char        gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE+GPS_PROCESSING_METHOD_SIZE];
-    //Other tags
-    char        dateTime[20];
-    rat_t       focalLength;
-    uint16_t    flashMode;
-    uint16_t    isoSpeed;
-
-    bool        mAltitude;
-    bool        mLongitude;
-    bool        mLatitude;
-    bool        mTimeStamp;
-    bool        mGpsProcess;
-
-    int         mAltitude_ref;
-    long        mGPSTimestamp;
-
-} exif_values_t;
-
-namespace android {
-
-class QCameraStream;
-
-class QCameraHardwareInterface : public virtual RefBase {
-public:
-
-    QCameraHardwareInterface(int  cameraId, int mode);
-
-    int set_request_queue_src_ops(
-        const camera2_request_queue_src_ops_t *request_src_ops);
-    int notify_request_queue_not_empty();
-    int set_frame_queue_dst_ops(const camera2_frame_queue_dst_ops_t *frame_dst_ops);
-    int get_in_progress_count();
-    int construct_default_request(int request_template, camera_metadata_t **request);
-    int allocate_stream(uint32_t width,
-        uint32_t height, int format,
-        const camera2_stream_ops_t *stream_ops,
-        uint32_t *stream_id,
-        uint32_t *format_actual,
-        uint32_t *usage,
-        uint32_t *max_buffers);
-    int register_stream_buffers(uint32_t stream_id, int num_buffers,
-        buffer_handle_t *buffers);
-    int release_stream(uint32_t stream_id);
-    int allocate_reprocess_stream(
-        uint32_t width,
-        uint32_t height,
-        uint32_t format,
-        const camera2_stream_in_ops_t *reprocess_stream_ops,
-        uint32_t *stream_id,
-        uint32_t *consumer_usage,
-        uint32_t *max_buffers);
-    int release_reprocess_stream(
-        uint32_t stream_id);
-    int get_metadata_vendor_tag_ops(vendor_tag_query_ops_t **ops);
-    int set_notify_callback(camera2_notify_callback notify_cb,
-            void *user);
-
-
-    void runCommandThread(void *);
-
-    int getBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data,
-                        mm_camera_frame_len_offset *frame_offset_info,
-                        uint8_t num_bufs,
-                        uint8_t *initial_reg_flag,
-                        mm_camera_buf_def_t  *bufs);
-    int putBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data, uint8_t num_bufs,
-                        mm_camera_buf_def_t *bufs);
-
-#if 0
-    static QCameraHardwareInterface *createInstance(int, int);
-    /** Set the ANativeWindow to which preview frames are sent */
-    int setPreviewWindow(preview_stream_ops_t* window);
-
-    /** 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);
-
-    /**
-     * The following three functions all take a msg_type, which is a bitmask of
-     * the messages defined in include/ui/Camera.h
-     */
-
-    /**
-     * Enable a message, or set of messages.
-     */
-    void enableMsgType(int32_t msg_type);
-
-    /**
-     * Disable a message, or a set of messages.
-     *
-     * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
-     * HAL should not rely on its client to call releaseRecordingFrame() to
-     * release video recording frames sent out by the cameral HAL before and
-     * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
-     * clients must not modify/access any video recording frame after calling
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
-     */
-    void disableMsgType(int32_t msg_type);
-
-    /**
-     * 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 msg_type);
-
-    /**
-     * Start preview mode.
-     */
-    int startPreview();
-    int startPreview2();
-
-    /**
-     * Stop a previously started preview.
-     */
-    void stopPreview();
-
-    /**
-     * Returns true if preview is enabled.
-     */
-    int previewEnabled();
-
-
-    /**
-     * Request the camera HAL to store meta data or real YUV data in the video
-     * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
-     * it is not called, the default camera HAL behavior is to store real YUV
-     * data in the video buffers.
-     *
-     * This method should be called before startRecording() in order to be
-     * effective.
-     *
-     * If meta data is stored in the video buffers, it is up to the receiver of
-     * the video buffers to interpret the contents and to find the actual frame
-     * data with the help of the meta data in the buffer. How this is done is
-     * outside of the scope of this method.
-     *
-     * Some camera HALs may not support storing meta data in the video buffers,
-     * but all camera HALs should support storing real YUV data in the video
-     * buffers. If the camera HAL does not support storing the meta data in the
-     * video buffers when it is requested to do do, INVALID_OPERATION must be
-     * returned. It is very useful for the camera HAL to pass meta data rather
-     * than the actual frame data directly to the video encoder, since the
-     * amount of the uncompressed frame data can be very large if video size is
-     * large.
-     *
-     * @param enable if true to instruct the camera HAL to store
-     *        meta data in the video buffers; false to instruct
-     *        the camera HAL to store real YUV data in the video
-     *        buffers.
-     *
-     * @return OK on success.
-     */
-    int storeMetaDataInBuffers(int enable);
-
-    /**
-     * 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 a camera HAL client via
-     * releaseRecordingFrame() before the client calls
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
-     * responsibility to manage the life-cycle of the video recording frames,
-     * and the client must not modify/access any video recording frames.
-     */
-    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.
-     *
-     * It is camera HAL client's responsibility to release video recording
-     * frames sent out by the camera HAL before the camera HAL receives a call
-     * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
-     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
-     * responsibility to manage the life-cycle of the video recording frames.
-     */
-    void releaseRecordingFrame(const void *opaque);
-
-    /**
-     * 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. This returns BAD_VALUE if any parameter is
-     * invalid or not supported.
-     */
-    int setParameters(const char *parms);
-
-    //status_t setParameters(const QCameraParameters& params);
-    /** Retrieve the camera parameters.  The buffer returned by the camera HAL
-        must be returned back to it with put_parameters, if put_parameters
-        is not NULL.
-     */
-    int getParameters(char **parms);
-
-    /** The camera HAL uses its own memory to pass us the parameters when we
-        call get_parameters.  Use this function to return the memory back to
-        the camera HAL, if put_parameters is not NULL.  If put_parameters
-        is NULL, then you have to use free() to release the memory.
-    */
-    void putParameters(char *);
-
-    /**
-     * Send command to camera driver.
-     */
-    int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
-
-
-    /**
-     * Dump state of the camera hardware
-     */
-    int dump(int fd);
-
-    //virtual sp<IMemoryHeap> getPreviewHeap() const;
-    //virtual sp<IMemoryHeap> getRawHeap() const;
-
-
-    status_t    takeLiveSnapshot();
-    status_t    takeFullSizeLiveshot();
-    bool        canTakeFullSizeLiveshot();
-
-    //virtual status_t          getBufferInfo( sp<IMemory>& Frame,
-    //size_t *alignedSize);
-    void         getPictureSize(int *picture_width, int *picture_height) const;
-    void         getPreviewSize(int *preview_width, int *preview_height) const;
-    cam_format_t getPreviewFormat() const;
-
-    cam_pad_format_t getPreviewPadding() const;
-
-    //bool     useOverlay(void);
-    //virtual status_t setOverlay(const sp<Overlay> &overlay);
-    void processEvent(mm_camera_event_t *);
-    int  getJpegQuality() const;
-    int  getNumOfSnapshots(void) const;
-    int  getNumOfSnapshots(const QCameraParameters& params);
-    int  getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
-                                     int *picture_width,
-                                     int *picture_height);
-    bool isRawSnapshot();
-    bool mShutterSoundPlayed;
-    void dumpFrameToFile(mm_camera_buf_def_t*, HAL_cam_dump_frm_type_t);
-
-    status_t setZSLBurstLookBack(const QCameraParameters& params);
-    status_t setZSLBurstInterval(const QCameraParameters& params);
-    int getZSLBurstInterval(void);
-    int getZSLQueueDepth(void) const;
-    int getZSLBackLookCount(void) const;
-#endif
-    /**
-     * Release the hardware resources owned by this object.  Note that this is
-     * *not* done in the destructor.
-     */
-    void release();
-
-    bool isCameraReady();
-    ~QCameraHardwareInterface();
-
-    mm_camear_mem_vtbl_t mMemHooks;
-    mm_camera_vtbl_t *mCameraHandle;
-    uint32_t mChannelId;
-
-#if 0
-    int initHeapMem( QCameraHalHeap_t *heap,
-                            int num_of_buf,
-                            int buf_len,
-                            int y_off,
-                            int cbcr_off,
-                            int pmem_type,
-                            mm_camera_buf_def_t *buf_def,
-                            uint8_t num_planes,
-                            uint32_t *planes);
-    int releaseHeapMem( QCameraHalHeap_t *heap);
-    status_t sendMappingBuf(int ext_mode, int idx, int fd, uint32_t size,
-      int cameraid, mm_camera_socket_msg_type msg_type);
-    status_t sendUnMappingBuf(int ext_mode, int idx, int cameraid,
-      mm_camera_socket_msg_type msg_type);
-
-    int allocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt,
-      int ion_type);
-    int deallocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt);
-
-    int allocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt,
-      int ion_type);
-    int deallocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt);
-
-    int cache_ops(int ion_fd, struct ion_flush_data *cache_inv_data, int type);
-
-    void dumpFrameToFile(const void * data, uint32_t size, char* name,
-      char* ext, int index);
-    preview_format_info_t getPreviewFormatInfo( );
-    bool isNoDisplayMode();
-
-    int getBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data,
-                        mm_camera_frame_len_offset *frame_offset_info,
-                        uint8_t num_bufs,
-                        uint8_t *initial_reg_flag,
-                        mm_camera_buf_def_t  *bufs);
-    int putBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data, uint8_t num_bufs,
-                        mm_camera_buf_def_t *bufs);
-
-
-private:
-    int16_t  zoomRatios[MAX_ZOOM_RATIOS];
-    struct camera_size_type default_preview_sizes[PREVIEW_TBL_MAX_SIZE];
-    struct camera_size_type default_video_sizes[VIDEO_TBL_MAX_SIZE];
-    struct camera_size_type default_hfr_sizes[HFR_TBL_MAX_SIZE];
-    struct camera_size_type default_thumbnail_sizes[THUMB_TBL_MAX_SIZE];
-    unsigned int preview_sizes_count;
-    unsigned int video_sizes_count;
-    unsigned int thumbnail_sizes_count;
-    unsigned int hfr_sizes_count;
-
-
-    bool mUseOverlay;
-
-    void loadTables();
-    void initDefaultParameters();
-    bool getMaxPictureDimension(mm_camera_dimension_t *dim);
-
-    status_t updateFocusDistances();
-
-    bool native_set_parms(mm_camera_parm_type_t type, uint16_t length, void *value);
-    bool native_set_parms( mm_camera_parm_type_t type, uint16_t length, void *value, int *result);
-
-    void hasAutoFocusSupport();
-    void debugShowPreviewFPS() const;
-    //void prepareSnapshotAndWait();
-
-    bool isPreviewRunning();
-    bool isRecordingRunning();
-    bool isSnapshotRunning();
-
-    void processChannelEvent(mm_camera_ch_event_t *, app_notify_cb_t *);
-    void processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
-    void processRecordChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
-    void processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
-    void processCtrlEvent(mm_camera_ctrl_event_t *, app_notify_cb_t *);
-    void processStatsEvent(mm_camera_stats_event_t *, app_notify_cb_t *);
-    void processInfoEvent(mm_camera_info_event_t *event, app_notify_cb_t *);
-    void processprepareSnapshotEvent(cam_ctrl_status_t *);
-    void roiEvent(fd_roi_t roi, app_notify_cb_t *);
-    void zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *);
-    void autofocusevent(cam_ctrl_status_t *status, app_notify_cb_t *);
-    void handleZoomEventForPreview(app_notify_cb_t *);
-    void handleZoomEventForSnapshot(void);
-    status_t autoFocusEvent(cam_ctrl_status_t *, app_notify_cb_t *);
-
-    void filterPictureSizes();
-    bool supportsSceneDetection();
-    bool supportsSelectableZoneAf();
-    bool supportsFaceDetection();
-    bool supportsRedEyeReduction();
-    bool preview_parm_config (cam_ctrl_dimension_t* dim,QCameraParameters& parm);
-
-    void stopPreviewInternal();
-    void stopRecordingInternal();
-    //void stopPreviewZSL();
-    status_t cancelPictureInternal();
-    //status_t startPreviewZSL();
-    void pausePreviewForSnapshot();
-    void pausePreviewForZSL();
-    status_t resumePreviewAfterSnapshot();
-
-    status_t runFaceDetection();
-
-    status_t           setParameters(const QCameraParameters& params);
-    QCameraParameters&  getParameters() ;
-
-    status_t setCameraMode(const QCameraParameters& params);
-    status_t setPictureSizeTable(void);
-    status_t setPreviewSizeTable(void);
-    status_t setVideoSizeTable(void);
-    status_t setPreviewSize(const QCameraParameters& params);
-    status_t setJpegThumbnailSize(const QCameraParameters& params);
-    status_t setPreviewFpsRange(const QCameraParameters& params);
-    status_t setPreviewFrameRate(const QCameraParameters& params);
-    status_t setPreviewFrameRateMode(const QCameraParameters& params);
-    status_t setVideoSize(const QCameraParameters& params);
-    status_t setPictureSize(const QCameraParameters& params);
-    status_t setJpegQuality(const QCameraParameters& params);
-    status_t setNumOfSnapshot(const QCameraParameters& params);
-    status_t setJpegRotation(int isZSL);
-    int getJpegRotation(void);
-    int getISOSpeedValue();
-    status_t setAntibanding(const QCameraParameters& params);
-    status_t setEffect(const QCameraParameters& params);
-    status_t setExposureCompensation(const QCameraParameters &params);
-    status_t setAutoExposure(const QCameraParameters& params);
-    status_t setWhiteBalance(const QCameraParameters& params);
-    status_t setFlash(const QCameraParameters& params);
-    status_t setGpsLocation(const QCameraParameters& params);
-    status_t setRotation(const QCameraParameters& params);
-    status_t setZoom(const QCameraParameters& params);
-    status_t setFocusMode(const QCameraParameters& params);
-    status_t setBrightness(const QCameraParameters& params);
-    status_t setSkinToneEnhancement(const QCameraParameters& params);
-    status_t setOrientation(const QCameraParameters& params);
-    status_t setLensshadeValue(const QCameraParameters& params);
-    status_t setMCEValue(const QCameraParameters& params);
-    status_t setISOValue(const QCameraParameters& params);
-    status_t setPictureFormat(const QCameraParameters& params);
-    status_t setSharpness(const QCameraParameters& params);
-    status_t setContrast(const QCameraParameters& params);
-    status_t setSaturation(const QCameraParameters& params);
-    status_t setWaveletDenoise(const QCameraParameters& params);
-    status_t setSceneMode(const QCameraParameters& params);
-    status_t setContinuousAf(const QCameraParameters& params);
-    status_t setFaceDetection(const char *str);
-    status_t setSceneDetect(const QCameraParameters& params);
-    status_t setStrTextures(const QCameraParameters& params);
-    status_t setPreviewFormat(const QCameraParameters& params);
-    status_t setSelectableZoneAf(const QCameraParameters& params);
-    status_t setOverlayFormats(const QCameraParameters& params);
-    status_t setHighFrameRate(const QCameraParameters& params);
-    status_t setRedeyeReduction(const QCameraParameters& params);
-    status_t setAEBracket(const QCameraParameters& params);
-    status_t setFaceDetect(const QCameraParameters& params);
-    status_t setDenoise(const QCameraParameters& params);
-    status_t setAecAwbLock(const QCameraParameters & params);
-    status_t setHistogram(int histogram_en);
-    status_t setRecordingHint(const QCameraParameters& params);
-    status_t setRecordingHintValue(const int32_t value);
-    status_t setFocusAreas(const QCameraParameters& params);
-    status_t setMeteringAreas(const QCameraParameters& params);
-    status_t setFullLiveshot(void);
-    status_t setDISMode(void);
-    status_t setCaptureBurstExp(void);
-    status_t setPowerMode(const QCameraParameters& params);
-    void takePicturePrepareHardware( );
-    status_t setNoDisplayMode(const QCameraParameters& params);
-
-    isp3a_af_mode_t getAutoFocusMode(const QCameraParameters& params);
-    bool isValidDimension(int w, int h);
-
-    String8 create_values_str(const str_map *values, int len);
-
-    void setMyMode(int mode);
-    bool isZSLMode();
-    bool isWDenoiseEnabled();
-    void wdenoiseEvent(cam_ctrl_status_t status, void *cookie);
-    bool isLowPowerCamcorder();
-    void freePictureTable(void);
-    void freeVideoSizeTable(void);
-
-    int32_t createPreview();
-    int32_t createRecord();
-    int32_t createSnapshot();
-
-    int getHDRMode();
-    //EXIF
-    void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
-                        uint32_t count, uint8_t copy, void *data);
-    void setExifTags();
-    void initExifData();
-    void deinitExifData();
-    void setExifTagsGPS();
-    exif_tags_info_t* getExifData(){ return mExifData; }
-    int getExifTableNumEntries() { return mExifTableNumEntries; }
-    void parseGPSCoordinate(const char *latlonString, rat_t* coord);
-    //added to support hdr
-    bool getHdrInfoAndSetExp(int max_num_frm, int *num_frame, int *exp);
-    void hdrEvent(cam_ctrl_status_t status, void *cookie);
-
-    camera_mode_t myMode;
-
-
-
-
-    QCameraParameters    mParameters;
-    //sp<Overlay>         mOverlay;
-    int32_t             mMsgEnabled;
-
-    camera_notify_callback         mNotifyCb;
-    camera_data_callback           mDataCb;
-    camera_data_timestamp_callback mDataCbTimestamp;
-    camera_request_memory          mGetMemory;
-    void                           *mCallbackCookie;
-
-    //sp<MemoryHeapBase>  mPreviewHeap;  //@Guru : Need to remove
-    sp<AshmemPool>      mMetaDataHeap;
-
-    mutable Mutex       mLock;
-    //mutable Mutex       eventLock;
-    Mutex         mCallbackLock;
-    Mutex         mRecordingMemoryLock;
-    Mutex         mAutofocusLock;
-    Mutex         mMetaDataWaitLock;
-    Mutex         mRecordFrameLock;
-    Mutex         mRecordLock;
-    Condition     mRecordWait;
-    pthread_mutex_t     mAsyncCmdMutex;
-    pthread_cond_t      mAsyncCmdWait;
-
-    cam_ctrl_dimension_t mDimension;
-    int  mPreviewWidth, mPreviewHeight;
-    int  videoWidth, videoHeight;
-    int  thumbnailWidth, thumbnailHeight;
-    int  maxSnapshotWidth, maxSnapshotHeight;
-    int  mPreviewFormat;
-    int  mFps;
-    int  mDebugFps;
-    int  mBrightness;
-    int  mContrast;
-    int  mBestShotMode;
-    int  mEffects;
-    int  mSkinToneEnhancement;
-    int  mDenoiseValue;
-    int  mHJR;
-    int  mRotation;
-    int  mJpegQuality;
-    int  mThumbnailQuality;
-    int  mTargetSmoothZoom;
-    int  mSmoothZoomStep;
-    int  mMaxZoom;
-    int  mCurrentZoom;
-    int  mSupportedPictureSizesCount;
-    int  mFaceDetectOn;
-    int  mDumpFrmCnt;
-    int  mDumpSkipCnt;
-    int  mFocusMode;
-
-    unsigned int mPictureSizeCount;
-    unsigned int mPreviewSizeCount;
-    int mPowerMode;
-    unsigned int mVideoSizeCount;
-
-    bool mAutoFocusRunning;
-    bool mMultiTouch;
-    bool mHasAutoFocusSupport;
-    bool mInitialized;
-    bool mDisEnabled;
-    bool strTexturesOn;
-    bool mIs3DModeOn;
-    bool mSmoothZoomRunning;
-    bool mPreparingSnapshot;
-    bool mParamStringInitialized;
-    bool mZoomSupported;
-    bool mSendMetaData;
-    bool mFullLiveshotEnabled;
-    bool mRecordingHint;
-    bool mStartRecording;
-    bool mReleasedRecordingFrame;
-    int mHdrMode;
-    int mSnapshotFormat;
-    int mZslInterval;
-    bool mRestartPreview;
-
-/*for histogram*/
-    int            mStatsOn;
-    int            mCurrentHisto;
-    bool           mSendData;
-    sp<AshmemPool> mStatHeap;
-    camera_memory_t *mStatsMapped[3];
-    QCameraStatHeap_t mHistServer;
-    int32_t        mStatSize;
-
-    bool mZslLookBackMode;
-    int mZslLookBackValue;
-	int mHFRLevel;
-    bool mZslEmptyQueueFlag;
-    String8 mEffectValues;
-    String8 mIsoValues;
-    String8 mSceneModeValues;
-    String8 mSceneDetectValues;
-    String8 mFocusModeValues;
-    String8 mSelectableZoneAfValues;
-    String8 mAutoExposureValues;
-    String8 mWhitebalanceValues;
-    String8 mAntibandingValues;
-    String8 mFrameRateModeValues;
-    String8 mTouchAfAecValues;
-    String8 mPreviewSizeValues;
-    String8 mPictureSizeValues;
-    String8 mVideoSizeValues;
-    String8 mFlashValues;
-    String8 mLensShadeValues;
-    String8 mMceValues;
-    String8 mHistogramValues;
-    String8 mSkinToneEnhancementValues;
-    String8 mPictureFormatValues;
-    String8 mDenoiseValues;
-    String8 mZoomRatioValues;
-    String8 mPreviewFrameRateValues;
-    String8 mPreviewFormatValues;
-    String8 mFaceDetectionValues;
-    String8 mHfrValues;
-    String8 mHfrSizeValues;
-    String8 mRedeyeReductionValues;
-    String8 denoise_value;
-    String8 mFpsRangesSupportedValues;
-    String8 mZslValues;
-    String8 mFocusDistance;
-
-
-    android :: FPSRange* mSupportedFpsRanges;
-    int mSupportedFpsRangesCount;
-
-    camera_size_type* mPictureSizes;
-    camera_size_type* mPreviewSizes;
-    camera_size_type* mVideoSizes;
-    const camera_size_type * mPictureSizesPtr;
-    HAL_camera_state_type_t mCameraState;
-
-     /* Temporary - can be removed after Honeycomb*/
-#ifdef USE_ION
-    sp<IonPool>  mPostPreviewHeap;
-#else
-    sp<PmemPool> mPostPreviewHeap;
-#endif
-    // mm_cameara_stream_buf_t mPrevForPostviewBuf;
-     int mStoreMetaDataInFrame;
-     preview_stream_ops_t *mPreviewWindow;
-     Mutex                mStateLock;
-     int                  mPreviewState;
-     /*preview memory without display case: memory is allocated
-      directly by camera */
-     QCameraHalHeap_t     mNoDispPreviewMemory;
-
-     QCameraHalHeap_t     mSnapshotMemory;
-     QCameraHalHeap_t     mThumbnailMemory;
-     QCameraHalHeap_t     mRecordingMemory;
-     QCameraHalHeap_t     mJpegMemory;
-     QCameraHalHeap_t     mRawMemory;
-     camera_frame_metadata_t mMetadata;
-     camera_face_t           mFace[MAX_ROI];
-     preview_format_info_t  mPreviewFormatInfo;
-    // friend void liveshot_callback(mm_camera_ch_data_buf_t *frame,void *user_data);
-     //EXIF
-     exif_tags_info_t       mExifData[MAX_EXIF_TABLE_ENTRIES];  //Exif tags for JPEG encoder
-     exif_values_t          mExifValues;                        //Exif values in usable format
-     int                    mExifTableNumEntries;            //NUmber of entries in mExifData
-     int                 mNoDisplayMode;
-#endif
-private:
-    int           mCameraId;
-    camera_metadata_t *mStaticInfo;
-
-    friend class QCameraStream;
-    friend class QCameraStream_record;
-    friend class QCameraStream_preview;
-    friend class QCameraStream_SnapshotMain;
-    friend class QCameraStream_SnapshotThumbnail;
-    friend class QCameraStream_Rdi;
-
-    friend void stream_cb_routine(mm_camera_super_buf_t *bufs, void *userdata);
-    friend void superbuf_cb_routine(mm_camera_super_buf_t *bufs, void *userdata);
-    friend void *command_thread(void *);
-
-    int tryRestartStreams(camera_metadata_entry_t& streams);
-
-    QCameraStream       *mStreamDisplay;
-    QCameraStream       *mStreamRecord;
-    QCameraStream       *mStreamSnapMain;
-    QCameraStream       *mStreamSnapThumb;
-    QCameraStream       *mStreamLiveSnap;
-    QCameraStream       *mStreamRdi;
-
-    const camera2_request_queue_src_ops *mRequestQueueSrc;
-    uint8_t mPendingRequests;
-    const camera2_frame_queue_dst_ops *mFrameQueueDst;
-    camera2_notify_callback mNotifyCb;
-    void *mNotifyUserPtr;
-    pthread_t mCommandThread;
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL2/core/inc/QCameraParameters.h b/camera/QCamera/HAL2/core/inc/QCameraParameters.h
deleted file mode 100644
index 6920413..0000000
--- a/camera/QCamera/HAL2/core/inc/QCameraParameters.h
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
-**
-** Copyright 2008, 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 ANDROID_HARDWARE_QCAMERA_PARAMETERS_H
-#define ANDROID_HARDWARE_QCAMERA_PARAMETERS_H
-
-//#include <utils/KeyedVector.h>
-//#include <utils/String8.h>
-#include <camera/CameraParameters.h>
-
-namespace android {
-
-struct FPSRange{
-    int minFPS;
-    int maxFPS;
-    FPSRange(){
-        minFPS=0;
-        maxFPS=0;
-    };
-    FPSRange(int min,int max){
-        minFPS=min;
-        maxFPS=max;
-    };
-};
-class QCameraParameters: public CameraParameters
-{
-public:
-#if 1
-    QCameraParameters() : CameraParameters() {};
-    QCameraParameters(const String8 &params): CameraParameters(params) {};
-    #else
-    QCameraParameters() : CameraParameters() {};
-    QCameraParameters(const String8 &params) { unflatten(params); }
-#endif
-    ~QCameraParameters();
-
-    // Supported PREVIEW/RECORDING SIZES IN HIGH FRAME RATE recording, sizes in pixels.
-    // Example value: "800x480,432x320". Read only.
-    static const char KEY_SUPPORTED_HFR_SIZES[];
-    // The mode of preview frame rate.
-    // Example value: "frame-rate-auto, frame-rate-fixed".
-    static const char KEY_PREVIEW_FRAME_RATE_MODE[];
-    static const char KEY_SUPPORTED_PREVIEW_FRAME_RATE_MODES[];
-    static const char KEY_PREVIEW_FRAME_RATE_AUTO_MODE[];
-    static const char KEY_PREVIEW_FRAME_RATE_FIXED_MODE[];
-
-    static const char KEY_SKIN_TONE_ENHANCEMENT[] ;
-    static const char KEY_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] ;
-
-    //Touch Af/AEC settings.
-    static const char KEY_TOUCH_AF_AEC[];
-    static const char KEY_SUPPORTED_TOUCH_AF_AEC[];
-    //Touch Index for AEC.
-    static const char KEY_TOUCH_INDEX_AEC[];
-    //Touch Index for AF.
-    static const char KEY_TOUCH_INDEX_AF[];
-    // Current auto scene detection mode.
-    // Example value: "off" or SCENE_DETECT_XXX constants. Read/write.
-    static const char KEY_SCENE_DETECT[];
-    // Supported auto scene detection settings.
-    // Example value: "off,backlight,snow/cloudy". Read only.
-    static const char KEY_SUPPORTED_SCENE_DETECT[];
-	   // Returns true if video snapshot is supported. That is, applications
-    static const char KEY_FULL_VIDEO_SNAP_SUPPORTED[];
-    static const char KEY_POWER_MODE_SUPPORTED[];
-
-    static const char KEY_ISO_MODE[];
-    static const char KEY_SUPPORTED_ISO_MODES[];
-    static const char KEY_LENSSHADE[] ;
-    static const char KEY_SUPPORTED_LENSSHADE_MODES[] ;
-
-    static const char KEY_AUTO_EXPOSURE[];
-    static const char KEY_SUPPORTED_AUTO_EXPOSURE[];
-
-    static const char KEY_GPS_LATITUDE_REF[];
-    static const char KEY_GPS_LONGITUDE_REF[];
-    static const char KEY_GPS_ALTITUDE_REF[];
-    static const char KEY_GPS_STATUS[];
-    static const char KEY_EXIF_DATETIME[];
-    static const char KEY_MEMORY_COLOR_ENHANCEMENT[];
-    static const char KEY_SUPPORTED_MEM_COLOR_ENHANCE_MODES[];
-
-
-    static const char KEY_POWER_MODE[];
-
-    static const char KEY_ZSL[];
-    static const char KEY_SUPPORTED_ZSL_MODES[];
-
-    static const char KEY_CAMERA_MODE[];
-
-    static const char KEY_VIDEO_HIGH_FRAME_RATE[];
-    static const char KEY_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[];
-    static const char KEY_HIGH_DYNAMIC_RANGE_IMAGING[];
-    static const char KEY_SUPPORTED_HDR_IMAGING_MODES[];
-    static const char KEY_AE_BRACKET_HDR[];
-
-
-    // DENOISE
-    static const char KEY_DENOISE[];
-    static const char KEY_SUPPORTED_DENOISE[];
-
-    //Selectable zone AF.
-    static const char KEY_SELECTABLE_ZONE_AF[];
-    static const char KEY_SUPPORTED_SELECTABLE_ZONE_AF[];
-
-    //Face Detection
-    static const char KEY_FACE_DETECTION[];
-    static const char KEY_SUPPORTED_FACE_DETECTION[];
-
-    //Redeye Reduction
-    static const char KEY_REDEYE_REDUCTION[];
-    static const char KEY_SUPPORTED_REDEYE_REDUCTION[];
-    static const char EFFECT_EMBOSS[];
-    static const char EFFECT_SKETCH[];
-    static const char EFFECT_NEON[];
-
-    // Values for Touch AF/AEC
-    static const char TOUCH_AF_AEC_OFF[] ;
-    static const char TOUCH_AF_AEC_ON[] ;
-    static const char SCENE_MODE_ASD[];
-    static const char SCENE_MODE_BACKLIGHT[];
-    static const char SCENE_MODE_FLOWERS[];
-    static const char SCENE_MODE_AR[];
-	static const char SCENE_DETECT_OFF[];
-    static const char SCENE_DETECT_ON[];
-    static const char PIXEL_FORMAT_YUV420SP_ADRENO[]; // ADRENO
-	static const char PIXEL_FORMAT_RAW[];
-    static const char PIXEL_FORMAT_YV12[]; // NV12
-    static const char PIXEL_FORMAT_NV12[]; //NV12
-    // Normal focus mode. Applications should call
-    // CameraHardwareInterface.autoFocus to start the focus in this mode.
-    static const char FOCUS_MODE_NORMAL[];
-    static const char ISO_AUTO[];
-    static const char ISO_HJR[] ;
-    static const char ISO_100[];
-    static const char ISO_200[] ;
-    static const char ISO_400[];
-    static const char ISO_800[];
-    static const char ISO_1600[];
-    // Values for Lens Shading
-    static const char LENSSHADE_ENABLE[] ;
-    static const char LENSSHADE_DISABLE[] ;
-
-    // Values for auto exposure settings.
-    static const char AUTO_EXPOSURE_FRAME_AVG[];
-    static const char AUTO_EXPOSURE_CENTER_WEIGHTED[];
-    static const char AUTO_EXPOSURE_SPOT_METERING[];
-
-    static const char KEY_SHARPNESS[];
-    static const char KEY_MAX_SHARPNESS[];
-    static const char KEY_CONTRAST[];
-    static const char KEY_MAX_CONTRAST[];
-    static const char KEY_SATURATION[];
-    static const char KEY_MAX_SATURATION[];
-
-    static const char KEY_HISTOGRAM[] ;
-    static const char KEY_SUPPORTED_HISTOGRAM_MODES[] ;
-    // Values for HISTOGRAM
-    static const char HISTOGRAM_ENABLE[] ;
-    static const char HISTOGRAM_DISABLE[] ;
-
-    // Values for SKIN TONE ENHANCEMENT
-    static const char SKIN_TONE_ENHANCEMENT_ENABLE[] ;
-    static const char SKIN_TONE_ENHANCEMENT_DISABLE[] ;
-
-    // Values for Denoise
-    static const char DENOISE_OFF[] ;
-    static const char DENOISE_ON[] ;
-
-    // Values for auto exposure settings.
-    static const char SELECTABLE_ZONE_AF_AUTO[];
-    static const char SELECTABLE_ZONE_AF_SPOT_METERING[];
-    static const char SELECTABLE_ZONE_AF_CENTER_WEIGHTED[];
-    static const char SELECTABLE_ZONE_AF_FRAME_AVERAGE[];
-
-    // Values for Face Detection settings.
-    static const char FACE_DETECTION_OFF[];
-    static const char FACE_DETECTION_ON[];
-
-    // Values for MCE settings.
-    static const char MCE_ENABLE[];
-    static const char MCE_DISABLE[];
-
-    // Values for ZSL settings.
-    static const char ZSL_OFF[];
-    static const char ZSL_ON[];
-
-    // Values for HDR Bracketing settings.
-    static const char AE_BRACKET_HDR_OFF[];
-    static const char AE_BRACKET_HDR[];
-    static const char AE_BRACKET[];
-
-    // Values for Power mode settings.
-    static const char LOW_POWER[];
-    static const char NORMAL_POWER[];
-
-    // Values for HFR settings.
-    static const char VIDEO_HFR_OFF[];
-    static const char VIDEO_HFR_2X[];
-    static const char VIDEO_HFR_3X[];
-    static const char VIDEO_HFR_4X[];
-
-    // Values for Redeye Reduction settings.
-    static const char REDEYE_REDUCTION_ENABLE[];
-    static const char REDEYE_REDUCTION_DISABLE[];
-    // Values for HDR settings.
-    static const char HDR_ENABLE[];
-    static const char HDR_DISABLE[];
-
-   // Values for Redeye Reduction settings.
-   // static const char REDEYE_REDUCTION_ENABLE[];
-   // static const char REDEYE_REDUCTION_DISABLE[];
-   // Values for HDR settings.
-   //    static const char HDR_ENABLE[];
-   //    static const char HDR_DISABLE[];
-
-
-   static const char KEY_SINGLE_ISP_OUTPUT_ENABLED[];
-
-    enum {
-        CAMERA_ORIENTATION_UNKNOWN = 0,
-        CAMERA_ORIENTATION_PORTRAIT = 1,
-        CAMERA_ORIENTATION_LANDSCAPE = 2,
-    };
-    int getOrientation() const;
-    void setOrientation(int orientation);
-    void getSupportedHfrSizes(Vector<Size> &sizes) const;
-    void setPreviewFpsRange(int minFPS,int maxFPS);
-	void setPreviewFrameRateMode(const char *mode);
-    const char *getPreviewFrameRateMode() const;
-    void setTouchIndexAec(int x, int y);
-    void getTouchIndexAec(int *x, int *y) const;
-    void setTouchIndexAf(int x, int y);
-    void getTouchIndexAf(int *x, int *y) const;
-    void getMeteringAreaCenter(int * x, int *y) const;
-
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL2/core/inc/QCameraStream.h b/camera/QCamera/HAL2/core/inc/QCameraStream.h
deleted file mode 100644
index a2fb8d7..0000000
--- a/camera/QCamera/HAL2/core/inc/QCameraStream.h
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
-** Copyright 2008, Google Inc.
-** Copyright (c) 2009-2012, The Linux Foundation. All rights reserved.
-**
-** 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_QCAMERA_STREAM_H
-#define ANDROID_HARDWARE_QCAMERA_STREAM_H
-
-
-#include <utils/threads.h>
-
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-
-
-#include "QCameraHWI.h"
-extern "C" {
-#include <mm_camera_interface.h>
-#include <mm_jpeg_interface.h>
-
-#define OPAQUE_BUFFER_COUNT 5
-#define STREAM_TABLE_SIZE 8
-
-#define MM_CAMERA_CH_PREVIEW_MASK    (0x01 << MM_CAMERA_CH_PREVIEW)
-#define MM_CAMERA_CH_VIDEO_MASK      (0x01 << MM_CAMERA_CH_VIDEO)
-#define MM_CAMERA_CH_SNAPSHOT_MASK   (0x01 << MM_CAMERA_CH_SNAPSHOT)
-
-} /* extern C*/
-
-namespace android {
-
-class QCameraHardwareInterface;
-
-class StreamQueue {
-private:
-    Mutex mQueueLock;
-    Condition mQueueWait;
-    bool mInitialized;
-
-    //Vector<struct msm_frame *> mContainer;
-    Vector<void *> mContainer;
-public:
-    StreamQueue();
-    virtual ~StreamQueue();
-    bool enqueue(void *element);
-    void flush();
-    void* dequeue();
-    void init();
-    void deinit();
-    bool isInitialized();
-bool isEmpty();
-};
-
-typedef struct {
-     int                     buffer_count;
-     buffer_handle_t         buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
-     struct private_handle_t *private_buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
-     int                     stride[MM_CAMERA_MAX_NUM_FRAMES];
-     uint32_t                addr_offset[MM_CAMERA_MAX_NUM_FRAMES];
-     uint8_t                 local_flag[MM_CAMERA_MAX_NUM_FRAMES];
-     int                     main_ion_fd[MM_CAMERA_MAX_NUM_FRAMES];
-     struct ion_fd_data      ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES];
-} QCameraStreamMemory_t;
-
-class QCameraStream {
-
-public:
-    bool mInit;
-    bool mActive;
-
-    uint32_t mCameraHandle;
-    uint32_t mChannelId;
-    uint32_t mMmStreamId;
-    uint32_t mWidth;
-    uint32_t mHeight;
-    cam_format_t mFormat;
-    uint8_t mNumBuffers;
-    mm_camera_frame_len_offset mFrameOffsetInfo;
-    mm_camera_vtbl_t *p_mm_ops;
-    mm_camera_img_mode mExtImgMode;
-
-    uint8_t mPendingCount;
-
-    pthread_mutex_t mFrameDeliveredMutex;
-    pthread_cond_t mFrameDeliveredCond;
-
-    virtual status_t    init();
-    virtual status_t    start();
-    virtual void        stop();
-    virtual void        release();
-
-    status_t setFormat();
-    status_t setMode(int enable);
-
-    int getStreamId() {return mStreamId;}
-    int getMaxBuffers() {return mMaxBuffers;}
-
-    static QCameraStream *getStreamAtId(int id);
-    static QCameraStream *getStreamAtMmId(uint32_t mm_id);
-    static void streamOffAll();
-
-    virtual void setHALCameraControl(QCameraHardwareInterface* ctrl);
-
-    virtual int prepareStream() {return NO_ERROR;}
-    void onNewRequest();
-    void dataCallback(mm_camera_super_buf_t *bufs);
-    int32_t streamOn();
-    int32_t streamOff(bool aSync);
-    virtual status_t initStream(mm_camera_img_mode imgmode, cam_format_t format);
-    virtual status_t deinitStream();
-    virtual status_t initBuffers(){return NO_ERROR;}
-    virtual sp<IMemoryHeap> getRawHeap() const {return NULL;}
-    virtual void *getLastQueuedFrame(void){return NULL;}
-    virtual status_t processPreviewFrame(mm_camera_super_buf_t *frame){return NO_ERROR;}
-
-    /* Set the ANativeWindow */
-    virtual int setPreviewWindow(const camera2_stream_ops_t* window) {return NO_ERROR;}
-    virtual void notifyWDenoiseEvent(cam_ctrl_status_t status, void * cookie) {;}
-    virtual void resetSnapshotCounters(void ){};
-    virtual void initHdrInfoForSnapshot(bool HDR_on, int number_frames, int *exp){};
-    virtual void notifyHdrEvent(cam_ctrl_status_t status, void * cookie){};
-    virtual status_t receiveRawPicture(mm_camera_super_buf_t* recvd_frame){return NO_ERROR;};
-
-    QCameraStream(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        mm_camera_vtbl_t *mm_ops,
-                        camera_mode_t mode);
-    virtual ~QCameraStream();
-public:
-    QCameraHardwareInterface*  mHalCamCtrl;
-    mm_camera_rect_t mCrop;
-
-    camera_mode_t myMode;
-
-    mutable Mutex mLock;
-protected:
-
-    uint32_t mStreamId;
-    int mMaxBuffers;
-    int allocateStreamId();
-    int deallocateStreamId(int id);
-
-private:
-    static QCameraStream *mStreamTable[STREAM_TABLE_SIZE];
-
-    StreamQueue mBusyQueue;
-    StreamQueue mFreeQueue;
-    
-    QCameraStream();
-public:
-//     friend void liveshot_callback(mm_camera_ch_data_buf_t *frame,void *user_data);
-};
-
-class QCameraStream_preview : public QCameraStream {
-public:
-    status_t    init();
-    status_t    start() ;
-    void        stop()  ;
-    void        release() ;
-
-    static QCameraStream* createInstance(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        int requestedFormat,
-                        mm_camera_vtbl_t *mm_ops,
-                        camera_mode_t mode);
-    static void deleteInstance(QCameraStream *p);
-
-    virtual ~QCameraStream_preview();
-    void *getLastQueuedFrame(void);
-    status_t initBuffers();
-    void deinitBuffers();
-
-    virtual int prepareStream();
-    virtual status_t processPreviewFrame(mm_camera_super_buf_t *frame);
-
-    int setPreviewWindow(const camera2_stream_ops_t* window);
-    int registerStreamBuffers(int num_buffers, buffer_handle_t *buffers);
-    friend class QCameraHardwareInterface;
-
-private:
-    QCameraStream_preview(); 
-    QCameraStream_preview(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        int requestedFormat,
-                        mm_camera_vtbl_t *mm_ops,
-                        camera_mode_t mode);
-
-    void                     dumpFrameToFile(mm_camera_buf_def_t* newFrame);
-
-private:
-    bool                     mFirstFrameRcvd;
-    QCameraStreamMemory_t mPreviewMemory;
-    Mutex         mPreviewMemoryLock;
-
-    int8_t                   my_id;
-    mm_camera_op_mode_type_t op_mode;
-    mm_camera_buf_def_t      *mLastQueuedFrame;
-    mm_camera_buf_def_t      *mDisplayBuf;
-    Mutex                   mDisplayLock;
-    const camera2_stream_ops_t   *mPreviewWindow;
-    mm_camera_super_buf_t mNotifyBuffer[16];
-    int8_t                  mNumFDRcvd;
-    int                     mVFEOutputs;
-    int                     mHFRFrameCnt;
-    int                     mHFRFrameSkip;
-};
-
-class QCameraStream_SnapshotMain : public QCameraStream {
-public:
-    status_t    init();
-    status_t    start();
-    void        stop();
-    void        release();
-    status_t    initMainBuffers();
-    void        releaseMainBuffers();
-    void        initHdrInfoForSnapshot(bool HDR_on, int number_frames, int *exp);
-    void        notifyHdrEvent(cam_ctrl_status_t status, void * cookie);
-    static void            deleteInstance(QCameraStream *p);
-    status_t receiveRawPicture(mm_camera_super_buf_t* recvd_frame);
-    mm_camera_buf_def_t mSnapshotStreamBuf[MM_CAMERA_MAX_NUM_FRAMES];
-    static QCameraStream* createInstance(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        uint32_t Format,
-                        uint8_t NumBuffers,
-                        mm_camera_vtbl_t *mm_ops,
-                        mm_camera_img_mode imgmode,
-                        camera_mode_t mode);
-    QCameraStream_SnapshotMain(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        uint32_t Format,
-                        uint8_t NumBuffers,
-                        mm_camera_vtbl_t *mm_ops,
-                        mm_camera_img_mode imgmode,
-                        camera_mode_t mode);
-    ~QCameraStream_SnapshotMain();
-
-private:
-    status_t doHdrProcessing();
-    status_t encodeData(mm_camera_super_buf_t* recvd_frame);
-    /*Member variables*/
-    mm_jpeg_ops_t mJpegHandle;
-    uint32_t mJpegClientHandle;
-    int mSnapshotState;
-    StreamQueue mSnapshotQueue;
-};
-
-class QCameraStream_SnapshotThumbnail : public QCameraStream {
-public:
-    status_t    init();
-    status_t    start();
-    void        stop();
-    void        release();
-    status_t    initThumbnailBuffers();
-    static QCameraStream* createInstance(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        uint32_t Format,
-                        uint8_t NumBuffers,
-                        mm_camera_vtbl_t *mm_ops,
-                        mm_camera_img_mode imgmode,
-                        camera_mode_t mode);
-    QCameraStream_SnapshotThumbnail(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        uint32_t Format,
-                        uint8_t NumBuffers,
-                        mm_camera_vtbl_t *mm_ops,
-                        mm_camera_img_mode imgmode,
-                        camera_mode_t mode);
-    ~QCameraStream_SnapshotThumbnail();
-    static void            deleteInstance(QCameraStream *p);
-    mm_camera_buf_def_t mPostviewStreamBuf[MM_CAMERA_MAX_NUM_FRAMES];
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL2/core/inc/QCamera_Intf.h b/camera/QCamera/HAL2/core/inc/QCamera_Intf.h
deleted file mode 100644
index bf6435e..0000000
--- a/camera/QCamera/HAL2/core/inc/QCamera_Intf.h
+++ /dev/null
@@ -1,2698 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 __QCAMERA_INTF_H__
-#define __QCAMERA_INTF_H__
-
-#include <stdint.h>
-#include <pthread.h>
-#include <inttypes.h>
-#include <media/msm_camera.h>
-
-#define PAD_TO_WORD(a)               (((a)+3)&~3)
-#define PAD_TO_2K(a)                 (((a)+2047)&~2047)
-#define PAD_TO_4K(a)                 (((a)+4095)&~4095)
-#define PAD_TO_8K(a)                 (((a)+8191)&~8191)
-
-#define CEILING32(X) (((X) + 0x0001F) & 0xFFFFFFE0)
-#define CEILING16(X) (((X) + 0x000F) & 0xFFF0)
-#define CEILING4(X)  (((X) + 0x0003) & 0xFFFC)
-#define CEILING2(X)  (((X) + 0x0001) & 0xFFFE)
-
-#define MAX_ROI 2
-#define MAX_NUM_PARM 5
-#define MAX_NUM_OPS 2
-#define VIDEO_MAX_PLANES 8
-#define MAX_SNAPSHOT_BUFFERS 5
-#define MAX_EXP_BRACKETING_LENGTH 32
-#define ANDROID_FB0 "/dev/graphics/fb0"
-#define LE_FB0 "/dev/fb0"
-
-// Events common to encoder and decoder
-#define JPEG_EVENT_DONE      0
-#define JPEG_EVENT_WARNING   1
-#define JPEG_EVENT_ERROR     2
-#define JPEG_EVENT_ABORTED   3
-// Events specific to encoder
-#define JPEG_EVENT_THUMBNAIL_DROPPED 4
-
-/* Exif Tag ID */
-typedef uint32_t exif_tag_id_t;
-
-/* Exif Info (opaque definition) */
-struct exif_info_t;
-typedef struct exif_info_t * exif_info_obj_t;
-
-typedef enum {
-  BACK_CAMERA,
-  FRONT_CAMERA,
-}cam_position_t;
-
-typedef enum {
-  CAM_CTRL_FAILED,        /* Failure in doing operation */
-  CAM_CTRL_SUCCESS,       /* Operation Succeded */
-  CAM_CTRL_INVALID_PARM,  /* Inavlid parameter provided */
-  CAM_CTRL_NOT_SUPPORTED, /* Parameter/operation not supported */
-  CAM_CTRL_ACCEPTED,      /* Parameter accepted */
-  CAM_CTRL_MAX,
-} cam_ctrl_status_t;
-
-typedef enum {
-  CAMERA_YUV_420_NV12,
-  CAMERA_YUV_420_NV21,
-  CAMERA_YUV_420_NV21_ADRENO,
-  CAMERA_BAYER_SBGGR10,
-  CAMERA_RDI,
-  CAMERA_YUV_420_YV12,
-  CAMERA_YUV_422_NV16,
-  CAMERA_YUV_422_NV61,
-  CAMERA_YUV_422_YUYV,
-} cam_format_t;
-
-typedef enum {
-  CAMERA_PAD_NONE,
-  CAMERA_PAD_TO_WORD,   /*2 bytes*/
-  CAMERA_PAD_TO_LONG_WORD, /*4 bytes*/
-  CAMERA_PAD_TO_8, /*8 bytes*/
-  CAMERA_PAD_TO_16, /*16 bytes*/
-
-  CAMERA_PAD_TO_1K, /*1k bytes*/
-  CAMERA_PAD_TO_2K, /*2k bytes*/
-  CAMERA_PAD_TO_4K,
-  CAMERA_PAD_TO_8K
-} cam_pad_format_t;
-
-typedef struct {
-  int ext_mode;   /* preview, main, thumbnail, video, raw, etc */
-  int frame_idx;  /* frame index */
-  int fd;         /* origin fd */
-  uint32_t size;
-} mm_camera_frame_map_type;
-
-typedef struct {
-  int ext_mode;   /* preview, main, thumbnail, video, raw, etc */
-  int frame_idx;  /* frame index */
-} mm_camera_frame_unmap_type;
-
-typedef enum {
-  CAM_SOCK_MSG_TYPE_FD_MAPPING,
-  CAM_SOCK_MSG_TYPE_FD_UNMAPPING,
-  CAM_SOCK_MSG_TYPE_WDN_START,
-  CAM_SOCK_MSG_TYPE_HIST_MAPPING,
-  CAM_SOCK_MSG_TYPE_HIST_UNMAPPING,
-  CAM_SOCK_MSG_TYPE_MAX
-}mm_camera_socket_msg_type;
-
-#define MM_MAX_WDN_NUM 2
-typedef struct {
-  unsigned long cookie;
-  int num_frames;
-  int ext_mode[MM_MAX_WDN_NUM];
-  int frame_idx[MM_MAX_WDN_NUM];
-} mm_camera_wdn_start_type;
-
-typedef struct {
-  mm_camera_socket_msg_type msg_type;
-  union {
-    mm_camera_frame_map_type frame_fd_map;
-    mm_camera_frame_unmap_type frame_fd_unmap;
-    mm_camera_wdn_start_type wdn_start;
-  } payload;
-} cam_sock_packet_t;
-
-
-typedef enum {
-  CAM_VIDEO_FRAME,
-  CAM_SNAPSHOT_FRAME,
-  CAM_PREVIEW_FRAME,
-}cam_frame_type_t;
-
-
-typedef enum {
-  CAMERA_MODE_2D = (1<<0),
-  CAMERA_MODE_3D = (1<<1),
-  CAMERA_NONZSL_MODE = (1<<2),
-  CAMERA_ZSL_MODE = (1<<3),
-  CAMERA_MODE_MAX = CAMERA_ZSL_MODE,
-} camera_mode_t;
-
-
-typedef struct {
-  int  modes_supported;
-  int8_t camera_id;
-  cam_position_t position;
-  uint32_t sensor_mount_angle;
-}camera_info_t;
-
-typedef struct {
-  camera_mode_t mode;
-  int8_t camera_id;
-  camera_mode_t cammode;
-}config_params_t;
-
-typedef struct {
-  uint32_t len;
-  uint32_t y_offset;
-  uint32_t cbcr_offset;
-} cam_sp_len_offset_t;
-
-typedef struct{
-  uint32_t len;
-  uint32_t offset;
-} cam_mp_len_offset_t;
-
-typedef struct {
-  int num_planes;
-  union {
-    cam_sp_len_offset_t sp;
-    cam_mp_len_offset_t mp[8];
-  };
-  uint32_t frame_len;
-} cam_frame_len_offset_t;
-
-typedef struct {
-  uint32_t parm[MAX_NUM_PARM];
-  uint32_t ops[MAX_NUM_OPS];
-  uint8_t yuv_output;
-  uint8_t jpeg_capture;
-  uint32_t max_pict_width;
-  uint32_t max_pict_height;
-  uint32_t max_preview_width;
-  uint32_t max_preview_height;
-  uint32_t max_video_width;
-  uint32_t max_video_height;
-  uint32_t effect;
-  camera_mode_t modes;
-  uint8_t preview_format;
-  uint32_t preview_sizes_cnt;
-  uint32_t thumb_sizes_cnt;
-  uint32_t video_sizes_cnt;
-  uint32_t hfr_sizes_cnt;
-  uint8_t vfe_output_enable;
-  uint8_t hfr_frame_skip;
-  uint32_t default_preview_width;
-  uint32_t default_preview_height;
-  uint32_t bestshot_reconfigure;
-  uint32_t pxlcode;
-}cam_prop_t;
-
-typedef struct {
-  uint16_t video_width;         /* Video width seen by VFE could be different than orig. Ex. DIS */
-  uint16_t video_height;        /* Video height seen by VFE */
-  uint16_t picture_width;       /* Picture width seen by VFE */
-  uint16_t picture_height;      /* Picture height seen by VFE */
-  uint16_t display_width;       /* width of display */
-  uint16_t display_height;      /* height of display */
-  uint16_t orig_video_width;    /* original video width received */
-  uint16_t orig_video_height;   /* original video height received */
-  uint16_t orig_picture_dx;     /* original picture width received */
-  uint16_t orig_picture_dy;     /* original picture height received */
-  uint16_t ui_thumbnail_height; /* Just like orig_picture_dx */
-  uint16_t ui_thumbnail_width;  /* Just like orig_picture_dy */
-  uint16_t thumbnail_height;
-  uint16_t thumbnail_width;
-  uint16_t orig_picture_width;
-  uint16_t orig_picture_height;
-  uint16_t orig_thumb_width;
-  uint16_t orig_thumb_height;
-  uint16_t raw_picture_height;
-  uint16_t raw_picture_width;
-  uint16_t rdi0_height;
-  uint16_t rdi0_width;
-  uint16_t rdi1_height;
-  uint16_t rdi1_width;
-  uint32_t hjr_xtra_buff_for_bayer_filtering;
-  cam_format_t    prev_format;
-  cam_format_t    enc_format;
-  cam_format_t    thumb_format;
-  cam_format_t    main_img_format;
-  cam_format_t    rdi0_format;
-  cam_format_t    rdi1_format;
-  cam_format_t    raw_img_format;
-  cam_pad_format_t prev_padding_format;
-  cam_pad_format_t enc_padding_format;
-  cam_pad_format_t thumb_padding_format;
-  cam_pad_format_t main_padding_format;
-  uint16_t display_luma_width;
-  uint16_t display_luma_height;
-  uint16_t display_chroma_width;
-  uint16_t display_chroma_height;
-  uint16_t video_luma_width;
-  uint16_t video_luma_height;
-  uint16_t video_chroma_width;
-  uint16_t video_chroma_height;
-  uint16_t thumbnail_luma_width;
-  uint16_t thumbnail_luma_height;
-  uint16_t thumbnail_chroma_width;
-  uint16_t thumbnail_chroma_height;
-  uint16_t main_img_luma_width;
-  uint16_t main_img_luma_height;
-  uint16_t main_img_chroma_width;
-  uint16_t main_img_chroma_height;
-  int rotation;
-  cam_frame_len_offset_t display_frame_offset;
-  cam_frame_len_offset_t video_frame_offset;
-  cam_frame_len_offset_t picture_frame_offset;
-  cam_frame_len_offset_t thumb_frame_offset;
-  uint32_t channel_interface_mask;
-} cam_ctrl_dimension_t;
-
-typedef struct {
-  uint8_t cid;
-  uint8_t dt;
-  uint32_t inst_handle;
-} cam_cid_entry_t;
-
-#define CAM_MAX_CID_NUM    8
-typedef struct {
-  /*should we hard code max CIDs? if not we need to have two CMD*/
-  uint8_t num_cids;
-  cam_cid_entry_t cid_entries[CAM_MAX_CID_NUM];
-} cam_cid_info_t;
-
-typedef struct {
-  /* we still use prev, video, main,
-   * thumb to interprete image types */
-  uint32_t image_mode;                 /* input */
-  cam_format_t format;                 /* input */
-  cam_pad_format_t padding_format;     /* input */
-  int rotation;                        /* input */
-  uint16_t width;                      /* input/output */
-  uint16_t height;                     /* input/output */
-  cam_frame_len_offset_t frame_offset; /* output */
-} cam_frame_resolution_t;
-
-/* Add enumenrations at the bottom but before MM_CAMERA_PARM_MAX */
-typedef enum {
-    MM_CAMERA_PARM_PICT_SIZE,
-    MM_CAMERA_PARM_ZOOM_RATIO,
-    MM_CAMERA_PARM_HISTOGRAM,
-    MM_CAMERA_PARM_DIMENSION,
-    MM_CAMERA_PARM_FPS,
-    MM_CAMERA_PARM_FPS_MODE, /*5*/
-    MM_CAMERA_PARM_EFFECT,
-    MM_CAMERA_PARM_EXPOSURE_COMPENSATION,
-    MM_CAMERA_PARM_EXPOSURE,
-    MM_CAMERA_PARM_SHARPNESS,
-    MM_CAMERA_PARM_CONTRAST, /*10*/
-    MM_CAMERA_PARM_SATURATION,
-    MM_CAMERA_PARM_BRIGHTNESS,
-    MM_CAMERA_PARM_WHITE_BALANCE,
-    MM_CAMERA_PARM_LED_MODE,
-    MM_CAMERA_PARM_ANTIBANDING, /*15*/
-    MM_CAMERA_PARM_ROLLOFF,
-    MM_CAMERA_PARM_CONTINUOUS_AF,
-    MM_CAMERA_PARM_FOCUS_RECT,
-    MM_CAMERA_PARM_AEC_ROI,
-    MM_CAMERA_PARM_AF_ROI, /*20*/
-    MM_CAMERA_PARM_HJR,
-    MM_CAMERA_PARM_ISO,
-    MM_CAMERA_PARM_BL_DETECTION,
-    MM_CAMERA_PARM_SNOW_DETECTION,
-    MM_CAMERA_PARM_BESTSHOT_MODE, /*25*/
-    MM_CAMERA_PARM_ZOOM,
-    MM_CAMERA_PARM_VIDEO_DIS,
-    MM_CAMERA_PARM_VIDEO_ROT,
-    MM_CAMERA_PARM_SCE_FACTOR,
-    MM_CAMERA_PARM_FD, /*30*/
-    MM_CAMERA_PARM_MODE,
-    /* 2nd 32 bits */
-    MM_CAMERA_PARM_3D_FRAME_FORMAT,
-    MM_CAMERA_PARM_CAMERA_ID,
-    MM_CAMERA_PARM_CAMERA_INFO,
-    MM_CAMERA_PARM_PREVIEW_SIZE, /*35*/
-    MM_CAMERA_PARM_QUERY_FALSH4SNAP,
-    MM_CAMERA_PARM_FOCUS_DISTANCES,
-    MM_CAMERA_PARM_BUFFER_INFO,
-    MM_CAMERA_PARM_JPEG_ROTATION,
-    MM_CAMERA_PARM_JPEG_MAINIMG_QUALITY, /* 40 */
-    MM_CAMERA_PARM_JPEG_THUMB_QUALITY,
-    MM_CAMERA_PARM_ZSL_ENABLE,
-    MM_CAMERA_PARM_FOCAL_LENGTH,
-    MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE,
-    MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE, /* 45 */
-    MM_CAMERA_PARM_MCE,
-    MM_CAMERA_PARM_RESET_LENS_TO_INFINITY,
-    MM_CAMERA_PARM_SNAPSHOTDATA,
-    MM_CAMERA_PARM_HFR,
-    MM_CAMERA_PARM_REDEYE_REDUCTION, /* 50 */
-    MM_CAMERA_PARM_WAVELET_DENOISE,
-    MM_CAMERA_PARM_3D_DISPLAY_DISTANCE,
-    MM_CAMERA_PARM_3D_VIEW_ANGLE,
-    MM_CAMERA_PARM_PREVIEW_FORMAT,
-    MM_CAMERA_PARM_RDI_FORMAT,
-    MM_CAMERA_PARM_HFR_SIZE, /* 55 */
-    MM_CAMERA_PARM_3D_EFFECT,
-    MM_CAMERA_PARM_3D_MANUAL_CONV_RANGE,
-    MM_CAMERA_PARM_3D_MANUAL_CONV_VALUE,
-    MM_CAMERA_PARM_ENABLE_3D_MANUAL_CONVERGENCE,
-    /* These are new parameters defined here */
-    MM_CAMERA_PARM_CH_IMAGE_FMT, /* 60 */       // mm_camera_ch_image_fmt_parm_t
-    MM_CAMERA_PARM_OP_MODE,             // camera state, sub state also
-    MM_CAMERA_PARM_SHARPNESS_CAP,       //
-    MM_CAMERA_PARM_SNAPSHOT_BURST_NUM,  // num shots per snapshot action
-    MM_CAMERA_PARM_LIVESHOT_MAIN,       // enable/disable full size live shot
-    MM_CAMERA_PARM_MAXZOOM, /* 65 */
-    MM_CAMERA_PARM_LUMA_ADAPTATION,     // enable/disable
-    MM_CAMERA_PARM_HDR,
-    MM_CAMERA_PARM_CROP,
-    MM_CAMERA_PARM_MAX_PICTURE_SIZE,
-    MM_CAMERA_PARM_MAX_PREVIEW_SIZE, /* 70 */
-    MM_CAMERA_PARM_ASD_ENABLE,
-    MM_CAMERA_PARM_RECORDING_HINT,
-    MM_CAMERA_PARM_CAF_ENABLE,
-    MM_CAMERA_PARM_FULL_LIVESHOT,
-    MM_CAMERA_PARM_DIS_ENABLE, /* 75 */
-    MM_CAMERA_PARM_AEC_LOCK,
-    MM_CAMERA_PARM_AWB_LOCK,
-    MM_CAMERA_PARM_AF_MTR_AREA,
-    MM_CAMERA_PARM_AEC_MTR_AREA,
-    MM_CAMERA_PARM_LOW_POWER_MODE,
-    MM_CAMERA_PARM_MAX_HFR_MODE, /* 80 */
-    MM_CAMERA_PARM_MAX_VIDEO_SIZE,
-    MM_CAMERA_PARM_DEF_PREVIEW_SIZES,
-    MM_CAMERA_PARM_DEF_VIDEO_SIZES,
-    MM_CAMERA_PARM_DEF_THUMB_SIZES,
-    MM_CAMERA_PARM_DEF_HFR_SIZES,
-    MM_CAMERA_PARM_PREVIEW_SIZES_CNT,
-    MM_CAMERA_PARM_VIDEO_SIZES_CNT,
-    MM_CAMERA_PARM_THUMB_SIZES_CNT,
-    MM_CAMERA_PARM_HFR_SIZES_CNT,
-    MM_CAMERA_PARM_GRALLOC_USAGE,
-    MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, //to check whether both oputputs are
-    MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH,
-    MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT,
-    MM_CAMERA_PARM_FOCUS_MODE,
-    MM_CAMERA_PARM_HFR_FRAME_SKIP,
-    MM_CAMERA_PARM_CH_INTERFACE,
-    //or single output enabled to differentiate 7x27a with others
-    MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
-    MM_CAMERA_PARM_MAX_NUM_FACES_DECT,
-    MM_CAMERA_PARM_FPS_RANGE,
-    MM_CAMERA_PARM_CID,
-    MM_CAMERA_PARM_FRAME_RESOLUTION,
-    MM_CAMERA_PARM_RAW_SNAPSHOT_FMT,
-    MM_CAMERA_PARM_FACIAL_FEATURE_INFO,
-    MM_CAMERA_PARM_CAF_LOCK_CANCEL,
-    MM_CAMERA_PARM_APERTURE,
-    MM_CAMERA_PARM_MAX
-} mm_camera_parm_type_t;
-
-typedef enum {
-  STREAM_IMAGE,
-  STREAM_RAW,
-  STREAM_IMAGE_AND_RAW,
-  STREAM_RAW_AND_RAW,
-  STREAM_MAX,
-} mm_camera_channel_stream_info_t;
-
-typedef enum {
-  CAMERA_SET_PARM_DISPLAY_INFO,
-  CAMERA_SET_PARM_DIMENSION,
-
-  CAMERA_SET_PARM_ZOOM,
-  CAMERA_SET_PARM_SENSOR_POSITION,
-  CAMERA_SET_PARM_FOCUS_RECT,
-  CAMERA_SET_PARM_LUMA_ADAPTATION,
-  CAMERA_SET_PARM_CONTRAST,
-  CAMERA_SET_PARM_BRIGHTNESS,
-  CAMERA_SET_PARM_EXPOSURE_COMPENSATION,
-  CAMERA_SET_PARM_SHARPNESS,
-  CAMERA_SET_PARM_HUE,  /* 10 */
-  CAMERA_SET_PARM_SATURATION,
-  CAMERA_SET_PARM_EXPOSURE,
-  CAMERA_SET_PARM_AUTO_FOCUS,
-  CAMERA_SET_PARM_WB,
-  CAMERA_SET_PARM_EFFECT,
-  CAMERA_SET_PARM_FPS,
-  CAMERA_SET_PARM_FLASH,
-  CAMERA_SET_PARM_NIGHTSHOT_MODE,
-  CAMERA_SET_PARM_REFLECT,
-  CAMERA_SET_PARM_PREVIEW_MODE,  /* 20 */
-  CAMERA_SET_PARM_ANTIBANDING,
-  CAMERA_SET_PARM_RED_EYE_REDUCTION,
-  CAMERA_SET_PARM_FOCUS_STEP,
-  CAMERA_SET_PARM_EXPOSURE_METERING,
-  CAMERA_SET_PARM_AUTO_EXPOSURE_MODE,
-  CAMERA_SET_PARM_ISO,
-  CAMERA_SET_PARM_BESTSHOT_MODE,
-  CAMERA_SET_PARM_ENCODE_ROTATION,
-
-  CAMERA_SET_PARM_PREVIEW_FPS,
-  CAMERA_SET_PARM_AF_MODE,  /* 30 */
-  CAMERA_SET_PARM_HISTOGRAM,
-  CAMERA_SET_PARM_FLASH_STATE,
-  CAMERA_SET_PARM_FRAME_TIMESTAMP,
-  CAMERA_SET_PARM_STROBE_FLASH,
-  CAMERA_SET_PARM_FPS_LIST,
-  CAMERA_SET_PARM_HJR,
-  CAMERA_SET_PARM_ROLLOFF,
-
-  CAMERA_STOP_PREVIEW,
-  CAMERA_START_PREVIEW,
-  CAMERA_START_SNAPSHOT, /* 40 */
-  CAMERA_START_RAW_SNAPSHOT,
-  CAMERA_STOP_SNAPSHOT,
-  CAMERA_EXIT,
-  CAMERA_ENABLE_BSM,
-  CAMERA_DISABLE_BSM,
-  CAMERA_GET_PARM_ZOOM,
-  CAMERA_GET_PARM_MAXZOOM,
-  CAMERA_GET_PARM_ZOOMRATIOS,
-  CAMERA_GET_PARM_AF_SHARPNESS,
-  CAMERA_SET_PARM_LED_MODE, /* 50 */
-  CAMERA_SET_MOTION_ISO,
-  CAMERA_AUTO_FOCUS_CANCEL,
-  CAMERA_GET_PARM_FOCUS_STEP,
-  CAMERA_ENABLE_AFD,
-  CAMERA_PREPARE_SNAPSHOT,
-  CAMERA_SET_FPS_MODE,
-  CAMERA_START_VIDEO,
-  CAMERA_STOP_VIDEO,
-  CAMERA_START_RECORDING,
-  CAMERA_STOP_RECORDING, /* 60 */
-  CAMERA_SET_VIDEO_DIS_PARAMS,
-  CAMERA_SET_VIDEO_ROT_PARAMS,
-  CAMERA_SET_PARM_AEC_ROI,
-  CAMERA_SET_CAF,
-  CAMERA_SET_PARM_BL_DETECTION_ENABLE,
-  CAMERA_SET_PARM_SNOW_DETECTION_ENABLE,
-  CAMERA_SET_PARM_STROBE_FLASH_MODE,
-  CAMERA_SET_PARM_AF_ROI,
-  CAMERA_START_LIVESHOT,
-  CAMERA_SET_SCE_FACTOR, /* 70 */
-  CAMERA_GET_CAPABILITIES,
-  CAMERA_GET_PARM_DIMENSION,
-  CAMERA_GET_PARM_LED_MODE,
-  CAMERA_SET_PARM_FD,
-  CAMERA_GET_PARM_3D_FRAME_FORMAT,
-  CAMERA_QUERY_FLASH_FOR_SNAPSHOT,
-  CAMERA_GET_PARM_FOCUS_DISTANCES,
-  CAMERA_START_ZSL,
-  CAMERA_STOP_ZSL,
-  CAMERA_ENABLE_ZSL, /* 80 */
-  CAMERA_GET_PARM_FOCAL_LENGTH,
-  CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
-  CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
-  CAMERA_SET_PARM_WAVELET_DENOISE,
-  CAMERA_SET_PARM_MCE,
-  CAMERA_ENABLE_STEREO_CAM,
-  CAMERA_SET_PARM_RESET_LENS_TO_INFINITY,
-  CAMERA_GET_PARM_SNAPSHOTDATA,
-  CAMERA_SET_PARM_HFR,
-  CAMERA_SET_REDEYE_REDUCTION, /* 90 */
-  CAMERA_SET_PARM_3D_DISPLAY_DISTANCE,
-  CAMERA_SET_PARM_3D_VIEW_ANGLE,
-  CAMERA_SET_PARM_3D_EFFECT,
-  CAMERA_SET_PARM_PREVIEW_FORMAT,
-  CAMERA_GET_PARM_3D_DISPLAY_DISTANCE, /* 95 */
-  CAMERA_GET_PARM_3D_VIEW_ANGLE,
-  CAMERA_GET_PARM_3D_EFFECT,
-  CAMERA_GET_PARM_3D_MANUAL_CONV_RANGE,
-  CAMERA_SET_PARM_3D_MANUAL_CONV_VALUE,
-  CAMERA_ENABLE_3D_MANUAL_CONVERGENCE, /* 100 */
-  CAMERA_SET_PARM_HDR,
-  CAMERA_SET_ASD_ENABLE,
-  CAMERA_POSTPROC_ABORT,
-  CAMERA_SET_AEC_MTR_AREA,
-  CAMERA_SET_AEC_LOCK,       /*105*/
-  CAMERA_SET_AWB_LOCK,
-  CAMERA_SET_RECORDING_HINT,
-  CAMERA_SET_PARM_CAF,
-  CAMERA_SET_FULL_LIVESHOT,
-  CAMERA_SET_DIS_ENABLE,  /*110*/
-  CAMERA_GET_PARM_MAX_HFR_MODE,
-  CAMERA_SET_LOW_POWER_MODE,
-  CAMERA_GET_PARM_DEF_PREVIEW_SIZES,
-  CAMERA_GET_PARM_DEF_VIDEO_SIZES,
-  CAMERA_GET_PARM_DEF_THUMB_SIZES, /*115*/
-  CAMERA_GET_PARM_DEF_HFR_SIZES,
-  CAMERA_GET_PARM_MAX_LIVESHOT_SIZE,
-  CAMERA_GET_PARM_FPS_RANGE,
-  CAMERA_SET_3A_CONVERGENCE,
-  CAMERA_SET_PREVIEW_HFR, /*120*/
-  CAMERA_GET_MAX_DIMENSION,
-  CAMERA_GET_MAX_NUM_FACES_DECT,
-  CAMERA_SET_CHANNEL_STREAM,
-  CAMERA_GET_CHANNEL_STREAM,
-  CAMERA_SET_PARM_CID, /*125*/
-  CAMERA_GET_PARM_FRAME_RESOLUTION,
-  CAMERA_GET_FACIAL_FEATURE_INFO,
-  CAMERA_SET_CAF_LOCK_CANCEL,
-  CAMERA_CTRL_PARM_MAX
-} cam_ctrl_type;
-
-typedef enum {
-  CAMERA_ERROR_NO_MEMORY,
-  CAMERA_ERROR_EFS_FAIL,                /* Low-level operation failed */
-  CAMERA_ERROR_EFS_FILE_OPEN,           /* File already opened */
-  CAMERA_ERROR_EFS_FILE_NOT_OPEN,       /* File not opened */
-  CAMERA_ERROR_EFS_FILE_ALREADY_EXISTS, /* File already exists */
-  CAMERA_ERROR_EFS_NONEXISTENT_DIR,     /* User directory doesn't exist */
-  CAMERA_ERROR_EFS_NONEXISTENT_FILE,    /* User directory doesn't exist */
-  CAMERA_ERROR_EFS_BAD_FILE_NAME,       /* Client specified invalid file/directory name*/
-  CAMERA_ERROR_EFS_BAD_FILE_HANDLE,     /* Client specified invalid file/directory name*/
-  CAMERA_ERROR_EFS_SPACE_EXHAUSTED,     /* Out of file system space */
-  CAMERA_ERROR_EFS_OPEN_TABLE_FULL,     /* Out of open-file table slots                */
-  CAMERA_ERROR_EFS_OTHER_ERROR,         /* Other error                                 */
-  CAMERA_ERROR_CONFIG,
-  CAMERA_ERROR_EXIF_ENCODE,
-  CAMERA_ERROR_VIDEO_ENGINE,
-  CAMERA_ERROR_IPL,
-  CAMERA_ERROR_INVALID_FORMAT,
-  CAMERA_ERROR_TIMEOUT,
-  CAMERA_ERROR_ESD,
-  CAMERA_ERROR_MAX
-} camera_error_type;
-
-#if defined CAMERA_ANTIBANDING_OFF
-#undef CAMERA_ANTIBANDING_OFF
-#endif
-
-#if defined CAMERA_ANTIBANDING_60HZ
-#undef CAMERA_ANTIBANDING_60HZ
-#endif
-
-#if defined CAMERA_ANTIBANDING_50HZ
-#undef CAMERA_ANTIBANDING_50HZ
-#endif
-
-#if defined CAMERA_ANTIBANDING_AUTO
-#undef CAMERA_ANTIBANDING_AUTO
-#endif
-
-typedef enum {
-  CAMERA_ANTIBANDING_OFF,
-  CAMERA_ANTIBANDING_60HZ,
-  CAMERA_ANTIBANDING_50HZ,
-  CAMERA_ANTIBANDING_AUTO,
-  CAMERA_ANTIBANDING_AUTO_50HZ,
-  CAMERA_ANTIBANDING_AUTO_60HZ,
-  CAMERA_MAX_ANTIBANDING,
-} camera_antibanding_type;
-
-/* Enum Type for different ISO Mode supported */
-typedef enum {
-  CAMERA_ISO_AUTO = 0,
-  CAMERA_ISO_DEBLUR,
-  CAMERA_ISO_100,
-  CAMERA_ISO_200,
-  CAMERA_ISO_400,
-  CAMERA_ISO_800,
-  CAMERA_ISO_1600,
-  CAMERA_ISO_MAX
-} camera_iso_mode_type;
-
-typedef enum {
-  MM_CAMERA_FACIAL_FEATURE_FD, // facial detection
-  MM_CAMERA_FACIAL_FEATURE_MAX
-} camera_facial_features;
-
-typedef enum {
-  AEC_ROI_OFF,
-  AEC_ROI_ON
-} aec_roi_ctrl_t;
-
-typedef enum {
-  AEC_ROI_BY_INDEX,
-  AEC_ROI_BY_COORDINATE,
-} aec_roi_type_t;
-
-typedef struct {
-  uint32_t x;
-  uint32_t y;
-} cam_coordinate_type_t;
-
-/*
- * Define DRAW_RECTANGLES to draw rectangles on screen. Just for test purpose.
- */
-//#define DRAW_RECTANGLES
-
-typedef struct {
-  uint16_t x;
-  uint16_t y;
-  uint16_t dx;
-  uint16_t dy;
-} roi_t;
-
-typedef struct {
-  aec_roi_ctrl_t aec_roi_enable;
-  aec_roi_type_t aec_roi_type;
-  union {
-    cam_coordinate_type_t coordinate;
-    uint32_t aec_roi_idx;
-  } aec_roi_position;
-} cam_set_aec_roi_t;
-
-typedef struct {
-  uint32_t frm_id;
-  uint8_t num_roi;
-  roi_t roi[MAX_ROI];
-  uint8_t is_multiwindow;
-} roi_info_t;
-
-/* Exif Tag Data Type */
-typedef enum
-{
-    EXIF_BYTE      = 1,
-    EXIF_ASCII     = 2,
-    EXIF_SHORT     = 3,
-    EXIF_LONG      = 4,
-    EXIF_RATIONAL  = 5,
-    EXIF_UNDEFINED = 7,
-    EXIF_SLONG     = 9,
-    EXIF_SRATIONAL = 10
-} exif_tag_type_t;
-
-
-/* Exif Rational Data Type */
-typedef struct
-{
-    uint32_t  num;    // Numerator
-    uint32_t  denom;  // Denominator
-
-} rat_t;
-
-/* Exif Signed Rational Data Type */
-typedef struct
-{
-    int32_t  num;    // Numerator
-    int32_t  denom;  // Denominator
-
-} srat_t;
-
-typedef struct
-{
-  exif_tag_type_t type;
-  uint8_t copy;
-  uint32_t count;
-  union
-  {
-    char      *_ascii;
-    uint8_t   *_bytes;
-    uint8_t    _byte;
-    uint16_t  *_shorts;
-    uint16_t   _short;
-    uint32_t  *_longs;
-    uint32_t   _long;
-    rat_t     *_rats;
-    rat_t      _rat;
-    uint8_t   *_undefined;
-    int32_t   *_slongs;
-    int32_t    _slong;
-    srat_t    *_srats;
-    srat_t     _srat;
-  } data;
-} exif_tag_entry_t;
-
-typedef struct {
-    uint32_t      tag_id;
-    exif_tag_entry_t  tag_entry;
-} exif_tags_info_t;
-
-
-typedef enum {
- HDR_BRACKETING_OFF,
- HDR_MODE,
- EXP_BRACKETING_MODE
- } hdr_mode;
-
-typedef struct {
-  hdr_mode mode;
-  uint32_t hdr_enable;
-  uint32_t total_frames;
-  uint32_t total_hal_frames;
-  char values[MAX_EXP_BRACKETING_LENGTH];  /* user defined values */
-} exp_bracketing_t;
-typedef struct {
-  roi_t      mtr_area[MAX_ROI];
-  uint32_t   num_area;
-  int        weight[MAX_ROI];
-} aec_mtr_area_t;
-
-typedef struct {
-  int denoise_enable;
-  int process_plates;
-} denoise_param_t;
-
-#ifndef HAVE_CAMERA_SIZE_TYPE
-  #define HAVE_CAMERA_SIZE_TYPE
-struct camera_size_type {
-  int width;
-  int height;
-};
-#endif
-
-typedef struct {
-  uint32_t yoffset;
-  uint32_t cbcr_offset;
-  uint32_t size;
-  struct camera_size_type resolution;
-}cam_buf_info_t;
-
-typedef struct {
-  int x;
-  int y;
-}cam_point_t;
-
-typedef struct {
-  /* AF parameters */
-  uint8_t focus_position;
-  /* AEC parameters */
-  uint32_t line_count;
-  uint8_t luma_target;
-  /* AWB parameters */
-  int32_t r_gain;
-  int32_t b_gain;
-  int32_t g_gain;
-  uint8_t exposure_mode;
-  uint8_t exposure_program;
-  float exposure_time;
-  uint32_t iso_speed;
-} snapshotData_info_t;
-
-
-typedef enum {
-  CAMERA_HFR_MODE_OFF = 1,
-  CAMERA_HFR_MODE_60FPS,
-  CAMERA_HFR_MODE_90FPS,
-  CAMERA_HFR_MODE_120FPS,
-  CAMERA_HFR_MODE_150FPS,
-} camera_hfr_mode_t;
-
-/* frame Q*/
-struct fifo_node
-{
-  struct fifo_node *next;
-  void *f;
-};
-
-struct fifo_queue
-{
-  int num_of_frames;
-  struct fifo_node *front;
-  struct fifo_node *back;
-  pthread_mutex_t mut;
-  pthread_cond_t wait;
-  char* name;
-};
-
-typedef struct {
-  uint32_t buf_len;
-  uint8_t num;
-  uint8_t pmem_type;
-  uint32_t vaddr[8];
-} mm_camera_histo_mem_info_t;
-
-typedef enum {
-  MM_CAMERA_CTRL_EVT_ZOOM_DONE,
-  MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE,
-  MM_CAMERA_CTRL_EVT_PREP_SNAPSHOT,
-  MM_CAMERA_CTRL_EVT_SNAPSHOT_CONFIG_DONE,
-  MM_CAMERA_CTRL_EVT_WDN_DONE, // wavelet denoise done
-  MM_CAMERA_CTRL_EVT_ERROR,
-  MM_CAMERA_CTRL_EVT_MAX
-}mm_camera_ctrl_event_type_t;
-
-typedef struct {
-  mm_camera_ctrl_event_type_t evt;
-  cam_ctrl_status_t status;
-  unsigned long cookie;
-} mm_camera_ctrl_event_t;
-
-typedef enum {
-  MM_CAMERA_CH_EVT_STREAMING_ON,
-  MM_CAMERA_CH_EVT_STREAMING_OFF,
-  MM_CAMERA_CH_EVT_STREAMING_ERR,
-  MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE,
-  MM_CAMERA_CH_EVT_DATA_REQUEST_MORE,
-  MM_CAMERA_CH_EVT_MAX
-}mm_camera_ch_event_type_t;
-
-typedef struct {
-  uint32_t ch;
-  mm_camera_ch_event_type_t evt;
-} mm_camera_ch_event_t;
-
-typedef struct {
-  uint32_t index;
-  /* TBD: need more fields for histo stats? */
-} mm_camera_stats_histo_t;
-
-typedef struct  {
-  uint32_t event_id;
-  union {
-    mm_camera_stats_histo_t    stats_histo;
-  } e;
-} mm_camera_stats_event_t;
-
-typedef enum {
-  FD_ROI_TYPE_HEADER,
-  FD_ROI_TYPE_DATA
-} fd_roi_type_t;
-
-typedef struct {
-  int fd_mode;
-  int num_fd;
-} fd_set_parm_t;
-
-typedef struct {
-  uint32_t frame_id;
-  int16_t num_face_detected;
-} fd_roi_header_type;
-
-struct fd_rect_t {
-  uint16_t x;
-  uint16_t y;
-  uint16_t dx;
-  uint16_t dy;
-};
-
-typedef struct {
-  struct fd_rect_t face_boundary;
-  uint16_t left_eye_center[2];
-  uint16_t right_eye_center[2];
-  uint16_t mouth_center[2];
-  uint8_t smile_degree;  //0 -100
-  uint8_t smile_confidence;  //
-  uint8_t blink_detected;  // 0 or 1
-  uint8_t is_face_recognised;  // 0 or 1
-  int8_t gaze_angle;  // -90 -45 0 45 90 for head left to rigth tilt
-  int8_t updown_dir;  // -90 to 90
-  int8_t leftright_dir;  //-90 to 90
-  int8_t roll_dir;  // -90 to 90
-  int8_t left_right_gaze;  // -50 to 50
-  int8_t top_bottom_gaze;  // -50 to 50
-  uint8_t left_blink;  // 0 - 100
-  uint8_t right_blink;  // 0 - 100
-  int8_t id;  // unique id for face tracking within view unless view changes
-  int8_t score;  // score of confidence( 0 -100)
-} fd_face_type;
-
-typedef struct {
-  uint32_t frame_id;
-  uint8_t idx;
-  fd_face_type face;
-} fd_roi_data_type;
-
-struct fd_roi_t {
-  fd_roi_type_t type;
-  union {
-    fd_roi_header_type hdr;
-    fd_roi_data_type data;
-  } d;
-};
-
-typedef struct  {
-  uint32_t event_id;
-  union {
-    mm_camera_histo_mem_info_t histo_mem_info;
-    struct fd_roi_t roi;
-  } e;
-} mm_camera_info_event_t;
-
-
-typedef enum {
-  MM_CAMERA_EVT_TYPE_CH,
-  MM_CAMERA_EVT_TYPE_CTRL,
-  MM_CAMERA_EVT_TYPE_STATS,
-  MM_CAMERA_EVT_TYPE_INFO,
-  MM_CAMERA_EVT_TYPE_MAX
-} mm_camera_event_type_t;
-
-/*
- * the APP event related defines
-*/
-typedef enum {
-  MM_CAMERA_STATS_EVT_HISTO,
-  MM_CAMERA_STATS_EVT_MAX
-} mm_camera_stats_event_type_t;
-
-typedef enum {
-  MM_CAMERA_INFO_EVT_ROI,
-  MM_CAMERA_INFO_FLASH_FRAME_IDX,
-  MM_CAMERA_INFO_EVT_MAX
-} mm_camera_info_event_type_t;
-
-/* !!WARNING: PLAESE BE VERY CAREFUL!!
- * v4l2_event payload has a limitation of 64 bytes.
- * This makes that the whole mm_camera_event_t size
- * cannot go beyond 64 bytes.
- */
-typedef struct {
-  mm_camera_event_type_t event_type;
-  /* the union size cannot go beyond 64 bytes. need RFC */
-  union {
-    mm_camera_ch_event_t ch;
-    mm_camera_ctrl_event_t ctrl;
-    mm_camera_stats_event_t stats;
-    mm_camera_info_event_t info;
-  } e;
-} mm_camera_event_t;
-
-/******************************************************************************
- * Function: exif_set_tag
- * Description: Inserts or modifies an Exif tag to the Exif Info object. Typical
- *              use is to call this function multiple times - to insert all the
- *              desired Exif Tags individually to the Exif Info object and
- *              then pass the info object to the Jpeg Encoder object so
- *              the inserted tags would be emitted as tags in the Exif header.
- * Input parameters:
- *   obj       - The Exif Info object where the tag would be inserted to or
- *               modified from.
- *   tag_id    - The Exif Tag ID of the tag to be inserted/modified.
- *   p_entry   - The pointer to the tag entry structure which contains the
- *               details of tag. The pointer can be set to NULL to un-do
- *               previous insertion for a certain tag.
- * Return values:
- *     JPEGERR_SUCCESS
- *     JPEGERR_ENULLPTR
- *     JPEGERR_EFAILED
- * (See jpegerr.h for description of error values.)
- * Notes: none
- *****************************************************************************/
-int exif_set_tag(exif_info_obj_t    obj,
-                 exif_tag_id_t      tag_id,
-                 exif_tag_entry_t  *p_entry);
-
-typedef uint32_t  jpeg_event_t;
-
-/* Auto focus mode, used for CAMERA_PARM_AF_MODE */
-typedef enum {
-  AF_MODE_UNCHANGED = -1,
-  AF_MODE_NORMAL    = 0,
-  AF_MODE_MACRO,
-  AF_MODE_AUTO,
-  AF_MODE_CAF,
-  AF_MODE_INFINITY,
-  AF_MODE_MAX
-} isp3a_af_mode_t;
-
-typedef struct {
-  uint32_t  in1_w;
-  uint32_t  out1_w;
-  uint32_t  in1_h;
-  uint32_t  out1_h;
-  uint32_t  in2_w;
-  uint32_t  out2_w;
-  uint32_t  in2_h;
-  uint32_t  out2_h;
-  uint8_t update_flag;
-} common_crop_t;
-
-typedef enum {
-  LED_MODE_OFF,
-  LED_MODE_AUTO,
-  LED_MODE_ON,
-  LED_MODE_TORCH,
-
-  /*new mode above should be added above this line*/
-  LED_MODE_MAX
-} led_mode_t;
-
-typedef struct video_dis_param_ctrl_t {
-  uint32_t dis_enable;       /* DIS feature: 1 = enable, 0 = disable.
-                               when enable, caller makes sure w/h are 10% more. */
-  uint32_t video_rec_width;  /* video frame width for recording */
-  uint32_t video_rec_height; /* video frame height for recording */
-  uint32_t output_cbcr_offset;
-} video_dis_param_ctrl_t;
-
-typedef enum camera_rotation_type {
-  ROT_NONE               = 0,
-  ROT_CLOCKWISE_90       = 1,
-  ROT_CLOCKWISE_180      = 6,
-  ROT_CLOCKWISE_270      = 7,
-} camera_rotation_type;
-
-typedef struct video_rotation_param_ctrl_t {
-  camera_rotation_type rotation; /* 0 degree = rot disable. */
-} video_rotation_param_ctrl_t;
-
-enum focus_distance_index{
-  FOCUS_DISTANCE_NEAR_INDEX,  /* 0 */
-  FOCUS_DISTANCE_OPTIMAL_INDEX,
-  FOCUS_DISTANCE_FAR_INDEX,
-  FOCUS_DISTANCE_MAX_INDEX
-};
-
-typedef struct {
-  float focus_distance[FOCUS_DISTANCE_MAX_INDEX];
-  float real_gain;
-} focus_distances_info_t;
-
-typedef enum msm_st_frame_packing cam_3d_frame_format_t;
-
-typedef struct {
-  cam_frame_type_t frame_type;
-  cam_3d_frame_format_t format;
-}camera_3d_frame_t;
-
-// Possibly supported color formats
-// Ordering handcrafted for efficient coding, alter with care!
-typedef enum
-{
-    YCRCBLP_H2V2 = 0,
-    YCBCRLP_H2V2 = 1,
-
-    YCRCBLP_H2V1 = 2,
-    YCBCRLP_H2V1 = 3,
-
-    YCRCBLP_H1V2 = 4,
-    YCBCRLP_H1V2 = 5,
-
-    YCRCBLP_H1V1 = 6,
-    YCBCRLP_H1V1 = 7,
-
-    RGB565 = 8,
-    RGB888 = 9,
-    RGBa   = 10,
-
-    JPEG_BITSTREAM_H2V2 = 12,
-    JPEG_BITSTREAM_H2V1 = 14,
-    JPEG_BITSTREAM_H1V2 = 16,
-    JPEG_BITSTREAM_H1V1 = 18,
-
-    JPEG_COLOR_FORMAT_MAX,
-
-} jpeg_color_format_t;
-
-typedef enum {
-    CAMERA_BESTSHOT_OFF = 0,
-    CAMERA_BESTSHOT_AUTO = 1,
-    CAMERA_BESTSHOT_LANDSCAPE = 2,
-    CAMERA_BESTSHOT_SNOW,
-    CAMERA_BESTSHOT_BEACH,
-    CAMERA_BESTSHOT_SUNSET,
-    CAMERA_BESTSHOT_NIGHT,
-    CAMERA_BESTSHOT_PORTRAIT,
-    CAMERA_BESTSHOT_BACKLIGHT,
-    CAMERA_BESTSHOT_SPORTS,
-    CAMERA_BESTSHOT_ANTISHAKE,
-    CAMERA_BESTSHOT_FLOWERS,
-    CAMERA_BESTSHOT_CANDLELIGHT,
-    CAMERA_BESTSHOT_FIREWORKS,
-    CAMERA_BESTSHOT_PARTY,
-    CAMERA_BESTSHOT_NIGHT_PORTRAIT,
-    CAMERA_BESTSHOT_THEATRE,
-    CAMERA_BESTSHOT_ACTION,
-    CAMERA_BESTSHOT_AR,
-    CAMERA_BESTSHOT_MAX
-} camera_bestshot_mode_type;
-
-typedef enum {
-  AUTO = 1,
-  SPOT,
-  CENTER_WEIGHTED,
-  AVERAGE
-} cam_af_focusrect_t;
-
-typedef enum {
-  CAMERA_AEC_FRAME_AVERAGE,
-  CAMERA_AEC_CENTER_WEIGHTED,
-  CAMERA_AEC_SPOT_METERING,
-  CAMERA_AEC_SMART_METERING,
-  CAMERA_AEC_USER_METERING,
-  CAMERA_AEC_MAX_MODES
-} camera_auto_exposure_mode_type;
-
-typedef enum {
-  FPS_MODE_AUTO,
-  FPS_MODE_FIXED,
-} fps_mode_t;
-
-typedef struct {
-  int32_t  buffer[256];       /* buffer to hold data */
-  int32_t  max_value;
-} camera_preview_histogram_info;
-
-/* Clockwise */
-typedef enum {
-  CAMERA_ENCODING_ROTATE_0,
-  CAMERA_ENCODING_ROTATE_90,
-  CAMERA_ENCODING_ROTATE_180,
-  CAMERA_ENCODING_ROTATE_270
-} camera_encoding_rotate_t;
-
-typedef enum {
-  MOTION_ISO_OFF,
-  MOTION_ISO_ON
-} motion_iso_t;
-
-typedef struct {
-  struct msm_ctrl_cmd ctrlCmd;
-  int fd;
-  void (*af_cb)(int8_t );
-  int8_t is_camafctrl_thread_join;
-  isp3a_af_mode_t af_mode;
-} cam_af_ctrl_t;
-
-/* Display */
-typedef struct {
-    uint16_t user_input_display_width;
-    uint16_t user_input_display_height;
-} USER_INPUT_DISPLAY_T;
-
-#if defined CAMERA_WB_AUTO
-#undef CAMERA_WB_AUTO
-#endif
-
-#if defined CAMERA_WB_CUSTOM
-#undef CAMERA_WB_CUSTOM
-#endif
-
-#if defined  CAMERA_WB_INCANDESCENT
-#undef CAMERA_WB_INCANDESCENT
-#endif
-
-#if defined CAMERA_WB_FLUORESCENT
-#undef CAMERA_WB_FLUORESCENT
-#endif
-
-#if defined CAMERA_WB_DAYLIGHT
-#undef CAMERA_WB_DAYLIGHT
-#endif
-
-#if defined CAMERA_WB_CLOUDY_DAYLIGHT
-#undef CAMERA_WB_CLOUDY_DAYLIGHT
-#endif
-
-#if defined CAMERA_WB_TWILIGHT
-#undef CAMERA_WB_TWILIGHT
-#endif
-
-#if defined CAMERA_WB_SHADE
-#undef CAMERA_WB_SHADE
-#endif
-
-typedef enum {
-  CAMERA_WB_MIN_MINUS_1,
-  CAMERA_WB_AUTO = 1,  /* This list must match aeecamera.h */
-  CAMERA_WB_CUSTOM,
-  CAMERA_WB_INCANDESCENT,
-  CAMERA_WB_FLUORESCENT,
-  CAMERA_WB_DAYLIGHT,
-  CAMERA_WB_CLOUDY_DAYLIGHT,
-  CAMERA_WB_TWILIGHT,
-  CAMERA_WB_SHADE,
-  CAMERA_WB_OFF,
-  CAMERA_WB_MAX_PLUS_1
-} config3a_wb_t;
-
-/* EXIF header */
-
-/* =======================================================================
-**                          Macro Definitions
-** ======================================================================= */
-/* Enum defined to let compiler generate unique offset numbers for different
- * tags - ordering matters! NOT INTENDED to be used by any application. */
-typedef enum
-{
-    // GPS IFD
-    GPS_VERSION_ID = 0,
-    GPS_LATITUDE_REF,
-    GPS_LATITUDE,
-    GPS_LONGITUDE_REF,
-    GPS_LONGITUDE,
-    GPS_ALTITUDE_REF,
-    GPS_ALTITUDE,
-    GPS_TIMESTAMP,
-    GPS_SATELLITES,
-    GPS_STATUS,
-    GPS_MEASUREMODE,
-    GPS_DOP,
-    GPS_SPEED_REF,
-    GPS_SPEED,
-    GPS_TRACK_REF,
-    GPS_TRACK,
-    GPS_IMGDIRECTION_REF,
-    GPS_IMGDIRECTION,
-    GPS_MAPDATUM,
-    GPS_DESTLATITUDE_REF,
-    GPS_DESTLATITUDE,
-    GPS_DESTLONGITUDE_REF,
-    GPS_DESTLONGITUDE,
-    GPS_DESTBEARING_REF,
-    GPS_DESTBEARING,
-    GPS_DESTDISTANCE_REF,
-    GPS_DESTDISTANCE,
-    GPS_PROCESSINGMETHOD,
-    GPS_AREAINFORMATION,
-    GPS_DATESTAMP,
-    GPS_DIFFERENTIAL,
-
-    // TIFF IFD
-    NEW_SUBFILE_TYPE,
-    SUBFILE_TYPE,
-    IMAGE_WIDTH,
-    IMAGE_LENGTH,
-    BITS_PER_SAMPLE,
-    COMPRESSION,
-    PHOTOMETRIC_INTERPRETATION,
-    THRESH_HOLDING,
-    CELL_WIDTH,
-    CELL_HEIGHT,
-    FILL_ORDER,
-    DOCUMENT_NAME,
-    IMAGE_DESCRIPTION,
-    MAKE,
-    MODEL,
-    STRIP_OFFSETS,
-    ORIENTATION,
-    SAMPLES_PER_PIXEL,
-    ROWS_PER_STRIP,
-    STRIP_BYTE_COUNTS,
-    MIN_SAMPLE_VALUE,
-    MAX_SAMPLE_VALUE,
-    X_RESOLUTION,
-    Y_RESOLUTION,
-    PLANAR_CONFIGURATION,
-    PAGE_NAME,
-    X_POSITION,
-    Y_POSITION,
-    FREE_OFFSET,
-    FREE_BYTE_COUNTS,
-    GRAY_RESPONSE_UNIT,
-    GRAY_RESPONSE_CURVE,
-    T4_OPTION,
-    T6_OPTION,
-    RESOLUTION_UNIT,
-    PAGE_NUMBER,
-    TRANSFER_FUNCTION,
-    SOFTWARE,
-    DATE_TIME,
-    ARTIST,
-    HOST_COMPUTER,
-    PREDICTOR,
-    WHITE_POINT,
-    PRIMARY_CHROMATICITIES,
-    COLOR_MAP,
-    HALFTONE_HINTS,
-    TILE_WIDTH,
-    TILE_LENGTH,
-    TILE_OFFSET,
-    TILE_BYTE_COUNTS,
-    INK_SET,
-    INK_NAMES,
-    NUMBER_OF_INKS,
-    DOT_RANGE,
-    TARGET_PRINTER,
-    EXTRA_SAMPLES,
-    SAMPLE_FORMAT,
-    TRANSFER_RANGE,
-    JPEG_PROC,
-    JPEG_INTERCHANGE_FORMAT,
-    JPEG_INTERCHANGE_FORMAT_LENGTH,
-    JPEG_RESTART_INTERVAL,
-    JPEG_LOSSLESS_PREDICTORS,
-    JPEG_POINT_TRANSFORMS,
-    JPEG_Q_TABLES,
-    JPEG_DC_TABLES,
-    JPEG_AC_TABLES,
-    YCBCR_COEFFICIENTS,
-    YCBCR_SUB_SAMPLING,
-    YCBCR_POSITIONING,
-    REFERENCE_BLACK_WHITE,
-    GAMMA,
-    ICC_PROFILE_DESCRIPTOR,
-    SRGB_RENDERING_INTENT,
-    IMAGE_TITLE,
-    COPYRIGHT,
-    EXIF_IFD,
-    ICC_PROFILE,
-    GPS_IFD,
-
-
-    // TIFF IFD (Thumbnail)
-    TN_IMAGE_WIDTH,
-    TN_IMAGE_LENGTH,
-    TN_BITS_PER_SAMPLE,
-    TN_COMPRESSION,
-    TN_PHOTOMETRIC_INTERPRETATION,
-    TN_IMAGE_DESCRIPTION,
-    TN_MAKE,
-    TN_MODEL,
-    TN_STRIP_OFFSETS,
-    TN_ORIENTATION,
-    TN_SAMPLES_PER_PIXEL,
-    TN_ROWS_PER_STRIP,
-    TN_STRIP_BYTE_COUNTS,
-    TN_X_RESOLUTION,
-    TN_Y_RESOLUTION,
-    TN_PLANAR_CONFIGURATION,
-    TN_RESOLUTION_UNIT,
-    TN_TRANSFER_FUNCTION,
-    TN_SOFTWARE,
-    TN_DATE_TIME,
-    TN_ARTIST,
-    TN_WHITE_POINT,
-    TN_PRIMARY_CHROMATICITIES,
-    TN_JPEGINTERCHANGE_FORMAT,
-    TN_JPEGINTERCHANGE_FORMAT_L,
-    TN_YCBCR_COEFFICIENTS,
-    TN_YCBCR_SUB_SAMPLING,
-    TN_YCBCR_POSITIONING,
-    TN_REFERENCE_BLACK_WHITE,
-    TN_COPYRIGHT,
-
-    // EXIF IFD
-    EXPOSURE_TIME,
-    F_NUMBER,
-    EXPOSURE_PROGRAM,
-    SPECTRAL_SENSITIVITY,
-    ISO_SPEED_RATING,
-    OECF,
-    EXIF_VERSION,
-    EXIF_DATE_TIME_ORIGINAL,
-    EXIF_DATE_TIME_DIGITIZED,
-    EXIF_COMPONENTS_CONFIG,
-    EXIF_COMPRESSED_BITS_PER_PIXEL,
-    SHUTTER_SPEED,
-    APERTURE,
-    BRIGHTNESS,
-    EXPOSURE_BIAS_VALUE,
-    MAX_APERTURE,
-    SUBJECT_DISTANCE,
-    METERING_MODE,
-    LIGHT_SOURCE,
-    FLASH,
-    FOCAL_LENGTH,
-    SUBJECT_AREA,
-    EXIF_MAKER_NOTE,
-    EXIF_USER_COMMENT,
-    SUBSEC_TIME,
-    SUBSEC_TIME_ORIGINAL,
-    SUBSEC_TIME_DIGITIZED,
-    EXIF_FLASHPIX_VERSION,
-    EXIF_COLOR_SPACE,
-    EXIF_PIXEL_X_DIMENSION,
-    EXIF_PIXEL_Y_DIMENSION,
-    RELATED_SOUND_FILE,
-    INTEROP,
-    FLASH_ENERGY,
-    SPATIAL_FREQ_RESPONSE,
-    FOCAL_PLANE_X_RESOLUTION,
-    FOCAL_PLANE_Y_RESOLUTION,
-    FOCAL_PLANE_RESOLUTION_UNIT,
-    SUBJECT_LOCATION,
-    EXPOSURE_INDEX,
-    SENSING_METHOD,
-    FILE_SOURCE,
-    SCENE_TYPE,
-    CFA_PATTERN,
-    CUSTOM_RENDERED,
-    EXPOSURE_MODE,
-    WHITE_BALANCE,
-    DIGITAL_ZOOM_RATIO,
-    FOCAL_LENGTH_35MM,
-    SCENE_CAPTURE_TYPE,
-    GAIN_CONTROL,
-    CONTRAST,
-    SATURATION,
-    SHARPNESS,
-    DEVICE_SETTINGS_DESCRIPTION,
-    SUBJECT_DISTANCE_RANGE,
-    IMAGE_UID,
-    PIM,
-
-    EXIF_TAG_MAX_OFFSET
-
-} exif_tag_offset_t;
-
-/* Below are the supported Tags (ID and structure for their data) */
-#define CONSTRUCT_TAGID(offset,ID)   (offset << 16 | ID)
-
-// GPS tag version
-// Use EXIFTAGTYPE_GPS_VERSION_ID as the exif_tag_type (EXIF_BYTE)
-// Count should be 4
-#define _ID_GPS_VERSION_ID                  0x0000
-#define EXIFTAGID_GPS_VERSION_ID            CONSTRUCT_TAGID(GPS_VERSION_ID, _ID_GPS_VERSION_ID)
-#define EXIFTAGTYPE_GPS_VERSION_ID          EXIF_BYTE
-// North or South Latitude
-// Use EXIFTAGTYPE_GPS_LATITUDE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-#define _ID_GPS_LATITUDE_REF                0x0001
-#define EXIFTAGID_GPS_LATITUDE_REF          CONSTRUCT_TAGID(GPS_LATITUDE_REF, _ID_GPS_LATITUDE_REF)
-#define EXIFTAGTYPE_GPS_LATITUDE_REF         EXIF_ASCII
-// Latitude
-// Use EXIFTAGTYPE_GPS_LATITUDE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_LATITUDE                    0x0002
-#define EXIFTAGID_GPS_LATITUDE              CONSTRUCT_TAGID(GPS_LATITUDE, _ID_GPS_LATITUDE)
-#define EXIFTAGTYPE_GPS_LATITUDE             EXIF_RATIONAL
-// East or West Longitude
-// Use EXIFTAGTYPE_GPS_LONGITUDE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-#define _ID_GPS_LONGITUDE_REF               0x0003
-#define EXIFTAGID_GPS_LONGITUDE_REF         CONSTRUCT_TAGID(GPS_LONGITUDE_REF, _ID_GPS_LONGITUDE_REF)
-#define EXIFTAGTYPE_GPS_LONGITUDE_REF       EXIF_ASCII
-// Longitude
-// Use EXIFTAGTYPE_GPS_LONGITUDE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_LONGITUDE                   0x0004
-#define EXIFTAGID_GPS_LONGITUDE             CONSTRUCT_TAGID(GPS_LONGITUDE, _ID_GPS_LONGITUDE)
-#define EXIFTAGTYPE_GPS_LONGITUDE           EXIF_RATIONAL
-// Altitude reference
-// Use EXIFTAGTYPE_GPS_ALTITUDE_REF as the exif_tag_type (EXIF_BYTE)
-#define _ID_GPS_ALTITUDE_REF                0x0005
-#define EXIFTAGID_GPS_ALTITUDE_REF          CONSTRUCT_TAGID(GPS_ALTITUDE_REF, _ID_GPS_ALTITUDE_REF)
-#define EXIFTAGTYPE_GPS_ALTITUDE_REF        EXIF_BYTE
-// Altitude
-// Use EXIFTAGTYPE_GPS_ALTITUDE as the exif_tag_type (EXIF_RATIONAL)
-#define _ID_GPS_ALTITUDE                    0x0006
-#define EXIFTAGID_GPS_ALTITUDE              CONSTRUCT_TAGID(GPS_ALTITUDE, _ID_GPS_ALTITUDE)
-#define EXIFTAGTYPE_GPS_ALTITUE             EXIF_RATIONAL
-// GPS time (atomic clock)
-// Use EXIFTAGTYPE_GPS_TIMESTAMP as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_TIMESTAMP                   0x0007
-#define EXIFTAGID_GPS_TIMESTAMP             CONSTRUCT_TAGID(GPS_TIMESTAMP, _ID_GPS_TIMESTAMP)
-#define EXIFTAGTYPE_GPS_TIMESTAMP           EXIF_RATIONAL
-// GPS Satellites
-// Use EXIFTAGTYPE_GPS_SATELLITES as the exif_tag_type (EXIF_ASCII)
-// Count can be anything.
-#define _ID_GPS_SATELLITES                  0x0008
-#define EXIFTAGID_GPS_SATELLITES            CONSTRUCT_TAGID(GPS_SATELLITES, _ID_GPS_SATELLITES)
-#define EXIFTAGTYPE_GPS_SATELLITES          EXIF_ASCII
-// GPS Status
-// Use EXIFTAGTYPE_GPS_STATUS as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "A" - Measurement in progress
-// "V" - Measurement Interoperability
-// Other - Reserved
-#define _ID_GPS_STATUS                      0x0009
-#define EXIFTAGID_GPS_STATUS                CONSTRUCT_TAGID(GPS_STATUS, _ID_GPS_STATUS)
-#define EXIFTATTYPE_GPS_STATUS              EXIF_ASCII
-// GPS Measure Mode
-// Use EXIFTAGTYPE_GPS_MEASUREMODE as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "2" - 2-dimensional measurement
-// "3" - 3-dimensional measurement
-// Other - Reserved
-#define _ID_GPS_MEASUREMODE                 0x000a
-#define EXIFTAGID_GPS_MEASUREMODE           CONSTRUCT_TAGID(GPS_MEASUREMODE, _ID_GPS_MEASUREMODE)
-#define EXIFTAGTYPE_GPS_MEASUREMODE         EXIF_ASCII
-// GPS Measurement precision (DOP)
-// Use EXIFTAGTYPE_GPS_DOP as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_DOP                         0x000b
-#define EXIFTAGID_GPS_DOP                   CONSTRUCT_TAGID(GPS_DOP, _ID_GPS_DOP)
-#define EXIFTAGTYPE_GPS_DOP                 EXIF_RATIONAL
-// Speed Unit
-// Use EXIFTAGTYPE_GPS_SPEED_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "K" - Kilometers per hour
-// "M" - Miles per hour
-// "N" - Knots
-// Other - Reserved
-#define _ID_GPS_SPEED_REF                   0x000c
-#define EXIFTAGID_GPS_SPEED_REF             CONSTRUCT_TAGID(GPS_SPEED_REF, _ID_GPS_SPEED_REF)
-#define EXIFTAGTYPE_GPS_SPEED_REF           EXIF_ASCII
-// Speed of GPS receiver
-// Use EXIFTAGTYPE_GPS_SPEED as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_SPEED                       0x000d
-#define EXIFTAGID_GPS_SPEED                 CONSTRUCT_TAGID(GPS_SPEED, _ID_GPS_SPEED)
-#define EXIFTAGTYPE_GPS_SPEED               EXIF_RATIONAL
-// Reference of direction of movement
-// Use EXIFTAGTYPE_GPS_TRACK_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "T" - True direction
-// "M" - Magnetic direction
-// Other - Reserved
-#define _ID_GPS_TRACK_REF                    0x000e
-#define EXIFTAGID_GPS_TRACK_REF              CONSTRUCT_TAGID(GPS_TRACK_REF, _ID_GPS_TRACK_REF)
-#define EXIFTAGTYPE_GPS_TRACK_REF            EXIF_ASCII
-// Direction of movement
-// Use EXIFTAGTYPE_GPS_TRACK as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_TRACK                       0x000f
-#define EXIFTAGID_GPS_TRACK                 CONSTRUCT_TAGID(GPS_TRACK, _ID_GPS_TRACK)
-#define EXIFTAGTYPE_GPS_TRACK               EXIF_RATIONAL
-// Reference of direction of image
-// Use EXIFTAGTYPE_GPS_IMGDIRECTION_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "T" - True direction
-// "M" - Magnetic direction
-// Other - Reserved
-#define _ID_GPS_IMGDIRECTION_REF            0x0010
-#define EXIFTAGID_GPS_IMGDIRECTION_REF      CONSTRUCT_TAGID(GPS_IMGDIRECTION_REF, _ID_GPS_IMGDIRECTION_REF)
-#define EXIFTAGTYPE_GPS_IMGDIRECTION_REF    EXIF_ASCII
-// Direction of image
-// Use EXIFTAGTYPE_GPS_IMGDIRECTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_IMGDIRECTION                0x0011
-#define EXIFTAGID_GPS_IMGDIRECTION          CONSTRUCT_TAGID(GPS_IMGDIRECTION, _ID_GPS_IMGDIRECTION)
-#define EXIFTAGTYPE_GPS_IMGDIRECTION        EXIF_RATIONAL
-// Geodetic survey data used
-// Use EXIFTAGTYPE_GPS_MAPDATUM as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_GPS_MAPDATUM                    0x0012
-#define EXIFTAGID_GPS_MAPDATUM              CONSTRUCT_TAGID(GPS_MAPDATUM, _ID_GPS_MAPDATUM)
-#define EXIFTAGTYPE_GPS_MAPDATUM            EXIF_ASCII
-// Reference for latitude of destination
-// Use EXIFTAGTYPE_GPS_DESTLATITUDE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "N" - North latitude
-// "S" - South latitude
-// Other - Reserved
-#define _ID_GPS_DESTLATITUDE_REF            0x0013
-#define EXIFTAGID_GPS_DESTLATITUDE_REF      CONSTRUCT_TAGID(GPS_DESTLATITUDE_REF, _ID_GPS_DESTLATITUDE_REF)
-#define EXIFTAGTYPE_GPS_DESTLATITUDE_REF    EXIF_ASCII
-// Latitude of destination
-// Use EXIFTAGTYPE_GPS_DESTLATITUDE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_DESTLATITUDE                0x0014
-#define EXIFTAGID_GPS_DESTLATITUDE          CONSTRUCT_TAGID(GPS_DESTLATITUDE, _ID_GPS_DESTLATITUDE)
-#define EXIFTAGTYPE_GPS_DESTLATITUDE        EXIF_RATIONAL
-// Reference for longitude of destination
-// Use EXIFTAGTYPE_GPS_DESTLONGITUDE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "E" - East longitude
-// "W" - West longitude
-// Other - Reserved
-#define _ID_GPS_DESTLONGITUDE_REF           0x0015
-#define EXIFTAGID_GPS_DESTLONGITUDE_REF     CONSTRUCT_TAGID(GPS_DESTLONGITUDE_REF, _ID_GPS_DESTLONGITUDE_REF)
-#define EXIFTAGTYPE_GPS_DESTLONGITUDE_REF   EXIF_ASCII
-// Longitude of destination
-// Use EXIFTAGTYPE_GPS_DESTLONGITUDE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_DESTLONGITUDE               0x0016
-#define EXIFTAGID_GPS_DESTLONGITUDE         CONSTRUCT_TAGID(GPS_DESTLONGITUDE, _ID_GPS_DESTLONGITUDE)
-#define EXIFTAGTYPE_GPS_DESTLONGITUDE       EXIF_RATIONAL
-// Reference for bearing of destination
-// Use EXIFTAGTYPE_GPS_DESTBEARING_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "T" - True direction
-// "M" - Magnetic direction
-// Other - Reserved
-#define _ID_GPS_DESTBEARING_REF             0x0017
-#define EXIFTAGID_GPS_DESTBEARING_REF       CONSTRUCT_TAGID(GPS_DESTBEARING_REF, _ID_GPS_DESTBEARING_REF)
-#define EXIFTAGTYPE_GPS_DESTBEARING_REF     EXIF_ASCII
-// Bearing of destination
-// Use EXIFTAGTYPE_GPS_DESTBEARING as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_DESTBEARING                 0x0018
-#define EXIFTAGID_GPS_DESTBEARING           CONSTRUCT_TAGID(GPS_DESTBEARING, _ID_GPS_DESTBEARING)
-#define EXIFTAGTYPE_GPS_DESTBEARING         EXIF_RATIONAL
-// Reference for distance to destination
-// Use EXIFTAGTYPE_GPS_DESTDISTANCE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "K" - Kilometers per hour
-// "M" - Miles per hour
-// "N" - Knots
-// Other - Reserved
-#define _ID_GPS_DESTDISTANCE_REF            0x0019
-#define EXIFTAGID_GPS_DESTDISTANCE_REF      CONSTRUCT_TAGID(GPS_DESTDISTANCE_REF, _ID_GPS_DESTDISTANCE_REF)
-#define EXIFTAGTYPE_GPS_DESTDISTANCE_REF    EXIF_ASCII
-// Distance to destination
-// Use EXIFTAGTYPE_GPS_DESTDISTANCE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_DESTDISTANCE                0x001a
-#define EXIFTAGID_GPS_DESTDISTANCE          CONSTRUCT_TAGID(GPS_DESTDISTANCE, _ID_GPS_DESTDISTANCE)
-#define EXIFTAGTYPE_GPS_DESTDISTANCE        EXIF_RATIONAL
-// Name of GPS processing method
-// Use EXIFTAGTYPE_GPS_PROCESSINGMETHOD as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_GPS_PROCESSINGMETHOD            0x001b
-#define EXIFTAGID_GPS_PROCESSINGMETHOD      CONSTRUCT_TAGID(GPS_PROCESSINGMETHOD, _ID_GPS_PROCESSINGMETHOD)
-#define EXIFTAGTYPE_GPS_PROCESSINGMETHOD    EXIF_UNDEFINED
-// Name of GPS area
-// Use EXIFTAGTYPE_GPS_AREAINFORMATION as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_GPS_AREAINFORMATION             0x001c
-#define EXIFTAGID_GPS_AREAINFORMATION       CONSTRUCT_TAGID(GPS_AREAINFORMATION, _ID_GPS_AREAINFORMATION)
-#define EXIFTAGTYPE_GPS_AREAINFORMATION     EXIF_UNDEFINED
-// GPS date
-// Use EXIFTAGTYPE_GPS_DATESTAMP as the exif_tag_type (EXIF_ASCII)
-// It should be 11 characters long including the null-terminating character.
-#define _ID_GPS_DATESTAMP                   0x001d
-#define EXIFTAGID_GPS_DATESTAMP             CONSTRUCT_TAGID(GPS_DATESTAMP, _ID_GPS_DATESTAMP)
-#define EXIFTAGTYPE_GPS_DATESTAMP           EXIF_ASCII
-// GPS differential correction
-// Use EXIFTAGTYPE_GPS_DIFFERENTIAL as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-// 0 - Measurement without differential correction
-// 1 - Differential correction applied
-// Other - Reserved
-#define _ID_GPS_DIFFERENTIAL                0x001e
-#define EXIFTAGID_GPS_DIFFERENTIAL          CONSTRUCT_TAGID(GPS_DIFFERENTIAL, _ID_GPS_DIFFERENTIAL)
-#define EXIFTAGTYPE_GPS_DIFFERENTIAL        EXIF_SHORT
-// Image width
-// Use EXIFTAGTYPE_IMAGE_WIDTH as the exif_tag_type (EXIF_LONG)
-// Count should be 1
-#define _ID_IMAGE_WIDTH                     0x0100
-#define EXIFTAGID_IMAGE_WIDTH               CONSTRUCT_TAGID(IMAGE_WIDTH, _ID_IMAGE_WIDTH)
-#define EXIFTAGTYPE_IMAGE_WIDTH             EXIF_LONG
-// Image height
-// Use EXIFTAGTYPE_IMAGE_LENGTH as the exif_tag_type (EXIF_SHORT_OR_LONG)
-// Count should be 1
-#define _ID_IMAGE_LENGTH                    0x0101
-#define EXIFTAGID_IMAGE_LENGTH              CONSTRUCT_TAGID(IMAGE_LENGTH, _ID_IMAGE_LENGTH)
-#define EXIFTAGTYPE_IMAGE_LENGTH            EXIF_LONG
-// Number of bits per component
-// Use EXIFTAGTYPE_BITS_PER_SAMPLE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_BITS_PER_SAMPLE                 0x0102
-#define EXIFTAGID_BITS_PER_SAMPLE           CONSTRUCT_TAGID(BITS_PER_SAMPLE, _ID_BITS_PER_SAMPLE)
-#define EXIFTAGTYPE_BITS_PER_SAMPLE         EXIF_SHORT
-// Compression scheme
-// Use EXIFTAGTYPE_COMPRESSION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_COMPRESSION                     0x0103
-#define EXIFTAGID_COMPRESSION               CONSTRUCT_TAGID(COMPRESSION, _ID_COMPRESSION)
-#define EXIFTAGTYPE_COMPRESSION             EXIF_SHORT
-// Pixel composition
-// Use EXIFTAGTYPE_PHOTOMETRIC_INTERPRETATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_PHOTOMETRIC_INTERPRETATION           0x0106
-#define EXIFTAGID_PHOTOMETRIC_INTERPRETATION     CONSTRUCT_TAGID(PHOTOMETRIC_INTERPRETATION, _ID_PHOTOMETRIC_INTERPRETATION)
-#define EXIFTAGTYPE_PHOTOMETRIC_INTERPRETATION   EXIF_SHORT
-
-// Thresholding
-// Use EXIFTAGTYPE_THRESH_HOLDING as the exif_tag_type (EXIF_SHORT)
-//
-//1 = No dithering or halftoning
-//2 = Ordered dither or halftone
-//3 = Randomized dither
-#define _ID_THRESH_HOLDING                  0x0107
-#define EXIFTAGID_THRESH_HOLDING            CONSTRUCT_TAGID(THRESH_HOLDING, _ID_THRESH_HOLDING)
-#define EXIFTAGTYPE_THRESH_HOLDING          EXIF_SHORT
-
-// Cell Width
-// Use EXIFTAGTYPE_CELL_WIDTH as the exif_tag_type (EXIF_SHORT)
-//
-#define _ID_CELL_WIDTH                      0x0108
-#define EXIFTAGID_CELL_WIDTH                CONSTRUCT_TAGID(CELL_WIDTH, _ID_CELL_WIDTH)
-#define EXIFTAGTYPE_CELL_WIDTH              EXIF_SHORT
-// Cell Height
-// Use EXIFTAGTYPE_CELL_HEIGHT as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_CELL_HEIGHT                     0x0109
-#define EXIFTAGID_CELL_HEIGHT               CONSTRUCT_TAGID(CELL_HEIGHT, _ID_CELL_HEIGHT)
-#define EXIFTAGTYPE_CELL_HEIGHT             EXIF_SHORT
-// Fill Order
-// Use EXIFTAGTYPE_FILL_ORDER as the exif_tag_type (EXIF_SHORT)
-// 	1 = Normal
-//  2 = Reversed
-#define _ID_FILL_ORDER                      0x010A
-#define EXIFTAGID_FILL_ORDER                CONSTRUCT_TAGID(FILL_ORDER, _ID_FILL_ORDER)
-#define EXIFTAGTYPE_FILL_ORDER              EXIF_SHORT
-
-// DOCUMENT NAME
-// Use EXIFTAGTYPE_DOCUMENT_NAME as the exif_tag_type (EXIF_ASCII)
-//
-#define _ID_DOCUMENT_NAME                   0x010D
-#define EXIFTAGID_DOCUMENT_NAME             CONSTRUCT_TAGID(DOCUMENT_NAME, _ID_DOCUMENT_NAME)
-#define EXIFTAGTYPE_DOCUMENT_NAME           EXIF_ASCII
-
-// Image title
-// Use EXIFTAGTYPE_IMAGE_DESCRIPTION as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_IMAGE_DESCRIPTION               0x010e
-#define EXIFTAGID_IMAGE_DESCRIPTION         CONSTRUCT_TAGID(IMAGE_DESCRIPTION, _ID_IMAGE_DESCRIPTION)
-#define EXIFTAGTYPE_IMAGE_DESCRIPTION       EXIF_ASCII
-// Image input equipment manufacturer
-// Use EXIFTAGTYPE_MAKE as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_MAKE                            0x010f
-#define EXIFTAGID_MAKE                      CONSTRUCT_TAGID(MAKE, _ID_MAKE)
-#define EXIFTAGTYPE_MAKE                    EXIF_ASCII
-// Image input equipment model
-// Use EXIFTAGTYPE_MODEL as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_MODEL                           0x0110
-#define EXIFTAGID_MODEL                     CONSTRUCT_TAGID(MODEL, _ID_MODEL)
-#define EXIFTAGTYPE_MODEL                   EXIF_ASCII
-// Image data location
-// Use EXIFTAGTYPE_STRIP_OFFSETS as the exif_tag_type (EXIF_LONG)
-// Count = StripsPerImage                    when PlanarConfiguration = 1
-//       = SamplesPerPixel * StripsPerImage  when PlanarConfiguration = 2
-#define _ID_STRIP_OFFSETS                   0x0111
-#define EXIFTAGID_STRIP_OFFSETS             CONSTRUCT_TAGID(STRIP_OFFSETS, _ID_STRIP_OFFSETS)
-#define EXIFTAGTYPE_STRIP_OFFSETS           EXIF_LONG
-// Orientation of image
-// Use EXIFTAGTYPE_ORIENTATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_ORIENTATION                     0x0112
-#define EXIFTAGID_ORIENTATION               CONSTRUCT_TAGID(ORIENTATION, _ID_ORIENTATION)
-#define EXIFTAGTYPE_ORIENTATION             EXIF_SHORT
-// Number of components
-// Use EXIFTAGTYPE_SAMPLES_PER_PIXEL as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SAMPLES_PER_PIXEL               0x0115
-#define EXIFTAGID_SAMPLES_PER_PIXEL         CONSTRUCT_TAGID(SAMPLES_PER_PIXEL, _ID_SAMPLES_PER_PIXEL)
-#define EXIFTAGTYPE_SAMPLES_PER_PIXEL       EXIF_SHORT
-// Number of rows per strip
-// Use EXIFTAGTYPE_ROWS_PER_STRIP as the exif_tag_type (EXIF_LONG)
-// Count should be 1
-#define _ID_ROWS_PER_STRIP                  0x0116
-#define EXIFTAGID_ROWS_PER_STRIP            CONSTRUCT_TAGID(ROWS_PER_STRIP, _ID_ROWS_PER_STRIP)
-#define EXIFTAGTYPE_ROWS_PER_STRIP          EXIF_LONG
-// Bytes per compressed strip
-// Use EXIFTAGTYPE_STRIP_BYTE_COUNTS as the exif_tag_type (EXIF_LONG)
-// Count = StripsPerImage                    when PlanarConfiguration = 1
-//       = SamplesPerPixel * StripsPerImage  when PlanarConfiguration = 2
-#define _ID_STRIP_BYTE_COUNTS               0x0117
-#define EXIFTAGID_STRIP_BYTE_COUNTS         CONSTRUCT_TAGID(STRIP_BYTE_COUNTS, _ID_STRIP_BYTE_COUNTS)
-#define EXIFTAGTYPE_STRIP_BYTE_COUNTS       EXIF_LONG
-// MinSampleValue
-// Use EXIFTAGTYPE_MIN_SAMPLE_VALUE as the exif_tag_type (EXIF_SHORT)
-#define _ID_MIN_SAMPLE_VALUE                0x0118
-#define EXIFTAGID_MIN_SAMPLE_VALUE          CONSTRUCT_TAGID(MIN_SAMPLE_VALUE, _ID_MIN_SAMPLE_VALUE)
-#define EXIFTAGTYPE_MIN_SAMPLE_VALUE        EXIF_SHORT
-// MaxSampleValue
-// Use EXIFTAGTYPE_MAX_SAMPLE_VALUE as the exif_tag_type (EXIF_SHORT)
-#define _ID_MAX_SAMPLE_VALUE                0x0119
-#define EXIFTAGID_MAX_SAMPLE_VALUE          CONSTRUCT_TAGID(MAX_SAMPLE_VALUE, _ID_MAX_SAMPLE_VALUE)
-#define EXIFTAGTYPE_MAX_SAMPLE_VALUE        EXIF_SHORT
-
-// Image resolution in width direction
-// Use EXIFTAGTYPE_X_RESOLUTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_X_RESOLUTION                    0x011a
-#define EXIFTAGID_X_RESOLUTION              CONSTRUCT_TAGID(X_RESOLUTION, _ID_X_RESOLUTION)
-#define EXIFTAGTYPE_X_RESOLUTION            EXIF_RATIONAL
-// Image resolution in height direction
-// Use EXIFTAGTYPE_Y_RESOLUTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_Y_RESOLUTION                    0x011b
-#define EXIFTAGID_Y_RESOLUTION              CONSTRUCT_TAGID(Y_RESOLUTION, _ID_Y_RESOLUTION)
-#define EXIFTAGTYPE_Y_RESOLUTION            EXIF_RATIONAL
-// Image data arrangement
-// Use EXIFTAGTYPE_PLANAR_CONFIGURATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_PLANAR_CONFIGURATION            0x011c
-#define EXIFTAGID_PLANAR_CONFIGURATION      CONSTRUCT_TAGID(PLANAR_CONFIGURATION, _ID_PLANAR_CONFIGURATION)
-#define EXIFTAGTYPE_PLANAR_CONFIGURATION    EXIF_SHORT
-// PageName
-// Use EXIFTAGTYPE_PAGE_NAME as the exif_tag_type (EXIF_ASCII)
-// Count should be 1
-#define _ID_PAGE_NAME                       0x011d
-#define EXIFTAGID_PAGE_NAME                 CONSTRUCT_TAGID(PAGE_NAME, _ID_PAGE_NAME)
-#define EXIFTAGTYPE_PAGE_NAME               EXIF_ASCII
-// XPosition
-// Use EXIFTAGTYPE_X_POSITION as the exif_tag_type (EXIF_RATIONAL)
-//
-#define _ID_X_POSITION                      0x011e
-#define EXIFTAGID_X_POSITION                CONSTRUCT_TAGID(X_POSITION, _ID_X_POSITION)
-#define EXIFTAGTYPE_X_POSITION              EXIF_RATIONAL
-// YPosition
-// Use EXIFTAGTYPE_Y_POSITION as the exif_tag_type (EXIF_RATIONAL)
-//
-#define _ID_Y_POSITION                      0x011f
-#define EXIFTAGID_Y_POSITION                CONSTRUCT_TAGID(Y_POSITION, _ID_Y_POSITION)
-#define EXIFTAGTYPE_Y_POSITION              EXIF_RATIONAL
-
-// FREE_OFFSET
-// Use EXIFTAGTYPE_FREE_OFFSET as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_FREE_OFFSET                     0x0120
-#define EXIFTAGID_FREE_OFFSET               CONSTRUCT_TAGID(FREE_OFFSET, _ID_FREE_OFFSET)
-#define EXIFTAGTYPE_FREE_OFFSET             EXIF_LONG
-// FREE_BYTE_COUNTS
-// Use EXIFTAGTYPE_FREE_BYTE_COUNTS as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_FREE_BYTE_COUNTS                0x0121
-#define EXIFTAGID_FREE_BYTE_COUNTS          CONSTRUCT_TAGID(FREE_BYTE_COUNTS, _ID_FREE_BYTE_COUNTS)
-#define EXIFTAGTYPE_FREE_BYTE_COUNTS        EXIF_LONG
-
-// GrayResponseUnit
-// Use EXIFTAGTYPE_GRAY_RESPONSE_UNIT as the exif_tag_type (EXIF_SHORT)
-//
-#define _ID_GRAY_RESPONSE_UNIT              0x0122
-#define EXIFTAGID_GRAY_RESPONSE_UNIT        CONSTRUCT_TAGID(GRAY_RESPONSE_UNIT, _ID_GRAY_RESPONSE_UNIT)
-#define EXIFTAGTYPE_GRAY_RESPONSE_UNIT      EXIF_SHORT
-// GrayResponseCurve
-// Use EXIFTAGTYPE_GRAY_RESPONSE_CURVE  as the exif_tag_type (EXIF_SHORT)
-//
-#define _ID_GRAY_RESPONSE_CURVE             0x0123
-#define EXIFTAGID_GRAY_RESPONSE_CURVE       CONSTRUCT_TAGID(GRAY_RESPONSE_CURVE , _ID_GRAY_RESPONSE_CURVE )
-#define EXIFTAGTYPE_GRAY_RESPONSE_CURVE     EXIF_SHORT
-
-// T4_OPTION
-// Use EXIFTAGTYPE_T4_OPTION as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_T4_OPTION                       0x0124
-#define EXIFTAGID_T4_OPTION                 CONSTRUCT_TAGID(T4_OPTION, _ID_T4_OPTION)
-#define EXIFTAGTYPE_T4_OPTION               EXIF_LONG
-// T6_OPTION
-// Use EXIFTAGTYPE_T6_OPTION as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_T6_OPTION                       0x0125
-#define EXIFTAGID_T6_OPTION                 CONSTRUCT_TAGID(T6_OPTION, _ID_T6_OPTION)
-#define EXIFTAGTYPE_T6_OPTION               EXIF_LONG
-
-// Unit of X and Y resolution
-// Use EXIFTAGTYPE_RESOLUTION_UNIT as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_RESOLUTION_UNIT                 0x0128
-#define EXIFTAGID_RESOLUTION_UNIT           CONSTRUCT_TAGID(RESOLUTION_UNIT, _ID_RESOLUTION_UNIT)
-#define EXIFTAGTYPE_RESOLUTION_UNIT         EXIF_SHORT
-
-// Page Number
-// Use EXIFTAGTYPE_PAGE_NUMBER  as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_PAGE_NUMBER                     0x0129
-#define EXIFTAGID_PAGE_NUMBER               CONSTRUCT_TAGID(PAGE_NUMBER, _ID_PAGE_NUMBER)
-#define EXIFTAGTYPE_PAGE_NUMBER             EXIF_SHORT
-// Transfer function
-// Use EXIFTAGTYPE_TRANSFER_FUNCTION as the exif_tag_type (EXIF_SHORT)
-// Count should be 3*256
-#define _ID_TRANSFER_FUNCTION               0x012d
-#define EXIFTAGID_TRANSFER_FUNCTION         CONSTRUCT_TAGID(TRANSFER_FUNCTION, _ID_TRANSFER_FUNCTION)
-#define EXIFTAGTYPE_TRANSFER_FUNCTION       EXIF_SHORT
-// Software used
-// Use EXIFTAGTYPE_SOFTWARE as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_SOFTWARE                        0x0131
-#define EXIFTAGID_SOFTWARE                  CONSTRUCT_TAGID(SOFTWARE, _ID_SOFTWARE)
-#define EXIFTAGTYPE_SOFTWARE                EXIF_ASCII
-// File change date and time
-// Use EXIFTAGTYPE_DATE_TIME as the exif_tag_type (EXIF_ASCII)
-// Count should be 20
-#define _ID_DATE_TIME                       0x0132
-#define EXIFTAGID_DATE_TIME                 CONSTRUCT_TAGID(DATE_TIME, _ID_DATE_TIME)
-#define EXIFTAGTYPE_DATE_TIME               EXIF_ASCII
-// ARTIST, person who created this image
-// Use EXIFTAGTYPE_ARTIST as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_ARTIST                          0x013b
-#define EXIFTAGID_ARTIST                    CONSTRUCT_TAGID(ARTIST, _ID_ARTIST)
-#define EXIFTAGTYPE_ARTIST                  EXIF_ASCII
-// Host Computer Name
-// Use EXIFTAGTYPE_HOST_COMPUTER as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_HOST_COMPUTER                   0x013c
-#define EXIFTAGID_HOST_COMPUTER             CONSTRUCT_TAGID(HOST_COMPUTER , _ID_HOST_COMPUTER )
-#define EXIFTAGTYPE_HOST_COMPUTER           EXIF_ASCII
-// Predictor
-// Use EXIFTAGTYPE_PREDICTOR as the exif_tag_type (EXIF_SHORT)
-// Count can be any
-#define _ID_PREDICTOR                       0x013d
-#define EXIFTAGID_PREDICTOR                 CONSTRUCT_TAGID(PREDICTOR , _ID_PREDICTOR )
-#define EXIFTAGTYPE_PREDICTOR               EXIF_SHORT
-// White point chromaticity
-// Use EXIFTAGTYPE_WHITE_POINT as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 2
-#define _ID_WHITE_POINT                     0x013e
-#define EXIFTAGID_WHITE_POINT               CONSTRUCT_TAGID(WHITE_POINT, _ID_WHITE_POINT)
-#define EXIFTAGTYPE_WHITE_POINT             EXIF_RATIONAL
-// Chromaticities of primaries
-// Use EXIFTAGTYPE_PRIMARY_CHROMATICITIES as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_PRIMARY_CHROMATICITIES                    0x013f
-#define EXIFTAGID_PRIMARY_CHROMATICITIES              CONSTRUCT_TAGID(PRIMARY_CHROMATICITIES, _ID_PRIMARY_CHROMATICITIES)
-#define EXIFTAGTYPE_PRIMARY_CHROMATICITIES            EXIF_RATIONAL
-
-// COLOR_MAP
-// Use EXIFTAGTYPE_COLOR_MAP as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_COLOR_MAP                       0x0140
-#define EXIFTAGID_COLOR_MAP                 CONSTRUCT_TAGID(COLOR_MAP, _ID_COLOR_MAP)
-#define EXIFTAGTYPE_COLOR_MAP               EXIF_SHORT
-// HALFTONE_HINTS
-// Use EXIFTAGTYPE_HALFTONE_HINTS as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_HALFTONE_HINTS                  0x0141
-#define EXIFTAGID_HALFTONE_HINTS            CONSTRUCT_TAGID(HALFTONE_HINTS, _ID_HALFTONE_HINTS)
-#define EXIFTAGTYPE_HALFTONE_HINTS          EXIF_SHORT
-
-// TILE_WIDTH
-// Use EXIFTAGTYPE_TILE_WIDTH as the exif_tag_type (EXIF_LONG)
-// Count should be 6
-#define _ID_TILE_WIDTH                      0x0142
-#define EXIFTAGID_TILE_WIDTH                CONSTRUCT_TAGID(TILE_WIDTH, _ID_TILE_WIDTH)
-#define EXIFTAGTYPE_TILE_WIDTH              EXIF_LONG
-// TILE_LENGTH
-// Use EXIFTAGTYPE_TILE_LENGTH  as the exif_tag_type (EXIF_LONG)
-// Count should be 6
-#define _ID_TILE_LENGTH                     0x0143
-#define EXIFTAGID_TILE_LENGTH               CONSTRUCT_TAGID(TILE_LENGTH , _ID_TILE_LENGTH )
-#define EXIFTAGTYPE_TILE_LENGTH             EXIF_LONG
-// TILE_OFFSET
-// Use EXIFTAGTYPE_TILE_OFFSET as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_TILE_OFFSET                     0x0144
-#define EXIFTAGID_TILE_OFFSET               CONSTRUCT_TAGID(TILE_OFFSET , _ID_TILE_OFFSET )
-#define EXIFTAGTYPE_TILE_OFFSET             EXIF_LONG
-// tile Byte Counts
-// Use EXIFTAGTYPE_TILE_OFFSET as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_TILE_BYTE_COUNTS                0x0145
-#define EXIFTAGID_TILE_BYTE_COUNTS          CONSTRUCT_TAGID(TILE_BYTE_COUNTS  , _ID_TILE_BYTE_COUNTS  )
-#define EXIFTAGTYPE_TILE_BYTE_COUNTS        EXIF_LONG
-
-// INK_SET
-// Use EXIFTAGTYPE_TILE_LENGTH  as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_INK_SET                         0x014c
-#define EXIFTAGID_INK_SET                   CONSTRUCT_TAGID(INK_SET , _ID_INK_SET )
-#define EXIFTAGTYPE_INK_SET                 EXIF_SHORT
-// INK_NAMES
-// Use EXIFTAGTYPE_INK_NAMES  as the exif_tag_type (EXIF_ASCII)
-// Count should be 6
-#define _ID_INK_NAMES                       0x014D
-#define EXIFTAGID_INK_NAMES                 CONSTRUCT_TAGID(INK_NAMES , _ID_INK_NAMES)
-#define EXIFTAGTYPE_INK_NAMES               EXIF_ASCII
-// NUMBER_OF_INKS
-// Use EXIFTAGTYPE_NUMBER_OF_INKS  as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_NUMBER_OF_INKS                  0x014e
-#define EXIFTAGID_NUMBER_OF_INKS            CONSTRUCT_TAGID(NUMBER_OF_INKS , _ID_NUMBER_OF_INKS )
-#define EXIFTAGTYPE_NUMBER_OF_INKS          EXIF_SHORT
-
-// DOT_RANGE
-// Use EXIFTAGTYPE_DOT_RANGE  as the exif_tag_type (EXIF_ASCII)
-// Count should be 6
-#define _ID_DOT_RANGE                       0x0150
-#define EXIFTAGID_DOT_RANGE                 CONSTRUCT_TAGID(DOT_RANGE , _ID_DOT_RANGE )
-#define EXIFTAGTYPE_DOT_RANGE               EXIF_ASCII
-
-// TARGET_PRINTER
-// Use EXIFTAGTYPE_TARGET_PRINTER  as the exif_tag_type (EXIF_ASCII)
-// Count should be 6
-#define _ID_TARGET_PRINTER                  0x0151
-#define EXIFTAGID_TARGET_PRINTER            CONSTRUCT_TAGID(TARGET_PRINTER , _ID_TARGET_PRINTER)
-#define EXIFTAGTYPE_TARGET_PRINTER          EXIF_ASCII
-// EXTRA_SAMPLES
-// Use EXIFTAGTYPE_EXTRA_SAMPLES as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_EXTRA_SAMPLES                   0x0152
-#define EXIFTAGID_EXTRA_SAMPLES             CONSTRUCT_TAGID(EXTRA_SAMPLES , _ID_EXTRA_SAMPLES )
-#define EXIFTAGTYPE_EXTRA_SAMPLES           EXIF_SHORT
-
-// SAMPLE_FORMAT
-// Use EXIFTAGTYPE_SAMPLE_FORMAT  as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_SAMPLE_FORMAT                   0x0153
-#define EXIFTAGID_SAMPLE_FORMAT             CONSTRUCT_TAGID(SAMPLE_FORMAT , _ID_SAMPLE_FORMAT )
-#define EXIFTAGTYPE_SAMPLE_FORMAT           EXIF_SHORT
-
-// Table of values that extends the range of the transfer function.
-// Use EXIFTAGTYPE_TRANSFER_RANGE as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_TRANSFER_RANGE                  0x0156
-#define EXIFTAGID_TRANSFER_RANGE            CONSTRUCT_TAGID(TRANSFER_RANGE , _ID_TRANSFER_RANGE )
-#define EXIFTAGTYPE_TRANSFER_RANGE          EXIF_SHORT
-
-// JPEG compression process.
-// Use EXIFTAGTYPE_JPEG_PROC as the exif_tag_type (EXIF_SHORT)
-//
-#define _ID_JPEG_PROC                       0x0200
-#define EXIFTAGID_JPEG_PROC                 CONSTRUCT_TAGID(JPEG_PROC , _ID_JPEG_PROC )
-#define EXIFTAGTYPE_JPEG_PROC               EXIF_SHORT
-
-
-// Offset to JPEG SOI
-// Use EXIFTAGTYPE_JPEG_INTERCHANGE_FORMAT as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_INTERCHANGE_FORMAT                   0x0201
-#define EXIFTAGID_JPEG_INTERCHANGE_FORMAT             CONSTRUCT_TAGID(JPEG_INTERCHANGE_FORMAT, _ID_JPEG_INTERCHANGE_FORMAT)
-#define EXIFTAGTYPE_JPEG_INTERCHANGE_FORMAT           EXIF_LONG
-// Bytes of JPEG data
-// Use EXIFTAGTYPE_JPEG_INTERCHANGE_FORMAT_LENGTH as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_INTERCHANGE_FORMAT_LENGTH            0x0202
-#define EXIFTAGID_JPEG_INTERCHANGE_FORMAT_LENGTH      CONSTRUCT_TAGID(JPEG_INTERCHANGE_FORMAT_LENGTH, _ID_JPEG_INTERCHANGE_FORMAT_LENGTH)
-#define EXIFTAGTYPE_JPEG_INTERCHANGE_FORMAT_LENGTH    EXIF_LONG
-
-// Length of the restart interval.
-// Use EXIFTAGTYPE_JPEG_RESTART_INTERVAL as the exif_tag_type (EXIF_SHORT)
-// Count is undefined
-#define _ID_JPEG_RESTART_INTERVAL           0x0203
-#define EXIFTAGID_JPEG_RESTART_INTERVAL     CONSTRUCT_TAGID(JPEG_RESTART_INTERVAL, _ID_JPEG_RESTART_INTERVAL)
-#define EXIFTAGTYPE_JPEG_RESTART_INTERVAL   EXIF_SHORT
-
-// JPEGLosslessPredictors
-// Use EXIFTAGTYPE_JPEG_LOSSLESS_PREDICTORS as the exif_tag_type (EXIF_SHORT)
-// Count is undefined
-#define _ID_JPEG_LOSSLESS_PREDICTORS                  0x0205
-#define EXIFTAGID_JPEG_LOSSLESS_PREDICTORS            CONSTRUCT_TAGID(JPEG_LOSSLESS_PREDICTORS, _ID_JPEG_LOSSLESS_PREDICTORS)
-#define EXIFTAGTYPE_JPEG_LOSSLESS_PREDICTORS          EXIF_SHORT
-
-// JPEGPointTransforms
-// Use EXIFTAGTYPE_JPEG_POINT_TRANSFORMS as the exif_tag_type (EXIF_SHORT)
-// Count is undefined
-#define _ID_JPEG_POINT_TRANSFORMS           0x0206
-#define EXIFTAGID_JPEG_POINT_TRANSFORMS     CONSTRUCT_TAGID(JPEG_POINT_TRANSFORMS, _ID_JPEG_POINT_TRANSFORMS)
-#define EXIFTAGTYPE_JPEG_POINT_TRANSFORMS   EXIF_SHORT
-
-// JPEG_Q_TABLES
-// Use EXIFTAGTYPE_JPEG_Q_TABLES as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_Q_TABLES                   0x0207
-#define EXIFTAGID_JPEG_Q_TABLES             CONSTRUCT_TAGID(JPEG_Q_TABLES, _ID_JPEG_Q_TABLES)
-#define EXIFTAGTYPE_JPEG_Q_TABLES           EXIF_LONG
-// JPEG_DC_TABLES
-// Use EXIFTAGTYPE_JPEG_DC_TABLES as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_DC_TABLES                  0x0208
-#define EXIFTAGID_JPEG_DC_TABLES            CONSTRUCT_TAGID(JPEG_DC_TABLES, _ID_JPEG_DC_TABLES)
-#define EXIFTAGTYPE_JPEG_DC_TABLES          EXIF_LONG
-// JPEG_AC_TABLES
-// Use EXIFTAGTYPE_JPEG_AC_TABLES as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_AC_TABLES                  0x0209
-#define EXIFTAGID_JPEG_AC_TABLES            CONSTRUCT_TAGID(JPEG_AC_TABLES, _ID_JPEG_AC_TABLES)
-#define EXIFTAGTYPE_JPEG_AC_TABLES          EXIF_LONG
-
-// Color space transformation matrix coefficients
-// Use EXIFTAGTYPE_YCBCR_COEFFICIENTS as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_YCBCR_COEFFICIENTS              0x0211
-#define EXIFTAGID_YCBCR_COEFFICIENTS        CONSTRUCT_TAGID(YCBCR_COEFFICIENTS, _ID_YCBCR_COEFFICIENTS)
-#define EXIFTAGTYPE_YCBCR_COEFFICIENTS      EXIF_RATIONAL
-// Subsampling ratio of Y to C
-// Use EXIFTAGTYPE_YCBCR_SUB_SAMPLING as the exif_tag_type (EXIF_SHORT)
-// Count should be 2
-#define _ID_YCBCR_SUB_SAMPLING              0x0212
-#define EXIFTAGID_YCBCR_SUB_SAMPLING        CONSTRUCT_TAGID(YCBCR_SUB_SAMPLING, _ID_YCBCR_SUB_SAMPLING)
-#define EXIFTAGTYPE_YCBCR_SUB_SAMPLING      EXIF_SHORT
-// Y and C positioning
-// Use EXIFTAGTYPE_YCBCR_POSITIONING as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_YCBCR_POSITIONING               0x0213
-#define EXIFTAGID_YCBCR_POSITIONING         CONSTRUCT_TAGID(YCBCR_POSITIONING, _ID_YCBCR_POSITIONING)
-#define EXIFTAGTYPE_YCBCR_POSITIONING       EXIF_SHORT
-// Pair of black and white reference values
-// Use EXIFTAGTYPE_REFERENCE_BLACK_WHITE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_REFERENCE_BLACK_WHITE           0x0214
-#define EXIFTAGID_REFERENCE_BLACK_WHITE     CONSTRUCT_TAGID(REFERENCE_BLACK_WHITE, _ID_REFERENCE_BLACK_WHITE)
-#define EXIFTAGTYPE_REFERENCE_BLACK_WHITE   EXIF_RATIONAL
-// GAMMA
-// Use EXIFTAGTYPE_GAMMA as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_GAMMA                           0x0301
-#define EXIFTAGID_GAMMA                     CONSTRUCT_TAGID(GAMMA, _ID_GAMMA)
-#define EXIFTAGTYPE_GAMMA                   EXIF_RATIONAL
-// Null-terminated character string that identifies an ICC profile.
-// Use EXIFTAGTYPE_ICC_PROFILE_DESCRIPTOR as the exif_tag_type (EXIF_ASCII)
-// Count should be 6
-#define _ID_ICC_PROFILE_DESCRIPTOR          0x0302
-#define EXIFTAGID_ICC_PROFILE_DESCRIPTOR    CONSTRUCT_TAGID(ICC_PROFILE_DESCRIPTOR, _ID_ICC_PROFILE_DESCRIPTOR)
-#define EXIFTAGTYPE_ICC_PROFILE_DESCRIPTOR  EXIF_ASCII
-// SRGB_RENDERING_INTENT
-// Use EXIFTAGTYPE_SRGB_RENDERING_INTENT as the exif_tag_type (EXIF_BYTE)
-// Count should be 6
-#define _ID_SRGB_RENDERING_INTENT           0x0303
-#define EXIFTAGID_SRGB_RENDERING_INTENT     CONSTRUCT_TAGID(SRGB_RENDERING_INTENT, _ID_SRGB_RENDERING_INTENT)
-#define EXIFTAGTYPE_SRGB_RENDERING_INTENT   EXIF_BYTE
-
-// Null-terminated character string that specifies the title of the image.
-// Use EXIFTAGTYPE_IMAGE_TITLE as the exif_tag_type (EXIF_ASCII		)
-//
-#define _ID_IMAGE_TITLE                     0x0320
-#define EXIFTAGID_IMAGE_TITLE               CONSTRUCT_TAGID(IMAGE_TITLE, _ID_IMAGE_TITLE)
-#define EXIFTAGTYPE_IMAGE_TITLE             EXIF_ASCII
-
-// Copyright holder
-// Use EXIFTAGTYPE_COPYRIGHT as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_COPYRIGHT                       0x8298
-#define EXIFTAGID_COPYRIGHT                 CONSTRUCT_TAGID(COPYRIGHT, _ID_COPYRIGHT)
-#define EXIFTAGTYPE_COPYRIGHT               EXIF_ASCII
-// Old Subfile Type
-// Use EXIFTAGTYPE_NEW_SUBFILE_TYPE as the exif_tag_type (EXIF_SHORT)
-// Count can be any
-#define _ID_NEW_SUBFILE_TYPE                0x00fe
-#define EXIFTAGID_NEW_SUBFILE_TYPE          CONSTRUCT_TAGID(NEW_SUBFILE_TYPE, _ID_NEW_SUBFILE_TYPE)
-#define EXIFTAGTYPE_NEW_SUBFILE_TYPE        EXIF_SHORT
-
-// New Subfile Type
-// Use EXIFTAGTYPE_NEW_SUBFILE_TYPE as the exif_tag_type (EXIF_LONG)
-// Count can be any
-#define _ID_SUBFILE_TYPE                    0x00ff
-#define EXIFTAGID_SUBFILE_TYPE              CONSTRUCT_TAGID(SUBFILE_TYPE, _ID_SUBFILE_TYPE)
-#define EXIFTAGTYPE_SUBFILE_TYPE            EXIF_LONG
-
-// Image width (of thumbnail)
-// Use EXIFTAGTYPE_TN_IMAGE_WIDTH as the exif_tag_type (EXIF_LONG)
-// Count should be 1
-#define _ID_TN_IMAGE_WIDTH                  0x0100
-#define EXIFTAGID_TN_IMAGE_WIDTH            CONSTRUCT_TAGID(TN_IMAGE_WIDTH, _ID_TN_IMAGE_WIDTH)
-#define EXIFTAGTYPE_TN_IMAGE_WIDTH          EXIF_LONG
-// Image height (of thumbnail)
-// Use EXIFTAGTYPE_TN_IMAGE_LENGTH as the exif_tag_type (EXIF_SHORT_OR_LONG)
-// Count should be 1
-#define _ID_TN_IMAGE_LENGTH                 0x0101
-#define EXIFTAGID_TN_IMAGE_LENGTH           CONSTRUCT_TAGID(TN_IMAGE_LENGTH, _ID_TN_IMAGE_LENGTH)
-#define EXIFTAGTYPE_TN_IMAGE_LENGTH         EXIF_LONG
-// Number of bits per component (of thumbnail)
-// Use EXIFTAGTYPE_TN_BITS_PER_SAMPLE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_BITS_PER_SAMPLE              0x0102
-#define EXIFTAGID_TN_BITS_PER_SAMPLE        CONSTRUCT_TAGID(TN_BITS_PER_SAMPLE, _ID_TN_BITS_PER_SAMPLE)
-#define EXIFTAGTYPE_TN_BITS_PER_SAMPLE      EXIF_SHORT
-// Compression scheme (of thumbnail)
-// Use EXIFTAGTYPE_TN_COMPRESSION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_COMPRESSION                  0x0103
-#define EXIFTAGID_TN_COMPRESSION            CONSTRUCT_TAGID(TN_COMPRESSION, _ID_TN_COMPRESSION)
-#define EXIFTAGTYPE_TN_COMPRESSION          EXIF_SHORT
-// Pixel composition (of thumbnail)
-// Use EXIFTAGTYPE_TN_PHOTOMETRIC_INTERPRETATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_PHOTOMETRIC_INTERPRETATION         0x0106
-#define EXIFTAGID_TN_PHOTOMETRIC_INTERPRETATION   CONSTRUCT_TAGID(TN_PHOTOMETRIC_INTERPRETATION, _ID_TN_PHOTOMETRIC_INTERPRETATION)
-#define EXIFTAGTYPE_TN_PHOTOMETRIC_INTERPRETATION EXIF_SHORT
-// Image title (of thumbnail)
-// Use EXIFTAGTYPE_TN_IMAGE_DESCRIPTION as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_IMAGE_DESCRIPTION            0x010e
-#define EXIFTAGID_TN_IMAGE_DESCRIPTION      CONSTRUCT_TAGID(TN_IMAGE_DESCRIPTION, _ID_TN_IMAGE_DESCRIPTION)
-#define EXIFTAGTYPE_TN_IMAGE_DESCRIPTION    EXIF_ASCII
-// Image input equipment manufacturer (of thumbnail)
-// Use EXIFTAGTYPE_TN_MAKE as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_MAKE                         0x010f
-#define EXIFTAGID_TN_MAKE                   CONSTRUCT_TAGID(TN_MAKE, _ID_TN_MAKE)
-#define EXIFTAGTYPE_TN_MAKE                 EXIF_ASCII
-// Image input equipment model (of thumbnail)
-// Use EXIFTAGTYPE_TN_MODEL as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_MODEL                        0x0110
-#define EXIFTAGID_TN_MODEL                  CONSTRUCT_TAGID(TN_MODEL, _ID_TN_MODEL)
-#define EXIFTAGTYPE_TN_MODEL                EXIF_ASCII
-// Image data location (of thumbnail)
-// Use EXIFTAGTYPE_TN_STRIP_OFFSETS as the exif_tag_type (EXIF_LONG)
-// Count = StripsPerImage                    when PlanarConfiguration = 1
-//       = SamplesPerPixel * StripsPerImage  when PlanarConfiguration = 2
-#define _ID_TN_STRIP_OFFSETS                0x0111
-#define EXIFTAGID_TN_STRIP_OFFSETS          CONSTRUCT_TAGID(STRIP_TN_OFFSETS, _ID_TN_STRIP_OFFSETS)
-#define EXIFTAGTYPE_TN_STRIP_OFFSETS        EXIF_LONG
-// Orientation of image (of thumbnail)
-// Use EXIFTAGTYPE_TN_ORIENTATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_ORIENTATION                  0x0112
-#define EXIFTAGID_TN_ORIENTATION            CONSTRUCT_TAGID(TN_ORIENTATION, _ID_TN_ORIENTATION)
-#define EXIFTAGTYPE_TN_ORIENTATION          EXIF_SHORT
-// Number of components (of thumbnail)
-// Use EXIFTAGTYPE_TN_SAMPLES_PER_PIXEL as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_SAMPLES_PER_PIXEL            0x0115
-#define EXIFTAGID_TN_SAMPLES_PER_PIXEL      CONSTRUCT_TAGID(TN_SAMPLES_PER_PIXEL, _ID_TN_SAMPLES_PER_PIXEL)
-#define EXIFTAGTYPE_TN_SAMPLES_PER_PIXEL    EXIF_SHORT
-// Number of rows per strip (of thumbnail)
-// Use EXIFTAGTYPE_TN_ROWS_PER_STRIP as the exif_tag_type (EXIF_LONG)
-// Count should be 1
-#define _ID_TN_ROWS_PER_STRIP               0x0116
-#define EXIFTAGID_TN_ROWS_PER_STRIP         CONSTRUCT_TAGID(TN_ROWS_PER_STRIP, _ID_TN_ROWS_PER_STRIP)
-#define EXIFTAGTYPE_TN_ROWS_PER_STRIP       EXIF_LONG
-// Bytes per compressed strip (of thumbnail)
-// Use EXIFTAGTYPE_TN_STRIP_BYTE_COUNTS as the exif_tag_type (EXIF_LONG)
-// Count = StripsPerImage                    when PlanarConfiguration = 1
-//       = SamplesPerPixel * StripsPerImage  when PlanarConfiguration = 2
-#define _ID_TN_STRIP_BYTE_COUNTS            0x0117
-#define EXIFTAGID_TN_STRIP_BYTE_COUNTS      CONSTRUCT_TAGID(TN_STRIP_BYTE_COUNTS, _ID_TN_STRIP_BYTE_COUNTS)
-#define EXIFTAGTYPE_TN_STRIP_BYTE_COUNTS    EXIF_LONG
-// Image resolution in width direction (of thumbnail)
-// Use EXIFTAGTYPE_TN_X_RESOLUTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_TN_X_RESOLUTION                 0x011a
-#define EXIFTAGID_TN_X_RESOLUTION           CONSTRUCT_TAGID(TN_X_RESOLUTION, _ID_TN_X_RESOLUTION)
-#define EXIFTAGTYPE_TN_X_RESOLUTION         EXIF_RATIONAL
-// Image resolution in height direction  (of thumbnail)
-// Use EXIFTAGTYPE_TN_Y_RESOLUTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_TN_Y_RESOLUTION                 0x011b
-#define EXIFTAGID_TN_Y_RESOLUTION           CONSTRUCT_TAGID(TN_Y_RESOLUTION, _ID_TN_Y_RESOLUTION)
-#define EXIFTAGTYPE_TN_Y_RESOLUTION         EXIF_RATIONAL
-// Image data arrangement (of thumbnail)
-// Use EXIFTAGTYPE_TN_PLANAR_CONFIGURATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_PLANAR_CONFIGURATION         0x011c
-#define EXIFTAGID_TN_PLANAR_CONFIGURATION   CONSTRUCT_TAGID(TN_PLANAR_CONFIGURATION, _ID_TN_PLANAR_CONFIGURATION)
-#define EXIFTAGTYPE_TN_PLANAR_CONFIGURATION EXIF_SHORT
-// Unit of X and Y resolution (of thumbnail)
-// Use EXIFTAGTYPE_TN_RESOLUTION_UNIT as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_RESOLUTION_UNIT              0x128
-#define EXIFTAGID_TN_RESOLUTION_UNIT        CONSTRUCT_TAGID(TN_RESOLUTION_UNIT, _ID_TN_RESOLUTION_UNIT)
-#define EXIFTAGTYPE_TN_RESOLUTION_UNIT      EXIF_SHORT
-// Transfer function (of thumbnail)
-// Use EXIFTAGTYPE_TN_TRANSFER_FUNCTION as the exif_tag_type (EXIF_SHORT)
-// Count should be 3*256
-#define _ID_TN_TRANSFER_FUNCTION            0x012d
-#define EXIFTAGID_TN_TRANSFER_FUNCTION      CONSTRUCT_TAGID(TN_TRANSFER_FUNCTION, _ID_TN_TRANSFER_FUNCTION)
-#define EXIFTAGTYPE_TN_TRANSFER_FUNCTION    EXIF_SHORT
-// Software used (of thumbnail)
-// Use EXIFTAGTYPE_TN_SOFTWARE as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_SOFTWARE                     0x0131
-#define EXIFTAGID_TN_SOFTWARE               CONSTRUCT_TAGID(TN_SOFTWARE, _ID_TN_SOFTWARE)
-#define EXIFTAGTYPE_TN_SOFTWARE             EXIF_ASCII
-// File change date and time (of thumbnail)
-// Use EXIFTAGTYPE_TN_DATE_TIME as the exif_tag_type (EXIF_ASCII)
-// Count should be 20
-#define _ID_TN_DATE_TIME                    0x0132
-#define EXIFTAGID_TN_DATE_TIME              CONSTRUCT_TAGID(TN_DATE_TIME, _ID_TN_DATE_TIME)
-#define EXIFTAGTYPE_TN_DATE_TIME            EXIF_ASCII
-// ARTIST, person who created this image (of thumbnail)
-// Use EXIFTAGTYPE_TN_ARTIST as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_ARTIST                       0x013b
-#define EXIFTAGID_TN_ARTIST                 CONSTRUCT_TAGID(TN_ARTIST, _ID_TN_ARTIST)
-#define EXIFTAGTYPE_TN_ARTIST               EXIF_ASCII
-// White point chromaticity (of thumbnail)
-// Use EXIFTAGTYPE_TN_WHITE_POINT as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 2
-#define _ID_TN_WHITE_POINT                  0x013e
-#define EXIFTAGID_TN_WHITE_POINT            CONSTRUCT_TAGID(TN_WHITE_POINT, _ID_TN_WHITE_POINT)
-#define EXIFTAGTYPE_TN_WHITE_POINT          EXIF_RATIONAL
-// Chromaticities of primaries (of thumbnail)
-// Use EXIFTAGTYPE_TN_PRIMARY_CHROMATICITIES as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_TN_PRIMARY_CHROMATICITIES            0x013f
-#define EXIFTAGID_TN_PRIMARY_CHROMATICITIES      CONSTRUCT_TAGID(TN_PRIMARY_CHROMATICITIES, _ID_TN_PRIMARY_CHROMATICITIES)
-#define EXIFTAGTYPE_TN_PRIMARY_CHROMATICITIES    EXIF_RATIONAL
-// Offset to JPEG SOI (of thumbnail)
-// Use EXIFTAGTYPE_TN_JPEGINTERCHANGE_FORMAT as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_TN_JPEGINTERCHANGE_FORMAT            0x0201
-#define EXIFTAGID_TN_JPEGINTERCHANGE_FORMAT      CONSTRUCT_TAGID(TN_JPEGINTERCHANGE_FORMAT, _ID_TN_JPEGINTERCHANGE_FORMAT)
-#define EXIFTAGTYPE_TN_JPEGINTERCHANGE_FORMAT    EXIF_LONG
-// Bytes of JPEG data (of thumbnail)
-// Use EXIFTAGTYPE_TN_JPEGINTERCHANGE_FORMAT_L as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_TN_JPEGINTERCHANGE_FORMAT_L          0x0202
-#define EXIFTAGID_TN_JPEGINTERCHANGE_FORMAT_L    CONSTRUCT_TAGID(TN_JPEGINTERCHANGE_FORMAT_L, _ID_TN_JPEGINTERCHANGE_FORMAT_L)
-#define EXIFTAGTYPE_TN_JPEGINTERCHANGE_FORMAT_L  EXIF_LONG
-// Color space transformation matrix coefficients (of thumbnail)
-// Use EXIFTAGTYPE_TN_YCBCR_COEFFICIENTS as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_TN_YCBCR_COEFFICIENTS           0x0211
-#define EXIFTAGID_TN_YCBCR_COEFFICIENTS     CONSTRUCT_TAGID(TN_YCBCR_COEFFICIENTS, _ID_TN_YCBCR_COEFFICIENTS)
-#define EXIFTAGTYPE_TN_YCBCR_COEFFICIENTS   EXIF_RATIONAL
-// Subsampling ratio of Y to C (of thumbnail)
-// Use EXIFTAGTYPE_TN_YCBCR_SUB_SAMPLING as the exif_tag_type (EXIF_SHORT)
-// Count should be 2
-#define _ID_TN_YCBCR_SUB_SAMPLING           0x0212
-#define EXIFTAGID_TN_YCBCR_SUB_SAMPLING     CONSTRUCT_TAGID(TN_YCBCR_SUB_SAMPLING, _ID_TN_YCBCR_SUB_SAMPLING)
-#define EXIFTAGTYPE_TN_YCBCR_SUB_SAMPLING   EXIF_SHORT
-// Y and C positioning (of thumbnail)
-// Use EXIFTAGTYPE_TN_YCBCR_POSITIONING as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_YCBCR_POSITIONING            0x0213
-#define EXIFTAGID_TN_YCBCR_POSITIONING      CONSTRUCT_TAGID(TN_YCBCR_POSITIONING, _ID_TN_YCBCR_POSITIONING)
-#define EXIFTAGTYPE_TN_YCBCR_POSITIONING    EXIF_SHORT
-// Pair of black and white reference values (of thumbnail)
-// Use EXIFTAGTYPE_TN_REFERENCE_BLACK_WHITE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_TN_REFERENCE_BLACK_WHITE          0x0214
-#define EXIFTAGID_TN_REFERENCE_BLACK_WHITE    CONSTRUCT_TAGID(TN_REFERENCE_BLACK_WHITE, _ID_TN_REFERENCE_BLACK_WHITE)
-#define EXIFTAGTYPE_TN_REFERENCE_BLACK_WHITE  EXIF_RATIONAL
-// Copyright holder (of thumbnail)
-// Use EXIFTAGTYPE_TN_COPYRIGHT as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_COPYRIGHT                    0x8298
-#define EXIFTAGID_TN_COPYRIGHT              CONSTRUCT_TAGID(TN_COPYRIGHT, _ID_TN_COPYRIGHT)
-#define EXIFTAGTYPE_TN_COPYRIGHT            EXIF_ASCII
-// Exposure time
-// Use EXIFTAGTYPE_EXPOSURE_TIME as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_EXPOSURE_TIME                   0x829a
-#define EXIFTAGID_EXPOSURE_TIME             CONSTRUCT_TAGID(EXPOSURE_TIME, _ID_EXPOSURE_TIME)
-#define EXIFTAGTYPE_EXPOSURE_TIME           EXIF_RATIONAL
-// F number
-// Use EXIFTAGTYPE_F_NUMBER as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_F_NUMBER                        0x829d
-#define EXIFTAGID_F_NUMBER                  CONSTRUCT_TAGID(F_NUMBER, _ID_F_NUMBER)
-#define EXIFTAGTYPE_F_NUMBER                EXIF_RATIONAL
-// Exif IFD pointer (NOT INTENDED to be accessible to user)
-#define _ID_EXIF_IFD_PTR                    0x8769
-#define EXIFTAGID_EXIF_IFD_PTR              CONSTRUCT_TAGID(EXIF_IFD, _ID_EXIF_IFD_PTR)
-#define EXIFTAGTYPE_EXIF_IFD_PTR            EXIF_LONG
-
-// ICC_PROFILE (NOT INTENDED to be accessible to user)
-#define _ID_ICC_PROFILE                     0x8773
-#define EXIFTAGID_ICC_PROFILE               CONSTRUCT_TAGID(ICC_PROFILE, _ID_ICC_PROFILE)
-#define EXIFTAGTYPE_ICC_PROFILE             EXIF_LONG
-// Exposure program
-// Use EXIFTAGTYPE_EXPOSURE_PROGRAM as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXPOSURE_PROGRAM                0x8822
-#define EXIFTAGID_EXPOSURE_PROGRAM          CONSTRUCT_TAGID(EXPOSURE_PROGRAM, _ID_EXPOSURE_PROGRAM)
-#define EXIFTAGTYPE_EXPOSURE_PROGRAM        EXIF_SHORT
-// Spectral sensitivity
-// Use EXIFTAGTYPE_SPECTRAL_SENSITIVITY as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_SPECTRAL_SENSITIVITY            0x8824
-#define EXIFTAGID_SPECTRAL_SENSITIVITY      CONSTRUCT_TAGID(SPECTRAL_SENSITIVITY, _ID_SPECTRAL_SENSITIVITY)
-#define EXIFTAGTYPE_SPECTRAL_SENSITIVITY    EXIF_ASCII
-// GPS IFD pointer (NOT INTENDED to be accessible to user)
-#define _ID_GPS_IFD_PTR                     0x8825
-#define EXIFTAGID_GPS_IFD_PTR               CONSTRUCT_TAGID(GPS_IFD, _ID_GPS_IFD_PTR)
-#define EXIFTAGTYPE_GPS_IFD_PTR             EXIF_LONG
-// ISO Speed Rating
-// Use EXIFTAGTYPE_ISO_SPEED_RATING as the exif_tag_type (EXIF_SHORT)
-// Count can be any
-#define _ID_ISO_SPEED_RATING                0x8827
-#define EXIFTAGID_ISO_SPEED_RATING          CONSTRUCT_TAGID(ISO_SPEED_RATING, _ID_ISO_SPEED_RATING)
-#define EXIFTAGTYPE_ISO_SPEED_RATING        EXIF_SHORT
-// Optoelectric conversion factor
-// Use EXIFTAGTYPE_OECF as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_OECF                            0x8828
-#define EXIFTAGID_OECF                      CONSTRUCT_TAGID(OECF, _ID_OECF)
-#define EXIFTAGTYPE_OECF                    EXIF_UNDEFINED
-// Exif version
-// Use EXIFTAGTYPE_EXIF_VERSION as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 4
-#define _ID_EXIF_VERSION                    0x9000
-#define EXIFTAGID_EXIF_VERSION              CONSTRUCT_TAGID(EXIF_VERSION, _ID_EXIF_VERSION)
-#define EXIFTAGTYPE_EXIF_VERSION            EXIF_UNDEFINED
-// Date and time of original data gerneration
-// Use EXIFTAGTYPE_EXIF_DATE_TIME_ORIGINAL as the exif_tag_type (EXIF_ASCII)
-// It should be 20 characters long including the null-terminating character.
-#define _ID_EXIF_DATE_TIME_ORIGINAL          0x9003
-#define EXIFTAGID_EXIF_DATE_TIME_ORIGINAL    CONSTRUCT_TAGID(EXIF_DATE_TIME_ORIGINAL, _ID_EXIF_DATE_TIME_ORIGINAL)
-#define EXIFTAGTYPE_EXIF_DATE_TIME_ORIGINAL  EXIF_ASCII
-// Date and time of digital data generation
-// Use EXIFTAGTYPE_EXIF_DATE_TIME_DIGITIZED as the exif_tag_type (EXIF_ASCII)
-// It should be 20 characters long including the null-terminating character.
-#define _ID_EXIF_DATE_TIME_DIGITIZED         0x9004
-#define EXIFTAGID_EXIF_DATE_TIME_DIGITIZED   CONSTRUCT_TAGID(EXIF_DATE_TIME_DIGITIZED, _ID_EXIF_DATE_TIME_DIGITIZED)
-#define EXIFTAGTYPE_EXIF_DATE_TIME_DIGITIZED EXIF_ASCII
-// Meaning of each component
-// Use EXIFTAGTYPE_EXIF_COMPONENTS_CONFIG as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 4
-#define _ID_EXIF_COMPONENTS_CONFIG          0x9101
-#define EXIFTAGID_EXIF_COMPONENTS_CONFIG    CONSTRUCT_TAGID(EXIF_COMPONENTS_CONFIG, _ID_EXIF_COMPONENTS_CONFIG)
-#define EXIFTAGTYPE_EXIF_COMPONENTS_CONFIG  EXIF_UNDEFINED
-// Meaning of Image compression mode
-// Use EXIFTAGTYPE_EXIF_COMPRESSED_BITS_PER_PIXEL as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_EXIF_COMPRESSED_BITS_PER_PIXEL  0x9102
-#define EXIFTAGID_EXIF_COMPRESSED_BITS_PER_PIXEL    CONSTRUCT_TAGID(EXIF_COMPRESSED_BITS_PER_PIXEL, _ID_EXIF_COMPRESSED_BITS_PER_PIXEL)
-#define EXIFTAGTYPE_EXIF_COMPRESSED_BITS_PER_PIXEL  EXIF_RATIONAL
-// Shutter speed
-// Use EXIFTAGTYPE_SHUTTER_SPEED as the exif_tag_type (EXIF_SRATIONAL)
-// Count should be 1
-#define _ID_SHUTTER_SPEED                   0x9201
-#define EXIFTAGID_SHUTTER_SPEED             CONSTRUCT_TAGID(SHUTTER_SPEED, _ID_SHUTTER_SPEED)
-#define EXIFTAGTYPE_SHUTTER_SPEED           EXIF_SRATIONAL
-// Aperture
-// Use EXIFTAGTYPE_APERTURE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_APERTURE                        0x9202
-#define EXIFTAGID_APERTURE                  CONSTRUCT_TAGID(APERTURE, _ID_APERTURE)
-#define EXIFTAGTYPE_APERTURE                EXIF_RATIONAL
-// Brigthness
-// Use EXIFTAGTYPE_BRIGHTNESS as the exif_tag_type (EXIF_SRATIONAL)
-// Count should be 1
-#define _ID_BRIGHTNESS                      0x9203
-#define EXIFTAGID_BRIGHTNESS                CONSTRUCT_TAGID(BRIGHTNESS, _ID_BRIGHTNESS)
-#define EXIFTAGTYPE_BRIGHTNESS              EXIF_SRATIONAL
-// Exposure bias
-// Use EXIFTAGTYPE_EXPOSURE_BIAS_VALUE as the exif_tag_type (EXIF_SRATIONAL)
-// Count should be 1
-#define _ID_EXPOSURE_BIAS_VALUE             0x9204
-#define EXIFTAGID_EXPOSURE_BIAS_VALUE       CONSTRUCT_TAGID(EXPOSURE_BIAS_VALUE, _ID_EXPOSURE_BIAS_VALUE)
-#define EXIFTAGTYPE_EXPOSURE_BIAS_VALUE     EXIF_SRATIONAL
-// Maximum lens aperture
-// Use EXIFTAGTYPE_MAX_APERTURE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_MAX_APERTURE                    0x9205
-#define EXIFTAGID_MAX_APERTURE              CONSTRUCT_TAGID(MAX_APERTURE, _ID_MAX_APERTURE)
-#define EXIFTAGTYPE_MAX_APERTURE            EXIF_RATIONAL
-// Subject distance
-// Use EXIFTAGTYPE_SUBJECT_DISTANCE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_SUBJECT_DISTANCE                0x9206
-#define EXIFTAGID_SUBJECT_DISTANCE          CONSTRUCT_TAGID(SUBJECT_DISTANCE, _ID_SUBJECT_DISTANCE)
-#define EXIFTAGTYPE_SUBJECT_DISTANCE        EXIF_RATIONAL
-// Metering mode
-// Use EXIFTAGTYPE_METERING_MODE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_METERING_MODE                   0x9207
-#define EXIFTAGID_METERING_MODE             CONSTRUCT_TAGID(METERING_MODE, _ID_METERING_MODE)
-#define EXIFTAGTYPE_METERING_MODE           EXIF_SHORT
-// Light source
-// Use EXIFTAGTYPE_LIGHT_SOURCE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_LIGHT_SOURCE                    0x9208
-#define EXIFTAGID_LIGHT_SOURCE              CONSTRUCT_TAGID(LIGHT_SOURCE, _ID_LIGHT_SOURCE)
-#define EXIFTAGTYPE_LIGHT_SOURCE            EXIF_SHORT
-// Flash
-// Use EXIFTAGTYPE_FLASH as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_FLASH                           0x9209
-#define EXIFTAGID_FLASH                     CONSTRUCT_TAGID(FLASH, _ID_FLASH)
-#define EXIFTAGTYPE_FLASH                   EXIF_SHORT
-// Lens focal length
-// Use EXIFTAGTYPE_FOCAL_LENGTH as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_FOCAL_LENGTH                    0x920a
-#define EXIFTAGID_FOCAL_LENGTH              CONSTRUCT_TAGID(FOCAL_LENGTH, _ID_FOCAL_LENGTH)
-#define EXIFTAGTYPE_FOCAL_LENGTH            EXIF_RATIONAL
-// Subject area
-// Use EXIFTAGTYPE_SUBJECT_AREA as exif_tag_type (EXIF_SHORT)
-// Count should be 2 or 3 or 4
-#define _ID_SUBJECT_AREA                    0x9214
-#define EXIFTAGID_SUBJECT_AREA              CONSTRUCT_TAGID(SUBJECT_AREA, _ID_SUBJECT_AREA)
-#define EXIFTAGTYPE_SUBJECT_AREA            EXIF_SHORT
-// Maker note
-// Use EXIFTAGTYPE_EXIF_MAKER_NOTE as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_EXIF_MAKER_NOTE                 0x927c
-#define EXIFTAGID_EXIF_MAKER_NOTE           CONSTRUCT_TAGID(EXIF_MAKER_NOTE, _ID_EXIF_MAKER_NOTE)
-#define EXIFTAGTYPE_EXIF_MAKER_NOTE         EXIF_UNDEFINED
-// User comments
-// Use EXIFTAGTYPE_EXIF_USER_COMMENT as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_EXIF_USER_COMMENT               0x9286
-#define EXIFTAGID_EXIF_USER_COMMENT         CONSTRUCT_TAGID(EXIF_USER_COMMENT, _ID_EXIF_USER_COMMENT)
-#define EXIFTAGTYPE_EXIF_USER_COMMENT       EXIF_UNDEFINED
-// Date time sub-seconds
-// Use EXIFTAGTYPE_SUBSEC_TIME as the exif_tag_type (EXIF_ASCII)
-// Count could be any
-#define _ID_SUBSEC_TIME                     0x9290
-#define EXIFTAGID_SUBSEC_TIME               CONSTRUCT_TAGID(SUBSEC_TIME, _ID_SUBSEC_TIME)
-#define EXIFTAGTYPE_SEBSEC_TIME             EXIF_ASCII
-// Date time original sub-seconds
-// use EXIFTAGTYPE_SUBSEC_TIME_ORIGINAL as the exif_tag_type (EXIF_ASCII)
-// Count could be any
-#define _ID_SUBSEC_TIME_ORIGINAL            0x9291
-#define EXIFTAGID_SUBSEC_TIME_ORIGINAL      CONSTRUCT_TAGID(SUBSEC_TIME_ORIGINAL, _ID_SUBSEC_TIME_ORIGINAL)
-#define EXIFTAGTYPE_SUBSEC_TIME_ORIGINAL    EXIF_ASCII
-// Date time digitized sub-seconds
-// use EXIFTAGTYPE_SUBSEC_TIME_DIGITIZED as the exif_tag_type (EXIF_ASCII)
-// Count could be any
-#define _ID_SUBSEC_TIME_DIGITIZED           0x9292
-#define EXIFTAGID_SUBSEC_TIME_DIGITIZED     CONSTRUCT_TAGID(SUBSEC_TIME_DIGITIZED, _ID_SUBSEC_TIME_DIGITIZED)
-#define EXIFTAGTYPE_SUBSEC_TIME_DIGITIZED   EXIF_ASCII
-// Supported Flashpix version
-// Use EXIFTAGTYPE_EXIF_FLASHPIX_VERSION as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 4
-#define _ID_EXIF_FLASHPIX_VERSION           0xa000
-#define EXIFTAGID_EXIF_FLASHPIX_VERSION     CONSTRUCT_TAGID(EXIF_FLASHPIX_VERSION, _ID_EXIF_FLASHPIX_VERSION)
-#define EXIFTAGTYPE_EXIF_FLASHPIX_VERSION   EXIF_UNDEFINED
-//  Color space information
-// Use EXIFTAGTYPE_EXIF_COLOR_SPACE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXIF_COLOR_SPACE                0xa001
-#define EXIFTAGID_EXIF_COLOR_SPACE          CONSTRUCT_TAGID(EXIF_COLOR_SPACE, _ID_EXIF_COLOR_SPACE)
-#define EXIFTAGTYPE_EXIF_COLOR_SPACE        EXIF_SHORT
-//  Valid image width
-// Use EXIFTAGTYPE_EXIF_PIXEL_X_DIMENSION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXIF_PIXEL_X_DIMENSION          0xa002
-#define EXIFTAGID_EXIF_PIXEL_X_DIMENSION    CONSTRUCT_TAGID(EXIF_PIXEL_X_DIMENSION, _ID_EXIF_PIXEL_X_DIMENSION)
-#define EXIFTAGTYPE_EXIF_PIXEL_X_DIMENSION  EXIF_SHORT
-// Valid image height
-// Use EXIFTAGTYPE_EXIF_PIXEL_Y_DIMENSION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXIF_PIXEL_Y_DIMENSION          0xa003
-#define EXIFTAGID_EXIF_PIXEL_Y_DIMENSION    CONSTRUCT_TAGID(EXIF_PIXEL_Y_DIMENSION, _ID_EXIF_PIXEL_Y_DIMENSION)
-#define EXIFTAGTYPE_EXIF_PIXEL_Y_DIMENSION  EXIF_SHORT
-// Related audio file
-// Use EXIFTAGTYPE_EXIF_RELATED_SOUND_FILE as the exif_tag_type (EXIF_ASCII)
-// Count should be 13
-#define _ID_RELATED_SOUND_FILE              0xa004
-#define EXIFTAGID_RELATED_SOUND_FILE        CONSTRUCT_TAGID(RELATED_SOUND_FILE, _ID_RELATED_SOUND_FILE)
-#define EXIFTAGTYPE_RELATED_SOUND_FILE      EXIF_ASCII
-// Interop IFD pointer (NOT INTENDED to be accessible to user)
-#define _ID_INTEROP_IFD_PTR                 0xa005
-#define EXIFTAGID_INTEROP_IFD_PTR           CONSTRUCT_TAGID(INTEROP, _ID_INTEROP_IFD_PTR)
-#define EXIFTAGTYPE_INTEROP_IFD_PTR         EXIF_LONG
-// Flash energy
-// Use EXIFTAGTYPE_EXIF_FLASH_ENERGY as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_FLASH_ENERGY                    0xa20b
-#define EXIFTAGID_FLASH_ENERGY              CONSTRUCT_TAGID(FLASH_ENERGY, _ID_FLASH_ENERGY)
-#define EXIFTAGTYPE_FLASH_ENERGY            EXIF_RATIONAL
-// Spatial frequency response
-// Use EXIFTAGTYPE_SPATIAL_FREQ_RESPONSE as exif_tag_type (EXIF_UNDEFINED)
-// Count would be any
-#define _ID_SPATIAL_FREQ_RESPONSE           0xa20c
-#define EXIFTAGID_SPATIAL_FREQ_RESPONSE     CONSTRUCT_TAGID(SPATIAL_FREQ_RESPONSE, _ID_SPATIAL_FREQ_RESPONSE)
-#define EXIFTAGTYPE_SPATIAL_FREQ_RESPONSE   EXIF_UNDEFINED
-// Focal plane x resolution
-// Use EXIFTAGTYPE_FOCAL_PLANE_X_RESOLUTION as exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_FOCAL_PLANE_X_RESOLUTION        0xa20e
-#define EXIFTAGID_FOCAL_PLANE_X_RESOLUTION  CONSTRUCT_TAGID(FOCAL_PLANE_X_RESOLUTION, _ID_FOCAL_PLANE_X_RESOLUTION)
-#define EXIFTAGTYPE_FOCAL_PLANE_X_RESOLUTION EXIF_RATIONAL
-// Focal plane y resolution
-// Use EXIFTAGTYPE_FOCAL_PLANE_Y_RESOLUTION as exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_FOCAL_PLANE_Y_RESOLUTION        0xa20f
-#define EXIFTAGID_FOCAL_PLANE_Y_RESOLUTION  CONSTRUCT_TAGID(FOCAL_PLANE_Y_RESOLUTION, _ID_FOCAL_PLANE_Y_RESOLUTION)
-#define EXIFTAGTYPE_FOCAL_PLANE_Y_RESOLUTION EXIF_RATIONAL
-// Focal plane  resolution unit
-// Use EXIFTAGTYPE_FOCAL_PLANE_RESOLUTION_UNIT as exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_FOCAL_PLANE_RESOLUTION_UNIT     0xa210
-#define EXIFTAGID_FOCAL_PLANE_RESOLUTION_UNIT CONSTRUCT_TAGID(FOCAL_PLANE_RESOLUTION_UNIT, _ID_FOCAL_PLANE_RESOLUTION_UNIT)
-#define EXIFTAGTYPE_FOCAL_PLANE_RESOLUTION_UNIT EXIF_SHORT
-// Subject location
-// Use EXIFTAGTYPE_SUBJECT_LOCATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 2
-#define _ID_SUBJECT_LOCATION                0xa214
-#define EXIFTAGID_SUBJECT_LOCATION          CONSTRUCT_TAGID(SUBJECT_LOCATION, _ID_SUBJECT_LOCATION)
-#define EXIFTAGTYPE_SUBJECT_LOCATION        EXIF_SHORT
-// Exposure index
-// Use EXIFTAGTYPE_EXPOSURE_INDEX as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_EXPOSURE_INDEX                  0xa215
-#define EXIFTAGID_EXPOSURE_INDEX            CONSTRUCT_TAGID(EXPOSURE_INDEX, _ID_EXPOSURE_INDEX)
-#define EXIFTAGTYPE_EXPOSURE_INDEX          EXIF_RATIONAL
-// Sensing method
-// Use EXIFTAGTYPE_SENSING_METHOD as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SENSING_METHOD                  0xa217
-#define EXIFTAGID_SENSING_METHOD            CONSTRUCT_TAGID(SENSING_METHOD, _ID_SENSING_METHOD)
-#define EXIFTAGTYPE_SENSING_METHOD          EXIF_SHORT
-// File source
-// Use EXIFTAGTYPE_FILE_SOURCE as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 1
-#define _ID_FILE_SOURCE                     0xa300
-#define EXIFTAGID_FILE_SOURCE               CONSTRUCT_TAGID(FILE_SOURCE, _ID_FILE_SOURCE)
-#define EXIFTAGTYPE_FILE_SOURCE             EXIF_UNDEFINED
-// Scene type
-// Use EXIFTAGTYPE_SCENE_TYPE as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 1
-#define _ID_SCENE_TYPE                      0xa301
-#define EXIFTAGID_SCENE_TYPE                CONSTRUCT_TAGID(SCENE_TYPE, _ID_SCENE_TYPE)
-#define EXIFTAGTYPE_SCENE_TYPE              EXIF_UNDEFINED
-// CFA pattern
-// Use EXIFTAGTYPE_CFA_PATTERN as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_CFA_PATTERN                     0xa302
-#define EXIFTAGID_CFA_PATTERN               CONSTRUCT_TAGID(CFA_PATTERN, _ID_CFA_PATTERN)
-#define EXIFTAGTYPE_CFA_PATTERN             EXIF_UNDEFINED
-// Custom image processing
-// Use EXIFTAGTYPE_CUSTOM_RENDERED as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_CUSTOM_RENDERED                 0xa401
-#define EXIFTAGID_CUSTOM_RENDERED           CONSTRUCT_TAGID(CUSTOM_RENDERED, _ID_CUSTOM_RENDERED)
-#define EXIFTAGTYPE_CUSTOM_RENDERED         EXIF_SHORT
-// Exposure mode
-// Use EXIFTAGTYPE_EXPOSURE_MODE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXPOSURE_MODE                   0xa402
-#define EXIFTAGID_EXPOSURE_MODE             CONSTRUCT_TAGID(EXPOSURE_MODE, _ID_EXPOSURE_MODE)
-#define EXIFTAGTYPE_EXPOSURE_MODE           EXIF_SHORT
-// White balance
-// Use EXIFTAGTYPE_WHITE_BALANCE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_WHITE_BALANCE                   0xa403
-#define EXIFTAGID_WHITE_BALANCE             CONSTRUCT_TAGID(WHITE_BALANCE, _ID_WHITE_BALANCE)
-#define EXIFTAGTYPE_WHITE_BALANCE           EXIF_SHORT
-// Digital zoom ratio
-// Use EXIFTAGTYPE_DIGITAL_ZOOM_RATIO as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_DIGITAL_ZOOM_RATIO              0xa404
-#define EXIFTAGID_DIGITAL_ZOOM_RATIO        CONSTRUCT_TAGID(DIGITAL_ZOOM_RATIO, _ID_DIGITAL_ZOOM_RATIO)
-#define EXIFTAGTYPE_DIGITAL_ZOOM_RATIO      EXIF_RATIONAL
-// Focal length in 35mm film
-// Use EXIFTAGTYPE_FOCAL_LENGTH_35MM as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_FOCAL_LENGTH_35MM               0xa405
-#define EXIFTAGID_FOCAL_LENGTH_35MM         CONSTRUCT_TAGID(FOCAL_LENGTH_35MM, _ID_FOCAL_LENGTH_35MM)
-#define EXIFTAGTYPE_FOCAL_LENGTH_35MM       EXIF_SHORT
-// Scene capture type
-// Use EXIFTAGTYPE_SCENE_CAPTURE_TYPE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SCENE_CAPTURE_TYPE              0xa406
-#define EXIFTAGID_SCENE_CAPTURE_TYPE        CONSTRUCT_TAGID(SCENE_CAPTURE_TYPE, _ID_SCENE_CAPTURE_TYPE)
-#define EXIFTAGTYPE_SCENE_CAPTURE_TYPE      EXIF_SHORT
-// Gain control
-// Use EXIFTAGTYPE_GAIN_CONTROL as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_GAIN_CONTROL                    0xa407
-#define EXIFTAGID_GAIN_CONTROL              CONSTRUCT_TAGID(GAIN_CONTROL, _ID_GAIN_CONTROL)
-#define EXIFTAGTYPE_GAIN_CONTROL            EXIF_SHORT
-// Contrast
-// Use EXIFTAGTYPE_CONTRAST as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_CONTRAST                        0xa408
-#define EXIFTAGID_CONTRAST                  CONSTRUCT_TAGID(CONTRAST, _ID_CONTRAST)
-#define EXIFTAGTYPE_CONTRAST                EXIF_SHORT
-// Saturation
-// Use EXIFTAGTYPE_SATURATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SATURATION                      0xa409
-#define EXIFTAGID_SATURATION                CONSTRUCT_TAGID(SATURATION, _ID_SATURATION)
-#define EXIFTAGTYPE_SATURATION              EXIF_SHORT
-// Sharpness
-// Use EXIFTAGTYPE_SHARPNESS as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SHARPNESS                       0xa40a
-#define EXIFTAGID_SHARPNESS                 CONSTRUCT_TAGID(SHARPNESS, _ID_SHARPNESS)
-#define EXIFTAGTYPE_SHARPNESS               EXIF_SHORT
-// Device settings description
-// Use EXIFTAGID_DEVICE_SETTINGS_DESCRIPTION as exif_tag_type (EXIF_UNDEFINED)
-// Count could be any
-#define _ID_DEVICE_SETTINGS_DESCRIPTION     0xa40b
-#define EXIFTAGID_DEVICE_SETTINGS_DESCRIPTION CONSTRUCT_TAGID(DEVICE_SETTINGS_DESCRIPTION, _ID_DEVICE_SETTINGS_DESCRIPTION)
-#define EXIFTAGTYPE_DEVIC_SETTIGNS_DESCRIPTION EXIF_UNDEFINED
-// Subject distance range
-// Use EXIFTAGTYPE_SUBJECT_DISTANCE_RANGE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SUBJECT_DISTANCE_RANGE          0xa40c
-#define EXIFTAGID_SUBJECT_DISTANCE_RANGE    CONSTRUCT_TAGID(SUBJECT_DISTANCE_RANGE, _ID_SUBJECT_DISTANCE_RANGE)
-#define EXIFTAGTYPE_SUBJECT_DISTANCE_RANGE  EXIF_SHORT
-// Unique image id
-// Use EXIFTAG_TYPE_IMAGE_UIDas the exif_tag_type (EXIF_ASCII)
-// Count should be 33
-#define _ID_IMAGE_UID                       0xa420
-#define EXIFTAGID_IMAGE_UID                 CONSTRUCT_TAGID(IMAGE_UID, _ID_IMAGE_UID)
-#define EXIFTAGTYPE_IMAGE_UID               EXIF_ASCII
-// PIM tag
-// Use EXIFTAGTYPE_PIM_TAG as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_PIM                             0xc4a5
-#define EXIFTAGID_PIM_TAG                   CONSTRUCT_TAGID(PIM, _ID_PIM)
-#define EXIFTAGTYPE_PIM_TAG                 EXIF_UNDEFINED
-
-#endif /* __QCAMERA_INTF_H__ */
diff --git a/camera/QCamera/HAL2/core/src/QCameraHAL.cpp b/camera/QCamera/HAL2/core/src/QCameraHAL.cpp
deleted file mode 100644
index 2264bcd..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraHAL.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
-** Copyright (c) 2011 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHAL"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-
-
-/* include QCamera Hardware Interface Header*/
-#include "QCameraHAL.h"
-
-int HAL_numOfCameras = 0;
-mm_camera_info_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS];
-camera_metadata_t *HAL_staticInfo[MSM_MAX_CAMERA_SENSORS];
-
-namespace android {
-/* HAL function implementation goes here*/
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-extern "C" int HAL_getNumberOfCameras()
-{
-    /* try to query every time we get the call!*/
-    uint8_t num_camera = 0;
-    mm_camera_info_t * handle_base = 0;
-    ALOGV("%s: E", __func__);
-
-    handle_base= camera_query(&num_camera);
-
-    if (!handle_base) {
-        HAL_numOfCameras = 0;
-    }
-    else
-    {
-        camera_info_t* p_camera_info = NULL;
-        HAL_numOfCameras=num_camera;
-
-        ALOGI("Handle base =0x%p",handle_base);
-        ALOGI("getCameraInfo: numOfCameras = %d", HAL_numOfCameras);
-        for(int i = 0; i < HAL_numOfCameras; i++) {
-            ALOGI("Handle [%d]=0x%p",i,handle_base+i);
-            HAL_camerahandle[i]=handle_base + i;
-            p_camera_info = &(HAL_camerahandle[i]->camera_info);
-            if (p_camera_info) {
-                ALOGI("Camera sensor %d info:", i);
-                ALOGI("camera_id: %d", p_camera_info->camera_id);
-                ALOGI("modes_supported: %x", p_camera_info->modes_supported);
-                ALOGI("position: %d", p_camera_info->position);
-                ALOGI("sensor_mount_angle: %d", p_camera_info->sensor_mount_angle);
-            }
-        }
-    }
-
-    ALOGV("%s: X", __func__);
-
-    return HAL_numOfCameras;
-}
-
-extern "C" int HAL_getCameraInfo(int cameraId, struct camera_info* cameraInfo)
-{
-    mm_camera_info_t *mm_camer_obj = 0;
-    ALOGV("%s: E", __func__);
-    mm_camera_vtbl_t *p_camera_vtbl=NULL;
-    status_t ret;
-
-    if (!HAL_numOfCameras || HAL_numOfCameras < cameraId || !cameraInfo)
-        return INVALID_OPERATION;
-    else
-        mm_camer_obj = HAL_camerahandle[cameraId];
-
-    if (!mm_camer_obj)
-        return INVALID_OPERATION;
-    else {
-        cameraInfo->facing =
-            (FRONT_CAMERA == mm_camer_obj->camera_info.position)?
-            CAMERA_FACING_FRONT : CAMERA_FACING_BACK;
-
-        cameraInfo->orientation = mm_camer_obj->camera_info.sensor_mount_angle;
-    }
-
-    if (HAL_staticInfo[cameraId])
-        goto end;
-
-    /*
-     * We need to open the camera in order to get the full list of static properties
-     * required in the Google Camera API 2.0
-    */
-    p_camera_vtbl=camera_open(cameraId, NULL);
-
-    if(p_camera_vtbl == NULL) {
-        ALOGE("%s:camera_open failed",__func__);
-        return INVALID_OPERATION;
-    }
-    p_camera_vtbl->ops->sync(p_camera_vtbl->camera_handle);
-
-    ret = getStaticInfo(&HAL_staticInfo[cameraId], p_camera_vtbl, true);
-    if (ret != OK) {
-        ALOGE("%s: Unable to allocate static info: %s (%d)",
-            __FUNCTION__, strerror(-ret), ret);
-        return ret;
-    }
-    ret = getStaticInfo(&HAL_staticInfo[cameraId], p_camera_vtbl, false);
-    if (ret != OK) {
-        ALOGE("%s: Unable to fill in static info: %s (%d)",
-                __FUNCTION__, strerror(-ret), ret);
-        return ret;
-    }
-    p_camera_vtbl->ops->camera_close(p_camera_vtbl->camera_handle);
-
-end:
-    cameraInfo->device_version = HARDWARE_DEVICE_API_VERSION(2, 0);
-    cameraInfo->static_camera_characteristics =
-        HAL_staticInfo[cameraId];
-
-    ALOGV("%s: X", __func__);
-    return OK;
-}
-
-}; // namespace android
diff --git a/camera/QCamera/HAL2/core/src/QCameraHWI.cpp b/camera/QCamera/HAL2/core/src/QCameraHWI.cpp
deleted file mode 100644
index 8b3114e..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraHWI.cpp
+++ /dev/null
@@ -1,492 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define LOG_NIDEBUG 0
-//#define LOG_NDEBUG 0
-
-#define LOG_TAG "QCameraHWI"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-
-/* QCameraHardwareInterface class implementation goes here*/
-/* following code implement the contol logic of this class*/
-
-namespace android {
-
-extern void stream_cb_routine(mm_camera_super_buf_t *bufs,
-                       void *userdata);
-extern void superbuf_cb_routine(mm_camera_super_buf_t *bufs,
-                       void *userdata);
-
-
-/*Command Thread startup function*/
-
-void *command_thread(void *obj)
-{
-    QCameraHardwareInterface *pme = (QCameraHardwareInterface *)obj;
-    ALOGD("%s: E", __func__);
-    if (pme != NULL) {
-        pme->runCommandThread(obj);
-    }
-    else ALOGW("not starting command thread: the object went away!");
-    ALOGD("%s: X", __func__);
-    return NULL;
-}
-
-int QCameraHardwareInterface::tryRestartStreams(
-    camera_metadata_entry_t& streams)
-{
-    int rc = 0;
-    bool needRestart = false;
-    bool needRecordingHint = false;
-
-    for (uint32_t i = 0; i < streams.count; i++) {
-        int streamId = streams.data.u8[i];
-        QCameraStream *stream = QCameraStream::getStreamAtId(streamId);
-        if (!stream->mInit) {
-            needRestart = true;
-            if (stream->mFormat == CAMERA_YUV_420_NV12)
-                needRecordingHint = true;
-        }
-    }
-
-    if (!needRestart)
-        goto end;
-
-    QCameraStream::streamOffAll();
-
-    if (needRecordingHint) {
-        uint32_t recordingHint = 1;
-        rc = mCameraHandle->ops->set_parm(mCameraHandle->camera_handle,
-            MM_CAMERA_PARM_RECORDING_HINT, &recordingHint);
-        if (rc < 0) {
-            ALOGE("set_parm MM_CAMERA_PARM_RECORDING_HINT returns %d", rc);
-            return rc;
-        }
-    }
-
-end:
-    for (uint32_t i = 0; i < streams.count; i++) {
-        int streamId = streams.data.u8[i];
-        QCameraStream *stream = QCameraStream::getStreamAtId(streamId);
-        if (!stream->mInit) {
-            rc = stream->prepareStream();
-            if (rc < 0) {
-                ALOGE("prepareStream for stream %d failed %d", streamId, rc);
-                return rc;
-            }
-        }
-    }
-    for (uint32_t i = 0; i < streams.count; i++) {
-        int streamId = streams.data.u8[i];
-        QCameraStream *stream = QCameraStream::getStreamAtId(streamId);
-
-        if (!stream->mActive) {
-            rc = stream->streamOn();
-            if (rc < 0) {
-                ALOGE("streamOn for stream %d failed %d", streamId, rc);
-                return rc;
-            }
-        }
-    }
-    return rc;
-}
-
-void QCameraHardwareInterface::runCommandThread(void *data)
-{
-   
-    /**
-     * This function implements the main service routine for the incoming
-     * frame requests, this thread routine is started everytime we get a 
-     * notify_request_queue_not_empty trigger, this thread makes the 
-     * assumption that once it receives a NULL on a dequest_request call 
-     * there will be a fresh notify_request_queue_not_empty call that is
-     * invoked thereby launching a new instance of this thread. Therefore,
-     * once we get a NULL on a dequeue request we simply let this thread die
-     */ 
-    int res;
-    camera_metadata_t *request=NULL;
-    mPendingRequests=0;
-
-    while(mRequestQueueSrc) {
-        ALOGV("%s:Dequeue request using mRequestQueueSrc:%p",__func__,mRequestQueueSrc);
-        mRequestQueueSrc->dequeue_request(mRequestQueueSrc,&request);
-        if(request==NULL) {
-            ALOGE("%s:No more requests available from src command \
-                    thread dying",__func__);
-            return;
-        }
-        mPendingRequests++;
-
-        /* Set the metadata values */
-
-        /* Wait for the SOF for the new metadata values to be applied */
-
-        /* Check the streams that need to be active in the stream request */
-        sort_camera_metadata(request);
-
-        camera_metadata_entry_t streams;
-        res = find_camera_metadata_entry(request,
-                ANDROID_REQUEST_OUTPUT_STREAMS,
-                &streams);
-        if (res != NO_ERROR) {
-            ALOGE("%s: error reading output stream tag", __FUNCTION__);
-            return;
-        }
-
-        res = tryRestartStreams(streams);
-        if (res != NO_ERROR) {
-            ALOGE("error tryRestartStreams %d", res);
-            return;
-        }
-
-        /* 3rd pass: Turn on all streams requested */
-        for (uint32_t i = 0; i < streams.count; i++) {
-            int streamId = streams.data.u8[i];
-            QCameraStream *stream = QCameraStream::getStreamAtId(streamId);
-
-            /* Increment the frame pending count in each stream class */
-
-            /* Assuming we will have the stream obj in had at this point may be
-             * may be multiple objs in which case we loop through array of streams */
-            stream->onNewRequest();
-        }
-        ALOGV("%s:Freeing request using mRequestQueueSrc:%p",__func__,mRequestQueueSrc);
-        /* Free the request buffer */
-        mRequestQueueSrc->free_request(mRequestQueueSrc,request);
-        mPendingRequests--;
-        ALOGV("%s:Completed request",__func__);
-    }
- 
-    QCameraStream::streamOffAll();
-}
-
-/*Mem Hooks*/
-int32_t get_buffer_hook(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data,
-                        mm_camera_frame_len_offset *frame_offset_info,
-                        uint8_t num_bufs,
-                        uint8_t *initial_reg_flag,
-                        mm_camera_buf_def_t  *bufs)
-{
-    QCameraHardwareInterface *pme=(QCameraHardwareInterface *)user_data;
-    return pme->getBuf(camera_handle, ch_id, stream_id,
-                user_data, frame_offset_info,
-                num_bufs,initial_reg_flag,
-                bufs);
-
-}
-
-int32_t put_buffer_hook(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data, uint8_t num_bufs,
-                        mm_camera_buf_def_t *bufs)
-{
-    QCameraHardwareInterface *pme=(QCameraHardwareInterface *)user_data;
-    return pme->putBuf(camera_handle, ch_id, stream_id,
-                user_data, num_bufs, bufs);
-
-}
-
-int QCameraHardwareInterface::getBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t mm_stream_id,
-                        void *user_data,
-                        mm_camera_frame_len_offset *frame_offset_info,
-                        uint8_t num_bufs,
-                        uint8_t *initial_reg_flag,
-                        mm_camera_buf_def_t  *bufs)
-{
-    status_t ret=NO_ERROR;
-    ALOGE("%s: E, stream_id = %d\n", __func__, mm_stream_id);
-    QCameraStream_preview *stream = (QCameraStream_preview *)
-                        QCameraStream::getStreamAtMmId(mm_stream_id);
-
-    ALOGE("%s: len:%d, y_off:%d, cbcr:%d num buffers: %d planes:%d streamid:%d",
-        __func__,
-        frame_offset_info->frame_len,
-	frame_offset_info->mp[0].len,
-	frame_offset_info->mp[1].len,
-        num_bufs,frame_offset_info->num_planes,
-        mm_stream_id);
-    /*************Preiew Stream*****************/
-    ALOGE("Interface requesting Preview Buffers");
-    stream->mFrameOffsetInfo=*frame_offset_info;
-    if(NO_ERROR!=stream->initBuffers()){
-        return BAD_VALUE;
-    } 
-    ALOGE("Debug : %s : initDisplayBuffers",__func__);
-    for(int i=0;i<num_bufs;i++) {
-        bufs[i] = stream->mDisplayBuf[i];
-        initial_reg_flag[i] =
-            (stream->mPreviewMemory.local_flag[i] == BUFFER_OWNED);
-        ALOGE("initial_reg_flag[%d]:%d",i,initial_reg_flag[i]);
-    }
-    return 0;
-}
-
-int QCameraHardwareInterface::putBuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t mm_stream_id,
-                        void *user_data, uint8_t num_bufs,
-                        mm_camera_buf_def_t *bufs)
-{
-    ALOGE("%s:E, stream_id = %d",__func__, mm_stream_id);
-    QCameraStream_preview *stream = (QCameraStream_preview *)
-                        QCameraStream::getStreamAtMmId(mm_stream_id);
-    stream->deinitBuffers();
-    return 0;
-}
-
-
-QCameraHardwareInterface::
-QCameraHardwareInterface(int cameraId, int mode)
-                  : mCameraId(cameraId)
-{
-
-    cam_ctrl_dimension_t mDimension;
-
-    /* Open camera stack! */
-    memset(&mMemHooks, 0, sizeof(mm_camear_mem_vtbl_t));
-    mMemHooks.user_data=this;
-    mMemHooks.get_buf=get_buffer_hook;
-    mMemHooks.put_buf=put_buffer_hook;
-
-    mCameraHandle=camera_open(mCameraId, &mMemHooks);
-    ALOGV("Cam open returned %p",mCameraHandle);
-    if(mCameraHandle == NULL) {
-        ALOGE("startCamera: cam_ops_open failed: id = %d", mCameraId);
-        return;
-    }
-    mCameraHandle->ops->sync(mCameraHandle->camera_handle);
-
-    mChannelId=mCameraHandle->ops->ch_acquire(mCameraHandle->camera_handle);
-    if(mChannelId<=0)
-    {
-        ALOGE("%s:Channel aquire failed",__func__);
-        mCameraHandle->ops->camera_close(mCameraHandle->camera_handle);
-        return;
-    }
-
-    /* Initialize # of frame requests the HAL is handling to zero*/
-    mPendingRequests=0;
-}
-
-QCameraHardwareInterface::~QCameraHardwareInterface()
-{
-    mCameraHandle->ops->camera_close(mCameraHandle->camera_handle);
-}
- 
-void QCameraHardwareInterface::release()
-{
-}
-
-bool QCameraHardwareInterface::isCameraReady()
-{
-    return true;
-}
-
-int QCameraHardwareInterface::set_request_queue_src_ops(
-    const camera2_request_queue_src_ops_t *request_src_ops)
-{
-    ALOGE("%s:E mRequestQueueSrc:%p",__func__,request_src_ops);
-    mRequestQueueSrc = request_src_ops;
-    ALOGE("%s:X",__func__);
-    return 0;
-}
-
-int QCameraHardwareInterface::notify_request_queue_not_empty()
-{
-
-    pthread_attr_t attr;
-    if(pthread_attr_init(&attr)!=0) { 
-        ALOGE("%s:pthread_attr_init failed",__func__);
-        return BAD_VALUE;
-    }
-    if(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)!=0){
-        ALOGE("%s:pthread_attr_setdetachstate failed",__func__);
-        return BAD_VALUE;
-    }
-    if(pthread_create(&mCommandThread,&attr,
-                   command_thread, (void *)this)!=0) {
-        ALOGE("%s:pthread_create failed to launch command_thread",__func__);
-        return BAD_VALUE;
-    }
-
-    return NO_ERROR;
-}
-
-int QCameraHardwareInterface::set_frame_queue_dst_ops(
-    const camera2_frame_queue_dst_ops_t *frame_dst_ops)
-{
-    mFrameQueueDst = frame_dst_ops;
-    return OK;
-}
-
-int QCameraHardwareInterface::get_in_progress_count()
-{
-    return mPendingRequests;
-}
-
-int QCameraHardwareInterface::construct_default_request(
-    int request_template, camera_metadata_t **request)
-{
-    status_t ret;
-    ALOGD("%s:E:request_template:%d ",__func__,request_template);
-
-    if (request == NULL)
-        return BAD_VALUE;
-    if (request_template < 0 || request_template >= CAMERA2_TEMPLATE_COUNT)
-        return BAD_VALUE;
-
-    ret = constructDefaultRequest(request_template, request, true);
-    if (ret != OK) {
-        ALOGE("%s: Unable to allocate default request: %s (%d)",
-            __FUNCTION__, strerror(-ret), ret);
-        return ret;
-    }
-    ret = constructDefaultRequest(request_template, request, false);
-    if (ret != OK) {
-        ALOGE("%s: Unable to fill in default request: %s (%d)",
-            __FUNCTION__, strerror(-ret), ret);
-        return ret;
-    }
-
-    ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO");
-    mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO;
-    ret = mCameraHandle->ops->set_parm(
-                         mCameraHandle->camera_handle,
-                         MM_CAMERA_PARM_OP_MODE,
-                         &op_mode);
-    ALOGE("OP Mode Set");
-
-    return ret;
-}
-
-int QCameraHardwareInterface::allocate_stream(
-    uint32_t width,
-    uint32_t height, int format,
-    const camera2_stream_ops_t *stream_ops,
-    uint32_t *stream_id,
-    uint32_t *format_actual,
-    uint32_t *usage,
-    uint32_t *max_buffers)
-{
-    int ret = OK;
-    QCameraStream *stream = NULL;
-    camera_mode_t myMode = (camera_mode_t)(CAMERA_MODE_2D|CAMERA_NONZSL_MODE);
-    ALOGE("%s : BEGIN",__func__);
-
-    ALOGE("Mymode Preview = %d",myMode);
-    stream = QCameraStream_preview::createInstance(
-                        mCameraHandle->camera_handle,
-                        mChannelId,
-                        width,
-                        height,
-                        format,
-                        mCameraHandle,
-                        myMode);
-    ALOGE("%s: createInstance done", __func__);
-    if (!stream) {
-        ALOGE("%s: error - can't creat preview stream!", __func__);
-        return BAD_VALUE;
-    }
-
-    stream->setPreviewWindow(stream_ops);
-    *stream_id = stream->getStreamId();
-    *max_buffers= stream->getMaxBuffers();
-    ALOGE("%s: stream_id = %d\n", __func__, *stream_id);
-    *usage = GRALLOC_USAGE_HW_CAMERA_WRITE | CAMERA_GRALLOC_HEAP_ID
-        | CAMERA_GRALLOC_FALLBACK_HEAP_ID;
-    /* Set to an arbitrary format SUPPORTED by gralloc */
-    //*format_actual = HAL_PIXEL_FORMAT_YCbCr_422_SP;
-    *format_actual = HAL_PIXEL_FORMAT_YCrCb_420_SP;
-    /*TODO: For hardware encoder, add CAMERA_GRALLOC_CACHING_ID */
-    stream->setHALCameraControl(this);
-
-    ALOGV("%s : END",__func__);
-    return ret;
-}
-
-int QCameraHardwareInterface::register_stream_buffers(
-    uint32_t stream_id, int num_buffers,
-    buffer_handle_t *buffers)
-{
-    struct private_handle_t *private_handle =
-                        (struct private_handle_t *)buffers[0];
-    QCameraStream_preview *stream = (QCameraStream_preview *)
-                        QCameraStream::getStreamAtId(stream_id);
-
-    if(!stream) {
-        ALOGE("%s: Request for unknown stream",__func__);
-        return BAD_VALUE;
-    }
-
-    if(NO_ERROR!=stream->registerStreamBuffers(num_buffers, buffers)) {
-        ALOGE("%s:registerStreamBuffers failed",__func__);
-        return BAD_VALUE;
-    }
-
-    return NO_ERROR;
-}
-
-int QCameraHardwareInterface::release_stream(uint32_t stream_id)
-{
-    QCameraStream *stream = QCameraStream::getStreamAtId(stream_id);
-
-    QCameraStream_preview::deleteInstance(stream);
- 
-    return OK;
-}
-
-int QCameraHardwareInterface::allocate_reprocess_stream(
-    uint32_t width,
-    uint32_t height,
-    uint32_t format,
-    const camera2_stream_in_ops_t *reprocess_stream_ops,
-    uint32_t *stream_id,
-    uint32_t *consumer_usage,
-    uint32_t *max_buffers)
-{
-    return INVALID_OPERATION;
-}
-
-int QCameraHardwareInterface::release_reprocess_stream(uint32_t stream_id)
-{
-    return INVALID_OPERATION;
-}
-
-int QCameraHardwareInterface::get_metadata_vendor_tag_ops(vendor_tag_query_ops_t **ops)
-{
-    *ops = NULL;
-    return OK;
-}
-
-int QCameraHardwareInterface::set_notify_callback(camera2_notify_callback notify_cb,
-            void *user)
-{
-    mNotifyCb = notify_cb;
-    mNotifyUserPtr = user;
-    return OK;
-}
-}; // namespace android
diff --git a/camera/QCamera/HAL2/core/src/QCameraHWI_Metatags.cpp b/camera/QCamera/HAL2/core/src/QCameraHWI_Metatags.cpp
deleted file mode 100644
index 3d09228..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraHWI_Metatags.cpp
+++ /dev/null
@@ -1,746 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_NIDEBUG 0
-
-#define ALOG_TAG __FILE__
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include <hardware/camera2.h>
-#include <mm_camera_interface.h>
-
-
-namespace android {
-
-
-const uint32_t QCAvailableFormats[4] = {
-        HAL_PIXEL_FORMAT_RAW_SENSOR,
-        HAL_PIXEL_FORMAT_BLOB,
-        HAL_PIXEL_FORMAT_YV12,
-        HAL_PIXEL_FORMAT_YCrCb_420_SP
-};
-
-const uint32_t QCAvailableRawSizes[2] = {
-    640, 480
-};
-
-
-const nsecs_t QCExposureTimeRange[2] =
-    {1000L, 30000000000L} ; // 1 us - 30 sec
-const nsecs_t QCFrameDurationRange[2] =
-    {33331760L, 30000000000L}; // ~1/30 s - 30 sec
-const nsecs_t QCMinVerticalBlank = 10000L;
-
-const uint8_t QCColorFilterArrangement = ANDROID_SENSOR_RGGB;
-
-// Output image data characteristics
-const uint32_t QCMaxRawValue = 4000;
-const uint32_t QCBlackLevel  = 1000;
-
-const uint64_t QCAvailableRawMinDurations[1] = {
-    QCFrameDurationRange[0]
-};
-
-const uint32_t QCAvailableProcessedSizes[4] = {
-    640, 480, 320, 240
-    //    Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-const uint64_t QCAvailableProcessedMinDurations[1] = {
-    QCFrameDurationRange[0]
-};
-
-
-const uint32_t QCAvailableJpegSizes[2] = {
-    640, 480
-    //    Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-const uint64_t QCAvailableJpegMinDurations[1] = {
-    QCFrameDurationRange[0]
-};
-
-static status_t addOrSize(camera_metadata_t *request,
-        bool sizeRequest,
-        size_t *entryCount,
-        size_t *dataCount,
-        uint32_t tag,
-        const void *entryData,
-        size_t entryDataCount) {
-    status_t res;
-    if (!sizeRequest) {
-        return add_camera_metadata_entry(request, tag, entryData,
-                entryDataCount);
-    } else {
-        int type = get_camera_metadata_tag_type(tag);
-        if (type < 0 ) return BAD_VALUE;
-        (*entryCount)++;
-        (*dataCount) += calculate_camera_metadata_entry_data_size(type,
-                entryDataCount);
-        return OK;
-    }
-}
-
-extern "C" status_t getStaticInfo(camera_metadata_t **info,
-        mm_camera_vtbl_t *camera_vtbl, bool sizeRequest)
-{
-    size_t entryCount = 0;
-    size_t dataCount = 0;
-    status_t ret;
-
-    if(!camera_vtbl) return BAD_VALUE;
-
-    bool mFacingBack = (camera_vtbl->camera_info->camera_info.position==BACK_CAMERA)?
-                       true:false;
-
-#define ADD_OR_SIZE( tag, data, count ) \
-    if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \
-            tag, data, count) ) != OK ) return ret
-
-    // android.lens
-
-    static float minFocusDistance = 0;
-    ADD_OR_SIZE(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE,
-            &minFocusDistance, 1);
-    ADD_OR_SIZE(ANDROID_LENS_HYPERFOCAL_DISTANCE,
-            &minFocusDistance, 1);
-
-    static float focalLength = 0.0f;
-    camera_vtbl->ops->get_parm(camera_vtbl->camera_handle,
-            MM_CAMERA_PARM_FOCAL_LENGTH,
-            (void *)&focalLength);
-    ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS,
-            &focalLength, 1);
-
-    static float aperture = 2.8f;
-    camera_vtbl->ops->get_parm(camera_vtbl->camera_handle,
-            MM_CAMERA_PARM_APERTURE,
-            (void *)&aperture);
-    ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_APERTURES,
-            &aperture, 1);
-
-    static float filterDensity = 0;
-    ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_FILTER_DENSITY,
-            &filterDensity, 1);
-
-    static const uint8_t availableOpticalStabilization =
-            ANDROID_LENS_OPTICAL_STABILIZATION_OFF;
-    ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_OPTICAL_STABILIZATION,
-            &availableOpticalStabilization, 1);
-
-    static const int32_t lensShadingMapSize[] = {1, 1};
-    ADD_OR_SIZE(ANDROID_LENS_SHADING_MAP_SIZE, lensShadingMapSize,
-            sizeof(lensShadingMapSize)/sizeof(int32_t));
-
-    static const float lensShadingMap[3 * 1 * 1 ] =
-            { 1.f, 1.f, 1.f };
-    ADD_OR_SIZE(ANDROID_LENS_SHADING_MAP, lensShadingMap,
-            sizeof(lensShadingMap)/sizeof(float));
-
-    // Identity transform
-    static const int32_t geometricCorrectionMapSize[] = {2, 2};
-    ADD_OR_SIZE(ANDROID_LENS_GEOMETRIC_CORRECTION_MAP_SIZE,
-            geometricCorrectionMapSize,
-            sizeof(geometricCorrectionMapSize)/sizeof(int32_t));
-
-    static const float geometricCorrectionMap[2 * 3 * 2 * 2] = {
-            0.f, 0.f,  0.f, 0.f,  0.f, 0.f,
-            1.f, 0.f,  1.f, 0.f,  1.f, 0.f,
-            0.f, 1.f,  0.f, 1.f,  0.f, 1.f,
-            1.f, 1.f,  1.f, 1.f,  1.f, 1.f};
-    ADD_OR_SIZE(ANDROID_LENS_GEOMETRIC_CORRECTION_MAP,
-            geometricCorrectionMap,
-            sizeof(geometricCorrectionMap)/sizeof(float));
-
-    int32_t lensFacing = mFacingBack ?
-            ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT;
-    ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1);
-
-    float lensPosition[3];
-    if (mFacingBack) {
-        // Back-facing camera is center-top on device
-        lensPosition[0] = 0;
-        lensPosition[1] = 20;
-        lensPosition[2] = -5;
-    } else {
-        // Front-facing camera is center-right on device
-        lensPosition[0] = 20;
-        lensPosition[1] = 20;
-        lensPosition[2] = 0;
-    }
-    ADD_OR_SIZE(ANDROID_LENS_POSITION, lensPosition, sizeof(lensPosition)/
-            sizeof(float));
-
-#if 0
-    // android.sensor
-
-    ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME_RANGE,
-            QCExposureTimeRange, 2);
-
-    ADD_OR_SIZE(ANDROID_SENSOR_MAX_FRAME_DURATION,
-            &QCFrameDurationRange[1], 1);
-
-    ADD_OR_SIZE(ANDROID_SENSOR_AVAILABLE_SENSITIVITIES,
-            QCAvailableSensitivities,
-            sizeof(QCAvailableSensitivities)
-            /sizeof(uint32_t));
-
-    ADD_OR_SIZE(ANDROID_SENSOR_COLOR_FILTER_ARRANGEMENT,
-            &QCColorFilterArrangement, 1);
-#endif
-    static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm
-    ADD_OR_SIZE(ANDROID_SENSOR_PHYSICAL_SIZE,
-            sensorPhysicalSize, 2);
-
-    const unsigned int kResolution[2]  = {640, 480};
-    ADD_OR_SIZE(ANDROID_SENSOR_PIXEL_ARRAY_SIZE,
-            kResolution, 2);
-
-    ADD_OR_SIZE(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE,
-            kResolution, 2);
-
-#if 0
-    ADD_OR_SIZE(ANDROID_SENSOR_WHITE_LEVEL,
-            &QCMaxRawValue, 1);
-
-    static const int32_t blackLevelPattern[4] = {
-            QCBlackLevel, QCBlackLevel,
-            QCBlackLevel, QCBlackLevel
-    };
-    ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
-            blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t));
-
-#endif
-    //TODO: sensor color calibration fields
-
-    // android.flash
-    static const uint8_t flashAvailable = 0;
-    ADD_OR_SIZE(ANDROID_FLASH_AVAILABLE, &flashAvailable, 1);
-
-    static const int64_t flashChargeDuration = 0;
-    ADD_OR_SIZE(ANDROID_FLASH_CHARGE_DURATION, &flashChargeDuration, 1);
-
-    // android.tonemap
-
-    static const int32_t tonemapCurvePoints = 128;
-    ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
-
-#if 1
-    // android.scaler
-    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS,
-            QCAvailableFormats,
-            sizeof(QCAvailableFormats)/sizeof(uint32_t));
-
-    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
-            QCAvailableRawSizes,
-            sizeof(QCAvailableRawSizes)/sizeof(uint32_t));
-
-    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
-            QCAvailableRawMinDurations,
-            sizeof(QCAvailableRawMinDurations)/sizeof(uint64_t));
-
-    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
-            QCAvailableProcessedSizes,
-            sizeof(QCAvailableProcessedSizes)/sizeof(uint32_t));
-
-    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
-            QCAvailableProcessedMinDurations,
-            sizeof(QCAvailableProcessedMinDurations)/sizeof(uint64_t));
-
-    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
-            QCAvailableJpegSizes,
-            sizeof(QCAvailableJpegSizes)/sizeof(uint32_t));
-
-    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
-            QCAvailableJpegMinDurations,
-            sizeof(QCAvailableJpegMinDurations)/sizeof(uint64_t));
-
-    static const float maxZoom = 10;
-    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_ZOOM,
-            &maxZoom, 1);
-
-    // android.jpeg
-
-    static const int32_t jpegThumbnailSizes[] = {
-            160, 120,
-            320, 240
-     };
-    ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
-            jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t));
-
-    static const int32_t jpegMaxSize = 300000;
-    ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
-
-    // android.stats
-
-    static const uint8_t availableFaceDetectModes[] = {
-            ANDROID_STATS_FACE_DETECTION_OFF
-    };
-    ADD_OR_SIZE(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES,
-            availableFaceDetectModes,
-            sizeof(availableFaceDetectModes));
-
-    static const int32_t maxFaceCount = 0;
-    ADD_OR_SIZE(ANDROID_STATS_MAX_FACE_COUNT,
-            &maxFaceCount, 1);
-
-    static const int32_t histogramSize = 64;
-    ADD_OR_SIZE(ANDROID_STATS_HISTOGRAM_BUCKET_COUNT,
-            &histogramSize, 1);
-
-    static const int32_t maxHistogramCount = 1000;
-    ADD_OR_SIZE(ANDROID_STATS_MAX_HISTOGRAM_COUNT,
-            &maxHistogramCount, 1);
-
-    static const int32_t sharpnessMapSize[2] = {64, 64};
-    ADD_OR_SIZE(ANDROID_STATS_SHARPNESS_MAP_SIZE,
-            sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t));
-
-    static const int32_t maxSharpnessMapValue = 1000;
-    ADD_OR_SIZE(ANDROID_STATS_MAX_SHARPNESS_MAP_VALUE,
-            &maxSharpnessMapValue, 1);
-
-    // android.control
-
-    static const uint8_t availableSceneModes[] = {
-            ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
-            availableSceneModes, sizeof(availableSceneModes));
-
-    static const uint8_t availableEffects[] = {
-            ANDROID_CONTROL_EFFECT_OFF
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS,
-            availableEffects, sizeof(availableEffects));
-
-    int32_t max3aRegions = 0;
-    ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS,
-            &max3aRegions, 1);
-
-    static const uint8_t availableAeModes[] = {
-            ANDROID_CONTROL_AE_OFF,
-            ANDROID_CONTROL_AE_ON
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES,
-            availableAeModes, sizeof(availableAeModes));
-
-    static const camera_metadata_rational exposureCompensationStep = {
-            1, 3
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP,
-            &exposureCompensationStep, 1);
-
-    int32_t exposureCompensationRange[] = {-9, 9};
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE,
-            exposureCompensationRange,
-            sizeof(exposureCompensationRange)/sizeof(int32_t));
-
-    static const int32_t availableTargetFpsRanges[] = {
-            5, 30, 15, 30
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
-            availableTargetFpsRanges,
-            sizeof(availableTargetFpsRanges)/sizeof(int32_t));
-
-    static const uint8_t availableAntibandingModes[] = {
-            ANDROID_CONTROL_AE_ANTIBANDING_OFF,
-            ANDROID_CONTROL_AE_ANTIBANDING_AUTO
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
-            availableAntibandingModes, sizeof(availableAntibandingModes));
-
-    static const uint8_t availableAwbModes[] = {
-            ANDROID_CONTROL_AWB_OFF,
-            ANDROID_CONTROL_AWB_AUTO,
-            ANDROID_CONTROL_AWB_INCANDESCENT,
-            ANDROID_CONTROL_AWB_FLUORESCENT,
-            ANDROID_CONTROL_AWB_DAYLIGHT,
-            ANDROID_CONTROL_AWB_SHADE
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
-            availableAwbModes, sizeof(availableAwbModes));
-
-    static const uint8_t availableAfModes[] = {
-            ANDROID_CONTROL_AF_OFF
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES,
-            availableAfModes, sizeof(availableAfModes));
-
-    static const uint8_t availableVstabModes[] = {
-            ANDROID_CONTROL_VIDEO_STABILIZATION_OFF
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
-            availableVstabModes, sizeof(availableVstabModes));
-#endif
-#undef ADD_OR_SIZE
-    /** Allocate metadata if sizing */
-    if (sizeRequest) {
-        ALOGV("Allocating %d entries, %d extra bytes for "
-                "static camera info",
-                entryCount, dataCount);
-        *info = allocate_camera_metadata(entryCount, dataCount);
-        if (*info == NULL) {
-            ALOGE("Unable to allocate camera static info"
-                    "(%d entries, %d bytes extra data)",
-                    entryCount, dataCount);
-            return NO_MEMORY;
-        }
-    }
-    return OK;
-}
-
-extern "C" status_t constructDefaultRequest(int request_template,
-        camera_metadata_t **request, bool sizeRequest)
-{
-    size_t entryCount = 0;
-    size_t dataCount = 0;
-    status_t ret;
-
-#define ADD_OR_SIZE( tag, data, count ) \
-    if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \
-            tag, data, count) ) != OK ) return ret
-
-    static const int64_t USEC = 1000LL;
-    static const int64_t MSEC = USEC * 1000LL;
-    static const int64_t SEC = MSEC * 1000LL;
-
-    /** android.request */
-
-    static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_NONE;
-    ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1);
-
-    static const int32_t id = 0;
-    ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1);
-
-    static const int32_t frameCount = 0;
-    ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1);
-
-    // OUTPUT_STREAMS set by user
-    entryCount += 1;
-    dataCount += 5; // TODO: Should be maximum stream number
-
-    /** android.lens */
-
-    static const float focusDistance = 0;
-    ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
-
-    static const float aperture = 2.8f;
-    ADD_OR_SIZE(ANDROID_LENS_APERTURE, &aperture, 1);
-
-    static const float focalLength = 5.0f;
-    ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1);
-
-    static const float filterDensity = 0;
-    ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1);
-
-    static const uint8_t opticalStabilizationMode =
-            ANDROID_LENS_OPTICAL_STABILIZATION_OFF;
-    ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
-            &opticalStabilizationMode, 1);
-
-    // FOCUS_RANGE set only in frame
-
-    /** android.sensor */
-
-    static const int64_t exposureTime = 10 * MSEC;
-    ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1);
-
-    static const int64_t frameDuration = 33333333L; // 1/30 s
-    ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1);
-
-    static const int32_t sensitivity = 100;
-    ADD_OR_SIZE(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1);
-
-    // TIMESTAMP set only in frame
-
-    /** android.flash */
-
-    static const uint8_t flashMode = ANDROID_FLASH_OFF;
-    ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1);
-
-    static const uint8_t flashPower = 10;
-    ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1);
-
-    static const int64_t firingTime = 0;
-    ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1);
-
-    /** Processing block modes */
-    uint8_t hotPixelMode = 0;
-    uint8_t demosaicMode = 0;
-    uint8_t noiseMode = 0;
-    uint8_t shadingMode = 0;
-    uint8_t geometricMode = 0;
-    uint8_t colorMode = 0;
-    uint8_t tonemapMode = 0;
-    uint8_t edgeMode = 0;
-    switch (request_template) {
-      case CAMERA2_TEMPLATE_PREVIEW:
-        hotPixelMode = ANDROID_PROCESSING_FAST;
-        demosaicMode = ANDROID_PROCESSING_FAST;
-        noiseMode = ANDROID_PROCESSING_FAST;
-        shadingMode = ANDROID_PROCESSING_FAST;
-        geometricMode = ANDROID_PROCESSING_FAST;
-        colorMode = ANDROID_PROCESSING_FAST;
-        tonemapMode = ANDROID_PROCESSING_FAST;
-        edgeMode = ANDROID_PROCESSING_FAST;
-        break;
-      case CAMERA2_TEMPLATE_STILL_CAPTURE:
-        hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        break;
-      case CAMERA2_TEMPLATE_VIDEO_RECORD:
-        hotPixelMode = ANDROID_PROCESSING_FAST;
-        demosaicMode = ANDROID_PROCESSING_FAST;
-        noiseMode = ANDROID_PROCESSING_FAST;
-        shadingMode = ANDROID_PROCESSING_FAST;
-        geometricMode = ANDROID_PROCESSING_FAST;
-        colorMode = ANDROID_PROCESSING_FAST;
-        tonemapMode = ANDROID_PROCESSING_FAST;
-        edgeMode = ANDROID_PROCESSING_FAST;
-        break;
-      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
-        hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        break;
-      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
-        hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
-        break;
-      default:
-        hotPixelMode = ANDROID_PROCESSING_FAST;
-        demosaicMode = ANDROID_PROCESSING_FAST;
-        noiseMode = ANDROID_PROCESSING_FAST;
-        shadingMode = ANDROID_PROCESSING_FAST;
-        geometricMode = ANDROID_PROCESSING_FAST;
-        colorMode = ANDROID_PROCESSING_FAST;
-        tonemapMode = ANDROID_PROCESSING_FAST;
-        edgeMode = ANDROID_PROCESSING_FAST;
-        break;
-    }
-    ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1);
-    ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1);
-    ADD_OR_SIZE(ANDROID_NOISE_MODE, &noiseMode, 1);
-    ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1);
-    ADD_OR_SIZE(ANDROID_GEOMETRIC_MODE, &geometricMode, 1);
-    ADD_OR_SIZE(ANDROID_COLOR_MODE, &colorMode, 1);
-    ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1);
-    ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1);
-
-    /** android.noise */
-    static const uint8_t noiseStrength = 5;
-    ADD_OR_SIZE(ANDROID_NOISE_STRENGTH, &noiseStrength, 1);
-
-    /** android.color */
-    static const float colorTransform[9] = {
-        1.0f, 0.f, 0.f,
-        0.f, 1.f, 0.f,
-        0.f, 0.f, 1.f
-    };
-    ADD_OR_SIZE(ANDROID_COLOR_TRANSFORM, colorTransform, 9);
-
-    /** android.tonemap */
-    static const float tonemapCurve[4] = {
-        0.f, 0.f,
-        1.f, 1.f
-    };
-    ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4);
-    ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4);
-    ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4);
-
-    /** android.edge */
-    static const uint8_t edgeStrength = 5;
-    ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
-
-    /** android.scaler */
-    static const int32_t cropRegion[3] = {
-        0, 0, /*kResolution[0]*/
-    };
-    ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
-
-    /** android.jpeg */
-    static const int32_t jpegQuality = 80;
-    ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1);
-
-    static const int32_t thumbnailSize[2] = {
-        640, 480
-    };
-    ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2);
-
-    static const int32_t thumbnailQuality = 80;
-    ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1);
-
-    static const double gpsCoordinates[2] = {
-        0, 0
-    };
-    ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2);
-
-    static const uint8_t gpsProcessingMethod[32] = "None";
-    ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32);
-
-    static const int64_t gpsTimestamp = 0;
-    ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1);
-
-    static const int32_t jpegOrientation = 0;
-    ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1);
-
-    /** android.stats */
-
-    static const uint8_t faceDetectMode = ANDROID_STATS_FACE_DETECTION_OFF;
-    ADD_OR_SIZE(ANDROID_STATS_FACE_DETECT_MODE, &faceDetectMode, 1);
-
-    static const uint8_t histogramMode = ANDROID_STATS_OFF;
-    ADD_OR_SIZE(ANDROID_STATS_HISTOGRAM_MODE, &histogramMode, 1);
-
-    static const uint8_t sharpnessMapMode = ANDROID_STATS_OFF;
-    ADD_OR_SIZE(ANDROID_STATS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
-
-    // faceRectangles, faceScores, faceLandmarks, faceIds, histogram,
-    // sharpnessMap only in frames
-
-    /** android.control */
-
-    uint8_t controlIntent = 0;
-    switch (request_template) {
-      case CAMERA2_TEMPLATE_PREVIEW:
-        controlIntent = ANDROID_CONTROL_INTENT_PREVIEW;
-        break;
-      case CAMERA2_TEMPLATE_STILL_CAPTURE:
-        controlIntent = ANDROID_CONTROL_INTENT_STILL_CAPTURE;
-        break;
-      case CAMERA2_TEMPLATE_VIDEO_RECORD:
-        controlIntent = ANDROID_CONTROL_INTENT_VIDEO_RECORD;
-        break;
-      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
-        controlIntent = ANDROID_CONTROL_INTENT_VIDEO_SNAPSHOT;
-        break;
-      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
-        controlIntent = ANDROID_CONTROL_INTENT_ZERO_SHUTTER_LAG;
-        break;
-      default:
-        controlIntent = ANDROID_CONTROL_INTENT_CUSTOM;
-        break;
-    }
-    ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
-
-    static const uint8_t controlMode = ANDROID_CONTROL_AUTO;
-    ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1);
-
-    static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_OFF;
-    ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
-
-    static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;
-    ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
-
-    static const uint8_t aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH;
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
-
-    const unsigned int kResolution[2]  = {640, 480};
-    static const int32_t controlRegions[5] = {
-        0, 0, kResolution[0], kResolution[1], 1000
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
-
-    static const int32_t aeExpCompensation = 0;
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION, &aeExpCompensation, 1);
-
-    static const int32_t aeTargetFpsRange[2] = {
-        10, 30
-    };
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2);
-
-    static const uint8_t aeAntibandingMode =
-            ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
-    ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1);
-
-    static const uint8_t awbMode =
-            ANDROID_CONTROL_AWB_AUTO;
-    ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
-
-    ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5);
-
-    uint8_t afMode = 0;
-    switch (request_template) {
-      case CAMERA2_TEMPLATE_PREVIEW:
-        afMode = ANDROID_CONTROL_AF_AUTO;
-        break;
-      case CAMERA2_TEMPLATE_STILL_CAPTURE:
-        afMode = ANDROID_CONTROL_AF_AUTO;
-        break;
-      case CAMERA2_TEMPLATE_VIDEO_RECORD:
-        afMode = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO;
-        break;
-      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
-        afMode = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO;
-        break;
-      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
-        afMode = ANDROID_CONTROL_AF_CONTINUOUS_PICTURE;
-        break;
-      default:
-        afMode = ANDROID_CONTROL_AF_AUTO;
-        break;
-    }
-    ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1);
-
-    ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5);
-
-    static const uint8_t vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
-    ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1);
-
-    // aeState, awbState, afState only in frame
-
-    /** Allocate metadata if sizing */
-    if (sizeRequest) {
-        ALOGV("Allocating %d entries, %d extra bytes for "
-                "request template type %d",
-                entryCount, dataCount, request_template);
-        *request = allocate_camera_metadata(entryCount, dataCount);
-        if (*request == NULL) {
-            ALOGE("Unable to allocate new request template type %d "
-                    "(%d entries, %d bytes extra data)", request_template,
-                    entryCount, dataCount);
-            return NO_MEMORY;
-        }
-    }
-    return OK;
-#undef ADD_OR_SIZE
-}
-
-};
diff --git a/camera/QCamera/HAL2/core/src/QCameraStream.cpp b/camera/QCamera/HAL2/core/src/QCameraStream.cpp
deleted file mode 100644
index 73e57ce..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraStream.cpp
+++ /dev/null
@@ -1,466 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG __FILE__
-#include <utils/Log.h>
-#include <utils/threads.h>
-
-#include "QCameraHWI.h"
-#include "QCameraStream.h"
-
-/* QCameraStream class implementation goes here*/
-/* following code implement the control logic of this class*/
-
-namespace android {
-
-StreamQueue::StreamQueue(){
-    mInitialized = false;
-}
-
-StreamQueue::~StreamQueue(){
-    flush();
-}
-
-void StreamQueue::init(){
-    Mutex::Autolock l(&mQueueLock);
-    mInitialized = true;
-    mQueueWait.signal();
-}
-
-void StreamQueue::deinit(){
-    Mutex::Autolock l(&mQueueLock);
-    mInitialized = false;
-    mQueueWait.signal();
-}
-
-bool StreamQueue::isInitialized(){
-   Mutex::Autolock l(&mQueueLock);
-   return mInitialized;
-}
-
-bool StreamQueue::enqueue(
-                 void * element){
-    Mutex::Autolock l(&mQueueLock);
-    if(mInitialized == false)
-        return false;
-
-    mContainer.add(element);
-    mQueueWait.signal();
-    return true;
-}
-
-bool StreamQueue::isEmpty(){
-    return (mInitialized && mContainer.isEmpty());
-}
-void* StreamQueue::dequeue(){
-
-    void *frame;
-    mQueueLock.lock();
-    while(mInitialized && mContainer.isEmpty()){
-        mQueueWait.wait(mQueueLock);
-    }
-
-    if(!mInitialized){
-        mQueueLock.unlock();
-        return NULL;
-    }
-
-    frame = mContainer.itemAt(0);
-    mContainer.removeAt(0);
-    mQueueLock.unlock();
-    return frame;
-}
-
-void StreamQueue::flush(){
-    Mutex::Autolock l(&mQueueLock);
-    mContainer.clear();
-}
-
-
-// ---------------------------------------------------------------------------
-// QCameraStream
-// ---------------------------------------------------------------------------
-
-void superbuf_cb_routine(mm_camera_super_buf_t *bufs,
-                       void *userdata)
-{
-    QCameraHardwareInterface *p_obj=(QCameraHardwareInterface*) userdata;
-    ALOGE("%s: E",__func__);
-
-    //Implement call to JPEG routine in Snapshot here
-     if(bufs->bufs[0]->stream_id == p_obj->mStreamSnapMain->mMmStreamId){
-         ALOGE("%s : jpeg callback for MM_CAMERA_SNAPSHOT_MAIN", __func__);
-         p_obj->mStreamSnapMain->receiveRawPicture(bufs);
-     }
-
-
-    for(int i=0;i<bufs->num_bufs;i++) {
-
-        p_obj->mCameraHandle->ops->qbuf(p_obj->mCameraHandle->camera_handle,
-                                       p_obj->mChannelId,
-                                       bufs->bufs[i]);
-
-    }
-
-
-}
-
-void stream_cb_routine(mm_camera_super_buf_t *bufs,
-                       void *userdata)
-{
-    ALOGE("%s E ", __func__);
-    QCameraStream *p_obj=(QCameraStream*) userdata;
-    ALOGE("DEBUG4:ExtMode:%d,streamid:%d",p_obj->mExtImgMode,bufs->bufs[0]->stream_id);
-    switch(p_obj->mExtImgMode) {
-    case MM_CAMERA_PREVIEW:
-        ALOGE("%s : callback for MM_CAMERA_PREVIEW", __func__);
-        ((QCameraStream_preview *)p_obj)->dataCallback(bufs);
-        break;
-    case MM_CAMERA_VIDEO:
-        ALOGE("%s : callback for MM_CAMERA_VIDEO", __func__);
-        ((QCameraStream_preview *)p_obj)->dataCallback(bufs);
-        break;
-    case MM_CAMERA_SNAPSHOT_MAIN:
-#if 0
-                if(p_obj->mHalCamCtrl->getHDRMode()) {
-                    ALOGE("%s: Skipping Q Buf for HDR mode",__func__);
-                    break;
-                }
-#endif
-
-                ALOGE("%s : callback for MM_CAMERA_SNAPSHOT_MAIN", __func__);
-                p_obj->p_mm_ops->ops->qbuf(p_obj->mCameraHandle,
-                                           p_obj->mChannelId,
-                                           bufs->bufs[0]);
-                break;
-         case MM_CAMERA_SNAPSHOT_THUMBNAIL:
-                break;
-         default:
-                break;
-    
-    }
-    ALOGE("%s X ", __func__);
-}
-
-QCameraStream *QCameraStream::mStreamTable[STREAM_TABLE_SIZE];
-
-void QCameraStream::dataCallback(mm_camera_super_buf_t *bufs)
-{
-    if(mPendingCount!=0) {
-        ALOGD("Got frame request");
-        pthread_mutex_lock(&mFrameDeliveredMutex);
-        mPendingCount--;
-        ALOGD("Completed frame request");
-        pthread_cond_signal(&mFrameDeliveredCond);
-        pthread_mutex_unlock(&mFrameDeliveredMutex);
-        processPreviewFrame(bufs);
-    } else {
-        p_mm_ops->ops->qbuf(mCameraHandle,
-                mChannelId, bufs->bufs[0]);
-    }
-}
-
-void QCameraStream::onNewRequest()
-{
-    ALOGI("%s:E",__func__);
-    pthread_mutex_lock(&mFrameDeliveredMutex);
-    ALOGI("Sending Frame request");
-    mPendingCount++;
-    pthread_cond_wait(&mFrameDeliveredCond,&mFrameDeliveredMutex);
-    ALOGV("Got frame");
-    pthread_mutex_unlock(&mFrameDeliveredMutex);
-    ALOGV("%s:X",__func__);
-}
-
-int32_t QCameraStream::streamOn()
-{
-   status_t rc=NO_ERROR;
-   mm_camera_stream_config_t stream_config;
-   ALOGE("%s:streamid:%d",__func__,mMmStreamId);
-   Mutex::Autolock lock(mLock);
-   if(mActive){
-       ALOGE("%s: Stream:%d is already active",
-            __func__,mMmStreamId);
-       return rc;
-   }
-
-   if (mInit == true) {
-       /* this is the restart case */
-       memset(&stream_config, 0, sizeof(mm_camera_stream_config_t));
-       stream_config.fmt.fmt=(cam_format_t)mFormat;
-       stream_config.fmt.meta_header=MM_CAMEAR_META_DATA_TYPE_DEF;
-       stream_config.fmt.width=mWidth;
-       stream_config.fmt.height=mHeight;
-       stream_config.fmt.rotation = 0;
-       ALOGE("<DEBUG>::%s: Width :%d Height:%d Format:%d",__func__,mWidth,mHeight,mFormat);
-       stream_config.num_of_bufs=mNumBuffers;
-       stream_config.need_stream_on=true;
-       rc=p_mm_ops->ops->config_stream(mCameraHandle,
-                                 mChannelId,
-                                 mMmStreamId,
-                                 &stream_config);
-       ALOGE("%s: config_stream, rc = %d", __func__, rc);
-   }
-
-   rc = p_mm_ops->ops->start_streams(mCameraHandle,
-                              mChannelId,
-                              1,
-                              &mMmStreamId);
-   if(rc==NO_ERROR)
-       mActive = true;
-   return rc;
-}
-
-int32_t QCameraStream::streamOff(bool isAsyncCmd)
-{
-    status_t rc=NO_ERROR;
-    Mutex::Autolock lock(mLock);
-    if(!mActive) {
-        ALOGE("%s: Stream:%d is not active",
-              __func__,mMmStreamId);
-        return rc;
-    }
-
-    rc = p_mm_ops->ops->stop_streams(mCameraHandle,
-                              mChannelId,
-                              1,
-                              &mMmStreamId);
-
-    mActive=false;
-    return rc;
-
-}
-
-/* initialize a streaming channel*/
-status_t QCameraStream::initStream(mm_camera_img_mode imgmode,
-    cam_format_t format)
-{
-    int rc = MM_CAMERA_OK;
-    status_t ret = NO_ERROR;
-    mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO;
-    cam_ctrl_dimension_t dim;
-    int i;
-    mm_camera_stream_config_t stream_config;
-
-    ALOGE("QCameraStream::initStream : E");
-
-    mFormat = format;
-    /*TODO: Convert between TEMPLATE to img_mode */
-    mExtImgMode = imgmode;
-    /***********Allocate Stream**************/
-
-    rc=p_mm_ops->ops->add_stream(mCameraHandle,
-                        mChannelId,
-                        stream_cb_routine,
-                        (void *)this,
-                        mExtImgMode,
-                        0/*sensor_idx*/);
-
-    if (rc < 0)
-       goto error1;
-
-    mMmStreamId=rc;
-    ALOGE("%s: mMmStreamId = %d\n", __func__, mMmStreamId);
-
-    memset(&stream_config, 0, sizeof(mm_camera_stream_config_t));
-    stream_config.fmt.fmt=format;
-    stream_config.fmt.meta_header=MM_CAMEAR_META_DATA_TYPE_DEF;
-    stream_config.fmt.width=mWidth;
-    stream_config.fmt.height=mHeight;
-    ALOGE("<DEBUG>::%s: Width :%d Height:%d Format:%d",__func__,mWidth,mHeight,format);
-    stream_config.num_of_bufs=mNumBuffers;
-    stream_config.need_stream_on=true;
-    rc=p_mm_ops->ops->config_stream(mCameraHandle,
-                              mChannelId,
-                              mMmStreamId,
-                              &stream_config);
-    if(MM_CAMERA_OK != rc)
-        goto error2;
-
-    goto end;
-
-
-error2:
-    ALOGE("%s: Error configuring stream",__func__);
-    p_mm_ops->ops->del_stream(mCameraHandle,mChannelId,
-                              mMmStreamId);
-
-error1: 
-    return BAD_VALUE;      
-end:
-    ALOGE("Setting mInit to true");
-    mInit=true;
-    return NO_ERROR;
-
-}
-
-status_t QCameraStream::deinitStream()
-{
-
-    int rc = MM_CAMERA_OK;
-
-    ALOGI("%s: E, Stream = %d\n", __func__, mMmStreamId);
-    
-    rc= p_mm_ops->ops->del_stream(mCameraHandle,mChannelId,
-                              mMmStreamId);
-
-    ALOGI("%s: X, Stream = %d\n", __func__, mMmStreamId);
-    mInit=false;
-    return NO_ERROR;
-}
-
-status_t QCameraStream::setMode(int enable) {
-  ALOGE("%s :myMode %x ", __func__, myMode);
-  if (enable) {
-      myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE);
-  } else {
-      myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE);
-  }
-  return NO_ERROR;
-}
-
-status_t QCameraStream::setFormat()
-{
-    ALOGE("%s: E",__func__);
-
-    char mDeviceName[PROPERTY_VALUE_MAX];
-    property_get("ro.product.device",mDeviceName," ");
-
-    ALOGE("%s: X",__func__);
-    return NO_ERROR;
-}
-
-QCameraStream::QCameraStream (){
-    mInit = false;
-    mActive = false;
-    /* memset*/
-    memset(&mCrop, 0, sizeof(mm_camera_rect_t));
-}
-
-QCameraStream::QCameraStream(uint32_t CameraHandle,
-                       uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        mm_camera_vtbl_t *mm_ops,
-                        camera_mode_t mode)
-              :myMode(mode)
-{
-    mInit = false;
-    mActive = false;
-
-    mCameraHandle=CameraHandle;
-    mChannelId=ChannelId;
-    mWidth=Width;
-    mHeight=Height;
-    p_mm_ops=mm_ops;
-
-    /* memset*/
-    memset(&mCrop, 0, sizeof(mm_camera_rect_t));
-
-    mPendingCount=0;
-    pthread_mutex_init(&mFrameDeliveredMutex, NULL);
-    pthread_cond_init(&mFrameDeliveredCond, NULL);
-}
-
-QCameraStream::~QCameraStream () {;}
-
-int QCameraStream::allocateStreamId() {
-    int i = 0;
-    for (i = 0; i < STREAM_TABLE_SIZE; i++)
-        if (mStreamTable[i] == NULL) {
-            mStreamTable[i] = this; 
-            break;
-        }
-    if (i == STREAM_TABLE_SIZE)
-        return INVALID_OPERATION; 
-    ALOGE("%s: mStreamTable[%d] = %p\n", __func__, i, mStreamTable[i]);
-    return i;
-}
-
-int QCameraStream::deallocateStreamId(int id) {
-    if (id < 0 || id >= STREAM_TABLE_SIZE)
-        return BAD_VALUE;
-    mStreamTable[id] = NULL;
-    return OK;
-}
-
-QCameraStream *QCameraStream::getStreamAtId(int id) {
-    if (id < 0 || id >= STREAM_TABLE_SIZE)
-        return NULL;
-    else
-        return mStreamTable[id];
-}
-
-QCameraStream *QCameraStream::getStreamAtMmId(uint32_t mm_id) {
-    /*TODO: More efficient to do direct lookup. But it requires
-     *mm-camera-interface to expose a macro for handle-index mapping*/
-    for (int i = 0; i < STREAM_TABLE_SIZE; i++) {
-        ALOGE("%s: %d: ", __func__, i);
-        if (mStreamTable[i])
-            ALOGE("%s: mMmStreamId = %d", __func__, mStreamTable[i]->mMmStreamId);
-        if (mStreamTable[i] && (mStreamTable[i]->mMmStreamId == mm_id))
-            return mStreamTable[i];
-    }
-    ALOGE("%s: Cannot find stream with interface id %d", __func__, mm_id);
-    return NULL;
-}
-
-void QCameraStream::streamOffAll()
-{
-    for (int i = 0; i < STREAM_TABLE_SIZE; i++) {
-        if (mStreamTable[i]) {
-            if (mStreamTable[i]->mActive) {
-                ALOGI("%s: stream off stream[%d]", __func__, i);
-                mStreamTable[i]->streamOff(0);
-                ALOGI("%s: stream off stream[%d] done", __func__, i);
-            }
-            if (mStreamTable[i]->mInit) {
-                ALOGI("%s: deinit stream[%d]", __func__, i);
-                mStreamTable[i]->deinitStream();
-                ALOGI("%s: deinit stream[%d] done", __func__, i);
-            }
-        }
-    }
-}
-
-status_t QCameraStream::init() {
-    return NO_ERROR;
-}
-
-status_t QCameraStream::start() {
-    return NO_ERROR;
-}
-
-void QCameraStream::stop() {
-    return;
-}
-
-void QCameraStream::release() {
-    return;
-}
-
-void QCameraStream::setHALCameraControl(QCameraHardwareInterface* ctrl) {
-
-    /* provide a frame data user,
-    for the  queue monitor thread to call the busy queue is not empty*/
-    mHalCamCtrl = ctrl;
-}
-
-}; // namespace android
diff --git a/camera/QCamera/HAL2/core/src/QCameraStream_Preview.cpp b/camera/QCamera/HAL2/core/src/QCameraStream_Preview.cpp
deleted file mode 100644
index 54a95a6..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraStream_Preview.cpp
+++ /dev/null
@@ -1,591 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_TAG "QCameraHWI_Preview"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-#include <genlock.h>
-#include <gralloc_priv.h>
-
-#define UNLIKELY(exp) __builtin_expect(!!(exp), 0)
-
-/* QCameraHWI_Preview class implementation goes here*/
-/* following code implement the preview mode's image capture & display logic of this class*/
-
-namespace android {
-
-status_t QCameraStream_preview::setPreviewWindow(const camera2_stream_ops_t* window)
-{
-    status_t retVal = NO_ERROR;
-    ALOGE(" %s: E ", __FUNCTION__);
-    if( window == NULL) {
-        ALOGW(" Setting NULL preview window ");
-        /* TODO: Current preview window will be invalidated.
-         * Release all the buffers back */
-       // relinquishBuffers();
-    }
-    Mutex::Autolock lock(mLock);
-    mPreviewWindow = window;
-    ALOGV(" %s : X ", __FUNCTION__ );
-    return retVal;
-}
-
-int QCameraStream_preview::registerStreamBuffers(int num_buffers,
-        buffer_handle_t *buffers)
-{
-    int err;
-
-    mNumBuffers = num_buffers;
-    mPreviewMemory.buffer_count = num_buffers;
-    for (int i = 0; i < num_buffers; i++) {
-        mPreviewMemory.buffer_handle[i] = buffers[i];
-        mPreviewMemory.private_buffer_handle[i] = (struct private_handle_t *)buffers[i];
-        ALOGD("%s:Buffer Size:%d",__func__, mPreviewMemory.private_buffer_handle[i]->size);
-    }
-    mDisplayBuf = new mm_camera_buf_def_t[num_buffers];
-    if (!mDisplayBuf) {
-        ALOGE("Unable to allocate mDisplayBuf");
-        return NO_MEMORY;
-    }
-
-   return OK;
-}
-
-status_t QCameraStream_preview::initBuffers()
-{
-    status_t ret = NO_ERROR;
-    int width = mWidth;  /* width of channel  */
-    int height = mHeight; /* height of channel */
-    uint32_t frame_len = mFrameOffsetInfo.frame_len; /* frame planner length */
-    int buffer_num = mNumBuffers; /* number of buffers for display */
-    const char *pmem_region;
-    uint8_t num_planes = mFrameOffsetInfo.num_planes;
-    uint32_t planes[VIDEO_MAX_PLANES];
-    void *vaddr = NULL;
-    buffer_handle_t *buffer_handle;
-
-    ALOGE("%s:BEGIN",__func__);
-    memset(mNotifyBuffer, 0, sizeof(mNotifyBuffer));
-
-    this->myMode=myMode; /*Need to assign this in constructor after translating from mask*/
-    num_planes = mFrameOffsetInfo.num_planes;
-    for(int i=0; i < num_planes; i++)
-        planes[i] = mFrameOffsetInfo.mp[i].len;
-
-
-    mPreviewMemoryLock.lock();
-    memset(mDisplayBuf, 0, sizeof(mm_camera_buf_def_t) * mNumBuffers);
-
-    /*allocate memory for the buffers*/
-    for(int i = 0; i < mNumBuffers; i++){
-        mDisplayBuf[i].num_planes = num_planes;
-        mDisplayBuf[i].buf_idx = i;
-
-        /* Plane 0 needs to be set seperately. Set other planes
-         * in a loop. */
-        mDisplayBuf[i].planes[0].length = planes[0];
-        mDisplayBuf[i].planes[0].m.userptr = mPreviewMemory.private_buffer_handle[i]->fd;
-        mDisplayBuf[i].planes[0].data_offset = mFrameOffsetInfo.mp[0].offset;
-        mDisplayBuf[i].planes[0].reserved[0] =0;
-        for (int j = 1; j < num_planes; j++) {
-            mDisplayBuf[i].planes[j].length = planes[j];
-            mDisplayBuf[i].planes[j].m.userptr = mPreviewMemory.private_buffer_handle[i]->fd;
-            mDisplayBuf[i].planes[j].data_offset = mFrameOffsetInfo.mp[j].offset;
-            mDisplayBuf[i].planes[j].reserved[0] =
-            mDisplayBuf[i].planes[j-1].reserved[0] +
-            mDisplayBuf[i].planes[j-1].length;
-        }
-
-        for (int j = 0; j < num_planes; j++)
-            ALOGE("Planes: %d length: %d userptr: %lu offset: %d\n", j,
-                     mDisplayBuf[i].planes[j].length,
-                     mDisplayBuf[i].planes[j].m.userptr,
-                     mDisplayBuf[i].planes[j].reserved[0]);
-
-        mDisplayBuf[i].stream_id = mMmStreamId;
-        mDisplayBuf[i].fd = mPreviewMemory.private_buffer_handle[i]->fd;
-        ALOGE("DEBUG2:Display buf[%d] fd:%d",i,mDisplayBuf[i].fd);
-        mDisplayBuf[i].frame_len = mFrameOffsetInfo.frame_len;
-    }/*end of for loop*/
-
-    /* Dequeue N frames from native window and queue into interface. Only dequeue our requested buffers */
-    for (int i = 0; i < mNumBuffers; i++)
-        mPreviewMemory.local_flag[i] = BUFFER_NOT_REGGED;
-    for (int i = 0; i < OPAQUE_BUFFER_COUNT; i++) {
-        ALOGE("mPreview Window %p",mPreviewWindow);
-        int err = mPreviewWindow->dequeue_buffer(mPreviewWindow, &buffer_handle);
-        if (err == NO_ERROR && buffer_handle) {
-            int j;
-            for (j = 0; j < mPreviewMemory.buffer_count; j++) {
-                if (mPreviewMemory.buffer_handle[j] == *buffer_handle) {
-                    mPreviewMemory.local_flag[j] = BUFFER_OWNED;
-                    ALOGE("%s: [%d]: local_flag = 1", __func__, j);
-                    break;
-                }
-            }
-            if (j == mPreviewMemory.buffer_count) {
-                ALOGE("Cannot find matching handle in the table.");
-                return INVALID_OPERATION;
-            }
-        } else {
-            ALOGE("dequeue_buffer failed.");
-            return INVALID_OPERATION;
-        }
-    }
-
-    /* register the streaming buffers for the channel*/
-    mPreviewMemoryLock.unlock();
-    ALOGE("%s:END",__func__);
-    return NO_ERROR;
-
-error:
-    mPreviewMemoryLock.unlock();
-
-    ALOGV("%s: X", __func__);
-    return ret;
-}
-
-void QCameraStream_preview::deinitBuffers()
-{
-    mPreviewMemoryLock.lock();
-    for (int i = 0; i < mNumBuffers; i++) {
-        if (mPreviewMemory.local_flag[i] == BUFFER_OWNED) {
-            mPreviewWindow->cancel_buffer(mPreviewWindow,
-                &mPreviewMemory.buffer_handle[i]);
-            mPreviewMemory.local_flag[i] = BUFFER_NOT_OWNED;
-        }
-    }
-    mPreviewMemoryLock.unlock();
-}
-
-void QCameraStream_preview::dumpFrameToFile(mm_camera_buf_def_t *newFrame)
-{
-  int32_t enabled = 0;
-  int frm_num;
-  uint32_t  skip_mode;
-  char value[PROPERTY_VALUE_MAX];
-  char buf[32];
-  int w, h;
-  static int count = 0;
-  int file_fd;
-  int rc = 0;
-  int len;
-  unsigned long addr;
-  unsigned long * tmp = (unsigned long *)newFrame->buffer;
-  addr = *tmp;
-
-  len = newFrame->frame_len;
-  count++;
-  if(count < 100) {
-    snprintf(buf, sizeof(buf), "/data/mzhu%d.yuv", count);
-    file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-
-    rc = write(file_fd, (const void *)addr, len);
-    ALOGE("%s: file='%s', vaddr_old=0x%x, addr_map = 0x%p, len = %d, rc = %d",
-          __func__, buf, (uint32_t)newFrame->buffer, (void *)addr, len, rc);
-    close(file_fd);
-    ALOGE("%s: dump %s, rc = %d, len = %d", __func__, buf, rc, len);
-  }
-}
-
-int QCameraStream_preview::prepareStream()
-{
-    mm_camera_img_mode img_mode;
-    cam_format_t format;
-    struct private_handle_t *private_handle = mPreviewMemory.private_buffer_handle[0];
-
-    ALOGE("%s: private_handle->format = %d, flags = %d", __func__,
-        private_handle->format, private_handle->flags);
-    if (private_handle->flags & private_handle_t::PRIV_FLAGS_VIDEO_ENCODER)
-        img_mode = MM_CAMERA_VIDEO;
-    else if (private_handle->flags & private_handle_t::PRIV_FLAGS_CAMERA_WRITE)
-        img_mode = MM_CAMERA_PREVIEW;
-    else {
-        ALOGE("%s: Invalid flags %d\n", __func__, private_handle->flags);
-        return BAD_VALUE;
-    }
-
-    switch (private_handle->format) {
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
-        format = CAMERA_YUV_420_NV12;
-        break;
-    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
-        format = CAMERA_YUV_420_NV21;
-        break;
-    default:
-        ALOGE("%s: Invalid format!!!", __func__);
-        return BAD_VALUE;
-    }
-    if(NO_ERROR!=initStream(img_mode, format)) {
-        ALOGE("Init stream failed");
-        return BAD_VALUE;
-    }
-    return OK;
-}
-
-status_t QCameraStream_preview::processPreviewFrame (
-  mm_camera_super_buf_t *frame)
-{
-    ALOGV("%s",__func__);
-    int err = 0;
-    int msgType = 0;
-    int i;
-    camera_frame_metadata_t *metadata = NULL;
-
-    Mutex::Autolock lock(mLock);
-    if(!mActive) {
-        ALOGE("Preview Stopped. Returning callback");
-        return NO_ERROR;
-    }
-
-    if(mHalCamCtrl==NULL) {
-        ALOGE("%s: X: HAL control object not set",__func__);
-       /*Call buf done*/
-       return BAD_VALUE;
-    }
-    nsecs_t timeStamp = seconds_to_nanoseconds(frame->bufs[0]->ts.tv_sec) ;
-    timeStamp += frame->bufs[0]->ts.tv_nsec;
-
-    if(mFirstFrameRcvd == false) {
-        //mm_camera_util_profile("HAL: First preview frame received");
-        mFirstFrameRcvd = true;
-    }
-
-    //  dumpFrameToFile(frame->bufs[0]);
-
-    mPreviewMemoryLock.lock();
-    mNotifyBuffer[frame->bufs[0]->buf_idx] = *frame;
-    ALOGE("processPreviewFrame: timeStamp = %lld", (int64_t)timeStamp);
-    err = mPreviewWindow->enqueue_buffer(mPreviewWindow, (int64_t)timeStamp,
-                  &mPreviewMemory.buffer_handle[frame->bufs[0]->buf_idx]);
-    if(err != 0) {
-        ALOGE("%s: enqueue_buffer failed, err = %d", __func__, err);
-    }
-    mPreviewMemory.local_flag[frame->bufs[0]->buf_idx] = BUFFER_NOT_OWNED;
-
-    buffer_handle_t *buffer_handle = NULL;
-    err = mPreviewWindow->dequeue_buffer(mPreviewWindow, &buffer_handle);
-    if (err == NO_ERROR && buffer_handle != NULL) {
-        int rc = MM_CAMERA_OK;
-        ALOGD("%s: dequed buf hdl =%p", __func__, *buffer_handle);
-        for(i = 0; i < mPreviewMemory.buffer_count; i++) {
-            if(mPreviewMemory.buffer_handle[i] == *buffer_handle) {
-                ALOGE("<DEBUG2>:Found buffer in idx:%d",i);
-                break;
-            }
-        }
-        if (mPreviewMemory.local_flag[i] == BUFFER_NOT_REGGED) {
-            mm_camera_buf_def_t buf = mDisplayBuf[i];
-            mPreviewMemory.local_flag[i] = BUFFER_OWNED;
-            rc = p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, &buf);
-        } else {
-            mPreviewMemory.local_flag[i] = BUFFER_OWNED;
-            rc = p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mNotifyBuffer[i].bufs[0]);
-        }
-
-        if(rc != MM_CAMERA_OK) {
-            /* how to handle the error of qbuf? */
-            ALOGE("BUF DONE FAILED");
-        }
-    }
-    /* Save the last displayed frame. We'll be using it to fill the gap between
-       when preview stops and postview start during snapshot.*/
-    mLastQueuedFrame = &(mDisplayBuf[frame->bufs[0]->buf_idx]);
-    mPreviewMemoryLock.unlock();
-
-    return NO_ERROR;
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-QCameraStream_preview::QCameraStream_preview(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        int requestedFormat,
-                        mm_camera_vtbl_t *mm_ops,
-                        camera_mode_t mode) :
-                 QCameraStream(CameraHandle,
-                        ChannelId,
-                        Width,
-                        Height,
-                        mm_ops,
-                        mode),
-                 mLastQueuedFrame(NULL),
-                 mDisplayBuf(NULL),
-                 mNumFDRcvd(0)
-{
-    mHalCamCtrl = NULL;
-    ALOGE("%s: E", __func__);
-
-    mStreamId = allocateStreamId();
-
-    switch (requestedFormat) {
-    case CAMERA2_HAL_PIXEL_FORMAT_OPAQUE:
-        mMaxBuffers = 5;
-        break;
-    case HAL_PIXEL_FORMAT_BLOB:
-        mMaxBuffers = 1;
-        break;
-    default:
-        ALOGE("Unsupported requested format %d", requestedFormat);
-        mMaxBuffers = 1;
-        break;
-    }
-    /*TODO: There has to be a better way to do this*/
-    ALOGE("%s: X", __func__);
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-QCameraStream_preview::~QCameraStream_preview() {
-    ALOGV("%s: E", __func__);
-	if(mActive) {
-		streamOff(0);
-	}
-	if(mInit) {
-		deinitStream();
-	}
-	mInit = false;
-	mActive = false;
-    if (mDisplayBuf) {
-        delete[] mDisplayBuf;
-        mDisplayBuf = NULL;
-    }
-    deallocateStreamId(mStreamId);
-    ALOGV("%s: X", __func__);
-
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-status_t QCameraStream_preview::init()
-{
-    status_t ret = NO_ERROR;
-    ALOGV("%s: E", __func__);
-
-#if 0
-    if (!(myMode & CAMERA_ZSL_MODE)) {
-        ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO");
-        mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO;
-        ret = p_mm_ops->ops->set_parm (mCameraHandle, MM_CAMERA_PARM_OP_MODE,
-                                        &op_mode);
-        ALOGE("OP Mode Set");
-
-        if(MM_CAMERA_OK != ret) {
-          ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_VIDEO err=%d\n", __func__, ret);
-          return BAD_VALUE;
-        }
-    }else {
-        ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_ZSL");
-        mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_ZSL;
-        ret =p_mm_ops->ops->set_parm (mCameraHandle, MM_CAMERA_PARM_OP_MODE,
-                                        &op_mode);
-        if(MM_CAMERA_OK != ret) {
-          ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_ZSL err=%d\n", __func__, ret);
-          return BAD_VALUE;
-        }
-     }
-
-    setFormat();
-    ret = QCameraStream::initStream();
-    if (NO_ERROR!=ret) {
-        ALOGE("%s E: can't init native cammera preview ch\n",__func__);
-        return ret;
-    }
-
-  mInit = true;
-#endif
-  return ret;
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-status_t QCameraStream_preview::start()
-{
-    ALOGV("%s: E", __func__);
-    status_t ret = NO_ERROR;
-
-    Mutex::Autolock lock(mLock);
-
-    /* call start() in parent class to start the monitor thread*/
-    //QCameraStream::start ();
-
-#if 0
-    ret = cam_config_prepare_buf(mCameraId, &mDisplayBuf);
-    ALOGE("Debug : %s : cam_config_prepare_buf",__func__);
-    if(ret != MM_CAMERA_OK) {
-        ALOGV("%s:reg preview buf err=%d\n", __func__, ret);
-        ret = BAD_VALUE;
-        goto error;
-    }else {
-        ret = NO_ERROR;
-    }
-#endif
-    /* For preview, the OP_MODE we set is dependent upon whether we are
-       starting camera or camcorder. For snapshot, anyway we disable preview.
-       However, for ZSL we need to set OP_MODE to OP_MODE_ZSL and not
-       OP_MODE_VIDEO. We'll set that for now in CamCtrl. So in case of
-       ZSL we skip setting Mode here */
-
-
-    /* call mm_camera action start(...)  */
-    ALOGE("Starting Preview/Video Stream. ");
-    mFirstFrameRcvd = false;
-
-    ALOGE("Starting Preview/Video Stream. ");
-    ret = streamOn();
-    if (MM_CAMERA_OK != ret) {
-      ALOGE ("%s: preview streaming start err=%d\n", __func__, ret);
-      ret = BAD_VALUE;
-      goto end;
-    }
-
-    ALOGE("Debug : %s : Preview streaming Started",__func__);
-    ret = NO_ERROR;
-
-    mActive =  true;
-    goto end;
-
-end:
-    ALOGE("%s: X", __func__);
-    return ret;
-  }
-
-
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-  void QCameraStream_preview::stop() {
-    ALOGE("%s: E", __func__);
-    int ret=MM_CAMERA_OK;
-
-    if(!mActive) {
-      return;
-    }
-    Mutex::Autolock lock(mLock);
-    mActive =  false;
-    /* unregister the notify fn from the mmmm_camera_t object*/
-
-    ALOGI("%s: Stop the thread \n", __func__);
-    /* call stop() in parent class to stop the monitor thread*/
-    //stream_info = mHalCamCtrl->getChannelInterface();
-
-    ret = streamOff(0);
-    if(MM_CAMERA_OK != ret) {
-      ALOGE ("%s: camera preview stop err=%d\n", __func__, ret);
-    }
-#if 0
-    ret = cam_config_unprepare_buf(mCameraId, MM_CAMERA_CH_PREVIEW);
-    if(ret != MM_CAMERA_OK) {
-      ALOGE("%s:Unreg preview buf err=%d\n", __func__, ret);
-      //ret = BAD_VALUE;
-    }
-#endif
-    /* In case of a clean stop, we need to clean all buffers*/
-    ALOGE("Debug : %s : Buffer Unprepared",__func__);
-    /*free camera_memory handles and return buffer back to surface*/
-    ret= QCameraStream::deinitStream();
-    ALOGE(": %s : De init Channel",__func__);
-    if(ret != MM_CAMERA_OK) {
-      ALOGE("%s:Deinit preview channel failed=%d\n", __func__, ret);
-      //ret = BAD_VALUE;
-    }
-    ALOGE("%s: X", __func__);
-
-  }
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-  void QCameraStream_preview::release() {
-
-    ALOGE("%s : BEGIN",__func__);
-    int ret=MM_CAMERA_OK,i;
-
-    if(!mInit)
-    {
-      ALOGE("%s : Stream not Initalized",__func__);
-      return;
-    }
-
-    if(mActive) {
-      this->streamOff(0);
-    }
-
-
-    if(mInit) {
-        deinitStream();
-    }
-    mInit = false;
-    ALOGE("%s: END", __func__);
-
-  }
-
-QCameraStream*
-QCameraStream_preview::createInstance(uint32_t CameraHandle,
-                        uint32_t ChannelId,
-                        uint32_t Width,
-                        uint32_t Height,
-                        int requestedFormat,
-                        mm_camera_vtbl_t *mm_ops,
-                        camera_mode_t mode)
-{
-  QCameraStream* pme = new QCameraStream_preview(CameraHandle,
-                        ChannelId,
-                        Width,
-                        Height,
-                        requestedFormat,
-                        mm_ops,
-                        mode);
-  return pme;
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-void QCameraStream_preview::deleteInstance(QCameraStream *p)
-{
-  if (p){
-    ALOGV("%s: BEGIN", __func__);
-    p->release();
-    delete p;
-    p = NULL;
-    ALOGV("%s: END", __func__);
-  }
-}
-
-
-/* Temp helper function */
-void *QCameraStream_preview::getLastQueuedFrame(void)
-{
-    return mLastQueuedFrame;
-}
-
-// ---------------------------------------------------------------------------
-// No code beyone this line
-// ---------------------------------------------------------------------------
-}; // namespace android
diff --git a/camera/QCamera/HAL2/test/Android.mk b/camera/QCamera/HAL2/test/Android.mk
deleted file mode 100644
index 8b13789..0000000
--- a/camera/QCamera/HAL2/test/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/camera/QCamera/HAL2/wrapper/QualcommCamera.cpp b/camera/QCamera/HAL2/wrapper/QualcommCamera.cpp
deleted file mode 100644
index c06bf33..0000000
--- a/camera/QCamera/HAL2/wrapper/QualcommCamera.cpp
+++ /dev/null
@@ -1,646 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- *
- */
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QualcommCamera"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraHAL.h"
-/* include QCamera Hardware Interface Header*/
-#include "QualcommCamera.h"
-
-extern "C" {
-#include <sys/time.h>
-}
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-
-static hw_module_methods_t camera_module_methods = {
-    open: camera_device_open,
-};
-
-static hw_module_t camera_common  = {
-    tag: HARDWARE_MODULE_TAG,
-    module_api_version: CAMERA_MODULE_API_VERSION_2_0,
-    hal_api_version: HARDWARE_HAL_API_VERSION,
-    id: CAMERA_HARDWARE_MODULE_ID,
-    name: "Qcamera",
-    author:"Qcom",
-    methods: &camera_module_methods,
-    dso: NULL,
-    reserved:  {0},
-};
-
-camera_module_t HAL_MODULE_INFO_SYM = {
-    common: camera_common,
-    get_number_of_cameras: get_number_of_cameras,
-    get_camera_info: get_camera_info,
-};
-
-camera2_device_ops_t camera_ops = {
-    set_request_queue_src_ops:           android::set_request_queue_src_ops,
-    notify_request_queue_not_empty:      android::notify_request_queue_not_empty,
-    set_frame_queue_dst_ops:             android::set_frame_queue_dst_ops,
-    get_in_progress_count:               android::get_in_progress_count,
-    flush_captures_in_progress:          android::flush_captures_in_progress,
-    construct_default_request:           android::construct_default_request,
-
-    allocate_stream:                     android::allocate_stream,
-    register_stream_buffers:             android::register_stream_buffers,
-    release_stream:                      android::release_stream,
-
-    allocate_reprocess_stream:           android::allocate_reprocess_stream,
-    allocate_reprocess_stream_from_stream: android::allocate_reprocess_stream_from_stream,
-    release_reprocess_stream:            android::release_reprocess_stream,
-
-    trigger_action:                      android::trigger_action,
-    set_notify_callback:                 android::set_notify_callback,
-    get_metadata_vendor_tag_ops:         android::get_metadata_vendor_tag_ops,
-    dump:                                android::dump,
-};
-
-namespace android {
-
-typedef struct {
-  camera2_device_t hw_dev;
-  QCameraHardwareInterface *hardware;
-  int camera_released;
-  int cameraId;
-} camera_hardware_t;
-
-QCameraHardwareInterface *util_get_Hal_obj(const camera2_device_t * device)
-{
-    QCameraHardwareInterface *hardware = NULL;
-    if(device && device->priv){
-        camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
-        hardware = camHal->hardware;
-    }
-    return hardware;
-}
-
-extern "C" int get_number_of_cameras()
-{
-    /* try to query every time we get the call!*/
-    ALOGE("Q%s: E", __func__);
-    return android::HAL_getNumberOfCameras();
-}
-
-extern "C" int get_camera_info(int camera_id, struct camera_info *info)
-{
-    int rc = -1;
-    ALOGE("Q%s: E, id = %d", __func__, camera_id);
-    if(info) {
-        rc = android::HAL_getCameraInfo(camera_id, info);
-    }
-    ALOGE("Q%s: X, id = %d", __func__, camera_id);
-    return rc;
-}
-
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" int  camera_device_open(
-  const struct hw_module_t* module, const char* id,
-          struct hw_device_t** hw_device)
-{
-    int rc = -1;
-    int mode = 0;
-    camera2_device_t *device = NULL;
-    ALOGE("Q%s: E, id = %s", __func__, id);
-    if(module && id && hw_device) {
-        int cameraId = atoi(id);
-
-        if (!strcmp(module->name, camera_common.name)) {
-            camera_hardware_t *camHal =
-                (camera_hardware_t *) malloc(sizeof (camera_hardware_t));
-            if(!camHal) {
-                *hw_device = NULL;
-	        ALOGE("%s:  end in no mem", __func__);
-		return rc;
-	    }
-            /* we have the camera_hardware obj malloced */
-            memset(camHal, 0, sizeof (camera_hardware_t));
-            camHal->hardware = new QCameraHardwareInterface(cameraId, mode);
-            if (camHal->hardware && camHal->hardware->isCameraReady()) {
-		camHal->cameraId = cameraId;
-	        device = &camHal->hw_dev;
-                device->common.close = close_camera_device;
-                device->common.version = CAMERA_DEVICE_API_VERSION_2_0;
-                device->ops = &camera_ops;
-                device->priv = (void *)camHal;
-                rc =  0;
-            } else {
-                if (camHal->hardware) {
-                    delete camHal->hardware;
-                    camHal->hardware = NULL;
-                }
-                free(camHal);
-                device = NULL;
-            }
-        }
-    }
-    /* pass actual hw_device ptr to framework. This amkes that we actally be use memberof() macro */
-    *hw_device = (hw_device_t*)&device->common;
-    ALOGE("%s:  end rc %d", __func__, rc);
-    return rc;
-}
-
-extern "C" int close_camera_device(hw_device_t *hw_dev)
-{
-    ALOGE("Q%s: device =%p E", __func__, hw_dev);
-    int rc =  -1;
-    camera2_device_t *device = (camera2_device_t *)hw_dev;
-
-    if(device) {
-        camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
-        if(camHal ) {
-            QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-            if(!camHal->camera_released) {
-                if(hardware != NULL) {
-                    hardware->release( );
-                }
-            }
-            if(hardware != NULL)
-                delete hardware;
-            free(camHal);
-        }
-        rc = 0;
-    }
-    return rc;
-}
-
-int set_request_queue_src_ops(const struct camera2_device *device,
-    const camera2_request_queue_src_ops_t *request_src_ops)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
-    if(hardware != NULL) {
-        rc = hardware->set_request_queue_src_ops(request_src_ops);
-    }
-    return rc;
-}
-
-int notify_request_queue_not_empty(const struct camera2_device *device)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    
-    if(hardware != NULL) {
-        rc = hardware->notify_request_queue_not_empty();
-    }
-    return rc;
-}
-
-int set_frame_queue_dst_ops(const struct camera2_device *device,
-    const camera2_frame_queue_dst_ops_t *frame_dst_ops)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    
-    if(hardware != NULL) {
-        rc = hardware->set_frame_queue_dst_ops(frame_dst_ops);
-    }
-    return rc;
-}
-
-int get_in_progress_count(const struct camera2_device *device)
-{
-    int rc = INVALID_OPERATION;
-    ALOGE("%s:E",__func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    
-    if(hardware != NULL) {
-        rc = hardware->get_in_progress_count();
-    }
-    ALOGE("%s:X",__func__);
-    return rc;
-}
-
-int flush_captures_in_progress(const struct camera2_device *)
-{
-    ALOGE("%s:E",__func__);
-    ALOGE("%s:X",__func__);
-    return INVALID_OPERATION;
-}
-
-int construct_default_request(const struct camera2_device *device,
-    int request_template,
-    camera_metadata_t **request)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    
-    if(hardware != NULL) {
-        rc = hardware->construct_default_request(request_template, request);
-    }
-    return rc;
-}
-
-int allocate_stream(const struct camera2_device *device,
-        uint32_t width,
-        uint32_t height,
-        int      format,
-        const camera2_stream_ops_t *stream_ops,
-        uint32_t *stream_id,
-        uint32_t *format_actual,
-        uint32_t *usage,
-        uint32_t *max_buffers)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    
-    if(hardware != NULL) {
-        rc = hardware->allocate_stream(width, height, format, stream_ops,
-            stream_id, format_actual, usage, max_buffers);
-    }
-    return rc;
-}
-
-int register_stream_buffers(
-        const struct camera2_device *device,
-        uint32_t stream_id,
-        int num_buffers,
-        buffer_handle_t *buffers)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    
-    if(hardware != NULL) {
-        rc = hardware->register_stream_buffers(stream_id, num_buffers, buffers);
-    }
-    return rc;
-}
-
-int release_stream(
-        const struct camera2_device *device,
-        uint32_t stream_id)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    
-    if(hardware != NULL) {
-        rc = hardware->release_stream(stream_id);
-    }
-    return rc;
-}
-
-int allocate_reprocess_stream(const struct camera2_device *,
-        uint32_t width,
-        uint32_t height,
-        uint32_t format,
-        const camera2_stream_in_ops_t *reprocess_stream_ops,
-        uint32_t *stream_id,
-        uint32_t *consumer_usage,
-        uint32_t *max_buffers)
-{
-    return INVALID_OPERATION;
-}
-
-int allocate_reprocess_stream_from_stream(const struct camera2_device *,
-        uint32_t output_stream_id,
-        const camera2_stream_in_ops_t *reprocess_stream_ops,
-        uint32_t *stream_id)
-{
-    return INVALID_OPERATION;
-}
-
-int release_reprocess_stream(
-        const struct camera2_device *,
-        uint32_t stream_id)
-{
-    return INVALID_OPERATION;
-}
-
-int trigger_action(const struct camera2_device *,
-        uint32_t trigger_id,
-        int32_t ext1,
-        int32_t ext2)
-{
-    return INVALID_OPERATION;
-}
-
-int set_notify_callback(const struct camera2_device *device,
-        camera2_notify_callback notify_cb,
-        void *user)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
-    if(hardware != NULL) {
-        rc = hardware->set_notify_callback(notify_cb, user);
-    }
-    return rc;
-}
-
-int get_metadata_vendor_tag_ops(const struct camera2_device *device,
-        vendor_tag_query_ops_t **ops)
-{
-    int rc = INVALID_OPERATION;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
-    if(hardware != NULL) {
-        rc = hardware->get_metadata_vendor_tag_ops(ops);
-    }
-    return rc;
-}
-
-int dump(const struct camera2_device *, int fd)
-{
-    return INVALID_OPERATION;
-}
-
-#if 0
-int set_preview_window(camera2_device_t * device,
-        struct preview_stream_ops *window)
-{
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
-    if(hardware != NULL) {
-        rc = hardware->setPreviewWindow(window);
-    }
-    return rc;
-}
-
-void set_CallBacks(camera2_device_t * 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)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->setCallbacks(notify_cb,data_cb, data_cb_timestamp, get_memory, user);
-    }
-}
-
-void enable_msg_type(camera2_device_t * device, int32_t msg_type)
-{
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->enableMsgType(msg_type);
-    }
-}
-
-void disable_msg_type(camera2_device_t * device, int32_t msg_type)
-{
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    ALOGE("Q%s: E", __func__);
-    if(hardware != NULL){
-        hardware->disableMsgType(msg_type);
-    }
-}
-
-int msg_type_enabled(camera2_device_t * device, int32_t msg_type)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->msgTypeEnabled(msg_type);
-    }
-    return rc;
-}
-
-int start_preview(camera2_device_t * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->startPreview( );
-    }
-    ALOGE("Q%s: X", __func__);
-    return rc;
-}
-
-void stop_preview(camera2_device_t * device)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->stopPreview( );
-    }
-}
-
-int preview_enabled(camera2_device_t * device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->previewEnabled( );
-    }
-    return rc;
-}
-
-int store_meta_data_in_buffers(camera2_device_t *device, int enable)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-      rc = hardware->storeMetaDataInBuffers(enable);
-    }
-    return rc;
-}
-
-int start_recording(camera2_device_t *device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->startRecording( );
-    }
-    return rc;
-}
-
-void stop_recording(camera2_device_t *device)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->stopRecording( );
-    }
-}
-
-int recording_enabled(camera2_device_t *device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->recordingEnabled( );
-    }
-    return rc;
-}
-
-void release_recording_frame(camera2_device_t *device,
-                const void *opaque)
-{
-    ALOGV("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        hardware->releaseRecordingFrame(opaque);
-    }
-}
-
-int auto_focus(camera2_device_t *device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->autoFocus( );
-    }
-    return rc;
-}
-
-int cancel_auto_focus(camera2_device_t *device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->cancelAutoFocus( );
-    }
-    return rc;
-}
-
-int take_picture(camera2_device_t *device)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->takePicture( );
-    }
-    return rc;
-}
-
-int cancel_picture(camera2_device_t *device)
-
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->cancelPicture( );
-    }
-    return rc;
-}
-
-int set_parameters(camera2_device_t *device, const char *parms)
-
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL && parms){
-        //QCameraParameters param;// = util_get_HAL_parameter(device);
-        //String8 str = String8(parms);
-
-        //param.unflatten(str);
-        rc = hardware->setParameters(parms);
-        //rc = 0;
-  }
-  return rc;
-}
-
-char* get_parameters(camera2_device_t *device)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-		char *parms = NULL;
-        hardware->getParameters(&parms);
-		return parms;
-    }
-    return NULL;
-}
-
-void put_parameters(camera2_device_t *device, char *parm)
-
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-      hardware->putParameters(parm);
-    }
-}
-
-int send_command(camera2_device_t *device,
-            int32_t cmd, int32_t arg1, int32_t arg2)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->sendCommand( cmd, arg1, arg2);
-    }
-    return rc;
-}
-
-void release(camera2_device_t *device)
-{
-    ALOGE("Q%s: E", __func__);
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
-        hardware->release( );
-        camHal->camera_released = true;
-    }
-}
-
-int dump(camera2_device_t *device, int fd)
-{
-    ALOGE("Q%s: E", __func__);
-    int rc = -1;
-    QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-    if(hardware != NULL){
-        rc = hardware->dump( fd );
-    }
-    return rc;
-}
-#endif
-
-}; // namespace android
diff --git a/camera/QCamera/HAL2/wrapper/QualcommCamera.h b/camera/QCamera/HAL2/wrapper/QualcommCamera.h
deleted file mode 100644
index 64ebc7c..0000000
--- a/camera/QCamera/HAL2/wrapper/QualcommCamera.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 ANDROID_HARDWARE_QUALCOMM_CAMERA_H
-#define ANDROID_HARDWARE_QUALCOMM_CAMERA_H
-
-#include <hardware/camera2.h>
-
-extern "C" {
-
-  int get_number_of_cameras();
-  int get_camera_info(int camera_id, struct camera_info *info);
-
-  int camera_device_open(const struct hw_module_t* module, const char* id,
-          struct hw_device_t** device);
-
-  hw_device_t * open_camera_device(int cameraId);
-
-  int close_camera_device( hw_device_t *);
-
-namespace android {
-  int set_request_queue_src_ops(const struct camera2_device *,
-    const camera2_request_queue_src_ops_t *request_src_ops);
-
-  int notify_request_queue_not_empty(const struct camera2_device *);
-
-  int set_frame_queue_dst_ops(const struct camera2_device *,
-    const camera2_frame_queue_dst_ops_t *frame_dst_ops);
-
-  int get_in_progress_count(const struct camera2_device *);
-
-  int flush_captures_in_progress(const struct camera2_device *);
-
-  int construct_default_request(const struct camera2_device *,
-    int request_template,
-    camera_metadata_t **request);
-
-  int allocate_stream(const struct camera2_device *,
-        uint32_t width,
-        uint32_t height,
-        int      format,
-        const camera2_stream_ops_t *stream_ops,
-        uint32_t *stream_id,
-        uint32_t *format_actual,
-        uint32_t *usage,
-        uint32_t *max_buffers);
-
-  int register_stream_buffers(
-        const struct camera2_device *,
-        uint32_t stream_id,
-        int num_buffers,
-        buffer_handle_t *buffers);
-
-  int release_stream(
-        const struct camera2_device *,
-        uint32_t stream_id);
-
-  int allocate_reprocess_stream(const struct camera2_device *,
-        uint32_t width,
-        uint32_t height,
-        uint32_t format,
-        const camera2_stream_in_ops_t *reprocess_stream_ops,
-        uint32_t *stream_id,
-        uint32_t *consumer_usage,
-        uint32_t *max_buffers);
-
-  int allocate_reprocess_stream_from_stream(const struct camera2_device *,
-        uint32_t output_stream_id,
-        const camera2_stream_in_ops_t *stream_ops,
-        uint32_t *stream_id);
-
-  int release_reprocess_stream(
-        const struct camera2_device *,
-        uint32_t stream_id);
-
-  int trigger_action(const struct camera2_device *,
-        uint32_t trigger_id,
-        int32_t ext1,
-        int32_t ext2);
-
-  int set_notify_callback(const struct camera2_device *,
-        camera2_notify_callback notify_cb,
-        void *user);
-
-  int get_metadata_vendor_tag_ops(const struct camera2_device*,
-        vendor_tag_query_ops_t **ops);
-
-  int dump(const struct camera2_device *, int fd);
-}; // namespace android
-
-} //extern "C"
-
-#endif
diff --git a/camera/QCamera/stack/Android.mk b/camera/QCamera/stack/Android.mk
deleted file mode 100755
index 9bd33b3..0000000
--- a/camera/QCamera/stack/Android.mk
+++ /dev/null
@@ -1,4 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(LOCAL_PATH)/mm-camera-interface/Android.mk
-include $(LOCAL_PATH)/mm-jpeg-interface/Android.mk
-include $(LOCAL_PATH)/mm-camera-test/Android.mk
diff --git a/camera/QCamera/stack/common/cam_list.h b/camera/QCamera/stack/common/cam_list.h
deleted file mode 100755
index ea30d7f..0000000
--- a/camera/QCamera/stack/common/cam_list.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-/* This file is a slave copy from /vendor/qcom/propreitary/mm-cammera/common,
- * Please do not modify it directly here. */
-
-#ifndef __CAMLIST_H
-#define __CAMLIST_H
-
-#include <stddef.h>
-
-#define member_of(ptr, type, member) ({ \
-  const typeof(((type *)0)->member) *__mptr = (ptr); \
-  (type *)((char *)__mptr - offsetof(type,member));})
-
-struct cam_list {
-  struct cam_list *next, *prev;
-};
-
-static inline void cam_list_init(struct cam_list *ptr)
-{
-  ptr->next = ptr;
-  ptr->prev = ptr;
-}
-
-static inline void cam_list_add_tail_node(struct cam_list *item,
-  struct cam_list *head)
-{
-  struct cam_list *prev = head->prev;
-
-  head->prev = item;
-  item->next = head;
-  item->prev = prev;
-  prev->next = item;
-}
-
-static inline void cam_list_del_node(struct cam_list *ptr)
-{
-  struct cam_list *prev = ptr->prev;
-  struct cam_list *next = ptr->next;
-
-  next->prev = ptr->prev;
-  prev->next = ptr->next;
-  ptr->next = ptr;
-  ptr->prev = ptr;
-}
-
-#endif /* __CAMLIST_H */
diff --git a/camera/QCamera/stack/mm-camera-interface/Android.mk b/camera/QCamera/stack/mm-camera-interface/Android.mk
deleted file mode 100755
index 33d0e14..0000000
--- a/camera/QCamera/stack/mm-camera-interface/Android.mk
+++ /dev/null
@@ -1,63 +0,0 @@
-#ifeq ($(call is-board-platform,msm8960),true)

-OLD_LOCAL_PATH := $(LOCAL_PATH)

-LOCAL_PATH := $(call my-dir)

-

-include $(CLEAR_VARS)

-

-MM_CAM_FILES := \

-        src/mm_camera_interface.c \

-        src/mm_camera_stream.c \

-        src/mm_camera_channel.c \

-        src/mm_camera.c \

-        src/mm_camera_thread.c \

-        src/mm_camera_data.c \

-        src/mm_camera_sock.c \

-        src/mm_camera_helper.c

-

-ifeq ($(strip $(TARGET_USES_ION)),true)

-    LOCAL_CFLAGS += -DUSE_ION

-endif

-

-LOCAL_CFLAGS += -D_ANDROID_

-LOCAL_COPY_HEADERS_TO := mm-camera-interface

-LOCAL_COPY_HEADERS := inc/mm_camera_interface.h

-LOCAL_COPY_HEADERS += ../common/cam_list.h

-

-LOCAL_C_INCLUDES := \

-    $(LOCAL_PATH)/inc \

-    $(LOCAL_PATH)/../common \

-    $(LOCAL_PATH)/../../../ \

-    $(TARGET_OUT_HEADERS)/mm-camera \

-    $(TARGET_OUT_HEADERS)/mm-camera/common

-

-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include

-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/media

-LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr

-

-# (BEGIN) Need to remove later once dependency on jpeg removed

-LOCAL_C_INCLUDES += \

-    $(TARGET_OUT_HEADERS)/mm-still \

-    $(TARGET_OUT_HEADERS)/mm-still/jpeg \

-    $(TARGET_OUT_HEADERS)/mm-core/omxcore \

-    $(TARGET_OUT_HEADERS)/mm-still/mm-omx

-# (END) Need to remove later once dependency on jpeg removed

-

-LOCAL_C_INCLUDES+= hardware/qcom/media/mm-core/inc

-LOCAL_CFLAGS += -include bionic/libc/kernel/common/linux/socket.h

-LOCAL_CFLAGS += -include bionic/libc/kernel/common/linux/un.h

-

-LOCAL_SRC_FILES := $(MM_CAM_FILES)

-

-LOCAL_MODULE           := libmmcamera_interface

-LOCAL_PRELINK_MODULE   := false

-LOCAL_SHARED_LIBRARIES := libdl libcutils liblog

-LOCAL_MODULE_TAGS := optional

-

-# (BEGIN) Need to remove later once dependency on jpeg removed

-# LOCAL_SHARED_LIBRARIES += libmmjpeg_interface

-# (END) Need to remove later once dependency on jpeg removed

-

-include $(BUILD_SHARED_LIBRARY)

-

-LOCAL_PATH := $(OLD_LOCAL_PATH)

-#endif

diff --git a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera.h b/camera/QCamera/stack/mm-camera-interface/inc/mm_camera.h
deleted file mode 100755
index e96e8b6..0000000
--- a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera.h
+++ /dev/null
@@ -1,696 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_CAMERA_H__
-#define __MM_CAMERA_H__
-
-#include "mm_camera_interface.h"
-
-/**********************************************************************************
-* Data structure declare
-***********************************************************************************/
-/* num of streams allowed in a channel obj */
-//TODO: change for Stats
-#define MM_CAMEAR_STRAEM_NUM_MAX (16)
-/* num of channels allowed in a camera obj */
-#define MM_CAMERA_CHANNEL_MAX 1
-/* num of callbacks allowed for an event type */
-#define MM_CAMERA_EVT_ENTRY_MAX 4
-/* num of data callbacks allowed in a stream obj */
-#define MM_CAMERA_STREAM_BUF_CB_MAX 4
-/* num of data poll threads allowed in a channel obj */
-#define MM_CAMERA_CHANNEL_POLL_THREAD_MAX 1
-
-#define MM_CAMERA_DEV_NAME_LEN 32
-#define MM_CAMERA_DEV_OPEN_TRIES 2
-#define MM_CAMERA_DEV_OPEN_RETRY_SLEEP 20
-
-struct mm_channel;
-struct mm_stream;
-struct mm_camera_obj;
-
-/* common use */
-typedef struct {
-    struct cam_list list;
-    void* data;
-} mm_camera_q_node_t;
-
-typedef struct {
-    mm_camera_q_node_t head; /* dummy head */
-    uint32_t size;
-    pthread_mutex_t lock;
-} mm_camera_queue_t;
-
-typedef enum
-{
-    MM_CAMERA_ASYNC_CMD_TYPE_STOP,    /* async stop */
-    MM_CAMERA_ASYNC_CMD_TYPE_MAX
-} mm_camera_async_cmd_type_t;
-
-typedef struct {
-    struct mm_channel* ch_obj;
-    uint8_t num_streams;
-    uint32_t stream_ids[MM_CAMEAR_STRAEM_NUM_MAX];
-} mm_camera_async_stop_cmd_t;
-
-typedef struct {
-    mm_camera_async_cmd_type_t cmd_type;
-    union {
-        mm_camera_async_stop_cmd_t stop_cmd;
-    } u;
-} mm_camera_async_cmd_t;
-
-typedef enum
-{
-    MM_CAMERA_CMD_TYPE_DATA_CB,    /* dataB CMD */
-    MM_CAMERA_CMD_TYPE_EVT_CB,     /* evtCB CMD */
-    MM_CAMERA_CMD_TYPE_ASYNC_CB,   /* asyncCB CMD */
-    MM_CAMERA_CMD_TYPE_EXIT,       /* EXIT */
-    MM_CAMERA_CMD_TYPE_REQ_DATA_CB,/* request data */
-    MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB,    /* superbuf dataB CMD */
-    MM_CAMERA_CMD_TYPE_MAX
-} mm_camera_cmdcb_type_t;
-
-typedef struct {
-    uint32_t stream_id;
-    uint32_t frame_idx;
-    mm_camera_buf_def_t *buf; /* ref to buf */
-} mm_camera_buf_info_t;
-
-typedef struct {
-    uint32_t num_buf_requested;
-} mm_camera_req_buf_t;
-
-typedef struct {
-    mm_camera_cmdcb_type_t cmd_type;
-    union {
-        mm_camera_buf_info_t buf;    /* frame buf if dataCB */
-        mm_camera_event_t evt;       /* evt if evtCB */
-        mm_camera_async_cmd_t async; /* async cmd */
-        mm_camera_super_buf_t superbuf; /* superbuf if superbuf dataCB*/
-        mm_camera_req_buf_t req_buf; /* num of buf requested */
-    } u;
-} mm_camera_cmdcb_t;
-
-typedef void (*mm_camera_cmd_cb_t)(mm_camera_cmdcb_t * cmd_cb, void* user_data);
-
-typedef struct {
-    mm_camera_queue_t cmd_queue; /* cmd queue (queuing dataCB, asyncCB, or exitCMD) */
-    pthread_t cmd_pid;           /* cmd thread ID */
-    sem_t cmd_sem;               /* semaphore for cmd thread */
-    mm_camera_cmd_cb_t cb;       /* cb for cmd */
-    void* user_data;             /* user_data for cb */
-} mm_camera_cmd_thread_t;
-
-typedef enum {
-    MM_CAMERA_POLL_TYPE_EVT,
-    MM_CAMERA_POLL_TYPE_CH,
-    MM_CAMERA_POLL_TYPE_MAX

-} mm_camera_poll_thread_type_t;
-

-/* function ptr defined for poll notify CB,
- * registered at poll thread with poll fd */
-typedef void (*mm_camera_poll_notify_t)(void *user_data);
-
-typedef struct {
-    int32_t fd;
-    mm_camera_poll_notify_t notify_cb;
-    uint32_t handler;
-    void* user_data;
-} mm_camera_poll_entry_t;
-
-typedef struct {
-    mm_camera_poll_thread_type_t poll_type;
-    /* array to store poll fd and cb info
-     * for MM_CAMERA_POLL_TYPE_EVT, only index 0 is valid;
-     * for MM_CAMERA_POLL_TYPE_CH, depends on valid stream fd */
-    mm_camera_poll_entry_t poll_entries[MM_CAMEAR_STRAEM_NUM_MAX];
-    int32_t pfds[2];
-    pthread_t pid;
-    int32_t state;
-    int timeoutms;
-    uint32_t cmd;
-    struct pollfd poll_fds[MM_CAMEAR_STRAEM_NUM_MAX+1];
-    uint8_t num_fds;
-    pthread_mutex_t mutex;
-    pthread_cond_t cond_v;
-    int32_t status;
-    //void *my_obj;
-} mm_camera_poll_thread_t;
-
-/* mm_stream */
-typedef enum {
-    MM_STREAM_STATE_NOTUSED = 0,      /* not used */
-    MM_STREAM_STATE_INITED,           /* inited  */
-    MM_STREAM_STATE_ACQUIRED,         /* acquired, fd opened  */
-    MM_STREAM_STATE_CFG,              /* fmt & dim configured */
-    MM_STREAM_STATE_BUFFED,           /* buf allocated */
-    MM_STREAM_STATE_REG,              /* buf regged, stream off */
-    MM_STREAM_STATE_ACTIVE_STREAM_ON, /* active with stream on */
-    MM_STREAM_STATE_ACTIVE_STREAM_OFF, /* active with stream off */
-    MM_STREAM_STATE_MAX
-} mm_stream_state_type_t;
-
-typedef enum {
-    MM_STREAM_EVT_ACQUIRE,
-    MM_STREAM_EVT_RELEASE,
-    MM_STREAM_EVT_SET_FMT,
-    MM_STREAM_EVT_GET_BUF,
-    MM_STREAM_EVT_PUT_BUF,
-    MM_STREAM_EVT_REG_BUF,
-    MM_STREAM_EVT_UNREG_BUF,
-    MM_STREAM_EVT_START,
-    MM_STREAM_EVT_STOP,
-    MM_STREAM_EVT_QBUF,
-    MM_STREAM_EVT_SET_PARM,
-    MM_STREAM_EVT_GET_PARM,
-    MM_STREAM_EVT_MAX
-} mm_stream_evt_type_t;
-
-typedef struct {
-    mm_camera_buf_notify_t cb;
-    void *user_data;
-    /* cb_count = -1: infinite
-     * cb_count > 0: register only for required times */
-    int8_t cb_count;
-} mm_stream_data_cb_t;
-
-typedef struct {
-    /* buf reference count */
-    uint8_t buf_refcnt;
-
-    /* This flag is to indicate if after allocation,
-     * the corresponding buf needs to qbuf into kernel
-     * (e.g. for preview usecase, display needs to hold two bufs,
-     * so no need to qbuf these two bufs initially) */
-    uint8_t initial_reg_flag;
-
-    /* indicate if buf is in kernel(1) or client(0) */
-    uint8_t in_kernel;
-} mm_stream_buf_status_t;
-
-typedef struct mm_stream {
-    uint32_t my_hdl;
-    uint32_t inst_hdl;
-    int32_t fd;
-    mm_stream_state_type_t state;
-
-    /* ext_image_mode used as id for stream obj */
-    uint32_t ext_image_mode;
-
-    /* sensor index used */
-    uint32_t sensor_idx;
-
-    mm_camera_image_fmt_t fmt;
-
-    mm_camera_cmd_thread_t cmd_thread;
-
-    /* dataCB registered on this stream obj */
-    pthread_mutex_t cb_lock; /* cb lock to protect buf_cb */
-    mm_stream_data_cb_t buf_cb[MM_CAMERA_STREAM_BUF_CB_MAX];
-
-    /* stream buffer management */
-    pthread_mutex_t buf_lock;
-    uint8_t buf_num; /* num of buffers allocated */
-    mm_camera_buf_def_t* buf; /* ptr to buf array */
-    mm_stream_buf_status_t* buf_status; /* ptr to buf status array */
-
-    /* reference to parent channel_obj */
-    struct mm_channel* ch_obj;
-
-    uint8_t is_bundled; /* flag if stream is bundled */
-    uint8_t is_local_buf; /* flag if buf is local copy, no need to qbuf to kernel */
-    uint8_t hal_requested_num_bufs;
-    uint8_t need_stream_on; /* flag if stream need streamon when start */
-    uint8_t num_stream_cb_times; /* how many times to register for other stream data CB */
-    uint8_t local_buf_idx; /* idx to local buf that can be used for non-stream-on cb */
-
-    mm_camera_frame_len_offset frame_offset; /*Stream buffer offset information*/
-} mm_stream_t;
-
-/* mm_channel */
-typedef enum {
-    MM_CHANNEL_STATE_NOTUSED = 0,   /* not used */
-    MM_CHANNEL_STATE_STOPPED,       /* stopped */
-    MM_CHANNEL_STATE_ACTIVE,        /* active, at least one stream active */
-    MM_CHANNEL_STATE_PAUSED,        /* paused */
-    MM_CHANNEL_STATE_MAX
-} mm_channel_state_type_t;
-
-typedef enum {
-    MM_CHANNEL_EVT_ADD_STREAM,
-    MM_CHANNEL_EVT_DEL_STREAM,
-    MM_CHANNEL_EVT_START_STREAM,
-    MM_CHANNEL_EVT_STOP_STREAM,
-    MM_CHANNEL_EVT_TEARDOWN_STREAM,
-    MM_CHANNEL_EVT_CONFIG_STREAM,
-    MM_CHANNEL_EVT_PAUSE,
-    MM_CHANNEL_EVT_RESUME,
-    MM_CHANNEL_EVT_INIT_BUNDLE,
-    MM_CHANNEL_EVT_DESTROY_BUNDLE,
-    MM_CHANNEL_EVT_REQUEST_SUPER_BUF,
-    MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF,
-    MM_CHANNEL_EVT_START_FOCUS,
-    MM_CHANNEL_EVT_ABORT_FOCUS,
-    MM_CHANNEL_EVT_PREPARE_SNAPSHOT,
-    MM_CHANNEL_EVT_SET_STREAM_PARM,
-    MM_CHANNEL_EVT_GET_STREAM_PARM,
-    MM_CHANNEL_EVT_DELETE,
-    MM_CHANNEL_EVT_OPEN_REPRO_ISP,
-    MM_CHANNEL_EVT_CONFIG_REPRO_ISP,
-    MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP,
-    MM_CHANNEL_EVT_START_REPRO_ISP,
-    MM_CHANNEL_EVT_REPROCESS,
-    MM_CHANNEL_EVT_STOP_REPRO_ISP,
-    MM_CHANNEL_EVT_DETACH_STREAM_FROM_REPRO_ISP,
-    MM_CHANNEL_EVT_CLOSE_REPRO_ISP,
-    MM_CHANNEL_EVT_MAX
-} mm_channel_evt_type_t;
-
-typedef struct {
-    mm_camera_buf_notify_t buf_cb;
-    void *user_data;
-    uint32_t ext_image_mode;
-    uint32_t sensor_idx;
-} mm_evt_paylod_add_stream_t;
-
-typedef struct {
-    uint32_t stream_id;
-    mm_camera_stream_config_t *config;
-} mm_evt_paylod_config_stream_t;
-
-typedef struct {
-    mm_camera_stream_parm_t parm_type;
-    void *value;
-} mm_evt_paylod_stream_parm_t;
-
-typedef struct {
-    mm_camera_buf_notify_t super_frame_notify_cb;
-    void *user_data;
-    mm_camera_bundle_attr_t *attr;
-    uint8_t num_streams;
-    uint32_t *stream_ids;
-} mm_evt_payload_bundle_stream_t;
-
-typedef struct {
-    uint8_t num_streams;
-    uint32_t *stream_ids;
-} mm_evt_payload_start_stream_t;
-
-typedef struct {
-    uint8_t num_streams;
-    uint32_t *stream_ids;
-} mm_evt_payload_stop_stream_t;
-
-typedef struct {
-    uint32_t sensor_idx;
-    uint32_t focus_mode;
-} mm_evt_payload_start_focus_t;
-
-typedef struct {
-    uint32_t repro_isp_handle;
-    mm_camera_repro_isp_config_t *config;
-} mm_evt_paylod_config_repro_isp_t;
-
-typedef struct {
-    uint32_t repro_isp_handle;
-    uint32_t stream_id;
-} mm_evt_paylod_stream_to_repro_isp_t;
-
-typedef struct {
-    uint32_t repro_isp_handle;
-    mm_camera_repro_data_t *repro_data;
-} mm_evt_paylod_reprocess_t;
-
-typedef struct {
-    uint32_t repro_isp_handle;
-    uint32_t stream_id;
-} mm_evt_paylod_repro_start_stop_t;
-
-typedef struct {
-    uint8_t num_of_bufs;
-    mm_camera_buf_info_t super_buf[MM_CAMEAR_MAX_STRAEM_BUNDLE];
-    uint8_t matched;
-} mm_channel_queue_node_t;
-
-typedef struct {
-    mm_camera_queue_t que;
-    uint8_t num_streams;
-    /* container for bundled stream handlers */
-    uint32_t bundled_streams[MM_CAMEAR_MAX_STRAEM_BUNDLE];
-    mm_camera_bundle_attr_t attr;
-    uint32_t expected_frame_id;
-    uint32_t match_cnt;
-} mm_channel_queue_t;
-
-typedef struct {
-    uint8_t is_active; /* flag to indicate if bundle is valid */
-    /* queue to store bundled super buffers */
-    mm_channel_queue_t superbuf_queue;
-    mm_camera_buf_notify_t super_buf_notify_cb;
-    void *user_data;
-} mm_channel_bundle_t;
-
-typedef struct mm_channel {
-    uint32_t my_hdl;
-    mm_channel_state_type_t state;
-    pthread_mutex_t ch_lock; /* channel lock */
-
-    /* stream bundle info in the channel */
-    mm_channel_bundle_t bundle;
-
-    /* num of pending suferbuffers */
-    uint32_t pending_cnt;
-
-    /* cmd thread for superbuffer dataCB and async stop*/
-    mm_camera_cmd_thread_t cmd_thread;
-
-    /* cb thread for sending data cb */
-    mm_camera_cmd_thread_t cb_thread;
-
-    /* data poll thread
-    * currently one data poll thread per channel
-    * could extended to support one data poll thread per stream in the channel */
-    mm_camera_poll_thread_t poll_thread[MM_CAMERA_CHANNEL_POLL_THREAD_MAX];
-
-    /* container for all streams in channel
-    * stream is indexed by ext_image_mode */
-    mm_stream_t streams[MM_CAMEAR_STRAEM_NUM_MAX];
-
-    /* reference to parent cam_obj */
-    struct mm_camera_obj* cam_obj;
-} mm_channel_t;
-
-/* struct to store information about pp cookie*/
-typedef struct {
-    uint32_t cam_hdl;
-    uint32_t ch_hdl;
-    uint32_t stream_hdl;
-    mm_channel_queue_node_t* super_buf;
-} mm_channel_pp_info_t;
-
-/* mm_camera */
-typedef struct {
-    mm_camera_event_notify_t evt_cb;
-    void *user_data;
-} mm_camera_evt_entry_t;
-
-typedef struct {
-    mm_camera_evt_entry_t evt[MM_CAMERA_EVT_ENTRY_MAX];
-    /* reg_count <=0: infinite
-     * reg_count > 0: register only for required times */
-    int reg_count;
-} mm_camera_evt_obj_t;
-
-typedef struct mm_camera_obj {
-    uint32_t my_hdl;
-    int ref_count;
-    int32_t ctrl_fd;
-    int32_t ds_fd; /* domain socket fd */
-    cam_prop_t properties;
-    mm_camera_2nd_sensor_t second_sensor; /*second sensor info */
-    pthread_mutex_t cam_lock;
-    pthread_mutex_t cb_lock; /* lock for evt cb */
-    mm_channel_t ch[MM_CAMERA_CHANNEL_MAX];
-    mm_camera_evt_obj_t evt[MM_CAMERA_EVT_TYPE_MAX];
-    uint32_t evt_type_mask;
-    mm_camear_mem_vtbl_t *mem_vtbl; /* vtable for memory management */
-    mm_camera_poll_thread_t evt_poll_thread; /* evt poll thread */
-    mm_camera_cmd_thread_t evt_thread;       /* thread for evt CB */
-    mm_camera_cmd_thread_t async_cmd_thread; /* thread for async cmd */
-    mm_camera_vtbl_t vtbl;
-
-    /* some local variables */
-    uint32_t snap_burst_num_by_user;
-    camera_mode_t current_mode;
-    uint32_t op_mode;
-    cam_ctrl_dimension_t dim;
-} mm_camera_obj_t;
-
-typedef struct {
-    mm_camera_info_t camera[MSM_MAX_CAMERA_SENSORS];
-    int8_t num_cam;
-    char video_dev_name[MSM_MAX_CAMERA_SENSORS][MM_CAMERA_DEV_NAME_LEN];
-    mm_camera_obj_t *cam_obj[MSM_MAX_CAMERA_SENSORS];
-} mm_camera_ctrl_t;
-
-/**********************************************************************************
-* external function declare
-***********************************************************************************/
-/* utility functions */
-/* set int32_t value */
-extern int32_t mm_camera_util_s_ctrl(int32_t fd,
-                                     uint32_t id,
-                                     int32_t value);
-
-extern int32_t mm_camera_util_private_s_ctrl( int32_t fd,
-                                              uint32_t id, void* value);
-
-/* get int32_t value */
-extern int32_t mm_camera_util_g_ctrl(int32_t fd,
-                                     uint32_t id,int32_t *value);
-
-/* send msg throught domain socket for fd mapping */
-extern int32_t mm_camera_util_sendmsg(mm_camera_obj_t *my_obj,
-                                      void *msg,
-                                      uint32_t buf_size,
-                                      int sendfd);
-
-/* mm-camera */
-extern int32_t mm_camera_open(mm_camera_obj_t *my_obj);
-extern int32_t mm_camera_close(mm_camera_obj_t *my_obj);
-extern uint8_t mm_camera_is_event_supported(mm_camera_obj_t *my_obj,
-                                            mm_camera_event_type_t evt_type);
-extern int32_t mm_camera_register_event_notify(mm_camera_obj_t *my_obj,
-                                               mm_camera_event_notify_t evt_cb,
-                                               void * user_data,
-                                               mm_camera_event_type_t evt_type);
-extern int32_t mm_camera_qbuf(mm_camera_obj_t *my_obj,
-                              uint32_t ch_id,
-                              mm_camera_buf_def_t *buf);
-extern mm_camera_2nd_sensor_t * mm_camera_query_2nd_sensor_info(mm_camera_obj_t *my_obj);
-extern int32_t mm_camera_sync(mm_camera_obj_t *my_obj);
-extern int32_t mm_camera_is_op_supported(mm_camera_obj_t *my_obj,
-                                              mm_camera_ops_type_t opcode);
-extern int32_t mm_camera_is_parm_supported(mm_camera_obj_t *my_obj,
-                                           mm_camera_parm_type_t parm_type,
-                                           uint8_t *support_set_parm,
-                                           uint8_t *support_get_parm);
-extern int32_t mm_camera_set_parm(mm_camera_obj_t *my_obj,
-                                  mm_camera_parm_type_t parm_type,
-                                  void* p_value);
-extern int32_t mm_camera_get_parm(mm_camera_obj_t *my_obj,
-                                  mm_camera_parm_type_t parm_type,
-                                  void* p_value);
-extern uint32_t mm_camera_add_channel(mm_camera_obj_t *my_obj);
-extern void mm_camera_del_channel(mm_camera_obj_t *my_obj,
-                                  uint32_t ch_id);
-extern uint32_t mm_camera_add_stream(mm_camera_obj_t *my_obj,
-                                     uint32_t ch_id,
-                                     mm_camera_buf_notify_t buf_cb, void *user_data,
-                                     uint32_t ext_image_mode, uint32_t sensor_idx);
-extern int32_t mm_camera_del_stream(mm_camera_obj_t *my_obj,
-                                    uint32_t ch_id,
-                                    uint32_t stream_id);
-extern int32_t mm_camera_config_stream(mm_camera_obj_t *my_obj,
-                                       uint32_t ch_id,
-                                       uint32_t stream_id,
-                                       mm_camera_stream_config_t *config);
-extern int32_t mm_camera_bundle_streams(mm_camera_obj_t *my_obj,
-                                        uint32_t ch_id,
-                                        mm_camera_buf_notify_t super_frame_notify_cb,
-                                        void *user_data,
-                                        mm_camera_bundle_attr_t *attr,
-                                        uint8_t num_streams,
-                                        uint32_t *stream_ids);
-extern int32_t mm_camera_destroy_bundle(mm_camera_obj_t *my_obj,
-                                        uint32_t ch_id);
-extern int32_t mm_camera_start_streams(mm_camera_obj_t *my_obj,
-                                       uint32_t ch_id,
-                                       uint8_t num_streams,
-                                       uint32_t *stream_ids);
-extern int32_t mm_camera_stop_streams(mm_camera_obj_t *my_obj,
-                                      uint32_t ch_id,
-                                      uint8_t num_streams,
-                                      uint32_t *stream_ids);
-extern int32_t mm_camera_async_teardown_streams(mm_camera_obj_t *my_obj,
-                                                uint32_t ch_id,
-                                                uint8_t num_streams,
-                                                uint32_t *stream_ids);
-extern int32_t mm_camera_request_super_buf(mm_camera_obj_t *my_obj,
-                                           uint32_t ch_id,
-                                           uint32_t num_buf_requested);
-extern int32_t mm_camera_cancel_super_buf_request(mm_camera_obj_t *my_obj,
-                                                  uint32_t ch_id);
-extern int32_t mm_camera_start_focus(mm_camera_obj_t *my_obj,
-                                     uint32_t ch_id,
-                                     uint32_t sensor_idx,
-                                     uint32_t focus_mode);
-extern int32_t mm_camera_abort_focus(mm_camera_obj_t *my_obj,
-                                     uint32_t ch_id,
-                                     uint32_t sensor_idx);
-extern int32_t mm_camera_prepare_snapshot(mm_camera_obj_t *my_obj,
-                                          uint32_t ch_id,
-                                          uint32_t sensor_idx);
-extern int32_t mm_camera_set_stream_parm(mm_camera_obj_t *my_obj,
-                                  uint32_t ch_id,
-                                  uint32_t s_id,
-                                  mm_camera_stream_parm_t parm_type,
-                                  void* p_value);
-
-extern int32_t mm_camera_get_stream_parm(mm_camera_obj_t *my_obj,
-                                  uint32_t ch_id,
-                                  uint32_t s_id,
-                                  mm_camera_stream_parm_t parm_type,
-                                  void* p_value);
-
-extern int32_t mm_camera_register_event_notify_internal(
-                                   mm_camera_obj_t *my_obj,
-                                   mm_camera_event_notify_t evt_cb,
-                                   void * user_data,
-                                   mm_camera_event_type_t evt_type);
-extern int32_t mm_camera_map_buf(mm_camera_obj_t *my_obj,
-                                 int ext_mode,
-                                 int idx,
-                                 int fd,
-                                 uint32_t size);
-extern int32_t mm_camera_unmap_buf(mm_camera_obj_t *my_obj,
-                                   int ext_mode,
-                                   int idx);
-extern int32_t mm_camera_send_ch_event(mm_camera_obj_t *my_obj,
-                                       uint32_t ch_id,
-                                       uint32_t stream_id,
-                                       mm_camera_ch_event_type_t evt);
-extern int32_t mm_camera_send_private_ioctl(mm_camera_obj_t *my_obj,
-                                            uint32_t cmd_id,
-                                            uint32_t cmd_length,
-                                            void *cmd);
-extern int32_t mm_camera_open_repro_isp(mm_camera_obj_t *my_obj,
-                                        uint32_t ch_id,
-                                        mm_camera_repro_isp_type_t repro_isp_type,
-                                        uint32_t *repro_isp_handle);
-extern int32_t mm_camera_config_repro_isp(mm_camera_obj_t *my_obj,
-                                          uint32_t ch_id,
-                                          uint32_t repro_isp_handle,
-                                          mm_camera_repro_isp_config_t *config);
-extern int32_t mm_camera_attach_stream_to_repro_isp(mm_camera_obj_t *my_obj,
-                                                    uint32_t ch_id,
-                                                    uint32_t repro_isp_handle,
-                                                    uint32_t stream_id);
-extern int32_t mm_camera_start_repro_isp(mm_camera_obj_t *my_obj,
-                                         uint32_t ch_id,
-                                         uint32_t repro_isp_handle,
-                                         uint32_t stream_id);
-extern int32_t mm_camera_reprocess(mm_camera_obj_t *my_obj,
-                                   uint32_t ch_id,
-                                   uint32_t repro_isp_handle,
-                                   mm_camera_repro_data_t *repo_data);
-extern int32_t mm_camera_stop_repro_isp(mm_camera_obj_t *my_obj,
-                                        uint32_t ch_id,
-                                        uint32_t repro_isp_handle,
-                                        uint32_t stream_id);
-extern int32_t mm_camera_detach_stream_from_repro_isp(mm_camera_obj_t *my_obj,
-                                                      uint32_t ch_id,
-                                                      uint32_t repro_isp_handle,
-                                                      uint32_t stream_id);
-extern int32_t mm_camera_close_repro_isp(mm_camera_obj_t *my_obj,
-                                         uint32_t ch_id,
-                                         uint32_t repro_isp_handle);
-
-extern uint8_t mm_camera_util_get_pp_mask(mm_camera_obj_t *my_obj);
-
-/* mm_channel */
-extern int32_t mm_channel_fsm_fn(mm_channel_t *my_obj,
-                                 mm_channel_evt_type_t evt,
-                                 void * in_val,
-                                 void * out_val);
-
-/* qbuf is a special case that not going through state machine.
- * This is to avoid deadlock when trying to aquire ch_lock,
- * from the context of dataCB, but async stop is holding ch_lock */
-extern int32_t mm_channel_qbuf(mm_channel_t *my_obj,
-                               mm_camera_buf_def_t *buf);
-
-/* Allow other stream to register dataCB at certain stream.
- * This is for use case of video sized live snapshot,
- * because snapshot stream need register one time CB at video stream.
- * ext_image_mode and sensor_idx are used to identify the destinate stream
- * to be register with dataCB. */
-extern int32_t mm_channel_reg_stream_cb(mm_channel_t *my_obj,
-                                        mm_stream_data_cb_t *cb,
-                                        uint32_t ext_image_mode,
-                                        uint32_t sensor_idx);
-
-/* mm_stream */
-extern int32_t mm_stream_fsm_fn(mm_stream_t *my_obj,
-                                mm_stream_evt_type_t evt,
-                                void * in_val,
-                                void * out_val);
-/* Allow other stream to register dataCB at certain stream.
- * This is for use case of video sized live snapshot,
- * because snapshot stream need register one time CB at video stream.
- * ext_image_mode and sensor_idx are used to identify the destinate stream
- * to be register with dataCB. */
-extern int32_t mm_stream_reg_buf_cb(mm_stream_t *my_obj,
-                                    mm_stream_data_cb_t *val);
-
-/* utiltity fucntion declared in mm-camera-inteface2.c
- * and need be used by mm-camera and below*/
-uint32_t mm_camera_util_generate_handler(uint8_t index);
-const char * mm_camera_util_get_dev_name(uint32_t cam_handler);
-uint8_t mm_camera_util_get_index_by_handler(uint32_t handler);
-
-/* queue functions */
-extern int32_t mm_camera_queue_init(mm_camera_queue_t* queue);
-extern int32_t mm_camera_queue_enq(mm_camera_queue_t* queue, void* node);
-extern void* mm_camera_queue_deq(mm_camera_queue_t* queue);
-extern int32_t mm_camera_queue_deinit(mm_camera_queue_t* queue);
-extern int32_t mm_camera_queue_flush(mm_camera_queue_t* queue);
-
-/* poll/cmd thread functions */
-extern int32_t mm_camera_poll_thread_launch(
-                                mm_camera_poll_thread_t * poll_cb,
-                                mm_camera_poll_thread_type_t poll_type);
-extern int32_t mm_camera_poll_thread_release(mm_camera_poll_thread_t *poll_cb);
-extern int32_t mm_camera_poll_thread_add_poll_fd(
-                                mm_camera_poll_thread_t * poll_cb,
-                                uint32_t handler,
-                                int32_t fd,
-                                mm_camera_poll_notify_t nofity_cb,
-                                void *userdata);
-extern int32_t mm_camera_poll_thread_del_poll_fd(
-                                mm_camera_poll_thread_t * poll_cb,
-                                uint32_t handler);
-extern int32_t mm_camera_cmd_thread_launch(
-                                mm_camera_cmd_thread_t * cmd_thread,
-                                mm_camera_cmd_cb_t cb,
-                                void* user_data);
-extern int32_t mm_camera_cmd_thread_release(mm_camera_cmd_thread_t * cmd_thread);
-
-#endif /* __MM_CAMERA_H__ */
diff --git a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_dbg.h b/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_dbg.h
deleted file mode 100755
index fcb7028..0000000
--- a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_dbg.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_CAMERA_DBG_H__
-#define __MM_CAMERA_DBG_H__
-
-//#define LOG_DEBUG 1
-
-#ifndef LOG_DEBUG
-  #ifdef _ANDROID_
-    #undef LOG_NIDEBUG
-    #undef LOG_TAG
-    #define LOG_NIDEBUG 0
-    #define LOG_TAG "mm-camera-intf"
-    #include <utils/Log.h>
-  #else
-    #include <stdio.h>
-    #define ALOGE CDBG
-  #endif
-  #undef CDBG
-  #define CDBG(fmt, args...) do{}while(0)
-  #define CDBG_ERROR(fmt, args...) ALOGE(fmt, ##args)
-#else
-  #ifdef _ANDROID_
-    #undef LOG_NIDEBUG
-    #undef LOG_TAG
-    #define LOG_NIDEBUG 0
-    #define LOG_TAG "mm-camera-intf"
-    #include <utils/Log.h>
-    #define CDBG(fmt, args...) ALOGE(fmt, ##args)
-  #else
-    #include <stdio.h>
-    #define CDBG(fmt, args...) fprintf(stderr, fmt, ##args)
-    #define ALOGE(fmt, args...) fprintf(stderr, fmt, ##args)
-  #endif
-#endif
-
-#ifdef _ANDROID_
-  #define CDBG_HIGH(fmt, args...)  ALOGE(fmt, ##args)
-  #define CDBG_ERROR(fmt, args...)  ALOGE(fmt, ##args)
-#else
-  #define CDBG_HIGH(fmt, args...) fprintf(stderr, fmt, ##args)
-  #define CDBG_ERROR(fmt, args...) fprintf(stderr, fmt, ##args)
-#endif
-#endif /* __MM_CAMERA_DBG_H__ */
diff --git a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_interface.h b/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_interface.h
deleted file mode 100755
index efaba9e..0000000
--- a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_interface.h
+++ /dev/null
@@ -1,451 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_CAMERA_INTERFACE_H__
-#define __MM_CAMERA_INTERFACE_H__
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include "QCamera_Intf.h"
-#include "cam_list.h"
-
-#define MM_CAMERA_MAX_NUM_FRAMES 16
-#define MM_CAMERA_MAX_2ND_SENSORS 4
-
-typedef enum {
-    MM_CAMERA_OPS_LOCAL = -1,  /*no need to query mm-camera*/
-    MM_CAMERA_OPS_STREAMING_PREVIEW = 0,
-    MM_CAMERA_OPS_STREAMING_ZSL,
-    MM_CAMERA_OPS_STREAMING_VIDEO,
-    MM_CAMERA_OPS_CAPTURE, /*not supported*/
-    MM_CAMERA_OPS_FOCUS,
-    MM_CAMERA_OPS_GET_PICTURE, /*5*/
-    MM_CAMERA_OPS_PREPARE_SNAPSHOT,
-    MM_CAMERA_OPS_SNAPSHOT,
-    MM_CAMERA_OPS_LIVESHOT,
-    MM_CAMERA_OPS_RAW_SNAPSHOT,
-    MM_CAMERA_OPS_VIDEO_RECORDING, /*10*/
-    MM_CAMERA_OPS_REGISTER_BUFFER,
-    MM_CAMERA_OPS_UNREGISTER_BUFFER,
-    MM_CAMERA_OPS_CAPTURE_AND_ENCODE,
-    MM_CAMERA_OPS_RAW_CAPTURE,
-    MM_CAMERA_OPS_ENCODE, /*15*/
-    MM_CAMERA_OPS_ZSL_STREAMING_CB,
-    /* add new above*/
-    MM_CAMERA_OPS_MAX
-}mm_camera_ops_type_t;
-
-typedef enum {
-    MM_CAMERA_STREAM_OFFSET,
-    MM_CAMERA_STREAM_CID,
-    MM_CAMERA_STREAM_CROP
-}mm_camera_stream_parm_t;
-
-typedef struct {
-   int32_t width;
-   int32_t height;
-} mm_camera_dimension_t;
-
-typedef struct{
-    uint32_t tbl_size;
-    struct camera_size_type *sizes_tbl;
-}default_sizes_tbl_t;
-
-typedef struct  {
-    int32_t left;
-    int32_t top;
-    int32_t width;
-    int32_t height;
-} mm_camera_rect_t;
-
-/* TBD: meta header needs to move to msm_camear.h */
-typedef enum {
-    /* no meta data header used */
-    MM_CAMEAR_META_DATA_TYPE_DEF,
-    /* has focus flag, exposure idx,
-     * flash flag, etc. TBD */
-    MM_CAMEAR_META_DATA_TYPE_BRACKETING,
-    MM_CAMEAR_META_DATA_TYPE_MAX,
-} mm_camera_meta_header_t;
-
-typedef struct {
-    cam_format_t fmt;
-    mm_camera_meta_header_t meta_header;
-    uint32_t width;
-    uint32_t height;
-    uint8_t rotation;
-} mm_camera_image_fmt_t;
-
-typedef struct {
-    /* image format */
-    mm_camera_image_fmt_t fmt;
-
-    /* num of buffers needed */
-    uint8_t num_of_bufs;
-
-    /* flag to indicate if this stream need stream on */
-    uint8_t need_stream_on;
-
-    /* num of CB needs to be registered on other stream,
-     * this field is valid only when need_stream_on is 0.
-     * When need_stream_on = 1, num_stream_cb_times will be ignored. */
-    uint8_t num_stream_cb_times;
-} mm_camera_stream_config_t;
-
-typedef struct {
-    uint8_t name[32];
-    int32_t min_value;
-    int32_t max_value;
-    int32_t step;
-    int32_t default_value;
-} mm_camera_ctrl_cap_sharpness_t;
-
-typedef struct {
-    int16_t *zoom_ratio_tbl;
-    int32_t size;
-} mm_camera_zoom_tbl_t;
-
-typedef enum {
-    /* ZSL use case: get burst of frames */
-    MM_CAMERA_SUPER_BUF_NOTIFY_BURST = 0,
-    /* get continuous frames: when the super buf is
-     * ready dispatch it to HAL */
-    MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS,
-    MM_CAMERA_SUPER_BUF_NOTIFY_MAX
-} mm_camera_super_buf_notify_mode_t;
-
-typedef enum {
-    /* save the frame. No matter focused or not */
-    MM_CAMERA_SUPER_BUF_PRIORITY_NORMAL = 0,
-    /* only queue the frame that is focused. Will enable
-     * meta data header to carry focus info*/
-    MM_CAMERA_SUPER_BUF_PRIORITY_FOCUS,
-    /* after shutter, only queue matched exposure index */
-    MM_CAMERA_SUPER_BUF_PRIORITY_EXPOSURE_BRACKETING,
-    MM_CAMERA_SUPER_BUF_PRIORITY_MAX
-} mm_camera_super_buf_priority_t;
-
-typedef struct {
-    mm_camera_super_buf_notify_mode_t notify_mode;
-    /* queue depth. Only for burst mode */
-    uint8_t water_mark;
-    /* look back how many frames from last buf */
-    uint8_t look_back;
-    /* after send first frame to HAL, how many frames
-     * needing to be skipped for next delivery? */
-    uint8_t post_frame_skip;
-    /* save matched priority frames only */
-    mm_camera_super_buf_priority_t priority;
-    /* in burst mode, how many super
-     * bufs for each shutter press? */
-    uint8_t burst_num;
-} mm_camera_bundle_attr_t;
-
-typedef struct {
-    uint8_t camera_id;                   /* camera id */
-    camera_info_t camera_info;           /* postion, mount_angle, etc. */
-    enum sensor_type_t main_sensor_type; /* BAYER, YUV, JPEG_SOC, etc. */
-    char *video_dev_name;                /* device node name, e.g. /dev/video1 */
-} mm_camera_info_t;
-
-typedef struct {
-  uint8_t cid;
-  uint8_t dt;
-}stream_cid_t;
-
-/* the stats struct will need rework after
- * defining the stats buf sharing logic */
-typedef struct {
-    int type;
-    uint32_t length;
-    void *value;
-} mm_camera_stats_t;
-
-typedef struct {
-    uint32_t stream_id; /* stream handler */
-    int8_t buf_idx; /* buf idx within the stream bufs */
-
-    struct timespec ts; /* time stamp, to be filled when DQBUF*/
-    uint32_t frame_idx; /* frame sequence num, to be filled when DQBUF */
-
-    int8_t num_planes; /* num of planes, to be filled during mem allocation */
-    struct v4l2_plane planes[VIDEO_MAX_PLANES]; /* plane info, to be filled during mem allocation*/
-    int fd; /* fd of the frame, to be filled during mem allocation */
-    void *buffer; /* ptr to real frame buffer, to be filled during mem allocation */
-    uint32_t frame_len; /* len of the whole frame, to be filled during mem allocation */
-    void *mem_info; /* reserved for pointing to mem info */
-    cam_exif_tags_t *p_mobicat_info; /*for mobicat info*/
-} mm_camera_buf_def_t;
-
-typedef struct {
-    uint32_t camera_handle;
-    uint32_t ch_id;
-    uint8_t num_bufs;
-    mm_camera_buf_def_t* bufs[MM_CAMEAR_MAX_STRAEM_BUNDLE];
-} mm_camera_super_buf_t;
-
-typedef void (*mm_camera_event_notify_t)(uint32_t camera_handle,
-                                         mm_camera_event_t *evt,
-                                         void *user_data);
-
-typedef void (*mm_camera_buf_notify_t) (mm_camera_super_buf_t *bufs,
-                                        void *user_data);
-typedef cam_frame_len_offset_t mm_camera_frame_len_offset;
-
-typedef struct {
-  void *user_data;
-  int32_t (*get_buf) (uint32_t camera_handle,
-                      uint32_t ch_id, uint32_t stream_id,
-                      void *user_data,
-                      mm_camera_frame_len_offset *frame_offset_info,
-                      uint8_t num_bufs,
-                      uint8_t *initial_reg_flag,
-                      mm_camera_buf_def_t *bufs);
-  int32_t (*put_buf) (uint32_t camera_handle,
-                      uint32_t ch_id, uint32_t stream_id,
-                      void *user_data, uint8_t num_bufs,
-                      mm_camera_buf_def_t *bufs);
-} mm_camear_mem_vtbl_t;
-
-typedef struct {
-    uint8_t num_2nd_sensors;
-    uint8_t sensor_idxs[MM_CAMERA_MAX_2ND_SENSORS];
-} mm_camera_2nd_sensor_t;
-
-typedef enum {
-    NATIVE_CMD_ID_SOCKET_MAP,
-    NATIVE_CMD_ID_SOCKET_UNMAP,
-    NATIVE_CMD_ID_IOCTL_CTRL,
-    NATIVE_CMD_ID_MAX
-} mm_camera_native_cmd_id_t;
-
-typedef enum {
-    MM_CAMERA_CMD_TYPE_PRIVATE,   /* OEM private ioctl */
-    MM_CAMERA_CMD_TYPE_NATIVE     /* native ctrl cmd through ioctl */
-} mm_camera_cmd_type_t;
-
-typedef struct {
-    mm_camera_buf_def_t *src_frame; /* src frame */
-} mm_camera_repro_data_t;
-
-typedef mm_camera_repro_cmd_config_t mm_camera_repro_isp_config_t;
-
-typedef struct {
-    /* to sync the internal camera settings */
-    int32_t (*sync) (uint32_t camera_handle);
-    uint8_t (*is_event_supported) (uint32_t camera_handle,
-                                 mm_camera_event_type_t evt_type);
-    int32_t (*register_event_notify) (uint32_t camera_handle,
-                                 mm_camera_event_notify_t evt_cb,
-                                 void * user_data,
-                                 mm_camera_event_type_t evt_type);
-    int32_t (*qbuf) (uint32_t camera_handle, uint32_t ch_id,
-                                 mm_camera_buf_def_t *buf);
-    void (*camera_close) (uint32_t camera_handle);
-    /* Only fo supporting advanced 2nd sensors. If no secondary sensor needed
-     * HAL can ignore this function */
-    mm_camera_2nd_sensor_t * (*query_2nd_sensor_info) (uint32_t camera_handle);
-
-    /* if the operation is supported: TRUE - support, FALSE - not support */
-    uint8_t (*is_op_supported)(uint32_t camera_handle, mm_camera_ops_type_t opcode);
-
-    /* if the parm is supported: TRUE - support, FALSE - not support */
-    int32_t (*is_parm_supported) (uint32_t camera_handle,
-                                 mm_camera_parm_type_t parm_type,
-                                 uint8_t *support_set_parm,
-                                 uint8_t *support_get_parm);
-    /* set a parm current value */
-    int32_t (*set_parm) (uint32_t camera_handle,
-                         mm_camera_parm_type_t parm_type,
-                         void* p_value);
-    /* get a parm current value */
-    int32_t (*get_parm) (uint32_t camera_handle,
-                         mm_camera_parm_type_t parm_type,
-                         void* p_value);
-    /* ch_id returned, zero is invalid ch_id */
-    uint32_t (*ch_acquire) (uint32_t camera_handle);
-    /* relaese channel */
-    void (*ch_release) (uint32_t camera_handle, uint32_t ch_id);
-    /* return stream_id. zero is invalid stream_id
-     * default set to preview: ext_image_mode = 0
-     * default set to primary sensor: sensor_idx = 0
-     * value of ext_image_mode is defined in msm_camera.h
-     */
-    uint32_t (*add_stream) (uint32_t camera_handle, uint32_t ch_id,
-                           mm_camera_buf_notify_t buf_cb, void *user_data,
-                           uint32_t ext_image_mode, uint32_t sensor_idx);
-    /* delete stream */
-    int32_t (*del_stream) (uint32_t camera_handle, uint32_t ch_id,
-                           uint32_t stream_id);
-    /* set straem format This will trigger getting bufs from HAL */
-    int32_t (*config_stream) (uint32_t camera_handle, uint32_t ch_id,
-                              uint32_t stream_id,
-                              mm_camera_stream_config_t *config);
-    /* setup super buf bundle for ZSL(with burst mode) or other use cases */
-    int32_t (*init_stream_bundle) (uint32_t camera_handle, uint32_t ch_id,
-                                   mm_camera_buf_notify_t super_frame_notify_cb,
-                                   void *user_data,  mm_camera_bundle_attr_t *attr,
-                                   uint8_t num_streams, uint32_t *stream_ids);
-    /* remove the super buf bundle */
-    int32_t (*destroy_stream_bundle) (uint32_t camera_handle, uint32_t ch_id);
-    /* start streaming */
-    int32_t (*start_streams) (uint32_t camera_handle, uint32_t ch_id,
-                              uint8_t num_streams, uint32_t *stream_ids);
-    /* stop streaming */
-    int32_t (*stop_streams) (uint32_t camera_handle, uint32_t ch_id,
-                             uint8_t num_streams, uint32_t *stream_ids);
-    /* tear down streams asyncly */
-    int32_t (*async_teardown_streams) (uint32_t camera_handle, uint32_t ch_id,
-                                       uint8_t num_streams, uint32_t *stream_ids);
-    /* get super bufs. for burst mode only */
-    int32_t (*request_super_buf) (uint32_t camera_handle,
-                                  uint32_t ch_id,
-                                  uint32_t num_buf_requested);
-    /* abort the super buf dispatching. for burst mode only  */
-    int32_t (*cancel_super_buf_request) (uint32_t camera_handle,
-                                         uint32_t ch_id);
-    /* start focus: by default sensor_idx=0 */
-    int32_t (*start_focus) (uint32_t camera_handle,
-                            uint32_t ch_id,
-                            uint32_t sensor_idx,
-                            uint32_t focus_mode);
-    /* abort focus: by default sensor_idx=0 */
-    int32_t (*abort_focus) (uint32_t camera_handle,
-                            uint32_t ch_id,
-                            uint32_t sensor_idx);
-    /* prepare hardware will settle aec and flash.
-     * by default sensor_idx=0 */
-    int32_t (*prepare_snapshot) (uint32_t camera_handle,
-                                 uint32_t ch_id,
-                                 uint32_t sensor_idx);
-    /* set a parm current value of a stream */
-    int32_t (*set_stream_parm) (uint32_t camera_handle,
-                                uint32_t ch_id,
-                                uint32_t s_id,
-                                mm_camera_stream_parm_t parm_type,
-                                void *p_value);
-    /* get a parm current value of a stream */
-    int32_t (*get_stream_parm) (uint32_t camera_handle,
-                                uint32_t ch_id,
-                                uint32_t s_id,
-                                mm_camera_stream_parm_t parm_type,
-                                void *p_value);
-    /* private communication tunnel */
-    int32_t (*send_command) (uint32_t camera_handle,
-                             mm_camera_cmd_type_t cmd_type,
-                             uint32_t cmd_id,
-                             uint32_t cmd_length,
-                             void *cmd);
-    /* open a re-process isp, return handler for repro isp (>0).
-     * if failed, reutrn 0 */
-    uint32_t (*open_repro_isp) (uint32_t camera_handle,
-                               uint32_t ch_id,
-                               mm_camera_repro_isp_type_t repro_isp_type);
-    /* config the re-process isp */
-    int32_t (*config_repro_isp) (uint32_t camera_handle,
-                                 uint32_t ch_id,
-                                 uint32_t repro_isp_handle,
-                                 mm_camera_repro_isp_config_t *config);
-    /* attach output stream to the re-process isp */
-    int32_t (*attach_stream_to_repro_isp) (uint32_t camera_handle,
-                                           uint32_t ch_id,
-                                           uint32_t repro_isp_handle,
-                                           uint32_t stream_id);
-    /* start a re-process isp. */
-    int32_t (*start_repro_isp) (uint32_t camera_handle,
-                                uint32_t ch_id,
-                                uint32_t repro_isp_handle,
-                                uint32_t stream_id);
-    /* start a reprocess job for a src frame.
-     * Only after repo_isp is started, reprocess API can be called */
-    int32_t (*reprocess) (uint32_t camera_handle,
-                          uint32_t ch_id,
-                          uint32_t repro_isp_handle,
-                          mm_camera_repro_data_t *repo_data);
-    /* stop a re-process isp */
-    int32_t (*stop_repro_isp) (uint32_t camera_handle,
-                               uint32_t ch_id,
-                               uint32_t repro_isp_handle,
-                               uint32_t stream_id);
-    /* detach an output stream from the re-process isp.
-     * Can only be called after the re-process isp is stopped */
-    int32_t (*detach_stream_from_repro_isp) (uint32_t camera_handle,
-                                             uint32_t ch_id,
-                                             uint32_t repro_isp_handle,
-                                             uint32_t stream_id);
-    /* close a re-process isp.
-     * Can only close after all dest streams are detached from it */
-    int32_t (*close_repro_isp) (uint32_t camera_handle,
-                                uint32_t ch_id,
-                                uint32_t repro_isp_handle);
-} mm_camera_ops_t;
-
-typedef struct {
-    uint32_t camera_handle;        /* camera object handle */
-    mm_camera_info_t *camera_info; /* reference pointer of camear info */
-    mm_camera_ops_t *ops;          /* API call table */
-} mm_camera_vtbl_t;
-
-mm_camera_info_t * camera_query(uint8_t *num_cameras);
-mm_camera_vtbl_t * camera_open(uint8_t camera_idx,
-                               mm_camear_mem_vtbl_t *mem_vtbl);
-
-//extern void mm_camera_util_profile(const char *str);
-
-typedef enum {
-    MM_CAMERA_PREVIEW,
-    MM_CAMERA_VIDEO,
-    MM_CAMERA_SNAPSHOT_MAIN,
-    MM_CAMERA_SNAPSHOT_THUMBNAIL,
-    MM_CAMERA_SNAPSHOT_RAW,
-    MM_CAMERA_RDI,
-    MM_CAMERA_RDI1,
-    MM_CAMERA_RDI2,
-    MM_CAMERA_SAEC,
-    MM_CAMERA_SAWB,
-    MM_CAMERA_SAFC,
-    MM_CAMERA_IHST,
-    MM_CAMERA_CS,
-    MM_CAMERA_RS,
-    MM_CAMERA_CSTA,
-    MM_CAMERA_ISP_PIX_OUTPUT1,
-    MM_CAMERA_ISP_PIX_OUTPUT2,
-    MM_CAMERA_IMG_MODE_MAX
-} mm_camera_img_mode;
-
-/* may remove later */
-typedef enum {
-    MM_CAMERA_OP_MODE_NOTUSED,
-    MM_CAMERA_OP_MODE_CAPTURE,
-    MM_CAMERA_OP_MODE_VIDEO,
-    MM_CAMERA_OP_MODE_ZSL,
-    MM_CAMERA_OP_MODE_RAW,
-    MM_CAMERA_OP_MODE_MAX
-} mm_camera_op_mode_type_t;
-
-#endif /*__MM_CAMERA_INTERFACE_H__*/
diff --git a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_sock.h b/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_sock.h
deleted file mode 100755
index 0846c05..0000000
--- a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_sock.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_CAMERA_SOCKET_H__
-#define __MM_CAMERA_SOCKET_H__
-
-#include <inttypes.h>
-
-typedef enum {
-    MM_CAMERA_SOCK_TYPE_UDP,
-    MM_CAMERA_SOCK_TYPE_TCP,
-} mm_camera_sock_type_t;
-
-int mm_camera_socket_create(int cam_id, mm_camera_sock_type_t sock_type);
-
-int mm_camera_socket_sendmsg(
-  int fd,
-  void *msg,
-  uint32_t buf_size,
-  int sendfd);
-
-int mm_camera_socket_recvmsg(
-  int fd,
-  void *msg,
-  uint32_t buf_size,
-  int *rcvdfd);
-
-void mm_camera_socket_close(int fd);
-
-#endif /*__MM_CAMERA_SOCKET_H__*/
-
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera.c
deleted file mode 100755
index 42b9215..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera.c
+++ /dev/null
@@ -1,2168 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_sock.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-#define SET_PARM_BIT32(parm, parm_arr) \
-    (parm_arr[parm/32] |= (1<<(parm%32)))
-
-#define GET_PARM_BIT32(parm, parm_arr) \
-    ((parm_arr[parm/32]>>(parm%32))& 0x1)
-
-/* internal function declare */
-int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
-                                       cam_ctrl_type type,
-                                       uint32_t length,
-                                       void *value);
-int32_t mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,
-                                               cam_ctrl_type type,
-                                               uint32_t length,
-                                               void *value,
-                                               int timeout);
-int mm_camera_evt_sub(mm_camera_obj_t * my_obj,
-                      mm_camera_event_type_t evt_type,
-                      int reg_count);
-int32_t mm_camera_set_general_parm(mm_camera_obj_t * my_obj,
-                                   mm_camera_parm_type_t parm_type,
-                                   void* p_value);
-int32_t mm_camera_enqueue_evt(mm_camera_obj_t *my_obj,
-                              mm_camera_event_t *event);
-extern int32_t mm_channel_init(mm_channel_t *my_obj);
-
-mm_channel_t * mm_camera_util_get_channel_by_handler(
-                                    mm_camera_obj_t * cam_obj,
-                                    uint32_t handler)
-{
-    int i;
-    mm_channel_t *ch_obj = NULL;
-    uint8_t ch_idx = mm_camera_util_get_index_by_handler(handler);
-
-    for(i = 0; i < MM_CAMERA_CHANNEL_MAX; i++) {
-        if (handler == cam_obj->ch[i].my_hdl) {
-            ch_obj = &cam_obj->ch[i];
-            break;
-        }
-    }
-    return ch_obj;
-}
-
-static void mm_camera_dispatch_app_event(mm_camera_cmdcb_t *cmd_cb,
-                                         void* user_data)
-{
-    int i;
-    mm_camera_event_type_t evt_type = cmd_cb->u.evt.event_type;
-    mm_camera_event_t *event = &cmd_cb->u.evt;
-    mm_camera_obj_t * my_obj = (mm_camera_obj_t *)user_data;
-    if (NULL != my_obj) {
-        if (evt_type < MM_CAMERA_EVT_TYPE_MAX) {
-            pthread_mutex_lock(&my_obj->cb_lock);
-            for(i = 0; i < MM_CAMERA_EVT_ENTRY_MAX; i++) {
-                if(my_obj->evt[evt_type].evt[i].evt_cb) {
-                    my_obj->evt[evt_type].evt[i].evt_cb(
-                        my_obj->my_hdl,
-                        event,
-                        my_obj->evt[evt_type].evt[i].user_data);
-                }
-            }
-            pthread_mutex_unlock(&my_obj->cb_lock);
-        }
-    }
-}
-
-static void mm_camera_handle_async_cmd(mm_camera_cmdcb_t *cmd_cb,
-                                       void* user_data)
-{
-    int i;
-    mm_camera_async_cmd_t *async_cmd = &cmd_cb->u.async;
-    mm_camera_obj_t * my_obj = NULL;
-    mm_evt_payload_stop_stream_t payload;
-
-    my_obj = (mm_camera_obj_t *)user_data;
-    if (NULL != my_obj) {
-        if (MM_CAMERA_ASYNC_CMD_TYPE_STOP == async_cmd->cmd_type) {
-            memset(&payload, 0, sizeof(mm_evt_payload_stop_stream_t));
-            payload.num_streams = async_cmd->u.stop_cmd.num_streams;
-            payload.stream_ids = async_cmd->u.stop_cmd.stream_ids;
-            mm_channel_fsm_fn(async_cmd->u.stop_cmd.ch_obj,
-                                   MM_CHANNEL_EVT_TEARDOWN_STREAM,
-                                   (void*)&payload,
-                                   NULL);
-        }
-    }
-}
-
-static void mm_camera_event_notify(void* user_data)
-{
-    struct v4l2_event ev;
-    int rc;
-    mm_camera_event_t *evt = NULL;
-    mm_camera_cmdcb_t *node = NULL;
-
-    mm_camera_obj_t *my_obj = (mm_camera_obj_t*)user_data;
-    if (NULL != my_obj) {
-        /* read evt */
-        memset(&ev, 0, sizeof(ev));
-        rc = ioctl(my_obj->ctrl_fd, VIDIOC_DQEVENT, &ev);
-        evt = (mm_camera_event_t *)ev.u.data;
-
-        if (rc >= 0) {
-            if(ev.type == V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_ERROR_EVENT) {
-                evt->event_type = MM_CAMERA_EVT_TYPE_CTRL;
-                evt->e.ctrl.evt = MM_CAMERA_CTRL_EVT_ERROR;
-                node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-                if (NULL != node) {
-                    memset(node, 0, sizeof(mm_camera_cmdcb_t));
-                    node->cmd_type = MM_CAMERA_CMD_TYPE_EVT_CB;
-                    memcpy(&node->u.evt, evt, sizeof(mm_camera_event_t));
-                }
-            } else {
-                switch (evt->event_type) {
-                case MM_CAMERA_EVT_TYPE_CH:
-                case MM_CAMERA_EVT_TYPE_CTRL:
-                case MM_CAMERA_EVT_TYPE_STATS:
-                case MM_CAMERA_EVT_TYPE_INFO:
-                    {
-                        node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-                        if (NULL != node) {
-                            memset(node, 0, sizeof(mm_camera_cmdcb_t));
-                            node->cmd_type = MM_CAMERA_CMD_TYPE_EVT_CB;
-                            memcpy(&node->u.evt, evt, sizeof(mm_camera_event_t));
-                        }
-                    }
-                    break;
-                case MM_CAMERA_EVT_TYPE_PRIVATE_EVT:
-                    {
-                        CDBG("%s: MM_CAMERA_EVT_TYPE_PRIVATE_EVT", __func__);
-                        struct msm_camera_v4l2_ioctl_t v4l2_ioctl;
-                        int32_t length =
-                            sizeof(mm_camera_cmdcb_t) + evt->e.pri_evt.data_length;
-                        node = (mm_camera_cmdcb_t *)malloc(length);
-                        if (NULL != node) {
-                            memset(node, 0, length);
-                            node->cmd_type = MM_CAMERA_CMD_TYPE_EVT_CB;
-                            memcpy(&node->u.evt, evt, sizeof(mm_camera_event_t));
-
-                            if (evt->e.pri_evt.data_length > 0) {
-                                CDBG("%s: data_length =%d (trans_id=%d), dequeue payload",
-                                     __func__, evt->e.pri_evt.data_length,
-                                     node->u.evt.e.pri_evt.trans_id);
-                                /* dequeue event payload if length > 0 */
-                                memset(&v4l2_ioctl, 0, sizeof(v4l2_ioctl));
-                                v4l2_ioctl.trans_code = node->u.evt.e.pri_evt.trans_id;
-                                v4l2_ioctl.len = node->u.evt.e.pri_evt.data_length;
-                                v4l2_ioctl.ioctl_ptr = &(node->u.evt.e.pri_evt.evt_data[0]);
-                                rc = ioctl(my_obj->ctrl_fd, MSM_CAM_V4L2_IOCTL_GET_EVENT_PAYLOAD,
-                                           &v4l2_ioctl);
-                                if (rc < 0) {
-                                    CDBG_ERROR("%s: get event payload returns error = %d",
-                                               __func__, rc);
-                                    free(node);
-                                    node = NULL;
-                                } else {
-                                    CDBG("%s: data_length =%d (trans_id=%d) (payload=%s)",
-                                         __func__, evt->e.pri_evt.data_length,
-                                         node->u.evt.e.pri_evt.trans_id,
-                                         (char*)&node->u.evt.e.pri_evt.evt_data[0]);
-                                }
-                            }
-                        }
-                    }
-                    break;
-                default:
-                    break;
-                }
-            }
-            if (NULL != node) {
-                /* enqueue to evt cmd thread */
-                mm_camera_queue_enq(&(my_obj->evt_thread.cmd_queue), node);
-                /* wake up evt cmd thread */
-                sem_post(&(my_obj->evt_thread.cmd_sem));
-            }
-        }
-    }
-}
-
-int32_t mm_camera_enqueue_evt(mm_camera_obj_t *my_obj,
-                              mm_camera_event_t *event)
-{
-    int32_t rc = 0;
-    mm_camera_cmdcb_t *node = NULL;
-
-    node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-    if (NULL != node) {
-        memset(node, 0, sizeof(mm_camera_cmdcb_t));
-        node->cmd_type = MM_CAMERA_CMD_TYPE_EVT_CB;
-        memcpy(&node->u.evt, event, sizeof(mm_camera_event_t));
-
-        /* enqueue to evt cmd thread */
-        mm_camera_queue_enq(&(my_obj->evt_thread.cmd_queue), node);
-        /* wake up evt cmd thread */
-        sem_post(&(my_obj->evt_thread.cmd_sem));
-    } else {
-        CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
-        rc = -1;
-    }
-
-    return rc;
-}
-
-/* send local CH evt to HAL
- * may not needed since we have return val for each channel/stream operation */
-int32_t mm_camera_send_ch_event(mm_camera_obj_t *my_obj,
-                                uint32_t ch_id,
-                                uint32_t stream_id,
-                                mm_camera_ch_event_type_t evt)
-{
-    int rc = 0;
-    mm_camera_event_t event;
-    event.event_type = MM_CAMERA_EVT_TYPE_CH;
-    event.e.ch.evt = evt;
-    /* TODO: need to change the ch evt struct to include ch_id and stream_id. */
-    event.e.ch.ch = stream_id;
-    CDBG("%s: stream on event, type=0x%x, ch=%d, evt=%d",
-         __func__, event.event_type, event.e.ch.ch, event.e.ch.evt);
-    rc = mm_camera_enqueue_evt(my_obj, &event);
-    return rc;
-}
-
-int32_t mm_camera_open(mm_camera_obj_t *my_obj)
-{
-    char dev_name[MM_CAMERA_DEV_NAME_LEN];
-    int32_t rc = 0;
-    int8_t n_try=MM_CAMERA_DEV_OPEN_TRIES;
-    uint8_t sleep_msec=MM_CAMERA_DEV_OPEN_RETRY_SLEEP;
-    uint8_t i;
-    uint8_t cam_idx = mm_camera_util_get_index_by_handler(my_obj->my_hdl);
-
-    CDBG("%s:  begin\n", __func__);
-
-    snprintf(dev_name, sizeof(dev_name), "/dev/%s",
-             mm_camera_util_get_dev_name(my_obj->my_hdl));
-
-    do{
-        n_try--;
-        my_obj->ctrl_fd = open(dev_name, O_RDWR | O_NONBLOCK);
-        CDBG("%s:  ctrl_fd = %d, errno == %d", __func__, my_obj->ctrl_fd, errno);
-        if((my_obj->ctrl_fd > 0) || (errno != EIO) || (n_try <= 0 )) {
-            CDBG_ERROR("%s:  opened, break out while loop", __func__);
-            break;
-        }
-        CDBG("%s:failed with I/O error retrying after %d milli-seconds",
-             __func__,sleep_msec);
-        usleep(sleep_msec*1000);
-    }while(n_try>0);
-
-    if (my_obj->ctrl_fd <= 0) {
-        CDBG_ERROR("%s: cannot open control fd of '%s' (%s)\n",
-                 __func__, dev_name, strerror(errno));
-        rc = -1;
-        goto on_error;
-    }
-
-    /* open domain socket*/
-    n_try=MM_CAMERA_DEV_OPEN_TRIES;
-    do{
-        n_try--;
-        my_obj->ds_fd = mm_camera_socket_create(cam_idx, MM_CAMERA_SOCK_TYPE_UDP);
-        CDBG("%s:  ds_fd = %d, errno = %d", __func__, my_obj->ds_fd, errno);
-        if((my_obj->ds_fd > 0) || (n_try <= 0 )) {
-            CDBG("%s:  opened, break out while loop", __func__);
-            break;
-        }
-        CDBG("%s:failed with I/O error retrying after %d milli-seconds",
-             __func__,sleep_msec);
-        usleep(sleep_msec*1000);
-    }while(n_try>0);
-
-    if (my_obj->ds_fd <= 0) {
-        CDBG_ERROR("%s: cannot open domain socket fd of '%s'(%s)\n",
-                 __func__, dev_name, strerror(errno));
-        rc = -1;
-        goto on_error;
-    }
-
-    /* set ctrl_fd to be the mem_mapping fd */
-    rc =  mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                        MSM_V4L2_PID_MMAP_INST, 0);
-    if (rc < 0) {
-        CDBG_ERROR("error: ioctl VIDIOC_S_CTRL MSM_V4L2_PID_MMAP_INST failed: %s\n",
-                   strerror(errno));
-        goto on_error;
-    }
-
-    /* set geo mode to 2D by default */
-    my_obj->current_mode = CAMERA_MODE_2D;
-
-    pthread_mutex_init(&my_obj->cb_lock, NULL);
-
-    CDBG("%s : Launch async cmd Thread in Cam Open",__func__);
-    mm_camera_cmd_thread_launch(&my_obj->async_cmd_thread,
-                                mm_camera_handle_async_cmd,
-                                (void *)my_obj);
-
-    CDBG("%s : Launch evt Thread in Cam Open",__func__);
-    mm_camera_cmd_thread_launch(&my_obj->evt_thread,
-                                mm_camera_dispatch_app_event,
-                                (void *)my_obj);
-
-    /* launch event poll thread
-     * we will add evt fd into event poll thread upon user first register for evt */
-    CDBG("%s : Launch evt Poll Thread in Cam Open",__func__);
-    mm_camera_poll_thread_launch(&my_obj->evt_poll_thread,
-                                 MM_CAMERA_POLL_TYPE_EVT);
-
-    CDBG("%s:  end (rc = %d)\n", __func__, rc);
-    /* we do not need to unlock cam_lock here before return
-     * because for open, it's done within intf_lock */
-    return rc;
-
-on_error:
-    if (my_obj->ctrl_fd > 0) {
-        close(my_obj->ctrl_fd);
-        my_obj->ctrl_fd = -1;
-    }
-    if (my_obj->ds_fd > 0) {
-        mm_camera_socket_close(my_obj->ds_fd);
-       my_obj->ds_fd = -1;
-    }
-
-    /* we do not need to unlock cam_lock here before return
-     * because for open, it's done within intf_lock */
-    return rc;
-}
-
-int32_t mm_camera_close(mm_camera_obj_t *my_obj)
-{
-    CDBG("%s : Close evt Poll Thread in Cam Close",__func__);
-    mm_camera_poll_thread_release(&my_obj->evt_poll_thread);
-
-    CDBG("%s : Close evt cmd Thread in Cam Close",__func__);
-    mm_camera_cmd_thread_release(&my_obj->evt_thread);
-
-    CDBG("%s : Close asyn cmd Thread in Cam Close",__func__);
-    mm_camera_cmd_thread_release(&my_obj->async_cmd_thread);
-
-    if(my_obj->ctrl_fd > 0) {
-        close(my_obj->ctrl_fd);
-        my_obj->ctrl_fd = -1;
-    }
-    if(my_obj->ds_fd > 0) {
-        mm_camera_socket_close(my_obj->ds_fd);
-        my_obj->ds_fd = -1;
-    }
-
-    pthread_mutex_destroy(&my_obj->cb_lock);
-
-    pthread_mutex_unlock(&my_obj->cam_lock);
-    return 0;
-}
-
-uint8_t mm_camera_is_event_supported(mm_camera_obj_t *my_obj, mm_camera_event_type_t evt_type)
-{
-    switch(evt_type) {
-    case MM_CAMERA_EVT_TYPE_CH:
-    case MM_CAMERA_EVT_TYPE_CTRL:
-    case MM_CAMERA_EVT_TYPE_STATS:
-    case MM_CAMERA_EVT_TYPE_INFO:
-      return 1;
-    default:
-      return 0;
-    }
-    return 0;
-}
-
-int32_t mm_camera_register_event_notify_internal(
-                                   mm_camera_obj_t *my_obj,
-                                   mm_camera_event_notify_t evt_cb,
-                                   void * user_data,
-                                   mm_camera_event_type_t evt_type)
-{
-    int i;
-    int rc = -1;
-    mm_camera_evt_obj_t *evt_array = NULL;
-
-    pthread_mutex_lock(&my_obj->cb_lock);
-    evt_array = &my_obj->evt[evt_type];
-    if(evt_cb) {
-        /* this is reg case */
-        for(i = 0; i < MM_CAMERA_EVT_ENTRY_MAX; i++) {
-            if(evt_array->evt[i].user_data == NULL) {
-                evt_array->evt[i].evt_cb = evt_cb;
-                evt_array->evt[i].user_data = user_data;
-                evt_array->reg_count++;
-                rc = 0;
-                break;
-            }
-        }
-    } else {
-        /* this is unreg case */
-        for(i = 0; i < MM_CAMERA_EVT_ENTRY_MAX; i++) {
-            if(evt_array->evt[i].user_data == user_data) {
-                evt_array->evt[i].evt_cb = NULL;
-                evt_array->evt[i].user_data = NULL;
-                evt_array->reg_count--;
-                rc = 0;
-                break;
-            }
-        }
-    }
-
-    if(rc == 0 && evt_array->reg_count <= 1) {
-        /* subscribe/unsubscribe event to kernel */
-        rc = mm_camera_evt_sub(my_obj, evt_type, evt_array->reg_count);
-    }
-
-    pthread_mutex_unlock(&my_obj->cb_lock);
-    return rc;
-}
-
-int32_t mm_camera_register_event_notify(mm_camera_obj_t *my_obj,
-                                   mm_camera_event_notify_t evt_cb,
-                                   void * user_data,
-                                   mm_camera_event_type_t evt_type)
-{
-    int i;
-    int rc = -1;
-    mm_camera_evt_obj_t *evt_array = &my_obj->evt[evt_type];
-
-    rc = mm_camera_register_event_notify_internal(my_obj, evt_cb,
-                                                  user_data, evt_type);
-
-    pthread_mutex_unlock(&my_obj->cam_lock);
-    return rc;
-}
-
-int32_t mm_camera_qbuf(mm_camera_obj_t *my_obj,
-                       uint32_t ch_id,
-                       mm_camera_buf_def_t *buf)
-{
-    int rc = -1;
-    mm_channel_t * ch_obj = NULL;
-    ch_obj = mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    pthread_mutex_unlock(&my_obj->cam_lock);
-
-    /* we always assume qbuf will be done before channel/stream is fully stopped
-     * because qbuf is done within dataCB context
-     * in order to avoid deadlock, we are not locking ch_lock for qbuf */
-    if (NULL != ch_obj) {
-        rc = mm_channel_qbuf(ch_obj, buf);
-    }
-
-    return rc;
-}
-
-mm_camera_2nd_sensor_t * mm_camera_query_2nd_sensor_info(mm_camera_obj_t *my_obj)
-{
-    /* TODO: need to sync with backend how to get 2nd sensor info */
-    return NULL;
-}
-
-int32_t mm_camera_sync(mm_camera_obj_t *my_obj)
-{
-    int32_t rc = 0;
-
-    /* get camera capabilities */
-    memset(&my_obj->properties, 0, sizeof(cam_prop_t));
-    rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                        CAMERA_GET_CAPABILITIES,
-                                        sizeof(cam_prop_t),
-                                        (void *)&my_obj->properties);
-    if (rc != 0) {
-        CDBG_ERROR("%s: cannot get camera capabilities\n", __func__);
-        goto on_error;
-    }
-
-on_error:
-    pthread_mutex_unlock(&my_obj->cam_lock);
-    return rc;
-
-}
-
-int32_t mm_camera_is_op_supported(mm_camera_obj_t *my_obj,
-                                   mm_camera_ops_type_t op_code)
-{
-    int32_t rc = 0;
-    int32_t is_ops_supported = false;
-    int index = 0;
-
-    if (op_code != MM_CAMERA_OPS_LOCAL) {
-        index = op_code/32;
-        is_ops_supported = ((my_obj->properties.ops[index] &
-            (1<<op_code)) != 0);
-
-    }
-    pthread_mutex_unlock(&my_obj->cam_lock);
-    return is_ops_supported;
-}
-
-int32_t mm_camera_is_parm_supported(mm_camera_obj_t *my_obj,
-                                   mm_camera_parm_type_t parm_type,
-                                   uint8_t *support_set_parm,
-                                   uint8_t *support_get_parm)
-{
-    /* TODO: need to sync with backend if it can support set/get */
-    int32_t rc = 0;
-    *support_set_parm = GET_PARM_BIT32(parm_type,
-                                       my_obj->properties.parm);
-    *support_get_parm = GET_PARM_BIT32(parm_type,
-                                       my_obj->properties.parm);
-    pthread_mutex_unlock(&my_obj->cam_lock);
-
-    return rc;
-}
-
-int32_t mm_camera_util_set_op_mode(mm_camera_obj_t * my_obj,
-                                   mm_camera_op_mode_type_t *op_mode)
-{
-    int32_t rc = 0;
-    int32_t v4l2_op_mode = MSM_V4L2_CAM_OP_DEFAULT;
-
-    if (my_obj->op_mode == *op_mode)
-        goto end;
-    switch(*op_mode) {
-    case MM_CAMERA_OP_MODE_ZSL:
-        v4l2_op_mode = MSM_V4L2_CAM_OP_ZSL;
-            break;
-    case MM_CAMERA_OP_MODE_CAPTURE:
-        v4l2_op_mode = MSM_V4L2_CAM_OP_CAPTURE;
-            break;
-    case MM_CAMERA_OP_MODE_VIDEO:
-        v4l2_op_mode = MSM_V4L2_CAM_OP_VIDEO;
-            break;
-    case MM_CAMERA_OP_MODE_RAW:
-        v4l2_op_mode = MSM_V4L2_CAM_OP_RAW;
-            break;
-    default:
-        rc = - 1;
-        goto end;
-        break;
-    }
-    if(0 != (rc =  mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-            MSM_V4L2_PID_CAM_MODE, v4l2_op_mode))){
-        CDBG_ERROR("%s: input op_mode=%d, s_ctrl rc=%d\n", __func__, *op_mode, rc);
-        goto end;
-    }
-    /* if success update mode field */
-    my_obj->op_mode = *op_mode;
-end:
-    CDBG("%s: op_mode=%d,rc=%d\n", __func__, *op_mode, rc);
-    return rc;
-}
-
-int32_t mm_camera_set_parm(mm_camera_obj_t *my_obj,
-                           mm_camera_parm_type_t parm_type,
-                           void* p_value)
-{
-    int32_t rc = 0;
-    CDBG("%s type =%d", __func__, parm_type);
-    switch(parm_type) {
-    case MM_CAMERA_PARM_OP_MODE:
-        rc = mm_camera_util_set_op_mode(my_obj,
-                        (mm_camera_op_mode_type_t *)p_value);
-        break;
-    case MM_CAMERA_PARM_DIMENSION:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                    CAMERA_SET_PARM_DIMENSION, sizeof(cam_ctrl_dimension_t), p_value);
-        if(rc != 0) {
-            CDBG("%s: mm_camera_send_native_ctrl_cmd err=%d\n", __func__, rc);
-            break;
-        }
-        memcpy(&my_obj->dim, (cam_ctrl_dimension_t *)p_value,
-                     sizeof(cam_ctrl_dimension_t));
-        CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,raw_w=%d,raw_h=%d\n",
-                 __func__,
-                 my_obj->dim.display_width,my_obj->dim.display_height,
-                 my_obj->dim.video_width, my_obj->dim.video_height,
-                 my_obj->dim.picture_width,my_obj->dim.picture_height,
-                 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
-                 my_obj->dim.raw_picture_width,my_obj->dim.raw_picture_height);
-        break;
-    case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
-        my_obj->snap_burst_num_by_user = *((uint32_t *)p_value);
-        break;
-    default:
-        rc = mm_camera_set_general_parm(my_obj, parm_type, p_value);
-        break;
-    }
-    pthread_mutex_unlock(&my_obj->cam_lock);
-    return rc;
-}
-
-int32_t mm_camera_get_parm(mm_camera_obj_t *my_obj,
-                           mm_camera_parm_type_t parm_type,
-                           void* p_value)
-{
-    int32_t rc = 0;
-
-    switch(parm_type) {
-    case MM_CAMERA_PARM_FRAME_RESOLUTION:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_FRAME_RESOLUTION,
-                                            sizeof(cam_frame_resolution_t),
-                                            p_value);
-        if (rc < 0)
-            CDBG_ERROR("%s: ERROR in CAMERA_GET_PARM_FRAME_RESOLUTION, rc = %d",
-                 __func__, rc);
-        break;
-    case MM_CAMERA_PARM_MAX_PICTURE_SIZE:
-        {
-            mm_camera_dimension_t *dim =
-                (mm_camera_dimension_t *)p_value;
-            dim->height = my_obj->properties.max_pict_height;
-            dim->width = my_obj->properties.max_pict_width;
-            CDBG("%s: Max Picture Size: %d X %d\n", __func__,
-                 dim->width, dim->height);
-        }
-        break;
-    case MM_CAMERA_PARM_PREVIEW_FORMAT:
-        *((int *)p_value) = my_obj->properties.preview_format;
-        break;
-    case MM_CAMERA_PARM_PREVIEW_SIZES_CNT:
-        *((int *)p_value) = my_obj->properties.preview_sizes_cnt;
-        break;
-    case MM_CAMERA_PARM_VIDEO_SIZES_CNT:
-        *((int *)p_value) = my_obj->properties.video_sizes_cnt;
-        break;
-    case MM_CAMERA_PARM_THUMB_SIZES_CNT:
-        *((int *)p_value) = my_obj->properties.thumb_sizes_cnt;
-        break;
-    case MM_CAMERA_PARM_HFR_SIZES_CNT:
-        *((int *)p_value) = my_obj->properties.hfr_sizes_cnt;
-        break;
-    case MM_CAMERA_PARM_HFR_FRAME_SKIP:
-        *((int *)p_value) = my_obj->properties.hfr_frame_skip;
-        break;
-    case MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH:
-        *((int *)p_value) = my_obj->properties.default_preview_width;
-        break;
-    case MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT:
-        *((int *)p_value) = my_obj->properties.default_preview_height;
-        break;
-    case MM_CAMERA_PARM_MAX_PREVIEW_SIZE:
-        {
-            mm_camera_dimension_t *dim =
-                (mm_camera_dimension_t *)p_value;
-            dim->height = my_obj->properties.max_preview_height;
-            dim->width = my_obj->properties.max_preview_width;
-            CDBG("%s: Max Preview Size: %d X %d\n", __func__,
-                 dim->width, dim->height);
-        }
-        break;
-    case MM_CAMERA_PARM_MAX_VIDEO_SIZE:
-        {
-            mm_camera_dimension_t *dim =
-                (mm_camera_dimension_t *)p_value;
-            dim->height = my_obj->properties.max_video_height;
-            dim->width = my_obj->properties.max_video_width;
-            CDBG("%s: Max Video Size: %d X %d\n", __func__,
-                 dim->width, dim->height);
-        }
-        break;
-    case MM_CAMERA_PARM_MAX_HFR_MODE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_MAX_HFR_MODE,
-                                            sizeof(camera_hfr_mode_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_FOCAL_LENGTH:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_FOCAL_LENGTH,
-                                            sizeof(float),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
-                                            sizeof(float),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
-                                            sizeof(float),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_FOCUS_DISTANCES:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_FOCUS_DISTANCES,
-                                            sizeof(focus_distances_info_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_QUERY_FALSH4SNAP:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_QUERY_FLASH_FOR_SNAPSHOT,
-                                            sizeof(int),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_3D_FRAME_FORMAT:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_3D_FRAME_FORMAT,
-                                            sizeof(camera_3d_frame_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_MAXZOOM:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_MAXZOOM,
-                                            sizeof(int),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_ZOOM_RATIO:
-        {
-            mm_camera_zoom_tbl_t *tbl = (mm_camera_zoom_tbl_t *)p_value;
-            rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                                CAMERA_GET_PARM_ZOOMRATIOS,
-                                                sizeof(int16_t)*tbl->size,
-                                                (void *)(tbl->zoom_ratio_tbl));
-        }
-        break;
-    case MM_CAMERA_PARM_DEF_PREVIEW_SIZES:
-        {
-            default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)p_value;
-            rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                                CAMERA_GET_PARM_DEF_PREVIEW_SIZES,
-                                                sizeof(struct camera_size_type)*tbl->tbl_size,
-                                                (void* )(tbl->sizes_tbl));
-        }
-        break;
-    case MM_CAMERA_PARM_DEF_VIDEO_SIZES:
-        {
-            default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)p_value;
-            rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                                CAMERA_GET_PARM_DEF_VIDEO_SIZES,
-                                                sizeof(struct camera_size_type)*tbl->tbl_size,
-                                                (void *)(tbl->sizes_tbl));
-        }
-        break;
-    case MM_CAMERA_PARM_DEF_THUMB_SIZES:
-        {
-            default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)p_value;
-            rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                                CAMERA_GET_PARM_DEF_THUMB_SIZES,
-                                                sizeof(struct camera_size_type)*tbl->tbl_size,
-                                                (void *)(tbl->sizes_tbl));
-        }
-        break;
-    case MM_CAMERA_PARM_DEF_HFR_SIZES:
-        {
-            default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)p_value;
-            rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                                CAMERA_GET_PARM_DEF_HFR_SIZES,
-                                                sizeof(struct camera_size_type)*tbl->tbl_size,
-                                                (void *)(tbl->sizes_tbl));
-        }
-        break;
-    case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
-        *((int *)p_value) = my_obj->snap_burst_num_by_user;
-        break;
-    case MM_CAMERA_PARM_VFE_OUTPUT_ENABLE:
-        *((int *)p_value) = my_obj->properties.vfe_output_enable;
-        break;
-    case MM_CAMERA_PARM_DIMENSION:
-        memcpy(p_value, &my_obj->dim, sizeof(my_obj->dim));
-        CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,ovx=%x,ovy=%d,opx=%d,opy=%d, m_fmt=%d, t_ftm=%d\n",
-                 __func__,
-                 my_obj->dim.display_width,my_obj->dim.display_height,
-                 my_obj->dim.video_width,my_obj->dim.video_height,
-                 my_obj->dim.picture_width,my_obj->dim.picture_height,
-                 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
-                 my_obj->dim.orig_video_width,my_obj->dim.orig_video_height,
-                 my_obj->dim.orig_picture_width,my_obj->dim.orig_picture_height,
-                 my_obj->dim.main_img_format, my_obj->dim.thumb_format);
-        break;
-    case MM_CAMERA_PARM_OP_MODE:
-        *((mm_camera_op_mode_type_t *)p_value) = my_obj->op_mode;
-        break;
-    case MM_CAMERA_PARM_MAX_NUM_FACES_DECT:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_MAX_NUM_FACES_DECT,
-                                            sizeof(int),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_HDR:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_HDR,
-                                            sizeof(exp_bracketing_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_FPS_RANGE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_FPS_RANGE,
-                                            sizeof(cam_sensor_fps_range_t),
-                                            p_value);
-        break;
-
-    case MM_CAMERA_PARM_BESTSHOT_RECONFIGURE:
-        *((int *)p_value) = my_obj->properties.bestshot_reconfigure;
-        break;
-
-    case MM_CAMERA_PARM_MOBICAT:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_MOBICAT,
-                                            sizeof(cam_exif_tags_t),
-                                            p_value);
-        break;
-    default:
-        /* needs to add more implementation */
-        rc = -1;
-        break;
-    }
-
-    pthread_mutex_unlock(&my_obj->cam_lock);
-    return rc;
-}
-
-uint32_t mm_camera_add_channel(mm_camera_obj_t *my_obj)
-{
-    mm_channel_t *ch_obj = NULL;
-    uint8_t ch_idx = 0;
-    uint32_t ch_hdl = 0;
-
-    for(ch_idx = 0; ch_idx < MM_CAMERA_CHANNEL_MAX; ch_idx++) {
-        if (MM_CHANNEL_STATE_NOTUSED == my_obj->ch[ch_idx].state) {
-            ch_obj = &my_obj->ch[ch_idx];
-            break;
-        }
-    }
-
-    if (NULL != ch_obj) {
-        /* initialize channel obj */
-        memset(ch_obj, 0, sizeof(mm_channel_t));
-        ch_hdl = mm_camera_util_generate_handler(ch_idx);
-        ch_obj->my_hdl = ch_hdl;
-        ch_obj->state = MM_CHANNEL_STATE_STOPPED;
-        ch_obj->cam_obj = my_obj;
-        pthread_mutex_init(&ch_obj->ch_lock, NULL);
-    }
-
-    mm_channel_init(ch_obj);
-    pthread_mutex_unlock(&my_obj->cam_lock);
-
-    return ch_hdl;
-}
-
-void mm_camera_del_channel(mm_camera_obj_t *my_obj,
-                           uint32_t ch_id)
-{
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_DELETE,
-                               NULL,
-                               NULL);
-
-        pthread_mutex_destroy(&ch_obj->ch_lock);
-        memset(ch_obj, 0, sizeof(mm_channel_t));
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-}
-
-uint32_t mm_camera_add_stream(mm_camera_obj_t *my_obj,
-                              uint32_t ch_id,
-                              mm_camera_buf_notify_t buf_cb, void *user_data,
-                              uint32_t ext_image_mode, uint32_t sensor_idx)
-{
-    uint32_t s_hdl = 0;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-    mm_evt_paylod_add_stream_t payload;
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_paylod_add_stream_t));
-        payload.buf_cb = buf_cb;
-        payload.user_data = user_data;
-        payload.ext_image_mode = ext_image_mode;
-        payload.sensor_idx = sensor_idx;
-        mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_ADD_STREAM,
-                               (void*)&payload,
-                               (void*)&s_hdl);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return s_hdl;
-}
-
-int32_t mm_camera_del_stream(mm_camera_obj_t *my_obj,
-                             uint32_t ch_id,
-                             uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_DEL_STREAM,
-                               (void*)&stream_id,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_config_stream(mm_camera_obj_t *my_obj,
-                                uint32_t ch_id,
-                                uint32_t stream_id,
-                                mm_camera_stream_config_t *config)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-    mm_evt_paylod_config_stream_t payload;
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_paylod_config_stream_t));
-        payload.stream_id = stream_id;
-        payload.config = config;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_CONFIG_STREAM,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_bundle_streams(mm_camera_obj_t *my_obj,
-                                 uint32_t ch_id,
-                                 mm_camera_buf_notify_t super_frame_notify_cb,
-                                 void *user_data,
-                                 mm_camera_bundle_attr_t *attr,
-                                 uint8_t num_streams,
-                                 uint32_t *stream_ids)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-    mm_evt_payload_bundle_stream_t payload;
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_payload_bundle_stream_t));
-        payload.super_frame_notify_cb = super_frame_notify_cb;
-        payload.user_data = user_data;
-        payload.attr = attr;
-        payload.num_streams = num_streams;
-        payload.stream_ids = stream_ids;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_INIT_BUNDLE,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_destroy_bundle(mm_camera_obj_t *my_obj, uint32_t ch_id)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_DESTROY_BUNDLE,
-                               NULL,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_start_streams(mm_camera_obj_t *my_obj,
-                                uint32_t ch_id,
-                                uint8_t num_streams,
-                                uint32_t *stream_ids)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-    mm_evt_payload_start_stream_t payload;
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_payload_start_stream_t));
-        payload.num_streams = num_streams;
-        payload.stream_ids = stream_ids;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_START_STREAM,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_stop_streams(mm_camera_obj_t *my_obj,
-                               uint32_t ch_id,
-                               uint8_t num_streams,
-                               uint32_t *stream_ids)
-{
-    int32_t rc = 0;
-    mm_evt_payload_stop_stream_t payload;
-    mm_camera_cmdcb_t * node = NULL;
-
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_payload_stop_stream_t));
-        payload.num_streams = num_streams;
-        payload.stream_ids = stream_ids;
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_STOP_STREAM,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-    return rc;
-}
-
-int32_t mm_camera_async_teardown_streams(mm_camera_obj_t *my_obj,
-                                          uint32_t ch_id,
-                                          uint8_t num_streams,
-                                          uint32_t *stream_ids)
-{
-    int32_t rc = 0;
-    mm_evt_payload_stop_stream_t payload;
-    mm_camera_cmdcb_t * node = NULL;
-
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        /* enqueu asyn stop cmd to async_cmd_thread */
-        node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-        if (NULL != node) {
-            memset(node, 0, sizeof(mm_camera_cmdcb_t));
-            node->cmd_type = MM_CAMERA_CMD_TYPE_ASYNC_CB;
-            node->u.async.cmd_type = MM_CAMERA_ASYNC_CMD_TYPE_STOP;
-            node->u.async.u.stop_cmd.ch_obj = ch_obj;
-            node->u.async.u.stop_cmd.num_streams = num_streams;
-            memcpy(node->u.async.u.stop_cmd.stream_ids, stream_ids, sizeof(uint32_t)*num_streams);
-
-            /* enqueue to async cmd thread */
-            mm_camera_queue_enq(&(my_obj->async_cmd_thread.cmd_queue), node);
-            /* wake up async cmd thread */
-            sem_post(&(my_obj->async_cmd_thread.cmd_sem));
-        } else {
-            CDBG_ERROR("%s: No memory for mm_camera_cmdcb_t", __func__);
-            pthread_mutex_unlock(&ch_obj->ch_lock);
-            rc = -1;
-            return rc;
-        }
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-    return rc;
-}
-
-int32_t mm_camera_request_super_buf(mm_camera_obj_t *my_obj,
-                                    uint32_t ch_id,
-                                    uint32_t num_buf_requested)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_REQUEST_SUPER_BUF,
-                               (void*)num_buf_requested,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_cancel_super_buf_request(mm_camera_obj_t *my_obj, uint32_t ch_id)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF,
-                               NULL,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_start_focus(mm_camera_obj_t *my_obj,
-                              uint32_t ch_id,
-                              uint32_t sensor_idx,
-                              uint32_t focus_mode)
-{
-    int32_t rc = -1;
-    mm_evt_payload_start_focus_t payload;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_payload_start_focus_t));
-        payload.sensor_idx = sensor_idx;
-        payload.focus_mode = focus_mode;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_START_FOCUS,
-                               (void *)&payload,
-                               NULL);
-        if (0 != rc) {
-            mm_camera_event_t event;
-            event.event_type = MM_CAMERA_EVT_TYPE_CTRL;
-            event.e.ctrl.evt = MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE;
-            event.e.ctrl.status = CAM_CTRL_FAILED;
-            rc = mm_camera_enqueue_evt(my_obj, &event);
-        }
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_abort_focus(mm_camera_obj_t *my_obj,
-                              uint32_t ch_id,
-                              uint32_t sensor_idx)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_ABORT_FOCUS,
-                               (void*)sensor_idx,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_prepare_snapshot(mm_camera_obj_t *my_obj,
-                                   uint32_t ch_id,
-                                   uint32_t sensor_idx)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_PREPARE_SNAPSHOT,
-                               (void *)sensor_idx,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_set_stream_parm(mm_camera_obj_t *my_obj,
-                                  uint32_t ch_id,
-                                  uint32_t s_id,
-                                  mm_camera_stream_parm_t parm_type,
-                                  void* p_value)
-{
-    int32_t rc = -1;
-    mm_evt_paylod_stream_parm_t payload;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload,0,sizeof(mm_evt_paylod_stream_parm_t));
-        payload.parm_type = parm_type;
-        payload.value = p_value;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_SET_STREAM_PARM,
-                               (void *)s_id,
-                               &payload);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_get_stream_parm(mm_camera_obj_t *my_obj,
-                                  uint32_t ch_id,
-                                  uint32_t s_id,
-                                  mm_camera_stream_parm_t parm_type,
-                                  void* p_value)
-{
-    int32_t rc = -1;
-    mm_evt_paylod_stream_parm_t payload;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload,0,sizeof(mm_evt_paylod_stream_parm_t));
-        payload.parm_type = parm_type;
-        payload.value = p_value;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_GET_STREAM_PARM,
-                               (void *)s_id,
-                               &payload);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_send_private_ioctl(mm_camera_obj_t *my_obj,
-                                     uint32_t cmd_id,
-                                     uint32_t cmd_length,
-                                     void *cmd)
-{
-    int32_t rc = -1;
-
-    struct msm_camera_v4l2_ioctl_t v4l2_ioctl;
-
-    CDBG("%s: cmd = %p, length = %d",
-               __func__, cmd, cmd_length);
-    memset(&v4l2_ioctl, 0, sizeof(v4l2_ioctl));
-    v4l2_ioctl.id = cmd_id;
-    v4l2_ioctl.len = cmd_length;
-    v4l2_ioctl.ioctl_ptr = cmd;
-    rc = ioctl (my_obj->ctrl_fd, MSM_CAM_V4L2_IOCTL_PRIVATE_GENERAL, &v4l2_ioctl);
-
-    if(rc < 0) {
-        CDBG_ERROR("%s: cmd = %p, id = %d, length = %d, rc = %d\n",
-                   __func__, cmd, cmd_id, cmd_length, rc);
-    } else {
-        rc = 0;
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_ctrl_set_specialEffect (mm_camera_obj_t *my_obj, int32_t effect) {
-    struct v4l2_control ctrl;
-    if (effect == CAMERA_EFFECT_MAX)
-        effect = CAMERA_EFFECT_OFF;
-    int rc = 0;
-
-    ctrl.id = MSM_V4L2_PID_EFFECT;
-    ctrl.value = effect;
-    rc = ioctl(my_obj->ctrl_fd, VIDIOC_S_CTRL, &ctrl);
-    return (rc >= 0)? 0: -1;;
-}
-
-int32_t mm_camera_ctrl_set_auto_focus (mm_camera_obj_t *my_obj, int32_t value)
-{
-    int32_t rc = 0;
-    struct v4l2_queryctrl queryctrl;
-
-    memset (&queryctrl, 0, sizeof (queryctrl));
-    queryctrl.id = V4L2_CID_FOCUS_AUTO;
-
-    if(value != 0 && value != 1) {
-        CDBG("%s:boolean required, invalid value = %d\n",__func__, value);
-        return -1;
-    }
-    if (-1 == ioctl (my_obj->ctrl_fd, VIDIOC_QUERYCTRL, &queryctrl)) {
-        CDBG ("V4L2_CID_FOCUS_AUTO is not supported\n");
-    } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-        CDBG ("%s:V4L2_CID_FOCUS_AUTO is not supported\n", __func__);
-    } else {
-        if(0 != (rc =  mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                V4L2_CID_FOCUS_AUTO, value))){
-            CDBG("%s: error, id=0x%x, value=%d, rc = %d\n",
-                     __func__, V4L2_CID_FOCUS_AUTO, value, rc);
-            rc = -1;
-        }
-    }
-    return rc;
-}
-
-int32_t mm_camera_ctrl_set_whitebalance (mm_camera_obj_t *my_obj, int32_t mode) {
-
-    int32_t rc = 0, auto_wb, temperature;
-    uint32_t id_auto_wb, id_temperature;
-
-    id_auto_wb = V4L2_CID_AUTO_WHITE_BALANCE;
-    id_temperature = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
-
-    switch(mode) {
-    case CAMERA_WB_DAYLIGHT:
-        auto_wb = 0;
-        temperature = 6500;
-        break;
-    case CAMERA_WB_INCANDESCENT:
-        auto_wb = 0;
-        temperature = 2800;
-        break;
-    case CAMERA_WB_FLUORESCENT:
-        auto_wb = 0;
-        temperature = 4200;
-        break;
-    case CAMERA_WB_CLOUDY_DAYLIGHT:
-        auto_wb = 0;
-        temperature = 7500;
-        break;
-    case CAMERA_WB_AUTO:
-    default:
-        auto_wb = 1; /* TRUE */
-        temperature = 0;
-        break;
-    }
-
-    rc =  mm_camera_util_s_ctrl(my_obj->ctrl_fd, id_auto_wb, auto_wb);
-    if(0 != rc){
-        CDBG_ERROR("%s: error, V4L2_CID_AUTO_WHITE_BALANCE value = %d, rc = %d\n",
-            __func__, auto_wb, rc);
-        return rc;
-    }
-    if (!auto_wb) {
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd, id_temperature, temperature);
-        if (0 != rc) {
-            CDBG_ERROR("%s: error, V4L2_CID_WHITE_BALANCE_TEMPERATURE value = %d, rc = %d\n",
-                __func__, temperature, rc);
-            return rc;
-        }
-    }
-    return rc;
-}
-
-int32_t mm_camera_set_general_parm(mm_camera_obj_t * my_obj,
-                                   mm_camera_parm_type_t parm_type,
-                                   void* p_value)
-{
-    int rc = -1;
-    int isZSL =0;
-
-    switch(parm_type)  {
-    case MM_CAMERA_PARM_EXPOSURE:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   MSM_V4L2_PID_EXP_METERING,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_SHARPNESS:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   V4L2_CID_SHARPNESS,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_CONTRAST:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   V4L2_CID_CONTRAST,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_SATURATION:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   V4L2_CID_SATURATION,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_BRIGHTNESS:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   V4L2_CID_BRIGHTNESS,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_WHITE_BALANCE:
-        rc = mm_camera_ctrl_set_whitebalance (my_obj, *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_ISO:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   MSM_V4L2_PID_ISO,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_ZOOM:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   V4L2_CID_ZOOM_ABSOLUTE,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_LUMA_ADAPTATION:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   MSM_V4L2_PID_LUMA_ADAPTATION,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_ANTIBANDING:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   V4L2_CID_POWER_LINE_FREQUENCY,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_CONTINUOUS_AF:
-        rc = mm_camera_ctrl_set_auto_focus(my_obj,
-                                           *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_HJR:
-        rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
-                                   MSM_V4L2_PID_HJR,
-                                   *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_EFFECT:
-        rc = mm_camera_ctrl_set_specialEffect (my_obj,
-                                               *((int32_t *)p_value));
-        break;
-    case MM_CAMERA_PARM_FPS:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_FPS,
-                                            sizeof(uint32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_FPS_MODE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_FPS_MODE,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_EXPOSURE_COMPENSATION:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_EXPOSURE_COMPENSATION,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_LED_MODE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_LED_MODE,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_ROLLOFF:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_ROLLOFF,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_MODE:
-        my_obj->current_mode = *((camera_mode_t *)p_value);
-        break;
-    case MM_CAMERA_PARM_FOCUS_RECT:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_FOCUS_RECT,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_AEC_ROI:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_AEC_ROI,
-                                            sizeof(cam_set_aec_roi_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_AF_ROI:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_AF_ROI,
-                                            sizeof(roi_info_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_FOCUS_MODE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_AF_MODE,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-#if 0 /* to be enabled later: @punits */
-    case MM_CAMERA_PARM_AF_MTR_AREA:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_AF_MTR_AREA,
-                                            sizeof(af_mtr_area_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_AEC_MTR_AREA:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_AEC_MTR_AREA,
-                                            sizeof(aec_mtr_area_t),
-                                            p_value);
-        break;
-#endif
-    case MM_CAMERA_PARM_CAF_ENABLE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_CAF,
-                                            sizeof(uint32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_BESTSHOT_MODE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_BESTSHOT_MODE,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_VIDEO_DIS:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_VIDEO_DIS_PARAMS,
-                                            sizeof(video_dis_param_ctrl_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_VIDEO_ROT:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_VIDEO_ROT_PARAMS,
-                                            sizeof(video_rotation_param_ctrl_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_SCE_FACTOR:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_SCE_FACTOR,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_FD:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_FD,
-                                            sizeof(fd_set_parm_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_AEC_LOCK:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_AEC_LOCK,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_AWB_LOCK:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_AWB_LOCK,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_MCE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_MCE,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
-                                            sizeof(focus_distances_info_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
-                                            sizeof(focus_distances_info_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_RESET_LENS_TO_INFINITY:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_RESET_LENS_TO_INFINITY,
-                                            0, NULL);
-        break;
-    case MM_CAMERA_PARM_SNAPSHOTDATA:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_GET_PARM_SNAPSHOTDATA,
-                                            sizeof(snapshotData_info_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_HFR:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_HFR,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_REDEYE_REDUCTION:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_REDEYE_REDUCTION,
-                                            sizeof(int32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_WAVELET_DENOISE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_WAVELET_DENOISE,
-                                            sizeof(denoise_param_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_3D_DISPLAY_DISTANCE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_3D_DISPLAY_DISTANCE,
-                                            sizeof(float),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_3D_VIEW_ANGLE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_3D_VIEW_ANGLE,
-                                            sizeof(uint32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_ZOOM_RATIO:
-        break;
-    case MM_CAMERA_PARM_HISTOGRAM:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_HISTOGRAM,
-                                            sizeof(int8_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_ASD_ENABLE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                          CAMERA_SET_ASD_ENABLE,
-                                          sizeof(uint32_t),
-                                          p_value);
-        break;
-    case MM_CAMERA_PARM_RECORDING_HINT:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_RECORDING_HINT,
-                                            sizeof(uint32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_PREVIEW_FORMAT:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_PREVIEW_FORMAT,
-                                            sizeof(uint32_t),
-                                            p_value);
-        break;
-    /* TODO: need code review to determine any of the three is redundent
-     * MM_CAMERA_PARM_DIS_ENABLE,
-     * MM_CAMERA_PARM_FULL_LIVESHOT,
-     * MM_CAMERA_PARM_LOW_POWER_MODE*/
-    case MM_CAMERA_PARM_DIS_ENABLE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_DIS_ENABLE,
-                                            sizeof(uint32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_FULL_LIVESHOT:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_FULL_LIVESHOT,
-                                            sizeof(uint32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_LOW_POWER_MODE:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_LOW_POWER_MODE,
-                                            sizeof(uint32_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_HDR:
-        rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_SET_PARM_HDR,
-                                            sizeof(exp_bracketing_t),
-                                            p_value);
-        break;
-    case MM_CAMERA_PARM_MOBICAT:
-	    rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                            CAMERA_ENABLE_MOBICAT,
-                                            sizeof(mm_cam_mobicat_info_t),
-                                            p_value);
-    default:
-        CDBG("%s: default: parm %d not supported\n", __func__, parm_type);
-        break;
-    }
-    return rc;
-}
-
-int32_t mm_camera_util_private_s_ctrl(int32_t fd, uint32_t id, void* value)
-{
-    int rc = -1;
-    struct msm_camera_v4l2_ioctl_t v4l2_ioctl;
-
-    memset(&v4l2_ioctl, 0, sizeof(v4l2_ioctl));
-    v4l2_ioctl.id = id;
-    v4l2_ioctl.ioctl_ptr = value;
-    rc = ioctl (fd, MSM_CAM_V4L2_IOCTL_PRIVATE_S_CTRL, &v4l2_ioctl);
-
-    if(rc < 0) {
-        CDBG_ERROR("%s: fd=%d, S_CTRL, id=0x%x, value = 0x%x, rc = %d\n",
-                   __func__, fd, id, (uint32_t)value, rc);
-        rc = -1;
-    } else {
-        rc = 0;
-    }
-    return rc;
-}
-
-int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
-                                              cam_ctrl_type type,
-                                              uint32_t length,
-                                              void *value)
-{
-    return mm_camera_send_native_ctrl_timeout_cmd(my_obj, type,
-                                                  length, value,
-                                                  1000);
-}
-
-int32_t mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,
-                                                      cam_ctrl_type type,
-                                                      uint32_t length,
-                                                      void *value,
-                                                      int timeout)
-{
-    int rc = -1;
-    struct msm_ctrl_cmd ctrl_cmd;
-
-    memset(&ctrl_cmd, 0, sizeof(ctrl_cmd));
-    ctrl_cmd.type = type;
-    ctrl_cmd.length = (uint16_t)length;
-    ctrl_cmd.timeout_ms = timeout;
-    ctrl_cmd.value = value;
-    ctrl_cmd.status = (uint16_t)CAM_CTRL_SUCCESS;
-    rc = mm_camera_util_private_s_ctrl(my_obj->ctrl_fd,
-                               MSM_V4L2_PID_CTRL_CMD,
-                               (void*)&ctrl_cmd);
-    CDBG("%s: type=%d, rc = %d, status = %d\n",
-        __func__, type, rc, ctrl_cmd.status);
-    if(rc != 0 || ((ctrl_cmd.status != CAM_CTRL_ACCEPTED) &&
-        (ctrl_cmd.status != CAM_CTRL_SUCCESS) &&
-        (ctrl_cmd.status != CAM_CTRL_INVALID_PARM)))
-        rc = -1;
-    return rc;
-}
-
-int mm_camera_evt_sub(mm_camera_obj_t * my_obj,
-                      mm_camera_event_type_t evt_type,
-                      int reg_count)
-{
-    int rc = 0;
-    struct v4l2_event_subscription sub;
-
-    memset(&sub, 0, sizeof(sub));
-    sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_EVENT;
-    if(reg_count == 0) {
-        /* unsubscribe */
-        if(my_obj->evt_type_mask == (uint32_t)(1 << evt_type)) {
-            rc = ioctl(my_obj->ctrl_fd, VIDIOC_UNSUBSCRIBE_EVENT, &sub);
-            CDBG("%s: unsubscribe event 0x%x, rc = %d", __func__, sub.type, rc);
-            sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_ERROR_EVENT;
-            rc = ioctl(my_obj->ctrl_fd, VIDIOC_UNSUBSCRIBE_EVENT, &sub);
-            CDBG("%s: unsubscribe event 0x%x, rc = %d", __func__, sub.type, rc);
-        }
-        my_obj->evt_type_mask &= ~(1 << evt_type);
-        if(my_obj->evt_type_mask == 0) {
-            /* remove evt fd from the polling thraed when unreg the last event */
-            mm_camera_poll_thread_del_poll_fd(&my_obj->evt_poll_thread, my_obj->my_hdl);
-        }
-    } else {
-        if(!my_obj->evt_type_mask) {
-            /* this is the first reg event */
-            rc = ioctl(my_obj->ctrl_fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
-            CDBG("%s: subscribe event 0x%x, rc = %d", __func__, sub.type, rc);
-            if (rc < 0)
-                goto end;
-            sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_ERROR_EVENT;
-            rc = ioctl(my_obj->ctrl_fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
-            CDBG("%s: subscribe event 0x%x, rc = %d", __func__, sub.type, rc);
-            if (rc < 0)
-                goto end;
-        }
-        my_obj->evt_type_mask |= (1 << evt_type);
-        if(my_obj->evt_type_mask == (uint32_t)(1 << evt_type)) {
-            /* add evt fd to polling thread when subscribe the first event */
-            rc = mm_camera_poll_thread_add_poll_fd(&my_obj->evt_poll_thread,
-                                                   my_obj->my_hdl,
-                                                   my_obj->ctrl_fd,
-                                                   mm_camera_event_notify,
-                                                   (void*)my_obj);
-        }
-    }
-end:
-    return rc;
-}
-
-int32_t mm_camera_util_sendmsg(mm_camera_obj_t *my_obj, void *msg, uint32_t buf_size, int sendfd)
-{
-    return mm_camera_socket_sendmsg(my_obj->ds_fd, msg, buf_size, sendfd);
-}
-
-int32_t mm_camera_map_buf(mm_camera_obj_t *my_obj,
-                          int ext_mode,
-                          int idx,
-                          int fd,
-                          uint32_t size)
-{
-    cam_sock_packet_t packet;
-    memset(&packet, 0, sizeof(cam_sock_packet_t));
-    packet.msg_type = CAM_SOCK_MSG_TYPE_FD_MAPPING;
-    packet.payload.frame_fd_map.ext_mode = ext_mode;
-    packet.payload.frame_fd_map.frame_idx = idx;
-    packet.payload.frame_fd_map.fd = fd;
-    packet.payload.frame_fd_map.size = size;
-
-    return mm_camera_util_sendmsg(my_obj, &packet,
-                                  sizeof(cam_sock_packet_t),
-                                  packet.payload.frame_fd_map.fd);
-}
-
-int32_t mm_camera_unmap_buf(mm_camera_obj_t *my_obj,
-                            int ext_mode,
-                            int idx)
-{
-    cam_sock_packet_t packet;
-    memset(&packet, 0, sizeof(cam_sock_packet_t));
-    packet.msg_type = CAM_SOCK_MSG_TYPE_FD_UNMAPPING;
-    packet.payload.frame_fd_unmap.ext_mode = ext_mode;
-    packet.payload.frame_fd_unmap.frame_idx = idx;
-    return mm_camera_util_sendmsg(my_obj, &packet,
-                                  sizeof(cam_sock_packet_t),
-                                  packet.payload.frame_fd_map.fd);
-}
-
-int32_t mm_camera_util_s_ctrl(int32_t fd,  uint32_t id, int32_t value)
-{
-    int rc = 0;
-    struct v4l2_control control;
-
-    memset(&control, 0, sizeof(control));
-    control.id = id;
-    control.value = value;
-    rc = ioctl (fd, VIDIOC_S_CTRL, &control);
-
-    CDBG("%s: fd=%d, S_CTRL, id=0x%x, value = 0x%x, rc = %d\n",
-         __func__, fd, id, (uint32_t)value, rc);
-    return (rc >= 0)? 0 : -1;
-}
-
-int32_t mm_camera_util_g_ctrl( int32_t fd, uint32_t id, int32_t *value)
-{
-    int rc = 0;
-    struct v4l2_control control;
-
-    memset(&control, 0, sizeof(control));
-    control.id = id;
-    control.value = (int32_t)value;
-    rc = ioctl (fd, VIDIOC_G_CTRL, &control);
-    *value = control.value;
-    CDBG("%s: fd=%d, G_CTRL, id=0x%x, rc = %d\n", __func__, fd, id, rc);
-    return (rc >= 0)? 0 : -1;
-}
-
-uint8_t mm_camera_util_get_pp_mask(mm_camera_obj_t *my_obj)
-{
-    uint8_t pp_mask = 0;
-    int32_t rc = 0;
-
-    /* query pp mask from mctl */
-    rc = mm_camera_send_native_ctrl_cmd(my_obj,
-                                        CAMERA_GET_PP_MASK,
-                                        sizeof(uint8_t),
-                                        (void *)&pp_mask);
-    if (0 != rc) {
-        CDBG_ERROR("%s: error getting post processing mask (rc=%d)",
-                   __func__, rc);
-    }
-
-    return pp_mask;
-}
-
-int32_t mm_camera_open_repro_isp(mm_camera_obj_t *my_obj,
-                                 uint32_t ch_id,
-                                 mm_camera_repro_isp_type_t repro_isp_type,
-                                 uint32_t *repro_isp_handle)
-{
-    int32_t rc = -1;
-    uint32_t repro_hdl = 0;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_OPEN_REPRO_ISP,
-                               (void*)repro_isp_type,
-                               (void*)&repro_hdl);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-        CDBG_ERROR("%s: no channel obj exist", __func__);
-    }
-
-    if (NULL != repro_isp_handle) {
-        *repro_isp_handle = repro_hdl;
-    }
-    return rc;
-}
-
-int32_t mm_camera_config_repro_isp(mm_camera_obj_t *my_obj,
-                                   uint32_t ch_id,
-                                   uint32_t repro_isp_handle,
-                                   mm_camera_repro_isp_config_t *config)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-    mm_evt_paylod_config_repro_isp_t payload;
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_paylod_config_repro_isp_t));
-        payload.repro_isp_handle = repro_isp_handle;
-        payload.config = config;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_CONFIG_REPRO_ISP,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-        CDBG_ERROR("%s: no channel obj exist", __func__);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_attach_stream_to_repro_isp(mm_camera_obj_t *my_obj,
-                                             uint32_t ch_id,
-                                             uint32_t repro_isp_handle,
-                                             uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-    mm_evt_paylod_stream_to_repro_isp_t payload;
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_paylod_stream_to_repro_isp_t));
-        payload.repro_isp_handle = repro_isp_handle;
-        payload.stream_id = stream_id;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-        CDBG_ERROR("%s: no channel obj exist", __func__);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_start_repro_isp(mm_camera_obj_t *my_obj,
-                                  uint32_t ch_id,
-                                  uint32_t repro_isp_handle,
-                                  uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_evt_paylod_repro_start_stop_t payload;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_paylod_repro_start_stop_t));
-        payload.repro_isp_handle = repro_isp_handle;
-        payload.stream_id = stream_id;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_START_REPRO_ISP,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-        CDBG_ERROR("%s: no channel obj exist", __func__);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_reprocess(mm_camera_obj_t *my_obj,
-                            uint32_t ch_id,
-                            uint32_t repro_isp_handle,
-                            mm_camera_repro_data_t *repro_data)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-    mm_evt_paylod_reprocess_t payload;
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_paylod_reprocess_t));
-        payload.repro_isp_handle = repro_isp_handle;
-        payload.repro_data = repro_data;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-        CDBG_ERROR("%s: no channel obj exist", __func__);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_stop_repro_isp(mm_camera_obj_t *my_obj,
-                                 uint32_t ch_id,
-                                 uint32_t repro_isp_handle,
-                                 uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_evt_paylod_repro_start_stop_t payload;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_paylod_repro_start_stop_t));
-        payload.repro_isp_handle = repro_isp_handle;
-        payload.stream_id = stream_id;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_STOP_REPRO_ISP,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-        CDBG_ERROR("%s: no channel obj exist", __func__);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_detach_stream_from_repro_isp(mm_camera_obj_t *my_obj,
-                                               uint32_t ch_id,
-                                               uint32_t repro_isp_handle,
-                                               uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-    mm_evt_paylod_stream_to_repro_isp_t payload;
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        memset(&payload, 0, sizeof(mm_evt_paylod_stream_to_repro_isp_t));
-        payload.repro_isp_handle = repro_isp_handle;
-        payload.stream_id = stream_id;
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_DETACH_STREAM_FROM_REPRO_ISP,
-                               (void*)&payload,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-        CDBG_ERROR("%s: no channel obj exist", __func__);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_close_repro_isp(mm_camera_obj_t *my_obj,
-                                  uint32_t ch_id,
-                                  uint32_t repro_isp_handle)
-{
-    int32_t rc = -1;
-    mm_channel_t * ch_obj =
-        mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
-    if (NULL != ch_obj) {
-        pthread_mutex_lock(&ch_obj->ch_lock);
-        pthread_mutex_unlock(&my_obj->cam_lock);
-
-        rc = mm_channel_fsm_fn(ch_obj,
-                               MM_CHANNEL_EVT_CLOSE_REPRO_ISP,
-                               (void*)repro_isp_handle,
-                               NULL);
-    } else {
-        pthread_mutex_unlock(&my_obj->cam_lock);
-        CDBG_ERROR("%s: no channel obj exist", __func__);
-    }
-
-    return rc;
-}
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_channel.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_channel.c
deleted file mode 100755
index 351c4d6..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_channel.c
+++ /dev/null
@@ -1,1871 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-extern mm_camera_obj_t* mm_camera_util_get_camera_by_handler(uint32_t cam_handler);
-extern mm_channel_t * mm_camera_util_get_channel_by_handler(
-                                    mm_camera_obj_t * cam_obj,
-                                    uint32_t handler);
-extern int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
-                                       cam_ctrl_type type,
-                                       uint32_t length,
-                                       void *value);
-extern int32_t mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,
-                                               cam_ctrl_type type,
-                                               uint32_t length,
-                                               void *value,
-                                               int timeout);
-
-/* internal function declare goes here */
-int32_t mm_channel_qbuf(mm_channel_t *my_obj,
-                        mm_camera_buf_def_t *buf);
-int32_t mm_channel_init(mm_channel_t *my_obj);
-void mm_channel_release(mm_channel_t *my_obj);
-uint32_t mm_channel_add_stream(mm_channel_t *my_obj,
-                                   mm_camera_buf_notify_t buf_cb, void *user_data,
-                                   uint32_t ext_image_mode, uint32_t sensor_idx);
-int32_t mm_channel_del_stream(mm_channel_t *my_obj,
-                                   uint32_t stream_id);
-int32_t mm_channel_config_stream(mm_channel_t *my_obj,
-                                 uint32_t stream_id,
-                                 mm_camera_stream_config_t *config);
-int32_t mm_channel_bundle_stream(mm_channel_t *my_obj,
-                                 mm_camera_buf_notify_t super_frame_notify_cb,
-                                 void *user_data,
-                                 mm_camera_bundle_attr_t *attr,
-                                 uint8_t num_streams,
-                                 uint32_t *stream_ids);
-int32_t mm_channel_destroy_bundle(mm_channel_t *my_obj);
-int32_t mm_channel_start_streams(mm_channel_t *my_obj,
-                                 uint8_t num_streams,
-                                 uint32_t *stream_ids);
-int32_t mm_channel_stop_streams(mm_channel_t *my_obj,
-                                uint8_t num_streams,
-                                uint32_t *stream_ids,
-                                uint8_t tear_down_flag);
-int32_t mm_channel_request_super_buf(mm_channel_t *my_obj, uint32_t num_buf_requested);
-int32_t mm_channel_cancel_super_buf_request(mm_channel_t *my_obj);
-int32_t mm_channel_start_focus(mm_channel_t *my_obj,
-                               uint32_t sensor_idx,
-                               uint32_t focus_mode);
-int32_t mm_channel_abort_focus(mm_channel_t *my_obj,
-                               uint32_t sensor_idx);
-int32_t mm_channel_prepare_snapshot(mm_channel_t *my_obj,
-                                    uint32_t sensor_idx);
-int32_t mm_channel_set_stream_parm(mm_channel_t *my_obj,
-                                   uint32_t s_id,
-                                   void *value);
-int32_t mm_channel_get_stream_parm(mm_channel_t *my_obj,
-                                   uint32_t s_id,
-                                   void *value);
-int32_t mm_channel_do_post_processing(mm_channel_t *my_obj,
-                                      mm_channel_queue_node_t *super_buf);
-int32_t mm_channel_superbuf_bufdone_overflow(mm_channel_t *my_obj,
-                                             mm_channel_queue_t *queue);
-int32_t mm_channel_superbuf_skip(mm_channel_t *my_obj,
-                                 mm_channel_queue_t *queue);
-uint32_t mm_channel_open_repro_isp(mm_channel_t *my_obj,
-                                   mm_camera_repro_isp_type_t isp_type);
-int32_t mm_channel_close_repro_isp(mm_channel_t *my_obj,
-                                   uint32_t repro_handle);
-int32_t mm_channel_config_repro_isp(mm_channel_t *my_obj,
-                                    uint32_t repro_handle,
-                                    mm_camera_repro_isp_config_t *config);
-int32_t mm_channel_repro_isp_dest_stream_ops(mm_channel_t *my_obj,
-                                             uint32_t repro_handle,
-                                             uint32_t stream_handle,
-                                             uint8_t attach_flag);
-int32_t mm_channel_repro_isp_ops(mm_channel_t *my_obj,
-                                 uint32_t repro_handle,
-                                 uint32_t stream_id,
-                                 uint8_t start_flag);
-int32_t mm_channel_reprocess(mm_channel_t *my_obj,
-                             uint32_t repro_handle,
-                             mm_camera_repro_data_t *repro_data);
-
-/* state machine function declare */
-int32_t mm_channel_fsm_fn_notused(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val);
-int32_t mm_channel_fsm_fn_stopped(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val);
-int32_t mm_channel_fsm_fn_active(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val);
-int32_t mm_channel_fsm_fn_paused(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val);
-
-/* channel super queue functions */
-int32_t mm_channel_superbuf_queue_init(mm_channel_queue_t * queue);
-int32_t mm_channel_superbuf_queue_deinit(mm_channel_t *my_obj,
-                                         mm_channel_queue_t * queue);
-int32_t mm_channel_superbuf_comp_and_enqueue(mm_channel_t *ch_obj,
-                                             mm_channel_queue_t * queue,
-                                             mm_camera_buf_info_t *buf);
-mm_channel_queue_node_t* mm_channel_superbuf_dequeue(mm_channel_queue_t * queue);
-
-/* channel utility function */
-mm_stream_t * mm_channel_util_get_stream_by_handler(
-                                    mm_channel_t * ch_obj,
-                                    uint32_t handler)
-{
-    int i;
-    mm_stream_t *s_obj = NULL;
-    uint8_t ch_idx = mm_camera_util_get_index_by_handler(handler);
-
-    for(i = 0; i < MM_CAMEAR_STRAEM_NUM_MAX; i++) {
-        if (handler == ch_obj->streams[i].my_hdl) {
-            s_obj = &ch_obj->streams[i];
-            break;
-        }
-    }
-    return s_obj;
-}
-
-static void mm_channel_dispatch_super_buf(mm_camera_cmdcb_t *cmd_cb,
-                                          void* user_data)
-{
-    int i;
-    mm_channel_t * my_obj = (mm_channel_t *)user_data;
-
-    if (NULL == my_obj) {
-        return;
-    }
-
-    if (MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB != cmd_cb->cmd_type) {
-        CDBG_ERROR("%s: Wrong cmd_type (%d) for super buf dataCB",
-                   __func__, cmd_cb->cmd_type);
-        return;
-    }
-
-    if (my_obj->bundle.super_buf_notify_cb) {
-        my_obj->bundle.super_buf_notify_cb(&cmd_cb->u.superbuf, my_obj->bundle.user_data);
-    }
-}
-
-/* CB for processing stream buffer */
-static void mm_channel_process_stream_buf(mm_camera_cmdcb_t * cmd_cb,
-                                          void *user_data)
-{
-    mm_camera_super_buf_notify_mode_t notify_mode;
-    mm_channel_queue_node_t *node = NULL;
-    mm_channel_t *ch_obj = (mm_channel_t *)user_data;
-    if (NULL == ch_obj) {
-        return;
-    }
-
-    if (MM_CAMERA_CMD_TYPE_DATA_CB  == cmd_cb->cmd_type) {
-        /* comp_and_enqueue */
-        mm_channel_superbuf_comp_and_enqueue(
-                        ch_obj,
-                        &ch_obj->bundle.superbuf_queue,
-                        &cmd_cb->u.buf);
-    } else if (MM_CAMERA_CMD_TYPE_REQ_DATA_CB  == cmd_cb->cmd_type) {
-        /* skip frames if needed */
-        ch_obj->pending_cnt = cmd_cb->u.req_buf.num_buf_requested;
-        mm_channel_superbuf_skip(ch_obj, &ch_obj->bundle.superbuf_queue);
-    }
-
-    notify_mode = ch_obj->bundle.superbuf_queue.attr.notify_mode;
-
-    /* bufdone for overflowed bufs */
-    mm_channel_superbuf_bufdone_overflow(ch_obj, &ch_obj->bundle.superbuf_queue);
-
-    /* dispatch frame if pending_cnt>0 or is in continuous streaming mode */
-    while ( (ch_obj->pending_cnt > 0) ||
-            (MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS == notify_mode) ) {
-
-        /* dequeue */
-        node = mm_channel_superbuf_dequeue(&ch_obj->bundle.superbuf_queue);
-        if (NULL != node) {
-            /* decrease pending_cnt */
-            CDBG("%s: Super Buffer received, Call client callback, pending_cnt=%d",
-                 __func__, ch_obj->pending_cnt);
-            if (MM_CAMERA_SUPER_BUF_NOTIFY_BURST == notify_mode) {
-                ch_obj->pending_cnt--;
-            }
-
-            /* do post processing if needed */
-            /* this is a blocking call */
-            mm_channel_do_post_processing(ch_obj, node);
-
-            /* dispatch superbuf */
-            if (NULL != ch_obj->bundle.super_buf_notify_cb) {
-                uint8_t i;
-                mm_camera_cmdcb_t* cb_node = NULL;
-
-                CDBG("%s: Send superbuf to HAL, pending_cnt=%d",
-                     __func__, ch_obj->pending_cnt);
-
-                /* send sem_post to wake up cb thread to dispatch super buffer */
-                cb_node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-                if (NULL != cb_node) {
-                    memset(cb_node, 0, sizeof(mm_camera_cmdcb_t));
-                    cb_node->cmd_type = MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB;
-                    cb_node->u.superbuf.num_bufs = node->num_of_bufs;
-                    for (i=0; i<node->num_of_bufs; i++) {
-                        cb_node->u.superbuf.bufs[i] = node->super_buf[i].buf;
-                    }
-                    cb_node->u.superbuf.camera_handle = ch_obj->cam_obj->my_hdl;
-                    cb_node->u.superbuf.ch_id = ch_obj->my_hdl;
-
-                    /* enqueue to cb thread */
-                    mm_camera_queue_enq(&(ch_obj->cb_thread.cmd_queue), cb_node);
-
-                    /* wake up cb thread */
-                    sem_post(&(ch_obj->cb_thread.cmd_sem));
-                } else {
-                    CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
-                    /* buf done with the nonuse super buf */
-                    for (i=0; i<node->num_of_bufs; i++) {
-                        mm_channel_qbuf(ch_obj, node->super_buf[i].buf);
-                    }
-                }
-            } else {
-                /* buf done with the nonuse super buf */
-                uint8_t i;
-                for (i=0; i<node->num_of_bufs; i++) {
-                    mm_channel_qbuf(ch_obj, node->super_buf[i].buf);
-                }
-            }
-            free(node);
-        } else {
-            /* no superbuf avail, break the loop */
-            break;
-        }
-    }
-}
-
-/* state machine entry */
-int32_t mm_channel_fsm_fn(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val)
-{
-    int32_t rc = -1;
-
-    CDBG("%s : E state = %d",__func__,my_obj->state);
-    switch (my_obj->state) {
-    case MM_CHANNEL_STATE_NOTUSED:
-        rc = mm_channel_fsm_fn_notused(my_obj, evt, in_val, out_val);
-        break;
-    case MM_CHANNEL_STATE_STOPPED:
-        rc = mm_channel_fsm_fn_stopped(my_obj, evt, in_val, out_val);
-        break;
-    case MM_CHANNEL_STATE_ACTIVE:
-        rc = mm_channel_fsm_fn_active(my_obj, evt, in_val, out_val);
-        break;
-    case MM_CHANNEL_STATE_PAUSED:
-        rc = mm_channel_fsm_fn_paused(my_obj, evt, in_val, out_val);
-        break;
-    default:
-        CDBG("%s: Not a valid state (%d)", __func__, my_obj->state);
-        break;
-    }
-
-    /* unlock ch_lock */
-    pthread_mutex_unlock(&my_obj->ch_lock);
-    CDBG("%s : X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_channel_fsm_fn_notused(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val)
-{
-    int32_t rc = -1;
-
-    switch (evt) {
-    default:
-        CDBG_ERROR("%s: invalid state (%d) for evt (%d)",
-                   __func__, my_obj->state, evt);
-        break;
-    }
-
-    return rc;
-}
-
-int32_t mm_channel_fsm_fn_stopped(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val)
-{
-    int32_t rc = 0;
-    CDBG("%s : E evt = %d",__func__,evt);
-    switch (evt) {
-    case MM_CHANNEL_EVT_ADD_STREAM:
-        {
-            uint32_t s_hdl = 0;
-            mm_evt_paylod_add_stream_t *payload =
-                (mm_evt_paylod_add_stream_t *)in_val;
-            s_hdl = mm_channel_add_stream(my_obj,
-                                          payload->buf_cb,
-                                          payload->user_data,
-                                          payload->ext_image_mode,
-                                          payload->sensor_idx);
-            *((uint32_t*)out_val) = s_hdl;
-            rc = 0;
-        }
-        break;
-    case MM_CHANNEL_EVT_DEL_STREAM:
-        {
-            uint32_t s_id = *((uint32_t *)in_val);
-            rc = mm_channel_del_stream(my_obj, s_id);
-        }
-        break;
-    case MM_CHANNEL_EVT_START_STREAM:
-        {
-            mm_evt_payload_start_stream_t *payload =
-                (mm_evt_payload_start_stream_t *)in_val;
-            rc = mm_channel_start_streams(my_obj,
-                                          payload->num_streams,
-                                          payload->stream_ids);
-            /* first stream started in stopped state
-             * move to active state */
-            if (0 == rc) {
-                my_obj->state = MM_CHANNEL_STATE_ACTIVE;
-            }
-        }
-        break;
-    case MM_CHANNEL_EVT_CONFIG_STREAM:
-        {
-            mm_evt_paylod_config_stream_t *payload =
-                (mm_evt_paylod_config_stream_t *)in_val;
-            rc = mm_channel_config_stream(my_obj,
-                                          payload->stream_id,
-                                          payload->config);
-        }
-        break;
-    case MM_CHANNEL_EVT_INIT_BUNDLE:
-        {
-            mm_evt_payload_bundle_stream_t *payload =
-                (mm_evt_payload_bundle_stream_t *)in_val;
-            rc = mm_channel_bundle_stream(my_obj,
-                                          payload->super_frame_notify_cb,
-                                          payload->user_data,
-                                          payload->attr,
-                                          payload->num_streams,
-                                          payload->stream_ids);
-        }
-        break;
-    case MM_CHANNEL_EVT_DESTROY_BUNDLE:
-        rc = mm_channel_destroy_bundle(my_obj);
-        break;
-    case MM_CHANNEL_EVT_PREPARE_SNAPSHOT:
-        {
-            uint32_t sensor_idx = (uint32_t)in_val;
-            rc = mm_channel_prepare_snapshot(my_obj, sensor_idx);
-        }
-        break;
-    case MM_CHANNEL_EVT_DELETE:
-        mm_channel_release(my_obj);
-        rc = 0;
-        break;
-    case MM_CHANNEL_EVT_SET_STREAM_PARM:
-        {
-            uint32_t s_id = (uint32_t)in_val;
-            rc = mm_channel_set_stream_parm(my_obj, s_id, out_val);
-        }
-        break;
-    case MM_CHANNEL_EVT_GET_STREAM_PARM:
-        {
-            uint32_t s_id = (uint32_t)in_val;
-            rc = mm_channel_get_stream_parm(my_obj, s_id, out_val);
-        }
-        break;
-    case MM_CHANNEL_EVT_OPEN_REPRO_ISP:
-        {
-            uint32_t repro_hdl = 0;
-            mm_camera_repro_isp_type_t isp_type =
-                (mm_camera_repro_isp_type_t)in_val;
-            repro_hdl = mm_channel_open_repro_isp(my_obj, isp_type);
-            *((uint32_t*)out_val) = repro_hdl;
-            rc = 0;
-        }
-        break;
-    case MM_CHANNEL_EVT_CONFIG_REPRO_ISP:
-        {
-            mm_evt_paylod_config_repro_isp_t *payload =
-                (mm_evt_paylod_config_repro_isp_t *)in_val;
-            rc = mm_channel_config_repro_isp(my_obj,
-                                            payload->repro_isp_handle,
-                                            payload->config);
-        }
-        break;
-    case MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP:
-        {
-            mm_evt_paylod_stream_to_repro_isp_t *payload =
-                (mm_evt_paylod_stream_to_repro_isp_t *)in_val;
-            rc = mm_channel_repro_isp_dest_stream_ops(my_obj,
-                                                     payload->repro_isp_handle,
-                                                     payload->stream_id,
-                                                     TRUE);
-        }
-        break;
-    case MM_CHANNEL_EVT_START_REPRO_ISP:
-        {
-            mm_evt_paylod_repro_start_stop_t *payload =
-                (mm_evt_paylod_repro_start_stop_t*)in_val;
-            rc = mm_channel_repro_isp_ops(my_obj,
-                                          payload->repro_isp_handle,
-                                          payload->stream_id,
-                                          TRUE);
-        }
-        break;
-    case MM_CHANNEL_EVT_REPROCESS:
-        {
-            mm_evt_paylod_reprocess_t *payload =
-                (mm_evt_paylod_reprocess_t *)in_val;
-            rc = mm_channel_reprocess(my_obj,
-                                      payload->repro_isp_handle,
-                                      payload->repro_data);
-        }
-        break;
-    case MM_CHANNEL_EVT_STOP_REPRO_ISP:
-        {
-            mm_evt_paylod_repro_start_stop_t *payload =
-                (mm_evt_paylod_repro_start_stop_t*)in_val;
-            rc = mm_channel_repro_isp_ops(my_obj,
-                                          payload->repro_isp_handle,
-                                          payload->stream_id,
-                                          FALSE);
-        }
-        break;
-    case MM_CHANNEL_EVT_DETACH_STREAM_FROM_REPRO_ISP:
-        {
-            mm_evt_paylod_stream_to_repro_isp_t *payload =
-                (mm_evt_paylod_stream_to_repro_isp_t *)in_val;
-            rc = mm_channel_repro_isp_dest_stream_ops(my_obj,
-                                                     payload->repro_isp_handle,
-                                                     payload->stream_id,
-                                                     FALSE);
-        }
-        break;
-    case MM_CHANNEL_EVT_CLOSE_REPRO_ISP:
-        {
-            uint32_t repro_handle = (uint32_t)in_val;
-            rc = mm_channel_close_repro_isp(my_obj, repro_handle);
-        }
-        break;
-    default:
-        CDBG_ERROR("%s: invalid state (%d) for evt (%d)",
-                   __func__, my_obj->state, evt);
-        break;
-    }
-    CDBG("%s : E rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_channel_fsm_fn_active(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val)
-{
-    int32_t rc = 0;
-
-    CDBG("%s : E evt = %d",__func__,evt);
-    switch (evt) {
-    case MM_CHANNEL_EVT_CONFIG_STREAM:
-        {
-            mm_evt_paylod_config_stream_t *payload =
-                (mm_evt_paylod_config_stream_t *)in_val;
-            rc = mm_channel_config_stream(my_obj,
-                                          payload->stream_id,
-                                          payload->config);
-        }
-        break;
-    case MM_CHANNEL_EVT_START_STREAM:
-        {
-            mm_evt_payload_start_stream_t *payload =
-                (mm_evt_payload_start_stream_t *)in_val;
-            rc = mm_channel_start_streams(my_obj,
-                                          payload->num_streams,
-                                          payload->stream_ids);
-        }
-        break;
-    case MM_CHANNEL_EVT_STOP_STREAM:
-    case MM_CHANNEL_EVT_TEARDOWN_STREAM:
-        {
-            int i;
-            uint8_t tear_down_flag = (MM_CHANNEL_EVT_TEARDOWN_STREAM == evt)? 1:0;
-            uint8_t all_stopped = 1;
-            mm_evt_payload_stop_stream_t *payload =
-                (mm_evt_payload_stop_stream_t *)in_val;
-
-            rc = mm_channel_stop_streams(my_obj,
-                                         payload->num_streams,
-                                         payload->stream_ids,
-                                         tear_down_flag);
-
-            /* check if all streams are stopped
-             * then we move to stopped state */
-
-            for (i=0; i<MM_CAMEAR_STRAEM_NUM_MAX; i++) {
-                if (MM_STREAM_STATE_ACTIVE_STREAM_ON == my_obj->streams[i].state ||
-                    MM_STREAM_STATE_ACTIVE_STREAM_OFF == my_obj->streams[i].state) {
-                    all_stopped = 0;
-                    break;
-                }
-            }
-            if (all_stopped) {
-                my_obj->state = MM_CHANNEL_STATE_STOPPED;
-            }
-
-        }
-        break;
-    case MM_CHANNEL_EVT_INIT_BUNDLE:
-        {
-            mm_evt_payload_bundle_stream_t *payload =
-                (mm_evt_payload_bundle_stream_t *)in_val;
-            rc = mm_channel_bundle_stream(my_obj,
-                                          payload->super_frame_notify_cb,
-                                          payload->user_data,
-                                          payload->attr,
-                                          payload->num_streams,
-                                          payload->stream_ids);
-        }
-        break;
-    case MM_CHANNEL_EVT_DESTROY_BUNDLE:
-        rc = mm_channel_destroy_bundle(my_obj);
-        break;
-    case MM_CHANNEL_EVT_REQUEST_SUPER_BUF:
-        {
-            uint32_t num_buf_requested = (uint32_t)in_val;
-            rc = mm_channel_request_super_buf(my_obj, num_buf_requested);
-        }
-        break;
-    case MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF:
-        rc = mm_channel_cancel_super_buf_request(my_obj);
-        break;
-    case MM_CHANNEL_EVT_START_FOCUS:
-        {
-            mm_evt_payload_start_focus_t* payload =
-                (mm_evt_payload_start_focus_t *)in_val;
-            rc = mm_channel_start_focus(my_obj,
-                                        payload->sensor_idx,
-                                        payload->focus_mode);
-        }
-        break;
-    case MM_CHANNEL_EVT_ABORT_FOCUS:
-        {
-            uint32_t sensor_idx = (uint32_t)in_val;
-            rc = mm_channel_abort_focus(my_obj, sensor_idx);
-        }
-        break;
-    case MM_CHANNEL_EVT_PREPARE_SNAPSHOT:
-        {
-            uint32_t sensor_idx = (uint32_t)in_val;
-            rc = mm_channel_prepare_snapshot(my_obj, sensor_idx);
-        }
-        break;
-    case MM_CHANNEL_EVT_SET_STREAM_PARM:
-        {
-            uint32_t s_id = (uint32_t)in_val;
-            rc = mm_channel_set_stream_parm(my_obj, s_id, out_val);
-        }
-        break;
-    case MM_CHANNEL_EVT_GET_STREAM_PARM:
-        {
-            uint32_t s_id = (uint32_t)in_val;
-            rc = mm_channel_get_stream_parm(my_obj, s_id, out_val);
-        }
-        break;
-
-    case MM_CHANNEL_EVT_DEL_STREAM:
-        {
-            uint32_t s_id = *((uint32_t *)in_val);
-            rc = mm_channel_del_stream(my_obj, s_id);
-        }
-        break;
-    case MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP:
-        {
-            mm_evt_paylod_stream_to_repro_isp_t *payload =
-                (mm_evt_paylod_stream_to_repro_isp_t *)in_val;
-            rc = mm_channel_repro_isp_dest_stream_ops(my_obj,
-                                                     payload->repro_isp_handle,
-                                                     payload->stream_id,
-                                                     TRUE);
-        }
-        break;
-    case MM_CHANNEL_EVT_START_REPRO_ISP:
-        {
-            mm_evt_paylod_repro_start_stop_t *payload =
-                (mm_evt_paylod_repro_start_stop_t*)in_val;
-            rc = mm_channel_repro_isp_ops(my_obj,
-                                          payload->repro_isp_handle,
-                                          payload->stream_id,
-                                          TRUE);
-        }
-        break;
-    case MM_CHANNEL_EVT_REPROCESS:
-        {
-            mm_evt_paylod_reprocess_t *payload =
-                (mm_evt_paylod_reprocess_t *)in_val;
-            rc = mm_channel_reprocess(my_obj,
-                                      payload->repro_isp_handle,
-                                      payload->repro_data);
-        }
-        break;
-    case MM_CHANNEL_EVT_STOP_REPRO_ISP:
-        {
-            mm_evt_paylod_repro_start_stop_t *payload =
-                (mm_evt_paylod_repro_start_stop_t*)in_val;
-            rc = mm_channel_repro_isp_ops(my_obj,
-                                          payload->repro_isp_handle,
-                                          payload->stream_id,
-                                          FALSE);
-        }
-        break;
-    case MM_CHANNEL_EVT_DETACH_STREAM_FROM_REPRO_ISP:
-        {
-            mm_evt_paylod_stream_to_repro_isp_t *payload =
-                (mm_evt_paylod_stream_to_repro_isp_t *)in_val;
-            rc = mm_channel_repro_isp_dest_stream_ops(my_obj,
-                                                     payload->repro_isp_handle,
-                                                     payload->stream_id,
-                                                     FALSE);
-        }
-        break;
-    default:
-        CDBG_ERROR("%s: invalid state (%d) for evt (%d)",
-                   __func__, my_obj->state, evt);
-        break;
-    }
-    CDBG("%s : X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_channel_fsm_fn_paused(mm_channel_t *my_obj,
-                          mm_channel_evt_type_t evt,
-                          void * in_val,
-                          void * out_val)
-{
-    int32_t rc = 0;
-
-    /* currently we are not supporting pause/resume channel */
-    CDBG_ERROR("%s: evt (%d) not supported in state (%d)",
-               __func__, evt, my_obj->state);
-
-    return rc;
-}
-
-int32_t mm_channel_init(mm_channel_t *my_obj)
-{
-    int32_t rc = 0;
-    CDBG("%s : Launch data poll thread in channel open",__func__);
-    mm_camera_poll_thread_launch(&my_obj->poll_thread[0],
-                                 MM_CAMERA_POLL_TYPE_CH);
-
-    /* change state to stopped state */
-    my_obj->state = MM_CHANNEL_STATE_STOPPED;
-    return rc;
-}
-
-void mm_channel_release(mm_channel_t *my_obj)
-{
-    /* stop data poll thread */
-    mm_camera_poll_thread_release(&my_obj->poll_thread[0]);
-
-    /* change state to notused state */
-    my_obj->state = MM_CHANNEL_STATE_NOTUSED;
-}
-
-uint32_t mm_channel_get_ext_mode_from_img_mode(uint32_t img_mode)
-{
-    switch (img_mode) {
-    case MM_CAMERA_PREVIEW:
-        return MSM_V4L2_EXT_CAPTURE_MODE_PREVIEW;
-    case MM_CAMERA_VIDEO:
-        return MSM_V4L2_EXT_CAPTURE_MODE_VIDEO;
-    case MM_CAMERA_SNAPSHOT_MAIN:
-        return MSM_V4L2_EXT_CAPTURE_MODE_MAIN;
-    case MM_CAMERA_SNAPSHOT_THUMBNAIL:
-        return MSM_V4L2_EXT_CAPTURE_MODE_THUMBNAIL;
-    case MM_CAMERA_SNAPSHOT_RAW:
-        return MSM_V4L2_EXT_CAPTURE_MODE_RAW;
-    case MM_CAMERA_RDI:
-        return MSM_V4L2_EXT_CAPTURE_MODE_RDI;
-    case MM_CAMERA_RDI1:
-        return MSM_V4L2_EXT_CAPTURE_MODE_RDI1;
-    case MM_CAMERA_RDI2:
-        return MSM_V4L2_EXT_CAPTURE_MODE_RDI2;
-	case MM_CAMERA_SAEC:
-		return MSM_V4L2_EXT_CAPTURE_MODE_AEC;
-	case MM_CAMERA_SAWB:
-		return MSM_V4L2_EXT_CAPTURE_MODE_AWB;
-	case MM_CAMERA_SAFC:
-		return MSM_V4L2_EXT_CAPTURE_MODE_AF;
-	case MM_CAMERA_IHST:
-		return MSM_V4L2_EXT_CAPTURE_MODE_IHIST;
-	case MM_CAMERA_CS:
-		return MSM_V4L2_EXT_CAPTURE_MODE_CS;
-	case MM_CAMERA_RS:
-		return MSM_V4L2_EXT_CAPTURE_MODE_RS;
-	case MM_CAMERA_CSTA:
-		return MSM_V4L2_EXT_CAPTURE_MODE_CSTA;
-    case MM_CAMERA_ISP_PIX_OUTPUT1:
-        return MSM_V4L2_EXT_CAPTURE_MODE_ISP_PIX_OUTPUT1;
-    case MM_CAMERA_ISP_PIX_OUTPUT2:
-        return MSM_V4L2_EXT_CAPTURE_MODE_ISP_PIX_OUTPUT2;
-    default:
-        return MSM_V4L2_EXT_CAPTURE_MODE_DEFAULT;
-    }
-}
-
-uint32_t mm_channel_add_stream(mm_channel_t *my_obj,
-                              mm_camera_buf_notify_t buf_cb, void *user_data,
-                              uint32_t ext_image_mode, uint32_t sensor_idx)
-{
-    int32_t rc = 0;
-    uint8_t idx = 0;
-    uint32_t s_hdl = 0;
-    mm_stream_t *stream_obj = NULL;
-
-    CDBG("%s : image mode = %d",__func__,ext_image_mode);
-    /* check available stream */
-    for (idx = 0; idx < MM_CAMEAR_STRAEM_NUM_MAX; idx++) {
-        if (MM_STREAM_STATE_NOTUSED == my_obj->streams[idx].state) {
-            stream_obj = &my_obj->streams[idx];
-            break;
-        }
-    }
-    if (NULL == stream_obj) {
-        CDBG_ERROR("%s: streams reach max, no more stream allowed to add", __func__);
-        return s_hdl;
-    }
-
-    /* initialize stream object */
-    memset(stream_obj, 0, sizeof(mm_stream_t));
-    stream_obj->my_hdl = mm_camera_util_generate_handler(idx);
-    stream_obj->ch_obj = my_obj;
-    /* cd through intf always palced at idx 0 of buf_cb */
-    stream_obj->buf_cb[0].cb = buf_cb;
-    stream_obj->buf_cb[0].user_data = user_data;
-    stream_obj->buf_cb[0].cb_count = -1; /* infinite by default */
-    stream_obj->ext_image_mode =
-        mm_channel_get_ext_mode_from_img_mode(ext_image_mode);
-    stream_obj->sensor_idx = sensor_idx;
-    stream_obj->fd = -1;
-    pthread_mutex_init(&stream_obj->buf_lock, NULL);
-    pthread_mutex_init(&stream_obj->cb_lock, NULL);
-    stream_obj->state = MM_STREAM_STATE_INITED;
-
-    /* acquire stream */
-    rc = mm_stream_fsm_fn(stream_obj, MM_STREAM_EVT_ACQUIRE, NULL, NULL);
-    if (0 == rc) {
-        s_hdl = stream_obj->my_hdl;
-    } else {
-        /* error during acquire, de-init */
-        pthread_mutex_destroy(&stream_obj->buf_lock);
-        pthread_mutex_destroy(&stream_obj->cb_lock);
-        memset(stream_obj, 0, sizeof(mm_stream_t));
-    }
-    CDBG("%s : stream handle = %d",__func__,s_hdl);
-    return s_hdl;
-}
-
-int32_t mm_channel_del_stream(mm_channel_t *my_obj,
-                              uint32_t stream_id)
-{
-    int rc = -1;
-    mm_stream_t * stream_obj = NULL;
-    stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_id);
-
-    if (NULL == stream_obj) {
-        CDBG_ERROR("%s :Invalid Stream Object for stream_id = %d",__func__, stream_id);
-        return rc;
-    }
-
-    rc = mm_stream_fsm_fn(stream_obj,
-                          MM_STREAM_EVT_RELEASE,
-                          NULL,
-                          NULL);
-
-    return rc;
-}
-
-int32_t mm_channel_config_stream(mm_channel_t *my_obj,
-                                   uint32_t stream_id,
-                                   mm_camera_stream_config_t *config)
-{
-    int rc = -1;
-    mm_stream_t * stream_obj = NULL;
-    CDBG("%s : E stream ID = %d",__func__,stream_id);
-    stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_id);
-
-    if (NULL == stream_obj) {
-        CDBG_ERROR("%s :Invalid Stream Object for stream_id = %d",__func__, stream_id);
-        return rc;
-    }
-
-    /* set stream fmt */
-    rc = mm_stream_fsm_fn(stream_obj,
-                          MM_STREAM_EVT_SET_FMT,
-                          (void *)config,
-                          NULL);
-    CDBG("%s : X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_channel_bundle_stream(mm_channel_t *my_obj,
-                                 mm_camera_buf_notify_t super_frame_notify_cb,
-                                 void *user_data,
-                                 mm_camera_bundle_attr_t *attr,
-                                 uint8_t num_streams,
-                                 uint32_t *stream_ids)
-{
-    int32_t rc = 0;
-    int i;
-    cam_stream_bundle_t bundle;
-    mm_stream_t* s_objs[MM_CAMEAR_MAX_STRAEM_BUNDLE] = {NULL};
-
-    /* first check if all streams to be bundled are valid */
-    for (i=0; i < num_streams; i++) {
-        s_objs[i] = mm_channel_util_get_stream_by_handler(my_obj, stream_ids[i]);
-        if (NULL == s_objs[i]) {
-            CDBG_ERROR("%s: invalid stream handler %d (idx=%d) to be bundled",
-                       __func__, stream_ids[i], i);
-            return -1;
-        }
-    }
-
-    /* init superbuf queue */
-    mm_channel_superbuf_queue_init(&my_obj->bundle.superbuf_queue);
-
-    memset(&bundle, 0, sizeof(bundle));
-    /* save bundle config */
-    memcpy(&my_obj->bundle.superbuf_queue.attr, attr, sizeof(mm_camera_bundle_attr_t));
-    my_obj->bundle.super_buf_notify_cb = super_frame_notify_cb;
-    my_obj->bundle.user_data = user_data;
-    my_obj->bundle.superbuf_queue.num_streams = num_streams;
-    my_obj->bundle.superbuf_queue.expected_frame_id = 0;
-
-    for (i=0; i < num_streams; i++) {
-        /* set bundled flag to streams */
-        s_objs[i]->is_bundled = 1;
-        /* init bundled streams to invalid value -1 */
-        my_obj->bundle.superbuf_queue.bundled_streams[i] = stream_ids[i];
-        bundle.stream_handles[bundle.num++] =
-            s_objs[i]->inst_hdl;
-    }
-    /* in the case of 1 bundle , current implementation is nop */
-    if (bundle.num > 1) {
-        rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                                    CAMERA_SET_BUNDLE,
-                                                    sizeof(bundle),
-                                                    (void *)&bundle);
-        if (0 != rc) {
-            CDBG_ERROR("%s: set_bundle failed (rc=%d)", __func__, rc);
-            return -1;
-        }
-    }
-
-    /* launch cb thread for dispatching super buf through cb */
-    mm_camera_cmd_thread_launch(&my_obj->cb_thread,
-                                mm_channel_dispatch_super_buf,
-                                (void*)my_obj);
-
-    /* launch cmd thread for super buf dataCB */
-    mm_camera_cmd_thread_launch(&my_obj->cmd_thread,
-                                mm_channel_process_stream_buf,
-                                (void*)my_obj);
-
-    /* set flag to TRUE */
-    my_obj->bundle.is_active = TRUE;
-
-    return rc;
-}
-
-/* bundled streams must all be stopped before bundle can be destroyed */
-int32_t mm_channel_destroy_bundle(mm_channel_t *my_obj)
-{
-    mm_stream_t* s_obj = NULL;
-    uint8_t i;
-
-    if (FALSE == my_obj->bundle.is_active) {
-        CDBG("%s: bundle not active, no need to destroy", __func__);
-        return 0;
-    }
-
-    /* first check all bundled streams should be stopped already */
-    for (i=0; i < my_obj->bundle.superbuf_queue.num_streams; i++) {
-        s_obj = mm_channel_util_get_stream_by_handler(my_obj,
-                        my_obj->bundle.superbuf_queue.bundled_streams[i]);
-        if (NULL != s_obj) {
-            if (MM_STREAM_STATE_ACTIVE_STREAM_ON == s_obj->state ||
-                MM_STREAM_STATE_ACTIVE_STREAM_OFF == s_obj->state) {
-                CDBG_ERROR("%s: at least one of the bundled streams (%d) is still active",
-                           __func__, my_obj->bundle.superbuf_queue.bundled_streams[i]);
-                return -1;
-            }
-        }
-    }
-
-    /* deinit superbuf queue */
-    mm_channel_superbuf_queue_deinit(my_obj, &my_obj->bundle.superbuf_queue);
-
-    /* memset bundle info */
-    memset(&my_obj->bundle, 0, sizeof(mm_channel_bundle_t));
-    my_obj->bundle.is_active = FALSE;
-    return 0;
-}
-
-int32_t mm_channel_start_streams(mm_channel_t *my_obj,
-                                 uint8_t num_streams,
-                                 uint32_t *stream_ids)
-{
-    int32_t rc = 0;
-    int i, j;
-    mm_stream_t* s_objs[MM_CAMEAR_MAX_STRAEM_BUNDLE] = {NULL};
-    uint8_t num_streams_to_start = num_streams;
-    uint32_t streams_to_start[MM_CAMEAR_MAX_STRAEM_BUNDLE];
-    uint8_t bundle_to_start = 0;
-
-    /* check if any bundled stream to be start,
-     * then all bundled stream should be started */
-    memcpy(streams_to_start, stream_ids, sizeof(uint32_t) * num_streams);
-    for (i=0; i < num_streams; i++) {
-        for (j=0; j < my_obj->bundle.superbuf_queue.num_streams; j++) {
-            if (stream_ids[i] == my_obj->bundle.superbuf_queue.bundled_streams[j]) {
-                bundle_to_start = 1;
-                break;
-            }
-        }
-    }
-
-    if (bundle_to_start) {
-        uint8_t need_add;
-        /* add bundled streams into the start list if not already added*/
-        for (i=0; i<my_obj->bundle.superbuf_queue.num_streams; i++) {
-            need_add = 1;
-            for (j=0; j<num_streams; j++) {
-                if (stream_ids[j] == my_obj->bundle.superbuf_queue.bundled_streams[i]) {
-                    need_add = 0;
-                    break;
-                }
-            }
-            if (need_add) {
-                streams_to_start[num_streams_to_start++] =
-                    my_obj->bundle.superbuf_queue.bundled_streams[i];
-            }
-        }
-    }
-
-    /* check if all streams to be started are valid */
-    for (i=0; i<num_streams_to_start; i++) {
-        s_objs[i] = mm_channel_util_get_stream_by_handler(my_obj, streams_to_start[i]);
-
-        if (NULL == s_objs[i]) {
-            CDBG_ERROR("%s: invalid stream handler %d (idx=%d) to be started",
-                       __func__, streams_to_start[i], i);
-            return -1;
-        }
-    }
-
-    for (i=0; i<num_streams_to_start; i++) {
-        /* if stream is already started, there is no need to start it */
-        if (s_objs[i]->state == MM_STREAM_STATE_ACTIVE_STREAM_ON ||
-            s_objs[i]->state == MM_STREAM_STATE_ACTIVE_STREAM_OFF) {
-            continue;
-        }
-
-        /* allocate buf */
-        rc = mm_stream_fsm_fn(s_objs[i],
-                              MM_STREAM_EVT_GET_BUF,
-                              NULL,
-                              NULL);
-        if (0 != rc) {
-            CDBG_ERROR("%s: get buf failed at idx(%d)", __func__, i);
-            break;
-        }
-
-        /* reg buf */
-        rc = mm_stream_fsm_fn(s_objs[i],
-                              MM_STREAM_EVT_REG_BUF,
-                              NULL,
-                              NULL);
-        if (0 != rc) {
-            CDBG_ERROR("%s: reg buf failed at idx(%d)", __func__, i);
-            break;
-        }
-
-        /* start stream */
-        rc = mm_stream_fsm_fn(s_objs[i],
-                              MM_STREAM_EVT_START,
-                              NULL,
-                              NULL);
-        if (0 != rc) {
-            CDBG_ERROR("%s: start stream failed at idx(%d)", __func__, i);
-            break;
-        }
-    }
-
-    /* error handling */
-    if (0 != rc) {
-        for (j=0; j<=i; j++) {
-            /* stop streams*/
-            mm_stream_fsm_fn(s_objs[i],
-                             MM_STREAM_EVT_STOP,
-                             NULL,
-                             NULL);
-
-            /* unreg buf */
-            mm_stream_fsm_fn(s_objs[i],
-                             MM_STREAM_EVT_UNREG_BUF,
-                             NULL,
-                             NULL);
-
-            /* put buf back */
-            mm_stream_fsm_fn(s_objs[i],
-                             MM_STREAM_EVT_PUT_BUF,
-                             NULL,
-                             NULL);
-        }
-    }
-
-    return rc;
-}
-
-/* Required: bundled streams need to be stopped together */
-int32_t mm_channel_stop_streams(mm_channel_t *my_obj,
-                                uint8_t num_streams,
-                                uint32_t *stream_ids,
-                                uint8_t tear_down_flag)
-{
-    int32_t rc = 0;
-    int i, j;
-    mm_stream_t* s_objs[MM_CAMEAR_MAX_STRAEM_BUNDLE] = {NULL};
-    uint8_t num_streams_to_stop = num_streams;
-    uint32_t streams_to_stop[MM_CAMEAR_MAX_STRAEM_BUNDLE];
-    uint8_t bundle_to_stop = 0;
-
-    /* make sure bundled streams are stopped together */
-    memcpy(streams_to_stop, stream_ids, sizeof(uint32_t) * num_streams);
-    for (i=0; i<num_streams; i++) {
-        for (j=0; j<my_obj->bundle.superbuf_queue.num_streams; j++) {
-            if (stream_ids[i] == my_obj->bundle.superbuf_queue.bundled_streams[j]) {
-                bundle_to_stop = 1;
-                break;
-            }
-        }
-    }
-    if (bundle_to_stop) {
-        /* first stop bundle thread */
-        mm_camera_cmd_thread_stop(&my_obj->cmd_thread);
-        mm_camera_cmd_thread_stop(&my_obj->cb_thread);
-
-        uint8_t need_add;
-        /* add bundled streams into the start list if not already added*/
-        for (i=0; i<my_obj->bundle.superbuf_queue.num_streams; i++) {
-            need_add = 1;
-            for (j=0; j<num_streams; j++) {
-                if (stream_ids[j] == my_obj->bundle.superbuf_queue.bundled_streams[i]) {
-                    need_add = 0;
-                    break;
-                }
-            }
-            if (need_add) {
-                streams_to_stop[num_streams_to_stop++] =
-                    my_obj->bundle.superbuf_queue.bundled_streams[i];
-            }
-        }
-    }
-
-    for (i=0; i<num_streams_to_stop; i++) {
-        s_objs[i] = mm_channel_util_get_stream_by_handler(my_obj, streams_to_stop[i]);
-
-        if (NULL != s_objs[i]) {
-            /* stream off */
-            mm_stream_fsm_fn(s_objs[i],
-                             MM_STREAM_EVT_STOP,
-                             NULL,
-                             NULL);
-
-            /* unreg buf at kernel */
-            mm_stream_fsm_fn(s_objs[i],
-                             MM_STREAM_EVT_UNREG_BUF,
-                             NULL,
-                             NULL);
-        }
-    }
-
-    /* destroy super buf cmd thread */
-    if (bundle_to_stop) {
-        /* first stop bundle thread */
-        mm_camera_cmd_thread_destroy(&my_obj->cmd_thread);
-        mm_camera_cmd_thread_destroy(&my_obj->cb_thread);
-    }
-
-    /* since all streams are stopped, we are safe to
-     * release all buffers allocated in stream */
-    for (i=0; i<num_streams_to_stop; i++) {
-        if (NULL != s_objs[i]) {
-            /* put buf back */
-            mm_stream_fsm_fn(s_objs[i],
-                             MM_STREAM_EVT_PUT_BUF,
-                             NULL,
-                             NULL);
-
-            if (tear_down_flag) {
-                /* to tear down stream totally, stream needs to be released */
-                mm_stream_fsm_fn(s_objs[i],
-                                 MM_STREAM_EVT_RELEASE,
-                                 NULL,
-                                 NULL);
-            }
-        }
-    }
-
-    return rc;
-}
-
-int32_t mm_channel_request_super_buf(mm_channel_t *my_obj, uint32_t num_buf_requested)
-{
-    int32_t rc = 0;
-    mm_camera_cmdcb_t* node = NULL;
-
-    /* set pending_cnt
-     * will trigger dispatching super frames if pending_cnt > 0 */
-    /* send sem_post to wake up cmd thread to dispatch super buffer */
-    node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-    if (NULL != node) {
-        memset(node, 0, sizeof(mm_camera_cmdcb_t));
-        node->cmd_type = MM_CAMERA_CMD_TYPE_REQ_DATA_CB;
-        node->u.req_buf.num_buf_requested = num_buf_requested;
-
-        /* enqueue to cmd thread */
-        mm_camera_queue_enq(&(my_obj->cmd_thread.cmd_queue), node);
-
-        /* wake up cmd thread */
-        sem_post(&(my_obj->cmd_thread.cmd_sem));
-    } else {
-        CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
-        rc = -1;
-    }
-
-    return rc;
-}
-
-int32_t mm_channel_cancel_super_buf_request(mm_channel_t *my_obj)
-{
-    int32_t rc = 0;
-    /* reset pending_cnt */
-    my_obj->pending_cnt = 0;
-
-    return rc;
-}
-
-int32_t mm_channel_qbuf(mm_channel_t *my_obj,
-                        mm_camera_buf_def_t *buf)
-{
-    int32_t rc = -1;
-    mm_stream_t* s_obj = mm_channel_util_get_stream_by_handler(my_obj, buf->stream_id);
-
-    if (NULL != s_obj) {
-        rc = mm_stream_fsm_fn(s_obj,
-                              MM_STREAM_EVT_QBUF,
-                              (void *)buf,
-                              NULL);
-    }
-
-    return rc;
-}
-
-int32_t mm_channel_start_focus(mm_channel_t *my_obj,
-                               uint32_t sensor_idx,
-                               uint32_t focus_mode)
-{
-    return mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                          CAMERA_SET_PARM_AUTO_FOCUS,
-                                          sizeof(uint32_t), (void*)focus_mode);
-}
-
-int32_t mm_channel_abort_focus(mm_channel_t *my_obj, uint32_t sensor_idx)
-{
-    return mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                          CAMERA_AUTO_FOCUS_CANCEL,
-                                          0, NULL);
-}
-
-int32_t mm_channel_prepare_snapshot(mm_channel_t *my_obj, uint32_t sensor_idx)
-{
-    return mm_camera_send_native_ctrl_timeout_cmd(my_obj->cam_obj,
-                                                CAMERA_PREPARE_SNAPSHOT,
-                                                0, NULL, 2000);
-}
-
-int32_t mm_channel_set_stream_parm(mm_channel_t *my_obj,
-                                   uint32_t s_id,
-                                   void *value)
-{
-    int32_t rc = -1;
-    mm_stream_t* s_obj = mm_channel_util_get_stream_by_handler(my_obj, s_id);
-    if (NULL != s_obj) {
-        rc = mm_stream_fsm_fn(s_obj,
-                              MM_STREAM_EVT_SET_PARM,
-                              value,
-                              NULL);
-    }
-
-    return rc;
-}
-
-int32_t mm_channel_get_stream_parm(mm_channel_t *my_obj,
-                                   uint32_t s_id,
-                                   void *value)
-{
-    int32_t rc = -1;
-    mm_stream_t* s_obj = mm_channel_util_get_stream_by_handler(my_obj, s_id);
-    if (NULL != s_obj) {
-        rc = mm_stream_fsm_fn(s_obj,
-                              MM_STREAM_EVT_GET_PARM,
-                              NULL,
-                              value);
-    }
-
-    return rc;
-}
-
-int32_t mm_channel_do_post_processing(mm_channel_t *my_obj,
-                                      mm_channel_queue_node_t *super_buf)
-{
-    int32_t rc = 0;
-    uint8_t pp_mask = 0;
-
-    pp_mask = mm_camera_util_get_pp_mask(my_obj->cam_obj);
-
-    if (pp_mask & CAMERA_PP_MASK_TYPE_WNR) {
-        mm_camera_wnr_info_t wnr_info;
-        uint8_t i, j = 0;
-        mm_stream_t* s_obj = NULL;
-
-        memset(&wnr_info, 0, sizeof(mm_camera_wnr_info_t));
-        for (i = 0; i < super_buf->num_of_bufs; i++) {
-            s_obj = mm_channel_util_get_stream_by_handler(my_obj, super_buf->super_buf[i].stream_id);
-            if (NULL != s_obj) {
-                wnr_info.frames[j].instance_hdl = s_obj->inst_hdl;
-                wnr_info.frames[j].frame_idx = super_buf->super_buf[i].buf->buf_idx;
-                wnr_info.frames[j].frame_width = s_obj->fmt.width;
-                wnr_info.frames[j].frame_height = s_obj->fmt.height;
-                memcpy(&wnr_info.frames[j].frame_offset,
-                       &s_obj->frame_offset,
-                       sizeof(cam_frame_len_offset_t));
-                j++;
-            }
-        }
-        wnr_info.num_frames = j;
-
-        rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                            CAMERA_DO_PP_WNR,
-                                            sizeof(mm_camera_wnr_info_t),
-                                            (void *)&wnr_info);
-        if (0 != rc) {
-            CDBG_ERROR("%s: do_pp_wnr failed (rc=%d)", __func__, rc);
-        }
-    }
-
-    return rc;
-}
-
-int32_t mm_channel_reg_stream_cb(mm_channel_t *my_obj,
-                                 mm_stream_data_cb_t *cb,
-                                 uint32_t ext_image_mode,
-                                 uint32_t sensor_idx)
-{
-    uint8_t idx;
-    mm_stream_t *dest_stream = NULL;
-    int32_t rc = -1;
-
-    /* browse all streams in channel to find the destination */
-    for (idx=0; idx < MM_CAMEAR_STRAEM_NUM_MAX; idx++) {
-        if (my_obj->streams[idx].state != MM_STREAM_STATE_NOTUSED &&
-            my_obj->streams[idx].ext_image_mode == ext_image_mode &&
-            my_obj->streams[idx].sensor_idx == sensor_idx) {
-            /* find matching stream as the destination */
-            dest_stream = &my_obj->streams[idx];
-            break;
-        }
-    }
-
-    if (NULL != dest_stream) {
-        rc = mm_stream_reg_buf_cb(dest_stream, cb);
-    }
-
-    return rc;
-}
-
-int32_t mm_channel_superbuf_queue_init(mm_channel_queue_t * queue)
-{
-    return mm_camera_queue_init(&queue->que);
-}
-
-int32_t mm_channel_superbuf_queue_deinit(mm_channel_t *my_obj,
-                                         mm_channel_queue_t * queue)
-{
-    return mm_camera_queue_deinit(&queue->que);
-}
-
-int8_t mm_channel_util_seq_comp_w_rollover(uint32_t v1,
-                                           uint32_t v2)
-{
-    int8_t ret = 0;
-
-    /* TODO: need to handle the case if v2 roll over to 0 */
-    if (v1 > v2) {
-        ret = 1;
-    } else if (v1 < v2) {
-        ret = -1;
-    }
-
-    return ret;
-}
-
-int32_t mm_channel_superbuf_comp_and_enqueue(
-                        mm_channel_t* ch_obj,
-                        mm_channel_queue_t * queue,
-                        mm_camera_buf_info_t *buf_info)
-{
-    mm_camera_q_node_t* node = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-    mm_channel_queue_node_t* super_buf = NULL;
-    uint8_t buf_s_idx, i;
-
-    CDBG("%s: E", __func__);
-    for (buf_s_idx=0; buf_s_idx < queue->num_streams; buf_s_idx++) {
-        if (buf_info->stream_id == queue->bundled_streams[buf_s_idx]) {
-            break;
-        }
-    }
-    if (buf_s_idx == queue->num_streams) {
-        CDBG_ERROR("%s: buf from stream (%d) not bundled", __func__, buf_info->stream_id);
-        return -1;
-    }
-
-    if (mm_channel_util_seq_comp_w_rollover(buf_info->frame_idx,
-                                            queue->expected_frame_id) < 0) {
-        /* incoming buf is older than expected buf id, will discard it */
-        mm_channel_qbuf(ch_obj, buf_info->buf);
-        return 0;
-    }
-
-    if (MM_CAMERA_SUPER_BUF_PRIORITY_NORMAL != queue->attr.priority) {
-        /* TODO */
-        /* need to decide if we want to queue the frame based on focus or exposure
-         * if frame not to be queued, we need to qbuf it back */
-    }
-
-    /* comp */
-    pthread_mutex_lock(&queue->que.lock);
-    head = &queue->que.head.list;
-    /* get the last one in the queue which is possibly having no matching */
-    pos = head->next;
-    while (pos != head) {
-        node = member_of(pos, mm_camera_q_node_t, list);
-        super_buf = (mm_channel_queue_node_t*)node->data;
-        if (NULL != super_buf) {
-            if (super_buf->matched) {
-                /* find a matched super buf, move to next one */
-                pos = pos->next;
-                continue;
-            } else {
-                /* have an unmatched super buf, break the loop */
-                break;
-            }
-        }
-    }
-
-    if (pos == head) {
-        CDBG("%s: all nodes in queue are mtached, or no node in queue, create a new node", __func__);
-        /* all nodes in queue are mtached, or no node in queue
-         * create a new node */
-        mm_channel_queue_node_t *new_buf = NULL;
-        mm_camera_q_node_t* new_node = NULL;
-
-        new_buf = (mm_channel_queue_node_t*)malloc(sizeof(mm_channel_queue_node_t));
-        new_node = (mm_camera_q_node_t*)malloc(sizeof(mm_camera_q_node_t));
-        if (NULL != new_buf && NULL != new_node) {
-            memset(new_buf, 0, sizeof(mm_channel_queue_node_t));
-            memset(new_node, 0, sizeof(mm_camera_q_node_t));
-            new_node->data = (void *)new_buf;
-            new_buf->num_of_bufs = queue->num_streams;
-            memcpy(&new_buf->super_buf[buf_s_idx], buf_info, sizeof(mm_camera_buf_info_t));
-
-            /* enqueue */
-            //cam_list_add_tail_node(&node->list, &queue->que.head.list);
-            cam_list_add_tail_node(&new_node->list, &queue->que.head.list);
-            queue->que.size++;
-
-            if(queue->num_streams == 1) {
-                //TODO : Check. Live snapshot will have one stream in bundle?
-                new_buf->matched = 1;
-
-                if (new_buf->matched) {
-                    queue->expected_frame_id = buf_info->frame_idx + queue->attr.post_frame_skip;
-                    queue->match_cnt++;
-                }
-            }
-        } else {
-            /* No memory */
-            if (NULL != new_buf) {
-                free(new_buf);
-            }
-            if (NULL != new_node) {
-                free(new_node);
-            }
-            /* qbuf the new buf since we cannot enqueue */
-            mm_channel_qbuf(ch_obj, buf_info->buf);
-        }
-    } else {
-        CDBG("%s: find an unmatched super buf", __func__);
-        /* find an unmatched super buf */
-        if (super_buf->super_buf[buf_s_idx].frame_idx == 0) {
-            /* new frame from the stream_id */
-            uint8_t is_new = 1;
-            uint32_t frame_idx;
-
-            for (i=0; i < super_buf->num_of_bufs; i++) {
-            //for (i=0; i < buf_s_idx; i++) {
-                if(super_buf->super_buf[i].buf == NULL) {
-                    continue;
-                }
-                frame_idx = super_buf->super_buf[i].buf->frame_idx;
-                if (frame_idx == 0) {
-                    continue;
-                }
-                if (frame_idx < buf_info->frame_idx) {
-                    /* existing frame is older than the new frame, qbuf it */
-                    mm_channel_qbuf(ch_obj, super_buf->super_buf[i].buf);
-                    memset(&super_buf->super_buf[i], 0, sizeof(mm_camera_buf_info_t));
-                } else if (frame_idx > buf_info->frame_idx) {
-                    /* new frame is older */
-                    is_new = 0;
-                    break;
-                }else{
-                    //TODO: reveiw again
-                    break;
-                }
-            }
-            if (is_new) {
-                CDBG("%s: add stream = %d frame id = %d ",
-                     __func__, buf_info->stream_id, buf_info->frame_idx);
-                memcpy(&super_buf->super_buf[buf_s_idx], buf_info, sizeof(mm_camera_buf_info_t));
-
-                /* check if superbuf is all matched */
-                super_buf->matched = 1;
-                for (i=0; i < super_buf->num_of_bufs; i++) {
-                    if (super_buf->super_buf[i].frame_idx == 0) {
-                        super_buf->matched = 0;
-                        break;
-                    }
-                }
-
-                if (super_buf->matched) {
-                    queue->expected_frame_id = buf_info->frame_idx + queue->attr.post_frame_skip;
-                    queue->match_cnt++;
-                    CDBG("%s, match_cnt = %d", __func__, queue->match_cnt);
-                }
-            } else {
-                mm_channel_qbuf(ch_obj, buf_info->buf);
-            }
-        } else {
-            if (super_buf->super_buf[buf_s_idx].frame_idx < buf_info->frame_idx) {
-                CDBG("%s: new frame is newer, add into superbuf", __func__);
-                /* current frames in superbuf are older than the new frame
-                 * qbuf all current frames */
-                for (i=0; i<super_buf->num_of_bufs; i++) {
-                    if (super_buf->super_buf[i].frame_idx != 0) {
-                            mm_channel_qbuf(ch_obj, super_buf->super_buf[i].buf);
-                            memset(&super_buf->super_buf[i], 0, sizeof(mm_camera_buf_info_t));
-                    }
-                }
-                /* add the new frame into the superbuf */
-                memcpy(&super_buf->super_buf[buf_s_idx], buf_info, sizeof(mm_camera_buf_info_t));
-            } else {
-                /* the new frame is older, just ignor */
-                mm_channel_qbuf(ch_obj, buf_info->buf);
-            }
-        }
-    }
-    pthread_mutex_unlock(&queue->que.lock);
-
-    CDBG("%s: X", __func__);
-    return 0;
-}
-
-mm_channel_queue_node_t* mm_channel_superbuf_dequeue_internal(mm_channel_queue_t * queue)
-{
-    mm_camera_q_node_t* node = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-    mm_channel_queue_node_t* super_buf = NULL;
-
-    head = &queue->que.head.list;
-    pos = head->next;
-    if (pos != head) {
-        /* get the first node */
-        node = member_of(pos, mm_camera_q_node_t, list);
-        super_buf = (mm_channel_queue_node_t*)node->data;
-        if (NULL != super_buf) {
-            if (super_buf->matched) {
-                /* we found a mtaching super buf, dequeue it */
-                cam_list_del_node(&node->list);
-                queue->que.size--;
-                queue->match_cnt--;
-                free(node);
-            } else {
-                super_buf = NULL;
-            }
-        }
-    }
-
-    return super_buf;
-}
-
-mm_channel_queue_node_t* mm_channel_superbuf_dequeue(mm_channel_queue_t * queue)
-{
-    mm_camera_q_node_t* node = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-    mm_channel_queue_node_t* super_buf = NULL;
-
-    pthread_mutex_lock(&queue->que.lock);
-    super_buf = mm_channel_superbuf_dequeue_internal(queue);
-    pthread_mutex_unlock(&queue->que.lock);
-
-    return super_buf;
-}
-
-int32_t mm_channel_superbuf_bufdone_overflow(mm_channel_t* my_obj,
-                                             mm_channel_queue_t * queue)
-{
-    int32_t rc = 0, i;
-    mm_channel_queue_node_t* super_buf = NULL;
-    if (MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS == queue->attr.notify_mode) {
-        /* for continuous streaming mode, no overflow is needed */
-        return 0;
-    }
-
-    CDBG("%s: before match_cnt=%d, water_mark=%d",
-         __func__, queue->match_cnt, queue->attr.water_mark);
-    /* bufdone overflowed bufs */
-    pthread_mutex_lock(&queue->que.lock);
-    while (queue->match_cnt > queue->attr.water_mark) {
-        super_buf = mm_channel_superbuf_dequeue_internal(queue);
-        if (NULL != super_buf) {
-            for (i=0; i<super_buf->num_of_bufs; i++) {
-                if (NULL != super_buf->super_buf[i].buf) {
-                    mm_channel_qbuf(my_obj, super_buf->super_buf[i].buf);
-                }
-            }
-            free(super_buf);
-        }
-    }
-    pthread_mutex_unlock(&queue->que.lock);
-    CDBG("%s: after match_cnt=%d, water_mark=%d",
-         __func__, queue->match_cnt, queue->attr.water_mark);
-
-    return rc;
-}
-
-int32_t mm_channel_superbuf_skip(mm_channel_t* my_obj,
-                                 mm_channel_queue_t * queue)
-{
-    int32_t rc = 0, i, count;
-    mm_channel_queue_node_t* super_buf = NULL;
-    if (MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS == queue->attr.notify_mode) {
-        /* for continuous streaming mode, no skip is needed */
-        return 0;
-    }
-
-    /* bufdone overflowed bufs */
-    pthread_mutex_lock(&queue->que.lock);
-    while (queue->match_cnt > queue->attr.look_back) {
-        super_buf = mm_channel_superbuf_dequeue_internal(queue);
-        if (NULL != super_buf) {
-            for (i=0; i<super_buf->num_of_bufs; i++) {
-                if (NULL != super_buf->super_buf[i].buf) {
-                    mm_channel_qbuf(my_obj, super_buf->super_buf[i].buf);
-                }
-            }
-            free(super_buf);
-        }
-    }
-    pthread_mutex_unlock(&queue->que.lock);
-
-    return rc;
-}
-
-uint32_t mm_channel_open_repro_isp(mm_channel_t *my_obj,
-                                   mm_camera_repro_isp_type_t isp_type)
-{
-    int32_t rc = -1;
-    mm_camera_repro_cmd_t repro_cmd;
-
-    memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
-    repro_cmd.cmd = MM_CAMERA_REPRO_CMD_OPEN;
-    repro_cmd.payload.open.isp_type = isp_type;
-    rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                        CAMERA_SEND_PP_PIPELINE_CMD,
-                                        sizeof(mm_camera_repro_cmd_t),
-                                        (void *)&repro_cmd);
-    if (0 != rc) {
-        CDBG_ERROR("%s: open repo isp failed (rc=%d)", __func__, rc);
-    }
-    return repro_cmd.payload.open.repro_handle;
-}
-
-int32_t mm_channel_close_repro_isp(mm_channel_t *my_obj,
-                                   uint32_t repro_handle)
-{
-    int32_t rc = -1;
-    mm_camera_repro_cmd_t repro_cmd;
-
-    memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
-    repro_cmd.cmd = MM_CAMERA_REPRO_CMD_CLOSE;
-    repro_cmd.payload.repro_handle = repro_handle;
-    rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                        CAMERA_SEND_PP_PIPELINE_CMD,
-                                        sizeof(mm_camera_repro_cmd_t),
-                                        (void *)&repro_cmd);
-    if (0 != rc) {
-        CDBG_ERROR("%s: close repo isp failed (rc=%d)", __func__, rc);
-    }
-    return rc;
-}
-
-int32_t mm_channel_config_repro_isp(mm_channel_t *my_obj,
-                                    uint32_t repro_handle,
-                                    mm_camera_repro_isp_config_t *config)
-{
-    int32_t rc = -1;
-    mm_camera_repro_cmd_t repro_cmd;
-    mm_stream_t *src_stream = NULL;
-    mm_stream_t *dest_streams[MM_CAMERA_MAX_NUM_REPROCESS_DEST];
-    uint8_t i;
-
-    /* first check if src and dest streams are valid */
-    src_stream = mm_channel_util_get_stream_by_handler(my_obj, config->src.inst_handle);
-    if (NULL == src_stream) {
-        CDBG_ERROR("%s: src stream obj not found %d", __func__, config->src.inst_handle);
-        return -1;
-    }
-    for (i = 0; i <  config->num_dest; i++) {
-        dest_streams[i] =
-            mm_channel_util_get_stream_by_handler(my_obj, config->dest[i].inst_handle);
-        if (NULL == dest_streams[i]) {
-            CDBG_ERROR("%s: dest stream obj not found %d", __func__, config->dest[i].inst_handle);
-            return -1;
-        }
-    }
-
-    /* fill in config */
-    memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
-    repro_cmd.cmd = MM_CAMERA_REPRO_CMD_CONFIG;
-    repro_cmd.payload.config.repro_handle = repro_handle;
-    /* using instant handler which can be understandable by mctl */
-    repro_cmd.payload.config.src.inst_handle = src_stream->inst_hdl;
-    /* translate to V4L2 ext image mode */
-    repro_cmd.payload.config.src.image_mode =
-        mm_channel_get_ext_mode_from_img_mode(config->src.image_mode);
-    repro_cmd.payload.config.src.format = config->src.format;
-    repro_cmd.payload.config.src.width = config->src.width;
-    repro_cmd.payload.config.src.height = config->src.height;
-    CDBG("%s: src: inst_hdl=0x%x, image_mode=%d, format=%d, width x height=%dx%d",
-         __func__,
-         repro_cmd.payload.config.src.inst_handle,
-         repro_cmd.payload.config.src.image_mode,
-         repro_cmd.payload.config.src.format,
-         repro_cmd.payload.config.src.width,
-         repro_cmd.payload.config.src.height);
-    repro_cmd.payload.config.num_dest = config->num_dest;
-    for (i = 0; i < repro_cmd.payload.config.num_dest; i++) {
-        /* using instant handler which can be understandable by mctl */
-        repro_cmd.payload.config.dest[i].inst_handle = dest_streams[i]->inst_hdl;
-        /* translate into V4L2 ext image mode */
-        repro_cmd.payload.config.dest[i].image_mode =
-            mm_channel_get_ext_mode_from_img_mode(config->dest[i].image_mode);
-        repro_cmd.payload.config.dest[i].format = config->dest[i].format;
-        repro_cmd.payload.config.dest[i].width = config->dest[i].width;
-        repro_cmd.payload.config.dest[i].height = config->dest[i].height;
-        CDBG("%s: dest %d: inst_hdl=0x%x, image_mode=%d, format=%d, width x height=%dx%d",
-             __func__, i,
-             repro_cmd.payload.config.dest[i].inst_handle,
-             repro_cmd.payload.config.dest[i].image_mode,
-             repro_cmd.payload.config.dest[i].format,
-             repro_cmd.payload.config.dest[i].width,
-             repro_cmd.payload.config.dest[i].height);
-    }
-    rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                        CAMERA_SEND_PP_PIPELINE_CMD,
-                                        sizeof(mm_camera_repro_cmd_t),
-                                        (void *)&repro_cmd);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config repo isp failed (rc=%d)", __func__, rc);
-    }
-    return rc;
-}
-
-int32_t mm_channel_repro_isp_dest_stream_ops(mm_channel_t *my_obj,
-                                             uint32_t repro_handle,
-                                             uint32_t stream_handle,
-                                             uint8_t attach_flag)
-{
-    int32_t rc = -1;
-    mm_stream_t *stream_obj = NULL;
-    mm_camera_repro_cmd_t repro_cmd;
-
-    /* first check if streams are valid */
-    stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_handle);
-    if (NULL == stream_obj) {
-        CDBG_ERROR("%s: stream obj not found %d", __func__, stream_handle);
-        return -1;
-    }
-
-    memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
-    repro_cmd.cmd = MM_CAMERA_REPRO_CMD_ATTACH_DETACH;
-    repro_cmd.payload.attach_detach.repro_handle = repro_handle;
-    repro_cmd.payload.attach_detach.attach_flag = attach_flag;
-    repro_cmd.payload.attach_detach.inst_handle = stream_obj->inst_hdl;
-    rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                        CAMERA_SEND_PP_PIPELINE_CMD,
-                                        sizeof(mm_camera_repro_cmd_t),
-                                        (void *)&repro_cmd);
-    if (0 != rc) {
-        CDBG_ERROR("%s: repo isp stream operation failed (flag=%d, rc=%d)",
-                   __func__, attach_flag, rc);
-    }
-    return rc;
-}
-
-int32_t mm_channel_repro_isp_ops(mm_channel_t *my_obj,
-                                 uint32_t repro_handle,
-                                 uint32_t stream_id,
-                                 uint8_t start_flag)
-{
-    int32_t rc = -1;
-    mm_camera_repro_cmd_t repro_cmd;
-    mm_stream_t *stream_obj = NULL;
-
-    /* first check if streams are valid */
-    stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_id);
-    if (NULL == stream_obj) {
-        CDBG_ERROR("%s: stream obj not found %d", __func__, stream_id);
-        return -1;
-    }
-
-    memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
-    repro_cmd.cmd = MM_CAMERA_REPRO_CMD_START_STOP;
-    repro_cmd.payload.start_stop.repro_handle = repro_handle;
-    repro_cmd.payload.start_stop.dest_handle = stream_obj->inst_hdl;
-    repro_cmd.payload.start_stop.start_flag = start_flag;
-    rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                        CAMERA_SEND_PP_PIPELINE_CMD,
-                                        sizeof(mm_camera_repro_cmd_t),
-                                        (void *)&repro_cmd);
-    if (0 != rc) {
-        CDBG_ERROR("%s: repo isp stream operation failed (flag=%d, rc=%d)",
-                   __func__, start_flag, rc);
-    }
-    return rc;
-}
-
-int32_t mm_channel_reprocess(mm_channel_t *my_obj,
-                             uint32_t repro_handle,
-                             mm_camera_repro_data_t *repro_data)
-{
-    int32_t rc = -1;
-    mm_camera_repro_cmd_t repro_cmd;
-    mm_stream_t *stream_obj = NULL;
-    uint8_t i;
-
-    /* check if input param is valid */
-    if (NULL == repro_data || NULL == repro_data->src_frame) {
-        CDBG_ERROR("%s: invalid input param", __func__);
-        return -1;
-    }
-
-    /* check if streams are valid */
-    stream_obj = mm_channel_util_get_stream_by_handler(my_obj,
-                                                       repro_data->src_frame->stream_id);
-    if (NULL == stream_obj) {
-        CDBG_ERROR("%s: stream obj not found %d",
-                   __func__, repro_data->src_frame->stream_id);
-        return -1;
-    }
-
-    memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
-    repro_cmd.cmd = MM_CAMERA_REPRO_CMD_START_STOP;
-    repro_cmd.payload.reprocess.repro_handle = repro_handle;
-    repro_cmd.payload.reprocess.inst_handle = stream_obj->inst_hdl;
-    repro_cmd.payload.reprocess.buf_idx = repro_data->src_frame->buf_idx;
-    repro_cmd.payload.reprocess.frame_id = repro_data->src_frame->frame_idx;
-    repro_cmd.payload.reprocess.frame_len = repro_data->src_frame->frame_len;
-    repro_cmd.payload.reprocess.timestamp.tv_sec =
-        repro_data->src_frame->ts.tv_sec;
-    repro_cmd.payload.reprocess.timestamp.tv_usec =
-        repro_data->src_frame->ts.tv_nsec/1000;
-    repro_cmd.payload.reprocess.num_planes = repro_data->src_frame->num_planes;
-    for (i = 0; i < repro_cmd.payload.reprocess.num_planes; i++) {
-        repro_cmd.payload.reprocess.planes[i].addr_offset =
-            repro_data->src_frame->planes[i].reserved[0];
-        repro_cmd.payload.reprocess.planes[i].data_offset =
-            repro_data->src_frame->planes[i].data_offset;
-        repro_cmd.payload.reprocess.planes[i].length =
-            repro_data->src_frame->planes[i].length;
-    }
-    rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
-                                        CAMERA_SEND_PP_PIPELINE_CMD,
-                                        sizeof(mm_camera_repro_cmd_t),
-                                        (void *)&repro_cmd);
-    if (0 != rc) {
-        CDBG_ERROR("%s: do reprocess failed (rc=%d)", __func__, rc);
-    }
-    return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_data.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_data.c
deleted file mode 100755
index b02567e..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_data.c
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <camera.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-#if 0
-#undef CDBG
-#undef LOG_TAG
-#define CDBG ALOGE
-#define LOG_TAG "NotifyLogs"
-#endif
-
-int32_t mm_camera_queue_init(mm_camera_queue_t* queue)
-{
-    pthread_mutex_init(&queue->lock, NULL);
-    cam_list_init(&queue->head.list);
-    queue->size = 0;
-    return 0;
-}
-
-int32_t mm_camera_queue_enq(mm_camera_queue_t* queue, void* data)
-{
-    mm_camera_q_node_t* node =
-        (mm_camera_q_node_t *)malloc(sizeof(mm_camera_q_node_t));
-    if (NULL == node) {
-        CDBG_ERROR("%s: No memory for mm_camera_q_node_t", __func__);
-        return -1;
-    }
-
-    memset(node, 0, sizeof(mm_camera_q_node_t));
-    node->data = data;
-
-    pthread_mutex_lock(&queue->lock);
-    cam_list_add_tail_node(&node->list, &queue->head.list);
-    queue->size++;
-    pthread_mutex_unlock(&queue->lock);
-
-    return 0;
-
-}
-
-void* mm_camera_queue_deq(mm_camera_queue_t* queue)
-{
-    mm_camera_q_node_t* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-    if (pos != head) {
-        node = member_of(pos, mm_camera_q_node_t, list);
-        cam_list_del_node(&node->list);
-        queue->size--;
-    }
-    pthread_mutex_unlock(&queue->lock);
-
-    if (NULL != node) {
-        data = node->data;
-        free(node);
-    }
-
-    return data;
-}
-
-int32_t mm_camera_queue_deinit(mm_camera_queue_t* queue)
-{
-    mm_camera_queue_flush(queue);
-    pthread_mutex_destroy(&queue->lock);
-    return 0;
-}
-
-int32_t mm_camera_queue_flush(mm_camera_queue_t* queue)
-{
-    mm_camera_q_node_t* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-
-    while(pos != head) {
-        node = member_of(pos, mm_camera_q_node_t, list);
-        pos = pos->next;
-        cam_list_del_node(&node->list);
-        queue->size--;
-
-        /* TODO later to consider ptr inside data */
-        /* for now we only assume there is no ptr inside data
-         * so we free data directly */
-        if (NULL != node->data) {
-            free(node->data);
-        }
-        free(node);
-
-    }
-    queue->size = 0;
-    pthread_mutex_unlock(&queue->lock);
-    return 0;
-}
-
-static void *mm_camera_cmd_thread(void *data)
-{
-    int rc = 0;
-    int running = 1;
-    int ret;
-    mm_camera_cmd_thread_t *cmd_thread =
-                (mm_camera_cmd_thread_t *)data;
-    mm_camera_cmdcb_t* node = NULL;
-
-    do {
-        do {
-            ret = sem_wait(&cmd_thread->cmd_sem);
-            if (ret != 0 && errno != EINVAL) {
-                CDBG_ERROR("%s: sem_wait error (%s)",
-                           __func__, strerror(errno));
-                return NULL;
-            }
-        } while (ret != 0);
-
-        /* we got notified about new cmd avail in cmd queue */
-        node = (mm_camera_cmdcb_t*)mm_camera_queue_deq(&cmd_thread->cmd_queue);
-        while (node != NULL) {
-            switch (node->cmd_type) {
-            case MM_CAMERA_CMD_TYPE_EVT_CB:
-            case MM_CAMERA_CMD_TYPE_DATA_CB:
-            case MM_CAMERA_CMD_TYPE_ASYNC_CB:
-            case MM_CAMERA_CMD_TYPE_REQ_DATA_CB:
-            case MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB:
-                if (NULL != cmd_thread->cb) {
-                    cmd_thread->cb(node, cmd_thread->user_data);
-                }
-                break;
-            case MM_CAMERA_CMD_TYPE_EXIT:
-            default:
-                running = 0;
-                break;
-            }
-            free(node);
-            node = (mm_camera_cmdcb_t*)mm_camera_queue_deq(&cmd_thread->cmd_queue);
-        } /* (node != NULL) */
-    } while (running);
-    return NULL;
-}
-
-int32_t mm_camera_cmd_thread_launch(mm_camera_cmd_thread_t * cmd_thread,
-                                    mm_camera_cmd_cb_t cb,
-                                    void* user_data)
-{
-    int32_t rc = 0;
-
-    sem_init(&cmd_thread->cmd_sem, 0, 0);
-    mm_camera_queue_init(&cmd_thread->cmd_queue);
-    cmd_thread->cb = cb;
-    cmd_thread->user_data = user_data;
-
-    /* launch the thread */
-    pthread_create(&cmd_thread->cmd_pid,
-                   NULL,
-                   mm_camera_cmd_thread,
-                   (void *)cmd_thread);
-    return rc;
-}
-
-int32_t mm_camera_cmd_thread_stop(mm_camera_cmd_thread_t * cmd_thread)
-{
-    int32_t rc = 0;
-    mm_camera_buf_info_t  buf_info;
-    mm_camera_cmdcb_t* node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-    if (NULL == node) {
-        CDBG_ERROR("%s: No memory for mm_camera_cmdcb_t", __func__);
-        return -1;
-    }
-
-    memset(node, 0, sizeof(mm_camera_cmdcb_t));
-    node->cmd_type = MM_CAMERA_CMD_TYPE_EXIT;
-
-    mm_camera_queue_enq(&cmd_thread->cmd_queue, node);
-    sem_post(&cmd_thread->cmd_sem);
-
-    /* wait until cmd thread exits */
-    if (pthread_join(cmd_thread->cmd_pid, NULL) != 0) {
-        CDBG("%s: pthread dead already\n", __func__);
-    }
-    return rc;
-}
-
-int32_t mm_camera_cmd_thread_destroy(mm_camera_cmd_thread_t * cmd_thread)
-{
-    int32_t rc = 0;
-    mm_camera_queue_deinit(&cmd_thread->cmd_queue);
-    sem_destroy(&cmd_thread->cmd_sem);
-    memset(cmd_thread, 0, sizeof(mm_camera_cmd_thread_t));
-    return rc;
-}
-
-int32_t mm_camera_cmd_thread_release(mm_camera_cmd_thread_t * cmd_thread)
-{
-    int32_t rc = 0;
-    rc = mm_camera_cmd_thread_stop(cmd_thread);
-    if (0 == rc) {
-        rc = mm_camera_cmd_thread_destroy(cmd_thread);
-    }
-    return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_helper.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_helper.c
deleted file mode 100755
index 5962149..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_helper.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <errno.h>
-#include <string.h>
-#include "mm_camera_dbg.h"
-
-/*============================================================
-   FUNCTION mm_camera_dump_image
-   DESCRIPTION:
-==============================================================*/
-int mm_camera_dump_image(void *addr, uint32_t size, char *filename)
-{
-  int file_fd = open(filename, O_RDWR | O_CREAT, 0777);
-
-  if (file_fd < 0) {
-    CDBG_HIGH("%s: cannot open file\n", __func__);
-    return -1;
-  } else
-    write(file_fd, addr, size);
-  close(file_fd);
-  CDBG("%s: %s, size=%d\n", __func__, filename, size);
-  return 0;
-}
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_interface.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_interface.c
deleted file mode 100755
index ae5462c..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_interface.c
+++ /dev/null
@@ -1,1319 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <linux/media.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera_sock.h"
-#include "mm_camera.h"
-
-static pthread_mutex_t g_intf_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t g_oem_lock = PTHREAD_MUTEX_INITIALIZER;
-
-static mm_camera_ctrl_t g_cam_ctrl = {{{0, {0, 0, 0, 0}, 0, 0}}, 0, {{0}}, {0}};
-
-static pthread_mutex_t g_handler_lock = PTHREAD_MUTEX_INITIALIZER;
-static uint16_t g_handler_history_count = 0; /* history count for handler */
-
-extern int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
-                                       cam_ctrl_type type,
-                                       uint32_t length,
-                                       void *value);
-
-/* utility function to generate handler */
-uint32_t mm_camera_util_generate_handler(uint8_t index)
-{
-    uint32_t handler = 0;
-    pthread_mutex_lock(&g_handler_lock);
-    g_handler_history_count++;
-    if (0 == g_handler_history_count) {
-        g_handler_history_count++;
-    }
-    handler = g_handler_history_count;
-    handler = (handler<<8) | index;
-    pthread_mutex_unlock(&g_handler_lock);
-    return handler;
-}
-
-uint8_t mm_camera_util_get_index_by_handler(uint32_t handler)
-{
-    return (handler&0x000000ff);
-}
-
-const char *mm_camera_util_get_dev_name(uint32_t cam_handler)
-{
-    char *dev_name = NULL;
-    uint8_t cam_idx = mm_camera_util_get_index_by_handler(cam_handler);
-    dev_name = g_cam_ctrl.camera[cam_idx].video_dev_name;
-    return dev_name;
-}
-
-mm_camera_obj_t* mm_camera_util_get_camera_by_handler(uint32_t cam_handler)
-{
-    mm_camera_obj_t *cam_obj = NULL;
-    uint8_t cam_idx = mm_camera_util_get_index_by_handler(cam_handler);
-
-    if ((NULL != g_cam_ctrl.cam_obj[cam_idx]) &&
-        (cam_handler == g_cam_ctrl.cam_obj[cam_idx]->my_hdl)) {
-        cam_obj = g_cam_ctrl.cam_obj[cam_idx];
-    }
-    return cam_obj;
-}
-
-static int32_t mm_camera_intf_sync(uint32_t camera_handler)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s E: camera_handler = %d ",__func__,camera_handler);
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_sync(my_obj);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-/* check if the operation is supported */
-static int32_t mm_camera_intf_is_op_supported(uint32_t camera_handler,mm_camera_ops_type_t opcode)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_is_op_supported(my_obj, opcode);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    return rc;
-}
-
-/* check if the parm is supported */
-static int32_t mm_camera_intf_is_parm_supported(uint32_t camera_handler,
-                                   mm_camera_parm_type_t parm_type,
-                                   uint8_t *support_set_parm,
-                                   uint8_t *support_get_parm)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-    *support_set_parm = 0;
-    *support_get_parm = 0;
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_is_parm_supported(my_obj, parm_type, support_set_parm, support_get_parm);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    return rc;
-}
-
-/* set a parmÂ’s current value */
-static int32_t mm_camera_intf_set_parm(uint32_t camera_handler,
-                                   mm_camera_parm_type_t parm_type,
-                                   void* p_value)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_set_parm(my_obj, parm_type, p_value);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    return rc;
-}
-
-/* get a parmÂ’s current value */
-static int32_t mm_camera_intf_get_parm(uint32_t camera_handler,
-                                mm_camera_parm_type_t parm_type,
-                                void* p_value)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_get_parm(my_obj, parm_type, p_value);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    return rc;
-}
-
-static void mm_camera_intf_close(uint32_t camera_handler)
-{
-    int32_t rc = -1;
-    uint8_t cam_idx = camera_handler & 0x00ff;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s E: camera_handler = %d ",__func__,camera_handler);
-
-    /* first we need to get oem_lock,
-     * in case oem private ioctl is still processing,
-     * we need to wait until it finishes */
-    pthread_mutex_lock(&g_oem_lock);
-
-    /* then we get intf_lock */
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if (my_obj){
-        my_obj->ref_count--;
-
-        if(my_obj->ref_count > 0) {
-            /* still have reference to obj, return here */
-            CDBG("%s: ref_count=%d\n", __func__, my_obj->ref_count);
-            pthread_mutex_unlock(&g_intf_lock);
-        } else {
-            /* need close camera here as no other reference
-             * first empty g_cam_ctrl's referent to cam_obj */
-            g_cam_ctrl.cam_obj[cam_idx] = NULL;
-
-            pthread_mutex_lock(&my_obj->cam_lock);
-            pthread_mutex_unlock(&g_intf_lock);
-
-            mm_camera_close(my_obj);
-
-            pthread_mutex_destroy(&my_obj->cam_lock);
-            free(my_obj);
-        }
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    /* unlock oem_lock before we leave */
-    pthread_mutex_unlock(&g_oem_lock);
-}
-
-static uint32_t mm_camera_intf_add_channel(uint32_t camera_handler)
-{
-    uint32_t ch_id = 0;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E camera_handler = %d",__func__,camera_handler);
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        ch_id = mm_camera_add_channel(my_obj);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X ch_id = %d",__func__,ch_id);
-    return ch_id;
-}
-
-static void mm_camera_intf_del_channel(uint32_t camera_handler, uint32_t ch_id)
-{
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E ch_id = %d",__func__,ch_id);
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        mm_camera_del_channel(my_obj, ch_id);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X",__func__);
-}
-
-static uint8_t mm_camera_intf_is_event_supported(uint32_t camera_handler,
-                                    mm_camera_event_type_t evt_type)
-{
-    switch(evt_type) {
-    case MM_CAMERA_EVT_TYPE_CH:
-    case MM_CAMERA_EVT_TYPE_CTRL:
-    case MM_CAMERA_EVT_TYPE_STATS:
-    case MM_CAMERA_EVT_TYPE_INFO:
-        return 1;
-    default:
-        return 0;
-    }
-    return 0;
-}
-
-static int32_t mm_camera_intf_register_event_notify(
-                                    uint32_t camera_handler,
-                                    mm_camera_event_notify_t evt_cb,
-                                    void * user_data,
-                                    mm_camera_event_type_t evt_type)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E evt_type = %d",__func__,evt_type);
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_register_event_notify(my_obj, evt_cb, user_data, evt_type);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :E rc = %d",__func__,rc);
-    return rc;
-}
-
-static mm_camera_2nd_sensor_t * mm_camera_intf_query_2nd_sensor_info(uint32_t camera_handler)
-{
-    mm_camera_2nd_sensor_t *sensor_info = NULL;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E camera_handler = %d",__func__,camera_handler);
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        sensor_info = mm_camera_query_2nd_sensor_info(my_obj);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X",__func__);
-    return sensor_info;
-}
-
-static int32_t mm_camera_intf_qbuf(uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    mm_camera_buf_def_t *buf)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_qbuf(my_obj, ch_id, buf);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X evt_type = %d",__func__,rc);
-    return rc;
-}
-
-static uint32_t mm_camera_intf_add_stream(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    mm_camera_buf_notify_t buf_cb, void *user_data,
-                                    uint32_t ext_image_mode, uint32_t sensor_idx)
-{
-    uint32_t stream_id = 0;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s : E handle = %d ch_id = %d",__func__,camera_handler,
-         ch_id);
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        stream_id = mm_camera_add_stream(my_obj, ch_id, buf_cb,
-                                  user_data, ext_image_mode, sensor_idx);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X stream_id = %d",__func__,stream_id);
-    return stream_id;
-}
-
-static int32_t mm_camera_intf_del_stream(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s : E handle = %d ch_id = %d stream_id = %d",__func__,camera_handler,
-         ch_id,stream_id);
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_del_stream(my_obj, ch_id, stream_id);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_config_stream(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint32_t stream_id,
-                                    mm_camera_stream_config_t *config)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E handle = %d, ch_id = %d,stream_id = %d",__func__,
-         camera_handler,ch_id,stream_id);
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    CDBG("%s :mm_camera_intf_config_stream stream_id = %d",__func__,stream_id);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_config_stream(my_obj, ch_id, stream_id, config);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_bundle_streams(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    mm_camera_buf_notify_t super_frame_notify_cb,
-                                    void *user_data,
-                                    mm_camera_bundle_attr_t *attr,
-                                    uint8_t num_streams,
-                                    uint32_t *stream_ids)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E handle = %d, ch_id = %d",__func__,
-         camera_handler,ch_id);
-
-    if (MM_CAMEAR_MAX_STRAEM_BUNDLE < num_streams) {
-        CDBG_ERROR("%s: number of streams (%d) exceeds max (%d)",
-                   __func__, num_streams, MM_CAMEAR_MAX_STRAEM_BUNDLE);
-        return rc;
-    }
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_bundle_streams(my_obj, ch_id,
-                                      super_frame_notify_cb,
-                                      user_data, attr,
-                                      num_streams, stream_ids);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_destroy_bundle(uint32_t camera_handler,
-                                    uint32_t ch_id)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E handle = %d, ch_id = %d",__func__,
-         camera_handler,ch_id);
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_destroy_bundle(my_obj, ch_id);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_start_streams(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint8_t num_streams,
-                                    uint32_t *stream_ids)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E camera_handler = %d,ch_id = %d, num_streams = %d",
-         __func__,camera_handler,ch_id,num_streams);
-    if (MM_CAMEAR_STRAEM_NUM_MAX < num_streams) {
-        CDBG_ERROR("%s: num of streams (%d) exceeds MAX (%d)",
-                   __func__, num_streams, MM_CAMEAR_STRAEM_NUM_MAX);
-        return rc;
-    }
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_start_streams(my_obj, ch_id, num_streams, stream_ids);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_stop_streams(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint8_t num_streams,
-                                    uint32_t *stream_ids)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E camera_handler = %d,ch_id = %d, num_streams = %d",
-         __func__,camera_handler,ch_id,num_streams);
-
-    if (MM_CAMEAR_STRAEM_NUM_MAX < num_streams) {
-        CDBG_ERROR("%s: num of streams (%d) exceeds MAX (%d)",
-                   __func__, num_streams, MM_CAMEAR_STRAEM_NUM_MAX);
-        return rc;
-    }
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_stop_streams(my_obj, ch_id,
-                                    num_streams, stream_ids);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_async_teardown_streams(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint8_t num_streams,
-                                    uint32_t *stream_ids)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E camera_handler = %d,ch_id = %d, num_streams = %d",
-         __func__,camera_handler,ch_id,num_streams);
-
-    if (MM_CAMEAR_STRAEM_NUM_MAX < num_streams) {
-        CDBG_ERROR("%s: num of streams (%d) exceeds MAX (%d)",
-                   __func__, num_streams, MM_CAMEAR_STRAEM_NUM_MAX);
-        return rc;
-    }
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_async_teardown_streams(my_obj, ch_id,
-                                              num_streams, stream_ids);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_request_super_buf(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint32_t num_buf_requested)
-{
-    int32_t rc = -1;
-    CDBG("%s :E camera_handler = %d,ch_id = %d",
-         __func__,camera_handler,ch_id);
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_request_super_buf(my_obj, ch_id, num_buf_requested);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_cancel_super_buf_request(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E camera_handler = %d,ch_id = %d",
-         __func__,camera_handler,ch_id);
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_cancel_super_buf_request(my_obj, ch_id);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_start_focus(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint32_t sensor_idx,
-                                    uint32_t focus_mode)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    CDBG("%s :E camera_handler = %d,ch_id = %d, focus_mode = %d",
-         __func__,camera_handler,ch_id,focus_mode);
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_start_focus(my_obj, ch_id, sensor_idx, focus_mode);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_abort_focus(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint32_t sensor_idx)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_abort_focus(my_obj, ch_id, sensor_idx);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_prepare_snapshot(
-                                    uint32_t camera_handler,
-                                    uint32_t ch_id,
-                                    uint32_t sensor_idx)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_prepare_snapshot(my_obj, ch_id, sensor_idx);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_set_stream_parm(
-                                     uint32_t camera_handle,
-                                     uint32_t ch_id,
-                                     uint32_t s_id,
-                                     mm_camera_stream_parm_t parm_type,
-                                     void* p_value)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    CDBG("%s :E camera_handle = %d,ch_id = %d,s_id = %d,parm_type = %d",__func__,
-            camera_handle,ch_id,s_id,parm_type);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_set_stream_parm(my_obj,ch_id,s_id,
-                                       parm_type,
-                                       p_value);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_get_stream_parm(
-                                     uint32_t camera_handle,
-                                     uint32_t ch_id,
-                                     uint32_t s_id,
-                                     mm_camera_stream_parm_t parm_type,
-                                     void* p_value)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    CDBG("%s :E camera_handle = %d,ch_id = %d,s_id = %d,parm_type = %d",__func__,
-            camera_handle,ch_id,s_id,parm_type);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_get_stream_parm(my_obj,ch_id,s_id,
-                                       parm_type,
-                                       p_value);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_send_private_ioctl(uint32_t camera_handle,
-                                                 uint32_t cmd_id,
-                                                 uint32_t cmd_length,
-                                                 void *cmd)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t *my_obj = NULL;
-
-    pthread_mutex_lock(&g_oem_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if (my_obj) {
-        rc = mm_camera_send_private_ioctl(my_obj, cmd_id, cmd_length, cmd);
-    }
-
-    pthread_mutex_unlock(&g_oem_lock);
-    CDBG("%s :X rc = %d", __func__, rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_send_native_cmd(uint32_t camera_handle,
-                                              uint32_t cmd_id,
-                                              uint32_t cmd_length,
-                                              void *cmd)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t *my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if (!cmd) {
-        CDBG_ERROR("%s Null cmd ", __func__);
-        return -EINVAL;
-    }
-
-    if (my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        switch(cmd_id) {
-        case NATIVE_CMD_ID_SOCKET_MAP: {
-            cam_sock_packet_t packet;
-            memset(&packet, 0, sizeof(cam_sock_packet_t));
-            memcpy(&packet.payload.frame_fd_map, cmd, sizeof(mm_camera_frame_map_type));
-            if(packet.payload.frame_fd_map.is_hist) {
-                packet.msg_type = CAM_SOCK_MSG_TYPE_HIST_MAPPING;
-            } else {
-                packet.msg_type = CAM_SOCK_MSG_TYPE_FD_MAPPING;
-            }
-            rc = mm_camera_util_sendmsg(my_obj, &packet,
-                                      sizeof(cam_sock_packet_t),
-                                      packet.payload.frame_fd_map.fd);
-          }
-          break;
-        case NATIVE_CMD_ID_SOCKET_UNMAP: {
-            cam_sock_packet_t packet;
-            memset(&packet, 0, sizeof(cam_sock_packet_t));
-            memcpy(&packet.payload.frame_fd_unmap, cmd, sizeof(mm_camera_frame_unmap_type));
-            if(packet.payload.frame_fd_unmap.is_hist) {
-                packet.msg_type = CAM_SOCK_MSG_TYPE_HIST_UNMAPPING;
-            } else {
-                packet.msg_type = CAM_SOCK_MSG_TYPE_FD_UNMAPPING;
-            }
-            rc = mm_camera_util_sendmsg(my_obj, &packet,
-                                      sizeof(cam_sock_packet_t), 0);
-          }
-          break;
-       case NATIVE_CMD_ID_IOCTL_CTRL:
-           /* may switch to send through native ctrl cmd ioctl */
-           rc = mm_camera_util_sendmsg(my_obj, cmd,
-                                      cmd_length, 0);
-#if 0
-           rc = mm_camera_send_native_ctrl_cmd(my_obj, cmd_id,
-                                                cmd_length, cmd);
-#endif
-          break;
-       default:
-          CDBG_ERROR("%s Invalid native cmd id %d ", __func__, cmd_id);
-          rc = -EINVAL;
-          break;
-        }
-        pthread_mutex_unlock(&my_obj->cam_lock);
-    } else {
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d", __func__, rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_send_cmd(uint32_t camera_handle,
-                                       mm_camera_cmd_type_t cmd_type,
-                                       uint32_t cmd_id,
-                                       uint32_t cmd_length,
-                                       void *cmd)
-{
-    int32_t rc = -1;
-
-    switch (cmd_type) {
-    case MM_CAMERA_CMD_TYPE_PRIVATE:
-        /* OEM private ioctl */
-        rc = mm_camera_intf_send_private_ioctl(camera_handle, cmd_id, cmd_length, cmd);
-        break;
-    case MM_CAMERA_CMD_TYPE_NATIVE:
-        rc = mm_camera_intf_send_native_cmd(camera_handle, cmd_id, cmd_length, cmd);
-        break;
-    }
-
-    return rc;
-}
-
-static uint32_t mm_camera_intf_open_repro_isp(uint32_t camera_handle,
-                                              uint32_t ch_id,
-                                              mm_camera_repro_isp_type_t repro_isp_type)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-    uint32_t repro_isp_handle = 0;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_open_repro_isp(my_obj,
-                                     ch_id,
-                                     repro_isp_type,
-                                     &repro_isp_handle);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return repro_isp_handle;
-}
-
-static int32_t mm_camera_intf_config_repro_isp(uint32_t camera_handle,
-                                               uint32_t ch_id,
-                                               uint32_t repro_isp_handle,
-                                               mm_camera_repro_isp_config_t *config)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_config_repro_isp(my_obj,
-                                        ch_id,
-                                        repro_isp_handle,
-                                        config);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_attach_stream_to_repro_isp(uint32_t camera_handle,
-                                                         uint32_t ch_id,
-                                                         uint32_t repro_isp_handle,
-                                                         uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_attach_stream_to_repro_isp(my_obj,
-                                                  ch_id,
-                                                  repro_isp_handle,
-                                                  stream_id);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_start_repro_isp(uint32_t camera_handle,
-                                              uint32_t ch_id,
-                                              uint32_t repro_isp_handle,
-                                              uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_start_repro_isp(my_obj,
-                                       ch_id,
-                                       repro_isp_handle,
-                                       stream_id);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_reprocess(uint32_t camera_handle,
-                                        uint32_t ch_id,
-                                        uint32_t repro_isp_handle,
-                                        mm_camera_repro_data_t *repro_data)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_reprocess(my_obj,
-                                 ch_id,
-                                 repro_isp_handle,
-                                 repro_data);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_stop_repro_isp(uint32_t camera_handle,
-                                             uint32_t ch_id,
-                                             uint32_t repro_isp_handle,
-                                             uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_stop_repro_isp(my_obj,
-                                      ch_id,
-                                      repro_isp_handle,
-                                      stream_id);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_detach_stream_from_repro_isp(uint32_t camera_handle,
-                                                           uint32_t ch_id,
-                                                           uint32_t repro_isp_handle,
-                                                           uint32_t stream_id)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_detach_stream_from_repro_isp(my_obj,
-                                                    ch_id,
-                                                    repro_isp_handle,
-                                                    stream_id);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static int32_t mm_camera_intf_close_repro_isp(uint32_t camera_handle,
-                                              uint32_t ch_id,
-                                              uint32_t repro_isp_handle)
-{
-    int32_t rc = -1;
-    mm_camera_obj_t * my_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
-    if(my_obj) {
-        pthread_mutex_lock(&my_obj->cam_lock);
-        pthread_mutex_unlock(&g_intf_lock);
-        rc = mm_camera_close_repro_isp(my_obj,
-                                       ch_id,
-                                       repro_isp_handle);
-    }else{
-        pthread_mutex_unlock(&g_intf_lock);
-    }
-
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-mm_camera_info_t * camera_query(uint8_t *num_cameras)
-{
-    int i = 0, rc = 0;
-    int dev_fd = 0;
-    struct media_device_info mdev_info;
-    int num_media_devices = 0;
-    if (!num_cameras) {
-        CDBG_ERROR("%s: num_cameras is NULL\n", __func__);
-        return NULL;
-    }
-
-    CDBG("%s : E",__func__);
-    /* lock the mutex */
-    pthread_mutex_lock(&g_intf_lock);
-    *num_cameras = 0;
-    while (1) {
-        char dev_name[32];
-        snprintf(dev_name, sizeof(dev_name), "/dev/media%d", num_media_devices);
-        dev_fd = open(dev_name, O_RDWR | O_NONBLOCK);
-        if (dev_fd < 0) {
-            CDBG("Done discovering media devices\n");
-            break;
-        }
-        num_media_devices++;
-        rc = ioctl(dev_fd, MEDIA_IOC_DEVICE_INFO, &mdev_info);
-        if (rc < 0) {
-            CDBG_ERROR("Error: ioctl media_dev failed: %s\n", strerror(errno));
-            close(dev_fd);
-            break;
-        }
-
-        if(strncmp(mdev_info.model, QCAMERA_NAME, sizeof(mdev_info.model) != 0)) {
-            close(dev_fd);
-            continue;
-        }
-
-        char * mdev_cfg;
-        int cam_type = 0, mount_angle = 0, info_index = 0;
-        mdev_cfg = strtok(mdev_info.serial, "-");
-        while(mdev_cfg != NULL) {
-            if(info_index == 0) {
-                if(strcmp(mdev_cfg, QCAMERA_NAME))
-                  break;
-            } else if(info_index == 1) {
-                mount_angle = atoi(mdev_cfg);
-            } else if(info_index == 2) {
-                cam_type = atoi(mdev_cfg);
-            }
-            mdev_cfg = strtok(NULL, "-");
-            info_index++;
-        }
-
-        if(info_index == 0) {
-            close(dev_fd);
-            continue;
-        }
-
-        int num_entities = 1;
-        while (1) {
-            struct media_entity_desc entity;
-            memset(&entity, 0, sizeof(entity));
-            entity.id = num_entities++;
-            rc = ioctl(dev_fd, MEDIA_IOC_ENUM_ENTITIES, &entity);
-            if (rc < 0) {
-                CDBG("Done enumerating media entities\n");
-                rc = 0;
-                break;
-            }
-            if(entity.type == MEDIA_ENT_T_DEVNODE_V4L && entity.group_id == QCAMERA_VNODE_GROUP_ID) {
-                strncpy(g_cam_ctrl.video_dev_name[*num_cameras],
-                     entity.name, sizeof(entity.name));
-                g_cam_ctrl.camera[*num_cameras].video_dev_name =
-                    &g_cam_ctrl.video_dev_name[*num_cameras][0];
-                break;
-            }
-        }
-
-        //g_cam_ctrl.camera[*num_cameras].camera_info.camera_id = *num_cameras;
-        g_cam_ctrl.camera[*num_cameras].camera_id = *num_cameras;
-
-        g_cam_ctrl.camera[*num_cameras].
-            camera_info.modes_supported = CAMERA_MODE_2D;
-
-        if(cam_type > 1) {
-            g_cam_ctrl.camera[*num_cameras].
-                camera_info.modes_supported |= CAMERA_MODE_3D;
-        }
-
-        g_cam_ctrl.camera[*num_cameras].camera_info.position =
-            (cam_type == 1) ? FRONT_CAMERA : BACK_CAMERA;
-
-        g_cam_ctrl.camera[*num_cameras].camera_info.sensor_mount_angle =
-            mount_angle;
-
-        g_cam_ctrl.camera[*num_cameras].main_sensor_type = 0;
-
-        CDBG("%s: dev_info[id=%d,name='%s',pos=%d,modes=0x%x,sensor=%d mount_angle = %d]\n",
-            __func__, *num_cameras,
-            g_cam_ctrl.camera[*num_cameras].video_dev_name,
-            g_cam_ctrl.camera[*num_cameras].camera_info.position,
-            g_cam_ctrl.camera[*num_cameras].camera_info.modes_supported,
-            g_cam_ctrl.camera[*num_cameras].main_sensor_type,
-            g_cam_ctrl.camera[*num_cameras].camera_info.sensor_mount_angle);
-
-        *num_cameras += 1;
-        if (dev_fd > 0) {
-            close(dev_fd);
-        }
-    }
-    *num_cameras = *num_cameras;
-    g_cam_ctrl.num_cam = *num_cameras;
-
-    /* unlock the mutex */
-    pthread_mutex_unlock(&g_intf_lock);
-    CDBG("%s: num_cameras=%d\n", __func__, g_cam_ctrl.num_cam);
-    if(rc == 0)
-        return &g_cam_ctrl.camera[0];
-    else
-        return NULL;
-}
-
-/* camera ops v-table */
-static mm_camera_ops_t mm_camera_ops = {
-    .sync = mm_camera_intf_sync,
-    .is_event_supported = mm_camera_intf_is_event_supported,
-    .register_event_notify = mm_camera_intf_register_event_notify,
-    .qbuf = mm_camera_intf_qbuf,
-    .camera_close = mm_camera_intf_close,
-    .query_2nd_sensor_info = mm_camera_intf_query_2nd_sensor_info,
-    .is_op_supported = mm_camera_intf_is_op_supported,
-    .is_parm_supported = mm_camera_intf_is_parm_supported,
-    .set_parm = mm_camera_intf_set_parm,
-    .get_parm = mm_camera_intf_get_parm,
-    .ch_acquire = mm_camera_intf_add_channel,
-    .ch_release = mm_camera_intf_del_channel,
-    .add_stream = mm_camera_intf_add_stream,
-    .del_stream = mm_camera_intf_del_stream,
-    .config_stream = mm_camera_intf_config_stream,
-    .init_stream_bundle = mm_camera_intf_bundle_streams,
-    .destroy_stream_bundle = mm_camera_intf_destroy_bundle,
-    .start_streams = mm_camera_intf_start_streams,
-    .stop_streams = mm_camera_intf_stop_streams,
-    .async_teardown_streams = mm_camera_intf_async_teardown_streams,
-    .request_super_buf = mm_camera_intf_request_super_buf,
-    .cancel_super_buf_request = mm_camera_intf_cancel_super_buf_request,
-    .start_focus = mm_camera_intf_start_focus,
-    .abort_focus = mm_camera_intf_abort_focus,
-    .prepare_snapshot = mm_camera_intf_prepare_snapshot,
-    .set_stream_parm = mm_camera_intf_set_stream_parm,
-    .get_stream_parm = mm_camera_intf_get_stream_parm,
-    .send_command = mm_camera_intf_send_cmd,
-    .open_repro_isp = mm_camera_intf_open_repro_isp,
-    .config_repro_isp = mm_camera_intf_config_repro_isp,
-    .attach_stream_to_repro_isp = mm_camera_intf_attach_stream_to_repro_isp,
-    .start_repro_isp = mm_camera_intf_start_repro_isp,
-    .reprocess =  mm_camera_intf_reprocess,
-    .stop_repro_isp = mm_camera_intf_stop_repro_isp,
-    .detach_stream_from_repro_isp = mm_camera_intf_detach_stream_from_repro_isp,
-    .close_repro_isp = mm_camera_intf_close_repro_isp
-};
-
-/* open camera. */
-mm_camera_vtbl_t * camera_open(uint8_t camera_idx,
-                               mm_camear_mem_vtbl_t *mem_vtbl)
-{
-    int32_t rc = 0;
-    mm_camera_obj_t* cam_obj = NULL;
-
-    CDBG("%s: E camera_idx = %d\n", __func__,camera_idx);
-    if (MSM_MAX_CAMERA_SENSORS <= camera_idx) {
-        CDBG_ERROR("%s: Invalid camera_idx (%d)", __func__, camera_idx);
-        return NULL;
-    }
-
-    pthread_mutex_lock(&g_oem_lock);
-    pthread_mutex_lock(&g_intf_lock);
-    /* opened already */
-    if(NULL != g_cam_ctrl.cam_obj[camera_idx]) {
-        /* Add reference */
-        g_cam_ctrl.cam_obj[camera_idx]->ref_count++;
-        pthread_mutex_unlock(&g_intf_lock);
-        pthread_mutex_unlock(&g_oem_lock);
-        CDBG("%s:  opened alreadyn", __func__);
-        return &cam_obj->vtbl;
-    }
-
-    cam_obj = (mm_camera_obj_t *)malloc(sizeof(mm_camera_obj_t));
-    if(NULL == cam_obj) {
-        pthread_mutex_unlock(&g_intf_lock);
-        pthread_mutex_unlock(&g_oem_lock);
-        CDBG("%s:  no mem", __func__);
-        return NULL;
-    }
-
-    /* initialize camera obj */
-    memset(cam_obj, 0, sizeof(mm_camera_obj_t));
-    cam_obj->ctrl_fd = -1;
-    cam_obj->ds_fd = -1;
-    cam_obj->ref_count++;
-    cam_obj->my_hdl = mm_camera_util_generate_handler(camera_idx);
-    cam_obj->vtbl.camera_handle = cam_obj->my_hdl; /* set handler */
-    cam_obj->vtbl.camera_info = &g_cam_ctrl.camera[camera_idx];
-    cam_obj->vtbl.ops = &mm_camera_ops;
-    cam_obj->mem_vtbl = mem_vtbl; /* save mem_vtbl */
-    pthread_mutex_init(&cam_obj->cam_lock, NULL);
-
-    rc = mm_camera_open(cam_obj);
-    if(rc != 0) {
-        CDBG_ERROR("%s: mm_camera_open err = %d", __func__, rc);
-        pthread_mutex_destroy(&cam_obj->cam_lock);
-        g_cam_ctrl.cam_obj[camera_idx] = NULL;
-        free(cam_obj);
-        cam_obj = NULL;
-        pthread_mutex_unlock(&g_intf_lock);
-        pthread_mutex_unlock(&g_oem_lock);
-        return NULL;
-    }else{
-        CDBG("%s: Open succeded\n", __func__);
-        g_cam_ctrl.cam_obj[camera_idx] = cam_obj;
-        pthread_mutex_unlock(&g_intf_lock);
-        pthread_mutex_unlock(&g_oem_lock);
-        return &cam_obj->vtbl;
-    }
-}
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_sock.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_sock.c
deleted file mode 100755
index 9d14950..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_sock.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/*

-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED

-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT

-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 <unistd.h>

-#include <stdlib.h>

-#include <errno.h>

-#include <string.h>

-#include <sys/socket.h>

-#include <sys/uio.h>

-#include <linux/un.h>

-

-#include "mm_camera_dbg.h"

-#include "mm_camera_sock.h"

-

-/*===========================================================================

- * FUNCTION    - mm_camera_socket_create -

- *

- * DESCRIPTION: opens a domain socket tied to camera ID and socket type

- *                        int cam_id: camera ID

-  *                       mm_camera_sock_type_t sock_type: socket type, TCP/UDP

- * retured fd related to the domain socket

- *==========================================================================*/

-int mm_camera_socket_create(int cam_id, mm_camera_sock_type_t sock_type)

-{

-    int socket_fd;

-    struct sockaddr_un sock_addr;

-    int sktype;

-    int rc;

-

-    switch (sock_type)

-    {

-      case MM_CAMERA_SOCK_TYPE_UDP:

-        sktype = SOCK_DGRAM;

-        break;

-      case MM_CAMERA_SOCK_TYPE_TCP:

-        sktype = SOCK_STREAM;

-        break;

-      default:

-        CDBG_ERROR("%s: unknown socket type =%d", __func__, sock_type);

-        return -1;

-    }

-    socket_fd = socket(AF_UNIX, sktype, 0);

-    if (socket_fd < 0) {

-        CDBG_ERROR("%s: error create socket fd =%d", __func__, socket_fd);

-        return socket_fd;

-    }

-

-    memset(&sock_addr, 0, sizeof(sock_addr));

-    sock_addr.sun_family = AF_UNIX;

-    snprintf(sock_addr.sun_path, UNIX_PATH_MAX, "/data/cam_socket%d", cam_id);

-    if((rc = connect(socket_fd, (struct sockaddr *) &sock_addr,

-      sizeof(sock_addr))) != 0) {

-      close(socket_fd);

-      socket_fd = -1;

-      CDBG_ERROR("%s: socket_fd=%d %s ", __func__, socket_fd, strerror(errno));

-    }

-

-    CDBG("%s: socket_fd=%d %s", __func__, socket_fd, sock_addr.sun_path);

-    return socket_fd;

-}

-

-/*===========================================================================

- * FUNCTION    - mm_camera_socket_close -

- *

- * DESCRIPTION:  close domain socket by its fd

- *==========================================================================*/

-void mm_camera_socket_close(int fd)

-{

-    if (fd > 0) {

-      close(fd);

-    }

-}

-

-/*===========================================================================

- * FUNCTION    - mm_camera_socket_sendmsg -

- *

- * DESCRIPTION:  send msg through domain socket

- *                         int fd: socket fd

- *                         mm_camera_sock_msg_packet_t *msg: pointer to msg to be sent over domain socket

- *                         int sendfd: file descriptors to be sent

- * return the total bytes of sent msg

- *==========================================================================*/

-int mm_camera_socket_sendmsg(

-  int fd,

-  void *msg,

-  uint32_t buf_size,

-  int sendfd)

-{

-    struct msghdr msgh;

-    struct iovec iov[1];

-    struct cmsghdr * cmsghp = NULL;

-    char control[CMSG_SPACE(sizeof(int))];

-

-    if (msg == NULL) {

-      CDBG("%s: msg is NULL", __func__);

-      return -1;

-    }

-    memset(&msgh, 0, sizeof(msgh));

-    msgh.msg_name = NULL;

-    msgh.msg_namelen = 0;

-

-    iov[0].iov_base = msg;

-    iov[0].iov_len = buf_size;

-    msgh.msg_iov = iov;

-    msgh.msg_iovlen = 1;

-    CDBG("%s: iov_len=%d", __func__, iov[0].iov_len);

-

-    msgh.msg_control = NULL;

-    msgh.msg_controllen = 0;

-

-    /* if sendfd is valid, we need to pass it through control msg */

-    if( sendfd > 0) {

-      msgh.msg_control = control;

-      msgh.msg_controllen = sizeof(control);

-      cmsghp = CMSG_FIRSTHDR(&msgh);

-      if (cmsghp != NULL) {

-        CDBG("%s: Got ctrl msg pointer", __func__);

-        cmsghp->cmsg_level = SOL_SOCKET;

-        cmsghp->cmsg_type = SCM_RIGHTS;

-        cmsghp->cmsg_len = CMSG_LEN(sizeof(int));

-        *((int *)CMSG_DATA(cmsghp)) = sendfd;

-        CDBG("%s: cmsg data=%d", __func__, *((int *) CMSG_DATA(cmsghp)));

-      } else {

-        CDBG("%s: ctrl msg NULL", __func__);

-        return -1;

-      }

-    }

-

-    return sendmsg(fd, &(msgh), 0);

-}

-

-/*===========================================================================

- * FUNCTION    - mm_camera_socket_recvmsg -

- *

- * DESCRIPTION:  receive msg from domain socket.

- *                         int fd: socket fd

- *                         void *msg: pointer to mm_camera_sock_msg_packet_t to hold incoming msg,

- *                                    need be allocated by the caller

- *                         uint32_t buf_size: the size of the buf that holds incoming msg

- *                         int *rcvdfd: pointer to hold recvd file descriptor if not NULL.

- * return the total bytes of received msg

- *==========================================================================*/

-int mm_camera_socket_recvmsg(

-  int fd,

-  void *msg,

-  uint32_t buf_size,

-  int *rcvdfd)

-{

-    struct msghdr msgh;

-    struct iovec iov[1];

-    struct cmsghdr *cmsghp = NULL;

-    char control[CMSG_SPACE(sizeof(int))];

-    int rcvd_fd = -1;

-    int rcvd_len = 0;

-

-    if ( (msg == NULL) || (buf_size <= 0) ) {

-      CDBG_ERROR(" %s: msg buf is NULL", __func__);

-      return -1;

-    }

-

-    memset(&msgh, 0, sizeof(msgh));

-    msgh.msg_name = NULL;

-    msgh.msg_namelen = 0;

-    msgh.msg_control = control;

-    msgh.msg_controllen = sizeof(control);

-

-    iov[0].iov_base = msg;

-    iov[0].iov_len = buf_size;

-    msgh.msg_iov = iov;

-    msgh.msg_iovlen = 1;

-

-    if ( (rcvd_len = recvmsg(fd, &(msgh), 0)) <= 0) {

-      CDBG_ERROR(" %s: recvmsg failed", __func__);

-      return rcvd_len;

-    }

-

-    CDBG("%s:  msg_ctrl %p len %d", __func__, msgh.msg_control, msgh.msg_controllen);

-

-    if( ((cmsghp = CMSG_FIRSTHDR(&msgh)) != NULL) &&

-        (cmsghp->cmsg_len == CMSG_LEN(sizeof(int))) ) {

-      if (cmsghp->cmsg_level == SOL_SOCKET &&

-        cmsghp->cmsg_type == SCM_RIGHTS) {

-        CDBG("%s:  CtrlMsg is valid", __func__);

-        rcvd_fd = *((int *) CMSG_DATA(cmsghp));

-        CDBG("%s:  Receieved fd=%d", __func__, rcvd_fd);

-      } else {

-        CDBG_ERROR("%s:  Unexpected Control Msg. Line=%d", __func__, __LINE__);

-      }

-    }

-

-    if (rcvdfd) {

-      *rcvdfd = rcvd_fd;

-    }

-

-    return rcvd_len;

-}

-

diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_stream.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_stream.c
deleted file mode 100755
index 9e48f2b..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_stream.c
+++ /dev/null
@@ -1,1672 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <time.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-#define MM_CAMERA_MAX_NUM_FRAMES     16
-
-/* internal function decalre */
-int32_t mm_stream_qbuf(mm_stream_t *my_obj,
-                       mm_camera_buf_def_t *buf);
-int32_t mm_stream_set_ext_mode(mm_stream_t * my_obj);
-int32_t mm_stream_set_fmt(mm_stream_t * my_obj);
-int32_t mm_stream_get_offset(mm_stream_t *my_obj);
-int32_t mm_stream_set_cid(mm_stream_t *my_obj,stream_cid_t *in_value);
-int32_t mm_stream_init_bufs(mm_stream_t * my_obj);
-int32_t mm_stream_deinit_bufs(mm_stream_t * my_obj);
-int32_t mm_stream_request_buf(mm_stream_t * my_obj);
-int32_t mm_stream_unreg_buf(mm_stream_t * my_obj);
-int32_t mm_stream_release(mm_stream_t *my_obj);
-int32_t mm_stream_get_crop(mm_stream_t *my_obj,
-                         mm_camera_rect_t *crop);
-int32_t mm_stream_get_cid(mm_stream_t *my_obj,
-                          stream_cid_t *out_value);
-int32_t mm_stream_set_parm_acquire(mm_stream_t *my_obj,
-                         void *value);
-int32_t mm_stream_get_parm_acquire(mm_stream_t *my_obj,
-                         void *value);
-int32_t mm_stream_set_parm_config(mm_stream_t *my_obj,
-                         void *value);
-int32_t mm_stream_get_parm_config(mm_stream_t *my_obj,
-                         void *value);
-int32_t mm_stream_set_parm_start(mm_stream_t *my_obj,
-                         void *value);
-int32_t mm_stream_get_parm_start(mm_stream_t *my_obj,
-                         void *value);
-int32_t mm_stream_streamon(mm_stream_t *my_obj);
-int32_t mm_stream_streamoff(mm_stream_t *my_obj);
-int32_t mm_stream_read_msm_frame(mm_stream_t * my_obj,
-                                 mm_camera_buf_info_t* buf_info);
-int32_t mm_stream_config(mm_stream_t *my_obj,
-                         mm_camera_stream_config_t *config);
-int32_t mm_stream_reg_buf(mm_stream_t * my_obj);
-int32_t mm_stream_buf_done(mm_stream_t * my_obj,
-                           mm_camera_buf_def_t *frame);
-
-
-/* state machine function declare */
-int32_t mm_stream_fsm_inited(mm_stream_t * my_obj,

-                             mm_stream_evt_type_t evt,
-                             void * in_val,
-                             void * out_val);
-int32_t mm_stream_fsm_acquired(mm_stream_t * my_obj,

-                               mm_stream_evt_type_t evt,
-                               void * in_val,
-                               void * out_val);
-int32_t mm_stream_fsm_cfg(mm_stream_t * my_obj,

-                          mm_stream_evt_type_t evt,
-                          void * in_val,
-                          void * out_val);
-int32_t mm_stream_fsm_buffed(mm_stream_t * my_obj,
-                             mm_stream_evt_type_t evt,
-                             void * in_val,
-                             void * out_val);
-int32_t mm_stream_fsm_reg(mm_stream_t * my_obj,

-                          mm_stream_evt_type_t evt,
-                          void * in_val,
-                          void * out_val);
-int32_t mm_stream_fsm_active_stream_on(mm_stream_t * my_obj,

-                                       mm_stream_evt_type_t evt,
-                                       void * in_val,
-                                       void * out_val);
-int32_t mm_stream_fsm_active_stream_off(mm_stream_t * my_obj,

-                                        mm_stream_evt_type_t evt,
-                                        void * in_val,
-                                        void * out_val);
-
-extern int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
-                                       cam_ctrl_type type,
-                                       uint32_t length,
-                                       void *value);
-
-static int get_stream_inst_handle(mm_stream_t *my_obj)
-{
-  int rc = 0;
-  uint32_t inst_handle;
-  struct msm_camera_v4l2_ioctl_t v4l2_ioctl;
-
-  v4l2_ioctl.id = MSM_V4L2_PID_INST_HANDLE;
-  v4l2_ioctl.ioctl_ptr = &inst_handle;
-  v4l2_ioctl.len = sizeof(inst_handle);
-  rc = ioctl(my_obj->fd, MSM_CAM_V4L2_IOCTL_PRIVATE_G_CTRL, &v4l2_ioctl);
-  if (rc) {
-    CDBG_ERROR("%s Error getting mctl pp inst handle", __func__);
-    return rc;
-  }
-
-  my_obj->inst_hdl = inst_handle;
-  CDBG("%s: X, inst_handle = 0x%x, my_handle = 0x%x, "
-       "image_mode = %d, fd = %d, state = %d, rc = %d",
-       __func__, my_obj->inst_hdl, my_obj->my_hdl,
-       my_obj->ext_image_mode, my_obj->fd, my_obj->state, rc);
-  return rc;
-}
-
-void mm_stream_handle_rcvd_buf(mm_stream_t *my_obj,
-                                  mm_camera_buf_info_t *buf_info)
-{
-    int32_t i;
-    uint8_t has_cb = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    /* enqueue to super buf thread */
-    if (my_obj->is_bundled) {
-        mm_camera_cmdcb_t* node = NULL;
-
-        /* send sem_post to wake up channel cmd thread to enqueue to super buffer */
-        node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-        if (NULL != node) {
-            memset(node, 0, sizeof(mm_camera_cmdcb_t));
-            node->cmd_type = MM_CAMERA_CMD_TYPE_DATA_CB;
-            memcpy(&node->u.buf, buf_info, sizeof(mm_camera_buf_info_t));
-
-            /* enqueue to cmd thread */
-            mm_camera_queue_enq(&(my_obj->ch_obj->cmd_thread.cmd_queue), node);
-
-            /* wake up cmd thread */
-            sem_post(&(my_obj->ch_obj->cmd_thread.cmd_sem));
-        } else {
-            CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
-        }
-    }
-
-    /* check if has CB */
-    for (i=0 ; i< MM_CAMERA_STREAM_BUF_CB_MAX; i++) {
-        if(NULL != my_obj->buf_cb[i].cb) {
-            has_cb = 1;
-        }
-    }
-    if(has_cb) {
-        mm_camera_cmdcb_t* node = NULL;
-
-        /* send sem_post to wake up cmd thread to dispatch dataCB */
-        node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
-        if (NULL != node) {
-            memset(node, 0, sizeof(mm_camera_cmdcb_t));
-            node->cmd_type = MM_CAMERA_CMD_TYPE_DATA_CB;
-            memcpy(&node->u.buf, buf_info, sizeof(mm_camera_buf_info_t));
-
-            /* enqueue to cmd thread */
-            mm_camera_queue_enq(&(my_obj->cmd_thread.cmd_queue), node);
-
-            /* wake up cmd thread */
-            sem_post(&(my_obj->cmd_thread.cmd_sem));
-        } else {
-            CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
-        }
-    }
-}
-
-static void mm_stream_data_notify(void* user_data)
-{
-    mm_stream_t *my_obj = (mm_stream_t*)user_data;
-    int32_t idx = -1, i, rc;
-    uint8_t has_cb = 0;
-    mm_camera_buf_info_t buf_info;
-
-    if (NULL == my_obj) {
-        return;
-    }
-
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-    if (MM_STREAM_STATE_ACTIVE_STREAM_ON != my_obj->state) {
-        /* this Cb will only received in active_stream_on state
-         * if not so, return here */
-        CDBG_ERROR("%s: ERROR!! Wrong state (%d) to receive data notify!",
-                   __func__, my_obj->state);
-        return;
-    }
-
-    memset(&buf_info, 0, sizeof(mm_camera_buf_info_t));
-
-    pthread_mutex_lock(&my_obj->buf_lock);
-    rc = mm_stream_read_msm_frame(my_obj, &buf_info);
-    if (rc != 0) {
-        pthread_mutex_unlock(&my_obj->buf_lock);
-        return;
-    }
-    idx = buf_info.buf->buf_idx;
-    /* update buffer location */
-    my_obj->buf_status[idx].in_kernel = 0;
-
-    /* update buf ref count */
-    if (my_obj->is_bundled) {
-        /* need to add into super buf since bundled, add ref count */
-        my_obj->buf_status[idx].buf_refcnt++;
-    }
-
-    for (i=0; i < MM_CAMERA_STREAM_BUF_CB_MAX; i++) {
-        if(NULL != my_obj->buf_cb[i].cb) {
-            /* for every CB, add ref count */
-            my_obj->buf_status[idx].buf_refcnt++;
-            has_cb = 1;
-        }
-    }
-    pthread_mutex_unlock(&my_obj->buf_lock);
-
-    mm_stream_handle_rcvd_buf(my_obj, &buf_info);
-}
-
-/* special function for dataCB registered at other stream */
-static void mm_stream_buf_notify(mm_camera_super_buf_t *super_buf,
-                                 void *user_data)
-{
-    mm_stream_t * my_obj = (mm_stream_t*)user_data;
-    mm_camera_buf_info_t buf_info;
-    int8_t i;
-    mm_camera_buf_def_t *buf = super_buf->bufs[0];
-
-    CDBG("%s : E",__func__);
-    if (my_obj == NULL) {
-        return;
-    }
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    if (MM_STREAM_STATE_ACTIVE_STREAM_OFF != my_obj->state) {
-        /* this CB will only received in active_stream_off state
-         * if not so, return here */
-        return;
-    }
-
-    /* 1) copy buf into local buf */
-    if (my_obj->buf_num <= 0) {
-        CDBG_ERROR("%s: Local buf is not allocated yet", __func__);
-        return;
-    }
-
-    my_obj->buf[my_obj->local_buf_idx].buf_idx = 0;
-    my_obj->buf[my_obj->local_buf_idx].stream_id = my_obj->my_hdl;
-    my_obj->buf[my_obj->local_buf_idx].frame_idx = buf->frame_idx;
-
-    memcpy(&my_obj->buf[my_obj->local_buf_idx].ts, &buf->ts, sizeof(buf->ts));
-
-    memcpy(my_obj->buf[my_obj->local_buf_idx].buffer, buf->buffer, buf->frame_len);
-
-    /* set flag to indicate buf be to sent out is from local */
-    my_obj->is_local_buf = 1;
-
-    /* 2) buf_done the buf from other stream */
-    mm_channel_qbuf(my_obj->ch_obj, buf);
-
-    /* 3) handle received buf */
-    memset(&buf_info, 0, sizeof(mm_camera_buf_info_t));
-    buf_info.frame_idx =my_obj->buf[my_obj->local_buf_idx].frame_idx;
-    buf_info.buf = &my_obj->buf[my_obj->local_buf_idx];
-    buf_info.stream_id = my_obj->my_hdl;
-
-    my_obj->local_buf_idx++;
-    if (my_obj->local_buf_idx >= my_obj->buf_num) {
-        my_obj->local_buf_idx = 0;
-    }
-    mm_stream_handle_rcvd_buf(my_obj, &buf_info);
-}
-
-static void mm_stream_dispatch_app_data(mm_camera_cmdcb_t *cmd_cb,
-                                        void* user_data)
-{
-    int i;
-    mm_stream_t * my_obj = (mm_stream_t *)user_data;
-    mm_camera_buf_info_t* buf_info = NULL;
-    mm_camera_super_buf_t super_buf;
-
-    if (NULL == my_obj) {
-        return;
-    }
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    if (MM_CAMERA_CMD_TYPE_DATA_CB != cmd_cb->cmd_type) {
-        CDBG_ERROR("%s: Wrong cmd_type (%d) for dataCB",
-                   __func__, cmd_cb->cmd_type);
-        return;
-    }
-
-    buf_info = &cmd_cb->u.buf;
-    memset(&super_buf, 0, sizeof(mm_camera_super_buf_t));
-    super_buf.num_bufs = 1;
-    super_buf.bufs[0] = buf_info->buf;
-    super_buf.camera_handle = my_obj->ch_obj->cam_obj->my_hdl;
-    super_buf.ch_id = my_obj->ch_obj->my_hdl;
-
-
-    pthread_mutex_lock(&my_obj->cb_lock);
-    for(i = 0; i < MM_CAMERA_STREAM_BUF_CB_MAX; i++) {
-        if(NULL != my_obj->buf_cb[i].cb) {
-            if (my_obj->buf_cb[i].cb_count != 0) {
-                /* if <0, means infinite CB
-                 * if >0, means CB for certain times
-                 * both case we need to call CB */
-                my_obj->buf_cb[i].cb(&super_buf,
-                                     my_obj->buf_cb[i].user_data);
-            }
-
-            /* if >0, reduce count by 1 every time we called CB until reaches 0
-             * when count reach 0, reset the buf_cb to have no CB */
-            if (my_obj->buf_cb[i].cb_count > 0) {
-                my_obj->buf_cb[i].cb_count--;
-                if (0 == my_obj->buf_cb[i].cb_count) {
-                    my_obj->buf_cb[i].cb = NULL;
-                    my_obj->buf_cb[i].user_data = NULL;
-                }
-            }
-        }
-    }
-    pthread_mutex_unlock(&my_obj->cb_lock);
-}
-
-/* state machine entry */
-int32_t mm_stream_fsm_fn(mm_stream_t *my_obj,
-                         mm_stream_evt_type_t evt,
-                         void * in_val,
-                         void * out_val)
-{
-    int32_t rc = -1;
-
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, event = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-    switch (my_obj->state) {
-    case MM_STREAM_STATE_NOTUSED:
-        CDBG("%s: Not handling evt in unused state", __func__);
-        break;
-    case MM_STREAM_STATE_INITED:
-        rc = mm_stream_fsm_inited(my_obj, evt, in_val, out_val);
-        break;
-    case MM_STREAM_STATE_ACQUIRED:
-        rc = mm_stream_fsm_acquired(my_obj, evt, in_val, out_val);
-        break;
-    case MM_STREAM_STATE_CFG:
-        rc = mm_stream_fsm_cfg(my_obj, evt, in_val, out_val);
-        break;
-    case MM_STREAM_STATE_BUFFED:
-        rc = mm_stream_fsm_buffed(my_obj, evt, in_val, out_val);
-        break;
-    case MM_STREAM_STATE_REG:
-        rc = mm_stream_fsm_reg(my_obj, evt, in_val, out_val);
-        break;
-    case MM_STREAM_STATE_ACTIVE_STREAM_ON:
-        rc = mm_stream_fsm_active_stream_on(my_obj, evt, in_val, out_val);
-        break;
-    case MM_STREAM_STATE_ACTIVE_STREAM_OFF:
-        rc = mm_stream_fsm_active_stream_off(my_obj, evt, in_val, out_val);
-        break;
-    default:
-        CDBG("%s: Not a valid state (%d)", __func__, my_obj->state);
-        break;
-    }
-    CDBG("%s : X rc =%d",__func__,rc);
-    return rc;
-}

-
-int32_t mm_stream_fsm_inited(mm_stream_t *my_obj,
-                             mm_stream_evt_type_t evt,
-                             void * in_val,
-                             void * out_val)
-{

-    int32_t rc = 0;
-    char dev_name[MM_CAMERA_DEV_NAME_LEN];
-
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, event = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-    switch(evt) {
-    case MM_STREAM_EVT_ACQUIRE:
-        if ((NULL == my_obj->ch_obj) || (NULL == my_obj->ch_obj->cam_obj)) {
-            CDBG_ERROR("%s: NULL channel or camera obj\n", __func__);
-            rc = -1;
-            break;
-        }
-

-        snprintf(dev_name, sizeof(dev_name), "/dev/%s",
-                 mm_camera_util_get_dev_name(my_obj->ch_obj->cam_obj->my_hdl));
-
-        my_obj->fd = open(dev_name, O_RDWR | O_NONBLOCK);
-        if (my_obj->fd <= 0) {
-            CDBG_ERROR("%s: open dev returned %d\n", __func__, my_obj->fd);
-            rc = -1;
-            break;
-        }

-        CDBG("%s: open dev fd = %d, ext_image_mode = %d, sensor_idx = %d\n",
-                 __func__, my_obj->fd, my_obj->ext_image_mode, my_obj->sensor_idx);
-        rc = mm_stream_set_ext_mode(my_obj);
-        if (0 == rc) {
-            my_obj->state = MM_STREAM_STATE_ACQUIRED;
-        } else {
-            /* failed setting ext_mode
-             * close fd */
-            if(my_obj->fd > 0) {
-                close(my_obj->fd);
-                my_obj->fd = -1;
-            }
-            break;
-        }
-        rc = get_stream_inst_handle(my_obj);
-        if(rc) {
-            if(my_obj->fd > 0) {
-                close(my_obj->fd);
-                my_obj->fd = -1;
-            }
-        }
-        break;
-    default:

-        CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
-                   __func__,evt,my_obj->state);

-        break;
-    }
-    return rc;
-}
-
-int32_t mm_stream_fsm_acquired(mm_stream_t *my_obj,
-                               mm_stream_evt_type_t evt,
-                               void * in_val,
-                               void * out_val)
-{
-    int32_t rc = 0;
-
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, event = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-    switch(evt) {
-    case MM_STREAM_EVT_SET_FMT:
-        {
-            mm_camera_stream_config_t *config =
-                (mm_camera_stream_config_t *)in_val;
-
-            rc = mm_stream_config(my_obj, config);
-
-            /* change state to configed */
-            my_obj->state = MM_STREAM_STATE_CFG;
-
-            break;
-        }
-    case MM_STREAM_EVT_RELEASE:
-        rc = mm_stream_release(my_obj);
-        /* change state to not used */
-         my_obj->state = MM_STREAM_STATE_NOTUSED;
-        break;
-    case MM_STREAM_EVT_SET_PARM:
-        rc = mm_stream_set_parm_acquire(my_obj, in_val);
-        break;
-    case MM_STREAM_EVT_GET_PARM:
-        rc = mm_stream_get_parm_acquire(my_obj,out_val);
-        break;
-    default:
-        CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
-                   __func__, evt, my_obj->state);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_fsm_cfg(mm_stream_t * my_obj,

-                          mm_stream_evt_type_t evt,
-                          void * in_val,
-                          void * out_val)
-{
-    int32_t rc = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, event = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-    switch(evt) {
-    case MM_STREAM_EVT_SET_FMT:
-        {
-            mm_camera_stream_config_t *config =
-                (mm_camera_stream_config_t *)in_val;
-
-            rc = mm_stream_config(my_obj, config);
-
-            /* change state to configed */
-            my_obj->state = MM_STREAM_STATE_CFG;
-
-            break;
-        }
-    case MM_STREAM_EVT_RELEASE:
-        rc = mm_stream_release(my_obj);
-        my_obj->state = MM_STREAM_STATE_NOTUSED;
-        break;
-    case MM_STREAM_EVT_SET_PARM:
-        rc = mm_stream_set_parm_config(my_obj, in_val);
-        break;
-    case MM_STREAM_EVT_GET_PARM:
-        rc = mm_stream_get_parm_config(my_obj, out_val);
-        break;
-    case MM_STREAM_EVT_GET_BUF:
-        rc = mm_stream_init_bufs(my_obj);
-        /* change state to buff allocated */
-        if(0 == rc) {
-            my_obj->state = MM_STREAM_STATE_BUFFED;
-        }
-        break;
-    default:
-        CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
-                   __func__, evt, my_obj->state);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_fsm_buffed(mm_stream_t * my_obj,
-                             mm_stream_evt_type_t evt,
-                             void * in_val,
-                             void * out_val)
-{
-    int32_t rc = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, event = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-    switch(evt) {
-    case MM_STREAM_EVT_PUT_BUF:
-        rc = mm_stream_deinit_bufs(my_obj);
-        /* change state to configed */
-        if(0 == rc) {
-            my_obj->state = MM_STREAM_STATE_CFG;
-        }
-        break;
-    case MM_STREAM_EVT_REG_BUF:
-        rc = mm_stream_reg_buf(my_obj);
-        /* change state to regged */
-        if(0 == rc) {
-            my_obj->state = MM_STREAM_STATE_REG;
-        }
-        break;
-    case MM_STREAM_EVT_SET_PARM:
-        rc = mm_stream_set_parm_config(my_obj, in_val);
-        break;
-    case MM_STREAM_EVT_GET_PARM:
-        rc = mm_stream_get_parm_config(my_obj, out_val);
-        break;
-    default:
-        CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
-                   __func__, evt, my_obj->state);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_fsm_reg(mm_stream_t * my_obj,

-                          mm_stream_evt_type_t evt,
-                          void * in_val,
-                          void * out_val)
-{
-    int32_t rc = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, event = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-
-    switch(evt) {
-    case MM_STREAM_EVT_UNREG_BUF:
-        rc = mm_stream_unreg_buf(my_obj);
-
-        /* change state to buffed */
-        my_obj->state = MM_STREAM_STATE_BUFFED;
-        break;
-    case MM_STREAM_EVT_START:
-        {
-            /* launch cmd thread if CB is not null */
-            if (NULL != my_obj->buf_cb) {
-                mm_camera_cmd_thread_launch(&my_obj->cmd_thread,
-                                mm_stream_dispatch_app_data,
-                                (void *)my_obj);
-
-            }
-
-            if(my_obj->need_stream_on) {
-                rc = mm_stream_streamon(my_obj);
-                if (0 != rc) {
-                    /* failed stream on, need to release cmd thread if it's launched */
-                    if (NULL != my_obj->buf_cb) {
-                        mm_camera_cmd_thread_release(&my_obj->cmd_thread);
-
-                    }
-                    break;
-                }
-                my_obj->state = MM_STREAM_STATE_ACTIVE_STREAM_ON;
-            } else {
-                /* register CB at video fd */
-                CDBG("%s : Video Size snapshot Enabled",__func__);
-                mm_stream_data_cb_t cb;
-                memset(&cb, 0, sizeof(mm_stream_data_cb_t));
-                cb.cb_count = my_obj->num_stream_cb_times; /* reigstration cb times */
-                if (cb.cb_count == 0) {
-                    cb.cb_count = 1;
-                }
-                cb.user_data = (void*)my_obj;
-                cb.cb = mm_stream_buf_notify;
-                rc = mm_channel_reg_stream_cb(my_obj->ch_obj, &cb,
-                                              MSM_V4L2_EXT_CAPTURE_MODE_VIDEO,
-                                              my_obj->sensor_idx);
-                my_obj->state = MM_STREAM_STATE_ACTIVE_STREAM_OFF;
-            }
-        }
-        break;
-    case MM_STREAM_EVT_SET_PARM:
-        rc = mm_stream_set_parm_config(my_obj, in_val);
-        break;
-    case MM_STREAM_EVT_GET_PARM:
-        rc = mm_stream_get_parm_config(my_obj, out_val);
-        break;
-    default:
-        CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
-                   __func__, evt, my_obj->state);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_fsm_active_stream_on(mm_stream_t * my_obj,

-                                              mm_stream_evt_type_t evt,
-                                              void * in_val,
-                                              void * out_val)
-{
-    int32_t rc = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, event = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-    switch(evt) {
-    case MM_STREAM_EVT_QBUF:
-        rc = mm_stream_buf_done(my_obj, (mm_camera_buf_def_t *)in_val);
-        break;
-    case MM_STREAM_EVT_STOP:
-        {
-            rc = mm_stream_streamoff(my_obj);
-            if (NULL != my_obj->buf_cb) {
-                mm_camera_cmd_thread_release(&my_obj->cmd_thread);
-
-            }
-            my_obj->state = MM_STREAM_STATE_REG;
-        }
-        break;
-    case MM_STREAM_EVT_SET_PARM:
-        rc = mm_stream_set_parm_start(my_obj, in_val);
-        break;
-    case MM_STREAM_EVT_GET_PARM:
-        rc = mm_stream_get_parm_start(my_obj, out_val);
-        break;
-    default:
-        CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
-                   __func__, evt, my_obj->state);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_fsm_active_stream_off(mm_stream_t * my_obj,

-                                               mm_stream_evt_type_t evt,
-                                               void * in_val,
-                                               void * out_val)
-{
-    int32_t rc = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, event = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-    switch(evt) {
-    case MM_STREAM_EVT_QBUF:
-        rc = mm_stream_buf_done(my_obj, (mm_camera_buf_def_t *)in_val);
-        break;
-    case MM_STREAM_EVT_STOP:
-        {
-            if (NULL != my_obj->buf_cb) {
-                rc = mm_camera_cmd_thread_release(&my_obj->cmd_thread);
-
-            }
-            my_obj->state = MM_STREAM_STATE_REG;
-        }
-        break;
-   case MM_STREAM_EVT_SET_PARM:
-        rc = mm_stream_set_parm_config(my_obj, in_val);
-        break;
-    case MM_STREAM_EVT_GET_PARM:
-        rc = mm_stream_get_parm_config(my_obj, out_val);
-        break;
-    default:
-        CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
-                   __func__, evt, my_obj->state);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_config(mm_stream_t *my_obj,
-                         mm_camera_stream_config_t *config)
-{
-    int32_t rc = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-    memcpy(&my_obj->fmt, &config->fmt, sizeof(mm_camera_image_fmt_t));
-    my_obj->hal_requested_num_bufs = config->num_of_bufs;
-    my_obj->need_stream_on = config->need_stream_on;
-    my_obj->num_stream_cb_times = config->num_stream_cb_times;
-
-    rc = mm_stream_get_offset(my_obj);
-    if(rc != 0) {
-        CDBG_ERROR("%s: Error in offset query",__func__);
-        return rc;
-    }
-    /* write back width and height to config in case mctl has modified the value */
-    config->fmt.width = my_obj->fmt.width;
-    config->fmt.height = my_obj->fmt.height;
-    if(my_obj->need_stream_on) {
-        /* only send fmt to backend if we need streamon */
-        rc = mm_stream_set_fmt(my_obj);
-    }
-    return rc;
-}
-
-int32_t mm_stream_release(mm_stream_t *my_obj)
-{
-    int32_t rc;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    /* close fd */
-    if(my_obj->fd > 0)
-    {
-        close(my_obj->fd);
-    }
-
-    /* destroy mutex */
-    pthread_mutex_destroy(&my_obj->buf_lock);
-    pthread_mutex_destroy(&my_obj->cb_lock);
-
-    /* reset stream obj */
-    memset(my_obj, 0, sizeof(mm_stream_t));
-    my_obj->fd = -1;
-
-    return 0;
-}
-
-int32_t mm_stream_streamon(mm_stream_t *my_obj)
-{
-    int32_t rc;
-    enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-    /* Add fd to data poll thread */
-    rc = mm_camera_poll_thread_add_poll_fd(&my_obj->ch_obj->poll_thread[0],
-                                           my_obj->my_hdl,
-                                           my_obj->fd,
-                                           mm_stream_data_notify,
-                                           (void*)my_obj);
-    if (rc < 0) {
-        return rc;
-    }
-    rc = ioctl(my_obj->fd, VIDIOC_STREAMON, &buf_type);
-    if (rc < 0) {
-        CDBG_ERROR("%s: ioctl VIDIOC_STREAMON failed: rc=%d\n",
-                   __func__, rc);
-        /* remove fd from data poll thread in case of failure */
-        mm_camera_poll_thread_del_poll_fd(&my_obj->ch_obj->poll_thread[0], my_obj->my_hdl);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_streamoff(mm_stream_t *my_obj)
-{
-    int32_t rc;
-    enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    /* step1: remove fd from data poll thread */
-    mm_camera_poll_thread_del_poll_fd(&my_obj->ch_obj->poll_thread[0], my_obj->my_hdl);
-
-    /* step2: stream off */
-    rc = ioctl(my_obj->fd, VIDIOC_STREAMOFF, &buf_type);
-    if (rc < 0) {
-        CDBG_ERROR("%s: STREAMOFF failed: %s\n",
-                __func__, strerror(errno));
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-static uint32_t mm_stream_util_get_v4l2_fmt(cam_format_t fmt,
-                                            uint8_t *num_planes)
-{
-    uint32_t val;
-    switch(fmt) {
-    case CAMERA_YUV_420_NV12:
-        val = V4L2_PIX_FMT_NV12;
-        *num_planes = 2;
-        break;
-    case CAMERA_YUV_420_NV21:
-        val = V4L2_PIX_FMT_NV21;
-        *num_planes = 2;
-        break;
-    case CAMERA_BAYER_SBGGR10:
-    case CAMERA_RDI:
-        val= V4L2_PIX_FMT_SBGGR10;
-        *num_planes = 1;
-        break;
-    case CAMERA_YUV_422_NV61:
-        val= V4L2_PIX_FMT_NV61;
-        *num_planes = 2;
-        break;
-    case CAMERA_SAEC:
-        val = V4L2_PIX_FMT_STATS_AE;
-        *num_planes = 1;
-        break;
-   case CAMERA_SAWB:
-        val = V4L2_PIX_FMT_STATS_AWB;
-        *num_planes = 1;
-        break;
-   case CAMERA_SAFC:
-        val = V4L2_PIX_FMT_STATS_AF;
-        *num_planes = 1;
-        break;
-   case CAMERA_SHST:
-        val = V4L2_PIX_FMT_STATS_IHST;
-        *num_planes = 1;
-        break;
-    case CAMERA_YUV_422_YUYV:
-        val= V4L2_PIX_FMT_YUYV;
-        *num_planes = 1;
-        break;
-    case CAMERA_YUV_420_YV12:
-        val= V4L2_PIX_FMT_NV12;
-        *num_planes = 3;
-        break;
-    default:
-        val = 0;
-        *num_planes = 0;
-        CDBG_ERROR("%s: Unknown fmt=%d", __func__, fmt);
-        break;
-    }
-    CDBG("%s: fmt=%d, val =%d, num_planes=%d", __func__, fmt, val , *num_planes);
-    return val;
-}
-
-int32_t mm_stream_read_msm_frame(mm_stream_t * my_obj,
-                                 mm_camera_buf_info_t* buf_info)
-{
-    int32_t idx = -1, rc = 0;
-    struct v4l2_buffer vb;
-    struct v4l2_plane planes[VIDEO_MAX_PLANES];
-    uint32_t i = 0;
-    uint8_t num_planes = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    mm_stream_util_get_v4l2_fmt(my_obj->fmt.fmt,
-                                &num_planes);
-
-    memset(&vb,  0,  sizeof(vb));
-    vb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    vb.memory = V4L2_MEMORY_USERPTR;
-    vb.m.planes = &planes[0];
-    vb.length = num_planes;
-
-    rc = ioctl(my_obj->fd, VIDIOC_DQBUF, &vb);
-    if (rc < 0) {
-        CDBG_ERROR("%s: VIDIOC_DQBUF ioctl call failed (rc=%d)\n",
-                   __func__, rc);
-    } else {
-        int8_t idx = vb.index;
-        buf_info->buf = &my_obj->buf[idx];
-        buf_info->frame_idx = vb.sequence;
-        buf_info->stream_id = my_obj->my_hdl;
-
-        buf_info->buf->stream_id = my_obj->my_hdl;
-        buf_info->buf->buf_idx = idx;
-        buf_info->buf->frame_idx = vb.sequence;
-        buf_info->buf->ts.tv_sec  = vb.timestamp.tv_sec;
-        buf_info->buf->ts.tv_nsec = vb.timestamp.tv_usec * 1000;
-
-        for(i = 0; i < vb.length; i++) {
-            CDBG("%s plane %d addr offset: %d data offset:%d\n",
-                 __func__, i, vb.m.planes[i].reserved[0],
-                 vb.m.planes[i].data_offset);
-            buf_info->buf->planes[i].reserved[0] =
-                vb.m.planes[i].reserved[0];
-            buf_info->buf->planes[i].data_offset =
-                vb.m.planes[i].data_offset;
-        }
-
-
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_get_crop(mm_stream_t *my_obj,
-                           mm_camera_rect_t *crop)
-{
-    struct v4l2_crop crop_info;
-    int32_t rc = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    memset(&crop_info, 0, sizeof(crop_info));
-    crop_info.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    rc = ioctl(my_obj->fd, VIDIOC_G_CROP, &crop_info);
-    if (0 == rc) {
-        crop->left = crop_info.c.left;
-        crop->top = crop_info.c.top;
-        crop->width = crop_info.c.width;
-        crop->height = crop_info.c.height;
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_set_parm_acquire(mm_stream_t *my_obj,
-                         void *in_value)
-{
-    int32_t rc = 0;
-    mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)in_value;
-    mm_camera_stream_parm_t parm_type = payload->parm_type;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, parm_type = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, parm_type);
-
-    switch(parm_type) {
-    case MM_CAMERA_STREAM_CID:{
-            stream_cid_t *value = (stream_cid_t *)in_value;
-            mm_stream_set_cid(my_obj,value);
-            break;
-        }
-        default:
-            CDBG_ERROR("%s : Parm -%d set is not supported here",__func__,(int)parm_type);
-            break;
-    }
-    return rc;
-}
-int32_t mm_stream_get_parm_acquire(mm_stream_t *my_obj,
-                         void *out_value)
-{
-    int32_t rc = 0;
-    mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)out_value;
-    mm_camera_stream_parm_t parm_type = payload->parm_type;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, parm_type = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, parm_type);
-
-    switch(parm_type) {
-    case MM_CAMERA_STREAM_CID:{
-            stream_cid_t *value = (stream_cid_t *)out_value;
-            rc = mm_stream_get_cid(my_obj,value);
-            break;
-        }
-        case MM_CAMERA_STREAM_CROP:{
-            mm_camera_rect_t *crop = (mm_camera_rect_t *)out_value;
-            rc = mm_stream_get_crop(my_obj, crop);
-            break;
-        }
-        default:
-            CDBG_ERROR("%s : Parm -%d get is not supported here",__func__,(int)parm_type);
-            break;
-    }
-    return rc;
-}
-
-int32_t mm_stream_set_parm_config(mm_stream_t *my_obj,
-                         void *in_value)
-{
-    int32_t rc = 0;
-    mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)in_value;
-    mm_camera_stream_parm_t parm_type = payload->parm_type;
-    void *value = payload->value;
-
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, parm_type = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, parm_type);
-    switch(parm_type) {
-        default:
-            CDBG_ERROR("%s : Parm -%d set is not supported here",__func__,(int)parm_type);
-            break;
-    }
-    return rc;
-}
-int32_t mm_stream_get_parm_config(mm_stream_t *my_obj,
-                         void *out_value)
-{
-    int32_t rc = 0;
-    mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)out_value;
-
-    if(payload == NULL) {
-        CDBG_ERROR("%s : Invalid Argument",__func__);
-        return -1;
-    }
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-     "image_mode = %d, fd = %d, state = %d, parm_type = %d",
-     __func__, my_obj->inst_hdl, my_obj->my_hdl,
-     my_obj->ext_image_mode, my_obj->fd, my_obj->state, (int)payload->parm_type);
-    switch(payload->parm_type) {
-        case MM_CAMERA_STREAM_OFFSET:
-            memcpy(payload->value,(void *)&my_obj->frame_offset,sizeof(mm_camera_frame_len_offset));
-            break;
-        case MM_CAMERA_STREAM_CROP:{
-            mm_camera_rect_t *crop = (mm_camera_rect_t *)payload->value;
-            rc = mm_stream_get_crop(my_obj, crop);
-            break;
-        }
-        default:
-            CDBG_ERROR("%s : Parm -%d get is not supported here",__func__,(int)payload->parm_type);
-            break;
-    }
-    return rc;
-}
-
-int32_t mm_stream_set_parm_start(mm_stream_t *my_obj,
-                         void *in_value)
-{
-    int32_t rc = 0;
-    mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)in_value;
-    mm_camera_stream_parm_t parm_type = payload->parm_type;
-    void *value = payload->value;
-
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d, parm_type = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state, parm_type);
-    switch(parm_type) {
-        default:
-            CDBG_ERROR("%s : Parm -%d set is not supported here",__func__,(int)parm_type);
-            break;
-    }
-    return rc;
-}
-int32_t mm_stream_get_parm_start(mm_stream_t *my_obj,
-                         void *out_value)
-{
-    int32_t rc = 0;
-    mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)out_value;
-
-    if(payload == NULL) {
-        CDBG_ERROR("%s : Invalid Argument",__func__);
-        return -1;
-    }
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-     "image_mode = %d, fd = %d, state = %d, parm_type = %d",
-     __func__, my_obj->inst_hdl, my_obj->my_hdl,
-     my_obj->ext_image_mode, my_obj->fd, my_obj->state, (int)payload->parm_type);
-    switch(payload->parm_type) {
-        case MM_CAMERA_STREAM_OFFSET:
-            memcpy(payload->value,(void *)&my_obj->frame_offset,sizeof(mm_camera_frame_len_offset));
-            break;
-        case MM_CAMERA_STREAM_CROP:{
-            mm_camera_rect_t *crop = (mm_camera_rect_t *)payload->value;
-            rc = mm_stream_get_crop(my_obj, crop);
-            break;
-        }
-        default:
-            CDBG_ERROR("%s : Parm -%d get is not supported here",__func__,(int)payload->parm_type);
-            break;
-    }
-    return rc;
-}
-int32_t mm_stream_set_ext_mode(mm_stream_t * my_obj)
-{
-    int32_t rc = 0;
-    struct v4l2_streamparm s_parm;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    s_parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    s_parm.parm.capture.extendedmode = my_obj->ext_image_mode;
-
-    rc = ioctl(my_obj->fd, VIDIOC_S_PARM, &s_parm);
-        CDBG("%s:stream fd=%d, rc=%d, extended_mode=%d\n",
-                 __func__, my_obj->fd, rc,
-                 s_parm.parm.capture.extendedmode);
-    return rc;
-}
-
-int32_t mm_stream_qbuf(mm_stream_t *my_obj, mm_camera_buf_def_t *buf)
-{
-    int32_t i, rc = 0;
-    int *ret;
-    struct v4l2_buffer buffer;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    memset(&buffer, 0, sizeof(buffer));
-    buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    buffer.memory = V4L2_MEMORY_USERPTR;
-    buffer.index = buf->buf_idx;
-    buffer.m.planes = &buf->planes[0];
-    buffer.length = buf->num_planes;
-
-    CDBG("%s:stream_hdl=%d,fd=%d,frame idx=%d,num_planes = %d\n", __func__,
-         buf->stream_id, buf->fd, buffer.index, buffer.length);
-
-    rc = ioctl(my_obj->fd, VIDIOC_QBUF, &buffer);
-    CDBG("%s: qbuf idx:%d, rc:%d", __func__, buffer.index, rc);
-    return rc;
-}
-
-/* This function let kernel know amount of buffers will be registered */
-int32_t mm_stream_request_buf(mm_stream_t * my_obj)
-{
-    int32_t rc = 0;
-    uint8_t i,reg = 0;
-    struct v4l2_requestbuffers bufreq;
-    uint8_t buf_num = my_obj->buf_num;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    if(buf_num > MM_CAMERA_MAX_NUM_FRAMES) {
-        CDBG_ERROR("%s: buf num %d > max limit %d\n",
-                 __func__, buf_num, MM_CAMERA_MAX_NUM_FRAMES);
-        return -1;
-    }
-    pthread_mutex_lock(&my_obj->buf_lock);
-    for(i = 0; i < buf_num; i++){
-        if (my_obj->buf_status[i].initial_reg_flag){
-            reg = 1;
-            break;
-        }
-    }
-    pthread_mutex_unlock(&my_obj->buf_lock);
-    if(!reg) {
-        //No need to register a buffer
-        CDBG_ERROR("No Need to register this buffer");
-        return rc;
-    }
-    memset(&bufreq, 0, sizeof(bufreq));
-    bufreq.count = buf_num;
-    bufreq.type  = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    bufreq.memory = V4L2_MEMORY_USERPTR;
-    rc = ioctl(my_obj->fd, VIDIOC_REQBUFS, &bufreq);
-    if (rc < 0) {
-      CDBG_ERROR("%s: fd=%d, ioctl VIDIOC_REQBUFS failed: rc=%d\n",
-           __func__, my_obj->fd, rc);
-    }
-    CDBG("%s :X rc = %d",__func__,rc);
-    return rc;
-}
-
-int32_t mm_stream_init_bufs(mm_stream_t * my_obj)
-{
-    int32_t i, rc = 0, j;
-    int image_type;
-    mm_camear_mem_vtbl_t *mem_vtbl = NULL;
-    mm_camera_frame_len_offset frame_offset;
-    uint8_t *reg_flags = NULL;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    /* deinit buf if it's not NULL*/
-    if (NULL != my_obj->buf) {
-        mm_stream_deinit_bufs(my_obj);
-    }
-
-    my_obj->buf_num = my_obj->hal_requested_num_bufs;
-    if (mm_camera_util_get_pp_mask(my_obj->ch_obj->cam_obj) > 0) {
-        /* reserve extra one buf for pp */
-        my_obj->buf_num++;
-    }
-
-    my_obj->buf =
-        (mm_camera_buf_def_t*)malloc(sizeof(mm_camera_buf_def_t) * my_obj->buf_num);
-    my_obj->buf_status =
-        (mm_stream_buf_status_t*)malloc(sizeof(mm_stream_buf_status_t) * my_obj->buf_num);
-    reg_flags = (uint8_t *)malloc(sizeof(uint8_t) * my_obj->buf_num);
-
-    if (NULL == my_obj->buf ||
-        NULL == my_obj->buf_status ||
-        NULL == reg_flags) {
-        CDBG_ERROR("%s: No memory for buf", __func__);
-        rc = -1;
-        goto error_malloc;
-    }
-
-    memset(my_obj->buf, 0, sizeof(mm_camera_buf_def_t) * my_obj->buf_num);
-    memset(my_obj->buf_status, 0, sizeof(mm_stream_buf_status_t) * my_obj->buf_num);
-    memset(reg_flags, 0, sizeof(uint8_t) * my_obj->buf_num);
-
-    mem_vtbl = my_obj->ch_obj->cam_obj->mem_vtbl;
-    rc = mem_vtbl->get_buf(my_obj->ch_obj->cam_obj->my_hdl,
-                           my_obj->ch_obj->my_hdl,
-                           my_obj->my_hdl,
-                           mem_vtbl->user_data,
-                           &my_obj->frame_offset,
-                           my_obj->buf_num,
-                           reg_flags,
-                           my_obj->buf);
-
-    if (0 != rc) {
-        CDBG_ERROR("%s: Error get buf, rc = %d\n", __func__, rc);
-        goto error_malloc;
-    }
-
-    for (i=0; i < my_obj->buf_num; i++) {
-        my_obj->buf_status[i].initial_reg_flag = reg_flags[i];
-        my_obj->buf[i].stream_id = my_obj->my_hdl;
-    }
-
-    free(reg_flags);
-    reg_flags = NULL;
-
-    for (i=0; i < my_obj->buf_num; i++) {
-        if (my_obj->buf[i].fd > 0) {
-            if(0 >= (rc = mm_camera_map_buf(my_obj->ch_obj->cam_obj,
-                          my_obj->ext_image_mode,
-                          i,
-                          my_obj->buf[i].fd,
-                          my_obj->buf[i].frame_len)))
-            {
-                CDBG_ERROR("%s: Error mapping buf (rc = %d)", __func__, rc);
-                goto error_map;
-            }
-        } else {
-            CDBG_ERROR("%s: Invalid fd for buf idx (%d)", __func__, i);
-        }
-    }
-
-    return 0;
-
-error_map:
-    /* error, unmapping previously mapped bufs */
-    for (j=0; j<i; j++) {
-        if (my_obj->buf[j].fd > 0) {
-            mm_camera_unmap_buf(my_obj->ch_obj->cam_obj,
-                                my_obj->ext_image_mode,
-                                j);
-        }
-    }
-
-    /* put buf back */
-    mem_vtbl->put_buf(my_obj->ch_obj->cam_obj->my_hdl,
-                      my_obj->ch_obj->my_hdl,
-                      my_obj->my_hdl,
-                      mem_vtbl->user_data,
-                      my_obj->buf_num,
-                      my_obj->buf);
-
-error_malloc:
-    if (NULL != my_obj->buf) {
-        free(my_obj->buf);
-        my_obj->buf = NULL;
-    }
-    if (NULL != my_obj->buf_status) {
-        free(my_obj->buf_status);
-        my_obj->buf_status = NULL;
-    }
-    if (NULL != reg_flags) {
-        free(reg_flags);
-        reg_flags = NULL;
-    }
-
-    return rc;
-}
-
-/* return buffers to surface or release buffers allocated */
-int32_t mm_stream_deinit_bufs(mm_stream_t * my_obj)
-{
-    int32_t rc = 0, i;
-    mm_camear_mem_vtbl_t *mem_vtbl = NULL;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    if (NULL == my_obj->buf) {
-        CDBG("%s: Buf is NULL, no need to deinit", __func__);
-        return rc;
-    }
-
-    /* IOMMU unmapping */
-    for (i=0; i<my_obj->buf_num; i++) {
-        if (my_obj->buf[i].fd > 0) {
-            rc = mm_camera_unmap_buf(my_obj->ch_obj->cam_obj,
-                                     my_obj->ext_image_mode,
-                                     i);
-            if (rc < 0 ) {
-                CDBG_ERROR("%s: Error unmapping bufs at idx(%d) rc=%d",
-                           __func__, i, rc);
-            }
-        }
-    }
-
-    /* release bufs */
-    mem_vtbl = my_obj->ch_obj->cam_obj->mem_vtbl;
-    if (NULL != mem_vtbl) {
-        rc = mem_vtbl->put_buf(my_obj->ch_obj->cam_obj->my_hdl,
-                          my_obj->ch_obj->my_hdl,
-                          my_obj->my_hdl,
-                          mem_vtbl->user_data,
-                          my_obj->buf_num,
-                          my_obj->buf);
-    } else {
-        CDBG_ERROR("%s: mem table is NULL, cannot release buf", __func__);
-        rc = -1;
-    }
-    free(my_obj->buf);
-    my_obj->buf = NULL;
-    free(my_obj->buf_status);
-    my_obj->buf_status = NULL;
-
-    return rc;
-}
-
-int32_t mm_stream_reg_buf(mm_stream_t * my_obj)
-{
-    int32_t rc = 0;
-    uint8_t i;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    rc = mm_stream_request_buf(my_obj);
-    if (rc != 0) {
-        return rc;
-    }
-
-    pthread_mutex_lock(&my_obj->buf_lock);
-    for(i = 0; i < my_obj->buf_num; i++){
-        my_obj->buf[i].buf_idx = i;
-
-        /* check if need to qbuf initially */
-        if (my_obj->buf_status[i].initial_reg_flag) {
-            rc = mm_stream_qbuf(my_obj, &my_obj->buf[i]);
-            if (rc != 0) {
-                CDBG_ERROR("%s: VIDIOC_QBUF rc = %d\n", __func__, rc);
-                break;
-            }
-            my_obj->buf_status[i].buf_refcnt = 0;
-            my_obj->buf_status[i].in_kernel = 1;
-        } else {
-            /* the buf is held by upper layer, will not queue into kernel.
-             * add buf reference count */
-            my_obj->buf_status[i].buf_refcnt = 1;
-            my_obj->buf_status[i].in_kernel = 0;
-        }
-    }
-
-    pthread_mutex_unlock(&my_obj->buf_lock);
-    return rc;
-}
-
-int32_t mm_stream_unreg_buf(mm_stream_t * my_obj)
-{
-    struct v4l2_requestbuffers bufreq;
-    int32_t i, rc = 0,reg = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    pthread_mutex_lock(&my_obj->buf_lock);
-    if (NULL != my_obj->buf_status) {
-        for(i = 0; i < my_obj->buf_num; i++){
-            if (my_obj->buf_status[i].initial_reg_flag){
-                reg = 1;
-                break;
-            }
-        }
-    }
-    pthread_mutex_unlock(&my_obj->buf_lock);
-    if(!reg) {
-        //No need to unregister a buffer
-        goto end;
-    }
-    bufreq.count = 0;
-    bufreq.type  = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    bufreq.memory = V4L2_MEMORY_USERPTR;
-    rc = ioctl(my_obj->fd, VIDIOC_REQBUFS, &bufreq);
-    if (rc < 0) {
-        CDBG_ERROR("%s: fd=%d, VIDIOC_REQBUFS failed, rc=%d\n",
-              __func__, my_obj->fd, rc);
-    }
-
-end:
-    /* reset buf reference count */
-    pthread_mutex_lock(&my_obj->buf_lock);
-    if (NULL != my_obj->buf_status) {
-        for(i = 0; i < my_obj->buf_num; i++){
-            my_obj->buf_status[i].buf_refcnt = 0;
-            my_obj->buf_status[i].in_kernel = 0;
-        }
-    }
-    pthread_mutex_unlock(&my_obj->buf_lock);
-
-    return rc;
-}
-
-int32_t mm_stream_set_fmt(mm_stream_t *my_obj)
-{
-    int32_t rc = 0;
-    struct v4l2_format fmt;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    if(my_obj->fmt.width == 0 || my_obj->fmt.height == 0) {
-        CDBG_ERROR("%s:invalid input[w=%d,h=%d,fmt=%d]\n",
-                 __func__, my_obj->fmt.width, my_obj->fmt.height, my_obj->fmt.fmt);
-        return -1;
-    }
-
-    memset(&fmt, 0, sizeof(fmt));
-    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    fmt.fmt.pix_mp.width = my_obj->fmt.width;
-    fmt.fmt.pix_mp.height= my_obj->fmt.height;
-    fmt.fmt.pix_mp.field = V4L2_FIELD_NONE;
-    fmt.fmt.pix_mp.pixelformat =
-            mm_stream_util_get_v4l2_fmt(my_obj->fmt.fmt,
-                                      &(fmt.fmt.pix_mp.num_planes));
-    rc = ioctl(my_obj->fd, VIDIOC_S_FMT, &fmt);
-    CDBG("%s:fd=%d, ext_image_mode=%d, rc=%d, fmt.fmt.pix_mp.pixelformat : 0x%x\n",
-       __func__, my_obj->fd, my_obj->ext_image_mode, rc,
-       fmt.fmt.pix_mp.pixelformat);
-    return rc;
-}
-
-int32_t mm_stream_get_offset(mm_stream_t *my_obj)
-{
-    int32_t rc = 0;
-    cam_frame_resolution_t frame_offset;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    memset(&my_obj->frame_offset,0,sizeof(mm_camera_frame_len_offset));
-
-    frame_offset.format = my_obj->fmt.fmt;
-    frame_offset.rotation = my_obj->fmt.rotation;
-    frame_offset.width = my_obj->fmt.width;
-    frame_offset.height = my_obj->fmt.height;
-    frame_offset.image_mode = my_obj->ext_image_mode;
-    if (!my_obj->need_stream_on &&
-        my_obj->ext_image_mode == MSM_V4L2_EXT_CAPTURE_MODE_MAIN) {
-        /* in case of video-sized snapshot,
-         * image_mode should be video when querying frame offset*/
-        frame_offset.image_mode = MSM_V4L2_EXT_CAPTURE_MODE_VIDEO;
-    }
-
-    switch (frame_offset.image_mode) {
-    case MSM_V4L2_EXT_CAPTURE_MODE_PREVIEW:
-        if (CAMERA_YUV_420_YV12 == frame_offset.format) {
-            frame_offset.padding_format = CAMERA_PAD_TO_2K;
-        } else {
-            frame_offset.padding_format = CAMERA_PAD_TO_WORD;
-        }
-        break;
-    case MSM_V4L2_EXT_CAPTURE_MODE_MAIN:
-    case MSM_V4L2_EXT_CAPTURE_MODE_RAW:
-    case MSM_V4L2_EXT_CAPTURE_MODE_THUMBNAIL:
-    case MSM_V4L2_EXT_CAPTURE_MODE_RDI:
-        frame_offset.padding_format = CAMERA_PAD_TO_WORD;
-        break;
-    case MSM_V4L2_EXT_CAPTURE_MODE_AEC:
-    case MSM_V4L2_EXT_CAPTURE_MODE_AWB:
-    case MSM_V4L2_EXT_CAPTURE_MODE_AF:
-    case MSM_V4L2_EXT_CAPTURE_MODE_IHIST:
-        break;
-    case MSM_V4L2_EXT_CAPTURE_MODE_VIDEO:
-    default:
-        frame_offset.padding_format = CAMERA_PAD_TO_2K;
-        break;
-    }
-
-    CDBG("%s: format = %d, image_mode = %d, padding_format = %d, rotation = %d,"
-            "width = %d height = %d",
-             __func__,frame_offset.format,frame_offset.image_mode,frame_offset.padding_format,
-             frame_offset.rotation,frame_offset.width,frame_offset.height);
-
-    rc = mm_camera_send_native_ctrl_cmd(my_obj->ch_obj->cam_obj,
-                                            CAMERA_GET_PARM_FRAME_RESOLUTION,
-                                            sizeof(cam_frame_resolution_t),
-                                            &frame_offset);
-    if(rc != 0) {
-        CDBG_ERROR("%s: Failed to get the stream offset and frame length",__func__);
-        return rc;
-    }
-    my_obj->fmt.width = frame_offset.width;
-    my_obj->fmt.height = frame_offset.height;
-    memcpy(&my_obj->frame_offset,&frame_offset.frame_offset,sizeof(mm_camera_frame_len_offset));
-    CDBG("%s: Frame length = %d width = %d, height = %d, rc = %d",
-         __func__,my_obj->frame_offset.frame_len,my_obj->fmt.width,my_obj->fmt.height,rc);
-    return rc;
-}
-
-
-int32_t mm_stream_set_cid(mm_stream_t *my_obj,stream_cid_t *value)
-{
-    int32_t rc = 0;
-    cam_cid_info_t cam_cid_info;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    cam_cid_info.num_cids = 1;
-    cam_cid_info.cid_entries[0].cid = value->cid;
-    cam_cid_info.cid_entries[0].dt = value->dt;
-    cam_cid_info.cid_entries[0].inst_handle = my_obj->inst_hdl;
-
-    rc = mm_camera_send_native_ctrl_cmd(my_obj->ch_obj->cam_obj,
-                                            CAMERA_SET_PARM_CID,
-                                            sizeof(cam_cid_info_t),
-                                            &cam_cid_info);
-    if(rc != 0) {
-        CDBG_ERROR("%s: Failed to set the CID",__func__);
-        return rc;
-    }
-    return rc;
-}
-
-int32_t mm_stream_get_cid(mm_stream_t *my_obj,stream_cid_t *out_value)
-{
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-    //TODO: Need to use sensor structure init in camera query
-    int32_t rc = 0;
-    return rc;
-}
-
-int32_t mm_stream_buf_done(mm_stream_t * my_obj,
-                           mm_camera_buf_def_t *frame)
-{
-    int32_t rc = 0;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    if (my_obj->is_local_buf) {
-        /* special case for video-sized live snapshot
-         * buf is local, no need to qbuf to kernel */
-        return 0;
-    }
-
-    pthread_mutex_lock(&my_obj->buf_lock);
-
-    if(my_obj->buf_status[frame->buf_idx].buf_refcnt == 0) {
-        CDBG("%s: Error Trying to free second time?(idx=%d) count=%d, ext_image_mode=%d\n",
-                   __func__, frame->buf_idx,
-                   my_obj->buf_status[frame->buf_idx].buf_refcnt,
-                   my_obj->ext_image_mode);
-        rc = -1;
-    }else{
-        my_obj->buf_status[frame->buf_idx].buf_refcnt--;
-        if (0 == my_obj->buf_status[frame->buf_idx].buf_refcnt) {
-            CDBG("<DEBUG> : Buf done for buffer:%d:%d", my_obj->ext_image_mode, frame->buf_idx);
-            rc = mm_stream_qbuf(my_obj, frame);
-            if(rc < 0) {
-                CDBG_ERROR("%s: mm_camera_stream_qbuf(idx=%d) err=%d\n",
-                     __func__, frame->buf_idx, rc);
-            } else {
-                my_obj->buf_status[frame->buf_idx].in_kernel = 1;
-            }
-        }else{
-            CDBG("<DEBUG> : Still ref count pending count :%d",
-                 my_obj->buf_status[frame->buf_idx].buf_refcnt);
-            CDBG("<DEBUG> : for buffer:%p:%d, ext_image_mode=%d",
-                 my_obj, frame->buf_idx, my_obj->ext_image_mode);
-        }
-    }
-    pthread_mutex_unlock(&my_obj->buf_lock);
-    return rc;
-}
-
-int32_t mm_stream_reg_buf_cb(mm_stream_t *my_obj,
-                             mm_stream_data_cb_t *val)
-{
-    int32_t rc = -1;
-    uint8_t i;
-    CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
-         "image_mode = %d, fd = %d, state = %d",
-         __func__, my_obj->inst_hdl, my_obj->my_hdl,
-         my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
-    pthread_mutex_lock(&my_obj->cb_lock);
-    for (i=0 ;i < MM_CAMERA_STREAM_BUF_CB_MAX; i++) {
-        if(NULL == my_obj->buf_cb[i].cb) {
-            memcpy(&my_obj->buf_cb[i], val, sizeof(mm_stream_data_cb_t));
-            rc = 0;
-            break;
-        }
-    }
-    pthread_mutex_unlock(&my_obj->cb_lock);
-
-    return rc;
-}
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_thread.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_thread.c
deleted file mode 100755
index 6947ed4..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_thread.c
+++ /dev/null
@@ -1,361 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-typedef enum {
-    /* poll entries updated */
-    MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED,
-    /* exit */
-    MM_CAMERA_PIPE_CMD_EXIT,
-    /* max count */
-    MM_CAMERA_PIPE_CMD_MAX
-} mm_camera_pipe_cmd_type_t;
-
-typedef enum {
-    MM_CAMERA_POLL_TASK_STATE_STOPPED,
-    MM_CAMERA_POLL_TASK_STATE_POLL,     /* polling pid in polling state. */
-    MM_CAMERA_POLL_TASK_STATE_MAX
-} mm_camera_poll_task_state_type_t;
-
-typedef struct {
-    uint8_t cmd;
-    mm_camera_event_t event;
-} mm_camera_sig_evt_t;
-
-static int32_t mm_camera_poll_sig(mm_camera_poll_thread_t *poll_cb,
-                                  uint32_t cmd)
-{
-    /* send through pipe */
-    /* get the mutex */
-    mm_camera_sig_evt_t cmd_evt;
-    int len;
-
-    CDBG("%s: E cmd = %d", __func__,cmd);
-    memset(&cmd_evt, 0, sizeof(cmd_evt));
-    cmd_evt.cmd = cmd;
-    pthread_mutex_lock(&poll_cb->mutex);
-    /* reset the statue to false */
-    poll_cb->status = FALSE;
-    /* send cmd to worker */
-
-    len = write(poll_cb->pfds[1], &cmd_evt, sizeof(cmd_evt));
-    if(len < 1) {
-        CDBG_ERROR("%s: len = %d, errno = %d", __func__, len, errno);
-    }
-    CDBG("%s: begin IN mutex write done, len = %d", __func__, len);
-    /* wait till worker task gives positive signal */
-    if (FALSE == poll_cb->status) {
-        CDBG("%s: wait", __func__);
-        pthread_cond_wait(&poll_cb->cond_v, &poll_cb->mutex);
-    }
-    /* done */
-    pthread_mutex_unlock(&poll_cb->mutex);
-    CDBG("%s: X", __func__);
-    return 0;
-}
-
-static void mm_camera_poll_sig_done(mm_camera_poll_thread_t *poll_cb)
-{
-    pthread_mutex_lock(&poll_cb->mutex);
-    poll_cb->status = TRUE;
-    pthread_cond_signal(&poll_cb->cond_v);
-    CDBG("%s: done, in mutex", __func__);
-    pthread_mutex_unlock(&poll_cb->mutex);
-}
-
-static void mm_camera_poll_set_state(mm_camera_poll_thread_t *poll_cb,
-                                     mm_camera_poll_task_state_type_t state)
-{
-    poll_cb->state = state;
-}
-
-static void mm_camera_poll_proc_pipe(mm_camera_poll_thread_t *poll_cb)
-{
-    ssize_t read_len;
-    int i;
-    mm_camera_sig_evt_t cmd_evt;
-    read_len = read(poll_cb->pfds[0], &cmd_evt, sizeof(cmd_evt));
-    CDBG("%s: read_fd = %d, read_len = %d, expect_len = %d cmd = %d",
-         __func__, poll_cb->pfds[0], (int)read_len, (int)sizeof(cmd_evt), cmd_evt.cmd);
-    switch (cmd_evt.cmd) {
-    case MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED:
-        /* we always have index 0 for pipe read */
-        poll_cb->num_fds = 0;
-        poll_cb->poll_fds[poll_cb->num_fds].fd = poll_cb->pfds[0];
-        poll_cb->poll_fds[poll_cb->num_fds].events = POLLIN|POLLRDNORM|POLLPRI;
-        poll_cb->num_fds++;
-
-        if (MM_CAMERA_POLL_TYPE_EVT == poll_cb->poll_type) {
-            if (poll_cb->poll_entries[0].fd > 0) {
-                /* fd is valid, we update poll_fds */
-                poll_cb->poll_fds[poll_cb->num_fds].fd = poll_cb->poll_entries[0].fd;
-                poll_cb->poll_fds[poll_cb->num_fds].events = POLLIN|POLLRDNORM|POLLPRI;
-                poll_cb->num_fds++;
-            }
-        } else if (MM_CAMERA_POLL_TYPE_CH == poll_cb->poll_type) {
-            for(i = 0; i < MM_CAMEAR_STRAEM_NUM_MAX; i++) {
-                if(poll_cb->poll_entries[i].fd > 0) {
-                    /* fd is valid, we update poll_fds to this fd */
-                    poll_cb->poll_fds[poll_cb->num_fds].fd = poll_cb->poll_entries[i].fd;
-                    poll_cb->poll_fds[poll_cb->num_fds].events = POLLIN|POLLRDNORM|POLLPRI;
-                    poll_cb->num_fds++;
-                } else {
-                    /* fd is invalid, we set the entry to -1 to prevent polling.
-                     * According to spec, polling will not poll on entry with fd=-1.
-                     * If this is not the case, we need to skip these invalid fds
-                     * when updating this array.
-                     * We still keep fd=-1 in this array because this makes easier to
-                     * map cb associated with this fd once incoming data avail by directly
-                     * using the index-1(0 is reserved for pipe read, so need to reduce index by 1) */
-                    poll_cb->poll_fds[poll_cb->num_fds].fd = -1;
-                    poll_cb->poll_fds[poll_cb->num_fds].events = 0;
-                    poll_cb->num_fds++;
-                }
-            }
-        }
-        mm_camera_poll_sig_done(poll_cb);
-        break;
-
-    case MM_CAMERA_PIPE_CMD_EXIT:
-    default:
-        mm_camera_poll_set_state(poll_cb, MM_CAMERA_POLL_TASK_STATE_STOPPED);
-        mm_camera_poll_sig_done(poll_cb);
-        break;
-    }
-}
-
-static void *mm_camera_poll_fn(mm_camera_poll_thread_t *poll_cb)
-{
-    int rc = 0, i;
-
-    CDBG("%s: poll type = %d, num_fd = %d poll_cb = %p\n",
-         __func__, poll_cb->poll_type, poll_cb->num_fds,poll_cb);
-    do {
-         for(i = 0; i < poll_cb->num_fds; i++) {
-            poll_cb->poll_fds[i].events = POLLIN|POLLRDNORM|POLLPRI;
-         }
-
-         rc = poll(poll_cb->poll_fds, poll_cb->num_fds, poll_cb->timeoutms);
-         if(rc > 0) {
-            if ((poll_cb->poll_fds[0].revents & POLLIN) &&
-                (poll_cb->poll_fds[0].revents & POLLRDNORM)) {
-                /* if we have data on pipe, we only process pipe in this iteration */
-                CDBG("%s: cmd received on pipe\n", __func__);
-                mm_camera_poll_proc_pipe(poll_cb);
-            } else {
-                for(i=1; i<poll_cb->num_fds; i++) {
-                    /* Checking for ctrl events */
-                    if ((poll_cb->poll_type == MM_CAMERA_POLL_TYPE_EVT) &&
-                        (poll_cb->poll_fds[i].revents & POLLPRI)) {
-                        CDBG("%s: mm_camera_evt_notify\n", __func__);
-                        if (NULL != poll_cb->poll_entries[i-1].notify_cb) {
-                            poll_cb->poll_entries[i-1].notify_cb(poll_cb->poll_entries[i-1].user_data);
-                        }
-                    }
-
-                    if ((poll_cb->poll_type == MM_CAMERA_POLL_TYPE_CH) &&
-                        (poll_cb->poll_fds[i].revents & POLLIN) &&
-                        (poll_cb->poll_fds[i].revents & POLLRDNORM)) {
-                        CDBG("%s: mm_stream_data_notify\n", __func__);
-                        if (NULL != poll_cb->poll_entries[i-1].notify_cb) {
-                            poll_cb->poll_entries[i-1].notify_cb(poll_cb->poll_entries[i-1].user_data);
-                        }
-                    }
-                }
-            }
-        } else {
-            /* in error case sleep 10 us and then continue. hard coded here */
-            usleep(10);
-            continue;
-        }
-    } while (poll_cb->state == MM_CAMERA_POLL_TASK_STATE_POLL);
-    return NULL;
-}
-
-static void *mm_camera_poll_thread(void *data)
-{
-    int rc = 0;
-    int i;
-    void *ret = NULL;
-    mm_camera_poll_thread_t *poll_cb = (mm_camera_poll_thread_t *)data;
-
-    /* add pipe read fd into poll first */
-    poll_cb->poll_fds[poll_cb->num_fds++].fd = poll_cb->pfds[0];
-
-    //poll_cb->poll_fds[poll_cb->num_fds++].fd = (((mm_camera_obj_t *)poll_cb->my_obj)->ctrl_fd);
-
-    mm_camera_poll_sig_done(poll_cb);
-    mm_camera_poll_set_state(poll_cb, MM_CAMERA_POLL_TASK_STATE_POLL);
-    ret = mm_camera_poll_fn(poll_cb);
-    return ret;
-}
-
-int32_t mm_camera_poll_thread_notify_entries_updated(mm_camera_poll_thread_t * poll_cb)
-{
-    /* send poll entries updated signal to poll thread */
-    return mm_camera_poll_sig(poll_cb, MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED);
-}
-
-int32_t mm_camera_poll_thread_add_poll_fd(mm_camera_poll_thread_t * poll_cb,
-                                          uint32_t handler,
-                                          int32_t fd,
-                                          mm_camera_poll_notify_t notify_cb,
-                                          void* userdata)
-{
-    int32_t rc = -1;
-    uint8_t idx = 0;
-
-    if (MM_CAMERA_POLL_TYPE_CH == poll_cb->poll_type) {
-        /* get stream idx from handler if CH type */
-        idx = mm_camera_util_get_index_by_handler(handler);
-    } else {
-        /* for EVT type, only idx=0 is valid */
-        idx = 0;
-    }
-
-    if (MM_CAMEAR_STRAEM_NUM_MAX > idx) {
-        poll_cb->poll_entries[idx].fd = fd;
-        poll_cb->poll_entries[idx].handler = handler;
-        poll_cb->poll_entries[idx].notify_cb = notify_cb;
-        poll_cb->poll_entries[idx].user_data = userdata;
-        /* send poll entries updated signal to poll thread */
-        rc = mm_camera_poll_sig(poll_cb, MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED);
-    } else {
-        CDBG_ERROR("%s: invalid handler %d (%d)",
-                   __func__, handler, idx);
-    }
-    return rc;
-}
-
-int32_t mm_camera_poll_thread_del_poll_fd(mm_camera_poll_thread_t * poll_cb,
-                                          uint32_t handler)
-{
-    int32_t rc = -1;
-    uint8_t idx = 0;
-
-    if (MM_CAMERA_POLL_TYPE_CH == poll_cb->poll_type) {
-        /* get stream idx from handler if CH type */
-        idx = mm_camera_util_get_index_by_handler(handler);
-    } else {
-        /* for EVT type, only idx=0 is valid */
-        idx = 0;
-    }
-
-    if ((MM_CAMEAR_STRAEM_NUM_MAX > idx) &&
-        (handler == poll_cb->poll_entries[idx].handler)) {
-        /* reset poll entry */
-        poll_cb->poll_entries[idx].fd = -1; /* set fd to invalid */
-        poll_cb->poll_entries[idx].handler = 0;
-        poll_cb->poll_entries[idx].notify_cb = NULL;
-
-        /* send poll entries updated signal to poll thread */
-        rc = mm_camera_poll_sig(poll_cb, MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED);
-    } else {
-        CDBG_ERROR("%s: invalid handler %d (%d)",
-                   __func__, handler, idx);
-    }
-
-    return rc;
-}
-
-int32_t mm_camera_poll_thread_launch(mm_camera_poll_thread_t * poll_cb,
-                                     mm_camera_poll_thread_type_t poll_type)
-{
-    int32_t rc = 0;
-    poll_cb->poll_type = poll_type;
-
-    poll_cb->pfds[0] = 0;
-    poll_cb->pfds[1] = 0;
-    rc = pipe(poll_cb->pfds);
-    if(rc < 0) {
-        CDBG_ERROR("%s: pipe open rc=%d\n", __func__, rc);
-        return -1;
-    }
-
-    poll_cb->timeoutms = -1;  /* Infinite seconds */
-
-    CDBG("%s: poll_type = %d, read fd = %d, write fd = %d timeout = %d",
-        __func__, poll_cb->poll_type,
-        poll_cb->pfds[0], poll_cb->pfds[1],poll_cb->timeoutms);
-
-    pthread_mutex_init(&poll_cb->mutex, NULL);
-    pthread_cond_init(&poll_cb->cond_v, NULL);
-
-    /* launch the thread */
-    pthread_mutex_lock(&poll_cb->mutex);
-    poll_cb->status = 0;
-    pthread_create(&poll_cb->pid, NULL, mm_camera_poll_thread, (void *)poll_cb);
-    if(!poll_cb->status) {
-        pthread_cond_wait(&poll_cb->cond_v, &poll_cb->mutex);
-    }
-    pthread_mutex_unlock(&poll_cb->mutex);
-    CDBG("%s: End",__func__);
-    return rc;
-}
-
-int32_t mm_camera_poll_thread_release(mm_camera_poll_thread_t *poll_cb)
-{
-    int32_t rc = 0;
-    if(MM_CAMERA_POLL_TASK_STATE_STOPPED == poll_cb->state) {
-        CDBG_ERROR("%s: err, poll thread is not running.\n", __func__);
-        return rc;
-    }
-
-    /* send exit signal to poll thread */
-    mm_camera_poll_sig(poll_cb, MM_CAMERA_PIPE_CMD_EXIT);
-    /* wait until poll thread exits */
-    if (pthread_join(poll_cb->pid, NULL) != 0) {
-        CDBG_ERROR("%s: pthread dead already\n", __func__);
-    }
-
-    /* close pipe */
-    if(poll_cb->pfds[0]) {
-        close(poll_cb->pfds[0]);
-    }
-    if(poll_cb->pfds[1]) {
-        close(poll_cb->pfds[1]);
-    }
-
-    pthread_mutex_destroy(&poll_cb->mutex);
-    pthread_cond_destroy(&poll_cb->cond_v);
-    memset(poll_cb, 0, sizeof(mm_camera_poll_thread_t));
-    return rc;
-}
diff --git a/camera/QCamera/stack/mm-camera-test/Android.mk b/camera/QCamera/stack/mm-camera-test/Android.mk
deleted file mode 100755
index 9613d05..0000000
--- a/camera/QCamera/stack/mm-camera-test/Android.mk
+++ /dev/null
@@ -1,62 +0,0 @@
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH:=$(call my-dir)
-include $(CLEAR_VARS)
-
-ifeq ($(call is-board-platform,msm8960),true)
-LOCAL_CFLAGS:= \
-        -DAMSS_VERSION=$(AMSS_VERSION) \
-        $(mmcamera_debug_defines) \
-        $(mmcamera_debug_cflags) \
-        $(USE_SERVER_TREE)
-
-LOCAL_CFLAGS += -include $(TARGET_OUT_INTERMEDIATES)/include/mm-camera/camera_defs_i.h
-LOCAL_CFLAGS += -include $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/linux/msm_ion.h
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
-LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_CFLAGS += -D_ANDROID_
-
-LOCAL_SRC_FILES:= \
-        src/mm_qcamera_main_menu.c \
-        src/mm_qcamera_display.c \
-        src/mm_qcamera_app.c \
-        src/mm_qcamera_snapshot.c \
-        src/mm_qcamera_video.c \
-        src/mm_qcamera_preview.c \
-        src/mm_qcamera_rdi.c \
-        src/mm_qcamera_unit_test.c \
-        src/mm_qcamera_dual_test.c \
-        src/mm_qcamera_pp.c
-
-LOCAL_C_INCLUDES:=$(LOCAL_PATH)/inc
-LOCAL_C_INCLUDES+= \
-        $(TARGET_OUT_INTERMEDIATES)/include/mm-still/jpeg \
-        $(TARGET_OUT_INTERMEDIATES)/include/mm-camera \
-        $(LOCAL_PATH)/../mm-camera-interface/inc \
-        $(LOCAL_PATH)/../mm-jpeg-interface/inc \
-        $(LOCAL_PATH)/../common \
-        $(LOCAL_PATH)/../../../ \
-
-LOCAL_C_INCLUDES+= $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/media
-LOCAL_C_INCLUDES+= $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
-
-ifeq ($(call is-board-platform,msm8960),true)
-LOCAL_CFLAGS += -DCAMERA_ION_HEAP_ID=ION_CP_MM_HEAP_ID
-else
-LOCAL_CFLAGS += -DCAMERA_ION_HEAP_ID=ION_CAMERA_HEAP_ID
-endif
-
-LOCAL_SHARED_LIBRARIES:= \
-         libcutils libdl
-
-LOCAL_MODULE:= mm-qcamera-app
-
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_EXECUTABLE)
-endif
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
diff --git a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_app.h b/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_app.h
deleted file mode 100755
index 9b51825..0000000
--- a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_app.h
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_QCAMERA_APP_H__
-#define __MM_QCAMERA_APP_H__
-
-#include "camera.h"
-#include "mm_qcamera_main_menu.h"
-#include "mm_camera_interface.h"
-#include "mm_jpeg_interface.h"
-
-#define MM_QCAMERA_APP_INTERATION 1
-
-#define MM_APP_MAX_DUMP_FRAME_NUM 1000
-
-#define PREVIEW_BUF_NUM 7
-#define VIDEO_BUF_NUM 7
-#define ISP_PIX_BUF_NUM 9
-
-#define STATS_BUF_NUM 4
-
-typedef enum {
-    MM_CAMERA_OK,
-    MM_CAMERA_E_GENERAL,
-    MM_CAMERA_E_NO_MEMORY,
-    MM_CAMERA_E_NOT_SUPPORTED,
-    MM_CAMERA_E_INVALID_INPUT,
-    MM_CAMERA_E_INVALID_OPERATION, /* 5 */
-    MM_CAMERA_E_ENCODE,
-    MM_CAMERA_E_BUFFER_REG,
-    MM_CAMERA_E_PMEM_ALLOC,
-    MM_CAMERA_E_CAPTURE_FAILED,
-    MM_CAMERA_E_CAPTURE_TIMEOUT, /* 10 */
-}mm_camera_status_type_t;
-
-typedef struct {
-    int num;
-    mm_camera_buf_def_t bufs[MM_CAMERA_MAX_NUM_FRAMES];
-    struct ion_allocation_data alloc[MM_CAMERA_MAX_NUM_FRAMES];
-    struct ion_fd_data ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES];
-} mm_camear_app_buf_t;
-
-typedef struct {
-    uint32_t id;
-    mm_camera_stream_config_t str_config;
-    mm_camear_app_buf_t app_bufs;
-}mm_camear_stream_t;
-
-typedef enum{
-    CAMERA_STATE_OPEN,
-    CAMERA_STATE_PREVIEW,
-    CAMERA_STATE_RECORD,
-    CAMERA_STATE_SNAPSHOT,
-    CAMERA_STATE_RDI
-}camera_state;
-
-typedef enum{
-    CAMERA_MODE,
-    RECORDER_MODE,
-    ZSL_MODE,
-    RDI_MODE
-}camera_mode;
-
-#define MM_QCAM_APP_MAX_STREAM_NUM MM_CAMERA_IMG_MODE_MAX
-
-typedef struct {
-    mm_camera_buf_def_t *frame;
-    uint8_t ref_cnt;
-} repro_src_buf_info;
-
-typedef struct {
-    struct cam_list list;
-    void* data;
-} mm_qcamera_q_node_t;
-
-typedef struct {
-    mm_qcamera_q_node_t head; /* dummy head */
-    uint32_t size;
-    pthread_mutex_t lock;
-} mm_qcamera_queue_t;
-
-typedef struct {
-    mm_camera_vtbl_t *cam;
-    mm_camear_mem_vtbl_t *mem_cam;
-    int8_t my_id;
-    //mm_camera_op_mode_type_t op_mode;
-    uint32_t ch_id;
-    cam_ctrl_dimension_t dim;
-    int open_flag;
-    int ionfd;
-    mm_camear_stream_t stream[MM_QCAM_APP_MAX_STREAM_NUM];
-    camera_mode cam_mode;
-    camera_state cam_state;
-    int fullSizeSnapshot;
-
-    mm_jpeg_ops_t jpeg_ops;
-    uint32_t jpeg_hdl;
-    mm_camera_super_buf_t* current_job_frames;
-    uint32_t current_job_id;
-    mm_camear_app_buf_t jpeg_buf;
-
-    uint32_t isp_repro_handle;
-    uint8_t repro_dest_num;
-    mm_qcamera_queue_t repro_q;
-    repro_src_buf_info repro_buf_info[ISP_PIX_BUF_NUM];
-    mm_camera_repro_config_data_t repro_config;
-} mm_camera_app_obj_t;
-
-typedef struct {
-  void *ptr;
-  void* ptr_jpeg;
-
-  mm_camera_info_t *(*mm_camera_query) (uint8_t *num_cameras);
-  mm_camera_vtbl_t *(*mm_camera_open) (uint8_t camera_idx,
-                               mm_camear_mem_vtbl_t *mem_vtbl);
-  uint32_t (*jpeg_open) (mm_jpeg_ops_t *ops);
-
-  /*uint8_t *(*mm_camera_do_mmap)(uint32_t size, int *pmemFd);
-  int (*mm_camera_do_munmap)(int pmem_fd, void *addr, size_t size);
-
-   uint8_t *(*mm_camera_do_mmap_ion)(int ion_fd, struct ion_allocation_data *alloc,
-             struct ion_fd_data *ion_info_fd, int *mapFd);
-  int (*mm_camera_do_munmap_ion) (int ion_fd, struct ion_fd_data *ion_info_fd,
-                   void *addr, size_t size);*/
-#if 0
-  uint32_t (*mm_camera_get_msm_frame_len)(cam_format_t fmt_type,
-                                            camera_mode_t mode,
-                                            int width,
-                                            int height,
-                                            int image_type,
-                                            uint8_t *num_planes,
-                                            uint32_t planes[]);
-#ifndef DISABLE_JPEG_ENCODING
-  void (*set_callbacks)(jpegfragment_callback_t fragcallback,
-    jpeg_callback_t eventcallback, void* userdata, void* output_buffer,
-    int * outBufferSize);
-  int8_t (*omxJpegOpen)(void);
-  void (*omxJpegClose)(void);
-  int8_t (*omxJpegStart)(void);
-  int8_t (*omxJpegEncode)(omx_jpeg_encode_params *encode_params);
-  void (*omxJpegFinish)(void);
-  int8_t (*mm_jpeg_encoder_setMainImageQuality)(uint32_t quality);
-#endif
-#endif
-} hal_interface_lib_t;
-
-typedef struct {
-    //mm_camera_vtbl_t *cam;
-    uint8_t num_cameras;
-    mm_camera_app_obj_t *obj[2];
-    mm_camera_info_t *cam_info;
-    int use_overlay;
-    int use_user_ptr;
-    hal_interface_lib_t hal_lib;
-    int cam_open;
-    int run_sanity;
-} mm_camera_app_t;
-
-extern mm_camera_app_t my_cam_app;
-extern USER_INPUT_DISPLAY_T input_display;
-extern int mm_app_dl_render(int frame_fd, struct crop_info * cropinfo);
-extern mm_camera_app_obj_t *mm_app_get_cam_obj(int8_t cam_id);
-extern int mm_app_load_hal();
-extern int mm_app_init();
-extern void mm_app_user_ptr(int use_user_ptr);
-extern int mm_app_open_ch(int cam_id);
-extern void mm_app_close_ch(int cam_id, int ch_type);
-extern int mm_app_set_dim(int8_t cam_id, cam_ctrl_dimension_t *dim);
-extern int mm_app_run_unit_test();
-extern int mm_app_unit_test_entry(mm_camera_app_t *cam_app);
-extern int mm_app_unit_test();
-extern void mm_app_set_dim_def(cam_ctrl_dimension_t *dim);
-extern int mm_app_open(uint8_t camera_idx);
-extern int mm_app_close(int8_t cam_id);
-extern int startPreview(int cam_id);
-extern int mm_app_stop_preview(int cam_id);
-extern int mm_app_stop_video(int cam_id);
-extern int startRecording(int cam_id);
-extern int stopRecording(int cam_id);
-extern int mm_app_take_picture(int cam_id);
-extern int mm_app_take_raw_picture(int cam_id);
-extern int mm_app_get_dim(int8_t cam_id, cam_ctrl_dimension_t *dim);
-extern int mm_app_streamon_preview(int cam_id);
-extern int mm_app_set_snapshot_fmt(int cam_id,mm_camera_image_fmt_t *fmt);
-
-extern int mm_app_dual_test_entry(mm_camera_app_t *cam_app);
-extern int mm_app_dual_test();
-
-extern int mm_camera_app_wait();
-extern void mm_camera_app_done();
-
-extern int mm_stream_initbuf(uint32_t camera_handle,
-                             uint32_t ch_id, uint32_t stream_id,
-                             void *user_data,
-                             mm_camera_frame_len_offset *frame_offset_info,
-                             uint8_t num_bufs,
-                             uint8_t *initial_reg_flag,
-                             mm_camera_buf_def_t *bufs);
-
-extern int mm_stream_deinitbuf(uint32_t camera_handle,
-                             uint32_t ch_id, uint32_t stream_id,
-                             void *user_data, uint8_t num_bufs,
-                             mm_camera_buf_def_t *bufs);
-
-extern void mm_app_preview_notify_cb(mm_camera_super_buf_t *bufs,
-                                     void *user_data);
-#endif /* __MM_QCAMERA_APP_H__ */
-
-
-
-
-
-
-
-
-
diff --git a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_display_dimensions.h b/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_display_dimensions.h
deleted file mode 100755
index 7ff486b..0000000
--- a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_display_dimensions.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_QCAMERA_DISPLAY_DIMENSIONS__
-#define __MM_QCAMERA_DISPLAY_DIMENSIONS__
-
-#define PREVIEW_WIDTH     800
-#define PREVIEW_HEIGHT    480
-#define DISPLAY_WIDTH     800
-#define DISPLAY_HEIGHT    480
-#define THUMBNAIL_WIDTH   192
-#define THUMBNAIL_HEIGHT  144
-#define PICTURE_WIDTH     1280
-#define PICTURE_HEIGHT    960
-
-#endif /* __MM_QCAMERA_DISPLAY_DIMENSIONS__ */
diff --git a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_main_menu.h b/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_main_menu.h
deleted file mode 100755
index 898f0b8..0000000
--- a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_main_menu.h
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_QCAMERA_MAIN_MENU_H__
-#define __MM_QCAMERA_MAIN_MENU_H__
-
-#include "camera.h"
-#include "mm_camera_interface.h"
-
-
-#define VIDEO_BUFFER_SIZE       (PREVIEW_WIDTH * PREVIEW_HEIGHT * 3/2)
-#define THUMBNAIL_BUFFER_SIZE   (THUMBNAIL_WIDTH * THUMBNAIL_HEIGHT * 3/2)
-#define SNAPSHOT_BUFFER_SIZE    (PICTURE_WIDTH * PICTURE_HEIGHT * 3/2)
-
-/*===========================================================================
- * Macro
- *===========================================================================*/
-#define PREVIEW_FRAMES_NUM    4
-#define VIDEO_FRAMES_NUM      4
-#define THUMBNAIL_FRAMES_NUM  1
-#define SNAPSHOT_FRAMES_NUM   1
-#define MAX_NUM_FORMAT        32
-
-typedef enum
-{
-  STOP_CAMERA = 1,
-  PREVIEW_VIDEO_RESOLUTION = 2,
-  TAKE_YUV_SNAPSHOT = 3,
-  TAKE_RAW_SNAPSHOT = 4,
-  TAKE_ZSL_SNAPSHOT = 5,
-  //TAKE_LIVE_SNAPSHOT = 17,
-  START_RECORDING = 6,
-  START_RDI = 7,
-  STOP_RDI = 8,
-  SWITCH_CAMERA = 9,
-  //STOP_RECORDING = 7,
-  //SET_WHITE_BALANCE = 3,
-  //SET_EXP_METERING = 4,
-  //GET_CTRL_VALUE = 5,
-  //TOGGLE_AFR = 6,
-  //SET_ISO = 7,
-  //BRIGHTNESS_GOTO_SUBMENU = 8,
-  //CONTRAST_GOTO_SUBMENU = 9,
-  //EV_GOTO_SUBMENU = 10,
-  //SATURATION_GOTO_SUBMENU = 11,
-  //SET_ZOOM = 12,
-  //SET_SHARPNESS = 13,
-} Camera_main_menu_t;
-
-typedef enum
-{
-  ACTION_NO_ACTION,
-  ACTION_STOP_CAMERA,
-  ACTION_PREVIEW_VIDEO_RESOLUTION,
-  ACTION_TAKE_YUV_SNAPSHOT,
-  ACTION_TAKE_RAW_SNAPSHOT,
-  ACTION_TAKE_ZSL_SNAPSHOT,
-  ACTION_TAKE_LIVE_SNAPSHOT,
-  ACTION_START_RECORDING,
-  ACTION_STOP_RECORDING,
-  ACTION_START_RDI,
-  ACTION_STOP_RDI,
-  ACTION_SWITCH_CAMERA,
-  ACTION_SET_WHITE_BALANCE,
-  ACTION_SET_EXP_METERING,
-  ACTION_GET_CTRL_VALUE,
-  ACTION_TOGGLE_AFR,
-  ACTION_SET_ISO,
-  ACTION_BRIGHTNESS_INCREASE,
-  ACTION_BRIGHTNESS_DECREASE,
-  ACTION_CONTRAST_INCREASE,
-  ACTION_CONTRAST_DECREASE,
-  ACTION_EV_INCREASE,
-  ACTION_EV_DECREASE,
-  ACTION_SATURATION_INCREASE,
-  ACTION_SATURATION_DECREASE,
-  ACTION_SET_ZOOM,
-  ACTION_SHARPNESS_INCREASE,
-  ACTION_SHARPNESS_DECREASE,
-} camera_action_t;
-
-#define INVALID_KEY_PRESS 0
-#define BASE_OFFSET  ('Z' - 'A' + 1)
-#define BASE_OFFSET_NUM  ('Z' - 'A' + 2)
-#define PAD_TO_WORD(a)  (((a)+3)&~3)
-
-
-#define SQCIF_WIDTH     128
-#define SQCIF_HEIGHT     96
-#define QCIF_WIDTH      176
-#define QCIF_HEIGHT     144
-#define QVGA_WIDTH      320
-#define QVGA_HEIGHT     240
-#define HD_THUMBNAIL_WIDTH      256
-#define HD_THUMBNAIL_HEIGHT     144
-#define CIF_WIDTH       352
-#define CIF_HEIGHT      288
-#define VGA_WIDTH       640
-#define VGA_HEIGHT      480
-#define WVGA_WIDTH      800
-#define WVGA_HEIGHT     480
-
-#define MP1_WIDTH      1280
-#define MP1_HEIGHT      960
-#define MP2_WIDTH      1600
-#define MP2_HEIGHT     1200
-#define MP3_WIDTH      2048
-#define MP3_HEIGHT     1536
-#define MP5_WIDTH      2592
-#define MP5_HEIGHT     1944
-
-#define SVGA_WIDTH      800
-#define SVGA_HEIGHT     600
-#define XGA_WIDTH      1024
-#define XGA_HEIGHT      768
-#define HD720_WIDTH    1280
-#define HD720_HEIGHT    720
-#define WXGA_WIDTH     1280
-#define WXGA_HEIGHT     768
-#define HD1080_WIDTH   1920
-#define HD1080_HEIGHT  1080
-
-typedef enum
-{
-  RESOLUTION_MIN         = 1,
-  SQCIF                  = RESOLUTION_MIN,
-  QCIF                   = 2,
-  QVGA                   = 3,
-  CIF                    = 4,
-  VGA                    = 5,
-  WVGA                   = 6,
-  SVGA                   = 7,
-  XGA                    = 8,
-  HD720                  = 9,
-  RESOLUTION_PREVIEW_VIDEO_MAX = HD720,
-  WXGA                   = 10,
-  MP1                    = 11,
-  MP2                    = 12,
-  HD1080                 = 13,
-  MP3                    = 14,
-  MP5                    = 15,
-  RESOLUTION_MAX         = MP5,
-} Camera_Resolution;
-
-
-typedef enum {
-    WHITE_BALANCE_STATE = 1,
-    WHITE_BALANCE_TEMPERATURE = 2,
-    BRIGHTNESS_CTRL = 3,
-    EV = 4,
-    CONTRAST_CTRL = 5,
-    SATURATION_CTRL = 6,
-    SHARPNESS_CTRL = 7,
-} Get_Ctrl_modes;
-
-typedef enum {
-	EXP_METERING_FRAME_AVERAGE   = 1,
-	EXP_METERING_CENTER_WEIGHTED = 2,
-  EXP_METERING_SPOT_METERING   = 3,
-} Exp_Metering_modes;
-
-typedef enum {
-  ISO_AUTO = 1,
-  ISO_DEBLUR = 2,
-  ISO_100 = 3,
-  ISO_200 = 4,
-  ISO_400 = 5,
-  ISO_800 = 6,
-  ISO_1600 = 7,
-} ISO_modes;
-
-typedef enum
-{
-  MENU_ID_MAIN,
-  MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE,
-  MENU_ID_WHITEBALANCECHANGE,
-  MENU_ID_EXPMETERINGCHANGE,
-  MENU_ID_GET_CTRL_VALUE,
-  MENU_ID_TOGGLEAFR,
-  MENU_ID_ISOCHANGE,
-  MENU_ID_BRIGHTNESSCHANGE,
-  MENU_ID_CONTRASTCHANGE,
-  MENU_ID_EVCHANGE,
-  MENU_ID_SATURATIONCHANGE,
-  MENU_ID_ZOOMCHANGE,
-  MENU_ID_SHARPNESSCHANGE,
-  MENU_ID_SWITCHCAMERA,
-  MENU_ID_RECORD,
-  MENU_ID_INVALID,
-} menu_id_change_t;
-
-typedef enum
-{
-  INCREASE_ZOOM      = 1,
-  DECREASE_ZOOM      = 2,
-  INCREASE_STEP_ZOOM = 3,
-  DECREASE_STEP_ZOOM = 4,
-} Camera_Zoom;
-
-typedef enum
-{
-  INC_CONTRAST = 1,
-  DEC_CONTRAST = 2,
-} Camera_Contrast_changes;
-
-typedef enum
-{
-  INC_BRIGHTNESS = 1,
-  DEC_BRIGHTNESS = 2,
-} Camera_Brightness_changes;
-
-typedef enum
-{
-  INCREASE_EV = 1,
-  DECREASE_EV = 2,
-} Camera_EV_changes;
-
-typedef enum {
-  INC_SATURATION = 1,
-  DEC_SATURATION = 2,
-} Camera_Saturation_changes;
-
-typedef enum
-{
-  INC_ISO = 1,
-  DEC_ISO = 2,
-} Camera_ISO_changes;
-
-typedef enum
-{
-  INC_SHARPNESS = 1,
-  DEC_SHARPNESS = 2,
-} Camera_Sharpness_changes;
-
-typedef enum {
-  ZOOM_IN = 1,
-  ZOOM_OUT = 2,
-} Zoom_direction;
-
-typedef enum
-{
-  LIVE_SNAPSHOT_MENU = 1,
-  STOP_RECORDING_MENU = 2,
-} Record_changes;
-
-typedef struct{
-    Camera_main_menu_t main_menu;
-    char * menu_name;
-} CAMERA_MAIN_MENU_TBL_T;
-
-typedef struct{
-    Camera_Resolution cs_id;
-    uint16_t width;
-    uint16_t  height;
-    char * name;
-    char * str_name;
-} PREVIEW_DIMENSION_TBL_T;
-
-typedef struct {
-  config3a_wb_t wb_id;
-  char * wb_name;
-} WHITE_BALANCE_TBL_T;
-
-typedef struct {
-  int cam_id;
-  char * cam_name;
-} CAMERA_TBL_T;
-
-typedef struct {
-  int act_id;
-  char * act_name;
-} RECORD_TBL_T;
-
-typedef struct {
-  Get_Ctrl_modes get_ctrl_id;
-  char * get_ctrl_name;
-} GET_CTRL_TBL_T;
-
-typedef struct{
-  Exp_Metering_modes exp_metering_id;
-  char * exp_metering_name;
-} EXP_METERING_TBL_T;
-
-typedef struct {
-  ISO_modes iso_modes;
-  char *iso_modes_name;
-} ISO_TBL_T;
-
-typedef struct {
-  Zoom_direction zoom_direction;
-  char * zoom_direction_name;
-} ZOOM_TBL_T;
-
-typedef struct {
-  Camera_Sharpness_changes sharpness_change;
-  char *sharpness_change_name;
-} SHARPNESS_TBL_T;
-
-typedef struct {
-  Camera_Brightness_changes bc_id;
-  char * brightness_name;
-} CAMERA_BRIGHTNESS_TBL_T;
-
-typedef struct {
-  Camera_Contrast_changes cc_id;
-  char * contrast_name;
-} CAMERA_CONTRST_TBL_T;
-
-typedef struct {
-  Camera_EV_changes ec_id;
-  char * EV_name;
-} CAMERA_EV_TBL_T;
-
-typedef struct {
-  Camera_Saturation_changes sc_id;
-  char * saturation_name;
-} CAMERA_SATURATION_TBL_T;
-
-typedef struct {
-  Camera_Sharpness_changes bc_id;
-  char * sharpness_name;
-} CAMERA_SHARPNESS_TBL_T;
-
-
-typedef struct {
-  void    *frameThread;
-  int8_t (*setDimension)(int , void *);
-  int8_t (*setDefaultParams)(int );
-  int8_t (*registerPreviewBuf)(int , void *, uint32_t, struct msm_frame *, int8_t );
-  int8_t (*unregisterPreviewBuf)(int , void *, uint32_t, int , unsigned char *);
-  int8_t (*registerVideoBuf)(int , void *, uint32_t, struct msm_frame *, int8_t );
-  int8_t (*unregisterVideoBuf)(int , void *, uint32_t, int , unsigned char *);
-  int8_t (*startPreview)(int );
-  int8_t (*stopPreview)(int );
-  int8_t (*startVideo)(int );
-  int8_t (*stopVideo)(int );
-  int8_t (*startRecording)(int );
-  int8_t (*stopRecording)(int );
-  int8_t (*startSnapshot)(int );
-  int8_t (*startRawSnapshot)(int );
-
-  int8_t (*registerSnapshotBuf)(int , void *, int , int ,
-    unsigned char *, unsigned char *);
-
-  int8_t (*registerRawSnapshotBuf)(int , void *, int , unsigned char *);
-
-  int8_t (*unregisterSnapshotBuf)(int , void *, int , int ,
-    unsigned char *, unsigned char *);
-
-  int8_t (*unregisterRawSnapshotBuf)(int , void *, int , unsigned char *);
-  int8_t (*getPicture)(int fd, struct crop_info *cropInfo );
-  int8_t (*stopSnapshot)(int );
-  int8_t (*jpegEncode)(const char *path, void *, int, int , unsigned char *,
-    unsigned char *, void *, camera_encoding_rotate_t rotate);
-  int8_t (*setZoom)(int , void *);
-  int8_t (*getMaxZoom)(int fd, void *pZm);
-  int8_t (*setSpecialEffect)(int, int effect);
-  int8_t (*setBrightness)(int, int);
-  int8_t (*setContrast)(int, int);
-  int8_t (*setSaturation)(int, int);
-  int8_t (*setEV)(int , int );
-  int8_t (*setAntiBanding)(int , int32_t antibanding);
-  int8_t (*setWhiteBalance)(int , int32_t );
-  int8_t (*setAecMode)(int , camera_auto_exposure_mode_type );
-  int8_t (*setIso)(int , camera_iso_mode_type );
-  int8_t (*setSharpness)(int , int );
-  int8_t (*setAutoFocus)(int , isp3a_af_mode_t, cam_af_ctrl_t *);
-  int8_t (*sethjr) (int fd, int8_t hjr_status);
-  int8_t (*setLensShading) (int fd, int8_t rolloff_status);
-  int8_t (*setLedMode) (int fd, led_mode_t led_mode);
-  int8_t (*getSharpness_AF) (int fd, int32_t *sharpness);
-  int8_t (*setMotionIso) (int fd, motion_iso_t motion_iso);
-  int8_t (*setHue) (int fd, int32_t hue);
-  int8_t (*cancelAF) (int fd);
-  int8_t (*getAfStep) (int fd, int32_t *afStep);
-  int8_t (*setAfStep) (int fd, int32_t afStep);
-  int8_t (*enableAFD) (int fd);
-  int8_t (*prepareSnapshot) (int fd);
-  int8_t (*setFpsMode) (int fd, fps_mode_t fps_mode);
-  int8_t (*setFps) (int fd, uint16_t fps);
-  int8_t (*setAFFocusRect) (int fd, cam_af_focusrect_t af_focus_rect);
-} interface_ctrl_t;
-
-int8_t native_interface_init(interface_ctrl_t *intrfcCtrl, int *camfd);
-int8_t v4l2_interface_init(interface_ctrl_t *intrfcCtrl, int *videofd);
-
-int set_zoom (int zoom_action_param);
-int set_hjr (void);
-int LensShading (void);
-int decrease_contrast (void);
-int increase_contrast (void);
-int decrease_saturation (void);
-int increase_saturation (void);
-int decrease_brightness (void);
-int increase_brightness (void);
-int decrease_EV (void);
-int increase_EV (void);
-int set_iso (int iso_action_param);
-int decrease_sharpness (void);
-int increase_sharpness (void);
-int SpecialEffect (void);
-int set_exp_metering (int exp_metering_action_param);
-int LED_mode_change (void);
-int set_sharpness_AF (void);
-int set_auto_focus (void);
-int set_antibanding (void);
-int set_whitebalance (int wb_action_param);
-int print_current_menu ();
-int set_MotionIso (void);
-int start_preview (void);
-int stop_preview (void);
-static int start_video (void);
-static int stop_video (void);
-int start_recording (void);
-int stop_recording (void);
-int snapshot_resolution (int);
-int preview_video_resolution (int);
-int system_init(void);
-int system_destroy(void);
-int toggle_hue(void);
-int cancel_af(void);
-int get_af_step();
-int set_af_step();
-int enable_afd();
-int prepare_snapshot();
-int set_fps_mode(void);
-int get_ctrl_value (int ctrl_value_mode_param);
-int toggle_afr ();
-int take_yuv_snapshot(int cam_id);
-int take_raw_snapshot();
-#endif /* __MM_QCAMERA_MAIN_MENU_H__ */
diff --git a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_unit_test.h b/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_unit_test.h
deleted file mode 100755
index 8e3e0a4..0000000
--- a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_unit_test.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_QCAMERA_APP_UNIT_TEST_H__
-#define __MM_QCAMERA_APP_UNIT_TEST_H__
-
-#include "camera.h"
-#include "mm_qcamera_main_menu.h"
-#include "mm_camera_interface.h"
-#include "mm_qcamera_app.h"
-
-typedef int (*mm_app_test_t) (mm_camera_app_t *cam_apps);
-typedef struct {
-    mm_app_test_t f;
-    int r;
-} mm_app_tc_t;
-
-#endif
-
-/* __MM_QCAMERA_APP_UNIT_TEST_H__ */
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_app.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_app.c
deleted file mode 100755
index b90f2b0..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_app.c
+++ /dev/null
@@ -1,621 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <dlfcn.h>
-#include "mm_qcamera_main_menu.h"
-#include "mm_qcamera_app.h"
-
-mm_camera_app_t my_cam_app;
-
-extern uint8_t *mm_camera_do_mmap_ion(int ion_fd, struct ion_allocation_data *alloc,
-                                      struct ion_fd_data *ion_info_fd, int *mapFd);
-extern int mm_camera_do_munmap_ion (int ion_fd, struct ion_fd_data *ion_info_fd,
-                                    void *addr, size_t size);
-
-static pthread_mutex_t app_mutex;
-static int thread_status = 0;
-static pthread_cond_t app_cond_v;
-
-#define MM_QCAMERA_APP_WAIT_TIME 1000000000
-
-int mm_camera_app_timedwait()
-{
-    int rc = 0;
-    pthread_mutex_lock(&app_mutex);
-    if(FALSE == thread_status) {
-        struct timespec tw;
-        memset(&tw, 0, sizeof tw);
-        tw.tv_sec = 0;
-        tw.tv_nsec = time(0) + MM_QCAMERA_APP_WAIT_TIME;
-
-        //pthread_cond_wait(&app_cond_v, &app_mutex);
-        rc = pthread_cond_timedwait(&app_cond_v, &app_mutex,&tw);
-        thread_status = FALSE;
-    }
-    pthread_mutex_unlock(&app_mutex);
-    return rc;
-}
-
-int mm_camera_app_wait()
-{
-    int rc = 0;
-    pthread_mutex_lock(&app_mutex);
-    if(FALSE == thread_status){
-        pthread_cond_wait(&app_cond_v, &app_mutex);
-        thread_status = FALSE;
-    }
-    pthread_mutex_unlock(&app_mutex);
-    return rc;
-}
-
-void mm_camera_app_done()
-{
-  pthread_mutex_lock(&app_mutex);
-  thread_status = TRUE;
-  pthread_cond_signal(&app_cond_v);
-  pthread_mutex_unlock(&app_mutex);
-}
-
-
-mm_camera_app_obj_t *mm_app_get_cam_obj(int8_t cam_id)
-{
-    mm_camera_app_obj_t *temp = my_cam_app.obj[cam_id];
-    return temp;
-}
-
-void mm_app_user_ptr(int use_user_ptr)
-{
-    my_cam_app.use_user_ptr = use_user_ptr;
-}
-
-void mm_app_set_dim_def(cam_ctrl_dimension_t *dim)
-{
-    dim->display_width = WVGA_WIDTH;
-    dim->display_height = WVGA_HEIGHT;
-    input_display.user_input_display_width = dim->display_width;
-    input_display.user_input_display_height = dim->display_height;
-    dim->video_width = WVGA_WIDTH;
-    dim->video_width = CEILING32(dim->video_width);
-    dim->video_height = WVGA_HEIGHT;
-    dim->orig_video_width = dim->video_width;
-    dim->orig_video_height = dim->video_height;
-    dim->picture_width = MP1_WIDTH;
-    dim->picture_height = MP1_HEIGHT;
-    dim->orig_picture_dx = dim->picture_width;
-    dim->orig_picture_dy = dim->picture_height;
-    dim->ui_thumbnail_height = QVGA_HEIGHT;
-    dim->ui_thumbnail_width = QVGA_WIDTH;
-    dim->thumbnail_height = dim->ui_thumbnail_height;
-    dim->thumbnail_width = dim->ui_thumbnail_width;
-    dim->orig_picture_width = dim->picture_width;
-    dim->orig_picture_height = dim->picture_height;
-    dim->orig_thumb_width = dim->thumbnail_width;
-    dim->orig_thumb_height = dim->thumbnail_height;
-    dim->raw_picture_height = MP1_HEIGHT;
-    dim->raw_picture_width = MP1_WIDTH;
-    dim->hjr_xtra_buff_for_bayer_filtering;
-    dim->prev_format = CAMERA_YUV_420_NV21;
-    dim->enc_format = CAMERA_YUV_420_NV12;
-    dim->thumb_format = CAMERA_YUV_420_NV21;
-    dim->main_img_format = CAMERA_YUV_420_NV21;
-    dim->raw_img_format = CAMERA_BAYER_SBGGR10;
-    dim->rdi0_format = CAMERA_YUV_422_YUYV;
-    dim->prev_padding_format = CAMERA_PAD_TO_4K;
-    dim->display_luma_width = dim->display_width;
-    dim->display_luma_height = dim->display_height;
-    dim->display_chroma_width = dim->display_width;
-    dim->display_chroma_height = dim->display_height;
-    dim->video_luma_width = dim->orig_video_width;
-    dim->video_luma_height = dim->orig_video_height;
-    dim->video_chroma_width = dim->orig_video_width;
-    dim->video_chroma_height = dim->orig_video_height;
-    dim->thumbnail_luma_width = dim->thumbnail_width;
-    dim->thumbnail_luma_height = dim->thumbnail_height;
-    dim->thumbnail_chroma_width = dim->thumbnail_width;
-    dim->thumbnail_chroma_height = dim->thumbnail_height;
-    dim->main_img_luma_width = dim->picture_width;
-    dim->main_img_luma_height = dim->picture_height;
-    dim->main_img_chroma_width = dim->picture_width;
-    dim->main_img_chroma_height = dim->picture_height;
-}
-
-int mm_app_load_hal()
-{
-  memset(&my_cam_app, 0, sizeof(my_cam_app));
-  memset(&my_cam_app.hal_lib, 0, sizeof(hal_interface_lib_t));
-#if defined(_MSM7630_)
-   my_cam_app.hal_lib.ptr = dlopen("/usr/lib/hw/camera.msm7630.so", RTLD_LAZY);
-#elif defined(_MSM7627A_)
-   my_cam_app.hal_lib.ptr = dlopen("/usr/lib/hw/camera.msm7627A.so", RTLD_LAZY);
-#else
-  //my_cam_app.hal_lib.ptr = dlopen("hw/camera.msm8960.so", RTLD_NOW);
-   my_cam_app.hal_lib.ptr = dlopen("libmmcamera_interface.so", RTLD_NOW);
-   my_cam_app.hal_lib.ptr_jpeg = dlopen("libmmjpeg_interface.so", RTLD_NOW);
-#endif
-  if (!my_cam_app.hal_lib.ptr) {
-    CDBG_ERROR("%s Error opening HAL library %s\n", __func__, dlerror());
-    return -1;
-  }
-  *(void **)&(my_cam_app.hal_lib.mm_camera_query) =
-        dlsym(my_cam_app.hal_lib.ptr,
-              "camera_query");
-  *(void **)&(my_cam_app.hal_lib.mm_camera_open) =
-        dlsym(my_cam_app.hal_lib.ptr,
-              "camera_open");
-  *(void **)&(my_cam_app.hal_lib.jpeg_open) =
-        dlsym(my_cam_app.hal_lib.ptr_jpeg,
-              "jpeg_open");
-  return 0;
-}
-
-int mm_app_init()
-{
-    int rc = MM_CAMERA_OK;
-    CDBG("%s:BEGIN\n", __func__);
-    my_cam_app.cam_info =  (mm_camera_info_t *)my_cam_app.hal_lib.mm_camera_query(&my_cam_app.num_cameras);
-    if(my_cam_app.cam_info == NULL) {
-        CDBG_ERROR("%s: Failed to query camera\n", __func__);
-        rc = -1;
-    }
-    CDBG("%s:END, num_cameras = %d\n", __func__, my_cam_app.num_cameras);
-    return rc;
-}
-
-static void notify_evt_cb(uint32_t camera_handle,
-                         mm_camera_event_t *evt,void *user_data)
-{
-    CDBG("%s:E evt = %d",__func__,evt->event_type);
-
-    switch(evt->event_type)
-    {
-        case MM_CAMERA_EVT_TYPE_CH:
-        break;
-        case MM_CAMERA_EVT_TYPE_CTRL:
-            break;
-        case MM_CAMERA_EVT_TYPE_STATS:
-            break;
-        case MM_CAMERA_EVT_TYPE_INFO:
-            break;
-        case MM_CAMERA_EVT_TYPE_PRIVATE_EVT:
-            CDBG("%s: private evt (%s)", __func__, (char *)evt->e.pri_evt.evt_data);
-            break;
-        default:
-            break;
-    }
-    CDBG("%s:X",__func__);
-}
-
-int mm_app_open(uint8_t cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = NULL;
-    int i;
-    mm_camera_event_type_t evt;
-
-    pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN\n", __func__);
-    if(pme != NULL) {
-        CDBG("%s:cam already open.nop\n",__func__);
-        goto end;
-    }
-    my_cam_app.cam_open = cam_id;
-    my_cam_app.obj[cam_id] = (mm_camera_app_obj_t *)malloc(sizeof(mm_camera_app_obj_t));
-    pme = my_cam_app.obj[cam_id];
-
-    pme->mem_cam = (mm_camear_mem_vtbl_t *)malloc(sizeof(mm_camear_mem_vtbl_t));
-    memset(pme->mem_cam,0,sizeof(mm_camear_mem_vtbl_t));
-    pme->mem_cam->user_data = pme;
-
-    pme->cam = my_cam_app.hal_lib.mm_camera_open(cam_id,pme->mem_cam);
-    if(pme->cam == NULL) {
-        CDBG("%s:dev open error=%d\n", __func__, rc);
-        memset(pme,0, sizeof(pme));
-        return -1;
-    }
-    CDBG("Open Camera id = %d handle = %d", cam_id, pme->cam->camera_handle);
-
-    pme->cam->ops->sync(pme->cam->camera_handle);
-
-    pme->my_id = cam_id;
-    pme->open_flag = TRUE;
-    mm_app_set_dim_def(&pme->dim);
-
-    for (i = 0; i < MM_CAMERA_EVT_TYPE_MAX; i++) {
-        evt = (mm_camera_event_type_t) i;
-        pme->cam->ops->register_event_notify(pme->cam->camera_handle, notify_evt_cb, pme,evt);
-    }
-    pme->cam_state = CAMERA_STATE_OPEN;
-    pme->cam_mode = CAMERA_MODE;
-    pme->fullSizeSnapshot = 0;
-
-    pme->ch_id = pme->cam->ops->ch_acquire(pme->cam->camera_handle);
-    CDBG("Channel Acquired Successfully %d",pme->ch_id);
-
-    memset(&pme->jpeg_ops, 0, sizeof(mm_jpeg_ops_t));
-    pme->jpeg_hdl = my_cam_app.hal_lib.jpeg_open(&pme->jpeg_ops);
-    if (pme->jpeg_hdl == 0) {
-        CDBG_ERROR("%s: jpeg lib open err", __func__);
-        rc = -1;
-        goto end;
-    }
-
-    pme->ionfd = open("/dev/ion", O_RDONLY);
-    if (pme->ionfd < 0) {
-        CDBG_ERROR("Ion dev open failed\n");
-        CDBG_ERROR("Error is %s\n", strerror(errno));
-        rc = -1;
-    }
-
-end:
-    CDBG("%s:END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_close(int8_t cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN\n", __func__);
-    if(!pme->cam) {
-        CDBG("%s:cam already closed. nop\n",__func__);
-        goto end;
-    }
-
-    pme->cam->ops->ch_release(pme->cam->camera_handle,pme->ch_id);
-    pme->cam->ops->camera_close(pme->cam->camera_handle);
-    pme->open_flag = FALSE;
-    pme->cam = NULL;
-    pme->my_id = 0;
-    free(pme->mem_cam);
-    pme->mem_cam = NULL;
-    memset(&pme->dim, 0, sizeof(pme->dim));
-
-    /* close jpeg client */
-    if (pme->jpeg_hdl && pme->jpeg_ops.close) {
-        pme->jpeg_ops.close(pme->jpeg_hdl);
-        pme->jpeg_hdl = 0;
-    }
-    close(pme->ionfd);
-
-    free(pme);
-    pme = NULL;
-    my_cam_app.obj[cam_id] = NULL;
-
-end:
-    CDBG("%s:END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-void switchRes(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    switch(pme->cam_state) {
-    case CAMERA_STATE_RECORD:
-    if(MM_CAMERA_OK != stopRecording(cam_id)){
-        CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
-        return;
-    }
-    case CAMERA_STATE_PREVIEW:
-        if(MM_CAMERA_OK !=  mm_app_stop_preview(cam_id)){
-            CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
-            return;
-        }
-        break;
-    case CAMERA_STATE_SNAPSHOT:
-    default:
-        break;
-    }
-}
-void switchCamera(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if(my_cam_app.cam_open == cam_id){
-        return;
-    }
-
-    switch(pme->cam_state) {
-        case CAMERA_STATE_RECORD:
-            if(MM_CAMERA_OK != stopRecording(cam_id)){
-                CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
-                return;
-            }
-        case CAMERA_STATE_PREVIEW:
-            if(MM_CAMERA_OK !=  mm_app_stop_preview(cam_id)){
-                CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
-                return;
-            }
-            break;
-        case CAMERA_STATE_SNAPSHOT:
-        default:
-            break;
-    }
-
-    mm_app_close(my_cam_app.cam_open);
-    mm_app_open(cam_id);
-}
-
-int mm_app_set_dim(int8_t cam_id, cam_ctrl_dimension_t *dim)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN\n", __func__);
-
-    memcpy(&pme->dim, dim, sizeof(cam_ctrl_dimension_t));
-    if(MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
-            pme->cam->camera_handle,MM_CAMERA_PARM_DIMENSION, &pme->dim)))
-    {
-        CDBG_ERROR("%s: set dimension err=%d\n", __func__, rc);
-    }
-    CDBG("%s:END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_get_dim(int8_t cam_id, cam_ctrl_dimension_t *dim)
-{
-    int rc = MM_CAMERA_OK;
-#if 0
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    CDBG("%s:BEGIN\n", __func__);
-    if(pme->open_flag != TRUE) {
-        CDBG("%s: dev not open yet\n", __func__);
-        rc = -MM_CAMERA_E_INVALID_OPERATION;
-        goto end;
-    }
-    /* now we only use the upper portion. TBD: needs to be fixed later */
-    //memcpy(&pme->dim, dim, sizeof(cam_ctrl_dimension_t));
-    if(MM_CAMERA_OK != (rc = pme->cam->cfg->get_parm(pme->cam,
-                                                    MM_CAMERA_PARM_DIMENSION, &pme->dim))) {
-        CDBG("%s: set dimension err=%d\n", __func__, rc);
-    }
-    CDBG("%s: raw_w=%d,raw_h=%d\n",
-            __func__, pme->dim.orig_picture_width, pme->dim.orig_picture_height);
-    if(dim)
-    memcpy(dim, &pme->dim, sizeof(cam_ctrl_dimension_t));
-
-end:
-    CDBG("%s:END, rc=%d\n", __func__, rc);
-#endif
-    return rc;
-}
-
-void mm_app_close_ch(int cam_id, int ch_type)
-{
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    pme->cam->ops->ch_release(pme->cam->camera_handle,pme->ch_id);
-    CDBG("%s:END,cam_id = %d, ch = %d\n", __func__, cam_id, ch_type);
-
-}
-
-int mm_app_unit_test()
-{
-    my_cam_app.run_sanity = 1;
-    mm_app_unit_test_entry(&my_cam_app);
-    return 0;
-}
-
-int mm_app_dual_test()
-{
-    my_cam_app.run_sanity = 1;
-    mm_app_dual_test_entry(&my_cam_app);
-    return 0;
-}
-
-int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,mm_camera_buf_def_t *frame)
-{
-    struct ion_flush_data cache_inv_data;
-    struct ion_custom_data custom_data;
-    mm_camear_app_buf_t* app_bufs = NULL;
-    int ion_fd;
-    int index = -1;
-    int i;
-
-    if(frame == NULL) {
-        CDBG_ERROR("%s: Invalid input",__func__);
-        return -1;
-    }
-#ifdef USE_ION
-    for (i = 0; i < MM_QCAM_APP_MAX_STREAM_NUM; i++) {
-        if (pme->stream[i].id == frame->stream_id) {
-            app_bufs = &pme->stream [i].app_bufs;
-            break;
-        }
-    }
-    if(app_bufs == NULL) {
-        CDBG_ERROR("Failed to match Stream");
-        return -1;
-    }
-    for (i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i++) {
-        if (app_bufs->bufs[i].buf_idx == frame->buf_idx) {
-            index = i;
-            break;
-        }
-    }
-    if(index < 0) {
-        CDBG_ERROR("Failed to match Frame");
-        return -1;
-    }
-
-    cache_inv_data.vaddr = app_bufs->bufs[index].buffer;
-    cache_inv_data.fd = app_bufs->bufs[index].fd;
-    cache_inv_data.handle = app_bufs->ion_info_fd[index].handle;
-    cache_inv_data.length = app_bufs->alloc[index].len;
-    cache_inv_data.offset = 0;
-    custom_data.cmd = ION_IOC_INV_CACHES;
-    custom_data.arg = (unsigned long)&cache_inv_data;
-    ion_fd = pme->ionfd;
-
-    CDBG("addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d",
-         cache_inv_data.vaddr,cache_inv_data.fd,cache_inv_data.handle,cache_inv_data.length,ion_fd);
-    if(ion_fd > 0) {
-        if(ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data) < 0)
-            CDBG_ERROR("%s: Cache Invalidate failed\n", __func__);
-        else {
-            CDBG("%s: Successful cache invalidate\n", __func__);
-        }
-    }
-#endif
-    return MM_CAMERA_OK;
-}
-
-int mm_stream_clear_invalid_cache(mm_camera_app_obj_t *pme,mm_camera_buf_def_t *frame)
-{
-
-#ifdef USE_ION
-    int i,index = -1;
-    struct ion_flush_data cache_inv_data;
-    struct ion_custom_data custom_data;
-    mm_camear_app_buf_t* app_bufs = NULL;
-    int ion_fd;
-
-    if (frame) {
-        memset(&cache_inv_data, 0, sizeof(struct ion_flush_data));
-
-        for (i = 0; i < MM_QCAM_APP_MAX_STREAM_NUM; i++) {
-            if (pme->stream[i].id == frame->stream_id) {
-                app_bufs = &pme->stream [i].app_bufs;
-                break;
-            }
-        }
-        if(app_bufs == NULL) {
-            CDBG_ERROR("Failed to match Stream");
-            return -1;
-        }
-        for (i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i++) {
-            if (app_bufs->bufs[i].buf_idx == frame->buf_idx) {
-                index = i;
-                break;
-            }
-        }
-        if(index < 0) {
-            CDBG_ERROR("Failed to match Frame");
-            return -1;
-        }
-
-        cache_inv_data.vaddr = app_bufs->bufs[index].buffer;
-        cache_inv_data.fd = app_bufs->bufs[index].fd;
-        cache_inv_data.handle = app_bufs->ion_info_fd[index].handle;
-        cache_inv_data.length = app_bufs->alloc[index].len;
-        cache_inv_data.offset = 0;
-        custom_data.cmd = ION_IOC_CLEAN_INV_CACHES;
-        custom_data.arg = (unsigned long)&cache_inv_data;
-        ion_fd = pme->ionfd;
-        if(ion_fd > 0) {
-          if(ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data) < 0)
-              ALOGE("%s: Cache Invalidate failed\n", __func__);
-          else {
-              ALOGD("%s: Successful cache invalidate\n", __func__);
-          }
-        }
-    }
-#endif
-    return MM_CAMERA_OK;
-}
-
-int mm_stream_alloc_bufs(mm_camera_app_obj_t *pme,
-                         mm_camear_app_buf_t* app_bufs,
-                         mm_camera_frame_len_offset *frame_offset_info,
-                         uint8_t num_bufs)
-{
-    int i, num_planes;
-
-    num_planes = frame_offset_info->num_planes;
-    CDBG("%s: num_planes = %d",__func__,num_planes);
-
-    app_bufs->num = num_bufs;
-    for (i = 0; i < num_bufs ; i++) {
-        int j;
-        app_bufs->bufs[i].buf_idx = i;
-        app_bufs->alloc[i].len = frame_offset_info->frame_len;
-        app_bufs->alloc[i].flags = ION_FLAG_CACHED;
-        app_bufs->alloc[i].heap_mask =
-        (0x1 << CAMERA_ION_HEAP_ID | 0x1 << ION_IOMMU_HEAP_ID);
-        app_bufs->alloc[i].align = 4096;
-
-        app_bufs->bufs[i].buffer = mm_camera_do_mmap_ion(pme->ionfd,
-                                                         &app_bufs->alloc[i],
-                                                         &app_bufs->ion_info_fd[i],
-                                                         &app_bufs->bufs[i].fd);
-        CDBG(" %s : Buffer allocated fd = %d, length = %d",
-             __func__,app_bufs->bufs[i].fd,app_bufs->alloc[i].len);
-
-        app_bufs->bufs[i].frame_len = app_bufs->alloc[i].len;
-        app_bufs->bufs[i].num_planes = num_planes;
-
-        /* Plane 0 needs to be set seperately. Set other planes
-             * in a loop. */
-        app_bufs->bufs[i].planes[0].length = frame_offset_info->mp[0].len;
-        app_bufs->bufs[i].planes[0].m.userptr = app_bufs->bufs[i].fd;
-        app_bufs->bufs[i].planes[0].data_offset = frame_offset_info->mp[0].offset;
-        app_bufs->bufs[i].planes[0].reserved[0] = 0;
-        for (j = 1; j < num_planes; j++) {
-            app_bufs->bufs[i].planes[j].length = frame_offset_info->mp[j].len;
-            app_bufs->bufs[i].planes[j].m.userptr = app_bufs->bufs[i].fd;
-            app_bufs->bufs[i].planes[j].data_offset = frame_offset_info->mp[j].offset;
-            app_bufs->bufs[i].planes[j].reserved[0] =
-                app_bufs->bufs[i].planes[j-1].reserved[0] +
-                app_bufs->bufs[i].planes[j-1].length;
-        }
-    }
-    CDBG("%s: X",__func__);
-    return MM_CAMERA_OK;
-}
-
-int mm_stream_release_bufs(mm_camera_app_obj_t *pme,
-                        mm_camear_app_buf_t* app_bufs)
-{
-    int i, rc = MM_CAMERA_OK;
-
-    CDBG("%s: E",__func__);
-
-    for (i = 0; i < app_bufs->num; i++) {
-        rc = mm_camera_do_munmap_ion (pme->ionfd,
-                                      &app_bufs->ion_info_fd[i],
-                                      (void *)app_bufs->bufs[i].buffer,
-                                      app_bufs->bufs[i].frame_len);
-    }
-    memset(app_bufs, 0, sizeof(mm_camear_app_buf_t));
-    CDBG("%s: X",__func__);
-    return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_display.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_display.c
deleted file mode 100755
index 9c27054..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_display.c
+++ /dev/null
@@ -1,572 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <sys/ioctl.h>
-struct file;
-struct inode;
-#include <linux/android_pmem.h>
-#include <sys/mman.h>
-#include <errno.h>
-#include <sys/time.h>
-#include <string.h>
-
-#include <inttypes.h>
-#include <linux/msm_mdp.h>
-#include <linux/fb.h>
-#include "camera.h"
-#include "mm_camera_dbg.h"
-
-#ifdef DRAW_RECTANGLES
-extern roi_info_t camframe_roi;
-
-#undef CAM_FRM_DRAW_RECT
-#define CAM_FRM_DRAW_RECT
-#endif
-
-#ifdef CAM_FRM_DRAW_FD_RECT
-#undef CAM_FRM_DRAW_RECT
-#define CAM_FRM_DRAW_RECT
-#endif
-
-struct fb_var_screeninfo vinfo;
-struct fb_fix_screeninfo finfo;
-int fb_fd = 0;
-union {
-  char dummy[sizeof(struct mdp_blit_req_list) +
-    sizeof(struct mdp_blit_req) * 1];
-  struct mdp_blit_req_list list;
-} yuv;
-
-static pthread_t cam_frame_fb_thread_id;
-static int camframe_fb_exit;
-
-static int is_camframe_fb_thread_ready;
-USER_INPUT_DISPLAY_T input_display;
-
-unsigned use_overlay = 0;
-struct msmfb_overlay_data ov_front, ov_back, *ovp_front, *ovp_back;
-struct mdp_overlay overlay, *overlayp;
-int vid_buf_front_id, vid_buf_back_id;
-static unsigned char please_initialize = 1;
-int num_of_ready_frames = 0;
-
-static pthread_cond_t  sub_thread_ready_cond  = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t sub_thread_ready_mutex = PTHREAD_MUTEX_INITIALIZER;
-pthread_cond_t  camframe_fb_cond  = PTHREAD_COND_INITIALIZER;
-pthread_mutex_t camframe_fb_mutex = PTHREAD_MUTEX_INITIALIZER;
-static void notify_camframe_fb_thread();
-
-void use_overlay_fb_display_driver(void)
-{
-  use_overlay = 1;
-}
-
-void overlay_set_params(struct mdp_blit_req *e)
-{
-  int result;
-
-  if (please_initialize) {
-    overlayp = &overlay;
-    ovp_front = &ov_front;
-    ovp_back = &ov_back;
-
-    overlayp->id = MSMFB_NEW_REQUEST;
-  }
-
-  overlayp->src.width  = e->src.width;
-  overlayp->src.height = e->src.height;
-  overlayp->src.format = e->src.format;
-
-  overlayp->src_rect.x = e->src_rect.x;
-  overlayp->src_rect.y = e->src_rect.y;
-  overlayp->src_rect.w = e->src_rect.w;
-  overlayp->src_rect.h = e->src_rect.h;
-
-  overlayp->dst_rect.x = e->dst_rect.x;
-  overlayp->dst_rect.y = e->dst_rect.y;
-  /* ROTATOR is enabled in overlay library, swap dimensions
-     here to take care of that */
-  overlayp->dst_rect.w = e->dst_rect.h;
-  overlayp->dst_rect.h = e->dst_rect.w;
-
-  if (overlayp->dst_rect.w > 480)
-    overlayp->dst_rect.w = 480;
-  if (overlayp->dst_rect.h > 800)
-    overlayp->dst_rect.h = 800;
-
-  overlayp->z_order = 0; // FB_OVERLAY_VID_0;
-  overlayp->alpha = e->alpha;
-  overlayp->transp_mask = 0; /* 0xF81F */
-  overlayp->flags = e->flags;
-  overlayp->is_fg = 1;
-
-  if (please_initialize) {
-    CDBG("src.width %d height %d; src_rect.x %d y %d w %d h %d; dst_rect.x %d y %d w %d h %d\n",
-      overlayp->src.width, overlayp->src.height,
-      overlayp->src_rect.x, overlayp->src_rect.y, overlayp->src_rect.w, overlayp->src_rect.h,
-      overlayp->dst_rect.x, overlayp->dst_rect.y, overlayp->dst_rect.w, overlayp->dst_rect.h
-      );
-
-    result = ioctl(fb_fd, MSMFB_OVERLAY_SET, overlayp);
-    if (result < 0) {
-      CDBG("ERROR: MSMFB_OVERLAY_SET failed!, result =%d\n", result);
-    }
-  }
-
-  if (please_initialize) {
-    vid_buf_front_id = overlayp->id; /* keep return id */
-
-    ov_front.id = overlayp->id;
-    ov_back.id = overlayp->id;
-    please_initialize = 0;
-  }
-
-  return;
-}
-
-void overlay_set_frame(struct msm_frame *frame)
-{
-  ov_front.data.offset = 0;
-  ov_front.data.memory_id = frame->fd;
-  return;
-}
-
-/*===========================================================================
- * FUNCTION     test_app_camframe_callback
- * DESCRIPTION  display frame
- *==========================================================================*/
-void test_app_camframe_callback(struct msm_frame *frame)
-{
-  int result = 0;
-  struct mdp_blit_req *e;
-  struct timeval td1, td2;
-  struct timezone tz;
-
-  common_crop_t *crop = (common_crop_t *) (frame->cropinfo);
-
-  /* Initialize yuv structure */
-  yuv.list.count = 1;
-
-  e = &yuv.list.req[0];
-
-  e->src.width = input_display.user_input_display_width;
-  e->src.height = input_display.user_input_display_height;
-  e->src.format = MDP_Y_CRCB_H2V2;
-  e->src.offset = 0;
-  e->src.memory_id = frame->fd;
-
-  e->dst.width = vinfo.xres;
-  e->dst.height = vinfo.yres;
-  e->dst.format = MDP_RGB_565;
-  e->dst.offset = 0;
-  e->dst.memory_id = fb_fd;
-
-  e->transp_mask = 0xffffffff;
-  e->flags = 0;
-  e->alpha = 0xff;
-
-  /* Starting doing MDP Cropping */
-  if (frame->path == OUTPUT_TYPE_P) {
-
-    if (crop->in2_w != 0 || crop->in2_h != 0) {
-
-      e->src_rect.x = (crop->out2_w - crop->in2_w + 1) / 2 - 1;
-
-      e->src_rect.y = (crop->out2_h - crop->in2_h + 1) / 2 - 1;
-
-      e->src_rect.w = crop->in2_w;
-      e->src_rect.h = crop->in2_h;
-
-      CDBG("e->src_rect.x = %d\n", e->src_rect.x);
-      CDBG("e->src_rect.y = %d\n", e->src_rect.y);
-      CDBG("e->src_rect.w = %d\n", e->src_rect.w);
-      CDBG("e->src_rect.h = %d\n", e->src_rect.h);
-
-      e->dst_rect.x = 0;
-      e->dst_rect.y = 0;
-      e->dst_rect.w = input_display.user_input_display_width;
-      e->dst_rect.h = input_display.user_input_display_height;
-    } else {
-      e->src_rect.x = 0;
-      e->src_rect.y = 0;
-      e->src_rect.w = input_display.user_input_display_width;
-      e->src_rect.h = input_display.user_input_display_height;
-
-      e->dst_rect.x = 0;
-      e->dst_rect.y = 0;
-      e->dst_rect.w = input_display.user_input_display_width;
-      e->dst_rect.h = input_display.user_input_display_height;
-    }
-    if (use_overlay) overlay_set_params(e);
-  } else {
-
-  }
-
-  gettimeofday(&td1, &tz);
-
-  if (use_overlay) overlay_set_frame(frame);
-  else {
-    result = ioctl(fb_fd, MSMFB_BLIT, &yuv.list);
-    if (result < 0) {
-      CDBG("MSM_FBIOBLT failed! line=%d\n", __LINE__);
-    }
-  }
-
-  gettimeofday(&td2, &tz);
-  CDBG("Profiling: MSMFB_BLIT takes %ld microseconds\n",
-    ((td2.tv_sec - td1.tv_sec) * 1000000 + (td2.tv_usec - td1.tv_usec)));
-
-  td1 = td2;
-  notify_camframe_fb_thread();
-  /* add frame back to the free queue*/
-  //camframe_add_frame(CAM_PREVIEW_FRAME, frame);
-}
-
-void notify_camframe_fb_thread()
-{
-  pthread_mutex_lock(&camframe_fb_mutex);
-
-  num_of_ready_frames ++;
-  pthread_cond_signal(&camframe_fb_cond);
-
-  pthread_mutex_unlock(&camframe_fb_mutex);
-}
-
-void camframe_fb_thread_ready_signal(void);
-
-void *camframe_fb_thread(void *data)
-{
-  int result = 0;
-  static struct timeval td1, td2;
-  struct timezone tz;
-
-#ifdef _ANDROID_
-  fb_fd = open(ANDROID_FB0, O_RDWR);
-  CDBG("%s:android dl '%s', fd=%d\n", __func__, ANDROID_FB0, fb_fd);
-#else
-  fb_fd = open(LE_FB0, O_RDWR);
-  CDBG("%s:LE_FB0 dl, '%s', fd=%d\n", __func__, LE_FB0, fb_fd);
-#endif
-  if (fb_fd < 0) {
-    CDBG_ERROR("cannot open framebuffer %s or %s file node\n",
-      ANDROID_FB0, LE_FB0);
-    goto fail1;
-  }
-
-  if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo) < 0) {
-    CDBG_ERROR("cannot retrieve vscreenInfo!\n");
-    goto fail;
-  }
-
-  if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo) < 0) {
-    CDBG_ERROR("can't retrieve fscreenInfo!\n");
-    goto fail;
-  }
-
-  vinfo.activate = FB_ACTIVATE_VBL;
-
-  camframe_fb_thread_ready_signal();
-
-  pthread_mutex_lock(&camframe_fb_mutex);
-  while (!camframe_fb_exit) {
-    CDBG("cam_frame_fb_thread: num_of_ready_frames: %d\n", num_of_ready_frames);
-    if (num_of_ready_frames <= 0) {
-      pthread_cond_wait(&camframe_fb_cond, &camframe_fb_mutex);
-    }
-    if (num_of_ready_frames > 0) {
-      num_of_ready_frames --;
-
-      gettimeofday(&td1, &tz);
-      if (use_overlay) {
-        result = ioctl(fb_fd, MSMFB_OVERLAY_PLAY, ovp_front);
-      } else {
-        result = ioctl(fb_fd, FBIOPAN_DISPLAY, &vinfo);
-      }
-
-      gettimeofday(&td2, &tz);
-
-      CDBG("Profiling: frame timestamp after FBIO display = %ld ms\n",
-        (td2.tv_sec*1000) + (td2.tv_usec/1000));
-
-      CDBG("cam_frame_fb_thread: elapse time for FBIOPAN_DISPLAY = %ld, return = %d\n",
-        (td2.tv_sec - td1.tv_sec) * 1000000 + td2.tv_usec - td1.tv_usec, result);
-
-      if (result < 0) {
-        CDBG("DISPLAY: Failed\n");
-      }
-    }
-  }
-
-  pthread_mutex_unlock(&camframe_fb_mutex);
-
-  if (use_overlay) {
-    if (ioctl(fb_fd, MSMFB_OVERLAY_UNSET, &vid_buf_front_id)) {
-      CDBG("\nERROR! MSMFB_OVERLAY_UNSET failed! (Line %d)\n", __LINE__);
-      goto fail;
-    }
-  }
-
-  return NULL;
-
-  fail:
-  close(fb_fd);
-  fail1:
-  camframe_fb_exit = -1;
-  camframe_fb_thread_ready_signal();
-  return NULL;
-}
-
-int launch_camframe_fb_thread(void)
-{
-
-  camframe_fb_exit = 0;
-  is_camframe_fb_thread_ready = 0;
-  pthread_create(&cam_frame_fb_thread_id, NULL, camframe_fb_thread, NULL);
-
-  /* Waiting for launching sub thread ready signal. */
-  CDBG("launch_camframe_fb_thread(), call pthread_cond_wait\n");
-
-  pthread_mutex_lock(&sub_thread_ready_mutex);
-  if (!is_camframe_fb_thread_ready) {
-    pthread_cond_wait(&sub_thread_ready_cond, &sub_thread_ready_mutex);
-  }
-  pthread_mutex_unlock(&sub_thread_ready_mutex);
-
-  CDBG("launch_camframe_fb_thread(), call pthread_cond_wait done\n");
-  CDBG("%s:fb rc=%d\n", __func__, camframe_fb_exit);
-  return camframe_fb_exit;
-}
-
-void release_camframe_fb_thread(void)
-{
-  camframe_fb_exit = 1;
-  please_initialize = 1;
-
-  /* Notify the camframe fb thread to wake up */
-  if (cam_frame_fb_thread_id != 0) {
-     pthread_mutex_lock(&camframe_fb_mutex);
-     pthread_cond_signal(&camframe_fb_cond);
-     pthread_mutex_unlock(&camframe_fb_mutex);
-     if (pthread_join(cam_frame_fb_thread_id, NULL) != 0) {
-       CDBG("cam_frame_fb_thread exit failure!\n");
-     }
-     close(fb_fd);
-  }
-}
-
-void camframe_fb_thread_ready_signal(void)
-{
-  /* Send the signal to control thread to indicate that the cam frame fb
-   * ready.
-   */
-  CDBG("cam_frame_fb_thread() is ready, call pthread_cond_signal\n");
-
-  pthread_mutex_lock(&sub_thread_ready_mutex);
-  is_camframe_fb_thread_ready = 1;
-  pthread_cond_signal(&sub_thread_ready_cond);
-  pthread_mutex_unlock(&sub_thread_ready_mutex);
-
-  CDBG("cam_frame_fb_thread() is ready, call pthread_cond_signal done\n");
-}
-
-#ifdef CAM_FRM_DRAW_RECT
-void draw_rect(char *buf, int buf_w,
-  int x, int y, int dx, int dy)
-{
-  int i;
-  int left   = x;
-  int right  = x+dx;
-  int top    = y;
-  int bottom = y+dy;
-
-  for (i = left; i < right; i++) {
-    buf[top*buf_w+i] = 0xff;
-    buf[bottom*buf_w+i] = 0xff;
-  }
-  for (i = top; i < bottom; i++) {
-    buf[i*buf_w+left] = 0xff;
-    buf[i*buf_w+right] = 0xff;
-  }
-}
-#endif
-
-void draw_rectangles(struct msm_frame* newFrame)
-{
-  struct fd_roi_t *p_fd_roi;
-#ifdef DRAW_RECTANGLES
-  uint8_t i;
-  for (i = 0; i < camframe_roi.num_roi; i++) {
-    CDBG("%s: camframe_roi: i=%d, x=%d, y=%d, dx=%d, dy=%d\n", __func__,
-      i, camframe_roi.roi[i].x, camframe_roi.roi[i].y,
-      camframe_roi.roi[i].dx, camframe_roi.roi[i].dy);
-    draw_rect((char*)newFrame->buffer, 640,
-      camframe_roi.roi[i].x, camframe_roi.roi[i].y,
-      camframe_roi.roi[i].dx, camframe_roi.roi[i].dy);
-  }
-#endif
-
-#ifdef CAM_FRM_DRAW_FD_RECT
-  p_fd_roi = (struct fd_roi_t *)newFrame->roi_info.info;
-  if(p_fd_roi && p_fd_roi->rect_num > 0){
-    int i;
-    for(i =0; i < p_fd_roi->rect_num; i++)
-    {
-      draw_rect((char*)newFrame->buffer, 800,
-        p_fd_roi->faces[i].x, p_fd_roi->faces[i].y,
-        p_fd_roi->faces[i].dx, p_fd_roi->faces[i].dy);
-    }
-  }
-#endif
-}
-
-/*===========================================================================
- * FUNCTION    - v4l2_render -
- *
- * DESCRIPTION:
- *==========================================================================*/
-int v4l2_render(int frame_fd, struct v4l2_buffer *vb, struct v4l2_crop *crop)
-{
-  struct mdp_blit_req *e;
-  /* Initialize yuv structure */
-  yuv.list.count = 1;
-  e = &yuv.list.req[0];
-
-  e->src.width = input_display.user_input_display_width;
-  e->src.height = input_display.user_input_display_height;
-  e->src.format = MDP_Y_CBCR_H2V2;
-  e->src.offset = 0;
-  e->src.memory_id = frame_fd;
-
-  e->dst.width = vinfo.xres;
-  e->dst.height = vinfo.yres;
-  e->dst.format = MDP_RGB_565;
-  e->dst.offset = 0;
-  e->dst.memory_id = fb_fd;
-
-  e->transp_mask = 0xffffffff;
-  e->flags = 0;
-  e->alpha = 0xff;
-
- if (crop != NULL && (crop->c.width != 0 || crop->c.height != 0)) {
-    e->src_rect.x = crop->c.left;
-    e->src_rect.y = crop->c.top;
-    e->src_rect.w = crop->c.width;
-    e->src_rect.h = crop->c.height;
-
-    e->dst_rect.x = 0;
-    e->dst_rect.y = 0;
-    e->dst_rect.w = input_display.user_input_display_width;
-    e->dst_rect.h = input_display.user_input_display_height;
-  } else {
-    e->dst_rect.x = 0;
-    e->dst_rect.y = 0;
-    e->dst_rect.w  = input_display.user_input_display_width;
-    e->dst_rect.h  = input_display.user_input_display_height;
-
-    e->src_rect.x = 0;
-    e->src_rect.y = 0;
-    e->src_rect.w  = input_display.user_input_display_width;
-    e->src_rect.h  = input_display.user_input_display_height;
-  }
-  overlay_set_params(e);
-  ov_front.data.offset = 0;
-  ov_front.data.memory_id = frame_fd;
-  notify_camframe_fb_thread();
-
-  return TRUE;
-}
-
-int mm_app_dl_render(int frame_fd, struct crop_info * cropinfo)
-{
-  struct mdp_blit_req *e;
-  int croplen = 0;
-  //struct crop_info *cropinfo;
-  common_crop_t *crop;
-
-  //cropinfo = (struct crop_info *)vb->input;
-  if(cropinfo != NULL) {
-    crop = (common_crop_t *)cropinfo->info;
-  }
-  /* Initialize yuv structure */
-  yuv.list.count = 1;
-  e = &yuv.list.req[0];
-
-  e->src.width = input_display.user_input_display_width;
-  e->src.height = input_display.user_input_display_height;
-  e->src.format = MDP_Y_CRCB_H2V2;
-  e->src.offset = 0;
-  e->src.memory_id = frame_fd;
-
-  e->dst.width = vinfo.xres;
-  e->dst.height = vinfo.yres;
-  e->dst.format = MDP_RGB_565;
-  e->dst.offset = 0;
-  e->dst.memory_id = fb_fd;
-
-  e->transp_mask = 0xffffffff;
-  e->flags = 0;
-  e->alpha = 0xff;
-
-  if (cropinfo != NULL && (crop->in2_w != 0 || crop->in2_h != 0)) {
-    e->src_rect.x = (crop->out2_w - crop->in2_w + 1) / 2 - 1;
-    e->src_rect.y = (crop->out2_h - crop->in2_h + 1) / 2 - 1;
-    e->src_rect.w = crop->in2_w;
-    e->src_rect.h = crop->in2_h;
-
-    e->dst_rect.x = 0;
-    e->dst_rect.y = 0;
-    e->dst_rect.w = input_display.user_input_display_width;
-    e->dst_rect.h = input_display.user_input_display_height;
-  } else {
-    e->dst_rect.x = 0;
-    e->dst_rect.y = 0;
-    e->dst_rect.w  = input_display.user_input_display_width;
-    e->dst_rect.h  = input_display.user_input_display_height;
-
-    e->src_rect.x = 0;
-    e->src_rect.y = 0;
-    e->src_rect.w  = input_display.user_input_display_width;
-    e->src_rect.h  = input_display.user_input_display_height;
-  }
-
-  overlay_set_params(e);
-
-  ov_front.data.offset = 0;
-  ov_front.data.memory_id = frame_fd;
-  notify_camframe_fb_thread();
-
-  return TRUE;
-}
-
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_dual_test.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_dual_test.c
deleted file mode 100755
index 6a3515c..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_dual_test.c
+++ /dev/null
@@ -1,1936 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include "mm_qcamera_unit_test.h"
-
-#define MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP 4
-#define MM_QCAM_APP_TEST_NUM 128
-
-#define MM_QCAMERA_APP_WAIT_TIME 1000000000
-
-extern int system_dimension_set(int cam_id);
-extern int stopPreview(int cam_id);
-extern int takePicture_yuv(int cam_id);
-extern int takePicture_rdi(int cam_id);
-extern int startRdi(int cam_id);
-extern int stopRdi(int cam_id);
-extern int startStats(int cam_id);
-extern int stopStats(int cam_id);
-
-
-/*
-* 1. open back
-* 2. open front
-* 3. start back
-* 4. start front
-* 5. stop back
-* 6. stop front
-* 7. close back
-* 8. close front
-* 9. take picture
-* a. start recording
-* b. stop recording
-* c. take picture rdi
-*/
-static mm_app_tc_t mm_app_tc[MM_QCAM_APP_TEST_NUM];
-static int num_test_cases = 0;
-struct test_case_params {
-  uint16_t launch;
-  uint16_t preview;
-  uint16_t recording;
-  uint16_t snapshot;
-};
-
-/*  Test case 12436857 :*/
-
-int mm_app_dtc_0(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 0...\n");
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Rdi for front \n");
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL start camera Preview for back \n");
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL stop camera Rdi for front \n");
-        if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-
-        CDBG_ERROR("DUAL close front camera\n");
-        if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        sleep(1);
-        CDBG_ERROR("DUAL stop camera Preview for back \n");
-        if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-                CDBG("%s: startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL close back camera \n");
-        if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case 12436587 :*/
-
-int mm_app_dtc_1(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 1...\n");
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Rdi for front \n");
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL start camera Preview for back \n");
-
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL end \n");
-
-        CDBG_ERROR("DUAL stop camera Preview for front \n");
-        if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL stop camera Preview for back \n");
-        if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-                CDBG("%s: startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL close front camera\n");
-        if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL close back camera \n");
-        if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case 12436578 :*/
-
-int mm_app_dtc_2(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 2...\n");
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Rdi for front \n");
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL start camera Preview for back \n");
-
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL end \n");
-
-        CDBG_ERROR("DUAL stop camera Preview for front \n");
-        if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL stop camera Preview for back \n");
-        if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-                CDBG("%s: startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL close back camera \n");
-        if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL close front camera\n");
-        if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case 241395768 : 1357 * 3, This is performed three times
-* And for each iteration 9 is performed thrice */
-
-int mm_app_dtc_3(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j,k;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview and snapshot on back Camera and RDI on Front camera 3...\n");
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Preview for front \n");
-
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() frontcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        usleep(10*1000);
-
-        for (k = 0; k < MM_QCAMERA_APP_INTERATION ; k++) {
-          CDBG_ERROR("DUAL open back camera %d \n",k);
-          if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                  CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                  rc = -1;
-                  goto end;
-          }
-
-          if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                  CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                  rc = -1;
-                  goto end;
-          }
-
-          CDBG_ERROR("DUAL start camera Preview for back \n");
-          if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                 CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                  goto end;
-          }
-
-          for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-              CDBG_ERROR("DUAL take picture for back \n");
-              if ( MM_CAMERA_OK != (rc = takePicture_yuv(back_camera))) {
-                  CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
-                  break;
-              }
-              mm_camera_app_wait();
-
-          }
-          usleep(10*1000);
-          CDBG_ERROR("DUAL stop camera Preview for back \n");
-          if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-                  CDBG_ERROR("%s: stopPreview() backcamera err=%d\n", __func__, rc);
-                  goto end;
-          }
-          usleep(10*1000);
-
-          CDBG_ERROR("DUAL close back camera\n");
-          if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-                  CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                  rc = -1;
-                  goto end;
-          }
-          usleep(20*1000);
-        }
-        CDBG_ERROR("DUAL stop camera Preview for Rdi \n");
-        if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-                CDBG("%s: stopRdi() err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL close front camera \n");
-        if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case 2413ab5768 : 1357 * 3, This is performed three times
-* And for each iteration ab is performed thrice */
-
-int mm_app_dtc_4(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j,k;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 4...\n");
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Preview for front \n");
-
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() frontcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        usleep(20*1000);
-
-        for (k = 0; k < MM_QCAMERA_APP_INTERATION ; k++){
-          CDBG_ERROR("DUAL open back camera %d \n",k);
-          if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                 CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                 rc = -1;
-                 goto end;
-          }
-
-          if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                 CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                 rc = -1;
-                 goto end;
-          }
-
-          CDBG_ERROR("DUAL start camera Preview for back \n");
-          if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                 goto end;
-          }
-          usleep(30*1000);
-
-          for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-             CDBG_ERROR("DUAL start camera record for back \n");
-             if ( MM_CAMERA_OK != (rc = startRecording(back_camera))) {
-                 CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
-                 break;
-             }
-
-             mm_camera_app_wait();
-             usleep(15*1000);
-             CDBG_ERROR("DUAL stop camera record for back \n");
-             if ( MM_CAMERA_OK != (rc = stopRecording(back_camera))) {
-                 CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
-                 break;
-             }
-          }
-          usleep(10*1000);
-
-          CDBG_ERROR("DUAL stop camera Preview for back \n");
-          if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-                 CDBG_ERROR("%s: stopPreview() backcamera err=%d\n", __func__, rc);
-                 goto end;
-          }
-          usleep(10*1000);
-
-          CDBG_ERROR("DUAL close back camera\n");
-          if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-                 CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                 rc = -1;
-                 goto end;
-          }
-          usleep(20*1000);
-        }
-        CDBG_ERROR("DUAL stop camera Preview for Rdi \n");
-        if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-                CDBG("%s: stopRdi() err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL close front camera \n");
-        if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case 24135768 : 1357 * 3, This is performed three times*/
-
-int mm_app_dtc_5(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j,k;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 5...\n");
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Preview for front \n");
-
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() frontcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        for (k = 0; k < 4 ; k++) {
-          CDBG_ERROR("DUAL open back camera %d \n",k);
-          if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                  CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                  rc = -1;
-                  goto end;
-          }
-
-          if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                  CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                  rc = -1;
-                  goto end;
-          }
-
-          CDBG_ERROR("DUAL start camera Preview for back \n");
-          if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                 CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                  goto end;
-          }
-          mm_camera_app_wait();
-          sleep(1);
-
-          CDBG_ERROR("DUAL stop camera Preview for back \n");
-          if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-                  CDBG_ERROR("%s: stopPreview() backcamera err=%d\n", __func__, rc);
-                  goto end;
-          }
-          usleep(10*1000);
-
-          CDBG_ERROR("DUAL close back camera\n");
-          if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-                  CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                  rc = -1;
-                  goto end;
-          }
-          sleep(1);
-        }
-        CDBG_ERROR("DUAL stop camera Preview for Rdi \n");
-        if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-                CDBG("%s: stopRdi() err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL close front camera \n");
-        if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case 13246857 : 2468 * 3, This is performed three times*/
-
-int mm_app_dtc_6(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j,k;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 6...\n");
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Preview for back \n");
-
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        for (k = 0; k < 4 ; k++) {
-        CDBG_ERROR("DUAL open front camera %d \n",k);
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Rdi for front \n");
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL stop camera Preview for front \n");
-        if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-
-        CDBG_ERROR("DUAL close front camera\n");
-        if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        sleep(1);
-        }
-        CDBG_ERROR("DUAL stop camera Preview for back \n");
-        if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-                CDBG("%s: startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL close back camera \n");
-        if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*Multi Threaded Test Cases*/
-static void *front_thread(void *data)
-{
-        int front_camera = 1;
-        int rc = MM_CAMERA_OK;
-        int i,j,k,m;
-        struct test_case_params params
-          = *((struct test_case_params *)data);
-        for (i = 0; i < params.launch; i++) {
-          CDBG_ERROR("DUAL open front camera %d\n",i);
-          if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-          }
-
-          if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-          }
-
-          for (j = 0; j < params.preview; j++) {
-            CDBG_ERROR("DUAL start camera Rdi for front %d ,%d \n",i,j);
-            if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-              CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-              goto end;
-            }
-            mm_camera_app_wait();
-            usleep(20*1000);
-            for (k = 0; k < params.snapshot; k++) {
-              CDBG_ERROR("DUAL take picture for front %d,%d,%d \n",i,j,k);
-              if ( MM_CAMERA_OK != (rc = takePicture_rdi(front_camera))) {
-                CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
-                goto end;
-              }
-              mm_camera_app_wait();
-              usleep(30*1000);
-            }
-            CDBG_ERROR("DUAL stop camera Rdi for front %d,%d\n",i,j);
-            if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-              CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-              goto end;
-            }
-            usleep(10*1000);
-          }
-
-          CDBG_ERROR("DUAL close front camera %d\n",i);
-          if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-          }
-        }
-end:
-        CDBG_ERROR("DUAL front thread close %d",rc);
-        return NULL;
-}
-
-static void *back_thread(void *data)
-{
-        int rc = MM_CAMERA_OK;
-        int back_camera = 0;
-        int i,j,k,m;
-        struct test_case_params params
-          = *((struct test_case_params *)data);
-        for (i = 0; i < params.launch; i++) {
-          CDBG_ERROR("DUAL open back camera %d\n",i);
-          if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-          }
-          if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-          }
-
-          for (j = 0; j < params.preview; j++) {
-            CDBG_ERROR("DUAL start camera Preview for back %d, %d\n",i,j);
-            if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-              CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-              goto end;
-            }
-            mm_camera_app_wait();
-            usleep(20*1000);
-            for (k = 0; k < params.snapshot; k++) {
-              CDBG_ERROR("DUAL take picture for back %d, %d, %d\n",i,j,k);
-              if ( MM_CAMERA_OK != (rc = takePicture_yuv(back_camera))) {
-                CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
-                goto end;
-              }
-              mm_camera_app_wait();
-              usleep(30*1000);
-            }
-
-            for (m = 0; m < params.recording; m++) {
-              CDBG_ERROR("DUAL start record for back %d, %d, %d\n",i,j,m);
-              if ( MM_CAMERA_OK != (rc = startRecording(back_camera))) {
-                CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
-                break;
-              }
-
-              mm_camera_app_wait();
-              usleep(10*1000);
-              CDBG_ERROR("DUAL stop camera record for back \n");
-              if ( MM_CAMERA_OK != (rc = stopRecording(back_camera))) {
-                CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
-                break;
-              }
-              usleep(10*1000);
-            }
-            CDBG_ERROR("DUAL stop camera Preview for back %d, %d\n",i,j);
-            if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-              CDBG("%s: startPreview() err=%d\n", __func__, rc);
-              goto end;
-            }
-            usleep(10*1000);
-          }
-
-          CDBG_ERROR("DUAL close back camera %d\n",i);
-          if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-          }
-        }
-end:
-        CDBG_ERROR("DUAL back thread close %d",rc);
-        return NULL;
-}
-
-/*  Test case m13572468 : Open & start  in 2 concurrent pthread*/
-int mm_app_dtc_7(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int result = 0;
-        pthread_t back_thread_id, front_thread_id;
-        struct test_case_params params;
-        memset(&params, 0, sizeof(struct test_case_params));
-        params.launch = 5;
-        params.preview = 5;
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 7...\n");
-
-        CDBG_ERROR("start back DUAL ");
-        rc = pthread_create(&back_thread_id, NULL, back_thread, &params);
-        CDBG_ERROR("start front DUAL ");
-        rc = pthread_create(&front_thread_id, NULL, front_thread, &params);
-        sleep(1);
-        CDBG_ERROR("stop back DUAL ");
-        rc = pthread_join(back_thread_id, NULL);
-        CDBG_ERROR("stop front DUAL ");
-        rc = pthread_join(front_thread_id, NULL);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-          printf("\nPassed\n");
-        }else{
-          printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case m139572468 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_8(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int result = 0;
-
-        pthread_t back_thread_id, front_thread_id;
-        struct test_case_params bparams, fparams;
-        memset(&bparams, 0, sizeof(struct test_case_params));
-        memset(&fparams, 0, sizeof(struct test_case_params));
-        bparams.launch = 5;
-        bparams.preview = 5;
-        bparams.snapshot= 5;
-        fparams.launch = 5;
-        fparams.preview = 5;
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 8...\n");
-
-        CDBG_ERROR("start back DUAL ");
-        rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
-        CDBG_ERROR("start front DUAL ");
-        rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
-        sleep(1);
-        CDBG_ERROR("stop back DUAL ");
-        rc = pthread_join(back_thread_id, NULL);
-        CDBG_ERROR("stop front DUAL ");
-        rc = pthread_join(front_thread_id, NULL);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0)
-          printf("\nPassed\n");
-        else
-          printf("\nFailed\n");
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case m1395724c68 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_9(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int result = 0;
-
-        pthread_t back_thread_id, front_thread_id;
-        struct test_case_params bparams, fparams;
-        memset(&bparams, 0, sizeof(struct test_case_params));
-        memset(&fparams, 0, sizeof(struct test_case_params));
-        bparams.launch = 5;
-        bparams.preview = 5;
-        bparams.snapshot= 5;
-        fparams.launch = 5;
-        fparams.preview = 5;
-        fparams.snapshot = 5;
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 9...\n");
-
-        CDBG_ERROR("start back DUAL ");
-        rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
-        CDBG_ERROR("start front DUAL ");
-        rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
-        sleep(1);
-        CDBG_ERROR("stop back DUAL ");
-        rc = pthread_join(back_thread_id, NULL);
-        CDBG_ERROR("stop front DUAL ");
-        rc = pthread_join(front_thread_id, NULL);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-          printf("\nPassed\n");
-        }else{
-          printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case m13ab572468 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_10(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int result = 0;
-
-        pthread_t back_thread_id, front_thread_id;
-        struct test_case_params bparams, fparams;
-        memset(&bparams, 0, sizeof(struct test_case_params));
-        memset(&fparams, 0, sizeof(struct test_case_params));
-        bparams.launch = 5;
-        bparams.preview = 5;
-        bparams.recording= 5;
-        fparams.launch = 5;
-        fparams.preview = 5;
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 10...\n");
-
-        CDBG_ERROR("start back DUAL ");
-        rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
-        CDBG_ERROR("start front DUAL ");
-        rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
-        sleep(1);
-        CDBG_ERROR("stop back DUAL ");
-        rc = pthread_join(back_thread_id, NULL);
-        CDBG_ERROR("stop front DUAL ");
-        rc = pthread_join(front_thread_id, NULL);
-        CDBG_ERROR("DUAL end \n");
-end:
-        if(rc == 0) {
-          printf("\nPassed\n");
-        }else{
-          printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case m13ab5724c68 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_11(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int result = 0;
-
-        pthread_t back_thread_id, front_thread_id;
-        struct test_case_params bparams, fparams;
-        memset(&bparams, 0, sizeof(struct test_case_params));
-        memset(&fparams, 0, sizeof(struct test_case_params));
-        bparams.launch = 5;
-        bparams.preview = 5;
-        bparams.recording= 5;
-        fparams.launch = 5;
-        fparams.preview = 5;
-        fparams.snapshot = 5;
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 11...\n");
-
-        CDBG_ERROR("start back DUAL ");
-        rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
-        CDBG_ERROR("start front DUAL ");
-        rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
-        sleep(1);
-        CDBG_ERROR("stop back DUAL ");
-        rc = pthread_join(back_thread_id, NULL);
-        CDBG_ERROR("stop front DUAL ");
-        rc = pthread_join(front_thread_id, NULL);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case m1728 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_12(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int result = 0;
-
-        pthread_t back_thread_id, front_thread_id;
-        struct test_case_params bparams, fparams;
-        memset(&bparams, 0, sizeof(struct test_case_params));
-        memset(&fparams, 0, sizeof(struct test_case_params));
-        bparams.launch = 15;
-        fparams.launch = 15;
-        printf("\n Verifying Preview on back Camera and RDI on Front camera 12...\n");
-
-        CDBG_ERROR("start back DUAL ");
-        rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
-        CDBG_ERROR("start front DUAL ");
-        rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
-        sleep(1);
-        CDBG_ERROR("stop back DUAL ");
-        rc = pthread_join(back_thread_id, NULL);
-        CDBG_ERROR("stop front DUAL ");
-        rc = pthread_join(front_thread_id, NULL);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*  Test case 2413(ab)5768
- *  Test the dual camera usecase. We startPreview on front camera,
- *  but backend will allocate RDI buffers and start front camera in
- *  RDI streaming mode. It then diverts RDI frames, converts them into YUV 420
- *  through C2D and generate preview data in the buffers allocated here.
- *  Back camera will use the pixel interface as usual.
- */
-
-int mm_app_dtc_13(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j,k;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n 13. Verifying Preview + Recording on back Camera and Preview(through RDI) on Front camera\n");
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Preview for front \n");
-        if( MM_CAMERA_OK != (rc = startPreview(front_camera))) {
-               CDBG_ERROR("%s: front camera startPreview() err=%d\n", __func__, rc);
-               goto end;
-        }
-        mm_camera_app_wait();
-        usleep(20*1000);
-
-        for (k = 0; k < MM_QCAMERA_APP_INTERATION ; k++){
-          CDBG_ERROR("DUAL open back camera %d \n",k);
-          if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                 CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                 rc = -1;
-                 goto end;
-          }
-
-          if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                 CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                 rc = -1;
-                 goto end;
-          }
-
-          CDBG_ERROR("DUAL start camera Preview for back \n");
-          if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                 goto end;
-          }
-          usleep(30*1000);
-
-          for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-             CDBG_ERROR("DUAL start camera record for back Iteration %d \n", j);
-             if ( MM_CAMERA_OK != (rc = startRecording(back_camera))) {
-                 CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
-                 break;
-             }
-
-             mm_camera_app_wait();
-             usleep(10*1000*1000);
-             CDBG_ERROR("DUAL stop camera record for back Iteration %d\n", j);
-             if ( MM_CAMERA_OK != (rc = stopRecording(back_camera))) {
-                 CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
-                 break;
-             }
-          }
-          usleep(10*1000);
-
-          CDBG_ERROR("DUAL stop camera Preview for back \n");
-          if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
-                 CDBG_ERROR("%s: stopPreview() backcamera err=%d\n", __func__, rc);
-                 goto end;
-          }
-          usleep(10*1000);
-
-          CDBG_ERROR("DUAL close back camera\n");
-          if( mm_app_close(back_camera) != MM_CAMERA_OK) {
-                 CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                 rc = -1;
-                 goto end;
-          }
-          usleep(20*1000);
-        }
-        CDBG_ERROR("DUAL stop camera Preview for Rdi \n");
-        if( MM_CAMERA_OK != (rc = stopPreview(front_camera))) {
-                CDBG_ERROR("%s: stopPreview() frontcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        usleep(10*1000);
-        CDBG_ERROR("DUAL close front camera \n");
-        if( mm_app_close(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/*Below 6  are reference test cases just to test the open path for dual camera*/
-int mm_app_dtc_1243(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Rdi for front \n");
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL start camera Preview for back \n");
-
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-int mm_app_dtc_2134(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera Preview for front \n");
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL start camera Rdi for back \n");
-
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-int mm_app_dtc_2143(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera rdi for front \n");
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL start camera preview for back \n");
-
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-int mm_app_dtc_2413(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera rdi for front \n");
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera preview for back \n");
-
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-int mm_app_dtc_1234(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-        CDBG_ERROR("DUAL open back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL open front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-        CDBG_ERROR("DUAL start camera preview for back \n");
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-               CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-
-        CDBG_ERROR("DUAL start camera rdi for front \n");
-
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-                printf("\nPassed\n");
-        }else{
-                printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-int mm_app_dtc_1324(mm_camera_app_t *cam_apps)
-{
-        int rc = MM_CAMERA_OK;
-        int i,j;
-        int result = 0;
-        int front_camera = 1;
-        int back_camera = 0;
-
-        printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-        CDBG_ERROR("DUAL start back camera \n");
-        if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL start camera preview for back \n");
-        if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-                CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-                goto end;
-        }
-        //mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL start front camera \n");
-        if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-                CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-
-       if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-                CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-                rc = -1;
-                goto end;
-        }
-        CDBG_ERROR("DUAL start rdi preview \n");
-
-        if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-                CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-                goto end;
-        }
-        mm_camera_app_wait();
-        sleep(1);
-        CDBG_ERROR("DUAL end \n");
-
-end:
-        if(rc == 0) {
-          printf("\nPassed\n");
-        }else{
-          printf("\nFailed\n");
-        }
-        CDBG("%s:END, rc = %d\n", __func__, rc);
-        return rc;
-}
-
-/* single camera test cases*/
-int mm_app_dtc_s_0(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-    int front_camera = 1;
-    int back_camera = 0;
-
-    printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-
-    if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-        CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-        rc = -1;
-        goto end;
-    }
-    if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-    CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
-        CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    mm_camera_app_wait();
-    if(mm_app_open(front_camera) != MM_CAMERA_OK) {
-        CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
-        rc = -1;
-        goto end;
-    }
-    if(system_dimension_set(front_camera) != MM_CAMERA_OK){
-        CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
-        CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-        goto end;
-    }
-    mm_camera_app_wait();
-
-    if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
-        CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
-        CDBG("%s: startPreview() err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-        CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-        rc = -1;
-        goto end;
-    }
-end:
-    if(rc == 0) {
-        printf("\nPassed\n");
-    }else{
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_dtc_s_1(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying Snapshot on front and back camera...\n");
-    for(i = 0; i < cam_apps->num_cameras; i++) {
-        if( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if(system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK){
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-
-        if( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
-                break;
-        }
-        for(j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if( MM_CAMERA_OK != (rc = takePicture_yuv(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
-                break;
-            }
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-                CDBG_ERROR("%s: Snapshot/Preview Callback not received in time or qbuf Faile\n", __func__);
-                break;
-            }*/
-            mm_camera_app_wait();
-            result++;
-        }
-        if( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
-            CDBG("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if(result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Snapshot Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-end:
-    if(rc == 0) {
-        printf("\t***Passed***\n");
-    }else{
-        printf("\t***Failed***\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_dtc_s_2(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying Video on front and back camera...\n");
-    for(i = 0; i < cam_apps->num_cameras; i++) {
-        if( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if(system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK){
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-
-        if( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        for(j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if( MM_CAMERA_OK != (rc = startRecording(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-            CDBG_ERROR("%s: Video Callback not received in time\n", __func__);
-            break;
-            }*/
-            mm_camera_app_wait();
-            if( MM_CAMERA_OK != (rc = stopRecording(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-            result++;
-        }
-        if( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
-            CDBG("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if(result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-end:
-    if(rc == 0) {
-        printf("\nPassed\n");
-    }else{
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_dtc_s_3(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying RDI Stream on front and back camera...\n");
-    if(cam_apps->num_cameras == 0) {
-        CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
-        rc = -1;
-        goto end;
-    }
-    for(i = 0; i < cam_apps->num_cameras; i++) {
-        if( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if(system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK){
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        for(j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if( MM_CAMERA_OK != (rc = startRdi(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-            CDBG_ERROR("%s: Video Callback not received in time\n", __func__);
-            break;
-            }*/
-            mm_camera_app_wait();
-            if( MM_CAMERA_OK != (rc = stopRdi(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-            result++;
-        }
-        if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if(result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-end:
-    if(rc == 0) {
-        printf("\nPassed\n");
-    }else{
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-/*Stats Test Case*/
-int mm_app_dtc_s_5(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-    int front_camera = 1;
-    int back_camera = 0;
-
-    printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-
-    if(mm_app_open(back_camera) != MM_CAMERA_OK) {
-        CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
-        rc = -1;
-        goto end;
-    }
-    if(system_dimension_set(back_camera) != MM_CAMERA_OK){
-    CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    if( MM_CAMERA_OK != (rc = startStats(back_camera))) {
-        CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    mm_camera_app_wait();
-
-    if( MM_CAMERA_OK != (rc = stopStats(my_cam_app.cam_open))) {
-        CDBG("%s: startPreview() err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-        CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-        rc = -1;
-        goto end;
-    }
-end:
-    if(rc == 0) {
-        printf("\nPassed\n");
-    }else{
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_gen_dual_test_cases()
-{
-    int tc = 0;
-    memset(mm_app_tc, 0, sizeof(mm_app_tc));
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_0;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_1;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_2;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_3;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_4;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_5;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_6;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_7;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_8;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_9;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_10;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_11;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_12;
-    if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_13;
-
-    return tc;
-}
-
-int mm_app_dual_test_entry(mm_camera_app_t *cam_app)
-{
-    int rc = MM_CAMERA_OK;
-    int i, tc = 0;
-    int cam_id = 0;
-
-    tc = mm_app_gen_dual_test_cases();
-    CDBG("Running %d test cases\n",tc);
-    for(i = 0; i < tc; i++) {
-        mm_app_tc[i].r = mm_app_tc[i].f(cam_app);
-        if(mm_app_tc[i].r != MM_CAMERA_OK) {
-            printf("%s: test case %d error = %d, abort unit testing engine!!!!\n",
-                    __func__, i, mm_app_tc[i].r);
-            rc = mm_app_tc[i].r;
-            goto end;
-        }
-    }
-end:
-    printf("nTOTAL_TSET_CASE = %d, NUM_TEST_RAN = %d, rc=%d\n", tc, i, rc);
-    return rc;
-}
-
-
-
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_main_menu.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_main_menu.c
deleted file mode 100755
index 1b26e1a..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_main_menu.c
+++ /dev/null
@@ -1,1931 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <termios.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <signal.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-#include <linux/fb.h>
-#ifdef _ANDROID_
-#include <cutils/log.h>
-#endif
-#include <dlfcn.h>
-
-#include "camera.h"
-#include "mm_camera_dbg.h"
-#include "mm_qcamera_main_menu.h"
-#include "mm_qcamera_display_dimensions.h"
-#include "camera_defs_i.h"
-#include "mm_qcamera_app.h"
-
-#define CAMERA_OPENED 0
-
-#define VIDEO_BUFFER_SIZE       (PREVIEW_WIDTH * PREVIEW_HEIGHT * 3/2)
-#define THUMBNAIL_BUFFER_SIZE   (THUMBNAIL_WIDTH * THUMBNAIL_HEIGHT * 3/2)
-#define SNAPSHOT_BUFFER_SIZE    (PICTURE_WIDTH * PICTURE_HEIGHT * 3/2)
-
-extern int mm_app_take_zsl(int cam_id);
-extern int mm_app_take_live_snapshot(int cam_id);
-extern int stopPreview(int cam_id);
-extern void switchRes(int cam_id);
-extern void switchCamera(int cam_id);
-extern int startRdi(int cam_id);
-extern int stopRdi(int cam_id);
-
-/*===========================================================================
- * Macro
- *===========================================================================*/
-#define PREVIEW_FRAMES_NUM    4
-#define VIDEO_FRAMES_NUM      4
-#define THUMBNAIL_FRAMES_NUM  1
-#define SNAPSHOT_FRAMES_NUM   1
-#define MAX_NUM_FORMAT        32
-/*===========================================================================
- * Defines
- *===========================================================================*/
-
-const CAMERA_MAIN_MENU_TBL_T camera_main_menu_tbl[] = {
-  {STOP_CAMERA,                   "Stop preview/video and exit camera."},
-  {PREVIEW_VIDEO_RESOLUTION,      "Preview/Video Resolution: SQCIF/QCIF/"
-                              "QVGA/CIF/VGA/WVGA... Default WVGA."},
-  {TAKE_YUV_SNAPSHOT,       "Take a snapshot"},
-  {TAKE_RAW_SNAPSHOT,       "Take a raw snapshot"},
-  {TAKE_ZSL_SNAPSHOT,       "Take a ZSL snapshot"},
-  {START_RECORDING,       "Start RECORDING"},
-  {START_RDI, "Start RDI stream"},
-  {STOP_RDI, "Stop RDI stream"},
-  {SWITCH_CAMERA,       "Switch Camera"},
-#if 0
-  {SET_WHITE_BALANCE,          "Set white balance mode: Auto/Off/Daylight/Incandescent/Fluorescent. Default Auto."},
-  {SET_EXP_METERING,          "Set exposure metering mode: FrameAverage/CenterWeighted/SpotMetering. Default CenterWeighted"},
-  {GET_CTRL_VALUE,              "Get control value menu"},
-  {TOGGLE_AFR,                 "Toggle auto frame rate. Default fixed frame rate"},
-  {SET_ISO,                 "ISO changes."},
-  {BRIGHTNESS_GOTO_SUBMENU,                               "Brightness changes."},
-  {CONTRAST_GOTO_SUBMENU,                                 "Contrast changes."},
-  {EV_GOTO_SUBMENU,                                       "EV changes."},
-  {SATURATION_GOTO_SUBMENU,                               "Saturation changes."},
-  {SET_ZOOM,          "Set Digital Zoom."},
-  {SET_SHARPNESS,          "Set Sharpness."},
-#endif
-};
-
-const PREVIEW_DIMENSION_TBL_T preview_video_dimension_tbl[] = {
-   { SQCIF, SQCIF_WIDTH, SQCIF_HEIGHT, "SQCIF",  "Preview/Video Resolution: SQCIF <128x96>"},
-   {  QCIF,  QCIF_WIDTH,  QCIF_HEIGHT,  "QCIF",  "Preview/Video Resolution: QCIF <176x144>"},
-   {  QVGA,  QVGA_WIDTH,  QVGA_HEIGHT,  "QVGA",  "Preview/Video Resolution: QVGA <320x240>"},
-   {   CIF,   CIF_WIDTH,   CIF_HEIGHT,   "CIF",  "Preview/Video Resolution: CIF <352x288>"},
-   {   VGA,   VGA_WIDTH,   VGA_HEIGHT,   "VGA",  "Preview/Video Resolution: VGA <640x480>"},
-   {  WVGA,  WVGA_WIDTH,  WVGA_HEIGHT,  "WVGA",  "Preview/Video Resolution: WVGA <800x480>"},
-   {  SVGA,  SVGA_WIDTH,  SVGA_HEIGHT,  "SVGA",  "Preview/Video Resolution: SVGA <800x600>"},
-   {   XGA,   XGA_WIDTH,   XGA_HEIGHT,    "XGA", "Preview/Video Resolution: XGA <1024x768>"},
-   { HD720, HD720_WIDTH, HD720_HEIGHT,  "HD720", "Preview/Video Resolution: HD720 <1280x720>"},
-};
-
-const CAMERA_BRIGHTNESS_TBL_T brightness_change_tbl[] = {
-  {INC_BRIGHTNESS, "Increase Brightness by one step."},
-  {DEC_BRIGHTNESS, "Decrease Brightness by one step."},
-};
-
-const CAMERA_CONTRST_TBL_T contrast_change_tbl[] = {
-  {INC_CONTRAST, "Increase Contrast by one step."},
-  {DEC_CONTRAST, "Decrease Contrast by one step."},
-};
-
-const CAMERA_EV_TBL_T camera_EV_tbl[] = {
-  {INCREASE_EV, "Increase EV by one step."},
-  {DECREASE_EV, "Decrease EV by one step."},
-};
-
-const CAMERA_SATURATION_TBL_T camera_saturation_tbl[] = {
-  {INC_SATURATION, "Increase Satuation by one step."},
-  {DEC_SATURATION, "Decrease Satuation by one step."},
-};
-
-const CAMERA_SHARPNESS_TBL_T camera_sharpness_tbl[] = {
-  {INC_SHARPNESS, "Increase Sharpness."},
-  {DEC_SHARPNESS, "Decrease Sharpness."},
-};
-
-const WHITE_BALANCE_TBL_T white_balance_tbl[] = {
-  { CAMERA_WB_AUTO,         "White Balance - Auto"},
-  { CAMERA_WB_DAYLIGHT,     "White Balance - Daylight"},
-  { CAMERA_WB_INCANDESCENT, "White Balance - Incandescent"},
-  { CAMERA_WB_FLUORESCENT,  "White Balance - Fluorescent"},
-  { CAMERA_WB_CLOUDY_DAYLIGHT,  "White Balance - Cloudy"},
-};
-
-const CAMERA_TBL_T cam_tbl[] = {
-  { 	1,          "Back Camera"},
-  { 	2,         "Front Camera"},
-};
-
-const RECORD_TBL_T record_tbl[] = {
-  { 	LIVE_SNAPSHOT_MENU,          "Take Live snapshot"},
-  { 	STOP_RECORDING_MENU,         "Stop Recording"},
-};
-
-const GET_CTRL_TBL_T get_ctrl_tbl[] = {
-  {     WHITE_BALANCE_STATE,           "Get white balance state (auto/off)"},
-  {     WHITE_BALANCE_TEMPERATURE,      "Get white balance temperature"},
-  {     BRIGHTNESS_CTRL,      "Get brightness value"},
-  {     EV,      "Get exposure value"},
-  {     CONTRAST_CTRL,      "Get contrast value"},
-  {     SATURATION_CTRL,      "Get saturation value"},
-  {     SHARPNESS_CTRL,      "Get sharpness value"},
-};
-
-const EXP_METERING_TBL_T exp_metering_tbl[] = {
-  {   EXP_METERING_FRAME_AVERAGE,      "Exposure Metering - Frame Average"},
-  {   EXP_METERING_CENTER_WEIGHTED,    "Exposure Metering - Center Weighted"},
-  {   EXP_METERING_SPOT_METERING,      "Exposure Metering - Spot Metering"},
-};
-
-const ISO_TBL_T iso_tbl[] = {
-  {   ISO_AUTO, "ISO: Auto"},
-  {   ISO_DEBLUR, "ISO: Deblur"},
-  {   ISO_100, "ISO: 100"},
-  {   ISO_200, "ISO: 200"},
-  {   ISO_400, "ISO: 400"},
-  {   ISO_800, "ISO: 800"},
-  {   ISO_1600, "ISO: 1600"},
-};
-
-const ZOOM_TBL_T zoom_tbl[] = {
-  {   ZOOM_IN, "Zoom In one step"},
-  {   ZOOM_OUT, "Zoom Out one step"},
-};
-
-
-struct v4l2_fmtdesc enumfmtdesc[MAX_NUM_FORMAT];
-struct v4l2_format current_fmt;
-
-/*===========================================================================
- * Forward declarations
- *===========================================================================*/
-static int set_fps(int fps);
-static int start_snapshot (void);
-static int stop_snapshot (void);
-/*===========================================================================
- * Static global variables
- *===========================================================================*/
-USER_INPUT_DISPLAY_T input_display;
-static int camframe_status = 0;
-
-#ifdef _ANDROID_
-char *sdcard_path = "/data";
-#else
-char *sdcard_path = ".";
-#endif
-
-//void *libqcamera = NULL;
-//void (**LINK_jpegfragment_callback)(uint8_t * buff_ptr , uint32_t buff_size);
-//void (**LINK_jpeg_callback)(void);
-
-int num_supported_fmts = 0;
-int memoryType = V4L2_MEMORY_MMAP; /* default */
-int preview_video_resolution_flag = 0;
-int effect = CAMERA_EFFECT_OFF;
-int brightness = CAMERA_DEF_BRIGHTNESS;
-int contrast = CAMERA_DEF_CONTRAST;
-int saturation = CAMERA_DEF_SATURATION;
-int sharpness = CAMERA_DEF_SHARPNESS;
-int32_t ev_num = 0;
-uint8_t ezTune = FALSE;
-int pmemThumbnailfd = 0;
-int pmemSnapshotfd = 0;
-int pmemRawSnapshotfd = 0;
-int fdSnapshot = 0;
-int fdThumbnail = 0;
-char snapshotBuf[256] = { 0};
-char thumbnailBuf[256] = { 0};
-uint32_t snapshot_buff_size = 0;
-uint32_t raw_snapshot_buffer_size = 0;
-static int thumbnailCntr = 0, snapshotCntr = 0;
-unsigned char *thumbnail_buf = NULL, *main_img_buf = NULL, *raw_img_buf = NULL;
-int32_t *sharpness_AF = NULL;
-struct crop_info cropInfo;
-common_crop_t cropInfo_s;
-
-interface_ctrl_t intrfcCtrl;
-config3a_wb_t autoWB = CAMERA_WB_AUTO;
-isp3a_af_mode_t af_mode = AF_MODE_AUTO;
-cam_af_focusrect_t afFocusRect = AUTO;
-
-cam_af_ctrl_t af_ctrl;
-camera_iso_mode_type iso = CAMERA_ISO_AUTO;
-camera_antibanding_type antibanding = CAMERA_ANTIBANDING_OFF;
-camera_auto_exposure_mode_type aec_mode = CAMERA_AEC_CENTER_WEIGHTED;
-led_mode_t led_mode = LED_MODE_OFF;
-motion_iso_t motion_iso = MOTION_ISO_OFF;
-int32_t hue = CAMERA_DEF_HUE;
-fps_mode_t fps_mode = FPS_MODE_AUTO;
-
-struct v4l2_cropcap cropcap;
-struct v4l2_queryctrl zoom_queryctrl;
-struct v4l2_queryctrl sharpness_queryctrl;
-int zoom_level;
-
-Camera_Resolution Resolution;
-//int32_t g_camParmInfo_current_value = 0;
-//extern unsigned long preview_frames_buf;
-//extern void test_app_mmcamera_videoframe_callback(struct msm_frame *frame); // video_cam.c
-
-/* To flush free video buffers queue */
-//void (*LINK_cam_frame_flush_free_video)(void);
-static int submain();
-
-//struct v4l2_frame_buffer frames[PREVIEW_FRAMES_NUM];
-//struct v4l2_frame_buffer video_frames[VIDEO_FRAMES_NUM];
-
-//pthread_t frame_thread;
-
-void test_app_camframe_timeout_callback(void)
-{
-  camframe_status = -1;
-}
-
-/*===========================================================================
- * FUNCTION    - keypress_to_event -
- *
- * DESCRIPTION:
- *==========================================================================*/
-int keypress_to_event(char keypress)
-{
-  char out_buf = INVALID_KEY_PRESS;
-  if ((keypress >= 'A' && keypress <= 'Z') ||
-    (keypress >= 'a' && keypress <= 'z')) {
-    out_buf = tolower(keypress);
-    out_buf = out_buf - 'a' + 1;
-  } else if (keypress >= '1' && keypress <= '9') {
-    out_buf = keypress;
-    out_buf = keypress - '1' + BASE_OFFSET_NUM;
-  }
-  return out_buf;
-}
-
-int next_menu(menu_id_change_t current_menu_id, char keypress, camera_action_t * action_id_ptr, int * action_param)
-{
-  int output_to_event;
-  menu_id_change_t next_menu_id = MENU_ID_INVALID;
-  * action_id_ptr = ACTION_NO_ACTION;
-
-  output_to_event = keypress_to_event(keypress);
-  CDBG("current_menu_id=%d\n",current_menu_id);
-  CDBG("output_to_event=%d\n",output_to_event);
-  switch(current_menu_id) {
-    case MENU_ID_MAIN:
-      switch(output_to_event) {
-        case STOP_CAMERA:
-          * action_id_ptr = ACTION_STOP_CAMERA;
-          CDBG("STOP_CAMERA\n");
-          break;
-
-        case PREVIEW_VIDEO_RESOLUTION:
-          next_menu_id = MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE;
-          CDBG("next_menu_id = MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE = %d\n", next_menu_id);
-          break;
-#if 0
-        case SET_WHITE_BALANCE:
-          next_menu_id = MENU_ID_WHITEBALANCECHANGE;
-          CDBG("next_menu_id = MENU_ID_WHITEBALANCECHANGE = %d\n", next_menu_id);
-          break;
-
-        case SET_EXP_METERING:
-          next_menu_id = MENU_ID_EXPMETERINGCHANGE;
-          CDBG("next_menu_id = MENU_ID_EXPMETERINGCHANGE = %d\n", next_menu_id);
-          break;
-
-        case GET_CTRL_VALUE:
-          next_menu_id = MENU_ID_GET_CTRL_VALUE;
-          CDBG("next_menu_id = MENU_ID_GET_CTRL_VALUE = %d\n", next_menu_id);
-          break;
-
-        case BRIGHTNESS_GOTO_SUBMENU:
-          next_menu_id = MENU_ID_BRIGHTNESSCHANGE;
-          CDBG("next_menu_id = MENU_ID_BRIGHTNESSCHANGE = %d\n", next_menu_id);
-          break;
-
-        case CONTRAST_GOTO_SUBMENU:
-          next_menu_id = MENU_ID_CONTRASTCHANGE;
-          break;
-
-        case EV_GOTO_SUBMENU:
-          next_menu_id = MENU_ID_EVCHANGE;
-          break;
-
-        case SATURATION_GOTO_SUBMENU:
-          next_menu_id = MENU_ID_SATURATIONCHANGE;
-          break;
-
-        case TOGGLE_AFR:
-          * action_id_ptr = ACTION_TOGGLE_AFR;
-          CDBG("next_menu_id = MENU_ID_TOGGLEAFR = %d\n", next_menu_id);
-          break;
-
-        case SET_ISO:
-          next_menu_id = MENU_ID_ISOCHANGE;
-          CDBG("next_menu_id = MENU_ID_ISOCHANGE = %d\n", next_menu_id);
-          break;
-
-        case SET_ZOOM:
-          next_menu_id = MENU_ID_ZOOMCHANGE;
-          CDBG("next_menu_id = MENU_ID_ZOOMCHANGE = %d\n", next_menu_id);
-          break;
-
-        case SET_SHARPNESS:
-          next_menu_id = MENU_ID_SHARPNESSCHANGE;
-          CDBG("next_menu_id = MENU_ID_SHARPNESSCHANGE = %d\n", next_menu_id);
-          break;
-#endif
-        case TAKE_YUV_SNAPSHOT:
-          * action_id_ptr = ACTION_TAKE_YUV_SNAPSHOT;
-          CDBG("Taking YUV snapshot\n");
-          break;
-
-        case TAKE_RAW_SNAPSHOT:
-          * action_id_ptr = ACTION_TAKE_RAW_SNAPSHOT;
-          CDBG("Taking RAW snapshot\n");
-          break;
-        case START_RECORDING:
-          *action_id_ptr = ACTION_START_RECORDING;
-          next_menu_id = MENU_ID_RECORD;
-          CDBG("Start recording\n");
-          break;
-        /*case STOP_RECORDING:
-          * action_id_ptr = ACTION_STOP_RECORDING;
-          CDBG("Stop recording\n");
-          break;*/
-        case SWITCH_CAMERA:
-          next_menu_id = MENU_ID_SWITCHCAMERA;
-          CDBG("SWitch Camera\n");
-          break;
-        case TAKE_ZSL_SNAPSHOT:
-          * action_id_ptr = ACTION_TAKE_ZSL_SNAPSHOT;
-          CDBG("Taking ZSL snapshot\n");
-          break;
-        case START_RDI:
-          * action_id_ptr = ACTION_START_RDI;
-          break;
-        case STOP_RDI:
-          * action_id_ptr = ACTION_STOP_RDI;
-          break;
-        default:
-          next_menu_id = MENU_ID_MAIN;
-          CDBG("next_menu_id = MENU_ID_MAIN = %d\n", next_menu_id);
-          break;
-      }
-      break;
-
-    case MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE:
-      printf("MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE\n");
-      * action_id_ptr = ACTION_PREVIEW_VIDEO_RESOLUTION;
-      if (output_to_event > RESOLUTION_PREVIEW_VIDEO_MAX ||
-        output_to_event < RESOLUTION_MIN) {
-          next_menu_id = current_menu_id;
-      }
-      else {
-        next_menu_id = MENU_ID_MAIN;
-        * action_param = output_to_event;
-      }
-      break;
-
-    case MENU_ID_WHITEBALANCECHANGE:
-      printf("MENU_ID_WHITEBALANCECHANGE\n");
-      * action_id_ptr = ACTION_SET_WHITE_BALANCE;
-      if (output_to_event > 0 &&
-        output_to_event <= sizeof(white_balance_tbl)/sizeof(white_balance_tbl[0])) {
-          next_menu_id = MENU_ID_MAIN;
-          * action_param = output_to_event;
-      }
-      else {
-        next_menu_id = current_menu_id;
-      }
-      break;
-
-    case MENU_ID_EXPMETERINGCHANGE:
-      printf("MENU_ID_EXPMETERINGCHANGE\n");
-      * action_id_ptr = ACTION_SET_EXP_METERING;
-      if (output_to_event > 0 &&
-        output_to_event <= sizeof(exp_metering_tbl)/sizeof(exp_metering_tbl[0])) {
-          next_menu_id = MENU_ID_MAIN;
-          * action_param = output_to_event;
-      }
-      else {
-        next_menu_id = current_menu_id;
-      }
-      break;
-
-    case MENU_ID_GET_CTRL_VALUE:
-      printf("MENU_ID_GET_CTRL_VALUE\n");
-      * action_id_ptr = ACTION_GET_CTRL_VALUE;
-      if (output_to_event > 0 &&
-        output_to_event <= sizeof(get_ctrl_tbl)/sizeof(get_ctrl_tbl[0])) {
-          next_menu_id = MENU_ID_MAIN;
-          * action_param = output_to_event;
-      }
-      else {
-        next_menu_id = current_menu_id;
-      }
-      break;
-
-    case MENU_ID_BRIGHTNESSCHANGE:
-      switch (output_to_event) {
-        case INC_BRIGHTNESS:
-          * action_id_ptr = ACTION_BRIGHTNESS_INCREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-
-        case DEC_BRIGHTNESS:
-          * action_id_ptr = ACTION_BRIGHTNESS_DECREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-
-        default:
-          next_menu_id = MENU_ID_BRIGHTNESSCHANGE;
-          break;
-      }
-      break;
-
-    case MENU_ID_CONTRASTCHANGE:
-      switch (output_to_event) {
-        case INC_CONTRAST:
-          * action_id_ptr = ACTION_CONTRAST_INCREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-
-        case DEC_CONTRAST:
-          * action_id_ptr = ACTION_CONTRAST_DECREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-
-        default:
-          next_menu_id = MENU_ID_CONTRASTCHANGE;
-          break;
-      }
-      break;
-
-    case MENU_ID_EVCHANGE:
-      switch (output_to_event) {
-        case INCREASE_EV:
-          * action_id_ptr = ACTION_EV_INCREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-
-        case DECREASE_EV:
-          * action_id_ptr = ACTION_EV_DECREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-
-        default:
-          next_menu_id = MENU_ID_EVCHANGE;
-          break;
-      }
-      break;
-
-    case MENU_ID_SATURATIONCHANGE:
-      switch (output_to_event) {
-        case INC_SATURATION:
-          * action_id_ptr = ACTION_SATURATION_INCREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-
-        case DEC_SATURATION:
-          * action_id_ptr = ACTION_SATURATION_DECREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-
-        default:
-          next_menu_id = MENU_ID_EVCHANGE;
-          break;
-      }
-      break;
-
-    case MENU_ID_ISOCHANGE:
-      printf("MENU_ID_ISOCHANGE\n");
-      * action_id_ptr = ACTION_SET_ISO;
-      if (output_to_event > 0 &&
-        output_to_event <= sizeof(iso_tbl)/sizeof(iso_tbl[0])) {
-          next_menu_id = MENU_ID_MAIN;
-          * action_param = output_to_event;
-      } else {
-        next_menu_id = current_menu_id;
-      }
-      break;
-
-    case MENU_ID_ZOOMCHANGE:
-      * action_id_ptr = ACTION_SET_ZOOM;
-      if (output_to_event > 0 &&
-        output_to_event <= sizeof(zoom_tbl)/sizeof(zoom_tbl[0])) {
-          next_menu_id = MENU_ID_MAIN;
-          * action_param = output_to_event;
-      } else {
-        next_menu_id = current_menu_id;
-      }
-      break;
-
-    case MENU_ID_SHARPNESSCHANGE:
-      switch (output_to_event) {
-        case INC_SHARPNESS:
-          * action_id_ptr = ACTION_SHARPNESS_INCREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-        case DEC_SHARPNESS:
-          * action_id_ptr = ACTION_SHARPNESS_DECREASE;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-        default:
-          next_menu_id = MENU_ID_SHARPNESSCHANGE;
-          break;
-      }
-      break;
-    case MENU_ID_SWITCHCAMERA:
-      * action_id_ptr = ACTION_SWITCH_CAMERA;
-      if (output_to_event >= 0 &&
-        output_to_event <= sizeof(cam_tbl)/sizeof(cam_tbl[0])) {
-          next_menu_id = MENU_ID_MAIN;
-          * action_param = output_to_event;
-      } else {
-        next_menu_id = current_menu_id;
-      }
-      break;
-   case MENU_ID_RECORD:
-      switch (output_to_event) {
-        case LIVE_SNAPSHOT_MENU:
-          * action_id_ptr = ACTION_TAKE_LIVE_SNAPSHOT;
-          next_menu_id = MENU_ID_RECORD;
-          break;
-
-        default:
-        case STOP_RECORDING_MENU:
-          * action_id_ptr = ACTION_STOP_RECORDING;
-          next_menu_id = MENU_ID_MAIN;
-          break;
-      }
-   default:
-      CDBG("menu id is wrong: %d\n", current_menu_id);
-      break;
-  }
-
-  return next_menu_id;
-}
-
-/*===========================================================================
- * FUNCTION    - print_menu_preview_video -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-static void print_menu_preview_video(void) {
-  unsigned int i;
-
-  printf("\n");
-  printf("===========================================\n");
-  printf("      Camera is in preview/video mode now        \n");
-  printf("===========================================\n\n");
-
-  char menuNum = 'A';
-  for (i = 0; i < sizeof(camera_main_menu_tbl)/sizeof(camera_main_menu_tbl[0]); i++) {
-    if (i == BASE_OFFSET) {
-      menuNum = '1';
-    }
-
-    printf("%c.  %s\n", menuNum, camera_main_menu_tbl[i].menu_name);
-    menuNum++;
-  }
-
-  printf("\nPlease enter your choice: ");
-
-  return;
-}
-
-static void camera_preview_video_resolution_change_tbl(void) {
-    unsigned int i;
-
-    printf("\n");
-    printf("==========================================================\n");
-    printf("      Camera is in preview/video resolution mode       \n");
-    printf("==========================================================\n\n");
-
-    char previewVideomenuNum = 'A';
-    for (i = 0; i < sizeof(preview_video_dimension_tbl) /
-      sizeof(preview_video_dimension_tbl[0]); i++) {
-        printf("%c.  %s\n", previewVideomenuNum,
-          preview_video_dimension_tbl[i].str_name);
-        previewVideomenuNum++;
-    }
-
-    printf("\nPlease enter your choice for Preview/Video Resolution: ");
-    return;
-}
-
-static void camera_preview_video_wb_change_tbl(void) {
-  unsigned int i;
-  printf("\n");
-  printf("==========================================================\n");
-  printf("      Camera is in white balance change mode       \n");
-  printf("==========================================================\n\n");
-
-  char submenuNum = 'A';
-  for (i = 0 ; i < sizeof(white_balance_tbl) /
-                   sizeof(white_balance_tbl[0]); i++) {
-        //printf("%c.  %s\n", submenuNum, white_balance_tbl[i].wb_name);
-        submenuNum++;
-  }
-  printf("\nPlease enter your choice for White Balance modes: ");
-  return;
-}
-
-static void camera_preview_video_get_ctrl_value_tbl(void) {
-  unsigned int i;
-  printf("\n");
-  printf("==========================================================\n");
-  printf("      Camera is in get control value mode       \n");
-  printf("==========================================================\n\n");
-
-  char submenuNum = 'A';
-  for (i = 0 ; i < sizeof(get_ctrl_tbl) /
-                   sizeof(get_ctrl_tbl[0]); i++) {
-        printf("%c.  %s\n", submenuNum, get_ctrl_tbl[i].get_ctrl_name);
-        submenuNum++;
-  }
-  printf("\nPlease enter your choice for control value you want to get: ");
-  return;
-}
-
-static void camera_preview_video_exp_metering_change_tbl(void) {
-  unsigned int i;
-  printf("\n");
-  printf("==========================================================\n");
-  printf("      Camera is in exposure metering change mode       \n");
-  printf("==========================================================\n\n");
-
-  char submenuNum = 'A';
-  for (i = 0 ; i < sizeof(exp_metering_tbl) /
-                   sizeof(exp_metering_tbl[0]); i++) {
-        printf("%c.  %s\n", submenuNum, exp_metering_tbl[i].exp_metering_name);
-        submenuNum++;
-  }
-  printf("\nPlease enter your choice for exposure metering modes: ");
-  return;
-}
-
-static void camera_contrast_change_tbl(void) {
-    unsigned int i;
-
-    printf("\n");
-    printf("==========================================================\n");
-    printf("      Camera is in change contrast resolution mode       \n");
-    printf("==========================================================\n\n");
-
-    char contrastmenuNum = 'A';
-    for (i = 0; i < sizeof(contrast_change_tbl) /
-                    sizeof(contrast_change_tbl[0]); i++) {
-        printf("%c.  %s\n", contrastmenuNum,
-                            contrast_change_tbl[i].contrast_name);
-        contrastmenuNum++;
-    }
-
-    printf("\nPlease enter your choice for contrast Change: ");
-    return;
-}
-
-static void camera_EV_change_tbl(void) {
-  unsigned int i;
-
-  printf("\n");
-  printf("===========================================\n");
-  printf("      Camera is in EV change mode now       \n");
-  printf("===========================================\n\n");
-
-  char submenuNum = 'A';
-  for (i = 0; i < sizeof(camera_EV_tbl)/sizeof(camera_EV_tbl[0]); i++) {
-    printf("%c.  %s\n", submenuNum, camera_EV_tbl[i].EV_name);
-    submenuNum++;
-  }
-
-  printf("\nPlease enter your choice for EV changes: ");
-  return;
-}
-
-static void camera_preview_video_zoom_change_tbl(void) {
-  unsigned int i;
-  struct v4l2_control ctrl;
-
-  memset(&ctrl, 0, sizeof(ctrl));
-  ctrl.id = V4L2_CID_ZOOM_ABSOLUTE;
-#if 0 /* TBD */
-  if (ioctl(camfd, VIDIOC_G_CTRL, &ctrl) >= 0) {
-    zoom_level = ctrl.value;
-    printf("\n");
-    printf("==========================================================\n");
-    printf("      Camera is in zoom change mode: %d,  [%d..%d]        \n",
-        ctrl.value, zoom_queryctrl.minimum, zoom_queryctrl.maximum);
-    printf("==========================================================\n\n");
-
-    char submenuNum = 'A';
-    for (i = 0 ; i < sizeof(zoom_tbl) /
-                   sizeof(zoom_tbl[0]); i++) {
-        printf("%c.  %s\n", submenuNum, zoom_tbl[i].zoom_direction_name);
-        submenuNum++;
-    }
-    printf("\nPlease enter your choice for zoom change direction: ");
-  } else {
-    printf("\nVIDIOC_G_CTRL error: %d\n", errno);
-  }
-#endif /* TBD */
-  return;
-}
-
-static void camera_brightness_change_tbl(void) {
-    unsigned int i;
-
-    printf("\n");
-    printf("==========================================================\n");
-    printf("      Camera is in change brightness mode       \n");
-    printf("==========================================================\n\n");
-
-    char brightnessmenuNum = 'A';
-    for (i = 0; i < sizeof(brightness_change_tbl) /
-                    sizeof(brightness_change_tbl[0]); i++) {
-        printf("%c.  %s\n", brightnessmenuNum,
-                            brightness_change_tbl[i].brightness_name);
-        brightnessmenuNum++;
-    }
-
-    printf("\nPlease enter your choice for Brightness Change: ");
-    return;
-}
-
-static void camera_saturation_change_tbl(void) {
-    unsigned int i;
-
-    printf("\n");
-    printf("==========================================================\n");
-    printf("      Camera is in change saturation mode       \n");
-    printf("==========================================================\n\n");
-
-    char saturationmenuNum = 'A';
-    for (i = 0; i < sizeof(camera_saturation_tbl) /
-                    sizeof(camera_saturation_tbl[0]); i++) {
-        printf("%c.  %s\n", saturationmenuNum,
-                            camera_saturation_tbl[i].saturation_name);
-        saturationmenuNum++;
-    }
-
-    printf("\nPlease enter your choice for Saturation Change: ");
-    return;
-}
-
-char * set_preview_video_dimension_tbl(Camera_Resolution cs_id, uint16_t * width, uint16_t * height)
-{
-  unsigned int i;
-  char * ptr = NULL;
-  for (i = 0; i < sizeof(preview_video_dimension_tbl) /
-    sizeof(preview_video_dimension_tbl[0]); i++) {
-      if (cs_id == preview_video_dimension_tbl[i].cs_id) {
-        *width = preview_video_dimension_tbl[i].width;
-        *height = preview_video_dimension_tbl[i].height;
-        ptr = preview_video_dimension_tbl[i].name;
-        break;
-      }
-  }
-  return ptr;
-}
-
-static void camera_preview_video_iso_change_tbl(void) {
-  unsigned int i;
-  printf("\n");
-  printf("==========================================================\n");
-  printf("      Camera is in ISO change mode       \n");
-  printf("==========================================================\n\n");
-
-  char submenuNum = 'A';
-  for (i = 0 ; i < sizeof(iso_tbl) /
-                   sizeof(iso_tbl[0]); i++) {
-        printf("%c.  %s\n", submenuNum, iso_tbl[i].iso_modes_name);
-        submenuNum++;
-  }
-  printf("\nPlease enter your choice for iso modes: ");
-  return;
-}
-
-static void camera_preview_video_sharpness_change_tbl(void) {
-  unsigned int i;
-  printf("\n");
-  printf("==========================================================\n");
-  printf("      Camera is in sharpness change mode       \n");
-  printf("==========================================================\n\n");
-
-  char submenuNum = 'A';
-  for (i = 0 ; i < sizeof(camera_sharpness_tbl) /
-                   sizeof(camera_sharpness_tbl[0]); i++) {
-        printf("%c.  %s\n", submenuNum, camera_sharpness_tbl[i].sharpness_name);
-        submenuNum++;
-  }
-  printf("\nPlease enter your choice for sharpness modes: ");
-  return;
-}
-
-static void camera_record_tbl(void) {
-  unsigned int i;
-  printf("\n");
-  printf("==========================================================\n");
-  printf("      Camera is in record mode       \n");
-  printf("==========================================================\n\n");
-
-  char submenuNum = 'A';
-  for (i = 0 ; i < sizeof(record_tbl) /
-                   sizeof(record_tbl[0]); i++) {
-        printf("%c.  %s\n", submenuNum, record_tbl[i].act_name);
-        submenuNum++;
-  }
-  printf("\nPlease enter your choice:  ");
-  return;
-}
-
-static void camera_switch_tbl(void) {
-  unsigned int i;
-  printf("\n");
-  printf("==========================================================\n");
-  printf("      Camera is in switch camera mode       \n");
-  printf("==========================================================\n\n");
-
-  char submenuNum = 'A';
-  for (i = 0 ; i < sizeof(cam_tbl) /
-                   sizeof(cam_tbl[0]); i++) {
-        printf("%c.  %s\n", submenuNum, cam_tbl[i].cam_name);
-        submenuNum++;
-  }
-  printf("\nPlease enter your choice for camera modes: ");
-  return;
-}
-/*===========================================================================
- * FUNCTION     - increase_contrast -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_contrast (void) {
-  ++contrast;
-  if (contrast > CAMERA_MAX_CONTRAST) {
-    contrast = CAMERA_MAX_CONTRAST;
-    printf("Reached max CONTRAST. \n");
-  } else
-    printf("Increase CONTRAST to %d\n", contrast);
-
-  /*intrfcCtrl.setContrast(camfd, contrast);*/
-
-  struct v4l2_queryctrl queryctrl;
-  struct v4l2_control control;
-
-  memset (&queryctrl, 0, sizeof (queryctrl));
-  queryctrl.id = V4L2_CID_CONTRAST;
-#if 0 /* TBD */
-  if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
-    if (errno != EINVAL) {
-      perror ("VIDIOC_QUERYCTRL");
-      exit (EXIT_FAILURE);
-    } else {
-      printf ("V4L2_CID_contrast is not supported\n");
-    }
-  } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-    printf ("V4L2_CID_contrast is not supported\n");
-  } else {
-    memset (&control, 0, sizeof (control));
-    control.id = V4L2_CID_CONTRAST;
-    /* Decreasing the contrast */
-    control.value = contrast;
-
- //   if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- //     perror ("VIDIOC_S_CTRL");
- //     return -1;
- //   }
-  }
-#endif /* TBD */
-  return 0;
-}
-
-/*===========================================================================
- * FUNCTION     - decrease_contrast -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_contrast (void) {
-  --contrast;
-  if (contrast < CAMERA_MIN_CONTRAST) {
-    contrast = CAMERA_MIN_CONTRAST;
-    printf("Reached min CONTRAST. \n");
-  } else
-    printf("Decrease CONTRAST to %d\n", contrast);
-
-  /*intrfcCtrl.setContrast(camfd, contrast);*/
-  struct v4l2_queryctrl queryctrl;
-  struct v4l2_control control;
-
-  memset (&queryctrl, 0, sizeof (queryctrl));
-  queryctrl.id = V4L2_CID_CONTRAST;
-#if 0 /* TBD */
-  if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
-    if (errno != EINVAL) {
-      perror ("VIDIOC_QUERYCTRL");
-      exit (EXIT_FAILURE);
-    } else {
-      printf ("V4L2_CID_contrast is not supported\n");
-    }
-  } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-    printf ("V4L2_CID_contrast is not supported\n");
-  } else {
-    memset (&control, 0, sizeof (control));
-    control.id = V4L2_CID_CONTRAST;
-    /* Decreasing the contrast */
-    control.value = contrast;
-
-  //  if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
-  //    perror ("VIDIOC_S_CTRL");
-  //    return -1;
-  //  }
-  }
-#endif /* TBD */
-  return 0;
-}
-
-/*===========================================================================
- * FUNCTION     - decrease_brightness -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_brightness (void) {
-  brightness -= CAMERA_BRIGHTNESS_STEP;
-  if (brightness < CAMERA_MIN_BRIGHTNESS) {
-    brightness = CAMERA_MIN_BRIGHTNESS;
-    printf("Reached min BRIGHTNESS. \n");
-  } else
-    printf("Decrease BRIGHTNESS to %d\n", brightness);
-
-  struct v4l2_queryctrl queryctrl;
-  struct v4l2_control control;
-
-  memset (&queryctrl, 0, sizeof (queryctrl));
-  queryctrl.id = V4L2_CID_BRIGHTNESS;
-#if 0 /* TBD */
-  if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
-    if (errno != EINVAL) {
-      perror ("VIDIOC_QUERYCTRL");
-      exit (EXIT_FAILURE);
-    } else {
-      printf ("V4L2_CID_BRIGHTNESS is not supported\n");
-    }
-  } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-    printf ("V4L2_CID_BRIGHTNESS is not supported\n");
-  } else {
-    memset (&control, 0, sizeof (control));
-    control.id = V4L2_CID_BRIGHTNESS;
-    /* Decreasing the Brightness */
-    control.value = brightness;
-
-    if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
-      perror ("VIDIOC_S_CTRL");
-      return -1;
-    }
-  }
-#endif /* TBD */
-  return 0;
-}
-
-/*===========================================================================
- * FUNCTION     - increase_brightness -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_brightness (void) {
-  brightness += CAMERA_BRIGHTNESS_STEP;
-  if (brightness > CAMERA_MAX_BRIGHTNESS) {
-    brightness = CAMERA_MAX_BRIGHTNESS;
-    printf("Reached max BRIGHTNESS. \n");
-  } else
-    printf("Increase BRIGHTNESS to %d\n", brightness);
-
-  struct v4l2_queryctrl queryctrl;
-  struct v4l2_control control;
-
-  memset (&queryctrl, 0, sizeof (queryctrl));
-  queryctrl.id = V4L2_CID_BRIGHTNESS;
-#if 0 /* TBD */
-  if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
-    if (errno != EINVAL) {
-      perror ("VIDIOC_QUERYCTRL");
-      exit (EXIT_FAILURE);
-    } else {
-      printf ("V4L2_CID_BRIGHTNESS is not supported\n");
-    }
-  } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-    printf ("V4L2_CID_BRIGHTNESS is not supported\n");
-  } else {
-    memset (&control, 0, sizeof (control));
-    control.id = V4L2_CID_BRIGHTNESS;
-    /* Increasing the Brightness */
-    control.value = brightness;
-
-    if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
-      perror ("VIDIOC_S_CTRL");
-      return -1;
-    }
-  }
-#endif /* TBD */
-  return 0;
-}
-
-/*===========================================================================
- * FUNCTION     - increase_EV -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_EV (void) {
-  int32_t ev = 0;
-  if (++ev_num <= 12) {
-     ev = (ev_num << 16) | 6;
-    printf("Increase EV to %d\n", ev_num);
-  } else {
-    printf("Reached max EV. \n");
-    ev = ev_num;
-  }
-
-  struct v4l2_queryctrl queryctrl;
-  struct v4l2_control control;
-
-  memset (&queryctrl, 0, sizeof (queryctrl));
-  queryctrl.id = V4L2_CID_EXPOSURE;
-#if 0 /* TBD */
-  if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
-    if (errno != EINVAL) {
-      perror ("VIDIOC_QUERYCTRL");
-      exit (EXIT_FAILURE);
-    } else {
-      printf ("V4L2_CID_EXPOSURE is not supported\n");
-    }
-  } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-    printf ("V4L2_CID_EXPOSURE is not supported\n");
-  } else {
-    memset (&control, 0, sizeof (control));
-    control.id = V4L2_CID_EXPOSURE;
-    /* Increasing the EV*/
-    control.value = ev;
-
-    if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
-      perror ("VIDIOC_S_CTRL");
-      return -1;
-    }
-  }
-#endif /* TBD */
-  return 0;
-}
-
-/*===========================================================================
- * FUNCTION     - decrease_EV -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_EV (void) {
-  int32_t ev = 0;
-  if (--ev_num > -12) {
-    ev = (ev_num << 16) | 6;
-    printf("Decrease EV to %d\n", ev_num);
-  } else {
-    printf("Reached min EV. \n");
-    ev = ev_num;
-  }
-
-  struct v4l2_queryctrl queryctrl;
-  struct v4l2_control control;
-
-  memset (&queryctrl, 0, sizeof (queryctrl));
-  queryctrl.id = V4L2_CID_EXPOSURE;
-#if 0 /* TBD */
-  if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
-    if (errno != EINVAL) {
-      perror ("VIDIOC_QUERYCTRL");
-      exit (EXIT_FAILURE);
-    } else {
-      printf ("V4L2_CID_EXPOSURE is not supported\n");
-    }
-  } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-    printf ("V4L2_CID_EXPOSURE is not supported\n");
-  } else {
-    memset (&control, 0, sizeof (control));
-    control.id = V4L2_CID_EXPOSURE;
-    /* Increasing the EV*/
-    control.value = ev;
-
-    if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
-      perror ("VIDIOC_S_CTRL");
-      return -1;
-    }
-  }
-#endif /* TBD */
-  return 0;
-}
-
-/*===========================================================================
- * FUNCTION     - increase_contrast -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_saturation (void) {
-  ++saturation;
-  if (saturation > CAMERA_MAX_SATURATION) {
-    saturation = CAMERA_MAX_SATURATION;
-    printf("Reached max saturation. \n");
-  } else
-    printf("Increase saturation to %d\n", saturation);
-
-  /*intrfcCtrl.setContrast(camfd, contrast);*/
-
-  struct v4l2_queryctrl queryctrl;
-  struct v4l2_control control;
-
-  memset (&queryctrl, 0, sizeof (queryctrl));
-  queryctrl.id = V4L2_CID_SATURATION;
-#if 0 /* TBD */
-  if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
-    if (errno != EINVAL) {
-      perror ("VIDIOC_QUERYCTRL");
-      exit (EXIT_FAILURE);
-    } else {
-      printf ("V4L2_CID_saturation is not supported\n");
-    }
-  } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-    printf ("V4L2_CID_saturation is not supported\n");
-  } else {
-    memset (&control, 0, sizeof (control));
-    control.id = V4L2_CID_SATURATION;
-    /* Decreasing the contrast */
-    control.value = saturation;
-
-    if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
-      perror ("VIDIOC_S_CTRL");
-      return -1;
-    }
-  }
-#endif /* TBD */
-  return 0;
-}
-
-/*===========================================================================
- * FUNCTION     - decrease_saturation -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_saturation (void) {
-  --saturation;
-  if (saturation < CAMERA_MIN_SATURATION) {
-    saturation = CAMERA_MIN_SATURATION;
-    printf("Reached min saturation. \n");
-  } else
-    printf("Decrease saturation to %d\n", saturation);
-
-  /*intrfcCtrl.setContrast(camfd, contrast);*/
-  struct v4l2_queryctrl queryctrl;
-  struct v4l2_control control;
-
-  memset (&queryctrl, 0, sizeof (queryctrl));
-  queryctrl.id = V4L2_CID_SATURATION;
-#if 0 /* TBD */
-  if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
-    if (errno != EINVAL) {
-      perror ("VIDIOC_QUERYCTRL");
-      exit (EXIT_FAILURE);
-    } else {
-      printf ("V4L2_CID_saturation is not supported\n");
-    }
-  } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
-    printf ("V4L2_CID_saturation is not supported\n");
-  } else {
-    memset (&control, 0, sizeof (control));
-    control.id = V4L2_CID_SATURATION;
-    /* Decreasing the contrast */
-    control.value = saturation;
-
-    if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
-      perror ("VIDIOC_S_CTRL");
-      return -1;
-    }
-  }
-#endif /* TBD */
-  return 0;
-}
-
-int takePicture_yuv(int cam_id)
-{
-  int rc = 0;
-  CDBG("%s:BEGIN\n", __func__);
-  if(0 != (rc = mm_app_take_picture(cam_id))) {
-    CDBG_ERROR("%s: mm_app_take_picture() err=%d\n", __func__, rc);
-  }
-  return rc;
-}
-
-int takePicture_zsl(int cam_id)
-{
-  int rc = 0;
-  CDBG("%s:BEGIN\n", __func__);
-  if(0 != (rc = mm_app_take_zsl(cam_id))) {
-    CDBG_ERROR("%s: mm_app_take_picture() err=%d\n", __func__, rc);
-  }
-  return rc;
-}
-
-int takePicture_live(int cam_id)
-{
-  int rc = 0;
-  CDBG("%s:BEGIN\n", __func__);
-  if(0 != (rc = mm_app_take_live_snapshot(cam_id))) {
-    CDBG_ERROR("%s: mm_app_take_picture() err=%d\n", __func__, rc);
-  }
-  return rc;
-}
-
-int takePicture_raw(int cam_id)
-{
-  int rc = 0;
-  CDBG("%s:BEGIN\n", __func__);
-  if(0 != (rc = mm_app_take_raw(cam_id))) {
-    CDBG("%s: mm_app_take_raw_picture() err=%d\n", __func__, rc);
-  }
-  return rc;
-}
-int system_dimension_set(int cam_id)
-{
-  static cam_ctrl_dimension_t dim;
-  int rc = 0;
-
-  if (preview_video_resolution_flag == 0) {
-    mm_app_set_dim_def(&dim);
-  } else {
-    dim.video_width = input_display.user_input_display_width;
-    dim.video_width = CEILING32(dim.video_width);
-    dim.video_height = input_display.user_input_display_height;
-    dim.orig_video_width = dim.video_width;
-    dim.orig_video_height = dim.video_height;
-    dim.display_width = dim.video_width;
-    dim.display_height = dim.video_height;
-  }
-  rc = mm_app_set_dim(cam_id, &dim);
-  return rc;
-}
-
-/*int run_test_harness()
-{
-    int good_test_cnt = 0;
-
-    rc = run_test_1();
-    if(rc < 0) 
-        CDBG_EROR("%s: run_test_1 err = %d", __func__, rc);
-    rc = run_test_2();
-}*/
-/*===========================================================================
- * FUNCTION    - main -
- *
- * DESCRIPTION:
- *==========================================================================*/
-int main(int argc, char **argv)
-{
-  int keep_on_going = 1;
-  int c, rc = 0, tmp_fd;
-  int run_tc = 0;
-  int run_dual_tc = 0;
-  struct v4l2_capability v4l2_cap;
-
-  /* get v4l2 params - memory type etc */
-  while ((c = getopt(argc, argv, "tdh")) != -1) {
-    //printf("usage: %s [-m] [-u] [-o]\n", argv[1]);
-    switch (c) {
-#if 0
-      case 'm':
-        memoryType = V4L2_MEMORY_MMAP;
-        break;
-
-      case 'o':
-        /*use_overlay_fb_display_driver();*/
-        break;
-      case 'u':
-        memoryType = V4L2_MEMORY_USERPTR;
-        break;
-#endif
-      case 't':
-        run_tc = 1;
-        break;
-      case 'd':
-        run_dual_tc = 1;
-        break;
-      case 'h':
-      default:
-        printf("usage: %s [-m] [-u] [-o]\n", argv[0]);
-        printf("-m:   V4L2_MEMORY_MMAP.      \n");
-        printf("-o:   use overlay fb display driver\n");
-        printf("-u:   V4L2_MEMORY_USERPTR\n");
-        exit(0);
-    }
-  }
-
-  CDBG("\nCamera Test Application\n");
-
-  struct timeval tdBeforePreviewVideo, tdStopCamera;
-  struct timezone tz;
-
-  //return run_test_harness();
-  if((rc = mm_app_load_hal())) {
-    CDBG_ERROR("%s:mm_app_init err=%d\n", __func__, rc);
-    exit(-1);
-  }
-    /* we must init mm_app first */
-  if(mm_app_init() != MM_CAMERA_OK) {
-    CDBG_ERROR("%s:mm_app_init err=%d\n", __func__, rc);
-    exit(-1);
-  }
-
-  if(run_tc) {
-    printf("\tRunning unit test engine only\n");
-    rc = mm_app_unit_test();
-    printf("\tUnit test engine. EXIT(%d)!!!\n", rc);
-    exit(rc);
-  }
-
-  if(run_dual_tc) {
-    printf("\tRunning Dual camera test engine only\n");
-    rc = mm_app_dual_test();
-    printf("\t Dual camera engine. EXIT(%d)!!!\n", rc);
-    exit(rc);
-  }
-
-  gettimeofday(&tdBeforePreviewVideo, &tz);
-
-  CDBG("Profiling: Start Camera timestamp = %ld ms\n",
-    (tdBeforePreviewVideo.tv_sec * 1000) + (tdBeforePreviewVideo.tv_usec/1000));
-
-  /* launch the primary camera in default mode */
-  if( mm_app_open(CAMERA_OPENED)) {
-    CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-    exit(-2);
-  }
-
-  /* main loop doing the work*/
-  do {
-    keep_on_going = submain();
-  } while ( keep_on_going );
-
-  /* Clean up and exit. */
-  CDBG("Exiting the app\n");
-
-error_ionfd_open:
-  mm_app_close(CAMERA_OPENED);
-
-  gettimeofday(&tdStopCamera, &tz);
-  CDBG("Exiting application\n");
-  CDBG("Profiling: Stop camera end timestamp = %ld ms\n",
-      (tdStopCamera.tv_sec * 1000) + (tdStopCamera.tv_usec/1000));
-
-  return 0;
-}
-
-
-/*===========================================================================
- * FUNCTION     - submain -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-static int submain()
-{
-  int rc = 0;
-  int back_mainflag = 0;
-  char tc_buf[3];
-  int stop_preview = 1;
-  menu_id_change_t current_menu_id = MENU_ID_MAIN, next_menu_id;
-  camera_action_t action_id;
-  int action_param;
-  int i;
-  int cam_id;
-
-  CDBG("%s:E", __func__);
-  struct timeval tdStopCamera;
-  struct timezone tz;
-
-  cam_id = my_cam_app.cam_open;
-
-  rc = system_dimension_set(cam_id);
-  CDBG("Start Preview");
-  if( 0 != (rc = startPreview(cam_id))) {
-    CDBG("%s: startPreview() err=%d\n", __func__, rc);
-    return 0;
-  }
-
-  do {
-    print_current_menu (current_menu_id);
-    fgets(tc_buf, 3, stdin);
-
-    next_menu_id = next_menu(current_menu_id, tc_buf[0], &action_id, &action_param);
-
-    if (next_menu_id != MENU_ID_INVALID) {
-      current_menu_id = next_menu_id;
-    }
-    if (action_id == ACTION_NO_ACTION) {
-      continue;
-    }
-    if(camframe_status == -1) {
-      printf("Preview/Video ERROR condition reported Closing Camera APP\n");
-      break;
-    }
-
-    switch(action_id) {
-      case ACTION_STOP_CAMERA:
-        CDBG("ACTION_STOP_CAMERA \n");
-        stopPreview(cam_id);
-        break;
-
-      case ACTION_PREVIEW_VIDEO_RESOLUTION:
-        back_mainflag = 1;
-        CDBG("Selection for the preview/video resolution change\n");
-        switchRes(cam_id);
-        preview_video_resolution (action_param);
-        break;
-      case ACTION_SET_WHITE_BALANCE:
-        CDBG("Selection for the White Balance changes\n");
-        set_whitebalance(action_param);
-        break;
-
-      case ACTION_SET_EXP_METERING:
-        CDBG("Selection for the Exposure Metering changes\n");
-        set_exp_metering(action_param);
-        break;
-
-      case ACTION_GET_CTRL_VALUE:
-        CDBG("Selection for getting control value\n");
-        get_ctrl_value(action_param);
-        break;
-
-      case ACTION_BRIGHTNESS_INCREASE:
-        printf("Increase brightness\n");
-        increase_brightness();
-        break;
-
-      case ACTION_BRIGHTNESS_DECREASE:
-        printf("Decrease brightness\n");
-        decrease_brightness();
-        break;
-
-      case ACTION_CONTRAST_INCREASE:
-        CDBG("Selection for the contrast increase\n");
-        increase_contrast ();
-        break;
-
-      case ACTION_CONTRAST_DECREASE:
-        CDBG("Selection for the contrast decrease\n");
-        decrease_contrast ();
-        break;
-
-      case ACTION_EV_INCREASE:
-        CDBG("Selection for the EV increase\n");
-        increase_EV ();
-        break;
-
-      case ACTION_EV_DECREASE:
-        CDBG("Selection for the EV decrease\n");
-        decrease_EV ();
-        break;
-
-      case ACTION_SATURATION_INCREASE:
-        CDBG("Selection for the EV increase\n");
-        increase_saturation ();
-        break;
-
-      case ACTION_SATURATION_DECREASE:
-        CDBG("Selection for the EV decrease\n");
-        decrease_saturation ();
-        break;
-
-      case ACTION_TOGGLE_AFR:
-        CDBG("Select for auto frame rate toggling\n");
-        toggle_afr();
-        break;
-
-      case ACTION_SET_ISO:
-        CDBG("Select for ISO changes\n");
-        set_iso(action_param);
-        break;
-
-      case ACTION_SET_ZOOM:
-        CDBG("Selection for the zoom direction changes\n");
-        set_zoom(action_param);
-        break;
-
-      case ACTION_SHARPNESS_INCREASE:
-        CDBG("Selection for sharpness increase\n");
-        increase_sharpness();
-        break;
-
-      case ACTION_SHARPNESS_DECREASE:
-        CDBG("Selection for sharpness decrease\n");
-        decrease_sharpness();
-        break;
-
-      case ACTION_TAKE_YUV_SNAPSHOT:
-        CDBG("Take YUV snapshot\n");
-        if (takePicture_yuv(cam_id) < 0)
-          goto ERROR;
-        break;
-      case ACTION_TAKE_RAW_SNAPSHOT:
-        CDBG("Take YUV snapshot\n");
-        if (takePicture_raw(cam_id) < 0)
-          goto ERROR;
-        break;
-      case ACTION_START_RECORDING:
-        CDBG("Start recording action\n");
-        if (startRecording(cam_id) < 0)
-          goto ERROR;
-        break;
-      case ACTION_STOP_RECORDING:
-        CDBG("Stop recording action\n");
-        if (stopRecording(cam_id) < 0)
-          goto ERROR;
-        break;
-      case ACTION_NO_ACTION:
-        printf("Go back to main menu");
-        break;
-      case ACTION_SWITCH_CAMERA:
-        CDBG("Toggle Camera action\n");
-        back_mainflag = 1;
-        switchCamera(action_param - 1);
-        break;
-
-      case ACTION_TAKE_ZSL_SNAPSHOT:
-        CDBG("Take ZSL snapshot\n");
-        if (takePicture_zsl(cam_id) < 0)
-        {
-          CDBG("Error");    
-          goto ERROR;
-        }
-        break;
-      case ACTION_START_RDI:
-		CDBG("Start RDI Stream\n");
-		startRdi(cam_id);
-		break;
-	  case ACTION_STOP_RDI:
-		CDBG("Stop RDI Stream\n");
-		stopRdi(cam_id);
-		break;
-      case ACTION_TAKE_LIVE_SNAPSHOT:
-        CDBG("Take Live snapshot\n");
-        if (takePicture_live(cam_id) < 0)
-        {
-          CDBG("Error");    
-          goto ERROR;
-        }
-        break;
-
-      default:
-        printf("\n\n!!!!!WRONG INPUT: %d!!!!\n", action_id);
-        break;
-    }
-
-    usleep(1000 * 1000);
-    CDBG("action_id = %d\n", action_id);
-    camframe_status = 0;
-
-  } while ((action_id != ACTION_STOP_CAMERA) &&
-      (action_id != ACTION_PREVIEW_VIDEO_RESOLUTION) && (action_id !=ACTION_SWITCH_CAMERA));
-  action_id = ACTION_NO_ACTION;
-
-  //system_destroy();
-
-
-  return back_mainflag;
-
-ERROR:
-  back_mainflag = 0;
-  return back_mainflag;
-}
-
-
-/*===========================================================================
- * FUNCTION     - preview_resolution -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int preview_video_resolution (int preview_video_action_param) {
-  char * resolution_name;
-  CDBG("Selecting the action for preview/video resolution = %d \n", preview_video_action_param);
-  resolution_name = set_preview_video_dimension_tbl(preview_video_action_param,
-                      & input_display.user_input_display_width,
-                      & input_display.user_input_display_height);
-
-  CDBG("Selected preview/video resolution is %s\n", resolution_name);
-
-  if (resolution_name == NULL) {
-    CDBG("main:%d set_preview_dimension failed!\n", __LINE__);
-    goto ERROR;
-  }
-
-  CDBG("Selected Preview Resolution: display_width = %d, display_height = %d\n",
-    input_display.user_input_display_width, input_display.user_input_display_height);
-
-  preview_video_resolution_flag = 1;
-  return 0;
-
-ERROR:
-  return -1;
-}
-
-/*===========================================================================
- * FUNCTION     - set_whitebalance -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int set_whitebalance (int wb_action_param) {
-
-    int rc = 0;
-    struct v4l2_control ctrl_awb, ctrl_temperature;
-
-    ctrl_awb.id = V4L2_CID_AUTO_WHITE_BALANCE;
-    ctrl_awb.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
-
-    switch (wb_action_param) {
-    case CAMERA_WB_INCANDESCENT:
-        ctrl_awb.value = FALSE;
-        ctrl_temperature.value = 2800;
-        break;
-    case CAMERA_WB_DAYLIGHT:
-        ctrl_awb.value = FALSE;
-        ctrl_temperature.value = 6500;
-	break;
-    case CAMERA_WB_FLUORESCENT:
-        ctrl_awb.value = FALSE;
-	ctrl_temperature.value = 4200;
-	break;
-    case CAMERA_WB_CLOUDY_DAYLIGHT:
-        ctrl_awb.value = FALSE;
-	ctrl_temperature.value = 7500;
-	break;
-    case CAMERA_WB_AUTO:
-    default:
-        ctrl_awb.value = TRUE;
-        break;
-    }
-
-DONE:
-    return rc;
-}
-
-
-/*===========================================================================
- * FUNCTION     - set_exp_metering -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int set_exp_metering (int exp_metering_action_param) {
-
-	int rc = 0;
-	struct v4l2_control ctrl;
-
-  ctrl.id = MSM_V4L2_PID_EXP_METERING;
-  ctrl.value = exp_metering_action_param;
- // rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
-  return rc;
-}
-
-int get_ctrl_value (int ctrl_value_mode_param){
-
-    int rc = 0;
-    struct v4l2_control ctrl;
-
-    if (ctrl_value_mode_param == WHITE_BALANCE_STATE) {
-        printf("You chose WHITE_BALANCE_STATE\n");
-        ctrl.id = V4L2_CID_AUTO_WHITE_BALANCE;
-    }
-    else if (ctrl_value_mode_param == WHITE_BALANCE_TEMPERATURE) {
-        printf("You chose WHITE_BALANCE_TEMPERATURE\n");
-        ctrl.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
-    }
-    else if (ctrl_value_mode_param == BRIGHTNESS_CTRL) {
-        printf("You chose brightness value\n");
-        ctrl.id = V4L2_CID_BRIGHTNESS;
-    }
-    else if (ctrl_value_mode_param == EV) {
-        printf("You chose exposure value\n");
-        ctrl.id = V4L2_CID_EXPOSURE;
-    }
-    else if (ctrl_value_mode_param == CONTRAST_CTRL) {
-        printf("You chose contrast value\n");
-        ctrl.id = V4L2_CID_CONTRAST;
-    }
-    else if (ctrl_value_mode_param == SATURATION_CTRL) {
-        printf("You chose saturation value\n");
-        ctrl.id = V4L2_CID_SATURATION;
-    } else if (ctrl_value_mode_param == SHARPNESS_CTRL) {
-        printf("You chose sharpness value\n");
-        ctrl.id = V4L2_CID_SHARPNESS;
-    }
-
-  //  rc = ioctl(camfd, VIDIOC_G_CTRL, &ctrl);
-
-    return rc;
-}
-
-/*===========================================================================
- * FUNCTION     - toggle_afr -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int toggle_afr () {
-  int rc = 0;
-  struct v4l2_control ctrl;
-
-  memset(&ctrl, 0, sizeof(ctrl));
-  ctrl.id = V4L2_CID_EXPOSURE_AUTO;
-//  rc = ioctl(camfd, VIDIOC_G_CTRL, &ctrl);
-  if (rc == -1) {
-    CDBG("%s: VIDIOC_G_CTRL V4L2_CID_EXPOSURE_AUTO failed: %s\n",
-        __func__, strerror(errno));
-    return rc;
-  }
-
-  /* V4L2_CID_EXPOSURE_AUTO needs to be AUTO or SHUTTER_PRIORITY */
-  if (ctrl.value != V4L2_EXPOSURE_AUTO &&
-    ctrl.value != V4L2_EXPOSURE_SHUTTER_PRIORITY) {
-    CDBG("%s: V4L2_CID_EXPOSURE_AUTO needs to be AUTO/SHUTTER_PRIORITY\n",
-        __func__);
-    return -1;
-  }
-
-  /* Get V4L2_CID_EXPOSURE_AUTO_PRIORITY */
-  memset(&ctrl, 0, sizeof(ctrl));
-  ctrl.id = V4L2_CID_EXPOSURE_AUTO_PRIORITY;
- // rc = ioctl(camfd, VIDIOC_G_CTRL, &ctrl);
-  if (rc == -1) {
-    CDBG("%s: VIDIOC_G_CTRL V4L2_CID_EXPOSURE_AUTO_PRIORITY failed: %s\n",
-        __func__, strerror(errno));
-    return rc;
-  }
-
-  ctrl.value = !ctrl.value;
-  printf("V4L2_CID_EXPOSURE_AUTO_PRIORITY changed to %d\n", ctrl.value);
- // rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-  if (rc == -1) {
-    CDBG("%s: VIDIOC_S_CTRL V4L2_CID_EXPOSURE_AUTO_PRIORITY failed: %s\n",
-      __func__, strerror(errno));
-  }
-  return rc;
-}
-
-int set_zoom (int zoom_action_param) {
-    int rc = 0;
-    struct v4l2_control ctrl;
-
-    if (zoom_action_param == ZOOM_IN) {
-        zoom_level += zoom_queryctrl.step;
-        if (zoom_level > zoom_queryctrl.maximum)
-            zoom_level = zoom_queryctrl.maximum;
-    } else if (zoom_action_param == ZOOM_OUT) {
-        zoom_level -= zoom_queryctrl.step;
-        if (zoom_level < zoom_queryctrl.minimum)
-            zoom_level = zoom_queryctrl.minimum;
-    } else {
-        CDBG("%s: Invalid zoom_action_param value\n", __func__);
-        return -EINVAL;
-    }
-    ctrl.id = V4L2_CID_ZOOM_ABSOLUTE;
-    ctrl.value = zoom_level;
-  //  rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
-    return rc;
-}
-
-/*===========================================================================
- * FUNCTION     - set_iso -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int set_iso (int iso_action_param) {
-    int rc = 0;
-    struct v4l2_control ctrl;
-
-    ctrl.id = MSM_V4L2_PID_ISO;
-    ctrl.value = iso_action_param - 1;
-  //  rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
-    return rc;
-}
-
-/*===========================================================================
- * FUNCTION     - increase_sharpness -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_sharpness () {
-    int rc = 0;
-    struct v4l2_control ctrl;
-
-    sharpness += sharpness_queryctrl.step;
-    if (sharpness > sharpness_queryctrl.maximum)
-        sharpness = sharpness_queryctrl.maximum;
-
-    ctrl.id = V4L2_CID_SHARPNESS;
-    ctrl.value = sharpness;
- //   rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
-    return rc;
-}
-
-/*===========================================================================
- * FUNCTION     - decrease_sharpness -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_sharpness () {
-    int rc = 0;
-    struct v4l2_control ctrl;
-
-    sharpness -= sharpness_queryctrl.step;
-    if (sharpness < sharpness_queryctrl.minimum)
-        sharpness = sharpness_queryctrl.minimum;
-
-    ctrl.id = V4L2_CID_SHARPNESS;
-    ctrl.value = sharpness;
-  //  rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
-    return rc;
-}
-
-/*===========================================================================
- * FUNCTION     - print_current_menu -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int print_current_menu (menu_id_change_t current_menu_id) {
-  if (current_menu_id == MENU_ID_MAIN) {
-    print_menu_preview_video ();
-  } else if (current_menu_id == MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE) {
-    camera_preview_video_resolution_change_tbl ();
-  }else if (current_menu_id == MENU_ID_WHITEBALANCECHANGE) {
-    camera_preview_video_wb_change_tbl();
-  } else if (current_menu_id == MENU_ID_EXPMETERINGCHANGE) {
-    camera_preview_video_exp_metering_change_tbl();
-  } else if (current_menu_id == MENU_ID_GET_CTRL_VALUE) {
-    camera_preview_video_get_ctrl_value_tbl();
-  } else if (current_menu_id == MENU_ID_ISOCHANGE) {
-    camera_preview_video_iso_change_tbl();
-  } else if (current_menu_id == MENU_ID_BRIGHTNESSCHANGE) {
-    camera_brightness_change_tbl ();
-  } else if (current_menu_id == MENU_ID_CONTRASTCHANGE) {
-    camera_contrast_change_tbl ();
-  } else if (current_menu_id == MENU_ID_EVCHANGE) {
-    camera_EV_change_tbl ();
-  } else if (current_menu_id == MENU_ID_SATURATIONCHANGE) {
-    camera_saturation_change_tbl ();
-  } else if (current_menu_id == MENU_ID_ZOOMCHANGE) {
-    camera_preview_video_zoom_change_tbl();
-  } else if (current_menu_id == MENU_ID_SHARPNESSCHANGE) {
-    camera_preview_video_sharpness_change_tbl();
-  }else if (current_menu_id == MENU_ID_SWITCHCAMERA) {
-    camera_switch_tbl();
-  }else if (current_menu_id == MENU_ID_RECORD) {
-    camera_record_tbl();
-  }
-
-  return 0;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_pp.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_pp.c
deleted file mode 100755
index 5ed5053..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_pp.c
+++ /dev/null
@@ -1,963 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <linux/ion.h>
-#include "mm_qcamera_app.h"
-
-extern int system_dimension_set(int cam_id);
-extern void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h, char* name, int main_422);
-
-int32_t mm_qcamera_queue_init(mm_qcamera_queue_t* queue);
-int32_t mm_qcamera_queue_enq(mm_qcamera_queue_t* queue, void* data);
-void* mm_qcamera_queue_deq(mm_qcamera_queue_t* queue);
-void* mm_qcamera_queue_peek(mm_qcamera_queue_t* queue);
-int32_t mm_qcamera_queue_deinit(mm_qcamera_queue_t* queue);
-int32_t mm_qcamera_queue_flush(mm_qcamera_queue_t* queue);
-
-static void mm_app_preview_pp_notify_cb(mm_camera_super_buf_t *bufs,
-                                        void *user_data)
-{
-    int rc;
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    repro_src_buf_info *buf_info = NULL;
-
-    CDBG("%s: BEGIN\n", __func__);
-    frame = bufs->bufs[0];
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n",
-         __func__, frame->frame_len, frame->frame_idx);
-
-    dumpFrameToFile(frame, pme->dim.display_width, pme->dim.display_height,"preview", 1);
-
-    buf_info = (repro_src_buf_info *)mm_qcamera_queue_peek(&pme->repro_q);
-    if (NULL != buf_info) {
-        buf_info->ref_cnt--;
-        if (0 == buf_info->ref_cnt) {
-            mm_qcamera_queue_deq(&pme->repro_q);
-            pme->cam->ops->qbuf(pme->cam->camera_handle, pme->ch_id, buf_info->frame);
-            mm_stream_invalid_cache(pme, buf_info->frame);
-            buf_info->frame = NULL;
-        }
-    }
-
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle, pme->ch_id, frame)) {
-        CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
-        return;
-    }
-    mm_stream_invalid_cache(pme,frame);
-    CDBG("%s: END\n", __func__);
-}
-
-static void mm_app_video_pp_notify_cb(mm_camera_super_buf_t *bufs,
-                                      void *user_data)
-{
-	int rc;
-	mm_camera_buf_def_t *frame = NULL;
-	mm_camera_app_obj_t *pme = NULL;
-    repro_src_buf_info *buf_info = NULL;
-
-	CDBG("%s: BEGIN\n", __func__);
-	frame = bufs->bufs[0] ;
-	pme = (mm_camera_app_obj_t *)user_data;
-
-	CDBG("%s: BEGIN - length=%d, frame idx = %d\n",
-         __func__, frame->frame_len, frame->frame_idx);
-
-	dumpFrameToFile(frame,pme->dim.orig_video_width,pme->dim.orig_video_height,"video", 1);
-
-    buf_info = (repro_src_buf_info *)mm_qcamera_queue_peek(&pme->repro_q);
-    if (NULL != buf_info) {
-        buf_info->ref_cnt--;
-        if (0 == buf_info->ref_cnt) {
-            mm_qcamera_queue_deq(&pme->repro_q);
-            pme->cam->ops->qbuf(pme->cam->camera_handle, pme->ch_id, buf_info->frame);
-            mm_stream_invalid_cache(pme, buf_info->frame);
-            buf_info->frame = NULL;
-        }
-    }
-
-    if(MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle, pme->ch_id, frame))
-    {
-        CDBG_ERROR("%s: Failed in Snapshot Qbuf\n", __func__);
-        return;
-    }
-    mm_stream_invalid_cache(pme,frame);
-    CDBG("%s: END\n", __func__);
-}
-
-static void mm_app_isp_pix_notify_cb(mm_camera_super_buf_t *bufs,
-                                     void *user_data)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    mm_camera_repro_data_t repro_data;
-
-    CDBG("%s: BEGIN\n", __func__);
-    frame = bufs->bufs[0] ;
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n",
-     __func__, frame->frame_len, frame->frame_idx);
-
-    pme->repro_buf_info[frame->buf_idx].frame = frame;
-    pme->repro_buf_info[frame->buf_idx].ref_cnt = pme->repro_dest_num;
-    mm_qcamera_queue_enq(&pme->repro_q,
-                         (void *)&pme->repro_buf_info[frame->buf_idx]);
-
-    memset(&repro_data, 0, sizeof(mm_camera_repro_data_t));
-    repro_data.src_frame = frame;
-
-    rc = pme->cam->ops->reprocess(
-                                 pme->cam->camera_handle,
-                                 pme->ch_id,
-                                 pme->isp_repro_handle,
-                                 &repro_data);
-    if (MM_CAMERA_OK != rc) {
-        CDBG_ERROR("%s: reprocess error = %d", __func__, rc);
-    }
-
-	CDBG("%s: END\n", __func__);
-}
-
-int prepareReprocess(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int op_mode;
-    mm_camera_repro_isp_config_t config;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: E",__func__);
-    pme->mem_cam->get_buf = mm_stream_initbuf;
-    pme->mem_cam->put_buf = mm_stream_deinitbuf;
-    pme->mem_cam->user_data = pme;
-
-    /* set mode */
-    op_mode = MM_CAMERA_OP_MODE_VIDEO;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
-                                     pme->cam->camera_handle,
-                                     MM_CAMERA_PARM_OP_MODE,
-                                     &op_mode))) {
-        CDBG_ERROR("%s: Set preview op mode error", __func__);
-        goto end;
-    }
-
-    /* init reprocess queue */
-    mm_qcamera_queue_init(&pme->repro_q);
-    memset(pme->repro_buf_info, 0, sizeof(pme->repro_buf_info));
-
-    /* add isp pix output1 stream */
-    pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = pme->cam->ops->add_stream(
-                                                        pme->cam->camera_handle,
-                                                        pme->ch_id,
-                                                        mm_app_isp_pix_notify_cb,
-                                                        pme,
-                                                        MM_CAMERA_ISP_PIX_OUTPUT1,
-                                                        0);
-
-    if (!pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id) {
-        CDBG_ERROR("%s:Add isp_pix_output1 error\n", __func__);
-        rc = -1;
-        goto end;
-    }
-
-    /* add preview stream */
-    pme->stream[MM_CAMERA_PREVIEW].id = pme->cam->ops->add_stream(
-                                                        pme->cam->camera_handle,
-                                                        pme->ch_id,
-                                                        mm_app_preview_pp_notify_cb,
-                                                        pme,
-                                                        MM_CAMERA_PREVIEW,
-                                                        0);
-
-    if (!pme->stream[MM_CAMERA_PREVIEW].id) {
-        CDBG_ERROR("%s:Add stream preview error\n", __func__);
-        rc = -1;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id);
-        pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = 0;
-        goto end;
-    }
-
-    /* add record stream */
-    pme->stream[MM_CAMERA_VIDEO].id = pme->cam->ops->add_stream(
-                                                        pme->cam->camera_handle,
-                                                        pme->ch_id,
-                                                        mm_app_video_pp_notify_cb,
-                                                        pme,
-                                                        MM_CAMERA_VIDEO,
-                                                        0);
-
-    if (!pme->stream[MM_CAMERA_VIDEO].id) {
-        CDBG_ERROR("%s:Add stream video error\n", __func__);
-        rc = -1;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->stream[MM_CAMERA_PREVIEW].id = 0;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id);
-        pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = 0;
-        goto end;
-    }
-
-    /* open isp reprocess */
-    pme->isp_repro_handle = pme->cam->ops->open_repro_isp(
-                                                        pme->cam->camera_handle,
-                                                        pme->ch_id,
-                                                        MM_CAMERA_REPRO_ISP_PIX);
-
-    if (!pme->isp_repro_handle) {
-        CDBG_ERROR("%s:open isp reprocess error\n", __func__);
-        rc = -1;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_VIDEO].id);
-        pme->stream[MM_CAMERA_VIDEO].id = 0;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->stream[MM_CAMERA_PREVIEW].id = 0;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id);
-        pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = 0;
-        goto end;
-    }
-
-    /* prepare repro isp config */
-    memset(&pme->repro_config, 0, sizeof(mm_camera_repro_config_data_t));
-    pme->repro_config.image_mode = MM_CAMERA_ISP_PIX_OUTPUT1;
-    if (pme->dim.display_width * pme->dim.display_height >
-        pme->dim.video_width * pme->dim.video_height) {
-        /* preview size is larger than video, use preview config as repro isp config */
-        pme->repro_config.format = pme->dim.prev_format;
-        pme->repro_config.width = pme->dim.display_width;
-        pme->repro_config.height = pme->dim.display_height;
-    } else {
-        pme->repro_config.format = pme->dim.enc_format;
-        pme->repro_config.width = pme->dim.video_width;
-        pme->repro_config.height = pme->dim.video_height;
-    }
-
-    /* config isp reprocess */
-    memset(&config, 0, sizeof(mm_camera_repro_isp_config_t));
-    config.src.format = pme->repro_config.format;
-    config.src.image_mode = pme->repro_config.image_mode;
-    config.src.width = pme->repro_config.width;
-    config.src.height = pme->repro_config.height;
-    config.src.inst_handle = pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id;
-
-    pme->repro_dest_num = 0;
-    config.num_dest = 2;
-    config.dest[0].image_mode = MM_CAMERA_PREVIEW;
-    config.dest[0].format = pme->dim.prev_format;
-    config.dest[0].width = pme->dim.display_width;
-    config.dest[0].height = pme->dim.display_height;
-    config.dest[0].inst_handle = pme->stream[MM_CAMERA_PREVIEW].id;
-    config.dest[1].image_mode = MM_CAMERA_VIDEO;
-    config.dest[1].format = pme->dim.enc_format;
-    config.dest[1].width = pme->dim.video_width;
-    config.dest[1].height = pme->dim.video_height;
-    config.dest[1].inst_handle = pme->stream[MM_CAMERA_VIDEO].id;
-
-    rc = pme->cam->ops->config_repro_isp(
-                                        pme->cam->camera_handle,
-                                        pme->ch_id,
-                                        pme->isp_repro_handle,
-                                        &config);
-
-    if (MM_CAMERA_OK != rc) {
-        CDBG_ERROR("%s:config isp reprocess error = %d\n", __func__, rc);
-        pme->cam->ops->close_repro_isp(pme->cam->camera_handle,
-                                       pme->ch_id,
-                                       pme->isp_repro_handle);
-        pme->isp_repro_handle = 0;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_VIDEO].id);
-        pme->stream[MM_CAMERA_VIDEO].id = 0;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->stream[MM_CAMERA_PREVIEW].id = 0;
-        pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                  pme->ch_id,
-                                  pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id);
-        pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = 0;
-    }
-
-end:
-    CDBG("%s: X rc = %d", __func__, rc);
-    return rc;
-}
-
-int unprepareReprocess(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: E",__func__);
-    rc = pme->cam->ops->close_repro_isp(pme->cam->camera_handle,
-                                        pme->ch_id,
-                                        pme->isp_repro_handle);
-    pme->isp_repro_handle = 0;
-    mm_qcamera_queue_deinit(&pme->repro_q);
-
-    CDBG("%s: X rc = %d", __func__, rc);
-    return rc;
-}
-
-int startPreviewPP(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[1];
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: E",__func__);
-
-    /* attach preview stream to isp reprocess pipe */
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->attach_stream_to_repro_isp(
-                                                            pme->cam->camera_handle,
-                                                            pme->ch_id,
-                                                            pme->isp_repro_handle,
-                                                            pme->stream[MM_CAMERA_PREVIEW].id))) {
-        CDBG_ERROR("%s : Attach preview to reprocess error",__func__);
-        goto end;
-    }
-
-    /* start isp reprocess pipe for preview */
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_repro_isp(pme->cam->camera_handle,
-                                                            pme->ch_id,
-                                                            pme->isp_repro_handle,
-                                                            pme->stream[MM_CAMERA_PREVIEW].id))) {
-        CDBG_ERROR("%s : Start reprocess for preview error",__func__);
-        pme->cam->ops->detach_stream_from_repro_isp(
-                                                pme->cam->camera_handle,
-                                                pme->ch_id,
-                                                pme->isp_repro_handle,
-                                                pme->stream[MM_CAMERA_PREVIEW].id);
-        goto end;
-    }
-
-    /* increase actual reprocess dest num */
-    pme->repro_dest_num++;
-
-    /* start preview stream */
-    pme->stream[MM_CAMERA_PREVIEW].str_config.fmt.meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    pme->stream[MM_CAMERA_PREVIEW].str_config.fmt.fmt = pme->dim.prev_format;
-    pme->stream[MM_CAMERA_PREVIEW].str_config.fmt.width = pme->dim.display_width;
-    pme->stream[MM_CAMERA_PREVIEW].str_config.fmt.height = pme->dim.display_height;
-    pme->stream[MM_CAMERA_PREVIEW].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_PREVIEW].str_config.num_of_bufs = PREVIEW_BUF_NUM;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,
-                                                           pme->ch_id,
-                                                           pme->stream[MM_CAMERA_PREVIEW].id,
-                                                           &pme->stream[MM_CAMERA_PREVIEW].str_config))) {
-        CDBG_ERROR("%s:config preview err=%d\n", __func__, rc);
-        pme->cam->ops->stop_repro_isp(
-                                    pme->cam->camera_handle,
-                                    pme->ch_id,
-                                    pme->isp_repro_handle,
-                                    pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->cam->ops->detach_stream_from_repro_isp(
-                                                pme->cam->camera_handle,
-                                                pme->ch_id,
-                                                pme->isp_repro_handle,
-                                                pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->repro_dest_num--;
-        goto end;
-    }
-    stream[0] = pme->stream[MM_CAMERA_PREVIEW].id;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,
-                                                          pme->ch_id,
-                                                          1,
-                                                          stream))) {
-        CDBG_ERROR("%s : Preview Stream on Error",__func__);
-        pme->cam->ops->stop_repro_isp(
-                                    pme->cam->camera_handle,
-                                    pme->ch_id,
-                                    pme->isp_repro_handle,
-                                    pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->cam->ops->detach_stream_from_repro_isp(
-                                                pme->cam->camera_handle,
-                                                pme->ch_id,
-                                                pme->isp_repro_handle,
-                                                pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->repro_dest_num--;
-        goto end;
-    }
-
-    /* start isp pix output1 stream */
-    pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.fmt.meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.fmt.fmt = pme->repro_config.format;
-    pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.fmt.width = pme->repro_config.width;
-    pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.fmt.height = pme->repro_config.height;
-    pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.num_of_bufs = ISP_PIX_BUF_NUM;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,
-                                                           pme->ch_id,
-                                                           pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id,
-                                                           &pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config))) {
-        CDBG_ERROR("%s:config isp pix stream err=%d\n", __func__, rc);
-        pme->cam->ops->stop_repro_isp(
-                                    pme->cam->camera_handle,
-                                    pme->ch_id,
-                                    pme->isp_repro_handle,
-                                    pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->cam->ops->detach_stream_from_repro_isp(
-                                                pme->cam->camera_handle,
-                                                pme->ch_id,
-                                                pme->isp_repro_handle,
-                                                pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->repro_dest_num--;
-    }
-    stream[0] = pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,
-                                                          pme->ch_id,
-                                                          1,
-                                                          stream))) {
-        CDBG_ERROR("%s : Preview Stream on Error",__func__);
-        pme->cam->ops->stop_repro_isp(
-                                    pme->cam->camera_handle,
-                                    pme->ch_id,
-                                    pme->isp_repro_handle,
-                                    pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->cam->ops->detach_stream_from_repro_isp(
-                                                pme->cam->camera_handle,
-                                                pme->ch_id,
-                                                pme->isp_repro_handle,
-                                                pme->stream[MM_CAMERA_PREVIEW].id);
-        pme->repro_dest_num--;
-        goto end;
-    }
-
-end:
-    CDBG("%s: X rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int stopPreviewPP(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[1];
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: E",__func__);
-
-    /* stop preview stream */
-    stream[0] = pme->stream[MM_CAMERA_PREVIEW].id;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,
-                                                          pme->ch_id,
-                                                          1,
-                                                          stream))) {
-        CDBG_ERROR("%s : Preview Stream off Error",__func__);
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                                        pme->ch_id,
-                                                        pme->stream[MM_CAMERA_PREVIEW].id))) {
-        CDBG_ERROR("%s : Delete Stream Preview error",__func__);
-    }
-
-    /* stop isp reprocess pipe for preview */
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_repro_isp(pme->cam->camera_handle,
-                                                            pme->ch_id,
-                                                            pme->isp_repro_handle,
-                                                            pme->stream[MM_CAMERA_PREVIEW].id))) {
-        CDBG_ERROR("%s : Stop reprocess for preview error",__func__);
-    }
-
-    /* decrease actual reprocess dest num */
-    pme->repro_dest_num--;
-
-    /* detach preview stream from isp reprocess pipe */
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->detach_stream_from_repro_isp(
-                                                            pme->cam->camera_handle,
-                                                            pme->ch_id,
-                                                            pme->isp_repro_handle,
-                                                            pme->stream[MM_CAMERA_PREVIEW].id))) {
-        CDBG_ERROR("%s : Detach preview from reprocess error",__func__);
-    }
-
-    /* stop isp pix output1 stream */
-    stream[0] = pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,
-                                                          pme->ch_id,
-                                                          1,
-                                                          stream))) {
-        CDBG_ERROR("%s : ISP pix Stream off Error",__func__);
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                                        pme->ch_id,
-                                                        pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id))) {
-        CDBG_ERROR("%s : Delete Stream isp pix error",__func__);
-    }
-
-end:
-    CDBG("%s: X rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int startRecordPP(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[1];
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: E",__func__);
-
-    /* attach video stream to isp reprocess pipe */
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->attach_stream_to_repro_isp(
-                                                            pme->cam->camera_handle,
-                                                            pme->ch_id,
-                                                            pme->isp_repro_handle,
-                                                            pme->stream[MM_CAMERA_VIDEO].id))) {
-        CDBG_ERROR("%s : Attach video to reprocess error",__func__);
-        goto end;
-    }
-
-    /* start isp reprocess pipe for video */
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_repro_isp(pme->cam->camera_handle,
-                                                            pme->ch_id,
-                                                            pme->isp_repro_handle,
-                                                            pme->stream[MM_CAMERA_VIDEO].id))) {
-        CDBG_ERROR("%s : Start reprocess for video error",__func__);
-        pme->cam->ops->detach_stream_from_repro_isp(
-                                                pme->cam->camera_handle,
-                                                pme->ch_id,
-                                                pme->isp_repro_handle,
-                                                pme->stream[MM_CAMERA_VIDEO].id);
-        goto end;
-    }
-
-    /* increase actual reprocess dest num */
-    pme->repro_dest_num++;
-
-    /* start preview stream */
-    pme->stream[MM_CAMERA_VIDEO].str_config.fmt.meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    pme->stream[MM_CAMERA_VIDEO].str_config.fmt.fmt = pme->dim.enc_format;
-    pme->stream[MM_CAMERA_VIDEO].str_config.fmt.width = pme->dim.video_width;
-    pme->stream[MM_CAMERA_VIDEO].str_config.fmt.height = pme->dim.video_height;
-    pme->stream[MM_CAMERA_VIDEO].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_VIDEO].str_config.num_of_bufs = VIDEO_BUF_NUM;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,
-                                                           pme->ch_id,
-                                                           pme->stream[MM_CAMERA_VIDEO].id,
-                                                           &pme->stream[MM_CAMERA_VIDEO].str_config))) {
-        CDBG_ERROR("%s:config video err=%d\n", __func__, rc);
-        pme->cam->ops->stop_repro_isp(
-                                    pme->cam->camera_handle,
-                                    pme->ch_id,
-                                    pme->isp_repro_handle,
-                                    pme->stream[MM_CAMERA_VIDEO].id);
-        pme->cam->ops->detach_stream_from_repro_isp(
-                                                pme->cam->camera_handle,
-                                                pme->ch_id,
-                                                pme->isp_repro_handle,
-                                                pme->stream[MM_CAMERA_VIDEO].id);
-        pme->repro_dest_num--;
-        goto end;
-    }
-    stream[0] = pme->stream[MM_CAMERA_VIDEO].id;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,
-                                                          pme->ch_id,
-                                                          1,
-                                                          stream))) {
-        CDBG_ERROR("%s : Preview Stream on Error",__func__);
-        pme->cam->ops->stop_repro_isp(
-                                    pme->cam->camera_handle,
-                                    pme->ch_id,
-                                    pme->isp_repro_handle,
-                                    pme->stream[MM_CAMERA_VIDEO].id);
-        pme->cam->ops->detach_stream_from_repro_isp(
-                                                pme->cam->camera_handle,
-                                                pme->ch_id,
-                                                pme->isp_repro_handle,
-                                                pme->stream[MM_CAMERA_VIDEO].id);
-        pme->repro_dest_num--;
-        goto end;
-    }
-
-end:
-    CDBG("%s: X rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int stopRecordPP(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[1];
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: E",__func__);
-
-    /* stop video stream */
-    stream[0] = pme->stream[MM_CAMERA_VIDEO].id;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,
-                                                          pme->ch_id,
-                                                          1,
-                                                          stream))) {
-        CDBG_ERROR("%s : Video Stream off Error",__func__);
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                                        pme->ch_id,
-                                                        pme->stream[MM_CAMERA_VIDEO].id))) {
-        CDBG_ERROR("%s : Delete Stream Preview error",__func__);
-    }
-
-    /* stop isp reprocess pipe for video */
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_repro_isp(pme->cam->camera_handle,
-                                                            pme->ch_id,
-                                                            pme->isp_repro_handle,
-                                                            pme->stream[MM_CAMERA_VIDEO].id))) {
-        CDBG_ERROR("%s : Stop reprocess for video error",__func__);
-    }
-
-    /* decrease actual reprocess dest num */
-    pme->repro_dest_num--;
-
-    /* detach preview stream from isp reprocess pipe */
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->detach_stream_from_repro_isp(
-                                                            pme->cam->camera_handle,
-                                                            pme->ch_id,
-                                                            pme->isp_repro_handle,
-                                                            pme->stream[MM_CAMERA_VIDEO].id))) {
-        CDBG_ERROR("%s : Detach video from reprocess error",__func__);
-    }
-
-    CDBG("%s: X rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int32_t mm_qcamera_queue_init(mm_qcamera_queue_t* queue)
-{
-    pthread_mutex_init(&queue->lock, NULL);
-    cam_list_init(&queue->head.list);
-    queue->size = 0;
-    return 0;
-}
-
-int32_t mm_qcamera_queue_enq(mm_qcamera_queue_t* queue, void* data)
-{
-    mm_qcamera_q_node_t* node =
-        (mm_qcamera_q_node_t *)malloc(sizeof(mm_qcamera_q_node_t));
-    if (NULL == node) {
-        CDBG_ERROR("%s: No memory for mm_camera_q_node_t", __func__);
-        return -1;
-    }
-
-    memset(node, 0, sizeof(mm_qcamera_q_node_t));
-    node->data = data;
-
-    pthread_mutex_lock(&queue->lock);
-    cam_list_add_tail_node(&node->list, &queue->head.list);
-    queue->size++;
-    pthread_mutex_unlock(&queue->lock);
-
-    return 0;
-
-}
-
-void* mm_qcamera_queue_deq(mm_qcamera_queue_t* queue)
-{
-    mm_qcamera_q_node_t* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-    if (pos != head) {
-        node = member_of(pos, mm_qcamera_q_node_t, list);
-        cam_list_del_node(&node->list);
-        queue->size--;
-    }
-    pthread_mutex_unlock(&queue->lock);
-
-    if (NULL != node) {
-        data = node->data;
-        free(node);
-    }
-
-    return data;
-}
-
-void* mm_qcamera_queue_peek(mm_qcamera_queue_t* queue)
-{
-    mm_qcamera_q_node_t* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-    if (pos != head) {
-        node = member_of(pos, mm_qcamera_q_node_t, list);
-    }
-    pthread_mutex_unlock(&queue->lock);
-
-    if (NULL != node) {
-        data = node->data;
-    }
-
-    return data;
-}
-
-int32_t mm_qcamera_queue_deinit(mm_qcamera_queue_t* queue)
-{
-    mm_qcamera_queue_flush(queue);
-    pthread_mutex_destroy(&queue->lock);
-    return 0;
-}
-
-int32_t mm_qcamera_queue_flush(mm_qcamera_queue_t* queue)
-{
-    mm_qcamera_q_node_t* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-
-    while(pos != head) {
-        node = member_of(pos, mm_qcamera_q_node_t, list);
-        pos = pos->next;
-        cam_list_del_node(&node->list);
-        queue->size--;
-
-        /* TODO later to consider ptr inside data */
-        /* for now we only assume there is no ptr inside data
-         * so we free data directly */
-        if (NULL != node->data) {
-            free(node->data);
-        }
-        free(node);
-
-    }
-    queue->size = 0;
-    pthread_mutex_unlock(&queue->lock);
-    return 0;
-}
-
-/* re-processing test case for preview only */
-int mm_app_tc_reprocess_preview_only(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j,k;
-    int result = 0;
-
-    printf("\n Verifying reprocess for preview on front and back camera...\n");
-    if (cam_apps->num_cameras == 0) {
-        CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
-        rc = -1;
-        goto end;
-    }
-    CDBG_ERROR("Re-processing test case for preview");
-    for (i = 1; i < cam_apps->num_cameras; i++) {
-        CDBG_ERROR("Open camera %d", i);
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        CDBG_ERROR("Prepare re-process");
-        if ( MM_CAMERA_OK != (rc = prepareReprocess(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: prepareReprocess() err=%d\n", __func__, rc);
-            break;
-        }
-        result = 0;
-        for (k = 0; k < MM_QCAMERA_APP_INTERATION; k++) {
-          CDBG_ERROR("Start preview with pp");
-          if ( MM_CAMERA_OK != (rc = startPreviewPP(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: startPreviewPP() err=%d\n", __func__, rc);
-            break;
-          }
-
-          CDBG_ERROR("Let preview run for 1s");
-          /* sleep for 1s */
-          usleep(1000*1000);
-
-          CDBG_ERROR("Stop preview with pp");
-          if ( MM_CAMERA_OK != (rc = stopPreviewPP(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: stopPreviewPP() err=%d\n", __func__, rc);
-            break;
-          }
-          result++;
-          usleep(10*1000);
-        }
-
-        CDBG_ERROR("Unprepare re-process");
-        if ( MM_CAMERA_OK != (rc = unprepareReprocess(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: unprepareReprocess() err=%d\n", __func__, rc);
-        }
-
-        CDBG_ERROR("Close camera");
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: preview re-reprocess Fails for Camera %d", __func__, i);
-            rc = -1;
-            break;
-        }
-    }
-end:
-    if (rc == 0) {
-        printf("\nPassed\n");
-    } else {
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-/* re-processing test case for preview and recording */
-int mm_app_tc_reprocess_preview_and_recording(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j,k;
-    int result = 0;
-
-    printf("\n Verifying reprocess for preview/recording on front and back camera...\n");
-    if (cam_apps->num_cameras == 0) {
-        CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
-        rc = -1;
-        goto end;
-    }
-    CDBG_ERROR("Re-processing test case for preview");
-    for (i = 1; i < cam_apps->num_cameras; i++) {
-        CDBG_ERROR("Open camera %d", i);
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        CDBG_ERROR("Prepare re-process");
-        if ( MM_CAMERA_OK != (rc = prepareReprocess(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: prepareReprocess() err=%d\n", __func__, rc);
-            break;
-        }
-        result = 0;
-        for (k = 0; k < MM_QCAMERA_APP_INTERATION; k++) {
-          CDBG_ERROR("Start preview with pp");
-          if ( MM_CAMERA_OK != (rc = startPreviewPP(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: startPreviewPP() err=%d\n", __func__, rc);
-            break;
-          }
-
-          CDBG_ERROR("Let preview run for 1s");
-          /* sleep for 1s */
-          usleep(1000*1000);
-
-          for (j = 0; j < 2; j++) {
-              CDBG_ERROR("Start recording with pp");
-              if ( MM_CAMERA_OK != (rc = startRecordPP(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: startRecordPP() err=%d\n", __func__, rc);
-                break;
-              }
-
-              CDBG_ERROR("Let recording run for 1s");
-              /* sleep for 1s */
-              usleep(1000*1000);
-
-              CDBG_ERROR("Stop recording with pp");
-              if ( MM_CAMERA_OK != (rc = stopRecordPP(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: stopRecordPP() err=%d\n", __func__, rc);
-                break;
-              }
-          }
-
-          CDBG_ERROR("Stop preview with pp");
-          if ( MM_CAMERA_OK != (rc = stopPreviewPP(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: stopPreviewPP() err=%d\n", __func__, rc);
-            break;
-          }
-          result++;
-          usleep(10*1000);
-        }
-
-        CDBG_ERROR("Unprepare re-process");
-        if ( MM_CAMERA_OK != (rc = unprepareReprocess(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: unprepareReprocess() err=%d\n", __func__, rc);
-        }
-
-        CDBG_ERROR("Close camera");
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: preview+recording re-reprocess Fails for Camera %d", __func__, i);
-            rc = -1;
-            break;
-        }
-    }
-end:
-    if (rc == 0) {
-        printf("\nPassed\n");
-    } else {
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_preview.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_preview.c
deleted file mode 100755
index 045fa2b..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_preview.c
+++ /dev/null
@@ -1,1584 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <linux/msm_ion.h>
-#include "mm_qcamera_app.h"
-
-int mm_app_start_preview(int cam_id);
-int mm_app_start_preview_zsl(int cam_id);
-int mm_app_stop_preview_zsl(int cam_id);
-int mm_app_stop_preview_stats(int cam_id);
-int mm_app_start_preview_stats(int cam_id);
-
-extern int mm_stream_alloc_bufs(mm_camera_app_obj_t *pme,
-                                mm_camear_app_buf_t* app_bufs,
-                                mm_camera_frame_len_offset *frame_offset_info,
-                                uint8_t num_bufs);
-extern int mm_stream_release_bufs(mm_camera_app_obj_t *pme,
-                                  mm_camear_app_buf_t* app_bufs);
-extern int mm_app_unprepare_video(int cam_id);
-extern int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,
-                                   mm_camera_buf_def_t *frame);
-
-/*===========================================================================
- * FUNCTION    - mm_camera_do_mmap_ion -
- *
- * DESCRIPTION:
- *==========================================================================*/
-uint8_t *mm_camera_do_mmap_ion(int ion_fd, struct ion_allocation_data *alloc,
-                               struct ion_fd_data *ion_info_fd, int *mapFd)
-{
-    void *ret; /* returned virtual address */
-    int rc = 0;
-    struct ion_handle_data handle_data;
-
-    /* to make it page size aligned */
-    alloc->len = (alloc->len + 4095) & (~4095);
-
-    rc = ioctl(ion_fd, ION_IOC_ALLOC, alloc);
-    if (rc < 0) {
-        CDBG_ERROR("ION allocation failed %s\n", strerror(errno));
-        goto ION_ALLOC_FAILED;
-    }
-
-    ion_info_fd->handle = alloc->handle;
-    rc = ioctl(ion_fd, ION_IOC_SHARE, ion_info_fd);
-    if (rc < 0) {
-        CDBG_ERROR("ION map failed %s\n", strerror(errno));
-        goto ION_MAP_FAILED;
-    }
-    *mapFd = ion_info_fd->fd;
-    ret = mmap(NULL,
-               alloc->len,
-               PROT_READ  | PROT_WRITE,
-               MAP_SHARED,
-               *mapFd,
-               0);
-
-    if (ret == MAP_FAILED) {
-        CDBG_ERROR("ION_MMAP_FAILED: %s (%d)\n", strerror(errno), errno);
-        goto ION_MAP_FAILED;
-    }
-
-    return ret;
-
-    ION_MAP_FAILED:
-    handle_data.handle = ion_info_fd->handle;
-    ioctl(ion_fd, ION_IOC_FREE, &handle_data);
-    ION_ALLOC_FAILED:
-    return NULL;
-}
-
-/*===========================================================================
- * FUNCTION    - mm_camera_do_munmap_ion -
- *
- * DESCRIPTION:
- *==========================================================================*/
-int mm_camera_do_munmap_ion (int ion_fd, struct ion_fd_data *ion_info_fd,
-                             void *addr, size_t size)
-{
-    int rc = 0;
-    rc = munmap(addr, size);
-    close(ion_info_fd->fd);
-
-    struct ion_handle_data handle_data;
-    handle_data.handle = ion_info_fd->handle;
-    ioctl(ion_fd, ION_IOC_FREE, &handle_data);
-    return rc;
-}
-
-
-int mm_app_set_preview_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = pme->dim.prev_format;
-    fmt->width = pme->dim.display_width;
-    fmt->height = pme->dim.display_height;
-    return rc;
-}
-
-int mm_app_set_aec_stats_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = CAMERA_SAEC;
-    fmt->width = 1060; //hard code for testing
-    fmt->height = 1;
-    return rc;
-}
-
-int mm_app_set_awb_stats_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = CAMERA_SAWB;
-    fmt->width = 1060; //hard code for testing
-    fmt->height = 1;
-    return rc;
-}
-
-int mm_app_set_af_stats_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = CAMERA_SAFC;
-    fmt->width = 1060; //hard code for testing
-    fmt->height = 1;
-    return rc;
-}
-
-
-int mm_app_set_ihist_stats_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = CAMERA_SHST;
-    fmt->width = 1060; //hard code for testing
-    fmt->height = 1;
-    return rc;
-}
-
-//void dumpFrameToFile(struct msm_frame* newFrame, int w, int h, char* name, int main_422)
-void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h, char* name, int main_422,char *ext)
-{
-    char buf[50];
-    int file_fd;
-    int i;
-    if ( newFrame != NULL) {
-        char * str;
-        snprintf(buf, sizeof(buf), "/data/%s.%s", name, ext);
-        file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-        if (file_fd < 0) {
-            CDBG_ERROR("%s: cannot open file %s \n", __func__, buf);
-        } else {
-            void* y_off = newFrame->buffer + newFrame->planes[0].data_offset;
-            void* cbcr_off = newFrame->buffer + newFrame->planes[0].length;
-
-            CDBG("%s: %s Y_off = %p cbcr_off = %p", __func__, name, y_off,cbcr_off);
-            CDBG("%s: Y_off length = %d cbcr_off length = %d", __func__, newFrame->planes[0].length,newFrame->planes[1].length);
-
-            write(file_fd, (const void *)(y_off), (w * h));
-            if (newFrame->num_planes > 1)
-                write(file_fd, (const void *)(cbcr_off), (w * h/2 * main_422));
-
-            close(file_fd);
-            CDBG("dump %s", buf);
-        }
-    }
-}
-
-int mm_app_open_camera(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int value = 0;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (pme->cam_mode == CAMERA_MODE) {
-        return rc;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))) {
-        CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_RECORDING_HINT, &value);
-
-    if (MM_CAMERA_OK != (rc = mm_app_start_preview(cam_id))) {
-        CDBG_ERROR("%s:Start preview err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    pme->cam_mode = CAMERA_MODE;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_open_camera_stats(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int value = 0;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (pme->cam_mode == CAMERA_MODE) {
-        return rc;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_stop_preview_stats(cam_id))) {
-        CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_RECORDING_HINT, &value);
-
-    if (MM_CAMERA_OK != (rc = mm_app_start_preview_stats(cam_id))) {
-        CDBG_ERROR("%s:Start preview err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    pme->cam_mode = CAMERA_MODE;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_open_zsl(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int value = 0;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (pme->cam_mode == ZSL_MODE) {
-        return rc;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))) {
-        CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_RECORDING_HINT, &value);
-
-    if (MM_CAMERA_OK != (rc = mm_app_start_preview_zsl(cam_id))) {
-        CDBG_ERROR("%s:stream on preview err=%d\n", __func__, rc);
-        goto end;
-    }
-    pme->cam_mode = ZSL_MODE;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-#if 0
-int mm_stream_deinit_preview_buf(uint32_t camera_handle,
-                                 uint32_t ch_id, uint32_t stream_id,
-                                 void *user_data, uint8_t num_bufs,
-                                 mm_camera_buf_def_t *bufs)
-{
-    int i, rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-    for (i = 0; i < num_bufs; i++) {
-        rc = my_cam_app.hal_lib.mm_camera_do_munmap_ion (pme->ionfd, &(pme->preview_buf.frame[i].fd_data),
-                                                         (void *)pme->preview_buf.frame[i].buffer, bufs[i].frame_len);
-        if (rc != MM_CAMERA_OK) {
-            CDBG("%s: mm_camera_do_munmap err, pmem_fd = %d, rc = %d",
-                 __func__, bufs[i].fd, rc);
-        }
-    }
-    close(pme->ionfd);
-    return rc;
-}
-
-int mm_stream_init_preview_buf(uint32_t camera_handle,
-                               uint32_t ch_id, uint32_t stream_id,
-                               void *user_data,
-                               mm_camera_frame_len_offset *frame_offset_info,
-                               uint8_t num_bufs,
-                               uint8_t *initial_reg_flag,
-                               mm_camera_buf_def_t *bufs)
-{
-    int i,j,num_planes, frame_len, y_off, cbcr_off;
-    uint32_t planes[VIDEO_MAX_PLANES];
-    uint32_t pmem_addr = 0;
-
-    mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-
-    num_planes = frame_offset_info->num_planes;
-    for ( i = 0; i < num_planes; i++) {
-        planes[i] = frame_offset_info->mp[i].len;
-    }
-
-    frame_len = frame_offset_info->frame_len;
-    y_off = frame_offset_info->mp[0].offset;
-    cbcr_off = frame_offset_info->mp[1].offset;
-
-    CDBG("Allocating Preview Memory for %d buffers frame_len = %d",num_bufs,frame_offset_info->frame_len);
-
-    for (i = 0; i < num_bufs ; i++) {
-        int j;
-        pme->preview_buf.reg[i] = 1;
-        initial_reg_flag[i] = 1;
-
-        pme->preview_buf.frame_len = frame_len;
-        pme->preview_buf.frame[i].ion_alloc.len = pme->preview_buf.frame_len;
-        pme->preview_buf.frame[i].ion_alloc.flags =
-        (0x1 << CAMERA_ION_HEAP_ID | 0x1 << ION_IOMMU_HEAP_ID);
-        pme->preview_buf.frame[i].ion_alloc.align = 4096;
-
-        pmem_addr = (unsigned long) my_cam_app.hal_lib.mm_camera_do_mmap_ion(pme->ionfd,
-                                                                             &(pme->preview_buf.frame[i].ion_alloc), &(pme->preview_buf.frame[i].fd_data),
-                                                                             &pme->preview_buf.frame[i].fd);
-
-        pme->preview_buf.frame[i].buffer = pmem_addr;
-        pme->preview_buf.frame[i].path = OUTPUT_TYPE_P;
-        pme->preview_buf.frame[i].y_off = 0;
-        pme->preview_buf.frame[i].cbcr_off = planes[0];
-        pme->preview_buf.frame[i].phy_offset = 0;
-
-        CDBG("Buffer allocated Successfully fd = %d",pme->preview_buf.frame[i].fd);
-
-        bufs[i].fd = pme->preview_buf.frame[i].fd;
-        //bufs[i].buffer = pmem_addr;
-        bufs[i].frame_len = pme->preview_buf.frame[i].ion_alloc.len;
-        bufs[i].num_planes = num_planes;
-
-        bufs[i].frame = &pme->preview_buf.frame[i];
-
-        /* Plane 0 needs to be set seperately. Set other planes
-             * in a loop. */
-        bufs[i].planes[0].length = planes[0];
-        bufs[i].planes[0].m.userptr = bufs[i].fd;
-        bufs[i].planes[0].data_offset = y_off;
-        bufs[i].planes[0].reserved[0] = 0;
-        //buf_def->buf.mp[i].frame_offset;
-        for (j = 1; j < num_planes; j++) {
-            bufs[i].planes[j].length = planes[j];
-            bufs[i].planes[j].m.userptr = bufs[i].fd;
-            bufs[i].planes[j].data_offset = cbcr_off;
-            bufs[i].planes[j].reserved[0] =
-            bufs[i].planes[j-1].reserved[0] +
-            bufs[i].planes[j-1].length;
-        }
-    }
-    return MM_CAMERA_OK;
-}
-#endif
-
-int mm_stream_initbuf(uint32_t camera_handle,
-                      uint32_t ch_id, uint32_t stream_id,
-                      void *user_data,
-                      mm_camera_frame_len_offset *frame_offset_info,
-                      uint8_t num_bufs,
-                      uint8_t *initial_reg_flag,
-                      mm_camera_buf_def_t *bufs)
-{
-    mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-    mm_camear_app_buf_t* app_bufs = NULL;
-    int i, rc;
-
-    if (MM_CAMERA_MAX_NUM_FRAMES < num_bufs) {
-        CDBG_ERROR("%s: num_bufs (%d) exceeds max (%d)",
-                   __func__, num_bufs, MM_CAMERA_MAX_NUM_FRAMES);
-        return -1;
-    }
-    for (i = 0; i < MM_QCAM_APP_MAX_STREAM_NUM; i++) {
-        if (pme->stream[i].id == stream_id) {
-            app_bufs = &pme->stream [i].app_bufs;
-            break;
-        }
-    }
-
-    if (app_bufs == NULL) {
-        CDBG_ERROR("%s: no matching stream for stream_id %d", __func__, stream_id);
-        return -1;
-    }
-
-    CDBG("%s: alloc buf for stream_id %d, len=%d",
-         __func__, stream_id, frame_offset_info->frame_len);
-    rc = mm_stream_alloc_bufs(pme,
-                              app_bufs,
-                              frame_offset_info,
-                              num_bufs);
-
-    if (rc != 0) {
-        CDBG_ERROR("%s: mm_stream_alloc_bufs err = %d", __func__, rc);
-        return rc;
-    }
-
-    memcpy(bufs, app_bufs->bufs, sizeof(mm_camera_buf_def_t) * num_bufs);
-    for (i = 0; i < num_bufs ; i++) {
-        initial_reg_flag[i] = 1;
-    }
-
-    CDBG("%s: X",__func__);
-    return MM_CAMERA_OK;
-}
-
-#if 0
-int mm_stream_initbuf_1(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data,
-                        mm_camera_frame_len_offset *frame_offset_info,
-                        uint8_t num_bufs,
-                        uint8_t *initial_reg_flag,
-                        mm_camera_buf_def_t *bufs)
-{
-    int i;
-    int streamType = 0;
-
-    mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s : E ", __FUNCTION__);
-
-    for (i= 0; i < 5; i++) {
-        if (pme->stream[i].id == stream_id) {
-            CDBG("Allocate Memory for Stream %d",i);
-            streamType = i;
-            break;
-        }
-    }
-
-    streamType = MM_CAMERA_PREVIEW;
-    switch (streamType) {
-    case MM_CAMERA_PREVIEW:
-        mm_stream_init_preview_buf( camera_handle,
-                                    ch_id, stream_id,
-                                    user_data,
-                                    frame_offset_info,
-                                    num_bufs,
-                                    initial_reg_flag,
-                                    bufs);
-        break;
-    case MM_CAMERA_VIDEO:
-        mm_stream_init_video_buf( camera_handle,
-                                  ch_id, stream_id,
-                                  user_data,
-                                  frame_offset_info,
-                                  num_bufs,
-                                  initial_reg_flag,
-                                  bufs);
-        break;
-    case MM_CAMERA_SNAPSHOT_MAIN:
-        mm_stream_init_main_buf( camera_handle,
-                                 ch_id, stream_id,
-                                 user_data,
-                                 frame_offset_info,
-                                 num_bufs,
-                                 initial_reg_flag,
-                                 bufs);
-        break;
-    case MM_CAMERA_SNAPSHOT_THUMBNAIL:
-        mm_stream_init_thumbnail_buf( camera_handle,
-                                      ch_id, stream_id,
-                                      user_data,
-                                      frame_offset_info,
-                                      num_bufs,
-                                      initial_reg_flag,
-                                      bufs);
-        break;
-    default:
-        break;
-    }
-
-    CDBG(" %s : X ",__FUNCTION__);
-    return MM_CAMERA_OK;
-}
-#endif
-int mm_stream_deinitbuf(uint32_t camera_handle,
-                        uint32_t ch_id, uint32_t stream_id,
-                        void *user_data, uint8_t num_bufs,
-                        mm_camera_buf_def_t *bufs)
-{
-    int i, rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-    mm_camear_app_buf_t* app_bufs = NULL;
-
-    for (i = 0; i < MM_QCAM_APP_MAX_STREAM_NUM; i++) {
-        if (pme->stream[i].id == stream_id) {
-            app_bufs = &pme->stream [i].app_bufs;
-            break;
-        }
-    }
-
-    if (app_bufs == NULL) {
-        CDBG_ERROR("%s: no matching stream for stream_id %d", __func__, stream_id);
-        return -1;
-    }
-
-    rc = mm_stream_release_bufs(pme, app_bufs);
-
-    if (rc != 0) {
-        CDBG_ERROR("%s: mm_stream_release_bufs err = %d", __func__, rc);
-    }
-
-    return rc;
-}
-
-#if 0
-static int mm_stream_deinitbuf_1(uint32_t camera_handle,
-                                 uint32_t ch_id, uint32_t stream_id,
-                                 void *user_data, uint8_t num_bufs,
-                                 mm_camera_buf_def_t *bufs)
-{
-    int i, rc = MM_CAMERA_OK;
-    int streamType = 0;
-    mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-    CDBG("%s: BEGIN",__func__);
-
-    for (i= 0; i < 5; i++) {
-        if (pme->stream[i].id == stream_id) {
-            CDBG("Allocate Memory for Stream %d",i);
-            streamType = i;
-            break;
-        }
-    }
-    streamType = MM_CAMERA_PREVIEW; 
-    switch (streamType) {
-    case MM_CAMERA_PREVIEW:
-        mm_stream_deinit_preview_buf(camera_handle,
-                                     ch_id, stream_id,
-                                     user_data, num_bufs,
-                                     bufs);
-        break;
-    case MM_CAMERA_VIDEO:
-        mm_stream_deinit_video_buf(camera_handle,
-                                   ch_id, stream_id,
-                                   user_data, num_bufs,
-                                   bufs);
-        break;
-    case MM_CAMERA_SNAPSHOT_MAIN:
-        mm_stream_deinit_main_buf(camera_handle,
-                                  ch_id, stream_id,
-                                  user_data, num_bufs,
-                                  bufs);
-        break;
-    case MM_CAMERA_SNAPSHOT_THUMBNAIL:
-        mm_stream_deinit_thumbnail_buf(camera_handle,
-                                       ch_id, stream_id,
-                                       user_data, num_bufs,
-                                       bufs);
-        break;
-    default:
-        break;
-    }
-
-    /* zero out the buf stuct */
-    CDBG("%s: END",__func__);
-    return MM_CAMERA_OK;
-}
-#endif
-
-void preview_cb_signal(mm_camera_app_obj_t *pme)
-{
-    if (pme->cam_state == CAMERA_STATE_PREVIEW && pme->cam_mode == CAMERA_MODE) {
-        mm_camera_app_done();
-    }
-}
-
-void previewzsl_cb_signal(mm_camera_app_obj_t *pme)
-{
-    if (pme->cam_state == CAMERA_STATE_PREVIEW && pme->cam_mode == ZSL_MODE) {
-        mm_camera_app_done();
-    }
-}
-
-
-void mm_app_preview_notify_cb(mm_camera_super_buf_t *bufs,
-                              void *user_data)
-{
-    int rc, cam = 0;
-    char buf[32];
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__); 
-    frame = bufs->bufs[MM_CAMERA_PREVIEW];
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
-    snprintf(buf, sizeof(buf), "P_%dx%d_C%d", pme->dim.display_width,
-        pme->dim.display_height, pme->cam->camera_info->camera_id);
-
-    dumpFrameToFile(frame, pme->dim.display_width,
-        pme->dim.display_height, buf, 1,"yuv");
-
-    if (!my_cam_app.run_sanity) {
-        if (0 != (rc = mm_app_dl_render(frame->fd, NULL))) {
-            CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
-                 __func__, rc, frame->fd, frame->frame_idx);
-        }
-    }
-
-    CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_PREVIEW],frame);
-
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
-        CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
-        return;
-    }
-    mm_stream_invalid_cache(pme,frame);
-    if (my_cam_app.run_sanity) {
-        preview_cb_signal(pme);
-    }
-    CDBG("%s: END\n", __func__); 
-
-}
-
-void mm_app_aec_stats_notify_cb(mm_camera_super_buf_t *bufs,
-                              void *user_data)
-{
-    int rc;
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__);
-    frame = bufs->bufs[0];
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
-    CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
-                 __func__, rc, frame->fd, frame->frame_idx);
-    CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_SAEC],frame);
-
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
-        CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
-        return;
-    }
-    mm_stream_invalid_cache(pme,frame);
-    CDBG("%s: END\n", __func__);
-}
-
-void mm_app_awb_stats_notify_cb(mm_camera_super_buf_t *bufs,
-                              void *user_data)
-{
-    int rc;
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__);
-    frame = bufs->bufs[0];
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
-    CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
-                 __func__, rc, frame->fd, frame->frame_idx);
-    CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_SAWB],frame);
-
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
-        CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
-        return;
-    }
-    mm_stream_invalid_cache(pme,frame);
-    CDBG("%s: END\n", __func__);
-}
-
-void mm_app_af_stats_notify_cb(mm_camera_super_buf_t *bufs,
-                              void *user_data)
-{
-    int rc;
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__);
-    frame = bufs->bufs[0] ;
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
-    CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
-                 __func__, rc, frame->fd, frame->frame_idx);
-    CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_SAFC],frame);
-
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
-        CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
-        return;
-    }
-    mm_stream_invalid_cache(pme,frame);
-    CDBG("%s: END\n", __func__);
-}
-
-void mm_app_ihist_stats_notify_cb(mm_camera_super_buf_t *bufs,
-                              void *user_data)
-{
-    int rc;
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__);
-    frame = bufs->bufs[0] ;
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
-    CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
-                 __func__, rc, frame->fd, frame->frame_idx);
-    CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_IHST],frame);
-
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
-        CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
-        return;
-    }
-    mm_stream_invalid_cache(pme,frame);
-    CDBG("%s: END\n", __func__);
-}
-
-static void mm_app_zsl_notify_cb(mm_camera_super_buf_t *bufs,
-                                 void *user_data)
-{
-    int rc;
-    int i = 0;
-    mm_camera_buf_def_t *preview_frame = NULL;
-    mm_camera_buf_def_t *main_frame = NULL;
-    mm_camera_buf_def_t *thumb_frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__); 
-
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s : total streams = %d",__func__,bufs->num_bufs);
-    preview_frame = bufs->bufs[0] ;
-    main_frame = bufs->bufs[1];
-    thumb_frame = bufs->bufs[0];
-
-    //dumpFrameToFile(preview_frame->frame,pme->dim.display_width,pme->dim.display_height,"preview", 1);
-    dumpFrameToFile(preview_frame,pme->dim.display_width,pme->dim.display_height,"zsl_preview", 1,"yuv");
-    if (0 != (rc = mm_app_dl_render(preview_frame->fd, NULL))) {
-        CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
-             __func__, rc, preview_frame->fd, preview_frame->frame_idx);
-    }
-
-    if (bufs->num_bufs == 2 && main_frame != NULL) {
-        CDBG("mainframe frame_idx = %d fd = %d frame length = %d",main_frame->frame_idx,main_frame->fd,main_frame->frame_len);
-        CDBG("thumnail frame_idx = %d fd = %d frame length = %d",thumb_frame->frame_idx,thumb_frame->fd,thumb_frame->frame_len);
-
-        //dumpFrameToFile(main_frame->frame,pme->dim.picture_width,pme->dim.picture_height,"main", 1);
-        //dumpFrameToFile(thumb_frame->frame,pme->dim.thumbnail_width,pme->dim.thumbnail_height,"thumb", 1);
-
-        dumpFrameToFile(main_frame,pme->dim.picture_width,pme->dim.picture_height,"zsl_main", 1,"yuv");
-        dumpFrameToFile(thumb_frame,pme->dim.thumbnail_width,pme->dim.thumbnail_height,"zsl_thumb", 1,"yuv");
-
-        if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,main_frame)) {
-            CDBG_ERROR("%s: Failed in thumbnail Qbuf\n", __func__); 
-        }
-        mm_stream_invalid_cache(pme,main_frame);
-    }
-
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,preview_frame)) {
-        CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__); 
-    }
-    mm_stream_invalid_cache(pme,preview_frame);
-	if (my_cam_app.run_sanity) {
-        previewzsl_cb_signal(pme);
-    }
-    CDBG("%s: END\n", __func__);
-}
-
-int mm_app_prepare_stats(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int op_mode;
-
-    CDBG("%s: E",__func__);
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    pme->mem_cam->get_buf = mm_stream_initbuf;
-    pme->mem_cam->put_buf = mm_stream_deinitbuf;
-    pme->mem_cam->user_data = pme;
-    // AEC Stream
-    pme->stream[MM_CAMERA_SAEC].id =
-        pme->cam->ops->add_stream(pme->cam->camera_handle, pme->ch_id,
-                                  mm_app_aec_stats_notify_cb, pme,
-                                  MM_CAMERA_SAEC, 0);
-    if (!pme->stream[MM_CAMERA_SAEC].id) {
-        CDBG_ERROR("%s:Add MM_CAMERA_SAEC error =%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    CDBG_ERROR("%s :Add stream is successful stream ID = %d",__func__,pme->stream[MM_CAMERA_SAEC].id);
-
-    mm_app_set_aec_stats_fmt(cam_id,&pme->stream[MM_CAMERA_SAEC].str_config.fmt);
-    pme->stream[MM_CAMERA_SAEC].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_SAEC].str_config.num_of_bufs = STATS_BUF_NUM;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAEC].id,
-                                                           &pme->stream[MM_CAMERA_SAEC].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-    // AWB Stream
-    pme->stream[MM_CAMERA_SAWB].id =
-        pme->cam->ops->add_stream(pme->cam->camera_handle, pme->ch_id,
-                                  mm_app_awb_stats_notify_cb, pme,
-                                  MM_CAMERA_SAWB, 0);
-    if (!pme->stream[MM_CAMERA_SAWB].id) {
-        CDBG_ERROR("%s:Add MM_CAMERA_SAWB error =%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    CDBG_ERROR("%s :Add stream is successful stream ID = %d",__func__,pme->stream[MM_CAMERA_SAWB].id);
-
-    mm_app_set_awb_stats_fmt(cam_id,&pme->stream[MM_CAMERA_SAWB].str_config.fmt);
-    pme->stream[MM_CAMERA_SAWB].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_SAWB].str_config.num_of_bufs = STATS_BUF_NUM;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAWB].id,
-                                                           &pme->stream[MM_CAMERA_SAWB].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    // AF Stream
-    pme->stream[MM_CAMERA_SAFC].id =
-        pme->cam->ops->add_stream(pme->cam->camera_handle, pme->ch_id,
-                                  mm_app_af_stats_notify_cb, pme,
-                                  MM_CAMERA_SAFC, 0);
-    if (!pme->stream[MM_CAMERA_SAFC].id) {
-        CDBG_ERROR("%s:Add MM_CAMERA_SAFC error =%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    CDBG_ERROR("%s :Add stream is successful stream ID = %d",__func__,pme->stream[MM_CAMERA_SAFC].id);
-
-    mm_app_set_af_stats_fmt(cam_id,&pme->stream[MM_CAMERA_SAFC].str_config.fmt);
-    pme->stream[MM_CAMERA_SAFC].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_SAFC].str_config.num_of_bufs = STATS_BUF_NUM;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAFC].id,
-                                                           &pme->stream[MM_CAMERA_SAFC].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    // HIST Stream
-    pme->stream[MM_CAMERA_IHST].id =
-        pme->cam->ops->add_stream(pme->cam->camera_handle, pme->ch_id,
-                                  mm_app_ihist_stats_notify_cb, pme,
-                                  MM_CAMERA_IHST, 0);
-    if (!pme->stream[MM_CAMERA_IHST].id) {
-        CDBG_ERROR("%s:Add MM_CAMERA_IHST error =%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    CDBG_ERROR("%s :Add stream is successful stream ID = %d",__func__,pme->stream[MM_CAMERA_IHST].id);
-
-    mm_app_set_ihist_stats_fmt(cam_id,&pme->stream[MM_CAMERA_IHST].str_config.fmt);
-    pme->stream[MM_CAMERA_IHST].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_IHST].str_config.num_of_bufs = STATS_BUF_NUM;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_IHST].id,
-                                                           &pme->stream[MM_CAMERA_IHST].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    end:
-    return rc;
-}
-
-int mm_app_prepare_preview(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int op_mode;
-
-    CDBG("%s: E",__func__);
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    pme->mem_cam->get_buf = mm_stream_initbuf;
-    pme->mem_cam->put_buf = mm_stream_deinitbuf;
-    pme->mem_cam->user_data = pme;
-
-    op_mode = MM_CAMERA_OP_MODE_VIDEO;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
-                                                     pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode))) {
-        CDBG_ERROR("%s: Set preview op mode error",__func__);
-        goto end;
-    }
-
-    pme->stream[MM_CAMERA_PREVIEW].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
-                                                                  mm_app_preview_notify_cb,pme,
-                                                                  MM_CAMERA_PREVIEW, 0);
-
-    if (!pme->stream[MM_CAMERA_PREVIEW].id) {
-        CDBG_ERROR("%s:Add stream preview error =%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    CDBG("%s :Add stream is successfull stream ID = %d",__func__,pme->stream[MM_CAMERA_PREVIEW].id);
-
-    mm_app_set_preview_fmt(cam_id,&pme->stream[MM_CAMERA_PREVIEW].str_config.fmt);
-    pme->stream[MM_CAMERA_PREVIEW].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_PREVIEW].str_config.num_of_bufs = PREVIEW_BUF_NUM;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id,
-                                                           &pme->stream[MM_CAMERA_PREVIEW].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-    end:
-    return rc;
-}
-
-int mm_app_unprepare_preview(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    return rc;
-}
-
-int mm_app_streamon_stats(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream_aec[2], stream_af[2], stream_awb[2], stream_ihist[2];
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    mm_camera_frame_len_offset frame_offset_info;
-
-    stream_aec[0] = pme->stream[MM_CAMERA_SAEC].id;
-    stream_aec[1] = 0;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,stream_aec))) {
-        CDBG_ERROR("%s : Start Stats Stream Error",__func__);
-        goto end;
-    }
-    stream_awb[0] = pme->stream[MM_CAMERA_SAWB].id;
-    stream_awb[1] = 0;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,stream_awb))) {
-        CDBG_ERROR("%s : Start Stats Stream Error",__func__);
-        goto end;
-    }
-
-    stream_af[0] = pme->stream[MM_CAMERA_SAFC].id;
-    stream_af[1] = 0;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,stream_af))) {
-        CDBG_ERROR("%s : Start Stats Stream Error",__func__);
-        goto end;
-    }
-
-    stream_ihist[0] = pme->stream[MM_CAMERA_IHST].id;
-    stream_ihist[1] = 0;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,stream_ihist))) {
-        CDBG_ERROR("%s : Start Stats Stream Error",__func__);
-        goto end;
-    }
-
-    end:
-    CDBG("%s: X rc = %d",__func__,rc);
-    return rc;
-}
-
-
-int mm_app_streamon_preview(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    mm_camera_frame_len_offset frame_offset_info;
-
-    stream = pme->stream[MM_CAMERA_PREVIEW].id;
-
-    pme->cam->ops->get_stream_parm(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id,MM_CAMERA_STREAM_OFFSET,&frame_offset_info);
-    ALOGE("DEBUG : length = %d",frame_offset_info.frame_len);
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,&stream))) {
-        CDBG_ERROR("%s : Start Stream preview Error",__func__);
-        goto end;
-    }
-    pme->cam_state = CAMERA_STATE_PREVIEW;
-    end:
-    CDBG("%s: X rc = %d",__func__,rc);
-    return rc;
-}
-
-int mm_app_prepare_preview_zsl(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_bundle_attr_t attr;
-    int stream[3];
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    int op_mode = 0;
-
-    op_mode = MM_CAMERA_OP_MODE_ZSL;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
-                                                     pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode))) {
-        CDBG_ERROR("%s: Set preview op mode error",__func__);
-        goto end;
-    }
-
-    pme->stream[MM_CAMERA_PREVIEW].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
-                                                                  mm_app_preview_notify_cb,pme,
-                                                                  MM_CAMERA_PREVIEW, 0);
-
-    if (!pme->stream[MM_CAMERA_PREVIEW].id) {
-        CDBG_ERROR("%s:Add stream preview error =%d\n", __func__, rc);
-        goto end;
-    }
-
-    CDBG("%s :Add stream is successfull stream ID = %d",__func__,pme->stream[MM_CAMERA_PREVIEW].id);
-
-    mm_app_set_preview_fmt(cam_id,&pme->stream[MM_CAMERA_PREVIEW].str_config.fmt);
-    pme->stream[MM_CAMERA_PREVIEW].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_PREVIEW].str_config.num_of_bufs = PREVIEW_BUF_NUM;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id,
-                                                           &pme->stream[MM_CAMERA_PREVIEW].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
-                                                                        NULL,pme,
-                                                                        MM_CAMERA_SNAPSHOT_MAIN, 0);
-
-    CDBG("Add Snapshot main is successfull stream ID = %d",pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id);
-    if (!pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.num_of_bufs = 7;
-
-    mm_app_set_snapshot_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.fmt);
-
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
-                                                           &pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc); 
-    return rc;
-}
-
-int mm_app_streamon_preview_zsl(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_bundle_attr_t attr;
-    uint32_t stream[2];
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    int op_mode = 0;
-
-    stream[0] = pme->stream[MM_CAMERA_PREVIEW].id;
-    stream[1] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-
-    attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
-    attr.burst_num = 1;
-    attr.look_back = 2;
-    attr.post_frame_skip = 0;
-    attr.water_mark = 2;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->init_stream_bundle(
-                                                               pme->cam->camera_handle,pme->ch_id,mm_app_zsl_notify_cb,pme,&attr,2,stream))) {
-        CDBG_ERROR("%s:init_stream_bundle err=%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,
-                                                           2, stream))) {
-        CDBG_ERROR("%s:start_streams err=%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-    pme->cam_state = CAMERA_STATE_PREVIEW;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc); 
-    return rc;
-
-}
-
-int initDisplay()
-{
-    int rc = MM_CAMERA_OK;
-
-    use_overlay_fb_display_driver();
-    if (launch_camframe_fb_thread()) {
-        CDBG_ERROR("%s:launch_camframe_fb_thread failed!\n", __func__);
-        //rc = -MM_CAMERA_E_GENERAL;
-    }
-    CDBG("%s: launch_camframe_fb_thread done\n", __func__);
-    return rc;
-}
-
-int deinitDisplay()
-{
-    /* stop the display thread */
-    release_camframe_fb_thread();
-    return MM_CAMERA_OK;
-}
-
-int mm_app_start_preview(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    int op_mode = 0;
-
-    CDBG("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
-         pme,pme->cam,pme->cam->camera_handle);
-
-    if (pme->cam_state == CAMERA_STATE_PREVIEW) {
-        return rc;
-    }
-
-    if (!my_cam_app.run_sanity) {
-        if (MM_CAMERA_OK != initDisplay()) {
-            CDBG_ERROR("%s : Could not initalize display",__func__);
-            goto end;
-        }
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_prepare_preview(cam_id))) {
-        CDBG_ERROR("%s:Stream On Preview failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamon_preview(cam_id))) {
-        CDBG_ERROR("%s:Stream On Preview failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc); 
-    return rc;
-}
-
-int mm_app_start_preview_stats(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    int op_mode = 0;
-
-    CDBG("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
-         pme,pme->cam,pme->cam->camera_handle);
-
-    if (pme->cam_state == CAMERA_STATE_PREVIEW) {
-        return rc;
-    }
-
-    if (!my_cam_app.run_sanity) {
-        if (MM_CAMERA_OK != initDisplay()) {
-            CDBG_ERROR("%s : Could not initalize display",__func__);
-            goto end;
-        }
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_prepare_stats(cam_id))) {
-        CDBG_ERROR("%s:Prepare On Stats failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_prepare_preview(cam_id))) {
-        CDBG_ERROR("%s:Stream On Preview failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamon_stats(cam_id))) {
-        CDBG_ERROR("%s:Stream On Stats failed rc=%d\n", __func__, rc);
-        goto end;
-	}
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamon_preview(cam_id))) {
-        CDBG_ERROR("%s:Stream On Preview failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc); 
-    return rc;
-}
-
-
-int mm_app_start_preview_zsl(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
-         pme,pme->cam,pme->cam->camera_handle);
-
-    if (!my_cam_app.run_sanity) {
-        if (MM_CAMERA_OK != initDisplay()) {
-            CDBG_ERROR("%s : Could not initalize display",__func__);
-            goto end;
-        }
-    }
-
-    pme->mem_cam->get_buf = mm_stream_initbuf;
-    pme->mem_cam->put_buf = mm_stream_deinitbuf;
-    pme->mem_cam->user_data = pme;
-
-    if (MM_CAMERA_OK != (rc = mm_app_prepare_preview_zsl(cam_id))) {
-        CDBG_ERROR("%s:Prepare preview err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamon_preview_zsl(cam_id))) {
-        CDBG_ERROR("%s:stream on preview err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    /*if(MM_CAMERA_OK != (rc = mm_app_bundle_zsl_stream(cam_id))){
-        CDBG_ERROR("%s: bundle and start of ZSl err=%d\n", __func__, rc);
-        goto end;
-    }*/
-
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc); 
-    return rc;
-}
-
-static int mm_app_streamoff_stats(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream_aec[2], stream_af[2],stream_awb[2], stream_ihist[2];
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream_aec[0] = pme->stream[MM_CAMERA_SAEC].id;
-    stream_aec[1] = 0;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream_aec))) {
-        CDBG_ERROR("%s : Stats Stream off Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAEC].id))) {
-        CDBG_ERROR("%s : Delete Stats Stream error",__func__);
-        goto end;
-    }
-    CDBG("AEC: del_stream successfull");
-    stream_awb[0] = pme->stream[MM_CAMERA_SAWB].id;
-    stream_awb[1] = 0;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream_awb))) {
-        CDBG_ERROR("%s : Stats Stream off Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAWB].id))) {
-        CDBG_ERROR("%s : Delete Stats Stream error",__func__);
-        goto end;
-    }
-    CDBG("AWB: del_stream successfull");
-
-    stream_af[0] = pme->stream[MM_CAMERA_SAFC].id;
-    stream_af[1] = 0;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1, stream_af))) {
-        CDBG_ERROR("%s : Stats Stream off Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAFC].id))) {
-        CDBG_ERROR("%s : Delete Stats Stream error",__func__);
-        goto end;
-    }
-    CDBG("AF: del_stream successfull");
-
-
-    stream_ihist[0] = pme->stream[MM_CAMERA_IHST].id;
-    stream_ihist[1] = 0;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream_ihist))) {
-        CDBG_ERROR("%s : Stats Stream off Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_IHST].id))) {
-        CDBG_ERROR("%s : Delete Stats Stream error",__func__);
-        goto end;
-    }
-    CDBG("IHIST: del_stream successfull");
-
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-
-    return rc;
-}
-
-static int mm_app_streamoff_preview(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream = pme->stream[MM_CAMERA_PREVIEW].id;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,&stream))) {
-        CDBG_ERROR("%s : Preview Stream off Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id))) {
-        CDBG_ERROR("%s : Delete Stream Preview error",__func__);
-        goto end;
-    }
-    CDBG("del_stream successfull");
-    pme->cam_state = CAMERA_STATE_OPEN;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-
-    return rc;
-}
-
-static int mm_app_streamoff_preview_zsl(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[2];
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream[0] = pme->stream[MM_CAMERA_PREVIEW].id;
-    stream[1] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,2,stream))) {
-        CDBG_ERROR("%s : Preview Stream off Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->destroy_stream_bundle(pme->cam->camera_handle,pme->ch_id))) {
-        CDBG_ERROR("%s : ZSL Snapshot destroy_stream_bundle Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id))) {
-        CDBG_ERROR("%s : Delete Stream Preview error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id))) {
-        CDBG_ERROR("%s : Delete Stream Preview error",__func__);
-        goto end;
-    }
-    CDBG("del_stream successfull");
-    pme->cam_state = CAMERA_STATE_OPEN;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-
-    return rc;
-}
-
-int startPreview(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: Start Preview",__func__);
-
-    if (pme->cam_mode == ZSL_MODE || pme->cam_mode == RECORDER_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_RECORD:
-            if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
-                CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
-                return -1;
-            }
-        case CAMERA_STATE_PREVIEW:
-            if (MM_CAMERA_OK != mm_app_open_camera(cam_id)) {
-                CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
-                return -1;
-            }
-            break;
-        case CAMERA_STATE_SNAPSHOT:
-        default:
-            break;
-        }
-    } else if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_OPEN) {
-
-        if (MM_CAMERA_OK != (rc = mm_app_start_preview(cam_id))) {
-            CDBG_ERROR("%s:preview streaming on err=%d\n", __func__, rc);
-            return -1;
-        }
-    }
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int stopPreview(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s : pme->cam_mode = %d, pme->cam_state = %d",__func__,pme->cam_mode,pme->cam_state);
-
-    if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        if (MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))) {
-            CDBG("%s:streamoff preview err=%d\n", __func__, rc);
-            goto end;
-        }
-    } else if (pme->cam_mode == ZSL_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        if (MM_CAMERA_OK != (rc = mm_app_stop_preview_zsl(cam_id))) {
-            CDBG("%s:streamoff preview err=%d\n", __func__, rc);
-            goto end;
-        }
-    } else if (pme->cam_mode == RECORDER_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        if (MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))) {
-            CDBG("%s:streamoff preview err=%d\n", __func__, rc);
-            goto end;
-        }
-        mm_app_unprepare_video(cam_id);
-    }
-    end:
-    return rc;
-}
-
-int startStats(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: Start Preview",__func__);
-
-    if (pme->cam_mode == ZSL_MODE || pme->cam_mode == RECORDER_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_RECORD:
-            if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
-                CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
-                return -1;
-            }
-        case CAMERA_STATE_PREVIEW:
-            if (MM_CAMERA_OK != mm_app_open_camera_stats(cam_id)) {
-                CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
-                return -1;
-            }
-            break;
-        case CAMERA_STATE_SNAPSHOT:
-        default:
-            break;
-        }
-    } else if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_OPEN) {
-
-        if (MM_CAMERA_OK != (rc = mm_app_start_preview_stats(cam_id))) {
-            CDBG_ERROR("%s:preview streaming on err=%d\n", __func__, rc);
-            return -1;
-        }
-    }
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int stopStats(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s : pme->cam_mode = %d, pme->cam_state = %d",__func__,pme->cam_mode,pme->cam_state);
-
-    if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        if (MM_CAMERA_OK != (rc = mm_app_stop_preview_stats(cam_id))) {
-            CDBG("%s:streamoff preview err=%d\n", __func__, rc);
-            goto end;
-        }
-    } else if (pme->cam_mode == ZSL_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        if (MM_CAMERA_OK != (rc = mm_app_stop_preview_zsl(cam_id))) {
-            CDBG("%s:streamoff preview err=%d\n", __func__, rc);
-            goto end;
-        }
-    } else if (pme->cam_mode == RECORDER_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        if (MM_CAMERA_OK != (rc = mm_app_stop_preview_stats(cam_id))) {
-            CDBG("%s:streamoff preview err=%d\n", __func__, rc);
-            goto end;
-        }
-        mm_app_unprepare_video(cam_id);
-    }
-    end:
-    return rc;
-}
-
-int mm_app_stop_preview(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamoff_preview(cam_id))) {
-        CDBG_ERROR("%s : Delete Stream Preview error",__func__);
-        goto end;
-    }
-    CDBG("Stop Preview successfull");
-
-    if (!my_cam_app.run_sanity) {
-        deinitDisplay();
-    }
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_stop_preview_stats(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamoff_stats(cam_id))) {
-        CDBG_ERROR("%s : Delete Stream Stats error",__func__);
-        goto end;
-    }
-    if (MM_CAMERA_OK != (rc = mm_app_streamoff_preview(cam_id))) {
-        CDBG_ERROR("%s : Delete Stream Preview error",__func__);
-        goto end;
-    }
-    CDBG("Stop Preview successfull");
-
-    if (!my_cam_app.run_sanity) {
-        deinitDisplay();
-    }
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_stop_preview_zsl(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamoff_preview_zsl(cam_id))) {
-        CDBG_ERROR("%s : Delete Stream Preview error",__func__);
-        goto end;
-    }
-
-    CDBG("Stop Preview successfull");
-    if (!my_cam_app.run_sanity) {
-        deinitDisplay();
-    }
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_rdi.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_rdi.c
deleted file mode 100755
index 6cfa9c6..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_rdi.c
+++ /dev/null
@@ -1,427 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <linux/msm_ion.h>
-#include "mm_qcamera_app.h"
-
-/*typedef enum {
-  STREAM_IMAGE,
-  STREAM_RAW,
-  STREAM_IMAGE_AND_RAW,
-  STREAM_RAW_AND_RAW,
-  STREAM_MAX,
-} mm_camera_channel_stream_info_t;*/
-
-#define RDI_MASK STREAM_RAW
-mm_camera_channel_stream_info_t rdi_mode;
-static int rdi_op_mode;
-extern int stopPreview(int cam_id);
-extern void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h,
-                            char* name, int main_422,char *ext);
-extern int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,
-                                   mm_camera_buf_def_t *frame);
-
-static int rdi_counter = 0;
-static void dumpRdi(mm_camera_buf_def_t* newFrame, int w, int h, char* name, int main_422)
-{
-    char buf[32];
-    int file_fd;
-    int i;
-    char *ext = "yuv";
-    if ( newFrame != NULL) {
-        char * str;
-        snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name, rdi_counter, ext);
-        file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-        if (file_fd < 0) {
-            CDBG_ERROR("%s: cannot open file\n", __func__);
-        } else {
-            void *y_off = newFrame->buffer + newFrame->planes[0].data_offset;
-            //int cbcr_off = newFrame->buffer + newFrame->planes[1].data_offset;//newFrame->buffer + newFrame->planes[0].length;
-            void *cbcr_off = newFrame->buffer + newFrame->planes[0].length;
-            CDBG("%s: Y_off = %p cbcr_off = %p", __func__, y_off,cbcr_off);
-            CDBG("%s: Y_off length = %d cbcr_off length = %d", __func__, newFrame->planes[0].length,newFrame->planes[1].length);
-
-            write(file_fd, (const void *)(y_off), newFrame->planes[0].length);
-            write(file_fd, (const void *)(cbcr_off),
-                  (newFrame->planes[1].length * newFrame->num_planes));
-            close(file_fd);
-            CDBG("dump %s", buf);
-        }
-    }
-}
-
-static int mm_app_set_opmode(int cam_id, mm_camera_op_mode_type_t op_mode)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    CDBG_ERROR("%s: Set rdi op mode = %d",__func__, op_mode);
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
-        pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode))) {
-        CDBG_ERROR("%s: Set rdi op mode error mode = %d",__func__, op_mode);
-    }
-    return rc;
-}
-
-static int mm_app_set_rdi_fmt(int cam_id, mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    cam_ctrl_dimension_t dim;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    //pme->cam->ops->get_parm(pme->cam->camera_handle,MM_CAMERA_PARM_DIMENSION, &dim);
-    fmt->fmt = pme->dim.rdi0_format;
-    fmt->width = 0;
-    fmt->height = 0;
-    fmt->rotation = 0;
-
-    CDBG("%s: RDI Dimensions = %d X %d", __func__, fmt->width, fmt->height);
-    return rc;
-}
-
-int mm_app_open_rdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int value = RDI_MASK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (pme->cam_mode == RDI_MODE) {
-        return rc;
-    }
-
-    if (MM_CAMERA_OK != (rc = stopPreview(cam_id))) {
-        CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
-        goto end;
-    }
-    pme->cam_mode = RDI_MODE;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-void rdi_cb_signal(mm_camera_app_obj_t *pme)
-{
-    if (pme->cam_mode == RDI_MODE) {
-        mm_camera_app_done();
-    }
-}
-
-static void mm_app_rdi_notify_cb(mm_camera_super_buf_t *bufs,
-                                 void *user_data)
-{
-    int rc;
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__); 
-    frame = bufs->bufs[0] ;
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
-    if (rdi_op_mode == MM_CAMERA_OP_MODE_VIDEO)
-      dumpFrameToFile(frame,pme->dim.rdi0_width,pme->dim.rdi0_height,"rdi_p", 1,"raw");
-    else {
-      rdi_counter++;
-      if (rdi_counter <=5)
-        dumpRdi(frame,pme->dim.rdi0_width,pme->dim.rdi0_height,"rdi_s", 1);
-    }
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,
-                                            pme->ch_id,
-                                            frame)) {
-        CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
-        return;
-    }
-    mm_stream_invalid_cache(pme,frame);
-    if (my_cam_app.run_sanity) {
-        mm_camera_app_done(pme);
-    }
-    CDBG("%s: END\n", __func__); 
-
-}
-
-int mm_app_prepare_rdi(int cam_id, uint8_t num_buf)
-{
-    int rc = MM_CAMERA_OK;
-    int op_mode;
-    int value = RDI_MASK;
-
-    CDBG("%s: E",__func__);
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    pme->mem_cam->get_buf = mm_stream_initbuf;
-    pme->mem_cam->put_buf = mm_stream_deinitbuf;
-    pme->mem_cam->user_data = pme;
-
-    //pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_CH_INTERFACE, &value);
-    //pme->cam->ops->get_parm(pme->cam->camera_handle,MM_CAMERA_PARM_CH_INTERFACE, &rdi_mode);
-
-    pme->stream[MM_CAMERA_RDI].id = pme->cam->ops->add_stream(pme->cam->camera_handle,
-                                                              pme->ch_id,
-                                                              mm_app_rdi_notify_cb,
-                                                              pme,
-                                                              MM_CAMERA_RDI,
-                                                              0);
-
-    if (!pme->stream[MM_CAMERA_RDI].id) {
-        CDBG_ERROR("%s:Add RDI error =%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-    CDBG("%s :Add RDI stream is successfull stream ID = %d",__func__,pme->stream[MM_CAMERA_RDI].id);
-
-    mm_app_set_rdi_fmt(cam_id,&pme->stream[MM_CAMERA_RDI].str_config.fmt);
-    pme->stream[MM_CAMERA_RDI].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_RDI].str_config.num_of_bufs = num_buf;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,
-                                                           pme->ch_id,
-                                                           pme->stream[MM_CAMERA_RDI].id,
-                                                           &pme->stream[MM_CAMERA_RDI].str_config))) {
-        CDBG_ERROR("%s:RDI streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-    end:
-    return rc;
-}
-
-int mm_app_unprepare_rdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    return rc;
-}
-
-int mm_app_streamon_rdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[2];
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    int num_of_streams;
-
-    /*if(rdi_mode == STREAM_IMAGE_AND_RAW){
-        num_of_streams = 2;
-        stream[0] = pme->stream[MM_CAMERA_RDI].id;
-        stream[1] = pme->stream[MM_CAMERA_PREVIEW].id;
-    }else */{
-        num_of_streams = 1;
-        stream[0] = pme->stream[MM_CAMERA_RDI].id;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,
-                                                           pme->ch_id,
-                                                           num_of_streams,
-                                                           stream))) {
-        CDBG_ERROR("%s : Start RDI Stream preview Error",__func__);
-        goto end;
-    }
-    pme->cam_state = CAMERA_STATE_RDI;
-    end:
-    CDBG("%s: X rc = %d",__func__,rc);
-    return rc;
-}
-
-int mm_app_start_rdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    int op_mode = 0;
-
-    CDBG_ERROR("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
-         pme,pme->cam,pme->cam->camera_handle);
-
-    if (pme->cam_state == CAMERA_STATE_RDI) {
-        return rc;
-    }
-
-    rdi_op_mode = MM_CAMERA_OP_MODE_VIDEO;
-    mm_app_set_opmode(cam_id, MM_CAMERA_OP_MODE_VIDEO);
-
-    if (MM_CAMERA_OK != (rc = mm_app_prepare_rdi(cam_id, 7))) {
-        CDBG_ERROR("%s:Prepare RDI failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamon_rdi(cam_id))) {
-        CDBG_ERROR("%s:Stream On RDI failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc); 
-    return rc;
-}
-
-static int mm_app_streamoff_rdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[2];
-    int num_of_streams;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    /*if(rdi_mode == STREAM_IMAGE_AND_RAW){
-        num_of_streams = 2;
-        stream[0] = pme->stream[MM_CAMERA_RDI].id;
-        stream[1] = pme->stream[MM_CAMERA_PREVIEW].id;
-    }else*/{
-        num_of_streams = 1;
-        stream[0] = pme->stream[MM_CAMERA_RDI].id;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,
-                                                          pme->ch_id,
-                                                          num_of_streams,
-                                                          stream))) {
-        CDBG_ERROR("%s : RDI Stream off Error",__func__);
-        goto end;
-    }
-
-    /*if(rdi_mode == STREAM_IMAGE_AND_RAW) {
-        if(MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id)))
-        {
-            CDBG_ERROR("%s : Delete Preview error",__func__);
-            goto end;
-        }
-    }*/
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,
-                                                        pme->ch_id,
-                                                        pme->stream[MM_CAMERA_RDI].id))) {
-        CDBG_ERROR("%s : Delete Stream RDI error",__func__);
-        goto end;
-    }
-    CDBG("del_stream successfull");
-    pme->cam_state = CAMERA_STATE_OPEN;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-
-    return rc;
-}
-
-static int mm_app_streamdel_rdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int stream[2];
-    int num_of_streams;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    /*if(rdi_mode == STREAM_IMAGE_AND_RAW){
-        num_of_streams = 2;
-        stream[0] = pme->stream[MM_CAMERA_RDI].id;
-        stream[1] = pme->stream[MM_CAMERA_PREVIEW].id;
-    }else*/{
-        num_of_streams = 1;
-        stream[0] = pme->stream[MM_CAMERA_RDI].id;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_RDI].id))) {
-        CDBG_ERROR("%s : Delete Stream RDI error",__func__);
-        goto end;
-    }
-    CDBG("del_stream successfull");
-    pme->cam_state = CAMERA_STATE_OPEN;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-
-    return rc;
-}
-
-
-int startRdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: Start Preview",__func__);
-
-    if (pme->cam_mode == ZSL_MODE || pme->cam_mode == RECORDER_MODE || pme->cam_mode == CAMERA_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_RECORD:
-            if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
-                CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
-                return -1;
-            }
-        case CAMERA_STATE_PREVIEW:
-            if (MM_CAMERA_OK != mm_app_open_rdi(cam_id)) {
-                CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
-                return -1;
-            }
-        case CAMERA_STATE_SNAPSHOT:
-        default:
-            break;
-        }
-    }
-    mm_app_start_rdi(cam_id);
-    return rc;
-}
-
-int stopRdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    rdi_counter = 0;
-    mm_app_streamoff_rdi(cam_id);
-
-    end:
-    return rc;
-}
-
-int takePicture_rdi(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    mm_app_streamoff_rdi(cam_id);
-    rdi_op_mode = MM_CAMERA_OP_MODE_CAPTURE;
-    mm_app_set_opmode(cam_id, MM_CAMERA_OP_MODE_CAPTURE);
-    if (MM_CAMERA_OK != (rc = mm_app_prepare_rdi(cam_id, 1))) {
-        CDBG_ERROR("%s:Prepare RDI failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-    if (MM_CAMERA_OK != (rc = mm_app_streamon_rdi(cam_id))) {
-        CDBG_ERROR("%s:Stream On RDI failed rc=%d\n", __func__, rc);
-        goto end;
-    }
-    mm_camera_app_wait(cam_id);
-    usleep(50*1000);
-    mm_app_streamoff_rdi(cam_id);
-    mm_app_start_rdi(cam_id);
-end:
-    return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_snapshot.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_snapshot.c
deleted file mode 100755
index 5d27305..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_snapshot.c
+++ /dev/null
@@ -1,1220 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include "mm_camera_dbg.h"
-#include "mm_qcamera_app.h"
-
-#define BUFF_SIZE_128 128
-
-#ifdef TEST_ABORT_JPEG_ENCODE
-static uint8_t aborted_flag = 1;
-#endif
-
-//static mm_camera_ch_data_buf_t *mCurrentFrameEncoded;
-static int JpegOffset = 0;
-static int raw_snapshot_cnt = 0;
-static int snapshot_cnt = 0;
-static pthread_mutex_t g_s_mutex;
-static int g_status = 0;
-static pthread_cond_t g_s_cond_v;
-
-extern void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h, char* name, int main_422,char *ext);
-extern int mm_app_open_zsl(int cam_id);
-extern int mm_app_open_camera(int cam_id);
-extern int mm_app_start_preview(int cam_id);
-extern int mm_stream_alloc_bufs(mm_camera_app_obj_t *pme,
-                                mm_camear_app_buf_t* app_bufs,
-                                mm_camera_frame_len_offset *frame_offset_info,
-                                uint8_t num_bufs);
-extern int mm_stream_release_bufs(mm_camera_app_obj_t *pme,
-                                  mm_camear_app_buf_t* app_bufs);
-extern int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,
-                                   mm_camera_buf_def_t *frame);
-
-static void mm_app_snapshot_done()
-{
-    pthread_mutex_lock(&g_s_mutex);
-    g_status = TRUE;
-    pthread_cond_signal(&g_s_cond_v);
-    pthread_mutex_unlock(&g_s_mutex);
-}
-
-static int mm_app_dump_snapshot_frame(struct msm_frame *frame,
-                                      uint32_t len, int is_main, int is_raw)
-{
-    char bufp[BUFF_SIZE_128];
-    int file_fdp;
-    int rc = 0;
-
-    if (is_raw) {
-        snprintf(bufp, BUFF_SIZE_128, "/data/main_raw_%d.yuv", raw_snapshot_cnt);
-    } else {
-        if (is_main) {
-            snprintf(bufp, BUFF_SIZE_128, "/data/main_%d.yuv", snapshot_cnt);
-        } else {
-            snprintf(bufp, BUFF_SIZE_128, "/data/thumb_%d.yuv", snapshot_cnt);
-        }
-    }
-
-    file_fdp = open(bufp, O_RDWR | O_CREAT, 0777);
-
-    if (file_fdp < 0) {
-        CDBG("cannot open file %s\n", bufp);
-        rc = -1;
-        goto end;
-    }
-    CDBG("%s:dump snapshot frame to '%s'\n", __func__, bufp);
-    write(file_fdp,
-          (const void *)frame->buffer, len);
-    close(file_fdp);
-    end:
-    return rc;
-}
-
-
-static void mm_app_dump_jpeg_frame(const void * data, uint32_t size, char* name, char* ext, int index)
-{
-    char buf[32];
-    int file_fd;
-    if ( data != NULL) {
-        char * str;
-        snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name, index, ext);
-        CDBG("%s: %s size =%d, jobId=%d", __func__, buf, size, index);
-        file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-        write(file_fd, data, size);
-        close(file_fd);
-    }
-}
-
-static int mm_app_set_thumbnail_fmt(int cam_id, mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = pme->dim.thumb_format;
-    fmt->width = pme->dim.thumbnail_width;
-    fmt->height = pme->dim.thumbnail_height;
-    if (cam_id == 0) {
-        /* back camera, rotate 90 */
-        fmt->rotation = 90;
-    }
-    CDBG("Thumbnail Dimension = %dX%d",fmt->width,fmt->height);
-    return rc;
-}
-
-int mm_app_set_snapshot_fmt(int cam_id, mm_camera_image_fmt_t *fmt)
-{
-
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = pme->dim.main_img_format;
-    fmt->width = pme->dim.picture_width;
-    fmt->height = pme->dim.picture_height;
-    if (cam_id == 0) {
-        /* back camera, rotate 90 */
-        fmt->rotation = 90;
-    }
-    CDBG("Snapshot Dimension = %dX%d",fmt->width,fmt->height);
-    return rc;
-}
-
-int mm_app_set_live_snapshot_fmt(int cam_id, mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = pme->dim.enc_format;
-    fmt->width = pme->dim.video_width;
-    fmt->height = pme->dim.video_height;
-    CDBG("Livesnapshot Dimension = %dX%d",fmt->width,fmt->height);
-    return rc;
-}
-
-int mm_app_set_raw_snapshot_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = pme->dim.raw_img_format;
-    fmt->width = pme->dim.raw_picture_width;
-    fmt->height = pme->dim.raw_picture_height;
-    if (cam_id == 0) {
-        /* back camera, rotate 90 */
-        fmt->rotation = 90;
-    }
-    CDBG("%s: Raw Snapshot Dimension = %d X %d",__func__,pme->dim.raw_picture_width,pme->dim.raw_picture_height);
-    return rc;
-}
-
-/* This callback is received once the complete JPEG encoding is done */
-static void jpeg_encode_cb(jpeg_job_status_t status,
-                           uint8_t thumbnailDroppedFlag,
-                           uint32_t client_hdl,
-                           uint32_t jobId,
-                           uint8_t* out_data,
-                           uint32_t data_size,
-                           void *userData)
-{
-    int rc;
-    int i = 0;
-    mm_camera_buf_def_t *main_frame = NULL;
-    mm_camera_buf_def_t *thumb_frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__);
-
-    pme = (mm_camera_app_obj_t *)userData;
-    if (jobId != pme->current_job_id || !pme->current_job_frames) {
-        CDBG_ERROR("%s: NULL current job frames or not matching job ID (%d, %d)",
-                   __func__, jobId, pme->current_job_id);
-        return;
-    }
-
-    /* dump jpeg img */
-    CDBG_ERROR("%s: job %d, status=%d, thumbnail_dropped=%d",
-               __func__, jobId, status, thumbnailDroppedFlag);
-    if (status == JPEG_JOB_STATUS_DONE) {
-        mm_app_dump_jpeg_frame(out_data, data_size, "jpeg_dump", "jpg", pme->my_id);
-    }
-
-    /* buf done current encoding frames */
-    pme->current_job_id = 0;
-    for (i=0; i<pme->current_job_frames->num_bufs; i++) {
-        if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->current_job_frames->camera_handle,
-                                                pme->current_job_frames->ch_id,
-                                                pme->current_job_frames->bufs[i])) {
-            CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
-        }
-    }
-    free(pme->current_job_frames);
-    pme->current_job_frames = NULL;
-
-    /* signal snapshot is done */
-    mm_app_snapshot_done();
-}
-
-static int encodeData(mm_camera_app_obj_t *pme,
-                      mm_camera_super_buf_t* recvd_frame)
-{
-    int rc = -1;
-    int i,index = -1;
-    mm_jpeg_job job;
-    mm_camera_buf_def_t *main_frame = NULL;
-    mm_camera_buf_def_t *thumb_frame = NULL;
-    src_image_buffer_info* main_buf_info = NULL;
-    src_image_buffer_info* thumb_buf_info = NULL;
-    mm_camera_frame_len_offset main_offset;
-    mm_camera_frame_len_offset thumb_offset;
-
-    /* dump raw img for debug purpose */
-    CDBG("%s : total streams = %d",__func__,recvd_frame->num_bufs);
-    for (i=0; i<recvd_frame->num_bufs; i++) {
-        if (pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id == recvd_frame->bufs[i]->stream_id) {
-            main_frame = recvd_frame->bufs[i];
-            CDBG("mainframe frame_idx = %d fd = %d frame length = %d",main_frame->frame_idx,main_frame->fd,main_frame->frame_len);
-            dumpFrameToFile(main_frame,pme->dim.picture_width,pme->dim.picture_height,"main", 1,"yuv");
-        } else if (pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id == recvd_frame->bufs[i]->stream_id){
-            thumb_frame = recvd_frame->bufs[1];
-            CDBG("thumnail frame_idx = %d fd = %d frame length = %d",thumb_frame->frame_idx,thumb_frame->fd,thumb_frame->frame_len);
-            dumpFrameToFile(thumb_frame,pme->dim.thumbnail_width,pme->dim.thumbnail_height,"thumb", 1,"yuv");
-        }
-    }
-
-    if (main_frame == NULL) {
-        CDBG_ERROR("%s: Main frame is NULL", __func__);
-        return rc;
-    }
-
-    /* remember current frames being encoded */
-    pme->current_job_frames =
-        (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
-    if (!pme->current_job_frames) {
-        CDBG_ERROR("%s: No memory for current_job_frames", __func__);
-        return rc;
-    }
-    memcpy(pme->current_job_frames, recvd_frame, sizeof(mm_camera_super_buf_t));
-
-    memset(&job, 0, sizeof(job));
-    job.job_type = JPEG_JOB_TYPE_ENCODE;
-    job.encode_job.jpeg_cb = jpeg_encode_cb;
-    job.encode_job.userdata = (void*)pme;
-    job.encode_job.encode_parm.exif_data = NULL;
-    job.encode_job.encode_parm.exif_numEntries = 0;
-    job.encode_job.encode_parm.rotation = 0;
-    job.encode_job.encode_parm.buf_info.src_imgs.src_img_num = recvd_frame->num_bufs;
-    job.encode_job.encode_parm.rotation = 0;
-    if (pme->my_id == 0) {
-        /* back camera, rotate 90 */
-        job.encode_job.encode_parm.rotation = 90;
-    }
-
-    /* fill in main src img encode param */
-    main_buf_info = &job.encode_job.encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN];
-    main_buf_info->type = JPEG_SRC_IMAGE_TYPE_MAIN;
-    main_buf_info->color_format = MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2; //TODO
-    main_buf_info->quality = 85;
-    main_buf_info->src_dim.width = pme->dim.picture_width;
-    main_buf_info->src_dim.height = pme->dim.picture_height;
-    main_buf_info->out_dim.width = pme->dim.picture_width;
-    main_buf_info->out_dim.height = pme->dim.picture_height;
-    main_buf_info->crop.width = pme->dim.picture_width;
-    main_buf_info->crop.height = pme->dim.picture_height;
-    main_buf_info->crop.offset_x = 0;
-    main_buf_info->crop.offset_y = 0;
-    main_buf_info->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
-    main_buf_info->num_bufs = 1;
-    main_buf_info->src_image[0].fd = main_frame->fd;
-    main_buf_info->src_image[0].buf_vaddr = main_frame->buffer;
-    pme->cam->ops->get_stream_parm(pme->cam->camera_handle,
-                                   pme->ch_id,
-                                   pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
-                                   MM_CAMERA_STREAM_OFFSET,
-                                   &main_buf_info->src_image[0].offset);
-    CDBG("%s: main offset: num_planes=%d, frame length=%d, y_offset=%d, cbcr_offset=%d",
-         __func__, main_buf_info->src_image[0].offset.num_planes,
-         main_buf_info->src_image[0].offset.frame_len,
-         main_buf_info->src_image[0].offset.mp[0].offset,
-         main_buf_info->src_image[0].offset.mp[1].offset);
-
-    mm_stream_clear_invalid_cache(pme,main_frame);
-
-    if (thumb_frame) {
-        /* fill in thumbnail src img encode param */
-        thumb_buf_info = &job.encode_job.encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB];
-        thumb_buf_info->type = JPEG_SRC_IMAGE_TYPE_THUMB;
-        thumb_buf_info->color_format = MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2; //TODO
-        thumb_buf_info->quality = 85;
-        thumb_buf_info->src_dim.width = pme->dim.thumbnail_width;
-        thumb_buf_info->src_dim.height = pme->dim.thumbnail_height;
-        thumb_buf_info->out_dim.width = pme->dim.thumbnail_width;
-        thumb_buf_info->out_dim.height = pme->dim.thumbnail_height;
-        thumb_buf_info->crop.width = pme->dim.thumbnail_width;
-        thumb_buf_info->crop.height = pme->dim.thumbnail_height;
-        thumb_buf_info->crop.offset_x = 0;
-        thumb_buf_info->crop.offset_y = 0;
-        thumb_buf_info->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
-        thumb_buf_info->num_bufs = 1;
-        thumb_buf_info->src_image[0].fd = thumb_frame->fd;
-        thumb_buf_info->src_image[0].buf_vaddr = thumb_frame->buffer;
-        pme->cam->ops->get_stream_parm(pme->cam->camera_handle,
-                                       pme->ch_id,
-                                       pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id,
-                                       MM_CAMERA_STREAM_OFFSET,
-                                       &thumb_buf_info->src_image[0].offset);
-    }
-
-    /* fill in sink img param */
-    job.encode_job.encode_parm.buf_info.sink_img.buf_len = pme->jpeg_buf.bufs[0].frame_len;
-    job.encode_job.encode_parm.buf_info.sink_img.buf_vaddr = pme->jpeg_buf.bufs[0].buffer;
-    job.encode_job.encode_parm.buf_info.sink_img.fd = pme->jpeg_buf.bufs[0].fd;
-
-    mm_stream_clear_invalid_cache(pme,thumb_frame);
-
-    rc = pme->jpeg_ops.start_job(pme->jpeg_hdl, &job, &pme->current_job_id);
-    if ( 0 != rc ) {
-        free(pme->current_job_frames);
-        pme->current_job_frames = NULL;
-    }
-
-    return rc;
-}
-
-static void snapshot_yuv_cb(mm_camera_super_buf_t *bufs,
-                            void *user_data)
-{
-
-    int rc;
-    int i = 0;
-    mm_camera_buf_def_t *main_frame = NULL;
-    mm_camera_buf_def_t *thumb_frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    char* cmd = "This is a private cmd from test app";
-
-    CDBG("%s: BEGIN\n", __func__);
-
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: send private ioctl here", __func__);
-    pme->cam->ops->send_command(bufs->camera_handle,
-                                MM_CAMERA_CMD_TYPE_PRIVATE,
-                                0,
-                                strlen(cmd) + 1,
-                                (void *)cmd);
-
-    /* start jpeg encoding job */
-    rc = encodeData(pme, bufs);
-
-    /* buf done rcvd frames in error case */
-    if ( 0 != rc ) {
-        for (i=0; i<bufs->num_bufs; i++) {
-            if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
-                                                    bufs->ch_id,
-                                                    bufs->bufs[i])) {
-                CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
-            }
-            mm_stream_invalid_cache(pme,bufs->bufs[i]);
-        }
-    }
-#ifdef TEST_ABORT_JPEG_ENCODE
-    else {
-        if (aborted_flag) {
-            aborted_flag = 0;
-            /* abort the job */
-            CDBG("%s: abort jpeg encode job  here", __func__);
-            rc = pme->jpeg_ops.abort_job(pme->jpeg_hdl, pme->current_job_id);
-            if (NULL != pme->current_job_frames) {
-                free(pme->current_job_frames);
-                pme->current_job_frames = NULL;
-            }
-            CDBG("%s: abort jpeg encode job returns %d", __func__, rc);
-            for (i=0; i<bufs->num_bufs; i++) {
-                if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
-                                                        bufs->ch_id,
-                                                        bufs->bufs[i])) {
-                    CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
-                }
-                mm_stream_invalid_cache(pme,bufs->bufs[i]);
-            }
-
-            /* signal snapshot is done */
-            mm_app_snapshot_done();
-        }
-    }
-#endif
-
-    CDBG("%s: END\n", __func__);
-}
-
-static void snapshot_raw_cb(mm_camera_super_buf_t *recvd_frame,
-                            void *user_data)
-{
-    int rc;
-    int i = 0;
-    mm_camera_buf_def_t *main_frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-
-    CDBG("%s: BEGIN\n", __func__);
-
-    pme = (mm_camera_app_obj_t *)user_data;
-
-     if (pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id == recvd_frame->bufs[i]->stream_id) {
-         main_frame = recvd_frame->bufs[i];
-         CDBG("mainframe frame_idx = %d fd = %d frame length = %d",main_frame->frame_idx,main_frame->fd,main_frame->frame_len);
-         dumpFrameToFile(main_frame,pme->dim.raw_picture_width,pme->dim.raw_picture_height,"raw_main", 1,"raw");
-     }
-     if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,
-                                                main_frame)) {
-        CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
-     }
-
-     mm_app_snapshot_done();
-}
-
-static int encodeDisplayAndSave(mm_camera_super_buf_t* recvd_frame,
-                                int enqueued, mm_camera_app_obj_t *pme)
-{
-    int ret = -1;
-#if 0
-
-
-    CDBG("%s: Send frame for encoding", __func__);
-    ret = encodeData(recvd_frame, pme->snapshot_buf.frame_len,
-                     enqueued, pme);
-    if (!ret) {
-        CDBG_ERROR("%s: Failure configuring JPEG encoder", __func__);
-    }
-
-    LOGD("%s: X", __func__);
-#endif
-    return ret;
-}
-
-int mm_app_add_snapshot_stream(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
-                                                                        NULL,pme,
-                                                                        MM_CAMERA_SNAPSHOT_MAIN, 0);
-
-    CDBG("Add Snapshot main is successfull stream ID = %d",pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id);
-    if (!pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id) {
-        CDBG_ERROR("%s:snapshot main streaming err=%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
-                                                                             NULL,pme,
-                                                                             MM_CAMERA_SNAPSHOT_THUMBNAIL, 0);
-    if (!pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id) {
-        CDBG_ERROR("%s:snapshot thumbnail streaming err=%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-void mm_app_set_snapshot_mode(int cam_id,int op_mode)
-{
-    denoise_param_t wnr;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode);
-
-    /* set wnr enabled */
-    memset(&wnr, 0, sizeof(denoise_param_t));
-    wnr.denoise_enable = 0;
-    wnr.process_plates = 0;
- //   pme->cam->ops->set_parm(pme->cam->camera_handle, MM_CAMERA_PARM_WAVELET_DENOISE, &wnr);
-}
-
-int mm_app_config_raw_format(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    mm_camera_image_fmt_t *m_fmt = NULL;
-    mm_camera_image_fmt_t *t_fmt = NULL;
-
-    mm_app_set_raw_snapshot_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.fmt);
-
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.num_of_bufs = 1;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
-                                                           &pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-
-end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-
-}
-
-int mm_app_config_snapshot_format(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    mm_app_set_snapshot_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.fmt);
-
-    mm_app_set_thumbnail_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].str_config.fmt);
-
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.num_of_bufs = 1;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
-                                                           &pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].str_config.num_of_bufs = 1;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id,
-                                                           &pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-
-}
-
-int mm_app_streamon_snapshot(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[2];
-    mm_camera_bundle_attr_t attr;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-    stream[1] = pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id;
-
-    attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
-    attr.burst_num = 1;
-    attr.look_back = 2;
-    attr.post_frame_skip = 0;
-    attr.water_mark = 2;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->init_stream_bundle(
-                                                               pme->cam->camera_handle,pme->ch_id,snapshot_yuv_cb,pme,&attr,2,stream))) {
-        CDBG_ERROR("%s:init_stream_bundle err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,
-                                                           2, stream))) {
-        CDBG_ERROR("%s:start_streams err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc =pme->cam->ops->request_super_buf(pme->cam->camera_handle,pme->ch_id, attr.burst_num))) {
-        CDBG_ERROR("%s:request_super_buf err=%d\n", __func__, rc);
-        goto end;
-    }
-    pme->cam_state = CAMERA_STATE_SNAPSHOT;
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_streamon_raw(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[2];
-    mm_camera_bundle_attr_t attr;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-
-    attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
-    attr.burst_num = 1;
-    attr.look_back = 2;
-    attr.post_frame_skip = 0;
-    attr.water_mark = 2;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->init_stream_bundle(
-                                                               pme->cam->camera_handle,pme->ch_id,snapshot_raw_cb,pme,&attr,1,stream))) {
-        CDBG_ERROR("%s:init_stream_bundle err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,
-                                                           1, stream))) {
-        CDBG_ERROR("%s:start_streams err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc =pme->cam->ops->request_super_buf(pme->cam->camera_handle,pme->ch_id, attr.burst_num))) {
-        CDBG_ERROR("%s:request_super_buf err=%d\n", __func__, rc);
-        goto end;
-    }
-    pme->cam_state = CAMERA_STATE_SNAPSHOT;
-end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_streamoff_snapshot(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    uint32_t stream[2];
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-    stream[1] = pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,2,stream))) {
-        CDBG_ERROR("%s : Snapshot Stream off Error",__func__);
-        goto end;
-    }
-    CDBG("Stop snapshot main successfull");
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->destroy_stream_bundle(pme->cam->camera_handle,pme->ch_id))) {
-        CDBG_ERROR("%s : Snapshot destroy_stream_bundle Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id))) {
-        CDBG_ERROR("%s : Snapshot main image del_stream Error",__func__);
-        goto end;
-    }
-    CDBG("del_stream successfull");
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id))) {
-        CDBG_ERROR("%s : Snapshot thumnail image del_stream Error",__func__);
-        goto end;
-    }
-    CDBG("del_stream successfull");
-
-    end:
-    return rc;
-}
-
-int mm_app_start_snapshot(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int stream[2];
-    int op_mode = 0;
-    uint8_t initial_reg_flag;
-    mm_camera_frame_len_offset frame_offset_info;
-
-    mm_camera_bundle_attr_t attr;
-
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (MM_CAMERA_OK != mm_app_stop_preview(cam_id)) {
-        CDBG_ERROR("%s: Stop preview Failed cam_id=%d\n",__func__,cam_id);
-        return -1;
-    }
-    op_mode = MM_CAMERA_OP_MODE_CAPTURE;
-    mm_app_set_snapshot_mode(cam_id,op_mode);
-    usleep(20*1000);
-//    pme->cam->ops->prepare_snapshot(pme->cam->camera_handle,pme->ch_id,0);
-
-    if (MM_CAMERA_OK != (rc = mm_app_add_snapshot_stream(cam_id))) {
-        CDBG_ERROR("%s : Add Snapshot stream err",__func__);
-        return rc;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_config_snapshot_format(cam_id))) {
-        CDBG_ERROR("%s : Config Snapshot stream err",__func__);
-        return rc;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamon_snapshot(cam_id))) {
-        CDBG_ERROR("%s : Stream on Snapshot stream err",__func__);
-        return rc;
-    }
-
-    /* init jpeg buf */
-    pme->cam->ops->get_stream_parm(pme->cam->camera_handle,
-                                   pme->ch_id,
-                                   pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
-                                   MM_CAMERA_STREAM_OFFSET,
-                                   &frame_offset_info);
-    CDBG_ERROR("%s : alloc jpeg buf (len=%d)",__func__, frame_offset_info.frame_len);
-    rc = mm_stream_alloc_bufs(pme,
-                              &pme->jpeg_buf,
-                              &frame_offset_info,
-                              1);
-    if (0 != rc) {
-        CDBG_ERROR("%s : mm_stream_alloc_bufs err",__func__);
-        return rc;
-    }
-
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_start_raw(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int op_mode = 0;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (MM_CAMERA_OK != mm_app_stop_preview(cam_id)) {
-        CDBG_ERROR("%s: Stop preview Failed cam_id=%d\n",__func__,cam_id);
-        return -1;
-    }
-    op_mode = MM_CAMERA_OP_MODE_RAW;
-    pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode);
-    usleep(20*1000);
-
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
-                                                                        NULL,pme,
-                                                                        MM_CAMERA_SNAPSHOT_MAIN, 0);
-
-    CDBG("Add RAW main is successfull stream ID = %d",pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id);
-    if (!pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id) {
-        CDBG_ERROR("%s:Raw main streaming err=%d\n", __func__, rc);
-        rc = -1;
-        return rc;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_config_raw_format(cam_id))) {
-        CDBG_ERROR("%s : Config Raw Snapshot stream err",__func__);
-        return rc;
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamon_raw(cam_id))) {
-        CDBG_ERROR("%s : Stream on Raw Snapshot stream err",__func__);
-        return rc;
-    }
-
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_stop_snapshot(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int i;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if (pme->current_job_id) {
-        /* have current jpeg encoding running, abort the job */
-        if (pme->jpeg_ops.abort_job) {
-            pme->jpeg_ops.abort_job(pme->jpeg_hdl, pme->current_job_id);
-            pme->current_job_id = 0;
-        }
-
-        if (pme->current_job_frames) {
-            for (i=0; i<pme->current_job_frames->num_bufs; i++) {
-                if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->current_job_frames->camera_handle,
-                                                        pme->current_job_frames->ch_id,
-                                                        pme->current_job_frames->bufs[i])) {
-                    CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
-                }
-                mm_stream_invalid_cache(pme,pme->current_job_frames->bufs[i]);
-            }
-            free(pme->current_job_frames);
-            pme->current_job_frames = NULL;
-        }
-    }
-
-    if (MM_CAMERA_OK != (rc = mm_app_streamoff_snapshot(cam_id))) {
-        CDBG_ERROR("%s : Stream off Snapshot stream err",__func__);
-    }
-    pme->cam_state = CAMERA_STATE_OPEN;
-
-    /* deinit jpeg buf */
-    rc = mm_stream_release_bufs(pme,
-                                &pme->jpeg_buf);
-end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-
-    return rc;
-}
-
-int mm_app_stop_raw(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int i;
-    uint32_t stream[1];
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream))) {
-        CDBG_ERROR("%s : Snapshot Stream off Error",__func__);
-        goto end;
-    }
-    CDBG("Stop snapshot main successfull");
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->destroy_stream_bundle(pme->cam->camera_handle,pme->ch_id))) {
-        CDBG_ERROR("%s : Snapshot destroy_stream_bundle Error",__func__);
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id))) {
-        CDBG_ERROR("%s : Snapshot main image del_stream Error",__func__);
-        goto end;
-    }
-    CDBG("del_stream successfull");
-
-    pme->cam_state = CAMERA_STATE_OPEN;
-end:
-    return rc;
-}
-
-static void mm_app_snapshot_wait(int cam_id)
-{
-    pthread_mutex_lock(&g_s_mutex);
-    if (FALSE == g_status) {
-        pthread_cond_wait(&g_s_cond_v, &g_s_mutex);
-        g_status = FALSE;
-    }
-    pthread_mutex_unlock(&g_s_mutex);
-}
-
-static void mm_app_live_notify_cb(mm_camera_super_buf_t *bufs,
-                                  void *user_data)
-{
-
-    int rc;
-    int i = 0;
-    mm_camera_buf_def_t *main_frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__);
-
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s : total streams = %d",__func__,bufs->num_bufs);
-    main_frame = bufs->bufs[0];
-    //thumb_frame = bufs->bufs[1];
-
-    CDBG("mainframe frame_idx = %d fd = %d frame length = %d",main_frame->frame_idx,main_frame->fd,main_frame->frame_len);
-    //CDBG("thumnail frame_idx = %d fd = %d frame length = %d",thumb_frame->frame_idx,thumb_frame->fd,thumb_frame->frame_len);
-
-    //dumpFrameToFile(main_frame->frame,pme->dim.picture_width,pme->dim.picture_height,"main", 1);
-
-    dumpFrameToFile(main_frame,pme->dim.picture_width,pme->dim.picture_height,"liveshot_main", 1,"yuv");
-
-    if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,main_frame)) {
-        CDBG_ERROR("%s: Failed in thumbnail Qbuf\n", __func__);
-    }
-    mm_stream_invalid_cache(pme,main_frame);
-    /*if(MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,thumb_frame))
-    {
-            CDBG_ERROR("%s: Failed in thumbnail Qbuf\n", __func__);
-    }*/
-
-    mm_app_snapshot_done();
-    CDBG("%s: END\n", __func__);
-
-
-}
-
-int mm_app_prepare_live_snapshot(int cam_id)
-{
-    int rc = 0;
-    uint32_t stream[1];
-    mm_camera_bundle_attr_t attr;
-    int value = 0;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
-    stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-    //stream[1] = pme->stream[MM_CAMERA_PREVIEW].id;  //Need to clarify
-
-    attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
-    attr.burst_num = 1;
-    attr.look_back = 2;
-    attr.post_frame_skip = 0;
-    attr.water_mark = 2;
-
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
-                                                     pme->cam->camera_handle,MM_CAMERA_PARM_FULL_LIVESHOT, (void *)&value))) {
-        CDBG_ERROR("%s: set dimension err=%d\n", __func__, rc);
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->init_stream_bundle(
-                                                               pme->cam->camera_handle,pme->ch_id,mm_app_live_notify_cb,pme,&attr,1,stream))) {
-        CDBG_ERROR("%s:init_stream_bundle err=%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,
-                                                           1, stream))) {
-        CDBG_ERROR("%s:start_streams err=%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-
-    end:
-    CDBG("%s:END, cam_id=%d\n",__func__,cam_id);
-    return rc;
-}
-
-int mm_app_unprepare_live_snapshot(int cam_id)
-{
-    int rc = 0;
-    uint32_t stream[2];
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-    CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
-    stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream))) {
-        CDBG_ERROR("%s : Snapshot Stream off Error",__func__);
-        return -1;
-    }
-
-    if (MM_CAMERA_OK != (rc = pme->cam->ops->destroy_stream_bundle(pme->cam->camera_handle,pme->ch_id))) {
-        CDBG_ERROR("%s : Snapshot destroy_stream_bundle Error",__func__);
-        return -1;
-    }
-    CDBG("%s:END, cam_id=%d\n",__func__,cam_id);
-    return rc;
-}
-
-int mm_app_take_live_snapshot(int cam_id)
-{
-    int rc = 0;
-    int stream[3];
-    mm_camera_bundle_attr_t attr;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
-    if (pme->cam_mode == RECORDER_MODE &&
-        pme->cam_state == CAMERA_STATE_RECORD) {
-        //Code to get live shot
-        if (mm_app_prepare_live_snapshot(cam_id) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s: Failed prepare liveshot",__func__);
-            return -1;
-        }
-        if (MM_CAMERA_OK != (rc =pme->cam->ops->request_super_buf(pme->cam->camera_handle,pme->ch_id, 1))) {
-            CDBG_ERROR("%s:request_super_buf err=%d\n", __func__, rc);
-            return -1;
-        }
-        CDBG("%s:waiting images\n",__func__);
-        mm_app_snapshot_wait(cam_id);
-
-        if (MM_CAMERA_OK !=mm_app_unprepare_live_snapshot(cam_id)) {
-            CDBG_ERROR("%s: Snapshot Stop error",__func__);
-        }
-
-    } else {
-        CDBG_ERROR("%s: Should not come here for liveshot",__func__);
-    }
-    return rc;
-}
-
-int mm_app_take_picture_raw(int cam_id)
-{
-
-    int rc;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
-    if (MM_CAMERA_OK != mm_app_start_raw(cam_id)) {
-        CDBG_ERROR("%s: cam_id=%d\n",__func__,cam_id);
-        rc = -1;
-        goto end;
-    }
-
-    CDBG("%s:waiting images\n",__func__);
-    mm_app_snapshot_wait(cam_id);
-
-    if (MM_CAMERA_OK !=mm_app_stop_raw(cam_id)) {
-        CDBG_ERROR("%s: Snapshot Stop error",__func__);
-    }
-
-preview:
-    if (MM_CAMERA_OK != (rc = mm_app_start_preview(cam_id))) {
-        CDBG("%s:preview start stream err=%d\n", __func__, rc);
-    }
-    end:
-    CDBG("%s:END, cam_id=%d\n",__func__,cam_id);
-    return rc;
-}
-
-int mm_app_take_picture_zsl(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int value = 1;
-    int op_mode;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: Take picture ZSL",__func__);
-
-    if (MM_CAMERA_OK != (rc =pme->cam->ops->request_super_buf(pme->cam->camera_handle,pme->ch_id, 1))) {
-        CDBG_ERROR("%s:request_super_buf err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    CDBG("%s: Start ZSL Preview",__func__);
-
-    end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_take_picture_yuv(int cam_id)
-{
-    int rc;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
-    if (MM_CAMERA_OK != mm_app_start_snapshot(cam_id)) {
-        CDBG_ERROR("%s: cam_id=%d\n",__func__,cam_id);
-        rc = -1;
-        goto end;
-    }
-
-    CDBG("%s:waiting images\n",__func__);
-    mm_app_snapshot_wait(cam_id);
-
-    if (MM_CAMERA_OK !=mm_app_stop_snapshot(cam_id)) {
-        CDBG_ERROR("%s: Snapshot Stop error",__func__);
-    }
-
-    preview:
-    if (MM_CAMERA_OK != (rc = mm_app_start_preview(cam_id))) {
-        CDBG("%s:preview start stream err=%d\n", __func__, rc);
-    }
-    end:
-    CDBG("%s:END, cam_id=%d\n",__func__,cam_id);
-    return rc;
-}
-
-int mm_app_take_zsl(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
-    if (pme->cam_mode == RECORDER_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_RECORD:
-            if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
-                CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
-                return -1;
-            }
-        case CAMERA_STATE_PREVIEW:
-            if (MM_CAMERA_OK != mm_app_open_zsl(cam_id)) {
-                CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
-                return -1;
-            }
-            break;
-        case CAMERA_STATE_SNAPSHOT:
-        default:
-            CDBG("%s: Cannot normal pciture in record mode\n", __func__);
-            break;
-        }
-    } else if (pme->cam_mode == CAMERA_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_PREVIEW:
-            mm_app_open_zsl(cam_id);
-            break;
-
-        case CAMERA_STATE_SNAPSHOT:
-        case CAMERA_STATE_RECORD:
-        default:
-            CDBG("%s: Cannot normal pciture in record mode\n", __func__);
-            break;
-        }
-    }
-
-    if (pme->cam_mode == ZSL_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        mm_app_take_picture_zsl(cam_id);
-    }
-    return rc;
-}
-
-int mm_app_take_picture(int cam_id)
-{
-    int rc = 0;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
-    if (pme->cam_mode == RECORDER_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_RECORD:
-            if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
-                CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
-                return -1;
-            }
-        case CAMERA_STATE_PREVIEW:
-            if (MM_CAMERA_OK != mm_app_open_camera(cam_id)) {
-                CDBG_ERROR("%s: Cannot switch to camera mode=%d\n", __func__,rc);
-                return -1;
-            }
-            break;
-        case CAMERA_STATE_SNAPSHOT:
-        default:
-            CDBG("%s: Cannot normal pciture in record mode\n", __func__);
-            break;
-        }
-    } else if (pme->cam_mode == ZSL_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_PREVIEW:
-            mm_app_open_camera(cam_id);
-            break;
-
-        case CAMERA_STATE_SNAPSHOT:
-        case CAMERA_STATE_RECORD:
-        default:
-            CDBG("%s: Cannot normal pciture in record mode\n", __func__);
-            break;
-        }
-    }
-
-    CDBG("%s : Takepicture : mode = %d state = %d, rc = %d",__func__,pme->cam_mode,pme->cam_state,rc);
-    if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        mm_app_take_picture_yuv(cam_id);
-    }
-    return rc;
-}
-
-
-int mm_app_take_raw(int cam_id)
-{
-    int rc = 0;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
-    if (pme->cam_mode == RECORDER_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_RECORD:
-            if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
-                CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
-                return -1;
-            }
-        case CAMERA_STATE_PREVIEW:
-            if (MM_CAMERA_OK != mm_app_open_camera(cam_id)) {
-                CDBG_ERROR("%s: Cannot switch to camera mode=%d\n", __func__,rc);
-                return -1;
-            }
-            break;
-        case CAMERA_STATE_SNAPSHOT:
-        default:
-            CDBG("%s: Cannot normal pciture in record mode\n", __func__);
-            break;
-        }
-    } else if (pme->cam_mode == ZSL_MODE) {
-        switch (pme->cam_state) {
-        case CAMERA_STATE_PREVIEW:
-            mm_app_open_camera(cam_id);
-            break;
-
-        case CAMERA_STATE_SNAPSHOT:
-        case CAMERA_STATE_RECORD:
-        default:
-            CDBG("%s: Cannot normal pciture in record mode\n", __func__);
-            break;
-        }
-    }
-
-    CDBG("%s : Takepicture RAW: mode = %d state = %d, rc = %d",__func__,pme->cam_mode,pme->cam_state,rc);
-    if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
-        mm_app_take_picture_raw(cam_id);
-    }
-    return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_unit_test.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_unit_test.c
deleted file mode 100755
index c1f0eba..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_unit_test.c
+++ /dev/null
@@ -1,757 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include "mm_qcamera_unit_test.h"
-
-#define MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP 4
-#define MM_QCAM_APP_TEST_NUM 128
-
-static mm_app_tc_t mm_app_tc[MM_QCAM_APP_TEST_NUM];
-static int num_test_cases = 0;
-static mm_jpeg_ops_t jpeg_ops;
-
-extern int system_dimension_set(int cam_id);
-extern int stopPreview(int cam_id);
-extern int takePicture_yuv(int cam_id);
-extern int startRdi(int cam_id);
-extern int stopRdi(int cam_id);
-extern int startStats(int cam_id);
-extern int stopStats(int cam_id);
-extern int takePicture_zsl(int cam_id);
-extern int takePicture_rdi(int cam_id);
-extern int mm_app_tc_reprocess_preview_only(mm_camera_app_t *cam_apps);
-extern int takePicture_raw(int cam_id);
-
-int mm_app_tc_0(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying Preview on front and back camera...\n");
-    if (cam_apps->num_cameras == 0) {
-        CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
-        rc = -1;
-        goto end;
-    }
-    for (i = 0; i < cam_apps->num_cameras; i++) {
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
-                break;
-            }
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-                    CDBG_ERROR("%s: Preview Callback not received in time or qbuf failed\n", __func__);
-                    break;
-            }*/
-            mm_camera_app_wait();
-            if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
-                CDBG("%s: startPreview() err=%d\n", __func__, rc);
-                break;
-            }
-            result++;
-        }
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-
-        if (result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Preview Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-    end:
-    if (rc == 0) {
-        printf("\nPassed\n");
-    } else {
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_1(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying Snapshot on front and back camera...\n");
-    for (i = 0; i < cam_apps->num_cameras; i++) {
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-
-        if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if ( MM_CAMERA_OK != (rc = takePicture_yuv(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
-                break;
-            }
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-                    CDBG_ERROR("%s: Snapshot/Preview Callback not received in time or qbuf Faile\n", __func__);
-                    break;
-            }*/
-            mm_camera_app_wait();
-            result++;
-        }
-        if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
-            CDBG("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Snapshot Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-    end:
-    if (rc == 0) {
-        printf("\t***Passed***\n");
-    } else {
-        printf("\t***Failed***\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_2(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying Video on front and back camera...\n");
-    for (i = 0; i < cam_apps->num_cameras; i++) {
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-
-        if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if ( MM_CAMERA_OK != (rc = startRecording(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-                    CDBG_ERROR("%s: Video Callback not received in time\n", __func__);
-                    break;
-            }*/
-            mm_camera_app_wait();
-            usleep(10*1000);
-            if ( MM_CAMERA_OK != (rc = stopRecording(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-            result++;
-        }
-        if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
-            CDBG("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-    end:
-    if (rc == 0) {
-        printf("\nPassed\n");
-    } else {
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_3(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying RDI Stream on front and back camera...\n");
-    if (cam_apps->num_cameras == 0) {
-        CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
-        rc = -1;
-        goto end;
-    }
-    CDBG_ERROR("SINGLE open RDI ");
-    for (i = 1; i < cam_apps->num_cameras; i++) {
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        CDBG_ERROR("SINGLE start RDI case");
-        for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if ( MM_CAMERA_OK != (rc = startRdi(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-                    CDBG_ERROR("%s: Video Callback not received in time\n", __func__);
-                    break;
-            }*/
-            mm_camera_app_wait();
-            usleep(10*1000);
-            CDBG_ERROR("SINGLE stop RDI");
-            if ( MM_CAMERA_OK != (rc = stopRdi(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-            result++;
-        }
-        CDBG_ERROR("SINGLE close RDI");
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-    end:
-    if (rc == 0) {
-        printf("\nPassed\n");
-    } else {
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_4(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying ZSL Snapshot on front and back camera...\n");
-    for (i = 0; i < cam_apps->num_cameras; i++) {
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-
-        if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if ( MM_CAMERA_OK != (rc = takePicture_zsl(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: TakePicture() ZSL err=%d\n", __func__, rc);
-                break;
-            }
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-                    CDBG_ERROR("%s: Snapshot/Preview Callback not received in time or qbuf Faile\n", __func__);
-                    break;
-            }*/
-            mm_camera_app_wait();
-            result++;
-        }
-        if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
-            CDBG("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Snapshot ZSL Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-    end:
-    if (rc == 0) {
-        printf("\t***Passed***\n");
-    } else {
-        printf("\t***Failed***\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-
-
-int mm_app_tc_5(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i;
-    printf("Running %s - open/close ,video0, open/close snapshot channel only\n", __func__);
-#if 0
-    for (i = 0; i < MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP; i++) {
-        if ( 0 != (rc = mm_app_open(cam_id, MM_CAMERA_OP_MODE_NOTUSED))) {
-            CDBG("%s: open cam %d at opmode = %d err, loop=%d, rc=%d\n",
-                 __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
-            goto end;
-        }
-        if (0 != (rc = mm_app_open_snapshot(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_close_snapshot(cam_id))) {
-            goto end;
-        }
-        if ( 0 != (rc = mm_app_close(cam_id))) {
-            CDBG("%s: close cam %d at opmode = %d err,loop=%d, rc=%d\n",
-                 __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
-            goto end;
-        }
-    }
-    end:
-#endif
-    CDBG("%s:END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_6(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i;
-    printf("Running %s - simple preview \n", __func__);
-#if 0
-    if ( 0 != (rc = mm_app_open(cam_id, MM_CAMERA_OP_MODE_NOTUSED))) {
-        CDBG("%s: open cam %d at opmode = %d err, loop=%d, rc=%d\n",
-             __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
-        goto end;
-    }
-
-    for (i = 0; i < MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP; i++) {
-        if (0 != (rc = mm_app_init_preview(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_start_preview(cam_id))) {
-            goto end;
-        }
-        /* sleep 8 seconds */
-        usleep(8000000);
-        if (0 != (rc = mm_app_stop_preview(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc=mm_app_deinit_preview(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_close_preview(cam_id))) {
-            goto end;
-        }
-    }
-    if ( 0 != (rc = mm_app_close(cam_id))) {
-        CDBG("%s: close cam %d at opmode = %d err,loop=%d, rc=%d\n",
-             __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
-        goto end;
-    }
-end:
-#endif
-    CDBG("%s:END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_7(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i;
-    printf("Running %s - simple preview and recording \n", __func__);
-#if 0
-    if ( 0 != (rc = mm_app_open(cam_id, MM_CAMERA_OP_MODE_NOTUSED))) {
-        CDBG("%s: open cam %d at opmode = %d err, loop=%d, rc=%d\n",
-             __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
-        goto end;
-    }
-
-    for (i = 0; i < MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP; i++) {
-        if (0 != (rc = mm_app_init_preview(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_start_preview(cam_id))) {
-            goto end;
-        }
-        /* sleep 8 seconds */
-        usleep(8000000);
-        if (0 != (rc = mm_app_start_recording(cam_id))) {
-            goto end;
-        }
-        usleep(1000000);
-        if (0 != (rc = mm_app_stop_recording(cam_id))) {
-            goto end;
-        }
-        usleep(8000000);
-        if (0 != (rc = mm_app_stop_preview(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc=mm_app_deinit_preview(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_close_preview(cam_id))) {
-            goto end;
-        }
-    }
-    if ( 0 != (rc = mm_app_close(cam_id))) {
-        CDBG("%s: close cam %d at opmode = %d err,loop=%d, rc=%d\n",
-             __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
-        goto end;
-    }
-end:
-#endif
-    CDBG("%s:END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_8(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i;
-    printf("Running %s - preview, recording, and snapshot, then preview again \n", __func__);
-#if 0
-    if ( 0 != (rc = mm_app_open(cam_id, MM_CAMERA_OP_MODE_NOTUSED))) {
-        CDBG("%s: open cam %d at opmode = %d err, loop=%d, rc=%d\n",
-             __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
-        goto end;
-    }
-
-    for (i = 0; i < MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP; i++) {
-        if (0 != (rc = mm_app_init_preview(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_start_preview(cam_id))) {
-            goto end;
-        }
-        /* sleep 8 seconds */
-        usleep(8000000);
-        if (0 != (rc = mm_app_start_recording(cam_id))) {
-            goto end;
-        }
-        usleep(1000000);
-        if (0 != (rc = mm_app_stop_recording(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_stop_preview(cam_id))) {
-            goto end;
-        }
-        if (0!=(rc=mm_app_init_snapshot(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc=mm_app_take_picture(cam_id))) {
-            goto end;
-        }
-        if ( 0 != (rc = mm_app_deinit_snahspot(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_start_preview(cam_id))) {
-            goto end;
-        }
-        usleep(8000000);
-        if (0 != (rc=mm_app_deinit_preview(cam_id))) {
-            goto end;
-        }
-        if (0 != (rc = mm_app_close_preview(cam_id))) {
-            goto end;
-        }
-    }
-    if ( 0 != (rc = mm_app_close(cam_id))) {
-        CDBG("%s: close cam %d at opmode = %d err,loop=%d, rc=%d\n",
-             __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
-        goto end;
-    }
-end:
-#endif
-    CDBG("%s:END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_9(mm_camera_app_t *cam_apps) /*RDI snapshot*/
-{
-    int rc = MM_CAMERA_OK;
-    int i,j,k;
-    int result = 0;
-
-    printf("\n Verifying RDI Stream on front and back camera...\n");
-    if (cam_apps->num_cameras == 0) {
-        CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
-        rc = -1;
-        goto end;
-    }
-    CDBG_ERROR("SINGLE open RDI snapshot test case");
-    for (i = 1; i < cam_apps->num_cameras; i++) {
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        CDBG_ERROR("SINGLE start RDI case");
-        for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if ( MM_CAMERA_OK != (rc = startRdi(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-            usleep(10*1000);
-            CDBG_ERROR("SINGLE start RDI snapshot");
-            for (k = 0; k < MM_QCAMERA_APP_INTERATION; k++) {
-              if ( MM_CAMERA_OK != (rc = takePicture_rdi(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
-                break;
-              }
-              usleep(10*1000);
-              mm_camera_app_wait();
-              result++;
-            }
-            CDBG_ERROR("SINGLE stop RDI");
-            if ( MM_CAMERA_OK != (rc = stopRdi(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
-                break;
-            }
-        }
-        CDBG_ERROR("SINGLE close RDI");
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (result != (MM_QCAMERA_APP_INTERATION * MM_QCAMERA_APP_INTERATION)) {
-            printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-    end:
-    if (rc == 0) {
-        printf("\nPassed\n");
-    } else {
-        printf("\nFailed\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_tc_10(mm_camera_app_t *cam_apps)
-{
-    int rc = MM_CAMERA_OK;
-    int i,j;
-    int result = 0;
-
-    printf("\n Verifying RAW Snapshot on front and back camera...\n");
-    for (i = 0; i < cam_apps->num_cameras; i++) {
-        if ( mm_app_open(i) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-
-        if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
-            CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
-            if ( MM_CAMERA_OK != (rc = takePicture_raw(my_cam_app.cam_open))) {
-                CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
-                break;
-            }
-            /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
-                    CDBG_ERROR("%s: Snapshot/Preview Callback not received in time or qbuf Faile\n", __func__);
-                    break;
-            }*/
-            mm_camera_app_wait();
-            result++;
-        }
-        if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
-            CDBG("%s: startPreview() err=%d\n", __func__, rc);
-            break;
-        }
-        if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
-            CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
-            rc = -1;
-            goto end;
-        }
-        if (result != MM_QCAMERA_APP_INTERATION) {
-            printf("%s: Snapshot Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
-            rc = -1;
-            break;
-        }
-
-        result = 0;
-    }
-    end:
-    if (rc == 0) {
-        printf("\t***Passed***\n");
-    } else {
-        printf("\t***Failed***\n");
-    }
-    CDBG("%s:END, rc = %d\n", __func__, rc);
-    return rc;
-}
-
-int mm_app_gen_test_cases()
-{
-    int tc = 0;
-    memset(mm_app_tc, 0, sizeof(mm_app_tc));
-    if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_0;
-    if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_1;
-    if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_2;
-    //if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_3; /*Enable only when RDI enabled for front camera*/
-    //if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_4;
-    /*if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_5;
-      if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_6;
-      if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_7;
-      if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_8;*/
-    //if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_9;  /*Enable only when rdi enabled for front camera*/
-    if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_10;
-
-    /* test case for reprocess with preview only */
-    /*
-    if (tc < MM_QCAM_APP_TEST_NUM) {
-        mm_app_tc[tc++].f = mm_app_tc_reprocess_preview_only;
-    }
-    */
-    /* test case for reprocess with preview and recording */
-    /*
-    if (tc < MM_QCAM_APP_TEST_NUM) {
-        mm_app_tc[tc++].f = mm_app_tc_reprocess_preview_and_recording;
-    }
-    */
-
-    return tc;
-}
-
-int mm_app_unit_test_entry(mm_camera_app_t *cam_app)
-{
-    int rc = MM_CAMERA_OK;
-    int i, tc = 0;
-    int cam_id = 0;
-
-    tc = mm_app_gen_test_cases();
-    CDBG("Running %d test cases\n",tc);
-    for (i = 0; i < tc; i++) {
-        mm_app_tc[i].r = mm_app_tc[i].f(cam_app);
-        if (mm_app_tc[i].r != MM_CAMERA_OK) {
-            printf("%s: test case %d error = %d, abort unit testing engine!!!!\n",
-                   __func__, i, mm_app_tc[i].r);
-            rc = mm_app_tc[i].r;
-            goto end;
-        }
-    }
-    end:
-    printf("nTOTAL_TSET_CASE = %d, NUM_TEST_RAN = %d, rc=%d\n", tc, i, rc);
-    return rc;
-}
-
-
-
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_video.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_video.c
deleted file mode 100755
index f19b82e..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_video.c
+++ /dev/null
@@ -1,500 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include "mm_qcamera_app.h"
-
-#define BUFF_SIZE_128 128
-static int num_run = 0;
-
-extern int mm_app_set_live_snapshot_fmt(int cam_id,mm_camera_image_fmt_t *fmt);
-extern void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h,
-                            char* name, int main_422,char *ext);
-extern int initDisplay();
-extern int mm_app_prepare_preview(int cam_id);
-extern int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,
-                                   mm_camera_buf_def_t *frame);
-
-static int mm_app_dump_video_frame(struct msm_frame *frame,
-                                   uint32_t len)
-{
-    static int v_cnt = 0;
-    char bufp[BUFF_SIZE_128];
-    int file_fdp;
-    int rc = 0;
-
-    return rc; /* disable dump */
-
-    v_cnt++;
-    if(0 == (v_cnt % 10))
-        snprintf(bufp, BUFF_SIZE_128, "/data/v_%d.yuv", v_cnt);
-    else
-        return 0;
-
-    file_fdp = open(bufp, O_RDWR | O_CREAT, 0777);
-
-    if (file_fdp < 0) {
-        CDBG("cannot open file %s\n", bufp);
-        rc = -1;
-        goto end;
-    }
-    CDBG("%s:dump frame to '%s'\n", __func__, bufp);
-    write(file_fdp,
-        (const void *)frame->buffer, len);
-    close(file_fdp);
-end:
-    return rc;
-}
-
-static int mm_app_set_video_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
-    fmt->fmt = pme->dim.enc_format;
-    fmt->width = pme->dim.video_width;
-    fmt->height = pme->dim.video_height;
-    return rc;
-}
-
-#if 0
-int mm_stream_deinit_video_buf(uint32_t camera_handle,
-                      uint32_t ch_id, uint32_t stream_id,
-                      void *user_data, uint8_t num_bufs,
-                      mm_camera_buf_def_t *bufs)
-{
-    int i, rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-
-    for(i = 0; i < num_bufs; i++) {
-        rc = my_cam_app.hal_lib.mm_camera_do_munmap_ion (pme->ionfd, &(pme->video_buf.frame[i].fd_data),
-                   (void *)pme->video_buf.frame[i].buffer, pme->video_buf.frame_len);
-        if(rc != MM_CAMERA_OK) {
-          CDBG_ERROR("%s: mm_camera_do_munmap err, pmem_fd = %d, rc = %d",
-               __func__, bufs[i].fd, rc);
-        }
-    }
-    return rc;
-}
-
-int mm_stream_init_video_buf(uint32_t camera_handle,
-                      uint32_t ch_id, uint32_t stream_id,
-                      void *user_data,
-                      mm_camera_frame_len_offset *frame_offset_info,
-                      uint8_t num_bufs,
-                      uint8_t *initial_reg_flag,
-                      mm_camera_buf_def_t *bufs)
-{
-    int i,j,num_planes, frame_len, y_off, cbcr_off;
-    uint32_t planes[VIDEO_MAX_PLANES];
-    uint32_t pmem_addr = 0;
-
-    mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-
-    num_planes = frame_offset_info->num_planes;
-    for ( i = 0; i < num_planes; i++) {
-        planes[i] = frame_offset_info->mp[i].len;
-    }
-
-    frame_len = frame_offset_info->frame_len;
-    y_off = frame_offset_info->mp[0].offset;
-    cbcr_off = frame_offset_info->mp[1].offset;
-
-    CDBG("Allocating video Memory for %d buffers frame_len = %d",num_bufs,frame_offset_info->frame_len);
-
-    for (i = 0; i < num_bufs ; i++) {
-        int j;
-        pme->video_buf.reg[i] = 1;
-        initial_reg_flag[i] = 1;
-
-        pme->video_buf.frame_len = frame_len;
-        pme->video_buf.frame[i].ion_alloc.len = pme->video_buf.frame_len;
-        pme->video_buf.frame[i].ion_alloc.flags =
-            (0x1 << CAMERA_ION_HEAP_ID | 0x1 << ION_IOMMU_HEAP_ID);
-        pme->video_buf.frame[i].ion_alloc.align = 4096;
-
-        pmem_addr = (unsigned long) my_cam_app.hal_lib.mm_camera_do_mmap_ion(pme->ionfd,
-                       &(pme->video_buf.frame[i].ion_alloc), &(pme->video_buf.frame[i].fd_data),
-                       &pme->video_buf.frame[i].fd);
-
-        pme->video_buf.frame[i].buffer = pmem_addr;
-        pme->video_buf.frame[i].path = OUTPUT_TYPE_V;
-        pme->video_buf.frame[i].y_off = 0;
-        pme->video_buf.frame[i].cbcr_off = planes[0];
-        pme->video_buf.frame[i].phy_offset = 0;
-
-        CDBG("Buffer allocated Successfully fd = %d",pme->video_buf.frame[i].fd);
-
-        bufs[i].fd = pme->video_buf.frame[i].fd;
-        //bufs[i].buffer = pmem_addr;
-        bufs[i].frame_len = pme->video_buf.frame[i].ion_alloc.len;
-        bufs[i].num_planes = num_planes;
-
-        bufs[i].frame = &pme->video_buf.frame[i];
-
-        /* Plane 0 needs to be set seperately. Set other planes
-             * in a loop. */
-        bufs[i].planes[0].length = planes[0];
-        bufs[i].planes[0].m.userptr = bufs[i].fd;
-        bufs[i].planes[0].data_offset = y_off;
-        bufs[i].planes[0].reserved[0] = 0;
-              //buf_def->buf.mp[i].frame_offset;
-        for (j = 1; j < num_planes; j++) {
-             bufs[i].planes[j].length = planes[j];
-             bufs[i].planes[j].m.userptr = bufs[i].fd;
-             bufs[i].planes[j].data_offset = cbcr_off;
-             bufs[i].planes[j].reserved[0] =
-                 bufs[i].planes[j-1].reserved[0] +
-                 bufs[i].planes[j-1].length;
-        }
-    }
-    return MM_CAMERA_OK;
-}
-#endif
-
-void video_cb_signal(mm_camera_app_obj_t *pme)
-{
-    if(pme->cam_state == CAMERA_STATE_RECORD) {
-        mm_camera_app_done();
-    }
-}
-
-static void mm_app_video_notify_cb(mm_camera_super_buf_t *bufs,
-    void *user_data)
-{
-    int rc;
-    char buf[32];
-    mm_camera_buf_def_t *frame = NULL;
-    mm_camera_app_obj_t *pme = NULL;
-    CDBG("%s: BEGIN\n", __func__);
-    frame = bufs->bufs[MM_CAMERA_PREVIEW] ;
-    pme = (mm_camera_app_obj_t *)user_data;
-
-    CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-    //Need to code to Send to Encoder .. Simulat
-    CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_PREVIEW],frame);
-
-    snprintf(buf, sizeof(buf), "V_%dx%d_C%d", pme->dim.orig_video_width,
-        pme->dim.orig_video_height, pme->cam->camera_info->camera_id);
-
-    dumpFrameToFile(frame, pme->dim.orig_video_width,
-        pme->dim.orig_video_height, buf, 1,"yuv");
-
-    if(MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame))
-    {
-        CDBG_ERROR("%s: Failed in Snapshot Qbuf\n", __func__);
-        return;
-    }
-        mm_stream_invalid_cache(pme,frame);
-    video_cb_signal(pme);
-    CDBG("%s: END\n", __func__);
-
-}
-
-int mm_app_config_video(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    mm_app_set_video_fmt(cam_id,&pme->stream[MM_CAMERA_VIDEO].str_config.fmt);
-    pme->stream[MM_CAMERA_VIDEO].str_config.need_stream_on = 1;
-    pme->stream[MM_CAMERA_VIDEO].str_config.num_of_bufs = VIDEO_BUF_NUM;
-
-    if(MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_VIDEO].id,
-                                 &pme->stream[MM_CAMERA_VIDEO].str_config))) {
-        CDBG_ERROR("%s:MM_CAMERA_VIDEO config streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    CDBG("config_stream stream is successfull");
-
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.need_stream_on = pme->fullSizeSnapshot;
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.num_of_bufs = 1;
-
-    mm_app_set_live_snapshot_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.fmt);
-
-    if(MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
-                                 &pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config))) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        goto end;
-    }
-end:
-    return rc;
-
-}
-
-int mm_app_prepare_video(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    pme->stream[MM_CAMERA_VIDEO].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
-                                                       mm_app_video_notify_cb,pme,
-                                                       MM_CAMERA_VIDEO, 0);
-
-    if(!pme->stream[MM_CAMERA_VIDEO].id) {
-        CDBG("%s:MM_CAMERA_VIDEO streaming err = %d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-
-    CDBG("Add stream is successfull stream ID = %d",pme->stream[MM_CAMERA_PREVIEW].id);
-
-    /* Code to add live snapshot*/
-    pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
-                                                   NULL,pme,
-                                                   MM_CAMERA_SNAPSHOT_MAIN, 0);
-
-    CDBG("Add Snapshot main is successfull stream ID = %d",pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id);
-    if(!pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id) {
-        CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
-        rc = -1;
-        goto end;
-    }
-    /*if(mm_app_config_video(cam_id) != MM_CAMERA_OK)
-    {
-        CDBG_ERROR("%s:Video config err=%d\n", __func__, rc);
-    }*/
-end:
-    return rc;
-}
-
-int mm_app_unprepare_video(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if(MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_VIDEO].id))){
-        CDBG_ERROR("%s : Delete Stream Video error",__func__);
-        goto end;
-    }
-
-    if(MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id))){
-        CDBG_ERROR("%s : Delete Stream Video error",__func__);
-        goto end;
-    }
-end:
-    CDBG("del_stream successfull");
-    return rc;
-}
-
-static int mm_app_streamon_video(int cam_id)
-{
-    uint32_t stream;
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if(mm_app_config_video(cam_id) != MM_CAMERA_OK)
-    {
-        CDBG_ERROR("%s:Video config err=%d\n", __func__, rc);
-    }
-
-    stream = pme->stream[MM_CAMERA_VIDEO].id;
-    if(MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,&stream)))
-    {
-        CDBG_ERROR("%s : Start Stream video Error",__func__);
-        return -1;
-    }
-    CDBG("Start video stream is successfull");
-    pme->cam_state = CAMERA_STATE_RECORD;
-    return rc;
-}
-
-static int mm_app_streamoff_video(int cam_id)
-{
-    uint32_t stream;
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream = pme->stream[MM_CAMERA_VIDEO].id;
-
-    if(MM_CAMERA_OK != (rc =pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,&stream)))
-    {
-        CDBG_ERROR("%s : stop Stream video Error",__func__);
-        goto end;
-    }
-    CDBG("stop video stream is successfull");
-    pme->cam_state = CAMERA_STATE_PREVIEW;
-end:
-    return rc;
-
-}
-int mm_app_stop_video(int cam_id)
-{
-    int stream[2];
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    stream[0] = pme->stream[MM_CAMERA_VIDEO].id;
-
-    if(MM_CAMERA_OK != (rc = mm_app_streamoff_video(cam_id))){
-        CDBG_ERROR("%s : Video Stream off error",__func__);
-        goto end;
-    }
-end:
-    return rc;
-}
-
-static int mm_app_start_video(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("pme = %p, pme->cam =%p, pme->ch = %d pme->cam->camera_handle = %d",
-         pme,pme->cam,pme->ch_id,pme->cam->camera_handle);
-
-    if(MM_CAMERA_OK != (rc =  mm_app_prepare_video(cam_id))){
-        CDBG_ERROR("%s:MM_CAMERA_VIDEO streaming err = %d\n", __func__, rc);
-        goto end;
-    }
-    if(MM_CAMERA_OK != (rc =  mm_app_streamon_video(cam_id))){
-        CDBG_ERROR("%s:MM_CAMERA_VIDEO streaming err = %d\n", __func__, rc);
-        goto end;
-    }
-
-end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-
-    return rc;
-}
-
-int mm_app_open_recorder(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-    int value = 1;
-    int powermode = 1;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: mm_app_open_recorder",__func__);
-    if(pme->cam_mode == RECORDER_MODE) {
-        CDBG("%s : Already in record mode",__func__);
-        return rc;
-    }
-
-    if(MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))){
-        CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
-        goto end;
-    }
-    usleep(10*1000);
-
-    if(MM_CAMERA_OK != initDisplay())
-    {
-        CDBG_ERROR("%s : Could not initalize display",__func__);
-        goto end;
-    }
-
-    pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_RECORDING_HINT, &value);
-
-    pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_LOW_POWER_MODE, &powermode);
-
-
-    if(MM_CAMERA_OK != (rc = mm_app_prepare_preview(cam_id))){
-        CDBG_ERROR("%s:stream on preview err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if(MM_CAMERA_OK != (rc = mm_app_prepare_video(cam_id))){
-        CDBG_ERROR("%s:stream on video err=%d\n", __func__, rc);
-        goto end;
-    }
-
-    if(MM_CAMERA_OK != (rc = mm_app_streamon_preview(cam_id))){
-        CDBG_ERROR("%s:start preview err=%d\n", __func__, rc);
-        goto end;
-    }
-    pme->cam_mode = RECORDER_MODE;
-end:
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int startRecording(int cam_id)
-{
-    int rc = MM_CAMERA_OK;
-
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    CDBG("%s: Start Recording mode = %d state = %d",__func__,pme->cam_mode,pme->cam_state);
-
-    if(pme->cam_mode == CAMERA_MODE || pme->cam_mode == ZSL_MODE) {
-        switch(pme->cam_state) {
-            case CAMERA_STATE_PREVIEW:
-                if(MM_CAMERA_OK != mm_app_open_recorder(cam_id)){
-                    CDBG_ERROR("%s: Open Record Failed \n", __func__);
-                    return -1;
-                }
-                break;
-            case CAMERA_STATE_RECORD:
-            case CAMERA_STATE_SNAPSHOT:
-            default:
-                break;
-        }
-    }/*else{
-        mm_app_prepare_video(cam_id);
-    }*/
-    CDBG("%s : startRecording : mode = %d state = %d",__func__,pme->cam_mode,pme->cam_state);
-    if(pme->cam_mode == RECORDER_MODE && pme->cam_state == CAMERA_STATE_PREVIEW){
-        if(MM_CAMERA_OK != mm_app_streamon_video(cam_id)){
-            CDBG_ERROR("%s:start video err=%d\n", __func__, rc);
-            return -1;
-        }
-    }
-    CDBG("%s: END, rc=%d\n", __func__, rc);
-    return rc;
-}
-
-int stopRecording(int cam_id)
-{
-
-    int rc = MM_CAMERA_OK;
-    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
-    if(pme->cam_mode != RECORDER_MODE || pme->cam_state != CAMERA_STATE_RECORD) {
-        return rc;
-    }
-    if(MM_CAMERA_OK != mm_app_stop_video(cam_id)){
-        CDBG_ERROR("%s:stop video err=%d\n", __func__, rc);
-        return -1;
-    }
-    return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-jpeg-interface/Android.mk b/camera/QCamera/stack/mm-jpeg-interface/Android.mk
deleted file mode 100755
index c7d151c..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/Android.mk
+++ /dev/null
@@ -1,38 +0,0 @@
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_CFLAGS+= -D_ANDROID_
-LOCAL_COPY_HEADERS_TO := mm-camera-interface
-LOCAL_COPY_HEADERS = inc/mm_jpeg_interface.h
-
-LOCAL_C_INCLUDES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/media
-LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
-
-LOCAL_C_INCLUDES += \
-    $(LOCAL_PATH)/inc \
-    $(LOCAL_PATH)/../common \
-    $(LOCAL_PATH)/../../../ \
-    $(TARGET_OUT_HEADERS)/mm-still \
-    $(TARGET_OUT_HEADERS)/mm-still/jpeg \
-    $(TARGET_OUT_HEADERS)/mm-core/omxcore \
-    $(TARGET_OUT_HEADERS)/mm-still/mm-omx
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
-    LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_SRC_FILES := \
-    src/mm_jpeg_queue.c \
-    src/mm_jpeg.c \
-    src/mm_jpeg_interface.c
-
-LOCAL_MODULE           := libmmjpeg_interface
-LOCAL_PRELINK_MODULE   := false
-LOCAL_SHARED_LIBRARIES := libdl libcutils liblog libmmstillomx libimage-jpeg-enc-omx-comp
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_SHARED_LIBRARY)
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
diff --git a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg.h b/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg.h
deleted file mode 100755
index be08427..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg.h
+++ /dev/null
@@ -1,168 +0,0 @@
-
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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 MM_JPEG_H_
-#define MM_JPEG_H_
-
-#include "mm_jpeg_interface.h"
-#include "cam_list.h"
-#include "OMX_Types.h"
-#include "OMX_Index.h"
-#include "OMX_Core.h"
-#include "OMX_Component.h"
-#include "omx_jpeg_ext.h"
-#include <semaphore.h>
-
-typedef struct {
-    struct cam_list list;
-    void* data;
-} mm_jpeg_q_node_t;
-
-typedef struct {
-    mm_jpeg_q_node_t head; /* dummy head */
-    uint32_t size;
-    pthread_mutex_t lock;
-} mm_jpeg_queue_t;
-
-typedef enum
-{
-    MM_JPEG_CMD_TYPE_JOB,          /* job cmd */
-    MM_JPEG_CMD_TYPE_EXIT,         /* EXIT cmd for exiting jobMgr thread */
-    MM_JPEG_CMD_TYPE_MAX
-} mm_jpeg_cmd_type_t;
-
-typedef struct {
-    OMX_BUFFERHEADERTYPE* buf_header;
-    uint32_t portIdx;
-} mm_jpeg_omx_buf_info;
-
-typedef struct {
-    uint8_t num_bufs;
-    mm_jpeg_omx_buf_info bufs[MAX_SRC_BUF_NUM];
-} mm_jpeg_omx_src_buf;
-
-typedef struct {
-    uint32_t client_hdl;           /* client handler */
-    uint32_t jobId;                /* job ID */
-    mm_jpeg_job job;               /* job description */
-    pthread_t cb_pid;              /* cb thread heandler*/
-
-    void* jpeg_obj;                /* ptr to mm_jpeg_obj */
-    jpeg_job_status_t job_status;  /* job status */
-    uint8_t thumbnail_dropped;     /* flag indicating if thumbnail is dropped */
-    int32_t jpeg_size;             /* the size of jpeg output after job is done */
-
-    mm_jpeg_omx_src_buf src_bufs[JPEG_SRC_IMAGE_TYPE_MAX];
-    mm_jpeg_omx_buf_info sink_buf;
-} mm_jpeg_job_entry;
-
-typedef struct {
-    mm_jpeg_cmd_type_t type;
-    union {
-        mm_jpeg_job_entry  entry;
-    };
-} mm_jpeg_job_q_node_t;
-
-typedef struct {
-    uint8_t is_used;                /* flag: if is a valid client */
-    uint32_t client_handle;         /* client handle */
-} mm_jpeg_client_t;
-
-typedef struct {
-    pthread_t pid;                  /* job cmd thread ID */
-    sem_t job_sem;                  /* semaphore for job cmd thread */
-    mm_jpeg_queue_t job_queue;      /* queue for job to do */
-} mm_jpeg_job_cmd_thread_t;
-
-typedef enum {
-    MM_JPEG_EVENT_MASK_JPEG_DONE    = 0x00000001, /* jpeg job is done */
-    MM_JPEG_EVENT_MASK_JPEG_ABORT   = 0x00000002, /* jpeg job is aborted */
-    MM_JPEG_EVENT_MASK_JPEG_ERROR   = 0x00000004, /* jpeg job has error */
-    MM_JPEG_EVENT_MASK_CMD_COMPLETE = 0x00000100  /* omx cmd complete evt */
-} mm_jpeg_event_mask_t;
-
-typedef struct {
-    uint32_t evt;
-    int omx_value1;  /* only valid when evt_mask == MM_JPEG_EVENT_MASK_CMD_COMPLETE */
-    int omx_value2;  /* only valid when evt_mask == MM_JPEG_EVENT_MASK_CMD_COMPLETE */
-} mm_jpeg_evt_t;
-
-#define MAX_JPEG_CLIENT_NUM 8
-typedef struct mm_jpeg_obj_t {
-    /* ClientMgr */
-    int num_clients;                                /* num of clients */
-    mm_jpeg_client_t clnt_mgr[MAX_JPEG_CLIENT_NUM]; /* client manager */
-
-    /* JobMkr */
-    pthread_mutex_t job_lock;                       /* job lock */
-    mm_jpeg_job_cmd_thread_t job_mgr;               /* job mgr thread including todo_q*/
-    mm_jpeg_queue_t ongoing_job_q;                  /* queue for ongoing jobs */
-
-    /* Notifier */
-    mm_jpeg_queue_t cb_q;                           /* queue for CB threads */
-
-    /* OMX related */
-    OMX_HANDLETYPE omx_handle;                      /* handle to omx engine */
-    OMX_CALLBACKTYPE omx_callbacks;                 /* callbacks to omx engine */
-
-    pthread_mutex_t omx_evt_lock;
-    pthread_cond_t omx_evt_cond;
-    mm_jpeg_evt_t omx_evt_rcvd;
-} mm_jpeg_obj;
-
-extern int32_t mm_jpeg_init(mm_jpeg_obj *my_obj);
-extern int32_t mm_jpeg_deinit(mm_jpeg_obj *my_obj);
-extern uint32_t mm_jpeg_new_client(mm_jpeg_obj *my_obj);
-extern int32_t mm_jpeg_start_job(mm_jpeg_obj *my_obj,
-                                 uint32_t client_hdl,
-                                 mm_jpeg_job* job,
-                                 uint32_t* jobId);
-extern int32_t mm_jpeg_abort_job(mm_jpeg_obj *my_obj,
-                                 uint32_t client_hdl,
-                                 uint32_t jobId);
-extern int32_t mm_jpeg_close(mm_jpeg_obj *my_obj,
-                             uint32_t client_hdl);
-
-/* utiltity fucntion declared in mm-camera-inteface2.c
- * and need be used by mm-camera and below*/
-uint32_t mm_jpeg_util_generate_handler(uint8_t index);
-uint8_t mm_jpeg_util_get_index_by_handler(uint32_t handler);
-
-/* basic queue functions */
-extern int32_t mm_jpeg_queue_init(mm_jpeg_queue_t* queue);
-extern int32_t mm_jpeg_queue_enq(mm_jpeg_queue_t* queue, void* node);
-extern void* mm_jpeg_queue_peek(mm_jpeg_queue_t* queue);
-extern void* mm_jpeg_queue_deq(mm_jpeg_queue_t* queue);
-extern int32_t mm_jpeg_queue_deinit(mm_jpeg_queue_t* queue);
-extern int32_t mm_jpeg_queue_flush(mm_jpeg_queue_t* queue);
-extern uint32_t mm_jpeg_queue_get_size(mm_jpeg_queue_t* queue);
-
-#endif /* MM_JPEG_H_ */
-
-
diff --git a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h b/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h
deleted file mode 100755
index 775d32a..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 __MM_JPEG_DBG_H__
-#define __MM_JPEG_DBG_H__
-
-//#define LOG_DEBUG 0
-
-#ifndef LOG_DEBUG
-  #ifdef _ANDROID_
-    #undef LOG_NIDEBUG
-    #undef LOG_TAG
-    #define LOG_NIDEBUG 0
-    #define LOG_TAG "mm-jpeg-intf"
-    #include <utils/Log.h>
-  #else
-    #include <stdio.h>
-    #define ALOGE CDBG
-  #endif
-  #undef CDBG
-  #define CDBG(fmt, args...) do{}while(0)
-#else
-  #ifdef _ANDROID_
-    #undef LOG_NIDEBUG
-    #undef LOG_TAG
-    #define LOG_NIDEBUG 0
-    #define LOG_TAG "mm-jpeg-intf"
-    #include <utils/Log.h>
-    #define CDBG(fmt, args...) ALOGE(fmt, ##args)
-  #else
-    #include <stdio.h>
-    #define CDBG(fmt, args...) fprintf(stderr, fmt, ##args)
-    #define ALOGE(fmt, args...) fprintf(stderr, fmt, ##args)
-  #endif
-#endif
-
-#ifdef _ANDROID_
-  #define CDBG_HIGH(fmt, args...)  ALOGE(fmt, ##args)
-  #define CDBG_ERROR(fmt, args...)  ALOGE(fmt, ##args)
-#else
-  #define CDBG_HIGH(fmt, args...) fprintf(stderr, fmt, ##args)
-  #define CDBG_ERROR(fmt, args...) fprintf(stderr, fmt, ##args)
-#endif
-#endif /* __MM_JPEG_DBG_H__ */
diff --git a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_interface.h b/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_interface.h
deleted file mode 100755
index cd1c9c8..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_interface.h
+++ /dev/null
@@ -1,217 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED

- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT

- * 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 MM_JPEG_INTERFACE_H_

-#define MM_JPEG_INTERFACE_H_

-#include "QCamera_Intf.h"

-

-typedef struct {

-    int width;

-    int height;

-} image_resolution;

-

-typedef enum {

-    JPEG_SRC_IMAGE_FMT_YUV,

-    JPEG_SRC_IMAGE_FMT_BITSTREAM

-} jpeg_enc_src_img_fmt_t;

-

-typedef enum {

-    JPEG_SRC_IMAGE_TYPE_MAIN,

-    JPEG_SRC_IMAGE_TYPE_THUMB,

-    JPEG_SRC_IMAGE_TYPE_MAX

-} jpeg_enc_src_img_type_t;

-

-typedef struct  {

-    int32_t offset_x;

-    int32_t offset_y;

-    int32_t width;

-    int32_t height;

-} image_crop_t;

-

-typedef struct {

-    uint8_t sequence;                /*for jpeg bit streams, assembling is based on sequence. sequence starts from 0*/

-    uint8_t *buf_vaddr;              /*ptr to buf*/

-    int fd;                          /*fd of buf*/

-    uint32_t buf_size;               /* total size of buf (header + image) */

-    uint32_t data_offset;            /*data offset*/

-} src_bitstream_buffer_t;

-

-typedef struct {

-    uint8_t *buf_vaddr;              /*ptr to buf*/

-    int fd;                          /*fd of buf*/

-    cam_frame_len_offset_t offset;   /*alway use multi-planar, offset is used to skip the metadata header*/

-} src_image_buffer_t;

-

-typedef enum {

-    MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2,

-    MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2,

-    MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1,

-    MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1,

-    MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2,

-    MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2,

-    MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1,

-    MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1,

-    MM_JPEG_COLOR_FORMAT_RGB565,

-    MM_JPEG_COLOR_FORMAT_RGB888,

-    MM_JPEG_COLOR_FORMAT_RGBa,

-    MM_JPEG_COLOR_FORMAT_BITSTREAM,

-    MM_JPEG_COLOR_FORMAT_MAX

-} mm_jpeg_color_format;

-

-#define MAX_SRC_BUF_NUM 2

-typedef struct {

-    /* src img format: YUV, Bitstream */

-    jpeg_enc_src_img_fmt_t img_fmt;

-

-	/* num of buf in src img */

-    uint8_t num_bufs;

-

-	/* src img bufs */

-    union {

-        src_bitstream_buffer_t bit_stream[MAX_SRC_BUF_NUM];

-        src_image_buffer_t src_image[MAX_SRC_BUF_NUM];

-    };

-

-    /* src img type: main or thumbnail */

-    jpeg_enc_src_img_type_t type;

-

-    /* color format */

-    mm_jpeg_color_format color_format;

-

-    /* src img dimension */

-    image_resolution src_dim;

-

-    /* jpeg output dimension */

-    image_resolution out_dim;

-

-    /* crop information */

-    image_crop_t crop;

-

-    /* jpeg quality: range 0~100 */

-    uint32_t quality;

-} src_image_buffer_info;

-

-typedef struct {

-  uint8_t *buf_vaddr;              /*ptr to buf*/

-  int fd;                          /*fd of buf*/

-  int buf_len;

-} out_image_buffer_info;

-

-typedef struct {

-    /* num of src imgs: e.g. main/thumbnail img

-     * if main img only: src_img_num = 1;

-     * if main+thumbnail: src_img_num = 2;

-     * No support for thumbnail only case */

-    uint8_t src_img_num;

-

-    /* index 0 is always for main image

-     * if thumbnail presented, it will be in index 1 */

-    src_image_buffer_info src_img[JPEG_SRC_IMAGE_TYPE_MAX];

-

-    /* flag indicating if buffer is from video stream (special case for video-sized live snapshot) */

-    uint8_t is_video_frame;

-} src_image_buffer_config;

-

-typedef struct {

-    src_image_buffer_config src_imgs;

-    out_image_buffer_info sink_img;

-} jpeg_image_buffer_config;

-

-typedef struct {

-    /* config for scr images */

-    jpeg_image_buffer_config buf_info;

-

-    /* rotation informaiton */

-    int rotation;

-

-    /* num of exif entries */

-    int exif_numEntries;

-

-    /* buf to exif entries, caller needs to

-     * take care of the memory manage with insider ptr */

-    exif_tags_info_t *exif_data;

-

-    /*for mobicat support*/

-    const uint8_t * mobicat_data;

-    int32_t mobicat_data_length;

-    int hasmobicat;

-} mm_jpeg_encode_params;

-

-typedef enum {

-  JPEG_JOB_STATUS_DONE = 0,

-  JPEG_JOB_STATUS_ERROR

-} jpeg_job_status_t;

-

-typedef void (*jpeg_encode_callback_t)(jpeg_job_status_t status,

-                                       uint8_t thumbnailDroppedFlag,

-                                       uint32_t client_hdl,

-                                       uint32_t jobId,

-                                       uint8_t* out_data,

-                                       uint32_t data_size,

-                                       void *userData);

-

-typedef struct {

-    mm_jpeg_encode_params encode_parm;

-    jpeg_encode_callback_t jpeg_cb;

-    void* userdata;

-} mm_jpeg_encode_job;

-

-typedef enum {

-    JPEG_JOB_TYPE_ENCODE,

-    //JPEG_JOB_TYPE_DECODE, /*enable decode later*/

-    JPEG_JOB_TYPE_MAX

-} mm_jpeg_job_type_t;

-

-typedef struct {

-    mm_jpeg_job_type_t job_type;

-    union {

-        mm_jpeg_encode_job encode_job;

-    };

-} mm_jpeg_job;

-

-typedef struct {

-    /* start a job -- async call

-     * the result of job (DONE/ERROR) will rcvd through CB */

-    int32_t (* start_job) (uint32_t client_hdl, mm_jpeg_job* job, uint32_t* jobId);

-

-    /* abort a job -- sync call */

-    int32_t  (* abort_job) (uint32_t client_hdl, uint32_t jobId);

-

-    /* close a jpeg client -- sync call */

-    int32_t  (* close) (uint32_t clientHdl);

-} mm_jpeg_ops_t;

-

-/* open a jpeg client -- sync call

- * returns client_handle.

- * failed if client_handle=0

- * jpeg ops tbl will be filled in if open succeeds */

-uint32_t jpeg_open(mm_jpeg_ops_t *ops);

-

-#endif /* MM_JPEG_INTERFACE_H_ */

-

-

diff --git a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg.c b/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg.c
deleted file mode 100755
index 442ecb9..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg.c
+++ /dev/null
@@ -1,1417 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <semaphore.h>
-
-#include "mm_jpeg_dbg.h"
-#include "mm_jpeg_interface.h"
-#include "mm_jpeg.h"
-
-/* define max num of supported concurrent jpeg jobs by OMX engine.
- * Current, only one per time */
-#define NUM_MAX_JPEG_CNCURRENT_JOBS 1
-
-#define INPUT_PORT_MAIN         0
-#define INPUT_PORT_THUMBNAIL    2
-#define OUTPUT_PORT             1
-
-void mm_jpeg_job_wait_for_event(mm_jpeg_obj *my_obj, uint32_t evt_mask);
-void mm_jpeg_job_wait_for_cmd_complete(mm_jpeg_obj *my_obj,
-                                       int cmd,
-                                       int status);
-OMX_ERRORTYPE mm_jpeg_etbdone(OMX_HANDLETYPE hComponent,
-                              OMX_PTR pAppData,
-                              OMX_BUFFERHEADERTYPE* pBuffer);
-OMX_ERRORTYPE mm_jpeg_ftbdone(OMX_HANDLETYPE hComponent,
-                              OMX_PTR pAppData,
-                              OMX_BUFFERHEADERTYPE* pBuffer);
-OMX_ERRORTYPE mm_jpeg_handle_omx_event(OMX_HANDLETYPE hComponent,
-                                       OMX_PTR pAppData,
-                                       OMX_EVENTTYPE eEvent,
-                                       OMX_U32 nData1,
-                                       OMX_U32 nData2,
-                                       OMX_PTR pEventData);
-/* special queue functions for job queue */
-int32_t mm_jpeg_queue_update_flag(mm_jpeg_queue_t* queue, uint32_t job_id, uint8_t flag);
-mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_client_id(mm_jpeg_queue_t* queue, uint32_t client_hdl);
-mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_job_id(mm_jpeg_queue_t* queue, uint32_t job_id);
-
-static OMX_INDEXTYPE mobicat_data;
-static omx_jpeg_mobicat mobicat_d;
-
-int32_t mm_jpeg_omx_load(mm_jpeg_obj* my_obj)
-{
-    int32_t rc = 0;
-
-    my_obj->omx_callbacks.EmptyBufferDone = mm_jpeg_etbdone;
-    my_obj->omx_callbacks.FillBufferDone = mm_jpeg_ftbdone;
-    my_obj->omx_callbacks.EventHandler = mm_jpeg_handle_omx_event;
-    rc = OMX_GetHandle(&my_obj->omx_handle,
-                       "OMX.qcom.image.jpeg.encoder",
-                       (void*)my_obj,
-                       &my_obj->omx_callbacks);
-
-    if (0 != rc) {
-        CDBG_ERROR("%s : OMX_GetHandle failed (%d)",__func__, rc);
-        return rc;
-    }
-
-    rc = OMX_Init();
-    if (0 != rc) {
-        CDBG_ERROR("%s : OMX_Init failed (%d)",__func__, rc);
-    }
-
-    return rc;
-}
-
-int32_t mm_jpeg_omx_unload(mm_jpeg_obj *my_obj)
-{
-    int32_t rc = 0;
-    rc = OMX_Deinit();
-    return rc;
-}
-
-int32_t mm_jpeg_clean_omx_job(mm_jpeg_obj *my_obj, mm_jpeg_job_entry* job_entry)
-{
-    int32_t rc = 0;
-    uint8_t i, j;
-
-    OMX_SendCommand(my_obj->omx_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
-    OMX_SendCommand(my_obj->omx_handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
-
-    /* free buffers used in OMX processing */
-    for (i = 0; i < JPEG_SRC_IMAGE_TYPE_MAX; i++) {
-        for (j = 0; j < job_entry->src_bufs[i].num_bufs; j++) {
-            if (NULL != job_entry->src_bufs[i].bufs[j].buf_header) {
-                OMX_FreeBuffer(my_obj->omx_handle,
-                               job_entry->src_bufs[i].bufs[j].portIdx,
-                               job_entry->src_bufs[i].bufs[j].buf_header);
-            }
-        }
-    }
-    OMX_FreeBuffer(my_obj->omx_handle,
-                   job_entry->sink_buf.portIdx,
-                   job_entry->sink_buf.buf_header);
-
-    return rc;
-}
-
-int32_t mm_jpeg_omx_abort_job(mm_jpeg_obj *my_obj, mm_jpeg_job_entry* job_entry)
-{
-    int32_t rc = 0;
-
-    OMX_SendCommand(my_obj->omx_handle, OMX_CommandFlush, 0, NULL);
-    mm_jpeg_job_wait_for_event(my_obj,
-        MM_JPEG_EVENT_MASK_JPEG_DONE|MM_JPEG_EVENT_MASK_JPEG_ABORT|MM_JPEG_EVENT_MASK_JPEG_ERROR);
-    CDBG("%s:waitForEvent: OMX_CommandFlush: DONE", __func__);
-
-    /* clean omx job */
-    mm_jpeg_clean_omx_job(my_obj, job_entry);
-
-    return rc;
-}
-
-/* TODO: needs revisit after omx lib supports multi src buffers */
-int32_t mm_jpeg_omx_config_main_buffer_offset(mm_jpeg_obj* my_obj,
-                                              src_image_buffer_info *src_buf,
-                                              uint8_t is_video_frame)
-{
-    int32_t rc = 0;
-    uint8_t i;
-    OMX_INDEXTYPE buf_offset_idx;
-    omx_jpeg_buffer_offset buffer_offset;
-
-    for (i = 0; i < src_buf->num_bufs; i++) {
-        OMX_GetExtensionIndex(my_obj->omx_handle,
-                              "omx.qcom.jpeg.exttype.buffer_offset",
-                              &buf_offset_idx);
-        memset(&buffer_offset, 0, sizeof(buffer_offset));
-
-        switch (src_buf->img_fmt) {
-        case JPEG_SRC_IMAGE_FMT_YUV:
-            if (1 == src_buf->src_image[i].offset.num_planes) {
-                buffer_offset.yOffset =
-                    src_buf->src_image[i].offset.sp.y_offset;
-                buffer_offset.cbcrOffset =
-                    src_buf->src_image[i].offset.sp.cbcr_offset;
-                buffer_offset.totalSize =
-                    src_buf->src_image[i].offset.sp.len;
-            } else {
-                buffer_offset.yOffset =
-                    src_buf->src_image[i].offset.mp[0].offset;
-                buffer_offset.cbcrOffset =
-                    src_buf->src_image[i].offset.mp[1].offset;
-                buffer_offset.totalSize =
-                    src_buf->src_image[i].offset.frame_len;
-            }
-            CDBG("%s: idx=%d, yOffset =%d, cbcrOffset =%d, totalSize = %d\n",
-                 __func__, i, buffer_offset.yOffset, buffer_offset.cbcrOffset, buffer_offset.totalSize);
-            OMX_SetParameter(my_obj->omx_handle, buf_offset_idx, &buffer_offset);
-
-            /* set acbcr (special case for video-sized live snapshot)*/
-            if (is_video_frame) {
-                CDBG("Using acbcroffset\n");
-                memset(&buffer_offset, 0, sizeof(buffer_offset));
-                buffer_offset.cbcrOffset = src_buf->src_image[i].offset.mp[0].offset +
-                                          src_buf->src_image[i].offset.mp[0].len +
-                                          src_buf->src_image[i].offset.mp[1].offset;;
-                OMX_GetExtensionIndex(my_obj->omx_handle,"omx.qcom.jpeg.exttype.acbcr_offset",&buf_offset_idx);
-                OMX_SetParameter(my_obj->omx_handle, buf_offset_idx, &buffer_offset);
-            }
-            break;
-        case JPEG_SRC_IMAGE_FMT_BITSTREAM:
-            /* TODO: need visit here when bit stream is supported */
-            buffer_offset.yOffset =
-                src_buf->bit_stream[i].data_offset;
-            buffer_offset.totalSize =
-                src_buf->bit_stream[i].buf_size;
-            CDBG("%s: idx=%d, yOffset =%d, cbcrOffset =%d, totalSize = %d\n",
-                 __func__, i, buffer_offset.yOffset, buffer_offset.cbcrOffset, buffer_offset.totalSize);
-            OMX_SetParameter(my_obj->omx_handle, buf_offset_idx, &buffer_offset);
-            break;
-        default:
-            break;
-        }
-    }
-
-    return rc;
-}
-
-/* TODO: needs revisit after omx lib supports multi src buffers */
-int32_t mm_jpeg_omx_config_port(mm_jpeg_obj* my_obj, src_image_buffer_info *src_buf, int port_idx)
-{
-    int32_t rc = 0;
-    uint8_t i;
-    OMX_PARAM_PORTDEFINITIONTYPE input_port;
-
-    for (i = 0; i < src_buf->num_bufs; i++) {
-        memset(&input_port, 0, sizeof(input_port));
-        input_port.nPortIndex = port_idx;
-        OMX_GetParameter(my_obj->omx_handle, OMX_IndexParamPortDefinition, &input_port);
-        input_port.format.image.nFrameWidth = src_buf->src_dim.width;
-        input_port.format.image.nFrameHeight =src_buf->src_dim.height;
-        input_port.format.image.nStride = src_buf->src_dim.width;
-        input_port.format.image.nSliceHeight = src_buf->src_dim.height;
-        switch (src_buf->img_fmt) {
-        case JPEG_SRC_IMAGE_FMT_YUV:
-            input_port.nBufferSize = src_buf->src_image[i].offset.frame_len;
-            break;
-        case JPEG_SRC_IMAGE_FMT_BITSTREAM:
-            input_port.nBufferSize = src_buf->bit_stream[i].buf_size;
-            break;
-        }
-
-        CDBG("%s: port_idx=%d, width =%d, height =%d, stride = %d, slice = %d, bufsize = %d\n",
-             __func__, port_idx,
-             input_port.format.image.nFrameWidth, input_port.format.image.nFrameHeight,
-             input_port.format.image.nStride, input_port.format.image.nSliceHeight,
-             input_port.nBufferSize);
-        OMX_SetParameter(my_obj->omx_handle, OMX_IndexParamPortDefinition, &input_port);
-    }
-
-    return rc;
-}
-
-omx_jpeg_color_format map_jpeg_format(mm_jpeg_color_format color_fmt)
-{
-    switch (color_fmt) {
-    case MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2:
-        return OMX_YCRCBLP_H2V2;
-    case MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2:
-        return OMX_YCBCRLP_H2V2;
-    case MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1:
-        return OMX_YCRCBLP_H2V1;
-    case MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1:
-        return OMX_YCBCRLP_H2V1;
-    case MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2:
-        return OMX_YCRCBLP_H1V2;
-    case MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2:
-        return OMX_YCBCRLP_H1V2;
-    case MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1:
-        return OMX_YCRCBLP_H1V1;
-    case MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1:
-        return OMX_YCBCRLP_H1V1;
-    case MM_JPEG_COLOR_FORMAT_RGB565:
-        return OMX_RGB565;
-    case MM_JPEG_COLOR_FORMAT_RGB888:
-        return OMX_RGB888;
-    case MM_JPEG_COLOR_FORMAT_RGBa:
-        return OMX_RGBa;
-    case MM_JPEG_COLOR_FORMAT_BITSTREAM:
-        /* TODO: need to change to new bitstream value once omx interface changes */
-        return OMX_JPEG_BITSTREAM_H2V2;
-    default:
-        return OMX_JPEG_COLOR_FORMAT_MAX;
-    }
-}
-
-int32_t mm_jpeg_omx_config_user_preference(mm_jpeg_obj* my_obj, mm_jpeg_encode_job* job)
-{
-    int32_t rc = 0;
-    OMX_INDEXTYPE user_pref_idx;
-    omx_jpeg_user_preferences user_preferences;
-
-    memset(&user_preferences, 0, sizeof(user_preferences));
-    user_preferences.color_format =
-        map_jpeg_format(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN].color_format);
-    if (job->encode_parm.buf_info.src_imgs.src_img_num > 1) {
-        user_preferences.thumbnail_color_format =
-            map_jpeg_format(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB].color_format);
-    }
-    OMX_GetExtensionIndex(my_obj->omx_handle,
-                          "omx.qcom.jpeg.exttype.user_preferences",
-                          &user_pref_idx);
-    CDBG("%s:User Preferences: color_format %d, thumbnail_color_format = %d",
-         __func__, user_preferences.color_format, user_preferences.thumbnail_color_format);
-
-    if (job->encode_parm.buf_info.src_imgs.is_video_frame != 0) {
-        user_preferences.preference = OMX_JPEG_PREF_SOFTWARE_ONLY;
-    } else {
-        user_preferences.preference = OMX_JPEG_PREF_HW_ACCELERATED_PREFERRED;
-    }
-
-    OMX_SetParameter(my_obj->omx_handle, user_pref_idx, &user_preferences);
-    return rc;
-}
-
-int32_t mm_jpeg_omx_config_thumbnail(mm_jpeg_obj* my_obj, mm_jpeg_encode_job* job)
-{
-    int32_t rc = -1;
-    OMX_INDEXTYPE thumb_idx, q_idx;
-    omx_jpeg_thumbnail thumbnail;
-    omx_jpeg_thumbnail_quality quality;
-
-    if (job->encode_parm.buf_info.src_imgs.src_img_num < 2) {
-        /*No thumbnail is required*/
-        return 0;
-    }
-    src_image_buffer_info *src_buf =
-        &(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB]);
-
-    /* config port */
-    CDBG("%s: config port", __func__);
-    rc = mm_jpeg_omx_config_port(my_obj, src_buf, INPUT_PORT_THUMBNAIL);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config port failed", __func__);
-        return rc;
-    }
-
-    if ((src_buf->crop.width == 0) || (src_buf->crop.height == 0)) {
-        src_buf->crop.width = src_buf->src_dim.width;
-        src_buf->crop.height = src_buf->src_dim.height;
-    }
-
-    /* check crop boundary */
-    if ((src_buf->crop.width + src_buf->crop.offset_x > src_buf->src_dim.width) ||
-        (src_buf->crop.height + src_buf->crop.offset_y > src_buf->src_dim.height)) {
-        CDBG_ERROR("%s: invalid crop boundary (%d, %d) offset (%d, %d) out of (%d, %d)",
-                   __func__,
-                   src_buf->crop.width,
-                   src_buf->crop.height,
-                   src_buf->crop.offset_x,
-                   src_buf->crop.offset_y,
-                   src_buf->src_dim.width,
-                   src_buf->src_dim.height);
-        return -1;
-    }
-
-    memset(&thumbnail, 0, sizeof(thumbnail));
-
-    /* thumbnail crop info */
-    thumbnail.cropWidth = CEILING2(src_buf->crop.width);
-    thumbnail.cropHeight = CEILING2(src_buf->crop.height);
-    thumbnail.left = src_buf->crop.offset_x;
-    thumbnail.top = src_buf->crop.offset_y;
-
-    /* thumbnail output dimention */
-    thumbnail.width = src_buf->out_dim.width;
-    thumbnail.height = src_buf->out_dim.height;
-
-    /* set scaling flag */
-    if (thumbnail.left > 0 || thumbnail.top > 0 ||
-        src_buf->crop.width != src_buf->src_dim.width ||
-        src_buf->crop.height != src_buf->src_dim.height ||
-        src_buf->src_dim.width != src_buf->out_dim.width ||
-        src_buf->src_dim.height != src_buf->out_dim.height) {
-        thumbnail.scaling = 1;
-    }
-
-    /* set omx thumbnail info */
-    OMX_GetExtensionIndex(my_obj->omx_handle, "omx.qcom.jpeg.exttype.thumbnail", &thumb_idx);
-    OMX_SetParameter(my_obj->omx_handle, thumb_idx, &thumbnail);
-    CDBG("%s: set thumbnail info: crop_w=%d, crop_h=%d, l=%d, t=%d, w=%d, h=%d, scaling=%d",
-          __func__, thumbnail.cropWidth, thumbnail.cropHeight,
-          thumbnail.left, thumbnail.top, thumbnail.width, thumbnail.height,
-          thumbnail.scaling);
-
-    OMX_GetExtensionIndex(my_obj->omx_handle, "omx.qcom.jpeg.exttype.thumbnail_quality", &q_idx);
-    OMX_GetParameter(my_obj->omx_handle, q_idx, &quality);
-    quality.nQFactor = src_buf->quality;
-    OMX_SetParameter(my_obj->omx_handle, q_idx, &quality);
-    CDBG("%s: thumbnail_quality=%d", __func__, quality.nQFactor);
-
-    rc = 0;
-    return rc;
-}
-
-int32_t mm_jpeg_omx_config_main_crop(mm_jpeg_obj* my_obj, src_image_buffer_info *src_buf)
-{
-    int32_t rc = 0;
-    OMX_CONFIG_RECTTYPE rect_type_in, rect_type_out;
-
-    if ((src_buf->crop.width == 0) || (src_buf->crop.height == 0)) {
-        src_buf->crop.width = src_buf->src_dim.width;
-        src_buf->crop.height = src_buf->src_dim.height;
-    }
-    /* error check first */
-    if ((src_buf->crop.width + src_buf->crop.offset_x > src_buf->src_dim.width) ||
-        (src_buf->crop.height + src_buf->crop.offset_y > src_buf->src_dim.height)) {
-        CDBG_ERROR("%s: invalid crop boundary (%d, %d) out of (%d, %d)", __func__,
-                   src_buf->crop.width + src_buf->crop.offset_x,
-                   src_buf->crop.height + src_buf->crop.offset_y,
-                   src_buf->src_dim.width,
-                   src_buf->src_dim.height);
-        return -1;
-    }
-
-    memset(&rect_type_in, 0, sizeof(rect_type_in));
-    memset(&rect_type_out, 0, sizeof(rect_type_out));
-    rect_type_in.nPortIndex = OUTPUT_PORT;
-    rect_type_out.nPortIndex = OUTPUT_PORT;
-
-    if ((src_buf->src_dim.width != src_buf->crop.width) ||
-        (src_buf->src_dim.height != src_buf->crop.height) ||
-        (src_buf->src_dim.width != src_buf->out_dim.width) ||
-        (src_buf->src_dim.height != src_buf->out_dim.height)) {
-        /* Scaler information */
-        rect_type_in.nWidth = CEILING2(src_buf->crop.width);
-        rect_type_in.nHeight = CEILING2(src_buf->crop.height);
-        rect_type_in.nLeft = src_buf->crop.offset_x;
-        rect_type_in.nTop = src_buf->crop.offset_y;
-
-        if (src_buf->out_dim.width && src_buf->out_dim.height) {
-            rect_type_out.nWidth = src_buf->out_dim.width;
-            rect_type_out.nHeight = src_buf->out_dim.height;
-        }
-    }
-
-    OMX_SetConfig(my_obj->omx_handle, OMX_IndexConfigCommonInputCrop, &rect_type_in);
-    CDBG("%s: OMX_IndexConfigCommonInputCrop w=%d, h=%d, l=%d, t=%d, port_idx=%d", __func__,
-         rect_type_in.nWidth, rect_type_in.nHeight,
-         rect_type_in.nLeft, rect_type_in.nTop,
-         rect_type_in.nPortIndex);
-
-    OMX_SetConfig(my_obj->omx_handle, OMX_IndexConfigCommonOutputCrop, &rect_type_out);
-    CDBG("%s: OMX_IndexConfigCommonOutputCrop w=%d, h=%d, port_idx=%d", __func__,
-         rect_type_out.nWidth, rect_type_out.nHeight,
-         rect_type_out.nPortIndex);
-
-    return rc;
-}
-
-int32_t mm_jpeg_omx_config_main(mm_jpeg_obj* my_obj, mm_jpeg_encode_job* job)
-{
-    int32_t rc = 0;
-    src_image_buffer_info *src_buf =
-        &(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN]);
-    OMX_IMAGE_PARAM_QFACTORTYPE q_factor;
-
-    /* config port */
-    CDBG("%s: config port", __func__);
-    rc = mm_jpeg_omx_config_port(my_obj, src_buf, INPUT_PORT_MAIN);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config port failed", __func__);
-        return rc;
-    }
-
-    /* config buffer offset */
-    CDBG("%s: config main buf offset", __func__);
-    rc = mm_jpeg_omx_config_main_buffer_offset(my_obj, src_buf, job->encode_parm.buf_info.src_imgs.is_video_frame);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config buffer offset failed", __func__);
-        return rc;
-    }
-
-    /* config crop */
-    CDBG("%s: config main crop", __func__);
-    rc = mm_jpeg_omx_config_main_crop(my_obj, src_buf);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config crop failed", __func__);
-        return rc;
-    }
-
-    /* set quality */
-    memset(&q_factor, 0, sizeof(q_factor));
-    q_factor.nPortIndex = INPUT_PORT_MAIN;
-    OMX_GetParameter(my_obj->omx_handle, OMX_IndexParamQFactor, &q_factor);
-    q_factor.nQFactor = src_buf->quality;
-    OMX_SetParameter(my_obj->omx_handle, OMX_IndexParamQFactor, &q_factor);
-    CDBG("%s: config QFactor: %d", __func__, q_factor.nQFactor);
-
-    return rc;
-}
-
-int32_t mm_jpeg_omx_config_common(mm_jpeg_obj* my_obj, mm_jpeg_encode_job* job)
-{
-    int32_t rc;
-    int i;
-    OMX_INDEXTYPE exif_idx;
-    omx_jpeg_exif_info_tag tag;
-    OMX_CONFIG_ROTATIONTYPE rotate;
-
-    /* config user prefernces */
-    CDBG("%s: config user preferences", __func__);
-    rc = mm_jpeg_omx_config_user_preference(my_obj, job);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config user preferences failed", __func__);
-        return rc;
-    }
-
-    /* set rotation */
-    memset(&rotate, 0, sizeof(rotate));
-    rotate.nPortIndex = OUTPUT_PORT;
-    rotate.nRotation = job->encode_parm.rotation;
-    OMX_SetConfig(my_obj->omx_handle, OMX_IndexConfigCommonRotate, &rotate);
-    CDBG("%s: Set rotation to %d at port_idx=%d", __func__,
-         job->encode_parm.rotation, rotate.nPortIndex);
-
-    /* set exif tags */
-    CDBG("%s: Set rexif tags", __func__);
-    OMX_GetExtensionIndex(my_obj->omx_handle, "omx.qcom.jpeg.exttype.exif", &exif_idx);
-    for(i = 0; i < job->encode_parm.exif_numEntries; i++) {
-        memcpy(&tag, job->encode_parm.exif_data + i, sizeof(omx_jpeg_exif_info_tag));
-        OMX_SetParameter(my_obj->omx_handle, exif_idx, &tag);
-    }
-
-    /* set mobicat info */
-    CDBG("%s: set Mobicat info", __func__);
-    if(job->encode_parm.hasmobicat) {
-        mobicat_d.mobicatData = job->encode_parm.mobicat_data;
-        mobicat_d.mobicatDataLength =  job->encode_parm.mobicat_data_length;
-        OMX_GetExtensionIndex(my_obj->omx_handle, "omx.qcom.jpeg.exttype.mobicat", &mobicat_data);
-        OMX_SetParameter(my_obj->omx_handle, mobicat_data, &mobicat_d);
-    }
-
-    return rc;
-}
-
-int32_t mm_jpeg_omx_use_buf(mm_jpeg_obj* my_obj,
-                            src_image_buffer_info *src_buf,
-                            mm_jpeg_omx_src_buf* omx_src_buf,
-                            int port_idx)
-{
-    int32_t rc = 0;
-    uint8_t i;
-    omx_jpeg_pmem_info pmem_info;
-
-    omx_src_buf->num_bufs = src_buf->num_bufs;
-    for (i = 0; i < src_buf->num_bufs; i++) {
-        memset(&pmem_info, 0, sizeof(pmem_info));
-        switch (src_buf->img_fmt) {
-        case JPEG_SRC_IMAGE_FMT_YUV:
-            pmem_info.fd = src_buf->src_image[i].fd;
-            pmem_info.offset = 0;
-            omx_src_buf->bufs[i].portIdx = port_idx;
-            OMX_UseBuffer(my_obj->omx_handle,
-                          &omx_src_buf->bufs[i].buf_header,
-                          port_idx,
-                          &pmem_info,
-                          src_buf->src_image[i].offset.frame_len,
-                          (void *)src_buf->src_image[i].buf_vaddr);
-            CDBG("%s: port_idx=%d, fd=%d, offset=%d, len=%d, ptr=%p",
-                 __func__, port_idx, pmem_info.fd, pmem_info.offset,
-                 src_buf->src_image[i].offset.frame_len,
-                 src_buf->src_image[i].buf_vaddr);
-            break;
-        case JPEG_SRC_IMAGE_FMT_BITSTREAM:
-            pmem_info.fd = src_buf->bit_stream[i].fd;
-            pmem_info.offset = 0;
-            omx_src_buf->bufs[i].portIdx = port_idx;
-            OMX_UseBuffer(my_obj->omx_handle,
-                          &omx_src_buf->bufs[i].buf_header,
-                          port_idx,
-                          &pmem_info,
-                          src_buf->bit_stream[i].buf_size,
-                          (void *)src_buf->bit_stream[i].buf_vaddr);
-            break;
-        default:
-            rc = -1;
-            break;
-        }
-    }
-
-    return rc;
-}
-
-int32_t mm_jpeg_omx_encode(mm_jpeg_obj* my_obj, mm_jpeg_job_entry* job_entry)
-{
-    int32_t rc = 0;
-    uint8_t i;
-    mm_jpeg_encode_job* job = &job_entry->job.encode_job;
-    uint8_t has_thumbnail = job->encode_parm.buf_info.src_imgs.src_img_num > 1? 1 : 0;
-    src_image_buffer_info *src_buf[JPEG_SRC_IMAGE_TYPE_MAX];
-    mm_jpeg_omx_src_buf *omx_src_buf[JPEG_SRC_IMAGE_TYPE_MAX];
-
-    /* config main img */
-    rc = mm_jpeg_omx_config_main(my_obj, job);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config main img failed", __func__);
-        return rc;
-    }
-
-    /* config thumbnail */
-    if (has_thumbnail) {
-        rc = mm_jpeg_omx_config_thumbnail(my_obj, job);
-        if (0 != rc) {
-            CDBG_ERROR("%s: config thumbnail img failed", __func__);
-            return rc;
-        }
-    }
-
-    /* common config */
-    rc = mm_jpeg_omx_config_common(my_obj, job);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config common failed", __func__);
-        return rc;
-    }
-
-    /* config input omx buffer for main input */
-    src_buf[JPEG_SRC_IMAGE_TYPE_MAIN] = &(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN]);
-    omx_src_buf[JPEG_SRC_IMAGE_TYPE_MAIN] = &job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_MAIN];
-    rc = mm_jpeg_omx_use_buf(my_obj,
-                             src_buf[JPEG_SRC_IMAGE_TYPE_MAIN],
-                             omx_src_buf[JPEG_SRC_IMAGE_TYPE_MAIN],
-                             INPUT_PORT_MAIN);
-    if (0 != rc) {
-        CDBG_ERROR("%s: config main input omx buffer failed", __func__);
-        return rc;
-    }
-
-    /* config input omx buffer for thumbnail input if there is thumbnail */
-    if (has_thumbnail) {
-        src_buf[JPEG_SRC_IMAGE_TYPE_THUMB] = &(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB]);
-        omx_src_buf[JPEG_SRC_IMAGE_TYPE_THUMB] = &job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_THUMB];
-        rc = mm_jpeg_omx_use_buf(my_obj,
-                                 src_buf[JPEG_SRC_IMAGE_TYPE_THUMB],
-                                 omx_src_buf[JPEG_SRC_IMAGE_TYPE_THUMB],
-                                 INPUT_PORT_THUMBNAIL);
-        if (0 != rc) {
-            CDBG_ERROR("%s: config thumbnail input omx buffer failed", __func__);
-            return rc;
-        }
-    }
-
-    /* config output omx buffer */
-    job_entry->sink_buf.portIdx = OUTPUT_PORT;
-    OMX_UseBuffer(my_obj->omx_handle,
-                  &job_entry->sink_buf.buf_header,
-                  job_entry->sink_buf.portIdx,
-                  NULL,
-                  job->encode_parm.buf_info.sink_img.buf_len,
-                  (void *)job->encode_parm.buf_info.sink_img.buf_vaddr);
-    CDBG("%s: Use output buf: port_idx=%d, len=%d, ptr=%p",
-         __func__, job_entry->sink_buf.portIdx,
-         job->encode_parm.buf_info.sink_img.buf_len,
-         job->encode_parm.buf_info.sink_img.buf_vaddr);
-
-    /* wait for OMX state ready */
-    CDBG("%s: Wait for state change to idle \n", __func__);
-    mm_jpeg_job_wait_for_cmd_complete(my_obj, OMX_CommandStateSet, OMX_StateIdle);
-    CDBG("%s: State changed to OMX_StateIdle\n", __func__);
-
-    /* start OMX encoding by sending executing cmd */
-    CDBG("%s: Send command to executing\n", __func__);
-    OMX_SendCommand(my_obj->omx_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
-    mm_jpeg_job_wait_for_cmd_complete(my_obj, OMX_CommandStateSet, OMX_StateExecuting);
-
-    /* start input feeding and output writing */
-    CDBG("%s: start main input feeding\n", __func__);
-    for (i = 0; i < job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_MAIN].num_bufs; i++) {
-        OMX_EmptyThisBuffer(my_obj->omx_handle,
-                            job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_MAIN].bufs[i].buf_header);
-    }
-    if (has_thumbnail) {
-        CDBG("%s: start thumbnail input feeding\n", __func__);
-        for (i = 0; i < job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_THUMB].num_bufs; i++) {
-            OMX_EmptyThisBuffer(my_obj->omx_handle,
-                                job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_THUMB].bufs[i].buf_header);
-        }
-    }
-    CDBG("%s: start output writing\n", __func__);
-    OMX_FillThisBuffer(my_obj->omx_handle, job_entry->sink_buf.buf_header);
-    return rc;
-}
-
-static void *mm_jpeg_notify_thread(void *data)
-{
-    mm_jpeg_job_q_node_t* job_node = (mm_jpeg_job_q_node_t *)data;
-    mm_jpeg_job_entry * job_entry = &job_node->entry;
-    mm_jpeg_obj* my_obj = (mm_jpeg_obj *)job_entry->jpeg_obj;
-    void* node = NULL;
-    int32_t rc = 0;
-    uint32_t jobId = job_entry->jobId;
-
-    if (NULL == my_obj) {
-        CDBG_ERROR("%s: jpeg obj is NULL", __func__);
-        return NULL;
-    }
-
-    /* call cb */
-    if (NULL != job_entry->job.encode_job.jpeg_cb) {
-        /* Add to cb queue */
-        rc = mm_jpeg_queue_enq(&my_obj->cb_q, data);
-        if (0 != rc) {
-            CDBG_ERROR("%s: enqueue into cb_q failed", __func__);
-            free(job_node);
-            return NULL;
-        }
-
-        CDBG("%s: send jpeg callback", __func__);
-        /* has callback, send CB */
-        job_entry->job.encode_job.jpeg_cb(job_entry->job_status,
-                                          job_entry->thumbnail_dropped,
-                                          job_entry->client_hdl,
-                                          job_entry->jobId,
-                                          job_entry->job.encode_job.encode_parm.buf_info.sink_img.buf_vaddr,
-                                          job_entry->jpeg_size,
-                                          job_entry->job.encode_job.userdata);
-
-        /* Remove from cb queue */
-        CDBG_ERROR("%s: remove job %d from cb queue", __func__, jobId);
-        node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->cb_q, jobId);
-        if (NULL != node) {
-            free(node);
-        }
-    } else {
-        CDBG_ERROR("%s: no cb provided, no action", __func__);
-        /* note here we are not freeing any internal memory */
-        free(data);
-    }
-
-    return NULL;
-}
-
-/* process encoding job */
-int32_t mm_jpeg_process_encoding_job(mm_jpeg_obj *my_obj, mm_jpeg_job_q_node_t* job_node)
-{
-    int32_t rc = 0;
-    mm_jpeg_job_entry* job_entry = &job_node->entry;
-
-    /* call OMX_Encode */
-    rc = mm_jpeg_omx_encode(my_obj, job_entry);
-    if (0 == rc) {
-        /* sent encode cmd to OMX, queue job into ongoing queue */
-        rc = mm_jpeg_queue_enq(&my_obj->ongoing_job_q, job_node);
-    } else {
-        /* OMX encode failed, notify error through callback */
-        job_entry->job_status = JPEG_JOB_STATUS_ERROR;
-        if (NULL != job_entry->job.encode_job.jpeg_cb) {
-            /* has callback, create a thread to send CB */
-            pthread_create(&job_entry->cb_pid,
-                           NULL,
-                           mm_jpeg_notify_thread,
-                           (void *)job_node);
-
-        } else {
-            CDBG_ERROR("%s: no cb provided, return here", __func__);
-            free(job_node);
-        }
-    }
-
-    return rc;
-}
-/* process job (encoding/decoding) */
-int32_t mm_jpeg_process_job(mm_jpeg_obj *my_obj, mm_jpeg_job_q_node_t* job_node)
-{
-    int32_t rc = 0;
-
-    switch (job_node->entry.job.job_type) {
-    case JPEG_JOB_TYPE_ENCODE:
-        rc = mm_jpeg_process_encoding_job(my_obj, job_node);
-        break;
-    default:
-        CDBG_ERROR("%s: job type not supported (%d)",
-                   __func__, job_node->entry.job.job_type);
-        free(job_node);
-        rc = -1;
-        break;
-    }
-
-    return rc;
-}
-
-static void *mm_jpeg_jobmgr_thread(void *data)
-{
-    int rc = 0;
-    int running = 1;
-    uint32_t num_ongoing_jobs = 0;
-    mm_jpeg_obj *my_obj = (mm_jpeg_obj*)data;
-    mm_jpeg_job_cmd_thread_t *cmd_thread = &my_obj->job_mgr;
-    mm_jpeg_job_q_node_t* node = NULL;
-
-    do {
-        do {
-            rc = sem_wait(&cmd_thread->job_sem);
-            if (rc != 0 && errno != EINVAL) {
-                CDBG_ERROR("%s: sem_wait error (%s)",
-                           __func__, strerror(errno));
-                return NULL;
-            }
-        } while (rc != 0);
-
-        /* check ongoing q size */
-        num_ongoing_jobs = mm_jpeg_queue_get_size(&my_obj->ongoing_job_q);
-        if (num_ongoing_jobs >= NUM_MAX_JPEG_CNCURRENT_JOBS) {
-            CDBG("%s: ongoing job already reach max %d", __func__, num_ongoing_jobs);
-            continue;
-        }
-
-        pthread_mutex_lock(&my_obj->job_lock);
-        /* can go ahead with new work */
-        node = (mm_jpeg_job_q_node_t*)mm_jpeg_queue_deq(&cmd_thread->job_queue);
-        if (node != NULL) {
-            switch (node->type) {
-            case MM_JPEG_CMD_TYPE_JOB:
-                mm_jpeg_process_job(my_obj, node);
-                break;
-            case MM_JPEG_CMD_TYPE_EXIT:
-            default:
-                /* free node */
-                free(node);
-                /* set running flag to false */
-                running = 0;
-                break;
-            }
-        }
-        pthread_mutex_unlock(&my_obj->job_lock);
-
-    } while (running);
-    return NULL;
-}
-
-int32_t mm_jpeg_jobmgr_thread_launch(mm_jpeg_obj * my_obj)
-{
-    int32_t rc = 0;
-    mm_jpeg_job_cmd_thread_t * job_mgr = &my_obj->job_mgr;
-
-    sem_init(&job_mgr->job_sem, 0, 0);
-    mm_jpeg_queue_init(&job_mgr->job_queue);
-
-    /* launch the thread */
-    pthread_create(&job_mgr->pid,
-                   NULL,
-                   mm_jpeg_jobmgr_thread,
-                   (void *)my_obj);
-    return rc;
-}
-
-int32_t mm_jpeg_jobmgr_thread_release(mm_jpeg_obj * my_obj)
-{
-    int32_t rc = 0;
-    mm_jpeg_job_cmd_thread_t * cmd_thread = &my_obj->job_mgr;
-    mm_jpeg_job_q_node_t* node =
-        (mm_jpeg_job_q_node_t *)malloc(sizeof(mm_jpeg_job_q_node_t));
-    if (NULL == node) {
-        CDBG_ERROR("%s: No memory for mm_jpeg_job_q_node_t", __func__);
-        return -1;
-    }
-
-    memset(node, 0, sizeof(mm_jpeg_job_q_node_t));
-    node->type = MM_JPEG_CMD_TYPE_EXIT;
-
-    mm_jpeg_queue_enq(&cmd_thread->job_queue, node);
-    sem_post(&cmd_thread->job_sem);
-
-    /* wait until cmd thread exits */
-    if (pthread_join(cmd_thread->pid, NULL) != 0) {
-        CDBG("%s: pthread dead already\n", __func__);
-    }
-    mm_jpeg_queue_deinit(&cmd_thread->job_queue);
-
-    sem_destroy(&cmd_thread->job_sem);
-    memset(cmd_thread, 0, sizeof(mm_jpeg_job_cmd_thread_t));
-    return rc;
-}
-
-int32_t mm_jpeg_init(mm_jpeg_obj *my_obj)
-{
-    int32_t rc = 0;
-
-    /* init locks */
-    pthread_mutex_init(&my_obj->job_lock, NULL);
-    pthread_mutex_init(&my_obj->omx_evt_lock, NULL);
-    pthread_cond_init(&my_obj->omx_evt_cond, NULL);
-
-    /* init ongoing job queue */
-    rc = mm_jpeg_queue_init(&my_obj->ongoing_job_q);
-    rc = mm_jpeg_queue_init(&my_obj->cb_q);
-
-    /* init job semaphore and launch jobmgr thread */
-    CDBG("%s : Launch jobmgr thread",__func__);
-    rc = mm_jpeg_jobmgr_thread_launch(my_obj);
-
-    /* load OMX */
-    rc = mm_jpeg_omx_load(my_obj);
-    if (0 != rc) {
-        /* roll back in error case */
-        mm_jpeg_jobmgr_thread_release(my_obj);
-        mm_jpeg_queue_deinit(&my_obj->ongoing_job_q);
-        pthread_mutex_destroy(&my_obj->job_lock);
-        pthread_mutex_destroy(&my_obj->omx_evt_lock);
-        pthread_cond_destroy(&my_obj->omx_evt_cond);
-    }
-
-    return rc;
-}
-
-int32_t mm_jpeg_deinit(mm_jpeg_obj *my_obj)
-{
-    int32_t rc = 0;
-
-    /* unload OMX engine */
-    rc = mm_jpeg_omx_unload(my_obj);
-
-    /* release jobmgr thread */
-    rc = mm_jpeg_jobmgr_thread_release(my_obj);
-
-    /* deinit ongoing job and cb queue */
-    rc = mm_jpeg_queue_deinit(&my_obj->ongoing_job_q);
-    rc = mm_jpeg_queue_deinit(&my_obj->cb_q);
-
-    /* destroy locks */
-    pthread_mutex_destroy(&my_obj->job_lock);
-    pthread_mutex_destroy(&my_obj->omx_evt_lock);
-    pthread_cond_destroy(&my_obj->omx_evt_cond);
-
-    return rc;
-}
-
-uint32_t mm_jpeg_new_client(mm_jpeg_obj *my_obj)
-{
-    uint32_t client_hdl = 0;
-    uint8_t idx;
-
-    if (my_obj->num_clients >= MAX_JPEG_CLIENT_NUM) {
-        CDBG_ERROR("%s: num of clients reached limit", __func__);
-        return client_hdl;
-    }
-
-    for (idx = 0; idx < MAX_JPEG_CLIENT_NUM; idx++) {
-        if (0 == my_obj->clnt_mgr[idx].is_used) {
-            break;
-        }
-    }
-
-    if (idx < MAX_JPEG_CLIENT_NUM) {
-        /* client entry avail */
-        /* generate client handler by index */
-        client_hdl = mm_jpeg_util_generate_handler(idx);
-
-        /* update client entry */
-        my_obj->clnt_mgr[idx].is_used = 1;
-        my_obj->clnt_mgr[idx].client_handle = client_hdl;
-
-        /* increse client count */
-        my_obj->num_clients++;
-    }
-
-    return client_hdl;
-}
-
-int32_t mm_jpeg_start_job(mm_jpeg_obj *my_obj,
-                          uint32_t client_hdl,
-                          mm_jpeg_job* job,
-                          uint32_t* jobId)
-{
-    int32_t rc = -1;
-    uint8_t clnt_idx = 0;
-    uint32_t job_id = 0;
-    mm_jpeg_job_q_node_t* node = NULL;
-
-    *jobId = 0;
-
-    /* check if valid client */
-    clnt_idx = mm_jpeg_util_get_index_by_handler(client_hdl);
-    if (clnt_idx >= MAX_JPEG_CLIENT_NUM ) {
-        CDBG_ERROR("%s: invalid client with handler (%d)", __func__, client_hdl);
-        return rc;
-    }
-
-    /* generate client handler by index */
-    job_id = mm_jpeg_util_generate_handler(clnt_idx);
-
-    /* enqueue new job into todo job queue */
-    node = (mm_jpeg_job_q_node_t *)malloc(sizeof(mm_jpeg_job_q_node_t));
-    if (NULL == node) {
-        CDBG_ERROR("%s: No memory for mm_jpeg_job_q_node_t", __func__);
-        return -rc;
-    }
-
-    memset(node, 0, sizeof(mm_jpeg_job_q_node_t));
-    node->type = MM_JPEG_CMD_TYPE_JOB;
-    node->entry.client_hdl = client_hdl;
-    node->entry.jobId = job_id;
-    memcpy(&node->entry.job, job, sizeof(mm_jpeg_job));
-    node->entry.jpeg_obj = (void*)my_obj; /* save a ptr to jpeg_obj */
-
-    rc = mm_jpeg_queue_enq(&my_obj->job_mgr.job_queue, node);
-    if (0 == rc) {
-        sem_post(&my_obj->job_mgr.job_sem);
-        *jobId = job_id;
-    }
-
-    return rc;
-}
-
-int32_t mm_jpeg_abort_job(mm_jpeg_obj *my_obj,
-                          uint32_t client_hdl,
-                          uint32_t jobId)
-{
-    int32_t rc = -1;
-    uint8_t clnt_idx = 0;
-    void * node = NULL;
-    mm_jpeg_job_entry* job_entry = NULL;
-
-    /* check if valid client */
-    clnt_idx = mm_jpeg_util_get_index_by_handler(client_hdl);
-    if (clnt_idx >= MAX_JPEG_CLIENT_NUM ) {
-        CDBG_ERROR("%s: invalid client with handler (%d)", __func__, client_hdl);
-        return rc;
-    }
-
-    pthread_mutex_lock(&my_obj->job_lock);
-
-    /* abort job if in ongoing queue */
-    node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->ongoing_job_q, jobId);
-    if (NULL != node) {
-        /* find job that is OMX ongoing, ask OMX to abort the job */
-        job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
-        rc = mm_jpeg_omx_abort_job(my_obj, job_entry);
-        free(node);
-        goto abort_done;
-    }
-
-    /* abort job if in todo queue */
-    node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->job_mgr.job_queue, jobId);
-    if (NULL != node) {
-        /* simply delete it */
-        free(node);
-        goto abort_done;
-    }
-    /* abort job if in cb queue */
-    node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->cb_q, jobId);
-    if (NULL != node) {
-        /* join cb thread */
-        job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
-        if (pthread_join(job_entry->cb_pid, NULL) != 0) {
-            CDBG("%s: pthread dead already\n", __func__);
-        }
-        free(node);
-    }
-abort_done:
-    pthread_mutex_unlock(&my_obj->job_lock);
-
-    /* wake up jobMgr thread to work on new job if there is any */
-    sem_post(&my_obj->job_mgr.job_sem);
-
-    return rc;
-}
-
-int32_t mm_jpeg_close(mm_jpeg_obj *my_obj, uint32_t client_hdl)
-{
-    int32_t rc = -1;
-    uint8_t clnt_idx = 0;
-    void* node = NULL;
-    mm_jpeg_job_entry* job_entry = NULL;
-
-    /* check if valid client */
-    clnt_idx = mm_jpeg_util_get_index_by_handler(client_hdl);
-    if (clnt_idx >= MAX_JPEG_CLIENT_NUM ) {
-        CDBG_ERROR("%s: invalid client with handler (%d)", __func__, client_hdl);
-        return rc;
-    }
-
-    CDBG("%s: E", __func__);
-
-    /* abort all jobs from the client */
-    pthread_mutex_lock(&my_obj->job_lock);
-
-    /* abort job if in ongoing queue */
-    CDBG("%s: abort ongoing jobs", __func__);
-    node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->ongoing_job_q, client_hdl);
-    while (NULL != node) {
-        /* find job that is OMX ongoing, ask OMX to abort the job */
-        job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
-        rc = mm_jpeg_omx_abort_job(my_obj, job_entry);
-        free(node);
-
-        /* find next job from ongoing queue that belongs to this client */
-        node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->ongoing_job_q, client_hdl);
-    }
-
-    /* abort job if in todo queue */
-    CDBG("%s: abort todo jobs", __func__);
-    node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->job_mgr.job_queue, client_hdl);
-    while (NULL != node) {
-        /* simply delete the job if in todo queue */
-        free(node);
-
-        /* find next job from todo queue that belongs to this client */
-        node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->job_mgr.job_queue, client_hdl);
-    }
-
-    /* abort job if in cb queue */
-    CDBG("%s: abort done jobs in cb threads", __func__);
-    node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->cb_q, client_hdl);
-    while (NULL != node) {
-        /* join cb thread */
-        job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
-        if (pthread_join(job_entry->cb_pid, NULL) != 0) {
-            CDBG("%s: pthread dead already\n", __func__);
-        }
-        free(node);
-
-        /* find next job from cb queue that belongs to this client */
-        node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->cb_q, client_hdl);
-    }
-
-    pthread_mutex_unlock(&my_obj->job_lock);
-
-    /* invalidate client entry */
-    memset(&my_obj->clnt_mgr[clnt_idx], 0, sizeof(mm_jpeg_client_t));
-
-    rc = 0;
-    CDBG("%s: X", __func__);
-    return rc;
-}
-
-void mm_jpeg_job_wait_for_event(mm_jpeg_obj *my_obj, uint32_t evt_mask)
-{
-    pthread_mutex_lock(&my_obj->omx_evt_lock);
-    while (!(my_obj->omx_evt_rcvd.evt & evt_mask)) {
-        pthread_cond_wait(&my_obj->omx_evt_cond, &my_obj->omx_evt_lock);
-    }
-    CDBG("%s:done", __func__);
-    pthread_mutex_unlock(&my_obj->omx_evt_lock);
-}
-
-void mm_jpeg_job_wait_for_cmd_complete(mm_jpeg_obj *my_obj,
-                                       int cmd,
-                                       int status)
-{
-    pthread_mutex_lock(&my_obj->omx_evt_lock);
-    while (!((my_obj->omx_evt_rcvd.evt & MM_JPEG_EVENT_MASK_CMD_COMPLETE) &&
-             (my_obj->omx_evt_rcvd.omx_value1 == cmd) &&
-             (my_obj->omx_evt_rcvd.omx_value2 == status))) {
-        pthread_cond_wait(&my_obj->omx_evt_cond, &my_obj->omx_evt_lock);
-    }
-    CDBG("%s:done", __func__);
-    pthread_mutex_unlock(&my_obj->omx_evt_lock);
-}
-
-OMX_ERRORTYPE mm_jpeg_etbdone(OMX_HANDLETYPE hComponent,
-                              OMX_PTR pAppData,
-                              OMX_BUFFERHEADERTYPE* pBuffer)
-{
-    /* no process needed for etbdone, return here */
-    return 0;
-}
-
-OMX_ERRORTYPE mm_jpeg_ftbdone(OMX_HANDLETYPE hComponent,
-                              OMX_PTR pAppData,
-                              OMX_BUFFERHEADERTYPE* pBuffer)
-{
-    int rc = 0;
-    void* node = NULL;
-    mm_jpeg_job_entry* job_entry = NULL;
-    mm_jpeg_obj * my_obj = (mm_jpeg_obj*)pAppData;
-
-    if (NULL == my_obj) {
-        CDBG_ERROR("%s: pAppData is NULL, return here", __func__);
-        return rc;
-    }
-
-    CDBG("%s: jpeg done", __func__);
-
-    /* signal JPEG_DONE event */
-    pthread_mutex_lock(&my_obj->omx_evt_lock);
-    my_obj->omx_evt_rcvd.evt = MM_JPEG_EVENT_MASK_JPEG_DONE;
-    pthread_cond_signal(&my_obj->omx_evt_cond);
-    pthread_mutex_unlock(&my_obj->omx_evt_lock);
-
-    /* find job that is OMX ongoing */
-    /* If OMX can support multi encoding, it should provide a way to pass jobID.
-     * then we can find job by jobID from ongoing queue.
-     * For now, since OMX only support one job per time, we simply dequeue it. */
-    pthread_mutex_lock(&my_obj->job_lock);
-    node = mm_jpeg_queue_deq(&my_obj->ongoing_job_q);
-    if (NULL != node) {
-        job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
-
-        /* update status in job entry */
-        job_entry->jpeg_size = pBuffer->nFilledLen;
-        job_entry->job_status = JPEG_JOB_STATUS_DONE;
-        CDBG("%s:filled len = %u, status = %d",
-             __func__, job_entry->jpeg_size, job_entry->job_status);
-
-        /* clean omx job */
-        mm_jpeg_clean_omx_job(my_obj, job_entry);
-
-        if (NULL != job_entry->job.encode_job.jpeg_cb) {
-            /* has callback, create a thread to send CB */
-            pthread_create(&job_entry->cb_pid,
-                           NULL,
-                           mm_jpeg_notify_thread,
-                           node);
-
-        } else {
-            CDBG_ERROR("%s: no cb provided, return here", __func__);
-            free(node);
-        }
-    }
-    pthread_mutex_unlock(&my_obj->job_lock);
-
-    /* Wake up jobMgr thread to work on next job if there is any */
-    sem_post(&my_obj->job_mgr.job_sem);
-
-    return rc;
-}
-
-OMX_ERRORTYPE mm_jpeg_handle_omx_event(OMX_HANDLETYPE hComponent,
-                                       OMX_PTR pAppData,
-                                       OMX_EVENTTYPE eEvent,
-                                       OMX_U32 nData1,
-                                       OMX_U32 nData2,
-                                       OMX_PTR pEventData)
-{
-    int rc = 0;
-    void* node = NULL;
-    mm_jpeg_job_entry* job_entry = NULL;
-    mm_jpeg_obj * my_obj = (mm_jpeg_obj*)pAppData;
-    uint32_t jobId = 0;
-
-    if (NULL == my_obj) {
-        CDBG_ERROR("%s: pAppData is NULL, return here", __func__);
-        return rc;
-    }
-
-    /* signal event */
-    switch (eEvent) {
-    case  OMX_EVENT_JPEG_ABORT:
-        {
-            CDBG("%s: eEvent=OMX_EVENT_JPEG_ABORT", __func__);
-            /* signal error evt */
-            pthread_mutex_lock(&my_obj->omx_evt_lock);
-            my_obj->omx_evt_rcvd.evt = MM_JPEG_EVENT_MASK_JPEG_ABORT;
-            pthread_cond_signal(&my_obj->omx_evt_cond);
-            pthread_mutex_unlock(&my_obj->omx_evt_lock);
-        }
-        break;
-    case OMX_EventError:
-        {
-            CDBG("%s: eEvent=OMX_EventError", __func__);
-            switch (nData1) {
-            case OMX_EVENT_THUMBNAIL_DROPPED:
-                {
-                    uint8_t thumbnail_dropped_flag = 1;
-                    mm_jpeg_job_q_node_t* data = (mm_jpeg_job_q_node_t*)mm_jpeg_queue_peek(&my_obj->ongoing_job_q);
-                    jobId = data->entry.jobId;
-                    mm_jpeg_queue_update_flag(&my_obj->ongoing_job_q,
-                                              jobId,
-                                              thumbnail_dropped_flag);
-                }
-                break;
-            case OMX_EVENT_JPEG_ERROR:
-                {
-                    /* signal error evt */
-                    pthread_mutex_lock(&my_obj->omx_evt_lock);
-                    my_obj->omx_evt_rcvd.evt = MM_JPEG_EVENT_MASK_JPEG_ERROR;
-                    pthread_cond_signal(&my_obj->omx_evt_cond);
-                    pthread_mutex_unlock(&my_obj->omx_evt_lock);
-
-                    /* send CB for error case */
-                    /* If OMX can support multi encoding, it should provide a way to pass jobID.
-                     * then we can find job by jobID from ongoing queue.
-                     * For now, since OMX only support one job per time, we simply dequeue it. */
-                    pthread_mutex_lock(&my_obj->job_lock);
-                    node = mm_jpeg_queue_deq(&my_obj->ongoing_job_q);
-                    if (NULL != node) {
-                        job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);;
-
-                        /* clean omx job */
-                        mm_jpeg_clean_omx_job(my_obj, job_entry);
-
-                        /* find job that is OMX ongoing */
-                        job_entry->job_status = JPEG_JOB_STATUS_ERROR;
-                        if (NULL != job_entry->job.encode_job.jpeg_cb) {
-                            /* has callback, create a thread to send CB */
-                            pthread_create(&job_entry->cb_pid,
-                                           NULL,
-                                           mm_jpeg_notify_thread,
-                                           node);
-
-                        } else {
-                            CDBG_ERROR("%s: no cb provided, return here", __func__);
-                            free(node);
-                        }
-                    }
-                    pthread_mutex_unlock(&my_obj->job_lock);
-
-                    /* Wake up jobMgr thread to work on next job if there is any */
-                    sem_post(&my_obj->job_mgr.job_sem);
-                }
-                break;
-            default:
-                break;
-            }
-        }
-        break;
-    case OMX_EventCmdComplete:
-        {
-            CDBG("%s: eEvent=OMX_EventCmdComplete, value1=%d, value2=%d",
-                 __func__, nData1, nData2);
-            /* signal cmd complete evt */
-            pthread_mutex_lock(&my_obj->omx_evt_lock);
-            my_obj->omx_evt_rcvd.evt = MM_JPEG_EVENT_MASK_CMD_COMPLETE;
-            my_obj->omx_evt_rcvd.omx_value1 = nData1;
-            my_obj->omx_evt_rcvd.omx_value2 = nData2;
-            pthread_cond_signal(&my_obj->omx_evt_cond);
-            pthread_mutex_unlock(&my_obj->omx_evt_lock);
-        }
-        break;
-    default:
-        break;
-    }
-    return rc;
-}
-
-/* remove the first job from the queue with matching client handle */
-mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_client_id(mm_jpeg_queue_t* queue, uint32_t client_hdl)
-{
-    mm_jpeg_q_node_t* node = NULL;
-    mm_jpeg_job_q_node_t* data = NULL;
-    mm_jpeg_job_q_node_t* job_node = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-    while(pos != head) {
-        node = member_of(pos, mm_jpeg_q_node_t, list);
-        data = (mm_jpeg_job_q_node_t *)node->data;
-
-        if (data && (data->entry.client_hdl == client_hdl)) {
-            CDBG_ERROR("%s: found matching client node", __func__);
-            job_node = data;
-            cam_list_del_node(&node->list);
-            queue->size--;
-            free(node);
-            CDBG_ERROR("%s: queue size = %d", __func__, queue->size);
-            break;
-        }
-        pos = pos->next;
-    }
-
-    pthread_mutex_unlock(&queue->lock);
-
-    return job_node;
-}
-
-/* remove job from the queue with matching job id */
-mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_job_id(mm_jpeg_queue_t* queue, uint32_t job_id)
-{
-    mm_jpeg_q_node_t* node = NULL;
-    mm_jpeg_job_q_node_t* data = NULL;
-    mm_jpeg_job_q_node_t* job_node = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-    while(pos != head) {
-        node = member_of(pos, mm_jpeg_q_node_t, list);
-        data = (mm_jpeg_job_q_node_t *)node->data;
-
-        if (data && (data->entry.jobId == job_id)) {
-            job_node = data;
-            cam_list_del_node(&node->list);
-            queue->size--;
-            free(node);
-            break;
-        }
-        pos = pos->next;
-    }
-
-    pthread_mutex_unlock(&queue->lock);
-
-    return job_node;
-}
-
-/* update thumbnail dropped flag in job queue */
-int32_t mm_jpeg_queue_update_flag(mm_jpeg_queue_t* queue, uint32_t job_id, uint8_t flag)
-{
-    int32_t rc = 0;
-    mm_jpeg_q_node_t* node = NULL;
-    mm_jpeg_job_q_node_t* data = NULL;
-    mm_jpeg_job_q_node_t* job_node = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-    while(pos != head) {
-        node = member_of(pos, mm_jpeg_q_node_t, list);
-        data = (mm_jpeg_job_q_node_t *)node->data;
-        if (data && (data->entry.jobId == job_id)) {
-            job_node = data;
-            break;
-        }
-        pos = pos->next;
-    }
-
-    if (job_node) {
-        /* find matching job for its job id */
-        job_node->entry.thumbnail_dropped = flag;
-    } else {
-        CDBG_ERROR("%s: No entry for jobId = %d", __func__, job_id);
-        rc = -1;
-    }
-    pthread_mutex_unlock(&queue->lock);
-    return rc;
-}
diff --git a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_interface.c b/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_interface.c
deleted file mode 100755
index 46f6fba..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_interface.c
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <semaphore.h>
-
-#include "mm_jpeg_dbg.h"
-#include "mm_jpeg_interface.h"
-#include "mm_jpeg.h"
-
-static pthread_mutex_t g_intf_lock = PTHREAD_MUTEX_INITIALIZER;
-static mm_jpeg_obj* g_jpeg_obj = NULL;
-
-static pthread_mutex_t g_handler_lock = PTHREAD_MUTEX_INITIALIZER;
-static uint16_t g_handler_history_count = 0; /* history count for handler */
-
-void static mm_jpeg_dump_job(mm_jpeg_job* job )
-{
-    #if 1
-    int i;
-    jpeg_image_buffer_config * buf_info;
-    buf_info = &job->encode_job.encode_parm.buf_info;
-    CDBG_ERROR("*****Dump job************");
-    CDBG_ERROR("rotation =%d, exif_numEntries=%d, is_video_frame=%d",
-               job->encode_job.encode_parm.rotation, job->encode_job.encode_parm.exif_numEntries,
-               job->encode_job.encode_parm.buf_info.src_imgs.is_video_frame);
-    CDBG_ERROR("Buff_inof: sin_img fd=%d, buf_len=%d, buf_add=%p: src img img num=%d", buf_info->sink_img.fd, buf_info->sink_img.buf_len,
-               buf_info->sink_img.buf_vaddr,  buf_info->src_imgs.src_img_num);
-    for (i=0; i < buf_info->src_imgs.src_img_num; i++) {
-        CDBG_ERROR("src_img[%d] fmt=%d, col_fmt=%d, type=%d, bum_buf=%d, quality=%d, src: %dx%d, out:%dx%d, crop: %dx%d, x=%d, y=%d", i, buf_info->src_imgs.src_img[i].img_fmt,
-                   buf_info->src_imgs.src_img[i].color_format,
-                   buf_info->src_imgs.src_img[i].type,
-                   buf_info->src_imgs.src_img[i].num_bufs,
-                   buf_info->src_imgs.src_img[i].quality,
-                   buf_info->src_imgs.src_img[i].src_dim.width, buf_info->src_imgs.src_img[i].src_dim.height,
-                   buf_info->src_imgs.src_img[i].out_dim.width, buf_info->src_imgs.src_img[i].out_dim.height,
-                   buf_info->src_imgs.src_img[i].crop.width, buf_info->src_imgs.src_img[i].crop.height,
-                   buf_info->src_imgs.src_img[i].crop.offset_x, buf_info->src_imgs.src_img[i].crop.offset_y
-                   );
-    }
-
-    #endif
-
-}
-
-/* utility function to generate handler */
-uint32_t mm_jpeg_util_generate_handler(uint8_t index)
-{
-    uint32_t handler = 0;
-    pthread_mutex_lock(&g_handler_lock);
-    g_handler_history_count++;
-    if (0 == g_handler_history_count) {
-        g_handler_history_count++;
-    }
-    handler = g_handler_history_count;
-    handler = (handler<<8) | index;
-    pthread_mutex_unlock(&g_handler_lock);
-    return handler;
-}
-
-uint8_t mm_jpeg_util_get_index_by_handler(uint32_t handler)
-{
-    return (handler&0x000000ff);
-}
-
-static int32_t mm_jpeg_intf_start_job(uint32_t client_hdl, mm_jpeg_job* job, uint32_t* jobId)
-{
-    int32_t rc = -1;
-
-    if (0 == client_hdl ||
-        NULL == job ||
-        NULL == jobId) {
-        CDBG_ERROR("%s: invalid parameters for client_hdl, job or jobId", __func__);
-        return rc;
-    }
-
-    pthread_mutex_lock(&g_intf_lock);
-    if (NULL == g_jpeg_obj) {
-        /* mm_jpeg obj not exists, return error */
-        CDBG_ERROR("%s: mm_jpeg is not opened yet", __func__);
-        pthread_mutex_unlock(&g_intf_lock);
-        return rc;
-    }
-    mm_jpeg_dump_job(job);
-    rc = mm_jpeg_start_job(g_jpeg_obj, client_hdl, job, jobId);
-    pthread_mutex_unlock(&g_intf_lock);
-    return rc;
-}
-
-static int32_t mm_jpeg_intf_abort_job(uint32_t client_hdl, uint32_t jobId)
-{
-    int32_t rc = -1;
-
-    if (0 == client_hdl || 0 == jobId) {
-        CDBG_ERROR("%s: invalid client_hdl or jobId", __func__);
-        return rc;
-    }
-
-    pthread_mutex_lock(&g_intf_lock);
-    if (NULL == g_jpeg_obj) {
-        /* mm_jpeg obj not exists, return error */
-        CDBG_ERROR("%s: mm_jpeg is not opened yet", __func__);
-        pthread_mutex_unlock(&g_intf_lock);
-        return rc;
-    }
-
-    rc = mm_jpeg_abort_job(g_jpeg_obj, client_hdl, jobId);
-    pthread_mutex_unlock(&g_intf_lock);
-    return rc;
-}
-
-static int32_t mm_jpeg_intf_close(uint32_t client_hdl)
-{
-    int32_t rc = -1;
-
-    if (0 == client_hdl) {
-        CDBG_ERROR("%s: invalid client_hdl", __func__);
-        return rc;
-    }
-
-    pthread_mutex_lock(&g_intf_lock);
-    if (NULL == g_jpeg_obj) {
-        /* mm_jpeg obj not exists, return error */
-        CDBG_ERROR("%s: mm_jpeg is not opened yet", __func__);
-        pthread_mutex_unlock(&g_intf_lock);
-        return rc;
-    }
-
-    rc = mm_jpeg_close(g_jpeg_obj, client_hdl);
-    g_jpeg_obj->num_clients--;
-    if(0 == rc) {
-        if (0 == g_jpeg_obj->num_clients) {
-            /* No client, close jpeg internally */
-            rc = mm_jpeg_deinit(g_jpeg_obj);
-            free(g_jpeg_obj);
-            g_jpeg_obj = NULL;
-        }
-    }
-
-    pthread_mutex_unlock(&g_intf_lock);
-    return rc;
-}
-
-/* open jpeg client */
-uint32_t jpeg_open(mm_jpeg_ops_t *ops)
-{
-    int32_t rc = 0;
-    uint32_t clnt_hdl = 0;
-    mm_jpeg_obj* jpeg_obj = NULL;
-
-    pthread_mutex_lock(&g_intf_lock);
-    /* first time open */
-    if(NULL == g_jpeg_obj) {
-        jpeg_obj = (mm_jpeg_obj *)malloc(sizeof(mm_jpeg_obj));
-        if(NULL == jpeg_obj) {
-            CDBG_ERROR("%s:  no mem", __func__);
-            pthread_mutex_unlock(&g_intf_lock);
-            return clnt_hdl;
-        }
-
-        /* initialize jpeg obj */
-        memset(jpeg_obj, 0, sizeof(mm_jpeg_obj));
-        rc = mm_jpeg_init(jpeg_obj);
-        if(0 != rc) {
-            CDBG_ERROR("%s: mm_jpeg_init err = %d", __func__, rc);
-            free(jpeg_obj);
-            pthread_mutex_unlock(&g_intf_lock);
-            return clnt_hdl;
-        }
-
-        /* remember in global variable */
-        g_jpeg_obj = jpeg_obj;
-    }
-
-    /* open new client */
-    clnt_hdl = mm_jpeg_new_client(g_jpeg_obj);
-    if (clnt_hdl > 0) {
-        /* valid client */
-        if (NULL != ops) {
-            /* fill in ops tbl if ptr not NULL */
-            ops->start_job = mm_jpeg_intf_start_job;
-            ops->abort_job = mm_jpeg_intf_abort_job;
-            //ops->abort_job_all = mm_jpeg_intf_close,
-            ops->close = mm_jpeg_intf_close;
-        }
-    } else {
-        /* failed new client */
-        CDBG_ERROR("%s: mm_jpeg_new_client failed", __func__);
-
-        if (0 == g_jpeg_obj->num_clients) {
-            /* no client, close jpeg */
-            mm_jpeg_deinit(g_jpeg_obj);
-            free(g_jpeg_obj);
-            g_jpeg_obj = NULL;
-        }
-    }
-
-    pthread_mutex_unlock(&g_intf_lock);
-    return clnt_hdl;
-}
diff --git a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_queue.c b/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_queue.c
deleted file mode 100755
index 222a7e3..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_queue.c
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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 <pthread.h>
-#include "mm_jpeg_dbg.h"
-#include "mm_jpeg.h"
-
-int32_t mm_jpeg_queue_init(mm_jpeg_queue_t* queue)
-{
-    pthread_mutex_init(&queue->lock, NULL);
-    cam_list_init(&queue->head.list);
-    queue->size = 0;
-    return 0;
-}
-
-int32_t mm_jpeg_queue_enq(mm_jpeg_queue_t* queue, void* data)
-{
-    mm_jpeg_q_node_t* node =
-        (mm_jpeg_q_node_t *)malloc(sizeof(mm_jpeg_q_node_t));
-    if (NULL == node) {
-        CDBG_ERROR("%s: No memory for mm_jpeg_q_node_t", __func__);
-        return -1;
-    }
-
-    memset(node, 0, sizeof(mm_jpeg_q_node_t));
-    node->data = data;
-
-    pthread_mutex_lock(&queue->lock);
-    cam_list_add_tail_node(&node->list, &queue->head.list);
-    queue->size++;
-    pthread_mutex_unlock(&queue->lock);
-
-    return 0;
-
-}
-
-
-void* mm_jpeg_queue_peek(mm_jpeg_queue_t* queue)
-{
-    mm_jpeg_q_node_t* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-    if (pos != head) {
-        node = member_of(pos, mm_jpeg_q_node_t, list);
-    }
-    pthread_mutex_unlock(&queue->lock);
-
-    if (NULL != node) {
-        data = node->data;
-    }
-    return data;
-}
-
-void* mm_jpeg_queue_deq(mm_jpeg_queue_t* queue)
-{
-    mm_jpeg_q_node_t* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-    if (pos != head) {
-        node = member_of(pos, mm_jpeg_q_node_t, list);
-        cam_list_del_node(&node->list);
-        queue->size--;
-    }
-    pthread_mutex_unlock(&queue->lock);
-
-    if (NULL != node) {
-        data = node->data;
-        free(node);
-    }
-
-    return data;
-}
-
-uint32_t mm_jpeg_queue_get_size(mm_jpeg_queue_t* queue)
-{
-    uint32_t size = 0;
-
-    pthread_mutex_lock(&queue->lock);
-    size = queue->size;
-    pthread_mutex_unlock(&queue->lock);
-
-    return size;
-
-}
-
-int32_t mm_jpeg_queue_deinit(mm_jpeg_queue_t* queue)
-{
-    mm_jpeg_queue_flush(queue);
-    pthread_mutex_destroy(&queue->lock);
-    return 0;
-}
-
-int32_t mm_jpeg_queue_flush(mm_jpeg_queue_t* queue)
-{
-    mm_jpeg_q_node_t* node = NULL;
-    void* data = NULL;
-    struct cam_list *head = NULL;
-    struct cam_list *pos = NULL;
-
-    pthread_mutex_lock(&queue->lock);
-    head = &queue->head.list;
-    pos = head->next;
-
-    while(pos != head) {
-        node = member_of(pos, mm_jpeg_q_node_t, list);
-        cam_list_del_node(&node->list);
-        queue->size--;
-
-        /* for now we only assume there is no ptr inside data
-         * so we free data directly */
-        if (NULL != node->data) {
-            free(node->data);
-        }
-        free(node);
-        pos = pos->next;
-    }
-    queue->size = 0;
-    pthread_mutex_unlock(&queue->lock);
-    return 0;
-}