huago-corrcet_tools/HuaGoCorrect/gscn_drv.cpp

#include "stdafx.h"
#include "gscn_drv.h"
#include "stdio.h"
#include "turbojpeg.h"
#include <map>
#include "jpeglib.h"
#include "HuaGoCorrect.h"
#include "HuaGoCorrectDlg.h"
#include <Windows.h>
#include "twain.h"
#include "filetools.h"
#include "scn_usb.h"

//#define BYTE unsigned char

GScn_Drv::GScn_Drv()
	:selectDeviceIndex(-1),m_scannerType(-1),m_isScanning(false)
{
	//run();
	
	XdPrint(L"Init GScn_Drv() \n");

	m_bRun = false;
	devState = DEV_STOP;
	InitMSGMap();
	InitScannerDiviceMap();

	
}

GScn_Drv::~GScn_Drv()
{
	if (m_threadUsb.joinable())
	{
		m_bRun = false;
		devState = DEV_STOP;
		m_threadUsb.join();
		XdPrint(L"m_threadUsb Released  True 22222222222222222222222 \n");
	}
	XdPrint(L"~ GScn_Drv() \n");
}

void GScn_Drv::InitMSGMap()
{
	if (ntcMsg.size()>0)
		ntcMsg.clear();
   ntcMsg[COUNT_MODE]="<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˳<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD>";
   ntcMsg[NO_FEED]="<EFBFBD><EFBFBD>ֽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>ţ<EFBFBD>";
   ntcMsg[OPEN_COVER]="ɨ<EFBFBD><EFBFBD><EFBFBD>ǿ<EFBFBD><EFBFBD>ǣ<EFBFBD>";
   ntcMsg[FEED_IN_ERROR]="ʰֽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
   ntcMsg[PAPER_JAM]="<EFBFBD><EFBFBD>ֽ<EFBFBD><EFBFBD>";
   ntcMsg[DETECT_DOUBLE_FEED]="˫<EFBFBD>ţ<EFBFBD>";
   ntcMsg[DETECT_STAPLE]="<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>룡";
   ntcMsg[PAPER_SKEW]="ֽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD><EFBFBD>";
   ntcMsg[HARDWARE_ERROR]="Ӳ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
   ntcMsg[PC_SCAN_BUSY_or_ERROR]="PC<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
}


void GScn_Drv::InitScannerDiviceMap()
{
	if (devType.size()>0)
	{
		devType.clear();
	}
	devType["G100"]=G100;
	devType["G200"]=G200;
	devType["G300"]=G300;
	devType["G400"]=G400;
	devType["G500"]=G500;
}

static int iNum = 0;

void GScn_Drv::open(int vid, int pid,int index)
{
	auto devs = UsbScan_List::find_vid_pid(vid, pid);

	if (devs.size() != 0)
	{
		m_usb = *devs.begin();
		m_usb->open();//ͬʱ<CDAC><CAB1><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>ͬ<EFBFBD><CDAC>ɨ<EFBFBD><C9A8><EFBFBD>豸ʱ<E8B1B8><CAB1>Ĭ<EFBFBD><C4AC>ѡȡ<D1A1><C8A1>һ<EFBFBD><D2BB>vid pidƥ<64><C6A5><EFBFBD><EFBFBD><EFBFBD>豸
		selectDeviceIndex=index;
		m_scannerType=G300;
		h= ::FindWindow(NULL, L"HGScannerTool");		
	}
}

static void DoEvents()
{
	MSG msg;
	if (PeekMessage(&msg
		, NULL, 0, 0, PM_REMOVE))
	{
		DispatchMessage(&msg);

		TranslateMessage(&msg);
	}
}

std::string GScn_Drv::popMat(int num)
{
	auto image = m_pImages.popMat(num);
	return image;
}


int GScn_Drv::aquire_image(std::string& image,int num)
{
	while (true)
	{
		if (this->Get_IsImageQueueEmpty())
		{
			DoEvents();
			if (!this->is_scan())
				break;
		}
		else
		{
			if (m_pImages.valid())
			{
				image = popMat(num);
				return 0;
			}
		}
	}
	return -1;
}

int GScn_Drv::getMatSum()
{
	int iSum = 0;
	iSum = m_pImages.getMatSum();
	return iSum;
}

void GScn_Drv::close()
{
	m_usb->close();
}

void GScn_Drv::GetExpose(int& Aside, int& Bside)
{
	USBCB asideexp = { GET_UV_EXPOSA,0,0 };
	m_usb->write_bulk(&asideexp, sizeof(asideexp));
	m_usb->read_bulk(&asideexp, sizeof(asideexp));
	Aside = asideexp.u32_Data;
	USBCB bsideexp = { GET_UV_EXPOSB,0,0 };
	m_usb->write_bulk(&bsideexp, sizeof(asideexp));
	m_usb->read_bulk(&bsideexp, sizeof(asideexp));
	Bside = bsideexp.u32_Data;

}

void GScn_Drv::SetExpose(int aside, int bside)
{
	USBCB asideexp = { SET_UV_EXPOSA,aside,0 };
	m_usb->write_bulk(&asideexp, sizeof(asideexp));
	USBCB bsideexp = { SET_UV_EXPOSB,bside,0 };
	m_usb->write_bulk(&bsideexp, sizeof(bsideexp));

}

void GScn_Drv::GetSptime(int type, int& time)
{
	USBCB usb = {0,0,0};
	switch (type)
	{
	case 0:
		usb.u32_CMD = 0x100;//GET_GRAY_SP
		break;
	case 1:
		usb.u32_CMD = 0x102;//GET_COLOR_SP
		break;
	case 2:
		usb.u32_CMD = 0x104;//GET_UV_SP
		break;
	default:
		break;
	}
	m_usb->write_bulk(&usb, sizeof(usb));
	m_usb->read_bulk(&usb, sizeof(usb));
	time = usb.u32_Data;
}

void GScn_Drv::SetSptime(int type, int time)
{
	USBCB usb = { 0,time,0 };
	switch (type)
	{
	case 0:
		usb.u32_CMD = 0x101;//GET_GRAY_SP
		break;
	case 1:
		usb.u32_CMD = 0x103;//GET_COLOR_SP
		break;
	case 2:
		usb.u32_CMD = 0x105;//GET_UV_SP
		break;
	default:
		break;
	}
	m_usb->write_bulk(&usb, sizeof(usb));
}

void GScn_Drv::GetSleepTime(int& sleeptime)
{
	if (m_usb.get() && m_usb->is_connected())
	{
		USBCB usb = { GET_SLEEP_TIME,0,0 };
		m_usb->write_bulk(&usb, sizeof(usb));
		m_usb->read_bulk(&usb, sizeof(usb));
		sleeptime=usb.u32_Data;
	}
}

void GScn_Drv::SetSleepTime(int sleeptime)
{
	if (m_usb.get() && m_usb->is_connected())
	{
		USBCB usb = { SET_SLEEP_TIME,sleeptime,0 };
		m_usb->write_bulk(&usb, sizeof(usb));
	}
}

void GScn_Drv::GetFlatMaxBright(bool iscolor, unsigned int& val)
{
}

void GScn_Drv::SetFlatMaxBright(bool iscolor, unsigned int val)
{
}

void GScn_Drv::SetFlatCallback(std::function<void(std::string)> func)
{
	m_flatcallback = func;
}

void GScn_Drv::GetSpeedMode(int& speedmode, bool get)
{
}

void GScn_Drv::reset()
{
	while (!m_pImages.empty())
	{
		m_pImages.clear();
	}
}

void GScn_Drv::pushMat(JpegBuffer& data)
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	m_pImages.pushMat(data);
}

bool GScn_Drv::IsConnected()
{	
	if(m_usb.get())
		return  m_usb->is_connected();
	else
		return false;

}


cv::Mat GScn_Drv::Get_Img_Data(int bufferSize)
{
	std::lock_guard<std::mutex> lck(m_Locker);
	cv::Mat iData(1, bufferSize,CV_8UC1);
	USBCB usbcb = { GET_IMAGE,0,bufferSize };
	DWORD transfer;

	m_usb->write_bulk(&usbcb, sizeof(usbcb));
	m_usb->read_bulk(iData.data, bufferSize);
	return iData;
}

void GScn_Drv::run()
{
	//m_isScanning=false;
	if (m_threadUsb.joinable())
	{
		m_bRun = false;
		devState = DEV_STOP;
		m_threadUsb.join();
	}
	m_bRun = true;
	devState = DEV_ISRUNNING;
	m_threadUsb = std::thread(&GScn_Drv::usbmain, this);
}


void GScn_Drv::ActiveteUSB()
{
	if (IsConnected())
	{
		DWORD transfer;
		USBCB usbcb = { 1024,0 ,0 };
		m_usb->write_bulk(&usbcb, sizeof(usbcb));
	}
}

bool GScn_Drv::Updata(std::string filename, std::function<void(long, long)> func)
{
	std::ifstream updatefile;
	updatefile.open(filename, std::ios_base::in | std::ios_base::binary);
	if (!updatefile.is_open())
	{
		return false;
	}
	updatefile.seekg(0, std::ios::end);
	size_t length = updatefile.tellg();
	func(0, length);
	updatefile.seekg(0, std::ios::beg);
	USBCB pre_update = { PRE_UPGRADE,0,length };
	m_usb->write_bulk(&pre_update, sizeof(pre_update));
	size_t nreaded = 0;
	size_t nleft = length;
	int buffersize = 1024 * 1024;
	if (length <= buffersize)//С<><D0A1>1MB
	{
		char* uotstream = new char[length];
		USBCB update = { START_UPGRADE,0,length };
		m_usb->write_bulk(&update, sizeof(update));
		updatefile.read(uotstream, length);
		m_usb->write_bulk(uotstream, length);
		m_usb->read_bulk(&update, sizeof(update));
		if (update.u32_Count != length)
			return false;
		delete[] uotstream;
	}
	else
	{
		while (true)
		{
			int ntotransfer;
			if (nleft < buffersize)
				ntotransfer = nleft;
			else
				ntotransfer = buffersize;
			USBCB update = { START_UPGRADE,0,ntotransfer };
			m_usb->write_bulk(&update, sizeof(update));
			std::vector<char> data;
			data.resize(ntotransfer);
			updatefile.read(data.data(), ntotransfer);
			m_usb->write_bulk(data.data(), ntotransfer);
			m_usb->read_bulk(&update, sizeof(update));
			nreaded += ntotransfer;
			nleft -= ntotransfer;
			func(nreaded, length);
			if (nreaded >= length)
				break;
			this_thread::sleep_for(std::chrono::milliseconds(10));
		}
	}

	USBCB updatefinished = { UPDATE_FINISHED,0,0 };
	m_usb->write_bulk(&updatefinished, sizeof(updatefinished));
	return true;
}


DWORD GScn_Drv::usbmain()
{
	try
	{
		while (m_bRun)
		{	
			if (devState==DEV_ISRUNNING)
			{
				if (!IsConnected())
				{
					Sleep(200);
					continue;
				}
				USBCB usbcb = Get_Scanner_Status();
				switch (usbcb.u32_Data)
				{
				case HAVE_IMAGE:
					{
						int totalNum = usbcb.u32_Count;
						DWORD transferCount = 0;
						iNum++;
						cv::Mat imgData = Get_Img_Data(totalNum);
						switch(m_scannerType)
						{
						case G100:
						case G200:
							{
							cv::Mat bufferF = imgData.clone();
							cv::Mat bufferB = imgData.clone();
							int j = 0;
							int k = 0;
							for (int i = 0; i < totalNum / 1024; i++)
							{
								if (imgData.data[1023 + i * 1024] == 0)
								{
									j++;
									memcpy(&(bufferB.data[(j - 1) * 1023]), &(imgData.data[(j + k - 1) * 1024]), 1023);
								}
								else if (imgData.data[1023 + i * 1024] == 255)
								{
									k++;
									memcpy(&(bufferF.data[(k - 1) * 1023]), &(imgData.data[(j + k - 1) * 1024]), 1023);
								}
							}
							pushMat(JpegBuffer(bufferB,m_config.g200params.color==1?TJPF_BGR:TJPF_GRAY,0,0));
							pushMat(JpegBuffer(bufferF, m_config.g200params.color == 1 ? TJPF_BGR : TJPF_GRAY,1,0));
							break;
							}
						case G300:
						case G400:
						case G500:
							pushMat(JpegBuffer(imgData, m_config.g200params.color == 1 ? TJPF_BGR : TJPF_GRAY,0,0));
							break;
						default:
							break;
						}
						Pop_Image();
						break;
					}
				case STOP_SCAN:
					{
						m_isScanning=false;
						devState = DEV_STOP;
						m_pImages.SetScanFlag(false);
						break;
					}
				case AUTO_FLAT_FINISHED:
				{
					m_isScanning = false;
					devState = DEV_STOP;
					MessageBox(NULL,TEXT("<EFBFBD>Զ<EFBFBD>У<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD>"), TEXT("<EFBFBD><EFBFBD>ʾ"), MB_OK);
				}
				break;
				case COUNT_MODE:
				case NO_FEED:
				case OPEN_COVER:
				case FEED_IN_ERROR:
				case DETECT_DOUBLE_FEED:
				case DETECT_STAPLE:
				case PAPER_SKEW:
				case HARDWARE_ERROR:
				case PC_SCAN_BUSY_or_ERROR:{
					USES_CONVERSION;
					MessageBox(h, CString(ntcMsg[usbcb.u32_Data].c_str()), L"<EFBFBD><EFBFBD>ʾ", MB_OK | MB_ICONERROR);
					devState = DEV_WRONG;
					m_pImages.SetScanFlag(false);
					break;
				}
				case NORMAL:
					break;
				default:
					break;
				}
				this_thread::sleep_for(std::chrono::milliseconds(20));
			}
		}
		return 0;
	}
	catch (CMemoryException* e)
	{
		XdPrint(L"CMemoryException");
	}
	catch (CFileException* e)
	{
		XdPrint(L"CFileException");
	}
	catch (CException* e)
	{
		XdPrint(L"CException");
	}
	return 0;
}

///////////////////////////////////////////////////////////////////////////
void GScn_Drv::Config_Scanner(PUSBCB pUSBCB)
{
	if (m_usb->is_connected())
	{
		std::lock_guard<std::mutex> lck(m_imgLocker);
		DWORD transfer;
		m_usb->write_bulk(pUSBCB, sizeof(USBCB));
	}
}

void GScn_Drv::Config_Scanner(HGScanConfig config)
{
	m_config = config;
	USBCB usbcb = { CONFIGURED_DATA ,m_config.value,0 };
	if (m_usb->is_connected())
	{
		std::lock_guard<std::mutex> lck(m_imgLocker);
		DWORD transfer;
		m_usb->write_bulk(&usbcb, sizeof(USBCB));
	}
}

///////////////////////////////////////////////////////////////////////////
void GScn_Drv::Scanner_StartScan(UINT16 count)
{
	//count = 0;
	//XdPrint("Scanner_StartScan.............\n");
	if (m_usb->is_connected())
	{
		//XdPrint("Scanner Isconnected.............\n");
		std::lock_guard<std::mutex> lck(m_imgLocker);
		DWORD transfer;
		USBCB usbcb = { START_COMMAND,AUTO_SCAN_MODE ,0 };
		m_usb->write_bulk(&usbcb, sizeof(usbcb));
		iNum = 0;
		m_pImages.pixType=m_config.g200params.color;
		m_pImages.SetDevModel(m_scannerType);
		m_pImages.SetFilePath(csPath);
		m_pImages.run();
		m_pImages.SetScanFlag(true);
		run();
	}
}

///////////////////////////////////////////////////////////////////////////
std::string GScn_Drv::GetFWVersion()
{
	if (m_usb->is_connected())
	{
	    std::lock_guard<std::mutex> lck(m_imgLocker);
		std::string pFWVersion = "          ";
		USBCB usbcb = { GET_FW_VERSION,0,0 };
	    XdPrint(L"Get GetFWVersion");
		m_usb->write_bulk(&usbcb, sizeof(usbcb));

		CString cslog;
		cslog.Format(L"GetFWVersion Read_Data %d",usbcb.u32_Data);

		m_usb->read_bulk(&pFWVersion[0], 10);
		return pFWVersion;
	}
	return "";
}

void GScn_Drv::SetFWVersion()
{
	if (m_usb->is_connected())
	{
		std::lock_guard<std::mutex> lck(m_imgLocker);

	}
}

void GScn_Drv::SetSerialNum(std::string pvalue)
{
	if (m_usb->is_connected())
	{
		std::lock_guard<std::mutex> lck(m_imgLocker);
		USBCB sercmd = { SEND_SERIAL ,0,14};
		m_usb->write_bulk(&sercmd, sizeof(sercmd));
		m_usb->write_bulk(&pvalue, pvalue.length());
	}
	return;
}

std::string GScn_Drv::GetKernelVersion()
{
	return "un support";
}

int GScn_Drv::GetScanNum()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	USBCB usbcb = { GET_SCANN_NUM,0,4 };
	DWORD transfer;
	XdPrint(L"Get GetScanNum");
	m_usb->write_bulk(&usbcb, sizeof(usbcb));

	CString cslog;
	cslog.Format(L"GetScanNum Read_Data %d",usbcb.u32_Data);
	//WriteLog(cslog);

	m_usb->read_bulk(&usbcb, sizeof(usbcb));
	return usbcb.u32_Data;
}

void GScn_Drv::ClrRollerNum()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	USBCB usbcb = { CLR_ROLLER_NUM,0,4 };
	DWORD transfer;
	XdPrint(L"Get ClrRollerNum");
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
	return;
}

void GScn_Drv::ClrScanNum()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	USBCB usbcb = { CLR_SCAN_NUM,0,4 };
	DWORD transfer;
	XdPrint(L"Get ClrScanNum");
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
	return;
}

void GScn_Drv::SendFlatData(CorrectParam param, int index)
{
	UsbKeyWords keyword;
	switch (index)
	{
	case 0:
		keyword = SEND_COLORCORRECT_FLAT;
		break;
	case 1:
		keyword = SEND_COLOR_FLAT;
		break;
	case 2:
		keyword = SEND_GRAYCORRECT_FLAT;
		break;
	case 3:
		keyword = SEND_GRAY_FLAT;
		break;
	default:
		break;
	}
	USBCB cmd = { keyword ,0,0 };
	m_usb->write_bulk(&cmd, sizeof(cmd));
	m_usb->write_bulk(&param, sizeof(param));
}

CaptureParams GScn_Drv::GetFlatData()
{
	CaptureParams param = {0};
	USBCB usbcb = { GET_FLAT_DATA,0,0 };
	DWORD transfer;
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
	m_usb->read_bulk(&param, sizeof(param));
	return param;
}

void GScn_Drv::StartFlat(bool iscolor)
{
	if (!m_usb->is_connected())
		return;

	USBCB usbcb = { START_FLAT,0,0 };
	DWORD transfer;
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
	if (m_threadUsb.joinable()) {
		m_bRun = false;
		devState = DEV_STOP;
		m_threadUsb.join();
	}
	m_bRun = true;
	devState = DEV_ISRUNNING;
	m_threadUsb = std::thread(&GScn_Drv::usbmain, this);
}

void GScn_Drv::DevStateChange()
{
	devState = DEV_STOP;
}

///////////////////////////////////////////////////////////////////////////
std::string GScn_Drv::GetSerialNum()
{
	if (!m_usb.get()&&!m_usb->is_connected())
	{
		return "";
	}

	std::lock_guard<std::mutex> lck(m_imgLocker);
	std::string str;
	str.resize(14);
	USBCB usbcb = { GET_SERIAL,0,14 };
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
	XdPrint(L"GetSerialNum Read_Data %d",usbcb.u32_Data);
	m_usb->read_bulk(&str, 14);
	return str;
}

void GScn_Drv::SetRatio(int tyepe, int ration)
{
	UsbKeyWords keyword = tyepe == 0 ? SET_JUST_COF_H : SET_JUST_COF_V;
	USBCB cmd = { keyword ,ration,0};
	m_usb->write_bulk(&cmd, sizeof(cmd));
}

void GScn_Drv::GetRatio(int type, int& ratio)
{
	UsbKeyWords keyword = type == 0 ? GET_JUST_COF_H : GET_JUST_COF_V;
	USBCB cmd = { keyword ,0,0 };
	m_usb->write_bulk(&cmd, sizeof(cmd));
	m_usb->read_bulk(&cmd, sizeof(cmd));
	ratio = cmd.u32_Data;
}

void GScn_Drv::Reboot()
{
	USBCB cmd = { REBOOT,0,0 };
	m_usb->write_bulk(&cmd, sizeof(cmd));
}

///////////////////////////////////////////////////////////////////////////
USBCB GScn_Drv::Get_Scanner_Status()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	if (!m_usb->is_connected())
	{
		//XdPrint("Get_Scanner_Status Error\n");
		USBCB errorType = { NO_COMMAND ,PC_SCAN_BUSY_or_ERROR ,0 };
		return errorType;
	}

	//XdPrint("Get_Scanner_Status GET_DSP_STATUS write_bulk\n");
	USBCB usbcb = { GET_DSP_STATUS ,0,0 };
	DWORD transfer;
	m_usb->write_bulk(&usbcb, sizeof(usbcb));

	//XdPrint("Get_Scanner_Status  Read_Data %d \n",usbcb.u32_Data);

	m_usb->read_bulk(&usbcb,sizeof(usbcb));

	//XdPrint("Get_Scanner_Status  return usbcb \n",usbcb.u32_Data);
	return usbcb;
}

///////////////////////////////////////////////////////////////////////////
bool GScn_Drv::is_scan()
{
	return devState==DEV_ISRUNNING;
}

///////////////////////////////////////////////////////////////////////////
bool GScn_Drv::Get_Scanner_PaperOn()
{
	if (!m_usb->is_connected())
	{
		return false;
	}
	USBCB usbcb = { GET_PAPERFEEDER_STATUS ,0,0 };
	DWORD transfer;
	std::lock_guard<std::mutex> lck(m_imgLocker);
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
	m_usb->read_bulk(&usbcb, sizeof(usbcb));
	return usbcb.u32_Data != 0;
}

///////////////////////////////////////////////////////////////////////////
void GScn_Drv::Pop_Image()
{
	if (!m_usb->is_connected())
	{
		return;
	}
	std::lock_guard<std::mutex> lck(m_imgLocker);
	USBCB usbcb = { POP_IMAGE ,0,0 };
	DWORD transfer;
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
}

///////////////////////////////////////////////////////////////////////////
void GScn_Drv::Stop_scan()
{
	if (!m_usb->is_connected())
	{
		return;
	}
	std::lock_guard<std::mutex> lck(m_imgLocker);
	USBCB usbcb = { STOP ,0,0 };
	DWORD transfer;
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
}

void GScn_Drv::ResetScanner()
{
	if (!m_usb->is_connected())
		return;

	std::lock_guard<std::mutex> lck(m_imgLocker);
	USBCB usbcb = { INIT_HARDWARE_SYS ,0,0 };
	DWORD transfer;
	m_usb->write_bulk(&usbcb, sizeof(usbcb));
}

///////////////////////////////////////////////////////////////////////////
bool GScn_Drv::Get_IsImageQueueEmpty()
{
	return m_pImages.empty();
}