#include "CameraPool.h"
#include <QDebug>
#include "callbackFunc.h"
#include "lpCameraConfig.h"
#include "QFunctionTransfer.h"

CCameraPool::CCameraPool(void)
    : m_libs("")
{
    m_nFrameRate    = 0;
    m_nCameraEncode = 0;
}

CCameraPool::~CCameraPool(void)
{
    releaseImagesList();
}

int CCameraPool::InitPool()
{
    int nRet = 0;

    return nRet;
}

void CCameraPool::FreePool()
{

    ICloseDevices();
    IDeleteDameraes();
}

int  CCameraPool::ICreateCamDevices()
{
	QList<QString> keys = lpCameraConfig::instance()->CameraKeys();
    for (int i = 0; i < keys.size(); ++i)
    {
        if (m_CamDevMap.contains(keys[i]))
        {
            continue;
        }
		ICameraObject* pObject = m_libs.Create(lpCameraConfig::instance()->getCameraOption(keys[i]), this);
        if (NULL == pObject)
        {
            continue;
        }
        pObject->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
        m_CamDevMap.insert(keys[i], pObject);
    }
    return m_CamDevMap.size();
}

bool CCameraPool::ICreateCamera(const QString& strSerial, int nType)
{
    if (m_CamDevMap.contains(strSerial))
    {
        return false;
    }

    TP_CAMERA_OPTION camOpt;
    camOpt.deviceType = nType;
    camOpt.uniqueName = strSerial;

    ICameraObject* pObject = m_libs.Create(&camOpt, this);
    if (NULL == pObject)
    {
        return false;
    }

    pObject->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
    m_CamDevMap.insert(strSerial, pObject);
	lpCameraConfig::instance()->addCameraOption(strSerial, camOpt);
    return true;
}

bool CCameraPool::IOpenCamera(const QString& strSerial, bool bReopen)
{
    ICameraObject* pCamera = m_CamDevMap.value(strSerial);
    if (!pCamera)
        return false;

    if (bReopen)
    {
        pCamera->ICloseCamera();
        pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
    }

    int nret = pCamera->IOpenCamera();
    if (nret == 1){
        pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
        return true;
    }
    return false;
}

bool CCameraPool::ICloseCamera(const QString& strSerial)
{
    ICameraObject* pCamera = m_CamDevMap.value(strSerial);
    if (!pCamera)
        return false;

    pCamera->ICloseCamera();
    pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
    return true;
}

bool CCameraPool::IDelCamera(const QString& strSerial)
{
    ICameraObject* pCamera = m_CamDevMap.value(strSerial);
    if (pCamera){
        pCamera->IStopCamera();
        pCamera->ICloseCamera();

        pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_UNINIT;
        m_libs.Delete(pCamera);
    }
    m_CamDevMap.remove(strSerial);
	lpCameraConfig::instance()->delCameraOption(strSerial);

    return true;
}

bool CCameraPool::IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt)
{
    bool bret = false;
	if(m_CamDevMap.contains(strName))
    {
        bret = ICloseCamera(strName);
        if (!bret) return bret;
    }

	lpCameraConfig::instance()->addCameraOption(strName, camOpt);

    {
		ICameraObject* pCamObj = m_libs.Create(lpCameraConfig::instance()->getCameraOption(strName), this);
        if (pCamObj)
        {
            pCamObj->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
            m_CamDevMap.insert(strName, pCamObj);
        }
        else{
            return false;
        }
    }

    bret = IOpenCamera(strName, true);
    if (!bret) return bret;

    {
       bret = IStartCamera(strName);
    }
    return bret;
}

bool CCameraPool::IRunAlg(const QString& strSerial, bool bRun)
{
	ICameraObject* pCamera = m_CamDevMap.value(strSerial);
	if (!pCamera)
		return false;
	pCamera->m_pCamOpt->bAutoRunAlg = bRun;
	return true;
}

bool CCameraPool::IStartCamera(const QString& strSerial)
{
    ICameraObject* pCamera = m_CamDevMap.value(strSerial);
    if (!pCamera)
        return false;

    int nret = pCamera->IStartCamera();
    if (nret == 1){
        pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_STARTED;
        return true;
    }
    return false;
}

bool CCameraPool::IStopCamera(const QString& strSerial)
{
    ICameraObject* pCamera = m_CamDevMap.value(strSerial);
    if (!pCamera)
        return false;

    pCamera->IStopCamera();
    pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
    return true;
}

void CCameraPool::IDeleteDameraes()
{
    IStopDevices();
    ICloseDevices();
    m_CamDevMap.clear(cameraErased, &m_libs);
}

void CCameraPool::cameraOpen(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;

    if (pCam->IOpenCamera() == 1)
    {
        pCam->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
    }
}

void CCameraPool::cameraOpenEx(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;
    if (pCam->m_pCamOpt->bAutoOpen)
    {
        if (pCam->IOpenCamera() == 1)
        {
            pCam->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
        }
    }
}

int CCameraPool::IOpenDevices(bool bReopenAll)
{
    if( bReopenAll )
    {
        ICloseDevices();
    }
    m_CamDevMap.iterateCall(cameraOpen, NULL);
    m_CamDevMap.iterateCall(cameraCalRelyOn, &m_CamDevMap);
    return 1;
}

int CCameraPool::IOpenDevicesEx(bool bReopenAll)
{
    if (bReopenAll)
    {
        ICloseDevices();
    }
    m_CamDevMap.iterateCall(cameraOpenEx, NULL);
    m_CamDevMap.iterateCall(cameraCalRelyOnEx, &m_CamDevMap);
    return 1;
}

int CCameraPool::InitDevices()
{
	for (QZkMutexMap<QString, class ICameraObject *>::iterator it = m_CamDevMap.begin(); it != m_CamDevMap.end(); ++it)
	{
		ICameraObject* pCamObj = *it;
		if (pCamObj)
		{
			pCamObj->InitProperty();
		}
	}
	return 1;
}

void CCameraPool::cameraClose(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;

    pCam->ICloseCamera();
    pCam->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
}
void CCameraPool::ICloseDevices()
{
    m_CamDevMap.iterateCall(cameraClose, NULL);
}


void CCameraPool::IStartDevices()
{

    m_CamDevMap.iterateCall(cameraStartDevices, NULL);
}

void CCameraPool::IStopDevices(const QString& sDef/* = NULL*/)
{
    if (sDef.isEmpty())
    {
        m_CamDevMap.iterateCall(cameraStopDevices, NULL);
    }
    else
    {
        m_CamDevMap.valueCall(sDef, cameraStopDevices, NULL);
    }
}

void CCameraPool::ISetTriggerMode(emTpDeviceTriggerMode mode)
{

}

// void CCameraPool::DeviceLost(const QString& strName)
// {
//     ICameraObject* pObj = m_CamDevMap.take(strName);
//     if (NULL != pObj)
//     {
//         m_libs.Delete(pObj);
//     }
// }

QList<QString> CCameraPool::ICameraKeys()
{
	return lpCameraConfig::instance()->CameraKeys();
}

QList<QString> CCameraPool::ICameraKeysOrderByIds()
{
	return lpCameraConfig::instance()->CameraKeysOrderByIds();
}

bool CCameraPool::ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
{
	return lpCameraConfig::instance()->getCameraOption(strSerial, camOpt);
}

bool CCameraPool::ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
{
    return lpCameraConfig::instance()->CameraOptionByKey(strSerial, camOpt);
}

bool CCameraPool::ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt)
{
    bool bRet = lpCameraConfig::instance()->SetCameraOption(strSerial, camOpt);
    if (bRet)
    {
        ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
        if (NULL != pCam)
        {
            pCam->ISetProperty(NULL);
        }
    }
    return bRet;
}

bool CCameraPool::IGetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt)
{
	bool bRet = lpCameraConfig::instance()->SetCameraOption(strSerial, camOpt);
	if (bRet)
	{
		ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
		if (NULL != pCam)
		{
			//return pCam->IGetProperty(&camOpt);
		}
	}
	return bRet;
}
QList<QString> CCameraPool::IEnumAvailableCameras(emTpDeviceType camType)
{
    QList<QString> ret;
    
    // if the camera dll has been loaded
    QZkMutexMap<QString, class ICameraObject*>::const_iterator iter = m_CamDevMap.constBegin();
    while (iter != m_CamDevMap.constEnd())
    {
        ICameraObject* pCam = iter.value();
        if (pCam && pCam->m_pCamOpt->deviceType == camType){
            ret = pCam->IEnumAvailableCameras();
            return ret;
        }
        iter++;
    }

    // the camera dll has not been loaded
    TP_CAMERA_OPTION camOpt;
    camOpt.deviceType = camType;

    ret = m_libs.enumAvailableCameras(&camOpt, this);
    return ret;
}

// void CCameraPool::ISetTriggerMode(emTpDeviceTriggerMode mode/* = TRIGGER_DIRECT_FOREWARD */, long nFrameRate /* = 0 */)
// {
// //     gGlobalPoolOption.triggerMode       = mode;
// //     gGlobalPoolOption.triggerDirection  = nDirection;
// //     gGlobalPoolOption.frameRate         = nFrameRate;
// //     gGlobalPoolOption.fixedFrames       = nFrameRate;
// //     m_nTriggerMode  = mode;
// //     m_nFrameRate    = nFrameRate;
// //     //set every device's trigger
// //     m_thdTrigger.LockWorked();
// //     m_cameraes.iterateCall(cameraSetTriggerMode, &gGlobalPoolOption);
// //    IStartDevices();
// //    m_thdTrigger.UnlockWorked();
//     //begin or end trigger's thread
//     if( DEV_TRIGGER_MODE_AUTO != mode && 
//         DEV_TRIGGER_MODE_FIXED_AUTO != mode )
//     {
//         //m_thdTrigger.EndThread();
// //        m_thdTrigger.SetAutoTrigger(false);
//     }
//     else
//     {
// //        m_thdTrigger.SetFrame(nFrameRate);
//         //m_thdTrigger.StartTrigger();
// //        m_thdTrigger.SetAutoTrigger(true);
//     }
// }

void gfunc_snap_camera_image(const QString& key, class ICameraObject*& pCam, void* pData)
{
	if (!pCam)
		return;
    QStringList* pKeys = (QStringList*)pData;
    if (!pKeys->contains(key))
    {
        return;
    }
    pCam->ISnapCamera();
}

void CCameraPool::ISnapImage(const QStringList& camKeys)
{
	foreach(QString var, camKeys) {
		QZkMutexMap<QString, class ICameraObject *>::iterator it = m_CamDevMap.find(var);
		if (it != m_CamDevMap.end())
		{
			ICameraObject* pObj = *it;
			if (pObj)
			{
				pObj->ISnapCamera();
			}
		}
	}
   // m_CamDevMap.iterateCall2(gfunc_snap_camera_image, (void*)(&camKeys));
}

void gfunc_send_soft_trigger(const QString& key, class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;

//     if (NULL != pCam->RelyOnCamera())
//     {
//         return;
//     }
    if (NULL != pData)
    {
        QStringList* pKeys = (QStringList*)pData;
        if (!pKeys->contains(key))
        {
            return;
        }
    }
  //  pCam->ISendSoftTrigger();
}

void CCameraPool::ISendSoftTrigger(const QStringList& camKeys)
{
    if (camKeys.isEmpty())
    {
        m_CamDevMap.iterateCall2(gfunc_send_soft_trigger, NULL);
    }
    else
    {
        m_CamDevMap.iterateCall2(gfunc_send_soft_trigger, (void*)(&camKeys));
    }
}


void CCameraPool::calRelyOn()
{
    m_CamDevMap.iterateCall(cameraCalRelyOn, &m_CamDevMap);
}

void CCameraPool::ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue)
{
}

void CCameraPool::ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property)
{
    if( camera.isNull() )
    {
        m_CamDevMap.iterateCall(cameraSetProperty, &property);
    }
    else
    {
        m_CamDevMap.valueCall(camera, cameraSetProperty, &property);
    }
}


void CCameraPool::IGetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property)
{

}

void CCameraPool::cameraSetProperty(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;
    pCam->ISetProperty((TP_CAMERA_PROPERTY*)pData);
}

lpCameraImage* CCameraPool::IPopCameraImage()
{
    return m_imagesList.takeFirst(NULL);
}

int CCameraPool::createDeviceByOptiones()
{
	QList<QString> keys = lpCameraConfig::instance()->CameraKeys();
    for( int i = 0; i < keys.size(); ++i )
    {
        if( m_CamDevMap.contains(keys[i]) )
        {
            continue;
        }
		ICameraObject* pObject = m_libs.Create(lpCameraConfig::instance()->getCameraOption(keys[i]), this);
        if( NULL == pObject )
        {
            continue;
        }
        if( 0 == pObject->IOpenCamera() )
        {
            m_libs.Delete(pObject);
            continue;
        }
        pObject->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
        m_CamDevMap.insert(keys[i], pObject);
    }
    return m_CamDevMap.size();
}

void CCameraPool::cameraErased(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) 
		return;
    CLibCamera* pLibs = (CLibCamera*)pData;
    pCam->IStopCamera();
    pCam->ICloseCamera();

    pCam->m_pCamOpt->status = TP_CAMERA_STATUS_UNINIT;
    pLibs->Delete(pCam);
}

void CCameraPool::cameraStartDevices(class ICameraObject*& pCam, void* pData)
{
	if (!pCam) 
		return;
	if (pCam->IStartCamera() == 1){
		pCam->m_pCamOpt->status = TP_CAMERA_STATUS_STARTED;
	}
}

void CCameraPool::cameraStopDevices(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;
    pCam->IStopCamera();
    pCam->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
}

void CCameraPool::cameraSetTriggerMode(class ICameraObject*& pCam, void* pData)
{

}

void CCameraPool::cameraSnaps(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;

    pCam->ISnapCamera();
}

void CCameraPool::cameraIntervalCaptures(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;
    //tagCOMMIT_TRIGGER_PARAM* pParam = (tagCOMMIT_TRIGGER_PARAM*)pData;
//     if (NULL != pCam->RelyOnCamera())
//     {
//         return;
//     }
    //pCam->ISnapCamera(pParam->direct);
    pCam->IAutoCapture();
}

void CCameraPool::cameraCalRelyOn(class ICameraObject*& pCam, void* pData)
{
//     if (!pCam) return;
//     QZkMutexMap<QString, class ICameraObject*>* pCameraes = (QZkMutexMap<QString, class ICameraObject*>*)pData;
//     TP_CAMERA_OPTION* pOpt = pCam->m_pCamOpt;
//     if( DEV_CAM_VIRTUAL_FOLDER == pOpt->deviceType && NULL == pCam->RelyOnCamera() && pCameraes->contains(pOpt->relyOnCamera) )
//     {
//         ICameraObject* pCamRelyOn = pCameraes->value(pOpt->relyOnCamera, NULL);
//         if( NULL != pCamRelyOn )
//         {
//             pCam->SetRelyOnCamera(pCamRelyOn);
//             pCamRelyOn->SetReliedByCamera(pCam);
//         }
//     }
}

void CCameraPool::cameraCalRelyOnEx(class ICameraObject*& pCam, void* pData)
{
//     if (!pCam) return;
//     QZkMutexMap<QString, class ICameraObject*>* pCameraes = (QZkMutexMap<QString, class ICameraObject*>*)pData;
//     TP_CAMERA_OPTION* pOpt = pCam->m_pCamOpt;
//     if (DEV_CAM_VIRTUAL_FOLDER == pOpt->deviceType && pOpt->bAutoOpen && NULL == pCam->RelyOnCamera() && pCameraes->contains(pOpt->relyOnCamera))
//     {
//         ICameraObject* pCamRelyOn = pCameraes->value(pOpt->relyOnCamera, NULL);
//         if (NULL != pCamRelyOn)
//         {
//             pCam->SetRelyOnCamera(pCamRelyOn);
//             pCamRelyOn->SetReliedByCamera(pCam);
//         }
//     }
}
//在主线程中运行？
int CCameraPool::IPushCameraData(ICameraObject* pCamObj)
{
    if (m_imagesList.size() >= 32)
    {
        qWarning("Cache OverFlow, Camera Image Count:%d", m_imagesList.size());
		if (pCamObj->m_nFrameNum > 0)
		{
			pCamObj->m_nFrameNum--;
		}
		return 0;
    }

    if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt )
    {
        return 0;
    }

    lpCameraImage *pImage = m_imagesMerging.value(pCamObj->m_pCamOpt->uniqueName, NULL);
    if (NULL == pImage)
    {
        pImage = new lpCameraImage();
    }
    int nRet = 0;
    if (NULL != pImage)
    {
        //
        int nRet = pImage->CopyCameraObject(pCamObj);
        if (-1 == nRet)
        {
            delete pImage;
            pImage = NULL;
        }
        else if (1 == nRet)
        {
// 			if (pCamObj->m_pCamOpt->bAutoRunAlg == false)
// 			{
// 
//  				delete pImage;
//  				pImage = NULL;
// 			}
// 			else 
			{	
				QString strSerial = pImage->Serial();
				QImage showImg = pImage->ToQImage();
				QFunctionTransfer::Instance()->execInMain([this, strSerial, showImg]() {
					if (lpCallBackFunc::instance()->m_ImageCallBackFunc)
					{
						lpCallBackFunc::instance()->m_ImageCallBackFunc(strSerial, showImg);
					}
				});
				
				try {
					//获取算法参数 绑定到图像
					if (lpCallBackFunc::instance()->m_GetVariantCallBackFunc)
					{
						QVariant val = lpCallBackFunc::instance()->m_GetVariantCallBackFunc(pCamObj->m_pCamOpt->id);
						pImage->SetVarFromUI(val);
					}
				}
				catch (...) {
					qCritical() << "Critical error." << __FUNCTION__;
					return 0;
				}

				pImage->SetMeterCode(m_nCameraEncode);
				m_imagesList.append(pImage);
				pImage = NULL;
			}
			
        }
        m_imagesMerging.insert(pCamObj->m_pCamOpt->uniqueName, pImage);
        nRet = 1;
    }

    //checks to stop trigger in fixed_auto
    return nRet;
}

//don't combine image
int CCameraPool::IPushCameraData2(ICameraObject* pCamObj)
{
    if (m_imagesList.size() >= 32)
    {
        qWarning("Cache OverFlow, Camera Image Count:%d", m_imagesList.size());
    }

    quint64 msec = QDateTime::currentMSecsSinceEpoch();
    if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt)
    {
        return 0;
    }
//    if (pCamObj->m_pCamOpt->bIgnoreImage)
    {
        if (pCamObj->m_nFrameNum > 0)
        {
            pCamObj->m_nFrameNum--;
        }
        return 0;
    }

//    pCamObj->SaveToFile();

    lpCameraImage* pImage = new lpCameraImage();
    if (NULL == pImage)
    {
        return 0;
    }
    if (0 == pImage->CopyCameraObject2(pCamObj))
    {
        delete pImage;
        return 0;
    }

	if (lpCallBackFunc::instance()->m_GetVariantCallBackFunc)
	{
		QVariant val = lpCallBackFunc::instance()->m_GetVariantCallBackFunc(pCamObj->m_pCamOpt->id);
		pImage->SetVarFromUI(val);
	}
    m_imagesList.append(pImage);

    return 1;
}

bool CCameraPool::IGetWidth(const QString& strSerial, int& width)
{
	ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
	if (NULL != pCam)
	{
		TP_CAMERA_PROPERTY nProperty;
		nProperty.property = TP_CAM_PROPERTY_IMAGE_WIDTH;
		bool bRet = pCam->IGetProperty(&nProperty);
		width = nProperty.value;
		return bRet;
	}
	return false;
}

bool CCameraPool::ISetWidth(const QString& strSerial, int& width)
{
	ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
	if (NULL != pCam)
	{
		TP_CAMERA_PROPERTY nProperty;
		nProperty.property = TP_CAM_PROPERTY_IMAGE_WIDTH;
		nProperty.value = width;
		TP_CAMERA_OPTION* opt = lpCameraConfig::instance()->getCameraOption(strSerial);
		if (opt) {
			opt->width = width;
		}
		return pCam->ISetProperty(&nProperty);
	}
	return false;
}

bool CCameraPool::IGetHeight(const QString& strSerial, int& height)
{
	ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
	if (NULL != pCam)
	{
		TP_CAMERA_PROPERTY nProperty;
		nProperty.property = TP_CAM_PROPERTY_IMAGE_HEIGHT;
		bool bRet = pCam->IGetProperty(&nProperty);
		height = nProperty.value;
		return bRet;
	}
	return false;
}

bool CCameraPool::ISetHeight(const QString& strSerial, int& height)
{
	ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
	if (NULL != pCam)
	{
		TP_CAMERA_PROPERTY nProperty;
		nProperty.property = TP_CAM_PROPERTY_IMAGE_HEIGHT;
		nProperty.value = height;
		TP_CAMERA_OPTION* opt = lpCameraConfig::instance()->getCameraOption(strSerial);
		if (opt) {
			opt->height = height;
		}
		return pCam->ISetProperty(&nProperty);
	}
	return false;
}

bool CCameraPool::IGetGain(const QString& strSerial, int& height)
{
	ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
	if (NULL != pCam)
	{
		TP_CAMERA_PROPERTY nProperty;
		nProperty.property = TP_CAM_PROPERTY_GAIN;
		bool bRet = pCam->IGetProperty(&nProperty);
		height = nProperty.value;
		return bRet;
	}
	return false;
}

bool CCameraPool::ISetGain(const QString& strSerial, int& height)
{
	ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
	if (NULL != pCam)
	{
		TP_CAMERA_PROPERTY nProperty;
		nProperty.property = TP_CAM_PROPERTY_GAIN;
		nProperty.value = height;
		pCam->ISetProperty(&nProperty);
		TP_CAMERA_OPTION* opt = lpCameraConfig::instance()->getCameraOption(strSerial);
		if (opt) {
			opt->gain = height;
		}
		return true;
	}
	return false;
}

bool CCameraPool::IGetExposureTime(const QString& strSerial, int& height)
{
	ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
	if (NULL != pCam)
	{
		TP_CAMERA_PROPERTY nProperty;
		nProperty.property = TP_CAM_PROPERTY_EXPOSURE;
		bool bRet = pCam->IGetProperty(&nProperty);
		height = nProperty.value;
		return bRet;
	}
	return false;
}

bool CCameraPool::ISetExposureTime(const QString& strSerial, int& height)
{
	ICameraObject* pCam = m_CamDevMap.value(strSerial, NULL);
	if (NULL != pCam)
	{
		TP_CAMERA_PROPERTY nProperty;
		nProperty.property = TP_CAM_PROPERTY_EXPOSURE;
		nProperty.value = height;
		pCam->ISetProperty(&nProperty);

		TP_CAMERA_OPTION* opt = lpCameraConfig::instance()->getCameraOption(strSerial);
		if (opt) {
			opt->exposure = height;
		}
		return true;
	}
	return false;
}

void CCameraPool::IFreeCameraImage(lpCameraImage *pCamImg)
{
    delete pCamImg;
}

QMap<QString, QString> CCameraPool::IGetCamShowNames()
{
	return lpCameraConfig::instance()->GetCamShowNames();
}

void CCameraPool::ISetCameraEncode(INT64 code, INT64 rate)
{
    m_nCameraEncode = code;
	m_nEncoderRate = rate;
}