#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 "../FFNvDecoder/logger.hpp"

#include "face_detect.h"
#include "CropImg.h"
//#include <strsafe.h>
//#include <shlwapi.h>
//#include <DbgHelp.h>
//#pragma comment(lib, "DbgHelp.Lib")
//#pragma comment(lib, "ShLwApi.lib")
//********************************************************//
//1.Ϊʲô��ʱ�򷵻ص�index=2��ȴδ�����ﳵ�ķ�������Ϊindex�ں�����Ϊ��2�����Ǵ�ʱ�Ŀ��ղ�������֮ǰ�Ŀ��գ����Կ���δ���£�����ͼ���С����Ϊ112*224

#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 LOG_INFO //�Ƿ������ٴ�ӡ
// #define SKIP_FRMAE 5  //��֡֡��
#define EXTIME 500

static int TaskID = 0;

auto show_gpu_syimage_ = [](sy_img& cur_frame) {

	unsigned char* cpu_data = new unsigned char[3 * cur_frame.w_ * cur_frame.h_];
	cudaMemcpy(cpu_data, cur_frame.data_, 3 * cur_frame.w_ * cur_frame.h_ * sizeof(unsigned char), cudaMemcpyDeviceToHost);
	cv::Mat img(cur_frame.h_, cur_frame.w_, CV_8UC3, cpu_data);

	cv::imshow("img", img);
	cv::waitKey(0);
	delete[] cpu_data;
};

auto show_gpu_image_ = [](DxGPUFrame& cur_frame) {

	unsigned char* cpu_data = new unsigned char[3 * cur_frame.width * cur_frame.height];
	cudaMemcpy(cpu_data, cur_frame.frame, 3 * cur_frame.width * cur_frame.height * sizeof(unsigned char), cudaMemcpyDeviceToHost);
	cv::Mat img(cur_frame.height, cur_frame.width, CV_8UC3, cpu_data);

	cv::imshow("img2", img);
	cv::waitKey(0);
	delete[] cpu_data;
}; 

auto show_gpu_image_withrect_ = [](DxGPUFrame& cur_frame, sy_rect &rect) {

	unsigned char* cpu_data = new unsigned char[3 * cur_frame.width * cur_frame.height];
	cudaMemcpy(cpu_data, cur_frame.frame, 3 * cur_frame.width * cur_frame.height * sizeof(unsigned char), cudaMemcpyDeviceToHost);
	cv::Mat img(cur_frame.height, cur_frame.width, CV_8UC3, cpu_data);
	cv::rectangle(img, cv::Rect(rect.left_, rect.top_, rect.width_, rect.height_), cv::Scalar(25, 25, 250), 2, 8, 0);
	cv::imshow("ori", img);
	cv::waitKey(0);
	delete[] cpu_data;
};

auto show_gpu_image_withfdinfo_ = [](DxGPUFrame& cur_frame, fd_info &face_info) {

	unsigned char* cpu_data = new unsigned char[3 * cur_frame.width * cur_frame.height];
	cudaMemcpy(cpu_data, cur_frame.frame, 3 * cur_frame.width * cur_frame.height * sizeof(unsigned char), cudaMemcpyDeviceToHost);
	cv::Mat img(cur_frame.height, cur_frame.width, CV_8UC3, cpu_data);
	
	printf("%d %d\n", cur_frame.width , cur_frame.height);
	for (int ii = 0; ii < 25; ii++)
	{
		printf("(%d %d) ", face_info.facial_fea_point[ii].x_, face_info.facial_fea_point[ii].y_);
		cv::circle(img, cv::Point(face_info.facial_fea_point[ii].x_, face_info.facial_fea_point[ii].y_), 1, cv::Scalar(0, 255, 0));

	}
	//cv::rectangle(img, cv::Rect(face_info.face_position.left_, face_info.face_position.top_, face_info.face_position.width_, face_info.face_position.height_), cv::Scalar(25, 25, 250), 2, 8, 0);

	cv::Mat big_img;
	cv::resize(img, big_img, cv::Size(400, 400));


	cv::imshow("ori33", img);
	cv::imshow("ori44", big_img);
	cv::waitKey(0);
	delete[] cpu_data;
};

auto show_gpu_image_with2rect_ = [](DxGPUFrame& cur_frame, sy_rect &rect, sy_rect &rect2) {

	unsigned char* cpu_data = new unsigned char[3 * cur_frame.width * cur_frame.height];
	cudaMemcpy(cpu_data, cur_frame.frame, 3 * cur_frame.width * cur_frame.height * sizeof(unsigned char), cudaMemcpyDeviceToHost);
	cv::Mat img(cur_frame.height, cur_frame.width, CV_8UC3, cpu_data);
	cv::rectangle(img, cv::Rect(rect.left_, rect.top_, rect.width_, rect.height_), cv::Scalar(25, 25, 250), 1, 8, 0);
	cv::rectangle(img, cv::Rect(rect2.left_, rect2.top_, rect2.width_, rect2.height_), cv::Scalar(25, 250, 25), 1, 8, 0);
	cv::imshow("ori2", img);
	cv::waitKey(0);
	delete[] cpu_data;
};

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();
}

std::function<void(DxGPUFrame&)> show_gpu_img_func = show_gpu_image_;

void check_thread(void* handle);
DWORD ThreadProcess(LPVOID param);


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

// dump�ļ�
//static LONG WINAPI CustomExceptionCrashHandler(_In_ EXCEPTION_POINTERS *CONST pException)
//{
//	char dumpPath[MAX_PATH];
//
//	BOOL tempDump = FALSE;
//	do {
//
//		if (0 == GetTempPath(_countof(dumpPath), dumpPath))
//			break;
//
//		// %temp%Ŀ¼���½�dump�ļ���
//		if (!PathAppend(dumpPath, "dump"))
//			break;
//		CreateDirectory(dumpPath, NULL);
//		// dump�ļ�����dump�ļ��ļ��� ���Զ����޸�
//		if (!PathAppend(dumpPath, "HSTProcessor"))
//			break;
//
//		SYSTEMTIME lclTm;
//		GetLocalTime(&lclTm);
//		char ext[29];
//		// dump�ļ�������ʱ����
//		if (FAILED(StringCchPrintf(ext, _countof(ext), ".%04hu%02hu%02hu%02hu%02hu%02hu.unhdlexc.dmp", lclTm.wYear, lclTm.wMonth, lclTm.wDay, lclTm.wHour, lclTm.wMinute, lclTm.wSecond)))
//			break;
//		if (FAILED(StringCchCat(dumpPath, _countof(dumpPath), ext)))
//			break;
//
//		tempDump = TRUE;
//	} while (FALSE);
//	HANDLE CONST dumpFile = CreateFile(dumpPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
//	if (INVALID_HANDLE_VALUE == dumpPath)
//	{
//		return EXCEPTION_EXECUTE_HANDLER;
//	}
//
//	MINIDUMP_EXCEPTION_INFORMATION dumpInfo;
//	dumpInfo.ThreadId = GetCurrentThreadId();
//	dumpInfo.ExceptionPointers = pException;
//	dumpInfo.ClientPointers = TRUE;
//
//	if (FAILED(MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), dumpFile, MiniDumpNormal, &dumpInfo, NULL, NULL)))
//	{
//		CloseHandle(dumpFile);
//	}
//	CloseHandle(dumpFile);
//
//	return EXCEPTION_EXECUTE_HANDLER;
//}


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

	VPT_Release(VPT_Handle);
	m_face_det_module->face_det_module_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, VIDEO_FINISH_CALLBACK tFinishCallbackFunc)
{
	set_default_logger(LogLevel(1), "multi_source_process", "logs/main.log", 64 * 1024 * 1024, 30);
	
	//	checkGpuMem();
	licence_status = -1;
	thrd_status = -1;
	//SetUnhandledExceptionFilter(CustomExceptionCrashHandler);

	int ret = SUCCESS;
	/*DxLogConfig sCfg = { 0 };
	sCfg.serviceID = vptParam.serviceID;
	sCfg.limitSize = vptParam.limitSize;
	strcpy(sCfg.name, vptParam.name);
	strcpy(sCfg.path, vptParam.path);
	DxInitializeLog(&sCfg);*/

	/*printf("=====================��ȨERROR==================\n");
	printf("=====================��ȨERROR==================\n");
	printf("=====================��ȨERROR==================\n");*/
#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);
	if (SUCCESS == ret)
#endif
#else
	ret =  license_check(vptParam.auth_license, productSN);// sy_time_check(2022, 2);
	if (ret == SUCCESS)
#endif
	{
		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;
		}

		VPTProcess_PARAM param{};
		//param.c = 3;
		param.mode = DEVICE_GPU;
		param.gpuid = vptParam.gpuid;
		//param.threshold = 0.6;
		param.threshold = 0.5;
		param.engine = ENGINE_TENSORRT;
		param.max_batch = section_batch_size;
		param.serialize_file = "./serialize_file/VPT";
		param.auth_license = vptParam.auth_license;
		mgpuid = vptParam.gpuid;
		VPT_Handle = NULL;
		ret = VPT_Init(VPT_Handle, param);
		if (0 != ret)
			return ret;

		m_face_det_module = nullptr;
		if (vptParam.face_det_config == SY_CONFIG_OPEN)
		{
			m_face_det_module = new face_det_module();
			printf("begin init face det\n");
			m_face_det_module->face_det_module_init(vptParam.gpuid, vptParam.auth_license);
		}

		viewTaskID = -1;
		TaskinPlay = 0;
		TotalTask = 0;
		capacity = 20;
		VPTResult.resize(capacity);
		//dwThreadID = 0;
		ProcessFlag = false;
		SourceFlag = false;

		mModeSnapshotVideo = "cpu";
		mModeSnapshotLittle = "cpu";

		taskFinishCallbackFunc = nullptr;
		if (tFinishCallbackFunc != nullptr)
			 taskFinishCallbackFunc = std::bind(tFinishCallbackFunc, this, std::placeholders::_1);
		
		taskObjInfoCallbackFunc = nullptr;
		if (tObjInfoCallbackFunc != nullptr)
			 taskObjInfoCallbackFunc = std::bind(tObjInfoCallbackFunc, this, std::placeholders::_1);

		minDistance[0] = minDistance[2] = 35;  //left right
		minDistance[1] = minDistance[3] = 50;  //top bottom

		m_hp_analysis_config = vptParam.hp_analysis_config;
		m_hcp_analysis_config = vptParam.hcp_analysis_config;
		m_vehicle_analysis_config = vptParam.vehicle_analysis_config;
		m_hf_recg_config = vptParam.hf_recg_config;
		m_hcf_recg_config = vptParam.hcf_recg_config;
		m_vcf_recg_config = vptParam.vcf_recg_config;
		m_face_det_config = vptParam.face_det_config;

		m_snaphot_helper.snapshot_helper_init(vptParam.gpuid, gpu_total_memory, vptParam.vrdbpath, vptParam.auth_license, vptParam.wait_framecount, m_hp_analysis_config, \
			m_hcp_analysis_config, m_vehicle_analysis_config, m_vehicle_recg_config, m_vehicle_plate_det_recg_config, m_hf_recg_config, m_hcf_recg_config, m_vcf_recg_config);
		if (ret == SUCCESS)  //�ɹ�
		{
			licence_status = 0;
#ifdef AUTHORIZATION
			m_bExit = false;
			thrd = std::thread(check_thread, this);
#endif
			thrd_status = 0;
		}

	}
	else
	{
		return AUTHOR_ERROR;
	}
/*
#ifdef AUTHORIZATION	
#ifdef __linux__
	if (wtime)
	{
		delete[] wtime;
		wtime = NULL;
	}
#endif
#endif */ // debug by zsh
	return ret;
}

void CMutliSourceVideoProcess::FinishDecode(const int taskID)
{
	for (int i = 0; i < tasks.size(); i++)
	{
		if (tasks[i].taskID == taskID && tasks[taskID].taskTcuvid != NULL)
		{
			tasks[taskID].taskState == FINISH;
			tasks[taskID].taskTcuvid->DxCloseDecoder();
			delete tasks[taskID].taskTcuvid;
			tasks[taskID].taskTcuvid = NULL;
			printf("-----------------------finish task: %d-----------------------\n", taskID);
			break;
		}
	}

}

void CMutliSourceVideoProcess::FinishTask(const int taskID)
{
	for (int i = 0; i < tasks.size(); i++)
	{
		if (tasks[i].taskID == taskID)
		{
			//printf("first begin finish\n");
			if (tasks[i].taskState == PLAY) TaskinPlay--;
			tasks[i].taskState = FINISH;
			tasks[i].taskFileSource = nullptr;
			tasks[i].taskObjCallbackFunc = nullptr;
			tasks[i].taskRealTimeCallbackFunc = nullptr;

			m_snaphot_helper.finish_task_ss_analysis(taskID, m_hp_analysis_config, m_hcp_analysis_config, m_vehicle_analysis_config, m_hf_recg_config, m_hcf_recg_config, m_vcf_recg_config);

			if (tasks[i].folderName)
			{
				delete tasks[i].folderName;
				tasks[i].folderName = nullptr;
			}


			if (tasks[i].folderNameLittle)
			{
				delete tasks[i].folderNameLittle;
				tasks[i].folderNameLittle = nullptr;
			}

			tasks[i].frameImage.release();


			if (tasks[i].task_algorithm_data.frame)
			{
				cudaFree(tasks[i].task_algorithm_data.frame);
				tasks[i].task_algorithm_data.frame = nullptr;
			}

			FinishTaskTracker(VPT_Handle, taskID);

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


			break;
		}
	}
}

void CMutliSourceVideoProcess::PauseTask(const int taskID)
{
	for (int i = 0; i < tasks.size(); i++)
	{
		if (tasks[i].taskID == taskID)
		{
			if (tasks[i].taskState == PLAY) TaskinPlay--;
			tasks[i].taskState = PAUSE;
			PauseTaskTracker(VPT_Handle, taskID);
			tasks[i].taskTcuvid->PauseDecoder();
			if (viewTaskID == taskID) viewTaskID = -1;
			printf("-----------------------pasue task: %d-----------------------\n", taskID);
			break;
		}
	}
}

void CMutliSourceVideoProcess::RestartTask(const int taskID)
{
	for (int i = 0; i < tasks.size(); i++)
	{
		if (tasks[i].taskID == taskID)
		{
			tasks[i].taskState = PLAY;
			TaskinPlay++;
			RestartTaskTraker(VPT_Handle, taskID);
			tasks[i].taskTcuvid->ResumeDecoder();
			printf("-----------------------restart task: %d-----------------------\n", taskID);
			break;
		}
	}
}

//ʵʱ�鿴�ӿ� �ɿ���һ·��ʵʱ�鿴������·�ķ������OSD��Ȼ�󽫻���ͨ���ص��������ظ��û�
void CMutliSourceVideoProcess::ViewTask(const int taskID)
{
	if (tasks.size() > taskID && tasks[taskID].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;
	//	printf("begin real add task\n");
	if (TaskinPlay >= capacity)
	{
		//cout << "********************** resize capacity *************************" << endl;
		capacity *= 2;
		VPTResult.resize(capacity);
	}

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

	DxConfig cfg = { 0 };
	cfg.devId = mgpuid;
	cfg.forceTcp = false;
	cfg.decMode = tparam.decMode;
	cfg.name = std::to_string(new_task.taskID);
	new_task.taskTcuvid = new DxDecoderWrap(&cfg);
	if (NULL == new_task.taskTcuvid)
	{
		printf("Add New DxDecoder Failed!");
		AddTaskSucFlag = -1;
		return false;
	}

	if (new_task.taskTcuvid->DxOpenDecoder(new_task.taskFileSource, skip_frame_) != 0)
	{
		cout << "Add Task Failed! Please check you video file name!" << endl;
		delete new_task.taskTcuvid;
		new_task.taskTcuvid = NULL;
		AddTaskSucFlag = -1;
		return false;
	}

	int total_frame = new_task.taskTcuvid->DxGetFrameCount();

	int width = 0;
	int height = 0;
	new_task.taskTcuvid->DxGetResolution(width, height);

	LOG_INFO("[{}] - finish add codec. w:{}  h:{} total_frame:{}", cfg.name.c_str(), width, height, total_frame);

	new_task.frameImage = cv::Mat::zeros(height, width, CV_8UC3);
	new_task.taskState = PLAY;
	new_task.task_algorithm_data.frame = NULL;
	new_task.taskFrameCount = 0;
	new_task.taskLastFrameCount = 0;

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

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

	new_task.taskTotalFrameCount = total_frame;
	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, "");
	}

	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);

	TotalTask++;
	TaskinPlay++;
	tasks.push_back(new_task);

	AddTaskTracker(VPT_Handle, new_task.taskID, width, height);

	if (!ProcessFlag) {
		m_bProcessExit = false;
		ProcessThread = std::thread(ThreadProcess, this);
		ProcessFlag = true;
	}

	printf("-----------------------add task: %d-----------------------\n", tasks.size() - 1);
	AddTaskSucFlag = 1;
	return true;
}

int CMutliSourceVideoProcess::AddOperator(task_param tparam)
{
	if (!ProcessFlag)
	{
		AddTask(tparam);
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
	}
	else
	{
		//	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;
		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();
		}
		cout << "Failed Add New Task! Algorithm Process Error! " << endl;
	}

	return addRes;
}

int CMutliSourceVideoProcess::get_task_progress(int taskid, double &progress)
{
	int ret = 0;
	for (auto &item : tasks)
	{
		if (item.taskID == taskid)
		{
			progress = (double)item.taskFrameCount / (double)item.taskTotalFrameCount;
			return 0;
		}
	}
	return -1;

}

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.decMode = newOperator.decMode;
				AddTask(tparam);
			}	
			break;
		case PAUSETASK:
			PauseTask(newOperator.changeTaskID);
			break;
		case RESTARTTASK:
			RestartTask(newOperator.changeTaskID);
			break;
		case FINISHTASK:
			FinishTask(newOperator.changeTaskID);
			break;
		default:
			break;
		}

	}
}


int CMutliSourceVideoProcess::SaveResultInFile(const OBJ_KEY & obj_key, const OBJ_VALUE & obj_value)
{
	if (0 == obj_value.index.index && obj_value.snapShotLittle.width == HP_WIDTH && obj_value.snapShotLittle.height == HP_HEIGHT)
	{
		if (m_face_det_config == SY_CONFIG_OPEN)
		{
			m_snaphot_helper.save_face_snapshot(obj_key);
		}

		if (m_hp_analysis_config == SY_CONFIG_OPEN || m_hf_recg_config == SY_CONFIG_OPEN)
		{
			m_snaphot_helper.save_snapshot(obj_key);
			m_snaphot_helper.hp_analysis(obj_key);
		}
		else
		{
			m_snaphot_helper.save_without_analysis(obj_key);
		}
	}
	else if ((1 == obj_value.index.index || 2 == obj_value.index.index) && obj_value.snapShotLittle.width == HCP_WIDTH && obj_value.snapShotLittle.height == HCP_HEIGHT)
	{
		if (m_hcp_analysis_config == SY_CONFIG_OPEN || m_hcf_recg_config == SY_CONFIG_OPEN)
		{
			m_snaphot_helper.save_snapshot(obj_key);
			m_snaphot_helper.hcp_analysis(obj_key);
		}
		else
		{
			m_snaphot_helper.save_without_analysis(obj_key);
		}
	}
	else if ((8 == obj_value.index.index || (obj_value.index.index >= 4 && obj_value.index.index <= 6)) && obj_value.snapShotLittle.width == VEHICLE_WIDTH && obj_value.snapShotLittle.height == VEHICLE_HEIGHT)
	{
		//VEHICLEAnalysis(obj_key, obj_value);
		if (m_vehicle_analysis_config == SY_CONFIG_OPEN || m_vcf_recg_config == SY_CONFIG_OPEN)
		{
			m_snaphot_helper.save_snapshot(obj_key);
			m_snaphot_helper.vehicle_analysis(obj_key);
		}
		else
		{
			m_snaphot_helper.save_without_analysis(obj_key);
		}

	}
	else 
	{
		m_snaphot_helper.save_without_analysis(obj_key);
	}

	return 0;
}


//#define LOG_INFO
void CMutliSourceVideoProcess::callTaskObjInfoCallbackFunc(int objCount, VPT_ObjInfo *obj, int taskFrameCount, int taskId)
{
	if (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 < objCount; c++)
		{
			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;
			if (m_snaphot_helper.snapShotInfo.find(newObj) == m_snaphot_helper.snapShotInfo.end())
				newObjInfo.index = obj[c].index;
			else
				newObjInfo.index = m_snaphot_helper.snapShotInfo[newObj].index.index;
			newObjInfo.confidence = obj[c].confidence;
			if (taskObjInfoCallbackFunc != nullptr)
			{
				taskObjInfoCallbackFunc(&newObjInfo);
			}
		}

	}
}
DWORD ThreadProcess(LPVOID param)
{
	set<int> k;
	int count = 0;
	sy_img * batch_img = new sy_img[20]{};

	DxGPUFrame frame = {};

	CMutliSourceVideoProcess *pThreadParam = (CMutliSourceVideoProcess *)param;

	cudaSetDevice(pThreadParam->mgpuid);

	CUdevice cuDevice;
	cuDeviceGet(&cuDevice, pThreadParam->mgpuid);
	CUcontext context;
	cuCtxCreate(&context, 0, cuDevice);
	cuCtxPushCurrent(context);

	int total_count = 0;
	long long begintime1 =get_cur_time_ms();

	int process_times = 0;

	long long last_time =  get_cur_time_ms();

	{
		while (!pThreadParam->m_bProcessExit)
		{
			if (pThreadParam->licence_status <= -3)
			{
				printf("authority failed!\n");
				break;
			} 

			double time_val, time_val_p = 0;
			{
				std::lock_guard<std::mutex> l(pThreadParam->taskMutex);
				pThreadParam->OperatorTask();
			}
			pThreadParam->taskCondVar.notify_all();

			int curTaskSize = pThreadParam->tasks.size();

			count = 0;
			static int ncount = 0;
			map<int, vector<int>> finishTaskDeleteObj;
			int curPlayTaskCount = 0;

			//�жϵ�ǰPLAY����Ľ���״̬��������ڽ����쳣��·������������·����
			for (int i = 0; i < curTaskSize; i++)
			{
				if ((pThreadParam->tasks[i].taskState == PLAY || pThreadParam->tasks[i].taskState == DECODEERROR))
				{
					if (!pThreadParam->tasks[i].taskTcuvid->DxDecoderIsRun())
					{
						cudaError_t cudaStatus = cudaGetLastError();
						if (cudaStatus != cudaSuccess) {
							printf("begin finish last error: %s\n", cudaGetErrorString(cudaStatus));
						}

						cout << "***************** Task " << i << " is Finished *****************" << endl;
						pThreadParam->tasks[i].taskState = FINISH;

						pThreadParam->FinishTask(pThreadParam->tasks[i].taskID);

						pThreadParam->tasks[i].taskTcuvid->DxCloseDecoder();
						delete pThreadParam->tasks[i].taskTcuvid;
						pThreadParam->tasks[i].taskTcuvid = NULL;
						int taskid = pThreadParam->tasks[i].taskID;

						//ѭ���ȴ� ֱ��finished_analysis_ss_info�����и�·Ŀ�궼�Ѿ����ظ��û����ſ���������������
						std::unique_lock<std::mutex> lock(pThreadParam->m_snaphot_helper.analysisThreadMutex);
						while (std::find_if(pThreadParam->m_snaphot_helper.finished_analysis_ss_info.begin(), pThreadParam->m_snaphot_helper.finished_analysis_ss_info.end(), [&taskid](const std::pair<OBJ_KEY, video_object_snapshot> & item) ->bool {
							if (item.first.videoID == taskid)
							{
								return true;
							}
							else
							{
								return false;
							}

						}) != pThreadParam->m_snaphot_helper.finished_analysis_ss_info.end())
						{
							lock.unlock();
							std::this_thread::yield();
							std::this_thread::sleep_for(std::chrono::milliseconds(100));
							lock.lock();
						}

						//�ص�֪ͨ�û� ��·�����������
						if (pThreadParam->taskFinishCallbackFunc != nullptr)
						{
							std::lock_guard<std::mutex> l(pThreadParam->m_snaphot_helper.callback_tx);
							pThreadParam->taskFinishCallbackFunc(pThreadParam->tasks[i].taskID);
						}

						pThreadParam->TaskinPlay--;
					}
				}

				if (pThreadParam->tasks[i].taskState == FINISH)
					count++;
			}
			
			//�������������FINISH״̬
			if (count >= pThreadParam->tasks.size())   //have no decode video, break
			{
				{
					std::lock_guard<std::mutex> l(pThreadParam->taskMutex);
					//�ж���������ȴ������Ƿ����µ���������
					if (pThreadParam->HasNewTask())
					{
						continue;
					}
					else
					{
						//std::this_thread::sleep_for(std::chrono::milliseconds(40));
						//continue;
						//printf("802 set ProcessFlag false\n");

						//Sleep(10);
						//continue;

						//printf("0708\n");
						//pThreadParam->ProcessFlag = false;
						break;
					}
				}
			}
			
			//��ǰû��PLAY������ ѭ���ȴ�
			curPlayTaskCount = pThreadParam->TaskinPlay;
			if (curPlayTaskCount <= 0) {
				Sleep(30);
				continue;
			}

			k.clear();
			pThreadParam->TaskinPlayID.clear();
			
		//��ȡ��������
		getdata_flag:
			for (int i = 0; i < curTaskSize; i++)
			{
				if (k.find(i) == k.end() && pThreadParam->tasks[i].taskState == PLAY && pThreadParam->tasks[i].taskTcuvid->DxDecoderIsRun())
				{
					if(pThreadParam->tasks[i].taskTcuvid->DxLockFrame(&pThreadParam->tasks[i].task_algorithm_data) == 0) {
						k.insert(i);
						pThreadParam->TaskinPlayID.insert(pThreadParam->tasks[i].taskID);
					}
				}
				else if (k.find(i) == k.end() && pThreadParam->tasks[i].taskState == PLAY && !pThreadParam->tasks[i].taskTcuvid->DxDecoderIsRun())
				{
					pThreadParam->tasks[i].taskState = DECODEERROR;
					curPlayTaskCount--;
					FinishTaskTracker(pThreadParam->VPT_Handle, pThreadParam->tasks[i].taskID);
				}
			}
		
			if (curPlayTaskCount <= 0) {
				Sleep(30);
				continue;
			}

			//��û�л�ȡ������·���Ľ������� ѭ���ȴ�
			if (k.size() < curPlayTaskCount)
			{
				std::this_thread::sleep_for(std::chrono::milliseconds(1));
				goto getdata_flag;
			}

#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();

			//------------------------------ ͳһBATCH���� --------------------------------//
			//////////////////////////////////////////////////////////////
			////
			////   compose data -> batch
			////
			/////////////////////////////////////////////////////////////

			vector<vector<int>> deleteObjectID;
			set<int>::iterator iter = pThreadParam->TaskinPlayID.begin();

			int cur_batch_size = 0;
			cur_batch_size = pThreadParam->section_batch_size;

			if (0)
			{
				if (pThreadParam->section_batch_size == 20)
					cur_batch_size = pThreadParam->section_batch_size;    
				else                                                      
				{
					if (curPlayTaskCount <= 2 * pThreadParam->section_batch_size)
						cur_batch_size = pThreadParam->section_batch_size;
					else if (curPlayTaskCount >= 2 * MAX_BATCH)
						cur_batch_size = MAX_BATCH;
					else
						cur_batch_size = curPlayTaskCount / 2 + (curPlayTaskCount % 2);
				}
			}
			
			long long start_time_vpt = get_cur_time_ms();

			vector<vector<VPT_Result>> unUsedResult;
			vector<unsigned long long> vec_frameIndex;
			unUsedResult.resize(pThreadParam->VPTResult.size());
			int cycleTimes = curPlayTaskCount / cur_batch_size + (curPlayTaskCount % cur_batch_size == 0 ? 0 : 1);
			for (int c = 0; c < cycleTimes; c++)
			{
				int batchsize = c == cycleTimes - 1 ? (curPlayTaskCount - cur_batch_size*c) : cur_batch_size;
				int startbatch = c*cur_batch_size;

				vec_frameIndex.clear();
				for (int i = 0; i < batchsize; i++) 
				{
					DxGPUFrame task_algorithm_data = pThreadParam->tasks[*iter].task_algorithm_data;
					int w = task_algorithm_data.width;
					int h = task_algorithm_data.height;
					int npitch = task_algorithm_data.size;

					batch_img[i].set_data(w, h, 3, (unsigned char *)task_algorithm_data.frame);
					vec_frameIndex.push_back(task_algorithm_data.timestamp);
					iter++;
				}

				vector<vector<int>> tempDeleteObjectID;				
				tempDeleteObjectID.resize(batchsize);
				int flag = VPT_Process_GPU(pThreadParam->GetVPT_Handle(), batch_img, startbatch, batchsize, vec_frameIndex, pThreadParam->VPTResult, tempDeleteObjectID, unUsedResult);
				process_times++ ;
			
				for (auto iter : tempDeleteObjectID)
				{
					deleteObjectID.push_back(iter);
				}
				vector<vector<int>>().swap(tempDeleteObjectID);
			}
#ifdef LOG_INFO2
			std::cout << "VPT_Process_GPU time_using: " << get_cur_time_ms() - start_time_vpt << std::endl;
#endif
			
			long long result_analysis_time = get_cur_time_ms();

			iter = pThreadParam->TaskinPlayID.begin();
			for (int i = 0; i < curPlayTaskCount; i++)
			{
				pThreadParam->tasks[*iter].taskFrameCount = pThreadParam->tasks[*iter].task_algorithm_data.timestamp;
				//若该路任务当前帧未检测到目标，返回ID为-1的目标表明未检测到目标
				if (pThreadParam->VPTResult[i].objCount == 0)
				{
					pThreadParam->callTaskObjInfoCallbackFunc(0, nullptr, pThreadParam->tasks[*iter].taskFrameCount, *iter);
				}
				
				//实时查看模块，若存在实时查看，把当前视频画面cp回内存
				bool view = false;
				int frameHeight = pThreadParam->tasks[*iter].task_algorithm_data.height;
				int frameWidth = pThreadParam->tasks[*iter].task_algorithm_data.width;

				if (*iter == pThreadParam->viewTaskID)
				{
					cudaMemcpy(pThreadParam->tasks[*iter].frameImage.data, pThreadParam->tasks[*iter].task_algorithm_data.frame, 3 * pThreadParam->tasks[*iter].task_algorithm_data.width * pThreadParam->tasks[*iter].task_algorithm_data.height * sizeof(unsigned char), cudaMemcpyDeviceToHost);
					view = true;
				}

				//跟踪帧也需要返回跟踪的结果
				if (pThreadParam->tasks[*iter].taskLastFrameCount > 0)
				{
					vector<VPT_Result> OneUnUsedResult = unUsedResult[i];
					if (OneUnUsedResult.size() == 0)
					{
						pThreadParam->callTaskObjInfoCallbackFunc(0, nullptr, pThreadParam->tasks[*iter].taskLastFrameCount + 1, *iter);
					}
					for (int k = 0; k < OneUnUsedResult.size(); ++k)
					{
						if (OneUnUsedResult[k].objCount == 0)
						{
							pThreadParam->callTaskObjInfoCallbackFunc(0, nullptr, pThreadParam->tasks[*iter].taskLastFrameCount + k + 1, *iter);
						}
						else
						{
							//cout << "OneUnUsedResult.size = " << OneUnUsedResult.size() << "  k=" << k << " OneUnUsedResult[k].objCount = " << OneUnUsedResult[k].objCount << endl;
							pThreadParam->callTaskObjInfoCallbackFunc(OneUnUsedResult[k].objCount, OneUnUsedResult[k].obj, pThreadParam->tasks[*iter].taskLastFrameCount + k + 1, *iter);
						}
					}
				}
				pThreadParam->tasks[*iter].taskLastFrameCount = pThreadParam->tasks[*iter].taskFrameCount;

				unsigned char* snapshot_image_data[MAX_OBJ_COUNT]{};// = new unsigned char*[pThreadParam->VPTResult[i].objCount];
				int snapshot_left[MAX_OBJ_COUNT]{};// = new int[pThreadParam->VPTResult[i].objCount];
				int snapshot_right[MAX_OBJ_COUNT]{};// = new int[pThreadParam->VPTResult[i].objCount];
				int snapshot_top[MAX_OBJ_COUNT]{};//  = new int[pThreadParam->VPTResult[i].objCount];
				int snapshot_bottom[MAX_OBJ_COUNT]{};//  = new int[pThreadParam->VPTResult[i].objCount];
				int snapshot_dst_width[MAX_OBJ_COUNT]{};//  = new int[pThreadParam->VPTResult[i].objCount];
				int snapshot_dst_height[MAX_OBJ_COUNT]{};//  = new int[pThreadParam->VPTResult[i].objCount];

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

				pThreadParam->callTaskObjInfoCallbackFunc(pThreadParam->VPTResult[i].objCount, pThreadParam->VPTResult[i].obj, pThreadParam->tasks[*iter].taskFrameCount, *iter);
				for (int c = 0; c < pThreadParam->VPTResult[i].objCount; c++)
				{
					OBJ_KEY newObj = { (*iter), pThreadParam->VPTResult[i].obj[c].id };

					int index = 0;
					if (pThreadParam->m_snaphot_helper.snapShotInfo.find(newObj) == pThreadParam->m_snaphot_helper.snapShotInfo.end())
						index = pThreadParam->VPTResult[i].obj[c].index;
					else
						index = pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index;

					//实时查看模块 绘制目标框到画面上
					if (view)
					{
						//cout << "---- vew ----  ";
						int p1 = pThreadParam->VPTResult[i].obj[c].left - 10 > 0 ? pThreadParam->VPTResult[i].obj[c].left - 10 : 0;
						int p2 = pThreadParam->VPTResult[i].obj[c].top - 15 > 0 ? pThreadParam->VPTResult[i].obj[c].top - 15 : 0;

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

					//逐个目标更新快照
					int boundary = 10;
					int boundaryLittle = 4;

					int cur_real_width = (pThreadParam->VPTResult[i].obj[c].right - pThreadParam->VPTResult[i].obj[c].left);
					int cur_real_height = (pThreadParam->VPTResult[i].obj[c].bottom - pThreadParam->VPTResult[i].obj[c].top);
					int cur_real_index = pThreadParam->VPTResult[i].obj[c].index;

					//第一次添加快照
					if (pThreadParam->m_snaphot_helper.snapShotInfo.find(newObj) == pThreadParam->m_snaphot_helper.snapShotInfo.end())
					{
						//DxAppendLog(DxLOG_INFO, "30");
						if (LegalMinArea(cur_real_width, cur_real_height, pThreadParam->tasks[*iter].task_min_boxsize[cur_real_index]))
						{
							//DxAppendLog(DxLOG_INFO, "31");
							//--------------------- 保存快照视频截图 -----------------------------//

							int left = max(0, (int)(pThreadParam->VPTResult[i].obj[c].left - boundaryLittle));
							int top = max(0, (int)(pThreadParam->VPTResult[i].obj[c].top - boundaryLittle));
							int right = min({ frameWidth - 1, (int)(pThreadParam->VPTResult[i].obj[c].right + boundaryLittle) });
							int bottom = min({ frameHeight - 1, (int)(pThreadParam->VPTResult[i].obj[c].bottom + boundaryLittle) });
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].frameCount = pThreadParam->tasks[*iter].taskFrameCount;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].isupdate = true;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].lost = 0;

							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.count++;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index = pThreadParam->VPTResult[i].obj[c].index;

							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].confidence = pThreadParam->VPTResult[i].obj[c].confidence;

							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.left = left;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.top = top;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.right = right;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.bottom = bottom;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].lastArea = (bottom - top)*(right - left);

							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].flags[0] = left < minDistance[0] + SCALE_OUT ? 0 : 1;           //left
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].flags[1] = top < minDistance[1] + SCALE_OUT ? 0 : 1;            //top
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].flags[2] = right > frameWidth - minDistance[2] - SCALE_OUT ? 0 : 1;   //right
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].flags[3] = bottom > frameHeight - minDistance[3] - SCALE_OUT ? 0 : 1;     //bottom

							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame = NULL;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShot.frame = NULL;

							if (pThreadParam->tasks[*iter].folderName != NULL)
							{
								//DxAppendLog(DxLOG_INFO, "32");
								FRAME_KEY frame_id = { (*iter),pThreadParam->tasks[*iter].taskFrameCount };
								pThreadParam->m_snaphot_helper.ImgSaveCache.insert(newObj, frame_id, pThreadParam->tasks[*iter].task_algorithm_data);

								pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShot.height = frameHeight;
								pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShot.width = frameWidth;
							}


							//--------------------- 保存快照抠图 -----------------------------/
							int vLeft = 0;
							int vTop = 0;
							int vRight = 0;
							int vBottom = 0;

							vLeft = max(0, pThreadParam->VPTResult[i].obj[c].left - boundary);
							vTop = max(0, pThreadParam->VPTResult[i].obj[c].top - boundary);
							vRight = min({ frameWidth - 1, pThreadParam->VPTResult[i].obj[c].right + boundary });
							vBottom = min({ frameHeight - 1, pThreadParam->VPTResult[i].obj[c].bottom + boundary });
							//DxAppendLog(DxLOG_INFO, "34");
							if (pThreadParam->tasks[*iter].folderNameLittle != NULL)
							{
								//DxAppendLog(DxLOG_INFO, "35");
								int cur_width = 0;
								int cur_height = 0;

								if (0 == pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index)
								{
									cur_width = HP_WIDTH;
									cur_height = HP_HEIGHT;
								
									human_idx.emplace_back(copy_obj_count);
									human_obj_keys.emplace_back (newObj);
								}
								else if (1 == pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index || 2 == pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index)
								{
									cur_width = HCP_WIDTH;
									cur_height = HCP_HEIGHT;
								}
								else if (8 == pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index || (pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index >= 4 && pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index <= 6))
								{
									cur_width = VEHICLE_WIDTH;
									cur_height = VEHICLE_HEIGHT;
								}
								else   //其余类别
								{
									cur_width = vRight - vLeft;
									cur_height = vBottom - vTop;
								}

								if (cur_width != 0 && cur_height != 0)
								{
									cudaMalloc((void**)&pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame, IMG_CHANNELS * cur_width * cur_height * sizeof(unsigned char));
									pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.height = cur_height;
									pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.width = cur_width;

									snapshot_image_data[copy_obj_count] = (unsigned char*)pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame;
									snapshot_left[copy_obj_count] = vLeft;
									snapshot_top[copy_obj_count] = vTop;
									snapshot_right[copy_obj_count] = vRight;
									snapshot_bottom[copy_obj_count] = vBottom;

									snapshot_dst_width[copy_obj_count] = cur_width;
									snapshot_dst_height[copy_obj_count++] = cur_height;
								}
							}
						}
					}
					else
					{
						//DxAppendLog(DxLOG_INFO, "36");
						bool updateShotInfo = false;
						int oldIndex = pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index;
						pThreadParam->m_snaphot_helper.snapShotInfo[newObj].frameCount = pThreadParam->tasks[*iter].taskFrameCount;
						pThreadParam->m_snaphot_helper.snapShotInfo[newObj].isupdate = true;
						pThreadParam->m_snaphot_helper.snapShotInfo[newObj].lost = 0;

						if (pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.count == 0)
						{
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.count++;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index = pThreadParam->VPTResult[i].obj[c].index;
						}
						else
						{
							if (pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index == pThreadParam->VPTResult[i].obj[c].index)
								pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.count++;
							else
								pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.count--;
						}
						if (oldIndex != pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index)
						{
							updateShotInfo = true;
						}

						int left = max(0, (int)(pThreadParam->VPTResult[i].obj[c].left - boundaryLittle));
						int top = max(0, (int)(pThreadParam->VPTResult[i].obj[c].top - boundaryLittle));
						int right = min(frameWidth - 1, (int)(pThreadParam->VPTResult[i].obj[c].right + boundaryLittle));
						int bottom = min(frameHeight - 1, (int)(pThreadParam->VPTResult[i].obj[c].bottom + boundaryLittle));

						int maxArea = (pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.right - pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.left)*(pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.bottom - pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.top);

						if ((LegalArea(maxArea, pThreadParam->m_snaphot_helper.snapShotInfo[newObj].lastArea, left, top, right, bottom)
							&& LegalPos(pThreadParam->m_snaphot_helper.snapShotInfo[newObj].flags, left, top, right, bottom, frameHeight, frameWidth)
							&& LegalMinArea(cur_real_width, cur_real_height, pThreadParam->tasks[*iter].task_min_boxsize[cur_real_index])) || updateShotInfo)
						{
							//DxAppendLog(DxLOG_INFO, "37");
							int boundary_w = (pThreadParam->VPTResult[i].obj[c].right - pThreadParam->VPTResult[i].obj[c].left) * 0.1;
							int boundary_h = (pThreadParam->VPTResult[i].obj[c].bottom - pThreadParam->VPTResult[i].obj[c].top)* 0.1;

							int boundary_left = boundary_w, boundary_right = boundary_w, boundary_top = boundary_h, boundary_bottom = boundary_h;

							ExpandMargin((left - pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.left),
								(bottom - pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.bottom),
								boundary_w, boundary_h, boundary_left, boundary_right, boundary_top, boundary_bottom);

							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.left = left;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.top = top;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.right = right;
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].box.bottom = bottom;
							//printf("ori: %d %d %d %d\n", left, top, right - left, bottom - top);
							pThreadParam->m_snaphot_helper.snapShotInfo[newObj].confidence = pThreadParam->VPTResult[i].obj[c].confidence;
							if (pThreadParam->tasks[*iter].folderName != NULL)
							{
								FRAME_KEY frame_id = { (*iter),pThreadParam->tasks[*iter].taskFrameCount };
								pThreadParam->m_snaphot_helper.ImgSaveCache.insert(newObj, frame_id, pThreadParam->tasks[*iter].task_algorithm_data);
							}


							//--------------------- 保存快照抠图 -----------------------------//
							int vLeft = 0;
							int vTop = 0;
							int vRight = 0;
							int vBottom = 0;

							vLeft = max(0, pThreadParam->VPTResult[i].obj[c].left - boundary_left);
							vTop = max(0, pThreadParam->VPTResult[i].obj[c].top - boundary_top);
							vRight = min(frameWidth - 1, pThreadParam->VPTResult[i].obj[c].right + boundary_right);
							vBottom = min(frameHeight - 1, pThreadParam->VPTResult[i].obj[c].bottom + boundary_bottom);
							if (pThreadParam->tasks[*iter].folderNameLittle != NULL)
							{
							
								if (0 == pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index)
								{
									if (pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.width != HP_WIDTH || pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.height != HP_HEIGHT)
									{
										cudaFree(pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame);      //释放显存
										cudaMalloc((void**)&pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame, 3 * HP_WIDTH * HP_HEIGHT * sizeof(unsigned char));
										pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.width = HP_WIDTH;
										pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.height = HP_HEIGHT;
									}
								
									human_idx.push_back(copy_obj_count);
									human_obj_keys.emplace_back(newObj);

									snapshot_image_data[copy_obj_count] = (unsigned char*)pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame;
									snapshot_left[copy_obj_count] = vLeft;
									snapshot_top[copy_obj_count] = vTop;
									snapshot_right[copy_obj_count] = vRight;
									snapshot_bottom[copy_obj_count] = vBottom;
									//printf("crop: %d %d %d %d\n", vLeft, vTop, vRight - vLeft, vBottom - vTop);
									snapshot_dst_width[copy_obj_count] = HP_WIDTH;
									snapshot_dst_height[copy_obj_count++] = HP_HEIGHT;

								}
								else if (1 == pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index || 2 == pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index)
								{
									//DxAppendLog(DxLOG_INFO, "42");
									if (pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.width != HCP_WIDTH || pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.height != HCP_HEIGHT)
									{
										//DxAppendLog(DxLOG_INFO, "43");
										cudaFree(pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame);      //释放显存
										cudaMalloc((void**)&pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame, 3 * HCP_WIDTH * HCP_HEIGHT * sizeof(unsigned char));
										pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.width = HCP_WIDTH;
										pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.height = HCP_HEIGHT;
									}

									snapshot_image_data[copy_obj_count] = (unsigned char*)pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame;
									snapshot_left[copy_obj_count] = vLeft;
									snapshot_top[copy_obj_count] = vTop;
									snapshot_right[copy_obj_count] = vRight;
									snapshot_bottom[copy_obj_count] = vBottom;

									snapshot_dst_width[copy_obj_count] = HCP_WIDTH;
									snapshot_dst_height[copy_obj_count++] = HCP_HEIGHT;

								}
								else if (8 == pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index || (pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index >= 4 && pThreadParam->m_snaphot_helper.snapShotInfo[newObj].index.index <= 6))
								{
									//DxAppendLog(DxLOG_INFO, "43.1");
									if (pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.width != VEHICLE_WIDTH || pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.height != VEHICLE_HEIGHT)
									{
										//DxAppendLog(DxLOG_INFO, "44");
										cudaFree(pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame);      //释放显存
										cudaMalloc((void**)&pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame, 3 * VEHICLE_WIDTH * VEHICLE_HEIGHT * sizeof(unsigned char));
										pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.width = VEHICLE_WIDTH;
										pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.height = VEHICLE_HEIGHT;
									}

									snapshot_image_data[copy_obj_count] = (unsigned char*)pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame;
									snapshot_left[copy_obj_count] = vLeft;
									snapshot_top[copy_obj_count] = vTop;
									snapshot_right[copy_obj_count] = vRight;
									snapshot_bottom[copy_obj_count] = vBottom;

									snapshot_dst_width[copy_obj_count] = VEHICLE_WIDTH;
									snapshot_dst_height[copy_obj_count++] = VEHICLE_HEIGHT;

								}
								else
								{
									//DxAppendLog(DxLOG_INFO, "45");
									// modified by zsh 220614----------------------------
									int cur_width = vRight - vLeft;
									int cur_height = vBottom - vTop;
									if (cur_width != 0 && cur_height != 0) {
									//----------------------------------------
										cudaFree(pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame);      //释放显存
										cudaMalloc((void**)&pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame, 3 * (vBottom - vTop)*(vRight - vLeft) * sizeof(unsigned char));
										pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.height = vBottom - vTop;
										pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.width = vRight - vLeft;

										//printf("begin partMemCopy: %d %d %d %d %d %d\n", vLeft, vTop, vRight, vBottom, frameWidth, frameHeight);
										partMemCopy((unsigned char*)pThreadParam->tasks[*iter].task_algorithm_data.frame, frameWidth, frameHeight,
											(unsigned char*)pThreadParam->m_snaphot_helper.snapShotInfo[newObj].snapShotLittle.frame, vLeft, vTop, vRight, vBottom);
									}
								}

							}
						}
						pThreadParam->m_snaphot_helper.snapShotInfo[newObj].lastArea = (bottom - top)*(right - left);
					}

				}

				//若待抠图的快照数不为0 则进行批量抠图
				if (0 != copy_obj_count)
				{
					cudaSetDevice(pThreadParam->mgpuid);
					cuCtxPushCurrent(context);
					PartMemResizeBatch((unsigned char*)pThreadParam->tasks[*iter].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);
					cuCtxPopCurrent(&context);
				
					//最新刚添加的人脸检测模块，针对存在的行人快照进行人脸检测+人脸快照框的优选
					if (pThreadParam->m_face_det_config == SY_CONFIG_OPEN && !human_idx.empty())
					{
						//需要做人脸检测
						int human_count = human_idx.size();
						sy_img *human_img = new sy_img[human_count];
					
						sy_point* ori_points = new sy_point[human_count];
						for (int idx = 0; idx < human_count; idx++)
						{
							int ii = human_idx[idx];
							human_img[idx].set_data(snapshot_dst_width[ii], snapshot_dst_height[ii], 3, snapshot_image_data[ii]);
							ori_points[idx].x_ = (snapshot_right[ii] - snapshot_left[ii]);
							ori_points[idx].y_ = (snapshot_bottom[ii] - snapshot_top[ii]);
						}

						fd_result *face_det_result = new fd_result[human_count];
						for (int fd_i = 0; fd_i < human_count; fd_i++)
						{
							face_det_result[fd_i].info = new fd_info[10];		//内存由外部申请
						}

						if (pThreadParam->m_face_det_module->face_det_module_process(human_img, human_count, face_det_result, ori_points) == SUCCESS)
						{
							//printf("finish face_det_module_process: %d\n", human_count);
							for (int idx = 0; idx < human_count; idx++)
							{
								OBJ_KEY cur_obj_key = human_obj_keys[idx];
								fd_result &cur_det_res = face_det_result[idx];
								int face_count = cur_det_res.count;
								int face_idx = 0;
								int ii = human_idx[idx];

								if (face_count == 0) continue;

								if (face_count > 1)   //检测到多余一个人脸 选最佳
								{
									sy_point center_human = { human_img[idx].w_/2, human_img [idx].h_/2};
									float min_distance = INT_MAX;
								
									for (int c = 0; c < face_count; c++)
									{
										sy_point face_center = { cur_det_res.info[c].face_position.width_/2, cur_det_res.info[c].face_position.height_/2};
										float distance = fabs(center_human.x_ - face_center.x_) + fabs(center_human.y_ - face_center.y_);
										
										if (distance < min_distance)
										{
											min_distance = distance;
											face_idx = c;
										}
									}
								}
							
								fd_info& cur_det_info = cur_det_res.info[face_idx];
								if (pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.frame == nullptr)
								{
									sy_rect face_ori_rect = { (int)(snapshot_left[ii] + cur_det_info.face_position.left_ ),
										(int)(snapshot_top[ii] + cur_det_info.face_position.top_),
										(int)(cur_det_info.face_position.width_), (int)(cur_det_info.face_position.height_) };

									int new_left = max(0, face_ori_rect.left_ - face_ori_rect.width_);
									int new_top = max(0, face_ori_rect.top_ - face_ori_rect.height_);
									int new_right = min((int)pThreadParam->tasks[*iter].task_algorithm_data.width - 1, (face_ori_rect.left_ + 2 * face_ori_rect.width_));
									int new_bottom = min((int)pThreadParam->tasks[*iter].task_algorithm_data.height - 1, (face_ori_rect.top_ + 2 * face_ori_rect.height_));
									int new_width = new_right - new_left;
									int new_height = new_bottom - new_top;

									sy_rect face_expand_rect = { new_left, new_top, new_width, new_height };

									int face_img_length = 3 * face_expand_rect.width_ * face_expand_rect.height_;
								
									cudaError_t cudaStatus = cudaMalloc((void**)&pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.frame, face_img_length * sizeof(unsigned char));
									if (cudaStatus != cudaSuccess) {
										fprintf(stderr, "here cudaMalloc frame[0] failed! error: %s\n", cudaGetErrorString(cudaStatus));
										break;
									}

									pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.width = face_expand_rect.width_;
									pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.height = face_expand_rect.height_;
									memcpy((void*)&pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].face_info, (void*)&cur_det_info, sizeof(fd_info));
									
									//矫正坐标 从行人抠图检测结果 -> 人脸外扩抠图坐标
									fd_info& tmp_info = pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].face_info;

									for (int p = 0; p < FACIALFEAPOINTSIZE; p++)
									{
										tmp_info.facial_fea_point[p].x_ =
											tmp_info.facial_fea_point[p].x_ - tmp_info.face_position.left_ + (face_ori_rect.left_ - face_expand_rect.left_);
										tmp_info.facial_fea_point[p].y_ =
											tmp_info.facial_fea_point[p].y_ - tmp_info.face_position.top_ + (face_ori_rect.top_ - face_expand_rect.top_);
									}

									pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].face_info.face_position =
									{ (face_ori_rect.left_ - face_expand_rect.left_), (face_ori_rect.top_ - face_expand_rect.top_), face_ori_rect.width_, face_ori_rect.height_ };


									cudacommon::CropImgGpu((unsigned char*)pThreadParam->tasks[*iter].task_algorithm_data.frame, pThreadParam->tasks[*iter].task_algorithm_data.width, pThreadParam->tasks[*iter].task_algorithm_data.height,
										(unsigned char*)pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.frame, face_expand_rect.left_, face_expand_rect.top_, face_expand_rect.width_, face_expand_rect.height_);

									//show_gpu_img_func(pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace);
								}
								else
								{
									sy_rect face_ori_rect = { (int)(snapshot_left[ii] + cur_det_info.face_position.left_),
										(int)(snapshot_top[ii] + cur_det_info.face_position.top_),
										(int)(cur_det_info.face_position.width_), (int)(cur_det_info.face_position.height_) };

									//更新人脸快照条件：① 角度满足条件 ② 面积比之前人脸面积大
									if (validAngle(cur_det_res.info[face_idx].roll, cur_det_res.info[face_idx].yaw, cur_det_res.info[face_idx].pitch, 15.0, 20.0)
										&& betterArea(face_ori_rect, pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].face_info.face_position))
									{
										int new_left = max(0, face_ori_rect.left_ - face_ori_rect.width_);
										int new_top = max(0, face_ori_rect.top_ - face_ori_rect.height_);
										int new_right = min((int)pThreadParam->tasks[*iter].task_algorithm_data.width - 1, (face_ori_rect.left_ + 2 * face_ori_rect.width_));
										int new_bottom = min((int)pThreadParam->tasks[*iter].task_algorithm_data.height - 1, (face_ori_rect.top_ + 2 * face_ori_rect.height_));
										int new_width = new_right - new_left;
										int new_height = new_bottom - new_top;

										sy_rect face_expand_rect = { new_left, new_top, new_width, new_height };

										//更新快照
										int face_img_length = 3 * face_expand_rect.width_ * face_expand_rect.height_;

										cudaFree(pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.frame);
										cudaError_t cudaStatus = cudaMalloc((void**)&pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.frame, face_img_length * sizeof(unsigned char));
										if (cudaStatus != cudaSuccess) {
											fprintf(stderr, "here cudaMalloc frame[0] failed! error: %s\n", cudaGetErrorString(cudaStatus));
											break;
										}

										pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.width = face_expand_rect.width_;
										pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.height = face_expand_rect.height_;
										memcpy((void*)&pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].face_info, (void*)&cur_det_info, sizeof(fd_info));

										//矫正坐标 从行人抠图检测结果 -> 人脸外扩抠图坐标
										fd_info& tmp_info = pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].face_info;

										for (int p = 0; p < FACIALFEAPOINTSIZE; p++)
										{
											tmp_info.facial_fea_point[p].x_ =
												tmp_info.facial_fea_point[p].x_ - tmp_info.face_position.left_ + (face_ori_rect.left_ - face_expand_rect.left_);
											tmp_info.facial_fea_point[p].y_ =
												tmp_info.facial_fea_point[p].y_ - tmp_info.face_position.top_ + (face_ori_rect.top_ - face_expand_rect.top_);
										}

										pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].face_info.face_position =
										{(face_ori_rect.left_ - face_expand_rect.left_), (face_ori_rect.top_ - face_expand_rect.top_), face_ori_rect.width_, face_ori_rect.height_};

										cudacommon::CropImgGpu((unsigned char*)pThreadParam->tasks[*iter].task_algorithm_data.frame, pThreadParam->tasks[*iter].task_algorithm_data.width, pThreadParam->tasks[*iter].task_algorithm_data.height,
											(unsigned char*)pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace.frame, face_expand_rect.left_, face_expand_rect.top_, face_expand_rect.width_, face_expand_rect.height_);

										//show_gpu_image_withfdinfo_(pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace, cur_det_info);

										//show_gpu_image_withfdinfo_(pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].snapShotFace, pThreadParam->m_snaphot_helper.snapShotInfo[cur_obj_key].face_info);
									}
								}
							}
						}

						if (face_det_result)
						{
							for (int fd_i = 0; fd_i < human_count; fd_i++)
								delete[] face_det_result[fd_i].info;
							delete face_det_result;
						}

						if (human_img) delete[] human_img;
						if (ori_points) delete[] ori_points;
					}
				}

				//实时查看 绘制目标轨迹 回调函数返回
				if (view)
				{
					DrawTracker(pThreadParam->VPT_Handle, *iter, &pThreadParam->tasks[*iter].frameImage);
					if (pThreadParam->tasks[*iter].taskRealTimeCallbackFunc != nullptr)
						pThreadParam->tasks[*iter].taskRealTimeCallbackFunc(pThreadParam->tasks[*iter].frameImage.data, pThreadParam->tasks[*iter].frameImage.rows, pThreadParam->tasks[*iter].frameImage.cols);
				}
				// pThreadParam->tasks[*iter].taskFrameCount += pThreadParam->skip_frame_;
				iter++;
			}

#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


			auto task_iter = pThreadParam->TaskinPlayID.begin();

			pThreadParam->AttributionAnalysis = false;  

			long long second_analysis_time = get_cur_time_ms();

			for (int i = 0; i < curPlayTaskCount; i++)
			{
				for (int j = 0; j < deleteObjectID[i].size(); j++)
				{
					OBJ_KEY deleteObj = { *task_iter, deleteObjectID[i][j] };

					if (pThreadParam->m_snaphot_helper.snapShotInfo.find(deleteObj) == pThreadParam->m_snaphot_helper.snapShotInfo.end())
						continue;

					auto iter = pThreadParam->m_snaphot_helper.snapShotInfo.find(deleteObj);
					iter->second.finishTracker = true;

					pThreadParam->SaveResultInFile(iter->first, iter->second);
				}

				task_iter++;
			}

			for (auto task_id: pThreadParam->TaskinPlayID) {
				cudaFree(pThreadParam->tasks[task_id].task_algorithm_data.frame);
			}
			

			for (int i = 0; i < deleteObjectID.size(); i++)
				vector<int>().swap(deleteObjectID[i]);
			vector<vector<int>>().swap(deleteObjectID);

			pThreadParam->m_snaphot_helper.object_attri_analysis();

#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
			
			cudaError_t cudaStatus = cudaGetLastError();
			if (cudaStatus != cudaSuccess) {
				LOG_ERROR("object_attri_analysis last error: {}", cudaGetErrorString(cudaStatus));
			}

			std::this_thread::sleep_for(std::chrono::milliseconds(1));

			++total_count;
			++ncount;

#ifdef LOG_INFO2
			last_time =  get_cur_time_ms();
			cout << "process time_using:" << last_time - gather_data_time << endl;
			cout << endl;
#endif
		}
	}
	//catch (exception &e)
	{
		//os << 51 << e.what()<< std::endl;
	/*	std::cout << e.what() << std::endl;
		exit(-1);*/
	}
	long long costTime1 = get_cur_time_ms() - begintime1;
	LOG_INFO("Process Thread is Finished. total frame cost time = {} ms,  process times: {}", costTime1, process_times);

	pThreadParam->m_snaphot_helper.snapShotInfo.clear();
	pThreadParam->ProcessFlag = false;

	if (batch_img != NULL)
	{
		delete[] batch_img;
		batch_img = NULL;
	}

	cuCtxPopCurrent(nullptr);
	cuCtxDestroy(context);

	return 0;
}

int CMutliSourceVideoProcess::GetRuningNb() {
	int no = 0;
	for(int i=0; i < tasks.size(); i++){
		if(tasks[i].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 *pThreadParam = (CMutliSourceVideoProcess *)handle;

	while (!pThreadParam->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)
		{
			pThreadParam->licence_status = pThreadParam->licence_status - 1;
			printf("CMutliSourceVideoProcess licence error, ret: %d \n", res);
		}
		else
		{
			if (pThreadParam->licence_status < 0)
			{
				pThreadParam->licence_status = 0;
			}
		}
		std::this_thread::sleep_for(std::chrono::seconds(300));
	}
}
#endif