/****************************************************************************** Copyright (C), 2001-2016, Allwinner Tech. Co., Ltd. ****************************************************************************** File Name : VIDevice.cpp Version : Initial Draft Author : Allwinner BU3-PD2 Team Created : 2016/06/06 Last Modified : Description : camera wrap MPP components. Function List : History : ******************************************************************************/ //#define LOG_NDEBUG 0 #define LOG_TAG "VIDevice" #include #include #include #include #include #include #include #include #include #include #include "VIChannel.h" #include "VIDevice.h" #define SUPPORT_ISP #define ILLEGAL_ISP_PARAM (-1024) using namespace std; namespace EyeseeLinux { VIDevice::VIDevice(int cameraId, CameraInfo *pCameraInfo) : mVIDeviceState(VI_STATE_CONSTRUCTED) , mCameraId(cameraId) { alogd("Construct"); mCameraInfo = *pCameraInfo; vector::iterator it = mCameraInfo.mMPPGeometry.mISPGeometrys.begin(); mIspDevId = it->mISPDev; //memset(&mDevAttr, 0, sizeof(mDevAttr)); mbIspRun = false; mbRefChannelPrepared = false; } VIDevice::~VIDevice() { alogd("Destruct"); ERRORTYPE ret; size_t num = mRgnHandleList.size(); if(num > 0) { alogw("Be careful! There are [%d]regions need to destroy!", num); for(RGN_HANDLE& i : mRgnHandleList) { ret = AW_MPI_RGN_Destroy(i); if(SUCCESS != ret) { aloge("fatal error! destroy region[%d] fail!", i); } } } } VIChannel *VIDevice::searchVIChannel(int chnId) { AutoMutex lock(mVIChannelVectorLock); for (vector::iterator it = mVIChannelVector.begin(); it != mVIChannelVector.end(); ++it) { if (it->mChnId == chnId) { return it->mpChannel; } } return NULL; } status_t VIDevice::setChannelDisplay(int chnId, int hlay) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->setPreviewDisplay(hlay); } status_t VIDevice::changeChannelDisplay(int chnId, int hlay) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->changePreviewDisplay(hlay); } bool VIDevice::previewEnabled(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return false; } return pChannel->isPreviewEnabled(); } status_t VIDevice::startRender(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->startRender(); } status_t VIDevice::stopRender(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->stopRender(); } status_t VIDevice::pauseRender(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->pauseRender(); } status_t VIDevice::resumeRender(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->resumeRender(); } status_t VIDevice::storeDisplayFrame(int chnId, uint64_t framePts) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->storeDisplayFrame(framePts); } /* status_t VIDevice::setDeviceAttr(VI_DEV_ATTR_S *devAttr) { mDevAttr = *devAttr; return NO_ERROR; } status_t VIDevice::getDeviceAttr(VI_DEV_ATTR_S *devAttr) { *devAttr = mDevAttr; return NO_ERROR; } */ status_t VIDevice::setParameters(int chnId, CameraParameters ¶m) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { alogd("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->setParameters(param); } void VIDevice::increaseBufRef(int chnId, VIDEO_FRAME_BUFFER_S *pBuf) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL){ alogd("channel %d is not exist!", chnId); return ; } return pChannel->increaseBufRef(pBuf); } status_t VIDevice::setPicCapMode(int chnId, uint32_t cap_mode_en) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { alogd("channel %d is not exist!", chnId); return NO_INIT; } pChannel->setPicCapMode(cap_mode_en); return NO_ERROR; } status_t VIDevice::setFrmDrpThrForPicCapMode(int chnId,uint32_t frm_cnt) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { alogd("channel %d is not exist!", chnId); return NO_INIT; } pChannel->setFrmDrpThrForPicCapMode(frm_cnt); return NO_ERROR; } status_t VIDevice::getParameters(int chnId, CameraParameters ¶m) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { alogd("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->getParameters(param); } status_t VIDevice::setISPParameters(CameraParameters ¶m) { // if(mVIDeviceState!=VI_STATE_PREPARED && mVIDeviceState!=VI_STATE_STARTED) // { // alogw("set isp parameters in wrong state[0x%x]", mVIDeviceState); // return INVALID_OPERATION; // } Mutex::Autolock lock(mVIChannelVectorLock); bool bCanSet = false; for(VIChannelInfo& i : mVIChannelVector) { if(VIChannel::VI_CHN_STATE_STARTED == i.mpChannel->getState()) { bCanSet = true; break; } } if(bCanSet) { #if (defined(SUPPORT_ISP)) printf("[FUN]:%s mIspDevId:%d \n", __FUNCTION__,mIspDevId); //detect param change, and update. //ModuleOnOff ISP_MODULE_ONOFF& curModuleOnOff = mISPParameters.getModuleOnOff(); ISP_MODULE_ONOFF& newModuleOnOff = param.getModuleOnOff(); if(memcmp(&curModuleOnOff, &newModuleOnOff, sizeof(ISP_MODULE_ONOFF))) { alogd("change ISP_ModuleOnOff"); AW_MPI_ISP_SetModuleOnOff(mIspDevId, &newModuleOnOff); } //AE mode int curAEMode = mISPParameters.ChnIspAe_GetMode(); int newAEMode = param.ChnIspAe_GetMode(); if(curAEMode!= newAEMode) { alogd("change AE mode"); AW_MPI_ISP_AE_SetMode(mIspDevId, newAEMode); } //AE exposure bias int curAEExposureBias = mISPParameters.ChnIspAe_GetExposureBias(); int newAEExposureBias = param.ChnIspAe_GetExposureBias(); if(curAEExposureBias != newAEExposureBias) { alogd("change AE Exposure Bias"); AW_MPI_ISP_AE_SetExposureBias(mIspDevId, newAEExposureBias); } //AE exposure int curAEExposure = mISPParameters.ChnIspAe_GetExposure(); int newAEExposure = param.ChnIspAe_GetExposure(); if(curAEExposure != newAEExposure) { alogd("change AE exposure"); AW_MPI_ISP_AE_SetExposure(mIspDevId, newAEExposure); } //AE gain int curAEGain = mISPParameters.ChnIspAe_GetGain(); int newAEGain = param.ChnIspAe_GetGain(); if(curAEGain != newAEGain) { alogd("change AE Gain"); AW_MPI_ISP_AE_SetGain(mIspDevId, newAEGain); } //AE ISOSensitive int curAEISOSensitive = mISPParameters.ChnIspAe_GetISOSensitive(); int newAEISOSensitive = param.ChnIspAe_GetISOSensitive(); if(curAEISOSensitive != newAEISOSensitive) { alogd("change AE ISOSensitive[%d]->[%d]", curAEISOSensitive, newAEISOSensitive); AW_MPI_ISP_AE_SetISOSensitive(mIspDevId, newAEISOSensitive); } //AE Metering int curMetering = mISPParameters.ChnIspAe_GetMetering(); int newMetering = param.ChnIspAe_GetMetering(); if(curMetering != newMetering) { alogd("change AE curMetering[%d]->[%d]", curMetering, newMetering); AW_MPI_ISP_AE_SetMetering(mIspDevId, newMetering); } //AWB Mode(0-1,2-7) int curAwbMode = mISPParameters.ChnIspAwb_GetMode(); int newAwbMode = param.ChnIspAwb_GetMode(); if(curAwbMode != newAwbMode) { if (newAwbMode==0 || newAwbMode==1) { AW_MPI_ISP_AWB_SetMode(mIspDevId, newAwbMode); } else { AW_MPI_ISP_AWB_SetColorTemp(mIspDevId, newAwbMode); } } //AWB RGain int curAwbRGain= mISPParameters.ChnIspAwb_GetRGain(); int newAwbRGain = param.ChnIspAwb_GetRGain(); if(curAwbRGain != newAwbRGain) { alogd("change AWB RGain"); AW_MPI_ISP_AWB_SetRGain(mIspDevId, newAwbRGain); } //AWB GrGain int curAwbGrGain= mISPParameters.ChnIspAwb_GetGrGain(); int newAwbGrGain = param.ChnIspAwb_GetGrGain(); if(curAwbGrGain != newAwbGrGain) { alogd("change AWB GrGain"); AW_MPI_ISP_AWB_SetGrGain(mIspDevId, newAwbGrGain); } //AWB GbGain int curAwbGbGain= mISPParameters.ChnIspAwb_GetGbGain(); int newAwbGbGain = param.ChnIspAwb_GetGbGain(); if(curAwbGbGain != newAwbGbGain) { alogd("change AWB GbGain"); AW_MPI_ISP_AWB_SetGbGain(mIspDevId, newAwbGbGain); } //AWB BGain int curAwbBGain= mISPParameters.ChnIspAwb_GetBGain(); int newAwbBGain = param.ChnIspAwb_GetBGain(); if(curAwbBGain != newAwbBGain) { alogd("change AWB BGain"); AW_MPI_ISP_AWB_SetBGain(mIspDevId, newAwbBGain); } //Flicker int curFlicker = mISPParameters.ChnIsp_GetFlicker(); int newFlicker = param.ChnIsp_GetFlicker(); if(curFlicker != newFlicker) { alogd("change flicker"); AW_MPI_ISP_SetFlicker(mIspDevId, newFlicker); } //brightness int curBrightness = mISPParameters.ChnIsp_GetBrightness(); int newBrightness = param.ChnIsp_GetBrightness(); if(curBrightness != newBrightness) { alogd("change brightness"); AW_MPI_ISP_SetBrightness(mIspDevId, newBrightness); } //contrast int curContrast = mISPParameters.ChnIsp_GetContrast(); int newContrast = param.ChnIsp_GetContrast(); if(curContrast != newContrast) { alogd("change contrast"); AW_MPI_ISP_SetContrast(mIspDevId, newContrast); } //saturation int curSaturation = mISPParameters.ChnIsp_GetSaturation(); int newSaturation = param.ChnIsp_GetSaturation(); if(curSaturation != newSaturation) { alogd("change saturation"); AW_MPI_ISP_SetSaturation(mIspDevId, newSaturation); } //sharpness int curSharpness = mISPParameters.ChnIsp_GetSharpness(); int newSharpness = param.ChnIsp_GetSharpness(); if(curSharpness != newSharpness) { alogd("change sharpness"); AW_MPI_ISP_SetSharpness(mIspDevId, newSharpness); } //hue /*int curHue = mISPParameters.ChnIsp_GetHue(); int newHue = param.ChnIsp_GetHue(); if(curHue != newHue) { alogd("change hue"); AW_MPI_ISP_SetHue(mIspDevId, newHue); }*/ //INI ISP config int curNRAttr = mISPParameters.getNRAttrValue(); int newNRAttr = param.getNRAttrValue(); if(curNRAttr != newNRAttr) { alogd("change ISP_NR_ATTR"); AW_MPI_ISP_SetNRAttr(mIspDevId, newNRAttr); } int cur3NRAttr = mISPParameters.get3NRAttrValue(); int new3NRAttr = param.get3NRAttrValue(); if(cur3NRAttr != new3NRAttr) { alogd("change ISP_3NR_ATTR"); AW_MPI_ISP_Set3NRAttr(mIspDevId, new3NRAttr); } //WDR int curPltmWDR = mISPParameters.getPltmWDR(); int newPltmWDR = param.getPltmWDR(); if(curPltmWDR != newPltmWDR) { alogd("change ISP_PltmWDR"); AW_MPI_ISP_SetPltmWDR(mIspDevId, newPltmWDR); } #endif } mISPParameters = param; return NO_ERROR; } status_t VIDevice::getISPParameters(CameraParameters ¶m) { param = mISPParameters; return NO_ERROR; } /* status_t VIDevice::setOSDRects(int chnId, std::list &rects) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("fatal error! VIPP channel[%d] is not exist!", chnId); return UNKNOWN_ERROR; } return pChannel->setOSDRects(rects); } status_t VIDevice::getOSDRects(int chnId, std::list **ppRects) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("fatal error! VIPP channel[%d] is not exist!", chnId); return UNKNOWN_ERROR; } return pChannel->getOSDRects(ppRects); } status_t VIDevice::OSDOnOff(int chnId, bool bOnOff) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("fatal error! VIPP channel[%d] is not exist!", chnId); return UNKNOWN_ERROR; } return pChannel->OSDOnOff(bOnOff); } */ RGN_HANDLE VIDevice::createRegion(const RGN_ATTR_S *pstRegion) { Mutex::Autolock lock(mRgnLock); ERRORTYPE ret; bool bSuccess = false; RGN_HANDLE handle = 0; while(handle < RGN_HANDLE_MAX) { ret = AW_MPI_RGN_Create(handle, pstRegion); if(SUCCESS == ret) { bSuccess = true; alogd("create region[%d] success!", handle); break; } else if(ERR_RGN_EXIST == ret) { alogv("region[%d] is exist, find next!", handle); handle++; } else { aloge("fatal error! create region[%d] ret[0x%x]!", handle, ret); break; } } if(bSuccess) { mRgnHandleList.push_back(handle); return handle; } else { alogd("create region fail"); return MM_INVALID_HANDLE; } } status_t VIDevice::getRegionAttr(RGN_HANDLE Handle, RGN_ATTR_S *pstRgnAttr) { Mutex::Autolock lock(mRgnLock); status_t result = NO_ERROR; bool bExist = false; for(RGN_HANDLE& i : mRgnHandleList) { if(i == Handle) { bExist = true; break; } } if(bExist) { ERRORTYPE ret = AW_MPI_RGN_GetAttr(Handle, pstRgnAttr); if(SUCCESS == ret) { result = NO_ERROR; } else { result = UNKNOWN_ERROR; } } else { result = UNKNOWN_ERROR; } return result; } status_t VIDevice::setRegionBitmap(RGN_HANDLE Handle, const BITMAP_S *pBitmap) { Mutex::Autolock lock(mRgnLock); status_t result = NO_ERROR; bool bExist = false; for(RGN_HANDLE& i : mRgnHandleList) { if(i == Handle) { bExist = true; break; } } if(bExist) { ERRORTYPE ret = AW_MPI_RGN_SetBitMap(Handle, pBitmap); if(SUCCESS == ret) { result = NO_ERROR; } else { result = UNKNOWN_ERROR; } } else { result = UNKNOWN_ERROR; } return result; } status_t VIDevice::attachRegionToChannel(RGN_HANDLE Handle, int chnId, const RGN_CHN_ATTR_S *pstChnAttr) { status_t result = NO_ERROR; Mutex::Autolock autoLock(mVIChannelVectorLock); VIChannel::VIChannelState chnState; bool bChannelExist = false; for(VIChannelInfo& i : mVIChannelVector) { if(i.mChnId == chnId) { chnState = i.mpChannel->getState(); bChannelExist = true; break; } } if(false == bChannelExist) { aloge("fatal error! wrong camera vipp[%d]", chnId); return UNKNOWN_ERROR; } if(chnState != VIChannel::VI_CHN_STATE_STARTED) { aloge("fatal error! vipp state[%d] is not started, can't attach region!", chnState); return UNKNOWN_ERROR; } Mutex::Autolock lock(mRgnLock); bool bExist = false; for(RGN_HANDLE& i : mRgnHandleList) { if(i == Handle) { bExist = true; break; } } if(bExist) { MPP_CHN_S stChn = {MOD_ID_VIU, chnId, 0}; ERRORTYPE ret = AW_MPI_RGN_AttachToChn(Handle, &stChn, pstChnAttr); if(SUCCESS == ret) { result = NO_ERROR; } else { result = UNKNOWN_ERROR; } } else { aloge("fatal error! region[%d] is unexist!", Handle); result = UNKNOWN_ERROR; } return result; } status_t VIDevice::detachRegionFromChannel(RGN_HANDLE Handle, int chnId) { status_t result = NO_ERROR; Mutex::Autolock autoLock(mVIChannelVectorLock); bool bChannelExist = false; for(VIChannelInfo& i : mVIChannelVector) { if(i.mChnId == chnId) { bChannelExist = true; break; } } if(false == bChannelExist) { aloge("fatal error! wrong camera vipp[%d]", chnId); return UNKNOWN_ERROR; } Mutex::Autolock lock(mRgnLock); bool bExist = false; for(RGN_HANDLE& i : mRgnHandleList) { if(i == Handle) { bExist = true; break; } } if(bExist) { MPP_CHN_S stChn = {MOD_ID_VIU, chnId, 0}; ERRORTYPE ret = AW_MPI_RGN_DetachFromChn(Handle, &stChn); if(SUCCESS == ret) { result = NO_ERROR; } else { result = UNKNOWN_ERROR; } } else { aloge("fatal error! region[%d] is unexist!", Handle); result = UNKNOWN_ERROR; } return result; } status_t VIDevice::setRegionDisplayAttr(RGN_HANDLE Handle, int chnId, const RGN_CHN_ATTR_S *pstChnAttr) { status_t result = NO_ERROR; Mutex::Autolock autoLock(mVIChannelVectorLock); bool bChannelExist = false; for(VIChannelInfo& i : mVIChannelVector) { if(i.mChnId == chnId) { bChannelExist = true; break; } } if(false == bChannelExist) { aloge("fatal error! wrong camera vipp[%d]", chnId); return UNKNOWN_ERROR; } Mutex::Autolock lock(mRgnLock); bool bExist = false; for(RGN_HANDLE& i : mRgnHandleList) { if(i == Handle) { bExist = true; break; } } if(bExist) { MPP_CHN_S stChn = {MOD_ID_VIU, chnId, 0}; ERRORTYPE ret = AW_MPI_RGN_SetDisplayAttr(Handle, &stChn, pstChnAttr); if(SUCCESS == ret) { result = NO_ERROR; } else { result = UNKNOWN_ERROR; } } else { aloge("fatal error! region[%d] is unexist!", Handle); result = UNKNOWN_ERROR; } return result; } status_t VIDevice::getRegionDisplayAttr(RGN_HANDLE Handle, int chnId, RGN_CHN_ATTR_S *pstChnAttr) { status_t result = NO_ERROR; Mutex::Autolock autoLock(mVIChannelVectorLock); bool bChannelExist = false; for(VIChannelInfo& i : mVIChannelVector) { if(i.mChnId == chnId) { bChannelExist = true; break; } } if(false == bChannelExist) { aloge("fatal error! wrong camera vipp[%d]", chnId); return UNKNOWN_ERROR; } Mutex::Autolock lock(mRgnLock); bool bExist = false; for(RGN_HANDLE& i : mRgnHandleList) { if(i == Handle) { bExist = true; break; } } if(bExist) { MPP_CHN_S stChn = {MOD_ID_VIU, chnId, 0}; ERRORTYPE ret = AW_MPI_RGN_GetDisplayAttr(Handle, &stChn, pstChnAttr); if(SUCCESS == ret) { result = NO_ERROR; } else { result = UNKNOWN_ERROR; } } else { aloge("fatal error! region[%d] is unexist!", Handle); result = UNKNOWN_ERROR; } return result; } status_t VIDevice::destroyRegion(RGN_HANDLE Handle) { status_t result = NO_ERROR; Mutex::Autolock lock(mRgnLock); bool bExist = false; std::list::iterator it; for(it = mRgnHandleList.begin(); it != mRgnHandleList.end(); ++it) { if(*it == Handle) { bExist = true; break; } } if(bExist) { ERRORTYPE ret = AW_MPI_RGN_Destroy(Handle); if(SUCCESS == ret) { mRgnHandleList.erase(it); result = NO_ERROR; } else { result = UNKNOWN_ERROR; } } else { aloge("fatal error! region[%d] is unexist!", Handle); result = UNKNOWN_ERROR; } return result; } status_t VIDevice::initIspParameters() { #if 0 //brightness int defaultBrightness; AW_MPI_ISP_GetBrightness(mIspDevId, &defaultBrightness); //contrast int defaultContrast; AW_MPI_ISP_GetContrast(mIspDevId, &defaultContrast); //saturation int defaultSaturation; AW_MPI_ISP_GetSaturation(mIspDevId, &defaultSaturation); //hue // int defaultHue; // AW_MPI_ISP_GetHue(mIspDevId, &defaultHue); //AE mode int defaultAEMode; AW_MPI_ISP_AE_GetMode(mIspDevId, &defaultAEMode); //AE exposure bias int defaultAEExposureBias; AW_MPI_ISP_AE_GetExposureBias(mIspDevId, &defaultAEExposureBias); //AE exposure int defaultAEExposure; AW_MPI_ISP_AE_GetExposure(mIspDevId, &defaultAEExposure); //AE gain int defaultAEGain; AW_MPI_ISP_AE_GetGain(mIspDevId, &defaultAEGain); //AE ISOSensitive int defaultAEISOSensitive = -1; AW_MPI_ISP_AE_GetISOSensitive(mIspDevId, &defaultAEISOSensitive); //AE Metering int defaultAEMetering = -1; AW_MPI_ISP_AE_GetMetering(mIspDevId, &defaultAEMetering); //AWB mode int defaultAwbMode; AW_MPI_ISP_AWB_GetMode(mIspDevId, &defaultAwbMode); //AWB color temp int defaultColorTemp; AW_MPI_ISP_AWB_GetColorTemp(mIspDevId, &defaultColorTemp); //AWB color RGain int defaultColorRGain = -1; AW_MPI_ISP_AWB_GetRGain(mIspDevId, &defaultColorRGain); //AWB color BGain int defaultColorBGain = -1; AW_MPI_ISP_AWB_GetBGain(mIspDevId, &defaultColorBGain); //flicker int defaultFlicker = -1; AW_MPI_ISP_GetFlicker(mIspDevId, &defaultFlicker); //sharpness int defaultSharpness = -1; AW_MPI_ISP_GetSharpness(mIspDevId, &defaultSharpness); //detailed AWB param setting //ISP_WB_ATTR_S defaultWBAttr; //AW_MPI_ISP_AWB_GetWBAttr(mIspDevId, &defaultWBAttr); // ISP_COLORMATRIX_ATTR_S defaultCMAttr; // AW_MPI_ISP_AWB_GetCCMAttr(mIspDevId, 0, &defaultCMAttr); // ISP_AWB_SPEED_S defaultWBSpeed; // AW_MPI_ISP_AWB_GetSpeed(mIspDevId, &defaultWBSpeed); // ISP_AWB_TEMP_RANGE_S defaultWBTempRange; // AW_MPI_ISP_AWB_GetTempRange(mIspDevId, &defaultWBTempRange); // std::map defaultWBLights; // int nLightMode; // ISP_AWB_TEMP_INFO_S defaultWBTempInfo; // nLightMode = 0x01; // AW_MPI_ISP_AWB_GetLight(mIspDevId, nLightMode, &defaultWBTempInfo); // defaultWBLights[nLightMode] = defaultWBTempInfo; // nLightMode = 0x02; // AW_MPI_ISP_AWB_GetLight(mIspDevId, nLightMode, &defaultWBTempInfo); // defaultWBLights[nLightMode] = defaultWBTempInfo; // nLightMode = 0x03; // AW_MPI_ISP_AWB_GetLight(mIspDevId, nLightMode, &defaultWBTempInfo); // defaultWBLights[nLightMode] = defaultWBTempInfo; // nLightMode = 0x04; // AW_MPI_ISP_AWB_GetLight(mIspDevId, nLightMode, &defaultWBTempInfo); // defaultWBLights[nLightMode] = defaultWBTempInfo; // ISP_AWB_FAVOR_S defaultWBFavor; // AW_MPI_ISP_AWB_GetFavor(mIspDevId, &defaultWBFavor); mISPParameters.ChnIspAe_SetMode(defaultAEMode); mISPParameters.ChnIspAe_SetExposureBias(defaultAEExposureBias); mISPParameters.ChnIspAe_SetExposure(defaultAEExposure); mISPParameters.ChnIspAe_SetGain(defaultAEGain); mISPParameters.ChnIspAe_SetISOSensitive(defaultAEISOSensitive); mISPParameters.ChnIspAe_SetMetering(defaultAEMetering); mISPParameters.ChnIspAwb_SetMode(defaultAwbMode); mISPParameters.ChnIspAwb_SetColorTemp(defaultColorTemp); mISPParameters.ChnIsp_SetFlicker(defaultFlicker); mISPParameters.ChnIsp_SetBrightness(defaultBrightness); mISPParameters.ChnIsp_SetContrast(defaultContrast); mISPParameters.ChnIsp_SetSaturation(defaultSaturation); mISPParameters.ChnIsp_SetSharpness(defaultSharpness); //mISPParameters.ChnIsp_SetHue(defaultHue); #else mISPParameters.ChnIspAe_SetMode(ILLEGAL_ISP_PARAM); mISPParameters.ChnIspAe_SetExposureBias(ILLEGAL_ISP_PARAM); mISPParameters.ChnIspAe_SetExposure(ILLEGAL_ISP_PARAM); mISPParameters.ChnIspAe_SetGain(ILLEGAL_ISP_PARAM); mISPParameters.ChnIspAe_SetISOSensitive(ILLEGAL_ISP_PARAM); mISPParameters.ChnIspAe_SetMetering(ILLEGAL_ISP_PARAM); mISPParameters.ChnIspAwb_SetMode(ILLEGAL_ISP_PARAM); mISPParameters.ChnIspAwb_SetColorTemp(ILLEGAL_ISP_PARAM); mISPParameters.ChnIsp_SetFlicker(ILLEGAL_ISP_PARAM); mISPParameters.ChnIsp_SetBrightness(ILLEGAL_ISP_PARAM); mISPParameters.ChnIsp_SetContrast(ILLEGAL_ISP_PARAM); mISPParameters.ChnIsp_SetSaturation(ILLEGAL_ISP_PARAM); mISPParameters.ChnIsp_SetSharpness(ILLEGAL_ISP_PARAM); //mISPParameters.ChnIsp_SetHue(ILLEGAL_ISP_PARAM); //INI ISP config ISP_MODULE_ONOFF defaultModuleOnOff; AW_MPI_ISP_GetModuleOnOff(mIspDevId, &defaultModuleOnOff); int defaultNRAttrValue; AW_MPI_ISP_GetNRAttr(mIspDevId, &defaultNRAttrValue); int default3NRAttrValue; AW_MPI_ISP_Get3NRAttr(mIspDevId, &default3NRAttrValue); int defaultPltmWDR; AW_MPI_ISP_GetPltmWDR(mIspDevId, &defaultPltmWDR); mISPParameters.setModuleOnOff(defaultModuleOnOff); mISPParameters.setNRAttrValue(defaultNRAttrValue); mISPParameters.set3NRAttrValue(default3NRAttrValue); mISPParameters.setPltmWDR(defaultPltmWDR); // mISPParameters.setAWB_WBAttrValue(defaultWBAttr); // mISPParameters.setAWB_CCMAttrValue(defaultCMAttr); // mISPParameters.setAWB_SpeedValue(defaultWBSpeed); // mISPParameters.setAWB_TempRangeValue(defaultWBTempRange); // mISPParameters.setAWB_LightValues(defaultWBLights); // mISPParameters.setAWB_FavorValue(defaultWBFavor); // mISPParameters.setFlickerValue(defaultFlicker); #endif return NO_ERROR; } status_t VIDevice::prepareDevice() { int ret; if (mVIDeviceState != VI_STATE_CONSTRUCTED) { aloge("prepareDevice in error state %d", mVIDeviceState); return INVALID_OPERATION; } if(CameraInfo::CAMERA_CSI == mCameraInfo.mCameraDeviceType) { } else if(CameraInfo::CAMERA_USB == mCameraInfo.mCameraDeviceType) { aloge("need implement"); } else { aloge("unsupported temporary"); } mVIDeviceState = VI_STATE_PREPARED; return NO_ERROR; } status_t VIDevice::releaseDevice() { if (mVIDeviceState != VI_STATE_PREPARED) { aloge("releaseDevice in error state %d", mVIDeviceState); return INVALID_OPERATION; } if(CameraInfo::CAMERA_CSI == mCameraInfo.mCameraDeviceType) { } else if(CameraInfo::CAMERA_USB == mCameraInfo.mCameraDeviceType) { aloge("need implement"); } else { aloge("unsupported temporary"); } mVIDeviceState = VI_STATE_CONSTRUCTED; return NO_ERROR; } status_t VIDevice::startDevice() { if (mVIDeviceState != VI_STATE_PREPARED) { aloge("startDevice in error state %d", mVIDeviceState); return INVALID_OPERATION; } if(CameraInfo::CAMERA_CSI == mCameraInfo.mCameraDeviceType) { } else if(CameraInfo::CAMERA_USB == mCameraInfo.mCameraDeviceType) { aloge("need implement"); } else { aloge("unsupported temporary"); } mVIDeviceState = VI_STATE_STARTED; return NO_ERROR; } status_t VIDevice::stopDevice() { status_t eError = NO_ERROR; if (mVIDeviceState != VI_STATE_STARTED) { aloge("stopDevice in error state %d", mVIDeviceState); return INVALID_OPERATION; } int nChnNum = 0; AutoMutex lock(mVIChannelVectorLock); for (vector::iterator it = mVIChannelVector.begin(); it != mVIChannelVector.end(); ++it) { aloge("fatal error! camera[%d] vipp[%d] is exist when stop device!", mCameraId, it->mChnId); nChnNum++; } if(0 == nChnNum) { mVIDeviceState = VI_STATE_PREPARED; eError = NO_ERROR; } else { eError = INVALID_OPERATION; } return eError; } status_t VIDevice::openChannel(int chnId, bool bForceRef) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel != NULL) { aloge("channel %d is opened!", chnId); return INVALID_OPERATION; } AutoMutex lock(mVIChannelVectorLock); if(bForceRef) { if(!mVIChannelVector.empty()) { aloge("fatal error! Some channels are running. ISP sensor param has done. can't open current channel as reference channel"); return BAD_VALUE; } } else { if(mVIChannelVector.empty()) { aloge("fatal error! first channel must be ref channel! can't open current channel as sub channel!"); return BAD_VALUE; } } VIChannelInfo chnInfo; chnInfo.mpChannel = new VIChannel(mIspDevId, chnId, bForceRef); chnInfo.mChnId = chnId; mVIChannelVector.push_back(chnInfo); return NO_ERROR; } status_t VIDevice::closeChannel(int chnId) { vector::iterator it; bool found = false; { AutoMutex lock(mVIChannelVectorLock); for (it = mVIChannelVector.begin(); it != mVIChannelVector.end(); ++it) { if (it->mChnId == chnId) { delete it->mpChannel; mVIChannelVector.erase(it); found = true; break; } } } if (!found) { aloge("channel %d is not exist!", chnId); return INVALID_OPERATION; } //delete it->mpChannel; return NO_ERROR; } status_t VIDevice::prepareChannel(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } if(false == mbRefChannelPrepared) { if(false == pChannel->mbForceRef) { aloge("fatal error! must prepare reference channel first!"); return INVALID_OPERATION; } } status_t ret = pChannel->prepare(); if (ret != NO_ERROR) { aloge("prepare channel error!"); return ret; } if(false == mbRefChannelPrepared) { mbRefChannelPrepared = true; } return NO_ERROR; } status_t VIDevice::releaseChannel(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } AutoMutex lock(mVIChannelVectorLock); status_t ret = pChannel->release(); if(NO_ERROR == ret) { bool bAllRelease = true; for(VIChannelInfo& i : mVIChannelVector) { if(i.mpChannel->getState() != VIChannel::VI_CHN_STATE_CONSTRUCTED) { bAllRelease = false; break; } } if(bAllRelease) { mbRefChannelPrepared = false; } } return ret; } status_t VIDevice::startChannel(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } #if (defined(SUPPORT_ISP)) if(!mbIspRun) { mbIspRun = true; AW_MPI_ISP_Run(mIspDevId); alogd("ISP[%d] run", mIspDevId); #if 0 ISP_MODULE_ONOFF ModuleOnOff = mISPParameters.getModuleOnOff(); if(ModuleOnOff.pltm != -1) { alogv("set ISP_ModuleOnOff"); AW_MPI_ISP_SetModuleOnOff(mIspDevId, &ModuleOnOff); } //set dynamic isp parameters int curChnIspAe_Mode = mISPParameters.ChnIspAe_GetMode(); if(curChnIspAe_Mode != -1) { alogv("set chnIspAe_Mode[%d]", curChnIspAe_Mode); AW_MPI_ISP_AE_SetMode(mIspDevId, curChnIspAe_Mode); } int curChnIspAe_ExposureBias = mISPParameters.ChnIspAe_GetExposureBias(); if(curChnIspAe_ExposureBias != -1) { alogv("set chnIspAe_ExposureBias[%d]]", curChnIspAe_ExposureBias); AW_MPI_ISP_AE_SetExposureBias(mIspDevId, curChnIspAe_ExposureBias); } int curChnIspAe_Exposure = mISPParameters.ChnIspAe_GetExposure(); if(curChnIspAe_Exposure != -1) { alogv("set chnIspAe_Exposure[%d]", curChnIspAe_Exposure); AW_MPI_ISP_AE_SetExposure(mIspDevId, curChnIspAe_Exposure); } int curChnIspAe_Gain = mISPParameters.ChnIspAe_GetGain(); if(curChnIspAe_Gain != -1) { alogv("set chnIspAe_Gain[%d]", curChnIspAe_Gain); AW_MPI_ISP_AE_SetGain(mIspDevId, curChnIspAe_Gain); } int curChnIspAwb_Mode = mISPParameters.ChnIspAwb_GetMode(); if(curChnIspAwb_Mode != -1) { alogv("set chnIspAwb_Mode[%d]", curChnIspAwb_Mode); AW_MPI_ISP_AWB_SetMode(mIspDevId, curChnIspAwb_Mode); } int curChnIspAwb_RGain = mISPParameters.ChnIspAwb_GetRGain(); if(curChnIspAwb_RGain != -1) { alogv("set chnIspAwb_RGain[%d]", curChnIspAwb_RGain); AW_MPI_ISP_AWB_SetRGain(mIspDevId, curChnIspAwb_RGain); } int curChnIspAwb_BGain = mISPParameters.ChnIspAwb_GetBGain(); if(curChnIspAwb_BGain != -1) { alogv("set chnIspAwb_BGain[%d]", curChnIspAwb_BGain); AW_MPI_ISP_AWB_SetBGain(mIspDevId, curChnIspAwb_BGain); } int curChnIsp_Flicker = mISPParameters.ChnIsp_GetFlicker(); if(curChnIsp_Flicker != -1) { alogv("set chnIsp_Flicker[%d]", curChnIsp_Flicker); AW_MPI_ISP_SetFlicker(mIspDevId, curChnIsp_Flicker); } int curChnIsp_Brightness = mISPParameters.ChnIsp_GetBrightness(); if(curChnIsp_Brightness != -1) { alogv("set chnIsp_Brightness[%d]", curChnIsp_Brightness); AW_MPI_ISP_SetBrightness(mIspDevId, curChnIsp_Brightness); } int curChnIsp_Contrast = mISPParameters.ChnIsp_GetContrast(); if(curChnIsp_Contrast != -1) { alogv("set chnIsp_Contrast[%d]", curChnIsp_Contrast); AW_MPI_ISP_SetContrast(mIspDevId, curChnIsp_Contrast); } int curChnIsp_Saturation = mISPParameters.ChnIsp_GetSaturation(); if(curChnIsp_Saturation != -1) { alogv("set chnIsp_Saturation[%d]", curChnIsp_Saturation); AW_MPI_ISP_SetSaturation(mIspDevId, curChnIsp_Saturation); } int curChnIsp_Sharpness = mISPParameters.ChnIsp_GetSharpness(); if(curChnIsp_Sharpness != -1) { alogv("set chnIsp_Sharpness[%d]", curChnIsp_Sharpness); AW_MPI_ISP_SetSharpness(mIspDevId, curChnIsp_Sharpness); } /*int curChnIsp_Hue = mISPParameters.ChnIsp_GetHue(); if(curChnIsp_Hue != -1) { alogd("set chnIsp_Hue[%d]", curChnIsp_Hue); AW_MPI_ISP_SetHue(mIspDevId, curChnIsp_Hue); }*/ //INI ISP config int stNRAttrValue = mISPParameters.getNRAttrValue(); if(stNRAttrValue != -1) { alogv("set ISP_NR_ATTR"); AW_MPI_ISP_SetNRAttr(mIspDevId, stNRAttrValue); } int st3NRAttrValue = mISPParameters.get3NRAttrValue(); if(st3NRAttrValue != -1) { alogv("set ISP_3NR_ATTR"); AW_MPI_ISP_Set3NRAttr(mIspDevId, st3NRAttrValue); } int stPltmWDR = mISPParameters.getPltmWDR(); if(stPltmWDR != -1) { alogv("set ISP_PltmWDR"); AW_MPI_ISP_SetPltmWDR(mIspDevId, stPltmWDR); } #endif initIspParameters(); } #endif status_t ret = pChannel->startChannel(); return ret; } status_t VIDevice::stopChannel(int chnId) { status_t ret; VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } ret = pChannel->stopChannel(); #if (defined(SUPPORT_ISP)) if(mbIspRun) { AutoMutex lock(mVIChannelVectorLock); int num = 0; for(VIChannelInfo& i : mVIChannelVector) { if(VIChannel::VI_CHN_STATE_STARTED == i.mpChannel->getState() && i.mChnId != chnId) { num++; } } if(0 == num) { //if(VIChannel::VI_CHN_STATE_STARTED == pChannel->getState()) //{ alogd("ISP[%d] stop", mIspDevId); AW_MPI_ISP_Stop(mIspDevId); mbIspRun = false; //} } } #endif return ret; } status_t VIDevice::getMODParams(int chnId, MOTION_DETECT_ATTR_S *pParamMD) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->getMODParams(pParamMD); } status_t VIDevice::setMODParams(int chnId, MOTION_DETECT_ATTR_S pParamMD) { VIChannel *pChannel = searchVIChannel(chnId); if(pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->setMODParams(pParamMD); } status_t VIDevice::startMODDetect(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if(pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->startMODDetect(); } status_t VIDevice::stopMODDetect(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->stopMODDetect(); } status_t VIDevice::getAdasParams(int chnId, AdasDetectParam *pParamADAS) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->getAdasParams(pParamADAS); } status_t VIDevice::setAdasParams(int chnId, AdasDetectParam pParamADAS) { VIChannel *pChannel = searchVIChannel(chnId); if(pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->setAdasParams(pParamADAS); } status_t VIDevice::getAdasInParams(int chnId, AdasInParam *pParamADAS) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->getAdasInParams(pParamADAS); } status_t VIDevice::setAdasInParams(int chnId, AdasInParam pParamADAS) { VIChannel *pChannel = searchVIChannel(chnId); if(pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->setAdasInParams(pParamADAS); } status_t VIDevice::startAdasDetect(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if(pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->startAdasDetect(); } status_t VIDevice::stopAdasDetect(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->stopAdasDetect(); } ///============ status_t VIDevice::getAdasParams_v2(int chnId, AdasDetectParam_v2 *pParamADAS_v2) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->getAdasParams_v2(pParamADAS_v2); } status_t VIDevice::setAdasParams_v2(int chnId, AdasDetectParam_v2 pParamADAS_v2) { VIChannel *pChannel = searchVIChannel(chnId); if(pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->setAdasParams_v2(pParamADAS_v2); } status_t VIDevice::getAdasInParams_v2(int chnId, AdasInParam_v2 *pParamADAS_v2) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->getAdasInParams_v2(pParamADAS_v2); } status_t VIDevice::setAdasInParams_v2(int chnId, AdasInParam_v2 pParamADAS_v2) { VIChannel *pChannel = searchVIChannel(chnId); if(pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->setAdasInParams_v2(pParamADAS_v2); } status_t VIDevice::startAdasDetect_v2(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if(pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->startAdasDetect_v2(); } status_t VIDevice::stopAdasDetect_v2(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->stopAdasDetect_v2(); } void VIDevice::releaseRecordingFrame(int chnId, uint32_t index) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return; } pChannel->releaseFrame(index); } status_t VIDevice::startRecording(int chnId, CameraRecordingProxyListener *pCb, int recorderId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->startRecording(pCb, recorderId); } status_t VIDevice::stopRecording(int chnId, int recorderId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->stopRecording(recorderId); } void VIDevice::setDataListener(int chnId, DataListener *pCb) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return; } pChannel->setDataListener(pCb); } void VIDevice::setNotifyListener(int chnId, NotifyListener *pCb) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return; } pChannel->setNotifyListener(pCb); } /* void VIDevice::postDataCompleted(int chnId, const void *pData, int size) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return; } pChannel->postDataCompleted(pData, size); } void VIDevice::postVdaDataCompleted(int chnId, const VDA_DATA_S *pData) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return; } pChannel->postVdaDataCompleted(pData); } */ status_t VIDevice::takePicture(int chnId, unsigned int msgType, PictureRegionCallback *pPicReg) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->takePicture(msgType, pPicReg); } status_t VIDevice::notifyPictureRelease(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->notifyPictureRelease(); } status_t VIDevice::cancelContinuousPicture(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->cancelContinuousPicture(); } status_t VIDevice::KeepPictureEncoder(int chnId, bool bKeep) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->KeepPictureEncoder(bKeep); } status_t VIDevice::releasePictureEncoder(int chnId) { VIChannel *pChannel = searchVIChannel(chnId); if (pChannel == NULL) { aloge("channel %d is not exist!", chnId); return NO_INIT; } return pChannel->releasePictureEncoder(); } status_t VIDevice::getISPDMsg(int *exp, int *exp_line, int *gain, int *lv_idx, int *color_temp, int *rgain, int *bgain, int *grgain, int *gbgain) { int tmp; AW_MPI_ISP_AE_GetExposure(mIspDevId, &tmp); *exp = tmp; AW_MPI_ISP_AE_GetExposureLine(mIspDevId, &tmp); *exp_line = tmp; AW_MPI_ISP_AE_GetGain(mIspDevId, &tmp); *gain = tmp; AW_MPI_ISP_AWB_GetRGain(mIspDevId, &tmp); *rgain = tmp; AW_MPI_ISP_AWB_GetBGain(mIspDevId, &tmp); *bgain = tmp; AW_MPI_ISP_AWB_GetGrGain(mIspDevId, &tmp); //get gr_gain *grgain = tmp; AW_MPI_ISP_AWB_GetGbGain(mIspDevId, &tmp); //get gb_gain *gbgain = tmp; AW_MPI_ISP_AWB_GetCurColorT(mIspDevId, &tmp); *color_temp = tmp; AW_MPI_ISP_AE_GetEvIdx(mIspDevId, &tmp); *lv_idx= tmp; return NO_ERROR; } }; /* namespace EyeseeLinux */