exynos5: fixup libcamera to build

Change-Id: I9914417bb193f7a611062416de1cf0625fa091e3
Signed-off-by: Dima Zavin <dima@android.com>

4 files changed, 572 insertions, 574 deletions

diff --git a/libcamera/Android.mk b/libcamera/Android.mk
index 2729a2f..5253ab8 100644
--- a/libcamera/Android.mk
+++ b/libcamera/Android.mk
@@ -3,12 +3,11 @@ include $(CLEAR_VARS)
 
 # HAL module implemenation stored in
 # hw/<COPYPIX_HARDWARE_MODULE_ID>.<ro.product.board>.so
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR_SHARED_LIBRARIES)/hw
 
 LOCAL_C_INCLUDES += \
-	$(LOCAL_PATH)/../include \
-	$(LOCAL_PATH)/../libexynosutils \
-	$(LOCAL_PATH)/../libcsc
+	hardware/samsung_slsi/exynos5/include \
+	frameworks/native/include
 
 LOCAL_SRC_FILES:= \
 	ExynosCamera.cpp \
@@ -19,9 +18,9 @@ LOCAL_SHARED_LIBRARIES:= libutils libcutils libbinder liblog libcamera_client li
 
 LOCAL_CFLAGS += -DGAIA_FW_BETA
 
-LOCAL_SHARED_LIBRARIES += libexynosutils libhwjpeg libexynosv4l2 libcsc libion
+LOCAL_SHARED_LIBRARIES += libexynosutils libhwjpeg libexynosv4l2 libcsc libion_exynos
 
-LOCAL_MODULE := camera.$(TARGET_DEVICE)
+LOCAL_MODULE := camera.exynos5
 
 LOCAL_MODULE_TAGS := optional
 
diff --git a/libcamera/ExynosCamera.cpp b/libcamera/ExynosCamera.cpp
index 383c902..699a3b3 100644
--- a/libcamera/ExynosCamera.cpp
+++ b/libcamera/ExynosCamera.cpp
@@ -698,7 +698,7 @@ bool ExynosCamera::create(int cameraId)
     struct media_link   *links = NULL;
 
     if (m_flagCreate == true) {
-        LOGE("ERR(%s):Already created", __func__);
+        ALOGE("ERR(%s):Already created", __func__);
         return false;
     }
 
@@ -729,7 +729,7 @@ bool ExynosCamera::create(int cameraId)
         // media device open
         m_media = exynos_media_open(MEDIA_DEV_INTERNAL_ISP);
         if (m_media == NULL) {
-            LOGE("ERR(%s):Cannot open media device (error : %s)", __func__, strerror(errno));
+            ALOGE("ERR(%s):Cannot open media device (error : %s)", __func__, strerror(errno));
             goto err;
         }
 
@@ -766,12 +766,12 @@ bool ExynosCamera::create(int cameraId)
         strcpy(node, ISP_VIDEO_3DNR_NAME);
         m_isp3dnrEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node));
 
-        LOGV("DEBUG(%s):m_ispSensorEntity  : numlink : %d", __func__, m_ispSensorEntity->num_links);
-        LOGV("DEBUG(%s):m_ispFrontEntity   : numlink : %d", __func__, m_ispFrontEntity->num_links);
-        LOGV("DEBUG(%s):m_ispBackEntity    : numlink : %d", __func__, m_ispBackEntity->num_links);
-        LOGV("DEBUG(%s):m_ispScalercEntity : numlink : %d", __func__, m_ispScalercEntity->num_links);
-        LOGV("DEBUG(%s):m_ispScalerpEntity : numlink : %d", __func__, m_ispScalerpEntity->num_links);
-        LOGV("DEBUG(%s):m_isp3dnrEntity    : numlink : %d", __func__, m_isp3dnrEntity->num_links);
+        ALOGV("DEBUG(%s):m_ispSensorEntity  : numlink : %d", __func__, m_ispSensorEntity->num_links);
+        ALOGV("DEBUG(%s):m_ispFrontEntity   : numlink : %d", __func__, m_ispFrontEntity->num_links);
+        ALOGV("DEBUG(%s):m_ispBackEntity    : numlink : %d", __func__, m_ispBackEntity->num_links);
+        ALOGV("DEBUG(%s):m_ispScalercEntity : numlink : %d", __func__, m_ispScalercEntity->num_links);
+        ALOGV("DEBUG(%s):m_ispScalerpEntity : numlink : %d", __func__, m_ispScalerpEntity->num_links);
+        ALOGV("DEBUG(%s):m_isp3dnrEntity    : numlink : %d", __func__, m_isp3dnrEntity->num_links);
 
         //////////////////
         // SETUP LINKS
@@ -781,13 +781,13 @@ bool ExynosCamera::create(int cameraId)
         if (links == NULL ||
             links->source->entity != m_ispSensorEntity ||
             links->sink->entity != m_ispFrontEntity) {
-            LOGE("ERR(%s):Can not make link isp_sensor to isp_front", __func__);
+            ALOGE("ERR(%s):Can not make link isp_sensor to isp_front", __func__);
             goto err;
         } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
-            LOGE("ERR(%s):Can not make setup isp_sensor to isp_front", __func__);
+            ALOGE("ERR(%s):Can not make setup isp_sensor to isp_front", __func__);
             goto err;
         }
-        LOGV("DEBUG(%s):[LINK SUCCESS] Sensor to front", __func__);
+        ALOGV("DEBUG(%s):[LINK SUCCESS] Sensor to front", __func__);
 
         // FRONT TO BACK
         for (i = 0; i < m_ispFrontEntity->num_links; i++) {
@@ -795,17 +795,17 @@ bool ExynosCamera::create(int cameraId)
             if (links == NULL ||
                 links->source->entity != m_ispFrontEntity ||
                 links->sink->entity != m_ispBackEntity) {
-                LOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_ispFrontEntity : %p", __func__, i,
+                ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_ispFrontEntity : %p", __func__, i,
                     links->source->entity, m_ispFrontEntity);
-                LOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_ispBackEntity : %p", __func__, i,
+                ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_ispBackEntity : %p", __func__, i,
                     links->sink->entity, m_ispBackEntity);
                 continue;
             } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
-                LOGE("ERR(%s):Can not make setup isp_front to isp_back", __func__);
+                ALOGE("ERR(%s):Can not make setup isp_front to isp_back", __func__);
                 goto err;
             }
         }
-        LOGV("DEBUG(%s):[LINK SUCCESS] front to back", __func__);
+        ALOGV("DEBUG(%s):[LINK SUCCESS] front to back", __func__);
 
         // BACK TO ScalerP Video
         for (i = 0; i < m_ispBackEntity->num_links; i++) {
@@ -813,22 +813,22 @@ bool ExynosCamera::create(int cameraId)
             if (links == NULL ||
                 links->source->entity != m_ispBackEntity ||
                 links->sink->entity != m_ispScalerpEntity) {
-                LOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_ispBackEntity : %p", __func__, i,
+                ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_ispBackEntity : %p", __func__, i,
                     links->source->entity, m_ispBackEntity);
-                LOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_ispScalerpEntity : %p", __func__, i,
+                ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_ispScalerpEntity : %p", __func__, i,
                     links->sink->entity, m_ispScalerpEntity);
                 continue;
             } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
-                LOGE("ERR(%s):Can not make setup isp_back to scalerP", __func__);
+                ALOGE("ERR(%s):Can not make setup isp_back to scalerP", __func__);
                 goto err;
             }
         }
-        LOGV("DEBUG(%s):[LINK SUCCESS] back to scalerP", __func__);
+        ALOGV("DEBUG(%s):[LINK SUCCESS] back to scalerP", __func__);
 
         sprintf(node, "%s%d", PFX_NODE, (ISP_VD_NODE_OFFSET + VIDEO_NODE_PREVIEW_ID));
         m_gscPreviewDev.fd = exynos_v4l2_open(node, O_RDWR, 0);
         if (m_gscPreviewDev.fd <= 0) {
-            LOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno));
+            ALOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno));
             goto err;
         }
         m_previewDev = &m_gscPreviewDev;
@@ -836,7 +836,7 @@ bool ExynosCamera::create(int cameraId)
         sprintf(node, "%s%d", PFX_NODE, (ISP_VD_NODE_OFFSET + VIDEO_NODE_RECODING_ID));
         m_gscVideoDev.fd = exynos_v4l2_open(node, O_RDWR, 0);
         if (m_gscVideoDev.fd <= 0) {
-            LOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno));
+            ALOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno));
             goto err;
         }
         m_videoDev = &m_gscVideoDev;
@@ -844,7 +844,7 @@ bool ExynosCamera::create(int cameraId)
         sprintf(node, "%s%d", PFX_NODE, (ISP_VD_NODE_OFFSET + VIDEO_NODE_SNAPSHOT_ID));
         m_gscPictureDev.fd = exynos_v4l2_open(node, O_RDWR, 0);
         if (m_gscPictureDev.fd <= 0) {
-            LOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno));
+            ALOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno));
             goto err;
         }
         m_pictureDev = &m_gscPictureDev;
@@ -856,7 +856,7 @@ bool ExynosCamera::create(int cameraId)
         // media device open
         m_media = exynos_media_open(MEDIA_DEV_EXTERNAL_ISP);
         if (m_media == NULL) {
-            LOGE("ERR(%s):Cannot open media device (error : %s)", __func__, strerror(errno));
+            ALOGE("ERR(%s):Cannot open media device (error : %s)", __func__, strerror(errno));
             goto err;
         }
 
@@ -865,46 +865,46 @@ bool ExynosCamera::create(int cameraId)
         //////////////////
         // camera subdev
         strcpy(node, M5MOLS_ENTITY_NAME);
-        LOGV("DEBUG(%s):node : %s", __func__, node);
+        ALOGV("DEBUG(%s):node : %s", __func__, node);
         m_sensorEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node));
-        LOGV("DEBUG(%s):m_sensorEntity : 0x%p", __func__, m_sensorEntity);
+        ALOGV("DEBUG(%s):m_sensorEntity : 0x%p", __func__, m_sensorEntity);
 
         // mipi subdev
         sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_MIPI_CSIS, MIPI_NUM);
-        LOGV("DEBUG(%s):node : %s", __func__, node);
+        ALOGV("DEBUG(%s):node : %s", __func__, node);
         m_mipiEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node));
-        LOGV("DEBUG(%s):m_mipiEntity : 0x%p", __func__, m_mipiEntity);
+        ALOGV("DEBUG(%s):m_mipiEntity : 0x%p", __func__, m_mipiEntity);
 
         // fimc-lite subdev
         sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_FLITE, FLITE_NUM);
-        LOGV("DEBUG(%s):node : %s", __func__, node);
+        ALOGV("DEBUG(%s):node : %s", __func__, node);
         m_fliteSdEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node));
-        LOGV("DEBUG(%s):m_fliteSdEntity : 0x%p", __func__, m_fliteSdEntity);
+        ALOGV("DEBUG(%s):m_fliteSdEntity : 0x%p", __func__, m_fliteSdEntity);
 
         // fimc-lite videodev
         sprintf(node, "%s.%d", PFX_VIDEODEV_ENTITY_FLITE, FLITE_NUM);
-        LOGV("DEBUG(%s):node : %s", __func__, node);
+        ALOGV("DEBUG(%s):node : %s", __func__, node);
         m_fliteVdEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node));
-        LOGV("DEBUG(%s):m_fliteVdEntity : 0x%p", __func__, m_fliteVdEntity);
+        ALOGV("DEBUG(%s):m_fliteVdEntity : 0x%p", __func__, m_fliteVdEntity);
 
         // gscaler subdev
         sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_GSC_CAP, GSC_NUM);
-        LOGV("DEBUG(%s):node : %s", __func__, node);
+        ALOGV("DEBUG(%s):node : %s", __func__, node);
         m_gscSdEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node));
-        LOGV("DEBUG(%s):m_gscSdEntity : 0x%p", __func__, m_gscSdEntity);
+        ALOGV("DEBUG(%s):m_gscSdEntity : 0x%p", __func__, m_gscSdEntity);
 
         // gscaler videodev
         sprintf(node, "%s.%d", PFX_VIDEODEV_ENTITY_GSC_CAP, GSC_NUM);
-        LOGV("DEBUG(%s):node : %s", __func__, node);
+        ALOGV("DEBUG(%s):node : %s", __func__, node);
         m_gscVdEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node));
-        LOGV("DEBUG(%s):m_gscVdEntity : 0x%p", __func__, m_gscVdEntity);
+        ALOGV("DEBUG(%s):m_gscVdEntity : 0x%p", __func__, m_gscVdEntity);
 
-        LOGV("DEBUG(%s):sensor_sd : numlink : %d", __func__, m_sensorEntity->num_links);
-        LOGV("DEBUG(%s):mipi_sd   : numlink : %d", __func__, m_mipiEntity->num_links);
-        LOGV("DEBUG(%s):flite_sd  : numlink : %d", __func__, m_fliteSdEntity->num_links);
-        LOGV("DEBUG(%s):flite_vd  : numlink : %d", __func__, m_fliteVdEntity->num_links);
-        LOGV("DEBUG(%s):gsc_sd    : numlink : %d", __func__, m_gscSdEntity->num_links);
-        LOGV("DEBUG(%s):gsc_vd    : numlink : %d", __func__, m_gscVdEntity->num_links);
+        ALOGV("DEBUG(%s):sensor_sd : numlink : %d", __func__, m_sensorEntity->num_links);
+        ALOGV("DEBUG(%s):mipi_sd   : numlink : %d", __func__, m_mipiEntity->num_links);
+        ALOGV("DEBUG(%s):flite_sd  : numlink : %d", __func__, m_fliteSdEntity->num_links);
+        ALOGV("DEBUG(%s):flite_vd  : numlink : %d", __func__, m_fliteVdEntity->num_links);
+        ALOGV("DEBUG(%s):gsc_sd    : numlink : %d", __func__, m_gscSdEntity->num_links);
+        ALOGV("DEBUG(%s):gsc_vd    : numlink : %d", __func__, m_gscVdEntity->num_links);
 
         //////////////////
         // SETUP LINKS
@@ -914,92 +914,92 @@ bool ExynosCamera::create(int cameraId)
         if (links == NULL ||
             links->source->entity != m_sensorEntity ||
             links->sink->entity != m_mipiEntity) {
-            LOGE("ERR(%s):Cannot make link camera sensor to mipi", __func__);
+            ALOGE("ERR(%s):Cannot make link camera sensor to mipi", __func__);
             goto err;
         }
 
         if (exynos_media_setup_link(m_media,  links->source,  links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
-            LOGE("ERR(%s):Cannot make setup camera sensor to mipi", __func__);
+            ALOGE("ERR(%s):Cannot make setup camera sensor to mipi", __func__);
             goto err;
         }
-        LOGV("DEBUG(%s):[LINK SUCCESS] sensor subdev to mipi subdev", __func__);
+        ALOGV("DEBUG(%s):[LINK SUCCESS] sensor subdev to mipi subdev", __func__);
 
         // mipi subdev to fimc-lite subdev
         for (i = 0; i < m_mipiEntity->num_links; i++) {
             links = &m_mipiEntity->links[i];
-            LOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_mipiEntity : %p", __func__, i,
+            ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_mipiEntity : %p", __func__, i,
                     links->source->entity, m_mipiEntity);
-            LOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_fliteSdEntity : %p", __func__, i,
+            ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_fliteSdEntity : %p", __func__, i,
                     links->sink->entity, m_fliteSdEntity);
             if (links == NULL ||
                 links->source->entity != m_mipiEntity ||
                 links->sink->entity != m_fliteSdEntity) {
                 continue;
             } else if (exynos_media_setup_link(m_media,  links->source,  links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
-                LOGE("ERR(%s):Cannot make setup mipi subdev to fimc-lite subdev", __func__);
+                ALOGE("ERR(%s):Cannot make setup mipi subdev to fimc-lite subdev", __func__);
                 goto err;
             }
         }
-        LOGV("DEBUG(%s):[LINK SUCCESS] mipi subdev to fimc-lite subdev", __func__);
+        ALOGV("DEBUG(%s):[LINK SUCCESS] mipi subdev to fimc-lite subdev", __func__);
 
         // fimc-lite subdev TO fimc-lite video dev
         for (i = 0; i < m_fliteSdEntity->num_links; i++) {
             links = &m_fliteSdEntity->links[i];
-            LOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_fliteSdEntity : %p", __func__, i,
+            ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_fliteSdEntity : %p", __func__, i,
                 links->source->entity, m_fliteSdEntity);
-            LOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_fliteVdEntity : %p", __func__, i,
+            ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_fliteVdEntity : %p", __func__, i,
                 links->sink->entity, m_fliteVdEntity);
             if (links == NULL ||
                 links->source->entity != m_fliteSdEntity ||
                 links->sink->entity != m_fliteVdEntity) {
                 continue;
             } else if (exynos_media_setup_link(m_media,  links->source,  links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
-                LOGE("ERR(%s):Cannot make setup fimc-lite subdev to fimc-lite video dev", __func__);
+                ALOGE("ERR(%s):Cannot make setup fimc-lite subdev to fimc-lite video dev", __func__);
                 goto err;
             }
         }
-        LOGV("DEBUG(%s):[LINK SUCCESS] fimc-lite subdev to fimc-lite video dev", __func__);
+        ALOGV("DEBUG(%s):[LINK SUCCESS] fimc-lite subdev to fimc-lite video dev", __func__);
 
         // fimc-lite subdev to gscaler subdev
         for (i = 0; i < m_gscSdEntity->num_links; i++) {
             links = &m_gscSdEntity->links[i];
-            LOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_fliteSdEntity : %p", __func__, i,
+            ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_fliteSdEntity : %p", __func__, i,
                     links->source->entity, m_fliteSdEntity);
-            LOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_gscSdEntity : %p", __func__, i,
+            ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_gscSdEntity : %p", __func__, i,
                     links->sink->entity, m_gscSdEntity);
             if (links == NULL ||
                 links->source->entity != m_fliteSdEntity ||
                 links->sink->entity != m_gscSdEntity) {
                 continue;
             } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
-                LOGE("ERR(%s):Cannot make setup fimc-lite subdev to gscaler subdev", __func__);
+                ALOGE("ERR(%s):Cannot make setup fimc-lite subdev to gscaler subdev", __func__);
                 goto err;
             }
         }
-        LOGV("DEBUG(%s):[LINK SUCCESS] fimc-lite subdev to gscaler subdev", __func__);
+        ALOGV("DEBUG(%s):[LINK SUCCESS] fimc-lite subdev to gscaler subdev", __func__);
 
         // gscaler subdev to gscaler video dev
         for (i = 0; i < m_gscVdEntity->num_links; i++) {
             links = &m_gscVdEntity->links[i];
-            LOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_gscSdEntity : %p", __func__, i,
+            ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_gscSdEntity : %p", __func__, i,
                     links->source->entity, m_gscSdEntity);
-            LOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_gscVdEntity : %p", __func__, i,
+            ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_gscVdEntity : %p", __func__, i,
                     links->sink->entity, m_gscVdEntity);
             if (links == NULL ||
                 links->source->entity != m_gscSdEntity ||
                 links->sink->entity != m_gscVdEntity) {
                 continue;
             } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
-                LOGE("ERR(%s):Cannot make setup gscaler subdev to gscaler video dev", __func__);
+                ALOGE("ERR(%s):Cannot make setup gscaler subdev to gscaler video dev", __func__);
                 goto err;
             }
         }
-        LOGV("DEBUG(%s):[LINK SUCCESS] gscaler subdev to gscaler video dev", __func__);
+        ALOGV("DEBUG(%s):[LINK SUCCESS] gscaler subdev to gscaler video dev", __func__);
 
         sprintf(node, "%s%d", PFX_NODE, (FLITE_VD_NODE_OFFSET + VIDEO_NODE_PREVIEW_ID));
         m_fliteDev.fd = exynos_v4l2_open(node, O_RDWR, 0);
         if (m_fliteDev.fd <= 0) {
-            LOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno));
+            ALOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno));
             goto err;
         }
         m_previewDev = &m_fliteDev;
@@ -1019,7 +1019,7 @@ bool ExynosCamera::create(int cameraId)
     m_flagAutoFocusRunning = false;
 
     if (exynos_v4l2_enuminput(m_previewDev->fd, m_cameraId, m_cameraName) == false) {
-        LOGE("ERR(%s):exynos_v4l2_enuminput(%d, %s) fail", __func__, m_cameraId, m_cameraName);
+        ALOGE("ERR(%s):exynos_v4l2_enuminput(%d, %s) fail", __func__, m_cameraId, m_cameraName);
         goto err;
     }
 
@@ -1030,7 +1030,7 @@ bool ExynosCamera::create(int cameraId)
         strcpy(m_cameraName, "S5K6A3");
 
     if (exynos_v4l2_s_input(m_previewDev->fd, m_cameraId) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_s_input() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_s_input() fail", __func__);
         goto err;
     }
 
@@ -1044,7 +1044,7 @@ bool ExynosCamera::create(int cameraId)
         m_defaultCameraInfo  = new ExynosCameraInfoM5M0;
         m_curCameraInfo      = new ExynosCameraInfoM5M0;
     } else {
-        LOGE("ERR(%s):invalid camera Name (%s) fail", __func__, m_cameraName);
+        ALOGE("ERR(%s):invalid camera Name (%s) fail", __func__, m_cameraName);
         goto err;
     }
 
@@ -1084,7 +1084,7 @@ err:
 bool ExynosCamera::destroy(void)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created", __func__);
+        ALOGE("ERR(%s):Not yet created", __func__);
         return false;
     }
 
@@ -1161,7 +1161,7 @@ int ExynosCamera::getVideoFd(void)
 bool ExynosCamera::startPreview(void)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet Created", __func__);
+        ALOGE("ERR(%s):Not yet Created", __func__);
         return false;
     }
 
@@ -1174,23 +1174,23 @@ bool ExynosCamera::startPreview(void)
                              m_curCameraInfo->previewColorFormat,
                              m_previewBuf,
                              m_validPreviewBuf) == false) {
-            LOGE("ERR(%s):m_setWidthHeight() fail", __func__);
+            ALOGE("ERR(%s):m_setWidthHeight() fail", __func__);
             return false;
         }
 
         if (setPreviewFrameRate(m_curCameraInfo->fps) == false)
-            LOGE("ERR(%s):Fail toggle setPreviewFrameRate(%d)",
+            ALOGE("ERR(%s):Fail toggle setPreviewFrameRate(%d)",
                 __func__, m_curCameraInfo->fps);
 
         if (exynos_v4l2_streamon(m_previewDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__);
             return false;
         }
 
         if (m_curCameraInfo->focusMode == FOCUS_MODE_CONTINUOUS_VIDEO
             || m_curCameraInfo->focusMode == FOCUS_MODE_CONTINUOUS_PICTURE) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_CAF_START_STOP, CAF_START) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -1204,19 +1204,19 @@ bool ExynosCamera::startPreview(void)
         bool toggle = getVideoStabilization();
 
         if (setVideoStabilization(toggle) == false)
-            LOGE("ERR(%s):setVideoStabilization() fail", __func__);
+            ALOGE("ERR(%s):setVideoStabilization() fail", __func__);
 #endif
 
 #ifdef USE_3DNR
         if (m_recordingHint == true && getCameraId() == CAMERA_ID_BACK) {
             if (set3DNR(true) == false)
-                LOGE("ERR(%s):set3DNR() fail", __func__);
+                ALOGE("ERR(%s):set3DNR() fail", __func__);
         }
 #endif
 
 #ifdef USE_ODC
         if (setODC(true) == false)
-            LOGE("ERR(%s):setODC() fail", __func__);
+            ALOGE("ERR(%s):setODC() fail", __func__);
 #endif
     }
 
@@ -1226,7 +1226,7 @@ bool ExynosCamera::startPreview(void)
 bool ExynosCamera::stopPreview(void)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet Created", __func__);
+        ALOGE("ERR(%s):Not yet Created", __func__);
         return false;
     }
 
@@ -1246,16 +1246,16 @@ bool ExynosCamera::stopPreview(void)
 /* Can not use 3DNR, ODC and DIS function because HW problem at exynos5250 EVT0 */
 #ifdef USE_3DNR
         if (set3DNR(false) == false)
-            LOGE("ERR(%s):set3DNR() fail", __func__);
+            ALOGE("ERR(%s):set3DNR() fail", __func__);
 #endif
 
 #ifdef USE_ODC
         if (setODC(false) == false)
-            LOGE("ERR(%s):setODC() fail", __func__);
+            ALOGE("ERR(%s):setODC() fail", __func__);
 #endif
 
         if (exynos_v4l2_streamoff(m_previewDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__);
             return false;
         }
 
@@ -1265,7 +1265,7 @@ bool ExynosCamera::stopPreview(void)
         req.memory = V4L2_MEMORY_USERPTR;
 
         if (exynos_v4l2_reqbufs(m_previewDev->fd, &req) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__);
             return false;
         }
 
@@ -1290,12 +1290,12 @@ int ExynosCamera::getPreviewMaxBuf(void)
 bool ExynosCamera::setPreviewBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
     if (VIDEO_MAX_FRAME <= buf->reserved.p) {
-        LOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME);
+        ALOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME);
         return false;
     }
 
@@ -1311,12 +1311,12 @@ bool ExynosCamera::setPreviewBuf(ExynosBuffer *buf)
 bool ExynosCamera::getPreviewBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
     if (m_previewDev->flagStart == false) {
-        LOGE("ERR(%s):Not yet preview started fail", __func__);
+        ALOGE("ERR(%s):Not yet preview started fail", __func__);
         return false;
     }
 
@@ -1334,12 +1334,12 @@ bool ExynosCamera::getPreviewBuf(ExynosBuffer *buf)
     }
 
     if (exynos_v4l2_dqbuf(m_previewDev->fd, &v4l2_buf) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__);
         return false;
     }
 
     if (VIDEO_MAX_FRAME <= v4l2_buf.index) {
-        LOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index);
+        ALOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index);
         return false;
     }
 
@@ -1351,12 +1351,12 @@ bool ExynosCamera::getPreviewBuf(ExynosBuffer *buf)
 bool ExynosCamera::putPreviewBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
     if (m_validPreviewBuf[buf->reserved.p] == false) {
-        LOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p);
+        ALOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p);
         return false;
     }
 
@@ -1378,7 +1378,7 @@ bool ExynosCamera::putPreviewBuf(ExynosBuffer *buf)
     }
 
     if (exynos_v4l2_qbuf(m_previewDev->fd, &v4l2_buf) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__);
         return false;
     }
 
@@ -1419,7 +1419,7 @@ int ExynosCamera::getVideoFormat(void)
 bool ExynosCamera::startVideo(void)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet Created", __func__);
+        ALOGE("ERR(%s):Not yet Created", __func__);
         return false;
     }
 
@@ -1433,12 +1433,12 @@ bool ExynosCamera::startVideo(void)
                              m_curCameraInfo->videoColorFormat,
                              m_videoBuf,
                              m_validVideoBuf) == false) {
-            LOGE("ERR(%s):m_setWidthHeight() fail", __func__);
+            ALOGE("ERR(%s):m_setWidthHeight() fail", __func__);
             return false;
         }
 
         if (exynos_v4l2_streamon(m_videoDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__);
             return false;
         }
 
@@ -1453,7 +1453,7 @@ bool ExynosCamera::startVideo(void)
 bool ExynosCamera::stopVideo(void)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet Created", __func__);
+        ALOGE("ERR(%s):Not yet Created", __func__);
         return false;
     }
 
@@ -1467,7 +1467,7 @@ bool ExynosCamera::stopVideo(void)
             return true;
 
         if (exynos_v4l2_streamoff(m_videoDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__);
             return false;
         }
         struct v4l2_requestbuffers req;
@@ -1476,7 +1476,7 @@ bool ExynosCamera::stopVideo(void)
         req.memory = V4L2_MEMORY_USERPTR;
 
         if (exynos_v4l2_reqbufs(m_videoDev->fd, &req) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__);
             return false;
         }
 
@@ -1499,12 +1499,12 @@ int ExynosCamera::getVideoMaxBuf(void)
 bool ExynosCamera::setVideoBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
     if (VIDEO_MAX_FRAME <= buf->reserved.p) {
-        LOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME);
+        ALOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME);
         return false;
     }
 
@@ -1515,12 +1515,12 @@ bool ExynosCamera::setVideoBuf(ExynosBuffer *buf)
 bool ExynosCamera::getVideoBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
     if (m_videoDev->flagStart == false) {
-        LOGE("ERR(%s):Not yet video started fail", __func__);
+        ALOGE("ERR(%s):Not yet video started fail", __func__);
         return false;
     }
 
@@ -1538,12 +1538,12 @@ bool ExynosCamera::getVideoBuf(ExynosBuffer *buf)
     }
 
     if (exynos_v4l2_dqbuf(m_videoDev->fd, &v4l2_buf) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__);
         return false;
     }
 
     if (VIDEO_MAX_FRAME <= v4l2_buf.index) {
-        LOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index);
+        ALOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index);
         return false;
     }
 
@@ -1555,7 +1555,7 @@ bool ExynosCamera::getVideoBuf(ExynosBuffer *buf)
 bool ExynosCamera::putVideoBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
@@ -1566,12 +1566,12 @@ bool ExynosCamera::putVideoBuf(ExynosBuffer *buf)
          * cases where fimc could crash if we called qbuf and it
          * wasn't expecting it.
          */
-        LOGV("DEBUG(%s):recording not in progress, ignoring", __func__);
+        ALOGV("DEBUG(%s):recording not in progress, ignoring", __func__);
         return true;
     }
 
     if (m_validVideoBuf[buf->reserved.p] == false) {
-        LOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p);
+        ALOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p);
         return false;
     }
 
@@ -1593,7 +1593,7 @@ bool ExynosCamera::putVideoBuf(ExynosBuffer *buf)
     }
 
     if (exynos_v4l2_qbuf(m_videoDev->fd, &v4l2_buf) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__);
         return false;
     }
 
@@ -1603,7 +1603,7 @@ bool ExynosCamera::putVideoBuf(ExynosBuffer *buf)
 bool ExynosCamera::startPicture(void)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet Created", __func__);
+        ALOGE("ERR(%s):Not yet Created", __func__);
         return false;
     }
 
@@ -1616,12 +1616,12 @@ bool ExynosCamera::startPicture(void)
                              m_curCameraInfo->pictureColorFormat,
                              m_pictureBuf,
                              m_validPictureBuf) == false) {
-            LOGE("ERR(%s):m_setWidthHeight() fail", __func__);
+            ALOGE("ERR(%s):m_setWidthHeight() fail", __func__);
             return false;
         }
 
         if (exynos_v4l2_streamon(m_pictureDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__);
             return false;
         }
 
@@ -1635,7 +1635,7 @@ bool ExynosCamera::startPicture(void)
 bool ExynosCamera::stopPicture(void)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet Created", __func__);
+        ALOGE("ERR(%s):Not yet Created", __func__);
         return false;
     }
 
@@ -1649,7 +1649,7 @@ bool ExynosCamera::stopPicture(void)
             return true;
 
         if (exynos_v4l2_streamoff(m_pictureDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__);
             return false;
         }
 
@@ -1659,7 +1659,7 @@ bool ExynosCamera::stopPicture(void)
         req.memory = V4L2_MEMORY_USERPTR;
 
         if (exynos_v4l2_reqbufs(m_pictureDev->fd, &req) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__);
             return false;
         }
 
@@ -1682,12 +1682,12 @@ int ExynosCamera::getPictureMaxBuf(void)
 bool ExynosCamera::setPictureBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
     if (VIDEO_MAX_FRAME <= buf->reserved.p) {
-        LOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME);
+        ALOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME);
         return false;
     }
 
@@ -1698,12 +1698,12 @@ bool ExynosCamera::setPictureBuf(ExynosBuffer *buf)
 bool ExynosCamera::getPictureBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
     if (m_pictureDev->flagStart == false) {
-        LOGE("ERR(%s):Not yet picture started fail", __func__);
+        ALOGE("ERR(%s):Not yet picture started fail", __func__);
         return false;
     }
 
@@ -1721,12 +1721,12 @@ bool ExynosCamera::getPictureBuf(ExynosBuffer *buf)
     }
 
     if (exynos_v4l2_dqbuf(m_pictureDev->fd, &v4l2_buf) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__);
         return false;
     }
 
     if (VIDEO_MAX_FRAME <= v4l2_buf.index) {
-        LOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index);
+        ALOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index);
         return false;
     }
 
@@ -1738,17 +1738,17 @@ bool ExynosCamera::getPictureBuf(ExynosBuffer *buf)
 bool ExynosCamera::putPictureBuf(ExynosBuffer *buf)
 {
     if (m_flagCreate == false) {
-        LOGE("ERR(%s):Not yet created fail", __func__);
+        ALOGE("ERR(%s):Not yet created fail", __func__);
         return false;
     }
 
     if (m_pictureDev->flagStart == false) {
-        LOGE("ERR(%s):Not yet picture started fail", __func__);
+        ALOGE("ERR(%s):Not yet picture started fail", __func__);
         return false;
     }
 
     if (m_validPictureBuf[buf->reserved.p] == false) {
-        LOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p);
+        ALOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p);
         return false;
     }
 
@@ -1770,7 +1770,7 @@ bool ExynosCamera::putPictureBuf(ExynosBuffer *buf)
     }
 
     if (exynos_v4l2_qbuf(m_pictureDev->fd, &v4l2_buf) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__);
         return false;
     }
 
@@ -1789,40 +1789,40 @@ bool ExynosCamera::yuv2Jpeg(ExynosBuffer *yuvBuf,
     unsigned int *yuvSize = yuvBuf->size.extS;
 
     if (jpegEnc.create()) {
-        LOGE("ERR(%s):jpegEnc.create() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.create() fail", __func__);
         goto jpeg_encode_done;
     }
 
     if (jpegEnc.setQuality(m_jpegQuality)) {
-        LOGE("ERR(%s):jpegEnc.setQuality() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.setQuality() fail", __func__);
         goto jpeg_encode_done;
     }
 
     if (jpegEnc.setSize(rect->w, rect->h)) {
-        LOGE("ERR(%s):jpegEnc.setSize() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.setSize() fail", __func__);
         goto jpeg_encode_done;
     }
 
     if (jpegEnc.setColorFormat(rect->colorFormat)) {
-        LOGE("ERR(%s):jpegEnc.setColorFormat() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.setColorFormat() fail", __func__);
         goto jpeg_encode_done;
     }
 
     if (jpegEnc.setJpegFormat(V4L2_PIX_FMT_JPEG_422)) {
-        LOGE("ERR(%s):jpegEnc.setJpegFormat() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.setJpegFormat() fail", __func__);
         goto jpeg_encode_done;
     }
 
     if (m_curCameraInfo->thumbnailW != 0 && m_curCameraInfo->thumbnailH != 0) {
         mExifInfo.enableThumb = true;
         if (jpegEnc.setThumbnailSize(m_curCameraInfo->thumbnailW, m_curCameraInfo->thumbnailH)) {
-            LOGE("ERR(%s):jpegEnc.setThumbnailSize(%d, %d) fail", __func__, m_curCameraInfo->thumbnailW, m_curCameraInfo->thumbnailH);
+            ALOGE("ERR(%s):jpegEnc.setThumbnailSize(%d, %d) fail", __func__, m_curCameraInfo->thumbnailW, m_curCameraInfo->thumbnailH);
             goto jpeg_encode_done;
         }
 
         if (0 < m_jpegThumbnailQuality && m_jpegThumbnailQuality <= 100) {
             if (jpegEnc.setThumbnailQuality(m_jpegThumbnailQuality)) {
-                LOGE("ERR(%s):jpegEnc.setThumbnailSize(%d, %d) fail", __func__, m_curCameraInfo->thumbnailW, m_curCameraInfo->thumbnailH);
+                ALOGE("ERR(%s):jpegEnc.setThumbnailSize(%d, %d) fail", __func__, m_curCameraInfo->thumbnailW, m_curCameraInfo->thumbnailH);
                 goto jpeg_encode_done;
             }
         }
@@ -1833,22 +1833,22 @@ bool ExynosCamera::yuv2Jpeg(ExynosBuffer *yuvBuf,
     }
 
     if (jpegEnc.setInBuf((char **)&(yuvBuf->virt.p), (int *)yuvSize)) {
-        LOGE("ERR(%s):jpegEnc.setInBuf() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.setInBuf() fail", __func__);
         goto jpeg_encode_done;
     }
 
     if (jpegEnc.setOutBuf(jpegBuf->virt.p, jpegBuf->size.extS[0] + jpegBuf->size.extS[1] + jpegBuf->size.extS[2])) {
-        LOGE("ERR(%s):jpegEnc.setOutBuf() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.setOutBuf() fail", __func__);
         goto jpeg_encode_done;
     }
 
     if (jpegEnc.updateConfig()) {
-        LOGE("ERR(%s):jpegEnc.updateConfig() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.updateConfig() fail", __func__);
         goto jpeg_encode_done;
     }
 
     if (jpegEnc.encode((int *)&jpegBuf->size.s, &mExifInfo)) {
-        LOGE("ERR(%s):jpegEnc.encode() fail", __func__);
+        ALOGE("ERR(%s):jpegEnc.encode() fail", __func__);
         goto jpeg_encode_done;
     }
 
@@ -1865,12 +1865,12 @@ jpeg_encode_done:
 bool ExynosCamera::autoFocus(void)
 {
     if (m_previewDev->fd <= 0) {
-        LOGE("ERR(%s):Camera was closed", __func__);
+        ALOGE("ERR(%s):Camera was closed", __func__);
         return false;
     }
 
     if (m_flagAutoFocusRunning == true) {
-        LOGD("DEBUG(%s):m_flagAutoFocusRunning == true", __func__);
+        ALOGD("DEBUG(%s):m_flagAutoFocusRunning == true", __func__);
         return true;
     }
 
@@ -1880,12 +1880,12 @@ bool ExynosCamera::autoFocus(void)
     case FOCUS_MODE_MACRO:
         if (m_touchAFMode == true) {
             if (setFocusMode(FOCUS_MODE_TOUCH) == false) {
-                LOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__);
+                ALOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__);
                 return false;
             }
         } else {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -1897,7 +1897,7 @@ bool ExynosCamera::autoFocus(void)
         break;
     case FOCUS_MODE_TOUCH:
         if (setFocusMode(FOCUS_MODE_TOUCH) == false) {
-            LOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__);
+            ALOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__);
             return false;
         }
         break;
@@ -1905,7 +1905,7 @@ bool ExynosCamera::autoFocus(void)
         break;
     case FOCUS_MODE_EDOF:
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, m_curCameraInfo->focusMode);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, m_curCameraInfo->focusMode);
         return false;
         break;
     }
@@ -1918,12 +1918,12 @@ bool ExynosCamera::autoFocus(void)
 bool ExynosCamera::cancelAutoFocus(void)
 {
     if (m_previewDev->fd <= 0) {
-        LOGE("ERR(%s):Camera was closed", __func__);
+        ALOGE("ERR(%s):Camera was closed", __func__);
         return false;
     }
 
     if (m_flagAutoFocusRunning == false) {
-        LOGV("DEBUG(%s):m_flagAutoFocusRunning == false", __func__);
+        ALOGV("DEBUG(%s):m_flagAutoFocusRunning == false", __func__);
         return true;
     }
 
@@ -1932,7 +1932,7 @@ bool ExynosCamera::cancelAutoFocus(void)
     case FOCUS_MODE_INFINITY:
     case FOCUS_MODE_MACRO:
         if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
             return false;
         }
         break;
@@ -1943,7 +1943,7 @@ bool ExynosCamera::cancelAutoFocus(void)
         break;
     case FOCUS_MODE_TOUCH:
         if (setFocusMode(FOCUS_MODE_TOUCH) == false) {
-            LOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__);
+            ALOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__);
             return false;
         }
         m_touchAFMode = false;
@@ -1952,7 +1952,7 @@ bool ExynosCamera::cancelAutoFocus(void)
         break;
     case FOCUS_MODE_EDOF:
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, m_curCameraInfo->focusMode);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, m_curCameraInfo->focusMode);
         return false;
         break;
     }
@@ -1975,7 +1975,7 @@ int ExynosCamera::getFucusModeResult(void)
             return -1;
 
         if (exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT, &ret) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__);
             return -1;
         }
 
@@ -2028,27 +2028,27 @@ int ExynosCamera::getFucusModeResult(void)
 bool ExynosCamera::startFaceDetection(void)
 {
     if (m_flagStartFaceDetection == true) {
-        LOGD("DEBUG(%s):Face detection already started..", __func__);
+        ALOGD("DEBUG(%s):Face detection already started..", __func__);
         return true;
     }
 
     if (m_previewDev->flagStart == true) {
         //if (this->setFocusMode(FOCUS_MODE_AUTO) == false)
-        //    LOGE("ERR(%s):Fail setFocusMode", __func__);
+        //    ALOGE("ERR(%s):Fail setFocusMode", __func__);
 
         if (m_internalISP == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_FD_SET_MAX_FACE_NUMBER, m_defaultCameraInfo->maxNumDetectedFaces) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
 
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CMD_FD, IS_FD_COMMAND_START) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         } else {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FACE_DETECTION, FACE_DETECTION_ON) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -2060,19 +2060,19 @@ bool ExynosCamera::startFaceDetection(void)
 bool ExynosCamera::stopFaceDetection(void)
 {
     if (m_flagStartFaceDetection == false) {
-        LOGD("DEBUG(%s):Face detection already stopped..", __func__);
+        ALOGD("DEBUG(%s):Face detection already stopped..", __func__);
         return true;
     }
 
     if (m_previewDev->flagStart == true) {
         if (m_internalISP == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CMD_FD, IS_FD_COMMAND_STOP) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         } else {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FACE_DETECTION, FACE_DETECTION_OFF) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -2091,7 +2091,7 @@ bool ExynosCamera::setFaceDetectLock(bool toggle)
     int lock = (toggle == true) ? 1 : 0;
 
     if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK, lock) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
         return false;
     }
     return true;
@@ -2100,7 +2100,7 @@ bool ExynosCamera::setFaceDetectLock(bool toggle)
 bool ExynosCamera::startSmoothZoom(int value)
 {
     if (m_defaultCameraInfo->hwZoomSupported == false) {
-        LOGE("ERR(%s):m_defaultCameraInfo->hwZoomSupported == false", __func__);
+        ALOGE("ERR(%s):m_defaultCameraInfo->hwZoomSupported == false", __func__);
         return false;
     }
 
@@ -2142,12 +2142,12 @@ int ExynosCamera::getDetectedFacesAreas(int num,
                                         ExynosRect *mouth)
 {
     if (m_defaultCameraInfo->maxNumDetectedFaces == 0) {
-        LOGE("ERR(%s):maxNumDetectedFaces == 0 fail", __func__);
+        ALOGE("ERR(%s):maxNumDetectedFaces == 0 fail", __func__);
         return -1;
     }
 
     if (m_flagStartFaceDetection == false) {
-        LOGD("DEBUG(%s):m_flagStartFaceDetection == false", __func__);
+        ALOGD("DEBUG(%s):m_flagStartFaceDetection == false", __func__);
         return 0;
     }
 
@@ -2200,12 +2200,12 @@ int ExynosCamera::getDetectedFacesAreas(int num,
                                      ExynosRect2 *mouth)
 {
     if (m_defaultCameraInfo->maxNumDetectedFaces == 0) {
-        LOGE("ERR(%s):maxNumDetectedFaces == 0 fail", __func__);
+        ALOGE("ERR(%s):maxNumDetectedFaces == 0 fail", __func__);
         return -1;
     }
 
     if (m_flagStartFaceDetection == false) {
-        LOGD("DEBUG(%s):m_flagStartFaceDetection == false", __func__);
+        ALOGD("DEBUG(%s):m_flagStartFaceDetection == false", __func__);
         return 0;
     }
 
@@ -2273,7 +2273,7 @@ int ExynosCamera::getDetectedFacesAreas(int num,
     fd_ctrls.controls = fd_ctrl;
 
     if (exynos_v4l2_g_ext_ctrl(m_previewDev->fd, &fd_ctrls) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_g_ext_ctrl() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_g_ext_ctrl() fail", __func__);
         num = -1;
         goto done;
     }
@@ -2618,19 +2618,19 @@ bool ExynosCamera::setAntibanding(int value)
         internalValue = ::ANTI_BANDING_OFF;
         break;
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, value);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, value);
         return false;
         break;
     }
 
     if (m_internalISP == true) {
         if (internalValue < ::IS_AFC_DISABLE || ::IS_AFC_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid value (%d)", __func__, value);
+            ALOGE("ERR(%s):Invalid value (%d)", __func__, value);
             return false;
         }
     } else {
         if (internalValue < ::ANTI_BANDING_AUTO || ::ANTI_BANDING_OFF < internalValue) {
-            LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
             return false;
         }
     }
@@ -2639,7 +2639,7 @@ bool ExynosCamera::setAntibanding(int value)
         m_curCameraInfo->antiBanding = value;
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_AFC_MODE, internalValue) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -2668,7 +2668,7 @@ bool ExynosCamera::setAutoExposureLock(bool toggle)
 
     if (m_flagCreate == true) {
         if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, internalValue) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
             return false;
         }
     }
@@ -2695,7 +2695,7 @@ bool ExynosCamera::setAutoWhiteBalanceLock(bool toggle)
 
     if (m_flagCreate == true) {
         if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, internalValue) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
             return false;
         }
     }
@@ -2734,19 +2734,19 @@ bool ExynosCamera::setColorEffect(int value)
     case EFFECT_WHITEBOARD:
     case EFFECT_BLACKBOARD:
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, value);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, value);
         return false;
         break;
     }
 
     if (m_internalISP == true) {
         if (internalValue < ::IS_IMAGE_EFFECT_DISABLE || ::IS_IMAGE_EFFECT_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
             return false;
         }
     } else {
         if (internalValue <= ::IMAGE_EFFECT_BASE || ::IMAGE_EFFECT_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
             return false;
         }
     }
@@ -2756,12 +2756,12 @@ bool ExynosCamera::setColorEffect(int value)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_IMAGE_EFFECT, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_EFFECT, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -2778,13 +2778,13 @@ bool ExynosCamera::setExposureCompensation(int value)
     if (m_internalISP == true) {
         internalValue += IS_EXPOSURE_DEFAULT;
         if (internalValue < IS_EXPOSURE_MINUS_2 || IS_EXPOSURE_PLUS_2 < internalValue) {
-            LOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
             return false;
         }
     } else {
         internalValue += EV_DEFAULT;
         if (internalValue < EV_MINUS_4 || EV_PLUS_4 < internalValue) {
-            LOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
             return false;
         }
     }
@@ -2794,12 +2794,12 @@ bool ExynosCamera::setExposureCompensation(int value)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXPOSURE, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (this->setBrightness(value) == false) {
-                    LOGE("ERR(%s):setBrightness() fail", __func__);
+                    ALOGE("ERR(%s):setBrightness() fail", __func__);
                     return false;
                 }
             }
@@ -2828,13 +2828,13 @@ bool ExynosCamera::setFlashMode(int value)
         break;
     case FLASH_MODE_RED_EYE:
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, value);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, value);
         return false;
         break;
     }
 
     if (internalValue <= ::FLASH_MODE_BASE || ::FLASH_MODE_MAX <= internalValue) {
-        LOGE("ERR(%s):Invalid value (%d)", __func__, value);
+        ALOGE("ERR(%s):Invalid value (%d)", __func__, value);
         return false;
     }
 
@@ -2842,7 +2842,7 @@ bool ExynosCamera::setFlashMode(int value)
         m_curCameraInfo->flashMode = value;
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FLASH_MODE, internalValue) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -2854,7 +2854,7 @@ bool ExynosCamera::setFlashMode(int value)
 bool ExynosCamera::setFocusAreas(int num, ExynosRect* rects, int *weights)
 {
     if (m_defaultCameraInfo->maxNumFocusAreas == 0) {
-        LOGV("DEBUG(%s):maxNumFocusAreas is 0. so, ignored", __func__);
+        ALOGV("DEBUG(%s):maxNumFocusAreas is 0. so, ignored", __func__);
         return true;
     }
 
@@ -2874,7 +2874,7 @@ bool ExynosCamera::setFocusAreas(int num, ExynosRect* rects, int *weights)
 bool ExynosCamera::setFocusAreas(int num, ExynosRect2* rect2s, int *weights)
 {
     if (m_defaultCameraInfo->maxNumFocusAreas == 0) {
-        LOGV("DEBUG(%s):maxNumFocusAreas is 0. so, ignored", __func__);
+        ALOGV("DEBUG(%s):maxNumFocusAreas is 0. so, ignored", __func__);
         return true;
     }
 
@@ -2902,7 +2902,7 @@ bool ExynosCamera::setFocusAreas(int num, ExynosRect2* rect2s, int *weights)
             m_touchAFMode = true;
             if (   exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJECT_POSITION_X, new_x) < 0
                 && exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJECT_POSITION_Y, new_y) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -2944,13 +2944,13 @@ bool ExynosCamera::setFocusMode(int value)
     case FOCUS_MODE_EDOF:
     default:
         m_touchAFMode = false;
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, value);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, value);
         return false;
         break;
     }
 
     if (::FOCUS_MODE_MAX <= internalValue) {
-        LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+        ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
         return false;
     }
 
@@ -2958,7 +2958,7 @@ bool ExynosCamera::setFocusMode(int value)
         m_curCameraInfo->focusMode = value;
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FOCUS_MODE, internalValue) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -3037,7 +3037,7 @@ bool ExynosCamera::setGpsTimeStamp(const char *gpsTimestamp)
 bool ExynosCamera::setJpegQuality(int quality)
 {
     if (quality < JPEG_QUALITY_MIN || JPEG_QUALITY_MAX < quality) {
-        LOGE("ERR(%s):Invalid quality (%d)", __func__, quality);
+        ALOGE("ERR(%s):Invalid quality (%d)", __func__, quality);
         return false;
     }
 
@@ -3049,7 +3049,7 @@ bool ExynosCamera::setJpegQuality(int quality)
 bool ExynosCamera::setJpegThumbnailQuality(int quality)
 {
     if (quality < JPEG_QUALITY_MIN || JPEG_QUALITY_MAX < quality) {
-        LOGE("ERR(%s):Invalid quality (%d)", __func__, quality);
+        ALOGE("ERR(%s):Invalid quality (%d)", __func__, quality);
         return false;
     }
 
@@ -3068,7 +3068,7 @@ bool ExynosCamera::setJpegThumbnailSize(int w, int h)
 bool ExynosCamera::setMeteringAreas(int num, ExynosRect *rects, int *weights)
 {
     if (m_defaultCameraInfo->maxNumMeteringAreas == 0) {
-        LOGV("DEBUG(%s):maxNumMeteringAreas is 0. so, ignored", __func__);
+        ALOGV("DEBUG(%s):maxNumMeteringAreas is 0. so, ignored", __func__);
         return true;
     }
 
@@ -3081,7 +3081,7 @@ bool ExynosCamera::setMeteringAreas(int num, ExynosRect *rects, int *weights)
                 && exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING_POSITION_Y, rects[i].y) < 0
                 && exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING_WINDOW_X,   rects[i].w) < 0
                 && exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING_WINDOW_Y,   rects[i].h) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -3093,7 +3093,7 @@ bool ExynosCamera::setMeteringAreas(int num, ExynosRect *rects, int *weights)
 bool ExynosCamera::setMeteringAreas(int num, ExynosRect2 *rect2s, int *weights)
 {
     if (m_defaultCameraInfo->maxNumMeteringAreas == 0) {
-        LOGV("DEBUG(%s):maxNumMeteringAreas is 0. so, ignored", __func__);
+        ALOGV("DEBUG(%s):maxNumMeteringAreas is 0. so, ignored", __func__);
         return true;
     }
 
@@ -3147,12 +3147,12 @@ bool ExynosCamera::setPreviewFormat(int colorFormat)
 bool ExynosCamera::setPreviewFrameRate(int fps)
 {
     if (fps < FRAME_RATE_AUTO || FRAME_RATE_MAX < fps)
-        LOGE("ERR(%s):Invalid fps(%d)", __func__, fps);
+        ALOGE("ERR(%s):Invalid fps(%d)", __func__, fps);
 
     if (m_flagCreate == true) {
         m_curCameraInfo->fps = fps;
         if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FRAME_RATE, fps) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
             return false;
         }
     }
@@ -3178,7 +3178,7 @@ bool ExynosCamera::setRecordingHint(bool hint)
 bool ExynosCamera::setRotation(int rotation)
 {
      if (rotation < 0) {
-         LOGE("ERR(%s):Invalid rotation (%d)", __func__, rotation);
+         ALOGE("ERR(%s):Invalid rotation (%d)", __func__, rotation);
          return false;
      }
      m_curCameraInfo->rotation = rotation;
@@ -3236,13 +3236,13 @@ bool ExynosCamera::setSceneMode(int value)
     case SCENE_MODE_NIGHT_PORTRAIT:
     case SCENE_MODE_THEATRE:
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, value);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, value);
         return false;
         break;
     }
 
     if (internalValue <= ::SCENE_MODE_BASE || ::SCENE_MODE_MAX <= internalValue) {
-        LOGE("ERR(%s):Invalid value (%d)", __func__, internalValue);
+        ALOGE("ERR(%s):Invalid value (%d)", __func__, internalValue);
         return false;
     }
 
@@ -3250,7 +3250,7 @@ bool ExynosCamera::setSceneMode(int value)
         m_curCameraInfo->sceneMode = value;
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SCENE_MODE, internalValue) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -3269,7 +3269,7 @@ bool ExynosCamera::setVideoStabilization(bool toggle)
             int dis = (toggle == true) ? CAMERA_DIS_ON : CAMERA_DIS_OFF;
 
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_DIS, dis) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             } else {
                 m_curCameraInfo->applyVideoStabilization = toggle;
@@ -3318,19 +3318,19 @@ bool ExynosCamera::setWhiteBalance(int value)
     case WHITE_BALANCE_TWILIGHT:
     case WHITE_BALANCE_SHADE:
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, value);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, value);
         return false;
         break;
     }
 
     if (m_internalISP == true) {
         if (internalValue < ::IS_AWB_AUTO || ::IS_AWB_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
             return false;
         }
     } else {
         if (internalValue <= ::WHITE_BALANCE_BASE || ::WHITE_BALANCE_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
             return false;
         }
     }
@@ -3340,12 +3340,12 @@ bool ExynosCamera::setWhiteBalance(int value)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_AWB_MODE, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_WHITE_BALANCE, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -3358,7 +3358,7 @@ bool ExynosCamera::setWhiteBalance(int value)
 bool ExynosCamera::setZoom(int value)
 {
     if (value < ZOOM_LEVEL_0 || ZOOM_LEVEL_MAX <= value) {
-        LOGE("ERR(%s):Invalid value (%d)", __func__, value);
+        ALOGE("ERR(%s):Invalid value (%d)", __func__, value);
         return false;
     }
 
@@ -3367,13 +3367,13 @@ bool ExynosCamera::setZoom(int value)
         if (m_defaultCameraInfo->hwZoomSupported == true) {
             if (m_flagCreate == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_ZOOM, value) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
         } else {
             if (m_setZoom(m_previewDev->fd, m_curCameraInfo->zoom, m_curCameraInfo->previewW, m_curCameraInfo->previewH) == false) {
-                LOGE("ERR(%s):m_setZoom(%d) fail", __func__, m_curCameraInfo->zoom);
+                ALOGE("ERR(%s):m_setZoom(%d) fail", __func__, m_curCameraInfo->zoom);
                 return false;
             }
         }
@@ -3428,7 +3428,7 @@ bool ExynosCamera::m_setWidthHeight(int mode,
         v4l2_fmt.fmt.pix_mp.num_planes = planes;
 
         if (exynos_v4l2_s_fmt(fd, &v4l2_fmt) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_s_fmt() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_s_fmt() fail", __func__);
             return false;
         }
         break;
@@ -3444,7 +3444,7 @@ bool ExynosCamera::m_setWidthHeight(int mode,
         v4l2_fmt.fmt.pix = pixfmt;
 
         if (exynos_v4l2_s_fmt(fd, &v4l2_fmt) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_s_fmt() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_s_fmt() fail", __func__);
             return false;
         }
         break;
@@ -3458,7 +3458,7 @@ bool ExynosCamera::m_setWidthHeight(int mode,
     req.memory = V4L2_MEMORY_USERPTR;
 
     if (exynos_v4l2_reqbufs(fd, &req) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_reqbufs(%d) fail", __func__, numOfBuf);
+        ALOGE("ERR(%s):exynos_v4l2_reqbufs(%d) fail", __func__, numOfBuf);
         return false;
     }
 
@@ -3483,7 +3483,7 @@ bool ExynosCamera::m_setWidthHeight(int mode,
             }
 
             if (exynos_v4l2_qbuf(fd, &v4l2_buf) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_qbuf(%d) fail", __func__, i);
+                ALOGE("ERR(%s):exynos_v4l2_qbuf(%d) fail", __func__, i);
                 return false;
             }
         }
@@ -3493,7 +3493,7 @@ bool ExynosCamera::m_setWidthHeight(int mode,
     m_currentZoom = -1;
 
     if (m_setZoom(fd, m_curCameraInfo->zoom, w, h) == false)
-        LOGE("ERR(%s):m_setZoom(%d, %d) fail", __func__, mode, m_curCameraInfo->zoom);
+        ALOGE("ERR(%s):m_setZoom(%d, %d) fail", __func__, mode, m_curCameraInfo->zoom);
     */
     return true;
 }
@@ -3514,7 +3514,7 @@ bool ExynosCamera::m_setZoom(int fd, int zoom, int w, int h)
 
         ret = m_setCrop(fd, w, h, real_zoom);
         if (ret == false)
-            LOGE("ERR(%s):m_setCrop(%d, %d) fail", __func__, w, h);
+            ALOGE("ERR(%s):m_setCrop(%d, %d) fail", __func__, w, h);
     }
 
     return ret;
@@ -3532,7 +3532,7 @@ bool ExynosCamera::m_setCrop(int fd, int w, int h, int zoom)
     cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
     if (exynos_v4l2_cropcap(fd, &cropcap) < 0)  {
-        LOGE("ERR(%s):exynos_v4l2_cropcap() fail)", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_cropcap() fail)", __func__);
         return false;
     }
 
@@ -3550,24 +3550,24 @@ bool ExynosCamera::m_setCrop(int fd, int w, int h, int zoom)
     crop.c    = cropcap.defrect;
 
     if (exynos_v4l2_s_crop(fd, &crop) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_s_crop() fail(%d))", __func__, zoom);
+        ALOGE("ERR(%s):exynos_v4l2_s_crop() fail(%d))", __func__, zoom);
         return false;
     }
 
     /*
-    LOGD("## 1 w                     : %d", w);
-    LOGD("## 1 h                     : %d", h);
-    LOGD("## 1 zoom                  : %d", zoom);
-    LOGD("## 1 cropcap.bounds.w      : %d", cropcap.bounds.width);
-    LOGD("## 1 cropcap.bounds.h      : %d", cropcap.bounds.height);
-    LOGD("## 2 crop_x                : %d", crop_x);
-    LOGD("## 2 crop_y                : %d", crop_y);
-    LOGD("## 2 crop_w                : %d", crop_w);
-    LOGD("## 2 crop_h                : %d", crop_h);
-    LOGD("## 2 cropcap.defrect.left  : %d", cropcap.defrect.left);
-    LOGD("## 2 cropcap.defrect.top   : %d", cropcap.defrect.top);
-    LOGD("## 2 cropcap.defrect.width : %d", cropcap.defrect.width);
-    LOGD("## 2 cropcap.defrect.height: %d", cropcap.defrect.height);
+    ALOGD("## 1 w                     : %d", w);
+    ALOGD("## 1 h                     : %d", h);
+    ALOGD("## 1 zoom                  : %d", zoom);
+    ALOGD("## 1 cropcap.bounds.w      : %d", cropcap.bounds.width);
+    ALOGD("## 1 cropcap.bounds.h      : %d", cropcap.bounds.height);
+    ALOGD("## 2 crop_x                : %d", crop_x);
+    ALOGD("## 2 crop_y                : %d", crop_y);
+    ALOGD("## 2 crop_w                : %d", crop_w);
+    ALOGD("## 2 crop_h                : %d", crop_h);
+    ALOGD("## 2 cropcap.defrect.left  : %d", cropcap.defrect.left);
+    ALOGD("## 2 cropcap.defrect.top   : %d", cropcap.defrect.top);
+    ALOGD("## 2 cropcap.defrect.width : %d", cropcap.defrect.width);
+    ALOGD("## 2 cropcap.defrect.height: %d", cropcap.defrect.height);
     */
 
     return true;
@@ -3750,7 +3750,7 @@ void ExynosCamera::m_setExifChangedAttribute(exif_attribute_t *exifInfo, ExynosR
        odd value into exif for now */
     if (   exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXIF_SHUTTERSPEED, &shutterSpeed) < 0
         || shutterSpeed < 0) {
-        LOGE("ERR(%s):exynos_v4l2_g_ctrl() fail, using 100", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail, using 100", __func__);
         shutterSpeed = 100;
     }
 
@@ -3766,7 +3766,7 @@ void ExynosCamera::m_setExifChangedAttribute(exif_attribute_t *exifInfo, ExynosR
        odd value into exif for now */
     if (   exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXIF_ISO, &iso) < 0
         || iso < 0) {
-        LOGE("ERR(%s):exynos_v4l2_g_ctrl() fail, using ISO_100", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail, using ISO_100", __func__);
         iso = ISO_100;
     }
 
@@ -3800,8 +3800,8 @@ void ExynosCamera::m_setExifChangedAttribute(exif_attribute_t *exifInfo, ExynosR
     sv = APEX_ISO_TO_FILMSENSITIVITY(exifInfo->iso_speed_rating);
     bv = av + tv - sv;
     ev = av + tv;
-    LOGD("Shutter speed=%d us, iso=%d", shutterSpeed, exifInfo->iso_speed_rating);
-    LOGD("AV=%d, TV=%d, SV=%d", av, tv, sv);
+    ALOGD("Shutter speed=%d us, iso=%d", shutterSpeed, exifInfo->iso_speed_rating);
+    ALOGD("AV=%d, TV=%d, SV=%d", av, tv, sv);
 
     //3 Shutter Speed
     exifInfo->shutter_speed.num = tv * EXIF_DEF_APEX_DEN;
@@ -3947,40 +3947,40 @@ void ExynosCamera::m_printFormat(int colorFormat, const char *arg)
 {
     switch (colorFormat) {
     case V4L2_PIX_FMT_YUV420:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_YUV420", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUV420", arg);
         break;
     case V4L2_PIX_FMT_YVU420:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_YVU420", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_YVU420", arg);
         break;
     case V4L2_PIX_FMT_YVU420M:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_YVU420M", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_YVU420M", arg);
         break;
     case V4L2_PIX_FMT_NV12M:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_NV12M", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12M", arg);
         break;
     case V4L2_PIX_FMT_NV12:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_NV12", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12", arg);
         break;
     case V4L2_PIX_FMT_NV12T:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_NV12T", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12T", arg);
         break;
     case V4L2_PIX_FMT_NV21:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_NV21", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV21", arg);
         break;
     case V4L2_PIX_FMT_YUV422P:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_YUV422PP", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUV422PP", arg);
         break;
     case V4L2_PIX_FMT_YUYV:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_YUYV", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUYV", arg);
         break;
     case V4L2_PIX_FMT_UYVY:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_UYVYI", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_UYVYI", arg);
         break;
     case V4L2_PIX_FMT_RGB565:
-        LOGV("DEBUG(%s):V4L2_PIX_FMT_RGB565", arg);
+        ALOGV("DEBUG(%s):V4L2_PIX_FMT_RGB565", arg);
         break;
     default:
-        LOGV("DEBUG(%s):Unknown Format", arg);
+        ALOGV("DEBUG(%s):Unknown Format", arg);
         break;
     }
 }
@@ -4015,13 +4015,13 @@ bool ExynosCamera::setAngle(int angle)
             break;
 
         default:
-            LOGE("ERR(%s):Invalid angle(%d)", __func__, angle);
+            ALOGE("ERR(%s):Invalid angle(%d)", __func__, angle);
             return false;
         }
 
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_ROTATION, angle) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -4065,7 +4065,7 @@ bool ExynosCamera::setISO(int iso)
     }
 
     if (internalValue < ISO_AUTO || ISO_MAX <= internalValue) {
-        LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+        ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
         return false;
     }
 
@@ -4074,12 +4074,12 @@ bool ExynosCamera::setISO(int iso)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_ISO, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_ISO, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -4103,7 +4103,7 @@ bool ExynosCamera::setContrast(int value)
         if (m_internalISP == true)
             internalValue = ::IS_CONTRAST_AUTO;
         else
-            LOGW("WARN(%s):Invalid contrast value (%d)", __func__, value);
+            ALOGW("WARN(%s):Invalid contrast value (%d)", __func__, value);
             return true;
         break;
     case CONTRAST_MINUS_2:
@@ -4137,19 +4137,19 @@ bool ExynosCamera::setContrast(int value)
             internalValue = ::CONTRAST_PLUS_2;
         break;
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, value);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, value);
         return false;
         break;
     }
 
     if (m_internalISP == true) {
         if (internalValue < ::IS_CONTRAST_AUTO || ::IS_CONTRAST_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
             return false;
         }
     } else {
         if (internalValue < ::CONTRAST_MINUS_2 || ::CONTRAST_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
             return false;
         }
     }
@@ -4159,12 +4159,12 @@ bool ExynosCamera::setContrast(int value)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_CONTRAST, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_CONTRAST, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -4183,7 +4183,7 @@ bool ExynosCamera::setSaturation(int saturation)
 {
     int internalValue = saturation + SATURATION_DEFAULT;
     if (internalValue < SATURATION_MINUS_2 || SATURATION_MAX <= internalValue) {
-        LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+        ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
         return false;
     }
 
@@ -4192,12 +4192,12 @@ bool ExynosCamera::setSaturation(int saturation)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SATURATION, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SATURATION, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -4216,7 +4216,7 @@ bool ExynosCamera::setSharpness(int sharpness)
 {
     int internalValue = sharpness + SHARPNESS_DEFAULT;
     if (internalValue < SHARPNESS_MINUS_2 || SHARPNESS_MAX <= internalValue) {
-        LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+        ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
         return false;
     }
 
@@ -4225,12 +4225,12 @@ bool ExynosCamera::setSharpness(int sharpness)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SHARPNESS, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SHARPNESS, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -4252,11 +4252,11 @@ bool ExynosCamera::setHue(int hue)
     if (m_internalISP == true) {
         internalValue += IS_HUE_DEFAULT;
         if (internalValue < IS_HUE_MINUS_2 || IS_HUE_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid hue (%d)", __func__, hue);
+            ALOGE("ERR(%s):Invalid hue (%d)", __func__, hue);
             return false;
         }
     } else {
-            LOGV("WARN(%s):Not supported hue setting", __func__);
+            ALOGV("WARN(%s):Not supported hue setting", __func__);
             return true;
     }
 
@@ -4264,7 +4264,7 @@ bool ExynosCamera::setHue(int hue)
         m_curCameraInfo->hue = hue;
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_HUE, internalValue) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -4299,12 +4299,12 @@ bool ExynosCamera::setWDR(bool toggle)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_SET_DRC, internalWdr) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_WDR, internalWdr) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -4330,7 +4330,7 @@ bool ExynosCamera::setAntiShake(bool toggle)
         m_curCameraInfo->antiShake = toggle;
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_ANTI_SHAKE, internalValue) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -4374,19 +4374,19 @@ bool ExynosCamera::setMeteringMode(int value)
             internalValue = METERING_SPOT;
         break;
     default:
-        LOGE("ERR(%s):Unsupported value(%d)", __func__, value);
+        ALOGE("ERR(%s):Unsupported value(%d)", __func__, value);
         return false;
         break;
     }
 
     if (m_internalISP == true) {
         if (internalValue < IS_METERING_AVERAGE || IS_METERING_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
             return false;
         }
     } else {
         if (internalValue <= METERING_BASE || METERING_MAX <= internalValue) {
-            LOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue);
             return false;
         }
     }
@@ -4396,12 +4396,12 @@ bool ExynosCamera::setMeteringMode(int value)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_METERING, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -4434,7 +4434,7 @@ bool ExynosCamera::setObjectTrackingStart(bool toggle)
 
         int startStop = (toggle == true) ? 1 : 0;
         if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP, startStop) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
             return false;
         }
     }
@@ -4447,7 +4447,7 @@ int ExynosCamera::getObjectTrackingStatus(void)
     int ret = 0;
 
     if (exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJ_TRACKING_STATUS, &ret) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__);
         return -1;
     }
     return ret;
@@ -4459,12 +4459,12 @@ bool ExynosCamera::setObjectPosition(int x, int y)
         x = x - 80;
 
     if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_OBJECT_POSITION_X, x) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
         return false;
     }
 
     if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_OBJECT_POSITION_Y, y) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
         return false;
     }
 
@@ -4478,7 +4478,7 @@ bool ExynosCamera::setTouchAFStart(bool toggle)
         int startStop = (toggle == true) ? 1 : 0;
 
         if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, startStop) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
             return false;
         }
     }
@@ -4495,7 +4495,7 @@ bool ExynosCamera::setSmartAuto(bool toggle)
 
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SMART_AUTO, smartAuto) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -4515,12 +4515,12 @@ int ExynosCamera::getSmartAutoStatus(void)
 
     if (m_curCameraInfo->smartAuto == true) {
         if (exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SMART_AUTO_STATUS, &autoscene_status) < 0) {
-            LOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__);
+            ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__);
             return -1;
         }
 
         if ((autoscene_status < SMART_AUTO_STATUS_AUTO) || (autoscene_status > SMART_AUTO_STATUS_MAX)) {
-            LOGE("ERR(%s):Invalid getSmartAutoStatus (%d)", __func__, autoscene_status);
+            ALOGE("ERR(%s):Invalid getSmartAutoStatus (%d)", __func__, autoscene_status);
             return -1;
         }
     }
@@ -4535,7 +4535,7 @@ bool ExynosCamera::setBeautyShot(bool toggle)
 
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_BEAUTY_SHOT, beautyShot) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -4552,12 +4552,12 @@ bool ExynosCamera::getBeautyShot(void)
 bool ExynosCamera::setTopDownMirror(void)
 {
     if (m_previewDev->fd <= 0) {
-        LOGE("ERR(%s):Camera was closed", __func__);
+        ALOGE("ERR(%s):Camera was closed", __func__);
         return false;
     }
 
     if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_VFLIP, 1) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
         return false;
     }
 
@@ -4567,12 +4567,12 @@ bool ExynosCamera::setTopDownMirror(void)
 bool ExynosCamera::setLRMirror(void)
 {
     if (m_previewDev->fd <= 0) {
-        LOGE("ERR(%s):Camera was closed", __func__);
+        ALOGE("ERR(%s):Camera was closed", __func__);
         return false;
     }
 
     if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_HFLIP, 1) < 0) {
-        LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+        ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
         return false;
     }
 
@@ -4586,13 +4586,13 @@ bool ExynosCamera::setBrightness(int brightness)
     if (m_internalISP == true) {
         internalValue += IS_BRIGHTNESS_DEFAULT;
         if (internalValue < IS_BRIGHTNESS_MINUS_2 || IS_BRIGHTNESS_PLUS_2 < internalValue) {
-            LOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
             return false;
         }
     } else {
         internalValue += EV_DEFAULT;
         if (internalValue < EV_MINUS_4 || EV_PLUS_4 < internalValue) {
-            LOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
+            ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue);
             return false;
         }
     }
@@ -4602,12 +4602,12 @@ bool ExynosCamera::setBrightness(int brightness)
         if (m_flagCreate == true) {
             if (m_internalISP == true) {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_BRIGHTNESS, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             } else {
                 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_BRIGHTNESS, internalValue) < 0) {
-                    LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                    ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                     return false;
                 }
             }
@@ -4631,7 +4631,7 @@ bool ExynosCamera::setGamma(bool toggle)
 
         if (m_flagCreate == true) {
              if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_GAMMA, gamma) < 0) {
-                 LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                  return false;
              }
          }
@@ -4654,7 +4654,7 @@ bool ExynosCamera::setODC(bool toggle)
             int odc = (toggle == true) ? CAMERA_ODC_ON : CAMERA_ODC_OFF;
 
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_ODC, odc) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -4677,7 +4677,7 @@ bool ExynosCamera::setSlowAE(bool toggle)
 
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_SLOW_AE, slow_ae) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
          }
@@ -4694,7 +4694,7 @@ bool ExynosCamera::getSlowAE(void)
 bool ExynosCamera::setShotMode(int shotMode)
 {
     if (shotMode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shotMode) {
-        LOGE("ERR(%s):Invalid shotMode (%d)", __func__, shotMode);
+        ALOGE("ERR(%s):Invalid shotMode (%d)", __func__, shotMode);
         return false;
     }
 
@@ -4703,7 +4703,7 @@ bool ExynosCamera::setShotMode(int shotMode)
 
         if (m_flagCreate == true) {
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SHOT_MODE_NORMAL, shotMode) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
@@ -4726,7 +4726,7 @@ bool ExynosCamera::set3DNR(bool toggle)
             int tdnr = (toggle == true) ? CAMERA_3DNR_ON : CAMERA_3DNR_OFF;
 
             if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_3DNR, tdnr) < 0) {
-                LOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
+                ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__);
                 return false;
             }
         }
diff --git a/libcamera/ExynosCameraHWInterface.cpp b/libcamera/ExynosCameraHWInterface.cpp
index 5069171..d829c4d 100644
--- a/libcamera/ExynosCameraHWInterface.cpp
+++ b/libcamera/ExynosCameraHWInterface.cpp
@@ -93,7 +93,7 @@ ExynosCameraHWInterface::ExynosCameraHWInterface(int cameraId, camera_device_t *
           m_halDevice(dev),
           m_numOfAvailableVideoBuf(0)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     int ret = 0;
 
     m_previewWindow = NULL;
@@ -152,11 +152,11 @@ ExynosCameraHWInterface::ExynosCameraHWInterface(int cameraId, camera_device_t *
     if (!m_grallocHal) {
         ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&m_grallocHal);
         if (ret)
-            LOGE("ERR(%s):Fail on loading gralloc HAL", __func__);
+            ALOGE("ERR(%s):Fail on loading gralloc HAL", __func__);
     }
 
     if (m_secCamera->create(cameraId) == false) {
-        LOGE("ERR(%s):Fail on m_secCamera->create(%d)", __func__, cameraId);
+        ALOGE("ERR(%s):Fail on m_secCamera->create(%d)", __func__, cameraId);
         return;
     }
 
@@ -166,15 +166,15 @@ ExynosCameraHWInterface::ExynosCameraHWInterface(int cameraId, camera_device_t *
 
     m_exynosPreviewCSC = csc_init(cscMethod);
     if (m_exynosPreviewCSC == NULL)
-        LOGE("ERR(%s):csc_init() fail", __func__);
+        ALOGE("ERR(%s):csc_init() fail", __func__);
 
     m_exynosPictureCSC = csc_init(cscMethod);
     if (m_exynosPictureCSC == NULL)
-        LOGE("ERR(%s):csc_init() fail", __func__);
+        ALOGE("ERR(%s):csc_init() fail", __func__);
 
     m_exynosVideoCSC = csc_init(cscMethod);
     if (m_exynosVideoCSC == NULL)
-        LOGE("ERR(%s):csc_init() fail", __func__);
+        ALOGE("ERR(%s):csc_init() fail", __func__);
 
     m_previewThread   = new PreviewThread(this);
     m_videoThread     = new VideoThread(this);
@@ -190,32 +190,32 @@ ExynosCameraHWInterface::~ExynosCameraHWInterface()
 status_t ExynosCameraHWInterface::setPreviewWindow(preview_stream_ops *w)
 {
     m_previewWindow = w;
-    LOGV("DEBUG(%s):m_previewWindow %p", __func__, m_previewWindow);
+    ALOGV("DEBUG(%s):m_previewWindow %p", __func__, m_previewWindow);
 
     if (m_previewWindow == NULL) {
-        LOGV("DEBUG(%s):preview window is NULL!", __func__);
+        ALOGV("DEBUG(%s):preview window is NULL!", __func__);
         return OK;
     }
 
     m_previewLock.lock();
 
     if (m_previewRunning == true && m_previewStartDeferred == false) {
-        LOGV("DEBUG(%s):stop preview (window change)", __func__);
+        ALOGV("DEBUG(%s):stop preview (window change)", __func__);
         m_stopPreviewInternal();
     }
 
     if (m_previewWindow->get_min_undequeued_buffer_count(m_previewWindow, &m_minUndequeuedBufs) != 0) {
-        LOGE("ERR(%s):could not retrieve min undequeued buffer count", __func__);
+        ALOGE("ERR(%s):could not retrieve min undequeued buffer count", __func__);
         return INVALID_OPERATION;
     }
 
     if (NUM_OF_PREVIEW_BUF <= m_minUndequeuedBufs) {
-        LOGE("ERR(%s):min undequeued buffer count %d is too high (expecting at most %d)", __func__,
+        ALOGE("ERR(%s):min undequeued buffer count %d is too high (expecting at most %d)", __func__,
              m_minUndequeuedBufs, NUM_OF_PREVIEW_BUF - 1);
     }
 
     if (m_previewWindow->set_buffer_count(m_previewWindow, NUM_OF_PREVIEW_BUF) != 0) {
-        LOGE("ERR(%s):could not set buffer count", __func__);
+        ALOGE("ERR(%s):could not set buffer count", __func__);
         return INVALID_OPERATION;
     }
 
@@ -224,7 +224,7 @@ status_t ExynosCameraHWInterface::setPreviewWindow(preview_stream_ops *w)
 
     m_params.getPreviewSize(&previewW, &previewH);
     const char *str_preview_format = m_params.getPreviewFormat();
-    LOGV("DEBUG(%s):str preview format %s width : %d height : %d ", __func__, str_preview_format, previewW, previewH);
+    ALOGV("DEBUG(%s):str preview format %s width : %d height : %d ", __func__, str_preview_format, previewW, previewH);
 
     if (!strcmp(str_preview_format,
                 CameraParameters::PIXEL_FORMAT_RGB565)) {
@@ -246,20 +246,20 @@ status_t ExynosCameraHWInterface::setPreviewWindow(preview_stream_ops *w)
                                   GRALLOC_USAGE_HWC_HWOVERLAY |
 #endif
                                   GRALLOC_USAGE_HW_ION) != 0) {
-        LOGE("ERR(%s):could not set usage on gralloc buffer", __func__);
+        ALOGE("ERR(%s):could not set usage on gralloc buffer", __func__);
         return INVALID_OPERATION;
     }
 
     if (m_previewWindow->set_buffers_geometry(m_previewWindow,
                                               previewW, previewH,
                                               hal_pixel_format) != 0) {
-        LOGE("ERR(%s):could not set buffers geometry to %s",
+        ALOGE("ERR(%s):could not set buffers geometry to %s",
              __func__, str_preview_format);
         return INVALID_OPERATION;
     }
 
     if (m_previewRunning == true && m_previewStartDeferred == true) {
-        LOGV("DEBUG(%s):start/resume preview", __func__);
+        ALOGV("DEBUG(%s):start/resume preview", __func__);
         if (m_startPreviewInternal() == true) {
             m_previewStartDeferred = false;
             m_previewCondition.signal();
@@ -285,7 +285,7 @@ void ExynosCameraHWInterface::setCallbacks(camera_notify_callback notify_cb,
 
 void ExynosCameraHWInterface::enableMsgType(int32_t msgType)
 {
-    LOGV("DEBUG(%s):msgType = 0x%x, m_msgEnabled before = 0x%x",
+    ALOGV("DEBUG(%s):msgType = 0x%x, m_msgEnabled before = 0x%x",
          __func__, msgType, m_msgEnabled);
     m_msgEnabled |= msgType;
 
@@ -294,7 +294,7 @@ void ExynosCameraHWInterface::enableMsgType(int32_t msgType)
         && m_previewRunning == true
         && m_previewStartDeferred == true) {
 
-        LOGV("DEBUG(%s):starting deferred preview", __func__);
+        ALOGV("DEBUG(%s):starting deferred preview", __func__);
 
         if (m_startPreviewInternal() == true) {
             m_previewStartDeferred = false;
@@ -303,15 +303,15 @@ void ExynosCameraHWInterface::enableMsgType(int32_t msgType)
     }
     m_previewLock.unlock();
 
-    LOGV("DEBUG(%s):m_msgEnabled = 0x%x", __func__, m_msgEnabled);
+    ALOGV("DEBUG(%s):m_msgEnabled = 0x%x", __func__, m_msgEnabled);
 }
 
 void ExynosCameraHWInterface::disableMsgType(int32_t msgType)
 {
-    LOGV("DEBUG(%s):msgType = 0x%x, m_msgEnabled before = 0x%x",
+    ALOGV("DEBUG(%s):msgType = 0x%x, m_msgEnabled before = 0x%x",
          __func__, msgType, m_msgEnabled);
     m_msgEnabled &= ~msgType;
-    LOGV("DEBUG(%s):m_msgEnabled = 0x%x", __func__, m_msgEnabled);
+    ALOGV("DEBUG(%s):m_msgEnabled = 0x%x", __func__, m_msgEnabled);
 }
 
 bool ExynosCameraHWInterface::msgTypeEnabled(int32_t msgType)
@@ -323,17 +323,17 @@ status_t ExynosCameraHWInterface::startPreview()
 {
     int ret = OK;
 
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
     Mutex::Autolock lock(m_stateLock);
     if (m_captureInProgress == true) {
-        LOGE("%s : capture in progress, not allowed", __func__);
+        ALOGE("%s : capture in progress, not allowed", __func__);
         return INVALID_OPERATION;
     }
 
     m_previewLock.lock();
     if (m_previewRunning == true) {
-        LOGE("%s : preview thread already running", __func__);
+        ALOGE("%s : preview thread already running", __func__);
         m_previewLock.unlock();
         return INVALID_OPERATION;
     }
@@ -343,12 +343,12 @@ status_t ExynosCameraHWInterface::startPreview()
 
     if (m_previewWindow == NULL) {
         if (!(m_msgEnabled & CAMERA_MSG_PREVIEW_FRAME)) {
-            LOGV("DEBUG(%s):deferring", __func__);
+            ALOGV("DEBUG(%s):deferring", __func__);
             m_previewStartDeferred = true;
             m_previewLock.unlock();
             return NO_ERROR;
         }
-        LOGE("%s(%d): m_previewWindow is NULL", __func__, __LINE__);
+        ALOGE("%s(%d): m_previewWindow is NULL", __func__, __LINE__);
         return UNKNOWN_ERROR;
     }
 
@@ -365,7 +365,7 @@ status_t ExynosCameraHWInterface::startPreview()
 
 void ExynosCameraHWInterface::stopPreview()
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
     /* request that the preview thread stop. */
     m_previewLock.lock();
@@ -376,14 +376,14 @@ void ExynosCameraHWInterface::stopPreview()
 bool ExynosCameraHWInterface::previewEnabled()
 {
     Mutex::Autolock lock(m_previewLock);
-    LOGV("DEBUG(%s):%d", __func__, m_previewRunning);
+    ALOGV("DEBUG(%s):%d", __func__, m_previewRunning);
     return m_previewRunning;
 }
 
 status_t ExynosCameraHWInterface::storeMetaDataInBuffers(bool enable)
 {
     if (!enable) {
-        LOGE("Non-m_frameMetadata buffer mode is not supported!");
+        ALOGE("Non-m_frameMetadata buffer mode is not supported!");
         return INVALID_OPERATION;
     }
     return OK;
@@ -391,7 +391,7 @@ status_t ExynosCameraHWInterface::storeMetaDataInBuffers(bool enable)
 
 status_t ExynosCameraHWInterface::startRecording()
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
     Mutex::Autolock lock(m_videoLock);
 
@@ -415,7 +415,7 @@ status_t ExynosCameraHWInterface::startRecording()
 
         m_videoHeap[i] = m_getMemoryCb(-1, videoFramesize, 1, NULL);
         if (!m_videoHeap[i]) {
-            LOGE("ERR(%s):m_getMemoryCb(m_videoHeap[%d], size(%d) fail", __func__, i, videoFramesize);
+            ALOGE("ERR(%s):m_getMemoryCb(m_videoHeap[%d], size(%d) fail", __func__, i, videoFramesize);
             return UNKNOWN_ERROR;
         }
 
@@ -443,14 +443,14 @@ status_t ExynosCameraHWInterface::startRecording()
 
         m_resizedVideoHeap[i] = m_getMemoryCb(-1, orgVideoFrameSize, 1, NULL);
         if (!m_resizedVideoHeap[i]) {
-            LOGE("ERR(%s):m_getMemoryCb(m_resizedVideoHeap[%d], size(%d) fail", __func__, i, orgVideoFrameSize);
+            ALOGE("ERR(%s):m_getMemoryCb(m_resizedVideoHeap[%d], size(%d) fail", __func__, i, orgVideoFrameSize);
             return UNKNOWN_ERROR;
         }
     }
 
     if (m_videoRunning == false) {
         if (m_secCamera->startVideo() == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->startVideo()", __func__);
+            ALOGE("ERR(%s):Fail on m_secCamera->startVideo()", __func__);
             return UNKNOWN_ERROR;
         }
 
@@ -470,7 +470,7 @@ status_t ExynosCameraHWInterface::startRecording()
 
 void ExynosCameraHWInterface::stopRecording()
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
 #ifndef USE_3DNR_DMAOUT
     m_videoStart = false;
@@ -485,7 +485,7 @@ void ExynosCameraHWInterface::stopRecording()
         /* wait until video thread is stopped */
         m_videoStoppedCondition.wait(m_videoLock);
     } else
-        LOGV("DEBUG(%s):video not running, doing nothing", __func__);
+        ALOGV("DEBUG(%s):video not running, doing nothing", __func__);
 }
 
 bool ExynosCameraHWInterface::recordingEnabled()
@@ -520,14 +520,14 @@ void ExynosCameraHWInterface::releaseRecordingFrame(const void *opaque)
         if (NUM_OF_VIDEO_BUF <= m_numOfAvailableVideoBuf)
             m_numOfAvailableVideoBuf = NUM_OF_VIDEO_BUF;
     } else {
-        LOGV("DEBUG(%s):no matched index(%p)", __func__, (char *)opaque);
+        ALOGV("DEBUG(%s):no matched index(%p)", __func__, (char *)opaque);
     }
     */
 }
 
 status_t ExynosCameraHWInterface::autoFocus()
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     /* signal m_autoFocusThread to run once */
     m_focusCondition.signal();
     return NO_ERROR;
@@ -536,7 +536,7 @@ status_t ExynosCameraHWInterface::autoFocus()
 status_t ExynosCameraHWInterface::cancelAutoFocus()
 {
     if (m_secCamera->cancelAutoFocus() == false) {
-        LOGE("ERR(%s):Fail on m_secCamera->cancelAutoFocus()", __func__);
+        ALOGE("ERR(%s):Fail on m_secCamera->cancelAutoFocus()", __func__);
         return UNKNOWN_ERROR;
     }
 
@@ -547,14 +547,14 @@ status_t ExynosCameraHWInterface::takePicture()
 {
     Mutex::Autolock lock(m_stateLock);
     if (m_captureInProgress == true) {
-        LOGE("%s : capture already in progress", __func__);
+        ALOGE("%s : capture already in progress", __func__);
         return INVALID_OPERATION;
     }
 
     if (m_pictureRunning == false) {
-        LOGI("%s(%d): m_pictureRunning is false", __func__, __LINE__);
+        ALOGI("%s(%d): m_pictureRunning is false", __func__, __LINE__);
         if (m_startPictureInternal() == false) {
-            LOGE("%s(%d): m_startPictureInternal() fail!!!", __func__, __LINE__);
+            ALOGE("%s(%d): m_startPictureInternal() fail!!!", __func__, __LINE__);
             return INVALID_OPERATION;
         }
     }
@@ -564,7 +564,7 @@ status_t ExynosCameraHWInterface::takePicture()
     m_pictureLock.unlock();
 
     if (m_pictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
-        LOGE("%s : couldn't run picture thread", __func__);
+        ALOGE("%s : couldn't run picture thread", __func__);
         return INVALID_OPERATION;
     }
 
@@ -573,12 +573,12 @@ status_t ExynosCameraHWInterface::takePicture()
 
 status_t ExynosCameraHWInterface::cancelPicture()
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
     if (m_pictureThread.get()) {
-        LOGV("DEBUG(%s):waiting for picture thread to exit", __func__);
+        ALOGV("DEBUG(%s):waiting for picture thread to exit", __func__);
         m_pictureThread->requestExitAndWait();
-        LOGV("DEBUG(%s):picture thread has exited", __func__);
+        ALOGV("DEBUG(%s):picture thread has exited", __func__);
     }
 
     return NO_ERROR;
@@ -586,7 +586,7 @@ status_t ExynosCameraHWInterface::cancelPicture()
 
 status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
     status_t ret = NO_ERROR;
 
@@ -652,7 +652,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     newPreviewH = newCalPreviewH;
 
     const char *strNewPreviewFormat = params.getPreviewFormat();
-    LOGV("DEBUG(%s):newPreviewW x newPreviewH = %dx%d, format = %s",
+    ALOGV("DEBUG(%s):newPreviewW x newPreviewH = %dx%d, format = %s",
          __func__, newPreviewW, newPreviewH, strNewPreviewFormat);
 
     if (0 < newPreviewW &&
@@ -689,40 +689,40 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             curPreviewFormat != newPreviewFormat) {
             if (   m_secCamera->setPreviewSize(newPreviewW, newPreviewH) == false
                 || m_secCamera->setPreviewFormat(newPreviewFormat) == false) {
-                LOGE("ERR(%s):Fail on m_secCamera->setPreviewSize(width(%d), height(%d), format(%d))",
+                ALOGE("ERR(%s):Fail on m_secCamera->setPreviewSize(width(%d), height(%d), format(%d))",
                      __func__, newPreviewW, newPreviewH, newPreviewFormat);
                 ret = UNKNOWN_ERROR;
             } else {
                 if (m_previewWindow) {
                     if (m_previewRunning == true && m_previewStartDeferred == false) {
-                        LOGE("ERR(%s):preview is running, cannot change size and format!", __func__);
+                        ALOGE("ERR(%s):preview is running, cannot change size and format!", __func__);
                         ret = INVALID_OPERATION;
                     }
 
-                    LOGV("DEBUG(%s):m_previewWindow (%p) set_buffers_geometry", __func__, m_previewWindow);
-                    LOGV("DEBUG(%s):m_previewWindow->set_buffers_geometry (%p)", __func__,
+                    ALOGV("DEBUG(%s):m_previewWindow (%p) set_buffers_geometry", __func__, m_previewWindow);
+                    ALOGV("DEBUG(%s):m_previewWindow->set_buffers_geometry (%p)", __func__,
                          m_previewWindow->set_buffers_geometry);
                     m_previewWindow->set_buffers_geometry(m_previewWindow,
                                                          newPreviewW, newPreviewH,
                                                          newPreviewFormat);
-                    LOGV("DEBUG(%s):DONE m_previewWindow (%p) set_buffers_geometry", __func__, m_previewWindow);
+                    ALOGV("DEBUG(%s):DONE m_previewWindow (%p) set_buffers_geometry", __func__, m_previewWindow);
                 }
                 m_params.setPreviewSize(newPreviewW, newPreviewH);
                 m_params.setPreviewFormat(strNewPreviewFormat);
             }
         }
         else {
-            LOGV("DEBUG(%s):preview size and format has not changed", __func__);
+            ALOGV("DEBUG(%s):preview size and format has not changed", __func__);
         }
     } else {
-        LOGE("ERR(%s):Invalid preview size(%dx%d)", __func__, newPreviewW, newPreviewH);
+        ALOGE("ERR(%s):Invalid preview size(%dx%d)", __func__, newPreviewW, newPreviewH);
         ret = INVALID_OPERATION;
     }
 
     int newPictureW = 0;
     int newPictureH = 0;
     params.getPictureSize(&newPictureW, &newPictureH);
-    LOGV("DEBUG(%s):newPictureW x newPictureH = %dx%d", __func__, newPictureW, newPictureH);
+    ALOGV("DEBUG(%s):newPictureW x newPictureH = %dx%d", __func__, newPictureW, newPictureH);
 
     if (0 < newPictureW && 0 < newPictureH) {
 
@@ -730,7 +730,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         m_secCamera->getPictureSize(&orgPictureW, &orgPictureH);
 
         if (m_secCamera->setPictureSize(newPictureW, newPictureH) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setPictureSize(width(%d), height(%d))",
+            ALOGE("ERR(%s):Fail on m_secCamera->setPictureSize(width(%d), height(%d))",
                     __func__, newPictureW, newPictureH);
             ret = UNKNOWN_ERROR;
         } else {
@@ -741,10 +741,10 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
                 if (m_pictureRunning == true) {
                     if (m_stopPictureInternal() == false)
-                        LOGE("ERR(%s):m_stopPictureInternal() fail", __func__);
+                        ALOGE("ERR(%s):m_stopPictureInternal() fail", __func__);
 
                     if (m_startPictureInternal() == false)
-                        LOGE("ERR(%s):m_startPictureInternal() fail", __func__);
+                        ALOGE("ERR(%s):m_startPictureInternal() fail", __func__);
                 }
             }
             m_orgPictureRect.w = newPictureW;
@@ -755,7 +755,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // picture format
     const char *newPictureFormat = params.getPictureFormat();
-    LOGV("DEBUG(%s):newPictureFormat %s", __func__, newPictureFormat);
+    ALOGV("DEBUG(%s):newPictureFormat %s", __func__, newPictureFormat);
 
     if (newPictureFormat != NULL) {
         int value = 0;
@@ -785,7 +785,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
         if (value != m_secCamera->getPictureFormat()) {
             if (m_secCamera->setPictureFormat(value) == false) {
-                LOGE("ERR(%s):Fail on m_secCamera->setPictureFormat(format(%d))", __func__, value);
+                ALOGE("ERR(%s):Fail on m_secCamera->setPictureFormat(format(%d))", __func__, value);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_orgPictureRect.colorFormat = value;
@@ -796,11 +796,11 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // JPEG image quality
     int newJpegQuality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
-    LOGV("DEBUG(%s):newJpegQuality %d", __func__, newJpegQuality);
+    ALOGV("DEBUG(%s):newJpegQuality %d", __func__, newJpegQuality);
     // we ignore bad values
     if (newJpegQuality >=1 && newJpegQuality <= 100) {
         if (m_secCamera->setJpegQuality(newJpegQuality) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setJpegQuality(quality(%d))", __func__, newJpegQuality);
+            ALOGE("ERR(%s):Fail on m_secCamera->setJpegQuality(quality(%d))", __func__, newJpegQuality);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set(CameraParameters::KEY_JPEG_QUALITY, newJpegQuality);
@@ -812,7 +812,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     int newJpegThumbnailH = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
     if (0 <= newJpegThumbnailW && 0 <= newJpegThumbnailH) {
         if (m_secCamera->setJpegThumbnailSize(newJpegThumbnailW, newJpegThumbnailH) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, newJpegThumbnailW, newJpegThumbnailH);
+            ALOGE("ERR(%s):Fail on m_secCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, newJpegThumbnailW, newJpegThumbnailH);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,  newJpegThumbnailW);
@@ -822,11 +822,11 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // JPEG thumbnail quality
     int newJpegThumbnailQuality = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
-    LOGV("DEBUG(%s):newJpegThumbnailQuality %d", __func__, newJpegThumbnailQuality);
+    ALOGV("DEBUG(%s):newJpegThumbnailQuality %d", __func__, newJpegThumbnailQuality);
     // we ignore bad values
     if (newJpegThumbnailQuality >=1 && newJpegThumbnailQuality <= 100) {
         if (m_secCamera->setJpegThumbnailQuality(newJpegThumbnailQuality) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setJpegThumbnailQuality(quality(%d))",
+            ALOGE("ERR(%s):Fail on m_secCamera->setJpegThumbnailQuality(quality(%d))",
                                                __func__, newJpegThumbnailQuality);
             ret = UNKNOWN_ERROR;
         } else {
@@ -838,14 +838,14 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     int newVideoW = 0;
     int newVideoH = 0;
     params.getVideoSize(&newVideoW, &newVideoH);
-    LOGV("DEBUG(%s):newVideoW (%d) newVideoH (%d)", __func__, newVideoW, newVideoH);
+    ALOGV("DEBUG(%s):newVideoW (%d) newVideoH (%d)", __func__, newVideoW, newVideoH);
     if (0 < newVideoW && 0 < newVideoH && m_videoStart == false) {
 
         m_orgVideoRect.w = newVideoW;
         m_orgVideoRect.h = newVideoH;
 
         if (m_secCamera->setVideoSize(newVideoW, newVideoH) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setVideoSize(width(%d), height(%d))",
+            ALOGE("ERR(%s):Fail on m_secCamera->setVideoSize(width(%d), height(%d))",
             __func__, newVideoW, newVideoH);
             ret = UNKNOWN_ERROR;
         }
@@ -855,7 +855,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     // video stablization
     const char *newVideoStabilization = params.get(CameraParameters::KEY_VIDEO_STABILIZATION);
     bool currVideoStabilization = m_secCamera->getVideoStabilization();
-    LOGV("DEBUG(%s):newVideoStabilization %s", __func__, newVideoStabilization);
+    ALOGV("DEBUG(%s):newVideoStabilization %s", __func__, newVideoStabilization);
     if (newVideoStabilization != NULL) {
         bool toggle = false;
 
@@ -864,7 +864,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
         if ( currVideoStabilization != toggle) {
             if (m_secCamera->setVideoStabilization(toggle) == false) {
-                LOGE("ERR(%s):setVideoStabilization() fail", __func__);
+                ALOGE("ERR(%s):setVideoStabilization() fail", __func__);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set(CameraParameters::KEY_VIDEO_STABILIZATION, newVideoStabilization);
@@ -874,7 +874,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // 3dnr
     const char *new3dnr = params.get("3dnr");
-    LOGV("DEBUG(%s):new3drn %s", __func__, new3dnr);
+    ALOGV("DEBUG(%s):new3drn %s", __func__, new3dnr);
     if (new3dnr != NULL) {
         bool toggle = false;
 
@@ -882,7 +882,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             toggle = true;
 
             if (m_secCamera->set3DNR(toggle) == false) {
-                LOGE("ERR(%s):set3DNR() fail", __func__);
+                ALOGE("ERR(%s):set3DNR() fail", __func__);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set("3dnr", new3dnr);
@@ -891,7 +891,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // odc
     const char *newOdc = params.get("odc");
-    LOGV("DEBUG(%s):newOdc %s", __func__, new3dnr);
+    ALOGV("DEBUG(%s):newOdc %s", __func__, new3dnr);
     if (newOdc != NULL) {
         bool toggle = false;
 
@@ -899,7 +899,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             toggle = true;
 
             if (m_secCamera->setODC(toggle) == false) {
-                LOGE("ERR(%s):setODC() fail", __func__);
+                ALOGE("ERR(%s):setODC() fail", __func__);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set("odc", newOdc);
@@ -908,12 +908,12 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // frame rate
     int newFrameRate = params.getPreviewFrameRate();
-    LOGV("DEBUG(%s):newFrameRate %d", __func__, newFrameRate);
+    ALOGV("DEBUG(%s):newFrameRate %d", __func__, newFrameRate);
     // ignore any fps request, we're determine fps automatically based
     // on scene mode.  don't return an error because it causes CTS failure.
     if (newFrameRate != m_params.getPreviewFrameRate()) {
         if (m_secCamera->setPreviewFrameRate(newFrameRate) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setPreviewFrameRate(%d)", __func__, newFrameRate);
+            ALOGE("ERR(%s):Fail on m_secCamera->setPreviewFrameRate(%d)", __func__, newFrameRate);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.setPreviewFrameRate(newFrameRate);
@@ -922,10 +922,10 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // zoom
     int newZoom = params.getInt(CameraParameters::KEY_ZOOM);
-    LOGV("DEBUG(%s):newZoom %d", __func__, newZoom);
+    ALOGV("DEBUG(%s):newZoom %d", __func__, newZoom);
     if (0 <= newZoom) {
         if (m_secCamera->setZoom(newZoom) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setZoom(newZoom(%d))", __func__, newZoom);
+            ALOGE("ERR(%s):Fail on m_secCamera->setZoom(newZoom(%d))", __func__, newZoom);
             ret = UNKNOWN_ERROR;
         }
         else {
@@ -935,11 +935,11 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // rotation
     int newRotation = params.getInt(CameraParameters::KEY_ROTATION);
-    LOGV("DEBUG(%s):newRotation %d", __func__, newRotation);
+    ALOGV("DEBUG(%s):newRotation %d", __func__, newRotation);
     if (0 <= newRotation) {
-        LOGV("DEBUG(%s):set orientation:%d", __func__, newRotation);
+        ALOGV("DEBUG(%s):set orientation:%d", __func__, newRotation);
         if (m_secCamera->setRotation(newRotation) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setRotation(%d)", __func__, newRotation);
+            ALOGE("ERR(%s):Fail on m_secCamera->setRotation(%d)", __func__, newRotation);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set(CameraParameters::KEY_ROTATION, newRotation);
@@ -955,7 +955,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             toggle = true;
 
         if (m_secCamera->setAutoExposureLock(toggle) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setAutoExposureLock()", __func__);
+            ALOGE("ERR(%s):Fail on m_secCamera->setAutoExposureLock()", __func__);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, newAutoExposureLock);
@@ -966,11 +966,11 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     int minExposureCompensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
     int maxExposureCompensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
     int newExposureCompensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
-    LOGV("DEBUG(%s):newExposureCompensation %d", __func__, newExposureCompensation);
+    ALOGV("DEBUG(%s):newExposureCompensation %d", __func__, newExposureCompensation);
     if ((minExposureCompensation <= newExposureCompensation) &&
         (newExposureCompensation <= maxExposureCompensation)) {
         if (m_secCamera->setExposureCompensation(newExposureCompensation) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setExposureCompensation(exposure(%d))", __func__, newExposureCompensation);
+            ALOGE("ERR(%s):Fail on m_secCamera->setExposureCompensation(exposure(%d))", __func__, newExposureCompensation);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, newExposureCompensation);
@@ -986,7 +986,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             toggle = true;
 
         if (m_secCamera->setAutoWhiteBalanceLock(toggle) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setAutoWhiteBalanceLock()", __func__);
+            ALOGE("ERR(%s):Fail on m_secCamera->setAutoWhiteBalanceLock()", __func__);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, newAutoWhitebalanceLock);
@@ -995,7 +995,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // white balance
     const char *newWhiteBalance = params.get(CameraParameters::KEY_WHITE_BALANCE);
-    LOGV("DEBUG(%s):newWhiteBalance %s", __func__, newWhiteBalance);
+    ALOGV("DEBUG(%s):newWhiteBalance %s", __func__, newWhiteBalance);
     if (newWhiteBalance != NULL) {
         int value = -1;
 
@@ -1016,13 +1016,13 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         else if (!strcmp(newWhiteBalance, CameraParameters::WHITE_BALANCE_SHADE))
             value = ExynosCamera::WHITE_BALANCE_SHADE;
         else {
-            LOGE("ERR(%s):Invalid white balance(%s)", __func__, newWhiteBalance); //twilight, shade, warm_flourescent
+            ALOGE("ERR(%s):Invalid white balance(%s)", __func__, newWhiteBalance); //twilight, shade, warm_flourescent
             ret = UNKNOWN_ERROR;
         }
 
         if (0 <= value) {
             if (m_secCamera->setWhiteBalance(value) == false) {
-                LOGE("ERR(%s):Fail on m_secCamera->setWhiteBalance(white(%d))", __func__, value);
+                ALOGE("ERR(%s):Fail on m_secCamera->setWhiteBalance(white(%d))", __func__, value);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set(CameraParameters::KEY_WHITE_BALANCE, newWhiteBalance);
@@ -1034,7 +1034,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     // This is the additional API(not Google API).
     // But, This is set berfore the below KEY_METERING_AREAS.
     const char *strNewMetering = params.get("metering");
-    LOGV("DEBUG(%s):strNewMetering %s", __func__, strNewMetering);
+    ALOGV("DEBUG(%s):strNewMetering %s", __func__, strNewMetering);
     if (strNewMetering != NULL) {
         int newMetering = -1;
 
@@ -1047,13 +1047,13 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         else if (!strcmp(strNewMetering, "spot"))
             newMetering = ExynosCamera::METERING_MODE_SPOT;
         else {
-            LOGE("ERR(%s):Invalid metering newMetering(%s)", __func__, strNewMetering);
+            ALOGE("ERR(%s):Invalid metering newMetering(%s)", __func__, strNewMetering);
             ret = UNKNOWN_ERROR;
         }
 
         if (0 <= newMetering) {
             if (m_secCamera->setMeteringMode(newMetering) == false) {
-                LOGE("ERR(%s):Fail on m_secCamera->setMeteringMode(%d)", __func__, newMetering);
+                ALOGE("ERR(%s):Fail on m_secCamera->setMeteringMode(%d)", __func__, newMetering);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set("metering", strNewMetering);
@@ -1080,7 +1080,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             }
 
             if (m_secCamera->setMeteringAreas(validMeteringAreas, rect2s, weights) == false) {
-                LOGE("ERR(%s):setMeteringAreas(%s) fail", __func__, newMeteringAreas);
+                ALOGE("ERR(%s):setMeteringAreas(%s) fail", __func__, newMeteringAreas);
                 ret = UNKNOWN_ERROR;
             }
             else {
@@ -1094,7 +1094,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // anti banding
     const char *newAntibanding = params.get(CameraParameters::KEY_ANTIBANDING);
-    LOGV("DEBUG(%s):newAntibanding %s", __func__, newAntibanding);
+    ALOGV("DEBUG(%s):newAntibanding %s", __func__, newAntibanding);
     if (newAntibanding != NULL) {
         int value = -1;
 
@@ -1107,13 +1107,13 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         else if (!strcmp(newAntibanding, CameraParameters::ANTIBANDING_OFF))
             value = ExynosCamera::ANTIBANDING_OFF;
         else {
-            LOGE("ERR(%s):Invalid antibanding value(%s)", __func__, newAntibanding);
+            ALOGE("ERR(%s):Invalid antibanding value(%s)", __func__, newAntibanding);
             ret = UNKNOWN_ERROR;
         }
 
         if (0 <= value) {
             if (m_secCamera->setAntibanding(value) == false) {
-                LOGE("ERR(%s):Fail on m_secCamera->setAntibanding(%d)", __func__, value);
+                ALOGE("ERR(%s):Fail on m_secCamera->setAntibanding(%d)", __func__, value);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set(CameraParameters::KEY_ANTIBANDING, newAntibanding);
@@ -1139,9 +1139,9 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     if (strNewSceneMode && strCurSceneMode) {
         if (!strcmp(strNewSceneMode, strCurSceneMode)) {
             if ((newMinFps != curMinFps) || (newMaxFps != curMaxFps)) {
-                LOGW("%s : requested newMinFps = %d, newMaxFps = %d not allowed",
+                ALOGW("%s : requested newMinFps = %d, newMaxFps = %d not allowed",
                         __func__, newMinFps, newMaxFps);
-                LOGE("%s : curMinFps = %d, curMaxFps = %d",
+                ALOGE("%s : curMinFps = %d, curMaxFps = %d",
                         __func__, curMinFps, curMaxFps);
                 ret = UNKNOWN_ERROR;
             }
@@ -1205,7 +1205,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             } else if (!strcmp(strNewSceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT)) {
                 newSceneMode = ExynosCamera::SCENE_MODE_CANDLELIGHT;
             } else {
-                LOGE("ERR(%s):unmatched scene_mode(%s)",
+                ALOGE("ERR(%s):unmatched scene_mode(%s)",
                         __func__, strNewSceneMode); //action, night-portrait, theatre, steadyphoto
                 ret = UNKNOWN_ERROR;
             }
@@ -1236,13 +1236,13 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             } else if (!strcmp(strNewFocusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)) {
                 newFocusMode = ExynosCamera::FOCUS_MODE_CONTINUOUS_PICTURE;
             } else {
-                LOGE("ERR(%s):unmatched focus_mode(%s)", __func__, strNewFocusMode);
+                ALOGE("ERR(%s):unmatched focus_mode(%s)", __func__, strNewFocusMode);
                 ret = UNKNOWN_ERROR;
             }
 
             if (0 <= newFocusMode) {
                 if (m_secCamera->setFocusMode(newFocusMode) == false) {
-                    LOGE("ERR(%s):m_secCamera->setFocusMode(%d) fail", __func__, newFocusMode);
+                    ALOGE("ERR(%s):m_secCamera->setFocusMode(%d) fail", __func__, newFocusMode);
                     ret = UNKNOWN_ERROR;
                 } else {
                     m_params.set(CameraParameters::KEY_FOCUS_MODE, strNewFocusMode);
@@ -1265,12 +1265,12 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             else if (!strcmp(strNewFlashMode, CameraParameters::FLASH_MODE_TORCH))
                 newFlashMode = ExynosCamera::FLASH_MODE_TORCH;
             else {
-                LOGE("ERR(%s):unmatched flash_mode(%s)", __func__, strNewFlashMode); //red-eye
+                ALOGE("ERR(%s):unmatched flash_mode(%s)", __func__, strNewFlashMode); //red-eye
                 ret = UNKNOWN_ERROR;
             }
             if (0 <= newFlashMode) {
                 if (m_secCamera->setFlashMode(newFlashMode) == false) {
-                    LOGE("ERR(%s):m_secCamera->setFlashMode(%d) fail", __func__, newFlashMode);
+                    ALOGE("ERR(%s):m_secCamera->setFlashMode(%d) fail", __func__, newFlashMode);
                     ret = UNKNOWN_ERROR;
                 } else {
                     m_params.set(CameraParameters::KEY_FLASH_MODE, strNewFlashMode);
@@ -1281,7 +1281,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         // scene mode
         if (0 <= newSceneMode) {
             if (m_secCamera->setSceneMode(newSceneMode) == false) {
-                LOGE("ERR(%s):m_secCamera->setSceneMode(%d) fail", __func__, newSceneMode);
+                ALOGE("ERR(%s):m_secCamera->setSceneMode(%d) fail", __func__, newSceneMode);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set(CameraParameters::KEY_SCENE_MODE, strNewSceneMode);
@@ -1331,7 +1331,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
                     }
 
                     if (m_secCamera->setFocusAreas(validFocusedAreas, rect2s, weights) == false) {
-                        LOGE("ERR(%s):setFocusAreas(%s) fail", __func__, newFocusAreas);
+                        ALOGE("ERR(%s):setFocusAreas(%s) fail", __func__, newFocusAreas);
                         ret = UNKNOWN_ERROR;
                     } else {
                         m_params.set(CameraParameters::KEY_FOCUS_AREAS, newFocusAreas);
@@ -1369,13 +1369,13 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         } else if (!strcmp(strNewEffect, CameraParameters::EFFECT_AQUA)) {
             newEffect = ExynosCamera::EFFECT_AQUA;
         } else {
-            LOGE("ERR(%s):Invalid effect(%s)", __func__, strNewEffect);
+            ALOGE("ERR(%s):Invalid effect(%s)", __func__, strNewEffect);
             ret = UNKNOWN_ERROR;
         }
 
         if (0 <= newEffect) {
             if (m_secCamera->setColorEffect(newEffect) == false) {
-                LOGE("ERR(%s):Fail on m_secCamera->setColorEffect(effect(%d))", __func__, newEffect);
+                ALOGE("ERR(%s):Fail on m_secCamera->setColorEffect(effect(%d))", __func__, newEffect);
                 ret = UNKNOWN_ERROR;
             } else {
                 const char *oldStrEffect = m_params.get(CameraParameters::KEY_EFFECT);
@@ -1394,7 +1394,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     const char *strNewGpsAltitude = params.get(CameraParameters::KEY_GPS_ALTITUDE);
 
     if (m_secCamera->setGpsAltitude(strNewGpsAltitude) == false) {
-        LOGE("ERR(%s):m_secCamera->setGpsAltitude(%s) fail", __func__, strNewGpsAltitude);
+        ALOGE("ERR(%s):m_secCamera->setGpsAltitude(%s) fail", __func__, strNewGpsAltitude);
         ret = UNKNOWN_ERROR;
     } else {
         if (strNewGpsAltitude)
@@ -1406,7 +1406,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     // gps latitude
     const char *strNewGpsLatitude = params.get(CameraParameters::KEY_GPS_LATITUDE);
     if (m_secCamera->setGpsLatitude(strNewGpsLatitude) == false) {
-        LOGE("ERR(%s):m_secCamera->setGpsLatitude(%s) fail", __func__, strNewGpsLatitude);
+        ALOGE("ERR(%s):m_secCamera->setGpsLatitude(%s) fail", __func__, strNewGpsLatitude);
         ret = UNKNOWN_ERROR;
     } else {
         if (strNewGpsLatitude)
@@ -1418,7 +1418,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     // gps longitude
     const char *strNewGpsLongtitude = params.get(CameraParameters::KEY_GPS_LONGITUDE);
     if (m_secCamera->setGpsLongitude(strNewGpsLongtitude) == false) {
-        LOGE("ERR(%s):m_secCamera->setGpsLongitude(%s) fail", __func__, strNewGpsLongtitude);
+        ALOGE("ERR(%s):m_secCamera->setGpsLongitude(%s) fail", __func__, strNewGpsLongtitude);
         ret = UNKNOWN_ERROR;
     } else {
         if (strNewGpsLongtitude)
@@ -1431,7 +1431,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     const char *strNewGpsProcessingMethod = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
 
     if (m_secCamera->setGpsProcessingMethod(strNewGpsProcessingMethod) == false) {
-        LOGE("ERR(%s):m_secCamera->setGpsProcessingMethod(%s) fail", __func__, strNewGpsProcessingMethod);
+        ALOGE("ERR(%s):m_secCamera->setGpsProcessingMethod(%s) fail", __func__, strNewGpsProcessingMethod);
         ret = UNKNOWN_ERROR;
     } else {
         if (strNewGpsProcessingMethod)
@@ -1443,7 +1443,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     // gps timestamp
     const char *strNewGpsTimestamp = params.get(CameraParameters::KEY_GPS_TIMESTAMP);
     if (m_secCamera->setGpsTimeStamp(strNewGpsTimestamp) == false) {
-        LOGE("ERR(%s):m_secCamera->setGpsTimeStamp(%s) fail", __func__, strNewGpsTimestamp);
+        ALOGE("ERR(%s):m_secCamera->setGpsTimeStamp(%s) fail", __func__, strNewGpsTimestamp);
         ret = UNKNOWN_ERROR;
     } else {
         if (strNewGpsTimestamp)
@@ -1459,10 +1459,10 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     int newBrightness = params.getInt("brightness");
     int maxBrightness = params.getInt("brightness-max");
     int minBrightness = params.getInt("brightness-min");
-    LOGV("DEBUG(%s):newBrightness %d", __func__, newBrightness);
+    ALOGV("DEBUG(%s):newBrightness %d", __func__, newBrightness);
     if ((minBrightness <= newBrightness) && (newBrightness <= maxBrightness)) {
         if (m_secCamera->setBrightness(newBrightness) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setBrightness(%d)", __func__, newBrightness);
+            ALOGE("ERR(%s):Fail on m_secCamera->setBrightness(%d)", __func__, newBrightness);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set("brightness", newBrightness);
@@ -1473,10 +1473,10 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     int newSaturation = params.getInt("saturation");
     int maxSaturation = params.getInt("saturation-max");
     int minSaturation = params.getInt("saturation-min");
-    LOGV("DEBUG(%s):newSaturation %d", __func__, newSaturation);
+    ALOGV("DEBUG(%s):newSaturation %d", __func__, newSaturation);
     if ((minSaturation <= newSaturation) && (newSaturation <= maxSaturation)) {
         if (m_secCamera->setSaturation(newSaturation) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setSaturation(%d)", __func__, newSaturation);
+            ALOGE("ERR(%s):Fail on m_secCamera->setSaturation(%d)", __func__, newSaturation);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set("saturation", newSaturation);
@@ -1487,10 +1487,10 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     int newSharpness = params.getInt("sharpness");
     int maxSharpness = params.getInt("sharpness-max");
     int minSharpness = params.getInt("sharpness-min");
-    LOGV("DEBUG(%s):newSharpness %d", __func__, newSharpness);
+    ALOGV("DEBUG(%s):newSharpness %d", __func__, newSharpness);
     if ((minSharpness <= newSharpness) && (newSharpness <= maxSharpness)) {
         if (m_secCamera->setSharpness(newSharpness) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setSharpness(%d)", __func__, newSharpness);
+            ALOGE("ERR(%s):Fail on m_secCamera->setSharpness(%d)", __func__, newSharpness);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set("sharpness", newSharpness);
@@ -1501,10 +1501,10 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
     int newHue = params.getInt("hue");
     int maxHue = params.getInt("hue-max");
     int minHue = params.getInt("hue-min");
-    LOGV("DEBUG(%s):newHue %d", __func__, newHue);
+    ALOGV("DEBUG(%s):newHue %d", __func__, newHue);
     if ((minHue <= newHue) && (maxHue >= newHue)) {
         if (m_secCamera->setHue(newHue) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setHue(hue(%d))", __func__, newHue);
+            ALOGE("ERR(%s):Fail on m_secCamera->setHue(hue(%d))", __func__, newHue);
             ret = UNKNOWN_ERROR;
         } else {
             m_params.set("hue", newHue);
@@ -1513,7 +1513,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // ISO
     const char *strNewISO = params.get("iso");
-    LOGV("DEBUG(%s):strNewISO %s", __func__, strNewISO);
+    ALOGV("DEBUG(%s):strNewISO %s", __func__, strNewISO);
     if (strNewISO != NULL) {
         int newISO = -1;
 
@@ -1522,14 +1522,14 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         else {
             newISO = (int)atoi(strNewISO);
             if (newISO == 0) {
-                LOGE("ERR(%s):Invalid iso value(%s)", __func__, strNewISO);
+                ALOGE("ERR(%s):Invalid iso value(%s)", __func__, strNewISO);
                 ret = UNKNOWN_ERROR;
             }
         }
 
         if (0 <= newISO) {
             if (m_secCamera->setISO(newISO) == false) {
-                LOGE("ERR(%s):Fail on m_secCamera->setISO(iso(%d))", __func__, newISO);
+                ALOGE("ERR(%s):Fail on m_secCamera->setISO(iso(%d))", __func__, newISO);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set("iso", strNewISO);
@@ -1539,7 +1539,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     //contrast
     const char *strNewContrast = params.get("contrast");
-    LOGV("DEBUG(%s):strNewContrast %s", __func__, strNewContrast);
+    ALOGV("DEBUG(%s):strNewContrast %s", __func__, strNewContrast);
     if (strNewContrast != NULL) {
         int newContrast = -1;
 
@@ -1556,13 +1556,13 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         else if (!strcmp(strNewContrast, "2"))
             newContrast = ExynosCamera::CONTRAST_PLUS_2;
         else {
-            LOGE("ERR(%s):Invalid contrast value(%s)", __func__, strNewContrast);
+            ALOGE("ERR(%s):Invalid contrast value(%s)", __func__, strNewContrast);
             ret = UNKNOWN_ERROR;
         }
 
         if (0 <= newContrast) {
             if (m_secCamera->setContrast(newContrast) == false) {
-                LOGE("ERR(%s):Fail on m_secCamera->setContrast(contrast(%d))", __func__, newContrast);
+                ALOGE("ERR(%s):Fail on m_secCamera->setContrast(contrast(%d))", __func__, newContrast);
                 ret = UNKNOWN_ERROR;
             } else {
                 m_params.set("contrast", strNewContrast);
@@ -1572,31 +1572,31 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     //WDR
     int newWdr = params.getInt("wdr");
-    LOGV("DEBUG(%s):newWdr %d", __func__, newWdr);
+    ALOGV("DEBUG(%s):newWdr %d", __func__, newWdr);
     if (0 <= newWdr) {
         if (m_secCamera->setWDR(newWdr) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setWDR(%d)", __func__, newWdr);
+            ALOGE("ERR(%s):Fail on m_secCamera->setWDR(%d)", __func__, newWdr);
             ret = UNKNOWN_ERROR;
         }
     }
 
     //anti shake
     int newAntiShake = m_internalParams.getInt("anti-shake");
-    LOGV("DEBUG(%s):newAntiShake %d", __func__, newAntiShake);
+    ALOGV("DEBUG(%s):newAntiShake %d", __func__, newAntiShake);
     if (0 <= newAntiShake) {
         bool toggle = false;
         if (newAntiShake == 1)
             toggle = true;
 
         if (m_secCamera->setAntiShake(toggle) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setAntiShake(%d)", __func__, newAntiShake);
+            ALOGE("ERR(%s):Fail on m_secCamera->setAntiShake(%d)", __func__, newAntiShake);
             ret = UNKNOWN_ERROR;
         }
     }
 
     //gamma
     const char *strNewGamma = m_internalParams.get("video_recording_gamma");
-    LOGV("DEBUG(%s):strNewGamma %s", __func__, strNewGamma);
+    ALOGV("DEBUG(%s):strNewGamma %s", __func__, strNewGamma);
     if (strNewGamma != NULL) {
         int newGamma = -1;
         if (!strcmp(strNewGamma, "off"))
@@ -1604,7 +1604,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         else if (!strcmp(strNewGamma, "on"))
             newGamma = 1;
         else {
-            LOGE("ERR(%s):unmatched gamma(%s)", __func__, strNewGamma);
+            ALOGE("ERR(%s):unmatched gamma(%s)", __func__, strNewGamma);
             ret = UNKNOWN_ERROR;
         }
 
@@ -1614,7 +1614,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
                 toggle = true;
 
             if (m_secCamera->setGamma(toggle) == false) {
-                LOGE("ERR(%s):m_secCamera->setGamma(%s) fail", __func__, strNewGamma);
+                ALOGE("ERR(%s):m_secCamera->setGamma(%s) fail", __func__, strNewGamma);
                 ret = UNKNOWN_ERROR;
             }
         }
@@ -1622,7 +1622,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     //slow ae
     const char *strNewSlowAe = m_internalParams.get("slow_ae");
-    LOGV("DEBUG(%s):strNewSlowAe %s", __func__, strNewSlowAe);
+    ALOGV("DEBUG(%s):strNewSlowAe %s", __func__, strNewSlowAe);
     if (strNewSlowAe != NULL) {
         int newSlowAe = -1;
 
@@ -1631,7 +1631,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
         else if (!strcmp(strNewSlowAe, "on"))
             newSlowAe = 1;
         else {
-            LOGE("ERR(%s):unmatched slow_ae(%s)", __func__, strNewSlowAe);
+            ALOGE("ERR(%s):unmatched slow_ae(%s)", __func__, strNewSlowAe);
             ret = UNKNOWN_ERROR;
         }
 
@@ -1640,7 +1640,7 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
             if (newSlowAe == 1)
                 toggle = true;
             if (m_secCamera->setSlowAE(newSlowAe) == false) {
-                LOGE("ERR(%s):m_secCamera->setSlowAE(%d) fail", __func__, newSlowAe);
+                ALOGE("ERR(%s):m_secCamera->setSlowAE(%d) fail", __func__, newSlowAe);
                 ret = UNKNOWN_ERROR;
             }
         }
@@ -1648,24 +1648,24 @@ status_t ExynosCameraHWInterface::setParameters(const CameraParameters& params)
 
     // Shot mode
     int newShotMode = m_internalParams.getInt("shot_mode");
-    LOGV("DEBUG(%s):newShotMode %d", __func__, newShotMode);
+    ALOGV("DEBUG(%s):newShotMode %d", __func__, newShotMode);
     if (0 <= newShotMode) {
         if (m_secCamera->setShotMode(newShotMode) == false) {
-            LOGE("ERR(%s):Fail on m_secCamera->setShotMode(%d)", __func__, newShotMode);
+            ALOGE("ERR(%s):Fail on m_secCamera->setShotMode(%d)", __func__, newShotMode);
             ret = UNKNOWN_ERROR;
         }
     } else {
         newShotMode=0;
     }
 
-    LOGV("DEBUG(%s):return ret = %d", __func__, ret);
+    ALOGV("DEBUG(%s):return ret = %d", __func__, ret);
 
     return ret;
 }
 
 CameraParameters ExynosCameraHWInterface::getParameters() const
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return m_params;
 }
 
@@ -1675,31 +1675,31 @@ status_t ExynosCameraHWInterface::sendCommand(int32_t command, int32_t arg1, int
     case CAMERA_CMD_START_FACE_DETECTION:
     case CAMERA_CMD_STOP_FACE_DETECTION:
         if (m_secCamera->getMaxNumDetectedFaces() == 0) {
-            LOGE("ERR(%s):getMaxNumDetectedFaces == 0", __func__);
+            ALOGE("ERR(%s):getMaxNumDetectedFaces == 0", __func__);
             return BAD_VALUE;
         }
 
         if (arg1 == CAMERA_FACE_DETECTION_SW) {
-            LOGE("ERR(%s):only support HW face dectection", __func__);
+            ALOGE("ERR(%s):only support HW face dectection", __func__);
             return BAD_VALUE;
         }
 
         if (command == CAMERA_CMD_START_FACE_DETECTION) {
             if (   m_secCamera->flagStartFaceDetection() == false
                 && m_secCamera->startFaceDetection() == false) {
-                LOGE("ERR(%s):startFaceDetection() fail", __func__);
+                ALOGE("ERR(%s):startFaceDetection() fail", __func__);
                 return BAD_VALUE;
             }
         } else { // if (command == CAMERA_CMD_STOP_FACE_DETECTION)
             if (   m_secCamera->flagStartFaceDetection() == true
                 && m_secCamera->stopFaceDetection() == false) {
-                LOGE("ERR(%s):stopFaceDetection() fail", __func__);
+                ALOGE("ERR(%s):stopFaceDetection() fail", __func__);
                 return BAD_VALUE;
             }
         }
         break;
     default:
-        LOGE("ERR(%s):unexpectect command(%d) fail", __func__, command);
+        ALOGE("ERR(%s):unexpectect command(%d) fail", __func__, command);
         return BAD_VALUE;
         break;
     }
@@ -1708,7 +1708,7 @@ status_t ExynosCameraHWInterface::sendCommand(int32_t command, int32_t arg1, int
 
 void ExynosCameraHWInterface::release()
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%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
@@ -1777,7 +1777,7 @@ void ExynosCameraHWInterface::release()
 
     if (m_pictureRunning == true) {
         if (m_stopPictureInternal() == false)
-            LOGE("ERR(%s):m_stopPictureInternal() fail", __func__);
+            ALOGE("ERR(%s):m_stopPictureInternal() fail", __func__);
     }
 
     if (m_exynosVideoCSC)
@@ -1827,7 +1827,7 @@ int ExynosCameraHWInterface::getCameraId() const
 void ExynosCameraHWInterface::m_initDefaultParameters(int cameraId)
 {
     if (m_secCamera == NULL) {
-        LOGE("ERR(%s):m_secCamera object is NULL", __func__);
+        ALOGE("ERR(%s):m_secCamera object is NULL", __func__);
         return;
     }
 
@@ -1839,7 +1839,7 @@ void ExynosCameraHWInterface::m_initDefaultParameters(int cameraId)
     char * cameraName;
     cameraName = m_secCamera->getCameraName();
     if (cameraName == NULL)
-        LOGE("ERR(%s):getCameraName() fail", __func__);
+        ALOGE("ERR(%s):getCameraName() fail", __func__);
 
     /*
     if (cameraId == ExynosCamera::CAMERA_ID_BACK) {
@@ -1869,7 +1869,7 @@ void ExynosCameraHWInterface::m_initDefaultParameters(int cameraId)
 
     listString.setTo("");
     if (m_getResolutionList(listString, strBuf, previewMaxW, previewMaxH) == false) {
-        LOGE("ERR(%s):m_getResolutionList() fail", __func__);
+        ALOGE("ERR(%s):m_getResolutionList() fail", __func__);
 
         previewMaxW = 640;
         previewMaxH = 480;
@@ -1892,7 +1892,7 @@ void ExynosCameraHWInterface::m_initDefaultParameters(int cameraId)
 
     listString.setTo("");
     if (m_getResolutionList(listString, strBuf, videoMaxW, videoMaxH) == false) {
-        LOGE("ERR(%s):m_getResolutionList() fail", __func__);
+        ALOGE("ERR(%s):m_getResolutionList() fail", __func__);
 
         videoMaxW = 640;
         videoMaxH = 480;
@@ -1926,7 +1926,7 @@ void ExynosCameraHWInterface::m_initDefaultParameters(int cameraId)
 
     listString.setTo("");
     if (m_getResolutionList(listString, strBuf, pictureMaxW, pictureMaxH) == false) {
-        LOGE("ERR(%s):m_getResolutionList() fail", __func__);
+        ALOGE("ERR(%s):m_getResolutionList() fail", __func__);
 
         pictureMaxW = 640;
         pictureMaxW = 480;
@@ -2368,7 +2368,7 @@ void ExynosCameraHWInterface::m_initDefaultParameters(int cameraId)
 
 bool ExynosCameraHWInterface::m_startPreviewInternal(void)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
     int i;
     int previewW, previewH, previewFormat, previewFramesize;
@@ -2390,11 +2390,11 @@ bool ExynosCameraHWInterface::m_startPreviewInternal(void)
         m_avaliblePreviewBufHandle[i] = false;
 
         if (m_previewWindow->dequeue_buffer(m_previewWindow, &m_previewBufHandle[i], &m_previewStride[i]) != 0) {
-            LOGE("ERR(%s):Could not dequeue gralloc buffer[%d]!!", __func__, i);
+            ALOGE("ERR(%s):Could not dequeue gralloc buffer[%d]!!", __func__, i);
             continue;
         } else {
              if (m_previewWindow->lock_buffer(m_previewWindow, m_previewBufHandle[i]) != 0)
-                 LOGE("ERR(%s):Could not lock gralloc buffer[%d]!!", __func__, i);
+                 ALOGE("ERR(%s):Could not lock gralloc buffer[%d]!!", __func__, i);
         }
 
         if (m_flagGrallocLocked[i] == false) {
@@ -2402,10 +2402,10 @@ bool ExynosCameraHWInterface::m_startPreviewInternal(void)
                                    *m_previewBufHandle[i],
                                    GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_YUV_ADDR,
                                    0, 0, previewW, previewH, virtAddr) != 0) {
-                LOGE("ERR(%s):could not obtain gralloc buffer", __func__);
+                ALOGE("ERR(%s):could not obtain gralloc buffer", __func__);
 
                 if (m_previewWindow->cancel_buffer(m_previewWindow, m_previewBufHandle[i]) != 0)
-                    LOGE("ERR(%s):Could not cancel_buffer gralloc buffer[%d]!!", __func__, i);
+                    ALOGE("ERR(%s):Could not cancel_buffer gralloc buffer[%d]!!", __func__, i);
 
                 continue;
             }
@@ -2431,7 +2431,7 @@ bool ExynosCameraHWInterface::m_startPreviewInternal(void)
 
         m_previewHeap[i] = m_getMemoryCb(-1, previewFramesize, 1, 0);
         if (!m_previewHeap[i]) {
-            LOGE("ERR(%s):m_getMemoryCb(m_previewHeap[%d], size(%d) fail", __func__, i, previewFramesize);
+            ALOGE("ERR(%s):m_getMemoryCb(m_previewHeap[%d], size(%d) fail", __func__, i, previewFramesize);
             continue;
         }
 
@@ -2439,13 +2439,13 @@ bool ExynosCameraHWInterface::m_startPreviewInternal(void)
     }
 
     if (m_secCamera->startPreview() == false) {
-        LOGE("ERR(%s):Fail on m_secCamera->startPreview()", __func__);
+        ALOGE("ERR(%s):Fail on m_secCamera->startPreview()", __func__);
         return false;
     }
 
     for (i = NUM_OF_PREVIEW_BUF - m_minUndequeuedBufs; i < NUM_OF_PREVIEW_BUF; i++) {
         if (m_secCamera->getPreviewBuf(&previewBuf) == false) {
-            LOGE("ERR(%s):getPreviewBuf() fail", __func__);
+            ALOGE("ERR(%s):getPreviewBuf() fail", __func__);
             return false;
         }
 
@@ -2455,7 +2455,7 @@ bool ExynosCameraHWInterface::m_startPreviewInternal(void)
         }
 
         if (m_previewWindow->cancel_buffer(m_previewWindow, m_previewBufHandle[previewBuf.reserved.p]) != 0)
-            LOGE("ERR(%s):Could not cancel_buffer gralloc buffer[%d]!!", __func__, previewBuf.reserved.p);
+            ALOGE("ERR(%s):Could not cancel_buffer gralloc buffer[%d]!!", __func__, previewBuf.reserved.p);
 
         m_avaliblePreviewBufHandle[previewBuf.reserved.p] = false;
     }
@@ -2464,14 +2464,14 @@ bool ExynosCameraHWInterface::m_startPreviewInternal(void)
 
     if (m_pictureRunning == false
         && m_startPictureInternal() == false)
-        LOGE("ERR(%s):m_startPictureInternal() fail", __func__);
+        ALOGE("ERR(%s):m_startPictureInternal() fail", __func__);
 
     return true;
 }
 
 void ExynosCameraHWInterface::m_stopPreviewInternal(void)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
     /* request that the preview thread stop. */
     if (m_previewRunning == true) {
@@ -2491,7 +2491,7 @@ void ExynosCameraHWInterface::m_stopPreviewInternal(void)
 
                     if (m_avaliblePreviewBufHandle[i] == true) {
                         if (m_previewWindow->cancel_buffer(m_previewWindow, m_previewBufHandle[i]) != 0) {
-                            LOGE("ERR(%s):Fail to cancel buffer(%d)", __func__, i);
+                            ALOGE("ERR(%s):Fail to cancel buffer(%d)", __func__, i);
                         } else {
                             m_previewBufHandle[i] = NULL;
                             m_previewStride[i] = NULL;
@@ -2502,35 +2502,35 @@ void ExynosCameraHWInterface::m_stopPreviewInternal(void)
                 }
             }
         } else {
-            LOGV("DEBUG(%s):preview running but deferred, doing nothing", __func__);
+            ALOGV("DEBUG(%s):preview running but deferred, doing nothing", __func__);
         }
     } else {
-        LOGV("DEBUG(%s):preview not running, doing nothing", __func__);
+        ALOGV("DEBUG(%s):preview not running, doing nothing", __func__);
     }
 }
 
 bool ExynosCameraHWInterface::m_previewThreadFuncWrapper(void)
 {
-    LOGV("DEBUG(%s):starting", __func__);
+    ALOGV("DEBUG(%s):starting", __func__);
     while (1) {
         m_previewLock.lock();
         while (m_previewRunning == false) {
             if (   m_secCamera->flagStartPreview() == true
                 && m_secCamera->stopPreview() == false)
-                LOGE("ERR(%s):Fail on m_secCamera->stopPreview()", __func__);
+                ALOGE("ERR(%s):Fail on m_secCamera->stopPreview()", __func__);
 
-            LOGV("DEBUG(%s):calling m_secCamera->stopPreview() and waiting", __func__);
+            ALOGV("DEBUG(%s):calling m_secCamera->stopPreview() and waiting", __func__);
 
             m_previewStoppedCondition.signal();
             m_previewCondition.wait(m_previewLock);
-            LOGV("DEBUG(%s):return from wait", __func__);
+            ALOGV("DEBUG(%s):return from wait", __func__);
         }
         m_previewLock.unlock();
 
         if (m_exitPreviewThread == true) {
             if (   m_secCamera->flagStartPreview() == true
                 && m_secCamera->stopPreview() == false)
-                LOGE("ERR(%s):Fail on m_secCamera->stopPreview()", __func__);
+                ALOGE("ERR(%s):Fail on m_secCamera->stopPreview()", __func__);
 
             return true;
         }
@@ -2546,7 +2546,7 @@ bool ExynosCameraHWInterface::m_previewThreadFunc(void)
     bool doPutPreviewBuf = true;
 
     if (m_secCamera->getPreviewBuf(&previewBuf) == false) {
-        LOGE("ERR(%s):getPreviewBuf() fail", __func__);
+        ALOGE("ERR(%s):getPreviewBuf() fail", __func__);
         return false;
     }
 
@@ -2562,11 +2562,11 @@ bool ExynosCameraHWInterface::m_previewThreadFunc(void)
     if (0 < m_skipFrame) {
         m_skipFrame--;
         m_skipFrameLock.unlock();
-        LOGV("DEBUG(%s):skipping %d frame", __func__, previewBuf.reserved.p);
+        ALOGV("DEBUG(%s):skipping %d frame", __func__, previewBuf.reserved.p);
 
         if (   doPutPreviewBuf == true
             && m_secCamera->putPreviewBuf(&previewBuf) == false) {
-            LOGE("ERR(%s):putPreviewBuf(%d) fail", __func__, previewBuf.reserved.p);
+            ALOGE("ERR(%s):putPreviewBuf(%d) fail", __func__, previewBuf.reserved.p);
             return false;
         }
 
@@ -2590,14 +2590,14 @@ bool ExynosCameraHWInterface::m_previewThreadFunc(void)
             m_flagGrallocLocked[previewBuf.reserved.p] = false;
         } else {
             if (m_previewWindow->lock_buffer(m_previewWindow, bufHandle) != 0)
-                LOGE("ERR(%s):Could not lock gralloc buffer!!", __func__);
+                ALOGE("ERR(%s):Could not lock gralloc buffer!!", __func__);
         }
 
         /* Enqueue lastest buffer */
         if (m_avaliblePreviewBufHandle[previewBuf.reserved.p] == true) {
             if (m_previewWindow->enqueue_buffer(m_previewWindow,
                                                 m_previewBufHandle[previewBuf.reserved.p]) != 0) {
-                LOGE("ERR(%s):Could not enqueue gralloc buffer[%d]!!", __func__, previewBuf.reserved.p);
+                ALOGE("ERR(%s):Could not enqueue gralloc buffer[%d]!!", __func__, previewBuf.reserved.p);
                 goto callbacks;
             }
 
@@ -2608,7 +2608,7 @@ bool ExynosCameraHWInterface::m_previewThreadFunc(void)
         if (m_previewWindow->dequeue_buffer(m_previewWindow,
                                             &bufHandle,
                                             &stride) != 0) {
-            LOGE("ERR(%s):Could not dequeue gralloc buffer!!", __func__);
+            ALOGE("ERR(%s):Could not dequeue gralloc buffer!!", __func__);
             goto callbacks;
         }
 
@@ -2617,7 +2617,7 @@ bool ExynosCameraHWInterface::m_previewThreadFunc(void)
                                *bufHandle,
                                GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_YUV_ADDR,
                                0, 0, previewW, previewH, virtAddr) != 0) {
-            LOGE("ERR(%s):could not obtain gralloc buffer", __func__);
+            ALOGE("ERR(%s):could not obtain gralloc buffer", __func__);
             goto callbacks;
         }
 
@@ -2641,13 +2641,13 @@ bool ExynosCameraHWInterface::m_previewThreadFunc(void)
         }
 
         if (findGrallocBuf == false) {
-            LOGE("%s:addr(%x) is not matched any gralloc buffer's addr", __func__, virtAddr[0]);
+            ALOGE("%s:addr(%x) is not matched any gralloc buffer's addr", __func__, virtAddr[0]);
             goto callbacks;
         }
 
         if (   doPutPreviewBuf == true
             && m_secCamera->putPreviewBuf(&previewBuf) == false)
-            LOGE("ERR(%s):putPreviewBuf(%d) fail", __func__, previewBuf.reserved.p);
+            ALOGE("ERR(%s):putPreviewBuf(%d) fail", __func__, previewBuf.reserved.p);
         else
             doPutPreviewBuf = false;
     }
@@ -2696,16 +2696,16 @@ callbacks:
                               0);
 
             if (csc_convert(m_exynosPreviewCSC) != 0)
-                LOGE("ERR(%s):csc_convert() fail", __func__);
+                ALOGE("ERR(%s):csc_convert() fail", __func__);
         } else {
-            LOGE("ERR(%s):m_exynosPreviewCSC == NULL", __func__);
+            ALOGE("ERR(%s):m_exynosPreviewCSC == NULL", __func__);
         }
     }
 
     /* TODO: We need better error handling scheme than this scheme */
     if (   doPutPreviewBuf == true
         && m_secCamera->putPreviewBuf(&previewBuf) == false)
-        LOGE("ERR(%s):putPreviewBuf(%d) fail", __func__, previewBuf.reserved.p);
+        ALOGE("ERR(%s):putPreviewBuf(%d) fail", __func__, previewBuf.reserved.p);
     else
         doPutPreviewBuf = false;
 
@@ -2790,7 +2790,7 @@ callbacks:
     // zero shutter lag
     if (m_pictureRunning == false
         && m_startPictureInternal() == false)
-        LOGE("ERR(%s):m_startPictureInternal() fail", __func__);
+        ALOGE("ERR(%s):m_startPictureInternal() fail", __func__);
 
     m_stateLock.lock();
     if (m_captureInProgress == true) {
@@ -2810,7 +2810,7 @@ callbacks:
             } while (cur->next);
 
             if (m_secCamera->getPictureBuf(&m_pictureBuf) == false)
-                LOGE("ERR(%s):getPictureBuf() fail", __func__);
+                ALOGE("ERR(%s):getPictureBuf() fail", __func__);
             else
                 m_numOfAvaliblePictureBuf++;
         }
@@ -2833,7 +2833,7 @@ callbacks:
 
             if (oldBuf != nullBuf) {
                 if (m_secCamera->putPictureBuf(&oldBuf) == false)
-                    LOGE("ERR(%s):putPictureBuf(%d) fail", __func__, oldBuf.reserved.p);
+                    ALOGE("ERR(%s):putPictureBuf(%d) fail", __func__, oldBuf.reserved.p);
                 else {
                     m_numOfAvaliblePictureBuf--;
                     if (m_numOfAvaliblePictureBuf < 0)
@@ -2856,14 +2856,14 @@ bool ExynosCameraHWInterface::m_videoThreadFuncWrapper(void)
 #ifdef USE_3DNR_DMAOUT
             if (   m_secCamera->flagStartVideo() == true
                 && m_secCamera->stopVideo() == false)
-                LOGE("ERR(%s):Fail on m_secCamera->stopVideo()", __func__);
+                ALOGE("ERR(%s):Fail on m_secCamera->stopVideo()", __func__);
 #endif
 
-            LOGV("DEBUG(%s):calling mExynosCamera->stopVideo() and waiting", __func__);
+            ALOGV("DEBUG(%s):calling mExynosCamera->stopVideo() and waiting", __func__);
 
             m_videoStoppedCondition.signal();
             m_videoCondition.wait(m_videoLock);
-            LOGV("DEBUG(%s):return from wait", __func__);
+            ALOGV("DEBUG(%s):return from wait", __func__);
 
             m_videoLock.unlock();
         }
@@ -2874,7 +2874,7 @@ bool ExynosCameraHWInterface::m_videoThreadFuncWrapper(void)
 #ifdef USE_3DNR_DMAOUT
             if (   m_secCamera->flagStartVideo() == true
                 && m_secCamera->stopVideo() == false)
-                LOGE("ERR(%s):Fail on m_secCamera->stopVideo()", __func__);
+                ALOGE("ERR(%s):Fail on m_secCamera->stopVideo()", __func__);
 #endif
 
             m_videoLock.unlock();
@@ -2906,13 +2906,13 @@ bool ExynosCameraHWInterface::m_videoThreadFunc(void)
             Mutex::Autolock lock(m_videoLock);
 
             if (m_numOfAvailableVideoBuf == 0) {
-                LOGV("DEBUG(%s):waiting releaseRecordingFrame()", __func__);
+                ALOGV("DEBUG(%s):waiting releaseRecordingFrame()", __func__);
                 return true;
             }
 
 #ifdef USE_3DNR_DMAOUT
             if (m_secCamera->getVideoBuf(&videoBuf) == false) {
-                LOGE("ERR(%s):Fail on ExynosCamera->getVideoBuf()", __func__);
+                ALOGE("ERR(%s):Fail on ExynosCamera->getVideoBuf()", __func__);
                 return false;
             }
 #endif
@@ -2946,7 +2946,7 @@ bool ExynosCameraHWInterface::m_videoThreadFunc(void)
                                    &cropW, &cropH,
                                    m_secCamera->getZoom());
 
-                    LOGV("DEBUG(%s):cropX = %d, cropY = %d, cropW = %d, cropH = %d",
+                    ALOGV("DEBUG(%s):cropX = %d, cropY = %d, cropW = %d, cropH = %d",
                              __func__, cropX, cropY, cropW, cropH);
 
 #ifdef USE_3DNR_DMAOUT
@@ -3003,9 +3003,9 @@ bool ExynosCameraHWInterface::m_videoThreadFunc(void)
                                       0);
 
                     if (csc_convert(m_exynosVideoCSC) != 0)
-                        LOGE("ERR(%s):csc_convert() fail", __func__);
+                        ALOGE("ERR(%s):csc_convert() fail", __func__);
                 } else {
-                    LOGE("ERR(%s):m_exynosVideoCSC == NULL", __func__);
+                    ALOGE("ERR(%s):m_exynosVideoCSC == NULL", __func__);
                 }
 #ifdef USE_3DNR_DMAOUT
                 m_dataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME,
@@ -3038,7 +3038,7 @@ bool ExynosCameraHWInterface::m_autoFocusThreadFunc(void)
 {
     int count =0;
     bool afResult = false;
-    LOGV("DEBUG(%s):starting", __func__);
+    ALOGV("DEBUG(%s):starting", __func__);
 
     /* block until we're told to start.  we don't want to use
      * a restartable thread and requestExitAndWait() in cancelAutoFocus()
@@ -3050,7 +3050,7 @@ bool ExynosCameraHWInterface::m_autoFocusThreadFunc(void)
     /* check early exit request */
     if (m_exitAutoFocusThread == true) {
         m_focusLock.unlock();
-        LOGV("DEBUG(%s):exiting on request0", __func__);
+        ALOGV("DEBUG(%s):exiting on request0", __func__);
         return true;
     }
 
@@ -3058,27 +3058,27 @@ bool ExynosCameraHWInterface::m_autoFocusThreadFunc(void)
     /* check early exit request */
     if (m_exitAutoFocusThread == true) {
         m_focusLock.unlock();
-        LOGV("DEBUG(%s):exiting on request1", __func__);
+        ALOGV("DEBUG(%s):exiting on request1", __func__);
         return true;
     }
     m_focusLock.unlock();
 
     if (m_secCamera->autoFocus() == false) {
-        LOGE("ERR(%s):Fail on m_secCamera->autoFocus()", __func__);
+        ALOGE("ERR(%s):Fail on m_secCamera->autoFocus()", __func__);
         return false;
     }
 
     switch (m_secCamera->getFucusModeResult()) {
     case 0:
-        LOGV("DEBUG(%s):AF Cancelled !!", __func__);
+        ALOGV("DEBUG(%s):AF Cancelled !!", __func__);
         afResult = true;
         break;
     case 1:
-        LOGV("DEBUG(%s):AF Success!!", __func__);
+        ALOGV("DEBUG(%s):AF Success!!", __func__);
         afResult = true;
         break;
     default:
-        LOGV("DEBUG(%s):AF Fail !!", __func__);
+        ALOGV("DEBUG(%s):AF Fail !!", __func__);
         afResult = false;
         break;
     }
@@ -3089,14 +3089,14 @@ bool ExynosCameraHWInterface::m_autoFocusThreadFunc(void)
     if (m_msgEnabled & CAMERA_MSG_FOCUS)
         m_notifyCb(CAMERA_MSG_FOCUS, afResult, 0, m_callbackCookie);
 
-    LOGV("DEBUG(%s):exiting with no error", __func__);
+    ALOGV("DEBUG(%s):exiting with no error", __func__);
     return true;
 }
 
 bool ExynosCameraHWInterface::m_startPictureInternal(void)
 {
     if (m_pictureRunning == true) {
-        LOGE("ERR(%s):Aready m_pictureRunning is running", __func__);
+        ALOGE("ERR(%s):Aready m_pictureRunning is running", __func__);
         return false;
     }
 
@@ -3113,7 +3113,7 @@ bool ExynosCameraHWInterface::m_startPictureInternal(void)
     }
     m_rawHeap = m_getMemoryCb(-1, pictureFramesize, 1, NULL);
     if (!m_rawHeap) {
-        LOGE("ERR(%s):m_getMemoryCb(m_rawHeap, size(%d) fail", __func__, pictureFramesize);
+        ALOGE("ERR(%s):m_getMemoryCb(m_rawHeap, size(%d) fail", __func__, pictureFramesize);
         return false;
     }
 
@@ -3126,7 +3126,7 @@ bool ExynosCameraHWInterface::m_startPictureInternal(void)
 
         m_pictureHeap[i] = m_getMemoryCb(-1, pictureFramesize, 1, NULL);
         if (!m_pictureHeap[i]) {
-            LOGE("ERR(%s):m_getMemoryCb(m_pictureHeap[%d], size(%d) fail", __func__, i, pictureFramesize);
+            ALOGE("ERR(%s):m_getMemoryCb(m_pictureHeap[%d], size(%d) fail", __func__, i, pictureFramesize);
             return false;
         }
 
@@ -3147,7 +3147,7 @@ bool ExynosCameraHWInterface::m_startPictureInternal(void)
 
     // zero shutter lag
     if (m_secCamera->startPicture() == false) {
-        LOGE("ERR(%s):Fail on m_secCamera->startPicture()", __func__);
+        ALOGE("ERR(%s):Fail on m_secCamera->startPicture()", __func__);
         return false;
     }
 
@@ -3170,13 +3170,13 @@ bool ExynosCameraHWInterface::m_startPictureInternal(void)
 bool ExynosCameraHWInterface::m_stopPictureInternal(void)
 {
     if (m_pictureRunning == false) {
-        LOGE("ERR(%s):Aready m_pictureRunning is stop", __func__);
+        ALOGE("ERR(%s):Aready m_pictureRunning is stop", __func__);
         return false;
     }
 
     if (m_secCamera->flagStartPicture() == true
         && m_secCamera->stopPicture() == false)
-        LOGE("ERR(%s):Fail on m_secCamera->stopPicture()", __func__);
+        ALOGE("ERR(%s):Fail on m_secCamera->stopPicture()", __func__);
 
     for (int i = 0; i < NUM_OF_PICTURE_BUF; i++) {
         if (m_pictureHeap[i]) {
@@ -3214,7 +3214,7 @@ bool ExynosCameraHWInterface::m_pictureThreadFunc(void)
 
     JpegHeap = m_getMemoryCb(-1, pictureFramesize, 1, 0);
     if (!JpegHeap) {
-        LOGE("ERR(%s):m_getMemoryCb(JpegHeap, size(%d) fail", __func__, pictureFramesize);
+        ALOGE("ERR(%s):m_getMemoryCb(JpegHeap, size(%d) fail", __func__, pictureFramesize);
         return false;
     }
 
@@ -3226,7 +3226,7 @@ bool ExynosCameraHWInterface::m_pictureThreadFunc(void)
                        &cropW, &cropH,
                        m_secCamera->getZoom());
 
-        LOGV("DEBUG(%s):cropX = %d, cropY = %d, cropW = %d, cropH = %d",
+        ALOGV("DEBUG(%s):cropX = %d, cropY = %d, cropW = %d, cropH = %d",
               __func__, cropX, cropY, cropW, cropH);
 
         csc_set_src_format(m_exynosPictureCSC,
@@ -3262,9 +3262,9 @@ bool ExynosCameraHWInterface::m_pictureThreadFunc(void)
                            0);
 
         if (csc_convert(m_exynosPictureCSC) != 0)
-            LOGE("ERR(%s):csc_convert() fail", __func__);
+            ALOGE("ERR(%s):csc_convert() fail", __func__);
     } else {
-        LOGE("ERR(%s):m_exynosPictureCSC == NULL", __func__);
+        ALOGE("ERR(%s):m_exynosPictureCSC == NULL", __func__);
     }
 
     if (m_msgEnabled & CAMERA_MSG_SHUTTER)
@@ -3276,7 +3276,7 @@ bool ExynosCameraHWInterface::m_pictureThreadFunc(void)
         if (pictureBuf.size.extS[i] != 0)
             pictureBuf.virt.extP[i] = pictureBuf.virt.extP[i-1] + pictureBuf.size.extS[i-1];
 
-        LOGV("(%s): pictureBuf.size.extS[%d] = %d", __func__, i, pictureBuf.size.extS[i]);
+        ALOGV("(%s): pictureBuf.size.extS[%d] = %d", __func__, i, pictureBuf.size.extS[i]);
     }
 
     if (m_msgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
@@ -3289,7 +3289,7 @@ bool ExynosCameraHWInterface::m_pictureThreadFunc(void)
         jpegRect.colorFormat = V4L2_PIX_FMT_NV16;
 
         if (m_secCamera->yuv2Jpeg(&pictureBuf, &jpegBuf, &jpegRect) == false) {
-            LOGE("ERR(%s):yuv2Jpeg() fail", __func__);
+            ALOGE("ERR(%s):yuv2Jpeg() fail", __func__);
             m_stateLock.lock();
             m_captureInProgress = false;
             m_pictureLock.lock();
@@ -3322,7 +3322,7 @@ bool ExynosCameraHWInterface::m_pictureThreadFunc(void)
     if (m_msgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
         JpegHeapOut = m_getMemoryCb(-1, jpegBuf.size.s, 1, 0);
         if (!JpegHeapOut) {
-            LOGE("ERR(%s):m_getMemoryCb(JpegHeapOut, size(%d) fail", __func__, jpegBuf.size.s);
+            ALOGE("ERR(%s):m_getMemoryCb(JpegHeapOut, size(%d) fail", __func__, jpegBuf.size.s);
             return false;
         }
 
@@ -3335,7 +3335,7 @@ bool ExynosCameraHWInterface::m_pictureThreadFunc(void)
     if (m_videoStart == false)
         stopPreview();
 
-    LOGV("DEBUG(%s):m_pictureThread end", __func__);
+    ALOGV("DEBUG(%s):m_pictureThread end", __func__);
 
     ret = true;
 
@@ -3364,14 +3364,14 @@ bool ExynosCameraHWInterface::m_fileDump(char *filename, void *srcBuf, uint32_t
     yuv_fd = fopen(filename, "w+");
 
     if (yuv_fd == NULL) {
-        LOGE("ERR file open fail: %s", filename);
+        ALOGE("ERR file open fail: %s", filename);
         return 0;
     }
 
     buffer = (char *)malloc(size);
 
     if (buffer == NULL) {
-        LOGE("ERR malloc file");
+        ALOGE("ERR malloc file");
         fclose(yuv_fd);
         return 0;
     }
@@ -3389,7 +3389,7 @@ bool ExynosCameraHWInterface::m_fileDump(char *filename, void *srcBuf, uint32_t
     if (buffer)
         free(buffer);
 
-    LOGV("filedump(%s) is successed!!", filename);
+    ALOGV("filedump(%s) is successed!!", filename);
     return true;
 }
 #endif
@@ -3411,14 +3411,14 @@ int ExynosCameraHWInterface::m_saveJpeg( unsigned char *real_jpeg, int jpeg_size
     /* file create/open, note to "wb" */
     yuv_fp = fopen("/data/camera_dump.jpeg", "wb");
     if (yuv_fp == NULL) {
-        LOGE("Save jpeg file open error");
+        ALOGE("Save jpeg file open error");
         return -1;
     }
 
-    LOGV("DEBUG(%s):[BestIQ]  real_jpeg size ========>  %d", __func__, jpeg_size);
+    ALOGV("DEBUG(%s):[BestIQ]  real_jpeg size ========>  %d", __func__, jpeg_size);
     buffer = (char *) malloc(jpeg_size);
     if (buffer == NULL) {
-        LOGE("Save YUV] buffer alloc failed");
+        ALOGE("Save YUV] buffer alloc failed");
         if (yuv_fp)
             fclose(yuv_fp);
 
@@ -3447,24 +3447,24 @@ void ExynosCameraHWInterface::m_savePostView(const char *fname, uint8_t *buf, ui
     int cnt = 0;
     uint32_t written = 0;
 
-    LOGD("opening file [%s]", fname);
+    ALOGD("opening file [%s]", fname);
     int fd = open(fname, O_RDWR | O_CREAT);
     if (fd < 0) {
-        LOGE("failed to create file [%s]: %s", fname, strerror(errno));
+        ALOGE("failed to create file [%s]: %s", fname, strerror(errno));
         return;
     }
 
-    LOGD("writing %d bytes to file [%s]", size, fname);
+    ALOGD("writing %d bytes to file [%s]", 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));
+            ALOGE("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",size, fname, cnt);
+    ALOGD("done writing %d bytes to file [%s] in %d passes",size, fname, cnt);
     ::close(fd);
 }
 
@@ -3476,7 +3476,7 @@ bool ExynosCameraHWInterface::m_scaleDownYuv422(char *srcBuf, uint32_t srcWidth,
     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");
+        ALOGE("scale_down_yuv422: invalid width, height for scaling");
         return false;
     }
 
@@ -3534,7 +3534,7 @@ bool ExynosCameraHWInterface::m_YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t
 bool ExynosCameraHWInterface::m_checkVideoStartMarker(unsigned char *pBuf)
 {
     if (!pBuf) {
-        LOGE("m_checkVideoStartMarker() => pBuf is NULL");
+        ALOGE("m_checkVideoStartMarker() => pBuf is NULL");
         return false;
     }
 
@@ -3548,7 +3548,7 @@ bool ExynosCameraHWInterface::m_checkVideoStartMarker(unsigned char *pBuf)
 bool ExynosCameraHWInterface::m_checkEOIMarker(unsigned char *pBuf)
 {
     if (!pBuf) {
-        LOGE("m_checkEOIMarker() => pBuf is NULL");
+        ALOGE("m_checkEOIMarker() => pBuf is NULL");
         return false;
     }
 
@@ -3562,7 +3562,7 @@ bool ExynosCameraHWInterface::m_checkEOIMarker(unsigned char *pBuf)
 bool ExynosCameraHWInterface::m_findEOIMarkerInJPEG(unsigned char *pBuf, int dwBufSize, int *pnJPEGsize)
 {
     if (NULL == pBuf || 0 >= dwBufSize) {
-        LOGE("m_findEOIMarkerInJPEG() => There is no contents.");
+        ALOGE("m_findEOIMarkerInJPEG() => There is no contents.");
         return false;
     }
 
@@ -3583,15 +3583,15 @@ bool ExynosCameraHWInterface::m_splitFrame(unsigned char *pFrame, int dwSize,
                     void *pJPEG, int *pdwJPEGSize,
                     void *pVideo, int *pdwVideoSize)
 {
-    LOGV("DEBUG(%s):===========m_splitFrame Start==============", __func__);
+    ALOGV("DEBUG(%s):===========m_splitFrame Start==============", __func__);
 
     if (NULL == pFrame || 0 >= dwSize) {
-        LOGE("There is no contents (pFrame=%p, dwSize=%d", pFrame, dwSize);
+        ALOGE("There is no contents (pFrame=%p, dwSize=%d", pFrame, dwSize);
         return false;
     }
 
     if (0 == dwJPEGLineLength || 0 == dwVideoLineLength) {
-        LOGE("There in no input information for decoding interleaved jpeg");
+        ALOGE("There in no input information for decoding interleaved jpeg");
         return false;
     }
 
@@ -3660,14 +3660,14 @@ bool ExynosCameraHWInterface::m_splitFrame(unsigned char *pFrame, int dwSize,
         if (pdwVideoSize)
             *pdwVideoSize = dwVSize;
     } else {
-        LOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI");
+        ALOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI");
         bRet = false;
         if (pdwJPEGSize)
             *pdwJPEGSize = 0;
         if (pdwVideoSize)
             *pdwVideoSize = 0;
     }
-    LOGV("DEBUG(%s):===========m_splitFrame end==============", __func__);
+    ALOGV("DEBUG(%s):===========m_splitFrame end==============", __func__);
 
     return bRet;
 }
@@ -3693,7 +3693,7 @@ int ExynosCameraHWInterface::m_decodeInterleaveData(unsigned char *pInterleaveDa
 
     int i = 0;
 
-    LOGV("DEBUG(%s):m_decodeInterleaveData Start~~~", __func__);
+    ALOGV("DEBUG(%s):m_decodeInterleaveData Start~~~", __func__);
     while (i < interleaveDataSize) {
         if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) ||
                 (*interleave_ptr == 0xFF02FFFF)) {
@@ -3753,7 +3753,7 @@ int ExynosCameraHWInterface::m_decodeInterleaveData(unsigned char *pInterleaveDa
             }
         }
     }
-    LOGV("DEBUG(%s):m_decodeInterleaveData End~~~", __func__);
+    ALOGV("DEBUG(%s):m_decodeInterleaveData End~~~", __func__);
     return ret;
 }
 
@@ -3819,7 +3819,7 @@ void ExynosCameraHWInterface::m_getAlignedYUVSize(int colorFormat, int w, int h,
         buf->size.extS[2] = ALIGN(w/2, 8) * ALIGN(h/2, 8);
         break;
     default:
-        LOGE("ERR(%s):unmatched colorFormat(%d)", __func__, colorFormat);
+        ALOGE("ERR(%s):unmatched colorFormat(%d)", __func__, colorFormat);
         return;
         break;
     }
@@ -3871,7 +3871,7 @@ bool ExynosCameraHWInterface::m_getResolutionList(String8 & string8Buf, char * s
     }
 
     if (ret == false)
-        LOGE("ERR(%s):cannot find resolutions", __func__);
+        ALOGE("ERR(%s):cannot find resolutions", __func__);
 
     return ret;
 }
@@ -3924,7 +3924,7 @@ int ExynosCameraHWInterface::m_bracketsStr2Ints(char *str, int num, ExynosRect2
         buf[bracketsClose - bracketsOpen + 1] = 0;
 
         if (m_subBracketsStr2Ints(5, buf, tempArray) == false) {
-            LOGE("ERR(%s):m_subBracketsStr2Ints(%s) fail", __func__, buf);
+            ALOGE("ERR(%s):m_subBracketsStr2Ints(%s) fail", __func__, buf);
             break;
         }
 
@@ -3944,7 +3944,7 @@ int ExynosCameraHWInterface::m_bracketsStr2Ints(char *str, int num, ExynosRect2
 bool ExynosCameraHWInterface::m_subBracketsStr2Ints(int num, char *str, int *arr)
 {
     if (str == NULL || arr == NULL) {
-        LOGE("ERR(%s):str or arr is NULL", __func__);
+        ALOGE("ERR(%s):str or arr is NULL", __func__);
         return false;
     }
 
@@ -3956,13 +3956,13 @@ bool ExynosCameraHWInterface::m_subBracketsStr2Ints(int num, char *str, int *arr
 
     bracketsOpen = strchr(str, '(');
     if (bracketsOpen == NULL) {
-        LOGE("ERR(%s):no '('", __func__);
+        ALOGE("ERR(%s):no '('", __func__);
         return false;
     }
 
     bracketsClose = strchr(bracketsOpen, ')');
     if (bracketsClose == NULL) {
-        LOGE("ERR(%s):no ')'", __func__);
+        ALOGE("ERR(%s):no ')'", __func__);
         return false;
     }
 
@@ -3971,7 +3971,7 @@ bool ExynosCameraHWInterface::m_subBracketsStr2Ints(int num, char *str, int *arr
 
     tok = strtok(buf, ",");
     if (tok == NULL) {
-        LOGE("ERR(%s):strtok(%s) fail", __func__, buf);
+        ALOGE("ERR(%s):strtok(%s) fail", __func__, buf);
         return false;
     }
 
@@ -3981,7 +3981,7 @@ bool ExynosCameraHWInterface::m_subBracketsStr2Ints(int num, char *str, int *arr
         tok = strtok(NULL, ",");
         if (tok == NULL) {
             if (i < num - 1) {
-                LOGE("ERR(%s):strtok() (index : %d, num : %d) fail", __func__, i, num);
+                ALOGE("ERR(%s):strtok() (index : %d, num : %d) fail", __func__, i, num);
                 return false;
             }
             break;
@@ -4100,7 +4100,7 @@ static camera_device_t *g_cam_device;
 
 static int HAL_camera_device_close(struct hw_device_t* device)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     if (device) {
         camera_device_t *cam_device = (camera_device_t *)device;
         delete static_cast<ExynosCameraHWInterface *>(cam_device->priv);
@@ -4119,7 +4119,7 @@ static inline ExynosCameraHWInterface *obj(struct camera_device *dev)
 static int HAL_camera_device_set_preview_window(struct camera_device *dev,
                                                 struct preview_stream_ops *buf)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->setPreviewWindow(buf);
 }
 
@@ -4131,7 +4131,7 @@ static void HAL_camera_device_set_callbacks(struct camera_device *dev,
         camera_request_memory get_memory,
         void* user)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     obj(dev)->setCallbacks(notify_cb, data_cb, data_cb_timestamp,
                            get_memory,
                            user);
@@ -4147,7 +4147,7 @@ static void HAL_camera_device_set_callbacks(struct camera_device *dev,
  */
 static void HAL_camera_device_enable_msg_type(struct camera_device *dev, int32_t msg_type)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     obj(dev)->enableMsgType(msg_type);
 }
 
@@ -4163,7 +4163,7 @@ static void HAL_camera_device_enable_msg_type(struct camera_device *dev, int32_t
  */
 static void HAL_camera_device_disable_msg_type(struct camera_device *dev, int32_t msg_type)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     obj(dev)->disableMsgType(msg_type);
 }
 
@@ -4174,7 +4174,7 @@ static void HAL_camera_device_disable_msg_type(struct camera_device *dev, int32_
  */
 static int HAL_camera_device_msg_type_enabled(struct camera_device *dev, int32_t msg_type)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->msgTypeEnabled(msg_type);
 }
 
@@ -4183,7 +4183,7 @@ static int HAL_camera_device_msg_type_enabled(struct camera_device *dev, int32_t
  */
 static int HAL_camera_device_start_preview(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->startPreview();
 }
 
@@ -4192,7 +4192,7 @@ static int HAL_camera_device_start_preview(struct camera_device *dev)
  */
 static void HAL_camera_device_stop_preview(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     obj(dev)->stopPreview();
 }
 
@@ -4201,7 +4201,7 @@ static void HAL_camera_device_stop_preview(struct camera_device *dev)
  */
 static int HAL_camera_device_preview_enabled(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->previewEnabled();
 }
 
@@ -4237,7 +4237,7 @@ static int HAL_camera_device_preview_enabled(struct camera_device *dev)
  */
 static int HAL_camera_device_store_meta_data_in_buffers(struct camera_device *dev, int enable)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->storeMetaDataInBuffers(enable);
 }
 
@@ -4253,7 +4253,7 @@ static int HAL_camera_device_store_meta_data_in_buffers(struct camera_device *de
  */
 static int HAL_camera_device_start_recording(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->startRecording();
 }
 
@@ -4262,7 +4262,7 @@ static int HAL_camera_device_start_recording(struct camera_device *dev)
  */
 static void HAL_camera_device_stop_recording(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     obj(dev)->stopRecording();
 }
 
@@ -4271,7 +4271,7 @@ static void HAL_camera_device_stop_recording(struct camera_device *dev)
  */
 static int HAL_camera_device_recording_enabled(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->recordingEnabled();
 }
 
@@ -4287,7 +4287,7 @@ static int HAL_camera_device_recording_enabled(struct camera_device *dev)
 static void HAL_camera_device_release_recording_frame(struct camera_device *dev,
                                 const void *opaque)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     obj(dev)->releaseRecordingFrame(opaque);
 }
 
@@ -4298,7 +4298,7 @@ static void HAL_camera_device_release_recording_frame(struct camera_device *dev,
  */
 static int HAL_camera_device_auto_focus(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->autoFocus();
 }
 
@@ -4310,7 +4310,7 @@ static int HAL_camera_device_auto_focus(struct camera_device *dev)
  */
 static int HAL_camera_device_cancel_auto_focus(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->cancelAutoFocus();
 }
 
@@ -4319,7 +4319,7 @@ static int HAL_camera_device_cancel_auto_focus(struct camera_device *dev)
  */
 static int HAL_camera_device_take_picture(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->takePicture();
 }
 
@@ -4329,7 +4329,7 @@ static int HAL_camera_device_take_picture(struct camera_device *dev)
  */
 static int HAL_camera_device_cancel_picture(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->cancelPicture();
 }
 
@@ -4340,7 +4340,7 @@ static int HAL_camera_device_cancel_picture(struct camera_device *dev)
 static int HAL_camera_device_set_parameters(struct camera_device *dev,
                                             const char *parms)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     String8 str(parms);
     CameraParameters p(str);
     return obj(dev)->setParameters(p);
@@ -4349,7 +4349,7 @@ static int HAL_camera_device_set_parameters(struct camera_device *dev,
 /** Return the camera parameters. */
 char *HAL_camera_device_get_parameters(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     String8 str;
     CameraParameters parms = obj(dev)->getParameters();
     str = parms.flatten();
@@ -4358,7 +4358,7 @@ char *HAL_camera_device_get_parameters(struct camera_device *dev)
 
 static void HAL_camera_device_put_parameters(struct camera_device *dev, char *parms)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     free(parms);
 }
 
@@ -4368,7 +4368,7 @@ static void HAL_camera_device_put_parameters(struct camera_device *dev, char *pa
 static int HAL_camera_device_send_command(struct camera_device *dev,
                     int32_t cmd, int32_t arg1, int32_t arg2)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->sendCommand(cmd, arg1, arg2);
 }
 
@@ -4378,7 +4378,7 @@ static int HAL_camera_device_send_command(struct camera_device *dev,
  */
 static void HAL_camera_device_release(struct camera_device *dev)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     obj(dev)->release();
 }
 
@@ -4387,19 +4387,19 @@ static void HAL_camera_device_release(struct camera_device *dev)
  */
 static int HAL_camera_device_dump(struct camera_device *dev, int fd)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return obj(dev)->dump(fd);
 }
 
 static int HAL_getNumberOfCameras()
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]);
 }
 
 static int HAL_getCameraInfo(int cameraId, struct camera_info *cameraInfo)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
     memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo));
     return 0;
 }
@@ -4438,20 +4438,20 @@ static int HAL_camera_device_open(const struct hw_module_t* module,
                                   const char *id,
                                   struct hw_device_t** device)
 {
-    LOGV("DEBUG(%s):", __func__);
+    ALOGV("DEBUG(%s):", __func__);
 
     int cameraId = atoi(id);
     if (cameraId < 0 || cameraId >= HAL_getNumberOfCameras()) {
-        LOGE("ERR(%s):Invalid camera ID %s", __func__, id);
+        ALOGE("ERR(%s):Invalid camera ID %s", __func__, id);
         return -EINVAL;
     }
 
     if (g_cam_device) {
         if (obj(g_cam_device)->getCameraId() == cameraId) {
-            LOGV("DEBUG(%s):returning existing camera ID %s", __func__, id);
+            ALOGV("DEBUG(%s):returning existing camera ID %s", __func__, id);
             goto done;
         } else {
-            LOGE("ERR(%s):Cannot open camera %d. camera %d is already running!",
+            ALOGE("ERR(%s):Cannot open camera %d. camera %d is already running!",
                     __func__, cameraId, obj(g_cam_device)->getCameraId());
             return -ENOSYS;
         }
@@ -4468,13 +4468,13 @@ static int HAL_camera_device_open(const struct hw_module_t* module,
 
     g_cam_device->ops = &camera_device_ops;
 
-    LOGV("DEBUG(%s):open camera %s", __func__, id);
+    ALOGV("DEBUG(%s):open camera %s", __func__, id);
 
     g_cam_device->priv = new ExynosCameraHWInterface(cameraId, g_cam_device);
 
 done:
     *device = (hw_device_t *)g_cam_device;
-    LOGV("DEBUG(%s):opened camera %s (%p)", __func__, id, *device);
+    ALOGV("DEBUG(%s):opened camera %s (%p)", __func__, id, *device);
     return 0;
 }
 
diff --git a/libcamera/ExynosCameraHWInterface.h b/libcamera/ExynosCameraHWInterface.h
index 53ac270..dd65875 100644
--- a/libcamera/ExynosCameraHWInterface.h
+++ b/libcamera/ExynosCameraHWInterface.h
@@ -37,12 +37,11 @@
 #include <utils/RefBase.h>
 #include <binder/MemoryBase.h>
 #include <binder/MemoryHeapBase.h>
-#include <binder/MemoryHeapBaseIon.h>
 #include <hardware/camera.h>
 #include <hardware/gralloc.h>
 #include <camera/Camera.h>
 #include <camera/CameraParameters.h>
-#include <media/stagefright/MetadataBufferType.h>
+#include <media/hardware/MetadataBufferType.h>
 
 #include "gralloc_priv.h"