#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] = "计数模式，请先退出计数模式！";
	ntcMsg[NO_FEED] = "无纸，请放置纸张！";
	ntcMsg[OPEN_COVER] = "扫描仪开盖！";
	ntcMsg[FEED_IN_ERROR] = "拾纸错误！";
	ntcMsg[PAPER_JAM] = "卡纸！";
	ntcMsg[DETECT_DOUBLE_FEED] = "双张！";
	ntcMsg[DETECT_STAPLE] = "订书针！";
	ntcMsg[PAPER_SKEW] = "纸张歪斜！";
	ntcMsg[HARDWARE_ERROR] = "硬件错误！";
	ntcMsg[PC_SCAN_BUSY_or_ERROR] = "PC错误！";
}



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();//?同时存在多个同种扫描设备时，默认选取第一个vid pid匹配的设备
		VID = vid;
		PID = pid;
		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)
{
	if (m_usb.get() && m_usb->is_connected())
	{
		USBCB speed = { get ? GET_SPEED_MODE : SET_SPEED_MODE,speedmode,0 };
		m_usb->write_bulk(&speed, sizeof(speed));
		if (get)
		{
			m_usb->read_bulk(&speed, sizeof(speed));
			speedmode = speed.u32_Data;
		}
	}
}

void GScn_Drv::GetOrSetVIDPID(int& value, bool get)
{
	if (m_usb.get() && m_usb->is_connected())
	{
		USBCB u_cmd = { get ? GET_USB_INFOR_VIDPID : SET_USB_INFOR_VIDPID,value,0 };
		m_usb->write_bulk(&u_cmd, sizeof(u_cmd));
		if (get)
		{
			m_usb->read_bulk(&u_cmd, sizeof(u_cmd));
			value = u_cmd.u32_Data;
		}
	}
}

std::string GScn_Drv::GetSysInfo()
{
	UsbKeyWords keyword = GETSYSINFO_LEN;
	USBCB cmd = { keyword ,0,0 };
	m_usb->write_bulk(&cmd, sizeof(cmd));
	m_usb->read_bulk(&cmd, sizeof(cmd));
	int len = cmd.u32_Count;
	string str;
	str.resize(len);
	cmd.u32_CMD = GETSYSINFO;
	cmd.u32_Count = 0;
	cmd.u32_Data = 0;
	m_usb->write_bulk(&cmd, sizeof(cmd));
	m_usb->read_bulk(&str[0], len);
	int aa = 0;
	return str;
}

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)//小于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));
		delete[] uotstream;
		if (update.u32_Count != length)
		{
			return false;
		}
		else
		{
			func(update.u32_Count, length);
		}
	}
	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));
						//auto img = fopen("inmg.jpg", "wb+");
						//fwrite(imgData.data, 1, totalNum, img);
						//fclose(img);
					}
					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;
					if (usbcb.u32_Count != 0)
					{
						std::string msg;
						msg.resize(usbcb.u32_Count);
						m_usb->read_bulk(&msg[0], usbcb.u32_Count);
						if (m_flatcallback)
							m_flatcallback(msg);
					}
					//MessageBox(NULL,TEXT("自动校正已完成！"), TEXT("提示"), MB_OK);
				}
				case AUTO_FLATTING:
				{
					if (usbcb.u32_Count != 0)
					{
						std::string msg;
						msg.resize(usbcb.u32_Count);
						m_usb->read_bulk(&msg[0], usbcb.u32_Count);
						if (m_flatcallback)
							m_flatcallback(msg);
					}
				}
				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"提示?", 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);
	}
}

std::string GScn_Drv::GetIpAddr()
{
	return "no support";
}

std::string GScn_Drv::GetMbVersion()
{
	return "no support";
}

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

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

	CString cslog;
	cslog.Format(L"GetRollerNum 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, int dpi)
{
	UsbKeyWords keyword = tyepe == 0 ? SET_JUST_COF_H : SET_JUST_COF_V;
	USBCB cmd = { keyword ,ration,dpi };
	m_usb->write_bulk(&cmd, sizeof(cmd));
}

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

void GScn_Drv::Reboot(bool loader)
{
	USBCB cmd = { REBOOT,loader ? 1 : 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();
}