/******************************************************************************
  Copyright (C), 2001-2016, Allwinner Tech. Co., Ltd.
 ******************************************************************************
  File Name     : EyeseeCamera.cpp
  Version       : Initial Draft
  Author        : Allwinner BU3-PD2 Team
  Created       : 2016/06/01
  Last Modified :
  Description   : camera wrap MPP components.
  Function List :
  History       :
******************************************************************************/

//#define LOG_NDEBUG 0
#define LOG_TAG "EyeseeCamera"
#include <utils/plat_log.h>

#include <vector>

#include <EyeseeCamera.h>

#include "VIDevice.h"

using namespace std;
namespace EyeseeLinux
{

std::map<int, CameraInfo> EyeseeCamera::mCameraInfos;
Mutex EyeseeCamera::mCameraInfosLock;
    
class EyeseeCamera;

class EyeseeCameraContext : public DataListener
                                    , public NotifyListener
{
public:
    EyeseeCameraContext(EyeseeCamera *pCamera);
    ~EyeseeCameraContext();

    virtual void postData(int msgType, int chnId, const std::shared_ptr<CMediaMemory>& dataPtr, size_t dataSize);
    virtual void notify(int msgType, int chnId, int ext1, int ext2);
    void addCallbackBuffer(int msgType, CMediaMemory &cbb);
    bool isRawImageCallbackBufferAvailable() const;

private:
    EyeseeCamera *mpCamera;
    vector<CMediaMemory> mRawImageCallbackBuffers;
    vector<CMediaMemory> mCallbackBuffers;
    Mutex mLock;
};

EyeseeCameraContext::EyeseeCameraContext(EyeseeCamera *pCamera)
    : mpCamera(pCamera)
{
}

EyeseeCameraContext::~EyeseeCameraContext()
{
}

void EyeseeCameraContext::postData(int msgType, int chnId, const std::shared_ptr<CMediaMemory>& dataPtr, size_t dataSize)
{
    EyeseeCamera::postEventFromNative(mpCamera, msgType, chnId, (int)dataSize, 0, &dataPtr);
}

void EyeseeCameraContext::notify(int msgType, int chnId, int ext1, int ext2)
{
    EyeseeCamera::postEventFromNative(mpCamera, msgType, chnId, ext1, ext2, NULL);
}

void EyeseeCameraContext::addCallbackBuffer(int msgType, CMediaMemory &cbb)
{
    alogw("addCallbackBuffer is not implement now!");
}

bool EyeseeCameraContext::isRawImageCallbackBufferAvailable() const
{
    return !mRawImageCallbackBuffers.empty();
}


void EyeseeCamera::postEventFromNative(EyeseeCamera *pCam, int what, int arg1, int arg2, int arg3, const std::shared_ptr<CMediaMemory>* pDataPtr)
{
    if (pCam == NULL)
    {
        aloge("fatal error! pCam == NULL");
        return;
    }
    CallbackMessage msg;

    msg.what = what;
    msg.arg1 = arg1;
    msg.arg2 = arg2;
    msg.extArgs.push_back(arg3);
    //msg.obj = obj;
    if(pDataPtr)
    {
        msg.mDataPtr = std::const_pointer_cast<const CMediaMemory>(*pDataPtr);
    }
    pCam->mpEventHandler->post(msg);
}


EyeseeCamera::EventHandler::EventHandler(EyeseeCamera *pCam)
    : mpCamera(pCam)
{
}

void EyeseeCamera::EventHandler::handleMessage(const CallbackMessage &msg)
{
    switch (msg.what) {
        case CAMERA_MSG_SHUTTER:
        {
            //if (mpCamera->mpShutterCallback != NULL)
            //{
            //    mpCamera->mpShutterCallback->onShutter(msg.arg1);
            //}
            AutoMutex lock(mpCamera->mSetTakePictureCallbackLock);
            int chnId = msg.arg1;
            std::map<int, EyeseeCamera::TakePictureCallback>::iterator it = mpCamera->mTakePictureCallback.find(chnId);
            if(it == mpCamera->mTakePictureCallback.end())
            {
                aloge("fatal error, why not find chnId[%d]", chnId);
                return;
            }

            if(it->second.mpShutterCallback)
            {
               it->second.mpShutterCallback->onShutter(chnId); 
            }            
            return;
        }
        case CAMERA_MSG_RAW_IMAGE:
        {
            AutoMutex lock(mpCamera->mSetTakePictureCallbackLock);
            int chnId = msg.arg1;
            std::map<int, EyeseeCamera::TakePictureCallback>::iterator it = mpCamera->mTakePictureCallback.find(chnId);
            if(it == mpCamera->mTakePictureCallback.end())
            {
                aloge("fatal error, why not find chnId[%d]", chnId);
                return;
            }
            
            if (it->second.mpRawImageCallback) 
            {
                if(msg.mDataPtr)
                {
                    if(msg.mDataPtr->getPointer() != NULL)
                    {
                        //int chnId = msg.arg1;
                        const void *pData = msg.mDataPtr->getPointer();
                        int nSize = msg.arg2;
                        it->second.mpRawImageCallback->onPictureTaken(chnId, pData, nSize, mpCamera);
                    }
                }
            }
            mpCamera->mpVIDevice->notifyPictureRelease(chnId);
            return;
        }

        case CAMERA_MSG_COMPRESSED_IMAGE:
        {
            AutoMutex lock(mpCamera->mSetTakePictureCallbackLock);
            int chnId = msg.arg1;
            std::map<int, EyeseeCamera::TakePictureCallback>::iterator it = mpCamera->mTakePictureCallback.find(chnId);
            if(it == mpCamera->mTakePictureCallback.end())
            {
                aloge("fatal error, why not find chnId[%d]", chnId);
                return;
            }
            
            if (it->second.mpJpegCallback) 
            {
                if(msg.mDataPtr)
                {
                    if(msg.mDataPtr->getPointer() != NULL) 
                    {
                        //int chnId = msg.arg1;
                        const void *pData = msg.mDataPtr->getPointer();
                        int nSize = msg.arg2;
                        it->second.mpJpegCallback->onPictureTaken(chnId, pData, nSize, mpCamera);
                        //mpCamera->postDataCompleted(msg.arg1, msg.obj, msg.arg2);
                    }
                }
            }
            mpCamera->mpVIDevice->notifyPictureRelease(chnId);
            return;
        }

        case CAMERA_MSG_PREVIEW_FRAME:
        {
            PreviewCallback *pCb = mpCamera->mpPreviewCallback;
            if (pCb != NULL) 
            {
                alogw("only for test, for fun. Don't use it now");
                if (mpCamera->mOneShot) 
                {
                    // Clear the callback variable before the callback
                    // in case the app calls setPreviewCallback from
                    // the callback function
                    mpCamera->mpPreviewCallback = NULL;
                } 
                else if (!mpCamera->mWithBuffer) 
                {
                    // We're faking the camera preview mode to prevent
                    // the app from being flooded with preview frames.
                    // Set to oneshot mode again.
                    mpCamera->setHasPreviewCallback(true, false);
                }
                //pCb.onPreviewFrame((byte[])msg.obj, mCamera);
                if(msg.mDataPtr)
                {
                    if(msg.mDataPtr->getPointer() != NULL)
                    {
                        int chnId = msg.arg1;
                        const void *pData = msg.mDataPtr->getPointer();
                        int nSize = msg.arg2;
                        pCb->onPreviewFrame(pData, nSize, mpCamera);
                    }
                }
            }
            return;
        }

        case CAMERA_MSG_POSTVIEW_FRAME:
        {
            AutoMutex lock(mpCamera->mSetTakePictureCallbackLock);
            int chnId = msg.arg1;
            std::map<int, EyeseeCamera::TakePictureCallback>::iterator it = mpCamera->mTakePictureCallback.find(chnId);
            if(it == mpCamera->mTakePictureCallback.end())
            {
                aloge("fatal error, why not find chnId[%d]", chnId);
                return;
            }
            
            if (it->second.mpPostviewCallback) 
            {
                if(msg.mDataPtr)
                {
                    if(msg.mDataPtr->getPointer() != NULL) 
                    {
                        //int chnId = msg.arg1;
                        const void *pData = msg.mDataPtr->getPointer();
                        int nSize = msg.arg2;
                        it->second.mpPostviewCallback->onPictureTaken(chnId, pData, nSize, mpCamera);
                    }
                }
            }
            mpCamera->mpVIDevice->notifyPictureRelease(chnId);
            return;
        }
        case CAMERA_MSG_MOD_DATA:
        {
            if(mpCamera->mpMODDataCallback != NULL)
            {
                if(msg.mDataPtr)
                {
                    if(msg.mDataPtr->getPointer() != NULL) 
                    {
                        int chnId = msg.arg1;
                        const void *pData = msg.mDataPtr->getPointer();
                        int nSize = msg.arg2;
                        mpCamera->mpMODDataCallback->onMODData(chnId, (MotionDetectResult*)pData, mpCamera);
                    }
                }
            }
            break;
        }
        case CAMERA_MSG_ADAS_DATA:
        {
            if(mpCamera->mpAdasDataCallback != NULL)
            {
                if(msg.mDataPtr)
                {
                    if(msg.mDataPtr->getPointer() != NULL)
                    {
                        int chnId = msg.arg1;
                        const void *pData = msg.mDataPtr->getPointer();
                        int nSize = msg.arg2;
                        #ifdef DEF_MPPCFG_ADAS_DETECT
                        mpCamera->mpAdasDataCallback->onAdasOutData(chnId, (AW_AI_ADAS_DETECT_R_*)pData, mpCamera);
                        #endif
                        #ifdef DEF_MPPCFG_ADAS_DETECT_V2
                        mpCamera->mpAdasDataCallback->onAdasOutData_v2(chnId, (AW_AI_ADAS_DETECT_R__v2*)pData, mpCamera);
                        #endif
                     }
                }
            }
            break;
        }
        case CAMERA_MSG_ERROR:
            aloge("Channel %d error %d", msg.arg1, msg.arg2);
            if (mpCamera->mpErrorCallback != NULL) {
                mpCamera->mpErrorCallback->onError(msg.arg1, msg.arg2, mpCamera);
            }
            return;
        case CAMERA_MSG_INFO:
        {
            int chnId = msg.arg1;
            CameraMsgInfoType what = (CameraMsgInfoType)msg.arg2;
            int extra = 0;
            if(msg.extArgs.size() > 0)
            {
                extra = msg.extArgs[0];
            }
            if (mpCamera->mpInfoCallback != NULL) 
            {
                mpCamera->mpInfoCallback->onInfo(chnId, what, extra, mpCamera);
            }
            return;
        }
        default:
        {
            aloge("Channel %d Unknown message type %d", msg.arg1, msg.what);
            return;
        }
    }
}

EyeseeCamera::EyeseeCamera(int cameraId)
    : mCameraId(cameraId)
    , mpNativeContext(NULL)
    , mpEventHandler(NULL)
    , mpPreviewCallback(NULL)
    , mpErrorCallback(NULL)
    , mpInfoCallback(NULL)
    , mOneShot(false)
    , mWithBuffer(false)
    , mpVIDevice(NULL)
{
    initCamerasConfiguration();
    CameraInfo stCameraInfo;
    if(NO_ERROR!=getCameraInfo(cameraId, &stCameraInfo))
    {
        return;
    }
    mpMODDataCallback = NULL;
    mpAdasDataCallback = NULL;
    mpEventHandler = new EventHandler(this);
    VIDevice *pVIDevice = new VIDevice(cameraId, &stCameraInfo);
    mpVIDevice = pVIDevice;
    EyeseeCameraContext *pContext = new EyeseeCameraContext(this);
    mpNativeContext = (void*)pContext;
}

EyeseeCamera::~EyeseeCamera()
{
    if (mpNativeContext != NULL) {
        EyeseeCameraContext *pContext = (EyeseeCameraContext*)mpNativeContext;
        delete pContext;
    }
    if (mpVIDevice != NULL) {
        VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
        delete pVIDevice;
    }
    if (mpEventHandler != NULL) {
        delete mpEventHandler;
    }
}

EyeseeCamera *EyeseeCamera::open(int cameraId)
{
    initCamerasConfiguration();
    if(NO_ERROR!=getCameraInfo(cameraId, NULL))
    {
        return NULL;
    }
    EyeseeCamera *pCam = new EyeseeCamera(cameraId);
    return pCam;
}

void EyeseeCamera::close(EyeseeCamera* pEyeseeCam)
{
    delete pEyeseeCam;
}

status_t EyeseeCamera::openChannel(int chnId, bool bForceRef)
{
    status_t ret;
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;

    ret = pVIDevice->openChannel(chnId, bForceRef);
    if (ret != NO_ERROR) {
        aloge("Failed to open channel %d", chnId);
        return ret;
    }
    EyeseeCameraContext *pContext = (EyeseeCameraContext*)mpNativeContext;
    pVIDevice->setDataListener(chnId, pContext);
    pVIDevice->setNotifyListener(chnId, pContext);
    return NO_ERROR;
}

status_t EyeseeCamera::closeChannel(int chnId)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->closeChannel(chnId);
}

/*status_t EyeseeCamera::setDeviceAttr(VI_DEV_ATTR_S *devAttr)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->setDeviceAttr(devAttr);
}

status_t EyeseeCamera::getDeviceAttr(VI_DEV_ATTR_S *devAttr)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->getDeviceAttr(devAttr);
}*/

status_t EyeseeCamera::setChannelDisplay(int chnId, int hlay)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->setChannelDisplay(chnId, hlay);
}

status_t EyeseeCamera::changeChannelDisplay(int chnId, int hlay)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->changeChannelDisplay(chnId, hlay);
}

status_t EyeseeCamera::prepareDevice()
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->prepareDevice();
}

status_t EyeseeCamera::releaseDevice()
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->releaseDevice();
}

status_t EyeseeCamera::prepareChannel(int chnId)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->prepareChannel(chnId);
}

status_t EyeseeCamera::releaseChannel(int chnId)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->releaseChannel(chnId);
}

status_t EyeseeCamera::startDevice()
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->startDevice();
}

status_t EyeseeCamera::stopDevice()
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->stopDevice();
}

status_t EyeseeCamera::startChannel(int chnId)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->startChannel(chnId);
}

status_t EyeseeCamera::stopChannel(int chnId)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->stopChannel(chnId);
}

status_t EyeseeCamera::getMODParams(int chnId, MOTION_DETECT_ATTR_S *pParamMD)
{
    return mpVIDevice->getMODParams(chnId, pParamMD);
}

status_t EyeseeCamera::setMODParams(int chnId,MOTION_DETECT_ATTR_S pParamMD)
{
    return mpVIDevice->setMODParams(chnId, pParamMD);
}

status_t EyeseeCamera::startMODDetect(int chnId)
{
    return mpVIDevice->startMODDetect(chnId);
}

status_t EyeseeCamera::stopMODDetect(int chnId)
{
    return mpVIDevice->stopMODDetect(chnId);
}

status_t EyeseeCamera::getAdasParams(int chnId, AdasDetectParam *pParamADAS)
{
    return mpVIDevice->getAdasParams(chnId, pParamADAS);
}
status_t EyeseeCamera::setAdasParams(int chnId, AdasDetectParam pParamADAS)
{
    return mpVIDevice->setAdasParams(chnId, pParamADAS);
}
status_t EyeseeCamera::getAdasInParams(int chnId, AdasInParam *pParamADAS)
{
    return mpVIDevice->getAdasInParams(chnId, pParamADAS);
}
status_t EyeseeCamera::setAdasInParams(int chnId, AdasInParam pParamADAS)
{
    return mpVIDevice->setAdasInParams(chnId, pParamADAS);
}
status_t EyeseeCamera::startAdasDetect(int chnId)
{
    return mpVIDevice->startAdasDetect(chnId);
}
status_t EyeseeCamera::stopAdasDetect(int chnId)
{
    return mpVIDevice->stopAdasDetect(chnId);
}
//==========adas-v2===========
status_t EyeseeCamera::getAdasParams_v2(int chnId, AdasDetectParam_v2 *pParamADAS_v2)
{
    return mpVIDevice->getAdasParams_v2(chnId, pParamADAS_v2);
}
status_t EyeseeCamera::setAdasParams_v2(int chnId, AdasDetectParam_v2 pParamADAS_v2)
{
    return mpVIDevice->setAdasParams_v2(chnId, pParamADAS_v2);
}
status_t EyeseeCamera::getAdasInParams_v2(int chnId, AdasInParam_v2 *pParamADAS_v2)
{
    return mpVIDevice->getAdasInParams_v2(chnId, pParamADAS_v2);
}
status_t EyeseeCamera::setAdasInParams_v2(int chnId, AdasInParam_v2 pParamADAS_v2)
{
    return mpVIDevice->setAdasInParams_v2(chnId, pParamADAS_v2);
}
status_t EyeseeCamera::startAdasDetect_v2(int chnId)
{
    return mpVIDevice->startAdasDetect_v2(chnId);
}
status_t EyeseeCamera::stopAdasDetect_v2(int chnId)
{
    return mpVIDevice->stopAdasDetect_v2(chnId);
}



void EyeseeCamera::releaseRecordingFrame(int chnId, uint32_t index)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    pVIDevice->releaseRecordingFrame(chnId, index);
}

status_t EyeseeCamera::startRecording(int chnId, CameraRecordingProxyListener *pCb, int recorderId)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->startRecording(chnId, pCb, recorderId);
}

status_t EyeseeCamera::stopRecording(int chnId, int recorderId)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->stopRecording(chnId, recorderId);
}

status_t EyeseeCamera::setParameters(int chnId, CameraParameters &param)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->setParameters(chnId, param);
}

void EyeseeCamera::increaseBufRef(int chnId, VIDEO_FRAME_BUFFER_S *pBuf)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->increaseBufRef(chnId, pBuf);
}

status_t EyeseeCamera::setPicCapMode(int chnId, uint32_t cap_mode_en)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->setPicCapMode(chnId, cap_mode_en);
}

status_t EyeseeCamera::setFrmDrpThrForPicCapMode(int chnId,uint32_t frm_cnt)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->setFrmDrpThrForPicCapMode(chnId, frm_cnt);
} 


status_t EyeseeCamera::getParameters(int chnId, CameraParameters &param)
{
    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    return pVIDevice->getParameters(chnId, param);
}

status_t EyeseeCamera::setISPParameters(CameraParameters &param)
{
    return mpVIDevice->setISPParameters(param);
}

status_t EyeseeCamera::getISPParameters(CameraParameters &param)
{
    return mpVIDevice->getISPParameters(param);
}

status_t EyeseeCamera::configCameraWithMPPModules(int cameraId, CameraInfo *pCameraInfo)
{
    std::map<int, CameraInfo>::iterator it = mCameraInfos.find(cameraId);
    if (it == mCameraInfos.end())
    {
        mCameraInfos[cameraId] = *pCameraInfo;
        return NO_ERROR;
    }
    else
    {
        aloge("fatal error! cameraId[%d] has already exist, refuse reconfig!", cameraId);
        return UNKNOWN_ERROR;
    }
}

status_t EyeseeCamera::initCamerasConfiguration()
{
    AutoMutex lock(mCameraInfosLock);
    if(mCameraInfos.size() > 0)
    {
        return NO_ERROR;
    }
    alogw("warning: we don't init cameraInfos according to real system situation. It it not ready. So we use default for example.");
    int cameraId;
    CameraInfo cameraInfo;
    VI_CHN viChn;
    ISP_DEV ispDev;
    ISPGeometry stISPGeometry;

    cameraId = 0;
    cameraInfo.facing = CAMERA_FACING_BACK;
    cameraInfo.orientation = 0;
    cameraInfo.canDisableShutterSound = true;
    cameraInfo.mCameraDeviceType = CameraInfo::CAMERA_CSI;
    cameraInfo.mMPPGeometry.mCSIChn = 0;
    stISPGeometry.mISPDev = 1;
    stISPGeometry.mScalerOutChns.clear();
    viChn = 0;
    stISPGeometry.mScalerOutChns.push_back(viChn);
    viChn = 2;
    stISPGeometry.mScalerOutChns.push_back(viChn);
    cameraInfo.mMPPGeometry.mISPGeometrys.push_back(stISPGeometry);
    configCameraWithMPPModules(cameraId, &cameraInfo);

    CameraInfo cameraInfo1;
    cameraId = 1;
    cameraInfo1.facing = CAMERA_FACING_BACK;
    cameraInfo1.orientation = 0;
    cameraInfo1.canDisableShutterSound = true;
    cameraInfo1.mCameraDeviceType = CameraInfo::CAMERA_CSI;
    cameraInfo1.mMPPGeometry.mCSIChn = 1;
    stISPGeometry.mISPDev = 0;
    stISPGeometry.mScalerOutChns.clear();
    viChn = 1;
    stISPGeometry.mScalerOutChns.push_back(viChn);
    viChn = 3;
    stISPGeometry.mScalerOutChns.push_back(viChn);
    cameraInfo1.mMPPGeometry.mISPGeometrys.push_back(stISPGeometry);
    configCameraWithMPPModules(cameraId, &cameraInfo1);

    return NO_ERROR;
}

status_t EyeseeCamera::clearCamerasConfiguration()
{
    initCamerasConfiguration();
    AutoMutex lock(mCameraInfosLock);
    alogw("warning: I don't know how to operate lower v4l2 drivers, so it take no effect.");
    mCameraInfos.clear();
    return NO_ERROR;
}

status_t EyeseeCamera::getCameraInfo(int cameraId, CameraInfo *pCameraInfo)
{
    initCamerasConfiguration();
    AutoMutex lock(mCameraInfosLock);
    std::map<int, CameraInfo>::iterator it = mCameraInfos.find(cameraId);
    if (it == mCameraInfos.end())
    {
        aloge("fatal error! cameraId[%d] not exist", cameraId);
        return UNKNOWN_ERROR;
    }
    else
    {
        if(pCameraInfo)
        {
            *pCameraInfo = it->second;
        }
        return NO_ERROR;
    }
}

status_t EyeseeCamera::getCameraInfos(std::map<int, CameraInfo>& cameraInfos)
{
    initCamerasConfiguration();
    AutoMutex lock(mCameraInfosLock);
    cameraInfos = mCameraInfos;
    return NO_ERROR;
}

bool EyeseeCamera::previewEnabled(int chnId)
{
    return mpVIDevice->previewEnabled(chnId);
}

status_t EyeseeCamera::startRender(int chnId)
{
    return mpVIDevice->startRender(chnId);
}
status_t EyeseeCamera::stopRender(int chnId)
{
    return mpVIDevice->stopRender(chnId);
}
status_t EyeseeCamera::pauseRender(int chnId)
{
    return mpVIDevice->pauseRender(chnId);
}
status_t EyeseeCamera::resumeRender(int chnId)
{
    return mpVIDevice->resumeRender(chnId);
}

status_t EyeseeCamera::storeDisplayFrame(int chnId, uint64_t framePts)
{
    return mpVIDevice->storeDisplayFrame(chnId, framePts);
}

status_t EyeseeCamera::takePicture(int chnId, ShutterCallback *pShutter, PictureCallback *pRaw,
        PictureCallback *pJpeg, PictureRegionCallback *pPicReg)
{
    return takePicture(chnId, pShutter, pRaw, NULL, pJpeg, pPicReg);
}

status_t EyeseeCamera::takePicture(int chnId, ShutterCallback *pShutter, PictureCallback *pRaw,
        PictureCallback *pPostview, PictureCallback *pJpeg, PictureRegionCallback *pPicReg)
{
    AutoMutex lock(mSetTakePictureCallbackLock);
    
    alogv("takePicture");

    ShutterCallback *pOldShutterCallback = NULL;
    PictureCallback *pOldRawImageCallback = NULL;  
    PictureCallback *pOldJpegCallback = NULL;  
    PictureCallback *pOldPostviewCallback = NULL;
    PictureRegionCallback *pOldPictureRegionCallback = NULL;		// a serious of callback function
    
    std::map<int, TakePictureCallback>::iterator it = mTakePictureCallback.find(chnId);
    if(it == mTakePictureCallback.end())
    {
        TakePictureCallback Temp;
        Temp.mpShutterCallback = pShutter;
        Temp.mpRawImageCallback = pRaw;
        Temp.mpPostviewCallback = pPostview;
        Temp.mpJpegCallback = pJpeg;
        Temp.mpPictureRegionCallback = pPicReg;
        mTakePictureCallback.insert(make_pair(chnId, Temp));
        if((it = mTakePictureCallback.find(chnId)) == mTakePictureCallback.end())
        {
            aloge("fatal error!");
            return UNKNOWN_ERROR;
        }
    }
    else
    {
        pOldShutterCallback = it->second.mpShutterCallback;
        pOldRawImageCallback = it->second.mpRawImageCallback;
        pOldPostviewCallback = it->second.mpPostviewCallback;
        pOldPostviewCallback = it->second.mpJpegCallback;
        pOldPictureRegionCallback = it->second.mpPictureRegionCallback;
        
        it->second.mpShutterCallback = pShutter;
        it->second.mpRawImageCallback = pRaw;
        it->second.mpPostviewCallback = pPostview;
        it->second.mpJpegCallback = pJpeg;
        it->second.mpPictureRegionCallback = pPicReg;
    }
    
    // If callback is not set, do not send me callbacks.
    unsigned int msgType = 0;
    status_t ret = NO_ERROR;
    EyeseeCameraContext *context = (EyeseeCameraContext*)mpNativeContext;

    if (pShutter != NULL) {
        msgType |= CAMERA_MSG_SHUTTER;
    }
    if (pRaw != NULL) {
        msgType |= CAMERA_MSG_RAW_IMAGE;
    }
    if (pPostview != NULL) {
        msgType |= CAMERA_MSG_POSTVIEW_FRAME;
    }
    if (pJpeg != NULL) {
        msgType |= CAMERA_MSG_COMPRESSED_IMAGE;
    }

#if 0
    /*
     * When CAMERA_MSG_RAW_IMAGE is requested, if the raw image callback
     * buffer is available, CAMERA_MSG_RAW_IMAGE is enabled to get the
     * notification _and_ the data; otherwise, CAMERA_MSG_RAW_IMAGE_NOTIFY
     * is enabled to receive the callback notification but no data.
     */
    if (msgType & CAMERA_MSG_RAW_IMAGE) {
        alogv("Enable raw image callback buffer");
        if (!context->isRawImageCallbackBufferAvailable()) {
            alogv("Enable raw image notification, since no callback buffer exists");
            msgType &= ~CAMERA_MSG_RAW_IMAGE;
            msgType |= CAMERA_MSG_RAW_IMAGE_NOTIFY;
        }
    }
#endif

    VIDevice *pVIDevice = (VIDevice*)mpVIDevice;
    ret = pVIDevice->takePicture(chnId, msgType, pPicReg);
    if (ret != NO_ERROR) {
        aloge("takePicture failed");
        it->second.mpShutterCallback = pOldShutterCallback;
        it->second.mpRawImageCallback = pOldRawImageCallback;
        it->second.mpPostviewCallback = pOldPostviewCallback ;
        it->second.mpJpegCallback = pOldPostviewCallback;
        it->second.mpPictureRegionCallback = pOldPictureRegionCallback;
        return ret;
    }
    
    return NO_ERROR;
}

status_t EyeseeCamera::cancelContinuousPicture(int chnId)
{
    status_t ret = mpVIDevice->cancelContinuousPicture(chnId);
    if (ret != NO_ERROR)
    {
        aloge("cancelContinuousPicture failed[0x%x]", ret);
    }
    return ret;
}

status_t EyeseeCamera::KeepPictureEncoder(int chnId, bool bKeep)
{
    return mpVIDevice->KeepPictureEncoder(chnId, bKeep);
}

status_t EyeseeCamera::releasePictureEncoder(int chnId)
{
    return mpVIDevice->releasePictureEncoder(chnId);
}

//add by jason
/*
status_t EyeseeCamera::getISPDMsg(int * exp, int * exp_line, int * gain, int * lv_idx, int * color_temp, int * rgain, int * bgain)
{
	int t1,t2,t3,t4,t5,t6,t7;
    mpVIDevice->getISPDMsg(&t1, &t2, &t3, &t4, &t5, &t6, &t7);
	*exp		 	= t1; 
	*exp_line 		= t2;  
	*gain 			= t3;  
	*lv_idx 		= t4;  
	*color_temp 	= t5; 
	*rgain 			= t6;  
	*bgain 			= t7; 
	return 0;
}
*/

//add by alien
status_t EyeseeCamera::getISPDMsg(int * exp, int * exp_line, int * gain, int * lv_idx, int * color_temp, int * rgain, int * bgain, int * grgain, int * gbgain)
{
	int t1,t2,t3,t4,t5,t6,t7,t8,t9;
    mpVIDevice->getISPDMsg(&t1, &t2, &t3, &t4, &t5, &t6, &t7, &t8, &t9);
	*exp		 	= t1; 
	*exp_line 		= t2;  
	*gain 			= t3;  
	*lv_idx 		= t4;  
	*color_temp 	= t5; 
	*rgain 			= t6;  
	*bgain 			= t7; 
	*grgain         = t8;
	*gbgain         = t9;
	
	return 0;
}



void EyeseeCamera::addCallbackBuffer(CMediaMemory &callbackBuffer)
{
    alogw("addCallbackBuffer is not implement now!");
    // todo
}

void EyeseeCamera::addRawImageCallbackBuffer(CMediaMemory &callbackBuffer)
{
    alogw("addRawImageCallbackBuffer is not implement now!");
    // todo
}

void EyeseeCamera::addCallbackBuffer(CMediaMemory &callbackBuffer, int msgType)
{
    // todo
}

void EyeseeCamera::_addCallbackBuffer(CMediaMemory &callbackBuffer, int msgType)
{
    // todo
}

void EyeseeCamera::setPreviewCallback(PreviewCallback *pCb)
{
    // todo
}

void EyeseeCamera::setOneShotPreviewCallback(PreviewCallback *pCb)
{
    // todo
}

void EyeseeCamera::setPreviewCallbackWithBuffer(PreviewCallback *pCb)
{
    // todo
}

void EyeseeCamera::setHasPreviewCallback(bool installed, bool manualBuffer)
{
    // todo
}

void EyeseeCamera::setMODDataCallback(MODDataCallback *pCb)
{
    mpMODDataCallback = pCb;
}
void EyeseeCamera::setAdasDataCallback(AdasDataCallback *pCb)
{
    mpAdasDataCallback = pCb;
}
/*status_t  EyeseeCamera::setWaterMark(int enable, const char *str)
{
    // todo
    return NO_ERROR;
}

status_t EyeseeCamera::setOSDRects(int chnId, std::list<OSDRectInfo> &rects)
{
    return mpVIDevice->setOSDRects(chnId, rects);
}

status_t EyeseeCamera::getOSDRects(int chnId, std::list<OSDRectInfo> **ppRects)
{
    return mpVIDevice->getOSDRects(chnId, ppRects);
}

status_t EyeseeCamera::OSDOnOff(int chnId, bool bOnOff)
{
    return mpVIDevice->OSDOnOff(chnId, bOnOff);
}*/

RGN_HANDLE EyeseeCamera::createRegion(const RGN_ATTR_S *pstRegion)
{
    return mpVIDevice->createRegion(pstRegion);
}
status_t EyeseeCamera::getRegionAttr(RGN_HANDLE Handle, RGN_ATTR_S *pstRgnAttr)
{
    return mpVIDevice->getRegionAttr(Handle, pstRgnAttr);
}
status_t EyeseeCamera::setRegionBitmap(RGN_HANDLE Handle, const BITMAP_S *pBitmap)
{
    return mpVIDevice->setRegionBitmap(Handle, pBitmap);
}
status_t EyeseeCamera::attachRegionToChannel(RGN_HANDLE Handle, int chnId, const RGN_CHN_ATTR_S *pstChnAttr)
{
    return mpVIDevice->attachRegionToChannel(Handle, chnId, pstChnAttr);
}
status_t EyeseeCamera::detachRegionFromChannel(RGN_HANDLE Handle, int chnId)
{
    return mpVIDevice->detachRegionFromChannel(Handle, chnId);
}
status_t EyeseeCamera::setRegionDisplayAttr(RGN_HANDLE Handle, int chnId, const RGN_CHN_ATTR_S *pstChnAttr)
{
    return mpVIDevice->setRegionDisplayAttr(Handle, chnId, pstChnAttr);
}
status_t EyeseeCamera::getRegionDisplayAttr(RGN_HANDLE Handle, int chnId, RGN_CHN_ATTR_S *pstChnAttr)
{
    return mpVIDevice->getRegionDisplayAttr(Handle, chnId, pstChnAttr);
}
status_t EyeseeCamera::destroyRegion(RGN_HANDLE Handle)
{
    return mpVIDevice->destroyRegion(Handle);
}

bool EyeseeCamera::enableShutterSound(bool enabled)
{
    // todo
    return true;
}

void EyeseeCamera::setErrorCallback(ErrorCallback *pCb)
{
    mpErrorCallback = pCb;
}

void EyeseeCamera::setInfoCallback(InfoCallback *pCb)
{
    mpInfoCallback = pCb;
}

CameraRecordingProxy* EyeseeCamera::getRecordingProxy()
{
    alogv("getProxy");
    return new CameraProxy(this);
}

EyeseeCamera::CameraProxy::CameraProxy(EyeseeCamera *pCamera)
{
    mpCamera = pCamera;
}

// CameraRecordingProxy interface
status_t EyeseeCamera::CameraProxy::startRecording(int chnId, CameraRecordingProxyListener *pListener, int recorderId)
{
    return mpCamera->startRecording(chnId, pListener, recorderId);
}

status_t EyeseeCamera::CameraProxy::stopRecording(int chnId, int recorderId)
{
    return mpCamera->stopRecording(chnId, recorderId);
}

void EyeseeCamera::CameraProxy::releaseRecordingFrame(int chnId, uint32_t frameIndex)
{
    return mpCamera->releaseRecordingFrame(chnId, frameIndex);
}

status_t EyeseeCamera::CameraProxy::setChannelDisplay(int chnId, int hlay)
{
    return mpCamera->setChannelDisplay(chnId, hlay);
}

status_t EyeseeCamera::CameraProxy::getParameters(int chnId, CameraParameters &param)
{
    return mpCamera->getParameters(chnId, param);
}

status_t EyeseeCamera::CameraProxy::setParameters(int chnId, CameraParameters &param)
{
    return mpCamera->setParameters(chnId, param);
}

void EyeseeCamera::CameraProxy::increaseBufRef(int chnId, VIDEO_FRAME_BUFFER_S *pBuf)
{
    return mpCamera->increaseBufRef(chnId, pBuf);
}

}; /* namespace EyeseeLinux */