/*
 * Copyright 2008, The Android Open Source Project
 * Copyright 2013, Samsung Electronics Co. LTD
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

 /*!
 * \file      ISecCameraHardware.cpp
 * \brief     source file for Android Camera Ext HAL
 * \author    teahyung kim (tkon.kim@samsung.com)
 * \date      2013/04/30
 *
 */

#ifndef ANDROID_HARDWARE_ISECCAMERAHARDWARE_CPP
#define ANDROID_HARDWARE_ISECCAMERAHARDWARE_CPP

#define LOG_NDEBUG 0
#define LOG_NFPS 1
#define LOG_NPERFORMANCE 1

#define LOG_TAG "ISecCameraHardware"

#include <ISecCameraHardware.h>

#if VENDOR_FEATURE
#define SMART_THREAD
#endif
#define SMART_READ_INFO
#ifdef SMART_READ_INFO
#define AUTO_PARAM_CALLBACK
#endif

#define PRE_AF_FAIL 5
#define PRE_AF_SUCCESS	6

#define REC_CAPTURE_WIDTH	2304
#define REC_CAPTURE_HEIGHT	1728

namespace android {

ISecCameraHardware::ISecCameraHardware(int cameraId, camera_device_t *dev)
    : mCameraId(cameraId),
    mParameters(),
    mFlagANWindowRegister(false),
    mPreviewHeap(NULL),
    mPostviewHeap(NULL),
    mPostviewHeapTmp(NULL),
    mRawHeap(NULL),
    mRecordingHeap(NULL),
    mJpegHeap(NULL),
    mHDRHeap(NULL),
    mYUVHeap(NULL),
    mPreviewFormat(CAM_PIXEL_FORMAT_YUV420SP),
    mPictureFormat(CAM_PIXEL_FORMAT_JPEG),
    mFliteFormat(CAM_PIXEL_FORMAT_YUV420SP),
    mMirror(false),
    mNeedSizeChange(false),
    mFastCaptureCalled(false),
    mRecordingTrace(false),
    mMsgEnabled(0),
    mGetMemoryCb(0),
    mPreviewWindow(NULL),
    mNotifyCb(0),
    mDataCb(0),
    mDataCbTimestamp(0),
    mCallbackCookie(0),
    mDisablePostview(false),
    mSamsungApp(false),
    mAntibanding60Hz(-1),

    mHalDevice(dev)
{
    if (mCameraId == CAMERA_FACING_BACK) {
        mZoomSupport = IsZoomSupported();
        mEnableDZoom = mZoomSupport ? IsAPZoomSupported() : false;
        mFastCaptureSupport = IsFastCaptureSupportedOnRear();

        mFLiteSize.width = backFLiteSizes[0].width;
        mFLiteSize.height = backFLiteSizes[0].height;
        mFLiteCaptureSize = mFLiteSize;

        mPreviewSize.width = backPreviewSizes[0].width;
        mPreviewSize.height = backPreviewSizes[0].height;
        mOrgPreviewSize = mPreviewSize;

        mPictureSize.width = backPictureSizes[0].width;
        mPictureSize.height = backPictureSizes[0].height;

        mThumbnailSize.width = backThumbSizes[0].width;
        mThumbnailSize.height = backThumbSizes[0].height;

        mVideoSize.width = backRecordingSizes[0].width;
        mVideoSize.height = backRecordingSizes[0].height;
    } else {
        mZoomSupport = IsZoomSupported();
        mEnableDZoom = mZoomSupport ? IsAPZoomSupported() : false;
        mFastCaptureSupport = IsFastCaptureSupportedOnFront();

        mFLiteSize.width = frontFLiteSizes[0].width;
        mFLiteSize.height = frontFLiteSizes[0].height;
        mFLiteCaptureSize = mFLiteSize;

        mPreviewSize.width = frontPreviewSizes[0].width;
        mPreviewSize.height = frontPreviewSizes[0].height;
        mOrgPreviewSize = mPreviewSize;

        mPictureSize.width = frontPictureSizes[0].width;
        mPictureSize.height = frontPictureSizes[0].height;

        mThumbnailSize.width = frontThumbSizes[0].width;
        mThumbnailSize.height = frontThumbSizes[0].height;

        mVideoSize.width = frontRecordingSizes[0].width;
        mVideoSize.height = frontRecordingSizes[0].height;
    }

#ifndef FCJUNG
    mFactoryPuntRangeData.min = -1;
    mFactoryPuntRangeData.max = -1;
    mFactoryPuntRangeData.num = -1;
    mFactoryZoomRangeCheckData.min = -1;
    mFactoryZoomRangeCheckData.max = -1;
    mFactoryZoomSlopeCheckData.min = -1;
    mFactoryZoomSlopeCheckData.max = -1;
    mFactoryOISRangeData.x_min = -1;
    mFactoryOISRangeData.x_max = -1;
    mFactoryOISRangeData.y_min = -1;
    mFactoryOISRangeData.y_max = -1;
    mFactoryOISRangeData.x_gain = -1;
    mFactoryOISRangeData.peak_x = -1;
    mFactoryOISRangeData.peak_y = -1;
    mFactoryVibRangeData.x_min = -1;
    mFactoryVibRangeData.x_max = -1;
    mFactoryVibRangeData.y_min = -1;
    mFactoryVibRangeData.y_max = -1;
    mFactoryVibRangeData.peak_x = -1;
    mFactoryVibRangeData.peak_y = -1;
    mFactoryGyroRangeData.x_min = -1;
    mFactoryGyroRangeData.x_max = -1;
    mFactoryGyroRangeData.y_min = -1;
    mFactoryGyroRangeData.y_max = -1;
    mFactoryAFScanLimit.min = -1;
    mFactoryAFScanLimit.max = -1;
    mFactoryAFScanRange.min = -1;
    mFactoryAFScanRange.max = -1;
    mFactoryIRISRange.min = -1;
    mFactoryIRISRange.max = -1;
    mFactoryGainLiveViewRange.min = -1;
    mFactoryGainLiveViewRange.max = -1;
    mFactoryShCloseSpeedTime.x = -1;
    mFactoryShCloseSpeedTime.y = -1;
    mFactoryCaptureGainRange.min = -1;
    mFactoryCaptureGainRange.max = -1;
    mFactoryAFDiffCheck.min = -1;
    mFactoryAFDiffCheck.max = -1;
    mFactoryFlashRange.x = -1;
    mFactoryFlashRange.y = -1;
    mFactoryWBRangeData.in_rg = -1;
    mFactoryWBRangeData.in_bg = -1;
    mFactoryWBRangeData.out_rg = -1;
    mFactoryWBRangeData.out_bg = -1;
    mFactoryAFLEDRangeData.start_x = -1;
    mFactoryAFLEDRangeData.end_x = -1;
    mFactoryAFLEDRangeData.start_y = -1;
    mFactoryAFLEDRangeData.end_y = -1;
    mFactoryAFLEDlvlimit.min = -1;
    mFactoryAFLEDlvlimit.max = -1;
    mFactoryTiltScanLimitData.min = -1;
    mFactoryTiltScanLimitData.max = -1;
    mFactoryTiltAFRangeData.min = -1;
    mFactoryTiltAFRangeData.max = -1;
    mFactoryTiltDiffRangeData.min = -1;
    mFactoryTiltDiffRangeData.max = -1;
    mFactoryIRCheckRGainData.min = -1;
    mFactoryIRCheckRGainData.max = -1;
    mFactoryIRCheckBGainData.min = -1;
    mFactoryIRCheckBGainData.max = -1;
    mFactorySysMode = 0;
    mFactoryNumCnt = 0;
#endif /* FCJUNG */

    mRawSize = mPreviewSize;
	mPostviewSize = mPreviewSize;
	mCaptureMode = RUNNING_MODE_SINGLE;

#if FRONT_ZSL
    rawImageMem = NULL;
    mFullPreviewHeap = NULL;
#endif

    mPreviewWindowSize.width = mPreviewWindowSize.height = 0;

    mFrameRate = 0;
    mFps = 0;
    mJpegQuality= 100;
    mSceneMode = (cam_scene_mode)sceneModes[0].val;
    mFlashMode = (cam_flash_mode)flashModes[0].val;
    if (mCameraId == CAMERA_FACING_BACK)
        mFocusMode = (cam_focus_mode)backFocusModes[0].val;
    else
        mFocusMode = (cam_focus_mode)frontFocusModes[0].val;

    mFirmwareMode = CAM_FW_MODE_NONE;
    mVtMode = CAM_VT_MODE_NONE;
    mMovieMode = false;
#ifdef DEBUG_PREVIEW_NO_FRAME /* 130221.DSLIM Delete me in a week*/
    mFactoryMode = false;
#endif
    mDtpMode = false;

    mMaxFrameRate = 30000;
    mDropFrameCount = 3;
    mbFirst_preview_started = false;

#if IS_FW_DEBUG
    if (mCameraId == CAMERA_FACING_FRONT || mCameraId == FD_SERVICE_CAMERA_ID)
        mPrintDebugEnabled = false;
#endif
	mIonCameraClient = -1;
	mPictureFrameSize = 0;
	mFullPreviewFrameSize = 0;
	CLEAR(mAntiBanding);
	mAutoFocusExit = false;
	mPreviewRunning = false;
	mPreviewThreadType = PREVIEW_THREAD_NONE;
	mRecordingRunning = false;
	mAutoFocusRunning = false;
	mPictureRunning = false;
	mRecordSrcIndex = -1;
	CLEAR(mRecordSrcSlot);
	mRecordDstIndex = -1;
	CLEAR(mRecordFrameAvailable);
	mRecordFrameAvailableCnt = 0;
	mFlagFirstFrameDump = false;
	mPostRecordIndex = -1;
	mRecordTimestamp = 0;
	mLastRecordTimestamp = 0;
	mPostRecordExit = false;
	mPreviewInitialized = false;
	mPreviewHeapFd = -1;
	mRecordHeapFd = -1;
	mPostviewHeapFd = -1;
	mPostviewHeapTmpFd = -1;
	CLEAR(mFrameMetadata);
	CLEAR(mFaces);
	mZSLindex = -1;
	mFullPreviewRunning = false;
	mPreviewFrameSize = 0;
    mPreviewFrameOffset = 0;
	mRecordingFrameSize = 0;
	mRawFrameSize = 0;
	mPostviewFrameSize = 0;
	mFirstStart = 0;
	mTimerSet = 0;
	mZoomParamSet = 1;
	mZoomCurrLevel = 0;
	mZoomSetVal = 0;
	mZoomStatus = 0;
	mLensStatus = 0;
	mZoomStatusBak = 0;
	mLensChecked = 0;
    mLensStatus = 0;

	mCameraPower = true;
#ifdef APPLY_ESD
	isResetedByESD = false;
#endif

	roi_x_pos = 0;
	roi_y_pos = 0;
	roi_width = 0;
	roi_height = 0;

	mBurstShotExit = false;

#ifdef ZOOM_CTRL_THREAD
       zoom_cmd = 0;
       old_zoom_cmd = 100;
#endif

}

ISecCameraHardware::~ISecCameraHardware()
{
    if (mPreviewHeap) {
        mPreviewHeap->release(mPreviewHeap);
        mPreviewHeap = 0;
        mPreviewHeapFd = -1;
    }

    if (mRecordingHeap) {
        mRecordingHeap->release(mRecordingHeap);
        mRecordingHeap = 0;
    }

    if (mRawHeap != NULL) {
        mRawHeap->release(mRawHeap);
        mRawHeap = 0;
    }

    if (mHDRHeap) {
        mHDRHeap->release(mHDRHeap);
        mHDRHeap = NULL;
    }

#ifndef RCJUNG
    if (mYUVHeap) {
        mYUVHeap->release(mYUVHeap);
        mYUVHeap = NULL;
    }
#endif

    if (mJpegHeap) {
        mJpegHeap->release(mJpegHeap);
        mJpegHeap = 0;
    }

    if (mPostviewHeap) {
        mPostviewHeap->release(mPostviewHeap);
        mPostviewHeap = 0;
    }

    if (mPostviewHeapTmp) {
        mPostviewHeapTmp->release(mPostviewHeapTmp);
        mPostviewHeapTmp = 0;
    }

    if (0 < mIonCameraClient)
        ion_client_destroy(mIonCameraClient);
    mIonCameraClient = -1;
}

#ifdef BURST_SHOT_SUPPORT
ISecCameraHardware::BurstShot::BurstShot()
{
    mLimitByte = 300*1024*1024;

    memset(mItem, 0, sizeof(mItem));
    init();
}

ISecCameraHardware::BurstShot::~BurstShot()
{
    release();
}

bool ISecCameraHardware::BurstShot::init()
{
    Mutex::Autolock lock(mBurstLock);

    ALOGD("BURSTSHOT BurstShot::init() ");

    mUsedByte = 0;
    mTotalIndex = 0;

    mCountMax = 0;
    mHead = 1;
    mTail = 0;
    mAttrib = 0;

    memset(mItem, 0, sizeof(mItem));
#ifdef USE_CONTEXTUAL_FILE_NAME
	freeContextualFileName();
	setContextualState(false);
#endif

	strcpy(mPath, "/data/media/0/DCIM/Camera");

    mInitialize = true;
    return true;
}

void ISecCameraHardware::BurstShot::release()
{
    Mutex::Autolock lock(mBurstLock);

	ALOGD("BURSTSHOT MEM: burst release.");
	for (int i=0;i<MAX_BURST_COUNT;i++) {
		if ( mItem[i].type == CAMERA_BURST_MEMORY_ION ) {  // ION memory
			burst_item *b_item = &mItem[i];
			if (b_item->size > 0) {
				int ret = 0;

				ret = ion_unmap(b_item->virt, b_item->size);
				if (ret < 0)
					ALOGE("ERR(%s):ion_unmap(%p, %d) fail", __FUNCTION__, b_item->virt, b_item->size);
				ion_free(b_item->fd);

				b_item->size = 0;
			}
			if (b_item->ion > 0) {
				ion_client_destroy(b_item->ion);
				b_item->ion = -1;
			}
		}
	}
}

bool ISecCameraHardware::BurstShot::isEmpty()
{
    return ( (mTail+1)%MAX_BURST_COUNT == mHead );
}

bool ISecCameraHardware::BurstShot::isLimit(int size)
{
    Mutex::Autolock lock(mBurstLock);

    if ( mLimitByte < mUsedByte+size )
        return false;

    int head = (mHead+1)%MAX_BURST_COUNT ;
    if ( head == mTail )
        return false;

    return true;
}

bool ISecCameraHardware::BurstShot::isStartLimit(void)
{
    Mutex::Autolock lock(mBurstLock);

    if ( (mLimitByte - mUsedByte) < (10 * 1024 * 1024) )
        return false;

    return true;
}

uint8_t* ISecCameraHardware::BurstShot::getAddress(burst_item* item)
{
    if ( item == NULL ) {
		ALOGE("BURSTSHOT: item address is NULL");
        return NULL;
	}

    if ( item->type == CAMERA_BURST_MEMORY_ION ) {
		ALOGD("BURSTSHOT: nativeSaveJpegPicture: buf (%p)", item->virt);
        return (uint8_t*)(item->virt);
	}

	return  NULL;
}

bool ISecCameraHardware::BurstShot::allocMemBurst(ion_client ionClient, ExynosBuffer *buf, int index, bool flagCache)
{
    if (ionClient == 0) {
        ALOGE("ERR(%s): ionClient is zero (%d)", __func__, ionClient);
        return false;
    }

    if (buf->size.extS[index] != 0) {
        /* HACK: For non-cacheable */
        buf->fd.extFd[index] = ion_alloc(ionClient, buf->size.extS[index], 0, ION_HEAP_SYSTEM_MASK, 0);
        if (buf->fd.extFd[index] <= 0) {
            ALOGE("ERR(%s): ion_alloc(%d, %d) failed", __func__, index, buf->size.extS[index]);
            buf->fd.extFd[index] = -1;
            freeMemBurst(buf, index);
            return false;
        }

        buf->virt.extP[index] = (char *)ion_map(buf->fd.extFd[index], buf->size.extS[index], 0);
        if ((buf->virt.extP[index] == (char *)MAP_FAILED) || (buf->virt.extP[index] == NULL)) {
            ALOGE("ERR(%s): ion_map(%d) failed", __func__, buf->size.extS[index]);
            buf->virt.extP[index] = NULL;
            freeMemBurst(buf, index);
            return false;
        }
    }

    return true;
}

void ISecCameraHardware::BurstShot::freeMemBurst(ExynosBuffer *buf, int index)
{
	ALOGD("BURSTSHOT MEM: freeMemBurst free item. buf->fd.extFd[%d] = %d", index, buf->fd.extFd[index]);
	if (0 < buf->fd.extFd[index]) {
		ALOGD("BURSTSHOT MEM: freeMemBurst free item2.");
		if (buf->virt.extP[index] != NULL) {
			ALOGD("BURSTSHOT MEM: freeMemBurst free item3.");
			int ret = 0;

            ret = ion_unmap(buf->virt.extP[index], buf->size.extS[index]);
            if (ret < 0)
                ALOGE("ERR(%s):ion_unmap(%p, %d) fail", __FUNCTION__, buf->virt.extP[index], buf->size.extS[index]);
			else
				ALOGD("BURSTSHOT MEM: memory unmmaped normaly");
        } else {
			ALOGE("BURSTSHOT MEM: freeMemBurst: buf->virt.extP[%p] is NULL", buf->virt.extP[index]);
		}
        ion_free(buf->fd.extFd[index]);
    } else {
		ALOGE("BURSTSHOT MEM: freeMemBurst: buf->fd.extFd[%d] = %d", index, buf->fd.extFd[index]);
	}

    buf->fd.extFd[index] = -1;
    buf->virt.extP[index] = NULL;
    buf->size.extS[index] = 0;
}

uint8_t* ISecCameraHardware::BurstShot::malloc(int size, bool cached)
{
	uint8_t *ptr;
	int mIonBurst = ion_client_create();
	ExynosBuffer nullBuf;
	ExynosBuffer burst_mem;

	burst_mem = nullBuf;
	burst_mem.size.extS[0] = size;
	if (allocMemBurst(mIonBurst, &burst_mem, 0, 1 << 1) == false) {
		ALOGE("BURSTSHOT: ERR(%s): malloc: mIonBurst allocMemBurst fail", __func__);
		ion_client_destroy(mIonBurst);
		return NULL;
	} else {
		ALOGV("BURSTSHOT MEM: DEBUG(%s): malloc: mIonBurst allocMem adr(%p), size(%d), ion(%d)", __FUNCTION__,
				burst_mem.virt.extP[0], burst_mem.size.extS[0], mIonBurst);
		memset(burst_mem.virt.extP[0], 0, burst_mem.size.extS[0]);
	}

	memset(&mJpegION, 0, sizeof(mJpegION));
	mJpegION.size = burst_mem.size.extS[0];
	mJpegION.type = CAMERA_BURST_MEMORY_ION;
	mJpegION.ion = mIonBurst;
	mJpegION.fd = burst_mem.fd.extFd[0];
	mJpegION.virt = (uint8_t*)burst_mem.virt.extP[0];

	ALOGD("BURSTSHOT MEM: malloc: mJpegION.size = %d", mJpegION.size);
	ALOGD("BURSTSHOT MEM: malloc: mJpegION->virt = %p", mJpegION.virt);

	ptr = (uint8_t *)mJpegION.virt;

	{
		Mutex::Autolock lock(mBurstLock);
		mUsedByte += mJpegION.size;
		ALOGD("BURSTSHOT: alloc mUsedByte = %d", mUsedByte);
	}
	return ptr;
}

bool ISecCameraHardware::BurstShot::free(burst_item *item)
{
	if ( item->type == CAMERA_BURST_MEMORY_ION ) {
		ALOGD("BURSTSHOT: free burstshot item. index = %d, size = %d", item->ix, item->size);
		if (item->size > 0) {
//			ALOGD("BURSTSHOT: free burstshot item.");
			int ret = 0;

            ret = ion_unmap(item->virt, item->size);
            if (ret < 0)
                ALOGE("ERR(%s):ion_unmap(%p, %d) fail", __FUNCTION__, item->virt, item->size);
			else {
//				ALOGD("BURSTSHOT MEM: memory unmmaped normaly");
			}
			ion_free(item->fd);
		} else {
			ALOGE("BURSTSHOT MEM: free - wrong size: item->size = %d", item->size);
		}

        if (item->ion > 0) {
            ion_client_destroy(item->ion);
            item->ion = -1;
        }
    }

    Mutex::Autolock lock(mBurstLock);
    mUsedByte -= item->size;
	ALOGD("BURSTSHOT: free mUsedByte = %d", mUsedByte);
	item->size = 0;

    return true;
}

bool ISecCameraHardware::BurstShot::push(int cnt)
{
    Mutex::Autolock lock(mBurstLock);

    if ( mLimitByte < mUsedByte  )
        return false;

    int head = (mHead+1)%MAX_BURST_COUNT ;
    if ( head == mTail )
        return false;

    if (cnt == 0) {
        srand((unsigned int)time(NULL));
        mRandNum = rand();
    }

    mJpegION.frame_num = cnt + 1;
    mJpegION.group = mRandNum;

    mItem[mHead] = mJpegION;
    mItem[mHead].ix = (++mTotalIndex)%1000;
	mItem[mHead].ion = mJpegION.ion;
	mItem[mHead].fd = mJpegION.fd;
	mItem[mHead].virt = mJpegION.virt;

	ALOGD("BURSTSHOT MEM: mItem[%d] = %p", mHead, &(mItem[mHead]));

    mHead = head;

    return true;
}

bool ISecCameraHardware::BurstShot::pop(burst_item *item)
{
    Mutex::Autolock lock(mBurstLock);

    int tail = (mTail+1)%MAX_BURST_COUNT;
    if ( tail == mHead )
        return false;

    mTail = tail;
    *item = mItem[mTail];

	ALOGE("BURSTSHOT MEM: pop: mTail = %d, mItem[mTail] = %p", mTail, &(mItem[tail]));

	memset(&mItem[mTail], 0, sizeof(burst_item));
    return true;
}

void ISecCameraHardware::BurstShot::DumpState(void)
{
    ALOGD("BURSTSHOT DumpState ------------------------------------------");
    ALOGD("BURSTSHOT	mHead=%d, mTail=%d ", mHead,  mTail);
    ALOGD("BURSTSHOT	mUsedByte=%d MaxByte:%d", mUsedByte, mLimitByte );
    ALOGD("BURSTSHOT	mAttrib=0x%08x", mAttrib);
    ALOGD("BURSTSHOT DumpState  ------------------------------------------");
}

void ISecCameraHardware::BurstShot::getFileName(char* buffer, int i, int group_num)
{
    ALOGV("getFileName %d, %d", i, group_num);

    time_t rawtime;
    struct tm *timeinfo;
    char date_time[20];

    time(&rawtime);
    timeinfo = localtime(&rawtime);
    strftime((char *)date_time, 20, "%Y%m%d_%H%M%S", timeinfo);

#ifdef USE_CONTEXTUAL_FILE_NAME
	ALOGD("mContextualstate %d, %s", mContextualstate, getContextualFileName());
	if ( getMode() & BURST_ATTRIB_BEST_MODE ) {
		if ( getContextualState() )
			sprintf(buffer, "%s/%s_%s_%d_bestshot.jpg%c", getPath(), date_time, getContextualFileName(), i, NULL);
		else
			sprintf(buffer, "%s/%s_%d_bestshot.jpg%c", getPath(), date_time, i, NULL);
	} else {
		if ( getContextualState() )
			sprintf(buffer, "%s/%s_%s_%d.jpg", getPath(), date_time, getContextualFileName(), i);
		else
			sprintf(buffer, "%s/%s_%d.jpg", getPath(), date_time, i);
	}
	ALOGD("getFileName~~~~ %d, %s/%s", i, buffer,  getContextualFileName());
#else
	if ( getMode() & BURST_ATTRIB_BEST_MODE )
		sprintf(buffer, "%s/%s_%d_bestshot.jpg%c", getPath(), date_time, i, NULL);
	else
		sprintf(buffer, "%s/%s_%d.jpg", getPath(), date_time, i);

	ALOGD("getFileName~~~~ %d, %s", i, buffer);
#endif
}

#ifdef USE_CONTEXTUAL_FILE_NAME
char* ISecCameraHardware::BurstShot::getContextualFileName(void)
{
    ALOGD("BurstShot::getContextualFileName");
    return mContextualFilename;
}

void ISecCameraHardware::BurstShot::setContextualFileName(char* strName)
{
    setContextualState(true);
    freeContextualFileName();
    memcpy(mContextualFilename, strName, strlen(strName));
    ALOGD("BurstShot::setContextualFileName: %s, %d", mContextualFilename, strlen(mContextualFilename));
}
#endif
#endif

bool ISecCameraHardware::init()
{
    mPreviewRunning = false;
    mPreviewThreadType = PREVIEW_THREAD_NONE;
    mFullPreviewRunning = false; /* for FRONT_ZSL */
    mPreviewInitialized = false;
#ifdef DEBUG_PREVIEW_CALLBACK
    mPreviewCbStarted = false;
#endif
    mRecordingRunning = false;
    mPictureRunning = false;
	mPictureStart = false;
	mCaptureStarted = false;
	mCancelCapture = false;
    mAutoFocusRunning = false;
    mSelfShotFDReading = false;
    mAutoFocusExit = false;
	mDualCapture = false;
#ifdef BURST_SHOT_SUPPORT
	mBurstWriteRunning = false;
	mEnableStrCb = true;
#endif
    mFaceDetectionStatus = V4L2_FACE_DETECTION_OFF;

    /* for NSM Mode */
    mbGetFDinfo = false;
    /* end NSM Mode */

    if (mEnableDZoom) {
        /* Thread for zoom */
        mPreviewZoomThread = new CameraThread(this, &ISecCameraHardware::previewZoomThread, "previewZoomThread");
        mPostRecordThread = new CameraThread(this, &ISecCameraHardware::postRecordThread, "postRecordThread");
        mPreviewThread = mRecordingThread = NULL;
#ifdef CHANGED_PREVIEW_SUPPORT
        mChangedPreviewThread = new CameraThread(this, &ISecCameraHardware::changedPreviewThread, "changedPreviewThread");
#endif
    } else {
        mPreviewThread = new CameraThread(this, &ISecCameraHardware::previewThread, "previewThread");
        mRecordingThread = new CameraThread(this, &ISecCameraHardware::recordingThread, "recordingThread");
        mPreviewZoomThread = mPostRecordThread = NULL;
    }

    mPictureThread = new CameraThread(this, &ISecCameraHardware::pictureThread, "pictureThread");
#if FRONT_ZSL
    mZSLPictureThread = new CameraThread(this, &ISecCameraHardware::zslpictureThread, "zslpictureThread");
#endif

#ifdef BURST_SHOT_SUPPORT
    mBurstPictureThread = new CameraThread(this, &ISecCameraHardware::burstPictureThread);
    mBurstWriteThread = new CameraThread(this, &ISecCameraHardware::burstWriteThread);
#endif
	if (mCameraId == CAMERA_FACING_BACK) {
        mAutoFocusThread = new CameraThread(this, &ISecCameraHardware::autoFocusThread, "autoFocusThread");
        mAutoFocusThread->run("autoFocusThread", PRIORITY_DEFAULT);
#ifdef SMART_THREAD
        mSmartThread = new CameraThread(this, &ISecCameraHardware::smartThread);
        mSmartThread->run("smartThread", PRIORITY_DEFAULT);
#endif
#ifdef ZOOM_CTRL_THREAD
        mZoomCtrlThread = new CameraThread(this, &ISecCameraHardware::ZoomCtrlThread);
        mZoomCtrlThread->run("ZoomCtrlThread", PRIORITY_DEFAULT);
#endif

        mHDRPictureThread = new CameraThread(this, &ISecCameraHardware::HDRPictureThread);
        mAEBPictureThread = new CameraThread(this, &ISecCameraHardware::AEBPictureThread);
        mBlinkPictureThread = new CameraThread(this, &ISecCameraHardware::BlinkPictureThread);
        mRecordingPictureThread = new CameraThread(this, &ISecCameraHardware::RecordingPictureThread);
		mDumpPictureThread = new CameraThread(this, &ISecCameraHardware::dumpPictureThread);

#if VENDOR_FEATURE
		mShutterThread = new CameraThread(this, &ISecCameraHardware::shutterThread);
		mShutterThread->run("shutterThread", PRIORITY_URGENT_DISPLAY);
#endif
    }

#if IS_FW_DEBUG
    if (!mPrintDebugEnabled &&
        (mCameraId == CAMERA_FACING_FRONT || mCameraId == FD_SERVICE_CAMERA_ID)) {
        mPrevOffset = 0;
        mCurrOffset = 0;
        mPrevWp = 0;
        mCurrWp = 0;
        mDebugVaddr = 0;

        int ret = nativeGetDebugAddr(&mDebugVaddr);
        if (ret < 0) {
            ALOGE("ERR(%s):Fail on SecCamera->getDebugAddr()", __func__);
            mPrintDebugEnabled = false;
        } else {
            ALOGD("mDebugVaddr = 0x%x", mDebugVaddr);
            mPrintDebugEnabled = true;
#if IS_FW_DEBUG_THREAD
            mStopDebugging = false;
            mDebugThread = new DebugThread(this);
            mDebugThread->run("debugThread", PRIORITY_DEFAULT);
#endif
        }
    }
#endif

    mIonCameraClient = ion_client_create();
    if (mIonCameraClient < 0) {
        ALOGE("ERR(%s):ion_client_create() fail", __func__);
        mIonCameraClient = -1;
    }

    for (int i = 0; i < REC_BUF_CNT; i++) {
        for (int j = 0; j < REC_PLANE_CNT; j++) {
            mRecordDstHeap[i][j] = NULL;
            mRecordDstHeapFd[i][j] = -1;
        }
    }

    mInitRecSrcQ();
    mInitRecDstBuf();

    return true;
}

void ISecCameraHardware::initDefaultParameters()
{
    /* Preview */
    mParameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);

    if (mCameraId == CAMERA_FACING_BACK) {
        mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
                SecCameraParameters::createSizesStr(backPreviewSizes, ARRAY_SIZE(backPreviewSizes)).string());

        mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, B_KEY_PREVIEW_FPS_RANGE_VALUE);
        mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, B_KEY_SUPPORTED_PREVIEW_FPS_RANGE_VALUE);

        mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, B_KEY_SUPPORTED_PREVIEW_FRAME_RATES_VALUE);
        mParameters.setPreviewFrameRate(B_KEY_PREVIEW_FRAME_RATE_VALUE);

        mParameters.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, B_KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO_VALUE);
    } else {
        mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
                SecCameraParameters::createSizesStr(frontPreviewSizes, ARRAY_SIZE(frontPreviewSizes)).string());

        mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, F_KEY_PREVIEW_FPS_RANGE_VALUE);
        mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, F_KEY_SUPPORTED_PREVIEW_FPS_RANGE_VALUE);

        mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, F_KEY_SUPPORTED_PREVIEW_FRAME_RATES_VALUE);
        mParameters.setPreviewFrameRate(F_KEY_PREVIEW_FRAME_RATE_VALUE);

        mParameters.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, F_KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO_VALUE);
    }

    mParameters.setPreviewFormat(previewPixelFormats[0].desc);
    mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
        SecCameraParameters::createValuesStr(previewPixelFormats, ARRAY_SIZE(previewPixelFormats)).string());

    /* Picture */
    mParameters.setPictureSize(mPictureSize.width, mPictureSize.height);
    mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, mThumbnailSize.width);
    mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, mThumbnailSize.height);

    if (mCameraId == CAMERA_FACING_BACK) {
        mParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
                SecCameraParameters::createSizesStr(backPictureSizes, ARRAY_SIZE(backPictureSizes)).string());

        mParameters.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
                SecCameraParameters::createSizesStr(backThumbSizes, ARRAY_SIZE(backThumbSizes)).string());
    } else {
        mParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
                SecCameraParameters::createSizesStr(frontPictureSizes, ARRAY_SIZE(frontPictureSizes)).string());

        mParameters.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
                SecCameraParameters::createSizesStr(frontThumbSizes, ARRAY_SIZE(frontThumbSizes)).string());
    }

    mParameters.setPictureFormat(picturePixelFormats[0].desc);
    mParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
        SecCameraParameters::createValuesStr(picturePixelFormats, ARRAY_SIZE(picturePixelFormats)).string());

	mParameters.set(CameraParameters::KEY_JPEG_QUALITY, 1);
	mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 100);

    mParameters.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, CameraParameters::PIXEL_FORMAT_YUV420SP);

    /* Video */
    mParameters.setVideoSize(mVideoSize.width, mVideoSize.height);
    if (mCameraId == CAMERA_FACING_BACK) {
        mParameters.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
            SecCameraParameters::createSizesStr(backRecordingSizes, ARRAY_SIZE(backRecordingSizes)).string());
        mParameters.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, B_KEY_VIDEO_STABILIZATION_SUPPORTED_VALUE);
    } else {
        mParameters.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
                SecCameraParameters::createSizesStr(frontRecordingSizes, ARRAY_SIZE(frontRecordingSizes)).string());
        mParameters.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, F_KEY_VIDEO_STABILIZATION_SUPPORTED_VALUE);
    }

    mParameters.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, KEY_VIDEO_SNAPSHOT_SUPPORTED_VALUE);

    /* UI settings */
    mParameters.set(CameraParameters::KEY_WHITE_BALANCE, whiteBalances[0].desc);
    mParameters.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
        SecCameraParameters::createValuesStr(whiteBalances, ARRAY_SIZE(whiteBalances)).string());

    mParameters.set(CameraParameters::KEY_EFFECT, effects[0].desc);
    mParameters.set(CameraParameters::KEY_SUPPORTED_EFFECTS,
       SecCameraParameters::createValuesStr(effects, ARRAY_SIZE(effects)).string());

    if (mCameraId == CAMERA_FACING_BACK) {
        mParameters.set(CameraParameters::KEY_SCENE_MODE, sceneModes[0].desc);
        mParameters.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
                SecCameraParameters::createValuesStr(sceneModes, ARRAY_SIZE(sceneModes)).string());

        if (IsFlashSupported()) {
            mParameters.set(CameraParameters::KEY_FLASH_MODE, flashModes[0].desc);
            mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
                    SecCameraParameters::createValuesStr(flashModes, ARRAY_SIZE(flashModes)).string());
        }

        mParameters.set(CameraParameters::KEY_FOCUS_MODE, backFocusModes[0].desc);
        mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, B_KEY_NORMAL_FOCUS_DISTANCES_VALUE);
        mParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
                SecCameraParameters::createValuesStr(backFocusModes, ARRAY_SIZE(backFocusModes)).string());

        if (IsAutoFocusSupported()) {
            /* FOCUS AREAS supported.
             * MAX_NUM_FOCUS_AREAS > 0 : supported
             * MAX_NUM_FOCUS_AREAS = 0 : not supported
             *
             * KEY_FOCUS_AREAS = "left,top,right,bottom,weight"
             */
            mParameters.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "1");
            mParameters.set(CameraParameters::KEY_FOCUS_AREAS, "(0,0,0,0,0)");
        }
    } else {
        mParameters.set(CameraParameters::KEY_FOCUS_MODE, frontFocusModes[0].desc);
        mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, F_KEY_FOCUS_DISTANCES_VALUE);
        mParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
                SecCameraParameters::createValuesStr(frontFocusModes, ARRAY_SIZE(frontFocusModes)).string());
    }

    /* Face Detect */
    if (mCameraId == CAMERA_FACING_BACK) {
        //mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, B_KEY_MAX_NUM_DETECTED_FACES_HW_VALUE);
        mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, "1");	/* FOR HAL TEST */
        mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, B_KEY_MAX_NUM_DETECTED_FACES_SW_VALUE);
    } else {
        mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, F_KEY_MAX_NUM_DETECTED_FACES_HW_VALUE);
        mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, F_KEY_MAX_NUM_DETECTED_FACES_SW_VALUE);
    }


    /* Zoom */
    if (mZoomSupport) {
        mParameters.set(CameraParameters::KEY_ZOOM, 0);
        mParameters.set(CameraParameters::KEY_MAX_ZOOM, 30);
        /* If zoom is supported, set zoom ratios as value of KEY_ZOOM_RATIOS here.
         * EX) mParameters.set(CameraParameters::KEY_ZOOM_RATIOS, "100,102,104");
         */
        mParameters.set(CameraParameters::KEY_ZOOM_RATIOS,
                "100,102,104,109,111,113,119,121,124,131,"
                "134,138,146,150,155,159,165,170,182,189,"
                "200,213,222,232,243,255,283,300,319,364,400");
        mParameters.set(CameraParameters::KEY_ZOOM_SUPPORTED, B_KEY_ZOOM_SUPPORTED_VALUE);
        mParameters.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, B_KEY_SMOOTH_ZOOM_SUPPORTED_VALUE);
    }

    mParameters.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, "3");		/* FOR HAL TEST 0 -> 3 */

    mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 0);
    mParameters.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 6);
    mParameters.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, -6);
    mParameters.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 0.33);

    /* AE, AWB Lock */
    if (mCameraId == CAMERA_FACING_BACK) {
        mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, B_KEY_AUTO_EXPOSURE_LOCK_SUPPORTED_VALUE);
        mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, B_KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED_VALUE);
    } else {
        mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, F_KEY_AUTO_EXPOSURE_LOCK_SUPPORTED_VALUE);
        mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, F_KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED_VALUE);
    }

    /* AntiBanding */
    // chooseAntiBandingFrequency();
    if (mCameraId == CAMERA_FACING_BACK) {
        mParameters.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
                SecCameraParameters::createValuesStr(antibandings, ARRAY_SIZE(antibandings)).string());
        mParameters.set(CameraParameters::KEY_ANTIBANDING, antibandings[3].desc);
    }

    ALOGV("initDefaultParameters EX: %s", mParameters.flatten().string());
}

status_t ISecCameraHardware::setPreviewWindow(preview_stream_ops *w)
{
    mPreviewWindow = w;

    if (CC_UNLIKELY(!w)) {
        mPreviewWindowSize.width = mPreviewWindowSize.height = 0;
        ALOGE("setPreviewWindow: NULL Surface!");
        return OK;
    }

    int halPixelFormat = HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_FULL;

    if (mMovieMode)
        halPixelFormat = HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP;

    ALOGD("DEBUG(%s): size(%d/%d)", __FUNCTION__, mPreviewSize.width, mPreviewSize.height);
    /* YV12 */
    ALOGV("setPreviewWindow: halPixelFormat = %s",
        halPixelFormat == HAL_PIXEL_FORMAT_YV12 ? "YV12" :
        halPixelFormat == HAL_PIXEL_FORMAT_YCrCb_420_SP ? "NV21" :
        halPixelFormat == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP ? "NV21M" :
        halPixelFormat == HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL ? "NV21 FULL" :
        "Others");

    mPreviewWindowSize = mPreviewSize;
    ALOGD("DEBUG(%s): setPreviewWindow window Size width=%d height=%d", __FUNCTION__, mPreviewWindowSize.width, mPreviewWindowSize.height);
    if (nativeCreateSurface(mPreviewWindowSize.width, mPreviewWindowSize.height, halPixelFormat) == false) {
        ALOGE("setPreviewWindow: error, nativeCreateSurface");
        return UNKNOWN_ERROR;
    }

    return NO_ERROR;
}

#if IS_FW_DEBUG
void ISecCameraHardware::printDebugFirmware()
{
    if (!mPrintDebugEnabled) {
        ALOGD("printDebugFirmware mPrintDebugEnabled is false..");
        return;
    }

    mIs_debug_ctrl.write_point = *((unsigned int *)(mDebugVaddr + FIMC_IS_FW_DEBUG_REGION_SIZE));
    mIs_debug_ctrl.assert_flag = *((unsigned int *)(mDebugVaddr + FIMC_IS_FW_DEBUG_REGION_SIZE + 4));
    mIs_debug_ctrl.pabort_flag = *((unsigned int *)(mDebugVaddr + FIMC_IS_FW_DEBUG_REGION_SIZE + 8));
    mIs_debug_ctrl.dabort_flag = *((unsigned int *)(mDebugVaddr + FIMC_IS_FW_DEBUG_REGION_SIZE + 12));

    mCurrWp = mIs_debug_ctrl.write_point;
    mCurrOffset = mCurrWp - FIMC_IS_FW_DEBUG_REGION_ADDR;

    if (mCurrWp != mPrevWp) {
		unsigned int LP, CP;
        *(char *)(mDebugVaddr + mCurrOffset - 1) = '\0';
        LP = CP = mDebugVaddr + mPrevOffset;

        if (mCurrWp < mPrevWp) {
            *(char *)(mDebugVaddr + FIMC_IS_FW_DEBUG_REGION_SIZE - 1) = '\0';
            while (CP < (mDebugVaddr + FIMC_IS_FW_DEBUG_REGION_SIZE) && *(char *)CP != 0) {
                while(*(char *)CP != '\n' && *(char *)CP != 0)
                    CP++;
                *(char *)CP = NULL;
                if (*(char *)LP != 0)
                    LOGD_IS("%s", (char *)LP);
                LP = ++CP;
            }
            LP = CP = mDebugVaddr;
        }

        while (CP < (mDebugVaddr + mCurrOffset) && *(char *)CP != 0) {
            while(*(char *)CP != '\n' && *(char *)CP != 0)
                CP++;
            *(char *)CP = NULL;
            if (*(char *)LP != 0)
                LOGD_IS("%s", (char *)LP);
            LP = ++CP;
        }
    }

    mPrevWp = mIs_debug_ctrl.write_point;
    mPrevOffset = mPrevWp - FIMC_IS_FW_DEBUG_REGION_ADDR;

}

#if IS_FW_DEBUG_THREAD
bool ISecCameraHardware::debugThread()
{
    mDebugLock.lock();
    mDebugCondition.waitRelative(mDebugLock, 2000000000);
    if (mStopDebugging) {
        mDebugLock.unlock();
        return false;
    }

    printDebugFirmware();

    mDebugLock.unlock();

    return true;

}
#endif
#endif

status_t ISecCameraHardware::startPreview()
{
    ALOGD("startPreview E");

    mSensorSize.width = 0;
    mSensorSize.height = 0;

    LOG_PERFORMANCE_START(1);

    Mutex::Autolock lock(mLock);

    if (mPictureRunning) {
        ALOGW("startPreview: warning, picture is not completed yet");
        if ((mMsgEnabled & CAMERA_MSG_RAW_IMAGE) ||
            (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME)) {
            /* upper layer can access the mmaped memory if raw or postview message is enabled
            But the data will be changed after preview is started */
            ALOGE("startPreview: error, picture data is not transferred yet");
            return INVALID_OPERATION;
        }
    }

    status_t ret;
    if (mEnableDZoom)
        ret = nativeStartPreviewZoom();
    else
        ret = nativeStartPreview();

    if (ret != NO_ERROR) {
        ALOGE("startPreview: error, nativeStartPreview");
#if IS_FW_DEBUG
        if (mCameraId == CAMERA_FACING_FRONT || mCameraId == FD_SERVICE_CAMERA_ID)
            printDebugFirmware();
#endif
        return NO_INIT;
    }

    mFlagFirstFrameDump = false;
    if (mEnableDZoom) {
#ifdef CHANGED_PREVIEW_SUPPORT
        int FaceMode = getFaceDetection();
        if(mPASMMode !=	MODE_BEAUTY_SHOT && FaceMode != V4L2_FACE_DETECTION_SMILE_SHOT) {
            ret = mPreviewZoomThread->run("previewZoomThread", PRIORITY_URGENT_DISPLAY);
            mPreviewThreadType = PREVIEW_THREAD_NORMAL;
        }
        else {
            ret = mChangedPreviewThread->run("changedPreviewThread", PRIORITY_URGENT_DISPLAY);
            mPreviewThreadType = PREVIEW_THREAD_CHANGED;
        }
#else
        ret = mPreviewZoomThread->run("previewZoomThread", PRIORITY_URGENT_DISPLAY);
        mPreviewThreadType = PREVIEW_THREAD_NORMAL;
#endif
    }
    else {
        ret = mPreviewThread->run("previewThread", PRIORITY_URGENT_DISPLAY);
        mPreviewThreadType = PREVIEW_THREAD_NORMAL;		
    }

    if (ret != NO_ERROR) {
        ALOGE("startPreview: error, Not starting preview");
        return UNKNOWN_ERROR;
    }

#if FRONT_ZSL
    if (mSamsungApp && !mMovieMode && mCameraId == CAMERA_FACING_FRONT) {
        if (nativeStartFullPreview() != NO_ERROR) {
            ALOGE("startPreview: error, nativeStartPreview");
            return NO_INIT;
        }

        if (mZSLPictureThread->run("zslpictureThread", PRIORITY_URGENT_DISPLAY) != NO_ERROR) {
            ALOGE("startPreview: error, Not starting preview");
            return UNKNOWN_ERROR;
        }

        mFullPreviewRunning = true;
    }
#endif
	mPreviewRunning = true;

    LOG_PERFORMANCE_END(1, "total");

    ALOGD("startPreview X");
    return NO_ERROR;
}

bool ISecCameraHardware::previewThread()
{
    int index = nativeGetPreview();
    if (CC_UNLIKELY(index < 0)) {
		if (mFastCaptureCalled) {
			return false;
		}
        ALOGE("previewThread: error, nativeGetPreview");
#if IS_FW_DEBUG
        if (mCameraId == CAMERA_FACING_FRONT || mCameraId == FD_SERVICE_CAMERA_ID) {
            dump_is_fw_log("streamOn", (uint8_t *)mDebugVaddr, (uint32_t)FIMC_IS_FW_DEBUG_REGION_SIZE);
            printDebugFirmware();
        }
#endif
        if (!mPreviewThread->exitRequested()) {
#ifdef DEBUG_PREVIEW_NO_FRAME
            if (!mFactoryMode)
                LOG_FATAL("nativeGetPreview: failed to get a frame!");
            else
                mNotifyCb(CAMERA_MSG_ERROR, 2000, 0, mCallbackCookie);
#else
            if (!recordingEnabled())
                mNotifyCb(CAMERA_MSG_ERROR, 2000, 0, mCallbackCookie);
            else {
                ALOGI("previewThread: X");
                return false;
            }
#endif
            ALOGI("previewThread: X, after callback");
        }
        return false;
    }else if (mPreviewThread->exitRequested()) {
        return false;
    }

#ifdef DUMP_LAST_PREVIEW_FRAME
    mLastIndex = index;
#endif

    mLock.lock();

    if (mDropFrameCount > 0) {
        mDropFrameCount--;
        mLock.unlock();
        nativeReleasePreviewFrame(index);
        return true;
    }

    mLock.unlock();

    /* Notify the client of a new frame. */
    if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
#ifdef DEBUG_PREVIEW_CALLBACK
        if (!mPreviewCbStarted) {
            mPreviewCbStarted = true;
            ALOGD("preview callback started");
        }
#endif
        mDataCb(CAMERA_MSG_PREVIEW_FRAME, mPreviewHeap, index, NULL, mCallbackCookie);
    }

    /* Display a new frame */
    if (CC_LIKELY(mFlagANWindowRegister)) {
        bool ret = nativeFlushSurface(mPreviewWindowSize.width, mPreviewWindowSize.height, mPreviewFrameSize, index);
        if (CC_UNLIKELY(!ret))
            ALOGE("previewThread: error, nativeFlushSurface");
    }

    mLock.lock();
    if (mFirstStart == 0)
        mFirstStart = 1;
    mLock.unlock();

#if DUMP_FILE
    static int i = 0;
    if (++i % 15 == 0) {
        dumpToFile(mPreviewHeap->data + (mPreviewFrameSize*index), mPreviewFrameSize, "/data/preview.yuv");
        i = 0;
    }
#endif

    /* Release the frame */
    int err = nativeReleasePreviewFrame(index);
    if (CC_UNLIKELY(err < 0)) {
        ALOGE("previewThread: error, nativeReleasePreviewFrame");
        return false;
    }

#if defined(SEC_USES_TVOUT) && defined(SUSPEND_ENABLE)
    nativeTvoutSuspendCall();
#endif

    /* prevent a frame rate from getting higher than the max value */
    mPreviewThread->calcFrameWaitTime(mMaxFrameRate);

    return true;
}

bool ISecCameraHardware::previewZoomThread()
{
    int index = nativeGetPreview();
    int err = -1;

    if (CC_UNLIKELY(index < 0)) {
		if (mFastCaptureCalled) {
			return false;
		}
        ALOGE("previewZoomThread: error, nativeGetPreview in %s", recordingEnabled() ? "recording" : "preview");
#ifndef APPLY_ESD
        if (!mPreviewZoomThread->exitRequested()) {
#ifdef DEBUG_PREVIEW_NO_FRAME
            if (!mFactoryMode) {
                LOG_FATAL("nativeGetPreview: failed to get a frame!");
            } else {
                mNotifyCb(CAMERA_MSG_ERROR, 2000, 0, mCallbackCookie);
                ALOGI("previewZoomThread: X, after callback");
            }
#else
            mNotifyCb(CAMERA_MSG_ERROR, 2000, 0, mCallbackCookie);
            ALOGI("previewZoomThread: X, after callback");
#endif
        }
#endif	/* #ifndef APPLY_ESD */

#if VENDOR_FEATURE
#ifdef APPLY_ESD
        if (!mFactoryNumCnt) { /*14.02.15. heechul, this notiCb makes factory test NG */
            ALOGE("previewZoomThread: error, Before CAMERA_MSG_ERROR. ESD");
            mNotifyCb(CAMERA_MSG_ERROR, CAMERA_ERROR_PREVIEWFRAME_TIMEOUT, 0, mCallbackCookie);
            ALOGE("previewZoomThread: error, After CAMERA_MSG_ERROR. ESD");
        }
#endif	/* #ifdef APPLY_ESD */
#endif
        return false;
    } else if (mPreviewZoomThread->exitRequested()) {
        return false;
    }

#ifdef DUMP_LAST_PREVIEW_FRAME
    mLastIndex = index;
#endif

    mPostRecordIndex = index;

    mLock.lock();
    if (mDropFrameCount > 0) {
        mDropFrameCount--;
        mLock.unlock();
        nativeReleasePreviewFrame(index);
        return true;
    }
    mLock.unlock();

    /* first frame dump to jpeg */
    if (mFlagFirstFrameDump == true) {
        memcpy(mPictureBuf.virt.extP[0], mFliteNode.buffer[index].virt.extP[0], mPictureBuf.size.extS[0]);
        nativeMakeJpegDump();
        mFlagFirstFrameDump = false;
    }

    /* when recording mode, push frame of dq from FLite */
    if (mRecordingRunning) {
        static int skip_cnt;
        bool skip_frame_set;
        int videoSlotIndex = getRecSrcBufSlotIndex();
        if (videoSlotIndex < 0) {
            ALOGE("ERROR(%s): videoSlotIndex is -1", __func__);
        } else {
            if ( (mFrameRate == 15000) && (skip_cnt++ % 2))
                skip_frame_set = true;
            else
                skip_frame_set = false;

            if(!skip_frame_set) {
                mRecordSrcSlot[videoSlotIndex].buf = &(mFliteNode.buffer[index]);
                mRecordSrcSlot[videoSlotIndex].timestamp = mRecordTimestamp;
                /* ALOGV("DEBUG(%s): recording src(%d) adr %p, timestamp %lld", __func__, videoSlotIndex,
                    (mRecordSrcSlot[videoSlotIndex].buf)->virt.p, mRecordSrcSlot[videoSlotIndex].timestamp); */
                mPushRecSrcQ(&mRecordSrcSlot[videoSlotIndex]);
                mPostRecordCondition.signal();
            }
        }
    }

    mPreviewRunning = true;

    if(mFps == 120) {
        static int nDisplayDropCnt = 0;
        if(nDisplayDropCnt > 0) {
            nDisplayDropCnt--;
			/* Release the frame */
            err = nativeReleasePreviewFrame(index);
            if (CC_UNLIKELY(err < 0)) {
                ALOGE("previewZoomThread: error, nativeReleasePreviewFrame");
                return false;
            }
            return true;
        }
        else {
            nDisplayDropCnt = 1;
        }
    }
    /* Display a new frame */
    if (CC_LIKELY(mFlagANWindowRegister)) {
        bool ret = nativeFlushSurface(mPreviewWindowSize.width, mPreviewWindowSize.height, mPreviewFrameSize, index);
        if (CC_UNLIKELY(!ret))
            ALOGE("previewThread: error, nativeFlushSurface");
    } else {
        /* if not register ANativeWindow, just prepare callback buffer on CAMERA_MSG_PREVIEW_FRAME */
        if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
            if (nativePreviewCallback(index, NULL) < 0)
                ALOGE("ERROR(%s): nativePreviewCallback failed", __func__);
    }

    /* Notify the client of a new frame. */
    if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
#ifdef DEBUG_PREVIEW_CALLBACK
        if (!mPreviewCbStarted) {
            mPreviewCbStarted = true;
            ALOGD("preview callback started");
        }
#endif
        mDataCb(CAMERA_MSG_PREVIEW_FRAME, mPreviewHeap, index, NULL, mCallbackCookie);
    }

#if DUMP_FILE
    static int i = 0;
    if (++i % 15 == 0) {
        dumpToFile(mPreviewHeap->data + (mPreviewFrameSize*index), mPreviewFrameSize, "/data/preview.yuv");
        i = 0;
    }
#endif

    /* Release the frame */
    err = nativeReleasePreviewFrame(index);
    if (CC_UNLIKELY(err < 0)) {
        ALOGE("previewZoomThread: error, nativeReleasePreviewFrame");
        return false;
    }

    return true;
}

#ifdef CHANGED_PREVIEW_SUPPORT
bool ISecCameraHardware::changedPreviewThread()
{
    int index = nativeGetPreview();
    int err = -1;

    if (CC_UNLIKELY(index < 0)) {
		if (mFastCaptureCalled) {
			return false;
		}
        ALOGE("changedPreviewThread: error, nativeGetPreview in %s", recordingEnabled() ? "recording" : "preview");
        if (!mChangedPreviewThread->exitRequested()) {
#ifdef DEBUG_PREVIEW_NO_FRAME
            if (!mFactoryMode) {
                LOG_FATAL("nativeGetPreview: failed to get a frame!");
            } else {
                mNotifyCb(CAMERA_MSG_ERROR, 2000, 0, mCallbackCookie);
                ALOGI("changedPreviewThread: X, after callback");
            }
#else
            mNotifyCb(CAMERA_MSG_ERROR, 2000, 0, mCallbackCookie);
            ALOGI("changedPreviewThread: X, after callback");
#endif
        }
        return false;
    } else if (mChangedPreviewThread->exitRequested()) {
        return false;
    }
#ifdef DUMP_LAST_PREVIEW_FRAME
    mLastIndex = index;
#endif

    mLock.lock();
    if (mDropFrameCount > 0) {
        mDropFrameCount--;
        mLock.unlock();
        nativeReleasePreviewFrame(index);
        return true;
    }
    mLock.unlock();

    /* first frame dump to jpeg */
    if (mFlagFirstFrameDump == true) {
        memcpy(mPictureBuf.virt.extP[0], mFliteNode.buffer[index].virt.extP[0], mPictureBuf.size.extS[0]);
        nativeMakeJpegDump();
        mFlagFirstFrameDump = false;
    }

    /* Convert frame format from YV12 to NV21  */
    nativeCSCPreview(index, CAMERA_HEAP_PREVIEW);
    /* Notify the client of a new frame. */
    if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
#ifdef DEBUG_PREVIEW_CALLBACK
        if (!mPreviewCbStarted) {
            mPreviewCbStarted = true;
            ALOGD("preview callback started");
        }
#endif
        mDataCb(CAMERA_MSG_PREVIEW_FRAME, mPreviewHeap, index, NULL, mCallbackCookie);
    }
    /* Display a new frame */
    if (CC_LIKELY(mFlagANWindowRegister)) {
        bool ret = beautyLiveFlushSurface(mPreviewWindowSize.width, mPreviewWindowSize.height, mPreviewFrameSize, index);
        if (CC_UNLIKELY(!ret))
            ALOGE("changedPreviewThread: error, nativeFlushSurface");
    } else {
        /* if not register ANativeWindow, just prepare callback buffer on CAMERA_MSG_PREVIEW_FRAME */
        if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
            if (nativePreviewCallback(index, NULL) < 0)
                ALOGE("ERROR(%s): nativePreviewCallback failed", __func__);
    }
    mPreviewRunning = true;

#if DUMP_FILE
    static int i = 0;
    if (++i % 15 == 0) {
        dumpToFile(mPreviewHeap->data + (mPreviewFrameSize*index), mPreviewFrameSize, "/data/preview.yuv");
        i = 0;
    }
#endif

    /* Release the frame */
    err = nativeReleasePreviewFrame(index);
    if (CC_UNLIKELY(err < 0)) {
        ALOGE("changedPreviewThread: error, nativeReleasePreviewFrame");
        return false;
    }
    return true;
}
#endif

void ISecCameraHardware::stopPreview()
{
	ALOGD("stopPreview E");

	/*
	 * try count to wait for stopping previewThread
	 * maximum wait time = 30 * 10ms
	 */
	int waitForCnt = 600; // 30 -->. 600 (300ms --> 6sec) because, Polling timeout is 5 sec.

	LOG_PERFORMANCE_START(1);

	{
		Mutex::Autolock lock(mLock);
		if (!mPreviewRunning) {
			ALOGW("stopPreview: warning, preview has been stopped");
			return;
		}
	}

    if(mPASMMode == MODE_PANORAMA)
        disableMsgType(CAMERA_MSG_PREVIEW_FRAME);

	if(!mFactorySysMode)
		nativeDestroySurface();
	/* don't hold the lock while waiting for the thread to quit */
#if FRONT_ZSL
	if (mFullPreviewRunning) {
		mZSLPictureThread->requestExitAndWait();
		nativeForceStopFullPreview();
		nativeStopFullPreview();
		mFullPreviewRunning = false;
	}
#endif
	if (mEnableDZoom) {
#ifdef CHANGED_PREVIEW_SUPPORT
		if(mPreviewThreadType == PREVIEW_THREAD_NORMAL) {
			mPreviewZoomThread->requestExit();
			/* if previewThread can't finish, wait for 300ms */
			while (waitForCnt > 0 && mPreviewZoomThread->getTid() >= 0) {
				usleep(10000);
				waitForCnt--;
				if(waitForCnt == 0)
					ALOGD("waitForCnt is ZERO");
			}
		}
		else {
			mChangedPreviewThread->requestExit();
			/* if mChangedPreviewThread can't finish, wait for 25ms */
			while (waitForCnt > 0 && mChangedPreviewThread->getTid() >= 0) {
				usleep(10000);
				waitForCnt--;
			}
		}
#else
		mPreviewZoomThread->requestExit();
		/* if previewThread can't finish, wait for 25ms */
		while (waitForCnt > 0 && mPreviewZoomThread->getTid() >= 0) {
			usleep(10000);
			waitForCnt--;
		}
#endif
	} else {
		mPreviewThread->requestExitAndWait();
	}

	mPreviewThreadType = PREVIEW_THREAD_NONE;
#ifdef DUMP_LAST_PREVIEW_FRAME
	uint32_t offset = mPreviewFrameSize * mLastIndex;
	dumpToFile(mPreviewHeap->base() + offset, mPreviewFrameSize, "/data/preview-last.dump");
#endif

	Mutex::Autolock lock(mLock);

	nativeStopPreview();

	if (mEnableDZoom == true && waitForCnt > 0)
		mPreviewZoomThread->requestExitAndWait();

	mPreviewRunning = false;
	mPreviewInitialized = false;
#ifdef DEBUG_PREVIEW_CALLBACK
	mPreviewCbStarted = false;
#endif
	mDropFrameCount = INITIAL_REAR_SKIP_FRAME;
	LOG_PERFORMANCE_END(1, "total");

	if (mPreviewHeap) {
		mPreviewHeap->release(mPreviewHeap);
		mPreviewHeap = 0;
		mPreviewHeapFd = -1;
	}

	if (mRecordingHeap) {
		mRecordingHeap->release(mRecordingHeap);
		mRecordingHeap = 0;
	}

	if (mRawHeap != NULL) {
		mRawHeap->release(mRawHeap);
		mRawHeap = 0;
	}

	if (mJpegHeap) {
		mJpegHeap->release(mJpegHeap);
		mJpegHeap = 0;
	}

	if (mHDRHeap) {
		mHDRHeap->release(mHDRHeap);
		mHDRHeap = 0;
	}

	if (mPostviewHeap) {
		mPostviewHeap->release(mPostviewHeap);
		mPostviewHeap = 0;
	}

	if (mPostviewHeapTmp) {
		mPostviewHeapTmp->release(mPostviewHeapTmp);
		mPostviewHeapTmp = 0;
	}

	ALOGD("stopPreview X");
}

status_t ISecCameraHardware::storeMetaDataInBuffers(bool enable)
{
    ALOGV("%s", __FUNCTION__);

    if (!enable) {
        ALOGE("Non-m_frameMetadata buffer mode is not supported!");
        return INVALID_OPERATION;
    }

    return OK;
}

status_t ISecCameraHardware::startRecording()
{
    ALOGD("startRecording E");

    Mutex::Autolock lock(mLock);

    status_t ret;
    mLastRecordTimestamp = 0;
#if FRONT_ZSL
    if (mFullPreviewRunning) {
        nativeForceStopFullPreview();
        mZSLPictureThread->requestExitAndWait();
        nativeStopFullPreview();
        mFullPreviewRunning = false;
    }
#endif

    if (mEnableDZoom) {
        ret = nativeStartRecordingZoom();
    } else {
        ret = nativeStartRecording();
    }

    if (CC_UNLIKELY(ret != NO_ERROR)) {
        ALOGE("startRecording X: error, nativeStartRecording");
        return UNKNOWN_ERROR;
    }

    if (mEnableDZoom) {
        mPostRecordExit = false;
        ret = mPostRecordThread->run("postRecordThread", PRIORITY_URGENT_DISPLAY);
    } else
        ret = mRecordingThread->run("recordingThread", PRIORITY_URGENT_DISPLAY);

    if (CC_UNLIKELY(ret != NO_ERROR)) {
        mRecordingTrace = true;
        ALOGE("startRecording: error %d, Not starting recording", ret);
        return ret;
    }

    mRecordingRunning = true;

    ALOGD("startRecording X");
    return NO_ERROR;
}

bool ISecCameraHardware::recordingThread()
{
    return true;
}

bool ISecCameraHardware::postRecordThread()
{
    mPostRecordLock.lock();
    mPostRecordCondition.wait(mPostRecordLock);
    mPostRecordLock.unlock();

    if (mSizeOfRecSrcQ() == 0) {
        ALOGW("WARN(%s): mSizeOfRecSrcQ size is zero", __func__);
    } else {
        rec_src_buf_t srcBuf;

        while (mSizeOfRecSrcQ() > 0) {
			int index;

            /* get dst video buf index */
            index = getRecDstBufIndex();
            if (index < 0) {
                ALOGW("WARN(%s): getRecDstBufIndex(%d) sleep and continue, skip frame buffer", __func__, index);
                usleep(13000);
                continue;
            }

            /* get src video buf */
            if (mPopRecSrcQ(&srcBuf) == false) {
                ALOGW("WARN(%s): mPopRecSrcQ(%d) failed", __func__, index);
                return false;
            }

            /* ALOGV("DEBUG(%s): SrcBuf(%d, %d, %lld), Dst idx(%d)", __func__,
                srcBuf.buf->fd.extFd[0], srcBuf.buf->fd.extFd[1], srcBuf.timestamp, index); */

            /* Notify the client of a new frame. */
            if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) {
				bool ret;
                /* csc from flite to video MHB and callback */
                ret = nativeCSCRecording(&srcBuf, index);
                if (ret == false) {
                    ALOGE("ERROR(%s): nativeCSCRecording failed.. SrcBuf(%d, %d, %lld), Dst idx(%d)", __func__,
                        srcBuf.buf->fd.extFd[0], srcBuf.buf->fd.extFd[1], srcBuf.timestamp, index);
                    setAvailDstBufIndex(index);
                    return false;
                } else {
                    if (0L < srcBuf.timestamp && mLastRecordTimestamp < srcBuf.timestamp) {
                        mDataCbTimestamp(srcBuf.timestamp, CAMERA_MSG_VIDEO_FRAME,
                                         mRecordingHeap, index, mCallbackCookie);
                        mLastRecordTimestamp = srcBuf.timestamp;
                        LOG_RECORD_TRACE("callback returned");
                    } else {
                        ALOGW("WARN(%s): timestamp(%lld) invaild - last timestamp(%lld) systemtime(%lld)",
                            __func__, srcBuf.timestamp, mLastRecordTimestamp, systemTime(SYSTEM_TIME_MONOTONIC));
                        setAvailDstBufIndex(index);
                    }
                }
            }
        }
    }
    LOG_RECORD_TRACE("X");
    return true;
}

void ISecCameraHardware::stopRecording()
{
    ALOGD("stopRecording E");

    Mutex::Autolock lock(mLock);
    if (!mRecordingRunning) {
        ALOGW("stopRecording: warning, recording has been stopped");
        return;
    }

    /* We request thread to exit. Don't wait. */
    if (mEnableDZoom) {
        mPostRecordExit = true;

        /* Change calling order of requestExit...() and signal
         * if you want to change requestExit() to requestExitAndWait().
         */
        mPostRecordThread->requestExit();
        mPostRecordCondition.signal();
        nativeStopRecording();
    } else {
        mRecordingThread->requestExit();
        nativeStopRecording();
    }

    mRecordingRunning = false;

    ALOGD("stopRecording X");
}

void ISecCameraHardware::releaseRecordingFrame(const void *opaque)
{
    status_t ret = NO_ERROR;
    bool found = false;
    int i;

    /* We does not release frames recorded any longer
     * if this function is called after stopRecording().
     */
    if (mEnableDZoom)
        ret = mPostRecordThread->exitRequested();
    else
        ret = mRecordingThread->exitRequested();

    if (CC_UNLIKELY(ret)) {
        ALOGW("releaseRecordingFrame: warning, we do not release any more!!");
        return;
    }

    {
        Mutex::Autolock lock(mLock);
        if (CC_UNLIKELY(!mRecordingRunning)) {
            ALOGW("releaseRecordingFrame: warning, recording is not running");
            return;
        }
    }

    struct addrs *addrs = (struct addrs *)mRecordingHeap->data;

    /* find MHB handler to match */
    if (addrs) {
        for (i = 0; i < REC_BUF_CNT; i++) {
            if ((char *)(&(addrs[i].type)) == (char *)opaque) {
                found = true;
                break;
            }
        }
    }

    mRecordDstLock.lock();
    if (found) {
        mRecordFrameAvailableCnt++;
        /* ALOGV("DEBUG(%s): found index[%d] FDy(%d), FDcbcr(%d) availableCount(%d)", __func__,
            i, addrs[i].fd_y, addrs[i].fd_cbcr, mRecordFrameAvailableCnt); */
        mRecordFrameAvailable[i] = true;
    } else
        ALOGE("ERR(%s):no matched index(%p)", __func__, (char *)opaque);

    if (mRecordFrameAvailableCnt > REC_BUF_CNT) {
        ALOGW("WARN(%s): mRecordFrameAvailableCnt is more than REC_BUF!!", __func__);
        mRecordFrameAvailableCnt = REC_BUF_CNT;
    }
    mRecordDstLock.unlock();
}

#ifdef ZOOM_CTRL_THREAD
bool ISecCameraHardware::ZoomCtrlThread()
{
	static int lens_checked;
	static int zoom_change;
	int get_zoom_read;
	int opti_zoom_level, opti_zoom_status;
	int get_lens_status;

	if (mZoomParamSet) {

	if (mPreviewRunning && !mPictureRunning && !mPictureStart) {
		nativeGetParameters(CAM_CID_ZOOM, &get_zoom_read);

		opti_zoom_level = get_zoom_read & 0x0F;
		opti_zoom_status = (get_zoom_read >> 4) & 0x07;

		if (opti_zoom_level != mZoomCurrLevel) {
			zoom_change = 1;
			mZoomCurrLevel = opti_zoom_level;
		}

		if (opti_zoom_status != mZoomStatus) {
			mZoomStatus = opti_zoom_status;
			if (!mZoomStatus) {
				zoom_change = 1;
			}
		}

		mLock.lock();
		mParameters.set("curr_zoom_level", mZoomCurrLevel);
		mParameters.set(CameraParameters::KEY_ZOOM_LENS_STATUS, mZoomStatus);
		mLock.unlock();

		if ( (mZoomStatusBak&0x06) != (mZoomStatus&0x6) ) {
			ALOGD("Smart LensStatus------- : %02x  ->  %02x (%d)   Level:%d", mZoomStatusBak, mZoomStatus, mZoomStatus&0x4, mZoomCurrLevel);
			mZoomStatusBak = mZoomStatus;
			if ( mZoomStatus&0x6 )
				zoom_change = 1;
		}


		if (!mLensChecked) {
			nativeGetParameters(CAM_CID_LENS_STATUS, &get_lens_status);
			if (get_lens_status == 3 || get_lens_status == 2) {
				lens_checked = 1;
				zoom_change = 1;
				mLensChecked = 1;
				ALOGD("Smart LensStatus : Lens %s error", (get_lens_status == 3 ? "open" : "close"));
			}
			ALOGV("Smart LensStatus : %d", get_lens_status);
		}

		if (!mPictureStart && (mMsgEnabled & CAMERA_MSG_ZOOM_STEP_NOTIFY)) {
			mLensStatus = mZoomStatus | (lens_checked << 3);
			lens_checked = 0;
			if(zoom_change == 1) {
				mNotifyCb(CAMERA_MSG_ZOOM_STEP_NOTIFY, mLensStatus, mZoomCurrLevel, mCallbackCookie);
				ALOGD("ZoomCtrlThread: callback  zoom level : %d, status : %02x, checked : %x02x, zoom_cmd:%d", mZoomCurrLevel, mLensStatus, lens_checked, zoom_cmd);
				zoom_change = 0;
			}

			if(zoom_cmd != 100) {
				if((zoom_cmd == V4L2_OPTICAL_ZOOM_TELE_START || zoom_cmd == V4L2_OPTICAL_ZOOM_WIDE_START ||zoom_cmd == V4L2_OPTICAL_ZOOM_SLOW_TELE_START 
					|| zoom_cmd == V4L2_OPTICAL_ZOOM_SLOW_WIDE_START	|| zoom_cmd == V4L2_OPTICAL_ZOOM_PINCH_START 
					|| zoom_cmd == V4L2_OPTICAL_ZOOM_PINCH_STOP)  && mLensStatus == 0) {
					if( ((zoom_cmd == V4L2_OPTICAL_ZOOM_TELE_START || zoom_cmd == V4L2_OPTICAL_ZOOM_SLOW_TELE_START) && mLensStatus == 0 && mZoomCurrLevel == 15) 
						||((zoom_cmd == V4L2_OPTICAL_ZOOM_WIDE_START || zoom_cmd == V4L2_OPTICAL_ZOOM_SLOW_WIDE_START) && mLensStatus == 0 && mZoomCurrLevel == 0)	) {
						ALOGD("ZoomCtrlThread: zoom_cmd:%d, mLensStatus:%d, mZoomCurrLevel:%d", zoom_cmd, mLensStatus, mZoomCurrLevel);
						ALOGD("ZoomCtrlThread: CAM_CID_OPTICAL_ZOOM_CTRL STOP 3");
						nativeSetParameters(CAM_CID_OPTICAL_ZOOM_CTRL, V4L2_OPTICAL_ZOOM_STOP);
						old_zoom_cmd = zoom_cmd;
						zoom_cmd = 100;
					} else {
						ALOGD("ZoomCtrlThread: CAM_CID_OPTICAL_ZOOM_CTRL zoom_cmd:%d, old_zoom_cmd:%d", zoom_cmd, old_zoom_cmd);
						if(zoom_cmd != V4L2_OPTICAL_ZOOM_STOP && old_zoom_cmd != V4L2_OPTICAL_ZOOM_STOP && zoom_cmd != 100 && old_zoom_cmd != 100) {
							ALOGD("ZoomCtrlThread: CAM_CID_OPTICAL_ZOOM_CTRL STOP 4");
							nativeSetParameters(CAM_CID_OPTICAL_ZOOM_CTRL, V4L2_OPTICAL_ZOOM_STOP);
							old_zoom_cmd = V4L2_OPTICAL_ZOOM_STOP;
						} else {
							ALOGD("ZoomCtrlThread: CAM_CID_OPTICAL_ZOOM_CTRL 4 zoom_cmd:%d", zoom_cmd);
							nativeSetParameters(CAM_CID_OPTICAL_ZOOM_CTRL, zoom_cmd);
							old_zoom_cmd = zoom_cmd;
							zoom_cmd = 100;
						}
					}
				} else if(zoom_cmd == V4L2_OPTICAL_ZOOM_STOP && mLensStatus == 1) {
					ALOGD("ZoomCtrlThread: CAM_CID_OPTICAL_ZOOM_CTRL STOP");
					nativeSetParameters(CAM_CID_OPTICAL_ZOOM_CTRL, zoom_cmd);
					old_zoom_cmd = zoom_cmd;
					zoom_cmd = 100;
				} else if(zoom_cmd == V4L2_OPTICAL_ZOOM_STOP && mLensStatus == 0 && (mZoomCurrLevel == 0 || mZoomCurrLevel == 15)) { 
					ALOGD("ZoomCtrlThread: CAM_CID_OPTICAL_ZOOM_CTRL STOP 2");
					nativeSetParameters(CAM_CID_OPTICAL_ZOOM_CTRL, zoom_cmd);
					old_zoom_cmd = zoom_cmd;
					zoom_cmd = 100;
				}
			}
		}
	}
	}

	usleep(10000);

	ALOGV("ZoomCtrlThread X");

	return true;
}
#endif

bool ISecCameraHardware::shutterThread()
{
	int read_val = 0;
	int err;

	ALOGD("ShutterThread: E");
	if (mCameraPower == false)
		return false;
	err = nativeGetNotiParameters(CAM_CID_NOTIFICATION, &read_val);
	ALOGD("ShutterThread: read_val = %d", read_val);
	if (err < 0) {
		ALOGD("ShutterThread: Sound interrupt wakeup by timeout(35sec). NO ERROR");
	} else {
		if (mCameraPower == false) {
			ALOGD("ShutterThread: Forced wakeup sound interrupt. NO ERROR.");
		} else {
#ifdef BURST_SHOT_SUPPORT
			if (mCaptureMode == RUNNING_MODE_BURST) {
				mBurstSoundCount++;
				if (mBurstSoundCount == 1) {
					ALOGD("BURSTSHOT: shutterThread: wakeup burstPictureThread()");
					mBurstShotCondition.signal();
				}

				if (mBurstSoundCount > mBurstSoundMaxCount) {
					mBurstSoundMaxCount = mBurstSoundCount;
					ALOGD("shutterThread: mBurstSoundMaxCount = %d", mBurstSoundMaxCount);
				}
			}
            ALOGE("BURSTSHOT ----- : CAMERA_MSG_SHUTTER  %d/%d", mBurstSoundCount, mBurstSoundMaxCount);
#endif
			if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
				ALOGD("ShutterThread: Sound interrupt issued. Play shutter sound.");
				mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
			} else {
				ALOGE("ShutterThread: Sound interrupt issued but CAMERA_MSG_SHUTTER is disabled.");
			}
		}
	}

	if (mCameraPower == false)
		return false;
	else
		return true;
}

#ifdef SMART_THREAD
bool ISecCameraHardware::smartThread()
{
    static unsigned int thread_cnt, time_setting;
//    int err;
    int get_lens_status;


//    int strobe_charge, strobe_up_down;
//    float now_AV, now_TV, now_EV, now_EXP;
//    int now_SceneMode, now_SceneSubMode, now_FDnum, now_OTstatus, now_LV;
    int smart_self_shot_fd_info1 = 0, smart_self_shot_fd_info2 = 0;
    int fd_info_top = 0, fd_info_left = 0, fd_info_right = 0, fd_info_bottom = 0;

    /* for NSM Mode*/
    int nsm_fd_update = 0;
    /* end NSM Mode */

//    ALOGV("smartThread E");
    if (mCameraId == CAMERA_FACING_FRONT)
        return true;

    thread_cnt++;

    //Mutex::Autolock lock(mLock);

#if 0
//LOW_TEMPERATURE_LOCK_SUPPORT
    if(nativeCheckTimeUnLockFreq()) {
        ALOGD("LOW_TEMPERATURE_LOCK_SUPPORT : UNLOCK");
        nativeUnlockCurrCpuFreq();
        nativeUnlockBusFreq();
        nativeUnlockCpuMax();

        mTempLockChecking = false;
    }
#endif
    if(mBFactoryStopSmartThread) {
        ALOGD("pass smartThread for factory test");
        usleep(50000);
        return true;
    }

    if (mPreviewRunning && !mPictureRunning && !mPictureStart) {
		static int zoom_change;
		static int lens_checked;
#ifdef AUTO_PARAM_CALLBACK
        int autoparam_update = 0;
#endif
#ifdef SMART_READ_INFO
        int smart_read1 = 0, smart_read2 = 0;
#endif

        if (mZoomParamSet) {
            int get_zoom_read;
            int opti_zoom_level, opti_zoom_status;
#ifndef SMART_READ_INFO
            nativeGetParameters(CAM_CID_OPTICAL_ZOOM_CTRL, &get_zoom_read);
#else
            nativeGetParameters(CAM_CID_ZOOM, &get_zoom_read);
#endif
            opti_zoom_level = get_zoom_read & 0x1F;
            opti_zoom_status = (get_zoom_read >> 5) & 0x01;

            if (opti_zoom_level != mZoomCurrLevel) {
                zoom_change = 1;
                mZoomCurrLevel = opti_zoom_level;
            }

            if (opti_zoom_status != mZoomStatus) {
                mZoomStatus = opti_zoom_status;
                if (!mZoomStatus) {
                    zoom_change = 1;
                }
            }

            mLock.lock();
            mParameters.set("curr_zoom_level", mZoomCurrLevel);
            mParameters.set(CameraParameters::KEY_ZOOM_LENS_STATUS, mZoomStatus);
            mLock.unlock();

            //ALOGV("zoom level: %d, status: %d", mZoomCurrLevel, mZoomStatus);
        }

        mLock.lock();
        if (!(thread_cnt % 9600) || mFirstStart == 1) {
            time_setting = 1;
        }
        mLock.unlock();

        if (!(thread_cnt % 10)) {
#ifndef SMART_READ_INFO
#if 0
            nativeGetParameters(CAM_CID_FLASH, &get_flash_read);

            strobe_charge = get_flash_read & 0xFF;
            strobe_up_down = (get_flash_read >> 8) & 0xFF;

            mLock.lock();
            mParameters.set(CameraParameters::KEY_FLASH_CHARGING, strobe_charge);
            mParameters.set(CameraParameters::KEY_FLASH_STANDBY,
                    strobe_up_down ? CameraParameters::FLASH_STANDBY_ON
                    : CameraParameters::FLASH_STANDBY_OFF);
            mLock.unlock();

            ALOGV("strobe charge: %d, up_down: %d", strobe_charge, strobe_up_down);

            now_AV = nativeGetAV();
            now_TV = nativeGetTV();
            now_LV = nativeGetLV();
            now_SV = nativeGetSV();
            now_SceneMode = nativeGetSceneMode();
            now_SceneSubMode = nativeGetSceneSubMode();
            now_FDnum = nativeGetFDnumber();
            now_OTstatus = nativeGetOTstatus();
            now_WC = nativegetWarningCondition();

            now_AV = now_AV / 65536;
            now_TV = now_TV / 65536;
            now_SV = now_SV / 65536;
            now_EV = now_AV + now_TV;

            //now_AV = sqrt(pow(2,now_AV));
            now_AV = findfnumbervalue((int)(now_AV*10));

            //now_TV = 1/(pow(2,now_TV))*1000;
            now_TV = findShutterSpeedIndex((int)(now_TV*10));

            now_EV = findEVindex(now_EV);

            now_SV = pow(2,now_SV) / 0.32;
            now_ISO = findISOIndex((int)now_SV);

            ALOGV("AV : %d,  TV : %d,  EV : %d FDnum : %d OT : %d LV : %d ISO : %d", (int)now_AV, (int)now_TV, (int)now_EV, now_FDnum, now_OTstatus, now_LV, now_ISO);

            if (now_EV > 6)
                now_EV = 6.000;
            else if (now_EV < -6)
                now_EV = -6.000;

            ALOGV("Smart AV : %d,  TV : %d,  EV : %d FDnum : %d OT : %d LV : %d ISO : %d", (int)now_AV, (int)now_TV, (int)now_EV, now_FDnum, now_OTstatus, now_LV, now_ISO);
            ALOGV("Smart Scene : %d,  SceneSub : %d,  Flash charge : %d Flash standby : %d", (int)now_SceneMode, (int)now_SceneSubMode, (int)strobe_charge, (int)strobe_up_down);

            mLock.lock();
            mParameters.setAutoParameter((int)now_AV, (int)now_TV, (int)now_EV, now_SceneMode, now_SceneSubMode, now_FDnum, now_OTstatus, now_LV, now_ISO/*, now_WC*/);
            mLock.unlock();
#endif
#else	//#ifndef SMART_READ_INFO
            nativeGetParameters(CAM_CID_SMART_READ1, &smart_read1);
            nativeGetParameters(CAM_CID_SMART_READ2, &smart_read2);

            /* for NSM Mode */
            if (mbGetFDinfo && (mPASMMode == MODE_SMART_SUGGEST)) {
                int fd_info;
                char str[32];
                char buf[10] = {0,};

                buf[0] = (smart_read2 >> 2) & 0x1F;	// scene main : 2~6
                buf[1] = smart_read2 & 0x03;	// scene sub : 0~1
                sprintf(str, "0x%02X%02X", buf[0], buf[1]);

                mParameters.set(SecCameraParameters::KEY_NSM_SCENE_DETECT, str);

                nativeGetParameters(CAM_CID_NSM_FD_INFO, &fd_info);
                mParameters.set(SecCameraParameters::KEY_NSM_FD_INFO, fd_info);

                ALOGD("@@@ smartThread : NSM [SCENE DETECT = %s] [FD_INFO = 0x%08x]", str, fd_info);

                nsm_fd_update = 1;
                mLock.lock();
                mbGetFDinfo = false;
                mLock.unlock();
            }
            /* end NSM Mode */

#ifndef AUTO_PARAM_CALLBACK  /* callback AutoParameter */
            now_EV = (smart_read1 & 0xF) - 6;
            now_FDnum = (smart_read1 >> 4) & 0x1;
            now_OTstatus = (smart_read1 >> 5) & 0x3;
            strobe_charge = (smart_read1 >> 7) & 0x1;
            strobe_up_down = (smart_read1 >> 8) & 0x1;
            now_LV = (smart_read1 >> 9) & 0xF;
            // now_ISO = calculate_ISO((smart_read1 >> 13) & 0x7);
            now_AV = ((smart_read1 >> 16) & 0xF) + (((smart_read1 >> 20) & 0xF) * 10);
            now_TV = ((smart_read1 >> 24) & 0x2F) + 1;
            now_EXP = (smart_read1 >> 30) & 0x1;

            now_SceneSubMode = smart_read2 & 0x3;
            now_SceneMode = (smart_read2 >> 2) & 0x1F;
            now_SceneSubMode = (now_SceneSubMode == 0 ? 0 : (now_SceneSubMode + 0x12));

            mLock.lock();
            mParameters.set(CameraParameters::KEY_FLASH_CHARGING, strobe_charge);
            mParameters.set(CameraParameters::KEY_FLASH_STANDBY,
                    strobe_up_down ? CameraParameters::FLASH_STANDBY_ON
                    : CameraParameters::FLASH_STANDBY_OFF);
            mLock.unlock();

            ALOGV("Smart strobe charge: %d, up_down: %d", strobe_charge, strobe_up_down);
            ALOGV("Smart AV : %d,  TV : %d,  EV : %d, EXP : %d ", (int)now_AV, (int)now_TV, (int)now_EV, now_EXP);
            ALOGV("Smart FDnum : %d, OT : %d, LV : %d, ISO : %d", now_FDnum, now_OTstatus, now_LV, now_ISO);
            ALOGV("Smart Scene : %d,  Sub : %d", (int)now_SceneMode, (int)now_SceneSubMode);

            mLock.lock();
            mParameters.setAutoParameter((int)now_AV, (int)now_TV, (int)now_EV, now_SceneMode, now_SceneSubMode, now_FDnum, now_OTstatus, now_LV, now_ISO/*, now_WC*/);
            mLock.unlock();
#else	//#ifndef AUTO_PARAM_CALLBACK  /* callback AutoParameter */
            autoparam_update = 1;
#if 0
            /* F number and Max aperture value is using AV value */
            if (((smart_read1 >> 16) & 0xFF) < 0x31 )  // ISP issue - occurred with the F-num greater than 1 byte at Zoom 8~10.
                mExifFnum = (((smart_read1 >> 16) & 0xF) + (((smart_read1 >> 20) & 0xF) * 10)+ 160) * 10 ;
            else
                mExifFnum = (((smart_read1 >> 16) & 0xF) + (((smart_read1 >> 20) & 0xF) * 10)) * 10;
            //ALOGV("integ = %d, minor = %d, mExifFnum = %d", (smart_read1 >> 16) & 0xF, ((smart_read1 >> 20) & 0xF), mExifFnum);
#else
            mExifFnum = ((smart_read1 >> 8) & 0xFF) * 10;
            //ALOGD("mExifFnum = %d", mExifFnum);
#endif
            mExifShutterSpeed = (smart_read1 >> 24) & 0x3F;
            //ALOGV("Real-time shutter speed = %d", mExifShutterSpeed);
#endif	//#ifndef AUTO_PARAM_CALLBACK  /* callback AutoParameter */
#endif  /* SMART_READ_INFO */

            if (!mLensChecked) {
                nativeGetParameters(CAM_CID_LENS_STATUS, &get_lens_status);

                if (get_lens_status == 3 || get_lens_status == 2) {
                    lens_checked = 1;
                    zoom_change = 1;
                    mLensChecked = 1;
                    ALOGD("Smart LensStatus : Lens %s error", (get_lens_status == 3 ? "open" : "close"));
                }
                //ALOGV("Smart LensStatus : %d", get_lens_status);
            }

            /* burst shot free buffer info */
            smart_read2 = (smart_read2 & ~0x80000000) | ((mBurstShot.isStartLimit() << 31) & 0x80000000);
        }

#ifdef AUTO_PARAM_CALLBACK  /* callback AutoParameter */
        if (!mPictureStart && autoparam_update && (mMsgEnabled & CAMERA_MSG_AUTO_PARAMETERS_NOTIFY)) {
            autoparam_update = 0;

            /* for NSM Mode */
            if (nsm_fd_update) {
                smart_read2 |= 0x40000;  // FD status : 18
                nsm_fd_update = 0;
                ALOGD("@@@ smartThread : NSM [FD STATUS UPDATE smart_read2 = 0x%08x]", smart_read2);
            }
            /* end NSM Mode */

            ALOGD("SmartThread: callback  auto param : %08x, %08x", smart_read1, smart_read2);
            mNotifyCb(CAMERA_MSG_AUTO_PARAMETERS_NOTIFY, smart_read1, smart_read2, mCallbackCookie);
        }
#endif

#if 0
        if (zoom_change && (mMsgEnabled & CAMERA_MSG_ZOOM_STEP_NOTIFY)) {
            zoom_change = 0;
            mLensStatus = mZoomStatus | (lens_checked << 3);
            lens_checked = 0;
            ALOGD("smartThread: callback  zoom level: %d  lens status: %x", mZoomCurrLevel, mLensStatus);
            mNotifyCb(CAMERA_MSG_ZOOM_STEP_NOTIFY, mLensStatus, mZoomCurrLevel, mCallbackCookie);
        }	
#endif

        if ( (mZoomStatusBak&0x06) != (mZoomStatus&0x6) ) {
            ALOGD("Smart LensStatus------- : %02x  ->  %02x (%d)   Level:%d", mZoomStatusBak, mZoomStatus, mZoomStatus&0x4, mZoomCurrLevel);
            mZoomStatusBak = mZoomStatus;
            if ( mZoomStatus&0x6 )
                zoom_change = 1;
        }

#ifdef ZOOM_CTRL_THREAD
#else
        if (!mPictureStart && zoom_change && (mMsgEnabled & CAMERA_MSG_ZOOM_STEP_NOTIFY)) {
            zoom_change = 0;
            mLensStatus = mZoomStatus | (lens_checked << 3);
            lens_checked = 0;
            ALOGD("SmartThread: callback  zoom level : %d, status : %02x, checked : %x02x", mZoomCurrLevel, mLensStatus, lens_checked);
            mNotifyCb(CAMERA_MSG_ZOOM_STEP_NOTIFY, mLensStatus, mZoomCurrLevel, mCallbackCookie);
        }
#endif

#if 0
        if(mSelfShotFDReading) {
            nativeGetParameters(CAM_CID_SMART_SELF_SHOT_FD_INFO1, &smart_self_shot_fd_info1);
            nativeGetParameters(CAM_CID_SMART_SELF_SHOT_FD_INFO2, &smart_self_shot_fd_info2);
            //ALOGD("mSelfShotFDReading : %d, smart_self_shot_fd_info1:%x, smart_self_shot_fd_info2 : %x", mSelfShotFDReading, smart_self_shot_fd_info1, smart_self_shot_fd_info2);
            if(mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA) {
                camera_memory_t *fdCallbackHeap = NULL;
                fdCallbackHeap = mGetMemoryCb(-1, sizeof(camera_frame_metadata_t) * NUM_OF_DETECTED_FACES, 1, 0);

                if(smart_self_shot_fd_info1 != 0 || smart_self_shot_fd_info2 != 0) {
	                mFrameMetadata.number_of_faces = 1;
	                mFaces[0].rect[0] = (smart_self_shot_fd_info1 >> 16) & 0xFFFF;								// left
	                mFaces[0].rect[1] = (smart_self_shot_fd_info1 >> 0) & 0xFFFF;								// top
	                mFaces[0].rect[2] = mFaces[0].rect[0] + ((smart_self_shot_fd_info2 >> 16) & 0xFFFF);	// right
	                mFaces[0].rect[3] = mFaces[0].rect[1] + ((smart_self_shot_fd_info2 >> 0) & 0xFFFF);	// bottom
	                //ALOGD("rect[0]:%d, rect[1]:%d, rect[2]:%d, rect[3]:%d", mFaces[0].rect[0], mFaces[0].rect[1], mFaces[0].rect[2], mFaces[0].rect[3]);
                } else {
	                mFrameMetadata.number_of_faces = 0;
	                memset(mFaces, 0, sizeof(camera_face_t) * NUM_OF_DETECTED_FACES);
                }
                mFrameMetadata.faces = mFaces;
                mDataCb(CAMERA_MSG_PREVIEW_METADATA, fdCallbackHeap, 0, &mFrameMetadata, mCallbackCookie);
                fdCallbackHeap->release(fdCallbackHeap);
            }
        }
#else
        if(mSelfShotFDReading) {
            nativeGetParameters(CAM_CID_SMART_SELF_SHOT_FD_INFO1, &smart_self_shot_fd_info1);
            nativeGetParameters(CAM_CID_SMART_SELF_SHOT_FD_INFO2, &smart_self_shot_fd_info2);
            //ALOGD("mSelfShotFDReading : %d, smart_self_shot_fd_info1:%x, smart_self_shot_fd_info2 : %x", mSelfShotFDReading, smart_self_shot_fd_info1, smart_self_shot_fd_info2);
            if(mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA) {
                camera_memory_t *fdCallbackHeap = NULL;
                fdCallbackHeap = mGetMemoryCb(-1, sizeof(camera_frame_metadata_t) * NUM_OF_DETECTED_FACES, 1, 0);

                if(smart_self_shot_fd_info1 != 0 || smart_self_shot_fd_info2 != 0) {
	                mFrameMetadata.number_of_faces = 1;
	                fd_info_left = (smart_self_shot_fd_info1 >> 16) & 0xFFFF;								// left
	                fd_info_top = (smart_self_shot_fd_info1 >> 0) & 0xFFFF;								// top
	                fd_info_right = fd_info_left + ((smart_self_shot_fd_info2 >> 16) & 0xFFFF);	// right
	                fd_info_bottom = fd_info_top + ((smart_self_shot_fd_info2 >> 0) & 0xFFFF);	// bottom
	                mFaces[0].rect[0] = ((int)((2000 * fd_info_left) / 1280)) - 1000;
	                mFaces[0].rect[1] = ((int)((2000 * fd_info_top) / 720)) - 1000;
	                mFaces[0].rect[2] = ((int)((2000 * fd_info_right) / 1280)) - 1000;
	                mFaces[0].rect[3] = ((int)((2000 * fd_info_bottom) / 720)) - 1000;
                } else {
	                mFrameMetadata.number_of_faces = 0;
	                memset(mFaces, 0, sizeof(camera_face_t) * NUM_OF_DETECTED_FACES);
                }
                //ALOGD("rect[0]:%d, rect[1]:%d, rect[2]:%d, rect[3]:%d", mFaces[0].rect[0], mFaces[0].rect[1], mFaces[0].rect[2], mFaces[0].rect[3]);
                mFrameMetadata.faces = mFaces;
                mDataCb(CAMERA_MSG_PREVIEW_METADATA, fdCallbackHeap, 0, &mFrameMetadata, mCallbackCookie);
                fdCallbackHeap->release(fdCallbackHeap);
            }
        }

#endif
    }

    if (!mPictureRunning && !mPictureStart && time_setting) {
		int set_real_time;
        time_t rawtime;
        struct tm *timeinfo;
        time(&rawtime);
        timeinfo = localtime(&rawtime);
        set_real_time = ((timeinfo->tm_hour) << 8) | (timeinfo->tm_min);
        ALOGD("setting real time : %x", set_real_time);
        nativeSetParameters(CAM_CID_TIME_INFO, set_real_time);
        time_setting = 0;
        mLock.lock();
        if (mFirstStart == 1)
            mFirstStart = 2;
        mLock.unlock();
    }
#if 0
    if (mFirmwareResult) {
        ALOGD("Smart Firmware Update : %s", (mFirmwareResult == 1 ? "Success" : "Fail"));
        mNotifyCb(FIRMWARE_MSG_NOTIFY, mFirmwareResult, 0, mCallbackCookie);
        mFirmwareResult = 0;
    }
#endif
    usleep(50000);
//    ALOGV("smartThread X");

    return true;
}
#endif  //#ifdef SMART_THREAD

status_t ISecCameraHardware::autoFocus()
{
    ALOGV("autoFocus EX");
    /* signal autoFocusThread to run once */

    /* for NSM Mode*/
    if (mPASMMode == MODE_SMART_SUGGEST) {
        nativeSetParameters(CAM_CID_NSM_FD_WRITE, 0xFFFFFF);
        mParameters.set(SecCameraParameters::KEY_NSM_FD_INFO, 0xFFFFFF);
        ALOGD("@@@ autoFocus : NSM [FD INFO reset: 0x%08x]",
            mParameters.getInt(SecCameraParameters::KEY_NSM_FD_INFO));
    }
    /* end NSM Mode */

    mAutoFocusCondition.signal();
    return NO_ERROR;
}

bool ISecCameraHardware::autoFocusThread()
{
    /* block until we're told to start.  we don't want to use
     * a restartable thread and requestExitAndWait() in cancelAutoFocus()
     * because it would cause deadlock between our callbacks and the
     * caller of cancelAutoFocus() which both want to grab the same lock
     * in CameraServices layer.
     */
    mAutoFocusLock.lock();
    mAutoFocusCondition.wait(mAutoFocusLock);
    mAutoFocusLock.unlock();

    /* check early exit request */
    if (mAutoFocusExit)
        return false;

    ALOGV("autoFocusThread E");
    LOG_PERFORMANCE_START(1);

    mAutoFocusRunning = true;

    if (!IsAutoFocusSupported()) {
        ALOGV("autofocus not supported");
        mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
        goto out;
    }

    if (!autoFocusCheckAndWaitPreview()) {
        ALOGI("autoFocusThread: preview not started");
        mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
        goto out;
    }

    /* Start AF operations */
    if (!nativeSetAutoFocus()) {
        ALOGE("autoFocusThread X: error, nativeSetAutofocus");
        goto out;
    }

    if (!mAutoFocusRunning) {
        ALOGV("autoFocusThread X: AF is canceled");
        nativeSetParameters(CAM_CID_FOCUS_MODE, mFocusMode | V4L2_FOCUS_MODE_DEFAULT);
        mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
        goto out;
    }

    if (mMsgEnabled & CAMERA_MSG_FOCUS) {

		 int read_status = nativeGetPreAutoFocus();
		 ALOGD("read_status : %x", read_status);
		 int get_val = read_status & 0x1FF;

		 if (mSamsungApp) {
            if (get_val) {
                ALOGD("autoFocusThread X: PRE AF success %d", get_val);
                mNotifyCb(CAMERA_MSG_FOCUS, PRE_AF_SUCCESS, get_val, mCallbackCookie);
            } else {
                ALOGW("autoFocusThread X: PRE AF fail");
                mNotifyCb(CAMERA_MSG_FOCUS, PRE_AF_FAIL, 0, mCallbackCookie);
            }
		 }

		 if (read_status != AF_STATUS_FOCUSING) {
            read_status = nativeGetAutoFocus();
            if (read_status == 0) {
                ALOGE("autoFocusThread X: nativeGetAutofocus: error %d", read_status);
            }
        } else {
            ALOGE("AF Timeout!! AF is still in progress(%d)", read_status);
        }

		 if (get_val) {
            ALOGD("autoFocusThread X: AF success %d", get_val);
            if (mSamsungApp) {
                mNotifyCb(CAMERA_MSG_FOCUS, true, get_val, mCallbackCookie);
            } else {
                mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
            }

            /* for NSM Mode */
            mLock.lock();
            mbGetFDinfo = true;
            mLock.unlock();
            ALOGE("@@@ autoFocusThread  success : mbGetFDinfo = %d", mbGetFDinfo);
            /* end NSM Mode */

        } else {
            ALOGW("autoFocusThread X: AF fail");
            mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
        }
#if 0
		 if (!mRecordingRunning) {
            /* get Manual Focus index value */
            read_status = nativeGetManualFocus();
            int default_index = (read_status & 0xFF0000) >> 16;
            int near_index = (read_status & 0x00FFFF);

            ALOGD("autoFocusThread X: MF - read_status 0x%x default 0x%x, near limit 0x%x", read_status, default_index, near_index);
            //mNotifyCb(CAMERA_MSG_MANUAL_FOCUS_NOTIFY, default_index, near_index, mCallbackCookie);
        }
#endif
    }

out:
    mAutoFocusRunning = false;

    LOG_PERFORMANCE_END(1, "total");
    return true;
}

status_t ISecCameraHardware::cancelAutoFocus()
{
    ALOGV("cancelAutoFocus: autoFocusThread is %s",
        mAutoFocusRunning ? "running" : "not running");

    if (!IsAutoFocusSupported())
        return NO_ERROR;
    status_t err = NO_ERROR;
#if 0
    if (mAutoFocusRunning) {
        ALOGE("%s [%d]", __func__, mAutoFocusRunning);
        int i, waitUs = 3000, tryCount = (500 * 1000) / waitUs;

        err = nativeCancelAutoFocus();

        for (i = 1; i <= tryCount; i++) {
            if (mAutoFocusRunning)
                usleep(waitUs);
            else
                break;

            if (!(i % 40))
                ALOGD("AF, waiting to be cancelled\n");
        }

        if (CC_UNLIKELY(i > tryCount))
            ALOGI("cancelAutoFocus: cancel timeout");
    } else {
        ALOGV("%s [%d]", __func__, mAutoFocusRunning);
        err = nativeSetParameters(CAM_CID_FOCUS_MODE, mFocusMode | V4L2_FOCUS_MODE_DEFAULT);
    }
#else
    err = nativeCancelAutoFocus();
	if(!mAutoFocusRunning){
		 ALOGV("%s [%d]", __func__, mAutoFocusRunning);
        err = nativeSetParameters(CAM_CID_FOCUS_MODE, mFocusMode | V4L2_FOCUS_MODE_DEFAULT);
	}
	mAutoFocusRunning = false;
#endif

    if (CC_UNLIKELY(err != NO_ERROR)) {
        ALOGE("cancelAutoFocus: error, nativeCancelAutofocus");
        return UNKNOWN_ERROR;
    }

    mAutoFocusRunning = false;
    return NO_ERROR;
}

#if FRONT_ZSL
bool ISecCameraHardware::zslpictureThread()
{
    mZSLindex = nativeGetFullPreview();

    if (CC_UNLIKELY(mZSLindex < 0)) {
        ALOGE("zslpictureThread: error, nativeGetFullPreview");
        return true;
    }

    nativeReleaseFullPreviewFrame(mZSLindex);

    return true;
}
#endif

/* --1 */
status_t ISecCameraHardware::takePicture()
{
    ALOGD("takePicture E");

    int facedetVal = 0;
#if VENDOR_FEATURE
#if 1 /* WORKAROUND */
	mFLiteCaptureSize = mPictureSize;
    if (mPictureSize.width < 640 || mPictureSize.width < 480) {
        mFLiteCaptureSize.width = 640;
        mFLiteCaptureSize.height = 480;
    }

    mRawSize = mPictureSize;

    facedetVal = getFaceDetection();
    ALOGD("takePicture facedetVal:%d", facedetVal);
#endif
#endif

    if (mPreviewRunning == false) {
        ALOGW("WARN(%s): preview is not initialized", __func__);
        int retry = 10;
        while (retry > 0 || mPreviewRunning == false) {
            usleep(5000);
            retry--;
        }
    }

	mPictureStart = true;

	if (mCaptureMode != RUNNING_MODE_SINGLE || facedetVal == V4L2_FACE_DETECTION_BLINK) {
		if (mPreviewRunning) {
			ALOGW("takePicture: warning, preview is running");
			stopPreview();
		}
		nativeSetFastCapture(false);
	}
	mPictureStart = false;

    if (mDualCapture) {
        mPictureSize.width = REC_CAPTURE_WIDTH;
        mPictureSize.height = REC_CAPTURE_HEIGHT;
    }

    Mutex::Autolock lock(mLock);
    if (mPictureRunning) {
        ALOGE("takePicture: error, picture already running");
        return INVALID_OPERATION;
    }

#ifdef BURST_SHOT_SUPPORT
	if (mCaptureMode == RUNNING_MODE_BURST) {
		ALOGD("mTakeBurst is true: BurstPictureThread run.");
		if (mBurstPictureThread->run("burstPictureThread", PRIORITY_URGENT_DISPLAY) != NO_ERROR) {
			ALOGE("BurstPictureThread: error, Not starting take BurstPicture");
			return UNKNOWN_ERROR;
		}
	} else if (mCaptureMode == RUNNING_MODE_HDR || mCaptureMode == RUNNING_MODE_LOWLIGHT) {
		ALOGD("mTakeHDR is true: HDRPictureThread run.");
		if (mHDRPictureThread->run("HDRPictureThread", PRIORITY_URGENT_DISPLAY) != NO_ERROR) {
			ALOGE("HDRPictureThread: error, Not starting take HDR Picture");
			return UNKNOWN_ERROR;
		}
	} else if (mCaptureMode == RUNNING_MODE_AE_BRACKET) {
		ALOGD("mTakeAEB is true: AEBPictureThread run.");
		if (mAEBPictureThread->run("AEBPictureThread", PRIORITY_URGENT_DISPLAY) != NO_ERROR) {
			ALOGE("AEBPictureThread: error, Not starting take AEB Picture");
			return UNKNOWN_ERROR;
		}
	//} else if (mCaptureMode == RUNNING_MODE_BLINK) {
	} else if (facedetVal == V4L2_FACE_DETECTION_BLINK) {
		ALOGD("mTakeBlink is true: BlinkPictureThread run.");
		if (mBlinkPictureThread->run("BlinkPictureThread", PRIORITY_URGENT_DISPLAY) != NO_ERROR) {
			ALOGE("BlinkPictureThread: error, Not starting take Blink Picture");
			return UNKNOWN_ERROR;
		}
	} else if (mDualCapture) {
		ALOGD("mDualCapture is true: RecordingPictureThread run.");
		if (mRecordingPictureThread->run("RecordingPictureThread", PRIORITY_URGENT_DISPLAY) != NO_ERROR) {
			ALOGE("RecordingPictureThread: error, Not starting take Recording Picture");
			return UNKNOWN_ERROR;
		}
	} else {
		if (mPictureThread->run("pictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
			ALOGE("takePicture: error, Not starting take picture");
			return UNKNOWN_ERROR;
		}
	}
#else
	if (mPictureThread->run("pictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
		ALOGE("takePicture: error, Not starting take picture");
		return UNKNOWN_ERROR;
	}
#endif

    ALOGD("takePicture X");
    return NO_ERROR;
}

void ISecCameraHardware::Fimc_stream_true_part2(void)
{
	nativeSetParameters(CAM_CID_STREAM_PART2, 0);
}

/* --2 */
bool ISecCameraHardware::pictureThread()
#if VENDOR_FEATURE
{
	int err;
	ALOGD("pictureThread E");

	err = NO_ERROR;

	if ((mCaptureMode == RUNNING_MODE_SINGLE) && (mFactoryTestNum == 0)) {
		nativeSetFastCapture(true);

		/* Start fast capture */
		mCaptureStarted = true;
		err = nativeSetParameters(CAM_CID_SET_FAST_CAPTURE, 0);
		mCaptureStarted = false;

		if (mCancelCapture && mSamsungApp) {
			ALOGD("pictureThread mCancelCapture %d", mCancelCapture);
			mCancelCapture = false;
			return false;
		}

		if (err != NO_ERROR)
			ALOGE("%s: Fast capture command is failed.", __func__);
		else
			ALOGD("%s: Mode change command is issued for fast capture.", __func__);
	}

	if (mCaptureMode == RUNNING_MODE_SINGLE) {
		if (mPreviewRunning && !mFullPreviewRunning) {
			ALOGW("takePicture: warning, preview is running");
			stopPreview();
		}
		nativeSetFastCapture(false);
	}
	mPictureRunning = true;

	if (mFactoryTestNum != 0) {
		if ((mFactoryTestNum == 131) ||      // WIDE Resolution
				(mFactoryTestNum == 132) ||  // TELE Resolution
				(mFactoryTestNum == 133) ||  // Tilt
				(mFactoryTestNum == 136) ||  // dust
				(mFactoryTestNum == 137) ||  // lens shading
				(mFactoryTestNum == 138) ||  // noise
				(mFactoryTestNum == 165)) {  // RED image test
			ALOGD("Don't set fast_capture mFactoryTestNum = %d", mFactoryTestNum);
			nativeSetParameters(CAM_CID_MAIN_FORMAT, 0);
		} else {
			mCaptureStarted = true;
			err = nativeSetParameters(CAM_CID_SET_FAST_CAPTURE , 0);
			mCaptureStarted = false;
			if (err != NO_ERROR)
				ALOGE("%s: Fast capture command is failed.", __func__);
			else
				ALOGD("%s: Mode change command is issued for fast capture", __func__);
		}
	}

	if ( mCaptureMode == RUNNING_MODE_RAW ) {
         return pictureThread_RAW();
	}

	mPictureLock.lock();

    LOG_PERFORMANCE_START(1);
	ALOGD("pictureThread: single picture thread. call nativeStartPostview");
	if (!nativeStartPostview()) {
		ALOGE("pictureThread: error, nativeStartPostview");
		mPictureLock.unlock();
		goto out;
	} else {
		ALOGD("pictureThread: nativeStartPostview");
	}

	if (!nativeGetPostview(1)) {
		ALOGE("pictureThread: error, nativeGetPostview");
		mPictureLock.unlock();
		mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
		goto out;
	} else {
		ALOGD("pictureThread: nativeGetPostview");
	}

    if ((mFactoryTestNum == 131) ||  // WIDE Resolution
        (mFactoryTestNum == 132) ||  // TELE Resolution
        (mFactoryTestNum == 133) ||  // Tilt
        (mFactoryTestNum == 136) ||  // dust
        (mFactoryTestNum == 137) ||  // lens shading
        (mFactoryTestNum == 138) ||  // noise
        (mFactoryTestNum == 165)) // RED image test
    {
        if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) {
            ALOGD("Postview mPostviewFrameSize = %d", mPostviewFrameSize);
            mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPostviewHeap, 0, NULL, mCallbackCookie);
        }
        return Factory_pictureThread_Resolution();
    }
    nativeStopSnapshot();

	/*
	   JPEG capture
	*/
    LOG_PERFORMANCE_START(2);
    if (!nativeStartSnapshot()) {
        ALOGE("pictureThread: error, nativeStartSnapshot");
        mPictureLock.unlock();
        goto out;
    }
    LOG_PERFORMANCE_END(2, "nativeStartSnapshot");

#if 0
    if ((mMsgEnabled & CAMERA_MSG_SHUTTER) && (mSceneMode != SCENE_MODE_NIGHTSHOT)) {
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
        mPictureLock.lock();
    }
#endif

    LOG_PERFORMANCE_START(3);
	/* --4 */
    int postviewOffset;

	if (!nativeGetSnapshot(1, &postviewOffset)) {
		ALOGE("pictureThread: error, nativeGetSnapshot");
		mPictureLock.unlock();
		mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
		goto out;
	}
	LOG_PERFORMANCE_END(3, "nativeGetSnapshot");

	mPictureLock.unlock();

	/* Display postview */
	LOG_PERFORMANCE_START(4);

	/* callbacks for capture */
	if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) {
		ALOGD("Postview mPostviewFrameSize = %d", mPostviewFrameSize);
		mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPostviewHeap, 0, NULL, mCallbackCookie);
	}
	if ((mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) && (mJpegHeap != NULL)) {
		ALOGD("JPEG COMPLRESSED");
		mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
	}
	if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
		ALOGD("RAW mRawFrameSize = %d", mRawFrameSize);
		mDataCb(CAMERA_MSG_RAW_IMAGE, mPostviewHeap, 0, NULL, mCallbackCookie);
	}
	if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY) {
		ALOGD("RAW image notify");
		mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
	}

    LOG_PERFORMANCE_END(4, "callback functions");

#if DUMP_FILE
    dumpToFile(mJpegHeap->base(), mPictureFrameSize, "/data/capture01.jpg");
#endif

out:
    nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();
    LOG_PERFORMANCE_END(1, "total");

    ALOGD("pictureThread X");
    return false;
}
#else
{
    if (mMovieMode) {
        doRecordingCapture();
    } else {
        if (mPreviewRunning && !mFullPreviewRunning) {
            ALOGW("takePicture: warning, preview is running");
            stopPreview();
        }

        doCameraCapture();
    }

    return false;
}
#endif

status_t ISecCameraHardware::doCameraCapture()
{
    ALOGD("doCameraCapture E");

    mPictureLock.lock();

    LOG_PERFORMANCE_START(1);

    LOG_PERFORMANCE_START(2);
    if (!nativeStartSnapshot()) {
        ALOGE("doCameraCapture: error, nativeStartSnapshot");
        mPictureLock.unlock();
        goto out;
    }
    LOG_PERFORMANCE_END(2, "nativeStartSnapshot");

    if ((mMsgEnabled & CAMERA_MSG_SHUTTER) && (mSceneMode != SCENE_MODE_NIGHTSHOT)) {
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
        mPictureLock.lock();
    }

    LOG_PERFORMANCE_START(3);
    int postviewOffset;
    if (!nativeGetSnapshot(1, &postviewOffset)) {
        ALOGE("doCameraCapture: error, nativeGetSnapshot");
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
        goto out;
    }
    LOG_PERFORMANCE_END(3, "nativeGetSnapshot");

    mPictureLock.unlock();

    if ((mMsgEnabled & CAMERA_MSG_SHUTTER) && (mSceneMode == SCENE_MODE_NIGHTSHOT))
        mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);

    /* Display postview */
    LOG_PERFORMANCE_START(4);

    /* callbacks for capture */
    if ((mMsgEnabled & CAMERA_MSG_RAW_IMAGE) && (mRawHeap != NULL))
        mDataCb(CAMERA_MSG_RAW_IMAGE, mRawHeap, 0, NULL, mCallbackCookie);

    if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY)
        mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);

    if ((mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) && (mRawHeap != NULL))
        mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mRawHeap, 0, NULL, mCallbackCookie);

    if ((mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) && (mJpegHeap != NULL))
        mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);

    LOG_PERFORMANCE_END(4, "callback functions");

#if DUMP_FILE
    dumpToFile(mJpegHeap->base(), mPictureFrameSize, "/data/capture01.jpg");
#endif

out:
    nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();

    LOG_PERFORMANCE_END(1, "total");

    ALOGD("doCameraCapture X");
    return NO_ERROR;
}

status_t ISecCameraHardware::doRecordingCapture()
{
    ALOGD("doRecordingCapture: E");

    if (!mRecordingRunning) {
        ALOGI("doRecordingCapture: nothing to do");
        return NO_ERROR;
    }

    mPictureLock.lock();

    bool ret = false;
    int index = mPostRecordIndex;
    if (index < 0) {
        ALOGW("WARN(%s):(%d)mPostRecordIndex(%d) invalid", __func__, __LINE__, mPostRecordIndex);
        index = 0;
    }

    ExynosBuffer rawFrame422Buf;

#if 0
    rawFrame422Buf.size.extS[0] = mFliteNode.buffer[index].size.extS[0];

    if (allocMem(mIonCameraClient, &rawFrame422Buf, 1 << 1) == false) {
        ALOGE("ERR(%s):(%d)allocMem(rawFrame422Buf) fail", __func__, __LINE__);
        mPictureLock.unlock();
        goto out;
    }

    ALOGD("DEBUG(%s): mFLiteSize(%d x %d), mFliteNode.buffer[index].size.extS[0](%d)", __FUNCTION__, mFLiteSize.width, mFLiteSize.height, mFliteNode.buffer[index].size.extS[0]);

    memcpy(rawFrame422Buf.virt.extP[0], mFliteNode.buffer[index].virt.extP[0], mFliteNode.buffer[index].size.extS[0]);

    ret = nativeGetRecordingJpeg(&rawFrame422Buf, mFLiteSize.width, mFLiteSize.height);
    if (CC_UNLIKELY(!ret)) {
        ALOGE("doRecordingCapture: error, nativeGetRecordingJpeg");
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
        goto out;
    }
#else
    int dstW = mPreviewSize.width;
    int dstH = mPreviewSize.height;

    rawFrame422Buf.size.extS[0] = dstW * dstH * 2;

    if (allocMem(mIonCameraClient, &rawFrame422Buf, 1 << 1) == false) {
        ALOGE("ERR(%s):(%d)allocMem(rawFrame422Buf) fail", __FUNCTION__, __LINE__);
        mPictureLock.unlock();
        goto out;
    }

    /* csc start flite(s) -> rawFrame422Buf */
    if (nativeCSCRecordingCapture(&(mFliteNode.buffer[index]), &rawFrame422Buf) != NO_ERROR)
        ALOGE("ERR(%s):(%d)nativeCSCRecordingCapture() fail", __FUNCTION__, __LINE__);

    ret = nativeGetRecordingJpeg(&rawFrame422Buf, dstW, dstH);
    if (CC_UNLIKELY(!ret)) {
        ALOGE("doRecordingCapture: error, nativeGetRecordingJpeg");
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
        goto out;
    }
#endif

    mPictureLock.unlock();

#if DUMP_FILE
    dumpToFile(mJpegHeap->base(), mPictureFrameSize, "/data/capture01.jpg");
#endif

    if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)
        mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);

out:
    freeMem(&rawFrame422Buf);

    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();

    ALOGD("doRecordingCapture: X");
    return NO_ERROR;
}

bool ISecCameraHardware::BlinkPictureThread()
{
    int i, ncnt;
    int count = 1;
    int shutter_count = 3;
    int postviewOffset;
    int err;

    ALOGD("BlinkPictureThread E");

    mPictureLock.lock();

    LOG_PERFORMANCE_START(1);

    nativeSetParameters(CAM_CID_CONTINUESHOT_PROC, V4L2_INT_STATE_START_CAPTURE);

#if 0
    for (i = shutter_count ; i ; i--) {
        ncnt = shutter_count- i + 1;
        ALOGD("BlinkPictureThread: Shutter_sound %d", ncnt);
        nativeSetParameters(CAM_CID_CONTINUESHOT_PROC, V4L2_INT_STATE_FRAME_SYNC);
        if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
            mPictureLock.lock();
        }
    }
#endif

    for (i = count ; i ; i--) {
        ncnt = count-i+1;
        ALOGD("BlinkPictureThread: StartPostview %d frame E", ncnt);
        if (!nativeStartPostview()) {
            ALOGE("BlinkPictureThread: error, nativeStartPostview");
            mPictureLock.unlock();
            goto out;
        } else {
            ALOGD("BlinkPictureThread: StartPostview %d frame X", ncnt);
        }

        if (!nativeGetPostview(ncnt)) {
            ALOGE("BlinkPictureThread: error, nativeGetPostview");
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
            goto out;
        } else {
            ALOGE("BlinkPictureThread: nativeGetPostview");
        }

        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
            ALOGD("RAW mRawFrameSize = %d", mRawFrameSize);
            mDataCb(CAMERA_MSG_RAW_IMAGE, mPostviewHeap, 0, NULL, mCallbackCookie);
        }
        if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) {
            ALOGD("JPEG mRawFrameSize = %d", mPostviewFrameSize);
            mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPostviewHeap, 0, NULL, mCallbackCookie);
        }
		nativeStopSnapshot();

        LOG_PERFORMANCE_START(2);
        ALOGD("BlinkPictureThread: StartSnapshot %d frame E", ncnt);
        if (!nativeStartSnapshot()) {
            ALOGE("BlinkPictureThread: error, nativeStartSnapshot");
            mPictureLock.unlock();
            goto out;
        } else {
            ALOGD("BlinkPictureThread: StartSnapshot %d frame X", ncnt);
        }
        LOG_PERFORMANCE_END(2, "nativeStartSnapshot");

        LOG_PERFORMANCE_START(3);
        if (!nativeGetSnapshot(ncnt, &postviewOffset)) {
            ALOGE("BlinkPictureThread: error, nativeGetSnapshot");
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
            goto out;
        } else {
            ALOGD("BlinkPictureThread: nativeGetSnapshot %d frame ", ncnt);
        }
        LOG_PERFORMANCE_END(3, "nativeGetSnapshot");

        mPictureLock.unlock();

        LOG_PERFORMANCE_START(4);

        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
            mDataCb(CAMERA_MSG_RAW_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
        }
        if ((mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) && (mJpegHeap != NULL)) {
            mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
        }
        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY) {
            mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
        }

        LOG_PERFORMANCE_END(4, "callback functions");
		nativeStopSnapshot();
    }

out:
    //nativeSetParameters(CAM_CID_BURSTSHOT_PROC, V4L2_INT_STATE_BURST_STOP);
	nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();

    LOG_PERFORMANCE_END(1, "total");

    ALOGD("BlinkPictureThread X");
    return false;
}

#ifdef BURST_SHOT_SUPPORT
bool ISecCameraHardware::burstPictureThread_postview(int ncnt)
{
	ALOGD("BURSTSHOT: burstPictureThread_postview E. call nativeStartPostview");
    if (!nativeStartPostview()) {
        ALOGE("BURSTSHOT burstPictureThread_postview: error, nativeStartPostview");
        mPictureLock.unlock();
        return false;
    }

    ALOGD("BURSTSHOT-----004 : nativeGetPostview start");
    if (!nativeGetPostview(ncnt)) {
        ALOGE("BURSTSHOT Burst: error, nativeGetPostview");
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
        return false;
    }

    if (mFlagANWindowRegister) {
        bool ret = nativeFlushSurface(mPreviewWindowSize.width, mPreviewWindowSize.height,
				mPostviewFrameSize, 0, CAMERA_HEAP_POSTVIEW);
        if (CC_UNLIKELY(!ret)) {
            ALOGE("%s::flushSurface() fail", __func__);
            /* We wonder if it's possible to validate our surface, using the below checking code.
            * Fix it if you have a better idea. */
        }
    }

    if ((mBurstShot.getAttrib() & BURST_ATTRIB_NOTUSING_POSTVIEW) == 0) {
        if ((mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) &&
            (mPASMMode!= MODE_BEST_SHOT)){
            mPictureLock.unlock();
            ALOGD("BURSTSHOT  JPEG mRawFrameSize = %d", mRawFrameSize);
            mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPostviewHeap, 0, NULL, mCallbackCookie);
            mPictureLock.lock();
        }
    }

    return true;
}

bool ISecCameraHardware::burstPictureThread()
{
    int postviewOffset;
    int ncnt = 0;
	int max;
    status_t rc = NO_ERROR;
    bool bCaptureModeSet = false;

    ALOGD("BURSTSHOT burstPictureThread E mCaptureMode=%d", mCaptureMode);

    mLock.lock();
    mPictureRunning = true;
    mLock.unlock();

    if ( mBurstShot.isInit() == false ) {
        ALOGD("BURSTSHOT burstPictureThread not init");
        goto burst_out;
    }

    mPictureLock.lock();

    int w, h;
    mParameters.getPictureSize(&w, &h);
    mPictureSize.width = w;
    mPictureSize.height = h;

	max = mBurstShot.getCountMax();

	nativeSetParameters(CAM_CID_CAPTURE_CNT, max);

	ALOGD("BURSTSHOT-----start burstshot proc = %d x %d", w, h);
	nativeSetParameters(CAM_CID_BURSTSHOT_PROC, V4L2_INT_STATE_BURST_START);

	mFlagANWindowRegister = true;

	if (mBurstSoundCount == 0) {
		/* Thread is waiting only in case of sound interrupt is not issued. */
		mBurstShotLock.lock();
		ALOGD("BURSTSHOT----- burstPictureThread waiting for first sound interrupt...");
		mBurstShotCondition.wait(mBurstShotLock);
		mBurstShotLock.unlock();
	} else if ( mBurstSoundCount > 0) {
		/* If sound interrupt is issued before waiting, skip thread waiting. */
		ALOGD("BURSTSHOT----- sound interrupt is issued before waiting. No signal waiting.");
	}

	if (mBurstShotExit)
		return false;

	for (int i = 0; i < max; i++) {
        ncnt = i;
        ALOGD("BURSTSHOT-----001  BurstPictureThread H:%d T:%d", mBurstShot.getIndexHead(),  mBurstShot.getIndexTail());

		if (mBurstStopReq == CAMERA_BURST_STOP_REQ) {
			ALOGD("BURSTSHOT: send stop command. mBurstSoundMaxCount = %d", mBurstSoundMaxCount);
			nativeSetParameters(CAM_CID_BURSTSHOT_PROC, V4L2_INT_STATE_BURST_STOP_REQ);
		}

        if ((i == max - 1) && (mBurstStopReq == CAMERA_BURST_STOP_NONE)) {
            ALOGD("BURSTSHOT-----001-1 stop_req : mBurstStopReq: %d, max: %d, i: %d", mBurstStopReq, max, i);
            mBurstStopReq = CAMERA_BURST_STOP_REQ;
            nativeSetParameters(CAM_CID_BURSTSHOT_PROC, V4L2_INT_STATE_BURST_STOP_REQ);
        }

		ALOGD("BURSTSHOT: BurstPictureThread ncnt = %d, mBurstSoundMaxCount = %d", ncnt, mBurstSoundMaxCount);
		if (ncnt < mBurstSoundMaxCount) {
			if (mPASMMode != MODE_MAGIC) {
				ALOGD("BURSTSHOT-----002 Postview() : mBurstStopReq :%d", mBurstStopReq);
				if ( burstPictureThread_postview(ncnt) == false ) {
					mPictureLock.unlock();
					goto burst_out;
				}
			}

			nativeStopSnapshot();
			ALOGD("BURSTSHOT-----003 : nativeStartSnapshot(): %d", mBurstSoundCount );
			if (!nativeStartSnapshot()) {
				ALOGE("BURSTSHOT Burst pictureThread: error, nativeStartSnapshot");
				mPictureLock.unlock();
				goto burst_out;
			}

			ALOGD("BURSTSHOT-----004 : nativeGetSnapshot()");
			if (!nativeGetSnapshot(ncnt, &postviewOffset)) {
				ALOGE("BURSTSHOT Burst pictureThread: error, nativeGetSnapshot");
				mPictureLock.unlock();
				mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
				goto burst_out;
			}

			ALOGD("BURSTSHOT-----005 : mBurstShot.push() size=%d", mPictureFrameSize);
			if ( mBurstShot.push(ncnt) == false ) {
				ALOGE("BURSTSHOT mBurstShot slot FULL");
				mPictureLock.unlock();
				mBurstShot.DumpState();
				mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
				goto burst_out;
			}

			if (mFlagANWindowRegister && mPASMMode == MODE_MAGIC) {
				bool ret = nativeFlushSurfaceYUV420(mPreviewWindowSize.width, mPreviewWindowSize.height,
						mPostviewFrameSize, 0, CAMERA_HEAP_POSTVIEW);
				if (CC_UNLIKELY(!ret)) {
					ALOGE("%s::flushSurface() fail", __func__);
					/* We wonder if it's possible to validate our surface, using the below checking code.
					 * Fix it if you have a better idea. */
				}
				/* PostView Callback */
				if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME){
					mPictureLock.unlock();
					mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPostviewHeap, 0, NULL, mCallbackCookie);
					mPictureLock.lock();
				}
			}
			nativeStopSnapshot();

			ALOGD("BURSTSHOT-----006 ------------------ %d/%d, STATE=%d", ncnt, mBurstSoundMaxCount, mBurstStopReq );
			ALOGD("BURSTSHOT start burstWriteThread. mBurstWriteRunning = %d", mBurstWriteRunning);
			if ( mBurstWriteRunning == false ) {
				if (mBurstWriteThread->run("burstWriteThread", PRIORITY_URGENT_DISPLAY) != NO_ERROR) {
					mPictureLock.unlock();
					usleep(10*1000);
					mPictureLock.lock();
					if (mBurstWriteThread->run("burstWriteThread", PRIORITY_URGENT_DISPLAY) != NO_ERROR) {
						mPictureLock.unlock();
						ALOGE("burstWriteThread: Not starting burstWriteThread");
						goto burst_out;
					}
				}
			}
		} else {
			mBurstStopReq = CAMERA_BURST_STOP_END;
		}

		if (mBurstStopReq == CAMERA_BURST_STOP_END) {
			ALOGE("BURSTSHOT: Stop burst shot. dump and break burst sequence.");
			mBurstShot.DumpState();
			break;
		}

        int lenzoff_timer = 0;
        while (true) {
            if (mBurstPictureThread->exitRequested()) {
                mPictureLock.unlock();
                mNotifyCb(CAMERA_MSG_ERROR, 0, 0, mCallbackCookie);
                ALOGE("BURSTSHOT Burst exitRequested().");
                goto burst_out;
            }

            bool enable = mBurstShot.isLimit();
            if (enable)
                break;

            ALOGE("BURSTSHOT ION memory Full");
            mBurstShot.DumpState();
            usleep(100*1000);
        }
    }
    mPictureLock.unlock();

burst_out:
    ALOGE("BURSTSHOT==========V4L2_INT_STATE_BURST_STOP proc() : %d, STATE=%d",mBurstSoundMaxCount, mBurstStopReq );
    nativeSetParameters(CAM_CID_BURSTSHOT_PROC, V4L2_INT_STATE_BURST_STOP);

    mLock.lock();
    nativeStopSnapshot();
    mFlagANWindowRegister = false;
    mPictureRunning = false;
#ifdef USE_CONTEXTUAL_FILE_NAME
	mBurstShot.freeContextualFileName();
	mBurstShot.setContextualState(false);
#endif
    mLock.unlock();

    usleep(50*1000);

#if VENDOR_FEATURE
	if (mMsgEnabled & CAMERA_MSG_SHOT_END) {
		ALOGE("BURSTSHOT==========END, Notify(0x40000), mBurstSoundCount = %d", mBurstSoundCount);
		mNotifyCb(CAMERA_MSG_SHOT_END, mBurstSoundCount, mBurstSoundCount, mCallbackCookie);
	}
#endif
    return false;
}

bool ISecCameraHardware::burstWriteThread()
{
    const int PATH_SIZE = 256;
    camera_memory_t *stringHeap = NULL;
	int stringHeapFd = -1;
    camera_memory_t *dataHeap = NULL;
	int dataHeapFd = -1;

	burst_item   *pitem, item;

    if ( mBurstShot.isInit() == false ) {
        ALOGD("BURSTSHOT burstPictureThread not init");
        goto burst_write_out;
    }

    ALOGD("BURSTSHOT: burstWriteThread E---------------");
    mBurstWriteRunning = true;

    if (mCaptureMode != RUNNING_MODE_BURST) {
        ALOGD("Not BurstMode");
        goto burst_write_out;
    }

    while( !mBurstShot.isEmpty() ) {

        if (mBurstWriteThread->exitRequested() ) {
            mNotifyCb(CAMERA_MSG_ERROR, 0, 0, mCallbackCookie);
            ALOGE("BURSTSHOT Burst mDeleteBurst is set.");
            goto burst_write_out;
        }

        for(int i=0; i<10, mBurstShot.isEmpty();i++) {
            if ( mPictureRunning == false )
                goto burst_write_out;
            usleep(100*1000);
        }

        //save images
        if ( mBurstShot.pop(&item) == false ) {
            mBurstShot.DumpState();
            goto burst_write_out;
        }

        ALOGD("BURSTSHOT MEM: pop start -- item->virt = %p getTailItem[%d] size(%d)", item.virt, item.ix, item.size);

		if (mEnableStrCb) {
			stringHeap = mGetMemoryCb(-1, PATH_SIZE, 1, &stringHeapFd);
			if (!stringHeap || stringHeap->data == MAP_FAILED) {
				ALOGE("ERR(%s): heap creation fail string", __func__);
				mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
				goto burst_write_out;
			}

			mBurstShot.getFileName((char*)stringHeap->data, item.frame_num, item.group);
			if (!nativeSaveJpegPicture((char*)stringHeap->data, &item)) {
				ALOGE("BURSTSHOT Burst thread : error, nativeSaveJpegPicture");
				mBurstShot.free(&item);
				goto burst_write_out;
			}
		} else {
			dataHeap = mGetMemoryCb(-1, item.size, 1, &dataHeapFd);
			if (!dataHeap || dataHeap->data == MAP_FAILED) {
				ALOGE("ERR(%s): dataHeap creation fail", __func__);
				mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
				goto burst_write_out;
			}
			memcpy((uint8_t *)dataHeap->data, (uint8_t *)item.virt, item.size);
		}

#ifdef  BURST_SHOT_SUPPORT_TEST
        usleep(1000*1000);
#endif

		mBurstShot.free(&item);

#ifdef  BURST_SHOT_SUPPORT_TEST
        mBurstShot.DumpState();
#endif

		if (mEnableStrCb) {
			if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
				ALOGD("BURSTSHOT : CAMERA_MSG_COMPRESSED_IMAGE start - string callback");
				mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, stringHeap, 0, NULL, mCallbackCookie);
			}
			stringHeap->release(stringHeap);
			stringHeap = NULL;
			stringHeapFd = -1;
		} else {
			if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
				ALOGD("BURSTSHOT : CAMERA_MSG_COMPRESSED_IMAGE start - string callback");
				mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, dataHeap, 0, NULL, mCallbackCookie);
			}
			dataHeap->release(dataHeap);
			dataHeap = NULL;
			dataHeapFd = -1;
		}
        ALOGD("BURSTSHOT : CAMERA_MSG_COMPRESSED_IMAGE end");
    }

burst_write_out:
	ALOGD("BURSTSHOT: mBurstWriteRunning set to false");
    mBurstWriteRunning = false;
    mPictureLock.lock();
    if (mPictureRunning == false){
        ALOGD("BURSTSHOT ***** mPictureRunning=%d", mPictureRunning);
        mBurstShot.release();
        mBurstShot.DumpState();
    }
    mPictureLock.unlock();

    ALOGE("BURSTSHOT BURST SHOT: burstWriteThread X---------------");

    return false;
}
#endif

bool ISecCameraHardware::HDRPictureThread()
{
    int i, ncnt;
	int count = 3;
    int postviewOffset;
    int err;

    ALOGD("HDRPictureThread E");

    mPictureLock.lock();

    LOG_PERFORMANCE_START(1);

	nativeSetParameters(CAM_CID_CONTINUESHOT_PROC, V4L2_INT_STATE_START_CAPTURE);

#if 0
    for ( i = count ; i ; i--) {
        ncnt = count-i+1;
        ALOGD("HDRPictureThread: AEB %d frame", ncnt);
        nativeSetParameters(CAM_CID_CONTINUESHOT_PROC, V4L2_INT_STATE_FRAME_SYNC);
        if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
            mPictureLock.lock();
        }
    }
#endif

    for ( i = count ; i ; i--) {

        if (i != count) {
            mPictureLock.lock();
        }

        if (!nativeStartYUVSnapshot()) {
	        ALOGE("HDRPictureThread: error, nativeStartYUVSnapshot");
	        mPictureLock.unlock();
	        goto out;
	    }
	    ALOGE("nativeGetYUVSnapshot: count[%d], i[%d]",count,i);

	    if (!nativeGetYUVSnapshot(count-i+1, &postviewOffset)) {
	        ALOGE("HDRPictureThread: error, nativeGetYUVSnapshot");
	        mPictureLock.unlock();
	        mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
	        goto out;
	    } else {
	        ALOGE("HDRPictureThread: success, nativeGetYUVSnapshot");
	    }

		mPictureLock.unlock();

        if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
            ALOGD("YUV mHDRTotalFrameSize(mHDRFrameSize) = %d, %d frame", mHDRFrameSize, i);
            mPictureLock.unlock();
            mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mHDRHeap, 0, NULL, mCallbackCookie);
        }
        nativeStopSnapshot();
    }

out:
    nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();

    LOG_PERFORMANCE_END(1, "total");

    ALOGD("HDRPictureThread X");
    return false;

}

bool ISecCameraHardware::AEBPictureThread()
{
    int i, ncnt;
	int count = 3;
    int postviewOffset;
    int err;

    ALOGD("AEBPictureThread E");

    mPictureLock.lock();

    LOG_PERFORMANCE_START(1);

	nativeSetParameters(CAM_CID_CONTINUESHOT_PROC, V4L2_INT_STATE_START_CAPTURE);

    for ( i = count ; i ; i--) {
        ncnt = count-i+1;
        ALOGD("AEBPictureThread: AEB %d frame", ncnt);
        nativeSetParameters(CAM_CID_CONTINUESHOT_PROC, V4L2_INT_STATE_FRAME_SYNC);
#if 0
        if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
            mPictureLock.lock();
        }
#endif
    }

    for (i = count ; i ; i--) {
        ncnt = count-i+1;
        ALOGD("AEBPictureThread: StartPostview %d frame E", ncnt);
        if (!nativeStartPostview()) {
            ALOGE("AEBPictureThread: error, nativeStartPostview");
            mPictureLock.unlock();
            goto out;
        } else {
            ALOGD("AEBPictureThread: StartPostview %d frame X", ncnt);
        }

        if (!nativeGetPostview(ncnt)) {
            ALOGE("AEBPictureThread: error, nativeGetPostview");
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
            goto out;
        } else {
            ALOGE("AEBPictureThread: nativeGetPostview");
        }

        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
            ALOGD("RAW mRawFrameSize = %d", mRawFrameSize);
            mDataCb(CAMERA_MSG_RAW_IMAGE, mPostviewHeap, 0, NULL, mCallbackCookie);
        }
        if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) {
            ALOGD("JPEG mRawFrameSize = %d", mPostviewFrameSize);
            mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPostviewHeap, 0, NULL, mCallbackCookie);
        }
		nativeStopSnapshot();

        LOG_PERFORMANCE_START(2);
        ALOGD("AEBPictureThread: StartSnapshot %d frame E", ncnt);
        if (!nativeStartSnapshot()) {
            ALOGE("AEBPictureThread: error, nativeStartSnapshot");
            mPictureLock.unlock();
            goto out;
        } else {
            ALOGD("AEBPictureThread: StartSnapshot %d frame X", ncnt);
        }
        LOG_PERFORMANCE_END(2, "nativeStartSnapshot");

        LOG_PERFORMANCE_START(3);
        if (!nativeGetSnapshot(ncnt, &postviewOffset)) {
            ALOGE("AEBPictureThread: error, nativeGetSnapshot");
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
            goto out;
        } else {
            ALOGD("AEBPictureThread: nativeGetSnapshot %d frame ", ncnt);
        }
        LOG_PERFORMANCE_END(3, "nativeGetSnapshot");

        mPictureLock.unlock();

        LOG_PERFORMANCE_START(4);

        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
            mDataCb(CAMERA_MSG_RAW_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
        }
        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY) {
            mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
        }
        if ((mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) && (mJpegHeap != NULL)) {
            mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
        }

        LOG_PERFORMANCE_END(4, "callback functions");
		nativeStopSnapshot();
    }

out:
    nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();

    LOG_PERFORMANCE_END(1, "total");

    ALOGD("AEBPictureThread X");
    return false;

}

bool ISecCameraHardware::RecordingPictureThread()
{
    int i, ncnt;
	int count = mMultiFullCaptureNum;
    int postviewOffset;
    int err;

    ALOGD("RecordingPictureThread : count (%d)E", count);

	if (mCaptureMode == RUNNING_MODE_SINGLE) {
		if (mPreviewRunning && !mFullPreviewRunning) {
			ALOGW("RecordingPictureThread: warning, preview is running");
			stopPreview();
		}
	}

    mPictureLock.lock();

    LOG_PERFORMANCE_START(1);
	ALOGD("RecordingPictureThread : postview width(%d), height(%d)", 
		mOrgPreviewSize.width, mOrgPreviewSize.height);
    nativeSetParameters(CAM_CID_SET_POSTVIEW_SIZE,
        (int)(mOrgPreviewSize.width<<16|mOrgPreviewSize.height));
	nativeSetParameters(CAM_CID_CONTINUESHOT_PROC, V4L2_INT_STATE_START_CAPTURE);

    for (i = count ; i ; i--) {
        ncnt = count-i+1;
        ALOGD("RecordingPictureThread: StartPostview %d frame E", ncnt);
        if (!nativeStartPostview()) {
            ALOGE("RecordingPictureThread: error, nativeStartPostview");
            mPictureLock.unlock();
            goto out;
        } else {
            ALOGD("RecordingPictureThread: StartPostview %d frame X", ncnt);
        }

        if (!nativeGetPostview(ncnt)) {
            ALOGE("RecordingPictureThread: error, nativeGetPostview");
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
            goto out;
        } else {
            ALOGE("RecordingPictureThread: nativeGetPostview");
        }

        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
            ALOGD("RAW mRawFrameSize = %d", mRawFrameSize);
            mDataCb(CAMERA_MSG_RAW_IMAGE, mPostviewHeap, 0, NULL, mCallbackCookie);
        }
        if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) {
            ALOGD("JPEG mRawFrameSize = %d", mPostviewFrameSize);
            mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPostviewHeap, 0, NULL, mCallbackCookie);
        }

        LOG_PERFORMANCE_START(2);
        ALOGD("RecordingPictureThread: StartSnapshot %d frame E", ncnt);
        if (!nativeStartSnapshot()) {
            ALOGE("RecordingPictureThread: error, nativeStartSnapshot");
            mPictureLock.unlock();
            goto out;
        } else {
            ALOGD("RecordingPictureThread: StartSnapshot %d frame X", ncnt);
        }
        LOG_PERFORMANCE_END(2, "nativeStartSnapshot");

        LOG_PERFORMANCE_START(3);
        if (!nativeGetSnapshot(ncnt, &postviewOffset)) {
            ALOGE("RecordingPictureThread: error, nativeGetSnapshot");
            mPictureLock.unlock();
            mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
            goto out;
        } else {
            ALOGD("RecordingPictureThread: nativeGetSnapshot %d frame ", ncnt);
        }
        LOG_PERFORMANCE_END(3, "nativeGetSnapshot");

        mPictureLock.unlock();

        LOG_PERFORMANCE_START(4);

        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
            mDataCb(CAMERA_MSG_RAW_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
        }
        if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY) {
            mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
        }
        if ((mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) && (mJpegHeap != NULL)) {
            ALOGD("RecordingPictureThread: CAMERA_MSG_COMPRESSED_IMAGE (%d) ", ncnt);
            mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
			
            // This delay is added for waiting until saving jpeg file is completed.
            // if it take short time to save jpeg file, this delay can be deleted.  
            usleep(300*1000);
        }

        LOG_PERFORMANCE_END(4, "callback functions");
    }

out:
    nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    if (mDualCapture) {
        int cap_sizes_width;
        int cap_sizes_height;
			
        mDualCapture = false;
        mParameters.getPictureSize(&cap_sizes_width, &cap_sizes_height);
        mPictureSize.width = cap_sizes_width;
        mPictureSize.height = cap_sizes_height;
    }	
    mLock.unlock();

    LOG_PERFORMANCE_END(1, "total");

    ALOGD("RecordingPictureThread X");
    return false;

}

bool ISecCameraHardware::dumpPictureThread()
{
	int err;
	mPictureRunning = true;

	if (mPreviewRunning && !mFullPreviewRunning) {
		ALOGW("takePicture: warning, preview is running");
		stopPreview();
	}

	/* Start fast capture */
	mCaptureStarted = true;
	err = nativeSetParameters(CAM_CID_SET_FAST_CAPTURE, 0);
	mCaptureStarted = false;
	if (mCancelCapture && mSamsungApp) {
		ALOGD("pictureThread mCancelCapture %d", mCancelCapture);
		mCancelCapture = false;
		return false;
	}
	if (err != NO_ERROR) {
		ALOGE("%s: Fast capture command is failed.", __func__);
	} else {
		ALOGD("%s: Mode change command is issued for fast capture.", __func__);
	}

    mPictureLock.lock();

    LOG_PERFORMANCE_START(1);
	LOG_PERFORMANCE_START(2);
    if (!nativeStartSnapshot()) {
        ALOGE("pictureThread: error, nativeStartSnapshot");
        mPictureLock.unlock();
        goto out;
    }
	LOG_PERFORMANCE_END(2, "nativeStartSnapshot");

    LOG_PERFORMANCE_START(3);
	/* --4 */
    int postviewOffset;

	if (!nativeGetSnapshot(1, &postviewOffset)) {
		ALOGE("pictureThread: error, nativeGetSnapshot");
		mPictureLock.unlock();
		mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
		goto out;
	}
	LOG_PERFORMANCE_END(3, "nativeGetSnapshot");

	mPictureLock.unlock();

	/* Display postview */
	LOG_PERFORMANCE_START(4);

	/* callbacks for capture */
	if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) {
		ALOGD("Postview mPostviewFrameSize = %d", mPostviewFrameSize);
		mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mPostviewHeap, 0, NULL, mCallbackCookie);
	}
	if ((mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) && (mJpegHeap != NULL)) {
		ALOGD("JPEG COMPLRESSED");
		mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
	}
	if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
		ALOGD("RAW mRawFrameSize = %d", mRawFrameSize);
		mDataCb(CAMERA_MSG_RAW_IMAGE, mPostviewHeap, 0, NULL, mCallbackCookie);
	}
	if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY) {
		ALOGD("RAW image notify");
		mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
	}

    LOG_PERFORMANCE_END(4, "callback functions");

#if DUMP_FILE
    dumpToFile(mJpegHeap->base(), mPictureFrameSize, "/data/capture01.jpg");
#endif

out:
    nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();
    LOG_PERFORMANCE_END(1, "total");

    ALOGD("pictureThread X");
    return false;
}

status_t ISecCameraHardware::pictureThread_RAW()
{
    int postviewOffset;
	int jpegSize;
	uint8_t *RAWsrc;
    ALOGE("pictureThread_RAW E");

    mPictureLock.lock();

	nativeSetParameters(CAM_CID_MAIN_FORMAT, 5);

    if (!nativeStartSnapshot()) {
        ALOGE("pictureThread: error, nativeStartSnapshot");
        mPictureLock.unlock();
        goto out;
    }

#if 0
    if ((mMsgEnabled & CAMERA_MSG_SHUTTER) && (mSceneMode != SCENE_MODE_NIGHTSHOT)) {
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
        mPictureLock.lock();
    }
#endif

    if (!nativeGetSnapshot(0, &postviewOffset)) {	//if (!nativeGetSnapshot(1, &postviewOffset)) {
        ALOGE("pictureThread: error, nativeGetSnapshot");
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
        goto out;
    }

    RAWsrc = (uint8_t *)mPictureBufDummy[0].virt.extP[0];

    if(mJpegHeap != NULL)
        memcpy((uint8_t *)mJpegHeap->data, RAWsrc, mPictureFrameSize );

    if ((mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) && (mJpegHeap != NULL)) {	//CAMERA_MSG_COMPRESSED_IMAGE
        ALOGD("RAW COMPLRESSED");
        mDataCb(CAMERA_MSG_POSTVIEW_FRAME, mJpegHeap, 0, NULL, mCallbackCookie);	//CAMERA_MSG_COMPRESSED_IMAGE
    }

    nativeSetParameters(CAM_CID_MAIN_FORMAT, 1);

    if (!nativeStartSnapshot()) {
        ALOGE("pictureThread: error, nativeStartSnapshot");
        mPictureLock.unlock();
        goto out;
    }

    if (!nativeGetSnapshot(1, &postviewOffset)) {
        ALOGE("pictureThread_RAW : error, nativeGetMultiSnapshot");
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
        goto out;
    }

    if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
		ALOGD("JPEG COMPRESSED");
        mPictureLock.unlock();
        mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mJpegHeap, 0, NULL, mCallbackCookie);
        mPictureLock.lock();
    }

	if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY) {
		ALOGD("RAW image notify");
		mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
	}

    mPictureLock.unlock();

    out:
    nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();

    ALOGD("pictureThread_RAW X");
    return false;
}

status_t ISecCameraHardware::Factory_pictureThread_Resolution()
{
    int postviewOffset;
    ALOGE("Factory_pictureThread_Resolution E");

    if (!nativeStartYUVSnapshot()) {
        ALOGE("pictureThread: error, nativeStartYUVSnapshot");
        mPictureLock.unlock();
        goto out;
    }

#if 0
    if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
        mPictureLock.lock();
    }
#endif

    if (!nativeGetOneYUVSnapshot()) {
        ALOGE("pictureThread: error, nativeGetOneYUVSnapshot");
        mPictureLock.unlock();
        mNotifyCb(CAMERA_MSG_ERROR, -1, 0, mCallbackCookie);
        goto out;
    } else {
        ALOGE("pictureThread: success, nativeGetOneYUVSnapshot");
    }

    mParameters.set("factory-resol-exif-fno", mFactoryExifFnum);
    ALOGD("pictureThread: mFactoryExifFnum [%d]", mFactoryExifFnum);
    mParameters.set("factory-resol-exif-iso", mFactoryExifISO);
    ALOGD("pictureThread: mFactoryExifISO [%d]", mFactoryExifISO);
    mParameters.set("factory-resol-exif-speed", mFactoryExifShutterSpeed);
    ALOGD("pictureThread: mFactoryExifShutterSpeed [%d]", mFactoryExifShutterSpeed);

    nativeDumpYUV();

#if 1
    if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
        ALOGD("YUV mRawFrameSize = %d", mRawFrameSize);
        mPictureLock.unlock();
        mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mYUVHeap, 0, NULL, mCallbackCookie);
        goto out;
    }
#endif

    mPictureLock.unlock();

    out:
    nativeStopSnapshot();
    mLock.lock();
    mPictureRunning = false;
    mLock.unlock();

    ALOGD("Factory_pictureThread_Resolution X");
    return false;
}

status_t ISecCameraHardware::cancelPicture()
{
    mPictureThread->requestExitAndWait();

    ALOGD("cancelPicture EX");
    return NO_ERROR;
}

status_t ISecCameraHardware::sendCommand(int32_t command, int32_t arg1, int32_t arg2)
{
    ALOGV("sendCommand E: command %d, arg1 %d, arg2 %d", command, arg1, arg2);
    int max;

    switch(command) {
    case CAMERA_CMD_DISABLE_POSTVIEW:
        mDisablePostview = arg1;
        break;

    case CAMERA_CMD_SET_SAMSUNG_APP:
        mSamsungApp = true;
        break;

    case CAMERA_CMD_START_FACE_DETECTION:
        if (arg1 == CAMERA_FACE_DETECTION_HW) {
            ALOGI("Not supported Face Detection HW");
            mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, "0");
            //return BAD_VALUE; /* return BAD_VALUE if not supported. */	/* delete for Self-shot mode */
        } else if (arg1 == CAMERA_FACE_DETECTION_SW) {
            if (arg2 > 0) {
                ALOGI("Support Face Detection SW");
                char Result[12];
                CLEAR(Result);
                snprintf(Result, sizeof(Result), "%d", arg2);
                mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, Result);
            } else {
                ALOGI("Not supported Face Detection SW");
                mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, "0");
                return BAD_VALUE;
            }
        } else {
            ALOGI("Not supported Face Detection");
        }
        break;

    case CAMERA_CMD_STOP_FACE_DETECTION:
        if (arg1 == CAMERA_FACE_DETECTION_SW) {
            mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, "0");
        } else if (arg1 == CAMERA_FACE_DETECTION_HW) {
            /* TODO: If implement the CAMERA_FACE_DETECTION_HW, remove the "return UNKNOWN_ERROR" */
            ALOGI("Not supported Face Detection HW");
            mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, "0");
            //return UNKNOWN_ERROR;	/* delete for Self-shot mode */
        }
        break;

    case CAMERA_CMD_SET_TOUCH_AF_POSITION:
#if 0
        if ((mSensorSize.width == 0 && mSensorSize.height == 0) ||
            ((mSensorSize.width*10/mSensorSize.height) != (mPreviewSize.width*10/mPreviewSize.height))) {
            int SensorSize = 0;
            nativeGetParameters(CAM_CID_SENSOR_OUTPUT_SIZE, &SensorSize);
            mSensorSize.height = SensorSize&0xFFFF;
            mSensorSize.width = (SensorSize>>16)&0xFFFF;
        }
        ALOGD("CAMERA_CMD_SET_TOUCH_AF_POSITION  ~~~~~~~~~ ");
        /* X */
        if (mPreviewSize.width != mSensorSize.width) {
            int diff = 0, x_position = 0;
            diff = mSensorSize.width*1000/mPreviewSize.width;
            x_position = (arg1*diff)/1000;
            nativeSetParameters(CAM_CID_SET_TOUCH_AF_POSX, x_position);
            ALOGD("TouchAF X position : %d -> %d", arg1, x_position);
        } else {
            nativeSetParameters(CAM_CID_SET_TOUCH_AF_POSX, arg1);
        }
        /* Y */
        if (mPreviewSize.width != mSensorSize.width) {
            int diff = 0, y_position = 0;
            diff = mSensorSize.height*1000/mPreviewSize.height;
            y_position = (arg2*diff)/1000;
            nativeSetParameters(CAM_CID_SET_TOUCH_AF_POSY, y_position);
            ALOGD("TouchAF y position : %d -> %d", arg2, y_position);
        } else {
            nativeSetParameters(CAM_CID_SET_TOUCH_AF_POSY, arg2);
        }
#else
        ALOGD("CAMERA_CMD_SET_TOUCH_AF_POSITION  X:%d, Y:%d", arg1, arg2);
        nativeSetParameters(CAM_CID_SET_TOUCH_AF_POSX, arg1);
        nativeSetParameters(CAM_CID_SET_TOUCH_AF_POSY, arg2);

#endif
        break;

    case HAL_OBJECT_TRACKING_STARTSTOP:
        if (mCameraId == CAMERA_FACING_BACK) {
            nativeSetParameters(CAM_CID_OBJ_TRACKING, arg1);
        }
        break;

    case CAMERA_CMD_START_STOP_TOUCH_AF:
        if (!mPreviewRunning && arg1) {
            ALOGW("Preview is not started before Touch AF");
            return NO_INIT;
        }
        ALOGD("CAMERA_CMD_START_STOP_TOUCH_AF  ~~~~~~~~~ arg1 == %d", arg1);
        nativeSetParameters(CAM_CID_SET_TOUCH_AF, arg1);
        break;

    case CAMERA_CMD_SET_FLIP:
        nativeSetParameters(CAM_CID_HFLIP, arg1, 0);
        nativeSetParameters(CAM_CID_HFLIP, arg1, 1);
        mMirror = arg1;
        break;

#ifdef BURST_SHOT_SUPPORT
	case CAMERA_CMD_RUN_BURST_TAKE:

        // mBurstShot.init(); : burst shot continue ...
        mBurstShot.setAttrib(arg1);
		if (arg1 & BURST_ATTRIB_STRING_CB_MODE)
			mEnableStrCb = true;
		else if (arg1 & BURST_ATTRIB_IMAGE_CB_MODE)
			mEnableStrCb = false;
		else
			mEnableStrCb = true;

        if ( mPictureRunning == false ) {
            if ( arg2 > 0 )
                mBurstShot.setCountMax(arg2);
            char *path = getBurstSavePath();
            if ( path != NULL )
                mBurstShot.setPath(path);

			mBurstSoundMaxCount = mBurstShot.getCountMax();

            mBurstSoundCount = 0;
            mBurstStopReq = CAMERA_BURST_STOP_NONE;
        }
        ALOGD("BURSTSHOT: CAMERA_CMD_RUN_BURST_TAKE--1, arg1 = %d, arg2 = %d, mBurstSoundMaxCount = %d",
				arg1, arg2, mBurstSoundMaxCount);
		break;
    case CAMERA_CMD_STOP_BURST_TAKE: //1572
        ALOGD("BURSTSHOT: CAMERA_CMD_STOP_BURST_TAKE--- %d, %d, %d/%d",
				mPictureRunning, mBurstWriteRunning, mBurstSoundCount, mBurstSoundMaxCount);

        if (mBurstStopReq == CAMERA_BURST_STOP_NONE) {
			mBurstSoundMaxCount = mBurstSoundCount;

            mBurstStopReq = CAMERA_BURST_STOP_REQ;
        }

		if (mPictureRunning == false && mBurstWriteRunning == false) {
            mBurstShot.release();
        }
        break;
#endif

    case CAMERA_CMD_SMART_AUTO_S1_RELEASE:
        if (mCameraId == CAMERA_FACING_BACK) {
            ALOGD("CAMERA_CMD_SMART_AUTO_S1_RELEASE  ~~~~~~~~~ ");
            nativeSetParameters(CAM_CID_S1_PUSH, 0);
        }
        break;

    case HAL_START_CONTINUOUS_AF:
        ALOGD("HAL_START_CONTINUOUS_AF  ~~~~~~~~~ ");
        nativeSetParameters(CAM_CID_CONTINUOUS_AF, 1);
        break;

    case HAL_STOP_CONTINUOUS_AF:
        ALOGD("HAL_STOP_CONTINUOUS_AF  ~~~~~~~~~ ");
        nativeSetParameters(CAM_CID_CONTINUOUS_AF, 0);
        break;

    case CAMERA_CMD_SETZOOM:
        if (mCameraId == CAMERA_FACING_BACK) {
            max = mParameters.getInt(CameraParameters::KEY_MAX_ZOOM);
            if ( arg1 < 0 || arg1 > max ) {  // ZOOM 0~15
                ALOGE("CAMERA_CMD_SETZOOM failed not support level=%d ", arg1);
                break;
            }

            ALOGD("CAMERA_CMD_SETZOOM  req=%d, currentlevel=%d/%d, zoomstate=%d", arg1, mZoomCurrLevel, max, mZoomStatus);
            if (arg1 != mZoomCurrLevel && mZoomStatus == 0 ) {
                int err = nativeSetParameters(CAM_CID_ZOOM, arg1);
                if (err < 0) {
                    ALOGE("%s: CAMERA_CMD_SETZOOM failed", __func__);
                    return err;
                }
            }
        }
	break;

	case CAMERA_CMD_GET_WB_CUSTOM_VALUE:
	{
		int x, y;
		char str[32];

		x = nativegetWBcustomX();
		y = nativegetWBcustomY();

		mWBcustomValue.x = x;
		mWBcustomValue.y = y;

		sprintf(str, "%d,%d", x, y);
		ALOGD("CAMERA_CMD_GET_WB_CUSTOM_VALUE %s", str);
		mParameters.set("wb-custom", str);
	}
	break;

	case HAL_AF_LAMP_CONTROL:
		nativeSetParameters(CAM_CID_TIMER_LED, (arg1 ? mTimerSet : V4L2_TIMER_LED_OFF));
	break;
	

#ifndef FCJUNG
    case CAMERA_CMD_ISP_DEBUG: //9000
        ALOGD("ISPD CAMERA_CMD_ISP_DEBUG==============");
        ISP_DBG_input();
        break;

    case CAMERA_CMD_ISP_LOG: //9001
        ALOGD("ISPD CAMERA_CMD_ISP_LOG==============");
        ISP_DBG_logwrite();
        break;

    case CAMERA_CMD_FACTORY_SYS_MODE://9005
        switch (arg2) {
        case FACTORY_SYSMODE_MONITOR:
            ALOGD("CAMERA_CMD_FACTORY_SYS_MODE==============MONITOR");
            nativeSetParameters(CAM_CID_FACTORY_CAM_SYS_MODE, arg2);
            startPreview();
            break;
        case FACTORY_SYSMODE_CAPTURE:
        case FACTORY_SYSMODE_PARAM:
            ALOGD("CAMERA_CMD_FACTORY_SYS_MODE==============%s",
                arg2 == FACTORY_SYSMODE_CAPTURE ? "FACTORY_SYSMODE_CAPTURE" : "FACTORY_SYSMODE_PARAM");
            mFactorySysMode = 1;    /* don't destroy surface */
            stopPreview();
            mFactorySysMode = 0;
            nativeSetParameters(CAM_CID_FACTORY_CAM_SYS_MODE, arg2);
            break;
        }
		break;

    case CAMERA_CMD_FACTORY_SEND_VALUE:
        nativeSetParameters(CAM_CID_FACTORY_SEND_SETTING, arg1);
        nativeSetParameters(CAM_CID_FACTORY_SEND_VALUE, arg2);
        break;

    case CAMERA_CMD_FACTORY_SEND_WORD_VALUE:
        nativeSetParameters(CAM_CID_FACTORY_SEND_SETTING, arg1);
        nativeSetParameters(CAM_CID_FACTORY_SEND_WORD_VALUE, arg2);
        break;

    case CAMERA_CMD_FACTORY_SEND_LONG_VALUE:
        nativeSetParameters(CAM_CID_FACTORY_SEND_SETTING, arg1);
        nativeSetParameters(CAM_CID_FACTORY_SEND_LONG_VALUE, arg2);
        break;
#endif /* FCJUNG */

    case CAMERA_CMD_SET_AFAE_DIVISION_AE_POSITION:
    {
#if 0
        int diff = 0, x_position = 0, y_position = 0;
        int ae_window_x_position = 0, ae_window_y_position = 0;
        ALOGD("CAMERA_CMD_SET_AFAE_DIVISION_AE_POSITION  X(arg1):%d, Y(arg2):%d", arg1, arg2);

	 /* 1. correcting the coordinate */
	 /* 1-1. X-coordinate */
	 if (mPreviewSize.width != mSensorSize.width) {
            diff = mSensorSize.width*1000/mPreviewSize.width;
            x_position = (arg1*diff)/1000;
        } else {
            x_position = arg1;
        }

	 /* 1-1. Y-coordinate */
	 if (mPreviewSize.width != mSensorSize.width) {
            diff = mSensorSize.height*1000/mPreviewSize.height;
            y_position = (arg2*diff)/1000;
        } else {
            y_position = arg2;
        }

	 /* 2. calculating the AE window size */
	 ae_window_x_position = x_position/(mPreviewSize.width/NUM_OF_AE_WINDOW_ROW);
	 ae_window_y_position = y_position/(mPreviewSize.height/NUM_OF_AE_WINDOW_COLUMN);
#else
        int x_position = 0, y_position = 0;
        int ae_window_x_position = 0, ae_window_y_position = 0;
        x_position = arg1;
        y_position = arg2;
	 /* 2. calculating the AE window size */
	 ae_window_x_position = x_position/(1280/NUM_OF_AE_WINDOW_ROW);
	 ae_window_y_position = y_position/(720/NUM_OF_AE_WINDOW_COLUMN);
#endif
        if(ae_window_x_position > NUM_OF_AE_WINDOW_ROW) {
            ae_window_x_position = NUM_OF_AE_WINDOW_ROW - 1;
        } else if(ae_window_y_position > NUM_OF_AE_WINDOW_COLUMN) {
            ae_window_y_position = NUM_OF_AE_WINDOW_COLUMN - 1;
        }

	 ALOGD("CAMERA_CMD_SET_AFAE_DIVISION_AE_POSITION  x_position:%d, y_position:%d", x_position, y_position);
	 ALOGD("CAMERA_CMD_SET_AFAE_DIVISION_AE_POSITION  ae_window_x_position:%d, ae_window_y_position:%d", ae_window_x_position, ae_window_y_position);
        nativeSetParameters(CAM_CID_CAMERA_AE_POSITION_X, ae_window_x_position);
        nativeSetParameters(CAM_CID_CAMERA_AE_POSITION_Y, ae_window_y_position);
        break;
    }

    case CAMERA_CMD_SET_AFAE_DIVISION_WINDOW_SIZE:
        ALOGD("CAMERA_CMD_SET_AFAE_DIVISION_WINDOW_SIZE  X(arg1):%d, Y(arg2):%d", arg1, arg2);
        nativeSetParameters(CAM_CID_CAMERA_AE_WINDOW_SIZE_WIDTH, SIZE_OF_AE_WINDOW_ROW);
        nativeSetParameters(CAM_CID_CAMERA_AE_WINDOW_SIZE_HEIGHT, SIZE_OF_AE_WINDOW_COLUMN);
        break;

    case CAMERA_CMD_SET_AFAE_DIVISION_PREVIEW_TOUCH_CTRL:
        ALOGD("CAMERA_CMD_SET_AFAE_DIVISION_PREVIEW_TOUCH_CTRL  X(arg1):%d, Y(arg2):%d", arg1, arg2);
        nativeSetParameters(CAM_CID_CAMERA_AE_PREVIEW_TOUCH_CTRL, arg1);
	break;

    case RECORDING_TAKE_PICTURE:
        if (mDualCapture) {
            mMultiFullCaptureNum++;
            ALOGD("Recording Capture cnt [%d]", mMultiFullCaptureNum);
        } else {
            mMultiFullCaptureNum = 1;
        }
        mDualCapture = true;
        if (mMultiFullCaptureNum > 6) {
            ALOGD("RECORDING_TAKE_PICTURE: error %d", mMultiFullCaptureNum);
            mMultiFullCaptureNum = 6;
            return NO_ERROR;
        }
        if (!nativeStartDualCapture(mMultiFullCaptureNum)) {
            ALOGD("nativeStartDualCapture: error");
            mNotifyCb(CAMERA_MSG_ERROR, -9, 0, mCallbackCookie);
            return NO_ERROR;
        }
        break;	

    default:
        ALOGE("no matching case");
        break;
    }

    return NO_ERROR;
}

void ISecCameraHardware::release()
{
	if (mPreviewThread != NULL) {
		mPreviewThread->requestExitAndWait();
		mPreviewThread.clear();
	}

	if (mPreviewZoomThread != NULL) {
		mPreviewZoomThread->requestExitAndWait();
		mPreviewZoomThread.clear();
	}

#if FRONT_ZSL
	if (mZSLPictureThread != NULL) {
		mZSLPictureThread->requestExitAndWait();
		mZSLPictureThread.clear();
	}
#endif

#if IS_FW_DEBUG_THREAD
	if (mCameraId == CAMERA_FACING_FRONT || mCameraId == FD_SERVICE_CAMERA_ID) {
		mStopDebugging = true;
		mDebugCondition.signal();
		if (mDebugThread != NULL) {
			mDebugThread->requestExitAndWait();
			mDebugThread.clear();
		}
	}
#endif

	if (mRecordingThread != NULL) {
		mRecordingThread->requestExitAndWait();
		mRecordingThread.clear();
	}

	if (mPostRecordThread != NULL) {
		mPostRecordThread->requestExit();
		mPostRecordExit = true;
		mPostRecordCondition.signal();
		mPostRecordThread->requestExitAndWait();
		mPostRecordThread.clear();
	}

	if (mAutoFocusThread != NULL) {
		/* this thread is normally already in it's threadLoop but blocked
		 * on the condition variable.  signal it so it wakes up and can exit.
		 */
		mAutoFocusThread->requestExit();
		mAutoFocusExit = true;
		mAutoFocusCondition.signal();
		mAutoFocusThread->requestExitAndWait();
		mAutoFocusThread.clear();
	}

#ifdef SMART_THREAD
    if (mSmartThread != NULL) {
        mSmartThread->requestExitAndWait();
        mSmartThread.clear();
    }
#endif

#ifdef ZOOM_CTRL_THREAD
    if (mZoomCtrlThread != NULL) {
        mZoomCtrlThread->requestExitAndWait();
        mZoomCtrlThread.clear();
    }
#endif

    if (mPictureThread != NULL) {
        mPictureThread->requestExitAndWait();
        mPictureThread.clear();
    }

	if (mPreviewHeap) {
		mPreviewHeap->release(mPreviewHeap);
		mPreviewHeap = 0;
		mPreviewHeapFd = -1;
	}

	if (mRecordingHeap) {
		mRecordingHeap->release(mRecordingHeap);
		mRecordingHeap = 0;
	}

	if (mRawHeap != NULL) {
		mRawHeap->release(mRawHeap);
		mRawHeap = 0;
	}

	if (mJpegHeap) {
		mJpegHeap->release(mJpegHeap);
		mJpegHeap = 0;
	}

	if (mHDRHeap) {
		mHDRHeap->release(mHDRHeap);
		mHDRHeap = 0;
	}

	if (mPostviewHeap) {
		mPostviewHeap->release(mPostviewHeap);
		mPostviewHeap = 0;
	}

#ifdef BURST_SHOT_SUPPORT
    if (mBurstPictureThread != NULL) {
		mBurstShotExit = true;
		mBurstShotCondition.signal();
        mBurstPictureThread->requestExitAndWait();
        mBurstPictureThread.clear();
    }
    if (mBurstWriteThread != NULL) {
        mBurstWriteThread->requestExitAndWait();
        mBurstWriteThread.clear();
    }
#endif

    if (mHDRPictureThread != NULL) {
        mHDRPictureThread->requestExitAndWait();
        mHDRPictureThread.clear();
    }
    if (mAEBPictureThread != NULL) {
        mAEBPictureThread->requestExitAndWait();
        mAEBPictureThread.clear();
    }
    if (mBlinkPictureThread != NULL) {
        mBlinkPictureThread->requestExitAndWait();
        mBlinkPictureThread.clear();
    }
    if (mRecordingPictureThread != NULL) {
        mRecordingPictureThread->requestExitAndWait();
        mRecordingPictureThread.clear();
    }
	if (mDumpPictureThread != NULL) {
        mDumpPictureThread->requestExitAndWait();
        mDumpPictureThread.clear();
    }

	if (mShutterThread != NULL) {
        mShutterThread->requestExitAndWait();
        mShutterThread.clear();
    }

	nativeDestroySurface();
}

status_t ISecCameraHardware::dump(int fd) const
{
    return NO_ERROR;
}

int ISecCameraHardware::getCameraId() const
{
    return mCameraId;
}

status_t ISecCameraHardware::setParameters(const CameraParameters &params)
{
    LOG_PERFORMANCE_START(1);

    if (mPictureRunning) {
        ALOGW("setParameters: warning, capture is not complete. please wait...");
        Mutex::Autolock l(&mPictureLock);
    }

    Mutex::Autolock l(&mLock);

    ALOGV("DEBUG(%s): [Before Param] %s", __FUNCTION__, params.flatten().string());

    status_t rc, final_rc = NO_ERROR;

    if ((rc = setRecordingMode(params)))
        final_rc = rc;
    if ((rc = setMovieMode(params)))
        final_rc = rc;
    if ((rc = setFirmwareMode(params)))
        final_rc = rc;

    if ((rc = setDtpMode(params)))
        final_rc = rc;
    if ((rc = setVtMode(params)))
        final_rc = rc;
    if ((rc = setVideoSize(params)))
        final_rc = rc;
    if ((rc = setPreviewSize(params)))
        final_rc = rc;
    if ((rc = setPreviewFormat(params)))
        final_rc = rc;
    if ((rc = setPictureSize(params)))
        final_rc = rc;
    if ((rc = setPictureFormat(params)))
        final_rc = rc;
    if ((rc = setThumbnailSize(params)))
        final_rc = rc;
    if ((rc = setJpegThumbnailQuality(params)))
        final_rc = rc;
    if ((rc = setJpegQuality(params)))
        final_rc = rc;
    if ((rc = setFrameRate(params)))
        final_rc = rc;
    if ((rc = setRotation(params)))
        final_rc = rc;
    if ((rc = setFocusMode(params)))
        final_rc = rc;

	/* UI settings */
	if (mCameraId == CAMERA_FACING_BACK) {
		/* Set anti-banding both rear and front camera if needed. */
#ifdef USE_CSC_FEATURE
		if ((rc = setAntiBanding()))			final_rc = rc;
#else
		if ((rc = setAntiBanding(params)))		final_rc = rc;
#endif
		if ((rc = setSceneMode(params)))		final_rc = rc;
		if ((rc = setFocusAreas(params)))		final_rc = rc;
		if ((rc = setFlash(params)))			final_rc = rc;
		if ((rc = setMetering(params)))			final_rc = rc;
		if ((rc = setMeteringAreas(params)))        final_rc = rc;
		if ((rc = setAutoContrast(params)))		final_rc = rc;
		/* Set for Adjust Image */
                if ((rc = setSharpness(params)))        final_rc = rc;
                if ((rc = setContrast(params)))         final_rc = rc;
                if ((rc = setSaturation(params)))       final_rc = rc;
                if ((rc = setColorAdjust(params)))    final_rc = rc;
		if ((rc = setAntiShake(params)))		final_rc = rc;
		if ((rc = setFaceBeauty(params)))		final_rc = rc;
		/* setCapturemode: Do not set before setPASMmode() */
		if ((rc = setZoomActionMethod(params)))     final_rc = rc;
		if ((rc = setZoom(params)))             final_rc = rc;
		if ((rc = setDzoom(params)))            final_rc = rc;
		if ((rc = setZoomSpeed(params)))        final_rc = rc;
	} else {
		if ((rc = setBlur(params)))				final_rc = rc;
	}
	if ((rc = setZoom(params)))				final_rc = rc;
	if ((rc = setWhiteBalance(params)))		final_rc = rc;
	if ((rc = setEffect(params)))			final_rc = rc;
	if ((rc = setBrightness(params)))		final_rc = rc;
	if ((rc = setAELock(params)))			final_rc = rc;
	if ((rc = setAWBLock(params)))			final_rc = rc;
	if ((rc = setGps(params)))			final_rc = rc;

#if VENDOR_FEATURE
	if ((rc = setWeather(params)))			final_rc = rc;
	if ((rc = setCityId(params)))			final_rc = rc;

    /* for NSM Mode */
    if ((rc = setNsmSystem(params))) final_rc = rc;
    if ((rc = setNsmState(params))) final_rc = rc;

    if ((rc = setNsmRGB(params))) final_rc = rc;
    if ((rc = setNsmContSharp(params))) final_rc = rc;

    if ((rc = setNsmHueAllRedOrange(params))) final_rc = rc;
    if ((rc = setNsmHueYellowGreenCyan(params))) final_rc = rc;
    if ((rc = setNsmHueBlueVioletPurple(params))) final_rc = rc;
    if ((rc = setNsmSatAllRedOrange(params))) final_rc = rc;
    if ((rc = setNsmSatYellowGreenCyan(params))) final_rc = rc;
    if ((rc = setNsmSatBlueVioletPurple(params))) final_rc = rc;

    if ((rc = setNsmR(params))) final_rc = rc;
    if ((rc = setNsmG(params))) final_rc =rc;
    if ((rc = setNsmB(params))) final_rc =rc;
    if ((rc = setNsmGlobalContrast(params))) final_rc =rc;
    if ((rc = setNsmGlobalSharpness(params))) final_rc =rc;

    if ((rc = setNsmHueAll(params))) final_rc =rc;
    if ((rc = setNsmHueRed(params))) final_rc =rc;
    if ((rc = setNsmHueOrange(params))) final_rc =rc;
    if ((rc = setNsmHueYellow(params))) final_rc =rc;
    if ((rc = setNsmHueGreen(params))) final_rc =rc;
    if ((rc = setNsmHueCyan(params))) final_rc =rc;
    if ((rc = setNsmHueBlue(params))) final_rc =rc;
    if ((rc = setNsmHueViolet(params))) final_rc =rc;
    if ((rc = setNsmHuePurple(params))) final_rc =rc;

    if ((rc = setNsmSatAll(params))) final_rc =rc;
    if ((rc = setNsmSatRed(params))) final_rc =rc;
    if ((rc = setNsmSatOrange(params))) final_rc =rc;
    if ((rc = setNsmSatYellow(params))) final_rc =rc;
    if ((rc = setNsmSatGreen(params))) final_rc =rc;
    if ((rc = setNsmSatCyan(params))) final_rc =rc;
    if ((rc = setNsmSatBlue(params))) final_rc =rc;
    if ((rc = setNsmSatViolet(params))) final_rc =rc;
    if ((rc = setNsmSatPurple(params))) final_rc =rc;
    /* end NSM Mode */
#endif /* VENDOR_FEATURE */

#if defined(KOR_CAMERA)
    if ((rc = setSelfTestMode(params)))
        final_rc = rc;
#endif

#if VENDOR_FEATURE
#ifndef FCJUNG
    if (mCameraId == CAMERA_FACING_BACK) {
        if (mFactoryTestNum != 0)
        {
            if ((rc = setLDC(params))) final_rc = rc;
            if ((rc = setLSC(params))) final_rc = rc;
            if ((rc = setApertureCmd(params))) final_rc = rc;
            if ((rc = setApertureStep(params))) final_rc = rc;
            if ((rc = setApertureStepPreview(params))) final_rc = rc;
            if ((rc = setApertureStepCapture(params))) final_rc = rc;
            if ((rc = setFactoryPunt(params))) final_rc = rc;
            if ((rc = setFactoryPuntShortScanData(params))) final_rc = rc;
            if ((rc = setFactoryPuntLongScanData(params))) final_rc = rc;
            if ((rc = setFactoryPuntRangeData(params))) final_rc = rc;
            if ((rc = setFactoryPuntInterpolation(params))) final_rc = rc;
            if ((rc = setFactoryOIS(params))) final_rc = rc;
            if ((rc = setFactoryOISDecenter(params))) final_rc = rc;
            if ((rc = setFactoryOISMoveShift(params))) final_rc = rc;
            if ((rc = setFactoryOISCenteringRangeData(params))) final_rc = rc;
            if ((rc = setFactoryZoom(params))) final_rc = rc;
            if ((rc = setFactoryZoomStep(params))) final_rc = rc;
            if ((rc = setFactoryZoomRangeCheckData(params))) final_rc = rc;
            if ((rc = setFactoryZoomSlopeCheckData(params))) final_rc = rc;
            if ((rc = setFactoryFailStop(params))) final_rc = rc;
            if ((rc = setFactoryNoDeFocus(params))) final_rc = rc;
            if ((rc = setFactoryInterPolation(params))) final_rc = rc;
            if ((rc = setFactoryCommon(params))) final_rc = rc;
            if ((rc = setFactoryVib(params))) final_rc = rc;
            if ((rc = setFactoryVibRangeData(params))) final_rc = rc;
            if ((rc = setFactoryGyro(params))) final_rc = rc;
            if ((rc = setFactoryGyroRangeData(params))) final_rc = rc;
            if ((rc = setFactoryBacklashMaxThreshold(params))) final_rc = rc;
            if ((rc = setFactoryBacklashCount(params))) final_rc = rc;
            if ((rc = setFactoryBacklash(params))) final_rc = rc;
            if ((rc = setFactoryAF(params))) final_rc = rc;
            if ((rc = setFactoryAFStepSet(params))) final_rc = rc;
            if ((rc = setFactoryAFPosition(params))) final_rc = rc;
            if ((rc = setFactoryAFZone(params))) final_rc = rc;
            if ((rc = setFactoryAFLens(params))) final_rc = rc;
            if ((rc = setFactoryDeFocus(params))) final_rc = rc;
            if ((rc = setFactoryDeFocusWide(params))) final_rc = rc;
            if ((rc = setFactoryDeFocusTele(params))) final_rc = rc;
            if ((rc = setFactoryResol(params))) final_rc = rc;
#if 1
            if ((rc = setFactoryLVTarget(params))) final_rc = rc;
            if ((rc = setFactoryAdjIRIS(params))) final_rc = rc;
            if ((rc = setFactoryLiveViewGain(params))) final_rc = rc;
            if ((rc = setFactoryLiveViewGainOffsetSign(params))) final_rc = rc;
            if ((rc = setFactoryLiveViewGainOffsetVal(params))) final_rc = rc;
            if ((rc = setFactoryShClose(params))) final_rc = rc;
            if ((rc = setFactoryShCloseIRISNum(params))) final_rc = rc;
            if ((rc = setFactoryShCloseSetIRIS(params))) final_rc = rc;
            if ((rc = setFactoryShCloseIso(params))) final_rc = rc;
            if ((rc = setFactoryShCloseRange(params))) final_rc = rc;
            if ((rc = setFactoryCaptureGain(params))) final_rc = rc;
            if ((rc = setFactoryCaptureGainOffsetSign(params))) final_rc = rc;
            if ((rc = setFactoryCaptureGainOffsetVal(params))) final_rc = rc;
            if ((rc = setFactoryLscFshdTable(params))) final_rc = rc;
            if ((rc = setFactoryLscFshdReference(params))) final_rc = rc;
            if ((rc = setFactoryIRISRange(params))) final_rc = rc;
            if ((rc = setFactoryGainLiveViewRange(params))) final_rc = rc;
            if ((rc = setFactoryShCloseSpeedTime(params))) final_rc = rc;
            if ((rc = setFactoryCameraMode(params))) final_rc = rc;
            if ((rc = setFactoryFlash(params))) final_rc = rc;
            if ((rc = setFactoryFlashChgChkTime(params))) final_rc = rc;
            if ((rc = setFactoryAFScanLimit(params))) final_rc = rc;
            if ((rc = setFactoryAFScanRange(params))) final_rc = rc;
            if ((rc = setFactoryFlashRange(params))) final_rc = rc;
            if ((rc = setFactoryWB(params))) final_rc = rc;
            if ((rc = setFactoryWBRange(params))) final_rc = rc;
            if ((rc = setFactoryFlicker(params))) final_rc = rc;
            if ((rc = setFactoryAETarget(params))) final_rc = rc;
            if ((rc = setFactoryAFLEDtime(params))) final_rc = rc;
            if ((rc = setFactoryCamSysMode(params))) final_rc = rc;
            if ((rc = setFactoryCaptureGainRange(params))) final_rc = rc;
            if ((rc = setFactoryCaptureCtrl(params))) final_rc = rc;
            if ((rc = setFactoryWBvalue(params))) final_rc = rc;
            if ((rc = setFactoryAFLEDRangeData(params))) final_rc = rc;
            if ((rc = setFactoryAFDiffCheck(params))) final_rc = rc;
            if ((rc = setFactoryDefectPixel(params))) final_rc = rc;
            if ((rc = setFactoryDFPXNLVCAP(params))) final_rc = rc;
            if ((rc = setFactoryDFPXNLVDR1HD(params))) final_rc = rc;
            if ((rc = setFactoryDFPXNLVDR0(params))) final_rc = rc;
            if ((rc = setFactoryDFPXNLVDR1(params))) final_rc = rc;
            if ((rc = setFactoryDFPXNLVDR2(params))) final_rc = rc;
            if ((rc = setFactoryDFPXNLVDRHS(params))) final_rc = rc;
            if ((rc = setFactoryAFLEDlevel(params))) final_rc = rc;
            if ((rc = setFactoryIspFwVerCheck(params))) final_rc = rc;
            if ((rc = setFactoryOisVerCheck(params))) final_rc = rc;
            if ((rc = setFactoryTiltScanLimitData(params))) final_rc = rc;
            if ((rc = setFactoryTiltAFRangeData(params))) final_rc = rc;
            if ((rc = setFactoryTiltAFScanLimitData(params))) final_rc = rc;
            if ((rc = setFactoryTiltDiffRangeData(params))) final_rc = rc;
            if ((rc = setFactoryIRCheckRGainData(params))) final_rc = rc;
            if ((rc = setFactoryIRCheckBGainData(params))) final_rc = rc;
//            if ((rc = setFactoryIRCheckGAvgData(params))) final_rc = rc;	//?
            if ((rc = setFactoryTiltField(params))) final_rc = rc;
            if ((rc = setFactoryFlashManCharge(params))) final_rc = rc;
            if ((rc = setFactoryFlashManEn(params))) final_rc = rc;
            if ((rc = setFactoryTilt(params))) final_rc = rc;
            if ((rc = setFactoryIRCheck(params))) final_rc = rc;
            if ((rc = setFactoryFlashCharge(params))) final_rc = rc;
            if ((rc = setFactoryMemCopy(params))) final_rc = rc;
            if ((rc = setFactoryMemMode(params))) final_rc = rc;
/* ccjung */
            if ((rc = setFactoryEEPWrite(params))) final_rc = rc;
            if ((rc = setFactoryLensCap(params))) final_rc = rc;
            if ((rc = setFactoryCheckSum(params))) final_rc = rc;

            if ((rc = setFactoryLogWriteAll(params))) final_rc = rc;
            if ((rc = setFactoryDataErase(params))) final_rc = rc;
            if ((rc = setFactoryNoLensOff(params))) final_rc = rc;
            if ((rc = setFactoryFocusCloseOpenCheck(params))) final_rc = rc;
            if ((rc = setFactoryResolutionLog(params))) final_rc = rc;
            if ((rc = setFactoryShadingLog(params))) final_rc = rc;
//            if ((rc = setFactoryWriteShadingData(params))) final_rc = rc;	//?
//            if ((rc = setFactoryClipValue(params))) final_rc = rc;
            if ((rc = setFactoryTiltCoordinate(params))) final_rc = rc;
//            if ((rc = setFactoryAFLED(params))) final_rc = rc;
            if ((rc = setFactoryDefectNoiseLevel(params))) final_rc = rc;
            if ((rc = setFactoryComapareMemory(params))) final_rc = rc;
#endif
        }
    }
#endif /* FCJUNG */
#endif /* VENDOR_FEATURE */

    LOG_PERFORMANCE_END(1, "total");

    ALOGV("DEBUG(%s): [After Param] %s", __FUNCTION__, params.flatten().string());

    ALOGD("setParameters X: %s", final_rc == NO_ERROR ? "success" : "failed");
    return final_rc;
}

#if VENDOR_FEATURE
status_t ISecCameraHardware::setPASMmode(const CameraParameters& params)
{
    const char *str = params.get(CameraParameters::KEY_MODE);
    const char *prevStr = mParameters.get(CameraParameters::KEY_MODE);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    ALOGE("setPASMmode: %s, %s", str, prevStr);

    int val;
    val = SecCameraParameters::lookupAttr(CameraModes, ARRAY_SIZE(CameraModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setPASMmode: warning, not supported value(%s)", str);
        return BAD_VALUE;
    }

    mPASMMode = val;
    mParameters.set(CameraParameters::KEY_MODE, str);

    if (mCameraId == CAMERA_FACING_BACK)
        return nativeSetParameters(CAM_CID_PASM_MODE, val);
    else
        return NO_ERROR;
}
#endif /* VENDOR_FEATURE */

void ISecCameraHardware::setDropFrame(int count)
{
    /* should be locked */
    if (mDropFrameCount < count)
        mDropFrameCount = count;
}

status_t ISecCameraHardware::setAELock(const CameraParameters &params)
{
    const char *str_support = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
    if (str_support == NULL || strcmp(str_support, "true"))
        return NO_ERROR;

    const char *str = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
    const char *prevStr = mParameters.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    ALOGV("setAELock: %s", str);
    if (!(!strcmp(str, "true") || !strcmp(str, "false")))
        return BAD_VALUE;

    mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, str);
#if 0
    int val;
    if (!strcmp(str, "true"))
        val = AE_LOCK;
    else
        val = AE_UNLOCK;
#endif

    return NO_ERROR;
    /*  TODO : sctrl not defined */
    /* return nativeSetParameters(CAM_CID_AE_LOCK_UNLOCK, val); */
}

status_t ISecCameraHardware::setAWBLock(const CameraParameters &params)
{
    const char *str_support = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
    if (str_support == NULL || strcmp(str_support, "true"))
        return NO_ERROR;

    const char *str = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
    const char *prevStr = mParameters.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    ALOGV("setAWBLock: %s", str);
    if (!(!strcmp(str, "true") || !strcmp(str, "false")))
        return BAD_VALUE;

    mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, str);
#if 0
    int val;
    if (!strcmp(str, "true"))
        val = AWB_LOCK;
    else
        val = AWB_UNLOCK;
#endif

    return NO_ERROR;
    /*  TODO : sctrl not defined */
    /*  return nativeSetParameters(CAM_CID_AWB_LOCK_UNLOCK, val); */
}

#ifdef PX_COMMON_CAMERA
/*
 * called when starting preview
 */
 inline void ISecCameraHardware::setDropUnstableInitFrames()
{
    int32_t frameCount = 3;

    if (mCameraId == CAMERA_FACING_BACK) {
        if (mbFirst_preview_started == false) {
            /* When camera_start_preview is called for the first time after camera application starts. */
            if (mSceneMode == SCENE_MODE_NIGHTSHOT || mSceneMode == SCENE_MODE_FIREWORKS)
                frameCount = 3;
            else
                frameCount = mSamsungApp ? INITIAL_REAR_SKIP_FRAME : 6;

            mbFirst_preview_started = true;
        } else {
            /* When startPreview is called after camera application got started. */
           frameCount = (mSamsungApp && mMovieMode) ? (INITIAL_REAR_SKIP_FRAME + 4) : 2;
        }
    } else {
        if (mbFirst_preview_started == false) {
            /* When camera_start_preview is called for the first time after camera application starts. */
            frameCount = INITIAL_FRONT_SKIP_FRAME;
            mbFirst_preview_started = true;
        } else {
            /* When startPreview is called after camera application got started. */
            frameCount = 2;
        }
    } /* (mCameraId == CAMERA_FACING_BACK) */

    setDropFrame(frameCount);
}
#endif

status_t ISecCameraHardware::setFirmwareMode(const CameraParameters &params)
{
    const char *str = params.get(SecCameraParameters::KEY_FIRMWARE_MODE);
	int err;
    if (str == NULL)
        return NO_ERROR;

    int val = SecCameraParameters::lookupAttr(firmwareModes, ARRAY_SIZE(firmwareModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGE("setFirmwareMode: error, invalid value %s", str);
        return BAD_VALUE;
    }

    ALOGV("setFirmwareMode: %s", str);
    mFirmwareMode = (cam_fw_mode)val;
    mParameters.set(SecCameraParameters::KEY_FIRMWARE_MODE, str);

    err = nativeSetParameters(CAM_CID_FW_MODE, val);
	 if (mFirmwareMode == CAM_FW_MODE_UPDATE) {
        if (err >= 0)
            mFirmwareResult = 1;    /* success */
        else if (err == -2)
            mFirmwareResult = 3;    /* fail : no file */
        else
            mFirmwareResult = 2;    /* fail */
    }

	 if (mFirmwareResult) {
        ALOGD("Smart Firmware Update : %s", (mFirmwareResult == 1 ? "Success" : "Fail"));
#if VENDOR_FEATURE
        mNotifyCb(CAMERA_MSG_FIRMWARE_NOTIFY, mFirmwareResult, 0, mCallbackCookie);
#endif
        mFirmwareResult = 0;
    }

	return NO_ERROR;
}

status_t ISecCameraHardware::setDtpMode(const CameraParameters &params)
{
    int val = params.getInt(SecCameraParameters::KEY_DTP_MODE);

#ifdef DEBUG_PREVIEW_NO_FRAME /* 130221.DSLIM Delete me in a week*/
    if ((val >= 0) && !mFactoryMode) {
        mFactoryMode = true;
        ALOGD("setDtpMode: Factory mode (DTP %d)", val);
    } else if ((val < 0) && mFactoryMode) {
        mFactoryMode = false;
        ALOGD("setDtpMode: not Factory mode");
    }
#endif

    if (val == -1 || mDtpMode == (bool)val)
        return NO_ERROR;

    ALOGD("setDtpMode: %d", val);
    mDtpMode = val ? true : false;
    mParameters.set(SecCameraParameters::KEY_DTP_MODE, val);
    if (mDtpMode > 0)
        setDropFrame(15);

    return nativeSetParameters(CAM_CID_DTP_MODE, val);
}

status_t ISecCameraHardware::setVtMode(const CameraParameters &params)
{
    int val = params.getInt(SecCameraParameters::KEY_VT_MODE);
    if (val == -1 || mVtMode == (cam_vt_mode)val)
        return NO_ERROR;

    ALOGV("setVtmode: %d", val);
    mVtMode = (cam_vt_mode)val;
    mParameters.set(SecCameraParameters::KEY_VT_MODE, val);

    return nativeSetParameters(CAM_CID_VT_MODE, val);
}

status_t ISecCameraHardware::setMovieMode(const CameraParameters &params)
{
    int val = params.getInt(SecCameraParameters::KEY_MOVIE_MODE);
#if 0
    const char* prev_val = mParameters.get(SecCameraParameters::KEY_MOVIE_MODE);
    int prev_intVal = mParameters.getInt(SecCameraParameters::KEY_MOVIE_MODE);
#endif

    if (val == -1 || mMovieMode == (bool)val)
        return NO_ERROR;

    ALOGV("setMovieMode: %d", val);
    mMovieMode = val ? true : false;
    mParameters.set(SecCameraParameters::KEY_MOVIE_MODE, val);

    /* Activate the below codes if effect setting has no problem in recording mode */
    if (((mCameraId == CAMERA_FACING_FRONT) || (mCameraId == FD_SERVICE_CAMERA_ID))
      && nativeIsInternalISP()) {
        if (mMovieMode)
            return nativeSetParameters(CAM_CID_IS_S_FORMAT_SCENARIO, IS_MODE_PREVIEW_VIDEO);
        else
            return nativeSetParameters(CAM_CID_IS_S_FORMAT_SCENARIO, IS_MODE_PREVIEW_STILL);
    }

    return nativeSetParameters(CAM_CID_MOVIE_MODE, val);
}

status_t ISecCameraHardware::setRecordingMode(const CameraParameters &params)
{
    const char *str = params.get(CameraParameters::KEY_RECORDING_HINT);
    const char *prevStr = mParameters.get(CameraParameters::KEY_RECORDING_HINT);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    mParameters.set(CameraParameters::KEY_RECORDING_HINT, str);

    String8 recordHint(str);
    ALOGV("setRecordingMode: %s", recordHint.string());

    if (recordHint == "true") {
        mFps = mMaxFrameRate / 1000;
        ALOGD("DEBUG(%s): fps(%d) %s ", __FUNCTION__, mFps, recordHint.string());

        mMovieMode = true;
    } else {
        mMovieMode = false;
    }

    return NO_ERROR;
#ifdef NOTDEFINED
    if (((mCameraId == CAMERA_FACING_FRONT) || (mCameraId == FD_SERVICE_CAMERA_ID))
      && nativeIsInternalISP()) {
        if (mMovieMode)
            return nativeSetParameters(CAM_CID_IS_S_FORMAT_SCENARIO, IS_MODE_PREVIEW_VIDEO);
        else
            return nativeSetParameters(CAM_CID_IS_S_FORMAT_SCENARIO, IS_MODE_PREVIEW_STILL);
    }

    return nativeSetParameters(CAM_CID_MOVIE_MODE, mMovieMode);
#endif
}

status_t ISecCameraHardware::setPreviewSize(const CameraParameters &params)
{
    int width, height;
    params.getPreviewSize(&width, &height);

    if (width <= 0 || height <= 0)
        return BAD_VALUE;

    int count;
    image_rect_type panoramaSize;
    const image_rect_type *sizes, *defaultSizes = NULL, *size = NULL;

    if (mCameraId == CAMERA_FACING_BACK) {
        count = ARRAY_SIZE(backPreviewSizes);
        sizes = backPreviewSizes;
    } else {
        count = ARRAY_SIZE(frontPreviewSizes);
        sizes = frontPreviewSizes;
    }

retry:
    if (mPASMMode == MODE_PANORAMA && width == 1920) {
        panoramaSize.width = 1920;
        panoramaSize.height = 1080;
        size = &panoramaSize;
    } else {
        for (int i = 0; i < count; i++) {
            if (((uint32_t)width == sizes[i].width) && ((uint32_t)height == sizes[i].height)) {
                size = &sizes[i];
                break;
            }
        }
    }

    if (CC_UNLIKELY(!size)) {
        if (!defaultSizes) {
            defaultSizes = sizes;
            if (mCameraId == CAMERA_FACING_BACK) {
                count = ARRAY_SIZE(hiddenBackPreviewSizes);
                sizes = hiddenBackPreviewSizes;
            } else {
                count = ARRAY_SIZE(hiddenFrontPreviewSizes);
                sizes = hiddenFrontPreviewSizes;
            }
            goto retry;
        } else
            sizes = defaultSizes;

        ALOGW("setPreviewSize: warning, not supported size(%dx%d)", width, height);
        size = &sizes[0];
    }

    mPreviewSize = *size;
    mParameters.setPreviewSize((int)size->width, (int)size->height);

    /* FLite size depends on preview size */
#if VENDOR_FEATURE
   if((mMovieMode == true) && (mVideoSize.height == 1080)){
	mFLiteSize.height = 1080;
	mFLiteSize.width = 1920;
   } else if((mPreviewSize.width == 352) && (mPreviewSize.height == 288)){
	mFLiteSize.height = 576;
	mFLiteSize.width = 704;
   } else if((mPreviewSize.width == 640) && (mPreviewSize.height == 480)){
	mFLiteSize.height = 720;
	mFLiteSize.width = 960;
   }else{
	mFLiteSize = *size;
  }
#else
    mFLiteSize = *size;
#endif

    /* backup orginal preview size due to ALIGN */
    mOrgPreviewSize = mPreviewSize;
    mPreviewSize.width = ALIGN(mPreviewSize.width, 128);
    mPreviewSize.height = ALIGN(mPreviewSize.height, 2);

#if 0
#if VENDOR_FEATURE
#else
    if (mPreviewSize.width < 640 || mPreviewSize.width < 480) {
        mFLiteSize.width = 640;
        mFLiteSize.height = 480;
    }

    /* HACK */
    if ((mPreviewSize.width * 9) == (mPreviewSize.height * 16)) {
        mFLiteSize.width = 1024;
        mFLiteSize.height = 576;
    }
#endif
#endif

    ALOGD("DEBUG(%s)(%d): preview size %dx%d/%dx%d/%dx%d", __FUNCTION__, __LINE__,
                width, height, mOrgPreviewSize.width, mOrgPreviewSize.height,
                mPreviewSize.width, mPreviewSize.height);

    return NO_ERROR;
}

status_t ISecCameraHardware::setPreviewFormat(const CameraParameters &params)
{
    const char *str = params.getPreviewFormat();
    const char *prevStr = mParameters.getPreviewFormat();
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(previewPixelFormats, ARRAY_SIZE(previewPixelFormats), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setPreviewFormat: warning, not supported value(%s)", str);
        str = reinterpret_cast<const char*>(previewPixelFormats[0].desc);
        goto retry;
    }

    ALOGD("setPreviewFormat: %s", str);
    mPreviewFormat = (cam_pixel_format)val;
    ALOGV("setPreviewFormat: mPreviewFormat = %s",
        mPreviewFormat == CAM_PIXEL_FORMAT_YVU420P ? "YV12" :
        mPreviewFormat == CAM_PIXEL_FORMAT_YUV420SP ? "NV21" :
        "Others");
    mParameters.setPreviewFormat(str);
    return NO_ERROR;
}

status_t ISecCameraHardware::setVideoSize(const CameraParameters &params)
{

    int width = 0, height = 0;
    params.getVideoSize(&width, &height);

    if ((mVideoSize.width == (uint32_t)width) && (mVideoSize.height == (uint32_t)height))
        return NO_ERROR;

    int count;
    const image_rect_type *sizes, *defaultSizes = NULL, *size = NULL;

    if (mCameraId == CAMERA_FACING_BACK) {
        count = ARRAY_SIZE(backRecordingSizes);
        sizes = backRecordingSizes;
    } else {
        count = ARRAY_SIZE(frontRecordingSizes);
        sizes = frontRecordingSizes;
    }

retry:
    for (int i = 0; i < count; i++) {
        if (((uint32_t)width == sizes[i].width) && ((uint32_t)height == sizes[i].height)) {
            size = &sizes[i];
            break;
        }
    }

    if (CC_UNLIKELY(!size)) {
        if (!defaultSizes) {
            defaultSizes = sizes;
            if (mCameraId == CAMERA_FACING_BACK) {
                count = ARRAY_SIZE(hiddenBackRecordingSizes);
                sizes = hiddenBackRecordingSizes;
            } else {
                count = ARRAY_SIZE(hiddenFrontRecordingSizes);
                sizes = hiddenFrontRecordingSizes;
            }
            goto retry;
        } else {
            sizes = defaultSizes;
        }

        ALOGW("setVideoSize: warning, not supported size(%dx%d)", width, height);
        size = &sizes[0];
    }

    ALOGD("setVideoSize: recording %dx%d", size->width, size->height);
    mVideoSize = *size;
    mParameters.setVideoSize((int)size->width, (int)size->height);

    /* const char *str = mParameters.get(CameraParameters::KEY_VIDEO_SIZE); */
    return NO_ERROR;
}

status_t ISecCameraHardware::setPictureSize(const CameraParameters &params)
{
    int width, height;
	int err;
    params.getPictureSize(&width, &height);

	/* RAW capture temp  width = 4608; , height = 3456; */

    ALOGD("DEBUG(%s): previous %dx%d after %dx%d", __FUNCTION__,
            mPictureSize.width, mPictureSize.height, width, height);

    if ((mPictureSize.width == (uint32_t)width) && (mPictureSize.height == (uint32_t)height)) {
        /* Continuous duplicate size setting makes ISP problem
           for all factory test (including 103 Centering, 123 Defect) */
        if (0 != mFactoryTestNum)
            return NO_ERROR;
    }

#if 0
    if ((mPictureSize.width == (uint32_t)width) && (mPictureSize.height == (uint32_t)height)) {
        mFLiteCaptureSize = mPictureSize;
        if (mPictureSize.width < 640 || mPictureSize.width < 480) {
            mFLiteCaptureSize.width = 640;
            mFLiteCaptureSize.height = 480;
        }
        return NO_ERROR;
    }
#endif

    int count;
    const image_rect_type *sizes, *defaultSizes = NULL, *size = NULL;

    if (mCameraId == CAMERA_FACING_BACK) {
        count = ARRAY_SIZE(backPictureSizes);
        sizes = backPictureSizes;
    } else {
        count = ARRAY_SIZE(frontPictureSizes);
        sizes = frontPictureSizes;
    }

retry:
    for (int i = 0; i < count; i++) {
        if (((uint32_t)width == sizes[i].width) && ((uint32_t)height == sizes[i].height)) {
            size = &sizes[i];
            break;
        }
    }

    if (CC_UNLIKELY(!size)) {
        if (!defaultSizes) {
            defaultSizes = sizes;
            if (mCameraId == CAMERA_FACING_BACK) {
                count = ARRAY_SIZE(hiddenBackPictureSizes);
                sizes = hiddenBackPictureSizes;
            } else {
                count = ARRAY_SIZE(hiddenFrontPictureSizes);
                sizes = hiddenFrontPictureSizes;
            }
            goto retry;
        } else
            sizes = defaultSizes;

        ALOGW("setPictureSize: warning, not supported size(%dx%d)", width, height);
        size = &sizes[0];
    }

    ALOGD("setPictureSize: %dx%d", size->width, size->height);
    mPictureSize = *size;
    mParameters.setPictureSize((int)size->width, (int)size->height);

    mFLiteCaptureSize = mPictureSize;
    if (mPictureSize.width < 640 || mPictureSize.width < 480) {
        mFLiteCaptureSize.width = 640;
        mFLiteCaptureSize.height = 480;
    }

    mRawSize = mPictureSize;

	uint32_t sizeData = (mFLiteCaptureSize.width << 16) | (mFLiteCaptureSize.height & 0xFFFF);
    err = nativeSetParameters(CAM_CID_SET_SNAPSHOT_SIZE, sizeData);
    if (CC_UNLIKELY(err < 0)) {
        ALOGE("setPictureSize: error");
        return UNKNOWN_ERROR;
    }

	/* Postview size need to be set before capture start */
	if (FRM_RATIO(mFLiteCaptureSize) == CAM_FRMRATIO_HD) {
		mPostviewSize.width = 1280;
		mPostviewSize.height = 720;
	} else if (FRM_RATIO(mFLiteCaptureSize) == CAM_FRMRATIO_D1) {
		mPostviewSize.width = 1056;
		mPostviewSize.height = 704;
	} else if (FRM_RATIO(mFLiteCaptureSize) == CAM_FRMRATIO_SQUARE) {
		mPostviewSize.width = 704;
		mPostviewSize.height = 704;
	} else {
		mPostviewSize.width = 960;
		mPostviewSize.height = 720;
	}
	nativeSetParameters(CAM_CID_SET_POSTVIEW_SIZE,
			(int)(mPostviewSize.width<<16|mPostviewSize.height));

    return NO_ERROR;
}

status_t ISecCameraHardware::setPictureFormat(const CameraParameters &params)
{
    const char *str = params.getPictureFormat();
    const char *prevStr = mParameters.getPictureFormat();
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(picturePixelFormats, ARRAY_SIZE(picturePixelFormats), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setPictureFormat: warning, not supported value(%s)", str);
#if 0
        str = reinterpret_cast<const char*>(picturePixelFormats[0].desc);
        goto retry;
#else
        return BAD_VALUE;
#endif	/* FOR HAL TEST */
    }

    ALOGV("setPictureFormat: %s", str);
    mPictureFormat = (cam_pixel_format)val;
    mParameters.setPictureFormat(str);
    return NO_ERROR;
}

status_t ISecCameraHardware::setThumbnailSize(const CameraParameters &params)
{
    int width, height;
    width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
    height = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);

    if (mThumbnailSize.width == (uint32_t)width && mThumbnailSize.height == (uint32_t)height)
        return NO_ERROR;

    int count;
    const image_rect_type *sizes, *size = NULL;

    if (mCameraId == CAMERA_FACING_BACK) {
        count = ARRAY_SIZE(backThumbSizes);
        sizes = backThumbSizes;
    } else {
        count = ARRAY_SIZE(frontThumbSizes);
        sizes = frontThumbSizes;
    }

    for (int i = 0; i < count; i++) {
        if ((uint32_t)width == sizes[i].width && (uint32_t)height == sizes[i].height) {
            size = &sizes[i];
            break;
        }
    }

    if (!size) {
        ALOGW("setThumbnailSize: warning, not supported size(%dx%d)", width, height);
        size = &sizes[0];
    }

    ALOGV("setThumbnailSize: %dx%d", size->width, size->height);
    mThumbnailSize = *size;
    mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, (int)size->width);
    mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, (int)size->height);

    return NO_ERROR;
}

status_t ISecCameraHardware::setJpegThumbnailQuality(const CameraParameters &params)
{
    int val = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
    int prevVal = mParameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
    if (val == -1 || prevVal == val)
        return NO_ERROR;

    if (CC_UNLIKELY(val < 1 || val > 100)) {
        ALOGE("setJpegThumbnailQuality: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

    ALOGV("setJpegThumbnailQuality: %d", val);
    mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, val);

    return 0;
}

status_t ISecCameraHardware::setJpegQuality(const CameraParameters &params)
{
    int val = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
    int prevVal = mParameters.getInt(CameraParameters::KEY_JPEG_QUALITY);
    if (val == -1 || prevVal == val)
        return NO_ERROR;

    if (CC_UNLIKELY(val < 1 || val > 100)) {
        ALOGE("setJpegQuality: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

    ALOGV("setJpegQuality: %d", val);
    mJpegQuality = val;
    mParameters.set(CameraParameters::KEY_JPEG_QUALITY, val);

    return nativeSetParameters(CAM_CID_JPEG_QUALITY, val);
}

status_t ISecCameraHardware::setFrameRate(const CameraParameters &params)
{
    int min, max;
    params.getPreviewFpsRange(&min, &max);
    int frameRate = params.getPreviewFrameRate();
    int prevFrameRate = mParameters.getPreviewFrameRate();
    if ((frameRate != -1) && (frameRate != prevFrameRate))
        mParameters.setPreviewFrameRate(frameRate);

    if (CC_UNLIKELY(min < 0 || max < 0 || max < min)) {
        ALOGE("setFrameRate: error, invalid range(%d, %d)", min, max);
        return BAD_VALUE;
    }

    /* 0 means auto frame rate */
    int val = (min == max) ? min : 0;
    mMaxFrameRate = max;

    if (mMovieMode)
        mFps = mMaxFrameRate / 1000;
    else
        mFps = val / 1000;

    ALOGV("setFrameRate: %d,%d,%d", min, max, mFps);

    if (mFrameRate == val)
        return NO_ERROR;

    mFrameRate = val;

    const char *str = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE);
    if (CC_LIKELY(str)) {
        mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, str);
    } else {
        ALOGE("setFrameRate: corrupted data (params)");
        char buffer[32];
        CLEAR(buffer);
        snprintf(buffer, sizeof(buffer), "%d,%d", min, max);
        mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, buffer);
    }

    mParameters.setPreviewFrameRate(val/1000);

    if (mFrameRate == 15000)
        val = 30000;    /* use skip frame */

    return nativeSetParameters(CAM_CID_FRAME_RATE, val/1000);
}

status_t ISecCameraHardware::setRotation(const CameraParameters &params)
{
    int val = params.getInt(CameraParameters::KEY_ROTATION);
    int prevVal = mParameters.getInt(CameraParameters::KEY_ROTATION);
    if (val == -1 || prevVal == val)
        return NO_ERROR;

    if (CC_UNLIKELY(val != 0 && val != 90 && val != 180 && val != 270)) {
        ALOGE("setRotation: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

    ALOGV("setRotation: %d", val);
    mParameters.set(CameraParameters::KEY_ROTATION, val);

    if (mVtMode)
        return nativeSetParameters(CAM_CID_ROTATION, val);

    return NO_ERROR;
}

status_t ISecCameraHardware::setPreviewFrameRate(const CameraParameters &params)
{
    int val = params.getPreviewFrameRate();
    int prevVal = mParameters.getPreviewFrameRate();
    if (val == -1 || prevVal == val)
        return NO_ERROR;

    if (CC_UNLIKELY(val < 0 || val > (mMaxFrameRate / 1000) )) {
        ALOGE("setPreviewFrameRate: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

    ALOGV("setPreviewFrameRate: %d", val);
    mFrameRate = val * 1000;
    mParameters.setPreviewFrameRate(val);

    return NO_ERROR;
}

status_t ISecCameraHardware::setSceneMode(const CameraParameters &params)
{
    const char *str = params.get(CameraParameters::KEY_SCENE_MODE);
    const char *prevStr = mParameters.get(CameraParameters::KEY_SCENE_MODE);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;

retry:
    val = SecCameraParameters::lookupAttr(sceneModes, ARRAY_SIZE(sceneModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setSceneMode: warning, not supported value(%s)", str);
#if 0
        str = reinterpret_cast<const char*>(sceneModes[0].desc);
        goto retry;
#else
        return BAD_VALUE;
#endif	/* FOR HAL TEST */
    }

    ALOGV("setSceneMode: %s", str);
    mSceneMode = (cam_scene_mode)val;
    mParameters.set(CameraParameters::KEY_SCENE_MODE, str);

    return nativeSetParameters(CAM_CID_SCENE_MODE, val);
}

#if VENDOR_FEATURE
#ifdef BURST_SHOT_SUPPORT
status_t ISecCameraHardware::setBurstSavePath(const CameraParameters& params)
{
    const char *str  = params.get(CameraParameters::KEY_CAPTURE_BURST_FILEPATH);
    const char *prevStr = mParameters.get(CameraParameters::KEY_CAPTURE_BURST_FILEPATH);
    ALOGV("setBurstSavePath ~~~~~~~~~~~~~~ str : %s, prevStr : %s",str, prevStr);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    ALOGD("setBurstSavePath: %s", str);
    mParameters.set(CameraParameters::KEY_CAPTURE_BURST_FILEPATH, str);

    return NO_ERROR;
}

char* ISecCameraHardware::getBurstSavePath(void)
{
    const char *str  = mParameters.get(CameraParameters::KEY_CAPTURE_BURST_FILEPATH);
    ALOGV("getBurstSavePath ~~~~~~~~~~~~~~ str : %s",str);

    return (char*)str;
}
#endif

status_t ISecCameraHardware::setCapturemode(const CameraParameters &params)
{
    const char *str  = params.get(CameraParameters::KEY_CAPTURE_MODE);
    const char *prevStr = mParameters.get(CameraParameters::KEY_CAPTURE_MODE);
    const int faceDetection = getFaceDetection();

#if 0
    /* Capture mode should be set after error case to prevent ISP malfunction. */
    if (str == NULL /* || (prevStr && !strcmp(str, prevStr)) */)
#else
    /* 14.02.11. heechul.,
       Continuous duplicate capture mode setting makes halt when auto focus.
       FD blink is a kind of capture mode. So although capture mode is same,
       if FD mode changes from Blink or to Blink, capture mode must change.
       */
    if (str == NULL || (prevStr && !strcmp(str, prevStr))) {
        if((faceDetection == mFaceDetectionStatus) ||
           ((faceDetection != V4L2_FACE_DETECTION_BLINK) &&
            (mFaceDetectionStatus != V4L2_FACE_DETECTION_BLINK)))
            return NO_ERROR;
    }
#endif

    if(str != NULL) {
        ALOGD("setCapturemode: str: %s, prevStr: %s, FDmode: %d",str, prevStr, faceDetection);

        mCaptureMode = SecCameraParameters::lookupAttr(captureMode, ARRAY_SIZE(captureMode), str);
        mParameters.set(CameraParameters::KEY_CAPTURE_MODE, str);
    }
    mFaceDetectionStatus = faceDetection;

    if (mCameraId == CAMERA_FACING_BACK)
        if(faceDetection == V4L2_FACE_DETECTION_BLINK) {
            ALOGD("blink");
            return nativeSetParameters(CAM_CID_SET_CAPTURE_MODE, RUNNING_MODE_BLINK);
        } else {
            ALOGD("no blink");
            return nativeSetParameters(CAM_CID_SET_CAPTURE_MODE, mCaptureMode);
        }
    else
        return NO_ERROR;
}

status_t ISecCameraHardware::setAFLED(const CameraParameters& params)
{
	//CameraParameters::KEY_AF_LAMP = "af-lamp"
    const char *str  = params.get("af-lamp");
    const char *prevStr = mParameters.get("af-lamp");
    //ALOGV("setAFLED ~~~~~~~~~~~~~~ str : %s, prevStr : %s",str, prevStr);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(AFLEDValues, ARRAY_SIZE(AFLEDValues), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setAFLED: warning, not supported value(%s)", str);
        return NO_ERROR;
    }

    ALOGD("setAFLED: %s", str);
    mParameters.set("af-lamp", str);

    nativeSetParameters(CAM_CID_AF_LED, val);

    return NO_ERROR;
}

status_t ISecCameraHardware::setTimerMode(const CameraParameters& params)
{
    const char *str  = params.get("timer");
    const char *prevStr = mParameters.get("timer");
    //ALOGV("setTimerMode ~~~~~~~~~~~~~~ str : %s, prevStr : %s",str, prevStr);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(timerLEDValues, ARRAY_SIZE(timerLEDValues), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setTimerMode: warning, not supported value(%s)", str);
        return NO_ERROR;
    }

    ALOGD("setTimerMode: %s", str);
    mParameters.set("timer", str);
    mTimerSet = val;

    nativeSetParameters(CAM_CID_TIMER_MODE, val);

    return NO_ERROR;
}

status_t ISecCameraHardware::setFocusAreaModes(const CameraParameters& params)
{
    const char *str  = params.get(CameraParameters::KEY_FOCUS_AREA_MODE);
    const char *prevStr = mParameters.get(CameraParameters::KEY_FOCUS_AREA_MODE);
    //ALOGV("setFocusAreaModes ~~~~~~~~~~~~~~ str : %s, prevStr : %s",str, prevStr);

    if (str == NULL /* || (prevStr && !strcmp(str, prevStr)) */)
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(focusareaModes, ARRAY_SIZE(focusareaModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setFocusAreaModes: warning, not supported value(%s)", str);
        return NO_ERROR;
    }

    ALOGD("setFocusAreaModes: %s", str);

    mFocusArea = (cam_focus_area)val;

    mParameters.set(CameraParameters::KEY_FOCUS_AREA_MODE, str);

    return nativeSetParameters(CAM_CID_FOCUS_AREA_MODE, val);
}

status_t ISecCameraHardware::setFaceDetection(const CameraParameters& params)
{
    const char *str  = params.get(CameraParameters::KEY_FACEDETECT);
    const char *prevStr = mParameters.get(CameraParameters::KEY_FACEDETECT);
    //ALOGV("setFaceDetection ~~~~~~~~~~~~~~ str : %s, prevStr : %s",str, prevStr);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(facedetectionModes, ARRAY_SIZE(facedetectionModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setFaceDetection: warning, not supported value(%s)", str);
        return NO_ERROR;
    }

    ALOGD("setFaceDetection: %s", str);
    mParameters.set(CameraParameters::KEY_FACEDETECT, str);

#if 1
    if (mCameraId == CAMERA_FACING_BACK) {
        if (val == V4L2_FACE_DETECTION_NORMAL) {
            ALOGD("setFaceDetection: start getting the FD Info");
            nativeSetParameters(CAM_CID_SET_FD_FOCUS_SELECT, 0x2);

            mSelfShotFDReading = 1;
        } else {
            ALOGD("setFaceDetection: top getting the FD Info");
            nativeSetParameters(CAM_CID_SET_FD_FOCUS_SELECT, 0x0);

            roi_x_pos = 0;
            roi_y_pos = 0;
            mSelfShotFDReading = 0;
        }
    }
#endif

    return nativeSetParameters(CAM_CID_FACE_DETECTION, val);
}


int ISecCameraHardware::getFaceDetection(void)
{
    const char *str  = mParameters.get(CameraParameters::KEY_FACEDETECT);
    //ALOGV("getFaceDetection ~~~~~~~~~~~~~~ str : %s",str);

    int val;
retry:
    val = SecCameraParameters::lookupAttr(facedetectionModes, ARRAY_SIZE(facedetectionModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("getFaceDetection: warning, not supported value(%s)", str);
        return NO_ERROR;
    }

    ALOGV("getFaceDetection value: %d", val);

    return val;
}


status_t ISecCameraHardware::setROIBox(const CameraParameters& params)
{
    const char *str_x  = params.get(CameraParameters::KEY_CURRENT_ROI_LEFT);
    const char *str_y  = params.get(CameraParameters::KEY_CURRENT_ROI_TOP);

    const char *str_width  = params.get(CameraParameters::KEY_CURRENT_ROI_WIDTH);
    const char *str_height  = params.get(CameraParameters::KEY_CURRENT_ROI_HEIGHT);


    if(str_x == NULL && str_y == NULL && str_width == NULL && str_height == NULL)
        return NO_ERROR;

retry:
#if 0
    val = SecCameraParameters::lookupAttr(facedetectionModes, ARRAY_SIZE(facedetectionModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setROIBox: warning, not supported value(%s)", str);
        return NO_ERROR;
    }
#endif

    ALOGD("setROIBox: x[%s], y[%s]", str_x, str_y);
    ALOGD("setROIBox: width[%s], height[%s]", str_width, str_height);


    if(str_x != NULL && str_y != NULL) {
        roi_x_pos = (int)atoi(str_x);
        roi_y_pos = (int)atoi(str_y);
        ALOGD("setROIBox: roi_x_pos[%d], roi_y_pos[%d]", roi_x_pos, roi_y_pos);

        uint32_t roi_pos_data = (roi_x_pos  << 16) | (roi_y_pos & 0x0FFFF);

        nativeSetParameters(CAM_CID_SET_ROI_BOX, roi_pos_data);
    }

    if(str_width != NULL && str_height != NULL) {
        roi_width = (int)atoi(str_width);
        roi_height = (int)atoi(str_height);
        ALOGD("setROIBox: roi_width[%d], height[%d]", roi_width, roi_height);

        uint32_t roi_wid_hei_data = (roi_width  << 16) | (roi_height & 0x0FFFF);

        nativeSetParameters(CAM_CID_SET_ROI_BOX_WIDTH_HEIGHT, roi_wid_hei_data);
    }

    return NO_ERROR;
}
#endif /* VENDOR_FEATURE */

/* -------------------Focus Area STARTS here---------------------------- */
status_t ISecCameraHardware::findCenter(struct FocusArea *focusArea,
        struct FocusPoint *center)
{
    /* range check */
    if ((focusArea->top > focusArea->bottom) || (focusArea->right < focusArea->left)) {
        ALOGE("findCenter: Invalid value range");
        return -EINVAL;
    }

    center->x = (focusArea->left + focusArea->right) / 2;
    center->y = (focusArea->top + focusArea->bottom) / 2;

    /* ALOGV("%s: center point (%d, %d)", __func__, center->x, center->y); */
    return NO_ERROR;
}

status_t ISecCameraHardware::normalizeArea(struct FocusPoint *center)
{
    struct FocusPoint tmpPoint;
    size_t hRange, vRange;
    double hScale, vScale;

    tmpPoint.x = center->x;
    tmpPoint.y = center->y;

    /* ALOGD("%s: before x = %d, y = %d", __func__, tmpPoint.x, tmpPoint.y); */

    hRange = FOCUS_AREA_RIGHT - FOCUS_AREA_LEFT;
    vRange = FOCUS_AREA_BOTTOM - FOCUS_AREA_TOP;
    hScale = (double)mPreviewSize.height / (double) hRange;
    vScale = (double)mPreviewSize.width / (double) vRange;

    /* Nomalization */
    /* ALOGV("normalizeArea: mPreviewSize.width = %d, mPreviewSize.height = %d",
            mPreviewSize.width, mPreviewSize.height);
     */

    tmpPoint.x = (center->x + vRange / 2) * vScale;
    tmpPoint.y = (center->y + hRange / 2) * hScale;

    center->x = tmpPoint.x;
    center->y = tmpPoint.y;

    if (center->x == 0 && center->y == 0) {
        ALOGE("normalizeArea: Invalid focus center point");
        return -EINVAL;
    }

    return NO_ERROR;
}

status_t ISecCameraHardware::checkArea(ssize_t top,
        ssize_t left,
        ssize_t bottom,
        ssize_t right,
        ssize_t weight)
{
    /* Handles the invalid regin corner case. */
    if ((0 == top) && (0 == left) && (0 == bottom) && (0 == right) && (0 == weight)) {
        ALOGE("checkArea: error, All values are zero");
        return NO_ERROR;
    }

    if ((FOCUS_AREA_WEIGHT_MIN > weight) || (FOCUS_AREA_WEIGHT_MAX < weight)) {
        ALOGE("checkArea: error, Camera area weight is invalid %d", weight);
        return -EINVAL;
    }

    if ((FOCUS_AREA_TOP > top) || (FOCUS_AREA_BOTTOM < top)) {
        ALOGE("checkArea: error, Camera area top coordinate is invalid %d", top );
        return -EINVAL;
    }

    if ((FOCUS_AREA_TOP > bottom) || (FOCUS_AREA_BOTTOM < bottom)) {
        ALOGE("checkArea: error, Camera area bottom coordinate is invalid %d", bottom );
        return -EINVAL;
    }

    if ((FOCUS_AREA_LEFT > left) || (FOCUS_AREA_RIGHT < left)) {
        ALOGE("checkArea: error, Camera area left coordinate is invalid %d", left );
        return -EINVAL;
    }

    if ((FOCUS_AREA_LEFT > right) || (FOCUS_AREA_RIGHT < right)) {
        ALOGE("checkArea: error, Camera area right coordinate is invalid %d", right );
        return -EINVAL;
    }

    if (left >= right) {
        ALOGE("checkArea: error, Camera area left larger than right");
        return -EINVAL;
    }

    if (top >= bottom) {
        ALOGE("checkArea: error, Camera area top larger than bottom");
        return -EINVAL;
    }

    return NO_ERROR;
}

/* TODO : muliple focus area is not supported yet */
status_t ISecCameraHardware::parseAreas(const char *area,
        size_t areaLength,
        struct FocusArea *focusArea,
        int *num_areas)
{
    status_t ret = NO_ERROR;
    char *ctx;
    char *pArea = NULL;
    char *pEnd = NULL;
    const char *startToken = "(";
    const char endToken = ')';
    const char sep = ',';
    ssize_t left, top, bottom, right, weight;
    char *tmpBuffer = NULL;

    if (( NULL == area ) || ( 0 >= areaLength)) {
        ALOGE("parseAreas: error, area is NULL or areaLength is less than 0");
        return -EINVAL;
    }

    tmpBuffer = (char *)malloc(areaLength);
    if (NULL == tmpBuffer) {
        ALOGE("parseAreas: error, tmpBuffer is NULL");
        return -ENOMEM;
    }

    memcpy(tmpBuffer, area, areaLength);

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

    do {
		char *pStart = NULL;
        pStart = pArea;
        if (NULL == pStart) {
            ALOGE("parseAreas: error, Parsing of the left area coordinate failed!");
            ret = -EINVAL;
            break;
        } else {
            left = static_cast<ssize_t>(strtol(pStart, &pEnd, 10));
        }

        if (sep != *pEnd) {
            ALOGE("parseAreas: error, Parsing of the top area coordinate failed!");
            ret = -EINVAL;
            break;
        } else {
            top = static_cast<ssize_t>(strtol(pEnd + 1, &pEnd, 10));
        }

        if (sep != *pEnd) {
            ALOGE("parseAreas: error, Parsing of the right area coordinate failed!");
            ret = -EINVAL;
            break;
        } else {
            right = static_cast<ssize_t>(strtol(pEnd + 1, &pEnd, 10));
        }

        if (sep != *pEnd) {
            ALOGE("parseAreas: error, Parsing of the bottom area coordinate failed!");
            ret = -EINVAL;
            break;
        } else {
            bottom = static_cast<ssize_t>(strtol(pEnd + 1, &pEnd, 10));
        }

        if (sep != *pEnd) {
            ALOGE("parseAreas: error, Parsing of the weight area coordinate failed!");
            ret = -EINVAL;
            break;
        } else {
            weight = static_cast<ssize_t>(strtol(pEnd + 1, &pEnd, 10));
        }

        if (endToken != *pEnd) {
            ALOGE("parseAreas: error, malformed area!");
            ret = -EINVAL;
            break;
        }

        ret = checkArea(top, left, bottom, right, weight);
        if (NO_ERROR != ret)
            break;

        /*
        ALOGV("parseAreas: Area parsed [%dx%d, %dx%d] %d",
                ( int ) left,
                ( int ) top,
                ( int ) right,
                ( int ) bottom,
                ( int ) weight);
         */

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

        focusArea->left = (int)left;
        focusArea->top = (int)top;
        focusArea->right = (int)right;
        focusArea->bottom = (int)bottom;
        focusArea->weight = (int)weight;
        (*num_areas)++;
    } while ( NULL != pArea );

    if (NULL != tmpBuffer)
        free(tmpBuffer);

    return ret;
}

/* TODO : muliple focus area is not supported yet */
status_t ISecCameraHardware::setFocusAreas(const CameraParameters &params)
{
    if (!IsAutoFocusSupported())
        return NO_ERROR;

    const char *str = params.get(CameraParameters::KEY_FOCUS_AREAS);
    const char *prevStr = mParameters.get(CameraParameters::KEY_FOCUS_AREAS);
    if ((str == NULL) || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    struct FocusArea focusArea;
    struct FocusPoint center;
    int err, num_areas = 0;
    const char *maxFocusAreasStr = params.get(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS);
    if (!maxFocusAreasStr) {
        ALOGE("setFocusAreas: error, KEY_MAX_NUM_FOCUS_AREAS is NULL");
        return NO_ERROR;
    }

    int maxFocusAreas = atoi(maxFocusAreasStr);
    if (!maxFocusAreas) {
        ALOGD("setFocusAreas: FocusAreas is not supported");
        return NO_ERROR;
    }

    /* Focus area parse here */
    err = parseAreas(str, (strlen(str) + 1), &focusArea, &num_areas);
    if (CC_UNLIKELY(err < 0)) {
        ALOGE("setFocusAreas: error, parseAreas %s", str);
        return BAD_VALUE;
    }
    if (CC_UNLIKELY(num_areas > maxFocusAreas)) {
        ALOGE("setFocusAreas: error, the number of areas is more than max");
        return BAD_VALUE;
    }

    /* find center point */
    err = findCenter(&focusArea, &center);
    if (CC_UNLIKELY(err < 0)) {
        ALOGE("setFocusAreas: error, findCenter");
        return BAD_VALUE;
    }

    /* Normalization */
    err = normalizeArea(&center);
    if (err < 0) {
        ALOGE("setFocusAreas: error, normalizeArea");
        return BAD_VALUE;
    }

    ALOGD("setFocusAreas: FocusAreas(%s) to (%d, %d)", str, center.x, center.y);

    mParameters.set(CameraParameters::KEY_FOCUS_AREAS, str);

//#ifdef ENABLE_TOUCH_AF
    if (CC_UNLIKELY(mFocusArea != V4L2_FOCUS_AREA_TRACKING)) {
        err = nativeSetParameters(CAM_CID_SET_TOUCH_AF_POSX, center.x);
        if (CC_UNLIKELY(err < 0)) {
            ALOGE("setFocusAreas: error, SET_TOUCH_AF_POSX");
            return UNKNOWN_ERROR;
        }

        err = nativeSetParameters(CAM_CID_SET_TOUCH_AF_POSY, center.y);
        if (CC_UNLIKELY(err < 0)) {
            ALOGE("setFocusAreas: error, SET_TOUCH_AF_POSX");
            return UNKNOWN_ERROR;
        }

        return nativeSetParameters(CAM_CID_SET_TOUCH_AF, 1);
    } else{
        return nativeSetParameters(CAM_CID_SET_TOUCH_AF, 0);
    }
//#endif

    return NO_ERROR;
}

/* -------------------Focus Area ENDS here---------------------------- */
#if VENDOR_FEATURE
status_t ISecCameraHardware::setWeather(const CameraParameters& params)
{
	int val = params.getInt(CameraParameters::KEY_WEATHER);
	int prevVal = mParameters.getInt(CameraParameters::KEY_WEATHER);
	if (prevVal == val)
		return NO_ERROR;

	if (CC_UNLIKELY(val < 0 || val > 5)) {
		ALOGE("setWeather: error, invalid value(%d)", val);
		return BAD_VALUE;
	}

	ALOGD("setWeather: %d", val);

	mWeather = val;
	mParameters.set(CameraParameters::KEY_WEATHER, val);

	return NO_ERROR;
}

status_t ISecCameraHardware::setCityId(const CameraParameters& params)
{
	long long int val = params.getInt64(CameraParameters::KEY_CITYID);

	if (val <= 0) {
		ALOGD("setCityid : null value");
		mCityId = 0;
		mParameters.set(CameraParameters::KEY_CITYID, 0);
	} else {
		mCityId = val;
		const char *v = params.get(CameraParameters::KEY_CITYID);
		mParameters.set(CameraParameters::KEY_CITYID, v);
		ALOGD("setCityid: %s", v);
	}

	return NO_ERROR;
}

status_t ISecCameraHardware::setBracketAEBvalue(const CameraParameters& params)
{
    int val = params.getInt(CameraParameters::KEY_BRACKET_AEB);
    int prevVal = mParameters.getInt(CameraParameters::KEY_BRACKET_AEB);

    /* AEB Value : 1~6 */
    if (val > 6 || val < 0 || prevVal == val)
        return NO_ERROR;

    ALOGD("setBracketAEBvalue: %d", val);
    mParameters.set(CameraParameters::KEY_BRACKET_AEB, val);

    return nativeSetParameters(CAM_CID_BRACKET_AEB, val);
}

status_t ISecCameraHardware::setIso(const CameraParameters &params)
{
#if 0
    const char *str = params.get(SecCameraParameters::KEY_ISO);
    const char *prevStr = mParameters.get(SecCameraParameters::KEY_ISO);
    if (str == NULL || (prevStr && !strcmp(str, prevStr))) {
        ALOGD("setIso: 1 str:%s, prevStr:%s", str, prevStr);
        return NO_ERROR;
    }
    if (prevStr == NULL && !strcmp(str, isos[0].desc)) {  /* default */
        ALOGD("setIso: 2 str:%s, prevStr:%s", str, prevStr);
        return NO_ERROR;
    }

    int val;
retry:
    val = SecCameraParameters::lookupAttr(isos, ARRAY_SIZE(isos), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setIso: warning, not supported value(%s)", str);
        /* str = reinterpret_cast<const char*>(isos[0].desc);
        goto retry;
         */
        return BAD_VALUE;
    }

    ALOGD("setIso: %s", str);
    mParameters.set(SecCameraParameters::KEY_ISO, str);

    return nativeSetParameters(CAM_CID_ISO, val);
#else
    const char *str = params.get(CameraParameters::KEY_ISO);
    const char *prevStr = mParameters.get(CameraParameters::KEY_ISO);
    if (str == NULL || (prevStr && !strcmp(str, prevStr))) {
        return NO_ERROR;
    }
    if (prevStr == NULL && !strcmp(str, isos[0].desc)) {  /* default */
        return NO_ERROR;
    }

    int val;
retry:
    val = SecCameraParameters::lookupAttr(isos, ARRAY_SIZE(isos), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setIso: warning, not supported value(%s)", str);
        /* str = reinterpret_cast<const char*>(isos[0].desc);
        goto retry;
         */
        return BAD_VALUE;
    }

    ALOGD("setIso: %s", str);
    mParameters.set(CameraParameters::KEY_ISO, str);

    return nativeSetParameters(CAM_CID_ISO, val);

#endif
}
#endif /* VENDOR_FEATURE */

status_t ISecCameraHardware::setBrightness(const CameraParameters &params)
{
    int val;
    if (CC_LIKELY(mSceneMode == SCENE_MODE_NONE)) {
        val = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
    } else {
        switch (mSceneMode) {
        case SCENE_MODE_BEACH_SNOW:
            val = 2;
            break;

        default:
            val = 0;
            break;
        }
    }

    int prevVal = mParameters.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
    int max = mParameters.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
    int min = mParameters.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
    if (prevVal == val)
        return NO_ERROR;

    if (CC_UNLIKELY(val < min || val > max)) {
        ALOGE("setBrightness: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

    ALOGV("setBrightness: %d", val);
    mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, val);

    if(mPASMMode == MODE_SNOW) {
        ALOGD("Current is snow mode. AP don't set EV value when snow-shot.");
        return NO_ERROR;
    } else {
        return nativeSetParameters(CAM_CID_BRIGHTNESS, val);
    }
}

status_t ISecCameraHardware::setWhiteBalance(const CameraParameters &params)
{
    const char *str;
    if (mSamsungApp) {
        if (CC_LIKELY(mSceneMode == SCENE_MODE_NONE)) {
            str = params.get(CameraParameters::KEY_WHITE_BALANCE);
        } else {
            switch (mSceneMode) {
            case SCENE_MODE_SUNSET:
            case SCENE_MODE_CANDLE_LIGHT:
                str = CameraParameters::WHITE_BALANCE_DAYLIGHT;
                break;

            case SCENE_MODE_DUSK_DAWN:
                str = CameraParameters::WHITE_BALANCE_FLUORESCENT;
                break;

            default:
                str = CameraParameters::WHITE_BALANCE_AUTO;
                break;
            }
        }
    } else
        str = params.get(CameraParameters::KEY_WHITE_BALANCE);

    const char *prevStr = mParameters.get(CameraParameters::KEY_WHITE_BALANCE);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(whiteBalances, ARRAY_SIZE(whiteBalances), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setWhiteBalance: warning, not supported value(%s)", str);
        str = reinterpret_cast<const char*>(whiteBalances[0].desc);
        goto retry;
    }

    ALOGV("setWhiteBalance: %s", str);
    mParameters.set(CameraParameters::KEY_WHITE_BALANCE, str);

    return nativeSetParameters(CAM_CID_WHITE_BALANCE, val);
}

status_t ISecCameraHardware::setFlash(const CameraParameters &params)
{
    if (!IsFlashSupported())
        return NO_ERROR;

    const char *str;
    if (mSamsungApp) {
        if (CC_LIKELY(mSceneMode == SCENE_MODE_NONE)) {
            str = params.get(CameraParameters::KEY_FLASH_MODE);
        } else {
            switch (mSceneMode) {
            case SCENE_MODE_PORTRAIT:
            case SCENE_MODE_PARTY_INDOOR:
            case SCENE_MODE_BACK_LIGHT:
            case SCENE_MODE_TEXT:
                str = params.get(CameraParameters::KEY_FLASH_MODE);
                break;

            default:
                str = CameraParameters::FLASH_MODE_OFF;
                break;
            }
        }
    } else {
        str = params.get(CameraParameters::KEY_FLASH_MODE);
    }

    const char *prevStr = mParameters.get(CameraParameters::KEY_FLASH_MODE);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(flashModes, ARRAY_SIZE(flashModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setFlash: warning, not supported value(%s)", str);
        return BAD_VALUE; /* return BAD_VALUE if invalid parameter */
    }

    ALOGV("setFlash: %s", str);
    mFlashMode = (cam_flash_mode)val;
    mParameters.set(CameraParameters::KEY_FLASH_MODE, str);

    return nativeSetParameters(CAM_CID_FLASH, val);
}

status_t ISecCameraHardware::setMetering(const CameraParameters &params)
{
    const char *str;
    if (CC_LIKELY(mSceneMode == SCENE_MODE_NONE)) {
        str = params.get(SecCameraParameters::KEY_METERING);
    } else {
        switch (mSceneMode) {
        case SCENE_MODE_LANDSCAPE:
            str = SecCameraParameters::METERING_MATRIX;
            break;

        case SCENE_MODE_BACK_LIGHT:
            if (mFlashMode == V4L2_FLASH_MODE_OFF)
                str = SecCameraParameters::METERING_SPOT;
            else
                str = SecCameraParameters::METERING_CENTER;
            break;

        default:
            str = SecCameraParameters::METERING_CENTER;
            break;
        }
    }

    const char *prevStr = mParameters.get(SecCameraParameters::KEY_METERING);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;
    if (prevStr == NULL && !strcmp(str, meterings[0].desc)) /* default */
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(meterings, ARRAY_SIZE(meterings), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setMetering: warning, not supported value(%s)", str);
        str = reinterpret_cast<const char*>(meterings[0].desc);
        goto retry;
    }

    ALOGD("setMetering: %s", str);
    mParameters.set(SecCameraParameters::KEY_METERING, str);

    return nativeSetParameters(CAM_CID_METERING, val);
}

status_t ISecCameraHardware::setMeteringAreas(const CameraParameters &params)
{
    const char *str = params.get(CameraParameters::KEY_METERING_AREAS);
    const char *prevStr = mParameters.get(CameraParameters::KEY_METERING_AREAS);
     if ((str == NULL) || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    /* Metering area use same strcut with Focus area */
    struct FocusArea meteringArea;
    int err, num_areas = 0;
    const char *maxMeteringAreasStr = params.get(CameraParameters::KEY_MAX_NUM_METERING_AREAS);
    if (!maxMeteringAreasStr) {
        ALOGE("setMeteringAreas: error, KEY_MAX_NUM_METERING_AREAS is NULL");
        return NO_ERROR;
    }

    int maxMeteringAreas = atoi(maxMeteringAreasStr);
    if (!maxMeteringAreas) {
        ALOGD("setMeteringAreas: FocusAreas is not supported");
        return NO_ERROR;
    }

    /* Metering area parse and check(max value) here */
    err = parseAreas(str, (strlen(str) + 1), &meteringArea, &num_areas);
    if (CC_UNLIKELY(err < 0)) {
        ALOGE("setMeteringAreas: error, parseAreas %s", str);
        return BAD_VALUE;
    }
    if (CC_UNLIKELY(num_areas > maxMeteringAreas)) {
        ALOGE("setMeteringAreas: error, the number of areas is more than max");
        return BAD_VALUE;
    }

    ALOGD("setMeteringAreas = %s\n", str);
    mParameters.set(CameraParameters::KEY_METERING_AREAS, str);

    return NO_ERROR;
}

status_t ISecCameraHardware::setFocusMode(const CameraParameters &params)
{
	status_t Ret = NO_ERROR;

    const char *str = params.get(CameraParameters::KEY_FOCUS_MODE);
    const char *prevStr = mParameters.get(CameraParameters::KEY_FOCUS_MODE);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int count, val;
    const cam_strmap_t *focusModes;

    if (mCameraId == CAMERA_FACING_BACK) {
        count = ARRAY_SIZE(backFocusModes);
        focusModes = backFocusModes;
    } else {
        count = ARRAY_SIZE(frontFocusModes);
        focusModes = frontFocusModes;
    }

retry:
    val = SecCameraParameters::lookupAttr(focusModes, count, str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setFocusMode: warning, not supported value(%s)", str);
        return BAD_VALUE; /* return BAD_VALUE if invalid parameter */
    }

    ALOGD("setFocusMode: %s", str);
    mFocusMode = (cam_focus_mode)val;
    mParameters.set(CameraParameters::KEY_FOCUS_MODE, str);
    if (val == V4L2_FOCUS_MODE_MACRO) {
        mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
                B_KEY_MACRO_FOCUS_DISTANCES_VALUE);
    } else {
        mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
                B_KEY_NORMAL_FOCUS_DISTANCES_VALUE);
    }


    if (mCameraId == CAMERA_FACING_BACK) {
        if (val == V4L2_FOCUS_MODE_MACRO) {
            mFocusRange = V4L2_FOCUS_RANGE_MACRO;
            nativeSetParameters(CAM_CID_FOCUS_RANGE, mFocusRange);
        } else if (val == V4L2_FOCUS_MODE_AUTO) {
            if (mMovieMode) {
                mFocusRange = V4L2_FOCUS_RANGE_AUTO_MACRO;
                nativeSetParameters(CAM_CID_FOCUS_RANGE, mFocusRange);
            } else {
                mFocusRange = V4L2_FOCUS_RANGE_AUTO;
                nativeSetParameters(CAM_CID_FOCUS_RANGE, mFocusRange);
            }
        }
    }

#if 0
    if (mCameraId == CAMERA_FACING_BACK) {
        if (val == V4L2_FOCUS_MODE_SELFSHOT) {
            ALOGD("setFocusMode: FOCUS_MODE_SELFSHOT");
            nativeSetParameters(CAM_CID_SET_FD_FOCUS_SELECT, 0x2);

            setFaceDetection(V4L2_FACE_DETECTION_NORMAL);
            mSelfShotFDReading = 1;
        } else {
            ALOGD("setFocusMode: not FOCUS_MODE_SELFSHOT");
            nativeSetParameters(CAM_CID_SET_FD_FOCUS_SELECT, 0x0);

            //setFaceDetection(V4L2_FACE_DETECTION_OFF);
            roi_x_pos = 0;
            roi_y_pos = 0;
            mSelfShotFDReading = 0;
        }
    }
#endif
    return nativeSetParameters(CAM_CID_FOCUS_MODE, val);
}

status_t ISecCameraHardware::setEffect(const CameraParameters &params)
{
    const char *str = params.get(CameraParameters::KEY_EFFECT);
    const char *prevStr = mParameters.get(CameraParameters::KEY_EFFECT);
    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
retry:
    val = SecCameraParameters::lookupAttr(effects, ARRAY_SIZE(effects), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setEffect: warning, not supported value(%s)", str);
#if 0
        str = reinterpret_cast<const char*>(effects[0].desc);
        goto retry;
#else
        return BAD_VALUE;
#endif	/* FOR HAL TEST */
    }

    ALOGV("setEffect: %s", str);
    mParameters.set(CameraParameters::KEY_EFFECT, str);

    return nativeSetParameters(CAM_CID_EFFECT, val);
}

status_t ISecCameraHardware::setZoom(const CameraParameters &params)
{
    if (!mZoomSupport)
        return NO_ERROR;

    int val = params.getInt(CameraParameters::KEY_ZOOM);
    int prevVal = mParameters.getInt(CameraParameters::KEY_ZOOM);
    int err;

    if (val == -1 || prevVal == val)
        return NO_ERROR;

    int max = params.getInt(CameraParameters::KEY_MAX_ZOOM);
    if (CC_UNLIKELY(val < 0 || val > max)) {
        ALOGE("setZoom: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

#if VENDOR_FEATURE
    if (prevVal != val ) {
	    ALOGD("setZoom succ: %d->%d, curr:%d/%d", prevVal, val, mZoomCurrLevel, max);
	    mZoomSetVal = val;
     	    mParameters.set(CameraParameters::KEY_ZOOM, val);

	    if (val != mZoomCurrLevel && !mZoomStatus ) {
		    err = nativeSetParameters(CAM_CID_ZOOM, val);
		    if (err < 0) {
			    ALOGE("%s: setZoom failed", __func__);
			    return err;
		    }
	    }
    }

    return NO_ERROR;
#else
    mParameters.set(CameraParameters::KEY_ZOOM, val);

    if (mEnableDZoom)
        /* Set AP zoom ratio */
        return nativeSetZoomRatio(val);
    else
        /* Set ISP/sensor zoom ratio */
        return nativeSetParameters(CAM_CID_ZOOM, val);
#endif
}

status_t ISecCameraHardware::setDzoom(const CameraParameters& params)
{
    int val = params.getInt("dzoom");
    int prevVal = mParameters.getInt("dzoom");
    int err;

    if (prevVal == val)
        return NO_ERROR;
    if (val < V4L2_ZOOM_LEVEL_0 || val >= 12) {
        ALOGE("invalid value for DZOOM val = %d", val);
        return BAD_VALUE;
    }

    ALOGD("setDZoom LEVEL %d->%d", prevVal, val);
    mParameters.set("dzoom", val);

    err = nativeSetParameters(CAM_CID_DZOOM, val);
    if (err < 0) {
        ALOGE("%s: setDZoom failed", __func__);
        return err;
    }

    return NO_ERROR;
}

status_t ISecCameraHardware::setZoomActionMethod(const CameraParameters& params)
{
    /* 0 : key, 1: zoom-ring */
    int err = 0;
    int actionMethod = params.getInt("zoom-ring" /*CameraParameters::KEY_ZOOM_RING*/);
    int prevActionMethod= mParameters.getInt("zoom-ring" /*CameraParameters::KEY_ZOOM_RING*/);

    if ((actionMethod == prevActionMethod) ||
        (actionMethod < 0))
        return NO_ERROR;

    mParameters.set("zoom-ring" /*CameraParameters::KEY_ZOOM_RING*/, actionMethod);
    mZoomActionMethod = actionMethod;

    err = nativeSetParameters(CAM_CID_CAMERA_ZOOM_ACTION_METHOD, actionMethod);
    if (err < 0) {
        ALOGE("%s : setZoomActionMethod failed", __func__);
        return err;
    }
    return NO_ERROR;
}

#if VENDOR_FEATURE
status_t ISecCameraHardware::setOpticalZoomCtrl(const CameraParameters& params)
{
    const char *str = params.get(CameraParameters::KEY_ZOOM_ACTION);
    const char *prevStr = mParameters.get(CameraParameters::KEY_ZOOM_ACTION);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;

    val = SecCameraParameters::lookupAttr(opticalzoomValues, ARRAY_SIZE(opticalzoomValues), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setOpticalZoomCtrl: warning, not supported value(%s)", str);
        return NO_ERROR;
    }

    ALOGD("setOpticalZoomCtrl: %s", str);

    mParameters.set(CameraParameters::KEY_ZOOM_ACTION, str);

    if (val == V4L2_OPTICAL_ZOOM_STOP) {
        // Initialize Zoom Speed Value
        mParameters.set("zoom-speed", -1);
    }
#ifdef ZOOM_CTRL_THREAD
    zoom_cmd = val;
    return NO_ERROR;
#else
    return nativeSetParameters(CAM_CID_OPTICAL_ZOOM_CTRL, val);
#endif
}
#endif /* VENDOR_FEATURE */

status_t ISecCameraHardware::setZoomSpeed(const CameraParameters& params)
{
    int speed = params.getInt("zoom-speed");
    int prevSpeed = mParameters.getInt("zoom-speed");

    if ( speed == -1 || speed == prevSpeed )
        return NO_ERROR;

	mParameters.set("zoom-speed", speed);

    return nativeSetParameters(CAM_CID_CAMERA_ZOOM_SPEED, speed);
}

#if VENDOR_FEATURE
status_t ISecCameraHardware::setSmartZoommode(const CameraParameters& params)
{
    const char *str = params.get("smartzoom"/*CameraParameters::KEY_SMART_ZOOM*/);
    const char *prevStr = mParameters.get("smartzoom"/*CameraParameters::KEY_SMART_ZOOM*/);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
    val = SecCameraParameters::lookupAttr(SmartZoomModes, ARRAY_SIZE(SmartZoomModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setSmartZoommode: warning, not supported value(%s)", str);
        return NO_ERROR;
    }

    ALOGD("setSmartZoommode: %s", str);
    mParameters.set("smartzoom"/*CameraParameters::KEY_SMART_ZOOM*/, str);

    return nativeSetParameters(CAM_CID_SMART_ZOOM, val);
}
#endif /* VENDOR_FEATURE */

status_t ISecCameraHardware::setAutoContrast(const CameraParameters &params)
{
    int val = params.getInt(SecCameraParameters::KEY_AUTO_CONTRAST);
    int prevVal = mParameters.getInt(SecCameraParameters::KEY_AUTO_CONTRAST);
    if (val == -1 || prevVal == val)
        return NO_ERROR;
    if (prevVal == -1 && val == 0)  /* default */
        return NO_ERROR;

    ALOGV("setAutoContrast: %d", val);
    mParameters.set(SecCameraParameters::KEY_AUTO_CONTRAST, val);

    return nativeSetParameters(CAM_CID_AUTO_CONTRAST, val);
}


status_t ISecCameraHardware::setColorAdjust(const CameraParameters& params)
{
    int val = params.getInt(SecCameraParameters::KEY_COLOR);
    int prevVal = mParameters.getInt(SecCameraParameters::KEY_COLOR);

    /* Value : 0~22 */
    if (val > 22 || val < 0 || prevVal == val)
        return NO_ERROR;

    ALOGE("setColorAdjust: %d", val);

    mParameters.set(SecCameraParameters::KEY_COLOR, val);

    return nativeSetParameters(CAM_CID_COLOR_ADJUST, val);
}

status_t ISecCameraHardware::setSharpness(const CameraParameters& params)
{
    int val = params.getInt("sharpness");
    int prevVal = mParameters.getInt("sharpness");
    if (prevVal == val)
        return NO_ERROR;

    if (CC_UNLIKELY(val < -2 || val > 2)) {
        ALOGE("setSharpness: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

    ALOGD("setSharpness: %d", val);
    mParameters.set("sharpness", val);
	
    if (mSceneMode == SCENE_MODE_NONE)
        return nativeSetParameters(CAM_CID_SHARPNESS, val + 2);

    return NO_ERROR;
}

status_t ISecCameraHardware::setContrast(const CameraParameters& params)
{
    int val = params.getInt("contrast");
    int prevVal = mParameters.getInt("contrast");
    if (prevVal == val)
        return NO_ERROR;

    if (CC_UNLIKELY(val < -2 || val > 2)) {
        ALOGE("setContrast: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

    ALOGD("setContrast: %d", val);
    mParameters.set("contrast", val);

    if (mSceneMode == SCENE_MODE_NONE)
        return nativeSetParameters(CAM_CID_CONTRAST, val + 2);

    return NO_ERROR;
}

status_t ISecCameraHardware::setSaturation(const CameraParameters& params)
{
    int val = params.getInt("saturation");
    int prevVal = mParameters.getInt("saturation");
    if (prevVal == val)
        return NO_ERROR;

    if (CC_UNLIKELY(val < -2 || val > 2)) {
        ALOGE("setSaturation: error, invalid value(%d)", val);
        return BAD_VALUE;
    }

    ALOGD("setSaturation: %d", val);
    mParameters.set("saturation", val);

    if (mSceneMode == SCENE_MODE_NONE)
        return nativeSetParameters(CAM_CID_SATURATION, val + 2);

    return NO_ERROR;
}

#if VENDOR_FEATURE
status_t ISecCameraHardware::setImageStabilizermode(const CameraParameters& params)
{
    const char *str  = params.get(CameraParameters::KEY_IMAGE_STABILIZER);
    const char *prevStr = mParameters.get(CameraParameters::KEY_IMAGE_STABILIZER);
    //ALOGV("setImageStabilizermode ~~~~~~~~~~~~~~ str : %s, prevStr : %s",str, prevStr);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;
    int err;
retry:
    val = SecCameraParameters::lookupAttr(imagestabilizerModes, ARRAY_SIZE(imagestabilizerModes), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setImageStabilizermode: warning, not supported value(%s)", str);
        return NO_ERROR;
    }

    ALOGD("setImageStabilizermode: %s", str);
    mParameters.set(CameraParameters::KEY_IMAGE_STABILIZER, str);

    err = nativeSetParameters(CAM_CID_IMAGE_STABILIZER, val);
    if (err < 0 ) {
        ALOGE("setImageStabilizermode is failed\n");
    }

    return NO_ERROR;
}
#endif /* VENDOR_FEATURE */

status_t ISecCameraHardware::setAntiShake(const CameraParameters &params)
{
    int val = params.getInt(SecCameraParameters::KEY_ANTI_SHAKE);
    int prevVal = mParameters.getInt(SecCameraParameters::KEY_ANTI_SHAKE);
    if (val == -1 || prevVal == val)
        return NO_ERROR;
    if (prevVal == -1 && val == 0)  /* default */
        return NO_ERROR;

    ALOGV("setAntiShake: %d", val);
    mParameters.set(SecCameraParameters::KEY_ANTI_SHAKE, val);

    return nativeSetParameters(CAM_CID_ANTISHAKE, val);
}

status_t ISecCameraHardware::setFaceBeauty(const CameraParameters &params)
{
    int val = params.getInt(SecCameraParameters::KEY_FACE_BEAUTY);
    int prevVal = mParameters.getInt(SecCameraParameters::KEY_FACE_BEAUTY);
    if (val == -1 || prevVal == val)
        return NO_ERROR;
    if (prevVal == -1 && val == 0)  /* default */
        return NO_ERROR;

    ALOGV("setFaceBeauty: %d", val);
    mParameters.set(SecCameraParameters::KEY_FACE_BEAUTY, val);

    return nativeSetParameters(CAM_CID_FACE_BEAUTY, val);
}

status_t ISecCameraHardware::setBlur(const CameraParameters &params)
{
    int val = params.getInt(SecCameraParameters::KEY_BLUR);
    int prevVal = mParameters.getInt(SecCameraParameters::KEY_BLUR);
    if (val == -1 || prevVal == val)
        return NO_ERROR;
    if (prevVal == -1 && val == 0)  /* default */
        return NO_ERROR;

    ALOGV("setBlur: %d", val);
    mParameters.set(SecCameraParameters::KEY_BLUR, val);
    if (val > 0)
        setDropFrame(2);

    return nativeSetParameters(CAM_CID_BLUR, val);
}

int ISecCameraHardware::checkFnumber(int f_val, int zoomLevel)
{
    int err = NO_ERROR;

    if (f_val == 0) {
        ALOGD("checkFnumber: f number is set to default value. f_val = %d",
                f_val);
        return err;
    }

    switch (zoomLevel) {
    case 0:
        if (f_val != 31 && f_val != 90)
        err = BAD_VALUE;
        break;
    case 1:
        if (f_val != 34 && f_val != 95)
        err = BAD_VALUE;
        break;
    case 2:
        if (f_val != 35 && f_val != 100)
        err = BAD_VALUE;
        break;
    case 3:
        if (f_val != 37 && f_val != 104)
        err = BAD_VALUE;
        break;
    case 4:
        if (f_val != 38 && f_val != 109)
        err = BAD_VALUE;
        break;
    case 5:
        if (f_val != 40 && f_val != 113)
        err = BAD_VALUE;
        break;
    case 6:
        if (f_val != 41 && f_val != 116)
        err = BAD_VALUE;
        break;
    case 7:
        if (f_val != 42 && f_val != 119)
        err = BAD_VALUE;
        break;
    case 8:
        if (f_val != 43 && f_val != 122)
        err = BAD_VALUE;
        break;
    case 9:
        if (f_val != 44 && f_val != 125)
        err = BAD_VALUE;
        break;
    case 10:
        if (f_val != 45 && f_val != 127)
        err = BAD_VALUE;
        break;
    case 11:
        if (f_val != 46 && f_val != 129)
        err = BAD_VALUE;
        break;
    case 12:
        if (f_val != 46 && f_val != 131)
        err = BAD_VALUE;
        break;
    case 13:
        if (f_val != 47 && f_val != 134)
        err = BAD_VALUE;
        break;
    case 14:
        if (f_val != 48 && f_val != 136)
        err = BAD_VALUE;
        break;
    case 15:
        if (f_val != 49 && f_val != 139)
        err = BAD_VALUE;
        break;
    case 16:
        if (f_val != 50 && f_val != 142)
        err = BAD_VALUE;
        break;
    case 17:
        if (f_val != 51 && f_val != 145)
        err = BAD_VALUE;
        break;
    case 18:
        if (f_val != 52 && f_val != 148)
        err = BAD_VALUE;
        break;
    case 19:
        if (f_val != 54 && f_val != 152)
        err = BAD_VALUE;
        break;
    case 20:
        if (f_val != 55 && f_val != 156)
        err = BAD_VALUE;
        break;
    case 21:
        if (f_val != 56 && f_val != 159)
        err = BAD_VALUE;
        break;
    case 22:
        if (f_val != 58 && f_val != 163)
        err = BAD_VALUE;
        break;
    case 23:
        if (f_val != 59 && f_val != 167)
        err = BAD_VALUE;
        break;
    case 24:
        if (f_val != 60 && f_val != 170)
        err = BAD_VALUE;
        break;
    case 25:
        if (f_val != 61 && f_val != 173)
        err = BAD_VALUE;
        break;
    case 26:
        if (f_val != 62 && f_val != 176)
        err = BAD_VALUE;
        break;
    case 27:
        if (f_val != 63 && f_val != 179)
        err = BAD_VALUE;
        break;
    case 28:
        if (f_val != 63 && f_val != 182)
        err = BAD_VALUE;
        break;
    case 29:
        if (f_val != 63 && f_val != 184)
        err = BAD_VALUE;
        break;
    default:
        err = NO_ERROR;
        break;
    }
    return err;
}

static void getAntiBandingFromLatinMCC(char *temp_str, int tempStrLength)
{
    char value[10];
    char country_value[10];

    if (temp_str == NULL) {
        ALOGE("ERR(%s) (%d): temp_str is null", __FUNCTION__, __LINE__);
        return;
    }

    memset(value, 0x00, sizeof(value));
    memset(country_value, 0x00, sizeof(country_value));
    if (!property_get("gsm.operator.numeric", value,"")) {
        strncpy(temp_str, CameraParameters::ANTIBANDING_60HZ, tempStrLength);
        return;
    }
    memcpy(country_value, value, 3);

    /** MCC Info. Jamaica : 338 / Argentina : 722 / Chile : 730 / Paraguay : 744 / Uruguay : 748  **/
    if (strstr(country_value,"338") || strstr(country_value,"722") ||
        strstr(country_value,"730") || strstr(country_value,"744") ||
        strstr(country_value,"748"))
        strncpy(temp_str, CameraParameters::ANTIBANDING_50HZ, tempStrLength);
    else
        strncpy(temp_str, CameraParameters::ANTIBANDING_60HZ, tempStrLength);
}

static int IsLatinOpenCSC()
{
    char sales_code[5] = {0};
    property_get("ro.csc.sales_code", sales_code, "");
    if (strstr(sales_code,"TFG") || strstr(sales_code,"TPA") || strstr(sales_code,"TTT") || strstr(sales_code,"JDI") || strstr(sales_code,"PCI") )
        return 1;
    else
        return 0;
}

void ISecCameraHardware::chooseAntiBandingFrequency()
{
#if NOTDEFINED
    status_t ret = NO_ERROR;
    int LatinOpenCSClength = 5;
    char *LatinOpenCSCstr = NULL;
    char *CSCstr = NULL;
    const char *defaultStr = "50hz";

    if (IsLatinOpenCSC()) {
        LatinOpenCSCstr = (char *)malloc(LatinOpenCSClength);
        if (LatinOpenCSCstr == NULL) {
            ALOGE("LatinOpenCSCstr is NULL");
            CSCstr = (char *)defaultStr;
            memset(mAntiBanding, 0, sizeof(mAntiBanding));
            strcpy(mAntiBanding, CSCstr);
            return;
        }
        memset(LatinOpenCSCstr, 0, LatinOpenCSClength);

        getAntiBandingFromLatinMCC(LatinOpenCSCstr, LatinOpenCSClength);
        CSCstr = LatinOpenCSCstr;
    } else {
        CSCstr = (char *)SecNativeFeature::getInstance()->getString("CscFeature_Camera_CameraFlicker");
    }

    if (CSCstr == NULL || strlen(CSCstr) == 0) {
        CSCstr = (char *)defaultStr;
    }
    memset(mAntiBanding, 0, sizeof(mAntiBanding));
    strcpy(mAntiBanding, CSCstr);
    ALOGV("mAntiBanding = %s",mAntiBanding);

    if (LatinOpenCSCstr != NULL)
       free(LatinOpenCSCstr);
#endif
}

status_t ISecCameraHardware::setAntiBanding()
{
    status_t ret = NO_ERROR;
    const char *prevStr = mParameters.get(CameraParameters::KEY_ANTIBANDING);

    if (prevStr && !strcmp(mAntiBanding, prevStr))
        return NO_ERROR;

retry:
    int val = SecCameraParameters::lookupAttr(antibandings, ARRAY_SIZE(antibandings), mAntiBanding);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGE("setAntiBanding: error, not supported value(%s)", mAntiBanding);
        return BAD_VALUE;
    }
    ALOGD("setAntiBanding: %s", mAntiBanding);
    mParameters.set(CameraParameters::KEY_ANTIBANDING, mAntiBanding);
    return nativeSetParameters(CAM_CID_ANTIBANDING, val);
}

status_t ISecCameraHardware::setAntiBanding(const CameraParameters &params)
{
    const char *str = params.get(CameraParameters::KEY_ANTIBANDING);
    const char *prevStr = mParameters.get(CameraParameters::KEY_ANTIBANDING);

    if (str == NULL || (prevStr && !strcmp(str, prevStr)))
        return NO_ERROR;

    int val;

retry:
    val = SecCameraParameters::lookupAttr(antibandings, ARRAY_SIZE(antibandings), str);
    if (CC_UNLIKELY(val == NOT_FOUND)) {
        ALOGW("setAntiBanding: warning, not supported value(%s)", str);
        str = reinterpret_cast<const char*>(antibandings[0].desc);
        goto retry;
    }

    ALOGV("setAntiBanding: %s, val: %d", str, val);
    mParameters.set(CameraParameters::KEY_ANTIBANDING, str);

    return nativeSetParameters(CAM_CID_ANTIBANDING, val);
}

status_t ISecCameraHardware::setGps(const CameraParameters &params)
{
    const char *latitude = params.get(CameraParameters::KEY_GPS_LATITUDE);
    const char *logitude = params.get(CameraParameters::KEY_GPS_LONGITUDE);
    const char *altitude = params.get(CameraParameters::KEY_GPS_ALTITUDE);
    if (latitude && logitude && altitude) {
        ALOGV("setParameters: GPS latitude %f, logitude %f, altitude %f",
             atof(latitude), atof(logitude), atof(altitude));
        mParameters.set(CameraParameters::KEY_GPS_LATITUDE, latitude);
        mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, logitude);
        mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, altitude);
    } else {
        mParameters.remove(CameraParameters::KEY_GPS_LATITUDE);
        mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE);
        mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE);
    }

    const char *timestamp = params.get(CameraParameters::KEY_GPS_TIMESTAMP);
    if (timestamp) {
        ALOGV("setParameters: GPS timestamp %s", timestamp);
        mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, timestamp);
    } else {
        mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
    }

    const char *progressingMethod = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
    if (progressingMethod) {
        ALOGV("setParameters: GPS timestamp %s", timestamp);
        mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, progressingMethod);
    } else {
        mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
    }

    return NO_ERROR;
}

/*------------------------------------------------------------------*/
/*   ISP Debug Code                                                 */
/*------------------------------------------------------------------*/
#define ISP_DBG_STATE	  "/data/media/0/ISPD/ISP_S.DAT"
#define ISP_DBG_CMD		  "/data/media/0/ISPD/ISP_C.DAT"
#define ISP_DBG_RESULT    "/data/media/0/ISPD/ISP_R.DAT"
#define ISP_DBG_LOGFILTER "/data/media/0/ISPD/ISP_TUNING.DAT"
#define ISP_DBG_CONFIG    "/data/media/0/ISPD/ISP_CONFIG.DAT"

#define ISP_DBG_MAX_BUFFER  0xFF

#define ISP_DBG_STATE_ING   "ING"
#define ISP_DBG_STATE_END   "END"
#define ISP_DBG_STATE_ER1   "E01" // cmd not found
#define ISP_DBG_STATE_ER2   "E02" // param
#define ISP_DBG_STATE_ER3   "E03" // opcode not found
#define ISP_DBG_STATE_ER4   "E04" // data parsing error
#define ISP_DBG_STATE_ER5   "E05" //
#define ISP_DBG_STATE_ER6   "E06" // malloc fail

enum {
    ISP_DBG_READ=0,
    ISP_DBG_WRITE,
    ISP_DBG_READ_MEM,
    ISP_DBG_WRITE_MEM,
    ISP_DBG_READ_FILE,
    ISP_DBG_WRITE_FILE,
    ISP_DBG_LOGV,
};

bool ISecCameraHardware::ISP_DBG_ouput_state(char* state)
{
    FILE *fp = NULL;
    fp = fopen(ISP_DBG_STATE, "wt");
    if ( fp == NULL ){
        ALOGE("ISP_DBG_ouput_state fp = null!!!");
        return true;
    }

    fflush(stdout);
    fwrite(state, sizeof(char), 3, fp);
    fflush(fp);

    if (fp)
        fclose(fp);

    return true;
}

bool ISecCameraHardware::ISP_DBG_input(void)
{
    FILE *fp = NULL;
    int fileSize = 0;
    char* buffer = NULL;

    fp = fopen(ISP_DBG_CMD, "rb");
    if ( fp == NULL ) {
        ALOGD("ISP_DBG_input() file open NG: %s", ISP_DBG_CMD);
        ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER1);
        return false;
    }

    ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ING);

    //fflush(stdin);

    fseek(fp, 0, SEEK_END);
    fileSize = ftell(fp);
    rewind(fp);

    ALOGD("ISPD ISP_DBG_input()----filesize=%d", fileSize);

    buffer = (char *) malloc(fileSize+1);
    if ( buffer == NULL ) {
        if (fp)
            fclose(fp);
        ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER6);

        return false;
    }

    fread(buffer, sizeof(char), fileSize , fp);
    buffer[fileSize]= '\0';

    ISP_DBG_proc(buffer, fileSize);

    fflush(fp);

    if (buffer)
    {
        free(buffer);
		buffer = NULL;
    }

    if (fp)
    {
        fclose(fp);
		fp = NULL;
    }

    return true;
}

int ISecCameraHardware::CharToByte(char *buf, int size)
{
    int i, p, out=0;

    for ( i=0, p=0, out=0; i<size; i++) {
        char c = buf[i] ;

        if ( 'a' <= c && c <= 'f' )
            c = c - 'a' + 10;
        else if ( 'A' <= c && c <= 'F' )
            c = c - 'A' + 10;
        else if ( '0' <= c && c <= '9' )
            c = c - '0';
        else
            continue;

        if ( p%2==0 ) {
            buf[out] = c<<4;
        }
        else {
            buf[out] += c;
            //ALOGD("ISPD CharToByte() buf:%2s, buf[out]:%x", buf, buf[out]);
            out++;
        }
        p++;
    }

    return out;
}

int ISecCameraHardware::intpow(int n,int m)
{
    int out=1;
    for (int i=0;i<m;i++)
        out *= n;

    return out;
}

int ISecCameraHardware::CharToNumber(char *buf, int size)
{
    int i, out=0;

    for ( i=0; i<size; i++) {
        char c = buf[i] ;

        if ( '0' <= c && c <= '9' )
            c = c - '0';
        else
            continue;

        out += ( c * intpow(10, size-i-1));
    }
    return out;
}

int ISecCameraHardware::find_seperator(char *buf,  int size)
{
    int i;

    for (i=0; i<size;i++) {
        if ( buf[i]==' ' || buf[i]==',' ) {
            buf[i] = '\0';
            break;
        }
    }
    return ( i<size ) ?  i+1  : size;
}

void ISecCameraHardware::upper(char *buf, int size)
{
    for (int i=0;i<size;i++)
        if ( 'a' <= buf[i] && buf[i] <= 'z' )
            buf[i] -= 0x20;
}

bool ISecCameraHardware::ISP_DBG_proc(char *buffer, int size)
{
    /* support type
    1) w	    Category    Byte Number : w 0 1 5
    2) r	    Category    Byte Number : r 0 1 100
    3) wm  Address1 Data~ : wm 8045000 00998877626
    4) rm   Address 1   Size : rm 90897877 100
    5) wf    filename   Address   Data~ :
    6) rf     filename  Address   Size :
    7) ALOGV filename   : logv test.dat
    */

    const int max = 16; /*data max length */
    int s=0, e=0;
    int len=0;
    char* workBUF=NULL;

    while (buffer[s]==' ' || buffer[s]=='\r' || buffer[s]=='\n' || buffer[s]=='\t' ) s++;

    e=size-1;
    while ((buffer[e]==' ' || buffer[e]=='\r' || buffer[e]=='\n' || buffer[e]=='\t' ) && e >=0 ) e--;
    size=e;

    char *cmd = &buffer[s];
    len = find_seperator(cmd, e-s+1);
    upper(cmd, len);
    s += len;

    ALOGD("ISPD ISP_DBG_proc()-1----cmd=%s  s(%d), e(%d) len(%d),", cmd, s, e, len);

    /* Read / Write */
    if ( strncmp("R", cmd, max )==0 || strncmp("W", cmd, max )==0 ) {
        char *category= &buffer[s];
        len = find_seperator(category, e-s+1);
        s += len;
        len = CharToByte(category, len);

        char *subcategory= &buffer[s];
        len = find_seperator(subcategory, e-s+1);
        s += len;
        len = CharToByte(subcategory, len);

        if ( strncmp("R", cmd, max )==0 ) {

            char *length = &buffer[s];
            len = find_seperator(length, e-s+1);

            if ( len < 1 ) {
                ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER5);
                return false;
            }

            int read_length = CharToNumber(length, len);
            ALOGD("ISPD ISP_DBG_proc()-2----read_length=%d, len=%d", read_length, len);
            if (read_length > ISP_DBG_MAX_BUFFER ) {
                ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER4);
                return false;
            }

            int cmd_size = 2;
            workBUF = (char *)malloc(read_length+cmd_size);
            if ( workBUF == NULL ) {
                ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER6);
                return false;
            }

            workBUF[0]=*category;
            workBUF[1]=*subcategory;

            ALOGD("ISPD CAM_CID_ISP_DEBUG_READ  cate:%x, sub:%x  length:%d===", *category, *subcategory, read_length);
            nativeGetExtParameters(CAM_CID_ISP_DEBUG_READ, workBUF, read_length+cmd_size);

            ISP_DBG_ouput(workBUF, read_length);

            ISP_DBG_ouput_state((char*)ISP_DBG_STATE_END);

            if (workBUF)
                free(workBUF);

        }
        else { /*strncmp("W", cmd, max )==0 */

            char *data = &buffer[s];
            len = CharToByte(data, e-s+1);

            if ( len < 1 ) {
                ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER5);
                return false;
            }

            int cmd_size = 2;
            workBUF = (char *)malloc( len+cmd_size);
            if ( workBUF == NULL ) {
                ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER6);
                return false;
            }
            workBUF[0]=*category;
            workBUF[1]=*subcategory;
            memcpy(&workBUF[2], data, len);

            ALOGD("ISPD CAM_CID_ISP_DEBUG_WRITE   cate:%x, sub:%x  data:%x===", workBUF[0], workBUF[1], workBUF[2]);
            nativeSetExtParameters(CAM_CID_ISP_DEBUG_WRITE, workBUF, len+cmd_size);

            ISP_DBG_ouput_state((char*)ISP_DBG_STATE_END);

            if (workBUF)
                free(workBUF);
        }
    }
    else if ( strncmp("RM", cmd, max )==0 || strncmp("WM", cmd, max )==0 ) {

        char *address = &buffer[s];
        len = find_seperator(address, e-s+1);
        s += len;
        len = CharToByte(address, len);

        if ( strncmp("RM", cmd, max )==0 ) {

            char *length = &buffer[s];
            len = find_seperator(length, e-s+1);

            if ( len < 1 ) {
                ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER5);
                return false;
            }

            int read_length = CharToNumber(length, len);
            ALOGD("ISPD ISP_DBG_proc()-2----read_length=%d, len=%d e=%d, s=%d", read_length, len, e, s);
            //			if (read_length > ISP_DBG_MAX_BUFFER ) {
            //				ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER4);
            //				return false;
            //			}

            int cmd_size = 4;
            workBUF = (char *)malloc(read_length+cmd_size);
            if ( workBUF == NULL ) {
                ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER6);
                return false;
            }
            memcpy(&workBUF[0], address, cmd_size);

            ALOGD("ISPD CAM_CID_ISP_DEBUG_READ  address:%x, [%02x,%02x,%02x,%02x]length:%d===", *(int*)address, workBUF[0], workBUF[1],workBUF[2], workBUF[3], *(int*)&workBUF[4]);
            nativeGetExtParameters(CAM_CID_ISP_DEBUG_READ_MEM, workBUF, read_length+cmd_size);
            ALOGD("ISPD CAM_CID_ISP_DEBUG_READ  [%02x,%02x,%02x,%02x]", workBUF[0], workBUF[1],workBUF[2], workBUF[3]);

            ISP_DBG_ouput(workBUF, read_length);

            ISP_DBG_ouput_state((char*)ISP_DBG_STATE_END);

            if (workBUF)
                free(workBUF);

        } else {  /* strncmp("wm", cmd, max )==0 */

        char *data = &buffer[s];
        len = CharToByte(data, e-s+1);

        if ( len < 1 ) {
            ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER5);
            return false;
        }

        int cmd_size = 4;
        workBUF = (char *)malloc(len+cmd_size);
        if ( workBUF == NULL ) {
            ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER6);
            return false;
        }
        memcpy(&workBUF[0], address, cmd_size);
        memcpy(&workBUF[cmd_size], data, len);

        ALOGD("ISPD CAM_CID_ISP_DEBUG_READ  address:%x, %x %x===", *(int*)address, workBUF[4], workBUF[5]);
        nativeSetExtParameters(CAM_CID_ISP_DEBUG_WRITE_MEM, workBUF, len+cmd_size);

        ISP_DBG_ouput_state((char*)ISP_DBG_STATE_END);

        if (workBUF)
            free(workBUF);

        }
    }
    else if ( strncmp("RF", cmd, max )==0 ) {
    }
    else if ( strncmp("WF", cmd, max )==0 ) {
    }
    else if ( strncmp("LOGV", cmd, max )==0 ) {
        len=0;
        char *filename = &buffer[s];
        len = find_seperator(filename, e-s+1);

        nativeSetExtParameters(CAM_CID_ISP_DEBUG_LOGV, filename, len);

        ISP_DBG_ouput_state((char*)ISP_DBG_STATE_END);
    }
    else {
        ISP_DBG_ouput_state((char*)ISP_DBG_STATE_ER3);
        return false;
    }
    return true;
}

bool ISecCameraHardware::ISP_DBG_ouput(char *buffer, int size)
{
    FILE *fp = NULL;
    fp = fopen(ISP_DBG_RESULT, "wb");

    fflush(stdout);
    fwrite(buffer, sizeof(char), size, fp);
    fflush(fp);

    if (fp)
        fclose(fp);

    ISP_DBG_ouput_state((char*)ISP_DBG_STATE_END);

    return true;
}

bool ISecCameraHardware::ISP_DBG_logwrite(void)
{
    FILE *fp = NULL;
    int readSize = 0;
    char buffer[256];
    int    nLogNo = 1;

    // Log Filter ------------------------------------------------------------------------------------------------
    readSize = 8;  // 8byte : filter flag

    fp = fopen(ISP_DBG_LOGFILTER, "rb");
    if ( fp != NULL ) {
        //fflush(stdin);
        fseek(fp, 0, SEEK_END);
        rewind(fp);

        fread(buffer, sizeof(char), readSize , fp);
        buffer[readSize]='\0';

        fflush(fp);
        if (fp)
            fclose(fp);

        int cmd_size = 2;
        int  len = CharToByte(buffer, 8);

        char workBUF[16];
        workBUF[0]=0x0d; // category
        workBUF[1]=0x10; // sub
        memcpy(&workBUF[2], buffer, 4); // data
        workBUF[6]=0;

        ALOGD("ISPD ISP_DBG_logwrite()----%2x%2x%2x%2x", workBUF[2],workBUF[3],workBUF[4],workBUF[5] );
        nativeSetExtParameters(CAM_CID_ISP_DEBUG_WRITE, workBUF, len+cmd_size);
    }

    //- Log Name------------------------------------------------------------------------------------------------
    readSize = 6;  // 6byte :log No

    fp = fopen(ISP_DBG_CONFIG, "rb");

    if ( fp != NULL ) {
        //fflush(stdin);
        fseek(fp, 0, SEEK_END);
        rewind(fp);

        fread(buffer, sizeof(char), readSize , fp);
        buffer[readSize]='\0';

        nLogNo = atoi( buffer );
        nLogNo ++;

        fflush(fp);
        if (fp)
            fclose(fp);
    }

    fp = fopen(ISP_DBG_CONFIG, "wb");
    fflush(stdout);

    sprintf(buffer, "%06d%c", nLogNo, 0);    // 6 = readSize
    fwrite(buffer, sizeof(char), readSize , fp);

    fflush(fp);
    if (fp)
        fclose(fp);

    //- Log Writer------------------------------------------------------------------------------------------------

    sprintf(buffer, "_ISP_%06d.LOG%c", nLogNo, NULL);
    ALOGD("ISPD ISP_DBG_logwrite()----filename=%s", buffer);

    nativeSetExtParameters(CAM_CID_ISP_DEBUG_LOGV, buffer, strlen(buffer));

    return true;
}

#if defined(KOR_CAMERA)
status_t ISecCameraHardware::setSelfTestMode(const CameraParameters &params)
{
    int val = params.getInt("selftestmode");
    if (val == -1)
        return NO_ERROR;

    ALOGV("selftestmode: %d", val);
    mSamsungApp = val ? true : false;

    return NO_ERROR;
}
#endif

bool ISecCameraHardware::allocMemSinglePlane(ion_client ionClient, ExynosBuffer *buf, int index, bool flagCache)
{
    if (ionClient == 0) {
        ALOGE("ERR(%s): ionClient is zero (%d)", __func__, ionClient);
        return false;
    }

    if (buf->size.extS[index] != 0) {
        int flagIon = (flagCache == true) ? ION_FLAG_CACHED : 0;

        /* HACK: For non-cacheable */
        buf->fd.extFd[index] = ion_alloc(ionClient, buf->size.extS[index], 0, ION_HEAP_SYSTEM_MASK, 0);
        if (buf->fd.extFd[index] <= 0) {
            ALOGE("ERR(%s): ion_alloc(%d, %d) failed", __func__, index, buf->size.extS[index]);
            buf->fd.extFd[index] = -1;
            freeMemSinglePlane(buf, index);
            return false;
        }

        buf->virt.extP[index] = (char *)ion_map(buf->fd.extFd[index], buf->size.extS[index], 0);
        if ((buf->virt.extP[index] == (char *)MAP_FAILED) || (buf->virt.extP[index] == NULL)) {
            ALOGE("ERR(%s): ion_map(%d) failed", __func__, buf->size.extS[index]);
            buf->virt.extP[index] = NULL;
            freeMemSinglePlane(buf, index);
            return false;
        }
    }

    return true;
}

void ISecCameraHardware::freeMemSinglePlane(ExynosBuffer *buf, int index)
{
    if (0 < buf->fd.extFd[index]) {
        if (buf->virt.extP[index] != NULL) {
			int ret = 0;
            ret = ion_unmap(buf->virt.extP[index], buf->size.extS[index]);
            if (ret < 0)
                ALOGE("ERR(%s):ion_unmap(%p, %d) fail", __FUNCTION__, buf->virt.extP[index], buf->size.extS[index]);
        }
        ion_free(buf->fd.extFd[index]);
    }

    buf->fd.extFd[index] = -1;
    buf->virt.extP[index] = NULL;
    buf->size.extS[index] = 0;
}

bool ISecCameraHardware::allocMem(ion_client ionClient, ExynosBuffer *buf, int cacheIndex)
{
    for (int i = 0; i < ExynosBuffer::BUFFER_PLANE_NUM_DEFAULT; i++) {
        bool flagCache = ((1 << i) & cacheIndex) ? true : false;
        if (allocMemSinglePlane(ionClient, buf, i, flagCache) == false) {
            freeMem(buf);
            ALOGE("ERR(%s): allocMemSinglePlane(%d) fail", __func__, i);
            return false;
        }
    }

    return true;
}

void ISecCameraHardware::freeMem(ExynosBuffer *buf)
{
    for (int i = 0; i < ExynosBuffer::BUFFER_PLANE_NUM_DEFAULT; i++)
        freeMemSinglePlane(buf, i);
}

void ISecCameraHardware::mInitRecSrcQ(void)
{
    Mutex::Autolock lock(mRecordSrcLock);
    mRecordSrcIndex = -1;

    mRecordSrcQ.clear();
}

int ISecCameraHardware::getRecSrcBufSlotIndex(void)
{
    Mutex::Autolock lock(mRecordSrcLock);
    mRecordSrcIndex++;
    mRecordSrcIndex = mRecordSrcIndex % FLITE_BUF_CNT;
    return mRecordSrcIndex;
}

void ISecCameraHardware::mPushRecSrcQ(rec_src_buf_t *buf)
{
    Mutex::Autolock lock(mRecordSrcLock);
    mRecordSrcQ.push_back(buf);
}

bool ISecCameraHardware::mPopRecSrcQ(rec_src_buf_t *buf)
{
    List<rec_src_buf_t *>::iterator r;

    Mutex::Autolock lock(mRecordSrcLock);

    if (mRecordSrcQ.size() == 0)
        return false;

    r = mRecordSrcQ.begin()++;

    buf->buf = (*r)->buf;
    buf->timestamp = (*r)->timestamp;
    mRecordSrcQ.erase(r);

    return true;
}

int ISecCameraHardware::mSizeOfRecSrcQ(void)
{
    Mutex::Autolock lock(mRecordSrcLock);

    return mRecordSrcQ.size();
}

#if 0
bool ISecCameraHardware::setRecDstBufStatus(int index, enum REC_BUF_STATUS status)
{
    Mutex::Autolock lock(mRecordDstLock);

    if (index < 0 || index >= REC_BUF_CNT) {
        ALOGE("ERR(%s): index(%d) out of range, status(%d)", __func__, index, status);
        return false;
    }

    mRecordDstStatus[index] = status;
    return true;
}
#endif

int ISecCameraHardware::getRecDstBufIndex(void)
{
    Mutex::Autolock lock(mRecordDstLock);

    for (int i = 0; i < REC_BUF_CNT; i++) {
        mRecordDstIndex++;
        mRecordDstIndex = mRecordDstIndex % REC_BUF_CNT;

        if (mRecordFrameAvailable[mRecordDstIndex] == true) {
            mRecordFrameAvailableCnt--;
            mRecordFrameAvailable[mRecordDstIndex] = false;
            return mRecordDstIndex;
        }
    }

    return -1;
}

void ISecCameraHardware::setAvailDstBufIndex(int index)
{
    Mutex::Autolock lock(mRecordDstLock);
    mRecordFrameAvailableCnt++;
    mRecordFrameAvailable[index] = true;
    return;
}

void ISecCameraHardware::mInitRecDstBuf(void)
{
    Mutex::Autolock lock(mRecordDstLock);

    ExynosBuffer nullBuf;

    mRecordDstIndex = -1;
    mRecordFrameAvailableCnt = REC_BUF_CNT;

    for (int i = 0; i < REC_BUF_CNT; i++) {
#ifdef BOARD_USE_MHB_ION
        for (int j = 0; j < REC_PLANE_CNT; j++) {
            if (mRecordDstHeap[i][j] != NULL)
                mRecordDstHeap[i][j]->release(mRecordDstHeap[i][j]);
            mRecordDstHeap[i][j] = NULL;
            mRecordDstHeapFd[i][j] = -1;
        }
#else
        if (0 < mRecordingDstBuf[i].fd.extFd)
            freeMem(&mRecordingDstBuf[i]);
#endif
        mRecordingDstBuf[i] = nullBuf;
        mRecordFrameAvailable[i] = true;
    }
}

int ISecCameraHardware::getAlignedYUVSize(int colorFormat, int w, int h, ExynosBuffer *buf, bool flagAndroidColorFormat)
{
    int FrameSize = 0;
    ExynosBuffer alignedBuf;

    /* ALOGV("[%s] (%d) colorFormat %d", __func__, __LINE__, colorFormat); */
    switch (colorFormat) {
    /* 1p */
    case V4L2_PIX_FMT_RGB565 :
    case V4L2_PIX_FMT_YUYV :
    case V4L2_PIX_FMT_UYVY :
    case V4L2_PIX_FMT_VYUY :
    case V4L2_PIX_FMT_YVYU :
        alignedBuf.size.extS[0] = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(colorFormat), w, h);
	if(h==1080){
		alignedBuf.size.extS[0] += 1024*28;
	}
        /* ALOGV("V4L2_PIX_FMT_YUYV buf->size.extS[0] %d", alignedBuf->size.extS[0]); */
        alignedBuf.size.extS[1] = SPARE_SIZE;
        alignedBuf.size.extS[2] = 0;
        break;
    /* 2p */
    case V4L2_PIX_FMT_NV12 :
    case V4L2_PIX_FMT_NV12T :
    case V4L2_PIX_FMT_NV21 :
    case V4L2_PIX_FMT_NV12M :
    case V4L2_PIX_FMT_NV21M :
        if (flagAndroidColorFormat == true) {
            alignedBuf.size.extS[0] = w * h;
            alignedBuf.size.extS[1] = w * h / 2;
            alignedBuf.size.extS[2] = SPARE_SIZE;
        } else {
            alignedBuf.size.extS[0] = ALIGN_UP(w, 16) * ALIGN_UP(h, 16);
            alignedBuf.size.extS[1] = ALIGN_UP(w, 16) * ALIGN_UP(h, 16) / 2;
            alignedBuf.size.extS[2] = SPARE_SIZE;
        }
        /* ALOGV("V4L2_PIX_FMT_NV21 buf->size.extS[0] %d buf->size.extS[1] %d",
            alignedBuf->size.extS[0], alignedBuf->size.extS[1]); */
        break;
    case V4L2_PIX_FMT_NV12MT_16X16 :
        if (flagAndroidColorFormat == true) {
            alignedBuf.size.extS[0] = w * h;
            alignedBuf.size.extS[1] = w * h / 2;
            alignedBuf.size.extS[2] = SPARE_SIZE;
        } else {
            alignedBuf.size.extS[0] = ALIGN_UP(w, 16) * ALIGN_UP(h, 16);
            alignedBuf.size.extS[1] = ALIGN(alignedBuf.size.extS[0] / 2, 256);
            alignedBuf.size.extS[2] = SPARE_SIZE;
        }
        /* ALOGV("V4L2_PIX_FMT_NV12M buf->size.extS[0] %d buf->size.extS[1] %d",
            alignedBuf->size.extS[0], alignedBuf->size.extS[1]); */
        break;
    case V4L2_PIX_FMT_NV16 :
    case V4L2_PIX_FMT_NV61 :
        alignedBuf.size.extS[0] = ALIGN_UP(w, 16) * ALIGN_UP(h, 16);
        alignedBuf.size.extS[1] = ALIGN_UP(w, 16) * ALIGN_UP(h, 16);
        alignedBuf.size.extS[2] = SPARE_SIZE;
        /* ALOGV("V4L2_PIX_FMT_NV16 buf->size.extS[0] %d buf->size.extS[1] %d",
            alignedBuf->size.extS[0], alignedBuf->size.extS[1]); */
        break;
    /* 3p */
    case V4L2_PIX_FMT_YUV420 :
    case V4L2_PIX_FMT_YVU420 :
        /* http://developer.android.com/reference/android/graphics/ImageFormat.html#YV12 */
        if (flagAndroidColorFormat == true) {
            alignedBuf.size.extS[0] = ALIGN_UP(w, 16) * h;
            alignedBuf.size.extS[1] = ALIGN_UP(w / 2, 16) * h / 2;
            alignedBuf.size.extS[2] = ALIGN_UP(w / 2, 16) * h / 2;
            alignedBuf.size.extS[3] = SPARE_SIZE;
        } else {
            alignedBuf.size.extS[0] = (w * h);
            alignedBuf.size.extS[1] = (w * h) >> 2;
            alignedBuf.size.extS[2] = (w * h) >> 2;
            alignedBuf.size.extS[3] = SPARE_SIZE;
        }
        /* ALOGV("V4L2_PIX_FMT_YUV420 Buf.size.extS[0] %d Buf.size.extS[1] %d Buf.size.extS[2] %d",
            alignedBuf.size.extS[0], alignedBuf.size.extS[1], alignedBuf.size.extS[2]); */
        break;
    case V4L2_PIX_FMT_YUV420M :
    case V4L2_PIX_FMT_YVU420M :
        if (flagAndroidColorFormat == true) {
            alignedBuf.size.extS[0] = ALIGN_UP(w, 16) * h;
            alignedBuf.size.extS[1] = ALIGN_UP(w / 2, 16) * h / 2;
            alignedBuf.size.extS[2] = ALIGN_UP(w / 2, 16) * h / 2;
            alignedBuf.size.extS[3] = SPARE_SIZE;
        } else {
            alignedBuf.size.extS[0] = ALIGN_UP(w,   32) * ALIGN_UP(h,  16);
            alignedBuf.size.extS[1] = ALIGN_UP(w/2, 16) * ALIGN_UP(h/2, 8);
            alignedBuf.size.extS[2] = ALIGN_UP(w/2, 16) * ALIGN_UP(h/2, 8);
            alignedBuf.size.extS[3] = SPARE_SIZE;
        }
        /* ALOGV("V4L2_PIX_FMT_YUV420M buf->size.extS[0] %d buf->size.extS[1] %d buf->size.extS[2] %d",
            alignedBuf->size.extS[0], alignedBuf->size.extS[1], alignedBuf->size.extS[2]); */
        break;
    case V4L2_PIX_FMT_YUV422P :
        alignedBuf.size.extS[0] = ALIGN_UP(w,   16) * ALIGN_UP(h,  16);
        alignedBuf.size.extS[1] = ALIGN_UP(w/2, 16) * ALIGN_UP(h/2, 8);
        alignedBuf.size.extS[2] = ALIGN_UP(w/2, 16) * ALIGN_UP(h/2, 8);
        alignedBuf.size.extS[3] = SPARE_SIZE;
        /* ALOGV("V4L2_PIX_FMT_YUV422P Buf.size.extS[0] %d Buf.size.extS[1] %d Buf.size.extS[2] %d",
            alignedBuf.size.extS[0], alignedBuf.size.extS[1], alignedBuf.size.extS[2]); */
        break;
	case V4L2_PIX_FMT_JPEG:
		alignedBuf.size.extS[0] = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(V4L2_PIX_FMT_YUYV), w, h);
		alignedBuf.size.extS[1] = SPARE_SIZE;
		alignedBuf.size.extS[2] = 0;
		ALOGD("V4L2_PIX_FMT_JPEG buf->size.extS[0] = %d", alignedBuf.size.extS[0]);
		break;
    default:
        ALOGE("ERR(%s):unmatched colorFormat(%d)", __func__, colorFormat);
        return 0;
        break;
    }

    for (int i = 0; i < ExynosBuffer::BUFFER_PLANE_NUM_DEFAULT; i++)
        FrameSize += alignedBuf.size.extS[i];

    if (buf != NULL) {
        for (int i = 0; i < ExynosBuffer::BUFFER_PLANE_NUM_DEFAULT; i++) {
            buf->size.extS[i] = alignedBuf.size.extS[i];

            /* if buf has vadr, calculate another vadr per plane */
            if (buf->virt.extP[0] != NULL && i > 0) {
                if (buf->size.extS[i] != 0)
                    buf->virt.extP[i] = buf->virt.extP[i - 1] + buf->size.extS[i - 1];
                else
                    buf->virt.extP[i] = NULL;
            }
        }
    }
    return (FrameSize - SPARE_SIZE);
}

}; /* namespace android */
#endif /* ANDROID_HARDWARE_ISECCAMERAHARDWARE_CPP */