Hu Chunming / Project_VideoStructure

#include "MutliSourceVideoProcess.h"

#ifdef _MSC_VER
#include <io.h>
#include <direct.h>
#include "../putText.h"
#endif
#include <fstream>
#include <algorithm>
#include <thread>
#include <chrono>
#include <future>

#include "../utils/logger.hpp"
#include "../cuda_src/CropImg.h"
#include "../SfxDecoder/SfxEnv.hpp"


#define AUTHORIZATION
//#define DQ_AUTHORIZATION


#ifdef DQ_AUTHORIZATION
#include "license_validator.h"
#ifdef _MSC_VER
#define productSN "2AC69C4638EF46c884BD2BF132FF41D9" //��ǧ����-������ȨID
#else
#define productSN "683E9D5E56474da5A4C2D3EA9A00568E" //��ǧ����-������ȨID
#endif
#endif

#ifdef AUTHORIZATION
#include "authority.h"
#ifdef _MSC_VER
#define productSN "4ACFCBE67EF645AB8F0B4CFCDD1926F1" //WINDOWS�����Ʒϵ�к�
#else
#define productSN "4FD45501D5104F0C8C4BE530FC872F46" //LINUX�����Ʒϵ�к�
//#define productSN "7CF8B4797F9E441686145BED07F662DE" //LINUX�����Ʒϵ�к�
#endif
#endif
 

#define AUTH_LICENSE "sy_va_sub_sdk_2023"

static int TaskID = 0;


static long long get_cur_time_ms(){
	chrono::time_point<chrono::system_clock, chrono::milliseconds> tpMicro
		= chrono::time_point_cast<chrono::milliseconds>(chrono::system_clock::now());

	return tpMicro.time_since_epoch().count();
}


void check_thread(void* handle);

static void algorthim_process_thread(void* arg) {
	CMutliSourceVideoProcess* _this=(CMutliSourceVideoProcess*)arg;
	if(_this != nullptr){
		_this->algorthim_process();
	} else {
		LOG_ERROR("算法处理线程启动失败 !");
	}
}


//std::ofstream g_os("./cudaMem.txt", std::ofstream::out | std::ofstream::trunc);
CMutliSourceVideoProcess::CMutliSourceVideoProcess()
{
}

CMutliSourceVideoProcess::~CMutliSourceVideoProcess()
{
	//��־����ʼ��
	//DxUninitializeLog();
}

int CMutliSourceVideoProcess::FinishProcessThread()
{
	if (thrd_status == 0)
	{
		m_bExit = true;
		thrd.join();
		thrd_status = -1;
	}

	m_bProcessExit = true;
	ProcessThread.join();         //waiting thread finish

	m_vptProcess.release();
	m_snaphot_helper.snapshot_helper_release();

	return 1;
}

/*
	AI_LOG_LEVEL_CLOSE = -1,  // 关闭日志
	AI_LOG_LEVEL_TRACE = 0,   // 跟踪变量
	AI_LOG_LEVEL_DEBUG = 1,       // 调试日志
	AI_LOG_LEVEL_INFO = 2,        // 普通日志信息 （如：无关紧要的信息输出）
	AI_LOG_LEVEL_WARNING = 3,     // 警告日志通知，模块一切正常（如：重要流程通知）
	AI_LOG_LEVEL_ERROR = 4,       // 重要日志，如结果和严重错误
*/
int CMutliSourceVideoProcess::InitAlgorthim(mvpt_param vptParam, VIDEO_OBJECT_INFO_CALLBACK tObjInfoCallbackFunc)
{
	set_default_logger(LogLevel(vptParam.serviceID), vptParam.name, vptParam.path, 64 * 1024 * 1024, 30);
	
	licence_status = -1;
	thrd_status = -1;

	int ret = SUCCESS;

#ifdef AUTHORIZATION
#ifdef _WIN32
	if (SUCCESS == (ret = sy_licence(productSN)))
#elif __linux__
	char wtime[15];
	memset(wtime, 0, 15);
	char * time = wtime;
	ret = sy_licence(productSN, &time);
#endif
#else
	ret =  license_check(vptParam.auth_license, productSN);// sy_time_check(2022, 2);
	// ret = strcmp(AUTH_LICENSE, vptParam.auth_license);
#endif
	if (ret != SUCCESS){
		return AUTHOR_ERROR;
	}
	
	SfxEnv::init();

	cuInit(0);
	int device_count = 0;
	cuDeviceGetCount(&device_count);

	if (vptParam.gpuid >= device_count)
	{
		printf("\nGPU_ID PARAM WRONG, gpuid: %d  device_count: %d\n", vptParam.gpuid, device_count);
		return GPUID_PARAM_ERROR;
	}

	CUdevice dev = 0;
	size_t memSize = 0;
	dev = vptParam.gpuid;

	CUresult rlt = CUDA_SUCCESS;
	rlt = cuDeviceTotalMem(&memSize, dev);

	gpu_total_memory = (float)memSize / (1024 * 1024);

	if (gpu_total_memory < 9000)   //8G�Դ棬С�ڴ淽��
		section_batch_size = 10;
	else
		section_batch_size = 20;

	if(vptParam.skip_frame > 0){
		// 默认值为5
		skip_frame_ = vptParam.skip_frame;
	}

	mgpuid = vptParam.gpuid;
	ret = m_vptProcess.init(mgpuid, section_batch_size);
	if (0 != ret)
		return ret;

	viewTaskID = -1;
	TotalTask = 0;
	
	taskObjInfoCallbackFunc = nullptr;
	if (tObjInfoCallbackFunc != nullptr)
			taskObjInfoCallbackFunc = std::bind(tObjInfoCallbackFunc, this, std::placeholders::_1);

	CommandConfig cmdConfig;
	cmdConfig.hp_analysis_config = vptParam.hp_analysis_config;
	cmdConfig.hcp_analysis_config = vptParam.hcp_analysis_config;
	cmdConfig.vehicle_analysis_config = vptParam.vehicle_analysis_config;
	cmdConfig.hf_recg_config = vptParam.hf_recg_config;
	cmdConfig.hcf_recg_config = vptParam.hcf_recg_config;
	cmdConfig.vcf_recg_config = vptParam.vcf_recg_config;
	cmdConfig.face_detect_config = vptParam.face_det_config;   

	m_face_det_config = vptParam.face_det_config;   

	m_snaphot_helper.snapshot_helper_init(vptParam.gpuid, gpu_total_memory, vptParam.vrdbpath, AUTH_LICENSE, vptParam.wait_framecount, cmdConfig);

	m_bProcessExit = false;
	ProcessThread = std::thread(algorthim_process_thread, this);

	if (ret == SUCCESS)  //�ɹ�
	{
		licence_status = 0;
#ifdef AUTHORIZATION
		m_bExit = false;
		thrd = std::thread(check_thread, this);
#endif
		thrd_status = 0;
	}

	return ret;
}

void CMutliSourceVideoProcess::FinishTask(const int taskID)
{
	task_over(taskID, true);
}

void CMutliSourceVideoProcess::task_over(const int taskID, bool bOver) {

	if (m_taskMap.find(taskID) == m_taskMap.end()) {
		return;
	}

	Task& task = m_taskMap[taskID];

	task.taskState = FINISH;
	task.taskFileSource = nullptr;
	task.taskObjCallbackFunc = nullptr;
	task.taskRealTimeCallbackFunc = nullptr;

	m_snaphot_helper.finish_task_ss_analysis(taskID);

	if (task.folderName) {
		delete task.folderName;
		task.folderName = nullptr;
	}

	if (task.folderNameLittle) {
		delete task.folderNameLittle;
		task.folderNameLittle = nullptr;
	}

	task.frameImage.release();

	m_vptProcess.FinishTaskTracker(taskID);

	if (viewTaskID == taskID) {
		viewTaskID = -1;
	}

	m_snaphot_helper.waitSaveAnalysisInfo(task.taskID);

	if (task.taskTcuvid)
	{
		task.taskTcuvid->DxCloseDecoder();
		delete task.taskTcuvid;
		task.taskTcuvid = NULL;
	}

	//回调通知上层任务结束
	if (bOver && task.taskFinishCallbackFunc != nullptr) {
		std::lock_guard<std::mutex> l(m_snaphot_helper.callback_tx);
		task.taskFinishCallbackFunc(task.taskID);
	}

	LOG_INFO("task {} is finished. timeusing: {}", taskID, get_cur_time_ms() - task.timestamp);
}

void CMutliSourceVideoProcess::PauseTask(const int taskID)
{
	if (m_taskMap.find(taskID) == m_taskMap.end()){
		return;
	}

	Task& task = m_taskMap[taskID];

	task.taskState = PAUSE;
	m_vptProcess.PauseTaskTracker(taskID);
	task.taskTcuvid->PauseDecoder();
	if (viewTaskID == taskID) viewTaskID = -1;
	printf("-----------------------pasue task: %d-----------------------\n", taskID);
}

void CMutliSourceVideoProcess::RestartTask(const int taskID)
{
	if (m_taskMap.find(taskID) == m_taskMap.end()){
		return;
	}

	Task& task = m_taskMap[taskID];

	task.taskState = PLAY;
	m_vptProcess.RestartTaskTraker(taskID);
	task.taskTcuvid->ResumeDecoder();
	printf("-----------------------restart task: %d-----------------------\n", taskID);
}

//ʵʱ�鿴�ӿ� �ɿ���һ·��ʵʱ�鿴������·�ķ������OSD��Ȼ�󽫻���ͨ���ص��������ظ��û�
void CMutliSourceVideoProcess::ViewTask(const int taskID)
{
	if (m_taskMap.find(taskID) == m_taskMap.end()){
		printf("Only can view playing task!");
		return;
	}

	Task& task = m_taskMap[taskID];
	if (task.taskState == PLAY) {
		viewTaskID = taskID;
		printf("-----------------------view task: %d-----------------------\n", taskID);
	} else {
		printf("Only can view playing task!");
	}
}

//����ʵʱ�鿴�ӿڣ��ر�ʵʱ����ķ���
void CMutliSourceVideoProcess::FinishViewTask()
{
	viewTaskID = -1;
	printf("-----------------------finish view task-----------------------\n");
}

bool CMutliSourceVideoProcess::AddTask(task_param tparam) //debug by zsh
{
	const char* videoFileName = tparam.video_filename;
	const char* resultFolderLittle = tparam.result_folder_little;
	const char* resultFolder = tparam.result_folder;
	const char* resultFolderface = tparam.result_folder_face;
	VIDEO_OBJECT_SNAPSHOT_CALLBACK objCallbackFunc = tparam.obj_snapshot_callback_func;
	VIDEO_REALTIME_CALLBACK realTimeCallbackFunc = tparam.rt_view_callback_func;

	std::lock_guard<std::mutex> l(_tx_add_task);
	using std::placeholders::_1;

	Task new_task = {};
	new_task.taskID = TotalTask;
	new_task.taskFileSource = videoFileName;
	memcpy(new_task.task_min_boxsize, tparam.minBoxsize, sizeof(sy_rect)* DETECTTYPE);

	new_task.taskTcuvid = new DxDecoderWrap();
	if (NULL == new_task.taskTcuvid)
	{
		printf("Add New DxDecoder Failed!");
		AddTaskSucFlag = -1;
		return false;
	}

	DxConfig cfg = { 0 };
	cfg.devId = mgpuid;
	cfg.forceTcp = false;
	cfg.decMode = tparam.decMode;
	cfg.name = std::to_string(new_task.taskID);
	cfg.skip_frame = skip_frame_;
	cfg.uri = new_task.taskFileSource;
	cfg.log_all = (LOG_ALL_CALLBACK)tparam.log;
	cfg.log_user_ptr = tparam.userPtr;
	if (new_task.taskTcuvid->DxOpenDecoder(cfg) != 0)
	{
		cout << "Add Task Failed! Please check you video file name!" << endl;
		delete new_task.taskTcuvid;
		new_task.taskTcuvid = NULL;
		AddTaskSucFlag = -1;
		return false;
	}

	LOG_INFO("[{}] - add codec succeed.", cfg.name.c_str());

	new_task.taskState = PLAY;
	new_task.taskFrameCount = 0;
	new_task.taskLastFrameCount = 1;

	new_task.taskObjCallbackFunc = nullptr;
	if (objCallbackFunc != nullptr)
		 new_task.taskObjCallbackFunc = std::bind(objCallbackFunc, tparam.userPtr, std::placeholders::_1);

	new_task.taskRealTimeCallbackFunc = nullptr;
	if (realTimeCallbackFunc != nullptr)
		 new_task.taskRealTimeCallbackFunc = std::bind(realTimeCallbackFunc, tparam.userPtr, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);

	new_task.taskFinishCallbackFunc = nullptr;
	if (tparam.tFinishCallbackFunc != nullptr)
		new_task.taskFinishCallbackFunc = std::bind(tparam.tFinishCallbackFunc, tparam.userPtr, std::placeholders::_1);

	if (resultFolderLittle == NULL)
	{
		new_task.folderNameLittle = NULL;
	}
	else
	{
		new_task.folderNameLittle = new char[strlen(resultFolderLittle) + 2]{};
		strcpy(new_task.folderNameLittle, resultFolderLittle);

		int length = strlen(new_task.folderNameLittle);
		if (new_task.folderNameLittle[length - 1] != '\\' && new_task.folderNameLittle[length - 1] != '/')
		{
			new_task.folderNameLittle[length] = '/';
			new_task.folderNameLittle[length + 1] = '\0';
		}

		CreateResultFolder(new_task.folderNameLittle, "");
	}


	if (resultFolder == NULL)
	{
		new_task.folderName = NULL;
	}
	else
	{
		new_task.folderName = new char[strlen(resultFolder) + 2]{};
		strcpy(new_task.folderName, resultFolder);

		int length = strlen(new_task.folderName);
		if (new_task.folderName[length - 1] != '\\' && new_task.folderName[length - 1] != '/')
		{
			new_task.folderName[length] = '/';
			new_task.folderName[length + 1] = '\0';
		}

		CreateResultFolder(new_task.folderName, "");
	}

	if (resultFolderface == NULL)
	{
		new_task.folderNameFace = NULL;
	}
	else
	{
		new_task.folderNameFace = new char[strlen(resultFolderface) + 2]{};
		strcpy(new_task.folderNameFace, resultFolderface);

		int length = strlen(new_task.folderNameFace);
		if (new_task.folderNameFace[length - 1] != '\\' && new_task.folderNameFace[length - 1] != '/')
		{
			new_task.folderNameFace[length] = '/';
			new_task.folderNameFace[length + 1] = '\0';
		}

		CreateResultFolder(new_task.folderNameFace, "");
	}
	new_task.timestamp = get_cur_time_ms();

	TASK_INFO new_task_info = {};
	new_task_info.image_folder = new_task.folderName;
	new_task_info.snapshot_folder = new_task.folderNameLittle;
	new_task_info.snapshot_folder_face = new_task.folderNameFace;
	new_task_info.task_total_framecount = new_task.taskTotalFrameCount;
	new_task_info._on_image_display = tparam.on_image_display;
	new_task_info.jpeg_quality_ = tparam.jpeg_quality; //debug by zsh
	new_task_info.obj_callback = new_task.taskObjCallbackFunc;
	m_snaphot_helper.add_task_info(new_task.taskID, new_task_info);

	m_taskMap[new_task.taskID] = new_task;

	TotalTask++;

	m_vptProcess.AddTaskTracker(new_task.taskID);
	
	AddTaskSucFlag = 1;

	LOG_INFO("add task: {} succeed. timestamp: {} ", new_task.taskID,  get_cur_time_ms());
	return true;
}

int CMutliSourceVideoProcess::AddOperator(task_param tparam)
{
	{
		//	printf("add first task in operator queue\n");
		std::unique_lock<std::mutex> l(taskMutex);
		AddTaskSucFlag = 0;
		Operator newOper;
		newOper.changeTaskID = 0;
		newOper.changeTaskOperator = ADDTASK;

		strcpy(newOper.videoFileName, tparam.video_filename);
		strcpy(newOper.resultFolderLittleName, tparam.result_folder_little);
		strcpy(newOper.resultFolderName, tparam.result_folder);
		strcpy(newOper.result_folder_face, tparam.result_folder_face);
		newOper.on_image_display = tparam.on_image_display;
		newOper.jpeg_quality = tparam.jpeg_quality; 
		newOper.decMode = tparam.decMode;
		newOper.taskObjCallbackFunc = tparam.obj_snapshot_callback_func;
		newOper.taskRealTimeCallbackFunc = tparam.rt_view_callback_func;
		newOper.tFinishCallbackFunc = tparam.tFinishCallbackFunc;
		newOper.taskSfxLogFunc = tparam.log;
		newOper.logUserPtr = tparam.userPtr;
		memcpy(newOper.minBoxsize, tparam.minBoxsize, sizeof(sy_rect)* DETECTTYPE);
		TaskOperatorQ.push_back(newOper);
		taskCondVar.wait_for(l, std::chrono::seconds(20));
	}

	int addRes = -1;
	int newTaskID = TaskID++;

	if (AddTaskSucFlag == 1)
	{
		addRes = newTaskID;
	}
	else if (AddTaskSucFlag == -1)
	{
		addRes = -1;
		TaskID--;
	}
	else if (AddTaskSucFlag == 0)
	{
		Operator newOper = TaskOperatorQ.back();
		if (strcmp(newOper.videoFileName, tparam.video_filename) == 0)
		{
			TaskOperatorQ.pop_back();
		}
		LOG_ERROR("Failed Add New Task! Algorithm Process Error: {}", tparam.video_filename);
	}

	return addRes;
}

int CMutliSourceVideoProcess::get_task_progress(int taskid, double &progress)
{
	int ret = -1;
	if (m_taskMap.find(taskid) == m_taskMap.end()){
		return ret;
	}

	Task& task = m_taskMap[taskid];
	progress = (double)task.taskFrameCount / (double)task.taskTotalFrameCount;
	return 0;
}

void CMutliSourceVideoProcess::AddOperator(int taskID, int taskOper)
{
	if (taskOper > 0 && taskOper < 4)
	{
		Operator newOper = {};
		newOper.changeTaskID = taskID;
		newOper.changeTaskOperator = TaskOperator(taskOper);
		//TaskOperatorQ.push(newOper);
		TaskOperatorQ.push_back(newOper);
	}
}

void CMutliSourceVideoProcess::OperatorTask()
{
	while (!TaskOperatorQ.empty())
	{
		Operator newOperator = TaskOperatorQ.front();
		TaskOperatorQ.pop_front();

		switch (newOperator.changeTaskOperator)
		{
		case ADDTASK:
			{
				task_param tparam;
				strcpy(tparam.video_filename, newOperator.videoFileName);
				strcpy(tparam.result_folder_little, newOperator.resultFolderLittleName);
				strcpy(tparam.result_folder, newOperator.resultFolderName);
				strcpy(tparam.result_folder_face, newOperator.result_folder_face);
				tparam.on_image_display = newOperator.on_image_display; 
				tparam.jpeg_quality = newOperator.jpeg_quality;
				memcpy(tparam.minBoxsize, newOperator.minBoxsize, sizeof(sy_rect)* DETECTTYPE);
				tparam.obj_snapshot_callback_func = newOperator.taskObjCallbackFunc;
				tparam.rt_view_callback_func = newOperator.taskRealTimeCallbackFunc;
				tparam.tFinishCallbackFunc = newOperator.tFinishCallbackFunc;
				tparam.decMode = newOperator.decMode;
				tparam.log = newOperator.taskSfxLogFunc;
				tparam.userPtr = newOperator.logUserPtr;

				AddTask(tparam);
			}	
			break;
		case PAUSETASK:
			PauseTask(newOperator.changeTaskID);
			break;
		case RESTARTTASK:
			RestartTask(newOperator.changeTaskID);
			break;
		case FINISHTASK:
			{
				FinishTask(newOperator.changeTaskID);
				auto iter = m_taskMap.find(newOperator.changeTaskID);
				if (iter != m_taskMap.end()) {
					m_taskMap.erase(iter);
				}
			}
			break;
		default:
			break;
		}

	}
}

//#define LOG_INFO
void CMutliSourceVideoProcess::callTaskObjInfoCallbackFunc(const VPT_Result& vptResult, int taskFrameCount, int taskId)
{
	if (vptResult.objCount == 0)
	{
		video_object_info newObjInfo;
		newObjInfo.task_id = taskId;
		newObjInfo.task_frame_count = taskFrameCount;
		newObjInfo.object_id = -1;
		newObjInfo.left = 0;
		newObjInfo.right = 0;
		newObjInfo.top = 0;
		newObjInfo.bottom = 0;
		newObjInfo.index = 0;
		newObjInfo.confidence = 0;

		if (taskObjInfoCallbackFunc != nullptr)
			taskObjInfoCallbackFunc(&newObjInfo);
	}
	else
	{
		for (int c = 0; c < vptResult.objCount; c++)
		{
			const VPT_ObjInfo* obj = vptResult.obj;
			OBJ_KEY newObj = { taskId, obj[c].id };
			video_object_info newObjInfo;
			newObjInfo.task_id = taskId;
			newObjInfo.task_frame_count = taskFrameCount;
			newObjInfo.object_id = obj[c].id;
			newObjInfo.left = obj[c].left;
			newObjInfo.right = obj[c].right;
			newObjInfo.top = obj[c].top;
			newObjInfo.bottom = obj[c].bottom;

			int index = m_snaphot_helper.getIndexByKey(newObj);
			if(index < 0) {
				newObjInfo.index = obj[c].index;
			} else {
				newObjInfo.index = index;
			}

			newObjInfo.confidence = obj[c].confidence;
			if (taskObjInfoCallbackFunc != nullptr)
			{
				taskObjInfoCallbackFunc(&newObjInfo);
			}
		}

	}
}

void CMutliSourceVideoProcess::algorthim_process()
{
	cudaSetDevice(mgpuid);

	int total_count = 0;
	long long begintime1 = get_cur_time_ms();
	long long last_time =  begintime1;
	while (!m_bProcessExit) {

		if (licence_status <= -3) {
			LOG_ERROR("authority failed!\n");
			break;
		} 

		{
			std::lock_guard<std::mutex> l(taskMutex);
			OperatorTask();
		}
		
		taskCondVar.notify_all();

		for (auto it=m_taskMap.begin(); it!=m_taskMap.end(); ) {
			Task& task = it->second;
			if (!task.taskTcuvid->DxDecoderIsRun() && task.taskTcuvid->DxFrameIsEmpty()) {
				//if (task.taskTcuvid->IsHandleClose())
				//{
				//	task_over(task.taskID, false);
				//}
				//else 
				{
					task_over(task.taskID, true);
				}
				it = m_taskMap.erase(it);
			} else {
				++it;
			}
		}

		vector<DxGPUFrame> vec_dxGpuFrame;
		for (auto it=m_taskMap.begin(); it!=m_taskMap.end(); ++it) {
			Task& task = it->second;
			DxGPUFrame dxFrame = task.taskTcuvid->DxGetFrame();
			if(nullptr == dxFrame.frame) {
				continue;
			}
			vec_dxGpuFrame.push_back(dxFrame);

			if(!task.bInited) {
				// 有些初始化信息只有在实时数据时才给出
				task.bInited = true;

				task.frameImage = cv::Mat::zeros(dxFrame.height, dxFrame.width, CV_8UC3);
			}
			if(task.taskTotalFrameCount <= 1) {
				task.taskTotalFrameCount = task.taskTcuvid->DxGetFrameCount();
				m_snaphot_helper.update_taotal_frame_count(task.taskID, task.taskTotalFrameCount);
			}

			task.taskFrameCount = dxFrame.timestamp;
		}

		if (vec_dxGpuFrame.size() <= 0) {
			std::this_thread::sleep_for(std::chrono::milliseconds(5));
			continue;
		}
		

#ifdef LOG_INFO2
		long long gather_data_time =  get_cur_time_ms();
		std::cout << "gather_data time_using: " << gather_data_time - last_time << std::endl;
#endif

		cudaDeviceSynchronize();
		
		long long start_time_vpt = get_cur_time_ms();

		vector<DataInfo> vec_data;
		for (auto task_algorithm_data: vec_dxGpuFrame) {
			int w = task_algorithm_data.width;
			int h = task_algorithm_data.height;
			
			DataInfo data_info;
			data_info.img.set_data(w, h, 3, (unsigned char *)task_algorithm_data.frame);
			data_info.task_id = atoi(task_algorithm_data.dec_name.c_str());
			data_info.frameIndex = task_algorithm_data.timestamp;

			vec_data.push_back(data_info);
		}

		vector<VPTProcessResult> vec_vptResult = m_vptProcess.process(vec_data);

		//LOG_DEBUG("VPT_Process_GPU time_using: {}", get_cur_time_ms() - start_time_vpt);
		
		long long result_analysis_time = get_cur_time_ms();

		for (int i = 0; i < vec_vptResult.size(); i++)
		{
			int task_id = vec_vptResult[i].task_id;
			Task& task = m_taskMap[task_id];

			DxGPUFrame& task_algorithm_data = vec_dxGpuFrame[i];
			
			//实时查看模块，若存在实时查看，把当前视频画面cp回内存
			bool view = false;
			int frameHeight = task_algorithm_data.height;
			int frameWidth = task_algorithm_data.width;

			if (task_id == viewTaskID) {
				cudaMemcpy(task.frameImage.data, task_algorithm_data.frame, 3 * frameWidth * frameHeight * sizeof(unsigned char), cudaMemcpyDeviceToHost);
				view = true;
			}

			//跟踪帧也需要返回跟踪的结果
			if (task.taskLastFrameCount > 0) {

				VPT_Result default_vptResult;
				default_vptResult.objCount = 0;

				vector<VPT_Result> OneUnUsedResult = vec_vptResult[i].vecUnUsedResult;
				if (OneUnUsedResult.size() == 0) {
					callTaskObjInfoCallbackFunc(default_vptResult, task.taskLastFrameCount + 1, task_id);
				}

				for (int k = 0; k < OneUnUsedResult.size(); ++k) {
					if (OneUnUsedResult[k].objCount == 0) {
						callTaskObjInfoCallbackFunc(default_vptResult, task.taskLastFrameCount + k + 1, task_id);
					} else {
						callTaskObjInfoCallbackFunc(OneUnUsedResult[k], task.taskLastFrameCount + k + 1, task_id);
					}
				}
			}

			VPT_Result vptResult = vec_vptResult[i].vptResult;
			callTaskObjInfoCallbackFunc(vptResult, task_algorithm_data.timestamp, task_id);

			task.taskLastFrameCount = task_algorithm_data.timestamp;

			unsigned char* snapshot_image_data[MAX_OBJ_COUNT]{};
			int snapshot_left[MAX_OBJ_COUNT]{};
			int snapshot_right[MAX_OBJ_COUNT]{};
			int snapshot_top[MAX_OBJ_COUNT]{};
			int snapshot_bottom[MAX_OBJ_COUNT]{};
			int snapshot_dst_width[MAX_OBJ_COUNT]{};
			int snapshot_dst_height[MAX_OBJ_COUNT]{};

			int copy_obj_count = 0;  //用于记录该路有多少个目标需要进行显存图像的更新
			vector<int> human_idx;    //用于记录快照数组中那些是人脸
			vector<OBJ_KEY> human_obj_keys;

			for (int c = 0; c < vptResult.objCount; c++)
			{
				VPT_ObjInfo obj = vptResult.obj[c];

				OBJ_KEY newObj = { task_id, obj.id };

				//实时查看模块 绘制目标框到画面上
				if (view)
				{
					int index = m_snaphot_helper.getIndexByKey(newObj);
					if(index < 0) {
						index = obj.index;
					}

					//cout << "---- vew ----  ";
					int p1 = obj.left - 10 > 0 ? obj.left - 10 : 0;
					int p2 = obj.top - 15 > 0 ? obj.top - 15 : 0;

					cv::rectangle(task.frameImage, Rect(obj.left, obj.top, obj.right - obj.left, obj.bottom - obj.top), Scalar(158, 52, 254), 3, 1, 0);
		#ifdef _MSC_VER
					string resss = "" + to_string(index) + " " + ObjTypes[index];
					putTextZH(task.frameImage, resss.c_str(), { p1, p2 }, Scalar(20, 255, 20), 14, "Arial");
		#else
					string resss = "" + to_string(obj.id) + " " + ObjTypesEnglish[obj.index];
					cv::putText(task.frameImage, resss.c_str(), cv::Point(p1, p2), cv::FONT_HERSHEY_COMPLEX, 2, Scalar(20, 255, 20), 2, 8, 0);
		#endif
				}

				bool bCacheSrc = false;
				if (task.folderName != NULL){
					bCacheSrc = true;
				}

				bool bCacheLittle = false;
				if (task.folderNameLittle != NULL) {
					bCacheLittle = true;
				}

				CropInfo crop_info = m_snaphot_helper.cacheSnapShotInfo(newObj, obj, task.task_min_boxsize, bCacheSrc, bCacheLittle, task_algorithm_data);
				if(crop_info.bCrop){
					snapshot_image_data[copy_obj_count] = crop_info.snapshot_image_data;
					snapshot_left[copy_obj_count] = crop_info.snapshot_left;
					snapshot_top[copy_obj_count] = crop_info.snapshot_top;
					snapshot_right[copy_obj_count] = crop_info.snapshot_right;
					snapshot_bottom[copy_obj_count] = crop_info.snapshot_bottom;
					snapshot_dst_width[copy_obj_count] = crop_info.snapshot_dst_width;
					snapshot_dst_height[copy_obj_count] = crop_info.snapshot_dst_height;

					int index = m_snaphot_helper.getIndexByKey(newObj);
					if(0 == index) {
						human_idx.push_back(copy_obj_count);
						human_obj_keys.emplace_back(newObj);
					}

					copy_obj_count++;
				}
			}

			//若待抠图的快照数不为0 则进行批量抠图
			if (0 != copy_obj_count)
			{
				PartMemResizeBatch((unsigned char*)task_algorithm_data.frame, frameWidth, frameHeight,
					snapshot_image_data, copy_obj_count, snapshot_left, snapshot_top, snapshot_right, snapshot_bottom, snapshot_dst_width, snapshot_dst_height, 0, 0, 0, 1, 1, 1);
			
				//最新刚添加的人脸检测模块，针对存在的行人快照进行人脸检测+人脸快照框的优选
				if (m_face_det_config == SY_CONFIG_OPEN && !human_idx.empty())
				{
					//需要做人脸检测
					int human_count = human_idx.size();
					vector<sy_img> vec_human_img;
					vector< sy_point> vec_points;
					for (int idx = 0; idx < human_count; idx++)
					{
						int ii = human_idx[idx];
						sy_img human_img;
						human_img.set_data(snapshot_dst_width[ii], snapshot_dst_height[ii], 3, snapshot_image_data[ii]);
						sy_point ori_point;
						ori_point.x_ = (snapshot_right[ii] - snapshot_left[ii]);
						ori_point.y_ = (snapshot_bottom[ii] - snapshot_top[ii]);
						vec_points.push_back(ori_point);
						vec_human_img.push_back(human_img);
					}

					m_snaphot_helper.cacheFaceSnapshotInfo(vec_human_img.data(), human_count, vec_points.data(), human_idx, human_obj_keys, snapshot_left, snapshot_top, task_algorithm_data);
				}
			}

			//实时查看 绘制目标轨迹 回调函数返回
			if (view) {
				m_vptProcess.DrawTracker(task_id, &task.frameImage);
				if (task.taskRealTimeCallbackFunc != nullptr)
					task.taskRealTimeCallbackFunc(task.frameImage.data, task.frameImage.rows, task.frameImage.cols);
			}
		}
		

#ifdef LOG_INFO2
		long long result_analysis_time2 = get_cur_time_ms();
		cout << "result_analysis time_using:" << result_analysis_time2 - result_analysis_time << endl;
#endif

		long long second_analysis_time = get_cur_time_ms();

		for (int i = 0; i < vec_vptResult.size(); i++)
		{
			vector<int>& vecDeleteObj = vec_vptResult[i].vecDeleteObj;
			for (int j = 0; j < vecDeleteObj.size(); j++)
			{
				OBJ_KEY deleteObj = { vec_vptResult[i].task_id, vecDeleteObj[j] };
				m_snaphot_helper.SaveResultInFile(deleteObj);
			}
		}

		m_snaphot_helper.object_attri_analysis();
		cudaError_t cudaStatus = cudaGetLastError();
		if (cudaStatus != cudaSuccess) {
			LOG_ERROR("object_attri_analysis last error: {}", cudaGetErrorString(cudaStatus));
		}

		for (auto task_algorithm_data: vec_dxGpuFrame) {
			cudaFree(task_algorithm_data.frame);
			task_algorithm_data.frame = nullptr;
		}

#ifdef LOG_INFO2
		long long second_analysis_time2 = get_cur_time_ms();
		cout << "second_analysis time_using:" << second_analysis_time2 - second_analysis_time << endl;
#endif

		++total_count;

#ifdef LOG_INFO2
		last_time =  get_cur_time_ms();
		cout << "process time_using:" << last_time - gather_data_time << endl;
		cout << endl;
#endif
	}

	m_snaphot_helper.clearSnapshotInfo();

	long long costTime1 = get_cur_time_ms() - begintime1;
	LOG_INFO("Process Thread is Finished. total frame cost time = {} ms", costTime1);
}

int CMutliSourceVideoProcess::GetRuningNb() {
	int no = 0;
	for (auto it=m_taskMap.begin(); it!=m_taskMap.end(); ++it) {
		Task& task = it->second;
		if(task.taskState == PLAY){
			no ++;
		}
	}
	return no;
}

#ifdef AUTHORIZATION
void check_thread(void* handle)
{
	int res = -1;
#ifndef _MSC_VER
	char wtime[15];
	memset(wtime, 0, 15);
	char * time = wtime;
#endif

	CMutliSourceVideoProcess *_this = (CMutliSourceVideoProcess *)handle;

	while (!_this->m_bExit)
	{
		//printf("xxx check status on process...\n");
#ifdef _MSC_VER
		res = sy_licence(productSN);
#else
		res = sy_licence(productSN, &time);
		//printf("--------------wtime in thread: %s, status: %d\n", wtime, licence_status);
#endif
		if (res < 0)
		{
			_this->licence_status = _this->licence_status - 1;
			printf("CMutliSourceVideoProcess licence error, ret: %d \n", res);
		}
		else
		{
			if (_this->licence_status < 0)
			{
				_this->licence_status = 0;
			}
		}
		std::this_thread::sleep_for(std::chrono::seconds(300));
	}
}
#endif