Replaced libcamera.so with a wrapper

Features:
    - Continuous AF
    - ISO
    - Metering
    - Scene-modes
    - Focus-modes
    - Touch to focus (dependent on Iafc575a5)
    - Additional FFC Preview sizes (was hacked in on the old libcamera.so)
    - Disabled Samsung hacks in Camera.apk because it's no longer needed

Note:
    - I believe that the same libcamera.so (now renamed libsamsungcamera.so)
      can be used for all variants now that the wrapper returns the
      correct number of comera (correct me if I'm wrong)
    - The vendor_samsung will need to be updated with libcamera.so removed
      for all models and http://www.mediafire.com/?3h7p4m0932l1dbv
      added as a proprietary file (renamed as libsamsungcamera.so).
      except for fascinatemtd, mesmerizemtd and showcasemtd and they
      require their libcamera.so with flash support. (Just rename
      the old one to libsamsungcamera.so)
    - This new libcamera.so requires a new prebuilt kernel (with
      pull request #41, which is already merged) for FFC to work.
      (only on models with FFC)

Change-Id: I1f179068bf9d5295a48d118be191cf65c834fe7b

8 files changed, 485 insertions, 6263 deletions

diff --git a/libcamera/Android.mk b/libcamera/Android.mk
index f4b41bb..fb274e8 100644
--- a/libcamera/Android.mk
+++ b/libcamera/Android.mk
@@ -1,51 +1,19 @@
-ifeq ($(Y_U_NO_HAVE_CAMERA),true)
+LOCAL_PATH:= $(call my-dir)
 
-# When zero we link against libqcamera; when 1, we dlopen libqcamera.
-ifeq ($(BOARD_CAMERA_LIBRARIES),libcamera)
+include $(CLEAR_VARS)
 
-DLOPEN_LIBSECCAMERA:=1
+LOCAL_SRC_FILES:= LibCameraWrapper.cpp
 
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
+LOCAL_SHARED_LIBRARIES:= libdl libutils libcutils libcamera_client
 
-LOCAL_CFLAGS:=-fno-short-enums
-LOCAL_CFLAGS+=-DDLOPEN_LIBSECCAMERA=$(DLOPEN_LIBSECCAMERA)
+LOCAL_MODULE := libcamera
+LOCAL_MODULE_TAGS := optional
 
-ifdef BOARD_CAMERA_DEVICE
-    LOCAL_CFLAGS += -DCAMERA_DEV_NAME=\"$(BOARD_CAMERA_DEVICE)\"
-endif
+LOCAL_PRELINK_MODULE := false
 
 ifdef BOARD_SECOND_CAMERA_DEVICE
-    LOCAL_CFLAGS += -DCAMERA_DEV_NAME2=\"$(BOARD_SECOND_CAMERA_DEVICE)\"
     LOCAL_CFLAGS += -DFFC_PRESENT
 endif
 
-LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
-LOCAL_C_INCLUDES += $(LOCAL_PATH)/../libs3cjpeg
-
-
-LOCAL_SRC_FILES:= \
-	SecCamera.cpp \
-	SecCameraHWInterface.cpp
-
-
-LOCAL_SHARED_LIBRARIES:= libutils libui liblog libbinder libcutils
-LOCAL_SHARED_LIBRARIES+= libs3cjpeg.aries
-LOCAL_SHARED_LIBRARIES+= libcamera_client
-
-ifeq ($(BOARD_USES_OVERLAY),true)
-LOCAL_CFLAGS += -DBOARD_USES_OVERLAY
-endif
-
-ifeq ($(DLOPEN_LIBSECCAMERA),1)
-LOCAL_SHARED_LIBRARIES+= libdl
-endif
-
-LOCAL_MODULE:= libcamera
-
-LOCAL_MODULE_TAGS := optional
-
 include $(BUILD_SHARED_LIBRARY)
 
-endif
-endif
diff --git a/libcamera/LibCameraWrapper.cpp b/libcamera/LibCameraWrapper.cpp
new file mode 100644
index 0000000..3ccf332
--- /dev/null
+++ b/libcamera/LibCameraWrapper.cpp
@@ -0,0 +1,414 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Adapted from JordanCameraWrapper
+
+// We can't use CameraParameters constants because we're linking against
+// Samsung's libcamera_client.so
+
+#define LOG_TAG "LibCameraWrapper"
+//#define LOG_NDEBUG 0
+
+#include <cmath>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <linux/videodev2.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <camera/Camera.h>
+#include "LibCameraWrapper.h"
+
+namespace android {
+
+typedef sp<CameraHardwareInterface> (*OpenCamFunc)(int);
+typedef void (*GetCamInfo)(int, struct CameraInfo*);
+
+static void * g_libHandle = NULL;
+static OpenCamFunc g_openCameraHardware = NULL;
+static GetCamInfo g_getCameraInfo = NULL;
+
+static const int CAMERA_CMD_SET_OBJECT_TRACKING_POSITION = 1103;
+static const int CAMERA_CMD_SET_TOUCH_AF = 1105;
+
+static void ensureLibOpened()
+{
+    if (g_libHandle == NULL) {
+        g_libHandle = ::dlopen("libsamsungcamera.so", RTLD_NOW);
+        if (g_libHandle == NULL) {
+            assert(0);
+            LOGE("dlopen() error: %s\n", dlerror());
+        } else {
+            g_openCameraHardware = (OpenCamFunc) ::dlsym(g_libHandle, "HAL_openCameraHardware");
+            g_getCameraInfo = (GetCamInfo) ::dlsym(g_libHandle, "HAL_getCameraInfo");
+            assert(g_openCameraHardware != NULL);
+        }
+    }
+}
+
+extern "C" int HAL_getNumberOfCameras()
+{
+#ifdef FFC_PRESENT
+    return 2;
+#else
+    return 1;
+#endif
+}
+
+extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo)
+{
+    ensureLibOpened();
+    g_getCameraInfo(cameraId, cameraInfo);
+}
+
+extern "C" sp<CameraHardwareInterface> HAL_openCameraHardware(int cameraId)
+{
+    LOGV("openCameraHardware: call createInstance");
+    ensureLibOpened();
+    return LibCameraWrapper::createInstance(cameraId);
+}
+
+wp<CameraHardwareInterface> LibCameraWrapper::singleton[2] = { 0 };
+
+sp<CameraHardwareInterface> LibCameraWrapper::createInstance(int cameraId)
+{
+    LOGV("%s :", __func__);
+    if (singleton[cameraId] != NULL) {
+        sp<CameraHardwareInterface> hardware = singleton[cameraId].promote();
+        if (hardware != NULL) {
+            return hardware;
+        }
+    }
+
+    ensureLibOpened();
+
+    sp<CameraHardwareInterface> hardware(new LibCameraWrapper(cameraId));
+    singleton[cameraId] = hardware;
+    return hardware;
+}
+
+LibCameraWrapper::LibCameraWrapper(int cameraId) :
+    mLibInterface(g_openCameraHardware(cameraId)),
+    mCameraId(cameraId),
+    mVideoMode(false),
+    mContinuousAf(false),
+    mTouchFocus(false)
+{
+    LOGV("%s :", __func__);
+}
+
+LibCameraWrapper::~LibCameraWrapper()
+{
+    LOGV("%s :", __func__);
+}
+
+sp<IMemoryHeap>
+LibCameraWrapper::getPreviewHeap() const
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->getPreviewHeap();
+}
+
+sp<IMemoryHeap>
+LibCameraWrapper::getRawHeap() const
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->getRawHeap();
+}
+
+void
+LibCameraWrapper::setCallbacks(notify_callback notify_cb,
+                                  data_callback data_cb,
+                                  data_callback_timestamp data_cb_timestamp,
+                                  void* user)
+{
+    LOGV("%s :", __func__);
+    mLibInterface->setCallbacks(notify_cb, data_cb, data_cb_timestamp, user);
+}
+
+void
+LibCameraWrapper::enableMsgType(int32_t msgType)
+{
+    LOGV("%s :", __func__);
+    mLibInterface->enableMsgType(msgType);
+}
+
+void
+LibCameraWrapper::disableMsgType(int32_t msgType)
+{
+    LOGV("%s :", __func__);
+    mLibInterface->disableMsgType(msgType);
+}
+
+bool
+LibCameraWrapper::msgTypeEnabled(int32_t msgType)
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->msgTypeEnabled(msgType);
+}
+
+status_t
+LibCameraWrapper::startPreview()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->startPreview();
+}
+
+bool
+LibCameraWrapper::useOverlay()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->useOverlay();
+}
+
+status_t
+LibCameraWrapper::setOverlay(const sp<Overlay> &overlay)
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->setOverlay(overlay);
+}
+
+void
+LibCameraWrapper::stopPreview()
+{
+    LOGV("%s :", __func__);
+    mLibInterface->stopPreview();
+}
+
+bool
+LibCameraWrapper::previewEnabled()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->previewEnabled();
+}
+
+status_t
+LibCameraWrapper::startRecording()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->startRecording();
+}
+
+void
+LibCameraWrapper::stopRecording()
+{
+    LOGV("%s :", __func__);
+    mLibInterface->stopRecording();
+}
+
+bool
+LibCameraWrapper::recordingEnabled()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->recordingEnabled();
+}
+
+void
+LibCameraWrapper::releaseRecordingFrame(const sp<IMemory>& mem)
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->releaseRecordingFrame(mem);
+}
+
+status_t
+LibCameraWrapper::autoFocus()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->autoFocus();
+}
+
+status_t
+LibCameraWrapper::cancelAutoFocus()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->cancelAutoFocus();
+}
+
+status_t
+LibCameraWrapper::takePicture()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->takePicture();
+}
+
+status_t
+LibCameraWrapper::cancelPicture()
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->cancelPicture();
+}
+
+status_t
+LibCameraWrapper::setParameters(const CameraParameters& params)
+{
+    LOGV("%s :", __func__);
+    CameraParameters pars(params.flatten());
+
+    if (mCameraId == 0) {
+        const char *metering;
+        const char *conAf;
+        const char *touchCoordinate;
+
+        /*
+         * getInt returns -1 if the value isn't present and 0 on parse failure,
+         * so if it's larger than 0, we can be sure the value was parsed properly
+         */
+        mVideoMode = pars.getInt("cam-mode") > 0;
+        pars.remove("cam-mode");
+
+        if (mVideoMode) {
+            // Special settings in video mode
+            pars.set("video_recording_gamma", "on");
+            pars.set("slow_ae", "on");
+            pars.set("iso", "movie");
+            pars.set("metering", "matrix");
+        }
+        else {
+            pars.set("video_recording_gamma", "off");
+            pars.set("slow_ae", "off");
+        }
+
+        // Parse continuous autofoucs into a format the driver understands
+        conAf = pars.get("enable-caf");
+        mContinuousAf = (conAf != 0 && strcmp(conAf, "on") == 0);
+        pars.set("continuous_af", mContinuousAf ? 1 : 0);
+
+        // Always set antibanding to 50hz
+        pars.set("antibanding", "50hz");
+
+        // Parse metering into something the driver understands
+        metering = pars.get("meter-mode");
+        if (metering != 0) {
+            if (strcmp(metering, "meter-center") == 0) {
+                pars.set("metering", "center");
+            }
+            else if (strcmp(metering, "meter-spot") == 0) {
+                pars.set("metering", "spot");
+            }
+            else if (strcmp(metering, "meter-matrix") == 0) {
+                pars.set("metering", "matrix");
+            }
+            pars.remove("auto-exposure");
+        }
+
+        // Read touch-to-focus
+        touchCoordinate = pars.get("touch-focus");
+        if (touchCoordinate != 0) {
+            int width, height;
+            int x, y;
+            char *comma;
+            x = mTouchFocusX = strtol(touchCoordinate, &comma, 10);
+            y = mTouchFocusY = strtol(comma + 1, NULL, 10);
+
+            pars.getPreviewSize(&width, &height);
+            if (fabs((float)width/height - 1.66) > 0.1) {
+                LOGV("Non-widescreen touch focus");
+                x += 80; // Only aries' Camera needs this for non-widescreen
+            }
+
+            sendCommand(CAMERA_CMD_SET_TOUCH_AF, 0, 0);
+            sendCommand(CAMERA_CMD_SET_OBJECT_TRACKING_POSITION, x, y);
+            sendCommand(CAMERA_CMD_SET_TOUCH_AF, 1, 0);
+
+            mTouchFocus = true;
+            pars.remove("touch-focus");
+        }
+        else if (mTouchFocus) {
+            LOGV("Disabling touch focus");
+            sendCommand(CAMERA_CMD_SET_TOUCH_AF, 0, 0);
+            mTouchFocus = false;
+        }
+
+    }
+
+    return mLibInterface->setParameters(pars);
+}
+
+CameraParameters
+LibCameraWrapper::getParameters() const
+{
+    LOGV("%s :", __func__);
+    CameraParameters ret = mLibInterface->getParameters();
+
+    if (mCameraId == 0) {
+        // The only value of antibanding supported is 50hz. Let's not say we support anything
+        ret.remove("antibanding-values");
+
+        // We support facedetect as well
+        ret.set("focus-mode-values", "auto,macro,facedetect");
+
+        // Auto-exposure modes. NOTE: matrix isn't a value supported in stock android
+        ret.set("meter-mode-values", "meter-center,meter-spot,meter-matrix");
+
+        // ISO values. The driver fails to return any of this.
+        ret.set("iso-values", "auto,50,100,200,400,800,1600,3200,sports,night,movie");
+
+        // Scene modes. The driver fails to return its proper supported values.
+        ret.set("scene-mode-values", "auto,portrait,landscape,sports,sunset,dusk-dawn,fireworks,beach,party,night,fall-color,text,candlelight,back-light");
+
+        // This is for detecting if we're in camcorder mode or not
+        ret.set("cam-mode", mVideoMode ? "1" : "0");
+
+        // Continuous AF
+        ret.set("enable-caf", mContinuousAf ? "on" : "off");
+
+        // Touch-to-focus
+        if (mTouchFocus) {
+            if (mTouchFocusX > 9999 || mTouchFocusY > 9999) {
+                LOGE("ERROR: Touch focus X, Y coordinate too large.");
+                ret.set("touch-focus", "");
+            }
+            else {
+                char touchfocus[10] = "";
+                sprintf(touchfocus, "%d,%d", mTouchFocusX, mTouchFocusY);
+                ret.set("touch-focus", touchfocus);
+            }
+        }
+        else {
+            ret.set("touch-focus", "");
+        }
+    }
+    else if (mCameraId == 1) {
+        // FFC: We need more preview and picture size to support GTalk
+        ret.set("preview-size-values", "176x144,320x240,640x480");
+        ret.set("picture-size-values", "176x144,320x240,640x480");
+    }
+
+    return ret;
+}
+
+status_t
+LibCameraWrapper::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->sendCommand(cmd, arg1, arg2);
+}
+
+void
+LibCameraWrapper::release()
+{
+    LOGV("%s :", __func__);
+    mLibInterface->release();
+}
+
+status_t
+LibCameraWrapper::dump(int fd, const Vector<String16>& args) const
+{
+    LOGV("%s :", __func__);
+    return mLibInterface->dump(fd, args);
+}
+
+}; //namespace android
diff --git a/libcamera/LibCameraWrapper.h b/libcamera/LibCameraWrapper.h
new file mode 100644
index 0000000..e999706
--- /dev/null
+++ b/libcamera/LibCameraWrapper.h
@@ -0,0 +1,64 @@
+#ifndef ANDROID_HARDWARE_LIB_CAMERA_WRAPPER_H
+#define ANDROID_HARDWARE_LIB_CAMERA_WRAPPER_H
+
+#include <camera/CameraHardwareInterface.h>
+
+namespace android {
+
+class LibCameraWrapper : public CameraHardwareInterface {
+public:
+    virtual sp<IMemoryHeap> getPreviewHeap() const;
+    virtual sp<IMemoryHeap> getRawHeap() const;
+
+    virtual void        setCallbacks(notify_callback notify_cb,
+                                     data_callback data_cb,
+                                     data_callback_timestamp data_cb_timestamp,
+                                     void *user);
+
+    virtual void        enableMsgType(int32_t msgType);
+    virtual void        disableMsgType(int32_t msgType);
+    virtual bool        msgTypeEnabled(int32_t msgType);
+
+    virtual status_t    startPreview();
+    virtual bool        useOverlay();
+    virtual status_t    setOverlay(const sp<Overlay> &overlay);
+    virtual void        stopPreview();
+    virtual bool        previewEnabled();
+
+    virtual status_t    startRecording();
+    virtual void        stopRecording();
+    virtual bool        recordingEnabled();
+    virtual void        releaseRecordingFrame(const sp<IMemory> &mem);
+
+    virtual status_t    autoFocus();
+    virtual status_t    cancelAutoFocus();
+    virtual status_t    takePicture();
+    virtual status_t    cancelPicture();
+    virtual status_t    dump(int fd, const Vector<String16> &args) const;
+    virtual status_t    setParameters(const CameraParameters& params);
+    virtual CameraParameters  getParameters() const;
+    virtual status_t    sendCommand(int32_t command, int32_t arg1,
+                                    int32_t arg2);
+    virtual void        release();
+
+    static    sp<CameraHardwareInterface> createInstance(int cameraId);
+
+private:
+            LibCameraWrapper(int CameraId);
+    virtual ~LibCameraWrapper();
+
+    sp<CameraHardwareInterface> mLibInterface;
+    int mCameraId;
+    bool mVideoMode;
+    bool mContinuousAf;
+    bool mTouchFocus;
+    int mTouchFocusX;
+    int mTouchFocusY;
+
+    static wp<CameraHardwareInterface> singleton[2];
+
+};
+
+}; // namespace android
+
+#endif
diff --git a/libcamera/NOTICE b/libcamera/NOTICE
deleted file mode 100644
index f921593..0000000
--- a/libcamera/NOTICE
+++ /dev/null
@@ -1,190 +0,0 @@
-
-   Copyright (C) 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.
-
-   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.
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
diff --git a/libcamera/SecCamera.cpp b/libcamera/SecCamera.cpp
deleted file mode 100644
index 4bd3fc7..0000000
--- a/libcamera/SecCamera.cpp
+++ /dev/null
@@ -1,3142 +0,0 @@
-/*
- * Copyright 2008, The Android Open Source Project
- * Copyright 2010, Samsung Electronics Co. LTD
- *
- * 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.
- */
-
-/*
-************************************
-* Filename: SecCamera.cpp
-* Author:   Sachin P. Kamat
-* Purpose:  This file interacts with the Camera and JPEG drivers.
-*************************************
-*/
-
-//#define LOG_NDEBUG 0
-#define LOG_TAG "SecCamera"
-
-#include <utils/Log.h>
-
-#include <string.h>
-#include <stdlib.h>
-#include <sys/poll.h>
-#include "SecCamera.h"
-#include "cutils/properties.h"
-
-using namespace android;
-
-#define CHECK(return_value)                                          \
-    if (return_value < 0) {                                          \
-        LOGE("%s::%d fail. errno: %s, m_camera_id = %d\n",           \
-             __func__, __LINE__, strerror(errno), m_camera_id);      \
-        return -1;                                                   \
-    }
-
-
-#define CHECK_PTR(return_value)                                      \
-    if (return_value < 0) {                                          \
-        LOGE("%s::%d fail, errno: %s, m_camera_id = %d\n",           \
-             __func__,__LINE__, strerror(errno), m_camera_id);       \
-        return NULL;                                                 \
-    }
-
-#define ALIGN_TO_32B(x)   ((((x) + (1 <<  5) - 1) >>  5) <<  5)
-#define ALIGN_TO_128B(x)  ((((x) + (1 <<  7) - 1) >>  7) <<  7)
-#define ALIGN_TO_8KB(x)   ((((x) + (1 << 13) - 1) >> 13) << 13)
-
-namespace android {
-
-// ======================================================================
-// Camera controls
-
-static struct timeval time_start;
-static struct timeval time_stop;
-
-unsigned long measure_time(struct timeval *start, struct timeval *stop)
-{
-    unsigned long sec, usec, time;
-
-    sec = stop->tv_sec - start->tv_sec;
-
-    if (stop->tv_usec >= start->tv_usec) {
-        usec = stop->tv_usec - start->tv_usec;
-    } else {
-        usec = stop->tv_usec + 1000000 - start->tv_usec;
-        sec--;
-    }
-
-    time = (sec * 1000000) + usec;
-
-    return time;
-}
-
-static int get_pixel_depth(unsigned int fmt)
-{
-    int depth = 0;
-
-    switch (fmt) {
-    case V4L2_PIX_FMT_NV12:
-        depth = 12;
-        break;
-    case V4L2_PIX_FMT_NV12T:
-        depth = 12;
-        break;
-    case V4L2_PIX_FMT_NV21:
-        depth = 12;
-        break;
-    case V4L2_PIX_FMT_YUV420:
-        depth = 12;
-        break;
-
-    case V4L2_PIX_FMT_RGB565:
-    case V4L2_PIX_FMT_YUYV:
-    case V4L2_PIX_FMT_YVYU:
-    case V4L2_PIX_FMT_UYVY:
-    case V4L2_PIX_FMT_VYUY:
-    case V4L2_PIX_FMT_NV16:
-    case V4L2_PIX_FMT_NV61:
-    case V4L2_PIX_FMT_YUV422P:
-        depth = 16;
-        break;
-
-    case V4L2_PIX_FMT_RGB32:
-        depth = 32;
-        break;
-    }
-
-    return depth;
-}
-
-#define ALIGN_W(x)      (((x) + 0x7F) & (~0x7F))    // Set as multiple of 128
-#define ALIGN_H(x)      (((x) + 0x1F) & (~0x1F))    // Set as multiple of 32
-#define ALIGN_BUF(x)    (((x) + 0x1FFF)& (~0x1FFF)) // Set as multiple of 8K
-
-static int init_preview_buffers(struct fimc_buffer *buffers, int width, int height, unsigned int fmt)
-{
-    int i, len;
-
-    if (fmt==V4L2_PIX_FMT_NV12T) {
-        len = ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height)) +
-              ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height / 2));
-    } else {
-        len = (width * height * get_pixel_depth(fmt)) / 8;
-    }
-
-    for (i = 0; i < MAX_BUFFERS; i++) {
-        buffers[i].length = len;
-    }
-
-    return 0;
-}
-
-static int fimc_poll(struct pollfd *events)
-{
-    int ret;
-
-    /* 10 second delay is because sensor can take a long time
-     * to do auto focus and capture in dark settings
-     */
-    ret = poll(events, 1, 10000);
-    if (ret < 0) {
-        LOGE("ERR(%s):poll error\n", __func__);
-        return ret;
-    }
-
-    if (ret == 0) {
-        LOGE("ERR(%s):No data in 10 secs..\n", __func__);
-        return ret;
-    }
-
-    return ret;
-}
-
-int SecCamera::previewPoll(bool preview)
-{
-    int ret;
-
-    if (preview) {
-#ifdef ENABLE_ESD_PREVIEW_CHECK
-        int status = 0;
-
-        if (!(++m_esd_check_count % 60)) {
-            status = getCameraSensorESDStatus();
-            m_esd_check_count = 0;
-            if (status) {
-               LOGE("ERR(%s) ESD status(%d)", __func__, status);
-               return status;
-            }
-        }
-#endif
-
-        ret = poll(&m_events_c, 1, 1000);
-    } else {
-        ret = poll(&m_events_c2, 1, 1000);
-    }
-
-    if (ret < 0) {
-        LOGE("ERR(%s):poll error\n", __func__);
-        return ret;
-    }
-
-    if (ret == 0) {
-        LOGE("ERR(%s):No data in 1 secs.. Camera Device Reset \n", __func__);
-        return ret;
-    }
-
-    return ret;
-}
-
-static int fimc_v4l2_querycap(int fp)
-{
-    struct v4l2_capability cap;
-    int ret = 0;
-
-    ret = ioctl(fp, VIDIOC_QUERYCAP, &cap);
-
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_QUERYCAP failed\n", __func__);
-        return -1;
-    }
-
-    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
-        LOGE("ERR(%s):no capture devices\n", __func__);
-        return -1;
-    }
-
-    return ret;
-}
-
-static const __u8* fimc_v4l2_enuminput(int fp, int index)
-{
-    static struct v4l2_input input;
-
-    input.index = index;
-    if (ioctl(fp, VIDIOC_ENUMINPUT, &input) != 0) {
-        LOGE("ERR(%s):No matching index found\n", __func__);
-        return NULL;
-    }
-    LOGI("Name of input channel[%d] is %s\n", input.index, input.name);
-
-    return input.name;
-}
-
-
-static int fimc_v4l2_s_input(int fp, int index)
-{
-    struct v4l2_input input;
-    int ret;
-
-    input.index = index;
-
-    ret = ioctl(fp, VIDIOC_S_INPUT, &input);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_S_INPUT failed\n", __func__);
-        return ret;
-    }
-
-    return ret;
-}
-
-static int fimc_v4l2_s_fmt(int fp, int width, int height, unsigned int fmt, int flag_capture)
-{
-    struct v4l2_format v4l2_fmt;
-    struct v4l2_pix_format pixfmt;
-    int ret;
-
-    v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-    memset(&pixfmt, 0, sizeof(pixfmt));
-
-    pixfmt.width = width;
-    pixfmt.height = height;
-    pixfmt.pixelformat = fmt;
-
-    pixfmt.sizeimage = (width * height * get_pixel_depth(fmt)) / 8;
-
-    pixfmt.field = V4L2_FIELD_NONE;
-
-    v4l2_fmt.fmt.pix = pixfmt;
-
-    /* Set up for capture */
-    ret = ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_S_FMT failed\n", __func__);
-        return -1;
-    }
-
-    return 0;
-}
-
-static int fimc_v4l2_s_fmt_cap(int fp, int width, int height, unsigned int fmt)
-{
-    struct v4l2_format v4l2_fmt;
-    struct v4l2_pix_format pixfmt;
-    int ret;
-
-    memset(&pixfmt, 0, sizeof(pixfmt));
-
-    v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-    pixfmt.width = width;
-    pixfmt.height = height;
-    pixfmt.pixelformat = fmt;
-    if (fmt == V4L2_PIX_FMT_JPEG) {
-        pixfmt.colorspace = V4L2_COLORSPACE_JPEG;
-    }
-
-    pixfmt.sizeimage = (width * height * get_pixel_depth(fmt)) / 8;
-
-    v4l2_fmt.fmt.pix = pixfmt;
-
-    LOGV("ori_w %d, ori_h %d, w %d, h %d\n", width, height, v4l2_fmt.fmt.pix.width, v4l2_fmt.fmt.pix.height);
-
-    /* Set up for capture */
-    ret = ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_S_FMT failed\n", __func__);
-        return ret;
-    }
-
-    return ret;
-}
-
-static int fimc_v4l2_enum_fmt(int fp, unsigned int fmt)
-{
-    struct v4l2_fmtdesc fmtdesc;
-    int found = 0;
-
-    fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    fmtdesc.index = 0;
-
-    while (ioctl(fp, VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
-        if (fmtdesc.pixelformat == fmt) {
-            LOGV("passed fmt = %#x found pixel format[%d]: %s\n", fmt, fmtdesc.index, fmtdesc.description);
-            found = 1;
-            break;
-        }
-
-        fmtdesc.index++;
-    }
-
-    if (!found) {
-        LOGE("unsupported pixel format\n");
-        return -1;
-    }
-
-    return 0;
-}
-
-static int fimc_v4l2_reqbufs(int fp, enum v4l2_buf_type type, int nr_bufs)
-{
-    struct v4l2_requestbuffers req;
-    int ret;
-
-    req.count = nr_bufs;
-    req.type = type;
-    req.memory = V4L2_MEMORY_MMAP;
-
-    ret = ioctl(fp, VIDIOC_REQBUFS, &req);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_REQBUFS failed\n", __func__);
-        return -1;
-    }
-
-    return req.count;
-}
-
-static int fimc_v4l2_querybuf(int fp, struct fimc_buffer *buffer, enum v4l2_buf_type type)
-{
-    struct v4l2_buffer v4l2_buf;
-    int ret;
-
-    LOGI("%s :", __func__);
-
-    v4l2_buf.type = type;
-    v4l2_buf.memory = V4L2_MEMORY_MMAP;
-    v4l2_buf.index = 0;
-
-    ret = ioctl(fp , VIDIOC_QUERYBUF, &v4l2_buf);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_QUERYBUF failed\n", __func__);
-        return -1;
-    }
-
-    buffer->length = v4l2_buf.length;
-    if ((buffer->start = (char *)mmap(0, v4l2_buf.length,
-                                         PROT_READ | PROT_WRITE, MAP_SHARED,
-                                         fp, v4l2_buf.m.offset)) < 0) {
-         LOGE("%s %d] mmap() failed\n",__func__, __LINE__);
-         return -1;
-    }
-
-    LOGI("%s: buffer->start = %p v4l2_buf.length = %d",
-         __func__, buffer->start, v4l2_buf.length);
-
-    return 0;
-}
-
-static int fimc_v4l2_streamon(int fp)
-{
-    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    int ret;
-
-    ret = ioctl(fp, VIDIOC_STREAMON, &type);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_STREAMON failed\n", __func__);
-        return ret;
-    }
-
-    return ret;
-}
-
-static int fimc_v4l2_streamoff(int fp)
-{
-    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    int ret;
-
-    LOGV("%s :", __func__);
-    ret = ioctl(fp, VIDIOC_STREAMOFF, &type);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_STREAMOFF failed\n", __func__);
-        return ret;
-    }
-
-    return ret;
-}
-
-static int fimc_v4l2_qbuf(int fp, int index)
-{
-    struct v4l2_buffer v4l2_buf;
-    int ret;
-
-    v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    v4l2_buf.memory = V4L2_MEMORY_MMAP;
-    v4l2_buf.index = index;
-
-    ret = ioctl(fp, VIDIOC_QBUF, &v4l2_buf);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_QBUF failed\n", __func__);
-        return ret;
-    }
-
-    return 0;
-}
-
-static int fimc_v4l2_dqbuf(int fp)
-{
-    struct v4l2_buffer v4l2_buf;
-    int ret;
-
-    v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    v4l2_buf.memory = V4L2_MEMORY_MMAP;
-
-    ret = ioctl(fp, VIDIOC_DQBUF, &v4l2_buf);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_DQBUF failed, dropped frame\n", __func__);
-        return ret;
-    }
-
-    return v4l2_buf.index;
-}
-
-static int fimc_v4l2_g_ctrl(int fp, unsigned int id)
-{
-    struct v4l2_control ctrl;
-    int ret;
-
-    ctrl.id = id;
-
-    ret = ioctl(fp, VIDIOC_G_CTRL, &ctrl);
-    if (ret < 0) {
-        LOGE("ERR(%s): VIDIOC_G_CTRL(id = 0x%x (%d)) failed, ret = %d\n",
-             __func__, id, id-V4L2_CID_PRIVATE_BASE, ret);
-        return ret;
-    }
-
-    return ctrl.value;
-}
-
-static int fimc_v4l2_s_ctrl(int fp, unsigned int id, unsigned int value)
-{
-    struct v4l2_control ctrl;
-    int ret;
-
-    ctrl.id = id;
-    ctrl.value = value;
-
-    ret = ioctl(fp, VIDIOC_S_CTRL, &ctrl);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_S_CTRL(id = %#x (%d), value = %d) failed ret = %d\n",
-             __func__, id, id-V4L2_CID_PRIVATE_BASE, value, ret);
-
-        return ret;
-    }
-
-    return ctrl.value;
-}
-
-static int fimc_v4l2_s_ext_ctrl(int fp, unsigned int id, void *value)
-{
-    struct v4l2_ext_controls ctrls;
-    struct v4l2_ext_control ctrl;
-    int ret;
-
-    ctrl.id = id;
-    ctrl.reserved = value;
-
-    ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
-    ctrls.count = 1;
-    ctrls.controls = &ctrl;
-
-    ret = ioctl(fp, VIDIOC_S_EXT_CTRLS, &ctrls);
-    if (ret < 0)
-        LOGE("ERR(%s):VIDIOC_S_EXT_CTRLS failed\n", __func__);
-
-    return ret;
-}
-
-static int fimc_v4l2_g_parm(int fp, struct v4l2_streamparm *streamparm)
-{
-    int ret;
-
-    streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-    ret = ioctl(fp, VIDIOC_G_PARM, streamparm);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_G_PARM failed\n", __func__);
-        return -1;
-    }
-
-    LOGV("%s : timeperframe: numerator %d, denominator %d\n", __func__,
-            streamparm->parm.capture.timeperframe.numerator,
-            streamparm->parm.capture.timeperframe.denominator);
-
-    return 0;
-}
-
-static int fimc_v4l2_s_parm(int fp, struct v4l2_streamparm *streamparm)
-{
-    int ret;
-
-    streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-    ret = ioctl(fp, VIDIOC_S_PARM, streamparm);
-    if (ret < 0) {
-        LOGE("ERR(%s):VIDIOC_S_PARM failed\n", __func__);
-        return ret;
-    }
-
-    return 0;
-}
-
-// ======================================================================
-// Constructor & Destructor
-
-SecCamera::SecCamera() :
-            m_flag_init(0),
-            m_camera_id(CAMERA_ID_BACK),
-            m_preview_v4lformat(V4L2_PIX_FMT_NV21),
-            m_preview_width      (0),
-            m_preview_height     (0),
-            m_preview_max_width  (MAX_BACK_CAMERA_PREVIEW_WIDTH),
-            m_preview_max_height (MAX_BACK_CAMERA_PREVIEW_HEIGHT),
-            m_snapshot_v4lformat(-1),
-            m_snapshot_width      (0),
-            m_snapshot_height     (0),
-            m_snapshot_max_width  (MAX_BACK_CAMERA_SNAPSHOT_WIDTH),
-            m_snapshot_max_height (MAX_BACK_CAMERA_SNAPSHOT_HEIGHT),
-            m_angle(-1),
-            m_anti_banding(-1),
-            m_wdr(-1),
-            m_anti_shake(-1),
-            m_zoom_level(-1),
-            m_object_tracking(-1),
-            m_smart_auto(-1),
-            m_beauty_shot(-1),
-            m_vintage_mode(-1),
-            m_face_detect(-1),
-            m_gps_latitude(-1),
-            m_gps_longitude(-1),
-            m_gps_altitude(-1),
-            m_gps_timestamp(-1),
-            m_vtmode(0),
-            m_sensor_mode(-1),
-            m_shot_mode(-1),
-            m_exif_orientation(-1),
-            m_blur_level(-1),
-            m_chk_dataline(-1),
-            m_video_gamma(-1),
-            m_slow_ae(-1),
-            m_camera_af_flag(-1),
-            m_flag_camera_start(0),
-            m_jpeg_thumbnail_width (0),
-            m_jpeg_thumbnail_height(0),
-            m_jpeg_quality(100)
-#ifdef ENABLE_ESD_PREVIEW_CHECK
-            ,
-            m_esd_check_count(0)
-#endif // ENABLE_ESD_PREVIEW_CHECK
-{
-    m_params = (struct sec_cam_parm*)&m_streamparm.parm.raw_data;
-    struct v4l2_captureparm capture;
-    m_params->capture.timeperframe.numerator = 1;
-    m_params->capture.timeperframe.denominator = 0;
-    m_params->contrast = -1;
-    m_params->effects = -1;
-    m_params->brightness = -1;
-    m_params->flash_mode = -1;
-    m_params->focus_mode = -1;
-    m_params->iso = -1;
-    m_params->metering = -1;
-    m_params->saturation = -1;
-    m_params->scene_mode = -1;
-    m_params->sharpness = -1;
-    m_params->white_balance = -1;
-
-    memset(&m_capture_buf, 0, sizeof(m_capture_buf));
-
-    LOGV("%s :", __func__);
-}
-
-int SecCamera::flagCreate(void) const
-{
-    LOGV("%s : : %d", __func__, m_flag_init);
-    return m_flag_init;
-}
-
-SecCamera::~SecCamera()
-{
-    LOGV("%s :", __func__);
-}
-
-int SecCamera::initCamera(int index)
-{
-    LOGV("%s :", __func__);
-    int ret = 0;
-
-    if (!m_flag_init) {
-        /* Arun C
-         * Reset the lense position only during camera starts; don't do
-         * reset between shot to shot
-         */
-        m_camera_af_flag = -1;
-
-        m_cam_fd_temp = -1;
-        m_cam_fd2_temp = -1;
-
-        m_cam_fd = open(CAMERA_DEV_NAME, O_RDWR);
-        if (m_cam_fd < 0) {
-            LOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME, strerror(errno));
-            return -1;
-        }
-
-        if (m_cam_fd < 3) { // for 0, 1, 2
-            LOGE("ERR(%s):m_cam_fd is %d\n", __func__, m_cam_fd);
-
-            close(m_cam_fd);
-
-            m_cam_fd_temp = open(CAMERA_DEV_NAME_TEMP, O_CREAT);
-
-            LOGE("ERR(%s):m_cam_fd_temp is %d\n", __func__, m_cam_fd_temp);
-
-            m_cam_fd = open(CAMERA_DEV_NAME, O_RDWR);
-
-            if (m_cam_fd < 3) { // for 0, 1, 2
-                LOGE("ERR(%s):retring to open %s is failed, %d\n", __func__, CAMERA_DEV_NAME, m_cam_fd);
-
-                if (m_cam_fd < 0) {
-                    return -1;
-                } else {
-                    close(m_cam_fd);
-                    m_cam_fd = -1;
-                }
-
-                if (m_cam_fd_temp != -1){
-                    close(m_cam_fd_temp);
-                    m_cam_fd_temp = -1;
-                }
-                return -1;
-            }
-        }
-
-        LOGE("initCamera: m_cam_fd(%d), m_jpeg_fd(%d)", m_cam_fd, m_jpeg_fd);
-
-        ret = fimc_v4l2_querycap(m_cam_fd);
-        CHECK(ret);
-        if (!fimc_v4l2_enuminput(m_cam_fd, index))
-            return -1;
-        ret = fimc_v4l2_s_input(m_cam_fd, index);
-        CHECK(ret);
-
-        m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR);
-        if (m_cam_fd2 < 0) {
-            LOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME2, strerror(errno));
-            return -1;
-        }
-        if (m_cam_fd2 < 3) { // for 0, 1, 2
-            LOGE("ERR(%s):m_cam_fd2 is %d\n", __func__, m_cam_fd2);
-
-            close(m_cam_fd2);
-
-            m_cam_fd2_temp = open(CAMERA_DEV_NAME2_TEMP, O_CREAT);
-
-            LOGE("ERR(%s):m_cam_fd2_temp is %d\n", __func__, m_cam_fd2_temp);
-
-            m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR);
-
-            if (m_cam_fd2 < 3) { // for 0, 1, 2
-                LOGE("ERR(%s):retring to open %s is failed, %d\n", __func__, CAMERA_DEV_NAME2, m_cam_fd2);
-
-                if (m_cam_fd2 < 0) {
-                    return -1;
-                }
-                else{
-                    close(m_cam_fd2);
-                    m_cam_fd2 = -1;
-                }
-
-                if (m_cam_fd2_temp != -1) {
-                    close(m_cam_fd2_temp);
-                    m_cam_fd2_temp = -1;
-                }
-
-                return -1;
-            }
-        }
-
-        if (m_cam_fd_temp != -1) {
-            close(m_cam_fd_temp);
-            m_cam_fd_temp = -1;
-        }
-
-        if (m_cam_fd2_temp != -1) {
-            close(m_cam_fd2_temp);
-            m_cam_fd2_temp = -1;
-        }
-
-        LOGE("initCamera: m_cam_fd2(%d)", m_cam_fd2);
-
-        ret = fimc_v4l2_querycap(m_cam_fd2);
-        CHECK(ret);
-        if (!fimc_v4l2_enuminput(m_cam_fd2, index))
-            return -1;
-        ret = fimc_v4l2_s_input(m_cam_fd2, index);
-        CHECK(ret);
-
-        m_camera_id = index;
-
-        switch (m_camera_id) {
-        case CAMERA_ID_FRONT:
-            m_preview_max_width   = MAX_FRONT_CAMERA_PREVIEW_WIDTH;
-            m_preview_max_height  = MAX_FRONT_CAMERA_PREVIEW_HEIGHT;
-            m_snapshot_max_width  = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH;
-            m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT;
-            break;
-
-        case CAMERA_ID_BACK:
-            m_preview_max_width   = MAX_BACK_CAMERA_PREVIEW_WIDTH;
-            m_preview_max_height  = MAX_BACK_CAMERA_PREVIEW_HEIGHT;
-            m_snapshot_max_width  = MAX_BACK_CAMERA_SNAPSHOT_WIDTH;
-            m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT;
-            break;
-        }
-
-        setExifFixedAttribute();
-
-        m_flag_init = 1;
-    }
-    return 0;
-}
-
-void SecCamera::resetCamera()
-{
-    LOGV("%s :", __func__);
-    DeinitCamera();
-    initCamera(m_camera_id);
-}
-
-void SecCamera::DeinitCamera()
-{
-    LOGV("%s :", __func__);
-
-    if (m_flag_init) {
-
-        stopRecord();
-
-        /* close m_cam_fd after stopRecord() because stopRecord()
-         * uses m_cam_fd to change frame rate
-         */
-        LOGI("DeinitCamera: m_cam_fd(%d)", m_cam_fd);
-        if (m_cam_fd > -1) {
-            close(m_cam_fd);
-            m_cam_fd = -1;
-        }
-
-        LOGI("DeinitCamera: m_cam_fd2(%d)", m_cam_fd2);
-        if (m_cam_fd2 > -1) {
-            close(m_cam_fd2);
-            m_cam_fd2 = -1;
-        }
-
-        if (m_cam_fd_temp != -1) {
-            close(m_cam_fd_temp);
-            m_cam_fd_temp = -1;
-        }
-
-        if (m_cam_fd2_temp != -1) {
-            close(m_cam_fd2_temp);
-            m_cam_fd2_temp = -1;
-        }
-
-        m_flag_init = 0;
-    }
-}
-
-
-int SecCamera::getCameraFd(void)
-{
-    return m_cam_fd;
-}
-
-// ======================================================================
-// Preview
-
-int SecCamera::startPreview(void)
-{
-    v4l2_streamparm streamparm;
-    struct sec_cam_parm *parms;
-    parms = (struct sec_cam_parm*)&streamparm.parm.raw_data;
-    LOGV("%s :", __func__);
-
-    // aleady started
-    if (m_flag_camera_start > 0) {
-        LOGE("ERR(%s):Preview was already started\n", __func__);
-        return 0;
-    }
-
-    if (m_cam_fd <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    memset(&m_events_c, 0, sizeof(m_events_c));
-    m_events_c.fd = m_cam_fd;
-    m_events_c.events = POLLIN | POLLERR;
-
-    /* enum_fmt, s_fmt sample */
-    int ret = fimc_v4l2_enum_fmt(m_cam_fd,m_preview_v4lformat);
-    CHECK(ret);
-    ret = fimc_v4l2_s_fmt(m_cam_fd, m_preview_width,m_preview_height,m_preview_v4lformat, 0);
-    CHECK(ret);
-
-    ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
-    CHECK(ret);
-
-    LOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d\n",
-            __func__, m_preview_width, m_preview_height, m_angle);
-
-    ret = fimc_v4l2_s_ctrl(m_cam_fd,
-                           V4L2_CID_CAMERA_CHECK_DATALINE, m_chk_dataline);
-    CHECK(ret);
-
-    if (m_camera_id == CAMERA_ID_FRONT) {
-        /* VT mode setting */
-        ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VT_MODE, m_vtmode);
-        CHECK(ret);
-    }
-
-    /* start with all buffers in queue */
-    for (int i = 0; i < MAX_BUFFERS; i++) {
-        ret = fimc_v4l2_qbuf(m_cam_fd, i);
-        CHECK(ret);
-    }
-
-    ret = fimc_v4l2_streamon(m_cam_fd);
-    CHECK(ret);
-
-    m_flag_camera_start = 1;
-
-    ret = fimc_v4l2_s_parm(m_cam_fd, &m_streamparm);
-    CHECK(ret);
-
-    if (m_camera_id == CAMERA_ID_FRONT) {
-        /* Blur setting */
-        LOGV("m_blur_level = %d", m_blur_level);
-        ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR,
-                               m_blur_level);
-        CHECK(ret);
-    }
-
-    // It is a delay for a new frame, not to show the previous bigger ugly picture frame.
-    ret = fimc_poll(&m_events_c);
-    CHECK(ret);
-    ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_RETURN_FOCUS, 0);
-    CHECK(ret);
-
-    LOGV("%s: got the first frame of the preview\n", __func__);
-
-    return 0;
-}
-
-int SecCamera::stopPreview(void)
-{
-    int ret;
-
-    LOGV("%s :", __func__);
-
-    if (m_flag_camera_start == 0) {
-        LOGW("%s: doing nothing because m_flag_camera_start is zero", __func__);
-        return 0;
-    }
-
-    if (m_params->flash_mode == FLASH_MODE_TORCH)
-        setFlashMode(FLASH_MODE_OFF);
-
-    if (m_cam_fd <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    ret = fimc_v4l2_streamoff(m_cam_fd);
-    CHECK(ret);
-
-    m_flag_camera_start = 0;
-
-    return ret;
-}
-
-//Recording
-int SecCamera::startRecord(void)
-{
-    int ret, i;
-
-    LOGV("%s :", __func__);
-
-    // aleady started
-    if (m_flag_record_start > 0) {
-        LOGE("ERR(%s):Preview was already started\n", __func__);
-        return 0;
-    }
-
-    if (m_cam_fd2 <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    /* enum_fmt, s_fmt sample */
-    ret = fimc_v4l2_enum_fmt(m_cam_fd2, V4L2_PIX_FMT_NV12T);
-    CHECK(ret);
-
-    LOGI("%s: m_recording_width = %d, m_recording_height = %d\n",
-         __func__, m_recording_width, m_recording_height);
-
-    ret = fimc_v4l2_s_fmt(m_cam_fd2, m_recording_width,
-                          m_recording_height, V4L2_PIX_FMT_NV12T, 0);
-    CHECK(ret);
-
-    ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE,
-                            m_params->capture.timeperframe.denominator);
-    CHECK(ret);
-
-    ret = fimc_v4l2_reqbufs(m_cam_fd2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
-    CHECK(ret);
-
-    /* start with all buffers in queue */
-    for (i = 0; i < MAX_BUFFERS; i++) {
-        ret = fimc_v4l2_qbuf(m_cam_fd2, i);
-        CHECK(ret);
-    }
-
-    ret = fimc_v4l2_streamon(m_cam_fd2);
-    CHECK(ret);
-
-    // Get and throw away the first frame since it is often garbled.
-    memset(&m_events_c2, 0, sizeof(m_events_c2));
-    m_events_c2.fd = m_cam_fd2;
-    m_events_c2.events = POLLIN | POLLERR;
-    ret = fimc_poll(&m_events_c2);
-    CHECK(ret);
-
-    m_flag_record_start = 1;
-
-    return 0;
-}
-
-int SecCamera::stopRecord(void)
-{
-    int ret;
-
-    LOGV("%s :", __func__);
-
-    if (m_flag_record_start == 0) {
-        LOGW("%s: doing nothing because m_flag_record_start is zero", __func__);
-        return 0;
-    }
-
-    if (m_cam_fd2 <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    m_flag_record_start = 0;
-
-    ret = fimc_v4l2_streamoff(m_cam_fd2);
-    CHECK(ret);
-
-    ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE,
-                            FRAME_RATE_AUTO);
-    CHECK(ret);
-
-    return 0;
-}
-
-unsigned int SecCamera::getRecPhyAddrY(int index)
-{
-    unsigned int addr_y;
-
-    addr_y = fimc_v4l2_s_ctrl(m_cam_fd2, V4L2_CID_PADDR_Y, index);
-    CHECK((int)addr_y);
-    return addr_y;
-}
-
-unsigned int SecCamera::getRecPhyAddrC(int index)
-{
-    unsigned int addr_c;
-
-    addr_c = fimc_v4l2_s_ctrl(m_cam_fd2, V4L2_CID_PADDR_CBCR, index);
-    CHECK((int)addr_c);
-    return addr_c;
-}
-
-unsigned int SecCamera::getPhyAddrY(int index)
-{
-    unsigned int addr_y;
-
-    addr_y = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_Y, index);
-    CHECK((int)addr_y);
-    return addr_y;
-}
-
-unsigned int SecCamera::getPhyAddrC(int index)
-{
-    unsigned int addr_c;
-
-    addr_c = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_CBCR, index);
-    CHECK((int)addr_c);
-    return addr_c;
-}
-
-void SecCamera::pausePreview()
-{
-    fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
-}
-
-int SecCamera::getPreview()
-{
-    int index;
-    int ret;
-
-    if (m_flag_camera_start == 0 || previewPoll(true) == 0) {
-        LOGE("ERR(%s):Start Camera Device Reset \n", __func__);
-        /* GAUDI Project([arun.c@samsung.com]) 2010.05.20. [Implemented ESD code] */
-        /*
-         * When there is no data for more than 1 second from the camera we inform
-         * the FIMC driver by calling fimc_v4l2_s_input() with a special value = 1000
-         * FIMC driver identify that there is something wrong with the camera
-         * and it restarts the sensor.
-         */
-        stopPreview();
-        /* Reset Only Camera Device */
-        ret = fimc_v4l2_querycap(m_cam_fd);
-        CHECK(ret);
-        if (fimc_v4l2_enuminput(m_cam_fd, m_camera_id))
-            return -1;
-        ret = fimc_v4l2_s_input(m_cam_fd, 1000);
-        CHECK(ret);
-        ret = startPreview();
-        if (ret < 0) {
-            LOGE("ERR(%s): startPreview() return %d\n", __func__, ret);
-            return 0;
-        }
-    }
-
-    index = fimc_v4l2_dqbuf(m_cam_fd);
-    if (!(0 <= index && index < MAX_BUFFERS)) {
-        LOGE("ERR(%s):wrong index = %d\n", __func__, index);
-        return -1;
-    }
-
-    ret = fimc_v4l2_qbuf(m_cam_fd, index);
-    CHECK(ret);
-
-    return index;
-}
-
-int SecCamera::getRecordFrame()
-{
-    if (m_flag_record_start == 0) {
-        LOGE("%s: m_flag_record_start is 0", __func__);
-        return -1;
-    }
-
-    previewPoll(false);
-    return fimc_v4l2_dqbuf(m_cam_fd2);
-}
-
-int SecCamera::releaseRecordFrame(int index)
-{
-    if (!m_flag_record_start) {
-        /* this can happen when recording frames are returned after
-         * the recording is stopped at the driver level.  we don't
-         * need to return the buffers in this case and we've seen
-         * cases where fimc could crash if we called qbuf and it
-         * wasn't expecting it.
-         */
-        LOGI("%s: recording not in progress, ignoring", __func__);
-        return 0;
-    }
-
-    return fimc_v4l2_qbuf(m_cam_fd2, index);
-}
-
-int SecCamera::setPreviewSize(int width, int height, int pixel_format)
-{
-    LOGV("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format);
-
-    int v4lpixelformat = pixel_format;
-
-#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
-    if (v4lpixelformat == V4L2_PIX_FMT_YUV420)
-        LOGV("PreviewFormat:V4L2_PIX_FMT_YUV420");
-    else if (v4lpixelformat == V4L2_PIX_FMT_NV12)
-        LOGV("PreviewFormat:V4L2_PIX_FMT_NV12");
-    else if (v4lpixelformat == V4L2_PIX_FMT_NV12T)
-        LOGV("PreviewFormat:V4L2_PIX_FMT_NV12T");
-    else if (v4lpixelformat == V4L2_PIX_FMT_NV21)
-        LOGV("PreviewFormat:V4L2_PIX_FMT_NV21");
-    else if (v4lpixelformat == V4L2_PIX_FMT_YUV422P)
-        LOGV("PreviewFormat:V4L2_PIX_FMT_YUV422P");
-    else if (v4lpixelformat == V4L2_PIX_FMT_YUYV)
-        LOGV("PreviewFormat:V4L2_PIX_FMT_YUYV");
-    else if (v4lpixelformat == V4L2_PIX_FMT_RGB565)
-        LOGV("PreviewFormat:V4L2_PIX_FMT_RGB565");
-    else
-        LOGV("PreviewFormat:UnknownFormat");
-#endif
-    m_preview_width  = width;
-    m_preview_height = height;
-    m_preview_v4lformat = v4lpixelformat;
-
-    return 0;
-}
-
-int SecCamera::getPreviewSize(int *width, int *height, int *frame_size)
-{
-    *width  = m_preview_width;
-    *height = m_preview_height;
-    *frame_size = m_frameSize(m_preview_v4lformat, m_preview_width, m_preview_height);
-
-    return 0;
-}
-
-int SecCamera::getPreviewMaxSize(int *width, int *height)
-{
-    *width  = m_preview_max_width;
-    *height = m_preview_max_height;
-
-    return 0;
-}
-
-int SecCamera::getPreviewPixelFormat(void)
-{
-    return m_preview_v4lformat;
-}
-
-
-// ======================================================================
-// Snapshot
-/*
- * Devide getJpeg() as two funcs, setSnapshotCmd() & getJpeg() because of the shutter sound timing.
- * Here, just send the capture cmd to camera ISP to start JPEG capture.
- */
-int SecCamera::setSnapshotCmd(void)
-{
-    LOGV("%s :", __func__);
-
-    int ret = 0;
-
-    LOG_TIME_DEFINE(0)
-    LOG_TIME_DEFINE(1)
-
-    if (m_cam_fd <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return 0;
-    }
-
-    if (m_flag_camera_start > 0) {
-        LOG_TIME_START(0)
-        LOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__);
-        stopPreview();
-        LOG_TIME_END(0)
-    }
-
-    memset(&m_events_c, 0, sizeof(m_events_c));
-    m_events_c.fd = m_cam_fd;
-    m_events_c.events = POLLIN | POLLERR;
-
-    LOG_TIME_START(1) // prepare
-    int nframe = 1;
-
-    ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat);
-    CHECK(ret);
-    ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, V4L2_PIX_FMT_JPEG);
-    CHECK(ret);
-    ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
-    CHECK(ret);
-    ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE);
-    CHECK(ret);
-
-    ret = fimc_v4l2_qbuf(m_cam_fd, 0);
-    CHECK(ret);
-
-    ret = fimc_v4l2_streamon(m_cam_fd);
-    CHECK(ret);
-    LOG_TIME_END(1)
-
-    return 0;
-}
-
-int SecCamera::endSnapshot(void)
-{
-    int ret;
-
-    LOGI("%s :", __func__);
-    if (m_capture_buf.start) {
-        munmap(m_capture_buf.start, m_capture_buf.length);
-        LOGI("munmap():virt. addr %p size = %d\n",
-             m_capture_buf.start, m_capture_buf.length);
-        m_capture_buf.start = NULL;
-        m_capture_buf.length = 0;
-    }
-    return 0;
-}
-
-/*
- * Set Jpeg quality & exif info and get JPEG data from camera ISP
- */
-unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr)
-{
-    LOGV("%s :", __func__);
-
-    int index, ret = 0;
-    unsigned char *addr;
-
-    LOG_TIME_DEFINE(2)
-
-    // capture
-    ret = fimc_poll(&m_events_c);
-    CHECK_PTR(ret);
-    index = fimc_v4l2_dqbuf(m_cam_fd);
-    if (index != 0) {
-        LOGE("ERR(%s):wrong index = %d\n", __func__, index);
-        return NULL;
-    }
-
-    *jpeg_size = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_SIZE);
-    CHECK_PTR(*jpeg_size);
-
-    int main_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_OFFSET);
-    CHECK_PTR(main_offset);
-    m_postview_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET);
-    CHECK_PTR(m_postview_offset);
-
-    ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
-    CHECK_PTR(ret);
-    LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d\n\n",
-            index, m_snapshot_width, m_snapshot_height, *jpeg_size);
-
-    addr = (unsigned char*)(m_capture_buf.start) + main_offset;
-    *phyaddr = getPhyAddrY(index) + m_postview_offset;
-
-    LOG_TIME_START(2) // post
-    ret = fimc_v4l2_streamoff(m_cam_fd);
-    CHECK_PTR(ret);
-    LOG_TIME_END(2)
-
-    return addr;
-}
-
-int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc)
-{
-    JpegEncoder jpgEnc;
-
-    LOGV("%s : m_jpeg_thumbnail_width = %d, height = %d",
-         __func__, m_jpeg_thumbnail_width, m_jpeg_thumbnail_height);
-    if ((m_jpeg_thumbnail_width > 0) && (m_jpeg_thumbnail_height > 0)) {
-        int inFormat = JPG_MODESEL_YCBCR;
-        int outFormat = JPG_422;
-        switch (m_snapshot_v4lformat) {
-        case V4L2_PIX_FMT_NV12:
-        case V4L2_PIX_FMT_NV21:
-        case V4L2_PIX_FMT_NV12T:
-        case V4L2_PIX_FMT_YUV420:
-            outFormat = JPG_420;
-            break;
-        case V4L2_PIX_FMT_YUYV:
-        case V4L2_PIX_FMT_UYVY:
-        case V4L2_PIX_FMT_YUV422P:
-            outFormat = JPG_422;
-            break;
-        }
-
-        if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS)
-            return -1;
-
-        if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS)
-            return -1;
-
-        if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2) != JPG_SUCCESS)
-            return -1;
-
-        int thumbWidth, thumbHeight, thumbSrcSize;
-        getThumbnailConfig(&thumbWidth, &thumbHeight, &thumbSrcSize);
-        if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, thumbWidth) != JPG_SUCCESS)
-            return -1;
-
-        if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, thumbHeight) != JPG_SUCCESS)
-            return -1;
-
-        char *pInBuf = (char *)jpgEnc.getInBuf(thumbSrcSize);
-        if (pInBuf == NULL)
-            return -1;
-        memcpy(pInBuf, pThumbSrc, thumbSrcSize);
-
-        unsigned int thumbSize;
-
-        jpgEnc.encode(&thumbSize, NULL);
-
-        LOGV("%s : enableThumb set to true", __func__);
-        mExifInfo.enableThumb = true;
-    } else {
-        LOGV("%s : enableThumb set to false", __func__);
-        mExifInfo.enableThumb = false;
-    }
-
-    unsigned int exifSize;
-
-    setExifChangedAttribute();
-
-    LOGV("%s: calling jpgEnc.makeExif, mExifInfo.width set to %d, height to %d\n",
-         __func__, mExifInfo.width, mExifInfo.height);
-
-    jpgEnc.makeExif(pExifDst, &mExifInfo, &exifSize, true);
-
-    return exifSize;
-}
-
-void SecCamera::getPostViewConfig(int *width, int *height, int *size)
-{
-    if (m_preview_width == 1024) {
-        *width = BACK_CAMERA_POSTVIEW_WIDE_WIDTH;
-        *height = BACK_CAMERA_POSTVIEW_HEIGHT;
-        *size = BACK_CAMERA_POSTVIEW_WIDE_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP / 8;
-    } else {
-        *width = BACK_CAMERA_POSTVIEW_WIDTH;
-        *height = BACK_CAMERA_POSTVIEW_HEIGHT;
-        *size = BACK_CAMERA_POSTVIEW_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP / 8;
-    }
-    LOGV("[5B] m_preview_width : %d, mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
-            m_preview_width, *width, *height, *size);
-}
-
-void SecCamera::getThumbnailConfig(int *width, int *height, int *size)
-{
-    if (m_camera_id == CAMERA_ID_BACK) {
-        *width  = BACK_CAMERA_THUMBNAIL_WIDTH;
-        *height = BACK_CAMERA_THUMBNAIL_HEIGHT;
-        *size   = BACK_CAMERA_THUMBNAIL_WIDTH * BACK_CAMERA_THUMBNAIL_HEIGHT
-                    * BACK_CAMERA_THUMBNAIL_BPP / 8;
-    } else {
-        *width  = FRONT_CAMERA_THUMBNAIL_WIDTH;
-        *height = FRONT_CAMERA_THUMBNAIL_HEIGHT;
-        *size   = FRONT_CAMERA_THUMBNAIL_WIDTH * FRONT_CAMERA_THUMBNAIL_HEIGHT
-                    * FRONT_CAMERA_THUMBNAIL_BPP / 8;
-    }
-}
-
-int SecCamera::getPostViewOffset(void)
-{
-    return m_postview_offset;
-}
-
-int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf,
-                                            unsigned int *output_size)
-{
-    LOGV("%s :", __func__);
-
-    int index;
-    //unsigned int addr;
-    unsigned char *addr;
-    int ret = 0;
-
-    LOG_TIME_DEFINE(0)
-    LOG_TIME_DEFINE(1)
-    LOG_TIME_DEFINE(2)
-    LOG_TIME_DEFINE(3)
-    LOG_TIME_DEFINE(4)
-    LOG_TIME_DEFINE(5)
-
-    //fimc_v4l2_streamoff(m_cam_fd); [zzangdol] remove - it is separate in HWInterface with camera_id
-
-    if (m_cam_fd <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    if (m_flag_camera_start > 0) {
-        LOG_TIME_START(0)
-        LOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__);
-        stopPreview();
-        LOG_TIME_END(0)
-    }
-
-    memset(&m_events_c, 0, sizeof(m_events_c));
-    m_events_c.fd = m_cam_fd;
-    m_events_c.events = POLLIN | POLLERR;
-
-#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
-    if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
-        LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV420");
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
-        LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12");
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
-        LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12T");
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
-        LOGV("SnapshotFormat:V4L2_PIX_FMT_NV21");
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
-        LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV422P");
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
-        LOGV("SnapshotFormat:V4L2_PIX_FMT_YUYV");
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
-        LOGV("SnapshotFormat:V4L2_PIX_FMT_UYVY");
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
-        LOGV("SnapshotFormat:V4L2_PIX_FMT_RGB565");
-    else
-        LOGV("SnapshotFormat:UnknownFormat");
-#endif
-
-    LOG_TIME_START(1) // prepare
-    int nframe = 1;
-
-    ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat);
-    CHECK(ret);
-    ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
-    CHECK(ret);
-    ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
-    CHECK(ret);
-    ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE);
-    CHECK(ret);
-
-    ret = fimc_v4l2_qbuf(m_cam_fd, 0);
-    CHECK(ret);
-
-    ret = fimc_v4l2_streamon(m_cam_fd);
-    CHECK(ret);
-    LOG_TIME_END(1)
-
-    LOG_TIME_START(2) // capture
-    fimc_poll(&m_events_c);
-    index = fimc_v4l2_dqbuf(m_cam_fd);
-    fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
-    LOGV("\nsnapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d\n\n",
-            index, m_snapshot_width, m_snapshot_height);
-
-    LOG_TIME_END(2)
-
-    LOGI("%s : calling memcpy from m_capture_buf", __func__);
-    memcpy(yuv_buf, (unsigned char*)m_capture_buf.start, m_snapshot_width * m_snapshot_height * 2);
-    LOG_TIME_START(5) // post
-    fimc_v4l2_streamoff(m_cam_fd);
-    LOG_TIME_END(5)
-
-    LOG_CAMERA("getSnapshotAndJpeg intervals : stopPreview(%lu), prepare(%lu),"
-                " capture(%lu), memcpy(%lu), yuv2Jpeg(%lu), post(%lu)  us",
-                    LOG_TIME(0), LOG_TIME(1), LOG_TIME(2), LOG_TIME(3), LOG_TIME(4), LOG_TIME(5));
-    /* JPEG encoding */
-    JpegEncoder jpgEnc;
-    int inFormat = JPG_MODESEL_YCBCR;
-    int outFormat = JPG_422;
-
-    switch (m_snapshot_v4lformat) {
-    case V4L2_PIX_FMT_NV12:
-    case V4L2_PIX_FMT_NV21:
-    case V4L2_PIX_FMT_NV12T:
-    case V4L2_PIX_FMT_YUV420:
-        outFormat = JPG_420;
-        break;
-    case V4L2_PIX_FMT_YUYV:
-    case V4L2_PIX_FMT_UYVY:
-    case V4L2_PIX_FMT_YUV422P:
-    default:
-        outFormat = JPG_422;
-        break;
-    }
-
-    if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS)
-        LOGE("[JPEG_SET_ENCODE_IN_FORMAT] Error\n");
-
-    if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS)
-        LOGE("[JPEG_SET_SAMPING_MODE] Error\n");
-
-    image_quality_type_t jpegQuality;
-    if (m_jpeg_quality >= 90)
-        jpegQuality = JPG_QUALITY_LEVEL_1;
-    else if (m_jpeg_quality >= 80)
-        jpegQuality = JPG_QUALITY_LEVEL_2;
-    else if (m_jpeg_quality >= 70)
-        jpegQuality = JPG_QUALITY_LEVEL_3;
-    else
-        jpegQuality = JPG_QUALITY_LEVEL_4;
-
-    if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, jpegQuality) != JPG_SUCCESS)
-        LOGE("[JPEG_SET_ENCODE_QUALITY] Error\n");
-    if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, m_snapshot_width) != JPG_SUCCESS)
-        LOGE("[JPEG_SET_ENCODE_WIDTH] Error\n");
-
-    if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, m_snapshot_height) != JPG_SUCCESS)
-        LOGE("[JPEG_SET_ENCODE_HEIGHT] Error\n");
-
-    unsigned int snapshot_size = m_snapshot_width * m_snapshot_height * 2;
-    unsigned char *pInBuf = (unsigned char *)jpgEnc.getInBuf(snapshot_size);
-
-    if (pInBuf == NULL) {
-        LOGE("JPEG input buffer is NULL!!\n");
-        return -1;
-    }
-    memcpy(pInBuf, yuv_buf, snapshot_size);
-
-    setExifChangedAttribute();
-    jpgEnc.encode(output_size, &mExifInfo);
-
-    uint64_t outbuf_size;
-    unsigned char *pOutBuf = (unsigned char *)jpgEnc.getOutBuf(&outbuf_size);
-
-    if (pOutBuf == NULL) {
-        LOGE("JPEG output buffer is NULL!!\n");
-        return -1;
-    }
-
-    memcpy(jpeg_buf, pOutBuf, outbuf_size);
-
-    return 0;
-}
-
-
-int SecCamera::setSnapshotSize(int width, int height)
-{
-    LOGV("%s(width(%d), height(%d))", __func__, width, height);
-
-    m_snapshot_width  = width;
-    m_snapshot_height = height;
-
-    return 0;
-}
-
-int SecCamera::getSnapshotSize(int *width, int *height, int *frame_size)
-{
-    *width  = m_snapshot_width;
-    *height = m_snapshot_height;
-
-    int frame = 0;
-
-    frame = m_frameSize(m_snapshot_v4lformat, m_snapshot_width, m_snapshot_height);
-
-    // set it big.
-    if (frame == 0)
-        frame = m_snapshot_width * m_snapshot_height * BPP;
-
-    *frame_size = frame;
-
-    return 0;
-}
-
-int SecCamera::getSnapshotMaxSize(int *width, int *height)
-{
-    switch (m_camera_id) {
-    case CAMERA_ID_FRONT:
-        m_snapshot_max_width  = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH;
-        m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT;
-        break;
-
-    default:
-    case CAMERA_ID_BACK:
-        m_snapshot_max_width  = MAX_BACK_CAMERA_SNAPSHOT_WIDTH;
-        m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT;
-        break;
-    }
-
-    *width  = m_snapshot_max_width;
-    *height = m_snapshot_max_height;
-
-    return 0;
-}
-
-int SecCamera::setSnapshotPixelFormat(int pixel_format)
-{
-    int v4lpixelformat= pixel_format;
-
-    if (m_snapshot_v4lformat != v4lpixelformat) {
-        m_snapshot_v4lformat = v4lpixelformat;
-    }
-
-#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
-    if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
-        LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV420", __func__);
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
-        LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__);
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
-        LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__);
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
-        LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__);
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
-        LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__);
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
-        LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__);
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
-        LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__);
-    else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
-        LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__);
-    else
-        LOGD("SnapshotFormat:UnknownFormat");
-#endif
-    return 0;
-}
-
-int SecCamera::getSnapshotPixelFormat(void)
-{
-    return m_snapshot_v4lformat;
-}
-
-// ======================================================================
-// Settings
-
-int SecCamera::getCameraId(void)
-{
-    return m_camera_id;
-}
-
-// -----------------------------------
-
-int SecCamera::setAutofocus(void)
-{
-    LOGV("%s :", __func__);
-
-    if (m_cam_fd <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) {
-            LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
-        return -1;
-    }
-
-    return 0;
-}
-
-int SecCamera::getAutoFocusResult(void)
-{
-    int af_result;
-
-    af_result = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT);
-
-    LOGV("%s : returning %d", __func__, af_result);
-
-    return af_result;
-}
-
-int SecCamera::cancelAutofocus(void)
-{
-    LOGV("%s :", __func__);
-
-    if (m_cam_fd <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF) < 0) {
-        LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
-        return -1;
-    }
-
-    return 0;
-}
-
-// -----------------------------------
-
-int SecCamera::zoomIn(void)
-{
-    LOGV("%s :", __func__);
-    return 0;
-}
-
-int SecCamera::zoomOut(void)
-{
-    LOGV("%s :", __func__);
-    return 0;
-}
-
-// -----------------------------------
-
-int SecCamera::SetRotate(int angle)
-{
-    LOGE("%s(angle(%d))", __func__, angle);
-
-    if (m_angle != angle) {
-        switch (angle) {
-        case -360:
-        case    0:
-        case  360:
-            m_angle = 0;
-            break;
-
-        case -270:
-        case   90:
-            m_angle = 90;
-            break;
-
-        case -180:
-        case  180:
-            m_angle = 180;
-            break;
-
-        case  -90:
-        case  270:
-            m_angle = 270;
-            break;
-
-        default:
-            LOGE("ERR(%s):Invalid angle(%d)", __func__, angle);
-            return -1;
-        }
-
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_ROTATION, angle) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_ROTATION", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getRotate(void)
-{
-    LOGV("%s : angle(%d)", __func__, m_angle);
-    return m_angle;
-}
-
-int SecCamera::setFrameRate(int frame_rate)
-{
-    LOGV("%s(FrameRate(%d))", __func__, frame_rate);
-
-    if (frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate )
-        LOGE("ERR(%s):Invalid frame_rate(%d)", __func__, frame_rate);
-
-    if (m_params->capture.timeperframe.denominator != (unsigned)frame_rate) {
-        m_params->capture.timeperframe.denominator = frame_rate;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-// -----------------------------------
-
-int SecCamera::setVerticalMirror(void)
-{
-    LOGV("%s :", __func__);
-
-    if (m_cam_fd <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_VFLIP, 0) < 0) {
-        LOGE("ERR(%s):Fail on V4L2_CID_VFLIP", __func__);
-        return -1;
-    }
-
-    return 0;
-}
-
-int SecCamera::setHorizontalMirror(void)
-{
-    LOGV("%s :", __func__);
-
-    if (m_cam_fd <= 0) {
-        LOGE("ERR(%s):Camera was closed\n", __func__);
-        return -1;
-    }
-
-    if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_HFLIP, 0) < 0) {
-        LOGE("ERR(%s):Fail on V4L2_CID_HFLIP", __func__);
-        return -1;
-    }
-
-    return 0;
-}
-
-// -----------------------------------
-
-int SecCamera::setWhiteBalance(int white_balance)
-{
-    LOGV("%s(white_balance(%d))", __func__, white_balance);
-
-    if (white_balance <= WHITE_BALANCE_BASE || WHITE_BALANCE_MAX <= white_balance) {
-        LOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance);
-        return -1;
-    }
-
-    if (m_params->white_balance != white_balance) {
-        m_params->white_balance = white_balance;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, white_balance) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WHITE_BALANCE", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getWhiteBalance(void)
-{
-    LOGV("%s : white_balance(%d)", __func__, m_params->white_balance);
-    return m_params->white_balance;
-}
-
-// -----------------------------------
-
-int SecCamera::setBrightness(int brightness)
-{
-    LOGV("%s(brightness(%d))", __func__, brightness);
-
-    brightness += EV_DEFAULT;
-
-    if (brightness < EV_MINUS_4 || EV_PLUS_4 < brightness) {
-        LOGE("ERR(%s):Invalid brightness(%d)", __func__, brightness);
-        return -1;
-    }
-
-    if (m_params->brightness != brightness) {
-        m_params->brightness = brightness;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, brightness) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BRIGHTNESS", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getBrightness(void)
-{
-    LOGV("%s : brightness(%d)", __func__, m_params->brightness);
-    return m_params->brightness;
-}
-
-// -----------------------------------
-
-int SecCamera::setImageEffect(int image_effect)
-{
-    LOGV("%s(image_effect(%d))", __func__, image_effect);
-
-    if (image_effect <= IMAGE_EFFECT_BASE || IMAGE_EFFECT_MAX <= image_effect) {
-        LOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect);
-        return -1;
-    }
-
-    if (m_params->effects != image_effect) {
-        m_params->effects = image_effect;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, image_effect) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_EFFECT", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getImageEffect(void)
-{
-    LOGV("%s : image_effect(%d)", __func__, m_params->effects);
-    return m_params->effects;
-}
-
-// ======================================================================
-int SecCamera::setAntiBanding(int anti_banding)
-{
-    LOGV("%s(anti_banding(%d))", __func__, anti_banding);
-
-    if (anti_banding < ANTI_BANDING_AUTO || ANTI_BANDING_OFF < anti_banding) {
-        LOGE("ERR(%s):Invalid anti_banding (%d)", __func__, anti_banding);
-        return -1;
-    }
-
-    if (m_anti_banding != anti_banding) {
-        m_anti_banding = anti_banding;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_BANDING, anti_banding) < 0) {
-                 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_BANDING", __func__);
-                 return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-//======================================================================
-int SecCamera::setSceneMode(int scene_mode)
-{
-    LOGV("%s(scene_mode(%d))", __func__, scene_mode);
-
-    if (scene_mode <= SCENE_MODE_BASE || SCENE_MODE_MAX <= scene_mode) {
-        LOGE("ERR(%s):Invalid scene_mode (%d)", __func__, scene_mode);
-        return -1;
-    }
-
-    if (m_params->scene_mode != scene_mode) {
-        m_params->scene_mode = scene_mode;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, scene_mode) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getSceneMode(void)
-{
-    return m_params->scene_mode;
-}
-
-//======================================================================
-
-int SecCamera::setFlashMode(int flash_mode)
-{
-    LOGV("%s(flash_mode(%d))", __func__, flash_mode);
-
-    if (flash_mode <= FLASH_MODE_BASE || FLASH_MODE_MAX <= flash_mode) {
-        LOGE("ERR(%s):Invalid flash_mode (%d)", __func__, flash_mode);
-        return -1;
-    }
-
-    if (m_params->flash_mode != flash_mode) {
-        m_params->flash_mode = flash_mode;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FLASH_MODE, flash_mode) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FLASH_MODE", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getFlashMode(void)
-{
-    return m_params->flash_mode;
-}
-
-//======================================================================
-
-int SecCamera::setISO(int iso_value)
-{
-    LOGV("%s(iso_value(%d))", __func__, iso_value);
-    if (iso_value < ISO_AUTO || ISO_MAX <= iso_value) {
-        LOGE("ERR(%s):Invalid iso_value (%d)", __func__, iso_value);
-        return -1;
-    }
-
-    if (m_params->iso != iso_value) {
-        m_params->iso = iso_value;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, iso_value) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ISO", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getISO(void)
-{
-    return m_params->iso;
-}
-
-//======================================================================
-
-int SecCamera::setContrast(int contrast_value)
-{
-    LOGV("%s(contrast_value(%d))", __func__, contrast_value);
-
-    if (contrast_value < CONTRAST_MINUS_2 || CONTRAST_MAX <= contrast_value) {
-        LOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value);
-        return -1;
-    }
-
-    if (m_params->contrast != contrast_value) {
-        m_params->contrast = contrast_value;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CONTRAST, contrast_value) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CONTRAST", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getContrast(void)
-{
-    return m_params->contrast;
-}
-
-//======================================================================
-
-int SecCamera::setSaturation(int saturation_value)
-{
-    LOGV("%s(saturation_value(%d))", __func__, saturation_value);
-
-    if (saturation_value <SATURATION_MINUS_2 || SATURATION_MAX<= saturation_value) {
-        LOGE("ERR(%s):Invalid saturation_value (%d)", __func__, saturation_value);
-        return -1;
-    }
-
-    if (m_params->saturation != saturation_value) {
-        m_params->saturation = saturation_value;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, saturation_value) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getSaturation(void)
-{
-    return m_params->saturation;
-}
-
-//======================================================================
-
-int SecCamera::setSharpness(int sharpness_value)
-{
-    LOGV("%s(sharpness_value(%d))", __func__, sharpness_value);
-
-    if (sharpness_value < SHARPNESS_MINUS_2 || SHARPNESS_MAX <= sharpness_value) {
-        LOGE("ERR(%s):Invalid sharpness_value (%d)", __func__, sharpness_value);
-        return -1;
-    }
-
-    if (m_params->sharpness != sharpness_value) {
-        m_params->sharpness = sharpness_value;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, sharpness_value) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getSharpness(void)
-{
-    return m_params->sharpness;
-}
-
-//======================================================================
-
-int SecCamera::setWDR(int wdr_value)
-{
-    LOGV("%s(wdr_value(%d))", __func__, wdr_value);
-
-    if (wdr_value < WDR_OFF || WDR_MAX <= wdr_value) {
-        LOGE("ERR(%s):Invalid wdr_value (%d)", __func__, wdr_value);
-        return -1;
-    }
-
-    if (m_wdr != wdr_value) {
-        m_wdr = wdr_value;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WDR, wdr_value) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WDR", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getWDR(void)
-{
-    return m_wdr;
-}
-
-//======================================================================
-
-int SecCamera::setAntiShake(int anti_shake)
-{
-    LOGV("%s(anti_shake(%d))", __func__, anti_shake);
-
-    if (anti_shake < ANTI_SHAKE_OFF || ANTI_SHAKE_MAX <= anti_shake) {
-        LOGE("ERR(%s):Invalid anti_shake (%d)", __func__, anti_shake);
-        return -1;
-    }
-
-    if (m_anti_shake != anti_shake) {
-        m_anti_shake = anti_shake;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_SHAKE, anti_shake) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_SHAKE", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getAntiShake(void)
-{
-    return m_anti_shake;
-}
-
-//======================================================================
-
-
-int SecCamera::setMetering(int metering_value)
-{
-    LOGV("%s(metering (%d))", __func__, metering_value);
-
-    if (metering_value <= METERING_BASE || METERING_MAX <= metering_value) {
-        LOGE("ERR(%s):Invalid metering_value (%d)", __func__, metering_value);
-        return -1;
-    }
-
-    if (m_params->metering != metering_value) {
-        m_params->metering = metering_value;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, metering_value) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_METERING", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getMetering(void)
-{
-    return m_params->metering;
-}
-
-//======================================================================
-
-int SecCamera::setJpegQuality(int jpeg_quality)
-{
-    LOGV("%s(jpeg_quality (%d))", __func__, jpeg_quality);
-
-    if (jpeg_quality < JPEG_QUALITY_ECONOMY || JPEG_QUALITY_MAX <= jpeg_quality) {
-        LOGE("ERR(%s):Invalid jpeg_quality (%d)", __func__, jpeg_quality);
-        return -1;
-    }
-
-    if (m_jpeg_quality != jpeg_quality) {
-        m_jpeg_quality = jpeg_quality;
-        if (m_flag_camera_start && (m_camera_id == CAMERA_ID_BACK)) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAM_JPEG_QUALITY", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getJpegQuality(void)
-{
-    return m_jpeg_quality;
-}
-
-//======================================================================
-
-int SecCamera::setZoom(int zoom_level)
-{
-    LOGV("%s(zoom_level (%d))", __func__, zoom_level);
-
-    if (zoom_level < ZOOM_LEVEL_0 || ZOOM_LEVEL_MAX <= zoom_level) {
-        LOGE("ERR(%s):Invalid zoom_level (%d)", __func__, zoom_level);
-        return -1;
-    }
-
-    if (m_zoom_level != zoom_level) {
-        m_zoom_level = zoom_level;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ZOOM, zoom_level) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ZOOM", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getZoom(void)
-{
-    return m_zoom_level;
-}
-
-//======================================================================
-
-int SecCamera::setObjectTracking(int object_tracking)
-{
-    LOGV("%s(object_tracking (%d))", __func__, object_tracking);
-
-    if (object_tracking < OBJECT_TRACKING_OFF || OBJECT_TRACKING_MAX <= object_tracking) {
-        LOGE("ERR(%s):Invalid object_tracking (%d)", __func__, object_tracking);
-        return -1;
-    }
-
-    if (m_object_tracking != object_tracking) {
-        m_object_tracking = object_tracking;
-    }
-
-    return 0;
-}
-
-int SecCamera::getObjectTracking(void)
-{
-    return m_object_tracking;
-}
-
-int SecCamera::getObjectTrackingStatus(void)
-{
-    int obj_status = 0;
-    obj_status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJ_TRACKING_STATUS);
-    return obj_status;
-}
-
-int SecCamera::setObjectTrackingStartStop(int start_stop)
-{
-    LOGV("%s(object_tracking_start_stop (%d))", __func__, start_stop);
-
-    if (m_object_tracking_start_stop != start_stop) {
-        m_object_tracking_start_stop = start_stop;
-        if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP, start_stop) < 0) {
-            LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP", __func__);
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::setTouchAFStartStop(int start_stop)
-{
-    LOGV("%s(touch_af_start_stop (%d))", __func__, start_stop);
-
-    if (m_touch_af_start_stop != start_stop) {
-        m_touch_af_start_stop = start_stop;
-        if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, start_stop) < 0) {
-            LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_TOUCH_AF_START_STOP", __func__);
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
-//======================================================================
-
-int SecCamera::setSmartAuto(int smart_auto)
-{
-    LOGV("%s(smart_auto (%d))", __func__, smart_auto);
-
-    if (smart_auto < SMART_AUTO_OFF || SMART_AUTO_MAX <= smart_auto) {
-        LOGE("ERR(%s):Invalid smart_auto (%d)", __func__, smart_auto);
-        return -1;
-    }
-
-    if (m_smart_auto != smart_auto) {
-        m_smart_auto = smart_auto;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SMART_AUTO, smart_auto) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SMART_AUTO", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getSmartAuto(void)
-{
-    return m_smart_auto;
-}
-
-int SecCamera::getAutosceneStatus(void)
-{
-    int autoscene_status = -1;
-
-    if (getSmartAuto() == SMART_AUTO_ON) {
-        autoscene_status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_SMART_AUTO_STATUS);
-
-        if ((autoscene_status < SMART_AUTO_STATUS_AUTO) || (autoscene_status > SMART_AUTO_STATUS_MAX)) {
-            LOGE("ERR(%s):Invalid getAutosceneStatus (%d)", __func__, autoscene_status);
-            return -1;
-        }
-    }
-    //LOGV("%s :    autoscene_status (%d)", __func__, autoscene_status);
-    return autoscene_status;
-}
-//======================================================================
-
-int SecCamera::setBeautyShot(int beauty_shot)
-{
-    LOGV("%s(beauty_shot (%d))", __func__, beauty_shot);
-
-    if (beauty_shot < BEAUTY_SHOT_OFF || BEAUTY_SHOT_MAX <= beauty_shot) {
-        LOGE("ERR(%s):Invalid beauty_shot (%d)", __func__, beauty_shot);
-        return -1;
-    }
-
-    if (m_beauty_shot != beauty_shot) {
-        m_beauty_shot = beauty_shot;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BEAUTY_SHOT, beauty_shot) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BEAUTY_SHOT", __func__);
-                return -1;
-            }
-        }
-
-        setFaceDetect(FACE_DETECTION_ON_BEAUTY);
-    }
-
-    return 0;
-}
-
-int SecCamera::getBeautyShot(void)
-{
-    return m_beauty_shot;
-}
-
-//======================================================================
-
-int SecCamera::setVintageMode(int vintage_mode)
-{
-    LOGV("%s(vintage_mode(%d))", __func__, vintage_mode);
-
-    if (vintage_mode <= VINTAGE_MODE_BASE || VINTAGE_MODE_MAX <= vintage_mode) {
-        LOGE("ERR(%s):Invalid vintage_mode (%d)", __func__, vintage_mode);
-        return -1;
-    }
-
-    if (m_vintage_mode != vintage_mode) {
-        m_vintage_mode = vintage_mode;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VINTAGE_MODE, vintage_mode) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VINTAGE_MODE", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getVintageMode(void)
-{
-    return m_vintage_mode;
-}
-
-//======================================================================
-
-int SecCamera::setFocusMode(int focus_mode)
-{
-    LOGV("%s(focus_mode(%d))", __func__, focus_mode);
-
-    if (FOCUS_MODE_MAX <= focus_mode) {
-        LOGE("ERR(%s):Invalid focus_mode (%d)", __func__, focus_mode);
-        return -1;
-    }
-
-    if (m_params->focus_mode != focus_mode) {
-        m_params->focus_mode = focus_mode;
-
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getFocusMode(void)
-{
-    return m_params->focus_mode;
-}
-
-//======================================================================
-
-int SecCamera::setFaceDetect(int face_detect)
-{
-    LOGV("%s(face_detect(%d))", __func__, face_detect);
-
-    if (m_face_detect != face_detect) {
-        m_face_detect = face_detect;
-        if (m_flag_camera_start) {
-            if (m_face_detect != FACE_DETECTION_OFF) {
-                if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_AUTO) < 0) {
-                    LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODin face detecion", __func__);
-                    return -1;
-                }
-            }
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACE_DETECTION, face_detect) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACE_DETECTION", __func__);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-int SecCamera::getFaceDetect(void)
-{
-    return m_face_detect;
-}
-
-//======================================================================
-
-int SecCamera::setGPSLatitude(const char *gps_latitude)
-{
-    double conveted_latitude = 0;
-    LOGV("%s(gps_latitude(%s))", __func__, gps_latitude);
-    if (gps_latitude == NULL)
-        m_gps_latitude = 0;
-    else {
-        conveted_latitude = atof(gps_latitude);
-        m_gps_latitude = (long)(conveted_latitude * 10000 / 1);
-    }
-
-    LOGV("%s(m_gps_latitude(%ld))", __func__, m_gps_latitude);
-    return 0;
-}
-
-int SecCamera::setGPSLongitude(const char *gps_longitude)
-{
-    double conveted_longitude = 0;
-    LOGV("%s(gps_longitude(%s))", __func__, gps_longitude);
-    if (gps_longitude == NULL)
-        m_gps_longitude = 0;
-    else {
-        conveted_longitude = atof(gps_longitude);
-        m_gps_longitude = (long)(conveted_longitude * 10000 / 1);
-    }
-
-    LOGV("%s(m_gps_longitude(%ld))", __func__, m_gps_longitude);
-    return 0;
-}
-
-int SecCamera::setGPSAltitude(const char *gps_altitude)
-{
-    double conveted_altitude = 0;
-    LOGV("%s(gps_altitude(%s))", __func__, gps_altitude);
-    if (gps_altitude == NULL)
-        m_gps_altitude = 0;
-    else {
-        conveted_altitude = atof(gps_altitude);
-        m_gps_altitude = (long)(conveted_altitude * 100 / 1);
-    }
-
-    LOGV("%s(m_gps_altitude(%ld))", __func__, m_gps_altitude);
-    return 0;
-}
-
-int SecCamera::setGPSTimeStamp(const char *gps_timestamp)
-{
-    LOGV("%s(gps_timestamp(%s))", __func__, gps_timestamp);
-    if (gps_timestamp == NULL)
-        m_gps_timestamp = 0;
-    else
-        m_gps_timestamp = atol(gps_timestamp);
-
-    LOGV("%s(m_gps_timestamp(%ld))", __func__, m_gps_timestamp);
-    return 0;
-}
-
-int SecCamera::setGPSProcessingMethod(const char *gps_processing_method)
-{
-    LOGV("%s(gps_processing_method(%s))", __func__, gps_processing_method);
-    memset(mExifInfo.gps_processing_method, 0, sizeof(mExifInfo.gps_processing_method));
-    if (gps_processing_method != NULL) {
-        size_t len = strlen(gps_processing_method);
-        if (len > sizeof(mExifInfo.gps_processing_method)) {
-            len = sizeof(mExifInfo.gps_processing_method);
-        }
-        memcpy(mExifInfo.gps_processing_method, gps_processing_method, len);
-    }
-    return 0;
-}
-
-int SecCamera::setFaceDetectLockUnlock(int facedetect_lockunlock)
-{
-    LOGV("%s(facedetect_lockunlock(%d))", __func__, facedetect_lockunlock);
-
-    if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK, facedetect_lockunlock) < 0) {
-        LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK", __func__);
-        return -1;
-    }
-
-    return 0;
-}
-
-int SecCamera::setObjectPosition(int x, int y)
-{
-    LOGV("%s(setObjectPosition(x=%d, y=%d))", __func__, x, y);
-
-    if (m_preview_width ==640)
-        x = x - 80;
-
-    if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJECT_POSITION_X, x) < 0) {
-        LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_X", __func__);
-        return -1;
-    }
-
-    if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJECT_POSITION_Y, y) < 0) {
-        LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_Y", __func__);
-        return -1;
-    }
-
-    return 0;
-}
-
-//======================================================================
-
-int SecCamera::setGamma(int gamma)
-{
-     LOGV("%s(gamma(%d))", __func__, gamma);
-
-     if (gamma < GAMMA_OFF || GAMMA_MAX <= gamma) {
-         LOGE("ERR(%s):Invalid gamma (%d)", __func__, gamma);
-         return -1;
-     }
-
-     if (m_video_gamma != gamma) {
-         m_video_gamma = gamma;
-         if (m_flag_camera_start) {
-             if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_GAMMA, gamma) < 0) {
-                 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_GAMMA", __func__);
-                 return -1;
-             }
-         }
-     }
-
-     return 0;
-}
-
-//======================================================================
-
-int SecCamera::setSlowAE(int slow_ae)
-{
-     LOGV("%s(slow_ae(%d))", __func__, slow_ae);
-
-     if (slow_ae < GAMMA_OFF || GAMMA_MAX <= slow_ae) {
-         LOGE("ERR(%s):Invalid slow_ae (%d)", __func__, slow_ae);
-         return -1;
-     }
-
-     if (m_slow_ae!= slow_ae) {
-         m_slow_ae = slow_ae;
-         if (m_flag_camera_start) {
-             if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_SLOW_AE, slow_ae) < 0) {
-                 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_SLOW_AE", __func__);
-                 return -1;
-             }
-         }
-     }
-
-     return 0;
-}
-
-//======================================================================
-int SecCamera::setRecordingSize(int width, int height)
-{
-     LOGV("%s(width(%d), height(%d))", __func__, width, height);
-
-     m_recording_width  = width;
-     m_recording_height = height;
-
-     return 0;
-}
-
-//======================================================================
-
-int SecCamera::setExifOrientationInfo(int orientationInfo)
-{
-     LOGV("%s(orientationInfo(%d))", __func__, orientationInfo);
-
-     if (orientationInfo < 0) {
-         LOGE("ERR(%s):Invalid orientationInfo (%d)", __func__, orientationInfo);
-         return -1;
-     }
-     m_exif_orientation = orientationInfo;
-
-     return 0;
-}
-
-//======================================================================
-int SecCamera::setBatchReflection()
-{
-    if (m_flag_camera_start) {
-        if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BATCH_REFLECTION, 1) < 0) {
-             LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BATCH_REFLECTION", __func__);
-             return -1;
-        }
-    }
-
-    return 0;
-}
-
-/*Video call*/
-int SecCamera::setVTmode(int vtmode)
-{
-    LOGV("%s(vtmode (%d))", __func__, vtmode);
-
-    if (vtmode < VT_MODE_OFF || VT_MODE_MAX <= vtmode) {
-        LOGE("ERR(%s):Invalid vtmode (%d)", __func__, vtmode);
-        return -1;
-    }
-
-    if (m_vtmode != vtmode) {
-        m_vtmode = vtmode;
-    }
-
-    return 0;
-}
-
-/* Camcorder fix fps */
-int SecCamera::setSensorMode(int sensor_mode)
-{
-    LOGV("%s(sensor_mode (%d))", __func__, sensor_mode);
-
-    if (sensor_mode < SENSOR_MODE_CAMERA || SENSOR_MODE_MOVIE < sensor_mode) {
-        LOGE("ERR(%s):Invalid sensor mode (%d)", __func__, sensor_mode);
-        return -1;
-    }
-
-    if (m_sensor_mode != sensor_mode) {
-        m_sensor_mode = sensor_mode;
-    }
-
-    return 0;
-}
-
-/*  Shot mode   */
-/*  SINGLE = 0
-*   CONTINUOUS = 1
-*   PANORAMA = 2
-*   SMILE = 3
-*   SELF = 6
-*/
-int SecCamera::setShotMode(int shot_mode)
-{
-    LOGV("%s(shot_mode (%d))", __func__, shot_mode);
-    if (shot_mode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shot_mode) {
-        LOGE("ERR(%s):Invalid shot_mode (%d)", __func__, shot_mode);
-        return -1;
-    }
-    m_shot_mode = shot_mode;
-
-    return 0;
-}
-
-int SecCamera::getVTmode(void)
-{
-    return m_vtmode;
-}
-
-int SecCamera::setBlur(int blur_level)
-{
-    LOGV("%s(level (%d))", __func__, blur_level);
-
-    if (blur_level < BLUR_LEVEL_0 || BLUR_LEVEL_MAX <= blur_level) {
-        LOGE("ERR(%s):Invalid level (%d)", __func__, blur_level);
-        return -1;
-    }
-
-    if (m_blur_level != blur_level) {
-        m_blur_level = blur_level;
-        if (m_flag_camera_start) {
-            if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR, blur_level) < 0) {
-                LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VGA_BLUR", __func__);
-                return -1;
-            }
-        }
-    }
-    return 0;
-}
-
-int SecCamera::getBlur(void)
-{
-    return m_blur_level;
-}
-
-int SecCamera::setDataLineCheck(int chk_dataline)
-{
-    LOGV("%s(chk_dataline (%d))", __func__, chk_dataline);
-
-    if (chk_dataline < CHK_DATALINE_OFF || CHK_DATALINE_MAX <= chk_dataline) {
-        LOGE("ERR(%s):Invalid chk_dataline (%d)", __func__, chk_dataline);
-        return -1;
-    }
-
-    if (m_chk_dataline != chk_dataline) {
-        m_chk_dataline = chk_dataline;
-    }
-
-    return 0;
-}
-
-int SecCamera::getDataLineCheck(void)
-{
-    return m_chk_dataline;
-}
-
-int SecCamera::setDataLineCheckStop(void)
-{
-    LOGV("%s", __func__);
-
-    if (m_flag_camera_start) {
-        if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CHECK_DATALINE_STOP, 1) < 0) {
-            LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CHECK_DATALINE_STOP", __func__);
-            return -1;
-        }
-    }
-    return 0;
-}
-
-const __u8* SecCamera::getCameraSensorName(void)
-{
-    LOGV("%s", __func__);
-
-    return fimc_v4l2_enuminput(m_cam_fd, getCameraId());
-}
-
-#ifdef ENABLE_ESD_PREVIEW_CHECK
-int SecCamera::getCameraSensorESDStatus(void)
-{
-    LOGV("%s", __func__);
-
-    // 0 : normal operation, 1 : abnormal operation
-    int status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_ESD_INT);
-
-    return status;
-}
-#endif // ENABLE_ESD_PREVIEW_CHECK
-
-// ======================================================================
-// Jpeg
-
-int SecCamera::setJpegThumbnailSize(int width, int height)
-{
-    LOGV("%s(width(%d), height(%d))", __func__, width, height);
-
-    m_jpeg_thumbnail_width  = width;
-    m_jpeg_thumbnail_height = height;
-
-    return 0;
-}
-
-int SecCamera::getJpegThumbnailSize(int *width, int  *height)
-{
-    if (width)
-        *width   = m_jpeg_thumbnail_width;
-    if (height)
-        *height  = m_jpeg_thumbnail_height;
-
-    return 0;
-}
-
-void SecCamera::setExifFixedAttribute()
-{
-    char property[PROPERTY_VALUE_MAX];
-
-    //2 0th IFD TIFF Tags
-    //3 Maker
-    property_get("ro.product.brand", property, EXIF_DEF_MAKER);
-    strncpy((char *)mExifInfo.maker, property,
-                sizeof(mExifInfo.maker) - 1);
-    mExifInfo.maker[sizeof(mExifInfo.maker) - 1] = '\0';
-    //3 Model
-    property_get("ro.product.model", property, EXIF_DEF_MODEL);
-    strncpy((char *)mExifInfo.model, property,
-                sizeof(mExifInfo.model) - 1);
-    mExifInfo.model[sizeof(mExifInfo.model) - 1] = '\0';
-    //3 Software
-    property_get("ro.build.id", property, EXIF_DEF_SOFTWARE);
-    strncpy((char *)mExifInfo.software, property,
-                sizeof(mExifInfo.software) - 1);
-    mExifInfo.software[sizeof(mExifInfo.software) - 1] = '\0';
-
-    //3 YCbCr Positioning
-    mExifInfo.ycbcr_positioning = EXIF_DEF_YCBCR_POSITIONING;
-
-    //2 0th IFD Exif Private Tags
-    //3 F Number
-    mExifInfo.fnumber.num = EXIF_DEF_FNUMBER_NUM;
-    mExifInfo.fnumber.den = EXIF_DEF_FNUMBER_DEN;
-    //3 Exposure Program
-    mExifInfo.exposure_program = EXIF_DEF_EXPOSURE_PROGRAM;
-    //3 Exif Version
-    memcpy(mExifInfo.exif_version, EXIF_DEF_EXIF_VERSION, sizeof(mExifInfo.exif_version));
-    //3 Aperture
-    uint32_t av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num/mExifInfo.fnumber.den);
-    mExifInfo.aperture.num = av*EXIF_DEF_APEX_DEN;
-    mExifInfo.aperture.den = EXIF_DEF_APEX_DEN;
-    //3 Maximum lens aperture
-    mExifInfo.max_aperture.num = mExifInfo.aperture.num;
-    mExifInfo.max_aperture.den = mExifInfo.aperture.den;
-    //3 Lens Focal Length
-    if (m_camera_id == CAMERA_ID_BACK)
-        mExifInfo.focal_length.num = BACK_CAMERA_FOCAL_LENGTH;
-    else
-        mExifInfo.focal_length.num = FRONT_CAMERA_FOCAL_LENGTH;
-
-    mExifInfo.focal_length.den = EXIF_DEF_FOCAL_LEN_DEN;
-    //3 User Comments
-    strcpy((char *)mExifInfo.user_comment, EXIF_DEF_USERCOMMENTS);
-    //3 Color Space information
-    mExifInfo.color_space = EXIF_DEF_COLOR_SPACE;
-    //3 Exposure Mode
-    mExifInfo.exposure_mode = EXIF_DEF_EXPOSURE_MODE;
-
-    //2 0th IFD GPS Info Tags
-    unsigned char gps_version[4] = { 0x02, 0x02, 0x00, 0x00 };
-    memcpy(mExifInfo.gps_version_id, gps_version, sizeof(gps_version));
-
-    //2 1th IFD TIFF Tags
-    mExifInfo.compression_scheme = EXIF_DEF_COMPRESSION;
-    mExifInfo.x_resolution.num = EXIF_DEF_RESOLUTION_NUM;
-    mExifInfo.x_resolution.den = EXIF_DEF_RESOLUTION_DEN;
-    mExifInfo.y_resolution.num = EXIF_DEF_RESOLUTION_NUM;
-    mExifInfo.y_resolution.den = EXIF_DEF_RESOLUTION_DEN;
-    mExifInfo.resolution_unit = EXIF_DEF_RESOLUTION_UNIT;
-}
-
-void SecCamera::setExifChangedAttribute()
-{
-    //2 0th IFD TIFF Tags
-    //3 Width
-    mExifInfo.width = m_snapshot_width;
-    //3 Height
-    mExifInfo.height = m_snapshot_height;
-    //3 Orientation
-    switch (m_exif_orientation) {
-    case 0:
-        mExifInfo.orientation = EXIF_ORIENTATION_UP;
-        break;
-    case 90:
-        mExifInfo.orientation = EXIF_ORIENTATION_90;
-        break;
-    case 180:
-        mExifInfo.orientation = EXIF_ORIENTATION_180;
-        break;
-    case 270:
-        mExifInfo.orientation = EXIF_ORIENTATION_270;
-        break;
-    default:
-        mExifInfo.orientation = EXIF_ORIENTATION_UP;
-        break;
-    }
-    //3 Date time
-    time_t rawtime;
-    struct tm *timeinfo;
-    time(&rawtime);
-    timeinfo = localtime(&rawtime);
-    strftime((char *)mExifInfo.date_time, 20, "%Y:%m:%d %H:%M:%S", timeinfo);
-
-    //2 0th IFD Exif Private Tags
-    //3 Exposure Time
-    int shutterSpeed = fimc_v4l2_g_ctrl(m_cam_fd,
-                                            V4L2_CID_CAMERA_GET_SHT_TIME);
-    /* TBD - front camera needs to be fixed to support this g_ctrl,
-       it current returns a negative err value, so avoid putting
-       odd value into exif for now */
-    if (shutterSpeed < 0) {
-        LOGE("%s: error %d getting shutterSpeed, camera_id = %d, using 100",
-             __func__, shutterSpeed, m_camera_id);
-        shutterSpeed = 100;
-    }
-    mExifInfo.exposure_time.num = 1;
-    // x us -> 1/x s */
-    mExifInfo.exposure_time.den = (uint32_t)(1000000 / shutterSpeed);
-
-    //3 ISO Speed Rating
-    int iso = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_ISO);
-    /* TBD - front camera needs to be fixed to support this g_ctrl,
-       it current returns a negative err value, so avoid putting
-       odd value into exif for now */
-    if (iso < 0) {
-        LOGE("%s: error %d getting iso, camera_id = %d, using 100",
-             __func__, iso, m_camera_id);
-        iso = ISO_100;
-    }
-    switch(iso) {
-        case ISO_50:
-            mExifInfo.iso_speed_rating = 50;
-            break;
-        case ISO_100:
-            mExifInfo.iso_speed_rating = 100;
-            break;
-        case ISO_200:
-            mExifInfo.iso_speed_rating = 200;
-            break;
-        case ISO_400:
-            mExifInfo.iso_speed_rating = 400;
-            break;
-        case ISO_800:
-            mExifInfo.iso_speed_rating = 800;
-            break;
-        case ISO_1600:
-            mExifInfo.iso_speed_rating = 1600;
-            break;
-        default:
-            mExifInfo.iso_speed_rating = 100;
-            break;
-    }
-
-    uint32_t av, tv, bv, sv, ev;
-    av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num / mExifInfo.fnumber.den);
-    tv = APEX_EXPOSURE_TO_SHUTTER((double)mExifInfo.exposure_time.num / mExifInfo.exposure_time.den);
-    sv = APEX_ISO_TO_FILMSENSITIVITY(mExifInfo.iso_speed_rating);
-    bv = av + tv - sv;
-    ev = av + tv;
-    LOGD("Shutter speed=%d us, iso=%d\n", shutterSpeed, mExifInfo.iso_speed_rating);
-    LOGD("AV=%d, TV=%d, SV=%d\n", av, tv, sv);
-
-    //3 Shutter Speed
-    mExifInfo.shutter_speed.num = tv*EXIF_DEF_APEX_DEN;
-    mExifInfo.shutter_speed.den = EXIF_DEF_APEX_DEN;
-    //3 Brightness
-    mExifInfo.brightness.num = bv*EXIF_DEF_APEX_DEN;
-    mExifInfo.brightness.den = EXIF_DEF_APEX_DEN;
-    //3 Exposure Bias
-    if (m_params->scene_mode == SCENE_MODE_BEACH_SNOW) {
-        mExifInfo.exposure_bias.num = EXIF_DEF_APEX_DEN;
-        mExifInfo.exposure_bias.den = EXIF_DEF_APEX_DEN;
-    } else {
-        mExifInfo.exposure_bias.num = 0;
-        mExifInfo.exposure_bias.den = 0;
-    }
-    //3 Metering Mode
-    switch (m_params->metering) {
-    case METERING_SPOT:
-        mExifInfo.metering_mode = EXIF_METERING_SPOT;
-        break;
-    case METERING_MATRIX:
-        mExifInfo.metering_mode = EXIF_METERING_AVERAGE;
-        break;
-    case METERING_CENTER:
-        mExifInfo.metering_mode = EXIF_METERING_CENTER;
-        break;
-    default :
-        mExifInfo.metering_mode = EXIF_METERING_AVERAGE;
-        break;
-    }
-
-    //3 Flash
-    int flash = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_FLASH_ONOFF);
-    if (flash < 0)
-        mExifInfo.flash = EXIF_DEF_FLASH;
-    else
-        mExifInfo.flash = flash;
-
-    //3 White Balance
-    if (m_params->white_balance == WHITE_BALANCE_AUTO)
-        mExifInfo.white_balance = EXIF_WB_AUTO;
-    else
-        mExifInfo.white_balance = EXIF_WB_MANUAL;
-    //3 Scene Capture Type
-    switch (m_params->scene_mode) {
-    case SCENE_MODE_PORTRAIT:
-        mExifInfo.scene_capture_type = EXIF_SCENE_PORTRAIT;
-        break;
-    case SCENE_MODE_LANDSCAPE:
-        mExifInfo.scene_capture_type = EXIF_SCENE_LANDSCAPE;
-        break;
-    case SCENE_MODE_NIGHTSHOT:
-        mExifInfo.scene_capture_type = EXIF_SCENE_NIGHT;
-        break;
-    default:
-        mExifInfo.scene_capture_type = EXIF_SCENE_STANDARD;
-        break;
-    }
-
-    //2 0th IFD GPS Info Tags
-    if (m_gps_latitude != 0 && m_gps_longitude != 0) {
-        if (m_gps_latitude > 0)
-            strcpy((char *)mExifInfo.gps_latitude_ref, "N");
-        else
-            strcpy((char *)mExifInfo.gps_latitude_ref, "S");
-
-        if (m_gps_longitude > 0)
-            strcpy((char *)mExifInfo.gps_longitude_ref, "E");
-        else
-            strcpy((char *)mExifInfo.gps_longitude_ref, "W");
-
-        if (m_gps_altitude > 0)
-            mExifInfo.gps_altitude_ref = 0;
-        else
-            mExifInfo.gps_altitude_ref = 1;
-
-        double latitude = fabs(m_gps_latitude / 10000.0);
-        double longitude = fabs(m_gps_longitude / 10000.0);
-        double altitude = fabs(m_gps_altitude / 100.0);
-
-        mExifInfo.gps_latitude[0].num = (uint32_t)latitude;
-        mExifInfo.gps_latitude[0].den = 1;
-        mExifInfo.gps_latitude[1].num = (uint32_t)((latitude - mExifInfo.gps_latitude[0].num) * 60);
-        mExifInfo.gps_latitude[1].den = 1;
-        mExifInfo.gps_latitude[2].num = (uint32_t)((((latitude - mExifInfo.gps_latitude[0].num) * 60)
-                                        - mExifInfo.gps_latitude[1].num) * 60);
-        mExifInfo.gps_latitude[2].den = 1;
-
-        mExifInfo.gps_longitude[0].num = (uint32_t)longitude;
-        mExifInfo.gps_longitude[0].den = 1;
-        mExifInfo.gps_longitude[1].num = (uint32_t)((longitude - mExifInfo.gps_longitude[0].num) * 60);
-        mExifInfo.gps_longitude[1].den = 1;
-        mExifInfo.gps_longitude[2].num = (uint32_t)((((longitude - mExifInfo.gps_longitude[0].num) * 60)
-                                        - mExifInfo.gps_longitude[1].num) * 60);
-        mExifInfo.gps_longitude[2].den = 1;
-
-        mExifInfo.gps_altitude.num = (uint32_t)altitude;
-        mExifInfo.gps_altitude.den = 1;
-
-        struct tm tm_data;
-        gmtime_r(&m_gps_timestamp, &tm_data);
-        mExifInfo.gps_timestamp[0].num = tm_data.tm_hour;
-        mExifInfo.gps_timestamp[0].den = 1;
-        mExifInfo.gps_timestamp[1].num = tm_data.tm_min;
-        mExifInfo.gps_timestamp[1].den = 1;
-        mExifInfo.gps_timestamp[2].num = tm_data.tm_sec;
-        mExifInfo.gps_timestamp[2].den = 1;
-        snprintf((char*)mExifInfo.gps_datestamp, sizeof(mExifInfo.gps_datestamp),
-                "%04d:%02d:%02d", tm_data.tm_year + 1900, tm_data.tm_mon, tm_data.tm_mday);
-
-        mExifInfo.enableGps = true;
-    } else {
-        mExifInfo.enableGps = false;
-    }
-
-    //2 1th IFD TIFF Tags
-    mExifInfo.widthThumb = m_jpeg_thumbnail_width;
-    mExifInfo.heightThumb = m_jpeg_thumbnail_height;
-}
-
-// ======================================================================
-// Conversions
-
-inline int SecCamera::m_frameSize(int format, int width, int height)
-{
-    int size = 0;
-
-    switch (format) {
-    case V4L2_PIX_FMT_YUV420:
-    case V4L2_PIX_FMT_NV12:
-    case V4L2_PIX_FMT_NV21:
-        size = (width * height * 3 / 2);
-        break;
-
-    case V4L2_PIX_FMT_NV12T:
-        size = ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)) +
-                            ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2));
-        break;
-
-    case V4L2_PIX_FMT_YUV422P:
-    case V4L2_PIX_FMT_YUYV:
-    case V4L2_PIX_FMT_UYVY:
-        size = (width * height * 2);
-        break;
-
-    default :
-        LOGE("ERR(%s):Invalid V4L2 pixel format(%d)\n", __func__, format);
-    case V4L2_PIX_FMT_RGB565:
-        size = (width * height * BPP);
-        break;
-    }
-
-    return size;
-}
-
-status_t SecCamera::dump(int fd, const Vector<String16> &args)
-{
-    const size_t SIZE = 256;
-    char buffer[SIZE];
-    String8 result;
-    snprintf(buffer, 255, "dump(%d)\n", fd);
-    result.append(buffer);
-    ::write(fd, result.string(), result.size());
-    return NO_ERROR;
-}
-
-double SecCamera::jpeg_ratio = 0.7;
-int SecCamera::interleaveDataSize = 4261248;
-int SecCamera::jpegLineLength = 636;
-
-}; // namespace android
diff --git a/libcamera/SecCamera.h b/libcamera/SecCamera.h
deleted file mode 100644
index b846201..0000000
--- a/libcamera/SecCamera.h
+++ /dev/null
@@ -1,538 +0,0 @@
-/*
-**
-** Copyright 2008, The Android Open Source Project
-** Copyright 2010, Samsung Electronics Co. LTD
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#ifndef ANDROID_HARDWARE_CAMERA_SEC_H
-#define ANDROID_HARDWARE_CAMERA_SEC_H
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include <fcntl.h>
-#include <unistd.h>
-#include <errno.h>
-#include <signal.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-#include <sys/poll.h>
-#include <sys/stat.h>
-
-#include <linux/videodev2.h>
-#include <videodev2_samsung.h>
-
-#include "JpegEncoder.h"
-
-#include <camera/CameraHardwareInterface.h>
-
-namespace android {
-
-#define ENABLE_ESD_PREVIEW_CHECK
-
-#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
-#define LOG_CAMERA LOGD
-#define LOG_CAMERA_PREVIEW LOGD
-
-#define LOG_TIME_DEFINE(n) \
-    struct timeval time_start_##n, time_stop_##n; unsigned long log_time_##n = 0;
-
-#define LOG_TIME_START(n) \
-    gettimeofday(&time_start_##n, NULL);
-
-#define LOG_TIME_END(n) \
-    gettimeofday(&time_stop_##n, NULL); log_time_##n = measure_time(&time_start_##n, &time_stop_##n);
-
-#define LOG_TIME(n) \
-    log_time_##n
-
-#else
-#define LOG_CAMERA(...)
-#define LOG_CAMERA_PREVIEW(...)
-#define LOG_TIME_DEFINE(n)
-#define LOG_TIME_START(n)
-#define LOG_TIME_END(n)
-#define LOG_TIME(n)
-#endif
-
-#define MAX_BACK_CAMERA_PREVIEW_WIDTH       720
-#define MAX_BACK_CAMERA_PREVIEW_HEIGHT      480
-#define MAX_BACK_CAMERA_SNAPSHOT_WIDTH      2560
-#define MAX_BACK_CAMERA_SNAPSHOT_HEIGHT     1920
-#define BACK_CAMERA_POSTVIEW_WIDTH          640
-#define BACK_CAMERA_POSTVIEW_WIDE_WIDTH     800
-#define BACK_CAMERA_POSTVIEW_HEIGHT         480
-#define BACK_CAMERA_POSTVIEW_BPP            16
-#define BACK_CAMERA_THUMBNAIL_WIDTH         320
-#define BACK_CAMERA_THUMBNAIL_HEIGHT        240
-#define BACK_CAMERA_THUMBNAIL_BPP           16
-
-#define BACK_CAMERA_FOCAL_LENGTH            379 /* 3.79mm */
-
-#define MAX_FRONT_CAMERA_PREVIEW_WIDTH      640
-#define MAX_FRONT_CAMERA_PREVIEW_HEIGHT     480
-#define MAX_FRONT_CAMERA_SNAPSHOT_WIDTH     640
-#define MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT    480
-
-#define FRONT_CAMERA_THUMBNAIL_WIDTH        160
-#define FRONT_CAMERA_THUMBNAIL_HEIGHT       120
-#define FRONT_CAMERA_THUMBNAIL_BPP          16
-#define FRONT_CAMERA_FOCAL_LENGTH           130 /* 1.3mm */
-
-#define DEFAULT_JPEG_THUMBNAIL_WIDTH        256
-#define DEFAULT_JPEG_THUMBNAIL_HEIGHT       192
-
-#ifndef CAMERA_DEV_NAME
-#define CAMERA_DEV_NAME   "/dev/video0"
-#endif
-#ifndef CAMERA_DEV_NAME2
-#define CAMERA_DEV_NAME2  "/dev/video2"
-#endif
-
-#define CAMERA_DEV_NAME_TEMP "/data/videotmp_000"
-#define CAMERA_DEV_NAME2_TEMP "/data/videotemp_002"
-
-
-#define BPP             2
-#define MIN(x, y)       (((x) < (y)) ? (x) : (y))
-#define MAX_BUFFERS     11
-
-/*
- * V 4 L 2   F I M C   E X T E N S I O N S
- *
- */
-#define V4L2_CID_ROTATION                   (V4L2_CID_PRIVATE_BASE + 0)
-#define V4L2_CID_PADDR_Y                    (V4L2_CID_PRIVATE_BASE + 1)
-#define V4L2_CID_PADDR_CB                   (V4L2_CID_PRIVATE_BASE + 2)
-#define V4L2_CID_PADDR_CR                   (V4L2_CID_PRIVATE_BASE + 3)
-#define V4L2_CID_PADDR_CBCR                 (V4L2_CID_PRIVATE_BASE + 4)
-#define V4L2_CID_STREAM_PAUSE               (V4L2_CID_PRIVATE_BASE + 53)
-
-#define V4L2_CID_CAM_JPEG_MAIN_SIZE         (V4L2_CID_PRIVATE_BASE + 32)
-#define V4L2_CID_CAM_JPEG_MAIN_OFFSET       (V4L2_CID_PRIVATE_BASE + 33)
-#define V4L2_CID_CAM_JPEG_THUMB_SIZE        (V4L2_CID_PRIVATE_BASE + 34)
-#define V4L2_CID_CAM_JPEG_THUMB_OFFSET      (V4L2_CID_PRIVATE_BASE + 35)
-#define V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET   (V4L2_CID_PRIVATE_BASE + 36)
-#define V4L2_CID_CAM_JPEG_QUALITY           (V4L2_CID_PRIVATE_BASE + 37)
-
-#define TPATTERN_COLORBAR           1
-#define TPATTERN_HORIZONTAL         2
-#define TPATTERN_VERTICAL           3
-
-#define V4L2_PIX_FMT_YVYU           v4l2_fourcc('Y', 'V', 'Y', 'U')
-
-/* FOURCC for FIMC specific */
-#define V4L2_PIX_FMT_VYUY           v4l2_fourcc('V', 'Y', 'U', 'Y')
-#define V4L2_PIX_FMT_NV16           v4l2_fourcc('N', 'V', '1', '6')
-#define V4L2_PIX_FMT_NV61           v4l2_fourcc('N', 'V', '6', '1')
-#define V4L2_PIX_FMT_NV12T          v4l2_fourcc('T', 'V', '1', '2')
-/*
- * U S E R   D E F I N E D   T Y P E S
- *
- */
-
-struct fimc_buffer {
-    void    *start;
-    size_t  length;
-};
-
-struct yuv_fmt_list {
-    const char  *name;
-    const char  *desc;
-    unsigned int    fmt;
-    int     depth;
-    int     planes;
-};
-
-//s1 [Apply factory standard]
-struct camsensor_date_info {
-    unsigned int year;
-    unsigned int month;
-    unsigned int date;
-};
-
-
-class SecCamera {
-public:
-
-    enum CAMERA_ID {
-        CAMERA_ID_BACK  = 0,
-        CAMERA_ID_FRONT = 1,
-    };
-
-    enum JPEG_QUALITY {
-        JPEG_QUALITY_ECONOMY    = 0,
-        JPEG_QUALITY_NORMAL     = 50,
-        JPEG_QUALITY_SUPERFINE  = 100,
-        JPEG_QUALITY_MAX,
-    };
-
-    enum OBJECT_TRACKING {
-        OBJECT_TRACKING_OFF,
-        OBJECT_TRACKING_ON,
-        OBJECT_TRACKING_MAX,
-    };
-
-    /*VT call*/
-    enum VT_MODE {
-        VT_MODE_OFF,
-        VT_MODE_ON,
-        VT_MODE_MAX,
-    };
-
-    /*Camera sensor mode - Camcorder fix fps*/
-    enum SENSOR_MODE {
-        SENSOR_MODE_CAMERA,
-        SENSOR_MODE_MOVIE,
-    };
-
-    /*Camera Shot mode*/
-    enum SHOT_MODE {
-        SHOT_MODE_SINGLE        = 0,
-        SHOT_MODE_CONTINUOUS    = 1,
-        SHOT_MODE_PANORAMA      = 2,
-        SHOT_MODE_SMILE         = 3,
-        SHOT_MODE_SELF          = 6,
-    };
-
-    enum CHK_DATALINE {
-        CHK_DATALINE_OFF,
-        CHK_DATALINE_ON,
-        CHK_DATALINE_MAX,
-    };
-
-    int m_touch_af_start_stop;
-
-    struct gps_info_latiude {
-        unsigned int    north_south;
-        unsigned int    dgree;
-        unsigned int    minute;
-        unsigned int    second;
-    } gpsInfoLatitude;
-    struct gps_info_longitude {
-        unsigned int    east_west;
-        unsigned int    dgree;
-        unsigned int    minute;
-        unsigned int    second;
-    } gpsInfoLongitude;
-    struct gps_info_altitude {
-        unsigned int    plus_minus;
-        unsigned int    dgree;
-        unsigned int    minute;
-        unsigned int    second;
-    } gpsInfoAltitude;
-
-    SecCamera();
-    ~SecCamera();
-
-    static SecCamera* createInstance(void)
-    {
-        static SecCamera singleton;
-        return &singleton;
-    }
-    status_t dump(int fd, const Vector<String16>& args);
-
-    int             flagCreate(void) const;
-
-    int             getCameraId(void);
-
-    int             startPreview(void);
-    int             stopPreview(void);
-
-    int             startRecord(void);
-    int             stopRecord(void);
-    int             getRecordFrame(void);
-    int             releaseRecordFrame(int index);
-    unsigned int    getRecPhyAddrY(int);
-    unsigned int    getRecPhyAddrC(int);
-
-    int             getPreview(void);
-    int             setPreviewSize(int width, int height, int pixel_format);
-    int             getPreviewSize(int *width, int *height, int *frame_size);
-    int             getPreviewMaxSize(int *width, int *height);
-    int             getPreviewPixelFormat(void);
-    int             setPreviewImage(int index, unsigned char *buffer, int size);
-
-    int             setSnapshotSize(int width, int height);
-    int             getSnapshotSize(int *width, int *height, int *frame_size);
-    int             getSnapshotMaxSize(int *width, int *height);
-    int             setSnapshotPixelFormat(int pixel_format);
-    int             getSnapshotPixelFormat(void);
-
-    unsigned char*  getJpeg(unsigned char *snapshot_data, int snapshot_size, int *size);
-    unsigned char*  yuv2Jpeg(unsigned char *raw_data, int raw_size,
-                                int *jpeg_size,
-                                int width, int height, int pixel_format);
-
-    int             setJpegThumbnailSize(int width, int height);
-    int             getJpegThumbnailSize(int *width, int *height);
-
-    int             setAutofocus(void);
-    int             zoomIn(void);
-    int             zoomOut(void);
-
-    int             SetRotate(int angle);
-    int             getRotate(void);
-
-    int             setVerticalMirror(void);
-    int             setHorizontalMirror(void);
-
-    int             setWhiteBalance(int white_balance);
-    int             getWhiteBalance(void);
-
-    int             setBrightness(int brightness);
-    int             getBrightness(void);
-
-    int             setImageEffect(int image_effect);
-    int             getImageEffect(void);
-
-    int             setSceneMode(int scene_mode);
-    int             getSceneMode(void);
-
-    int             setFlashMode(int flash_mode);
-    int             getFlashMode(void);
-
-    int             setMetering(int metering_value);
-    int             getMetering(void);
-
-    int             setISO(int iso_value);
-    int             getISO(void);
-
-    int             setContrast(int contrast_value);
-    int             getContrast(void);
-
-    int             setSaturation(int saturation_value);
-    int             getSaturation(void);
-
-    int             setSharpness(int sharpness_value);
-    int             getSharpness(void);
-
-    int             setWDR(int wdr_value);
-    int             getWDR(void);
-
-    int             setAntiShake(int anti_shake);
-    int             getAntiShake(void);
-
-    int             setJpegQuality(int jpeg_qality);
-    int             getJpegQuality(void);
-
-    int             setZoom(int zoom_level);
-    int             getZoom(void);
-
-    int             setObjectTracking(int object_tracking);
-    int             getObjectTracking(void);
-    int             getObjectTrackingStatus(void);
-
-    int             setSmartAuto(int smart_auto);
-    int             getSmartAuto(void);
-    int             getAutosceneStatus(void);
-
-    int             setBeautyShot(int beauty_shot);
-    int             getBeautyShot(void);
-
-    int             setVintageMode(int vintage_mode);
-    int             getVintageMode(void);
-
-    int             setFocusMode(int focus_mode);
-    int             getFocusMode(void);
-
-    int             setFaceDetect(int face_detect);
-    int             getFaceDetect(void);
-
-    int             setGPSLatitude(const char *gps_latitude);
-    int             setGPSLongitude(const char *gps_longitude);
-    int             setGPSAltitude(const char *gps_altitude);
-    int             setGPSTimeStamp(const char *gps_timestamp);
-    int             setGPSProcessingMethod(const char *gps_timestamp);
-    int             cancelAutofocus(void);
-    int             setFaceDetectLockUnlock(int facedetect_lockunlock);
-    int             setObjectPosition(int x, int y);
-    int             setObjectTrackingStartStop(int start_stop);
-    int             setTouchAFStartStop(int start_stop);
-    int             setCAFStatus(int on_off);
-    int             getAutoFocusResult(void);
-    int             setAntiBanding(int anti_banding);
-    int             getPostview(void);
-    int             setRecordingSize(int width, int height);
-    int             setGamma(int gamma);
-    int             setSlowAE(int slow_ae);
-    int             setExifOrientationInfo(int orientationInfo);
-    int             setBatchReflection(void);
-    int             setSnapshotCmd(void);
-    int             endSnapshot(void);
-    int             setCameraSensorReset(void);
-    int             setSensorMode(int sensor_mode); /* Camcorder fix fps */
-    int             setShotMode(int shot_mode);     /* Shot mode */
-    /*VT call*/
-    int             setVTmode(int vtmode);
-    int             getVTmode(void);
-    int             setBlur(int blur_level);
-    int             getBlur(void);
-    int             setDataLineCheck(int chk_dataline);
-    int             getDataLineCheck(void);
-    int             setDataLineCheckStop(void);
-    int             setDefultIMEI(int imei);
-    int             getDefultIMEI(void);
-    const __u8*     getCameraSensorName(void);
-    int             previewPoll(bool preview);
-#ifdef ENABLE_ESD_PREVIEW_CHECK
-    int             getCameraSensorESDStatus(void);
-#endif // ENABLE_ESD_PREVIEW_CHECK
-
-    int setFrameRate(int frame_rate);
-    unsigned char*  getJpeg(int*, unsigned int*);
-    int             getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf,
-                                        unsigned int *output_size);
-    int             getExif(unsigned char *pExifDst, unsigned char *pThumbSrc);
-
-    void            getPostViewConfig(int*, int*, int*);
-    void            getThumbnailConfig(int *width, int *height, int *size);
-
-    int             getPostViewOffset(void);
-    int             getCameraFd(void);
-    int             getJpegFd(void);
-    void            SetJpgAddr(unsigned char *addr);
-    unsigned int    getPhyAddrY(int);
-    unsigned int    getPhyAddrC(int);
-    void            pausePreview();
-    int             initCamera(int index);
-    void            DeinitCamera();
-    static void     setJpegRatio(double ratio)
-    {
-        if((ratio < 0) || (ratio > 1))
-            return;
-
-        jpeg_ratio = ratio;
-    }
-
-    static double   getJpegRatio()
-    {
-        return jpeg_ratio;
-    }
-
-    static void     setInterleaveDataSize(int x)
-    {
-        interleaveDataSize = x;
-    }
-
-    static int      getInterleaveDataSize()
-    {
-        return interleaveDataSize;
-    }
-
-    static void     setJpegLineLength(int x)
-    {
-        jpegLineLength = x;
-    }
-
-    static int      getJpegLineLength()
-    {
-        return jpegLineLength;
-    }
-
-
-private:
-    v4l2_streamparm m_streamparm;
-    struct sec_cam_parm   *m_params;
-    int             m_flag_init;
-
-    int             m_camera_id;
-
-    int             m_cam_fd;
-
-    int             m_cam_fd_temp;
-    int             m_cam_fd2_temp;
-
-    int             m_cam_fd2;
-    struct pollfd   m_events_c2;
-    int             m_flag_record_start;
-
-    int             m_preview_v4lformat;
-    int             m_preview_width;
-    int             m_preview_height;
-    int             m_preview_max_width;
-    int             m_preview_max_height;
-
-    int             m_snapshot_v4lformat;
-    int             m_snapshot_width;
-    int             m_snapshot_height;
-    int             m_snapshot_max_width;
-    int             m_snapshot_max_height;
-
-    int             m_angle;
-    int             m_anti_banding;
-    int             m_wdr;
-    int             m_anti_shake;
-    int             m_zoom_level;
-    int             m_object_tracking;
-    int             m_smart_auto;
-    int             m_beauty_shot;
-    int             m_vintage_mode;
-    int             m_face_detect;
-    int             m_object_tracking_start_stop;
-    int             m_recording_width;
-    int             m_recording_height;
-    long            m_gps_latitude;
-    long            m_gps_longitude;
-    long            m_gps_altitude;
-    long            m_gps_timestamp;
-    int             m_vtmode;
-    int             m_sensor_mode; /*Camcorder fix fps */
-    int             m_shot_mode; /* Shot mode */
-    int             m_exif_orientation;
-    int             m_blur_level;
-    int             m_chk_dataline;
-    int             m_video_gamma;
-    int             m_slow_ae;
-    int             m_caf_on_off;
-    int             m_default_imei;
-    int             m_camera_af_flag;
-
-    int             m_flag_camera_start;
-
-    int             m_jpeg_fd;
-    int             m_jpeg_thumbnail_width;
-    int             m_jpeg_thumbnail_height;
-    int             m_jpeg_quality;
-
-    int             m_postview_offset;
-
-#ifdef ENABLE_ESD_PREVIEW_CHECK
-    int             m_esd_check_count;
-#endif // ENABLE_ESD_PREVIEW_CHECK
-
-    exif_attribute_t mExifInfo;
-
-    struct fimc_buffer m_capture_buf;
-    struct pollfd   m_events_c;
-
-    inline int      m_frameSize(int format, int width, int height);
-
-    void            setExifChangedAttribute();
-    void            setExifFixedAttribute();
-    void            resetCamera();
-
-    static double   jpeg_ratio;
-    static int      interleaveDataSize;
-    static int      jpegLineLength;
-};
-
-extern unsigned long measure_time(struct timeval *start, struct timeval *stop);
-
-}; // namespace android
-
-#endif // ANDROID_HARDWARE_CAMERA_SEC_H
diff --git a/libcamera/SecCameraHWInterface.cpp b/libcamera/SecCameraHWInterface.cpp
deleted file mode 100644
index f019e01..0000000
--- a/libcamera/SecCameraHWInterface.cpp
+++ /dev/null
@@ -1,2142 +0,0 @@
-/*
-**
-** Copyright 2008, The Android Open Source Project
-** Copyright 2010, Samsung Electronics Co. LTD
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#define LOG_NDEBUG 0
-#define LOG_TAG "CameraHardwareSec"
-#include <utils/Log.h>
-
-#include "SecCameraHWInterface.h"
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#if defined(BOARD_USES_OVERLAY)
-#include <hardware/overlay.h>
-#include <ui/Overlay.h>
-#define CACHEABLE_BUFFERS       0x1
-#define ALL_BUFFERS_FLUSHED     -66
-#endif
-
-#define VIDEO_COMMENT_MARKER_H          0xFFBE
-#define VIDEO_COMMENT_MARKER_L          0xFFBF
-#define VIDEO_COMMENT_MARKER_LENGTH     4
-#define JPEG_EOI_MARKER                 0xFFD9
-#define HIBYTE(x) (((x) >> 8) & 0xFF)
-#define LOBYTE(x) ((x) & 0xFF)
-
-#define BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR       "0.10,1.20,Infinity"
-#define BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR      "0.10,0.20,Infinity"
-#define BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR   "0.10,1.20,Infinity"
-#define FRONT_CAMERA_FOCUS_DISTANCES_STR           "0.20,0.25,Infinity"
-
-namespace android {
-
-struct addrs {
-    unsigned int addr_y;
-    unsigned int addr_cbcr;
-    unsigned int buf_index;
-    unsigned int reserved;
-};
-
-struct addrs_cap {
-    unsigned int addr_y;
-    unsigned int width;
-    unsigned int height;
-};
-
-static const int INITIAL_SKIP_FRAME = 3;
-static const int EFFECT_SKIP_FRAME = 1;
-
-CameraHardwareSec::CameraHardwareSec(int cameraId)
-        :
-          mCaptureInProgress(false),
-          mParameters(),
-          mPreviewHeap(0),
-          mRawHeap(0),
-          mRecordHeap(0),
-          mJpegHeap(0),
-          mSecCamera(NULL),
-          mCameraSensorName(NULL),
-          mSkipFrame(0),
-#if defined(BOARD_USES_OVERLAY)
-          mUseOverlay(false),
-          mOverlayBufferIdx(0),
-#endif
-          mNotifyCb(0),
-          mDataCb(0),
-          mDataCbTimestamp(0),
-          mCallbackCookie(0),
-          mMsgEnabled(0),
-          mRecordRunning(false),
-          mPostViewWidth(0),
-          mPostViewHeight(0),
-          mPostViewSize(0)
-{
-    LOGV("%s :", __func__);
-    int ret = 0;
-
-    mSecCamera = SecCamera::createInstance();
-
-    if (mSecCamera == NULL) {
-        LOGE("ERR(%s):Fail on mSecCamera object creation", __func__);
-    }
-
-    ret = mSecCamera->initCamera(cameraId);
-    if (ret < 0) {
-        LOGE("ERR(%s):Fail on mSecCamera init", __func__);
-    }
-
-    if (mSecCamera->flagCreate() == 0) {
-        LOGE("ERR(%s):Fail on mSecCamera->flagCreate()", __func__);
-    }
-
-    int recordHeapSize = sizeof(struct addrs) * kBufferCount;
-    LOGV("mRecordHeap : MemoryHeapBase(recordHeapSize(%d))", recordHeapSize);
-    mRecordHeap = new MemoryHeapBase(recordHeapSize);
-    if (mRecordHeap->getHeapID() < 0) {
-        LOGE("ERR(%s): Record heap creation fail", __func__);
-        mRecordHeap.clear();
-    }
-
-    mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
-    LOGV("mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
-            mPostViewWidth,mPostViewHeight,mPostViewSize);
-
-    int rawHeapSize = mPostViewSize;
-    LOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize);
-    mRawHeap = new MemoryHeapBase(rawHeapSize);
-    if (mRawHeap->getHeapID() < 0) {
-        LOGE("ERR(%s): Raw heap creation fail", __func__);
-        mRawHeap.clear();
-    }
-
-    initDefaultParameters(cameraId);
-
-    mExitAutoFocusThread = false;
-    mExitPreviewThread = false;
-    /* whether the PreviewThread is active in preview or stopped.  we
-     * create the thread but it is initially in stopped state.
-     */
-    mPreviewRunning = false;
-    mPreviewThread = new PreviewThread(this);
-    mAutoFocusThread = new AutoFocusThread(this);
-    mPictureThread = new PictureThread(this);
-}
-
-void CameraHardwareSec::initDefaultParameters(int cameraId)
-{
-    if (mSecCamera == NULL) {
-        LOGE("ERR(%s):mSecCamera object is NULL", __func__);
-        return;
-    }
-
-    CameraParameters p;
-    CameraParameters ip;
-
-    mCameraSensorName = mSecCamera->getCameraSensorName();
-    LOGV("CameraSensorName: %s", mCameraSensorName);
-
-    int preview_max_width   = 0;
-    int preview_max_height  = 0;
-    int snapshot_max_width  = 0;
-    int snapshot_max_height = 0;
-
-    if (cameraId == SecCamera::CAMERA_ID_BACK) {
-        p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
-              "720x480,640x480,320x240,176x144");
-        p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
-              "2560x1920,2048x1536,1600x1200,1600x960,640x480");
-    } else {
-        p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
-              "640x480,320x240,176x144");
-        p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
-              "640x480");
-    }
-
-    // If these fail, then we are using an invalid cameraId and we'll leave the
-    // sizes at zero to catch the error.
-    if (mSecCamera->getPreviewMaxSize(&preview_max_width,
-                                      &preview_max_height) < 0)
-        LOGE("getPreviewMaxSize fail (%d / %d) \n",
-             preview_max_width, preview_max_height);
-    if (mSecCamera->getSnapshotMaxSize(&snapshot_max_width,
-                                       &snapshot_max_height) < 0)
-        LOGE("getSnapshotMaxSize fail (%d / %d) \n",
-             snapshot_max_width, snapshot_max_height);
-
-    p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP);
-    p.setPreviewSize(preview_max_width, preview_max_height);
-
-    p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
-    p.setPictureSize(snapshot_max_width, snapshot_max_height);
-    p.set(CameraParameters::KEY_JPEG_QUALITY, "100"); // maximum quality
-
-    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
-          CameraParameters::PIXEL_FORMAT_YUV420SP);
-    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
-          CameraParameters::PIXEL_FORMAT_JPEG);
-    p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
-          CameraParameters::PIXEL_FORMAT_YUV420SP);
-
-    String8 parameterString;
-
-    if (cameraId == SecCamera::CAMERA_ID_BACK) {
-        parameterString = CameraParameters::FOCUS_MODE_AUTO;
-        parameterString.append(",");
-        parameterString.append(CameraParameters::FOCUS_MODE_INFINITY);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::FOCUS_MODE_MACRO);
-        p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
-              parameterString.string());
-        p.set(CameraParameters::KEY_FOCUS_MODE,
-              CameraParameters::FOCUS_MODE_AUTO);
-        p.set(CameraParameters::KEY_FOCUS_DISTANCES,
-              BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
-        p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
-              "320x240,0x0");
-        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "320");
-        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "240");
-        p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "30");
-        p.setPreviewFrameRate(30);
-    } else {
-        parameterString = CameraParameters::FOCUS_MODE_FIXED;
-        p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
-              parameterString.string());
-        p.set(CameraParameters::KEY_FOCUS_MODE,
-              CameraParameters::FOCUS_MODE_FIXED);
-        p.set(CameraParameters::KEY_FOCUS_DISTANCES,
-              FRONT_CAMERA_FOCUS_DISTANCES_STR);
-        p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
-              "160x120,0x0");
-        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160");
-        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120");
-        p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "15");
-        p.setPreviewFrameRate(15);
-    }
-
-    parameterString = CameraParameters::EFFECT_NONE;
-    parameterString.append(",");
-    parameterString.append(CameraParameters::EFFECT_MONO);
-    parameterString.append(",");
-    parameterString.append(CameraParameters::EFFECT_NEGATIVE);
-    parameterString.append(",");
-    parameterString.append(CameraParameters::EFFECT_SEPIA);
-    p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, parameterString.string());
-
-    if (cameraId == SecCamera::CAMERA_ID_BACK) {
-        parameterString = CameraParameters::FLASH_MODE_ON;
-        parameterString.append(",");
-        parameterString.append(CameraParameters::FLASH_MODE_OFF);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::FLASH_MODE_AUTO);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::FLASH_MODE_TORCH);
-        p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
-              parameterString.string());
-        p.set(CameraParameters::KEY_FLASH_MODE,
-              CameraParameters::FLASH_MODE_OFF);
-
-        parameterString = CameraParameters::SCENE_MODE_AUTO;
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_PORTRAIT);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_LANDSCAPE);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_NIGHT);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_BEACH);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_SNOW);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_SUNSET);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_FIREWORKS);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_SPORTS);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_PARTY);
-        parameterString.append(",");
-        parameterString.append(CameraParameters::SCENE_MODE_CANDLELIGHT);
-        p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
-              parameterString.string());
-        p.set(CameraParameters::KEY_SCENE_MODE,
-              CameraParameters::SCENE_MODE_AUTO);
-
-        /* we have two ranges, 4-30fps for night mode and
-         * 15-30fps for all others
-         */
-        p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
-        p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000");
-
-        p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.43");
-    } else {
-        p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(7500,30000)");
-        p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "7500,30000");
-
-        p.set(CameraParameters::KEY_FOCAL_LENGTH, "0.9");
-    }
-
-    parameterString = CameraParameters::WHITE_BALANCE_AUTO;
-    parameterString.append(",");
-    parameterString.append(CameraParameters::WHITE_BALANCE_INCANDESCENT);
-    parameterString.append(",");
-    parameterString.append(CameraParameters::WHITE_BALANCE_FLUORESCENT);
-    parameterString.append(",");
-    parameterString.append(CameraParameters::WHITE_BALANCE_DAYLIGHT);
-    parameterString.append(",");
-    parameterString.append(CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT);
-    p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
-          parameterString.string());
-
-    ip.set("sharpness-min", 0);
-    ip.set("sharpness-max", 4);
-    ip.set("saturation-min", 0);
-    ip.set("saturation-max", 4);
-    ip.set("contrast-min", 0);
-    ip.set("contrast-max", 4);
-
-    p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100");
-
-    p.set(CameraParameters::KEY_ROTATION, 0);
-    p.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO);
-
-    p.set(CameraParameters::KEY_EFFECT, CameraParameters::EFFECT_NONE);
-
-    ip.set("sharpness", SHARPNESS_DEFAULT);
-    ip.set("contrast", CONTRAST_DEFAULT);
-    ip.set("saturation", SATURATION_DEFAULT);
-    ip.set("iso", "auto");
-    ip.set("metering", "center");
-
-    ip.set("wdr", 0);
-    ip.set("chk_dataline", 0);
-    if (cameraId == SecCamera::CAMERA_ID_FRONT) {
-        ip.set("vtmode", 0);
-        ip.set("blur", 0);
-    }
-
-    p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "51.2");
-    p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "39.4");
-
-    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0");
-    p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "4");
-    p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-4");
-    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5");
-
-    mParameters = p;
-    mInternalParameters = ip;
-
-    /* make sure mSecCamera has all the settings we do.  applications
-     * aren't required to call setParameters themselves (only if they
-     * want to change something.
-     */
-    setParameters(p);
-    mSecCamera->setISO(ISO_AUTO);
-    mSecCamera->setMetering(METERING_CENTER);
-    mSecCamera->setContrast(CONTRAST_DEFAULT);
-    mSecCamera->setSharpness(SHARPNESS_DEFAULT);
-    mSecCamera->setSaturation(SATURATION_DEFAULT);
-    if (cameraId == SecCamera::CAMERA_ID_BACK)
-        mSecCamera->setFrameRate(30);
-    else
-        mSecCamera->setFrameRate(15);
-}
-
-CameraHardwareSec::~CameraHardwareSec()
-{
-    LOGV("%s :", __func__);
-
-    singleton.clear();
-}
-
-sp<IMemoryHeap> CameraHardwareSec::getPreviewHeap() const
-{
-    return mPreviewHeap;
-}
-
-sp<IMemoryHeap> CameraHardwareSec::getRawHeap() const
-{
-    return mRawHeap;
-}
-
-void CameraHardwareSec::setCallbacks(notify_callback notify_cb,
-                                      data_callback data_cb,
-                                      data_callback_timestamp data_cb_timestamp,
-                                      void *user)
-{
-    mNotifyCb = notify_cb;
-    mDataCb = data_cb;
-    mDataCbTimestamp = data_cb_timestamp;
-    mCallbackCookie = user;
-}
-
-void CameraHardwareSec::enableMsgType(int32_t msgType)
-{
-    LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
-         __func__, msgType, mMsgEnabled);
-    mMsgEnabled |= msgType;
-    LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
-}
-
-void CameraHardwareSec::disableMsgType(int32_t msgType)
-{
-    LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
-         __func__, msgType, mMsgEnabled);
-    mMsgEnabled &= ~msgType;
-    LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
-}
-
-bool CameraHardwareSec::msgTypeEnabled(int32_t msgType)
-{
-    return (mMsgEnabled & msgType);
-}
-
-// ---------------------------------------------------------------------------
-void CameraHardwareSec::setSkipFrame(int frame)
-{
-    Mutex::Autolock lock(mSkipFrameLock);
-    if (frame < mSkipFrame)
-        return;
-
-    mSkipFrame = frame;
-}
-
-int CameraHardwareSec::previewThreadWrapper()
-{
-    LOGI("%s: starting", __func__);
-    while (1) {
-        mPreviewLock.lock();
-        while (!mPreviewRunning) {
-            LOGI("%s: calling mSecCamera->stopPreview() and waiting", __func__);
-            mSecCamera->stopPreview();
-            /* signal that we're stopping */
-            mPreviewStoppedCondition.signal();
-            mPreviewCondition.wait(mPreviewLock);
-            LOGI("%s: return from wait", __func__);
-        }
-        mPreviewLock.unlock();
-
-        if (mExitPreviewThread) {
-            LOGI("%s: exiting", __func__);
-            mSecCamera->stopPreview();
-            return 0;
-        }
-        previewThread();
-    }
-}
-
-int CameraHardwareSec::previewThread()
-{
-    int index;
-    nsecs_t timestamp;
-    unsigned int phyYAddr;
-    unsigned int phyCAddr;
-    struct addrs *addrs;
-
-    index = mSecCamera->getPreview();
-    if (index < 0) {
-        LOGE("ERR(%s):Fail on SecCamera->getPreview()", __func__);
-        return UNKNOWN_ERROR;
-    }
-    mSkipFrameLock.lock();
-    if (mSkipFrame > 0) {
-        mSkipFrame--;
-        mSkipFrameLock.unlock();
-        return NO_ERROR;
-    }
-    mSkipFrameLock.unlock();
-
-    timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
-
-    phyYAddr = mSecCamera->getPhyAddrY(index);
-    phyCAddr = mSecCamera->getPhyAddrC(index);
-
-    if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) {
-        LOGE("ERR(%s):Fail on SecCamera getPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr);
-        return UNKNOWN_ERROR;
-     }
-
-    int width, height, frame_size, offset;
-
-    mSecCamera->getPreviewSize(&width, &height, &frame_size);
-
-    offset = (frame_size + 16) * index;
-    sp<MemoryBase> buffer = new MemoryBase(mPreviewHeap, offset, frame_size);
-
-    memcpy(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size    ), &phyYAddr, 4);
-    memcpy(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size + 4), &phyCAddr, 4);
-
-#if defined(BOARD_USES_OVERLAY)
-    if (mUseOverlay) {
-        int ret;
-        overlay_buffer_t overlay_buffer;
-
-        mOverlayBufferIdx ^= 1;
-        memcpy(static_cast<unsigned char*>(mPreviewHeap->base()) + offset + frame_size + sizeof(phyYAddr) + sizeof(phyCAddr),
-                &mOverlayBufferIdx, sizeof(mOverlayBufferIdx));
-
-        ret = mOverlay->queueBuffer((void*)(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size)));
-
-        if (ret == -1 ) {
-            LOGE("ERR(%s):overlay queueBuffer fail", __func__);
-        } else if (ret != ALL_BUFFERS_FLUSHED) {
-            ret = mOverlay->dequeueBuffer(&overlay_buffer);
-            if (ret == -1) {
-                LOGE("ERR(%s):overlay dequeueBuffer fail", __func__);
-            }
-         }
-     }
-#endif
-
-    // Notify the client of a new frame.
-    if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
-        mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);
-    }
-
-    Mutex::Autolock lock(mRecordLock);
-    if (mRecordRunning == true) {
-        index = mSecCamera->getRecordFrame();
-        if (index < 0) {
-            LOGE("ERR(%s):Fail on SecCamera->getRecord()", __func__);
-            return UNKNOWN_ERROR;
-        }
-
-        phyYAddr = mSecCamera->getRecPhyAddrY(index);
-        phyCAddr = mSecCamera->getRecPhyAddrC(index);
-
-        if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) {
-            LOGE("ERR(%s):Fail on SecCamera getRectPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr);
-            return UNKNOWN_ERROR;
-        }
-
-        addrs = (struct addrs *)mRecordHeap->base();
-
-        sp<MemoryBase> buffer = new MemoryBase(mRecordHeap, index * sizeof(struct addrs), sizeof(struct addrs));
-        addrs[index].addr_y = phyYAddr;
-        addrs[index].addr_cbcr = phyCAddr;
-        addrs[index].buf_index = index;
-
-        // Notify the client of a new frame.
-        if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) {
-            mDataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, buffer, mCallbackCookie);
-        } else {
-            mSecCamera->releaseRecordFrame(index);
-        }
-    }
-
-    return NO_ERROR;
-}
-
-status_t CameraHardwareSec::startPreview()
-{
-    int ret = 0;        //s1 [Apply factory standard]
-
-    LOGV("%s :", __func__);
-
-    Mutex::Autolock lock(mStateLock);
-    if (mCaptureInProgress) {
-        LOGE("%s : capture in progress, not allowed", __func__);
-        return INVALID_OPERATION;
-    }
-
-    mPreviewLock.lock();
-    if (mPreviewRunning) {
-        // already running
-        LOGE("%s : preview thread already running", __func__);
-        mPreviewLock.unlock();
-        return INVALID_OPERATION;
-    }
-
-    setSkipFrame(INITIAL_SKIP_FRAME);
-
-    ret  = mSecCamera->startPreview();
-    LOGV("%s : mSecCamera->startPreview() returned %d", __func__, ret);
-
-    if (ret < 0) {
-        LOGE("ERR(%s):Fail on mSecCamera->startPreview()", __func__);
-        return -1; //UNKNOWN_ERROR;
-    }
-
-    if (mPreviewHeap != NULL)
-        mPreviewHeap.clear();
-
-    int width, height, frame_size;
-
-    mSecCamera->getPreviewSize(&width, &height, &frame_size);
-
-    int previewHeapSize = (frame_size + 16) * kBufferCount;
-
-    LOGD("MemoryHeapBase(fd(%d), size(%d), width(%d), height(%d))", (int)mSecCamera->getCameraFd(), (size_t)(previewHeapSize), width, height);
-    mPreviewHeap = new MemoryHeapBase((int)mSecCamera->getCameraFd(), (size_t)(previewHeapSize), (uint32_t)0);
-
-    mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
-    LOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",mPostViewWidth,mPostViewHeight,mPostViewSize);
-
-    mPreviewRunning = true;
-    mPreviewCondition.signal();
-    mPreviewLock.unlock();
-
-    return NO_ERROR;
-}
-
-#if defined(BOARD_USES_OVERLAY)
-bool CameraHardwareSec::useOverlay()
-{
-    LOGV("%s: returning true", __func__);
-    return true;
-}
-
-status_t CameraHardwareSec::setOverlay(const sp<Overlay> &overlay)
-{
-    LOGV("%s :", __func__);
-
-    int overlayWidth  = 0;
-    int overlayHeight = 0;
-    int overlayFrameSize = 0;
-
-    if (overlay == NULL) {
-        LOGV("%s : overlay == NULL", __func__);
-        goto setOverlayFail;
-    }
-    LOGV("%s : overlay = %p", __func__, overlay->getHandleRef());
-
-    if (overlay->getHandleRef()== NULL && mUseOverlay == true) {
-        if (mOverlay != 0)
-            mOverlay->destroy();
-
-        mOverlay = NULL;
-        mUseOverlay = false;
-
-        return NO_ERROR;
-    }
-
-    if (overlay->getStatus() != NO_ERROR) {
-        LOGE("ERR(%s):overlay->getStatus() fail", __func__);
-        goto setOverlayFail;
-    }
-
-    mSecCamera->getPreviewSize(&overlayWidth, &overlayHeight, &overlayFrameSize);
-
-    if (overlay->setCrop(0, 0, overlayWidth, overlayHeight) != NO_ERROR) {
-        LOGE("ERR(%s)::(mOverlay->setCrop(0, 0, %d, %d) fail", __func__, overlayWidth, overlayHeight);
-        goto setOverlayFail;
-    }
-
-    mOverlay = overlay;
-    mUseOverlay = true;
-
-    return NO_ERROR;
-
-setOverlayFail :
-    if (mOverlay != 0)
-        mOverlay->destroy();
-    mOverlay = 0;
-
-    mUseOverlay = false;
-
-    return UNKNOWN_ERROR;
-}
-#endif
-
-void CameraHardwareSec::stopPreview()
-{
-    LOGV("%s :", __func__);
-
-    /* request that the preview thread stop. */
-    mPreviewLock.lock();
-    if (mPreviewRunning) {
-        mPreviewRunning = false;
-        mPreviewCondition.signal();
-        /* wait until preview thread is stopped */
-        mPreviewStoppedCondition.wait(mPreviewLock);
-    } else {
-        LOGI("%s : preview not running, doing nothing", __func__);
-    }
-    mPreviewLock.unlock();
-}
-
-bool CameraHardwareSec::previewEnabled()
-{
-    Mutex::Autolock lock(mPreviewLock);
-    LOGV("%s : %d", __func__, mPreviewRunning);
-    return mPreviewRunning;
-}
-
-// ---------------------------------------------------------------------------
-
-status_t CameraHardwareSec::startRecording()
-{
-    LOGV("%s :", __func__);
-
-    Mutex::Autolock lock(mRecordLock);
-
-    if (mRecordRunning == false) {
-        if (mSecCamera->startRecord() < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__);
-            return UNKNOWN_ERROR;
-        }
-        mRecordRunning = true;
-    }
-    return NO_ERROR;
-}
-
-void CameraHardwareSec::stopRecording()
-{
-    LOGV("%s :", __func__);
-
-    Mutex::Autolock lock(mRecordLock);
-
-    if (mRecordRunning == true) {
-        if (mSecCamera->stopRecord() < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__);
-            return;
-        }
-        mRecordRunning = false;
-    }
-}
-
-bool CameraHardwareSec::recordingEnabled()
-{
-    LOGV("%s :", __func__);
-
-    return mRecordRunning;
-}
-
-void CameraHardwareSec::releaseRecordingFrame(const sp<IMemory>& mem)
-{
-    ssize_t offset;
-    sp<IMemoryHeap> heap = mem->getMemory(&offset, NULL);
-    struct addrs *addrs = (struct addrs *)((uint8_t *)heap->base() + offset);
-
-    mSecCamera->releaseRecordFrame(addrs->buf_index);
-}
-
-// ---------------------------------------------------------------------------
-
-int CameraHardwareSec::autoFocusThread()
-{
-    int count =0;
-    int af_status =0 ;
-
-    LOGV("%s : starting", __func__);
-
-    /* block until we're told to start.  we don't want to use
-     * a restartable thread and requestExitAndWait() in cancelAutoFocus()
-     * because it would cause deadlock between our callbacks and the
-     * caller of cancelAutoFocus() which both want to grab the same lock
-     * in CameraServices layer.
-     */
-    mFocusLock.lock();
-    /* check early exit request */
-    if (mExitAutoFocusThread) {
-        mFocusLock.unlock();
-        LOGV("%s : exiting on request0", __func__);
-        return NO_ERROR;
-    }
-    mFocusCondition.wait(mFocusLock);
-    /* check early exit request */
-    if (mExitAutoFocusThread) {
-        mFocusLock.unlock();
-        LOGV("%s : exiting on request1", __func__);
-        return NO_ERROR;
-    }
-    mFocusLock.unlock();
-
-    LOGV("%s : calling setAutoFocus", __func__);
-    if (mSecCamera->setAutofocus() < 0) {
-        LOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__);
-        return UNKNOWN_ERROR;
-    }
-
-    af_status = mSecCamera->getAutoFocusResult();
-    
-    int i;
-    
-    i = 0;   
-    
-    af_status = mSecCamera->getAutoFocusResult();
-    
-    while(af_status == 0x05 && i < 100)
-    {
-        LOGV("%s : AF Result == 0X05 sleeping!!", __func__);
-        usleep(50000);
-        af_status = mSecCamera->getAutoFocusResult();
-        i++;        
-    }
-    
-    LOGV("%s : AF Result == %d", __func__, af_status);
-
-    if (af_status == 0x02) {
-        LOGV("%s : AF Success!!", __func__);
-        if (mMsgEnabled & CAMERA_MSG_FOCUS)
-            mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
-    }
-//FIXME: determine that the user cancled the AF  
-#if 0
-     else if (af_status == 0x02) {
-        LOGV("%s : AF Cancelled !!", __func__);
-        if (mMsgEnabled & CAMERA_MSG_FOCUS) {
-            /* CAMERA_MSG_FOCUS only takes a bool.  true for
-             * finished and false for failure.  cancel is still
-             * considered a true result.
-             */
-            mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
-        }
-    }
-#endif
-     else {
-        LOGV("%s : AF Fail !!", __func__);
-        LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
-        if (mMsgEnabled & CAMERA_MSG_FOCUS)
-            mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
-    }
-
-    LOGV("%s : exiting with no error", __func__);
-    return NO_ERROR;
-}
-
-status_t CameraHardwareSec::autoFocus()
-{
-    LOGV("%s :", __func__);
-    /* signal autoFocusThread to run once */
-    mFocusCondition.signal();
-    return NO_ERROR;
-}
-
-/* 2009.10.14 by icarus for added interface */
-status_t CameraHardwareSec::cancelAutoFocus()
-{
-    LOGV("%s :", __func__);
-
-    if (mSecCamera->cancelAutofocus() < 0) {
-        LOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__);
-        return UNKNOWN_ERROR;
-    }
-
-    return NO_ERROR;
-}
-
-int CameraHardwareSec::save_jpeg( unsigned char *real_jpeg, int jpeg_size)
-{
-    FILE *yuv_fp = NULL;
-    char filename[100], *buffer = NULL;
-
-    /* file create/open, note to "wb" */
-    yuv_fp = fopen("/data/camera_dump.jpeg", "wb");
-    if (yuv_fp == NULL) {
-        LOGE("Save jpeg file open error");
-        return -1;
-    }
-
-    LOGV("[BestIQ]  real_jpeg size ========>  %d\n", jpeg_size);
-    buffer = (char *) malloc(jpeg_size);
-    if (buffer == NULL) {
-        LOGE("Save YUV] buffer alloc failed");
-        if (yuv_fp)
-            fclose(yuv_fp);
-
-        return -1;
-    }
-
-    memcpy(buffer, real_jpeg, jpeg_size);
-
-    fflush(stdout);
-
-    fwrite(buffer, 1, jpeg_size, yuv_fp);
-
-    fflush(yuv_fp);
-
-    if (yuv_fp)
-            fclose(yuv_fp);
-    if (buffer)
-            free(buffer);
-
-    return 0;
-}
-
-void CameraHardwareSec::save_postview(const char *fname, uint8_t *buf, uint32_t size)
-{
-    int nw;
-    int cnt = 0;
-    uint32_t written = 0;
-
-    LOGD("opening file [%s]\n", fname);
-    int fd = open(fname, O_RDWR | O_CREAT);
-    if (fd < 0) {
-        LOGE("failed to create file [%s]: %s", fname, strerror(errno));
-    return;
-    }
-
-    LOGD("writing %d bytes to file [%s]\n", size, fname);
-    while (written < size) {
-        nw = ::write(fd, buf + written, size - written);
-        if (nw < 0) {
-            LOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno));
-            break;
-        }
-        written += nw;
-        cnt++;
-    }
-    LOGD("done writing %d bytes to file [%s] in %d passes\n",size, fname, cnt);
-    ::close(fd);
-}
-
-bool CameraHardwareSec::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHeight,
-                                        char *dstBuf, uint32_t dstWidth, uint32_t dstHeight)
-{
-    int32_t step_x, step_y;
-    int32_t iXsrc, iXdst;
-    int32_t x, y, src_y_start_pos, dst_pos, src_pos;
-
-    if (dstWidth % 2 != 0 || dstHeight % 2 != 0){
-        LOGE("scale_down_yuv422: invalid width, height for scaling");
-        return false;
-    }
-
-    step_x = srcWidth / dstWidth;
-    step_y = srcHeight / dstHeight;
-
-    dst_pos = 0;
-    for (uint32_t y = 0; y < dstHeight; y++) {
-        src_y_start_pos = (y * step_y * (srcWidth * 2));
-
-        for (uint32_t x = 0; x < dstWidth; x += 2) {
-            src_pos = src_y_start_pos + (x * (step_x * 2));
-
-            dstBuf[dst_pos++] = srcBuf[src_pos    ];
-            dstBuf[dst_pos++] = srcBuf[src_pos + 1];
-            dstBuf[dst_pos++] = srcBuf[src_pos + 2];
-            dstBuf[dst_pos++] = srcBuf[src_pos + 3];
-        }
-    }
-
-    return true;
-}
-
-bool CameraHardwareSec::YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight)
-{
-    int32_t        x, y, src_y_start_pos, dst_cbcr_pos, dst_pos, src_pos;
-    unsigned char *srcBufPointer = (unsigned char *)srcBuf;
-    unsigned char *dstBufPointer = (unsigned char *)dstBuf;
-
-    dst_pos = 0;
-    dst_cbcr_pos = srcWidth*srcHeight;
-    for (uint32_t y = 0; y < srcHeight; y++) {
-        src_y_start_pos = (y * (srcWidth * 2));
-
-        for (uint32_t x = 0; x < (srcWidth * 2); x += 2) {
-            src_pos = src_y_start_pos + x;
-
-            dstBufPointer[dst_pos++] = srcBufPointer[src_pos];
-        }
-    }
-    for (uint32_t y = 0; y < srcHeight; y += 2) {
-        src_y_start_pos = (y * (srcWidth * 2));
-
-        for (uint32_t x = 0; x < (srcWidth * 2); x += 4) {
-            src_pos = src_y_start_pos + x;
-
-            dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 3];
-            dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 1];
-        }
-    }
-
-    return true;
-}
-
-int CameraHardwareSec::pictureThread()
-{
-   LOGV("%s :", __func__);
-
-    int jpeg_size = 0;
-    int ret = NO_ERROR;
-    unsigned char *jpeg_data = NULL;
-    int postview_offset = 0;
-    unsigned char *postview_data = NULL;
-
-    unsigned char *addr = NULL;
-    int mPostViewWidth, mPostViewHeight, mPostViewSize;
-    int mThumbWidth, mThumbHeight, mThumbSize;
-    int cap_width, cap_height, cap_frame_size;
-
-    unsigned int output_size = 0;
-
-    mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
-    mSecCamera->getThumbnailConfig(&mThumbWidth, &mThumbHeight, &mThumbSize);
-    int postviewHeapSize = mPostViewSize;
-    mSecCamera->getSnapshotSize(&cap_width, &cap_height, &cap_frame_size);
-    int mJpegHeapSize;
-    if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK)
-        mJpegHeapSize = cap_frame_size * SecCamera::getJpegRatio();
-    else
-        mJpegHeapSize = cap_frame_size;
-
-    LOG_TIME_DEFINE(0)
-    LOG_TIME_START(0)
-    
-    sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, mPostViewSize + 8);
-
-    struct addrs_cap *addrs = (struct addrs_cap *)mRawHeap->base();
-
-    addrs[0].width = mPostViewWidth;
-    addrs[0].height = mPostViewHeight;
-    LOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight);
-
-    sp<MemoryHeapBase> JpegHeap = new MemoryHeapBase(mJpegHeapSize);
-    sp<MemoryHeapBase> PostviewHeap = new MemoryHeapBase(mPostViewSize);
-    sp<MemoryHeapBase> ThumbnailHeap = new MemoryHeapBase(mThumbSize);
-
-    if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
-        LOG_TIME_DEFINE(1)
-        LOG_TIME_START(1)
-
-        int picture_size, picture_width, picture_height;
-        mSecCamera->getSnapshotSize(&picture_width, &picture_height, &picture_size);
-        int picture_format = mSecCamera->getSnapshotPixelFormat();
-
-        unsigned int phyAddr;
-
-        // Modified the shutter sound timing for Jpeg capture
-        if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK)
-            mSecCamera->setSnapshotCmd();
-        if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
-            mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
-        }
-
-        if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){
-            jpeg_data = mSecCamera->getJpeg(&jpeg_size, &phyAddr);
-            if (jpeg_data == NULL) {
-                LOGE("ERR(%s):Fail on SecCamera->getSnapshot()", __func__);
-                ret = UNKNOWN_ERROR;
-            }
-        } else {
-            if (mSecCamera->getSnapshotAndJpeg((unsigned char*)PostviewHeap->base(),
-                    (unsigned char*)JpegHeap->base(), &output_size) < 0) {
-                mStateLock.lock();
-                mCaptureInProgress = false;
-                mStateLock.unlock();
-                return UNKNOWN_ERROR;
-            }
-            LOGI("snapshotandjpeg done\n");
-        }
-
-        addrs[0].addr_y = phyAddr;
-
-        LOG_TIME_END(1)
-        LOG_CAMERA("getSnapshotAndJpeg interval: %lu us", LOG_TIME(1));
-    }
-
-    /* the capture is done at this point so we can allow sensor commands
-     * again, we still need to do jpeg and thumbnail processing, but the
-     * sensor is available for something else
-     */
-    mStateLock.lock();
-    mCaptureInProgress = false;
-    mStateLock.unlock();
-
-    if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
-        mDataCb(CAMERA_MSG_RAW_IMAGE, buffer, mCallbackCookie);
-    }
-
-    if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
-        
-        memcpy(JpegHeap->base (), jpeg_data, jpeg_size + 2);
-        
-        int JpegExifSize;
-        sp<MemoryHeapBase> ExifHeap = new MemoryHeapBase(EXIF_FILE_SIZE + JPG_STREAM_BUF_SIZE);
-        JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->base(),
-                 (unsigned char *)ThumbnailHeap->base());
- 
-         LOGV("JpegExifSize=%d", JpegExifSize);
- 
-         if (JpegExifSize < 0) {
-             ret = UNKNOWN_ERROR;
-             goto out;
-         }
-        
-        unsigned char *ExifStart = (unsigned char *)JpegHeap->base() + 2;
-        unsigned char *ImageStart = ExifStart + JpegExifSize;
-        memmove(ImageStart, ExifStart, jpeg_size - 2);
-        memcpy(ExifStart, ExifHeap->base(), JpegExifSize);
-        
-        sp<MemoryBase> mem = new MemoryBase(JpegHeap, 0, jpeg_size + JpegExifSize);                    
-
-        mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);
-    }
-
-    LOG_TIME_END(0)
-    LOG_CAMERA("pictureThread interval: %lu us", LOG_TIME(0));
-out:
-    LOGV("%s : pictureThread end", __func__);
-    return ret;
-}
-
-status_t CameraHardwareSec::takePicture()
-{
-    LOGV("%s :", __func__);
-
-    stopPreview();
-
-    Mutex::Autolock lock(mStateLock);
-    if (mCaptureInProgress) {
-        LOGE("%s : capture already in progress", __func__);
-        return INVALID_OPERATION;
-    }
-
-    if (mPictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
-        LOGE("%s : couldn't run picture thread", __func__);
-        return INVALID_OPERATION;
-    }
-    mCaptureInProgress = true;
-
-    return NO_ERROR;
-}
-
-status_t CameraHardwareSec::cancelPicture()
-{
-    mPictureThread->requestExitAndWait();
-
-    return NO_ERROR;
-}
-
-bool CameraHardwareSec::CheckVideoStartMarker(unsigned char *pBuf)
-{
-    if (!pBuf) {
-        LOGE("CheckVideoStartMarker() => pBuf is NULL\n");
-        return false;
-    }
-
-    if (HIBYTE(VIDEO_COMMENT_MARKER_H) == * pBuf      && LOBYTE(VIDEO_COMMENT_MARKER_H) == *(pBuf + 1) &&
-        HIBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 2) && LOBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 3))
-        return true;
-
-    return false;
-}
-
-bool CameraHardwareSec::CheckEOIMarker(unsigned char *pBuf)
-{
-    if (!pBuf) {
-        LOGE("CheckEOIMarker() => pBuf is NULL\n");
-        return false;
-    }
-
-    // EOI marker [FF D9]
-    if (HIBYTE(JPEG_EOI_MARKER) == *pBuf && LOBYTE(JPEG_EOI_MARKER) == *(pBuf + 1))
-        return true;
-
-    return false;
-}
-
-bool CameraHardwareSec::FindEOIMarkerInJPEG(unsigned char *pBuf, int dwBufSize, int *pnJPEGsize)
-{
-    if (NULL == pBuf || 0 >= dwBufSize) {
-        LOGE("FindEOIMarkerInJPEG() => There is no contents.");
-        return false;
-    }
-
-    unsigned char *pBufEnd = pBuf + dwBufSize;
-
-    while (pBuf < pBufEnd) {
-        if (CheckEOIMarker(pBuf++))
-            return true;
-
-        (*pnJPEGsize)++;
-    }
-
-    return false;
-}
-
-bool CameraHardwareSec::SplitFrame(unsigned char *pFrame, int dwSize,
-                    int dwJPEGLineLength, int dwVideoLineLength, int dwVideoHeight,
-                    void *pJPEG, int *pdwJPEGSize,
-                    void *pVideo, int *pdwVideoSize)
-{
-    LOGV("===========SplitFrame Start==============");
-
-    if (NULL == pFrame || 0 >= dwSize) {
-        LOGE("There is no contents.\r\n");
-        return false;
-    }
-
-    if (0 == dwJPEGLineLength || 0 == dwVideoLineLength) {
-        LOGE("There in no input information for decoding interleaved jpeg");
-        return false;
-    }
-
-    unsigned char *pSrc = pFrame;
-    unsigned char *pSrcEnd = pFrame + dwSize;
-
-    unsigned char *pJ = (unsigned char *)pJPEG;
-    int dwJSize = 0;
-    unsigned char *pV = (unsigned char *)pVideo;
-    int dwVSize = 0;
-
-    bool bRet = false;
-    bool isFinishJpeg = false;
-
-    while (pSrc < pSrcEnd) {
-        // Check video start marker
-        if (CheckVideoStartMarker(pSrc)) {
-            int copyLength;
-
-            if (pSrc + dwVideoLineLength <= pSrcEnd)
-                copyLength = dwVideoLineLength;
-            else
-                copyLength = pSrcEnd - pSrc - VIDEO_COMMENT_MARKER_LENGTH;
-
-            // Copy video data
-            if (pV) {
-                memcpy(pV, pSrc + VIDEO_COMMENT_MARKER_LENGTH, copyLength);
-                pV += copyLength;
-                dwVSize += copyLength;
-            }
-
-            pSrc += copyLength + VIDEO_COMMENT_MARKER_LENGTH;
-        } else {
-            // Copy pure JPEG data
-            int size = 0;
-            int dwCopyBufLen = dwJPEGLineLength <= pSrcEnd-pSrc ? dwJPEGLineLength : pSrcEnd - pSrc;
-
-            if (FindEOIMarkerInJPEG((unsigned char *)pSrc, dwCopyBufLen, &size)) {
-                isFinishJpeg = true;
-                size += 2;  // to count EOF marker size
-            } else {
-                if ((dwCopyBufLen == 1) && (pJPEG < pJ)) {
-                    unsigned char checkBuf[2] = { *(pJ - 1), *pSrc };
-
-                    if (CheckEOIMarker(checkBuf))
-                        isFinishJpeg = true;
-                }
-                size = dwCopyBufLen;
-            }
-
-            memcpy(pJ, pSrc, size);
-
-            dwJSize += size;
-
-            pJ += dwCopyBufLen;
-            pSrc += dwCopyBufLen;
-        }
-        if (isFinishJpeg)
-            break;
-    }
-
-    if (isFinishJpeg) {
-        bRet = true;
-        if(pdwJPEGSize)
-            *pdwJPEGSize = dwJSize;
-        if(pdwVideoSize)
-            *pdwVideoSize = dwVSize;
-    } else {
-        LOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI");
-        bRet = false;
-        if(pdwJPEGSize)
-            *pdwJPEGSize = 0;
-        if(pdwVideoSize)
-            *pdwVideoSize = 0;
-    }
-    LOGV("===========SplitFrame end==============");
-
-    return bRet;
-}
-
-int CameraHardwareSec::decodeInterleaveData(unsigned char *pInterleaveData,
-                                                 int interleaveDataSize,
-                                                 int yuvWidth,
-                                                 int yuvHeight,
-                                                 int *pJpegSize,
-                                                 void *pJpegData,
-                                                 void *pYuvData)
-{
-    if (pInterleaveData == NULL)
-        return false;
-
-    bool ret = true;
-    unsigned int *interleave_ptr = (unsigned int *)pInterleaveData;
-    unsigned char *jpeg_ptr = (unsigned char *)pJpegData;
-    unsigned char *yuv_ptr = (unsigned char *)pYuvData;
-    unsigned char *p;
-    int jpeg_size = 0;
-    int yuv_size = 0;
-
-    int i = 0;
-
-    LOGV("decodeInterleaveData Start~~~");
-    while (i < interleaveDataSize) {
-        if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) ||
-                (*interleave_ptr == 0xFF02FFFF)) {
-            // Padding Data
-//            LOGE("%d(%x) padding data\n", i, *interleave_ptr);
-            interleave_ptr++;
-            i += 4;
-        }
-        else if ((*interleave_ptr & 0xFFFF) == 0x05FF) {
-            // Start-code of YUV Data
-//            LOGE("%d(%x) yuv data\n", i, *interleave_ptr);
-            p = (unsigned char *)interleave_ptr;
-            p += 2;
-            i += 2;
-
-            // Extract YUV Data
-            if (pYuvData != NULL) {
-                memcpy(yuv_ptr, p, yuvWidth * 2);
-                yuv_ptr += yuvWidth * 2;
-                yuv_size += yuvWidth * 2;
-            }
-            p += yuvWidth * 2;
-            i += yuvWidth * 2;
-
-            // Check End-code of YUV Data
-            if ((*p == 0xFF) && (*(p + 1) == 0x06)) {
-                interleave_ptr = (unsigned int *)(p + 2);
-                i += 2;
-            } else {
-                ret = false;
-                break;
-            }
-        } else {
-            // Extract JPEG Data
-//            LOGE("%d(%x) jpg data, jpeg_size = %d bytes\n", i, *interleave_ptr, jpeg_size);
-            if (pJpegData != NULL) {
-                memcpy(jpeg_ptr, interleave_ptr, 4);
-                jpeg_ptr += 4;
-                jpeg_size += 4;
-            }
-            interleave_ptr++;
-            i += 4;
-        }
-    }
-    if (ret) {
-        if (pJpegData != NULL) {
-            // Remove Padding after EOI
-            for (i = 0; i < 3; i++) {
-                if (*(--jpeg_ptr) != 0xFF) {
-                    break;
-                }
-                jpeg_size--;
-            }
-            *pJpegSize = jpeg_size;
-
-        }
-        // Check YUV Data Size
-        if (pYuvData != NULL) {
-            if (yuv_size != (yuvWidth * yuvHeight * 2)) {
-                ret = false;
-            }
-        }
-    }
-    LOGV("decodeInterleaveData End~~~");
-    return ret;
-}
-
-status_t CameraHardwareSec::dump(int fd, const Vector<String16>& args) const
-{
-    const size_t SIZE = 256;
-    char buffer[SIZE];
-    String8 result;
-
-    if (mSecCamera != 0) {
-        mSecCamera->dump(fd, args);
-        mParameters.dump(fd, args);
-        mInternalParameters.dump(fd, args);
-        snprintf(buffer, 255, " preview running(%s)\n", mPreviewRunning?"true": "false");
-        result.append(buffer);
-    } else {
-        result.append("No camera client yet.\n");
-    }
-    write(fd, result.string(), result.size());
-    return NO_ERROR;
-}
-
-status_t CameraHardwareSec::setParameters(const CameraParameters& params)
-{
-    LOGV("%s :", __func__);
-
-    status_t ret = NO_ERROR;
-
-    /* if someone calls us while picture thread is running, it could screw
-     * up the sensor quite a bit so return error.  we can't wait because
-     * that would cause deadlock with the callbacks
-     */
-    mStateLock.lock();
-    if (mCaptureInProgress) {
-        mStateLock.unlock();
-        LOGE("%s : capture in progress, not allowed", __func__);
-        return UNKNOWN_ERROR;
-    }
-    mStateLock.unlock();
-
-    // preview size
-    int new_preview_width  = 0;
-    int new_preview_height = 0;
-    params.getPreviewSize(&new_preview_width, &new_preview_height);
-    const char *new_str_preview_format = params.getPreviewFormat();
-    LOGV("%s : new_preview_width x new_preview_height = %dx%d, format = %s",
-         __func__, new_preview_width, new_preview_height, new_str_preview_format);
-
-    if (0 < new_preview_width && 0 < new_preview_height && new_str_preview_format != NULL) {
-        int new_preview_format = 0;
-
-        if (!strcmp(new_str_preview_format,
-                    CameraParameters::PIXEL_FORMAT_RGB565))
-            new_preview_format = V4L2_PIX_FMT_RGB565;
-        else if (!strcmp(new_str_preview_format,
-                         CameraParameters::PIXEL_FORMAT_YUV420SP))
-            new_preview_format = V4L2_PIX_FMT_NV21;
-        else if (!strcmp(new_str_preview_format, "yuv420sp_custom"))
-            new_preview_format = V4L2_PIX_FMT_NV12T;
-        else if (!strcmp(new_str_preview_format, "yuv420p"))
-            new_preview_format = V4L2_PIX_FMT_YUV420;
-        else if (!strcmp(new_str_preview_format, "yuv422i"))
-            new_preview_format = V4L2_PIX_FMT_YUYV;
-        else if (!strcmp(new_str_preview_format, "yuv422p"))
-            new_preview_format = V4L2_PIX_FMT_YUV422P;
-        else
-            new_preview_format = V4L2_PIX_FMT_NV21; //for 3rd party
-
-        if (mSecCamera->setPreviewSize(new_preview_width, new_preview_height, new_preview_format) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))",
-                    __func__, new_preview_width, new_preview_height, new_preview_format);
-            ret = UNKNOWN_ERROR;
-        } else {
-                mParameters.setPreviewSize(new_preview_width, new_preview_height);
-                mParameters.setPreviewFormat(new_str_preview_format);
-        }
-#if defined(BOARD_USES_OVERLAY)
-        if (mUseOverlay == true && mOverlay != 0) {
-            if (mOverlay->setCrop(0, 0, new_preview_width, new_preview_height) != NO_ERROR)     {
-                LOGE("ERR(%s)::(mOverlay->setCrop(0, 0, %d, %d) fail",
-                        __func__, new_preview_width, new_preview_height);
-            }
-        }
-#endif
-    }
-
-    int new_picture_width  = 0;
-    int new_picture_height = 0;
-
-    params.getPictureSize(&new_picture_width, &new_picture_height);
-    LOGV("%s : new_picture_width x new_picture_height = %dx%d", __func__, new_picture_width, new_picture_height);
-    if (0 < new_picture_width && 0 < new_picture_height) {
-        if (mSecCamera->setSnapshotSize(new_picture_width, new_picture_height) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setSnapshotSize(width(%d), height(%d))",
-                    __func__, new_picture_width, new_picture_height);
-            ret = UNKNOWN_ERROR;
-        } else {
-            mParameters.setPictureSize(new_picture_width, new_picture_height);
-        }
-    }
-
-    // picture format
-    const char *new_str_picture_format = params.getPictureFormat();
-    LOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format);
-    if (new_str_picture_format != NULL) {
-        int new_picture_format = 0;
-
-        if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGB565))
-            new_picture_format = V4L2_PIX_FMT_RGB565;
-        else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_YUV420SP))
-            new_picture_format = V4L2_PIX_FMT_NV21;
-        else if (!strcmp(new_str_picture_format, "yuv420sp_custom"))
-            new_picture_format = V4L2_PIX_FMT_NV12T;
-        else if (!strcmp(new_str_picture_format, "yuv420p"))
-            new_picture_format = V4L2_PIX_FMT_YUV420;
-        else if (!strcmp(new_str_picture_format, "yuv422i"))
-            new_picture_format = V4L2_PIX_FMT_YUYV;
-        else if (!strcmp(new_str_picture_format, "uyv422i_custom")) //Zero copy UYVY format
-            new_picture_format = V4L2_PIX_FMT_UYVY;
-        else if (!strcmp(new_str_picture_format, "uyv422i")) //Non-zero copy UYVY format
-            new_picture_format = V4L2_PIX_FMT_UYVY;
-        else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_JPEG))
-            new_picture_format = V4L2_PIX_FMT_YUYV;
-        else if (!strcmp(new_str_picture_format, "yuv422p"))
-            new_picture_format = V4L2_PIX_FMT_YUV422P;
-        else
-            new_picture_format = V4L2_PIX_FMT_NV21; //for 3rd party
-
-        if (mSecCamera->setSnapshotPixelFormat(new_picture_format) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format);
-            ret = UNKNOWN_ERROR;
-        } else {
-            mParameters.setPictureFormat(new_str_picture_format);
-        }
-    }
-
-    //JPEG image quality
-    int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
-    LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
-    /* we ignore bad values */
-    if (new_jpeg_quality >=1 && new_jpeg_quality <= 100) {
-        if (mSecCamera->setJpegQuality(new_jpeg_quality) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality);
-            ret = UNKNOWN_ERROR;
-        } else {
-            mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality);
-        }
-    }
-
-    // JPEG thumbnail size
-    int new_jpeg_thumbnail_width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
-    int new_jpeg_thumbnail_height= params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
-    if (0 <= new_jpeg_thumbnail_width && 0 <= new_jpeg_thumbnail_height) {
-        if (mSecCamera->setJpegThumbnailSize(new_jpeg_thumbnail_width, new_jpeg_thumbnail_height) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height);
-            ret = UNKNOWN_ERROR;
-        } else {
-            mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, new_jpeg_thumbnail_width);
-            mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, new_jpeg_thumbnail_height);
-        }
-    }
-
-    // frame rate
-    int new_frame_rate = params.getPreviewFrameRate();
-    /* ignore any fps request, we're determine fps automatically based
-     * on scene mode.  don't return an error because it causes CTS failure.
-     */
-    if (new_frame_rate != mParameters.getPreviewFrameRate()) {
-        LOGW("WARN(%s): request for preview frame %d not allowed, != %d\n",
-             __func__, new_frame_rate, mParameters.getPreviewFrameRate());
-    }
-
-    // rotation
-    int new_rotation = params.getInt(CameraParameters::KEY_ROTATION);
-    LOGV("%s : new_rotation %d", __func__, new_rotation);
-    if (0 <= new_rotation) {
-        LOGV("%s : set orientation:%d\n", __func__, new_rotation);
-        if (mSecCamera->setExifOrientationInfo(new_rotation) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation);
-            ret = UNKNOWN_ERROR;
-        } else {
-            mParameters.set(CameraParameters::KEY_ROTATION, new_rotation);
-        }
-    }
-
-    // brightness
-    int new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
-    int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
-    int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
-    LOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation);
-    if ((min_exposure_compensation <= new_exposure_compensation) &&
-        (max_exposure_compensation >= new_exposure_compensation)) {
-        if (mSecCamera->setBrightness(new_exposure_compensation) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_exposure_compensation);
-            ret = UNKNOWN_ERROR;
-        } else {
-            mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, new_exposure_compensation);
-        }
-    }
-
-    // whitebalance
-    const char *new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE);
-    LOGV("%s : new_white_str %s", __func__, new_white_str);
-    if (new_white_str != NULL) {
-        int new_white = -1;
-
-        if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO))
-            new_white = WHITE_BALANCE_AUTO;
-        else if (!strcmp(new_white_str,
-                         CameraParameters::WHITE_BALANCE_DAYLIGHT))
-            new_white = WHITE_BALANCE_SUNNY;
-        else if (!strcmp(new_white_str,
-                         CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT))
-            new_white = WHITE_BALANCE_CLOUDY;
-        else if (!strcmp(new_white_str,
-                         CameraParameters::WHITE_BALANCE_FLUORESCENT))
-            new_white = WHITE_BALANCE_FLUORESCENT;
-        else if (!strcmp(new_white_str,
-                         CameraParameters::WHITE_BALANCE_INCANDESCENT))
-            new_white = WHITE_BALANCE_TUNGSTEN;
-        else {
-            LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent
-            ret = UNKNOWN_ERROR;
-        }
-
-        if (0 <= new_white) {
-            if (mSecCamera->setWhiteBalance(new_white) < 0) {
-                LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white);
-                ret = UNKNOWN_ERROR;
-            } else {
-                mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str);
-            }
-        }
-    }
-
-    // scene mode
-    const char *new_scene_mode_str = params.get(CameraParameters::KEY_SCENE_MODE);
-    const char *current_scene_mode_str = mParameters.get(CameraParameters::KEY_SCENE_MODE);
-
-    // fps range
-    int new_min_fps = 0;
-    int new_max_fps = 0;
-    int current_min_fps, current_max_fps;
-    params.getPreviewFpsRange(&new_min_fps, &new_max_fps);
-    mParameters.getPreviewFpsRange(&current_min_fps, &current_max_fps);
-    /* our fps range is determined by the sensor, reject any request
-     * that isn't exactly what we're already at.
-     * but the check is performed when requesting only changing fps range
-     */
-    if (new_scene_mode_str && current_scene_mode_str) {
-        if (!strcmp(new_scene_mode_str, current_scene_mode_str)) {
-            if ((new_min_fps != current_min_fps) || (new_max_fps != current_max_fps)) {
-                LOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed",
-                        __func__, new_min_fps, new_max_fps);
-                LOGE("%s : current_min_fps = %d, current_max_fps = %d",
-                        __func__, current_min_fps, current_max_fps);
-                ret = UNKNOWN_ERROR;
-            }
-        }
-    } else {
-        /* Check basic validation if scene mode is different */
-        if ((new_min_fps > new_max_fps) ||
-            (new_min_fps < 0) || (new_max_fps < 0))
-        ret = UNKNOWN_ERROR;
-    }
-
-    if (new_scene_mode_str != NULL) {
-        int  new_scene_mode = -1;
-
-        const char *new_flash_mode_str = params.get(CameraParameters::KEY_FLASH_MODE);
-        const char *new_focus_mode_str;
-
-        new_focus_mode_str = params.get(CameraParameters::KEY_FOCUS_MODE);
-        // fps range is (15000,30000) by default.
-        mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)");
-        mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
-                "15000,30000");
-
-        if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) {
-            new_scene_mode = SCENE_MODE_NONE;
-        } else {
-            // defaults for non-auto scene modes
-            if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) {
-                new_focus_mode_str = CameraParameters::FOCUS_MODE_AUTO;
-            }
-            new_flash_mode_str = CameraParameters::FLASH_MODE_OFF;
-
-            if (!strcmp(new_scene_mode_str,
-                       CameraParameters::SCENE_MODE_PORTRAIT)) {
-                new_scene_mode = SCENE_MODE_PORTRAIT;
-                new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO;
-            } else if (!strcmp(new_scene_mode_str,
-                               CameraParameters::SCENE_MODE_LANDSCAPE)) {
-                new_scene_mode = SCENE_MODE_LANDSCAPE;
-            } else if (!strcmp(new_scene_mode_str,
-                               CameraParameters::SCENE_MODE_SPORTS)) {
-                new_scene_mode = SCENE_MODE_SPORTS;
-            } else if (!strcmp(new_scene_mode_str,
-                               CameraParameters::SCENE_MODE_PARTY)) {
-                new_scene_mode = SCENE_MODE_PARTY_INDOOR;
-                new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO;
-            } else if ((!strcmp(new_scene_mode_str,
-                                CameraParameters::SCENE_MODE_BEACH)) ||
-                        (!strcmp(new_scene_mode_str,
-                                 CameraParameters::SCENE_MODE_SNOW))) {
-                new_scene_mode = SCENE_MODE_BEACH_SNOW;
-            } else if (!strcmp(new_scene_mode_str,
-                               CameraParameters::SCENE_MODE_SUNSET)) {
-                new_scene_mode = SCENE_MODE_SUNSET;
-            } else if (!strcmp(new_scene_mode_str,
-                               CameraParameters::SCENE_MODE_NIGHT)) {
-                new_scene_mode = SCENE_MODE_NIGHTSHOT;
-                mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(4000,30000)");
-                mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
-                                "4000,30000");
-            } else if (!strcmp(new_scene_mode_str,
-                               CameraParameters::SCENE_MODE_FIREWORKS)) {
-                new_scene_mode = SCENE_MODE_FIREWORKS;
-            } else if (!strcmp(new_scene_mode_str,
-                               CameraParameters::SCENE_MODE_CANDLELIGHT)) {
-                new_scene_mode = SCENE_MODE_CANDLE_LIGHT;
-            } else {
-                LOGE("%s::unmatched scene_mode(%s)",
-                        __func__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto
-                ret = UNKNOWN_ERROR;
-            }
-        }
-
-        // focus mode
-        if (new_focus_mode_str != NULL) {
-            int  new_focus_mode = -1;
-
-            if (!strcmp(new_focus_mode_str,
-                        CameraParameters::FOCUS_MODE_AUTO)) {
-                new_focus_mode = FOCUS_MODE_AUTO;
-                mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
-                                BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
-            }
-            else if (!strcmp(new_focus_mode_str,
-                             CameraParameters::FOCUS_MODE_MACRO)) {
-                new_focus_mode = FOCUS_MODE_MACRO;
-                mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
-                                BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR);
-            }
-            else if (!strcmp(new_focus_mode_str,
-                             CameraParameters::FOCUS_MODE_INFINITY)) {
-                new_focus_mode = FOCUS_MODE_INFINITY;
-                mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
-                                BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR);
-            }
-            else {
-                LOGE("%s::unmatched focus_mode(%s)", __func__, new_focus_mode_str);
-                ret = UNKNOWN_ERROR;
-            }
-
-            if (0 <= new_focus_mode) {
-                if (mSecCamera->setFocusMode(new_focus_mode) < 0) {
-                    LOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode);
-                    ret = UNKNOWN_ERROR;
-                } else {
-                    mParameters.set(CameraParameters::KEY_FOCUS_MODE, new_focus_mode_str);
-                }
-            }
-        }
-
-        // flash..
-        if (new_flash_mode_str != NULL) {
-            int  new_flash_mode = -1;
-
-            if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_OFF))
-                new_flash_mode = FLASH_MODE_OFF;
-            else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_AUTO))
-                new_flash_mode = FLASH_MODE_AUTO;
-            else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_ON))
-                new_flash_mode = FLASH_MODE_ON;
-            else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_TORCH))
-                new_flash_mode = FLASH_MODE_TORCH;
-            else {
-                LOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye
-                ret = UNKNOWN_ERROR;
-            }
-            if (0 <= new_flash_mode) {
-                if (mSecCamera->setFlashMode(new_flash_mode) < 0) {
-                    LOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode);
-                    ret = UNKNOWN_ERROR;
-                } else {
-                    mParameters.set(CameraParameters::KEY_FLASH_MODE, new_flash_mode_str);
-                }
-            }
-        }
-
-        //  scene..
-        if (0 <= new_scene_mode) {
-            if (mSecCamera->setSceneMode(new_scene_mode) < 0) {
-                LOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode);
-                ret = UNKNOWN_ERROR;
-            } else {
-                mParameters.set(CameraParameters::KEY_SCENE_MODE, new_scene_mode_str);
-            }
-        }
-    }
-
-    // ---------------------------------------------------------------------------
-
-    // image effect
-    const char *new_image_effect_str = params.get(CameraParameters::KEY_EFFECT);
-    if (new_image_effect_str != NULL) {
-
-        int  new_image_effect = -1;
-
-        if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NONE))
-            new_image_effect = IMAGE_EFFECT_NONE;
-        else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_MONO))
-            new_image_effect = IMAGE_EFFECT_BNW;
-        else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_SEPIA))
-            new_image_effect = IMAGE_EFFECT_SEPIA;
-        else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_AQUA))
-            new_image_effect = IMAGE_EFFECT_AQUA;
-        else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NEGATIVE))
-            new_image_effect = IMAGE_EFFECT_NEGATIVE;
-        else {
-            //posterize, whiteboard, blackboard, solarize
-            LOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str);
-            ret = UNKNOWN_ERROR;
-        }
-
-        if (new_image_effect >= 0) {
-            if (mSecCamera->setImageEffect(new_image_effect) < 0) {
-                LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect);
-                ret = UNKNOWN_ERROR;
-            } else {
-                const char *old_image_effect_str = mParameters.get(CameraParameters::KEY_EFFECT);
-
-                if (old_image_effect_str) {
-                    if (strcmp(old_image_effect_str, new_image_effect_str)) {
-                        setSkipFrame(EFFECT_SKIP_FRAME);
-                    }
-                }
-
-                mParameters.set(CameraParameters::KEY_EFFECT, new_image_effect_str);
-            }
-        }
-    }
-
-    //vt mode
-    int new_vtmode = mInternalParameters.getInt("vtmode");
-    if (0 <= new_vtmode) {
-        if (mSecCamera->setVTmode(new_vtmode) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setVTMode(%d)", __func__, new_vtmode);
-            ret = UNKNOWN_ERROR;
-        }
-    }
-
-    //contrast
-    int new_contrast = mInternalParameters.getInt("contrast");
-
-    if (0 <= new_contrast) {
-        if (mSecCamera->setContrast(new_contrast) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setContrast(%d)", __func__, new_contrast);
-            ret = UNKNOWN_ERROR;
-        }
-    }
-
-    //WDR
-    int new_wdr = mInternalParameters.getInt("wdr");
-
-    if (0 <= new_wdr) {
-        if (mSecCamera->setWDR(new_wdr) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_wdr);
-            ret = UNKNOWN_ERROR;
-        }
-    }
-
-    //anti shake
-    int new_anti_shake = mInternalParameters.getInt("anti-shake");
-
-    if (0 <= new_anti_shake) {
-        if (mSecCamera->setAntiShake(new_anti_shake) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_anti_shake);
-            ret = UNKNOWN_ERROR;
-        }
-    }
-
-    // gps latitude
-    const char *new_gps_latitude_str = params.get(CameraParameters::KEY_GPS_LATITUDE);
-    if (mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) {
-        LOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str);
-        ret = UNKNOWN_ERROR;
-    } else {
-        if (new_gps_latitude_str) {
-            mParameters.set(CameraParameters::KEY_GPS_LATITUDE, new_gps_latitude_str);
-        } else {
-            mParameters.remove(CameraParameters::KEY_GPS_LATITUDE);
-        }
-    }
-
-    // gps longitude
-    const char *new_gps_longitude_str = params.get(CameraParameters::KEY_GPS_LONGITUDE);
-
-    if (mSecCamera->setGPSLongitude(new_gps_longitude_str) < 0) {
-        LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str);
-        ret = UNKNOWN_ERROR;
-    } else {
-        if (new_gps_longitude_str) {
-            mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, new_gps_longitude_str);
-        } else {
-            mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE);
-        }
-    }
-
-    // gps altitude
-    const char *new_gps_altitude_str = params.get(CameraParameters::KEY_GPS_ALTITUDE);
-
-    if (mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) {
-        LOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str);
-        ret = UNKNOWN_ERROR;
-    } else {
-        if (new_gps_altitude_str) {
-            mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, new_gps_altitude_str);
-        } else {
-            mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE);
-        }
-    }
-
-    // gps timestamp
-    const char *new_gps_timestamp_str = params.get(CameraParameters::KEY_GPS_TIMESTAMP);
-
-    if (mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) {
-        LOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str);
-        ret = UNKNOWN_ERROR;
-    } else {
-        if (new_gps_timestamp_str) {
-            mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, new_gps_timestamp_str);
-        } else {
-            mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
-        }
-    }
-
-    // gps processing method
-    const char *new_gps_processing_method_str = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
-
-    if (mSecCamera->setGPSProcessingMethod(new_gps_processing_method_str) < 0) {
-        LOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str);
-        ret = UNKNOWN_ERROR;
-    } else {
-        if (new_gps_processing_method_str) {
-            mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, new_gps_processing_method_str);
-        } else {
-            mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
-        }
-    }
-
-    // Recording size
-    int new_recording_width = mInternalParameters.getInt("recording-size-width");
-    int new_recording_height= mInternalParameters.getInt("recording-size-height");
-
-    if (0 < new_recording_width && 0 < new_recording_height) {
-        if (mSecCamera->setRecordingSize(new_recording_width, new_recording_height) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_recording_width, new_recording_height);
-            ret = UNKNOWN_ERROR;
-        }
-    } else {
-        if (mSecCamera->setRecordingSize(new_preview_width, new_preview_height) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_preview_width, new_preview_height);
-            ret = UNKNOWN_ERROR;
-        }
-    }
-
-    //gamma
-    const char *new_gamma_str = mInternalParameters.get("video_recording_gamma");
-
-    if (new_gamma_str != NULL) {
-        int new_gamma = -1;
-        if (!strcmp(new_gamma_str, "off"))
-            new_gamma = GAMMA_OFF;
-        else if (!strcmp(new_gamma_str, "on"))
-            new_gamma = GAMMA_ON;
-        else {
-            LOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str);
-            ret = UNKNOWN_ERROR;
-        }
-
-        if (0 <= new_gamma) {
-            if (mSecCamera->setGamma(new_gamma) < 0) {
-                LOGE("%s::mSecCamera->setGamma(%d) fail", __func__, new_gamma);
-                ret = UNKNOWN_ERROR;
-            }
-        }
-    }
-
-    //slow ae
-    const char *new_slow_ae_str = mInternalParameters.get("slow_ae");
-
-    if (new_slow_ae_str != NULL) {
-        int new_slow_ae = -1;
-
-        if (!strcmp(new_slow_ae_str, "off"))
-            new_slow_ae = SLOW_AE_OFF;
-        else if (!strcmp(new_slow_ae_str, "on"))
-            new_slow_ae = SLOW_AE_ON;
-        else {
-            LOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str);
-            ret = UNKNOWN_ERROR;
-        }
-
-        if (0 <= new_slow_ae) {
-            if (mSecCamera->setSlowAE(new_slow_ae) < 0) {
-                LOGE("%s::mSecCamera->setSlowAE(%d) fail", __func__, new_slow_ae);
-                ret = UNKNOWN_ERROR;
-            }
-        }
-    }
-
-    /*Camcorder fix fps*/
-    int new_sensor_mode = mInternalParameters.getInt("cam_mode");
-
-    if (0 <= new_sensor_mode) {
-        if (mSecCamera->setSensorMode(new_sensor_mode) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __func__, new_sensor_mode);
-            ret = UNKNOWN_ERROR;
-        }
-    } else {
-        new_sensor_mode=0;
-    }
-
-    /*Shot mode*/
-    int new_shot_mode = mInternalParameters.getInt("shot_mode");
-
-    if (0 <= new_shot_mode) {
-        if (mSecCamera->setShotMode(new_shot_mode) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __func__, new_shot_mode);
-            ret = UNKNOWN_ERROR;
-        }
-    } else {
-        new_shot_mode=0;
-    }
-
-    //blur for Video call
-    int new_blur_level = mInternalParameters.getInt("blur");
-
-    if (0 <= new_blur_level) {
-        if (mSecCamera->setBlur(new_blur_level) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setBlur(%d)", __func__, new_blur_level);
-            ret = UNKNOWN_ERROR;
-        }
-    }
-
-
-    // chk_dataline
-    int new_dataline = mInternalParameters.getInt("chk_dataline");
-
-    if (0 <= new_dataline) {
-        if (mSecCamera->setDataLineCheck(new_dataline) < 0) {
-            LOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __func__, new_dataline);
-            ret = UNKNOWN_ERROR;
-        }
-    }
-    LOGV("%s return ret = %d", __func__, ret);
-    
-    if (mSecCamera->stopPreview() < 0) {
-                LOGE("ERR(%s):Fail on mSecCamera->stopPreview", __func__);
-                ret = UNKNOWN_ERROR;
-    }
-    
-    //sleep a bit to give the cam a chance to get ready
-    usleep(100000);
-    if (mSecCamera->startPreview() < 0) {
-         LOGE("ERR(%s):Fail on mSecCamera->startPreview", __func__);
-         ret = UNKNOWN_ERROR;
-    }
-
-    return ret;
-}
-
-CameraParameters CameraHardwareSec::getParameters() const
-{
-    LOGV("%s :", __func__);
-    return mParameters;
-}
-
-status_t CameraHardwareSec::sendCommand(int32_t command, int32_t arg1, int32_t arg2)
-{
-    return BAD_VALUE;
-}
-
-void CameraHardwareSec::release()
-{
-    LOGV("%s :", __func__);
-
-    /* shut down any threads we have that might be running.  do it here
-     * instead of the destructor.  we're guaranteed to be on another thread
-     * than the ones below.  if we used the destructor, since the threads
-     * have a reference to this object, we could wind up trying to wait
-     * for ourself to exit, which is a deadlock.
-     */
-    if (mPreviewThread != NULL) {
-        /* this thread is normally already in it's threadLoop but blocked
-         * on the condition variable or running.  signal it so it wakes
-         * up and can exit.
-         */
-        mPreviewThread->requestExit();
-        mExitPreviewThread = true;
-        mPreviewRunning = true; /* let it run so it can exit */
-        mPreviewCondition.signal();
-        mPreviewThread->requestExitAndWait();
-        mPreviewThread.clear();
-    }
-    if (mAutoFocusThread != NULL) {
-        /* this thread is normally already in it's threadLoop but blocked
-         * on the condition variable.  signal it so it wakes up and can exit.
-         */
-        mFocusLock.lock();
-        mAutoFocusThread->requestExit();
-        mExitAutoFocusThread = true;
-        mFocusCondition.signal();
-        mFocusLock.unlock();
-        mAutoFocusThread->requestExitAndWait();
-        mAutoFocusThread.clear();
-    }
-    if (mPictureThread != NULL) {
-        mPictureThread->requestExitAndWait();
-        mPictureThread.clear();
-    }
-    if (mRawHeap != NULL)
-        mRawHeap.clear();
-
-    if (mJpegHeap != NULL)
-        mJpegHeap.clear();
-
-    if (mPreviewHeap != NULL) {
-        LOGI("%s: calling mPreviewHeap.dispose()", __func__);
-        mPreviewHeap->dispose();
-        mPreviewHeap.clear();
-    }
-
-    if (mRecordHeap != NULL)
-        mRecordHeap.clear();
-
-#if defined(BOARD_USES_OVERLAY)
-    if (mUseOverlay) {
-        mOverlay->destroy();
-        mUseOverlay = false;
-        mOverlay = NULL;
-    }
-#endif
-
-    /* close after all the heaps are cleared since those
-     * could have dup'd our file descriptor.
-     */
-    mSecCamera->DeinitCamera();
-    mSecCamera = NULL;
-
-}
-
-wp<CameraHardwareInterface> CameraHardwareSec::singleton;
-
-sp<CameraHardwareInterface> CameraHardwareSec::createInstance(int cameraId)
-{
-    LOGV("%s :", __func__);
-    if (singleton != 0) {
-        sp<CameraHardwareInterface> hardware = singleton.promote();
-        if (hardware != 0) {
-            return hardware;
-        }
-    }
-    sp<CameraHardwareInterface> hardware(new CameraHardwareSec(cameraId));
-    singleton = hardware;
-    return hardware;
-}
-
-static CameraInfo sCameraInfo[] = {
-    {
-        CAMERA_FACING_BACK,
-        90,  /* orientation */
-    },
-#ifdef FFC_PRESENT
-    {
-        CAMERA_FACING_FRONT,
-        0,  /* orientation */
-    }
-#endif
-};
-
-extern "C" int HAL_getNumberOfCameras()
-{
-    return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]);
-}
-
-extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo *cameraInfo)
-{
-    memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo));
-}
-
-extern "C" sp<CameraHardwareInterface> HAL_openCameraHardware(int cameraId)
-{
-    return CameraHardwareSec::createInstance(cameraId);
-}
-
-}; // namespace android
diff --git a/libcamera/SecCameraHWInterface.h b/libcamera/SecCameraHWInterface.h
deleted file mode 100644
index 75526c6..0000000
--- a/libcamera/SecCameraHWInterface.h
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
-**
-** Copyright 2008, The Android Open Source Project
-** Copyright 2010, Samsung Electronics Co. LTD
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#ifndef ANDROID_HARDWARE_CAMERA_HARDWARE_SEC_H
-#define ANDROID_HARDWARE_CAMERA_HARDWARE_SEC_H
-
-#include "SecCamera.h"
-#include <utils/threads.h>
-#include <camera/CameraHardwareInterface.h>
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-
-namespace android {
-class CameraHardwareSec : public CameraHardwareInterface {
-public:
-    virtual sp<IMemoryHeap> getPreviewHeap() const;
-    virtual sp<IMemoryHeap> getRawHeap() const;
-
-    virtual void        setCallbacks(notify_callback notify_cb,
-                                     data_callback data_cb,
-                                     data_callback_timestamp data_cb_timestamp,
-                                     void *user);
-
-    virtual void        enableMsgType(int32_t msgType);
-    virtual void        disableMsgType(int32_t msgType);
-    virtual bool        msgTypeEnabled(int32_t msgType);
-
-    virtual status_t    startPreview();
-#if defined(BOARD_USES_OVERLAY)
-    virtual bool        useOverlay();
-    virtual status_t    setOverlay(const sp<Overlay> &overlay);
-#endif
-    virtual void        stopPreview();
-    virtual bool        previewEnabled();
-
-    virtual status_t    startRecording();
-    virtual void        stopRecording();
-    virtual bool        recordingEnabled();
-    virtual void        releaseRecordingFrame(const sp<IMemory> &mem);
-
-    virtual status_t    autoFocus();
-    virtual status_t    cancelAutoFocus();
-    virtual status_t    takePicture();
-    virtual status_t    cancelPicture();
-    virtual status_t    dump(int fd, const Vector<String16> &args) const;
-    virtual status_t    setParameters(const CameraParameters& params);
-    virtual CameraParameters  getParameters() const;
-    virtual status_t    sendCommand(int32_t command, int32_t arg1,
-                                    int32_t arg2);
-    virtual void        release();
-
-    static    sp<CameraHardwareInterface> createInstance(int cameraId);
-
-private:
-                        CameraHardwareSec(int cameraId);
-    virtual             ~CameraHardwareSec();
-
-    static wp<CameraHardwareInterface> singleton;
-
-    static  const int   kBufferCount = MAX_BUFFERS;
-    static  const int   kBufferCountForRecord = MAX_BUFFERS;
-
-    class PreviewThread : public Thread {
-        CameraHardwareSec *mHardware;
-    public:
-        PreviewThread(CameraHardwareSec *hw):
-        Thread(false),
-        mHardware(hw) { }
-        virtual void onFirstRef() {
-            run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY);
-        }
-        virtual bool threadLoop() {
-            mHardware->previewThreadWrapper();
-            return false;
-        }
-    };
-
-    class PictureThread : public Thread {
-        CameraHardwareSec *mHardware;
-    public:
-        PictureThread(CameraHardwareSec *hw):
-        Thread(false),
-        mHardware(hw) { }
-        virtual bool threadLoop() {
-            mHardware->pictureThread();
-            mHardware->mSecCamera->endSnapshot();
-            return false;
-        }
-    };
-
-    class AutoFocusThread : public Thread {
-        CameraHardwareSec *mHardware;
-    public:
-        AutoFocusThread(CameraHardwareSec *hw): Thread(false), mHardware(hw) { }
-        virtual void onFirstRef() {
-            run("CameraAutoFocusThread", PRIORITY_DEFAULT);
-        }
-        virtual bool threadLoop() {
-            mHardware->autoFocusThread();
-            return true;
-        }
-    };
-
-            void        initDefaultParameters(int cameraId);
-            void        initHeapLocked();
-
-    sp<PreviewThread>   mPreviewThread;
-            int         previewThread();
-            int         previewThreadWrapper();
-
-    sp<AutoFocusThread> mAutoFocusThread;
-            int         autoFocusThread();
-
-    sp<PictureThread>   mPictureThread;
-            int         pictureThread();
-            bool        mCaptureInProgress;
-
-            int         save_jpeg(unsigned char *real_jpeg, int jpeg_size);
-            void        save_postview(const char *fname, uint8_t *buf,
-                                        uint32_t size);
-            int         decodeInterleaveData(unsigned char *pInterleaveData,
-                                                int interleaveDataSize,
-                                                int yuvWidth,
-                                                int yuvHeight,
-                                                int *pJpegSize,
-                                                void *pJpegData,
-                                                void *pYuvData);
-            bool        YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight);
-            bool        scaleDownYuv422(char *srcBuf, uint32_t srcWidth,
-                                        uint32_t srcHight, char *dstBuf,
-                                        uint32_t dstWidth, uint32_t dstHight);
-
-            bool        CheckVideoStartMarker(unsigned char *pBuf);
-            bool        CheckEOIMarker(unsigned char *pBuf);
-            bool        FindEOIMarkerInJPEG(unsigned char *pBuf,
-                                            int dwBufSize, int *pnJPEGsize);
-            bool        SplitFrame(unsigned char *pFrame, int dwSize,
-                                   int dwJPEGLineLength, int dwVideoLineLength,
-                                   int dwVideoHeight, void *pJPEG,
-                                   int *pdwJPEGSize, void *pVideo,
-                                   int *pdwVideoSize);
-            void        setSkipFrame(int frame);
-    /* used by auto focus thread to block until it's told to run */
-    mutable Mutex       mFocusLock;
-    mutable Condition   mFocusCondition;
-            bool        mExitAutoFocusThread;
-
-    /* used by preview thread to block until it's told to run */
-    mutable Mutex       mPreviewLock;
-    mutable Condition   mPreviewCondition;
-    mutable Condition   mPreviewStoppedCondition;
-            bool        mPreviewRunning;
-            bool        mExitPreviewThread;
-
-    /* used to guard threading state */
-    mutable Mutex       mStateLock;
-
-    CameraParameters    mParameters;
-    CameraParameters    mInternalParameters;
-
-    sp<MemoryHeapBase>  mPreviewHeap;
-    sp<MemoryHeapBase>  mRawHeap;
-    sp<MemoryHeapBase>  mRecordHeap;
-    sp<MemoryHeapBase>  mJpegHeap;
-    sp<MemoryBase>      mBuffers[kBufferCount];
-    sp<MemoryBase>      mRecordBuffers[kBufferCountForRecord];
-
-            SecCamera   *mSecCamera;
-            const __u8  *mCameraSensorName;
-
-    mutable Mutex       mSkipFrameLock;
-            int         mSkipFrame;
-
-#if defined(BOARD_USES_OVERLAY)
-            sp<Overlay> mOverlay;
-            bool        mUseOverlay;
-            int         mOverlayBufferIdx;
-#endif
-
-    notify_callback     mNotifyCb;
-    data_callback       mDataCb;
-    data_callback_timestamp mDataCbTimestamp;
-            void        *mCallbackCookie;
-
-            int32_t     mMsgEnabled;
-
-            bool        mRecordRunning;
-    mutable Mutex       mRecordLock;
-            int         mPostViewWidth;
-            int         mPostViewHeight;
-            int         mPostViewSize;
-};
-
-}; // namespace android
-
-#endif