Google Git
Sign in
cos / third_party / overlays / chromiumos-overlay / 176b6878526b462725727fd8c10d0db9d9726afb / . / media-gfx / sane-backends / files / sane-backends-1.0.32-epsonds.patch
blob: 2c666bdec19e2bb8f45062aa07bd87f5985d7662 [file] [log] [blame]
commit 1e88e1504ef77f09d49da95d393a0af09d20f7fa
Author: Ralph Little <skelband@gmail.com>
Date: Sat Jul 3 15:55:25 2021 -0700
epsonds: Merge to master
diff --git a/backend/Makefile.am b/backend/Makefile.am
index 48a1393a5..ca282e4c6 100644
--- a/backend/Makefile.am
+++ b/backend/Makefile.am
@@ -511,11 +511,20 @@ libepsonds_la_CPPFLAGS = $(AM_CPPFLAGS) -DBACKEND_NAME=epsonds
nodist_libsane_epsonds_la_SOURCES = epsonds-s.c
libsane_epsonds_la_CPPFLAGS = $(AM_CPPFLAGS) -DBACKEND_NAME=epsonds
libsane_epsonds_la_LDFLAGS = $(DIST_SANELIBS_LDFLAGS)
+
+if have_libavahi
+libsane_epsonds_la_LIBADD = $(COMMON_LIBS) libepsonds.la ../sanei/sanei_init_debug.lo ../sanei/sanei_constrain_value.lo \
+ ../sanei/sanei_config.lo ../sanei/sanei_config2.lo sane_strstatus.lo \
+ ../sanei/sanei_usb.lo ../sanei/sanei_scsi.lo \
+ ../sanei/sanei_tcp.lo ../sanei/sanei_udp.lo \
+ $(SANEI_SANEI_JPEG_LO) $(JPEG_LIBS) $(USB_LIBS) $(MATH_LIB) $(RESMGR_LIBS) $(SOCKET_LIBS) $(AVAHI_LIBS)
+else
libsane_epsonds_la_LIBADD = $(COMMON_LIBS) libepsonds.la ../sanei/sanei_init_debug.lo ../sanei/sanei_constrain_value.lo \
../sanei/sanei_config.lo ../sanei/sanei_config2.lo sane_strstatus.lo \
../sanei/sanei_usb.lo ../sanei/sanei_scsi.lo \
../sanei/sanei_tcp.lo ../sanei/sanei_udp.lo \
$(SANEI_SANEI_JPEG_LO) $(JPEG_LIBS) $(USB_LIBS) $(MATH_LIB) $(RESMGR_LIBS) $(SOCKET_LIBS)
+endif
EXTRA_DIST += epsonds.conf.in
libfujitsu_la_SOURCES = fujitsu.c fujitsu.h fujitsu-scsi.h
diff --git a/backend/epsonds-cmd.c b/backend/epsonds-cmd.c
index 5141e0765..6f0ec6487 100644
--- a/backend/epsonds-cmd.c
+++ b/backend/epsonds-cmd.c
@@ -134,6 +134,7 @@ static SANE_Status esci2_cmd(epsonds_scanner* s,
SANE_Status status;
unsigned int more;
char header[13], rbuf[64]; /* add one more byte for header buffer to correct buffer overflow issue,*/
+ char *buf;
DBG(8, "%s: %4s len %lu, payload len: %lu\n", __func__, cmd, len, plen);
@@ -151,6 +152,21 @@ static SANE_Status esci2_cmd(epsonds_scanner* s,
// send RequestBlock, request immediate response if there's no payload
status = eds_txrx(s, header, len, rbuf, (plen > 0) ? 0 : 64);
+
+ /* pointer to the token's value */
+ buf = rbuf + 12;
+ /* nrd / nrdBUSY */
+ DBG(8, "buf = %s\n",buf);
+ if (strncmp("#nrd", buf, 4) == 0) {
+ buf += 4;
+ DBG(8, "buf = %s\n",buf);
+ if (strncmp("BUSY", buf, 4) == 0) {
+ DBG(8, "device busy\n");
+ DBG(8, "SANE_STATUS:%d\n", SANE_STATUS_DEVICE_BUSY);
+ return SANE_STATUS_DEVICE_BUSY;
+ }
+ }
+
if (status != SANE_STATUS_GOOD) {
return status;
}
@@ -227,6 +243,21 @@ SANE_Status esci2_fin(epsonds_scanner *s)
DBG(5, "%s\n", __func__);
status = esci2_cmd_simple(s, "FIN x0000000", NULL);
+
+ for(int i = 0; i < 10; i++) {
+
+ if(status == SANE_STATUS_DEVICE_BUSY || status == SANE_STATUS_IO_ERROR) {
+ status = esci2_cmd_simple(s, "FIN x0000000", NULL);
+ }
+ else {
+ DBG(1, "break\n");
+ break;
+ }
+ DBG(1, "sleep(5)\n");
+ sleep(5);
+
+ }
+
s->locked = 0;
return status;
}
@@ -264,13 +295,13 @@ static char *decode_binary(char *buf, int len)
memcpy(tmp, buf, 4);
tmp[4] = '\0';
- len -= 4;
if (buf[0] != 'h')
return NULL;
hl = strtol(tmp + 1, NULL, 16);
- if (hl > len) hl = len;
+ if (hl > len)
+ hl = len;
if (hl) {
char *v = malloc(hl + 1);
@@ -313,9 +344,6 @@ static SANE_Status info_cb(void *userdata, char *token, int len)
epsonds_scanner *s = (epsonds_scanner *)userdata;
char *value;
- if (DBG_LEVEL >= 11) {
- debug_token(DBG_LEVEL, __func__, token, len);
- }
/* pointer to the token's value */
value = token + 3;
@@ -333,7 +361,6 @@ static SANE_Status info_cb(void *userdata, char *token, int len)
s->hw->model = decode_string(value, len);
s->hw->sane.model = s->hw->model;
DBG(1, " product: %s\n", s->hw->model);
- /* we will free the string later */
}
if (strncmp("VER", token, 3) == 0) {
@@ -421,6 +448,7 @@ static SANE_Status info_cb(void *userdata, char *token, int len)
int max = decode_value(value + 4 + 8, 8);
DBG(1, " ADF: area %dx%d @ 100dpi\n", min, max);
+ eds_set_adf_area(s->hw, min, max, 100);
}
if (strncmp("AMIN", value, 4) == 0) {
@@ -437,11 +465,40 @@ static SANE_Status info_cb(void *userdata, char *token, int len)
int max = decode_value(value + 4 + 8, 8);
DBG(1, " ADF: max %dx%d @ 100dpi\n", min, max);
+ }
+ }
+
+
+
+
+
+
+ if (len == 16) {
+
+ if (strncmp("AREA", value, 4) == 0) {
+
+ int min = decode_value(value + 4, 4);
+ int max = decode_value(value + 4 + 4, 8);
+
+ DBG(1, " ADF: area %dx%d @ 100dpi\n", min, max);
eds_set_adf_area(s->hw, min, max, 100);
}
+
+ if (strncmp("AMAX", value, 4) == 0) {
+
+ // d
+ int min = decode_value(value + 4, 4);
+ // i
+ int max = decode_value(value + 4 + 4, 8);
+
+ DBG(1, " ADF: max %dx%d @ 100dpi\n", min, max);
+ }
}
+
+
+
if (len == 12) {
/* RESOi0000600 */
@@ -483,6 +540,22 @@ static SANE_Status info_cb(void *userdata, char *token, int len)
}
}
+
+ if (len == 16) {
+
+ /* AREAi0000850i0001400 */
+ if (strncmp("AREA", value, 4) == 0) {
+ //d
+ int min = decode_value(value + 4, 4);
+ //i
+ int max = decode_value(value + 4 + 4, 8);
+
+ DBG(1, " FB: area %dx%d @ 100dpi\n", min, max);
+
+ eds_set_fbf_area(s->hw, min, max, 100);
+ }
+ }
+
if (len == 8) {
if (strncmp("ALGNLEFT", value, len) == 0) {
@@ -602,6 +675,7 @@ static SANE_Status capa_cb(void *userdata, char *token, int len)
if (strncmp("ADFCRP ", token, 3 + 4) == 0) {
DBG(1, " ADF: image cropping\n");
+ s->hw->adf_has_crp = 1;
}
if (strncmp("ADFFAST", token, 3 + 4) == 0) {
@@ -636,6 +710,23 @@ static SANE_Status capa_cb(void *userdata, char *token, int len)
}
}
+
+ if (strncmp("COLLIST", token, 3 + 4) == 0)
+ {
+ char *p = token + 3 + 4;
+ int count = (len - 4);
+ int readBytes = 0;
+ s->hw->has_mono = 0;
+ while (readBytes < count) {
+ if (strncmp(p, "M001", 4) == 0)
+ {
+ s->hw->has_mono = 1;
+ }
+ readBytes+=4;
+ p+=4;
+ }
+ }
+
/* RSMRANGi0000050i0000600 */
if (strncmp("RSMRANG", token, 3 + 4) == 0) {
@@ -659,17 +750,24 @@ static SANE_Status capa_cb(void *userdata, char *token, int len)
char *p = token + 3 + 4;
- if (p[0] == 'i') {
- int i;
- int count = (len - 4) / 8;
-
- for (i = 0; i < count; i++) {
+ int count = (len - 4);
+ int readBytes = 0;
+ while (readBytes < count) {
+ if(*p == 'i')
+ {
eds_add_resolution(s->hw, decode_value(p, 8));
p += 8;
+ readBytes += 8;
+ }else if(*p == 'd')
+ {
+ eds_add_resolution(s->hw, decode_value(p, 4));
+ p += 4;
+ readBytes +=4;
+ }
}
- }
+
}
return SANE_STATUS_GOOD;
@@ -684,16 +782,26 @@ SANE_Status esci2_capa(epsonds_scanner *s)
static SANE_Status stat_cb(void *userdata, char *token, int len)
{
-/*
- epsonds_scanner *s = (epsonds_scanner *)userdata;
char *value = token + 3;
-*/
+
userdata = userdata;
if (DBG_LEVEL >= 11) {
debug_token(DBG_LEVEL, __func__, token, len);
}
+ if (strncmp("ERR", token, 3) == 0) {
+ if (strncmp("ADF PE ", value, len) == 0) {
+ DBG(1, " PE : paper empty\n");
+ return SANE_STATUS_NO_DOCS;
+ }
+
+ if (strncmp("ADF OPN", value, len) == 0) {
+ DBG(1, " conver open\n");
+ return SANE_STATUS_COVER_OPEN;
+ }
+ }
+
return SANE_STATUS_GOOD;
}
@@ -742,10 +850,10 @@ static SANE_Status para_cb(void *userdata, char *token, int len)
return SANE_STATUS_GOOD;
}
-SANE_Status esci2_para(epsonds_scanner *s, char *parameters)
+SANE_Status esci2_para(epsonds_scanner *s, char *parameters, int len)
{
DBG(8, "%s: %s\n", __func__, parameters);
- return esci2_cmd(s, "PARAx0000000", 12, parameters, strlen(parameters), NULL, &para_cb);
+ return esci2_cmd(s, "PARAx0000000", 12, parameters, len, NULL, &para_cb);
}
SANE_Status esci2_mech(epsonds_scanner *s, char *parameters)
@@ -784,12 +892,105 @@ static SANE_Status img_cb(void *userdata, char *token, int len)
return SANE_STATUS_GOOD;
}
+ if (len == 12 && strncmp("pst", token, 3) == 0) {
+
+ s->dummy = decode_value(token + 3 + 4, 4);
+
+ DBG(10, "%s: pst width: %d, height: %d, dummy: %d\n",
+ __func__,
+ decode_value(token + 3, 4),
+ decode_value(token + 3 + 4 + 4, 4),
+ s->dummy);
+
+ return SANE_STATUS_GOOD;
+ }
+
+ if (len == 16 && strncmp("pst", token, 3) == 0) {
+
+ s->dummy = decode_value(token + 3 + 4, 4);
+
+ DBG(10, "%s: pst width: %d, height: %d, dummy: %d\n",
+ __func__,
+ decode_value(token + 3, 4),
+ decode_value(token + 3 + 4 + 4, 8),
+ s->dummy);
+
+ return SANE_STATUS_GOOD;
+ }
+
+ if (len == 20 && strncmp("pst", token, 3) == 0) {
+
+ s->dummy = decode_value(token + 3 + 8, 4);
+
+ DBG(10, "%s: pst width: %d, height: %d, dummy: %d\n",
+ __func__,
+ decode_value(token + 3, 8),
+ decode_value(token + 3 + 8 + 4, 8),
+ s->dummy);
+
+ return SANE_STATUS_GOOD;
+ }
+
+
+ // i0001696i0002347
if (len == 16 && strncmp("pen", token, 3) == 0) {
DBG(10, "%s: page end\n", __func__);
s->eof = 1;
+ if (s->isflatbedScan)
+ {
+ s->scanning = 0;
+ }
+ DBG(10, "%s: pen width: %d, height: %d, dummy: %d\n",
+ __func__,
+ decode_value(token + 3, 8),
+ decode_value(token + 3 + 8, 8),
+ s->dummy);
+ s->width_temp = decode_value(token + 3, 8);
+ s->height_temp = decode_value(token + 3 + 8, 8);
return SANE_STATUS_EOF;
}
+ // d696i0002347
+ if (len == 12 && strncmp("pen", token, 3) == 0) {
+ DBG(10, "%s: page end\n", __func__);
+ s->eof = 1;
+ if (s->isflatbedScan)
+ {
+ s->scanning = 0;
+ }
+
+ DBG(10, "%s: pen width: %d, height: %d, dummy: %d\n",
+ __func__,
+ decode_value(token + 3, 4),
+ decode_value(token + 3 + 4, 8),
+ s->dummy);
+
+ s->width_temp = decode_value(token + 3, 4);
+ s->height_temp = decode_value(token + 3 + 4, 8);
+ return SANE_STATUS_EOF;
+ }
+
+ // d696d2347
+ if (len == 8 && strncmp("pen", token, 3) == 0) {
+ DBG(10, "%s: page end\n", __func__);
+ s->eof = 1;
+ if (s->isflatbedScan)
+ {
+ s->scanning = 0;
+ }
+ DBG(10, "%s: pen width: %d, height: %d, dummy: %d\n",
+ __func__,
+ decode_value(token + 3, 4),
+ decode_value(token + 3 + 4, 4),
+ s->dummy);
+
+ s->width_temp = decode_value(token + 3, 4);
+ s->height_temp = decode_value(token + 3 + 4, 4);
+
+ return SANE_STATUS_EOF;
+ }
+
+
/* typIMGA or typIMGB */
if (len == 4 && strncmp("typ", token, 3) == 0) {
@@ -807,6 +1008,7 @@ static SANE_Status img_cb(void *userdata, char *token, int len)
char *cause = token + 3 + 4; /* OPN, PJ, PE, ERR, LTF, LOCK, DFED, DTCL, AUT, PERM */
s->scanning = 0;
+ s->scanEnd = 1;
DBG(1, "%s: error on option %3.3s, cause %4.4s\n",
__func__, option, cause);
@@ -831,6 +1033,8 @@ static SANE_Status img_cb(void *userdata, char *token, int len)
}
if (len == 4 && strncmp("lftd000", token, 3 + 4) == 0) {
+ DBG(1, "%s:lft ok\n", __func__);
+ s->scanEnd = 1;
s->scanning = 0;
}
@@ -846,6 +1050,8 @@ esci2_img(struct epsonds_scanner *s, SANE_Int *length)
unsigned int more;
ssize_t read;
+ DBG(15, "esci2_img start\n");
+
*length = 0;
if (s->canceling)
@@ -856,6 +1062,7 @@ esci2_img(struct epsonds_scanner *s, SANE_Int *length)
if (status != SANE_STATUS_GOOD) {
return status;
}
+ DBG(15, "request img OK\n");
/* receive DataHeaderBlock */
memset(s->buf, 0x00, 64);
@@ -863,6 +1070,7 @@ esci2_img(struct epsonds_scanner *s, SANE_Int *length)
if (status != SANE_STATUS_GOOD) {
return status;
}
+ DBG(15, "receive img OK\n");
/* check if we need to read any image data */
more = 0;
@@ -873,6 +1081,17 @@ esci2_img(struct epsonds_scanner *s, SANE_Int *length)
/* this handles eof and errors */
parse_status = esci2_parse_block((char *)s->buf + 12, 64 - 12, s, &img_cb);
+ if (s->backside)
+ {
+ s->width_back = s->width_temp;
+ s->height_back = s->height_temp;
+ }else{
+ s->width_front = s->width_temp;
+ s->height_front = s->height_temp;
+
+ }
+
+
/* no more data? return using the status of the esci2_parse_block
* call, which might hold other error conditions.
*/
@@ -884,7 +1103,6 @@ esci2_img(struct epsonds_scanner *s, SANE_Int *length)
if (more > s->bsz) {
return SANE_STATUS_IO_ERROR;
}
-
/* ALWAYS read image data */
if (s->hw->connection == SANE_EPSONDS_NET) {
epsonds_net_request_read(s, more);
diff --git a/backend/epsonds-cmd.h b/backend/epsonds-cmd.h
index 973609a03..2bd19dbb3 100644
--- a/backend/epsonds-cmd.h
+++ b/backend/epsonds-cmd.h
@@ -20,7 +20,7 @@ SANE_Status esci2_can(epsonds_scanner *s);
SANE_Status esci2_capa(epsonds_scanner *s);
SANE_Status esci2_resa(epsonds_scanner *s);
SANE_Status esci2_stat(epsonds_scanner *s);
-SANE_Status esci2_para(epsonds_scanner *s, char *parameters);
+SANE_Status esci2_para(epsonds_scanner *s, char *parameters, int len);
SANE_Status esci2_mech(epsonds_scanner *s, char *parameters);
SANE_Status esci2_trdt(epsonds_scanner *s);
SANE_Status esci2_img(struct epsonds_scanner *s, SANE_Int *length) ;
diff --git a/backend/epsonds-jpeg.c b/backend/epsonds-jpeg.c
index 244f442ec..99ca53af2 100644
--- a/backend/epsonds-jpeg.c
+++ b/backend/epsonds-jpeg.c
@@ -20,19 +20,39 @@
#include "epsonds.h"
#include "epsonds-jpeg.h"
#include "epsonds-ops.h"
+#include <setjmp.h>
-#define min(A,B) (((A)<(B)) ? (A) : (B))
+struct my_error_mgr {
+ struct jpeg_error_mgr pub;
+ jmp_buf setjmp_buffer;
+};
+
+typedef struct my_error_mgr * my_error_ptr;
+
+
+METHODDEF(void) my_error_exit (j_common_ptr cinfo)
+{
+
+ char buffer[JMSG_LENGTH_MAX];
+ (*cinfo->err->format_message) (cinfo, buffer);
+
+ DBG(10,"Jpeg decode error [%s]", buffer);
+}
+
+LOCAL(struct jpeg_error_mgr *) jpeg_custom_error (struct my_error_mgr * err)
+{
+
+ struct jpeg_error_mgr* pRet = jpeg_std_error(&(err->pub));
+ err->pub.error_exit = my_error_exit;
+
+ return pRet;
+}
typedef struct
{
struct jpeg_source_mgr pub;
-
- epsonds_scanner *s;
JOCTET *buffer;
-
- SANE_Byte *linebuffer;
- SANE_Int linebuffer_size;
- SANE_Int linebuffer_index;
+ int length;
}
epsonds_src_mgr;
@@ -50,22 +70,11 @@ METHODDEF(boolean)
jpeg_fill_input_buffer(j_decompress_ptr cinfo)
{
epsonds_src_mgr *src = (epsonds_src_mgr *)cinfo->src;
- int avail, size;
-
- /* read from the scanner or the ring buffer */
-
- avail = eds_ring_avail(src->s->current);
- if (avail == 0) {
- return FALSE;
- }
-
/* read from scanner if no data? */
- size = min(1024, avail);
-
- eds_ring_read(src->s->current, src->buffer, size);
src->pub.next_input_byte = src->buffer;
- src->pub.bytes_in_buffer = size;
+ src->pub.bytes_in_buffer = src->length;
+ DBG(18, "reading from ring buffer, %d left\n", src->length);
return TRUE;
}
@@ -87,140 +96,140 @@ jpeg_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
}
}
-SANE_Status
-eds_jpeg_start(epsonds_scanner *s)
+
+void eds_decode_jpeg(epsonds_scanner*s, SANE_Byte *data, SANE_Int size, ring_buffer* ringBuffer, SANE_Int isBackSide, SANE_Int needToConvertBW)
{
- epsonds_src_mgr *src;
+ struct jpeg_decompress_struct jpeg_cinfo;
+ struct my_error_mgr jpeg_err;
- s->jpeg_cinfo.err = jpeg_std_error(&s->jpeg_err);
+ {
+ epsonds_src_mgr *src;
- jpeg_create_decompress(&s->jpeg_cinfo);
+ jpeg_cinfo.err = jpeg_custom_error(&jpeg_err);
- s->jpeg_cinfo.src = (struct jpeg_source_mgr *)(*s->jpeg_cinfo.mem->alloc_small)((j_common_ptr)&s->jpeg_cinfo,
- JPOOL_PERMANENT, sizeof(epsonds_src_mgr));
+ jpeg_create_decompress(&jpeg_cinfo);
- memset(s->jpeg_cinfo.src, 0x00, sizeof(epsonds_src_mgr));
+ jpeg_cinfo.src = (struct jpeg_source_mgr *)(*jpeg_cinfo.mem->alloc_small)((j_common_ptr)&jpeg_cinfo,
+ JPOOL_PERMANENT, sizeof(epsonds_src_mgr));
- src = (epsonds_src_mgr *)s->jpeg_cinfo.src;
- src->s = s;
+ memset(jpeg_cinfo.src, 0x00, sizeof(epsonds_src_mgr));
+;
+ src = (epsonds_src_mgr *)jpeg_cinfo.src;
+ src->pub.init_source = jpeg_init_source;
+ src->pub.fill_input_buffer = jpeg_fill_input_buffer;
+ src->pub.skip_input_data = jpeg_skip_input_data;
+ src->pub.resync_to_restart = jpeg_resync_to_restart;
+ src->pub.term_source = jpeg_term_source;
+ src->pub.bytes_in_buffer = 0;
+ src->pub.next_input_byte = NULL;
+ src->buffer = (JOCTET*)data;
+ src->length = size;
+ }
+ {
+ if (jpeg_read_header(&jpeg_cinfo, TRUE)) {
- src->buffer = (JOCTET *)(*s->jpeg_cinfo.mem->alloc_small)((j_common_ptr)&s->jpeg_cinfo,
- JPOOL_PERMANENT,
- 1024 * sizeof(JOCTET));
+ if (jpeg_start_decompress(&jpeg_cinfo)) {
- src->pub.init_source = jpeg_init_source;
- src->pub.fill_input_buffer = jpeg_fill_input_buffer;
- src->pub.skip_input_data = jpeg_skip_input_data;
- src->pub.resync_to_restart = jpeg_resync_to_restart;
- src->pub.term_source = jpeg_term_source;
- src->pub.bytes_in_buffer = 0;
- src->pub.next_input_byte = NULL;
-
- s->jpeg_header_seen = 0;
-
- return SANE_STATUS_GOOD;
-}
-
-SANE_Status
-eds_jpeg_read_header(epsonds_scanner *s)
-{
- epsonds_src_mgr *src = (epsonds_src_mgr *)s->jpeg_cinfo.src;
-
- if (jpeg_read_header(&s->jpeg_cinfo, TRUE)) {
-
- s->jdst = sanei_jpeg_jinit_write_ppm(&s->jpeg_cinfo);
-
- if (jpeg_start_decompress(&s->jpeg_cinfo)) {
-
- int size;
-
- DBG(3, "%s: w: %d, h: %d, components: %d\n",
+ DBG(10,"%s: w: %d, h: %d, components: %d\n",
__func__,
- s->jpeg_cinfo.output_width, s->jpeg_cinfo.output_height,
- s->jpeg_cinfo.output_components);
-
- size = s->jpeg_cinfo.output_width * s->jpeg_cinfo.output_components * 1;
-
- src->linebuffer = (*s->jpeg_cinfo.mem->alloc_large)((j_common_ptr)&s->jpeg_cinfo,
- JPOOL_PERMANENT, size);
-
- src->linebuffer_size = 0;
- src->linebuffer_index = 0;
-
- s->jpeg_header_seen = 1;
-
- return SANE_STATUS_GOOD;
-
- } else {
- DBG(0, "%s: decompression failed\n", __func__);
- return SANE_STATUS_IO_ERROR;
+ jpeg_cinfo.output_width, jpeg_cinfo.output_height,
+ jpeg_cinfo.output_components);
}
- } else {
- DBG(0, "%s: cannot read JPEG header\n", __func__);
- return SANE_STATUS_IO_ERROR;
- }
-}
-
-void
-eds_jpeg_finish(epsonds_scanner *s)
-{
- jpeg_destroy_decompress(&s->jpeg_cinfo);
-}
-
-void
-eds_jpeg_read(SANE_Handle handle, SANE_Byte *data,
- SANE_Int max_length, SANE_Int *length)
-{
- epsonds_scanner *s = handle;
-
- struct jpeg_decompress_struct cinfo = s->jpeg_cinfo;
- epsonds_src_mgr *src = (epsonds_src_mgr *)s->jpeg_cinfo.src;
-
- int l;
-
- *length = 0;
-
- /* copy from line buffer if available */
- if (src->linebuffer_size && src->linebuffer_index < src->linebuffer_size) {
-
- *length = src->linebuffer_size - src->linebuffer_index;
-
- if (*length > max_length)
- *length = max_length;
-
- memcpy(data, src->linebuffer + src->linebuffer_index, *length);
- src->linebuffer_index += *length;
-
- return;
- }
-
- if (cinfo.output_scanline >= cinfo.output_height) {
- *length = 0;
- return;
- }
-
- /* scanlines of decompressed data will be in s->jdst->buffer
- * only one line at time is supported
- */
-
- l = jpeg_read_scanlines(&cinfo, s->jdst->buffer, 1);
- if (l == 0) {
- return;
- }
-
- /* from s->jdst->buffer to linebuffer
- * linebuffer holds width * bytesperpixel
- */
-
- (*s->jdst->put_pixel_rows)(&cinfo, s->jdst, 1, (char *)src->linebuffer);
-
- *length = cinfo.output_width * cinfo.output_components * 1;
- src->linebuffer_size = *length;
- src->linebuffer_index = 0;
-
- if (*length > max_length)
- *length = max_length;
-
- memcpy(data, src->linebuffer + src->linebuffer_index, *length);
- src->linebuffer_index += *length;
+ }
+ }
+ {
+ int sum = 0;
+ int bufSize = jpeg_cinfo.output_width * jpeg_cinfo.output_components;
+
+ int monoBufSize = (jpeg_cinfo.output_width + 7)/8;
+
+ JSAMPARRAY scanlines = (jpeg_cinfo.mem->alloc_sarray)((j_common_ptr)&jpeg_cinfo, JPOOL_IMAGE, bufSize, 1);
+ while (jpeg_cinfo.output_scanline < jpeg_cinfo.output_height) {
+ int l = jpeg_read_scanlines(&jpeg_cinfo, scanlines, 1);
+ if (l == 0) {
+ break;
+ }
+ sum += l;
+
+ if (needToConvertBW)
+ {
+ SANE_Byte* bytes = scanlines[0];
+
+ SANE_Int imgPos = 0;
+
+ for (int i = 0; i < monoBufSize; i++)
+ {
+ SANE_Byte outByte = 0;
+
+ for(SANE_Int bitIndex = 0; bitIndex < 8 && imgPos < bufSize; bitIndex++) {
+ //DBG(10,"bytes[imgPos] = %d\n", bytes[imgPos]);
+
+ if(bytes[imgPos] >= 110) {
+ SANE_Byte bit = 7 - (bitIndex % 8);
+ outByte |= (1<< bit);
+ }
+ imgPos += 1;
+ }
+ //DBG(10,"outByte = %d\n", outByte);
+ eds_ring_write(ringBuffer, &outByte, 1);
+ }
+ }
+ else
+ {
+ eds_ring_write(ringBuffer, scanlines[0], bufSize);
+ }
+
+ // decode until valida data
+ if (isBackSide)
+ {
+ if (sum >= s->height_back)
+ {
+ break;
+ }
+ }else
+ {
+ if (sum >= s->height_front)
+ {
+ break;
+ }
+ }
+ }
+ DBG(10,"decodded lines = %d\n", sum);
+
+ // abandon unncessary data
+ if ((JDIMENSION)sum < jpeg_cinfo.output_height)
+ {
+ // unncessary data
+ while(1)
+ {
+ int l = jpeg_read_scanlines(&jpeg_cinfo, scanlines, 1);
+ if (l == 0)
+ {
+ break;
+ }
+ }
+ }
+
+ // if not auto crop mode padding to lines
+ if (s->val[OPT_ADF_CRP].w == 0)
+ {
+ unsigned char* padding = malloc(s->params.bytes_per_line);
+ memset(padding, 255, s->params.bytes_per_line);
+ DBG(10,"padding data lines = %d to %d pa \n", sum, s->params.lines);
+
+ while(sum < s->params.lines)
+ {
+ eds_ring_write(ringBuffer, padding, bufSize);
+ sum++;
+ }
+
+ free(padding);
+ padding = NULL;
+ }
+ }
+ {
+ jpeg_finish_decompress(&jpeg_cinfo);
+ jpeg_destroy_decompress(&jpeg_cinfo);
+ }
+ return;
}
diff --git a/backend/epsonds-jpeg.h b/backend/epsonds-jpeg.h
index a804dec9b..42f542d33 100644
--- a/backend/epsonds-jpeg.h
+++ b/backend/epsonds-jpeg.h
@@ -10,8 +10,4 @@
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, version 2.
*/
-
-SANE_Status eds_jpeg_start(epsonds_scanner *s);
-void eds_jpeg_finish(epsonds_scanner *s);
-SANE_Status eds_jpeg_read_header(epsonds_scanner *s);
-void eds_jpeg_read(SANE_Handle handle, SANE_Byte *data, SANE_Int max_length, SANE_Int *length);
+void eds_decode_jpeg(epsonds_scanner*s, SANE_Byte *data, SANE_Int size, ring_buffer* ringBuffer, SANE_Int isBackSide, SANE_Int needToConvertBW);
diff --git a/backend/epsonds-net.c b/backend/epsonds-net.c
index 3c8be2931..4f4c1e267 100644
--- a/backend/epsonds-net.c
+++ b/backend/epsonds-net.c
@@ -32,10 +32,19 @@
#include "sane/sanei_debug.h"
+
static ssize_t
epsonds_net_read_raw(epsonds_scanner *s, unsigned char *buf, ssize_t wanted,
SANE_Status *status)
{
+ DBG(15, "%s: wanted: %ld\n", __func__, wanted);
+
+ if (wanted == 0)
+ {
+ *status = SANE_STATUS_GOOD;
+ return 0;
+ }
+
int ready;
ssize_t read = -1;
fd_set readable;
@@ -284,3 +293,228 @@ epsonds_net_unlock(struct epsonds_scanner *s)
/* epsonds_net_read(s, buf, 1, &status); */
return status;
}
+#if WITH_AVAHI
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <avahi-client/lookup.h>
+#include <avahi-common/error.h>
+#include <avahi-common/simple-watch.h>
+#include <sys/time.h>
+#include <errno.h>
+
+static AvahiSimplePoll *simple_poll = NULL;
+
+static struct timeval borowseEndTime;
+
+static int resolvedCount = 0;
+static int browsedCount = 0;
+static int waitResolver = 0;
+
+typedef struct {
+ AvahiClient* client;
+ Device_Found_CallBack callBack;
+}EDSAvahiUserData;
+
+static int my_avahi_simple_poll_loop(AvahiSimplePoll *s) {
+ struct timeval currentTime;
+
+ for (;;)
+ {
+ int r = avahi_simple_poll_iterate(s, 1);
+ if (r != 0)
+ {
+ if (r >= 0 || errno != EINTR)
+ {
+ DBG(10, "my_avahi_simple_poll_loop end\n");
+ return r;
+ }
+ }
+
+ if (waitResolver) {
+ gettimeofday(&currentTime, NULL);
+
+ if ((currentTime.tv_sec - borowseEndTime.tv_sec) >= 3)
+ {
+ avahi_simple_poll_quit(simple_poll);
+ DBG(10, "resolve timeout\n");
+ return 0;
+ }
+ }
+ }
+}
+
+static void
+epsonds_resolve_callback(AvahiServiceResolver *r, AVAHI_GCC_UNUSED AvahiIfIndex interface,
+ AVAHI_GCC_UNUSED AvahiProtocol protocol,
+ AvahiResolverEvent event, const char *name,
+ const char *type,
+ const char *domain,
+ const char *host_name,
+ const AvahiAddress *address, uint16_t port, AvahiStringList *txt,
+ AvahiLookupResultFlags flags,
+ void *userdata)
+{
+ // unused parameter
+ (void)r;
+ (void)type;
+ (void)domain;
+ (void)host_name;
+ (void)port;
+ (void)flags;
+ EDSAvahiUserData* data = userdata;
+ char ipAddr[AVAHI_ADDRESS_STR_MAX];
+
+ DBG(10, "epsonds_searchDevices resolve_callback\n");
+
+
+ resolvedCount++;
+
+ switch (event) {
+ case AVAHI_RESOLVER_FAILURE:
+ break;
+ case AVAHI_RESOLVER_FOUND:
+ avahi_address_snprint(ipAddr, sizeof(ipAddr), address);
+ DBG(10, "epsonds_searchDevices name = %s \n", name);
+ if (strlen(name) > 7)
+ {
+ if (strncmp(name, "EPSON", 5) == 0)
+ {
+ while(txt != NULL)
+ {
+ char* text = (char*)avahi_string_list_get_text(txt);
+ DBG(10, "avahi string = %s\n", text);
+
+ if (strlen(text) > 4 && strncmp(text, "mdl=", 4) == 0)
+ {
+ if (data->callBack)
+ {
+ data->callBack(&text[4], ipAddr);
+ break;
+ }
+ }
+ txt = avahi_string_list_get_next(txt);
+ }
+
+ }
+ }
+ break;
+ }
+}
+
+static void
+browse_callback(AvahiServiceBrowser *b, AvahiIfIndex interface,
+ AvahiProtocol protocol, AvahiBrowserEvent event,
+ const char *name, const char *type,
+ const char *domain,
+ AvahiLookupResultFlags flags,
+ void* userdata)
+{
+ DBG(10, "browse_callback event = %d\n", event);
+
+ //unused parameter
+ (void)b;
+ (void)flags;
+
+ EDSAvahiUserData *data = userdata;
+ switch (event) {
+ case AVAHI_BROWSER_FAILURE:
+ avahi_simple_poll_quit(simple_poll);
+ return;
+ case AVAHI_BROWSER_NEW:
+ DBG(10, "browse_callback name = %s\n", name);
+ browsedCount++;
+ if (!(avahi_service_resolver_new(data->client, interface, protocol, name,
+ type, domain,
+ AVAHI_PROTO_UNSPEC, 0,
+ epsonds_resolve_callback, data)))
+ {
+ DBG(10, "avahi_service_resolver_new fails\n");
+ break;
+ }
+ case AVAHI_BROWSER_REMOVE:
+ break;
+ case AVAHI_BROWSER_ALL_FOR_NOW:
+ DBG(10, "AVAHI_BROWSER_ALL_FOR_NOW\n");
+ gettimeofday(&borowseEndTime, NULL);
+
+ if (browsedCount > resolvedCount)
+ {
+ DBG(10, "WAIT RESOLVER\n");
+ waitResolver = 1;
+ }else{
+ DBG(10, "QUIT POLL\n");
+ avahi_simple_poll_quit(simple_poll);
+ }
+ break;
+ case AVAHI_BROWSER_CACHE_EXHAUSTED:
+ DBG(10, "AVAHI_BROWSER_CACHE_EXHAUSTED\n");
+ break;
+ }
+}
+
+static void
+client_callback(AvahiClient *c, AvahiClientState state,
+ AVAHI_GCC_UNUSED void *userdata)
+{
+ assert(c);
+ if (state == AVAHI_CLIENT_FAILURE)
+ avahi_simple_poll_quit(simple_poll);
+}
+
+SANE_Status epsonds_searchDevices(Device_Found_CallBack deviceFoundCallBack)
+{
+ int result = SANE_STATUS_GOOD;
+
+ AvahiClient *client = NULL;
+ AvahiServiceBrowser *sb = NULL;
+
+ EDSAvahiUserData data;
+
+ resolvedCount = 0;
+ browsedCount = 0;
+ waitResolver = 0;
+
+
+ int error = 0;
+ DBG(10, "epsonds_searchDevices\n");
+
+ if (!(simple_poll = avahi_simple_poll_new())) {
+ DBG(10, "avahi_simple_poll_new failed\n");
+ result = SANE_STATUS_INVAL;
+ goto fail;
+ }
+ client = avahi_client_new(avahi_simple_poll_get(simple_poll), 0,
+ client_callback, NULL, &error);
+ if (!client) {
+ DBG(10, "avahi_client_new failed %s\n", avahi_strerror(error));
+ result = SANE_STATUS_INVAL;
+ goto fail;
+ }
+ data.client = client;
+ data.callBack = deviceFoundCallBack;
+
+ if (!(sb = avahi_service_browser_new(client, AVAHI_IF_UNSPEC,
+ AVAHI_PROTO_UNSPEC, "_scanner._tcp",
+ NULL, 0, browse_callback, &data))) {
+ DBG(10, "avahi_service_browser_new failed: %s\n",
+ avahi_strerror(avahi_client_errno(client)));
+ result = SANE_STATUS_INVAL;
+ goto fail;
+ }
+ my_avahi_simple_poll_loop(simple_poll);
+fail:
+ if (sb)
+ avahi_service_browser_free(sb);
+ if (client)
+ avahi_client_free(client);
+ if (simple_poll)
+ avahi_simple_poll_free(simple_poll);
+
+ DBG(10, "epsonds_searchDevices fin\n");
+
+ return result;
+}
+#endif
diff --git a/backend/epsonds-net.h b/backend/epsonds-net.h
index 107301bdc..2431c3594 100644
--- a/backend/epsonds-net.h
+++ b/backend/epsonds-net.h
@@ -4,6 +4,8 @@
#include <sys/types.h>
#include "../include/sane/sane.h"
+typedef void (*Device_Found_CallBack) (const char* name, const char* ip);
+
extern ssize_t epsonds_net_read(struct epsonds_scanner *s, unsigned char *buf, ssize_t buf_size,
SANE_Status *status);
extern size_t epsonds_net_write(struct epsonds_scanner *s, unsigned int cmd, const unsigned char *buf,
@@ -13,4 +15,8 @@ extern SANE_Status epsonds_net_lock(struct epsonds_scanner *s);
extern SANE_Status epsonds_net_unlock(struct epsonds_scanner *s);
extern SANE_Status epsonds_net_request_read(epsonds_scanner *s, size_t len);
+#if WITH_AVAHI
+extern SANE_Status epsonds_searchDevices(Device_Found_CallBack deviceFoundCallBack);
+#endif
+
#endif
diff --git a/backend/epsonds-ops.c b/backend/epsonds-ops.c
index 8b9d11586..56194c428 100644
--- a/backend/epsonds-ops.c
+++ b/backend/epsonds-ops.c
@@ -28,10 +28,9 @@
extern struct mode_param mode_params[];
/* Define the different scan sources */
-
-#define FBF_STR SANE_I18N("Flatbed")
-#define TPU_STR SANE_I18N("Transparency Unit")
-#define ADF_STR SANE_I18N("Automatic Document Feeder")
+#define STRING_FLATBED SANE_I18N("Flatbed")
+#define STRING_ADFFRONT SANE_I18N("ADF Front")
+#define STRING_ADFDUPLEX SANE_I18N("ADF Duplex")
extern SANE_String_Const source_list[];
@@ -53,10 +52,13 @@ eds_dev_post_init(struct epsonds_device *dev)
DBG(10, "%s\n", __func__);
if (dev->has_fb)
- *source_list_add++ = FBF_STR;
+ *source_list_add++ = STRING_FLATBED;
if (dev->has_adf)
- *source_list_add++ = ADF_STR;
+ *source_list_add++ = STRING_ADFFRONT;
+
+ if (dev->adf_is_duplex)
+ *source_list_add++ = STRING_ADFDUPLEX;
if (source_list[0] == 0
|| (dev->res_list[0] == 0 && dev->dpi_range.min == 0)
@@ -209,8 +211,6 @@ eds_init_parameters(epsonds_scanner *s)
memset(&s->params, 0, sizeof(SANE_Parameters));
- s->dummy = 0;
-
/* setup depth according to our mode table */
if (mode_params[s->val[OPT_MODE].w].depth == 1)
s->params.depth = 1;
@@ -314,6 +314,7 @@ eds_init_parameters(epsonds_scanner *s)
return SANE_STATUS_GOOD;
}
+#define min(A,B) (((A)<(B)) ? (A) : (B))
void
eds_copy_image_from_ring(epsonds_scanner *s, SANE_Byte *data, SANE_Int max_length,
@@ -322,17 +323,13 @@ eds_copy_image_from_ring(epsonds_scanner *s, SANE_Byte *data, SANE_Int max_lengt
int lines, available;
int hw_line_size = (s->params.bytes_per_line + s->dummy);
- /* trim max_length to a multiple of hw_line_size */
- max_length -= (max_length % hw_line_size);
-
- /* check available data */
available = eds_ring_avail(s->current);
if (max_length > available)
max_length = available;
- lines = max_length / hw_line_size;
+ lines = min(max_length / s->params.bytes_per_line, available / hw_line_size);
- DBG(18, "copying %d lines (%d, %d)\n", lines, s->params.bytes_per_line, s->dummy);
+ DBG(18, "copying %d lines (%d, %d, %d)\n", lines, s->params.bytes_per_line, s->dummy, s->params.depth);
/* need more data? */
if (lines == 0) {
@@ -490,3 +487,12 @@ void eds_ring_flush(ring_buffer *ring)
{
eds_ring_skip(ring, ring->fill);
}
+
+void eds_ring_destory(ring_buffer *ring)
+{
+ if (ring->ring)
+ {
+ free(ring->ring);
+ ring->ring = NULL;
+ }
+}
diff --git a/backend/epsonds-ops.h b/backend/epsonds-ops.h
index fe503d60d..108d5444b 100644
--- a/backend/epsonds-ops.h
+++ b/backend/epsonds-ops.h
@@ -38,3 +38,4 @@ extern SANE_Int eds_ring_read(ring_buffer *ring, SANE_Byte *buf, SANE_Int size);
extern SANE_Int eds_ring_skip(ring_buffer *ring, SANE_Int size);
extern SANE_Int eds_ring_avail(ring_buffer *ring);
extern void eds_ring_flush(ring_buffer *ring) ;
+extern void eds_ring_destory(ring_buffer *ring) ;
diff --git a/backend/epsonds-usb.c b/backend/epsonds-usb.c
index c7e514cb7..dacfd5fa1 100644
--- a/backend/epsonds-usb.c
+++ b/backend/epsonds-usb.c
@@ -12,22 +12,3 @@
*/
#include "epsonds-usb.h"
-
-SANE_Word epsonds_usb_product_ids[] = {
- 0x0145, /* DS-5500, DS-6500, DS-7500 */
- 0x0146, /* DS-50000, DS-60000, DS-70000 */
- 0x014c, /* DS-510 */
- 0x014d, /* DS-560 */
- 0x0150, /* DS-40 */
- 0x0152, /* DS-760, DS-860 */
- 0x0154, /* DS-520 */
- 0x08bc, /* PX-M7050 Series, WF-8510/8590 Series */
- 0x08cc, /* PX-M7050FX Series, WF-R8590 Series */
- 0 /* last entry - this is used for devices that are specified
- in the config file as "usb <vendor> <product>" */
-};
-
-int epsonds_get_number_of_ids(void)
-{
- return sizeof (epsonds_usb_product_ids) / sizeof (SANE_Word);
-}
diff --git a/backend/epsonds-usb.h b/backend/epsonds-usb.h
index 96c77b5b6..9baab701e 100644
--- a/backend/epsonds-usb.h
+++ b/backend/epsonds-usb.h
@@ -18,7 +18,4 @@
#define SANE_EPSONDS_VENDOR_ID (0x4b8)
-extern SANE_Word epsonds_usb_product_ids[];
-extern int epsonds_get_number_of_ids(void);
-
#endif
diff --git a/backend/epsonds.c b/backend/epsonds.c
index 1a7f953d0..06721c3d0 100644
--- a/backend/epsonds.c
+++ b/backend/epsonds.c
@@ -50,6 +50,7 @@
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
+#include <math.h>
#include "sane/saneopts.h"
#include "sane/sanei_config.h"
@@ -64,7 +65,8 @@
#include "epsonds-jpeg.h"
#include "epsonds-net.h"
-
+static SANE_Status
+setvalue(SANE_Handle handle, SANE_Int option, void *value, SANE_Int *info);
/*
* Definition of the mode_param struct, that is used to
* specify the valid parameters for the different scan modes.
@@ -72,6 +74,1231 @@
* The depth variable gets updated when the bit depth is modified.
*/
+
+static unsigned char LUT[][256] =
+{
+ {// 0
+ 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
+ 0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
+ 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
+ 0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
+ 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
+ 0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
+ 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
+ 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
+ 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
+ 0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
+ 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
+ 0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
+ 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
+ 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
+ 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
+ 0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
+ 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
+ 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
+ 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
+ 0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
+ 0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
+ 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
+ 0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
+ 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
+ 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
+ 0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
+ 0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
+ 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
+ 0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
+ },
+ { // 1
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x06,0x07,0x09,0x0B,0x0D,
+ 0x10,0x12,0x14,0x17,0x19,0x1B,0x1E,0x20,
+ 0x22,0x24,0x26,0x28,0x2A,0x2C,0x2E,0x30,
+ 0x32,0x33,0x35,0x37,0x39,0x3B,0x3C,0x3E,
+ 0x40,0x41,0x43,0x45,0x46,0x48,0x4A,0x4B,
+ 0x4D,0x4F,0x50,0x52,0x53,0x55,0x57,0x58,
+ 0x5A,0x5B,0x5D,0x5E,0x60,0x61,0x63,0x64,
+ 0x66,0x67,0x69,0x6A,0x6C,0x6D,0x6F,0x70,
+ 0x71,0x73,0x74,0x76,0x77,0x79,0x7A,0x7B,
+ 0x7D,0x7E,0x7F,0x81,0x82,0x84,0x85,0x86,
+ 0x88,0x89,0x8A,0x8C,0x8D,0x8E,0x90,0x91,
+ 0x92,0x94,0x95,0x96,0x98,0x99,0x9A,0x9C,
+ 0x9D,0x9E,0xA0,0xA1,0xA2,0xA3,0xA5,0xA6,
+ 0xA7,0xA8,0xAA,0xAB,0xAC,0xAE,0xAF,0xB0,
+ 0xB1,0xB3,0xB4,0xB5,0xB6,0xB8,0xB9,0xBA,
+ 0xBB,0xBC,0xBE,0xBF,0xC0,0xC1,0xC3,0xC4,
+ 0xC5,0xC6,0xC7,0xC9,0xCA,0xCB,0xCC,0xCD,
+ 0xCF,0xD0,0xD1,0xD2,0xD3,0xD5,0xD6,0xD7,
+ 0xD8,0xD9,0xDA,0xDC,0xDD,0xDE,0xDF,0xE0,
+ 0xE1,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,
+ 0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF3,
+ 0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFB,0xFC,
+ 0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
+ },
+ { // 2
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x05,0x07,0x08,0x0A,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x16,0x19,0x1B,
+ 0x1D,0x1F,0x21,0x23,0x25,0x27,0x28,0x2A,
+ 0x2C,0x2E,0x30,0x32,0x33,0x35,0x37,0x39,
+ 0x3A,0x3C,0x3E,0x40,0x41,0x43,0x45,0x46,
+ 0x48,0x4A,0x4B,0x4D,0x4F,0x50,0x52,0x53,
+ 0x55,0x57,0x58,0x5A,0x5B,0x5D,0x5F,0x60,
+ 0x62,0x63,0x65,0x66,0x68,0x69,0x6B,0x6C,
+ 0x6E,0x6F,0x71,0x72,0x74,0x75,0x77,0x78,
+ 0x7A,0x7B,0x7D,0x7E,0x80,0x81,0x83,0x84,
+ 0x86,0x87,0x88,0x8A,0x8B,0x8D,0x8E,0x90,
+ 0x91,0x92,0x94,0x95,0x97,0x98,0x99,0x9B,
+ 0x9C,0x9E,0x9F,0xA0,0xA2,0xA3,0xA5,0xA7,
+ 0xA9,0xAA,0xAB,0xAD,0xAE,0xB0,0xB1,0xB2,
+ 0xB4,0xB5,0xB6,0xB8,0xB9,0xBA,0xBC,0xBD,
+ 0xBE,0xC0,0xC1,0xC2,0xC4,0xC5,0xC6,0xC8,
+ 0xC9,0xCA,0xCC,0xCD,0xCE,0xD0,0xD1,0xD2,
+ 0xD4,0xD5,0xD6,0xD7,0xD9,0xDA,0xDB,0xDD,
+ 0xDE,0xDF,0xE1,0xE2,0xE3,0xE4,0xE6,0xE7,
+ 0xE8,0xE9,0xEB,0xEC,0xED,0xEF,0xF0,0xF1,
+ 0xF2,0xF4,0xF5,0xF6,0xF7,0xF9,0xFA,0xFB,
+ 0xFC,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ { // 3
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x07,
+ 0x08,0x0A,0x0C,0x0E,0x10,0x12,0x14,0x16,
+ 0x18,0x1A,0x1C,0x1E,0x20,0x22,0x24,0x26,
+ 0x28,0x2A,0x2B,0x2D,0x2F,0x31,0x33,0x34,
+ 0x36,0x38,0x39,0x3B,0x3D,0x3E,0x40,0x42,
+ 0x43,0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4F,
+ 0x50,0x52,0x53,0x55,0x56,0x58,0x59,0x5B,
+ 0x5D,0x5E,0x60,0x61,0x63,0x64,0x66,0x67,
+ 0x69,0x6A,0x6B,0x6D,0x6E,0x70,0x71,0x73,
+ 0x74,0x76,0x77,0x79,0x7A,0x7B,0x7D,0x7E,
+ 0x80,0x81,0x83,0x84,0x85,0x87,0x88,0x8A,
+ 0x8B,0x8C,0x8E,0x8F,0x90,0x92,0x93,0x95,
+ 0x96,0x97,0x99,0x9A,0x9B,0x9D,0x9E,0x9F,
+ 0xA1,0xA2,0xA3,0xA5,0xA6,0xA7,0xA9,0xAA,
+ 0xAB,0xAD,0xAE,0xAF,0xB1,0xB2,0xB3,0xB5,
+ 0xB6,0xB7,0xB9,0xBA,0xBB,0xBD,0xBE,0xBF,
+ 0xC0,0xC2,0xC3,0xC4,0xC6,0xC7,0xC8,0xC9,
+ 0xCB,0xCC,0xCD,0xCF,0xD0,0xD1,0xD2,0xD4,
+ 0xD5,0xD6,0xD7,0xD9,0xDA,0xDB,0xDC,0xDF,
+ 0xE0,0xE1,0xE3,0xE4,0xE5,0xE6,0xE8,0xE9,
+ 0xEA,0xEB,0xED,0xEE,0xEF,0xF0,0xF2,0xF3,
+ 0xF4,0xF5,0xF6,0xF8,0xF9,0xFA,0xFB,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ { //4
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x01,0x02,0x03,
+ 0x04,0x05,0x07,0x08,0x0A,0x0C,0x0E,0x10,
+ 0x12,0x14,0x16,0x18,0x1A,0x1C,0x1E,0x20,
+ 0x22,0x24,0x26,0x28,0x2A,0x2B,0x2D,0x2F,
+ 0x31,0x33,0x34,0x36,0x38,0x39,0x3B,0x3D,
+ 0x3E,0x40,0x42,0x43,0x45,0x47,0x48,0x4A,
+ 0x4B,0x4D,0x4F,0x50,0x52,0x53,0x55,0x56,
+ 0x58,0x59,0x5B,0x5D,0x5E,0x60,0x61,0x63,
+ 0x64,0x66,0x67,0x69,0x6A,0x6B,0x6D,0x6E,
+ 0x70,0x71,0x73,0x74,0x76,0x77,0x79,0x7A,
+ 0x7B,0x7D,0x7E,0x80,0x81,0x83,0x84,0x85,
+ 0x87,0x88,0x8A,0x8B,0x8C,0x8E,0x8F,0x90,
+ 0x92,0x93,0x95,0x96,0x97,0x99,0x9A,0x9B,
+ 0x9D,0x9E,0x9F,0xA1,0xA2,0xA3,0xA5,0xA6,
+ 0xA7,0xA9,0xAA,0xAB,0xAD,0xAE,0xAF,0xB1,
+ 0xB2,0xB3,0xB5,0xB6,0xB7,0xB9,0xBA,0xBB,
+ 0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,0xC6,
+ 0xC7,0xC8,0xC9,0xCB,0xCC,0xCD,0xCF,0xD0,
+ 0xD1,0xD2,0xD4,0xD5,0xD6,0xD7,0xD9,0xDA,
+ 0xDB,0xDC,0xDE,0xDF,0xE0,0xE1,0xE3,0xE5,
+ 0xE6,0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,
+ 0xF0,0xF2,0xF3,0xF4,0xF5,0xF6,0xF8,0xF9,
+ 0xFA,0xFB,0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ { // 5
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0x05,0x07,0x08,0x0A,
+ 0x0C,0x0E,0x10,0x12,0x14,0x16,0x18,0x1A,
+ 0x1C,0x1E,0x20,0x22,0x24,0x26,0x28,0x2A,
+ 0x2B,0x2D,0x2F,0x31,0x33,0x34,0x36,0x38,
+ 0x39,0x3B,0x3D,0x3E,0x40,0x42,0x43,0x45,
+ 0x47,0x48,0x4A,0x4B,0x4D,0x4F,0x50,0x52,
+ 0x53,0x55,0x56,0x58,0x59,0x5B,0x5D,0x5E,
+ 0x60,0x61,0x63,0x64,0x66,0x67,0x69,0x6A,
+ 0x6B,0x6D,0x6E,0x70,0x71,0x73,0x74,0x76,
+ 0x77,0x79,0x7A,0x7B,0x7D,0x7E,0x80,0x81,
+ 0x83,0x84,0x85,0x87,0x88,0x8A,0x8B,0x8C,
+ 0x8E,0x8F,0x90,0x92,0x93,0x95,0x96,0x97,
+ 0x99,0x9A,0x9B,0x9D,0x9E,0x9F,0xA1,0xA2,
+ 0xA3,0xA5,0xA6,0xA7,0xA9,0xAA,0xAB,0xAD,
+ 0xAE,0xAF,0xB1,0xB2,0xB3,0xB5,0xB6,0xB7,
+ 0xB9,0xBA,0xBB,0xBD,0xBE,0xBF,0xC0,0xC2,
+ 0xC3,0xC4,0xC6,0xC7,0xC8,0xC9,0xCB,0xCC,
+ 0xCD,0xCF,0xD0,0xD1,0xD2,0xD4,0xD5,0xD6,
+ 0xD7,0xD9,0xDA,0xDB,0xDC,0xDE,0xDF,0xE0,
+ 0xE3,0xE4,0xE5,0xE6,0xE8,0xE9,0xEA,0xEB,
+ 0xED,0xEE,0xEF,0xF0,0xF2,0xF3,0xF4,0xF5,
+ 0xF6,0xF8,0xF9,0xFA,0xFB,0xFD,0xFE,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ { // 6
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,
+ 0x03,0x04,0x05,0x07,0x08,0x0A,0x0C,0x0E,
+ 0x10,0x12,0x14,0x16,0x18,0x18,0x1A,0x1C,
+ 0x1E,0x20,0x22,0x24,0x26,0x27,0x29,0x2B,
+ 0x2C,0x2E,0x30,0x31,0x33,0x35,0x36,0x38,
+ 0x39,0x3B,0x3C,0x3E,0x40,0x41,0x43,0x44,
+ 0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4E,0x50,
+ 0x51,0x52,0x54,0x55,0x56,0x58,0x59,0x5B,
+ 0x5C,0x5D,0x5F,0x60,0x61,0x63,0x64,0x65,
+ 0x67,0x68,0x69,0x6A,0x6C,0x6D,0x6E,0x70,
+ 0x71,0x72,0x73,0x75,0x76,0x77,0x78,0x7A,
+ 0x7B,0x7C,0x7D,0x7E,0x80,0x81,0x82,0x83,
+ 0x85,0x86,0x87,0x88,0x89,0x8A,0x8C,0x8D,
+ 0x8E,0x8F,0x90,0x92,0x93,0x94,0x95,0x96,
+ 0x97,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
+ 0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,
+ 0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,
+ 0xB2,0xB3,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,
+ 0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC2,0xC4,
+ 0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,
+ 0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD4,0xD5,
+ 0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,
+ 0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,
+ 0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,
+ 0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,
+ 0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ { // 7
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,
+ 0x03,0x04,0x05,0x06,0x07,0x09,0x0B,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x18,0x1A,0x1C,
+ 0x1E,0x20,0x21,0x23,0x25,0x27,0x28,0x2A,
+ 0x2C,0x2D,0x2F,0x31,0x32,0x34,0x36,0x37,
+ 0x39,0x3B,0x3C,0x3E,0x3F,0x41,0x42,0x44,
+ 0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4E,0x50,
+ 0x51,0x53,0x54,0x56,0x57,0x59,0x5A,0x5C,
+ 0x5D,0x5F,0x60,0x61,0x63,0x64,0x66,0x67,
+ 0x68,0x6A,0x6B,0x6D,0x6E,0x6F,0x71,0x72,
+ 0x73,0x75,0x76,0x78,0x79,0x7A,0x7C,0x7D,
+ 0x7E,0x80,0x81,0x82,0x84,0x85,0x86,0x88,
+ 0x89,0x8A,0x8B,0x8D,0x8E,0x8F,0x91,0x92,
+ 0x93,0x95,0x96,0x97,0x98,0x9A,0x9B,0x9C,
+ 0x9E,0x9F,0xA0,0xA1,0xA3,0xA4,0xA5,0xA6,
+ 0xA8,0xA9,0xAA,0xAB,0xAD,0xAE,0xAF,0xB0,
+ 0xB2,0xB3,0xB4,0xB5,0xB7,0xB8,0xB9,0xBA,
+ 0xBC,0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,
+ 0xC5,0xC7,0xC8,0xC9,0xCA,0xCB,0xCD,0xCE,
+ 0xCF,0xD0,0xD1,0xD3,0xD4,0xD5,0xD6,0xD7,
+ 0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xE0,0xE1,
+ 0xE2,0xE3,0xE4,0xE6,0xE7,0xE8,0xE9,0xEA,
+ 0xEB,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,
+ 0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFC,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ }
+};
+
+static unsigned char LUT_R[][256] =
+{
+ { // 0
+ 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
+ 0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
+ 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
+ 0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
+ 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
+ 0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
+ 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
+ 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
+ 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
+ 0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
+ 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
+ 0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
+ 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
+ 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
+ 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
+ 0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
+ 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
+ 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
+ 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
+ 0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
+ 0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
+ 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
+ 0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
+ 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
+ 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
+ 0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
+ 0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
+ 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
+ 0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
+ },
+ { // 1
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x06,0x07,0x09,0x0B,0x0D,
+ 0x10,0x12,0x14,0x17,0x19,0x1B,0x1E,0x20,
+ 0x22,0x24,0x26,0x28,0x2A,0x2C,0x2E,0x30,
+ 0x32,0x33,0x35,0x37,0x39,0x3B,0x3C,0x3E,
+ 0x40,0x41,0x43,0x45,0x46,0x48,0x4A,0x4B,
+ 0x4D,0x4F,0x50,0x52,0x53,0x55,0x57,0x58,
+ 0x5A,0x5B,0x5D,0x5E,0x60,0x61,0x63,0x64,
+ 0x66,0x67,0x69,0x6A,0x6C,0x6D,0x6F,0x70,
+ 0x71,0x73,0x74,0x76,0x77,0x79,0x7A,0x7B,
+ 0x7D,0x7E,0x7F,0x81,0x82,0x84,0x85,0x86,
+ 0x88,0x89,0x8A,0x8C,0x8D,0x8E,0x90,0x91,
+ 0x92,0x94,0x95,0x96,0x98,0x99,0x9A,0x9C,
+ 0x9D,0x9E,0xA0,0xA1,0xA2,0xA3,0xA5,0xA6,
+ 0xA7,0xA8,0xAA,0xAB,0xAC,0xAE,0xAF,0xB0,
+ 0xB1,0xB3,0xB4,0xB5,0xB6,0xB8,0xB9,0xBA,
+ 0xBB,0xBC,0xBE,0xBF,0xC0,0xC1,0xC3,0xC4,
+ 0xC5,0xC6,0xC7,0xC9,0xCA,0xCB,0xCC,0xCD,
+ 0xCF,0xD0,0xD1,0xD2,0xD3,0xD5,0xD6,0xD7,
+ 0xD8,0xD9,0xDA,0xDC,0xDD,0xDE,0xDF,0xE0,
+ 0xE1,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,
+ 0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF3,
+ 0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFB,0xFC,
+ 0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
+ },
+ { // 2
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,
+ 0x03,0x04,0x05,0x07,0x08,0x0A,0x0C,0x0E,
+ 0x10,0x12,0x14,0x16,0x19,0x1B,0x1D,0x1F,
+ 0x21,0x23,0x25,0x27,0x28,0x2A,0x2C,0x2E,
+ 0x30,0x32,0x33,0x35,0x37,0x39,0x3A,0x3C,
+ 0x3E,0x40,0x41,0x43,0x45,0x46,0x48,0x4A,
+ 0x4B,0x4D,0x4F,0x50,0x52,0x53,0x55,0x57,
+ 0x58,0x5A,0x5B,0x5D,0x5F,0x60,0x62,0x63,
+ 0x65,0x66,0x68,0x69,0x6B,0x6C,0x6E,0x6F,
+ 0x71,0x72,0x74,0x75,0x77,0x78,0x7A,0x7B,
+ 0x7D,0x7E,0x80,0x81,0x83,0x84,0x86,0x87,
+ 0x88,0x8A,0x8B,0x8D,0x8E,0x90,0x91,0x92,
+ 0x94,0x95,0x97,0x98,0x99,0x9B,0x9C,0x9E,
+ 0x9F,0xA0,0xA2,0xA3,0xA5,0xA6,0xA7,0xA9,
+ 0xAA,0xAB,0xAD,0xAE,0xB0,0xB1,0xB2,0xB4,
+ 0xB5,0xB6,0xB8,0xB9,0xBA,0xBC,0xBD,0xBE,
+ 0xC0,0xC1,0xC2,0xC4,0xC5,0xC6,0xC8,0xC9,
+ 0xCA,0xCC,0xCD,0xCE,0xD0,0xD1,0xD2,0xD4,
+ 0xD5,0xD6,0xD7,0xD9,0xDA,0xDB,0xDD,0xDE,
+ 0xDF,0xE1,0xE2,0xE3,0xE4,0xE6,0xE7,0xE8,
+ 0xE9,0xEB,0xEC,0xED,0xEF,0xF0,0xF1,0xF2,
+ 0xF4,0xF5,0xF6,0xF7,0xF9,0xFA,0xFB,0xFC,
+ 0xFE,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0x05,0x07,0x08,0x0A,
+ 0x0C,0x0E,0x10,0x12,0x14,0x16,0x18,0x1A,
+ 0x1C,0x1E,0x20,0x22,0x24,0x26,0x28,0x2A,
+ 0x2B,0x2D,0x2F,0x31,0x33,0x34,0x36,0x38,
+ 0x39,0x3B,0x3D,0x3E,0x40,0x42,0x43,0x45,
+ 0x47,0x48,0x4A,0x4B,0x4D,0x4F,0x50,0x52,
+ 0x53,0x55,0x56,0x58,0x59,0x5B,0x5D,0x5E,
+ 0x60,0x61,0x63,0x64,0x66,0x67,0x69,0x6A,
+ 0x6B,0x6D,0x6E,0x70,0x71,0x73,0x74,0x76,
+ 0x77,0x79,0x7A,0x7B,0x7D,0x7E,0x80,0x81,
+ 0x83,0x84,0x85,0x87,0x88,0x8A,0x8B,0x8C,
+ 0x8E,0x8F,0x90,0x92,0x93,0x95,0x96,0x97,
+ 0x99,0x9A,0x9B,0x9D,0x9E,0x9F,0xA1,0xA2,
+ 0xA3,0xA5,0xA6,0xA7,0xA9,0xAA,0xAB,0xAD,
+ 0xAE,0xAF,0xB1,0xB2,0xB3,0xB5,0xB6,0xB7,
+ 0xB9,0xBA,0xBB,0xBD,0xBE,0xBF,0xC0,0xC2,
+ 0xC3,0xC4,0xC6,0xC7,0xC8,0xC9,0xCB,0xCC,
+ 0xCD,0xCF,0xD0,0xD1,0xD2,0xD4,0xD5,0xD6,
+ 0xD7,0xD9,0xDA,0xDB,0xDC,0xDE,0xDF,0xE0,
+ 0xE1,0xE3,0xE4,0xE5,0xE5,0xE6,0xE8,0xE9,
+ 0xEA,0xEB,0xED,0xEE,0xEF,0xF0,0xF2,0xF3,
+ 0xF4,0xF5,0xF6,0xF8,0xF9,0xFA,0xFB,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x01,0x02,0x03,0x04,0x05,
+ 0x07,0x08,0x0A,0x0C,0x0E,0x10,0x12,0x14,
+ 0x16,0x18,0x1A,0x1C,0x1E,0x20,0x22,0x24,
+ 0x26,0x28,0x2A,0x2B,0x2D,0x2F,0x31,0x33,
+ 0x34,0x36,0x38,0x39,0x3B,0x3D,0x3E,0x40,
+ 0x42,0x43,0x45,0x47,0x48,0x4A,0x4B,0x4D,
+ 0x4F,0x50,0x52,0x53,0x55,0x56,0x58,0x59,
+ 0x5B,0x5D,0x5E,0x60,0x61,0x63,0x64,0x66,
+ 0x67,0x69,0x6A,0x6B,0x6D,0x6E,0x70,0x71,
+ 0x73,0x74,0x76,0x77,0x79,0x7A,0x7B,0x7D,
+ 0x7E,0x80,0x81,0x83,0x84,0x85,0x87,0x88,
+ 0x8A,0x8B,0x8C,0x8E,0x8F,0x90,0x92,0x93,
+ 0x95,0x96,0x97,0x99,0x9A,0x9B,0x9D,0x9E,
+ 0x9F,0xA1,0xA2,0xA3,0xA5,0xA6,0xA7,0xA9,
+ 0xAA,0xAB,0xAD,0xAE,0xAF,0xB1,0xB2,0xB3,
+ 0xB5,0xB6,0xB7,0xB9,0xBA,0xBB,0xBD,0xBE,
+ 0xBF,0xC0,0xC2,0xC3,0xC4,0xC6,0xC7,0xC8,
+ 0xC9,0xCB,0xCC,0xCD,0xCF,0xD0,0xD1,0xD2,
+ 0xD4,0xD5,0xD6,0xD7,0xD9,0xDA,0xDB,0xDC,
+ 0xDE,0xDF,0xE0,0xE1,0xE3,0xE4,0xE5,0xE6,
+ 0xE8,0xE9,0xEA,0xEB,0xEB,0xED,0xEE,0xEF,
+ 0xF0,0xF2,0xF3,0xF4,0xF5,0xF6,0xF8,0xF9,
+ 0xFA,0xFB,0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,
+ 0x03,0x04,0x05,0x07,0x08,0x0A,0x0C,0x0E,
+ 0x10,0x12,0x14,0x16,0x18,0x1A,0x1C,0x1E,
+ 0x20,0x22,0x24,0x26,0x28,0x2A,0x2B,0x2D,
+ 0x2F,0x31,0x33,0x34,0x36,0x38,0x39,0x3B,
+ 0x3D,0x3E,0x40,0x42,0x43,0x45,0x47,0x48,
+ 0x4A,0x4B,0x4D,0x4F,0x50,0x52,0x53,0x55,
+ 0x56,0x58,0x59,0x5B,0x5D,0x5E,0x60,0x61,
+ 0x63,0x64,0x66,0x67,0x69,0x6A,0x6B,0x6D,
+ 0x6E,0x70,0x71,0x73,0x74,0x76,0x77,0x79,
+ 0x7A,0x7B,0x7D,0x7E,0x80,0x81,0x83,0x84,
+ 0x85,0x87,0x88,0x8A,0x8B,0x8C,0x8E,0x8F,
+ 0x90,0x92,0x93,0x95,0x96,0x97,0x99,0x9A,
+ 0x9B,0x9D,0x9E,0x9F,0xA1,0xA2,0xA3,0xA5,
+ 0xA6,0xA7,0xA9,0xAA,0xAB,0xAD,0xAE,0xAF,
+ 0xB1,0xB2,0xB3,0xB5,0xB6,0xB7,0xB9,0xBA,
+ 0xBB,0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,
+ 0xC6,0xC7,0xC8,0xC9,0xCB,0xCC,0xCD,0xCF,
+ 0xD0,0xD1,0xD2,0xD4,0xD5,0xD6,0xD7,0xD9,
+ 0xDA,0xDB,0xDC,0xDE,0xDF,0xE0,0xE1,0xE3,
+ 0xE4,0xE5,0xE6,0xE8,0xE9,0xEA,0xEB,0xED,
+ 0xEE,0xEF,0xF0,0xF2,0xF3,0xF4,0xF5,0xF6,
+ 0xF8,0xF9,0xFA,0xFB,0xFD,0xFE,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x05,0x06,0x08,0x0A,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x19,0x1B,0x1D,
+ 0x1F,0x20,0x22,0x24,0x26,0x28,0x2A,0x2B,
+ 0x2D,0x2F,0x31,0x32,0x34,0x35,0x37,0x39,
+ 0x3A,0x3C,0x3D,0x3F,0x41,0x42,0x44,0x45,
+ 0x47,0x48,0x4A,0x4B,0x4D,0x4E,0x4F,0x51,
+ 0x52,0x54,0x55,0x57,0x58,0x59,0x5B,0x5C,
+ 0x5E,0x5F,0x60,0x62,0x63,0x64,0x66,0x67,
+ 0x68,0x6A,0x6B,0x6C,0x6E,0x6F,0x70,0x72,
+ 0x73,0x74,0x75,0x77,0x78,0x79,0x7B,0x7C,
+ 0x7D,0x7E,0x80,0x81,0x82,0x83,0x85,0x86,
+ 0x87,0x88,0x89,0x8B,0x8C,0x8D,0x8E,0x90,
+ 0x91,0x92,0x93,0x94,0x96,0x97,0x98,0x99,
+ 0x9A,0x9B,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,
+ 0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAB,0xAC,
+ 0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB4,0xB5,
+ 0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBD,0xBE,
+ 0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,
+ 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
+ 0xD0,0xD1,0xD2,0xD3,0xD4,0xD6,0xD7,0xD8,
+ 0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,
+ 0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xEA,
+ 0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,
+ 0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,
+ 0xFB,0xFC,0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,
+ 0x03,0x04,0x05,0x06,0x07,0x09,0x0B,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x18,0x1A,0x1C,
+ 0x1E,0x20,0x21,0x23,0x25,0x27,0x28,0x2A,
+ 0x2C,0x2D,0x2F,0x31,0x32,0x34,0x36,0x37,
+ 0x39,0x3B,0x3C,0x3E,0x3F,0x41,0x42,0x44,
+ 0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4E,0x50,
+ 0x51,0x53,0x54,0x56,0x57,0x59,0x5A,0x5C,
+ 0x5D,0x5F,0x60,0x61,0x63,0x64,0x66,0x67,
+ 0x68,0x6A,0x6B,0x6D,0x6E,0x6F,0x71,0x72,
+ 0x73,0x75,0x76,0x78,0x79,0x7A,0x7C,0x7D,
+ 0x7E,0x80,0x81,0x82,0x84,0x85,0x86,0x88,
+ 0x89,0x8A,0x8B,0x8D,0x8E,0x8F,0x91,0x92,
+ 0x93,0x95,0x96,0x97,0x98,0x9A,0x9B,0x9C,
+ 0x9E,0x9F,0xA0,0xA1,0xA3,0xA4,0xA5,0xA6,
+ 0xA8,0xA9,0xAA,0xAB,0xAD,0xAE,0xAF,0xB0,
+ 0xB2,0xB3,0xB4,0xB5,0xB7,0xB8,0xB9,0xBA,
+ 0xBC,0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,
+ 0xC5,0xC7,0xC8,0xC9,0xCA,0xCB,0xCD,0xCE,
+ 0xCF,0xD0,0xD1,0xD3,0xD4,0xD5,0xD6,0xD7,
+ 0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xE0,0xE1,
+ 0xE2,0xE3,0xE4,0xE6,0xE7,0xE8,0xE9,0xEA,
+ 0xEB,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,
+ 0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFC,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
+ }
+};
+
+static unsigned char LUT_G[][256] =
+{
+ {
+ 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
+ 0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
+ 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
+ 0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
+ 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
+ 0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
+ 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
+ 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
+ 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
+ 0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
+ 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
+ 0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
+ 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
+ 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
+ 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
+ 0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
+ 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
+ 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
+ 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
+ 0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
+ 0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
+ 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
+ 0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
+ 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
+ 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
+ 0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
+ 0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
+ 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
+ 0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x06,0x07,0x09,0x0B,0x0D,
+ 0x10,0x12,0x14,0x17,0x19,0x1B,0x1E,0x20,
+ 0x22,0x24,0x26,0x28,0x2A,0x2C,0x2E,0x30,
+ 0x32,0x33,0x35,0x37,0x39,0x3B,0x3C,0x3E,
+ 0x40,0x41,0x43,0x45,0x46,0x48,0x4A,0x4B,
+ 0x4D,0x4F,0x50,0x52,0x53,0x55,0x57,0x58,
+ 0x5A,0x5B,0x5D,0x5E,0x60,0x61,0x63,0x64,
+ 0x66,0x67,0x69,0x6A,0x6C,0x6D,0x6F,0x70,
+ 0x71,0x73,0x74,0x76,0x77,0x79,0x7A,0x7B,
+ 0x7D,0x7E,0x7F,0x81,0x82,0x84,0x85,0x86,
+ 0x88,0x89,0x8A,0x8C,0x8D,0x8E,0x90,0x91,
+ 0x92,0x94,0x95,0x96,0x98,0x99,0x9A,0x9C,
+ 0x9D,0x9E,0xA0,0xA1,0xA2,0xA3,0xA5,0xA6,
+ 0xA7,0xA8,0xAA,0xAB,0xAC,0xAE,0xAF,0xB0,
+ 0xB1,0xB3,0xB4,0xB5,0xB6,0xB8,0xB9,0xBA,
+ 0xBB,0xBC,0xBE,0xBF,0xC0,0xC1,0xC3,0xC4,
+ 0xC5,0xC6,0xC7,0xC9,0xCA,0xCB,0xCC,0xCD,
+ 0xCF,0xD0,0xD1,0xD2,0xD3,0xD5,0xD6,0xD7,
+ 0xD8,0xD9,0xDA,0xDC,0xDD,0xDE,0xDF,0xE0,
+ 0xE1,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,
+ 0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF3,
+ 0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFB,0xFC,
+ 0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x05,0x07,0x08,0x0A,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x16,0x19,0x1B,
+ 0x1D,0x1F,0x21,0x23,0x25,0x27,0x28,0x2A,
+ 0x2C,0x2E,0x30,0x32,0x33,0x35,0x37,0x39,
+ 0x3A,0x3C,0x3E,0x40,0x41,0x43,0x45,0x46,
+ 0x48,0x4A,0x4B,0x4D,0x4F,0x50,0x52,0x53,
+ 0x55,0x57,0x58,0x5A,0x5B,0x5D,0x5F,0x60,
+ 0x62,0x63,0x65,0x66,0x68,0x69,0x6B,0x6C,
+ 0x6E,0x6F,0x71,0x72,0x74,0x75,0x77,0x78,
+ 0x7A,0x7B,0x7D,0x7E,0x80,0x81,0x83,0x84,
+ 0x86,0x87,0x88,0x8A,0x8B,0x8D,0x8E,0x90,
+ 0x91,0x92,0x94,0x95,0x97,0x98,0x99,0x9B,
+ 0x9C,0x9E,0x9F,0xA0,0xA2,0xA3,0xA5,0xA7,
+ 0xA9,0xAA,0xAB,0xAD,0xAE,0xB0,0xB1,0xB2,
+ 0xB4,0xB5,0xB6,0xB8,0xB9,0xBA,0xBC,0xBD,
+ 0xBE,0xC0,0xC1,0xC2,0xC4,0xC5,0xC6,0xC8,
+ 0xC9,0xCA,0xCC,0xCD,0xCE,0xD0,0xD1,0xD2,
+ 0xD4,0xD5,0xD6,0xD7,0xD9,0xDA,0xDB,0xDD,
+ 0xDE,0xDF,0xE1,0xE2,0xE3,0xE4,0xE6,0xE7,
+ 0xE8,0xE9,0xEB,0xEC,0xED,0xEF,0xF0,0xF1,
+ 0xF2,0xF4,0xF5,0xF6,0xF7,0xF9,0xFA,0xFB,
+ 0xFC,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x07,
+ 0x08,0x0A,0x0C,0x0E,0x10,0x12,0x14,0x16,
+ 0x18,0x1A,0x1C,0x1E,0x20,0x22,0x24,0x26,
+ 0x28,0x2A,0x2B,0x2D,0x2F,0x31,0x33,0x34,
+ 0x36,0x38,0x39,0x3B,0x3D,0x3E,0x40,0x42,
+ 0x43,0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4F,
+ 0x50,0x52,0x53,0x55,0x56,0x58,0x59,0x5B,
+ 0x5D,0x5E,0x60,0x61,0x63,0x64,0x66,0x67,
+ 0x69,0x6A,0x6B,0x6D,0x6E,0x70,0x71,0x73,
+ 0x74,0x76,0x77,0x79,0x7A,0x7B,0x7D,0x7E,
+ 0x80,0x81,0x83,0x84,0x85,0x87,0x88,0x8A,
+ 0x8B,0x8C,0x8E,0x8F,0x90,0x92,0x93,0x95,
+ 0x96,0x97,0x99,0x9A,0x9B,0x9D,0x9E,0x9F,
+ 0xA1,0xA2,0xA3,0xA5,0xA6,0xA7,0xA9,0xAA,
+ 0xAB,0xAD,0xAE,0xAF,0xB1,0xB2,0xB3,0xB5,
+ 0xB6,0xB7,0xB9,0xBA,0xBB,0xBD,0xBE,0xBF,
+ 0xC0,0xC2,0xC3,0xC4,0xC6,0xC7,0xC8,0xC9,
+ 0xCB,0xCC,0xCD,0xCF,0xD0,0xD1,0xD2,0xD4,
+ 0xD5,0xD6,0xD7,0xD9,0xDA,0xDB,0xDC,0xDF,
+ 0xE0,0xE1,0xE3,0xE4,0xE5,0xE6,0xE8,0xE9,
+ 0xEA,0xEB,0xED,0xEE,0xEF,0xF0,0xF2,0xF3,
+ 0xF4,0xF5,0xF6,0xF8,0xF9,0xFA,0xFB,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x01,0x02,0x03,
+ 0x04,0x05,0x07,0x08,0x0A,0x0C,0x0E,0x10,
+ 0x12,0x14,0x16,0x18,0x1A,0x1C,0x1E,0x20,
+ 0x22,0x24,0x26,0x28,0x2A,0x2B,0x2D,0x2F,
+ 0x31,0x33,0x34,0x36,0x38,0x39,0x3B,0x3D,
+ 0x3E,0x40,0x42,0x43,0x45,0x47,0x48,0x4A,
+ 0x4B,0x4D,0x4F,0x50,0x52,0x53,0x55,0x56,
+ 0x58,0x59,0x5B,0x5D,0x5E,0x60,0x61,0x63,
+ 0x64,0x66,0x67,0x69,0x6A,0x6B,0x6D,0x6E,
+ 0x70,0x71,0x73,0x74,0x76,0x77,0x79,0x7A,
+ 0x7B,0x7D,0x7E,0x80,0x81,0x83,0x84,0x85,
+ 0x87,0x88,0x8A,0x8B,0x8C,0x8E,0x8F,0x90,
+ 0x92,0x93,0x95,0x96,0x97,0x99,0x9A,0x9B,
+ 0x9D,0x9E,0x9F,0xA1,0xA2,0xA3,0xA5,0xA6,
+ 0xA7,0xA9,0xAA,0xAB,0xAD,0xAE,0xAF,0xB1,
+ 0xB2,0xB3,0xB5,0xB6,0xB7,0xB9,0xBA,0xBB,
+ 0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,0xC6,
+ 0xC7,0xC8,0xC9,0xCB,0xCC,0xCD,0xCF,0xD0,
+ 0xD1,0xD2,0xD4,0xD5,0xD6,0xD7,0xD9,0xDA,
+ 0xDB,0xDC,0xDE,0xDF,0xE0,0xE1,0xE3,0xE5,
+ 0xE6,0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,
+ 0xF0,0xF2,0xF3,0xF4,0xF5,0xF6,0xF8,0xF9,
+ 0xFA,0xFB,0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x02,0x03,0x04,0x05,0x07,0x08,0x0A,
+ 0x0C,0x0E,0x10,0x12,0x14,0x16,0x18,0x1A,
+ 0x1C,0x1E,0x20,0x22,0x24,0x26,0x28,0x2A,
+ 0x2B,0x2D,0x2F,0x31,0x33,0x34,0x36,0x38,
+ 0x39,0x3B,0x3D,0x3E,0x40,0x42,0x43,0x45,
+ 0x47,0x48,0x4A,0x4B,0x4D,0x4F,0x50,0x52,
+ 0x53,0x55,0x56,0x58,0x59,0x5B,0x5D,0x5E,
+ 0x60,0x61,0x63,0x64,0x66,0x67,0x69,0x6A,
+ 0x6B,0x6D,0x6E,0x70,0x71,0x73,0x74,0x76,
+ 0x77,0x79,0x7A,0x7B,0x7D,0x7E,0x80,0x81,
+ 0x83,0x84,0x85,0x87,0x88,0x8A,0x8B,0x8C,
+ 0x8E,0x8F,0x90,0x92,0x93,0x95,0x96,0x97,
+ 0x99,0x9A,0x9B,0x9D,0x9E,0x9F,0xA1,0xA2,
+ 0xA3,0xA5,0xA6,0xA7,0xA9,0xAA,0xAB,0xAD,
+ 0xAE,0xAF,0xB1,0xB2,0xB3,0xB5,0xB6,0xB7,
+ 0xB9,0xBA,0xBB,0xBD,0xBE,0xBF,0xC0,0xC2,
+ 0xC3,0xC4,0xC6,0xC7,0xC8,0xC9,0xCB,0xCC,
+ 0xCD,0xCF,0xD0,0xD1,0xD2,0xD4,0xD5,0xD6,
+ 0xD7,0xD9,0xDA,0xDB,0xDC,0xDE,0xDF,0xE0,
+ 0xE3,0xE4,0xE5,0xE6,0xE8,0xE9,0xEA,0xEB,
+ 0xED,0xEE,0xEF,0xF0,0xF2,0xF3,0xF4,0xF5,
+ 0xF6,0xF8,0xF9,0xFA,0xFB,0xFD,0xFE,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,
+ 0x03,0x04,0x05,0x07,0x08,0x0A,0x0C,0x0E,
+ 0x10,0x12,0x14,0x16,0x18,0x18,0x1A,0x1C,
+ 0x1E,0x20,0x22,0x24,0x26,0x27,0x29,0x2B,
+ 0x2C,0x2E,0x30,0x31,0x33,0x35,0x36,0x38,
+ 0x39,0x3B,0x3C,0x3E,0x40,0x41,0x43,0x44,
+ 0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4E,0x50,
+ 0x51,0x52,0x54,0x55,0x56,0x58,0x59,0x5B,
+ 0x5C,0x5D,0x5F,0x60,0x61,0x63,0x64,0x65,
+ 0x67,0x68,0x69,0x6A,0x6C,0x6D,0x6E,0x70,
+ 0x71,0x72,0x73,0x75,0x76,0x77,0x78,0x7A,
+ 0x7B,0x7C,0x7D,0x7E,0x80,0x81,0x82,0x83,
+ 0x85,0x86,0x87,0x88,0x89,0x8A,0x8C,0x8D,
+ 0x8E,0x8F,0x90,0x92,0x93,0x94,0x95,0x96,
+ 0x97,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
+ 0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,
+ 0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,
+ 0xB2,0xB3,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,
+ 0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC2,0xC4,
+ 0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,
+ 0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD4,0xD5,
+ 0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,
+ 0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,
+ 0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,
+ 0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,
+ 0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ { // 7
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,
+ 0x03,0x04,0x05,0x06,0x07,0x09,0x0B,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x18,0x1A,0x1C,
+ 0x1E,0x20,0x21,0x23,0x25,0x27,0x28,0x2A,
+ 0x2C,0x2D,0x2F,0x31,0x32,0x34,0x36,0x37,
+ 0x39,0x3B,0x3C,0x3E,0x3F,0x41,0x42,0x44,
+ 0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4E,0x50,
+ 0x51,0x53,0x54,0x56,0x57,0x59,0x5A,0x5C,
+ 0x5D,0x5F,0x60,0x61,0x63,0x64,0x66,0x67,
+ 0x68,0x6A,0x6B,0x6D,0x6E,0x6F,0x71,0x72,
+ 0x73,0x75,0x76,0x78,0x79,0x7A,0x7C,0x7D,
+ 0x7E,0x80,0x81,0x82,0x84,0x85,0x86,0x88,
+ 0x89,0x8A,0x8B,0x8D,0x8E,0x8F,0x91,0x92,
+ 0x93,0x95,0x96,0x97,0x98,0x9A,0x9B,0x9C,
+ 0x9E,0x9F,0xA0,0xA1,0xA3,0xA4,0xA5,0xA6,
+ 0xA8,0xA9,0xAA,0xAB,0xAD,0xAE,0xAF,0xB0,
+ 0xB2,0xB3,0xB4,0xB5,0xB7,0xB8,0xB9,0xBA,
+ 0xBC,0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,
+ 0xC5,0xC7,0xC8,0xC9,0xCA,0xCB,0xCD,0xCE,
+ 0xCF,0xD0,0xD1,0xD3,0xD4,0xD5,0xD6,0xD7,
+ 0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xE0,0xE1,
+ 0xE2,0xE3,0xE4,0xE6,0xE7,0xE8,0xE9,0xEA,
+ 0xEB,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,
+ 0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFC,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ }
+};
+
+static unsigned char LUT_B[][256] =
+{
+ {
+ 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
+ 0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
+ 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
+ 0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
+ 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
+ 0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
+ 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
+ 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
+ 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
+ 0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
+ 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
+ 0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
+ 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
+ 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
+ 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
+ 0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
+ 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
+ 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
+ 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
+ 0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
+ 0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
+ 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
+ 0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
+ 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
+ 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
+ 0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
+ 0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
+ 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
+ 0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x06,0x07,0x09,0x0B,0x0D,
+ 0x10,0x12,0x14,0x17,0x19,0x1B,0x1E,0x20,
+ 0x22,0x24,0x26,0x28,0x2A,0x2C,0x2E,0x30,
+ 0x32,0x33,0x35,0x37,0x39,0x3B,0x3C,0x3E,
+ 0x40,0x41,0x43,0x45,0x46,0x48,0x4A,0x4B,
+ 0x4D,0x4F,0x50,0x52,0x53,0x55,0x57,0x58,
+ 0x5A,0x5B,0x5D,0x5E,0x60,0x61,0x63,0x64,
+ 0x66,0x67,0x69,0x6A,0x6C,0x6D,0x6F,0x70,
+ 0x71,0x73,0x74,0x76,0x77,0x79,0x7A,0x7B,
+ 0x7D,0x7E,0x7F,0x81,0x82,0x84,0x85,0x86,
+ 0x88,0x89,0x8A,0x8C,0x8D,0x8E,0x90,0x91,
+ 0x92,0x94,0x95,0x96,0x98,0x99,0x9A,0x9C,
+ 0x9D,0x9E,0xA0,0xA1,0xA2,0xA3,0xA5,0xA6,
+ 0xA7,0xA8,0xAA,0xAB,0xAC,0xAE,0xAF,0xB0,
+ 0xB1,0xB3,0xB4,0xB5,0xB6,0xB8,0xB9,0xBA,
+ 0xBB,0xBC,0xBE,0xBF,0xC0,0xC1,0xC3,0xC4,
+ 0xC5,0xC6,0xC7,0xC9,0xCA,0xCB,0xCC,0xCD,
+ 0xCF,0xD0,0xD1,0xD2,0xD3,0xD5,0xD6,0xD7,
+ 0xD8,0xD9,0xDA,0xDC,0xDD,0xDE,0xDF,0xE0,
+ 0xE1,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,
+ 0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF3,
+ 0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFB,0xFC,
+ 0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x05,0x07,0x08,0x0A,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x16,0x19,0x1B,
+ 0x1D,0x1F,0x21,0x23,0x25,0x27,0x28,0x2A,
+ 0x2C,0x2E,0x30,0x32,0x33,0x35,0x37,0x39,
+ 0x3A,0x3C,0x3E,0x40,0x41,0x43,0x45,0x46,
+ 0x48,0x4A,0x4B,0x4D,0x4F,0x50,0x52,0x53,
+ 0x55,0x57,0x58,0x5A,0x5B,0x5D,0x5F,0x60,
+ 0x62,0x63,0x65,0x66,0x68,0x69,0x6B,0x6C,
+ 0x6E,0x6F,0x71,0x72,0x74,0x75,0x77,0x78,
+ 0x7A,0x7B,0x7D,0x7E,0x80,0x81,0x83,0x84,
+ 0x86,0x87,0x88,0x8A,0x8B,0x8D,0x8E,0x90,
+ 0x91,0x92,0x94,0x95,0x97,0x98,0x99,0x9B,
+ 0x9C,0x9E,0x9F,0xA0,0xA2,0xA3,0xA5,0xA7,
+ 0xA9,0xAA,0xAB,0xAD,0xAE,0xB0,0xB1,0xB2,
+ 0xB4,0xB5,0xB6,0xB8,0xB9,0xBA,0xBC,0xBD,
+ 0xBE,0xC0,0xC1,0xC2,0xC4,0xC5,0xC6,0xC8,
+ 0xC9,0xCA,0xCC,0xCD,0xCE,0xD0,0xD1,0xD2,
+ 0xD4,0xD5,0xD6,0xD7,0xD9,0xDA,0xDB,0xDD,
+ 0xDE,0xDF,0xE1,0xE2,0xE3,0xE4,0xE6,0xE7,
+ 0xE8,0xE9,0xEB,0xEC,0xED,0xEF,0xF0,0xF1,
+ 0xF2,0xF4,0xF5,0xF6,0xF7,0xF9,0xFA,0xFB,
+ 0xFC,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x01,0x02,0x03,0x04,0x05,0x07,0x08,
+ 0x0A,0x0C,0x0E,0x10,0x12,0x14,0x16,0x18,
+ 0x1A,0x1C,0x1E,0x20,0x22,0x24,0x26,0x28,
+ 0x2A,0x2B,0x2D,0x2F,0x31,0x33,0x34,0x36,
+ 0x38,0x39,0x3B,0x3D,0x3E,0x40,0x42,0x43,
+ 0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4F,0x50,
+ 0x52,0x53,0x55,0x56,0x58,0x59,0x5B,0x5D,
+ 0x5E,0x60,0x61,0x63,0x64,0x66,0x67,0x69,
+ 0x6A,0x6B,0x6D,0x6E,0x70,0x71,0x73,0x74,
+ 0x76,0x77,0x79,0x7A,0x7B,0x7D,0x7E,0x80,
+ 0x81,0x83,0x84,0x85,0x87,0x88,0x8A,0x8B,
+ 0x8C,0x8E,0x8F,0x90,0x92,0x93,0x95,0x96,
+ 0x97,0x99,0x9A,0x9B,0x9D,0x9E,0x9F,0xA1,
+ 0xA2,0xA3,0xA5,0xA6,0xA7,0xA9,0xAA,0xAB,
+ 0xAD,0xAE,0xAF,0xB1,0xB2,0xB3,0xB5,0xB6,
+ 0xB7,0xB9,0xBA,0xBB,0xBD,0xBE,0xBF,0xC0,
+ 0xC2,0xC3,0xC4,0xC6,0xC7,0xC8,0xC9,0xCB,
+ 0xCC,0xCD,0xCF,0xD0,0xD1,0xD2,0xD4,0xD5,
+ 0xD6,0xD7,0xD9,0xDA,0xDB,0xDC,0xDE,0xDF,
+ 0xE0,0xE1,0xE3,0xE4,0xE5,0xE6,0xE8,0xE9,
+ 0xEA,0xEB,0xED,0xEE,0xEF,0xF0,0xF2,0xF3,
+ 0xF4,0xF5,0xF6,0xF8,0xF9,0xFA,0xFB,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x01,0x02,0x03,0x04,
+ 0x05,0x07,0x08,0x0A,0x0C,0x0E,0x10,0x12,
+ 0x14,0x16,0x18,0x1A,0x1C,0x1E,0x20,0x22,
+ 0x24,0x26,0x28,0x2A,0x2B,0x2D,0x2F,0x31,
+ 0x33,0x34,0x36,0x38,0x39,0x3B,0x3D,0x3E,
+ 0x40,0x42,0x43,0x45,0x47,0x48,0x4A,0x4B,
+ 0x4D,0x4F,0x50,0x52,0x53,0x55,0x56,0x58,
+ 0x59,0x5B,0x5D,0x5E,0x60,0x61,0x63,0x64,
+ 0x66,0x67,0x69,0x6A,0x6B,0x6D,0x6E,0x70,
+ 0x71,0x73,0x74,0x76,0x77,0x79,0x7A,0x7B,
+ 0x7D,0x7E,0x80,0x81,0x83,0x84,0x85,0x87,
+ 0x88,0x8A,0x8B,0x8C,0x8E,0x8F,0x90,0x92,
+ 0x93,0x95,0x96,0x97,0x99,0x9A,0x9B,0x9D,
+ 0x9E,0x9F,0xA1,0xA2,0xA3,0xA5,0xA6,0xA7,
+ 0xA9,0xAA,0xAB,0xAD,0xAE,0xAF,0xB1,0xB2,
+ 0xB3,0xB5,0xB6,0xB7,0xB9,0xBA,0xBB,0xBD,
+ 0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,0xC6,0xC7,
+ 0xC8,0xC9,0xCB,0xCC,0xCD,0xCF,0xD0,0xD1,
+ 0xD2,0xD4,0xD5,0xD6,0xD7,0xD9,0xDA,0xDB,
+ 0xDC,0xDE,0xDF,0xE0,0xE1,0xE3,0xE4,0xE5,
+ 0xE6,0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,
+ 0xF0,0xF2,0xF3,0xF4,0xF5,0xF6,0xF8,0xF9,
+ 0xFA,0xFB,0xFD,0xFE,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,
+ 0x02,0x03,0x04,0x05,0x07,0x08,0x0A,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x16,0x18,0x1A,
+ 0x1C,0x1E,0x20,0x22,0x24,0x26,0x28,0x2A,
+ 0x2B,0x2D,0x2F,0x31,0x33,0x34,0x36,0x38,
+ 0x39,0x3B,0x3D,0x3E,0x40,0x42,0x43,0x45,
+ 0x47,0x48,0x4A,0x4B,0x4D,0x4F,0x50,0x52,
+ 0x53,0x55,0x56,0x58,0x59,0x5B,0x5D,0x5E,
+ 0x60,0x61,0x63,0x64,0x66,0x67,0x69,0x6A,
+ 0x6B,0x6D,0x6E,0x70,0x71,0x73,0x74,0x76,
+ 0x77,0x79,0x7A,0x7B,0x7D,0x7E,0x80,0x81,
+ 0x83,0x84,0x85,0x87,0x88,0x8A,0x8B,0x8C,
+ 0x8E,0x8F,0x90,0x92,0x93,0x95,0x96,0x97,
+ 0x99,0x9A,0x9B,0x9D,0x9E,0x9F,0xA1,0xA3,
+ 0xA5,0xA6,0xA7,0xA9,0xAA,0xAB,0xAD,0xAE,
+ 0xAF,0xB1,0xB2,0xB3,0xB5,0xB6,0xB7,0xB9,
+ 0xBA,0xBB,0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,
+ 0xC4,0xC6,0xC7,0xC8,0xC9,0xCB,0xCC,0xCD,
+ 0xCF,0xD0,0xD1,0xD2,0xD4,0xD5,0xD6,0xD7,
+ 0xD9,0xDA,0xDB,0xDC,0xDE,0xDF,0xE0,0xE1,
+ 0xE3,0xE4,0xE5,0xE6,0xE8,0xE9,0xEA,0xEB,
+ 0xED,0xEE,0xEF,0xF0,0xF2,0xF3,0xF4,0xF5,
+ 0xF6,0xF8,0xF9,0xFA,0xFB,0xFD,0xFE,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x01,0x02,0x03,
+ 0x04,0x05,0x07,0x08,0x0A,0x0C,0x0E,0x10,
+ 0x12,0x14,0x16,0x18,0x1A,0x1C,0x1E,0x20,
+ 0x22,0x24,0x26,0x27,0x29,0x2B,0x2C,0x2E,
+ 0x30,0x31,0x33,0x35,0x36,0x38,0x39,0x3B,
+ 0x3C,0x3E,0x40,0x41,0x43,0x44,0x45,0x47,
+ 0x48,0x4B,0x4D,0x4E,0x50,0x51,0x52,0x54,
+ 0x55,0x56,0x58,0x59,0x5B,0x5C,0x5D,0x5F,
+ 0x60,0x61,0x63,0x64,0x65,0x67,0x68,0x69,
+ 0x6A,0x6C,0x6D,0x6E,0x70,0x71,0x72,0x73,
+ 0x75,0x76,0x77,0x78,0x7A,0x7B,0x7C,0x7D,
+ 0x7E,0x80,0x81,0x82,0x83,0x85,0x86,0x87,
+ 0x88,0x89,0x8A,0x8C,0x8D,0x8E,0x8F,0x90,
+ 0x92,0x93,0x94,0x95,0x96,0x96,0x97,0x99,
+ 0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA1,0xA2,
+ 0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xAA,0xAB,
+ 0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,
+ 0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,
+ 0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,0xC5,
+ 0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,
+ 0xCE,0xCF,0xD0,0xD1,0xD2,0xD4,0xD5,0xD6,
+ 0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,
+ 0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,
+ 0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,
+ 0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,
+ 0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ },
+ {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,
+ 0x03,0x04,0x05,0x06,0x07,0x09,0x0B,0x0C,
+ 0x0E,0x10,0x12,0x14,0x16,0x18,0x1A,0x1C,
+ 0x1E,0x20,0x21,0x23,0x25,0x27,0x28,0x2A,
+ 0x2C,0x2D,0x2F,0x31,0x32,0x34,0x36,0x37,
+ 0x39,0x3B,0x3C,0x3E,0x3F,0x41,0x42,0x44,
+ 0x45,0x47,0x48,0x4A,0x4B,0x4D,0x4E,0x50,
+ 0x51,0x53,0x54,0x56,0x57,0x59,0x5A,0x5C,
+ 0x5D,0x5F,0x60,0x61,0x63,0x64,0x66,0x67,
+ 0x68,0x6A,0x6B,0x6D,0x6E,0x6F,0x71,0x72,
+ 0x73,0x75,0x76,0x78,0x79,0x7A,0x7C,0x7D,
+ 0x7E,0x80,0x81,0x82,0x84,0x85,0x86,0x88,
+ 0x89,0x8A,0x8B,0x8D,0x8E,0x8F,0x91,0x92,
+ 0x93,0x95,0x96,0x97,0x98,0x9A,0x9B,0x9C,
+ 0x9E,0x9F,0xA0,0xA1,0xA3,0xA4,0xA5,0xA6,
+ 0xA8,0xA9,0xAA,0xAB,0xAD,0xAE,0xAF,0xB0,
+ 0xB2,0xB3,0xB4,0xB5,0xB7,0xB8,0xB9,0xBA,
+ 0xBC,0xBD,0xBE,0xBF,0xC0,0xC2,0xC3,0xC4,
+ 0xC5,0xC7,0xC8,0xC9,0xCA,0xCB,0xCD,0xCE,
+ 0xCF,0xD0,0xD1,0xD3,0xD4,0xD5,0xD6,0xD7,
+ 0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xE0,0xE1,
+ 0xE2,0xE3,0xE4,0xE6,0xE7,0xE8,0xE9,0xEA,
+ 0xEB,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,
+ 0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFC,0xFD,
+ 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ }
+};
+//// profile array ////
+
+typedef struct
+{
+ int productID; // USB PID
+ char productName[50]; // ESCI/2 procduct name
+ char deviceID[50]; // device ID (same as bonjour mdl name)
+ int lutID; // look up table no
+}epsonds_profile_map;
+
+const epsonds_profile_map epsonds_models_predefined[] = {
+ {0x0145, "DS-5500","DS-5500", 7},
+ {0x0145, "DS-6500","DS-6500", 7},
+ {0x0145, "DS-7500","DS-7500", 7},
+ {0x0146, "DS-50000","DS-50000", 7},
+ {0x0146, "DS-60000","DS-60000", 7},
+ {0x0146, "DS-70000","DS-70000", 7},
+ {0x014C, "DS-510","DS-510", 7},
+ {0x0150, "DS-560","DS-560", 7},
+ {0x0152, "DS-40","DS-40", 7},
+ {0x014D, "DS-760","DS-760", 7},
+ {0x014D, "DS-860","DS-860", 7},
+ {0x0154, "DS-520","DS-520", 7},
+ {0x08BC, "PID 08BC","PX-M7050 Series", 7},
+ {0x08BC, "PID 08BC","WF-8510 Series", 7},
+ {0x08BC, "PID 08BC","WF-8590 Series", 7},
+ {0x08CC, "PID 08CC","PX-M7050FX Series", 7},
+ {0x08CC, "PID 08CC","WF-R8590 Series", 7},
+ {0x0165, "DS-410","DS-410", 7},
+ {0x016C, "ES-50","ES-50", 6},
+ {0x0160, "DS-70","DS-70", 6},
+ {0x016D, "ES-55R","ES-55R", 6},
+ {0x018C, "RR-60","RR-60", 6},
+ {0x016E, "ES-60W","ES-60W", 6},
+ {0x0166, "DS-80W","DS-80W", 6},
+ {0x016F, "ES-65WR","ES-65WR", 6},
+ {0x018B, "RR-70W","RR-70W", 6},
+ {0x016E, "ES-60WW","ES-60WW", 6},
+ {0x016E, "ES-60WB","ES-60WB", 6},
+ {0x015C, "DS-1630","DS-1630", 4},
+ {0x015D, "DS-1610","DS-1610", 4},
+ {0x015E, "DS-1660W","DS-1660W", 4},
+ {0x0159, "DS-310","DS-310", 5},
+ {0x0159, "ES-200","ES-200", 5},
+ {0x0162, "DS-320","DS-320", 5},
+ {0x015A, "DS-360W","DS-360W", 5},
+ {0x015A, "ES-300W","ES-300W", 5},
+ {0x0177, "ES-300WR","ES-300WR", 5},
+ {0x0181, "ES-400II","ES-400II", 2},
+ {0x0183, "DS-535II","DS-535II", 2},
+ {0x0184, "DS-531","DS-531", 2},
+ {0x0182, "DS-530II","DS-530II", 2},
+ {0x0185, "ES-500WII","ES-500WII", 2},
+ {0x0188, "DS-571W","DS-571W", 2},
+ {0x0187, "DS-575WII","DS-575WII", 2},
+ {0x0186, "DS-570WII","DS-570WII", 2},
+ {0x017F, "ES-580W","ES-580W", 2},
+ {0x0180, "RR-600W","RR-600W", 2},
+ {0x0167, "DS-535","DS-535", 2},
+ {0x017A, "DS-535H","DS-535H", 2},
+ {0x0156, "ES-400","ES-400", 2},
+ {0x0155, "DS-530","DS-530", 2},
+ {0x016B, "FF-680W","FF-680W", 2},
+ {0x0157, "DS-570W","DS-570W", 2},
+ {0x0157, "ES-500W","ES-500W", 2},
+ {0x0169, "DS-575W","DS-575W", 2},
+ {0x0176, "ES-500WR","ES-500WR", 2},
+ {0x114E, "PID 114E","EW-052A Series", 7},
+ {0x114E, "PID 114E","XP-2100 Series", 7},
+ {0x1135, "PID 1135","ET-2700 Series", 7},
+ {0x1135, "PID 1135","L4150 Series", 7},
+ {0x114A, "PID 114A","ET-M2140 Series", 7},
+ {0x114A, "PID 114A","M2140 Series", 7},
+ {0x114F, "PID 114F","ET-M3140 Series", 7},
+ {0x114F, "PID 114F","M3140 Series", 7},
+ {0x1143, "PID 1143","L3150 Series", 7},
+ {0x1143, "PID 1143","ET-2710 Series", 7},
+ {0x00, "","", 0x00 }
+};
+
+typedef struct
+{
+ epsonds_profile_map *array;
+ int used;
+ int size;
+}epsonds_profile_map_array;
+
+
+static epsonds_profile_map_array stProfileMapArray;
+
+static void insert_profile_map(epsonds_profile_map_array *a, epsonds_profile_map element);
+
+static void init_profile_maps(epsonds_profile_map_array *a, size_t initialSize) {
+ a->array = malloc(initialSize * sizeof(epsonds_profile_map));
+ a->used = 0;
+ a->size = initialSize;
+
+ for (int i = 0; epsonds_models_predefined[i].productID != 0; i++) {
+
+ //DBG(6, "epsonds_models_predefined[i].productID = %x\n", epsonds_models_predefined[i].productID );
+
+ insert_profile_map(a, epsonds_models_predefined[i]);
+ }
+}
+
+static void insert_profile_map(epsonds_profile_map_array *a, epsonds_profile_map element) {
+ if (a->used == a->size) {
+ a->size *= 2;
+ a->array = realloc(a->array, a->size * sizeof(epsonds_profile_map));
+ }
+ a->array[a->used++] = element;
+}
+
+static void free_profile_maps(epsonds_profile_map_array *a) {
+ free(a->array);
+ a->array = NULL;
+ a->used = a->size = 0;
+}
+/////////////////////////
+
+
struct mode_param mode_params[] = {
{0, 0x00, 0x30, 1},
{0, 0x00, 0x30, 8},
@@ -86,16 +1313,12 @@ static SANE_String_Const mode_list[] = {
NULL
};
-static const SANE_String_Const adf_mode_list[] = {
- SANE_I18N("Simplex"),
- SANE_I18N("Duplex"),
- NULL
-};
/* Define the different scan sources */
-#define FBF_STR SANE_I18N("Flatbed")
-#define ADF_STR SANE_I18N("Automatic Document Feeder")
+#define STRING_FLATBED SANE_I18N("Flatbed")
+#define STRING_ADFFRONT SANE_I18N("ADF Front")
+#define STRING_ADFDUPLEX SANE_I18N("ADF Duplex")
/* order will be fixed: fb, adf, tpu */
SANE_String_Const source_list[] = {
@@ -129,6 +1352,9 @@ max_string_size(const SANE_String_Const strings[])
static SANE_Status attach_one_usb(SANE_String_Const devname);
static SANE_Status attach_one_net(SANE_String_Const devname);
+static SANE_Status acquire_jpeg_data(epsonds_scanner* s);
+static SANE_Status acquire_and_decode_jpeg_data(epsonds_scanner* s);
+static SANE_Status acquire_raw_data(epsonds_scanner* s);
static void
print_params(const SANE_Parameters params)
@@ -146,6 +1372,11 @@ close_scanner(epsonds_scanner *s)
{
DBG(7, "%s: fd = %d\n", __func__, s->fd);
+ if (s->scanning)
+ {
+ sane_cancel(s);
+ }
+
if (s->fd == -1)
goto free;
@@ -171,49 +1402,6 @@ free:
DBG(7, "%s: ZZZ\n", __func__);
}
-static void
-e2_network_discovery(void)
-{
- fd_set rfds;
- int fd, len;
- SANE_Status status;
-
- char *ip, *query = "EPSONP\x00\xff\x00\x00\x00\x00\x00\x00\x00";
- unsigned char buf[76];
-
- struct timeval to;
-
- status = sanei_udp_open_broadcast(&fd);
- if (status != SANE_STATUS_GOOD)
- return;
-
- sanei_udp_write_broadcast(fd, 3289, (unsigned char *) query, 15);
-
- DBG(5, "%s, sent discovery packet\n", __func__);
-
- to.tv_sec = 1;
- to.tv_usec = 0;
-
- FD_ZERO(&rfds);
- FD_SET(fd, &rfds);
-
- sanei_udp_set_nonblock(fd, SANE_TRUE);
- while (select(fd + 1, &rfds, NULL, NULL, &to) > 0) {
- if ((len = sanei_udp_recvfrom(fd, buf, 76, &ip)) == 76) {
- DBG(5, " response from %s\n", ip);
-
- /* minimal check, protocol unknown */
- if (strncmp((char *) buf, "EPSON", 5) == 0)
- attach_one_net(ip);
- }
- }
-
- DBG(5, "%s, end\n", __func__);
-
- sanei_udp_close(fd);
-}
-
-
static SANE_Status
open_scanner(epsonds_scanner *s)
{
@@ -230,7 +1418,7 @@ open_scanner(epsonds_scanner *s)
unsigned char buf[5];
/* device name has the form net:ipaddr */
- status = sanei_tcp_open(&s->hw->sane.name[4], 1865, &s->fd);
+ status = sanei_tcp_open(&s->hw->name[4], 1865, &s->fd);
if (status == SANE_STATUS_GOOD) {
ssize_t read;
@@ -272,12 +1460,10 @@ open_scanner(epsonds_scanner *s)
}
} else if (s->hw->connection == SANE_EPSONDS_USB) {
-
status = sanei_usb_open(s->hw->sane.name, &s->fd);
if (status == SANE_STATUS_GOOD) {
sanei_usb_set_timeout(USB_TIMEOUT);
- sanei_usb_clear_halt(s->fd);
}
} else {
@@ -307,7 +1493,6 @@ static struct epsonds_scanner *
scanner_create(struct epsonds_device *dev, SANE_Status *status)
{
struct epsonds_scanner *s;
-
s = malloc(sizeof(struct epsonds_scanner));
if (s == NULL) {
*status = SANE_STATUS_NO_MEM;
@@ -428,7 +1613,32 @@ device_detect(const char *name, int type, SANE_Status *status)
DBG(1, "scanner model: %s\n", dev->model);
- /* add this scanner to the device list */
+
+ s->hw->lut_id = 0;
+
+ for (int i = 0; i < stProfileMapArray.used; i++) {
+
+ epsonds_profile_map* map = &stProfileMapArray.array[i];
+
+
+ if (strcmp(map->productName, dev->model) == 0) {
+
+ {//Convert to user friendly model name
+ free(s->hw->model);
+
+ char* deviceName = (char*)malloc(strlen(map->deviceID) + 1);
+ memset(deviceName, 0, strlen(map->deviceID) + 1);
+ strncpy(deviceName, map->deviceID, strlen(map->deviceID));
+ s->hw->model = deviceName;
+ s->hw->sane.model = s->hw->model;
+ }
+ {// set lutid
+ s->hw->lut_id = map->lutID;
+ }
+ break;
+ }
+ }
+ DBG(1, "scanner lut_id: %d\n", s->hw->lut_id);
num_devices++;
dev->next = first_dev;
@@ -479,6 +1689,67 @@ attach_one_net(const char *dev)
return attach(name, SANE_EPSONDS_NET);
}
+static void found_net_device(const char* device_name, const char* ip)
+{
+ DBG(7, "Found %s: ip = %s\n", device_name, ip);
+
+ int foundSupportedDevice = 0;
+
+ // search models
+ for (int i = 0; i < stProfileMapArray.used; i++) {
+ if (strcmp(stProfileMapArray.array[i].deviceID, device_name) == 0) {
+ foundSupportedDevice = 1;
+ break;
+ }
+ }
+
+
+ if (foundSupportedDevice)
+ {
+ char name[39 + 4];
+
+ strcpy(name, "net:");
+ strncat(name, ip, 39);
+
+ int foundCache = 0;
+ // search cache and prents duplicated model
+ for (epsonds_device* dev = first_dev; dev; dev = dev->next) {
+ if (strcmp(dev->sane.name, name) == 0) {
+ foundCache = 1;
+ }
+ }
+ if (foundCache == 0)
+ {
+ attach(name, SANE_EPSONDS_NET);
+ }
+ }
+}
+
+static void
+splitProfileName(const char* input, int* outProductID, char *outProductName, char* outDeviceID, int* outLutID)
+{
+ char target[1024];
+ strncpy(target, input, 1023);
+
+ strtok(target, ":");//profile
+
+ //productID
+ char* pid = strtok(NULL, ",");
+ sscanf(pid, "%x", (unsigned int*)outProductID);
+
+ //productName
+ char* productName = strtok(NULL, ",");
+ strncpy(outProductName, productName, 49);
+
+ //deviceID
+ char* deviceID = strtok(NULL, ",");
+ strncpy(outDeviceID, deviceID, 49);
+
+ //lutID
+ char* lutID = strtok(NULL, ",");
+ sscanf(lutID, "%d", outLutID);
+}
+
static SANE_Status
attach_one_config(SANEI_Config __sane_unused__ *config, const char *line,
@@ -489,8 +1760,17 @@ attach_one_config(SANEI_Config __sane_unused__ *config, const char *line,
int len = strlen(line);
DBG(7, "%s: len = %d, line = %s\n", __func__, len, line);
+ if (strncmp(line, "profile", 7) == 0 ) {
+ DBG(7, " found profile device profile\n");
- if (sscanf(line, "usb %i %i", &vendor, &product) == 2) {
+ epsonds_profile_map profle_map;
+
+ splitProfileName(line, &profle_map.productID, profle_map.productName, profle_map.deviceID, &profle_map.lutID);
+
+ DBG(7, "Found profile : %x %s %s %d\n", profle_map.productID, profle_map.productName, profle_map.deviceID, profle_map.lutID);
+
+ insert_profile_map(&stProfileMapArray, profle_map);
+ }else if (sscanf(line, "usb %i %i", &vendor, &product) == 2) {
DBG(7, " user configured device\n");
@@ -501,15 +1781,11 @@ attach_one_config(SANEI_Config __sane_unused__ *config, const char *line,
} else if (strncmp(line, "usb", 3) == 0 && len == 3) {
- int i, numIds;
-
DBG(7, " probing usb devices\n");
- numIds = epsonds_get_number_of_ids();
-
- for (i = 0; i < numIds; i++) {
- sanei_usb_find_devices(SANE_EPSONDS_VENDOR_ID,
- epsonds_usb_product_ids[i], attach_one_usb);
+ for (int i = 0; i < stProfileMapArray.used; i++) {
+ int usbPid = stProfileMapArray.array[i].productID;
+ sanei_usb_find_devices(SANE_EPSONDS_VENDOR_ID, usbPid, attach_one_usb);
}
} else if (strncmp(line, "net", 3) == 0) {
@@ -520,11 +1796,17 @@ attach_one_config(SANEI_Config __sane_unused__ *config, const char *line,
sanei_config_skip_whitespace(line + 3);
if (strncmp(name, "autodiscovery", 13) == 0)
- e2_network_discovery();
+ {
+ #if WITH_AVAHI
+ epsonds_searchDevices(found_net_device);
+ #else
+ // currently does not support
+ //e2_network_discovery();
+ #endif
+ }
else
attach_one_net(name);
}
-
} else {
DBG(0, "unable to parse config line: %s\n", line);
}
@@ -564,6 +1846,9 @@ SANE_Status
sane_init(SANE_Int *version_code, SANE_Auth_Callback __sane_unused__ authorize)
{
DBG_INIT();
+
+ init_profile_maps(&stProfileMapArray, 100);
+
DBG(2, "%s: " PACKAGE " " VERSION "\n", __func__);
DBG(1, "epsonds backend, version %i.%i.%i\n",
@@ -582,6 +1867,7 @@ void
sane_exit(void)
{
DBG(5, "** %s\n", __func__);
+ free_profile_maps(&stProfileMapArray);
free_devices();
}
@@ -591,7 +1877,8 @@ sane_get_devices(const SANE_Device ***device_list, SANE_Bool local_only)
int i;
epsonds_device *dev;
- DBG(5, "** %s\n", __func__);
+ DBG(5, "** %s local_only = %d \n", __func__, local_only);
+
probe_devices(local_only);
@@ -612,12 +1899,14 @@ sane_get_devices(const SANE_Device ***device_list, SANE_Bool local_only)
*device_list = devlist;
+
return SANE_STATUS_GOOD;
}
static SANE_Status
init_options(epsonds_scanner *s)
{
+ DBG(5, "init_options\n");
int i;
for (i = 0; i < NUM_OPTIONS; i++) {
@@ -632,11 +1921,11 @@ init_options(epsonds_scanner *s)
s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
/* "Scan Mode" group: */
-
- s->opt[OPT_MODE_GROUP].title = SANE_I18N("Scan Mode");
- s->opt[OPT_MODE_GROUP].desc = "";
- s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
- s->opt[OPT_MODE_GROUP].cap = 0;
+ s->opt[OPT_STANDARD_GROUP].name = SANE_NAME_STANDARD;
+ s->opt[OPT_STANDARD_GROUP].title = SANE_TITLE_STANDARD;
+ s->opt[OPT_STANDARD_GROUP].desc = SANE_DESC_STANDARD;
+ s->opt[OPT_STANDARD_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_STANDARD_GROUP].cap = 0;
/* scan mode */
s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
@@ -761,18 +2050,6 @@ init_options(epsonds_scanner *s)
if (!s->hw->adf_has_load)
s->opt[OPT_LOAD].cap |= SANE_CAP_INACTIVE;
- s->opt[OPT_ADF_MODE].name = "adf-mode";
- s->opt[OPT_ADF_MODE].title = SANE_I18N("ADF Mode");
- s->opt[OPT_ADF_MODE].desc =
- SANE_I18N("Selects the ADF mode (simplex/duplex)");
- s->opt[OPT_ADF_MODE].type = SANE_TYPE_STRING;
- s->opt[OPT_ADF_MODE].size = max_string_size(adf_mode_list);
- s->opt[OPT_ADF_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
- s->opt[OPT_ADF_MODE].constraint.string_list = adf_mode_list;
- s->val[OPT_ADF_MODE].w = 0; /* simplex */
-
- if (!s->hw->adf_is_duplex)
- s->opt[OPT_ADF_MODE].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_ADF_SKEW].name = "adf-skew";
s->opt[OPT_ADF_SKEW].title = SANE_I18N("ADF Skew Correction");
@@ -781,8 +2058,26 @@ init_options(epsonds_scanner *s)
s->opt[OPT_ADF_SKEW].type = SANE_TYPE_BOOL;
s->val[OPT_ADF_SKEW].w = 0;
+
+ s->opt[OPT_ADF_CRP].name = "adf-crp";
+ s->opt[OPT_ADF_CRP].title = SANE_I18N("ADF CRP Correction");
+ s->opt[OPT_ADF_CRP].desc =
+ SANE_I18N("Enables ADF auto cropping"); //
+ s->opt[OPT_ADF_CRP].type = SANE_TYPE_BOOL;
+ s->val[OPT_ADF_CRP].w = 0;
+
+
if (!s->hw->adf_has_skew)
+ {
+ s->val[OPT_ADF_SKEW].w = 0;
s->opt[OPT_ADF_SKEW].cap |= SANE_CAP_INACTIVE;
+ }
+
+ if(!s->hw->adf_has_crp)
+ {
+ s->val[OPT_ADF_CRP].w = 0;
+ s->opt[OPT_ADF_CRP].cap |= SANE_CAP_INACTIVE;
+ }
return SANE_STATUS_GOOD;
}
@@ -793,6 +2088,8 @@ sane_open(SANE_String_Const name, SANE_Handle *handle)
SANE_Status status;
epsonds_scanner *s = NULL;
+
+
DBG(7, "** %s: name = '%s'\n", __func__, name);
/* probe if empty device name provided */
@@ -848,6 +2145,8 @@ sane_open(SANE_String_Const name, SANE_Handle *handle)
status = eds_lock(s);
}
+ setvalue((SANE_Handle)s, OPT_MODE, (void*)SANE_VALUE_SCAN_MODE_COLOR, NULL);
+
return status;
}
@@ -881,24 +2180,6 @@ search_string_list(const SANE_String_Const *list, SANE_String value)
return ((*list == NULL) ? NULL : list);
}
-static void
-activateOption(epsonds_scanner *s, SANE_Int option, SANE_Bool *change)
-{
- if (!SANE_OPTION_IS_ACTIVE(s->opt[option].cap)) {
- s->opt[option].cap &= ~SANE_CAP_INACTIVE;
- *change = SANE_TRUE;
- }
-}
-
-static void
-deactivateOption(epsonds_scanner *s, SANE_Int option, SANE_Bool *change)
-{
- if (SANE_OPTION_IS_ACTIVE(s->opt[option].cap)) {
- s->opt[option].cap |= SANE_CAP_INACTIVE;
- *change = SANE_TRUE;
- }
-}
-
/*
* Handles setting the source (flatbed, transparency adapter (TPU),
* or auto document feeder (ADF)).
@@ -911,7 +2192,6 @@ static void
change_source(epsonds_scanner *s, SANE_Int optindex, char *value)
{
int force_max = SANE_FALSE;
- SANE_Bool dummy;
DBG(1, "%s: optindex = %d, source = '%s'\n", __func__, optindex,
value);
@@ -928,26 +2208,17 @@ change_source(epsonds_scanner *s, SANE_Int optindex, char *value)
force_max = SANE_TRUE;
}
- if (strcmp(ADF_STR, value) == 0) {
-
+ if (strcmp(STRING_ADFFRONT, value) == 0 || strcmp(STRING_ADFDUPLEX, value) == 0) {
s->hw->x_range = &s->hw->adf_x_range;
s->hw->y_range = &s->hw->adf_y_range;
s->hw->alignment = s->hw->adf_alignment;
- if (s->hw->adf_is_duplex) {
- activateOption(s, OPT_ADF_MODE, &dummy);
- } else {
- deactivateOption(s, OPT_ADF_MODE, &dummy);
- s->val[OPT_ADF_MODE].w = 0;
- }
} else if (strcmp(TPU_STR, value) == 0) {
s->hw->x_range = &s->hw->tpu_x_range;
s->hw->y_range = &s->hw->tpu_y_range;
- deactivateOption(s, OPT_ADF_MODE, &dummy);
-
} else {
/* neither ADF nor TPU active, assume FB */
@@ -995,7 +2266,6 @@ getvalue(SANE_Handle handle, SANE_Int option, void *value)
break;
case OPT_MODE:
- case OPT_ADF_MODE:
case OPT_SOURCE:
strcpy((char *) value, sopt->constraint.string_list[sval->w]);
break;
@@ -1045,12 +2315,9 @@ setvalue(SANE_Handle handle, SANE_Int option, void *value, SANE_Int *info)
switch (option) {
- case OPT_ADF_MODE: /* simple lists */
- sval->w = optindex;
- break;
-
case OPT_ADF_SKEW:
case OPT_RESOLUTION:
+ case OPT_ADF_CRP:
sval->w = *((SANE_Word *) value);
reload = SANE_TRUE;
break;
@@ -1064,9 +2331,29 @@ setvalue(SANE_Handle handle, SANE_Int option, void *value, SANE_Int *info)
// fall through
case OPT_TL_X:
case OPT_TL_Y:
+
sval->w = *((SANE_Word *) value);
if (NULL != info)
*info |= SANE_INFO_RELOAD_PARAMS;
+
+ if (option == OPT_BR_X)
+ {
+ DBG(17, "OPT_BR_X = %d\n", sval->w);
+ }
+ if (option == OPT_BR_Y)
+ {
+ DBG(17, "OPT_BR_Y = %d\n", sval->w);
+ }
+ if (option == OPT_TL_X)
+ {
+ DBG(17, "OPT_TL_X = %d\n", sval->w);
+ }
+ if (option == OPT_TL_Y)
+ {
+ DBG(17, "OPT_TL_Y = %d\n", sval->w);
+ }
+ // adf crop set to off
+ s->val[OPT_ADF_CRP].w = 0;
break;
case OPT_SOURCE:
@@ -1076,6 +2363,8 @@ setvalue(SANE_Handle handle, SANE_Int option, void *value, SANE_Int *info)
case OPT_MODE:
{
+ DBG(17, " OPT_MODE = index %d\n", optindex);
+
/* use JPEG mode if RAW is not available when bpp > 1 */
if (optindex > 0 && !s->hw->has_raw) {
s->mode_jpeg = 1;
@@ -1152,6 +2441,183 @@ sane_control_option(SANE_Handle handle, SANE_Int option, SANE_Action action,
return SANE_STATUS_INVAL;
}
+
+static void setBit (SANE_Byte* bytes, SANE_Int bitIndex, SANE_Bool isTrue)
+{
+ SANE_Int octet = bitIndex / 8;
+ SANE_Byte bit = 7 - (bitIndex % 8);
+
+ if (isTrue) {
+ bytes[octet] |= (1 << bit);
+ } else {
+ bytes[octet] &= ~(1 << bit);
+ }
+}
+
+static SANE_Bool getBit (SANE_Byte* bytes, SANE_Int bitIndex)
+{
+ SANE_Int octet = bitIndex / 8;
+ SANE_Byte mask = 1 << (7 - (bitIndex % 8));
+
+ if( bytes[octet] & mask ){
+ return SANE_TRUE;
+ }
+
+ return SANE_FALSE;
+}
+
+static void swapPixel1(SANE_Int x1,
+ SANE_Int y1,
+ SANE_Int x2,
+ SANE_Int y2,
+ SANE_Byte* bytes,
+ SANE_Byte bitsPerSample,
+ SANE_Int samplesPerPixel,
+ SANE_Int bytesPerRow)
+{
+ SANE_Int pixelBits = bitsPerSample * samplesPerPixel;
+ SANE_Int widthBits = bytesPerRow * 8;
+
+ SANE_Byte temp = getBit(bytes, widthBits * y1 + x1 * pixelBits);
+ {
+ SANE_Byte right = getBit(bytes, widthBits * y2 + x2 * pixelBits);
+ setBit(bytes, widthBits * y1 + x1 * pixelBits, right);
+ }
+ setBit(bytes, widthBits * y2 + x2 * pixelBits, temp);
+}
+
+static void swapPixel8(SANE_Int x1,
+ SANE_Int y1,
+ SANE_Int x2,
+ SANE_Int y2,
+ SANE_Byte* bytes,
+ SANE_Byte bitsPerSample,
+ SANE_Int samplesPerPixel,
+ SANE_Int bytesPerRow)
+{
+ SANE_Int pixelBytes = samplesPerPixel * bitsPerSample / 8;
+
+ for (SANE_Byte i = 0; i < pixelBytes; i++) {
+ SANE_Byte temp = bytes[y1 * bytesPerRow + (pixelBytes * x1 + i)];
+ bytes[y1 * bytesPerRow + (pixelBytes * x1 + i)] = bytes[y2 * bytesPerRow + (pixelBytes * x2 + i)];
+ bytes[y2 * bytesPerRow + (pixelBytes * x2 + i)] = temp;
+ }
+}
+
+
+
+static void swapPixel(SANE_Int x1,
+ SANE_Int y1,
+ SANE_Int x2,
+ SANE_Int y2,
+ SANE_Byte* bytes,
+ SANE_Byte bitsPerSample,
+ SANE_Int samplesPerPixel,
+ SANE_Int bytesPerRow)
+{
+ if (bitsPerSample == 1) {
+ swapPixel1(x1, y1, x2, y2, bytes, bitsPerSample, samplesPerPixel, bytesPerRow);
+ }else if(bitsPerSample == 8 || bitsPerSample == 16){
+ swapPixel8(x1, y1, x2, y2, bytes, bitsPerSample, samplesPerPixel, bytesPerRow);
+ }
+}
+
+
+void
+upside_down_backside_image(epsonds_scanner *s)
+{
+ // get all data from ring_buffer
+ if (eds_ring_avail(&s->back) &&
+ (strcmp(s->hw->sane.model, (char*)"DS-1630") == 0
+ || strcmp(s->hw->sane.model, (char*)"DS-1610") == 0
+ || strcmp(s->hw->sane.model, (char*)"DS-1660W") == 0))
+ {
+ SANE_Int bytesPerLine = s->params.bytes_per_line;
+ SANE_Int imageSize = bytesPerLine * s->height_back;
+
+ SANE_Byte* workBuffer = malloc(imageSize);
+ // if there is not enough memory, do nothing.
+ if (workBuffer)
+ {
+ eds_ring_read(&s->back, workBuffer, imageSize);
+ SANE_Int samplesPerPxel = 3;
+ if (s->params.format == SANE_FRAME_RGB)
+ {
+ samplesPerPxel = 3;
+ }
+ else if (s->params.format == SANE_FRAME_GRAY)
+ {
+ samplesPerPxel = 1;
+ }
+
+ SANE_Int half = (s->height_back / 2) - 1;
+ if (half < 0) {
+ half = 0;
+ }
+
+ if((s->height_back % 2) == 1) {
+ SANE_Int ymid = ( (s->height_back - 1 ) / 2 );
+ for(SANE_Int x = 0;x < (s->width_back / 2); x++) {
+ swapPixel(x, ymid, s->width_back - x - 1, ymid, workBuffer, s->params.depth, samplesPerPxel, s->params.bytes_per_line);
+ }
+ }
+
+ if (s->height_back != 1) {
+ for(SANE_Int x = 0; x < s->width_back; x++) {
+ for(SANE_Int y = 0;y <= half; y++) {
+ swapPixel(x, y, s->width_back - x - 1, s->height_back - y -1, workBuffer, s->params.depth, samplesPerPxel, s->params.bytes_per_line);
+ }
+ }
+ }
+
+ eds_ring_write(&s->back, workBuffer, imageSize);
+ free(workBuffer);
+ workBuffer = NULL;
+
+ }
+ }
+
+}
+
+
+SANE_Status
+get_next_image(epsonds_scanner *s)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+
+ if (s->acquirePage == 0 && s->current == &s->front)
+ {
+ DBG(20, "** %s: get_next_image\n", __func__);
+
+
+ /*page info will be updatted by pen*/
+ s->width_back = 0;
+ s->width_front = 0;
+ s->height_back = 0;
+ s->height_front = 0;
+
+ if (s->mode_jpeg)
+ {
+ status = acquire_and_decode_jpeg_data(s);
+ }else{
+ status = acquire_raw_data(s);
+ }
+ if (status != SANE_STATUS_GOOD)
+ {
+ eds_ring_flush(&s->front);
+ eds_ring_flush(&s->back);
+ eds_ring_destory(&s->front);
+ eds_ring_destory(&s->back);
+ }
+ DBG(20," ringFront = %d ringBack = %d\n", eds_ring_avail(&s->front), eds_ring_avail(&s->back));
+
+ s->acquirePage = 1;
+ }
+
+ return status;
+}
+
+
SANE_Status
sane_get_parameters(SANE_Handle handle, SANE_Parameters *params)
{
@@ -1173,25 +2639,186 @@ sane_get_parameters(SANE_Handle handle, SANE_Parameters *params)
eds_init_parameters(s);
}
+
+ SANE_Status status = SANE_STATUS_GOOD;
+
+ status = get_next_image(s);
+
+ // if size auto, update page size value
+ if(s->val[OPT_ADF_CRP].w)
+ {
+ // frontside
+ if (s->current == &s->front)
+ {
+ DBG(20, "front side \n");
+ if (s->width_front != 0 && s->height_front != 0)
+ {
+ if (s->params.format == SANE_FRAME_RGB)
+ {
+ s->params.bytes_per_line = s->width_front * 3;
+ s->params.pixels_per_line = s->width_front;
+ }
+
+ if (s->params.format == SANE_FRAME_GRAY && s->params.depth == 8)
+ {
+ s->params.bytes_per_line = s->width_front;
+ s->params.pixels_per_line = s->width_front;
+ }
+
+ if (s->params.format == SANE_FRAME_GRAY && s->params.depth == 1)
+ {
+ s->params.bytes_per_line = (s->width_front + 7)/8;
+ s->params.pixels_per_line = s->width_front;
+ }
+ s->params.lines = s->height_front;
+ }
+ }
+ // backside
+ if (s->current == &s->back)
+ {
+ DBG(20, "back side \n");
+ if (s->width_back != 0 && s->height_back != 0)
+ {
+ if (s->params.format == SANE_FRAME_RGB)
+ {
+ s->params.bytes_per_line = s->width_back * 3;
+ s->params.pixels_per_line = s->width_back;
+ }
+
+ if (s->params.format == SANE_FRAME_GRAY && s->params.depth == 8)
+ {
+ s->params.bytes_per_line = s->width_back;
+ s->params.pixels_per_line = s->width_back;
+ }
+
+ if (s->params.format == SANE_FRAME_GRAY && s->params.depth == 1)
+ {
+ s->params.bytes_per_line = (s->width_back + 7)/8;
+ s->params.pixels_per_line = s->width_back;
+ }
+ s->params.lines = s->height_back;
+ }
+ }
+ }
if (params != NULL)
*params = s->params;
print_params(s->params);
- return SANE_STATUS_GOOD;
+ DBG(20, "s->params.line = %d s->params.bytes_per_line = %d s->params.pixels_per_line = %d \n", s->params.lines, s->params.bytes_per_line , s->params.pixels_per_line );
+ return status;
}
+
+
+typedef float ColorMatrix[3][3];
+
+#define CCT_TABLE_SIZE 9
+static int get_roundup_index(double frac[], int n)
+{
+ int i, index = -1;
+ double max_val = 0.0;
+
+ for (i=0; i<n; i++) {
+ if (frac[i]<0) continue;
+ if (max_val<frac[i]) {
+ index = i;
+ max_val = frac[i];
+ }
+ }
+ return index;
+}
+
+static int get_rounddown_index(double frac[], int n)
+{
+ int i, index = -1;
+ double min_val = 1.0;
+
+ for (i=0; i<n; i++) {
+ if (frac[i]>0) continue;
+ if (min_val>frac[i]) {
+ index = i;
+ min_val = frac[i];
+ }
+ }
+ return index;
+}
+
+
+void ESCIRoundColorCorrectionMatrix(int mult, double org_cct[], int rnd_cct[])
+{
+ int i, j, index;
+ double mult_cct[CCT_TABLE_SIZE], frac[CCT_TABLE_SIZE];
+ int sum[3];
+ int loop;
+
+ for (i=0; i<CCT_TABLE_SIZE; i++) {
+ mult_cct[i] = org_cct[i] * mult;
+ }
+
+ // round value multiplied by 'mult' off to integer.
+ for (i=0; i<CCT_TABLE_SIZE; i++) {
+ rnd_cct[i] = (int)floor(org_cct[i] * mult + 0.5);
+ }
+
+ loop=0;
+ do {
+ // If all element equal to 11, diagonal element is set to 10.
+ for (i=0; i<3; i++) {
+ if ( (rnd_cct[i*3]==11) &&
+ (rnd_cct[i*3]==rnd_cct[i*3+1]) &&
+ (rnd_cct[i*3]==rnd_cct[i*3+2]) ) {
+ rnd_cct[i*3+i] --;
+ mult_cct[i*3+i] = rnd_cct[i*3+i];
+ }
+ }
+ // calc. summation of each line.
+ for (i=0; i<3; i++) {
+ sum[i] = 0;
+ for (j=0; j<3; j++) {
+ sum[i] += rnd_cct[i*3+j];
+ }
+ }
+ // calc. values rounded up or down.
+ for (i=0; i<CCT_TABLE_SIZE; i++) {
+ frac[i] = mult_cct[i] - rnd_cct[i];
+ }
+
+ // if summation does not equal to 'mult', adjust rounded up or down value.
+ for (i=0; i<3; i++) {
+ if (sum[i]<mult) {
+ index = get_roundup_index(&frac[i*3], 3);
+ if (index!=-1) {
+ rnd_cct[i*3+index] ++;
+ mult_cct[i*3+index] = rnd_cct[i*3+index];
+ sum[i]++;
+ }
+ } else if (sum[i]>mult) {
+ index = get_rounddown_index(&frac[i*3], 3);
+ if (index!=-1) {
+ rnd_cct[i*3+index] --;
+ mult_cct[i*3+index] = rnd_cct[i*3+index];
+ sum[i]--;
+ }
+ }
+ }
+
+ } while ((++loop<2)&&((sum[0]!=mult)||(sum[1]!=mult)||(sum[2]!=mult)));
+}
+
+
+
/*
* This function is part of the SANE API and gets called from the front end to
* start the scan process.
*/
-
+#define CMD_BUF_SIZE 1000
SANE_Status
sane_start(SANE_Handle handle)
{
epsonds_scanner *s = (epsonds_scanner *)handle;
char buf[65]; /* add one more byte to correct buffer overflow issue */
- char cmd[100]; /* take care not to overflow */
+ char cmd[CMD_BUF_SIZE]; /* take care not to overflow */
SANE_Status status = 0;
s->pages++;
@@ -1203,26 +2830,28 @@ sane_start(SANE_Handle handle)
s->eof = 0;
s->canceling = 0;
+ s->acquirePage = 0;
if ((s->pages % 2) == 1) {
s->current = &s->front;
- eds_ring_flush(s->current);
} else if (eds_ring_avail(&s->back)) {
DBG(5, "back side\n");
s->current = &s->back;
}
- /* prepare the JPEG decompressor */
- if (s->mode_jpeg) {
- status = eds_jpeg_start(s);
- if (status != SANE_STATUS_GOOD) {
- goto end;
- } }
-
/* scan already in progress? (one pass adf) */
- if (s->scanning) {
+ if (s->scanning || eds_ring_avail(&s->back) > 0) {
DBG(5, " scan in progress, returning early\n");
- return SANE_STATUS_GOOD;
+ return get_next_image(s);
+ }
+ if (strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFFRONT) == 0 || strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFDUPLEX) == 0) {
+ if (s->scanEnd)
+ {
+ s->scanEnd = 0;
+ return SANE_STATUS_NO_DOCS;
+ }
+ }else{
+ s->scanEnd = 0;
}
/* calc scanning parameters */
@@ -1239,13 +2868,7 @@ sane_start(SANE_Handle handle)
/* transfer buffer size, bsz */
/* XXX read value from scanner */
- s->bsz = (65536 * 4);
-
- /* ring buffer for front page */
- status = eds_ring_init(&s->front, s->bsz * 2);
- if (status != SANE_STATUS_GOOD) {
- return status;
- }
+ s->bsz = (1048576 * 4);
/* transfer buffer */
s->buf = realloc(s->buf, s->bsz);
@@ -1256,29 +2879,34 @@ sane_start(SANE_Handle handle)
/* set scanning parameters */
+ s->isDuplexScan = 0;
/* document source */
- if (strcmp(source_list[s->val[OPT_SOURCE].w], ADF_STR) == 0) {
+ if (strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFFRONT) == 0 || strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFDUPLEX) == 0) {
- sprintf(buf, "#ADF%s%s",
- s->val[OPT_ADF_MODE].w ? "DPLX" : "",
- s->val[OPT_ADF_SKEW].w ? "SKEW" : "");
-
- /* it seems that DFL only works in duplex mode, but it's
- * also required to be enabled or duplex will be rejected.
- */
-
- if (s->val[OPT_ADF_MODE].w) {
-
- if (s->hw->adf_has_dfd == 2) {
- strcat(buf, "DFL2");
- } else if (s->hw->adf_has_dfd == 1) {
- strcat(buf, "DFL1");
- }
+ SANE_Int status = esci2_stat(s);
+ if (status == SANE_STATUS_NO_DOCS)
+ {
+ return SANE_STATUS_NO_DOCS;
}
- } else if (strcmp(source_list[s->val[OPT_SOURCE].w], FBF_STR) == 0) {
+ SANE_Int duplexMode = (strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFDUPLEX) == 0);
+
+ sprintf(buf, "#ADF%s%s%s",
+ duplexMode ? "DPLX" : "",
+ s->val[OPT_ADF_SKEW].w ? "SKEW" : "",
+ s->val[OPT_ADF_CRP].w ? "CRP " : ""
+ );
+
+ if (duplexMode)
+ {
+ s->isDuplexScan = 1;
+ }
+ s->isflatbedScan = 0;
+ }
+ else if (strcmp(source_list[s->val[OPT_SOURCE].w], STRING_FLATBED) == 0) {
strcpy(buf, "#FB ");
+ s->isflatbedScan = 1;
} else {
/* XXX */
@@ -1286,8 +2914,18 @@ sane_start(SANE_Handle handle)
strcpy(cmd, buf);
+ s->needToConvertBW = 0;
+
if (s->params.format == SANE_FRAME_GRAY) {
- sprintf(buf, "#COLM%03d", s->params.depth);
+ if (s->params.depth == 1 && s->hw->has_mono == 0)
+ {
+ sprintf(buf, "#COLM008");
+ s->needToConvertBW = 1;
+ s->mode_jpeg = 1;
+ }else
+ {
+ sprintf(buf, "#COLM%03d", s->params.depth);
+ }
} else if (s->params.format == SANE_FRAME_RGB) {
sprintf(buf, "#COLC%03d", s->params.depth * 3);
}
@@ -1303,9 +2941,29 @@ sane_start(SANE_Handle handle)
strcat(cmd, "#FMTJPG #JPGd090");
}
+ /* set GMM */
+ if (s->params.depth == 1)
+ {
+ sprintf(buf, "#GMMUG10");
+ } else
+ {
+ sprintf(buf, "#GMMUG18");
+ }
+ strcat(cmd, buf);
+
/* resolution (RSMi not always supported) */
- if (s->val[OPT_RESOLUTION].w > 999) {
+ if (strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFFRONT) == 0 && s->val[OPT_RESOLUTION].w > 600) {
+ DBG(0, "Automatic Document Feeder supported resolution of 600dpi or less. \n");
+ } else if (s->val[OPT_RESOLUTION].w > 999) {
+ sprintf(buf, "#RSMi%07d#RSSi%07d", s->val[OPT_RESOLUTION].w, s->val[OPT_RESOLUTION].w);
+ } else {
+ sprintf(buf, "#RSMd%03d#RSSd%03d", s->val[OPT_RESOLUTION].w, s->val[OPT_RESOLUTION].w);
+ }
+
+ if (strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFDUPLEX) == 0 && s->val[OPT_RESOLUTION].w > 600) {
+ DBG(0, "Automatic Document Feeder supported resolution of 600dpi or less. \n");
+ } else if (s->val[OPT_RESOLUTION].w > 999) {
sprintf(buf, "#RSMi%07d#RSSi%07d", s->val[OPT_RESOLUTION].w, s->val[OPT_RESOLUTION].w);
} else {
sprintf(buf, "#RSMd%03d#RSSd%03d", s->val[OPT_RESOLUTION].w, s->val[OPT_RESOLUTION].w);
@@ -1313,13 +2971,321 @@ sane_start(SANE_Handle handle)
strcat(cmd, buf);
+ if (strcmp(s->hw->sane.model, (char*)"DS-70") == 0 || strcmp(s->hw->sane.model, (char*)"ES-65WR") == 0 || strcmp(s->hw->sane.model, (char*)"ES-60W") == 0
+ || strcmp(s->hw->sane.model, (char*)"DS-80W") == 0 || strcmp(s->hw->sane.model, (char*)"ES-55R") == 0 || strcmp(s->hw->sane.model, (char*)"ES-50") == 0){
+ sprintf(buf, "#BSZi0262144");
+ strcat(cmd, buf);
+ }
+ else {
+ sprintf(buf, "#BSZi1048576");
+ strcat(cmd, buf);
+ }
+
+
/* scanning area */
+
sprintf(buf, "#ACQi%07di%07di%07di%07d",
s->left, s->top, s->params.pixels_per_line, s->params.lines);
+
+ if (strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFFRONT) == 0 || strcmp(source_list[s->val[OPT_SOURCE].w], STRING_ADFDUPLEX) == 0) {
+ status = esci2_stat(s);
+ if (status != SANE_STATUS_GOOD) {
+ goto end;
+ }
+ }
+
strcat(cmd, buf);
- status = esci2_para(s, cmd);
+
+ int pos = 0;
+
+ {
+ for (int i = 0; i < CMD_BUF_SIZE; i++)
+ {
+ // find end of string
+ if(cmd[i] == 0)
+ {
+ pos = i;
+ break;
+ }
+ }
+
+
+ if (s->params.format == SANE_FRAME_GRAY && s->params.depth == 8) {
+ DBG(10, "SANE_FRAME_GRAY\n");
+ cmd[pos++] = '#';
+ cmd[pos++] = 'G';
+ cmd[pos++] = 'M';
+ cmd[pos++] = 'T';
+ cmd[pos++] = 'M';
+ cmd[pos++] = 'O';
+ cmd[pos++] = 'N';
+ cmd[pos++] = 'O';
+ cmd[pos++] = 'h';
+ cmd[pos++] = '1';
+ cmd[pos++] = '0';
+ cmd[pos++] = '0';
+
+ for(int count = 0; count < 256; count++) {
+ cmd[pos++] = LUT[s->hw->lut_id][count];
+ }
+ }
+ if (s->params.format == SANE_FRAME_GRAY && s->params.depth == 1) {
+ DBG(10, "SANE_FRAME_GRAY\n");
+ cmd[pos++] = '#';
+ cmd[pos++] = 'G';
+ cmd[pos++] = 'M';
+ cmd[pos++] = 'T';
+ cmd[pos++] = 'M';
+ cmd[pos++] = 'O';
+ cmd[pos++] = 'N';
+ cmd[pos++] = 'O';
+ cmd[pos++] = 'h';
+ cmd[pos++] = '1';
+ cmd[pos++] = '0';
+ cmd[pos++] = '0';
+
+ for(int count = 0; count < 256; count++) {
+ cmd[pos++] = LUT[0][count];
+ }
+ }
+ else if (s->params.format == SANE_FRAME_RGB) {
+ DBG(10, "SANE_FRAME_RGB\n");
+ cmd[pos++] = '#';
+ cmd[pos++] = 'G';
+ cmd[pos++] = 'M';
+ cmd[pos++] = 'T';
+ cmd[pos++] = 'R';
+ cmd[pos++] = 'E';
+ cmd[pos++] = 'D';
+ cmd[pos++] = ' ';
+ cmd[pos++] = 'h';
+ cmd[pos++] = '1';
+ cmd[pos++] = '0';
+ cmd[pos++] = '0';
+
+ for(int count = 0; count < 256; count++) {
+ cmd[pos++] = LUT_R[s->hw->lut_id][count];
+ }
+
+ cmd[pos++] = '#';
+ cmd[pos++] = 'G';
+ cmd[pos++] = 'M';
+ cmd[pos++] = 'T';
+ cmd[pos++] = 'G';
+ cmd[pos++] = 'R';
+ cmd[pos++] = 'N';
+ cmd[pos++] = ' ';
+ cmd[pos++] = 'h';
+ cmd[pos++] = '1';
+ cmd[pos++] = '0';
+ cmd[pos++] = '0';
+
+ for(int count = 0; count < 256; count++) {
+ cmd[pos++] = LUT_G[s->hw->lut_id][count];
+ }
+
+ cmd[pos++] = '#';
+ cmd[pos++] = 'G';
+ cmd[pos++] = 'M';
+ cmd[pos++] = 'T';
+ cmd[pos++] = 'B';
+ cmd[pos++] = 'L';
+ cmd[pos++] = 'U';
+ cmd[pos++] = ' ';
+ cmd[pos++] = 'h';
+ cmd[pos++] = '1';
+ cmd[pos++] = '0';
+ cmd[pos++] = '0';
+
+ for(int count = 0; count < 256; count++) {
+ cmd[pos++] = LUT_B[s->hw->lut_id][count];
+ }
+ }
+ cmd[pos] = 0;
+
+ }
+ {// Set Color Matrix
+ if (s->params.format == SANE_FRAME_RGB && s->hw->lut_id != 0 )/*Color Matrix Target devide and color Scan*/
+ {
+ ColorMatrix matrix;
+
+ // DS-530
+
+ if (s->hw->lut_id == 2)
+ {
+ // R
+ matrix[0][0] = 1.0229;
+ matrix[0][1] = 0.0009;
+ matrix[0][2] = -0.0238;
+
+ // G
+ matrix[1][0] = 0.0031;
+ matrix[1][1] = 1.0287;
+ matrix[1][2] = -0.0318;
+
+ //B
+ matrix[2][0] = 0.0044;
+ matrix[2][1] = -0.1150;
+ matrix[2][2] = 1.1106;
+ }
+
+ // DS-1660W Flatbed
+
+ if (s->hw->lut_id == 4)
+ {
+ // R
+ matrix[0][0] = 1.0229;
+ matrix[0][1] = 0.0009;
+ matrix[0][2] = -0.0238;
+
+ // G
+ matrix[1][0] = 0.0031;
+ matrix[1][1] = 1.0287;
+ matrix[1][2] = -0.0318;
+
+ //B
+ matrix[2][0] = 0.0044;
+ matrix[2][1] = -0.1150;
+ matrix[2][2] = 1.1106;
+ }
+
+
+ // DS-320
+
+ if (s->hw->lut_id == 5)
+ {
+ // R
+ matrix[0][0] = 1.0250;
+ matrix[0][1] = 0.0004;
+ matrix[0][2] = -0.0254;
+
+ // G
+ matrix[1][0] = 0.0003;
+ matrix[1][1] = 1.0022;
+ matrix[1][2] = -0.0025;
+
+ //B
+ matrix[2][0] = 0.0049;
+ matrix[2][1] = -0.0949;
+ matrix[2][2] = 1.0900;
+ }
+
+
+ // ES-50
+
+ if (s->hw->lut_id == 6)
+ {
+ // R
+ matrix[0][0] = 1.0383;
+ matrix[0][1] = -0.0021;
+ matrix[0][2] = -0.0362;
+
+ // G
+ matrix[1][0] = 0.0046;
+ matrix[1][1] = 1.0576;
+ matrix[1][2] = -0.0622;
+
+ //B
+ matrix[2][0] = 0.0235;
+ matrix[2][1] = -0.2396;
+ matrix[2][2] = 1.2161;
+ }
+
+
+ // R
+ matrix[0][0] = 0.9864;
+ matrix[0][1] = 0.0248;
+ matrix[0][2] = -0.0112;
+
+ // G
+ matrix[1][0] = 0.0021;
+ matrix[1][1] = 1.0100;
+ matrix[1][2] = -0.0112;
+
+ //B
+ matrix[2][0] = 0.0139;
+ matrix[2][1] = -0.1249;
+ matrix[2][2] = 1.1110;
+
+
+ // Set Matrix value
+ {
+ cmd[pos++] = '#';
+ cmd[pos++] = 'C';
+ cmd[pos++] = 'M';
+ cmd[pos++] = 'X';
+ cmd[pos++] = 'U';
+ cmd[pos++] = 'M';
+ cmd[pos++] = '0';
+ cmd[pos++] = '8';
+ cmd[pos++] = 'h';
+ cmd[pos++] = '0';
+ cmd[pos++] = '0';
+ cmd[pos++] = '9';
+ }
+
+
+ // Matrix to be sent to scanner must be following d1-d9 order:
+ //
+ // G R B
+ // G [d1 d4 d7]
+ // R [d2 d5 d8]
+ // B [d3 d6 d9]
+ //
+ // So, we will convert it with index table.
+ char index[9] = {4, 1, 7, 3, 0, 6, 5, 2, 8};
+
+ double flatten[9] = {0};
+ for (int row = 0; row < 3; row++) {
+ for (int col = 0; col < 3; col++) {
+ flatten[row * 3 + col] = matrix[row][col];
+ }
+ }
+
+ int rounded[9] = {0};
+ ESCIRoundColorCorrectionMatrix(32, flatten, rounded);
+
+
+ char ordered[9] = {0};
+ for (int row = 0; row < 3; row++) {
+ for (int col = 0; col < 3; col++) {
+ int val = rounded[row * 3 + col];
+ unsigned char oct = (unsigned char)abs(val);
+ oct |= ((val < 0) ? (1 << 7) : 0);
+ ordered[(signed char)index[row * 3 + col]] = oct;
+ }
+ }
+ {
+ cmd[pos++] = ordered[0];
+ cmd[pos++] = ordered[1];
+ cmd[pos++] = ordered[2];
+ cmd[pos++] = ordered[3];
+ cmd[pos++] = ordered[4];
+ cmd[pos++] = ordered[5];
+ cmd[pos++] = ordered[6];
+ cmd[pos++] = ordered[7];
+ cmd[pos++] = ordered[8];
+ cmd[pos++] = 0; //padding
+ cmd[pos++] = 0; //padding
+ cmd[pos++] = 0; //padding
+
+
+ DBG(1, "color matrix\n");
+ for (int i = 0; i < 9; i++)
+ {
+ DBG(1, "%d\n", ordered[i]);
+ }
+
+ }
+ cmd[pos] = 0;
+ }
+
+ }
+
+
+ status = esci2_para(s, cmd, pos);
if (status != SANE_STATUS_GOOD) {
goto end;
}
@@ -1336,7 +3302,8 @@ sane_start(SANE_Handle handle)
/* first page is page 1 */
s->pages = 1;
s->scanning = 1;
-
+ s->dummy = 0;
+ s->scanEnd = 0;
end:
if (status != SANE_STATUS_GOOD) {
DBG(1, "%s: start failed: %s\n", __func__, sane_strstatus(status));
@@ -1345,140 +3312,305 @@ end:
return status;
}
-/* this moves data from our buffers to SANE */
-
-SANE_Status
-sane_read(SANE_Handle handle, SANE_Byte *data, SANE_Int max_length,
- SANE_Int *length)
+static SANE_Status acquire_jpeg_data(epsonds_scanner* s)
{
- SANE_Int read = 0, tries = 3;
- SANE_Int available;
- SANE_Status status = 0;
- epsonds_scanner *s = (epsonds_scanner *)handle;
- *length = read = 0;
+ SANE_Int read = 0;
- DBG(20, "** %s: backside = %d\n", __func__, s->backside);
-
- /* sane_read called before sane_start? */
- if (s->current == NULL) {
- DBG(0, "%s: buffer is NULL", __func__);
- return SANE_STATUS_INVAL;
+ SANE_Int jpegBufSize = s->params.bytes_per_line * s->params.lines;
+ if (s->needToConvertBW)
+ {
+ jpegBufSize = s->params.pixels_per_line * s->params.lines;
}
+
+ s->frontJpegBuf = malloc(jpegBufSize);
+ s->backJpegBuf = malloc(jpegBufSize);
+ s->frontJpegBufLen = 0;
+ s->backJpegBufLen = 0;
+
+ // load all images, decode and fill buffer
+ SANE_Int status = SANE_STATUS_GOOD;
+
+ int eofFront = 0;
+ int eofBack = 0;
+
+
+ status = eds_ring_init(&s->front, (s->params.bytes_per_line) * s->params.lines);
+ if (status != SANE_STATUS_GOOD) {
+ return status;
+ }
+
+ status = eds_ring_init(&s->back, (s->params.bytes_per_line) * s->params.lines);
+ if (status != SANE_STATUS_GOOD) {
+ return status;
+ }
+
+ while (1)
+ {
+ status = esci2_img(s, &read);
+ DBG(20, "acquire_jpeg_data read: %d, eof: %d, backside: %d, status: %d\n", read, s->eof, s->backside, status);
+ if (read)
+ {
+ if (s->backside)
+ {
+ SANE_Byte* backBuffer = s->backJpegBuf + s->backJpegBufLen;
+ memcpy(backBuffer, s->buf, read);
+ s->backJpegBufLen += read;
+ }else{
+ SANE_Byte* frontBuffer = s->frontJpegBuf + s->frontJpegBufLen ;
+ memcpy(frontBuffer, s->buf, read);
+ s->frontJpegBufLen += read;
+ }
+ }
+ if (status == SANE_STATUS_GOOD)
+ {
+
+ DBG(20, "continue acquire image\n");
+ continue;
+ }
+ else if (status == SANE_STATUS_EOF)
+ {
+ if (s->backside)
+ {
+ DBG(20, "eofBack\n");
+ eofBack = 1;
+ }else{
+ DBG(20, "eofFront\n");
+ eofFront = 1;
+ }
+ }else if (status == SANE_STATUS_CANCELLED)
+ {
+ // cancel cleanup
+ esci2_can(s);
+
+ free(s->frontJpegBuf);
+ free(s->backJpegBuf);
+ s->frontJpegBuf = NULL;
+ s->backJpegBuf = NULL;
+ return status;
+ }else{
+ // error occurs cleanup
+ free(s->frontJpegBuf);
+ free(s->backJpegBuf);
+ s->frontJpegBuf = NULL;
+ s->backJpegBuf = NULL;
+ return status;
+ }
+
+
+ if (s->isDuplexScan)
+ {
+ DBG(20, "eofFront = %d eofBack = %d\n", eofFront, eofBack);
+ // acquire finish
+ if (eofFront && eofBack)
+ {
+ DBG(20, "eofFront && eofBack end\n");
+ break;
+ }
+ }else{
+ if (eofFront)
+ {
+ DBG(20, "eofFront end\n");
+ break;
+ }
+ }
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+acquire_raw_data(epsonds_scanner* s)
+{
+ SANE_Int read = 0;
+
+ // load all images, decode and fill buffer
+ SANE_Int status = SANE_STATUS_GOOD;
+
+ int eofFront = 0;
+ int eofBack = 0;
+ int firstWrite = 1;
+
+ while (1)
+ {
+ DBG(20, "acquire_raw_data loop start\n");
+ status = esci2_img(s, &read);
+ DBG(20, "acquire_raw_data read: %d, eof: %d, backside: %d, status: %d\n", read, s->eof, s->backside, status);
+
+ if (read)
+ {
+ if (firstWrite)
+ {
+ status = eds_ring_init(&s->front, (s->params.bytes_per_line + s->dummy) * s->params.lines);
+ if (status != SANE_STATUS_GOOD) {
+ return status;
+ }
+
+ status = eds_ring_init(&s->back, (s->params.bytes_per_line + s->dummy) * s->params.lines);
+ if (status != SANE_STATUS_GOOD) {
+ return status;
+ }
+ firstWrite = 0;
+ }
+
+ DBG(20, "eds_ring_write start\n");
+ status = eds_ring_write(s->backside ? &s->back : &s->front, s->buf, read);
+ DBG(20, "eds_ring_write end\n");
+ }
+ DBG(20, "acquire_raw_data3\n");
+
+ if (status == SANE_STATUS_GOOD)
+ {
+ DBG(20, "contiune acquire image\n");
+ continue;
+ }
+ else if (status == SANE_STATUS_EOF)
+ {
+ if (s->backside)
+ {
+ eofBack = 1;
+ }else{
+ eofFront = 1;
+ }
+ }
+ else if (status == SANE_STATUS_CANCELLED)
+ {
+ esci2_can(s);
+ return status;
+ }else{
+ // error occurs cleanup
+ return status;
+ }
+
+ if (s->isDuplexScan)
+ {
+ // acquire finish
+ if (eofFront && eofBack)
+ {
+ break;
+ }
+ }else{
+ if (eofFront)
+ {
+ break;
+ }
+ }
+ }
+
+
+ int needBytes = (s->params.bytes_per_line + s->dummy) * s->params.lines;
+ {
+ int available = eds_ring_avail(&s->front);
+ if (available < needBytes)
+ {
+ int required = needBytes - available;
+ unsigned char* padding = (unsigned char*)malloc(required);
+ memset(padding, 255, required);
+ eds_ring_write(&s->front, padding, required);
+ free(padding);
+
+ }
+
+ }
+ {
+ int available = eds_ring_avail(&s->back);
+ if (available > 0 && available < needBytes)
+ {
+ int required = needBytes - available;
+ unsigned char* padding = (unsigned char*)malloc(required);
+ memset(padding, 255, required);
+ eds_ring_write(&s->back, padding, required);
+ free(padding);
+ }
+
+ }
+
+ if (s->isDuplexScan)
+ {
+ upside_down_backside_image(s);
+ }
+
+ DBG(20, "acquire_raw_data finish");
+ return SANE_STATUS_GOOD;
+
+}
+
+static SANE_Status
+acquire_and_decode_jpeg_data(epsonds_scanner* s)
+{
+ SANE_Int status = acquire_jpeg_data(s);
+ if (status == SANE_STATUS_GOOD)
+ {
+ DBG(20, "** %s: sane status = %d needToConvertBW = %d \n", __func__, status, s->needToConvertBW);
+
+ // process front page
+ if (s->frontJpegBufLen > 0)
+ {
+ eds_decode_jpeg(s, s->frontJpegBuf, s->frontJpegBufLen, &s->front,0, s->needToConvertBW);
+ free(s->frontJpegBuf);
+ s->frontJpegBuf = NULL;
+ }
+ // process back page
+ if (s->backJpegBufLen > 0)
+ {
+ eds_decode_jpeg(s, s->backJpegBuf, s->backJpegBufLen, &s->back, 1, s->needToConvertBW);
+ free(s->backJpegBuf);
+ s->backJpegBuf = NULL;
+ }
+
+ if (s->isDuplexScan)
+ {
+ upside_down_backside_image(s);
+ }
+ }else{
+ DBG(20, "** %s: sane finish status = %d\n", __func__, status);
+ return status;
+ }
+ return status;
+}
+
+int sumLength = 0;
+/* this moves data from our buffers to SANE */
+SANE_Status
+sane_read(SANE_Handle handle, SANE_Byte *data, SANE_Int max_length, SANE_Int *length)
+{
+ epsonds_scanner *s = (epsonds_scanner *)handle;
+ SANE_Int read = 0;
+
+ if (s->canceling)
+ {
+ esci2_can(s);
+ *length = 0;
+ return SANE_STATUS_CANCELLED;
+ }
+
+ int available = eds_ring_avail(s->current);
/* anything in the buffer? pass it to the frontend */
- available = eds_ring_avail(s->current);
- if (available) {
+ if (available > 0) {
DBG(18, "reading from ring buffer, %d left\n", available);
- if (s->mode_jpeg && !s->jpeg_header_seen) {
-
- status = eds_jpeg_read_header(s);
- if (status != SANE_STATUS_GOOD && --tries) {
- goto read_again;
- }
- }
-
- if (s->mode_jpeg) {
- eds_jpeg_read(handle, data, max_length, &read);
- } else {
- eds_copy_image_from_ring(s, data, max_length, &read);
- }
+ eds_copy_image_from_ring(s, data, max_length, &read);
+ // data is empty fin
if (read == 0) {
- goto read_again;
+ *length = 0;
+ eds_ring_flush(s->current);
+ eds_ring_destory(s->current);
+ DBG(18, "returns EOF 2\n");
+ return SANE_STATUS_EOF;
}
-
*length = read;
return SANE_STATUS_GOOD;
-
-
- } else if (s->current == &s->back) {
-
- /* finished reading the back page, next
- * command should give us the EOF
- */
- DBG(18, "back side ring buffer empty\n");
+ }else{
+ *length = 0;
+ eds_ring_flush(s->current);
+ eds_ring_destory(s->current);
+ DBG(18, "returns EOF 1\n");
+ return SANE_STATUS_EOF;
}
-
- /* read until data or error */
-
-read_again:
-
- status = esci2_img(s, &read);
- if (status != SANE_STATUS_GOOD) {
- DBG(20, "read: %d, eof: %d, backside: %d, status: %d\n", read, s->eof, s->backside, status);
- }
-
- /* just got a back side page, alloc ring buffer if necessary
- * we didn't before because dummy was not known
- */
- if (s->backside) {
-
- int required = s->params.lines * (s->params.bytes_per_line + s->dummy);
-
- if (s->back.size < required) {
-
- DBG(20, "allocating buffer for the back side\n");
-
- status = eds_ring_init(&s->back, required);
- if (status != SANE_STATUS_GOOD) {
- return status;
- }
- }
- }
-
- /* abort scanning when appropriate */
- if (status == SANE_STATUS_CANCELLED) {
- esci2_can(s);
- return status;
- }
-
- if (s->eof && s->backside) {
- DBG(18, "back side scan finished\n");
- }
-
- /* read again if no error and no data */
- if (read == 0 && status == SANE_STATUS_GOOD) {
- goto read_again;
- }
-
- /* got something, write to ring */
- if (read) {
-
- DBG(20, " %d bytes read, %d lines, eof: %d, canceling: %d, status: %d, backside: %d\n",
- read, read / (s->params.bytes_per_line + s->dummy),
- s->canceling, s->eof, status, s->backside);
-
- /* move data to the appropriate ring */
- status = eds_ring_write(s->backside ? &s->back : &s->front, s->buf, read);
-
- if (0 && s->mode_jpeg && !s->jpeg_header_seen
- && status == SANE_STATUS_GOOD) {
-
- status = eds_jpeg_read_header(s);
- if (status != SANE_STATUS_GOOD && --tries) {
- goto read_again;
- }
- }
- }
-
- /* continue reading if appropriate */
- if (status == SANE_STATUS_GOOD)
- return status;
-
- /* cleanup */
- DBG(5, "** %s: cleaning up\n", __func__);
-
- if (s->mode_jpeg) {
- eds_jpeg_finish(s);
- }
-
- eds_ring_flush(s->current);
-
- return status;
}
/*
diff --git a/backend/epsonds.conf.in b/backend/epsonds.conf.in
index 1967a00fd..e2880fa21 100644
--- a/backend/epsonds.conf.in
+++ b/backend/epsonds.conf.in
@@ -10,7 +10,8 @@ usb
# e.g.:
# usb 0x4b8 0x14c
-# Network (not yet supported!)
+#
+# Network
#
# net 192.168.1.123
-#net autodiscovery
+net autodiscovery
diff --git a/backend/epsonds.h b/backend/epsonds.h
index 04cb7244d..7f1b6509b 100644
--- a/backend/epsonds.h
+++ b/backend/epsonds.h
@@ -66,9 +66,14 @@
#define TPU_STR SANE_I18N("Transparency Unit")
#define ADF_STR SANE_I18N("Automatic Document Feeder")
+#define STRING_FLATBED SANE_I18N("Flatbed")
+#define STRING_ADFFRONT SANE_I18N("ADF Front")
+#define STRING_ADFDUPLEX SANE_I18N("ADF Duplex")
+
enum {
OPT_NUM_OPTS = 0,
- OPT_MODE_GROUP,
+ OPT_STANDARD_GROUP,
+ OPT_SOURCE,
OPT_MODE,
OPT_DEPTH,
OPT_RESOLUTION,
@@ -78,11 +83,10 @@ enum {
OPT_BR_X,
OPT_BR_Y,
OPT_EQU_GROUP,
- OPT_SOURCE,
OPT_EJECT,
OPT_LOAD,
- OPT_ADF_MODE,
OPT_ADF_SKEW,
+ OPT_ADF_CRP,
NUM_OPTIONS
};
@@ -119,6 +123,8 @@ struct epsonds_device
SANE_Bool has_raw; /* supports RAW format */
+ SANE_Bool has_mono; /*supprt M001*/
+
SANE_Bool has_fb; /* flatbed */
SANE_Range fbf_x_range; /* x range */
SANE_Range fbf_y_range; /* y range */
@@ -136,9 +142,13 @@ struct epsonds_device
SANE_Byte adf_alignment; /* left, center, right */
SANE_Byte adf_has_dfd; /* supports double feed detection */
+ SANE_Byte adf_has_crp; /* supports crp */
+
SANE_Bool has_tpu; /* tpu */
SANE_Range tpu_x_range; /* transparency unit x range */
SANE_Range tpu_y_range; /* transparency unit y range */
+
+ SANE_Int lut_id;
};
typedef struct epsonds_device epsonds_device;
@@ -171,6 +181,10 @@ struct epsonds_scanner
SANE_Int left, top, pages, dummy;
+ SANE_Int width_front, height_front;
+ SANE_Int width_back , height_back;
+ SANE_Int width_temp, height_temp;
+
/* jpeg stuff */
djpeg_dest_ptr jdst;
@@ -181,7 +195,18 @@ struct epsonds_scanner
/* network buffers */
unsigned char *netbuf, *netptr;
size_t netlen;
-};
+
+ SANE_Byte *frontJpegBuf, *backJpegBuf;
+ SANE_Int frontJpegBufLen, backJpegBufLen;
+ SANE_Int acquirePage;
+
+ SANE_Int isflatbedScan;
+ SANE_Int isDuplexScan;
+
+ SANE_Int needToConvertBW;
+
+ SANE_Int scanEnd;
+ };
typedef struct epsonds_scanner epsonds_scanner;
diff --git a/doc/descriptions/epsonds.desc b/doc/descriptions/epsonds.desc
index 37d0e7635..2e79a118f 100644
--- a/doc/descriptions/epsonds.desc
+++ b/doc/descriptions/epsonds.desc
@@ -93,3 +93,253 @@
:interface "USB"
:usbid "0x04b8" "0x08cc"
:status :untested
+
+:model "DS-410"
+:interface "USB"
+:usbid "0x04b8" "0x0165"
+:status :complete
+
+:model "ES-50"
+:interface "USB"
+:usbid "0x04b8" "0x016c"
+:status :complete
+
+:model "DS-70"
+:interface "USB"
+:usbid "0x04b8" "0x0160"
+:status :complete
+
+:model "ES-55R"
+:interface "USB"
+:usbid "0x04b8" "0x016d"
+:status :complete
+
+:model "RR-60"
+:interface "USB"
+:usbid "0x04b8" "0x018c"
+:status :complete
+
+:model "ES-60W"
+:interface "USB"
+:usbid "0x04b8" "0x016e"
+:status :complete
+
+:model "DS-80W"
+:interface "USB"
+:usbid "0x04b8" "0x0166"
+:status :complete
+
+:model "ES-65WR"
+:interface "USB"
+:usbid "0x04b8" "0x016f"
+:status :complete
+
+:model "RR-70W"
+:interface "USB"
+:usbid "0x04b8" "0x018b"
+:status :complete
+
+:model "ES-60WW"
+:interface "USB"
+:usbid "0x04b8" "0x016e"
+:status :complete
+
+:model "ES-60WB"
+:interface "USB"
+:usbid "0x04b8" "0x016e"
+:status :complete
+
+:model "DS-1630"
+:interface "USB"
+:usbid "0x04b8" "0x015c"
+:status :complete
+
+:model "DS-1610"
+:interface "USB"
+:usbid "0x04b8" "0x015d"
+:status :complete
+
+:model "DS-1660W"
+:interface "USB"
+:usbid "0x04b8" "0x015e"
+:status :complete
+
+:model "DS-310"
+:interface "USB"
+:usbid "0x04b8" "0x0159"
+:status :complete
+
+:model "ES-200"
+:interface "USB"
+:usbid "0x04b8" "0x0159"
+:status :complete
+
+:model "DS-320"
+:interface "USB"
+:usbid "0x04b8" "0x0162"
+:status :complete
+
+:model "DS-360W"
+:interface "USB"
+:usbid "0x04b8" "0x015a"
+:status :complete
+
+:model "ES-300W"
+:interface "USB"
+:usbid "0x04b8" "0x015a"
+:status :complete
+
+:model "ES-300WR"
+:interface "USB"
+:usbid "0x04b8" "0x0177"
+:status :complete
+
+:model "ES-400II"
+:interface "USB"
+:usbid "0x04b8" "0x0181"
+:status :complete
+
+:model "DS-535II"
+:interface "USB"
+:usbid "0x04b8" "0x0183"
+:status :complete
+
+:model "DS-531"
+:interface "USB"
+:usbid "0x04b8" "0x0184"
+:status :complete
+
+:model "DS-530II"
+:interface "USB"
+:usbid "0x04b8" "0x0182"
+:status :complete
+
+:model "ES-500WII"
+:interface "USB"
+:usbid "0x04b8" "0x0185"
+:status :complete
+
+:model "DS-571W"
+:interface "USB"
+:usbid "0x04b8" "0x0188"
+:status :complete
+
+:model "DS-575WII"
+:interface "USB"
+:usbid "0x04b8" "0x0187"
+:status :complete
+
+:model "DS-570WII"
+:interface "USB"
+:usbid "0x04b8" "0x0186"
+:status :complete
+
+:model "ES-580W"
+:interface "USB"
+:usbid "0x04b8" "0x017f"
+:status :complete
+
+:model "RR-600W"
+:interface "USB"
+:usbid "0x04b8" "0x0180"
+:status :complete
+
+:model "DS-535"
+:interface "USB"
+:usbid "0x04b8" "0x0167"
+:status :complete
+
+:model "DS-535H"
+:interface "USB"
+:usbid "0x04b8" "0x017a"
+:status :complete
+
+:model "ES-400"
+:interface "USB"
+:usbid "0x04b8" "0x0156"
+:status :complete
+
+:model "DS-530"
+:interface "USB"
+:usbid "0x04b8" "0x0155"
+:status :complete
+
+:model "FF-680W"
+:interface "USB"
+:usbid "0x04b8" "0x016b"
+:status :complete
+
+:model "DS-570W"
+:interface "USB"
+:usbid "0x04b8" "0x0157"
+:status :complete
+
+:model "ES-500W"
+:interface "USB"
+:usbid "0x04b8" "0x0157"
+:status :complete
+
+:model "DS-575W"
+:interface "USB"
+:usbid "0x04b8" "0x0169"
+:status :complete
+
+:model "ES-500WR"
+:interface "USB"
+:usbid "0x04b8" "0x0176"
+:status :complete
+
+:model "EW-052A Series"
+:interface "USB"
+:usbid "0x04b8" "0x114e"
+:status :complete
+
+:model "XP-2100 Series"
+:interface "USB"
+:usbid "0x04b8" "0x114e"
+:status :complete
+
+:model "ET-2700 Series"
+:interface "USB"
+:usbid "0x04b8" "0x1135"
+:status :complete
+
+:model "L4150 Series"
+:interface "USB"
+:usbid "0x04b8" "0x1135"
+:status :complete
+
+:model "ET-M2140 Series"
+:interface "USB"
+:usbid "0x04b8" "0x114a"
+:status :complete
+
+:model "M2140 Series"
+:interface "USB"
+:usbid "0x04b8" "0x114a"
+:status :complete
+
+:model "ET-M3140 Series"
+:interface "USB"
+:usbid "0x04b8" "0x114f"
+:status :complete
+
+:model "M3140 Series"
+:interface "USB"
+:usbid "0x04b8" "0x114f"
+:status :complete
+
+:model "L3150 Series"
+:interface "USB"
+:usbid "0x04b8" "0x1143"
+:status :complete
+
+:model "ET-2710 Series"
+:interface "USB"
+:usbid "0x04b8" "0x1143"
+:status :complete
+
+:model ""
+:interface "USB"
+:usbid "0x04b8" "0x00"
+:status :complete