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

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

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

int CCameraPool::InitPool()
{
    int nRet = 0;//IOpenDevices(true);
//    m_thdTrigger.StartTrigger();
    return nRet;
}

void CCameraPool::FreePool()
{
//    m_thdTrigger.EndTrigger();
    ICloseDevices();
    IDeleteDameraes();
}

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

bool CCameraPool::ICreateCamera(const QString& strSerial, int nType)
{
    if (m_cameraes.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_cameraes.insert(strSerial, pObject);
    return true;
}

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

    //if (pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_INITED &&
    //    pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_CLOSED){
    //    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_cameraes.value(strSerial);
    if (!pCamera)
        return false;

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

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

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

    return true;
}

bool CCameraPool::IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt, bool bNew, bool bAutoRun/* = false */)
{
    bool bret = false;
    if (!bNew){
        bret = ICloseCamera(strName);
        if (!bret) return bret;
    }

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

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

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

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

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

    //if (pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_OPENED &&
    //    pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_STOPPED )
    //{
    //    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_cameraes.value(strSerial);
    if (!pCamera)
        return false;

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

void CCameraPool::IDeleteDameraes()
{
    IStopDevices();
    ICloseDevices();
    m_cameraes.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_cameraes.iterateCall(cameraOpen, NULL);
    m_cameraes.iterateCall(cameraCalRelyOn, &m_cameraes);
    //calRelyOn();
    //ISetTriggerMode(DEV_TRIGGER_MODE_AUTO, TRIGGER_DIRECT_FOREWARD, gGlobalPoolOption.frameRate);
    return 1;
}

int CCameraPool::IOpenDevicesEx(bool bReopenAll)
{
    if (bReopenAll)
    {
        ICloseDevices();
    }
    m_cameraes.iterateCall(cameraOpenEx, NULL);
    m_cameraes.iterateCall(cameraCalRelyOnEx, &m_cameraes);
    //calRelyOn();
    //ISetTriggerMode(DEV_TRIGGER_MODE_AUTO, TRIGGER_DIRECT_FOREWARD, gGlobalPoolOption.frameRate);
    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_cameraes.iterateCall(cameraClose, NULL);
//    m_devVessel.Erase(NULL, deviceErased, false);
    //m_cameraes.clear(cameraErased, &m_libs);
}


void CCameraPool::IStartDevices()
{

    m_cameraes.iterateCall(cameraStartDevices, NULL);
}

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

bool CCameraPool::ICamsStartPush()
{
	m_cameraes.iterateCall(camerasStartPush, NULL);
	return true;
}

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

	//if (pCam->m_pCamOpt->deviceType != 110) return;

	pCam->IStartPush();
}

bool CCameraPool::ICamsPausePush()
{
	m_cameraes.iterateCall(camerasPausePush, NULL);
	return true;
}

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

	//if (pCam->m_pCamOpt->deviceType != 110) return;

	pCam->IPausePush();
}

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



void CCameraPool::DeviceLost(const QString& strName)
{
    ICameraObject* pObj = m_cameraes.take(strName);
    if (NULL != pObj)
    {
        m_libs.Delete(pObj);
    }
//    m_devVessel.Erase(strName, deviceErased, false);
//    m_virVessel.Erase(strName, deviceErased, false);
}

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()->CameraOption(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_cameraes.value(strSerial, NULL);
        if (NULL != pCam)
        {
            pCam->ISetProperty(NULL);
        }
    }
    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_cameraes.constBegin();
    while (iter != m_cameraes.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, emTpTriggerDirection nDirection /* = 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 CCameraPool::IManualTrigger(emTpTriggerDirection nDirection /* = TRIGGER_DIRECT_FOREWARD */)
{
    if( DEV_TRIGGER_MODE_OUT != m_nTriggerMode )
    {
        ISetTriggerMode(DEV_TRIGGER_MODE_OUT);
    }
    tagCOMMIT_TRIGGER_PARAM prm;
    prm.direct  = nDirection;
    prm.count   = 0;
    prm.bFromMenual = true;
    m_cameraes.iterateCall(cameraSnaps, &prm);
//    SnapImages(prm);
}

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

void CCameraPool::ISnapImage(const QStringList& camKeys)
{
    m_cameraes.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_cameraes.iterateCall2(gfunc_send_soft_trigger, NULL);
    }
    else
    {
        m_cameraes.iterateCall2(gfunc_send_soft_trigger, (void*)(&camKeys));
    }
}

void CCameraPool::IntervalCaptureImages(tagCOMMIT_TRIGGER_PARAM& prm)
{
    m_cameraes.iterateCall(cameraIntervalCaptures, &prm);
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

//**difficult to understand**
//iterate the virtual camera's vessel and the device's vessel as the parameter
void CCameraPool::calRelyOn()
{
    m_cameraes.iterateCall(cameraCalRelyOn, &m_cameraes);
}


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

void CCameraPool::ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property)
{
    if( camera.isNull() )
    {
        m_cameraes.iterateCall(cameraSetProperty, &property);
    }
    else
    {
        m_cameraes.valueCall(camera, cameraSetProperty, &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_cameraes.contains(keys[i]) )
        {
            continue;
        }
		ICameraObject* pObject = m_libs.Create(lpCameraConfig::instance()->CameraOption(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_cameraes.insert(keys[i], pObject);
    }
    return m_cameraes.size();
}

void CCameraPool::cameraErased(class ICameraObject*& pCam, void* pData)
{
    if (!pCam) return;
    CLibCameraes* pLibs = (CLibCameraes*)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->m_pCamOpt->status != TP_CAMERA_STATUS_OPENED &&
	//	pCam->m_pCamOpt->status != TP_CAMERA_STATUS_STOPPED)
	//{
	//	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)
{
    if (!pCam) return;
    TP_CAMERAPOOL_OPTION* pOpt = (TP_CAMERAPOOL_OPTION*)pData;
    pCam->SetFixedFrames(pOpt->fixedFrames);
    pCam->SetTriggerMode(pOpt->triggerMode);
}

void CCameraPool::cameraSnaps(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);
}

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;
    }
    if (pCamObj->m_pCamOpt->bIgnoreImage)
    {
        if (pCamObj->m_nFrameNum > 0)
        {
            pCamObj->m_nFrameNum--;
        }
        return 0;
    }
    //
    pCamObj->SaveToFile();

    lpCameraImage *pImage = m_imagesMerging.value(pCamObj->m_pCamOpt->uniqueName, NULL);
    if (NULL == pImage)
    {
        pImage = new lpCameraImage();
    }
    int nRet = 0;
    if (NULL != pImage)
    {
        //
// 		if (!gpGlobalCamCallback){
// 			delete pImage;
// 			return 0;
// 		}
		try{

			if (lpCallBackFunc::instance()->m_GetVariantCallBackFunc)
			{
				QVariant val = lpCallBackFunc::instance()->m_GetVariantCallBackFunc(pCamObj->m_pCamOpt->id);
				pImage->SetVarFromUI(val);
			}
// 			else
// 				pImage->SetVarFromUI(gpGlobalCamCallback->IGetVariantById(pCamObj->m_pCamOpt->id));

            //QVariantMap map;
            //map.clear();
            //map.insert("width", pCamObj->m_nImageWidth);
            //map.insert("height", pCamObj->m_nImageHeight);
            //map.insert("size", pCamObj->m_nImageSize);
            //map.insert("frame", pCamObj->m_nFrameNum);
            //qint64 nSizes = pCamObj->m_nImageHeight*pCamObj->m_nImageWidth*((pCamObj->m_nBitsPerPixel + 7) / 8);
            ////QByteArray baimgdat = QByteArray::fromRawData((const char*)(pCamObj->m_pCameraData), nSizes);
            //QByteArray baimgdat = QByteArray((const char*)(pCamObj->m_pCameraData));
            //map.insert("imgdata", baimgdat);

            //std::string imgb64 = base64_encode(pCamObj->m_pCameraData, nSizes);
            //int b64len = imgb64.length();
            //QString qsimgb64(imgb64.c_str());
            //map.insert("imgb64", qsimgb64);
            //gpGlobalCamCallback->INewCameraImage(map);
		}
		catch (...){
			qCritical() << "Critical error." << __FUNCTION__;
			return 0;
		}
        //
        int nRet = pImage->CopyCameraObject(pCamObj);
        if (-1 == nRet)
        {
            delete pImage;
            pImage = NULL;
        }
        else if (1 == nRet)
        {
            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
    if (pCamObj->NeedStopping())
    {
        //IStopDevices(pCamObj->CameraOption()->uniqueName);//不是好方法，如果正在SetTriggerStart，这里可能会立刻Stop这次Start 
        //pCamObj->IStopCamera();//不是好方法，如果正在SetTriggerStart，这里可能会立刻Stop这次Start 
        m_cameraes.valueCall(pCamObj->m_pCamOpt->uniqueName, fixedFramesStopCamera, NULL);
    }
    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);
	}
    //pImage->SetVarFromUI(gpGlobalCamCallback->IGetVariantById(pCamObj->m_pCamOpt->id));
    m_imagesList.append(pImage);
    //
    if (pCamObj->NeedStopping())
    {
        m_cameraes.valueCall(pCamObj->m_pCamOpt->uniqueName, fixedFramesStopCamera, NULL);
    }
    return 1;
}

char* CCameraPool::IGetMainPath()
{
	return nullptr;// gpGlobalCamera->m_pGlobalData->tgdMainPath;
}
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;
}

void CCameraPool::ISetVirtualImages(const QString& camera, const QStringList& szImages)
{
    if (camera.isEmpty())
    {
        m_cameraes.iterateCall(cameraSetVirtuleImages, (void*)&szImages);
    }
    else
    {
        m_cameraes.valueCall(camera, cameraSetVirtuleImages, (void*)&szImages);
    }
}
void CCameraPool::cameraSetVirtuleImages(class ICameraObject*& pCam, void* pData)
{
    QStringList* pszImages = (QStringList*)pData;
    if (pCam->m_pCamOpt->deviceType / 10 == DEV_CAM_VIRTUAL / 10)
    {
        pCam->ISetVirtualImages(*pszImages);
    }
}