#include <errno.h></errno.h>

#include "texception.h"

#include "tscanner.h"

#include "tscannerepson.h"

#include "tscannerutil.h"

#include "tsystem.h"

#include "tconvert.h"

#include "trop.h"

#include "TScannerIO/TUSBScannerIO.h"

#include <cassert></cassert>

#include <memory></memory>

#include <fstream></fstream>

#include <strstream></strstream>

using namespace TScannerUtil;

void sense(bool) {}

int scsi_maxlen()

{

	assert(0);

	return 0;

}

#define BW_USES_GRAYTONES

#ifndef _WIN32

#define SWAPIT

#endif

#ifdef i386

#undef SWAPIT

#endif

/*

Commands used to drive the scanner:

cmd   spec                    Level

@     Reset                B2 B3 B4 B5 A5

Q     Sharpness                  B4 B5 A5

B     Halftoning        B1 B2 B3 B4 B5 A5

Z     Gamma                B2 B3 B4 B5 A5

L     Brightness           B2 B3 B4 B5 A5

t     Threshold

H     Zoom                 B2 B3 B4 B5 A5

R     Resolution        B1 B2 B3 B4 B5 A5

A     Set read Area     B1 B2 B3 B4 B5 A5

C     Linesequence Mode B1 B2 B3 B4 B5 A5

d     Line count                 B4 B5 A5

D     Dataformat        B1 B2 B3 B4 B5 A5

g     Scan speed                 B4 B5 A5

G     Start Scan        B1 B2 B3 B4 B5

e     Activate ADF   

0x19  Load from ADF

0x0C  Unload from ADF

*/

/* NOTE: you can find these codes with "man ascii". */

static unsigned char STX = 0x02;

static unsigned char ACK = 0x06;

static unsigned char NAK = 0x15;

static unsigned char CAN = 0x18;

static unsigned char ESC = 0x1B;

static unsigned char PF = 0x19;

/* STATUS bit in readLineData */

static unsigned char FatalError = 1 << 7;

static unsigned char NotReady = 1 << 6;

//-----------------------------------------------------------------------------

#define log

class TScannerExpection : public TException

{

	TString m_scannerMsg;

public:

	TScannerExpection(const std::vector<std::string> ¬Fatal, const std::string &fatal)</std::string>

		: TException("Scanner Expection")

	{

		m_scannerMsg = ::to_wstring(fatal);

		for (int i = notFatal.size(); i; i--)

			m_scannerMsg += L"\n" + ::to_wstring(notFatal[i - 1]);

		log("Exception created: " + ::to_string(m_scannerMsg));

	}

	TString getMessage() const { return m_scannerMsg; }

};

//-----------------------------------------------------------------------------

namespace

{

/*

void log(string s)

{

  std::ofstream os("C:\\butta.txt", std::ios::app);

  os << s << std::endl;

  os.flush();

}

*/

}

//-----------------------------------------------------------------------------

TScannerEpson::TScannerEpson()

	: m_scannerIO(new TUSBScannerIO()), m_hasADF(false), m_isOpened(false)

{

	log("Created");

}

//-----------------------------------------------------------------------------

void TScannerEpson::closeIO()

{

	log("CloseIO.");

	if (m_scannerIO && m_isOpened)

		m_scannerIO->close();

	m_isOpened = false;

}

//-----------------------------------------------------------------------------

TScannerEpson::~TScannerEpson()

{

	closeIO();

	log("Destroyed");

}

//-----------------------------------------------------------------------------

void TScannerEpson::selectDevice()

{

	log(std::string("selectDevice; isOpened=") + (m_isOpened ? "true" : "false"));

	if (!m_scannerIO->open()) {

		log("open() failed");

		throw TException("unable to get handle to scanner");

	}

	m_isOpened = true;

	/*

  char lev0, lev1;

  unsigned short lowRes, hiRes, hMax,vMax;

  collectInformation(&lev0, &lev1, &lowRes, &hiRes, &hMax, &vMax);

  string version = toString(lev0) + "." + toString(lev1);

  */

	setName("Scanner EPSON (Internal driver)");

}

//-----------------------------------------------------------------------------

bool TScannerEpson::isDeviceAvailable()

{

	return true;

}

//-----------------------------------------------------------------------------

bool TScannerEpson::isDeviceSelected()

{

	return m_isOpened;

}

//-----------------------------------------------------------------------------

void TScannerEpson::updateParameters(TScannerParameters ¶meters)

{

	log("updateParameters()");

	char lev0, lev1;

	unsigned short lowRes, hiRes, hMax, vMax;

	collectInformation(&lev0, &lev1, &lowRes, &hiRes, &hMax, &vMax);

	log("collected info. res = " + std::to_string(lowRes) + "/" + std::to_string(hiRes));

	// non supportiamo black & white

	parameters.setSupportedTypes(true, true, true);

	// param.m_scanArea = TRectD(0, 0, 0, 0);

	parameters.setMaxPaperSize((25.4 * hMax) / (float)hiRes, (25.4 * vMax) / (float)hiRes);

	parameters.updatePaperFormat();

	// cambio range, default, step, e supported. aggiorno, se necessario, il value (n.b. non dovrebbe succedere

	// mai, perche' i range sono sempre gli stessi su tutti gli scanner

	TScanParam defaultEpsonParam(0., 255., 128., 1.);

	parameters.m_brightness.update(defaultEpsonParam);

	parameters.m_contrast.update(defaultEpsonParam);

	parameters.m_threshold.update(defaultEpsonParam);

	if (m_hasADF) {

		TScanParam defaultPaperFeederParam(0., 1., 0., 1.);

		parameters.m_paperFeeder.update(defaultPaperFeederParam);

	} else

		parameters.m_paperFeeder.m_supported = false;

	// cerco un default per il dpi. il piu' piccolo possibile nella forma 100+k50

	float defaultDpi = 100;

	while (defaultDpi < lowRes)

		defaultDpi += 50;

	TScanParam defaultDpiParam(lowRes, hiRes, defaultDpi, hiRes > lowRes ? 1.F : 0.F);

	parameters.m_dpi.update(defaultDpiParam);

	//  parameters.m_twainVersion = "NATIVE";

	//  parameters.m_manufacturer = "EPSON";

	//  parameters.m_version = toString(lev0) + "." + toString(lev1);

	log("end updateParameters()");

}

//-----------------------------------------------------------------------------

void TScannerEpson::acquire(const TScannerParameters ¶ms, int paperCount)

{

	log("acquire");

	TRectD scanArea = params.getScanArea();

	if (scanArea.isEmpty())

		throw TException("Scan area is empty, select a paper size");

	/*

  if ((scanArea.getSize().lx > params.m_maxPaperSize.lx) ||

      (scanArea.getSize().ly > params.m_maxPaperSize.ly))

    throw TException("Scan area too large, select a correct paper size");

*/

	for (int i = 0; i < paperCount; ++i) {

		log("paper " + std::to_string(i));

#ifdef _DEBUG

		m_scannerIO->trace(true);

#endif

		doSettings(params, i == 0);

		unsigned int nTimes = 0;

		unsigned int bytes_to_read;

		bool rc;

		unsigned char stx;

#ifdef _DEBUG

		m_scannerIO->trace(false);

#endif

		TRasterP ras, rasBuffer;

		unsigned char *buffer = 0;

		log("Scan command");

		rc = ESCI_command('G', false); /* 'SCAN' command */

		if (!rc)

			throw TException("Start Scan failed");

		log("Scan command OK");

		unsigned short offsetx = 0, offsety = 0;

		unsigned short dimlx = 0, dimly = 0;

		TRectD scanArea = params.isPreview() ? params.getScanArea() : params.getCropBox();

		scanArea2pix(params, offsetx, offsety, dimlx, dimly, scanArea);

		tswap(dimlx, dimly);

		unsigned int bytes;

		switch (params.getScanType()) {

		case TScannerParameters::BW:

#ifdef BW_USES_GRAYTONES

			ras = TRasterGR8P(dimlx, dimly);

			bytes = dimlx * dimly;

			rasBuffer = TRasterGR8P(dimlx, dimly);

			buffer = rasBuffer->getRawData();

			break;

			break;

#else

			ras = TRasterGR8P(dimlx, dimly);

			bytes = tceil(dimlx / 8) * dimly;

			rasBuffer = TRasterGR8P(tceil(dimlx / 8), dimly);

			//bytes = (dimlx + 7) % 8 * dimly;

			//rasBuffer = TRasterGR8P((dimlx + 7) % 8,dimly);

			buffer = rasBuffer->getRawData();

			break;

#endif

		case TScannerParameters::GR8:

#ifdef GRAYTONES_USES_RGB

			ras = TRasterGR8P(dimlx, dimly);

			bytes = dimlx * dimly * 3;

			rasBuffer = TRasterGR8P(dimlx * 3, dimly);

			buffer = rasBuffer->getRawData();

			break;

#else

			ras = TRasterGR8P(dimlx, dimly);

			bytes = dimlx * dimly;

			rasBuffer = TRasterGR8P(dimlx, dimly);

			buffer = rasBuffer->getRawData();

			break;

#endif

		case TScannerParameters::RGB24:

			ras = TRaster32P(dimlx, dimly);

			bytes = dimlx * dimly * 3;

			rasBuffer = TRasterGR8P(dimlx * 3, dimly);

			buffer = rasBuffer->getRawData();

			break;

		default:

			throw TException("Unknown scanner mode");

			break;

		}

		log("sleep");

		TSystem::sleep(2000);

		log("reading data");

		bool areaEnd = false;

		unsigned int bytes_read = 0;

		while (!areaEnd) {

			unsigned short lines, counter;

			unsigned char status = 0;

			unsigned int retryCount = 0;

			do {

				ESCI_readLineData(stx, status, counter, lines, areaEnd);

				if (status & FatalError) {

					retryCount++;

					if (retryCount == 1)

						throw TException("Error scanning");

				}

			} while (status & FatalError);

			bytes_to_read = lines * counter;

			if (stx != 0x02) {

				std::ostrstream os;

				os << "header corrupted (" << std::hex << stx << ")" << '\0';

				throw TException(os.str());

			}

			unsigned long reqBytes = bytes_to_read;

			std::unique_ptr<unsigned char[]=""> readBuffer = ESCI_read_data2(reqBytes);</unsigned>

			if (!readBuffer)

				throw TException("Error reading image data");

			log("readline: OK");

			/*

      if (params.getScanType() == TScannerParameters::BW )

      {

        for (unsigned int i = 0; i< reqBytes;i++)

          readBuffer[i] = ~readBuffer[i];

      }

      */

			memcpy(buffer + bytes_read, readBuffer.get(), reqBytes);

			bytes_read += reqBytes;

			nTimes++;

			if (bytes_read == bytes)

				break; /* I've read enough bytes */

			if (!(stx & 0x20))

				sendACK();

		}

		log("read: OK");

		{ /*

    FILE *myFile = fopen("C:\\temp\\prova.dmp", "w+");

    fwrite(buffer, 1, bytes_to_read, myFile); 

    fclose(myFile);*/

		}

		if (params.m_paperFeeder.m_supported && (params.m_paperFeeder.m_value == 1.)) {

			log("Advance paper");

			if (m_settingsMode == OLD_STYLE)

				ESCI_doADF(0);

			log("Advance paper: OK");

		}

		switch (params.getScanType()) {

		case TScannerParameters::BW:

#ifdef BW_USES_GRAYTONES

			copyGR8BufferToTRasterBW(buffer, dimlx, dimly, ras, true, params.m_threshold.m_value);

			//copyGR8BufferToTRasterGR8(buffer, dimlx, dimly, ras, true);

			break;

#else

			copyBWBufferToTRasterGR8(buffer, dimlx, dimly, ras, true, true);

			break;

#endif

		case TScannerParameters::GR8:

#ifdef GRAYTONES_USES_RGB

			copyRGBBufferToTRasterGR8(buffer, dimlx, dimly, dimlx, ras);

			break;

#else

			copyGR8BufferToTRasterGR8(buffer, dimlx, dimly, ras, true);

			break;

#endif

		case TScannerParameters::RGB24:

			copyRGBBufferToTRaster32(buffer, dimlx, dimly, ras, true);

			break;

		default:

			throw TException("Unknown scanner mode");

			break;

		}

		if (params.getCropBox() != params.getScanArea() && !params.isPreview()) {

			TRect scanRect(TPoint(offsetx, offsety), TDimension(dimly, dimlx)); //dimLx and ly was has been swapped

			scanArea2pix(params, offsetx, offsety, dimlx, dimly, params.getScanArea());

			TRasterP app = ras->create(dimly, dimlx);

			TRaster32P app32(app);

			TRasterGR8P appGR8(app);

			if (app32)

				app32->fill(TPixel32::White);

			else if (appGR8)

				appGR8->fill(TPixelGR8::White);

			app->copy(ras, TPoint(dimly - scanRect.y1 - 1, dimlx - scanRect.x1 - 1));

			ras = app;

		}

		TRasterImageP rasImg(ras);

		if (ras) {

			rasImg->setDpi(params.m_dpi.m_value, params.m_dpi.m_value);

			rasImg->setSavebox(ras->getBounds());

		}

		log("notifying");

		notifyImageDone(rasImg);

		if (!(params.m_paperFeeder.m_value == 1.) || params.isPreview()) //feeder here!

		{

			if ((paperCount - i) > 1)

				notifyNextPaper();

		} else

			notifyAutomaticallyNextPaper();

		if (isScanningCanceled())

			break;

	}

	/*Unload Paper if need*/

	if ((m_settingsMode == NEW_STYLE) && params.m_paperFeeder.m_supported && (params.m_paperFeeder.m_value == 1.)) {

		if (!ESCI_command_1b('e', 1, true)) {

			std::vector<std::string> notFatal;</std::string>

			throw TScannerExpection(notFatal, "Scanner error (un)loading paper");

		}

		unsigned char p = 0x0C;

		bool status = true;

		send(&p, 1);

		status = expectACK();

	}

	log("acquire OK");

}

//-----------------------------------------------------------------------------

bool TScannerEpson::isAreaSupported()

{

	return true;

}

//-----------------------------------------------------------------------------

inline unsigned char B0(const unsigned int v) { return (v & 0x000000ff); }

inline unsigned char B1(const unsigned int v) { return (v & 0x0000ff00) >> 8; }

inline unsigned char B2(const unsigned int v) { return (v & 0x00ff0000) >> 16; }

inline unsigned char B3(const unsigned int v) { return (v & 0xff000000) >> 24; }

void TScannerEpson::doSettings(const TScannerParameters ¶ms, bool firstSheet)

{

	log("doSettings");

	int retryCount = 3;

	std::vector<std::string> notFatal;</std::string>

	while (retryCount--) {

		if (m_settingsMode == NEW_STYLE) {

			if (firstSheet)

				if (!resetScanner()) {

					notFatal.push_back("Scanner error resetting");

					continue;

				}

		} else {

			if (!resetScanner()) {

				notFatal.push_back("Scanner error resetting");

				continue;

			}

		}

		unsigned char cmd[64];

		memset(&cmd, 0, 64);

		unsigned char brightness = 0x00;

		float bv = params.m_brightness.m_value;

		if (bv >= 0 && bv < 43)

			brightness = 0xFD;

		if (bv >= 43 && bv < 86)

			brightness = 0xFE;

		if (bv >= 86 && bv < 128)

			brightness = 0xFF;

		if (bv >= 128 && bv < 171)

			brightness = 0x00;

		if (bv >= 171 && bv < 214)

			brightness = 0x01;

		if (bv >= 214 && bv < 255)

			brightness = 0x02;

		if (bv == 255)

			brightness = 0x03;

		unsigned short dpi = (unsigned short)params.m_dpi.m_value;

		unsigned short offsetx, offsety;

		unsigned short sizelx, sizely;

		TRectD scanArea = params.isPreview() ? params.getScanArea() : params.getCropBox();

		scanArea2pix(params, offsetx, offsety, sizelx, sizely, scanArea);

		// the main scan resolution (ESC R)

		cmd[0] = B0(dpi);

		cmd[1] = B1(dpi);

		cmd[2] = B2(dpi);

		cmd[3] = B3(dpi);

		//the sub scan resolution (ESC R)

		cmd[4] = B0(dpi);

		cmd[5] = B1(dpi);

		cmd[6] = B2(dpi);

		cmd[7] = B3(dpi);

		//skipping length of main scan (ESC A)

		cmd[8] = B0(offsetx);

		cmd[9] = B1(offsetx);

		cmd[10] = B2(offsetx);

		cmd[11] = B3(offsetx);

		//skipping length of sub scan (ESC A)

		cmd[12] = B0(offsety);

		cmd[13] = B1(offsety);

		cmd[14] = B2(offsety);

		cmd[15] = B3(offsety);

		//the length of main scanning (ESC A)

		cmd[16] = B0(sizelx);

		cmd[17] = B1(sizelx);

		cmd[18] = B2(sizelx);

		cmd[19] = B3(sizelx);

		//the length of sub scanning (ESC A)

		cmd[20] = B0(sizely);

		cmd[21] = B1(sizely);

		cmd[22] = B2(sizely);

		cmd[23] = B3(sizely);

#ifdef GRAYTONES_USES_RGB

		cmd[24] = 0x13; //scanning color (ESC C)

		cmd[25] = 0x08; // data format (ESC D)

#else

		switch (params.getScanType()) {

		case TScannerParameters::BW:

			cmd[24] = 0x00; //scanning BW/Gray (ESC C)

#ifdef BW_USES_GRAYTONES

			cmd[25] = 0x08; // data format (ESC D)

#else

			cmd[25] = 0x01; // data format (ESC D)

			break;

#endif

		case TScannerParameters::GR8:

			cmd[24] = 0x00; //scanning BW/Gray (ESC C)

			cmd[25] = 0x08; // data format (ESC D)

			break;

		case TScannerParameters::RGB24:

			cmd[24] = 0x13; //scanning color (ESC C)

			cmd[25] = 0x08; // data format (ESC D)

			break;

		default:

			throw TException("Unknown scanner mode");

			break;

		}

//  cmd[24] = (params.getScanType() == TScannerParameters::RGB24)?0x13:0x00; //scanning color (ESC C)

//  cmd[25] = (params.getScanType() == TScannerParameters::RGB24)?0x08:0x08; // data format (ESC D)

#endif

		if (m_settingsMode == NEW_STYLE)

			cmd[26] = 0;

		else

			cmd[26] = (params.m_paperFeeder.m_supported && (params.m_paperFeeder.m_value == 1.)) ? 0x01 : 0x00; // option control (ESC e)

		cmd[27] = 0x00;																							// scanning mode (ESC g)

		cmd[28] = 0xFF;																							// the number of block line (ESC d)

		cmd[29] = 0x02;																							// gamma (ESC Z)

		cmd[30] = brightness;																					//  brightness (ESC L)

		cmd[31] = 0x80;																							// color collection (ESC M)

		cmd[32] = 0x01;																							// half toning processing (ESC B)

		cmd[33] = (unsigned char)params.m_threshold.m_value;													// threshold (ESC t)

		cmd[34] = 0x00;																							// separate of area (ESC s)

		cmd[35] = 0x01;																							// sharpness control (ESC Q)

		cmd[36] = 0x00;																							// mirroring (ESC K)

		cmd[37] = 0x00;																							// set film type (ESC N)

																												// other bytes should be set to 0x00 !

		if (m_settingsMode == NEW_STYLE)

			if (params.m_paperFeeder.m_supported && (params.m_paperFeeder.m_value == 1.)) {

				unsigned char v = (params.m_paperFeeder.m_value == 1.) ? 0x01 : 0x00;

				if (!ESCI_command_1b('e', v, true))

					throw TScannerExpection(notFatal, "Scanner error (un)loading paper");

				if (v) {

					unsigned char p = 0x19;

					bool status = true;

					send(&p, 1);

					status = expectACK();

				}

			}

		unsigned char setParamCmd[2] = {0x1C, 0x57};

		int wrote = send(&setParamCmd[0], 2);

		if (wrote != 2)

			throw TScannerExpection(notFatal, "Error setting scanner parameters - W -");

		if (!expectACK()) {

			notFatal.push_back("Error setting scanner parameters - NAK on W -");

			continue;

		}

		wrote = send(&cmd[0], 0x40);

		if (wrote != 0x40)

			throw TScannerExpection(notFatal, "Error setting scanner parameters - D -");

		if (!expectACK()) {

			notFatal.push_back("Error setting scanner parameters - NAK on D -");

			continue;

		}

		//if here, everything is ok, exit from loop

		break;

	}

	if (retryCount <= 0)

		throw TScannerExpection(notFatal, "Error setting scanner parameters, too many retries");

	log("doSettings:OK");

}

//-----------------------------------------------------------------------------

void TScannerEpson::collectInformation(char *lev0, char *lev1, unsigned short *lowRes, unsigned short *hiRes, unsigned short *hMax, unsigned short *vMax)

{

	log("collectInformation");

	unsigned char stx;

	int pos = 0;

	unsigned short counter;

	unsigned char status;

	/*

if (!resetScanner())

  throw TException("Scanner error resetting");

*/

	if (!ESCI_command('I', false))

		throw TException("Unable to get scanner info. Is it off ?");

	unsigned long s = 4; // 4 bytes cfr Identity Data Block on ESCI Manual!!!

	std::unique_ptr<unsigned char[]=""> buffer2 = ESCI_read_data2(s);</unsigned>

	if (!buffer2 || (s != 4))

		throw TException("Error reading scanner info");

	memcpy(&stx, buffer2.get(), 1);

	memcpy(&counter, &(buffer2[2]), 2);

#ifdef SWAPIT

	counter = swapUshort(counter);

#endif

#ifdef _DEBUG

	memcpy(&status, &(buffer2[1]), 1);

	std::ostrstream os;

	os.freeze(false);

	os << "stx = " << stx << " status = " << status << " counter=" << counter << '\n' << '\0';

#endif

	s = counter;

	std::unique_ptr<unsigned char[]=""> buffer = ESCI_read_data2(s);</unsigned>

	int len = strlen((const char *)buffer.get());

	/*printf("Level %c%c", buffer[0], buffer[1]);*/

	if (len > 1) {

		*lev0 = buffer[0];

		*lev1 = buffer[1];

	}

	pos = 2;

	/* buffer[pos] contains 'R' */

	if (len < 3 || buffer[pos] != 'R') {

		*lev0 = '0';

		*lev1 = '0';

		*lowRes = 0;

		*hiRes = 0;

		*vMax = 0;

		*hMax = 0;

		throw TException("unable to get information from scanner");

	}

	*lowRes = (buffer[pos + 2] * 256) + buffer[pos + 1];

	*hiRes = *lowRes;

	while (buffer[pos] == 'R') {

		*hiRes = (buffer[pos + 2] * 256) + buffer[pos + 1];

		/*  printf("Resolution %c  %d", buffer[pos], *hiRes);*/

		pos += 3;

	}

	if (buffer[pos] != 'A') {

		*lev0 = '0';

		*lev1 = '0';

		*lowRes = 0;

		*hiRes = 0;

		*vMax = 0;

		*hMax = 0;

		throw TException("unable to get information from scanner");

	}

	*hMax = (buffer[pos + 2] * 256) + buffer[pos + 1];

	*vMax = (buffer[pos + 4] * 256) + buffer[pos + 3];

	ESCI_command('f', false);

	ESCI_readLineData2(stx, status, counter);

	if (status & FatalError)

		throw TException("Fatal error reading information from scanner");

	s = counter;

	buffer = ESCI_read_data2(s);

	//name buffer+1A

	const char *name = (const char *)(buffer.get() + 0x1A);

	if (strncmp(name, "Perfection1640", strlen("Perfection1640"))) {

		m_settingsMode = NEW_STYLE;

	} else {

		m_settingsMode = OLD_STYLE;

	}

#if 0

scsi_new_d("ESCI_extended_status");

scsi_len(42);

/* main status*/

scsi_b00(0, "push_button_supported", 0);

scsi_b11(0, "warming_up", 0);

scsi_b33(0, "adf_load_sequence", 0);  /* 1 from first sheet; 0 from last or not supp */

scsi_b44(0, "both_sides_on_adf", 0);

scsi_b55(0, "adf_installed_main_status", 0);

scsi_b66(0, "NFlatbed", 0);   /*0 if scanner is flatbed else 1 */

scsi_b77(0, "system_error", 0);

/* adf status */

scsi_b77(1, "adf_installed",0);

/*... some other info.., refer to manual if needed*/

/**/

#endif

	m_hasADF = !!(buffer[1] & 0x80);

	log("collectInformation:OK");

}

//-----------------------------------------------------------------------------

bool TScannerEpson::resetScanner()

{

	log("resetScanner");

	bool ret = ESCI_command('@', true);

	log(std::string("resetScanner: ") + (ret ? "OK" : "FAILED"));

	return ret;

}

//-----------------------------------------------------------------------------

int TScannerEpson::receive(unsigned char *buffer, int size)

{

	return m_scannerIO->receive(buffer, size);

}

int TScannerEpson::send(unsigned char *buffer, int size)

{

	return m_scannerIO->send(buffer, size);

}

int TScannerEpson::sendACK()

{

	return send(&ACK, 1);

}

bool TScannerEpson::expectACK()

{

	log("expectACK");

	unsigned char ack = NAK;

	int nb = receive(&ack, 1);

#ifdef _DEBUG

	if (ack != ACK) {

		std::ostrstream os;

		os.freeze(false);

		os << "ack fails ret = 0x" << std::hex << (int)ack << '\n' << '\0';

		TSystem::outputDebug(os.str());

	}

#endif

	log(std::string("expectACK: ") + (ack == ACK ? "ACK" : "FAILED"));

	return (ack == ACK);

}

char *TScannerEpson::ESCI_inquiry(char cmd) /* returns 0 if failed */

{

	assert(0);

	return 0;

}

bool TScannerEpson::ESCI_command(char cmd, bool checkACK)

{

	unsigned char p[2];

	p[0] = ESC;

	p[1] = cmd;

	bool status;

	int count = send(&(p[0]), 2);

	status = count == 2;

	if (checkACK)

		status = expectACK();

	return status;

}

bool TScannerEpson::ESCI_command_1b(char cmd, unsigned char p0, bool checkACK)

{

	bool status = false;

	if (ESCI_command(cmd, checkACK)) {

		unsigned char p = p0;

		status = true;

		send(&p, 1);

		if (checkACK)

			status = expectACK();

	}

	return status;

}

bool TScannerEpson::ESCI_command_2b(char cmd, unsigned char p0, unsigned char p1, bool checkACK)

{

	bool status = false;

	if (ESCI_command(cmd, checkACK)) {

		status = true;

		unsigned char p[2];

		p[0] = p0;

		p[1] = p1;

		int timeout = 30000;

		send(&(p[0]), 2);

		if (checkACK)

			status = expectACK();

	}

	return status;

}

bool TScannerEpson::ESCI_command_2w(char cmd, unsigned short p0, unsigned short p1, bool checkACK)

{

	bool status = false;

	if (ESCI_command(cmd, checkACK)) {

		status = true;

		unsigned short p[2];

		p[0] = p0;

		p[1] = p1;

		const int len = 1;

		int timeout = 30000;

		send((unsigned char *)(&(p[0])), 4);

		if (checkACK)

			status = expectACK();

	}

	return status;

}

bool TScannerEpson::ESCI_command_4w(char cmd, unsigned short p0, unsigned short p1, unsigned short p2, unsigned short p3, bool checkACK)

{

	bool status = false;

	if (ESCI_command(cmd, checkACK)) {

		status = true;

		unsigned char p[8];

		p[0] = (unsigned char)p0;

		p[1] = (unsigned char)(p0 >> 8);

		p[2] = (unsigned char)p1;

		p[3] = (unsigned char)(p1 >> 8);

		p[4] = (unsigned char)p2;

		p[5] = (unsigned char)(p2 >> 8);

		p[6] = (unsigned char)(p3);

		p[7] = (unsigned char)(p3 >> 8);

		send((unsigned char *)&(p[0]), 8);

		if (checkACK)

			status = expectACK();

	}

	return status;

}