summaryrefslogtreecommitdiff
path: root/backend/kodakaio.c
diff options
context:
space:
mode:
Diffstat (limited to 'backend/kodakaio.c')
-rw-r--r--backend/kodakaio.c150
1 files changed, 75 insertions, 75 deletions
diff --git a/backend/kodakaio.c b/backend/kodakaio.c
index a9bec7b..c8cc9a7 100644
--- a/backend/kodakaio.c
+++ b/backend/kodakaio.c
@@ -3,7 +3,7 @@
*
* Copyright (C) 2011-2017 Paul Newall
*
- * Based on the Magicolor sane backend:
+ * Based on the Magicolor sane backend:
* Based on the epson2 sane backend:
* Based on Kazuhiro Sasayama previous
* work on epson.[ch] file from the SANE package.
@@ -16,13 +16,13 @@
* Modified 30/12/14 to fix bug where network connection was broken after 30s of idle time.
* The connection is now made in sane_start and ended in sane_cancel.
- * 01/01/13 Now with adf, the scan can be padded to make up the full page length,
+ * 01/01/13 Now with adf, the scan can be padded to make up the full page length,
* or the page can terminate at the end of the paper. This is a selectable option.
* 25/11/12 Using avahi now for net autodiscovery. Use configure option --enable-avahi
* 1/5/17 patched to use local pointer for avahi callback
*/
-/*
+/*
Packages to add to a clean ubuntu install
libavahi-common-dev
libusb-dev
@@ -45,7 +45,7 @@ If you want to use the test backend, for example with sane-troubleshoot, you sho
*/
/* SANE-FLOW-DIAGRAM Kodakaio commands in [] brackets
-
+
- sane_init() : initialize backend, attach scanners(devicename,0)
. - sane_get_devices() : query list of scanner-devices
. - sane_open() : open a particular scanner-device and attach_scanner(devicename,&dev)
@@ -58,7 +58,7 @@ If you want to use the test backend, for example with sane-troubleshoot, you sho
. . - sane_get_parameters() : returns actual scan-parameters
. . - sane_read() : read image-data (from pipe)
. . - sane_cancel() : cancel operation, kill reader_process [(F), U]
-
+
. - sane_close() : close opened scanner-device, do_cancel, free buffer and handle
- sane_exit() : terminate use of backend, free devicename and device-struture
*/
@@ -169,7 +169,7 @@ In terminal use: export SANE_DEBUG_KODAKAIO=40 to set the level to 40 or whateve
level you want.
Then you can scan with scanimage or simple-scan from terminal and see debug info
-use these defines to promote certain functions that you are interested in
+use these defines to promote certain functions that you are interested in
define low values to make detail of a section appear when DBG level is low
define a high value eg 99 to get normal behaviour. */
#define DBG_READ 99
@@ -248,7 +248,7 @@ FILE *RawScan = NULL;
char RawScanPath[] = ""; /* empty path means no raw scan file is made */
/*
- * Devices supported by this backend
+ * Devices supported by this backend
*/
/* kodak command strings */
@@ -286,7 +286,7 @@ The following are not used but may be in future
commandtype, max depth, pointer to depth list
*/
-/* list of cap data the first scanner is the default
+/* list of cap data the first scanner is the default
*/
/* KODAK AIO DEFAULT, */
{
@@ -295,7 +295,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(100), 0}, {0, SANE_FIX(100), 0} /* ADF x/y ranges (TODO!) */
},
/* KODAK ESP 5100, */
@@ -305,7 +305,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP 5300, */
@@ -315,7 +315,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP 5500, */
@@ -325,7 +325,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP 5000, */
@@ -335,7 +335,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP 3300, */
@@ -345,7 +345,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP5, */
@@ -355,7 +355,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP7, */
@@ -365,7 +365,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP9, */
@@ -375,7 +375,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP5210 or 5250, */
@@ -385,7 +385,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP3200 , */
@@ -395,7 +395,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP4100 , */
@@ -405,7 +405,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP6100 , */
@@ -415,7 +415,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_TRUE, SANE_FALSE, /* ADF, duplex */
+ SANE_TRUE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP7200 , */
@@ -425,7 +425,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP C110 , */
@@ -435,7 +435,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP C115 , */
@@ -445,7 +445,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP 2150 , */
@@ -455,7 +455,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_TRUE, SANE_FALSE, /* ADF, duplex */
+ SANE_TRUE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP C310 , */
@@ -465,7 +465,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP C315 , */
@@ -475,7 +475,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_FALSE, SANE_FALSE, /* ADF, duplex */
+ SANE_FALSE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* ADVENT AW10, */
@@ -525,7 +525,7 @@ commandtype, max depth, pointer to depth list
600, {75, 600, 0}, kodakaio_resolution_list, 4, /* 600 dpi max, 4 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_TRUE, SANE_FALSE, /* ADF, duplex */
+ SANE_TRUE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK ESP2170 , */
@@ -535,7 +535,7 @@ commandtype, max depth, pointer to depth list
1200, {75, 1200, 0}, kodakaio_resolution_list, 5, /* 1200 dpi optical, {from, to, 0} 5 resolutions */
8, kodakaio_depth_list, /* color depth max 8, list above */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(11.7 * MM_PER_INCH), 0}, /* FBF x/y ranges */
- SANE_TRUE, SANE_FALSE, /* ADF, duplex */
+ SANE_TRUE, SANE_FALSE, /* ADF, duplex */
{0, SANE_FIX(8.5 * MM_PER_INCH), 0}, {0, SANE_FIX(14 * MM_PER_INCH), 0} /* 14 ADF x/y ranges */
},
/* KODAK HERO 9.1, */
@@ -748,7 +748,7 @@ sanei_kodakaio_net_write_raw(struct KodakAio_Scanner *s,
SANE_Status *status)
{
DBG(32, "net write:%x,%x,%x,%x,%x,%x,%x,%x\n",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]);
-
+
sanei_tcp_write(s->fd, buf, buf_size);
/* TODO: Check whether sending failed... */
@@ -863,8 +863,8 @@ static ssize_t
k_recv(KodakAio_Scanner * s, void *buf, ssize_t buf_size,
SANE_Status * status)
{
-/* requests and receives data this function makes the split between USB and NET
-this function called by a number of others
+/* requests and receives data this function makes the split between USB and NET
+this function called by a number of others
In USB mode, this function will wait until data is available for a maximum of SCANNER_READ_TIMEOUT seconds.
In NET mode the timeout is in kodakaio_net_read
@@ -878,7 +878,7 @@ In NET mode the timeout is in kodakaio_net_read
usb_delay.tv_nsec = 300000000; /* 0.3 sec */
if (s->hw->connection == SANE_KODAKAIO_NET) {
-
+
time(&time_start);
DBG(min(16,DBG_READ), "[%ld] %s: net req size = %ld ", (long) time_start, __func__, (long) buf_size);
n = kodakaio_net_read(s, buf, buf_size, status);
@@ -1015,7 +1015,7 @@ and returns appropriate status
s->adf_loaded = SANE_TRUE;
DBG(5, "%s: News - docs in ADF\n", __func__);
}
- else if (rxbuf[4] !=
+ else if (rxbuf[4] !=
0x01 && s->adf_loaded == SANE_TRUE) {
s->adf_loaded = SANE_FALSE;
DBG(5, "%s: News - ADF is empty\n", __func__);
@@ -1031,7 +1031,7 @@ and returns appropriate status
}
/* unused function
-static ssize_t
+static ssize_t
kodakaio_rxflush(KodakAio_Scanner *s)
Tries to get 64 byte reply
@@ -1052,7 +1052,7 @@ and returns number of bytes read
*/
/*
- * high-level communication commands
+ * high-level communication commands
*/
static SANE_Status
@@ -1064,7 +1064,7 @@ k_hello (KodakAio_Scanner * s)
DBG(5, "%s\n", __func__);
-/* check that there is nothing already in the input buffer before starting
+/* check that there is nothing already in the input buffer before starting
kodakaio_rxflush(s);
*/
/* preset the reply, so I can see if it gets changed */
@@ -1129,12 +1129,12 @@ cmd_cancel_scan (SANE_Handle handle)
unsigned char reply[8];
/* adf added 20/2/12 should it be adf? or adf with paper in? */
if (strcmp(source_list[s->val[OPT_SOURCE].w], ADF_STR) == 0) { /* adf */
- if (kodakaio_txrxack(s, KodakEsp_F, reply)!= SANE_STATUS_GOOD)
+ if (kodakaio_txrxack(s, KodakEsp_F, reply)!= SANE_STATUS_GOOD)
{
DBG(1, "%s: KodakEsp_F command failed\n", __func__);
return SANE_STATUS_IO_ERROR;
}
- if (kodakaio_txrxack(s, KodakEsp_UnLock, reply)!= SANE_STATUS_GOOD)
+ if (kodakaio_txrxack(s, KodakEsp_UnLock, reply)!= SANE_STATUS_GOOD)
{
DBG(1, "%s: KodakEsp_UnLock command failed\n", __func__);
return SANE_STATUS_IO_ERROR;
@@ -1193,7 +1193,7 @@ cmd_set_color_curve(SANE_Handle handle, unsigned char col)
int i; /* 7/9/14 was unsigned char and that stopped the loop that made the linear curve from going to 255 */
DBG(32, "%s: start\n", __func__);
tx_col[0]=0x1b; tx_col[1]='S'; tx_col[2]='K'; tx_col[3]=col; tx_col[4]=0; tx_col[5]=0; tx_col[6]=0; tx_col[7]=0;
-/* linear curve now but could send tailor made curves in future */
+/* linear curve now but could send tailor made curves in future */
for(i=0;i<=255;++i) tx_curve[i]=i; /* 7/9/14 was i<255 the missing elements caused speckles */
k_send(s, tx_col, 8, &status);
@@ -1255,7 +1255,7 @@ cmd_set_scanning_parameters(SANE_Handle handle,
tx_dpi[7]=0;
kodakaio_txrxack(s, tx_dpi, bufread);
-/* colour curves don't seem to be sent for usb preview
+/* colour curves don't seem to be sent for usb preview
but it seems to do no harm to send them */
cmd_set_color_curve(s, 'R');
cmd_set_color_curve(s, 'G');
@@ -1298,7 +1298,7 @@ this command needs actual DPI units*/
int
cmparray (unsigned char *array1, unsigned char *array2, size_t len)
{
-/* compares len bytes of the arrays returns 0 if they match
+/* compares len bytes of the arrays returns 0 if they match
returns the first missmatch position if they don't match */
unsigned int i;
for(i=0; i<len; ++i)
@@ -1311,7 +1311,7 @@ unsigned int i;
static SANE_Status
cmd_read_data (SANE_Handle handle, unsigned char *buf, size_t *len)
{
-/*
+/*
cmd_read_data is only used in k_read. It reads one block of data
read data using k_recv until you get the ackstring
when you get the ackstring return s->ack and do padding if the padding option is selected
@@ -1363,7 +1363,7 @@ But it seems that the scanner takes care of that, and gives you the ack as a sep
/* it may be the last block from the scanner so look for Ack response in last 8 bytes */
Last8 = buf + bytecount - 8;
- /* only compare 4 bytes because we sometimes get escSS02.. or escSS00..
+ /* only compare 4 bytes because we sometimes get escSS02.. or escSS00..
is 4 the right number ? */
if (cmparray(Last8,KodakEsp_Ack,4) == 0) {
DBG(min(10,DBG_READ), "%s: found KodakEsp_Ack at %lu bytes of %lu\n", __func__, (unsigned long) bytecount, (unsigned long) *len);
@@ -1404,12 +1404,12 @@ But it seems that the scanner takes care of that, and gives you the ack as a sep
if (status == SANE_STATUS_GOOD)
if (s->bytes_unread <= 0)
- DBG(min(2,DBG_READ), "%s: Page fully read %d blocks, %ld bytes unread\n", __func__, s->counter, (long) s->bytes_unread);
+ DBG(min(2,DBG_READ), "%s: Page fully read %d blocks, %ld bytes unread\n", __func__, s->counter, (long) s->bytes_unread);
else
DBG(min(20,DBG_READ), "%s: Image data successfully read %ld bytes, %ld bytes unread\n", __func__, (long) bytecount, (long) s->bytes_unread);
else if (s->ack) /* was (status == SANE_STATUS_EOF) */
DBG(min(2,DBG_READ), "%s: scanner data read ended %d blocks %ld bytes, %ld bytes unread\n", __func__, s->counter, (long) bytecount, (long) s->bytes_unread);
- else
+ else
DBG(min(1,DBG_READ), "%s: Image data read stopped with %s after %d blocks %ld bytes, %ld bytes unread\n", __func__, sane_strstatus(status), s->counter, (long) bytecount, (long) s->bytes_unread);
return status;
@@ -1549,7 +1549,7 @@ k_setup_block_mode (KodakAio_Scanner *s)
return SANE_STATUS_GOOD;
}
-/* Call the commands to set scanning parameters
+/* Call the commands to set scanning parameters
In the Kodak Aio the parameters are:
(x1b,"S","F",0,0,0,0,0)
(x1b,"S","S",1,0,0,0,0)
@@ -1615,7 +1615,7 @@ k_set_scanning_parameters(KodakAio_Scanner * s)
/* TODO: Any way to set PREVIEW??? */
/* Remaining bytes unused */
- status = cmd_set_scanning_parameters(s, dpi,
+ status = cmd_set_scanning_parameters(s, dpi,
s->left * dpi / optres, s->top * dpi / optres, /* top/left start (dpi units)*/
s->params.pixels_per_line, s->params.lines, /* extent was s->width, s->height*/
source); /* source */
@@ -1696,7 +1696,7 @@ k_scan_finish(KodakAio_Scanner * s)
static void
k_copy_image_data(KodakAio_Scanner * s, SANE_Byte * data, SANE_Int max_length,
SANE_Int * length)
-/* copies the read data from s->line_buffer to the position in data pointer to by s->ptr
+/* copies the read data from s->line_buffer to the position in data pointer to by s->ptr
uncompressed data is RRRR...GGGG...BBBB per line */
{
SANE_Int bytes_available;
@@ -1724,7 +1724,7 @@ uncompressed data is RRRR...GGGG...BBBB per line */
/* We have filled as much as possible of the current line
* with data from the scanner. If we have a complete line,
- * copy it over.
+ * copy it over.
line points to the current byte in the input s->line_buffer
data points to the output buffer*/
if ((s->bytes_read_in_line >= s->scan_bytes_per_line) &&
@@ -1753,8 +1753,8 @@ uncompressed data is RRRR...GGGG...BBBB per line */
*data &= ~mask; /* white clear the bit in mask */
else
*data |= mask; /* black set the bit in mask */
-
- if (offset == 7 || i == s->params.pixels_per_line-1)
+
+ if (offset == 7 || i == s->params.pixels_per_line-1)
data++; /* move on a byte if the byte is full or the line is complete */
}
@@ -1768,7 +1768,7 @@ uncompressed data is RRRR...GGGG...BBBB per line */
}
/*debug file The same for color or grey because the scan is colour */
if (RawScan != NULL) {
- for (i=0; i< s->scan_bytes_per_line; ++i) fputc(s->line_buffer[i],RawScan);
+ for (i=0; i< s->scan_bytes_per_line; ++i) fputc(s->line_buffer[i],RawScan);
}
max_length -= s->params.bytes_per_line;
s->bytes_read_in_line -= s->scan_bytes_per_line;
@@ -1840,7 +1840,7 @@ k_init_parametersta(KodakAio_Scanner * s)
s->params.last_frame = SANE_TRUE;
s->params.bytes_per_line = 3 * ceil (s->params.depth * s->params.pixels_per_line / 8.0);
-/* kodak only scans in color and conversion to grey or lineart is done in the driver
+/* kodak only scans in color and conversion to grey or lineart is done in the driver
s->params.format = SANE_FRAME_RGB; */
DBG(20, "%s: s->val[OPT_MODE].w = %d (color is %d)\n", __func__,s->val[OPT_MODE].w, MODE_COLOR);
if (s->val[OPT_MODE].w == MODE_COLOR) s->params.format = SANE_FRAME_RGB;
@@ -1870,7 +1870,7 @@ k_read(struct KodakAio_Scanner *s)
{
unsigned char rx[8];
-/* monitors progress of blocks and calls cmd_read_data to get each block
+/* monitors progress of blocks and calls cmd_read_data to get each block
you don't know how many blocks there will be in advance because their size may be determined by the scanner*/
SANE_Status status = SANE_STATUS_GOOD;
size_t buf_len = 0;
@@ -1907,7 +1907,7 @@ you don't know how many blocks there will be in advance because their size may b
if (status == SANE_STATUS_EOF) {
/* page ended prematurely. */
}
- }
+ }
else { /* s->bytes_unread <=0 This is the end of a page */
s->eof = SANE_TRUE;
DBG(min(10,DBG_READ), "%s: set EOF after %d blocks\n=============\n", __func__, s->counter);
@@ -1932,7 +1932,7 @@ you don't know how many blocks there will be in advance because their size may b
}
/*
- * SANE API implementation (high-level functions)
+ * SANE API implementation (high-level functions)
*/
#if WITH_AVAHI
@@ -1951,12 +1951,12 @@ get_device_from_identification (const char *ident, const char *vid, const char *
return NULL;
}
for (n = 0; n < NELEMS (kodakaio_cap); n++) {
-
+
if (strcmp (kodakaio_cap[n].model, ident)==0) {
DBG(20, "matched <%s> & <%s>\n", kodakaio_cap[n].model, ident);
return &kodakaio_cap[n];
}
- else
+ else
if (kodakaio_cap[n].id == pidnum && 0x040A == vidnum) {
DBG(20, "matched <%s> & <%s:%s>\n", kodakaio_cap[n].model, vid, pid);
return &kodakaio_cap[n];
@@ -2124,7 +2124,7 @@ detect_usb(struct KodakAio_Scanner *s)
* about the device */
while (i != numIds && !is_valid) {
/* if (product == kodakaio_usb_product_ids[i]) */
- if (product == kodakaio_cap[i].id)
+ if (product == kodakaio_cap[i].id)
is_valid = SANE_TRUE;
i++;
}
@@ -2259,20 +2259,20 @@ device_detect(const char *name, int type, SANE_Status *status)
#if WITH_AVAHI
/* ProcessAvahiDevice is called to process each discovered device in turn */
-void
+void
ProcessAvahiDevice(const char *device_id, const char *vid, const char *pid, const char *ip_addr)
{
struct KodakaioCap *cap;
DBG(min(10,DBG_AUTO),"device_id = <%s> vid:pid = <%s:%s>\n", device_id,vid,pid);
-/* check if it is a model likely to be supported: "KODAK ESP" or "KODAK HERO"
+/* check if it is a model likely to be supported: "KODAK ESP" or "KODAK HERO"
DBG(min(10,DBG_AUTO),"look up model <%s>\n", device_model); */
cap = get_device_from_identification("", vid, pid);
if (cap == NULL) {
return;
- }
+ }
DBG(min(10,DBG_AUTO), "%s: Found autodiscovered device: %s (type 0x%x)\n", __func__, cap->model, cap->id);
attach_one_net (ip_addr, cap->id);
@@ -2337,12 +2337,12 @@ static void resolve_callback(
else DBG(min(10,DBG_AUTO), "didn't call ProcessAvahiDevice\n");
if(vid_pair_list != NULL) {
- avahi_free(vidkey);
+ avahi_free(vidkey);
avahi_free(vidvalue);
DBG(min(15,DBG_AUTO), "vidkey and vidvalue freed\n");
}
if(pid_pair_list != NULL) {
- avahi_free(pidkey);
+ avahi_free(pidkey);
avahi_free(pidvalue);
DBG(min(15,DBG_AUTO), "pidkey and pidvalue freed\n");
}
@@ -2413,7 +2413,7 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void * userd
static int
kodak_network_discovery(const char*host)
-/* If host = NULL do autodiscovery. If host != NULL try to verify the model
+/* If host = NULL do autodiscovery. If host != NULL try to verify the model
First version only does autodiscovery */
{
AvahiSimplePoll *simple_poll;
@@ -2586,7 +2586,7 @@ attach_one_config(SANEI_Config __sane_unused__ *config, const char *line)
/* Timeout for all other read requests */
DBG(50, "%s: Request timeout set to %d\n", __func__, timeout);
K_Request_Timeout = timeout;
-
+
} else {
/* TODO: Warning about unparsable line! */
}
@@ -2790,7 +2790,7 @@ init_options(KodakAio_Scanner *s)
s->opt[OPT_BIT_DEPTH].constraint.word_list = s->hw->cap->depth_list;
s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE;
s->val[OPT_BIT_DEPTH].w = s->hw->cap->depth_list[1]; /* the first "real" element is the default */
-
+
DBG(20, "%s: depth list has depth_list[0] = %d entries\n", __func__, s->hw->cap->depth_list[0]);
if (s->hw->cap->depth_list[0] == 1) { /* only one element in the list -> hide the option */
s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE;
@@ -2814,7 +2814,7 @@ init_options(KodakAio_Scanner *s)
s->val[OPT_RESOLUTION].w = s->hw->cap->dpi_range.min;
- /* trial option for debugging
+ /* trial option for debugging
s->opt[OPT_TRIALOPT].name = "trialoption";
s->opt[OPT_TRIALOPT].title = "trialoption";
s->opt[OPT_TRIALOPT].desc = "trialoption";
@@ -2834,7 +2834,7 @@ init_options(KodakAio_Scanner *s)
for(i=0;source_list[i]!=NULL;++i)
DBG(18, "source_list: %s\n",source_list[i]);
-
+
/* source */
s->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
@@ -2850,7 +2850,7 @@ init_options(KodakAio_Scanner *s)
s->opt[OPT_SOURCE].cap |= SANE_CAP_INACTIVE;
}
-/* Are there any ESP scanners that are duplex? */
+/* Are there any ESP scanners that are duplex? */
s->opt[OPT_ADF_MODE].name = "adf-mode";
s->opt[OPT_ADF_MODE].title = SANE_I18N("ADF Mode");
s->opt[OPT_ADF_MODE].desc =
@@ -2991,7 +2991,7 @@ sane_open(SANE_String_Const name, SANE_Handle *handle)
/* s is always valid here */
DBG(10, "handle obtained\n");
- status = k_discover_capabilities(s); /* added 27/12/11 to fix source list problem
+ status = k_discover_capabilities(s); /* added 27/12/11 to fix source list problem
maybe we should only be rebuilding the source list here? */
if (status != SANE_STATUS_GOOD)
return status;
@@ -3000,7 +3000,7 @@ maybe we should only be rebuilding the source list here? */
*handle = (SANE_Handle) s;
-/* moving the open scanner section below to sane_start 27/12/14
+/* moving the open scanner section below to sane_start 27/12/14
status = open_scanner(s);
if (status != SANE_STATUS_GOOD) {
free(s);
@@ -3400,8 +3400,8 @@ sane_start(SANE_Handle handle)
/* set scanning parameters; also query the current image
* parameters from the sanner and save
- * them to s->params
-Only set scanning params the first time, or after a cancel
+ * them to s->params
+Only set scanning params the first time, or after a cancel
try change 22/2/12 take lock scanner out of k_set_scanning_parameters */
/* moved open_scanner here 27/12/14 from sane_open */
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-20 19:03:52 +0000