#include "EntityCamera.h"




/// 初始化相机环境
bool ICamera::initEnv()
{

	return true;
}
/// 关闭相机环境
bool ICamera::closeEnv()
{
	return true;
}

/// 获取所有相机序列号       
QVector<QString> ICamera::cameraSerial()
{
	QVector<QString> Seriallist;
	Seriallist.clear();
	int g_serverCount = m_pManger->GetServerCount(SapManager::ResourceAcqDevice);//得到采集设备的数量
	char* serverSerial = new char[100];
	for (int i = 0; i < g_serverCount; i++)
	{
		memset(serverSerial, 0, 100 * sizeof(char));
		m_pManger->GetServerSerialNumber(i + 1, serverSerial);
		if (serverSerial != NULL)
		{
			QString str = QString(QLatin1String(serverSerial));
			Seriallist.push_back(str);
		}
	}
	delete serverSerial;
	return Seriallist;
}






EntityCamera::EntityCamera() :
	m_pCamParamConfig(nullptr),
	m_pDialogCamPasram(nullptr)
{
	m_nImageChannels = 1;

	//////////////////////////////////////////////////////////////////////////
	m_Xfer = NULL;
	m_pBuffers = NULL;
	m_pCamera = NULL;
	m_pColorconv = NULL;
	m_pFeature = NULL;

}



EntityCamera::~EntityCamera(void)
{
	this->stopWork();


	//检查当前数据传输是否正在进行中。
	for (int i = 0; i < 30; i++)
	{
		if (m_Xfer != NULL)
		{
			if (m_Xfer->IsGrabbing())
			{
				Sleep(100);
			}
		}

	}



	bool bcloseCamera = this->closeCamera();


	if (nullptr != m_pDialogCamPasram)
	{
		delete m_pDialogCamPasram;
		m_pDialogCamPasram = NULL;
	}

	if (nullptr != m_pCamParamConfig)
	{
		delete m_pCamParamConfig;
		m_pCamParamConfig = nullptr;
	}

}



/// 创建ENTITY相机
EntityCamera* EntityCamera::createCamera(QString serial)
{
	EntityCamera* camera = NULL;

	try
	{
		camera = new EntityCamera();
		if (camera)
		{
			/// 打开相机
			if (true == camera->openCamera(serial))
			{
				if (false == camera->initialize())
				{
					delete camera;
					camera = NULL;
				}
			}
			else
			{
				delete camera;
				camera = NULL;
			}
		}
		
	}
	catch (...)
	{
		delete camera;
		camera = NULL;
	}
	return camera;
}



/// 打开相机        
bool EntityCamera::openCamera(QString serial)
{
	bool bret = true;
	m_strSerial = serial;
	char* serverName = new char[100];
	memset(serverName, 0, 100 * sizeof(char));
	bool bIsServerName = SN_ToSeverName(serial, serverName);
	
	if (bIsServerName == false)
	{
		return false;
	}
	SapLocation loc(serverName, 0);
	delete serverName;
	m_pCamera = new SapAcqDevice(loc, NULL);//第二个参数写载入的ccf文件路径   m_pCamera->SaveFeatures("123.ccf");//error


	if (m_pCamera && !*m_pCamera && !m_pCamera->Create())
	{
		return false;
	}
	m_pFeature = new SapFeature(m_pCamera->GetLocation());
	m_pFeature->Create();


	BOOL isAvailable;
	m_pCamera->IsFeatureAvailable("Width", &isAvailable);//检查节点可以使用
	if (isAvailable)
	{
		m_pCamera->GetFeatureValue("Width", &m_iImageWidth);
	}
	m_pCamera->IsFeatureAvailable("Height", &isAvailable);//检查节点可以使用
	if (isAvailable)
	{
		m_pCamera->GetFeatureValue("Height", &m_iImageHeight);
	}

	//mImgCapBuffer.imgData = new uint8_t * [m_iImageWidth * m_iImageHeight * 3];


	m_pBuffers = new SapBufferWithTrash(2, m_pCamera);
	m_pColorconv = new SapColorConversion(m_pBuffers);
	m_Xfer = new SapAcqDeviceToBuf(m_pCamera, m_pBuffers, XferCallback, this);

	if (m_pBuffers && !*m_pBuffers && !m_pBuffers->Create())
	{
		return false;
	}
	if (m_pColorconv && !*m_pColorconv && !m_pColorconv->Create())
	{
		return false;
	}

	if (m_Xfer && !*m_Xfer && !m_Xfer->Create())
	{
		return false;
	}

	return bret;
}

/// 关闭相机        
bool EntityCamera::closeCamera()
{
	bool bret = true;

	if (m_Xfer && *m_Xfer) m_Xfer->Destroy();

	if (m_pFeature && *m_pFeature) m_pFeature->Destroy();
	//	if (m_pColorconv && *m_pColorconv) m_pColorconv->Destroy();
	if (m_pBuffers && *m_pBuffers) m_pBuffers->Destroy();
	if (m_pCamera && *m_pCamera) m_pCamera->Destroy();


	if (m_Xfer) delete m_Xfer;

	if (m_pFeature) delete m_pFeature;
	//	if (m_pColorconv) delete m_pColorconv;
	if (m_pBuffers) delete m_pBuffers;
	if (m_pCamera) delete m_pCamera;

	return bret;
}

/// 初始化
bool EntityCamera::initialize()
{

	if (NULL == m_pDialogCamPasram)
	{
		m_pDialogCamPasram = new DialogCamPasram(this);
	}

	if (imageChannels() == 3)
	{
		m_pColorconv->Enable(true, false);
		m_pColorconv->SetOutputFormat(SapFormatRGB888);
		m_pColorconv->SetAlign(SapColorConversion::AlignRGGB);
	}



	return true;
}


/// 加载参数
void EntityCamera::loadCamParam()
{

}



/// 保存参数
void EntityCamera::saveCamParam()
{

}


/// 设置相机工作模式
bool EntityCamera::setWorkMode(IBaseCamCommon::CamWorkMode mode, bool Running )
{
	if (!m_pCamera->IsServerAccessible(m_pCamera->GetLocation()))
	{
		return false;
	}
	bool bret = true;
	this->stopWork();
	
	switch (mode)
	{
	case IBaseCamCommon::eContinu:
		//连续采集模式 相机一直工作采图
		this->setToFreeRunMode();
		break;
	case IBaseCamCommon::eHardware:
		//中断采集模式 相机接收到硬件中断中断命令采集图像
		this->setToHardwareTrigerMode();  
		break;
	case IBaseCamCommon::eSoftware:
		//中断采集模式 相机接收到软件中断命令采集图像
		bret = this->setToSoftwareTrigerMode(); 
		break;
	case IBaseCamCommon::eSuspendCou:

		break;
	default:

		break;
	}
	mWorkMode = mode; //工作模式
	
	return bret;
}

/// 相机工作模式
IBaseCamCommon::CamWorkMode EntityCamera::workMode()
{
	return mWorkMode;
}


/// 相机开始工作
bool EntityCamera::startWork()
{
	if (!m_Xfer)
	{
		return false;
	}
	bool bret = true;
	if (!m_Xfer->IsGrabbing())//检查当前数据传输是否正在进行中。
	{
		bret = !m_Xfer->Grab();//   Grab()如果成功返回true，否则为false
	}
	return bret;
}

/// 相机停止工作
bool EntityCamera::stopWork()
{
	if (!m_pCamera->IsServerAccessible(m_pCamera->GetLocation()))
	{
		return false;
	}
	if (!m_Xfer)
	{
		return false;
	}
	bool bret = true;
	if (m_Xfer->IsGrabbing())//检查当前数据传输是否正在进行中。
	{
		bret = !m_Xfer->Freeze();
	}
	return bret;
}

/// 相机序列号
QString EntityCamera::serial()
{
	return m_strSerial;
}

/// 重启相机
bool EntityCamera::restartCamera()
{
	if (m_pCamera == NULL)
	{
		return false;
	}
	if (m_pCamera->IsServerAccessible(m_pCamera->GetLocation()))
	{
		stopWork();
	
		startWork();			
	}
	
	return true;
}

/// 获取一桢图像 
bool EntityCamera::captureImage(void** buf, int size)
{
	return true;
}

/// 获取图像宽
int EntityCamera::imageWidth(void)
{
	return 0;
}

/// 获取图像高
int EntityCamera::imageHeight(void)
{
	return 0;
}

/// 获取图像通道数
int EntityCamera::imageChannels(void)
{
	return m_nImageChannels;
}

/// 获取配置参数类
IBaseCamParamConfig* EntityCamera::camParamConfig()
{
	CamParamConfig* paramConfig = nullptr; //配置参数类

	if (nullptr == m_pCamParamConfig)
	{
		m_pCamParamConfig = new CamParamConfig(this);
	}
	paramConfig = m_pCamParamConfig;

	return paramConfig;
}

/// 显示设置参数窗口页面
void EntityCamera::showParamConfigWindow(int mode )
{
	if (m_pDialogCamPasram)
	{
		m_pDialogCamPasram->setModal(true);
		m_pDialogCamPasram->show();
	}
}


/// 获取相机最大分辨率
bool EntityCamera::getMaxSize(int& w, int& h)
{
	return true;
}


/// 设置相机分辨率
bool EntityCamera::setResolution(int w, int h)
{
	return true;
}

/// 获取已注册图像回调的数量
int EntityCamera::getReceCallBackSIze()
{
	return m_pImgCallBack.size();
}

///设置接收图像数据回调函数
void EntityCamera::setReceCallBack(IBaseCamCommon::receImgCallBack callBack, long long userParam, QString userID)
{
	//this->m_pReceImgFunction = callBack;
	//this->mUserParam = userParam;

	IBaseCamCommon::ImgCallBack* pImgCallBack = new IBaseCamCommon::ImgCallBack;
	pImgCallBack->pReceFunction = callBack;
	pImgCallBack->pUserParam = userParam;
	pImgCallBack->strUserID = userID;

	m_pImgCallBack.push_back(pImgCallBack);
}

///设置接收Log数据回调函数
void EntityCamera::setReceLogCallBack(IBaseCamCommon::receLogCallBack callBack, long long userParam)
{
	this->m_pReceLogFunction = callBack;
	this->mLogUserParam = userParam;
}


/// 执行回调函数
void EntityCamera::execCallFunction(IBaseCamCommon::CamImgData* img, int frameCount)
{
	//	printf( "执行回调函数\n" );
// 	if (this->m_pReceImgFunction != NULL)
// 	{
// 		this->m_pReceImgFunction(img, frameCount, m_strSerial, mUserParam);
// 	}
	for (int i = 0; i < m_pImgCallBack.size(); i++)
	{
		if (m_pImgCallBack[i]->pReceFunction != nullptr)
		{
			if (m_pImgCallBack[i]->strUserID == m_strUserID)
			{
				m_pImgCallBack[i]->pReceFunction(img, frameCount, m_strSerial, m_pImgCallBack[i]->pUserParam);

			}
		}
	}
	m_strUserID = "main";
}


/// 执行Log回调函数
void EntityCamera::execLogCallFunction(QString serial, QString Massage, long long userParam)
{
	//	printf( "执行回调函数\n" );
	if (this->m_pReceLogFunction != NULL)
	{
		this->m_pReceLogFunction(serial, Massage, userParam);
	}
}


/// 软件触发采图
void EntityCamera::softTriggerCap(QString userID)
{

	if (!m_pCamera->IsServerAccessible(m_pCamera->GetLocation()))
	{
		return;
	}
	//if (IBaseCamCommon::eSuspend == this->mWorkMode)//
	{
		bool Trigger = true;
		BOOL isAvailable;
		m_pCamera->IsFeatureAvailable("TriggerSoftware", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerSoftware", Trigger);
		}
	}
	//if (ICamCommon::eContinu == this->mWorkMode)
	{
		//	m_Xfer->Snap();
	}
	m_strUserID = userID;
}



//////////////////////////////////////////////////////////////////////////

bool EntityCamera::SN_ToSeverName(QString strSN, char* ServerName)
{
	char* serverSerial;
	serverSerial = new char[100];
	int serverCount = m_pManger->GetServerCount(SapManager::ResourceAcqDevice);//得到采集设备的数量
	for (int serverIndex = 0; serverIndex < serverCount; serverIndex++)
	{
		{
			memset(serverSerial, 0, 100 * sizeof(char));
			m_pManger->GetServerSerialNumber(serverIndex + 1, serverSerial);
			
			QString str = QString(QLatin1String(serverSerial));
			if (str == strSN)
			{
				BOOL IsServerName = m_pManger->GetServerName(serverIndex, SapManager::ResourceAcqDevice, ServerName);
				if (IsServerName)
				{
					delete serverSerial;
					return true;
				}
			}
		}
	}
	delete serverSerial;

	return false;
}


void EntityCamera::XferCallback(SapXferCallbackInfo* pInfo)
{
	EntityCamera* pDlg = (EntityCamera*)pInfo->GetContext();

	if (pInfo->IsTrash())
	{
		return;
	}

	if (pDlg->m_Xfer->UpdateFrameRateStatistics())
	{
		SapXferFrameRateInfo* pStats = pDlg->m_Xfer->GetFrameRateStatistics();

		if (pStats->IsLiveFrameRateAvailable() && !pStats->IsLiveFrameRateStalled())
		{
			//pDlg->strLiveFrameRate.Format(_T("帧率:%.1f"), pStats->GetLiveFrameRate());
		}
	}


	int m_iImageWidth = pDlg->m_pBuffers->GetWidth();
	int m_iImageHeight = pDlg->m_pBuffers->GetHeight();

	//BYTE* pData;
	//pDlg->m_pBuffers->GetAddress((void**)&pData);

	int nImageCount = 1;
	BOOL success = pDlg->m_pBuffers->GetAddress((void**)&pDlg->mImgCapBuffer.imgData);

	pDlg->mImgCapBuffer.count = nImageCount;
	pDlg->mImgCapBuffer.height = m_iImageHeight;
	pDlg->mImgCapBuffer.width = m_iImageWidth;
 	pDlg->execCallFunction(&pDlg->mImgCapBuffer, nImageCount);
}

//每次输入信号连接状态改变时都调用这个函数。
void EntityCamera::SignalCallback(SapAcqCallbackInfo* pInfo)
{
	EntityCamera* pDlg = (EntityCamera*)pInfo->GetContext();
	pDlg->GetSignalStatus(pInfo->GetSignalStatus());
}


void EntityCamera::GetSignalStatus()
{

}

void EntityCamera::GetSignalStatus(SapAcquisition::SignalStatus signalStatus)
{
	m_IsSignalDetected = (signalStatus != SapAcquisition::SignalNone);

	if (!m_IsSignalDetected)
	{
		QString newTitle = "未检测到摄像机信号";
		qDebug() << newTitle;
	}
}



/// 设置连续采集模式
bool EntityCamera::setToFreeRunMode()
{
	if (!m_Xfer->IsGrabbing())//检查当前数据传输是否正在进行中。
	{
		BOOL isAvailable;
		m_pCamera->IsFeatureAvailable("TriggerSelector", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerSelector", "FrameStart");
		}
		m_pCamera->IsFeatureAvailable("TriggerMode", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerMode", "Off");
		}
	}
	return true;
}
/// 设置软件触发模式
bool EntityCamera::setToSoftwareTrigerMode()
{
	if (!m_Xfer->IsGrabbing())//检查当前数据传输是否正在进行中。
	{
		BOOL isAvailable;
		m_pCamera->IsFeatureAvailable("TriggerSelector", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerSelector", "FrameStart");
		}
		m_pCamera->IsFeatureAvailable("TriggerMode", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerMode", "On");
		}
		m_pCamera->IsFeatureAvailable("TriggerSource", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerSource", "Software");
		}
	}
	return true;
}

/// 设置硬件触发模式
bool  EntityCamera::setToHardwareTrigerMode()
{
	//if (!m_Xfer->IsGrabbing())//检查当前数据传输是否正在进行中。
	{
		BOOL isAvailable;
		m_pCamera->IsFeatureAvailable("TriggerSelector", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerSelector", "FrameStart");
		}
		m_pCamera->IsFeatureAvailable("TriggerMode", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerMode", "On");
		}
		m_pCamera->IsFeatureAvailable("TriggerSource", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("TriggerSource", "Line1");
		}
		m_pCamera->IsFeatureAvailable("LineSelector", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("LineSelector", "Line3");
		}
		m_pCamera->IsFeatureAvailable("outputLineSource", &isAvailable);//检查节点可以使用
		if (isAvailable)
		{
			m_pCamera->SetFeatureValue("outputLineSource", "ExposureActive");
		}
		//m_pCamera->SetFeatureValue("outputLinePulseDuration", "400");
	}
	return true;
}