diff options
Diffstat (limited to 'backend/epjitsu.c')
| -rw-r--r-- | backend/epjitsu.c | 4330 |
1 files changed, 4330 insertions, 0 deletions
diff --git a/backend/epjitsu.c b/backend/epjitsu.c new file mode 100644 index 0000000..3e102da --- /dev/null +++ b/backend/epjitsu.c @@ -0,0 +1,4330 @@ +/* sane - Scanner Access Now Easy. + + This file is part of the SANE package. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + -------------------------------------------------------------------------- + + This file implements a SANE backend for the Fujitsu fi-60F, the + ScanSnap S300/S1300, and (hopefully) other Epson-based scanners. + + Copyright 2007-2010 by m. allan noah <kitno455 at gmail dot com> + Copyright 2009 by Richard Goedeken <richard at fascinationsoftware dot com> + + Development funded by Microdea, Inc., TrueCheck, Inc. and Archivista, GmbH + + -------------------------------------------------------------------------- + + The source code is divided in sections which you can easily find by + searching for the tag "@@". + + Section 1 - Init & static stuff + Section 2 - sane_init, _get_devices, _open & friends + Section 3 - sane_*_option functions + Section 4 - sane_start, _get_param, _read & friends + Section 5 - sane_close functions + Section 6 - misc functions + + Changes: + v0, 2007-08-08, MAN + - initial alpha release, S300 raw data only + v1, 2007-09-03, MAN + - only supports 300dpi duplex binary for S300 + v2, 2007-09-05, MAN + - add resolution option (only one choice) + - add simplex option + v3, 2007-09-12, MAN + - add support for 150 dpi resolution + v4, 2007-10-03, MAN + - change binarization algo to use average of all channels + v5, 2007-10-10, MAN + - move data blocks to separate file + - add basic fi-60F support (600dpi color) + v6, 2007-11-12, MAN + - move various data vars into transfer structs + - move most of read_from_scanner to sane_read + - add single line reads to calibration code + - generate calibration buffer from above reads + v7, 2007-12-05, MAN + - split calibration into fine and coarse functions + - add S300 fine calibration code + - add S300 color and grayscale support + v8, 2007-12-06, MAN + - change sane_start to call ingest earlier + - enable SOURCE_ADF_BACK + - add if() around memcopy and better debugs in sane_read + - shorten default scan sizes from 15.4 to 11.75 inches + v9, 2007-12-17, MAN + - fi-60F 300 & 600 dpi support (150 is non-square?) + - fi-60F gray & binary support + - fi-60F improved calibration + v10, 2007-12-19, MAN (SANE v1.0.19) + - fix missing function (and memory leak) + v11 2008-02-14, MAN + - sanei_config_read has already cleaned string (#310597) + v12 2008-02-28, MAN + - cleanup double free bug with new destroy() + v13 2008-09-18, MAN + - add working page-height control + - add working brightness, contrast and threshold controls + - add disabled threshold curve and geometry controls + - move initialization code to sane_get_devices, for hotplugging + v14 2008-09-24, MAN + - support S300 on USB power + - support S300 225x200 and 600x600 scans + - support for automatic paper length detection (parm.lines = -1) + v15 2008-09-24, MAN + - expose hardware buttons/sensors as options for S300 + v16 2008-10-01, MAN + - split fill_frontback_buffers_S300 into 3 functions + - enable threshold_curve option + - add 1-D dynamic binary thresholding code + - remove y-resolution option + - pad 225x200 data to 225x225 + v17 2008-10-03, MAN + - increase scan height ~1/2 inch due to head offset + - change page length autodetection condition + v18 2009-01-21, MAN + - dont export private symbols + v19 2009-08-31, RG + - rewritten calibration routines + v20 2010-02-09, MAN (SANE 1.0.21 & 1.0.22) + - cleanup #include lines & copyright + - add S1300 + + SANE FLOW DIAGRAM + + - sane_init() : initialize backend + . - sane_get_devices() : query list of scanner devices + . - sane_open() : open a particular scanner device + . . - sane_set_io_mode : set blocking mode + . . - sane_get_select_fd : get scanner fd + . . + . . - sane_get_option_descriptor() : get option information + . . - sane_control_option() : change option values + . . - sane_get_parameters() : returns estimated scan parameters + . . - (repeat previous 3 functions) + . . + . . - sane_start() : start image acquisition + . . - sane_get_parameters() : returns actual scan parameters + . . - sane_read() : read image data (from pipe) + . . (sane_read called multiple times; after sane_read returns EOF, + . . loop may continue with sane_start which may return a 2nd page + . . when doing duplex scans, or load the next page from the ADF) + . . + . . - sane_cancel() : cancel operation + . - sane_close() : close opened scanner device + - sane_exit() : terminate use of backend + +*/ + +/* + * @@ Section 1 - Init + */ + +#include "../include/sane/config.h" + +#include <string.h> /*memcpy...*/ +#include <ctype.h> /*isspace*/ +#include <math.h> /*tan*/ +#include <unistd.h> /*usleep*/ +#include <time.h> /*time*/ + +#include "../include/sane/sanei_backend.h" +#include "../include/sane/sanei_usb.h" +#include "../include/sane/saneopts.h" +#include "../include/sane/sanei_config.h" + +#include "epjitsu.h" +#include "epjitsu-cmd.h" + +#define DEBUG 1 +#define BUILD 20 + +#ifndef MAX3 + #define MAX3(a,b,c) ((a) > (b) ? ((a) > (c) ? a : c) : ((b) > (c) ? b : c)) +#endif + +unsigned char global_firmware_filename[PATH_MAX]; + +/* values for SANE_DEBUG_EPJITSU env var: + - errors 5 + - function trace 10 + - function detail 15 + - get/setopt cmds 20 + - usb cmd trace 25 + - usb cmd detail 30 + - useless noise 35 +*/ + +/* Calibration settings */ +#define COARSE_OFFSET_TARGET 15 +static int coarse_gain_min[3] = { 88, 88, 88 }; /* front, back, FI-60F 3rd plane */ +static int coarse_gain_max[3] = { 92, 92, 92 }; +static int fine_gain_target[3] = {185, 150, 170}; /* front, back, FI-60F is this ok? */ +static float white_factor[3] = {1.0, 0.93, 0.98}; /* Blue, Red, Green */ + +/* ------------------------------------------------------------------------- */ +#define STRING_FLATBED SANE_I18N("Flatbed") +#define STRING_ADFFRONT SANE_I18N("ADF Front") +#define STRING_ADFBACK SANE_I18N("ADF Back") +#define STRING_ADFDUPLEX SANE_I18N("ADF Duplex") + +#define STRING_LINEART SANE_VALUE_SCAN_MODE_LINEART +#define STRING_GRAYSCALE SANE_VALUE_SCAN_MODE_GRAY +#define STRING_COLOR SANE_VALUE_SCAN_MODE_COLOR + +/* + * used by attach* and sane_get_devices + * a ptr to a null term array of ptrs to SANE_Device structs + * a ptr to a single-linked list of scanner structs + */ +static const SANE_Device **sane_devArray = NULL; +static struct scanner *scanner_devList = NULL; + +/* + * @@ Section 2 - SANE & scanner init code + */ + +/* + * Called by SANE initially. + * + * From the SANE spec: + * This function must be called before any other SANE function can be + * called. The behavior of a SANE backend is undefined if this + * function is not called first. The version code of the backend is + * returned in the value pointed to by version_code. If that pointer + * is NULL, no version code is returned. Argument authorize is either + * a pointer to a function that is invoked when the backend requires + * authentication for a specific resource or NULL if the frontend does + * not support authentication. + */ +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) +{ + authorize = authorize; /* get rid of compiler warning */ + + DBG_INIT (); + DBG (10, "sane_init: start\n"); + + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); + + DBG (5, "sane_init: epjitsu backend %d.%d.%d, from %s\n", + SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING); + + DBG (10, "sane_init: finish\n"); + + return SANE_STATUS_GOOD; +} + +/* + * Called by SANE to find out about supported devices. + * + * From the SANE spec: + * This function can be used to query the list of devices that are + * available. If the function executes successfully, it stores a + * pointer to a NULL terminated array of pointers to SANE_Device + * structures in *device_list. The returned list is guaranteed to + * remain unchanged and valid until (a) another call to this function + * is performed or (b) a call to sane_exit() is performed. This + * function can be called repeatedly to detect when new devices become + * available. If argument local_only is true, only local devices are + * returned (devices directly attached to the machine that SANE is + * running on). If it is false, the device list includes all remote + * devices that are accessible to the SANE library. + * + * SANE does not require that this function is called before a + * sane_open() call is performed. A device name may be specified + * explicitly by a user which would make it unnecessary and + * undesirable to call this function first. + * + * Read the config file, find scanners with help from sanei_* + * store in global device structs + */ +SANE_Status +sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) +{ + SANE_Status ret = SANE_STATUS_GOOD; + struct scanner * s; + struct scanner * prev = NULL; + char line[PATH_MAX]; + const char *lp; + FILE *fp; + int num_devices=0; + int i=0; + + local_only = local_only; /* get rid of compiler warning */ + + DBG (10, "sane_get_devices: start\n"); + + /* mark all existing scanners as missing, attach_one will remove mark */ + for (s = scanner_devList; s; s = s->next) { + s->missing = 1; + } + + sanei_usb_init(); + + fp = sanei_config_open (CONFIG_FILE); + + if (fp) { + + DBG (15, "sane_get_devices: reading config file %s\n", CONFIG_FILE); + + while (sanei_config_read (line, PATH_MAX, fp)) { + + lp = line; + + /* ignore comments */ + if (*lp == '#') + continue; + + /* skip empty lines */ + if (*lp == 0) + continue; + + if ((strncmp ("firmware", lp, 8) == 0) && isspace (lp[8])) { + lp += 8; + lp = sanei_config_skip_whitespace (lp); + DBG (15, "sane_get_devices: firmware '%s'\n", lp); + strncpy((char *)global_firmware_filename,lp,PATH_MAX); + } + else if ((strncmp ("usb", lp, 3) == 0) && isspace (lp[3])) { + DBG (15, "sane_get_devices: looking for '%s'\n", lp); + sanei_usb_attach_matching_devices(lp, attach_one); + } + else{ + DBG (5, "sane_get_devices: config line \"%s\" ignored.\n", lp); + } + } + fclose (fp); + } + + else { + DBG (5, "sane_get_devices: no config file '%s'!\n", + CONFIG_FILE); + } + + /*delete missing scanners from list*/ + for (s = scanner_devList; s;) { + if(s->missing){ + DBG (5, "sane_get_devices: missing scanner %s\n",s->sane.name); + + /*splice s out of list by changing pointer in prev to next*/ + if(prev){ + prev->next = s->next; + free(s); + s=prev->next; + } + /*remove s from head of list, using prev to cache it*/ + else{ + prev = s; + s = s->next; + free(prev); + prev=NULL; + + /*reset head to next s*/ + scanner_devList = s; + } + } + else{ + prev = s; + s=prev->next; + } + } + + for (s = scanner_devList; s; s=s->next) { + DBG (15, "sane_get_devices: found scanner %s\n",s->sane.name); + num_devices++; + } + + DBG (15, "sane_get_devices: found %d scanner(s)\n",num_devices); + + if (sane_devArray) + free (sane_devArray); + + sane_devArray = calloc (num_devices + 1, sizeof (SANE_Device*)); + if (!sane_devArray) + return SANE_STATUS_NO_MEM; + + for (s = scanner_devList; s; s=s->next) { + sane_devArray[i++] = (SANE_Device *)&s->sane; + } + sane_devArray[i] = 0; + + if(device_list){ + *device_list = sane_devArray; + } + + DBG (10, "sane_get_devices: finish\n"); + + return ret; +} + +/* callback used by sane_init + * build the scanner struct and link to global list + * unless struct is already loaded, then pretend + */ +static SANE_Status +attach_one (const char *name) +{ + struct scanner *s; + int ret, i; + + DBG (10, "attach_one: start '%s'\n", name); + + for (s = scanner_devList; s; s = s->next) { + if (strcmp (s->sane.name, name) == 0) { + DBG (10, "attach_one: already attached!\n"); + s->missing = 0; + return SANE_STATUS_GOOD; + } + } + + /* build a scanner struct to hold it */ + DBG (15, "attach_one: init struct\n"); + + if ((s = calloc (sizeof (*s), 1)) == NULL) + return SANE_STATUS_NO_MEM; + + /* copy the device name */ + s->sane.name = strdup (name); + if (!s->sane.name){ + destroy(s); + return SANE_STATUS_NO_MEM; + } + + /* connect the fd */ + DBG (15, "attach_one: connect fd\n"); + + s->fd = -1; + ret = connect_fd(s); + if(ret != SANE_STATUS_GOOD){ + destroy(s); + return ret; + } + + /* load the firmware file into scanner */ + ret = load_fw(s); + if (ret != SANE_STATUS_GOOD) { + destroy(s); + DBG (5, "attach_one: firmware load failed\n"); + return ret; + } + + /* Now query the device to load its vendor/model/version */ + ret = get_ident(s); + if (ret != SANE_STATUS_GOOD) { + destroy(s); + DBG (5, "attach_one: identify failed\n"); + return ret; + } + + DBG (15, "attach_one: Found %s scanner %s at %s\n", + s->sane.vendor, s->sane.model, s->sane.name); + + if (strstr (s->sane.model, "S300") || strstr (s->sane.model, "S1300")){ + unsigned char stat; + + DBG (15, "attach_one: Found S300/S1300\n"); + + stat = get_stat(s); + if(stat & 0x01){ + DBG (5, "attach_one: on USB power?\n"); + s->usb_power=1; + } + + s->model = MODEL_S300; + + s->has_adf = 1; + s->x_res_150 = 1; + s->x_res_225 = 1; + s->x_res_300 = 1; + s->x_res_600 = 1; + s->y_res_150 = 1; + s->y_res_225 = 1; + s->y_res_300 = 1; + s->y_res_600 = 1; + + s->source = SOURCE_ADF_FRONT; + s->mode = MODE_LINEART; + s->resolution_x = 300; + s->page_height = 11.5 * 1200; + + s->threshold = 120; + s->threshold_curve = 55; + } + + else if (strstr (s->sane.model, "fi-60F")){ + DBG (15, "attach_one: Found fi-60F\n"); + + s->model = MODEL_FI60F; + + s->has_fb = 1; + s->x_res_150 = 0; + s->x_res_300 = 1; + s->x_res_600 = 1; + s->y_res_150 = 0; + s->y_res_300 = 1; + s->y_res_600 = 1; + + s->source = SOURCE_FLATBED; + s->mode = MODE_COLOR; + s->resolution_x = 300; + s->page_height = 5.83 * 1200; + + s->threshold = 120; + s->threshold_curve = 55; + } + + else{ + DBG (15, "attach_one: Found other\n"); + } + + /* set SANE option 'values' to good defaults */ + DBG (15, "attach_one: init options\n"); + + /* go ahead and setup the first opt, because + * frontend may call control_option on it + * before calling get_option_descriptor + */ + memset (s->opt, 0, sizeof (s->opt)); + for (i = 0; i < NUM_OPTIONS; ++i) { + s->opt[i].name = "filler"; + s->opt[i].size = sizeof (SANE_Word); + s->opt[i].cap = SANE_CAP_INACTIVE; + } + + s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS; + s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; + s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; + s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + + DBG (15, "attach_one: init settings\n"); + ret = change_params(s); + + /* we close the connection, so that another backend can talk to scanner */ + disconnect_fd(s); + + s->next = scanner_devList; + scanner_devList = s; + + DBG (10, "attach_one: finish\n"); + + return SANE_STATUS_GOOD; +} + +/* + * connect the fd in the scanner struct + */ +static SANE_Status +connect_fd (struct scanner *s) +{ + SANE_Status ret; + + DBG (10, "connect_fd: start\n"); + + if(s->fd > -1){ + DBG (5, "connect_fd: already open\n"); + ret = SANE_STATUS_GOOD; + } + else { + DBG (15, "connect_fd: opening USB device\n"); + ret = sanei_usb_open (s->sane.name, &(s->fd)); + } + + if(ret != SANE_STATUS_GOOD){ + DBG (5, "connect_fd: could not open device: %d\n", ret); + } + + DBG (10, "connect_fd: finish\n"); + + return ret; +} + +/* + * try to load fw into scanner + */ +static SANE_Status +load_fw (struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + int file, i; + int len = 0; + unsigned char * buf; + + unsigned char cmd[4]; + size_t cmdLen; + unsigned char stat[2]; + size_t statLen; + + DBG (10, "load_fw: start\n"); + + /*check status*/ + /*reuse stat buffer*/ + stat[0] = get_stat(s); + + if(stat[0] & 0x10){ + DBG (5, "load_fw: firmware already loaded?\n"); + return SANE_STATUS_GOOD; + } + + if(!global_firmware_filename[0]){ + DBG (5, "load_fw: missing filename\n"); + return SANE_STATUS_NO_DOCS; + } + + file = open((char *)global_firmware_filename,O_RDONLY); + if(!file){ + DBG (5, "load_fw: failed to open file %s\n",global_firmware_filename); + return SANE_STATUS_NO_DOCS; + } + + if(lseek(file,0x100,SEEK_SET) != 0x100){ + DBG (5, "load_fw: failed to lseek file %s\n",global_firmware_filename); + close(file); + return SANE_STATUS_NO_DOCS; + } + + buf = malloc(FIRMWARE_LENGTH); + if(!buf){ + DBG (5, "load_fw: failed to alloc mem\n"); + close(file); + return SANE_STATUS_NO_MEM; + } + + len = read(file,buf,FIRMWARE_LENGTH); + close(file); + + if(len != FIRMWARE_LENGTH){ + DBG (5, "load_fw: firmware file %s wrong length\n", + global_firmware_filename); + free(buf); + return SANE_STATUS_NO_DOCS; + } + + DBG (15, "load_fw: read firmware file %s ok\n", global_firmware_filename); + + /* firmware upload is in three commands */ + + /*start/status*/ + cmd[0] = 0x1b; + cmd[1] = 0x06; + cmdLen = 2; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "load_fw: error on cmd 1\n"); + free(buf); + return ret; + } + if(stat[0] != 6){ + DBG (5, "load_fw: bad stat on cmd 1\n"); + free(buf); + return SANE_STATUS_IO_ERROR; + } + + /*length/data*/ + cmd[0] = 0x01; + cmd[1] = 0x00; + cmd[2] = 0x01; + cmd[3] = 0x00; + cmdLen = 4; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + buf, FIRMWARE_LENGTH, + NULL, 0 + ); + if(ret){ + DBG (5, "load_fw: error on cmd 2\n"); + free(buf); + return ret; + } + + /*checksum/status*/ + cmd[0] = 0; + for(i=0;i<FIRMWARE_LENGTH;i++){ + cmd[0] += buf[i]; + } + free(buf); + + cmdLen = 1; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "load_fw: error on cmd 3\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "load_fw: bad stat on cmd 3\n"); + return SANE_STATUS_IO_ERROR; + } + + /*reinit*/ + cmd[0] = 0x1b; + cmd[1] = 0x16; + cmdLen = 2; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "load_fw: error reinit cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "load_fw: reinit cmd bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + cmd[0] = 0x80; + cmdLen = 1; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "load_fw: error reinit payload\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "load_fw: reinit payload bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + /*reuse stat buffer*/ + stat[0] = get_stat(s); + + if(!(stat[0] & 0x10)){ + DBG (5, "load_fw: firmware not loaded? %#x\n",stat[0]); + return SANE_STATUS_IO_ERROR; + } + + return ret; +} + +/* + * try to load fw into scanner + */ +static unsigned char +get_stat(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + unsigned char cmd[2]; + size_t cmdLen; + unsigned char stat[2]; + size_t statLen; + + DBG (10, "get_stat: start\n"); + + /*check status*/ + cmd[0] = 0x1b; + cmd[1] = 0x03; + cmdLen = 2; + statLen = 2; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "get_stat: error checking status\n"); + return 0; + } + + return stat[0]; +} + +static SANE_Status +get_ident(struct scanner *s) +{ + int i; + SANE_Status ret; + + unsigned char cmd[] = {0x1b,0x13}; + size_t cmdLen = 2; + unsigned char in[0x20]; + size_t inLen = sizeof(in); + + DBG (10, "get_ident: start\n"); + + ret = do_cmd ( + s, 0, + cmd, cmdLen, + NULL, 0, + in, &inLen + ); + + if (ret != SANE_STATUS_GOOD){ + return ret; + } + + /*hmm, similar to scsi?*/ + for (i = 7; (in[i] == ' ' || in[i] == 0xff) && i >= 0; i--){ + in[i] = 0; + } + s->sane.vendor = strndup((char *)in, 8); + + for (i = 23; (in[i] == ' ' || in[i] == 0xff) && i >= 8; i--){ + in[i] = 0; + } + s->sane.model= strndup((char *)in+8, 24); + + s->sane.type = "scanner"; + + DBG (10, "get_ident: finish\n"); + return ret; +} + +/* + * From the SANE spec: + * This function is used to establish a connection to a particular + * device. The name of the device to be opened is passed in argument + * name. If the call completes successfully, a handle for the device + * is returned in *h. As a special case, specifying a zero-length + * string as the device requests opening the first available device + * (if there is such a device). + */ +SANE_Status +sane_open (SANE_String_Const name, SANE_Handle * handle) +{ + struct scanner *dev = NULL; + struct scanner *s = NULL; + SANE_Status ret; + + DBG (10, "sane_open: start\n"); + + if(scanner_devList){ + DBG (15, "sane_open: searching currently attached scanners\n"); + } + else{ + DBG (15, "sane_open: no scanners currently attached, attaching\n"); + + ret = sane_get_devices(NULL,0); + if(ret != SANE_STATUS_GOOD){ + return ret; + } + } + + if(name[0] == 0){ + DBG (15, "sane_open: no device requested, using default\n"); + s = scanner_devList; + } + else{ + DBG (15, "sane_open: device %s requested, attaching\n", name); + + for (dev = scanner_devList; dev; dev = dev->next) { + if (strcmp (dev->sane.name, name) == 0) { + s = dev; + break; + } + } + } + + if (!s) { + DBG (5, "sane_open: no device found\n"); + return SANE_STATUS_INVAL; + } + + DBG (15, "sane_open: device %s found\n", s->sane.name); + + *handle = s; + + /* connect the fd so we can talk to scanner */ + ret = connect_fd(s); + if(ret != SANE_STATUS_GOOD){ + return ret; + } + + DBG (10, "sane_open: finish\n"); + + return SANE_STATUS_GOOD; +} + +/* + * @@ Section 3 - SANE Options functions + */ + +/* + * Returns the options we know. + * + * From the SANE spec: + * This function is used to access option descriptors. The function + * returns the option descriptor for option number n of the device + * represented by handle h. Option number 0 is guaranteed to be a + * valid option. Its value is an integer that specifies the number of + * options that are available for device handle h (the count includes + * option 0). If n is not a valid option index, the function returns + * NULL. The returned option descriptor is guaranteed to remain valid + * (and at the returned address) until the device is closed. + */ +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) +{ + struct scanner *s = handle; + int i; + SANE_Option_Descriptor *opt = &s->opt[option]; + + DBG (20, "sane_get_option_descriptor: %d\n", option); + + if ((unsigned) option >= NUM_OPTIONS) + return NULL; + + /* "Mode" group -------------------------------------------------------- */ + if(option==OPT_MODE_GROUP){ + opt->title = "Scan Mode"; + opt->desc = ""; + opt->type = SANE_TYPE_GROUP; + opt->constraint_type = SANE_CONSTRAINT_NONE; + } + + /* source */ + else if(option==OPT_SOURCE){ + i=0; + if(s->has_fb){ + s->source_list[i++]=STRING_FLATBED; + } + if(s->has_adf){ + s->source_list[i++]=STRING_ADFFRONT; + s->source_list[i++]=STRING_ADFBACK; + s->source_list[i++]=STRING_ADFDUPLEX; + } + s->source_list[i]=NULL; + + opt->name = SANE_NAME_SCAN_SOURCE; + opt->title = SANE_TITLE_SCAN_SOURCE; + opt->desc = SANE_DESC_SCAN_SOURCE; + opt->type = SANE_TYPE_STRING; + opt->constraint_type = SANE_CONSTRAINT_STRING_LIST; + opt->constraint.string_list = s->source_list; + opt->size = maxStringSize (opt->constraint.string_list); + if(i > 1){ + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + } + + /* scan mode */ + else if(option==OPT_MODE){ + i=0; + s->mode_list[i++]=STRING_LINEART; + s->mode_list[i++]=STRING_GRAYSCALE; + s->mode_list[i++]=STRING_COLOR; + s->mode_list[i]=NULL; + + opt->name = SANE_NAME_SCAN_MODE; + opt->title = SANE_TITLE_SCAN_MODE; + opt->desc = SANE_DESC_SCAN_MODE; + opt->type = SANE_TYPE_STRING; + opt->constraint_type = SANE_CONSTRAINT_STRING_LIST; + opt->constraint.string_list = s->mode_list; + opt->size = maxStringSize (opt->constraint.string_list); + if(i > 1){ + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + } + + else if(option==OPT_X_RES){ + i=0; + if(s->x_res_150){ + s->x_res_list[++i] = 150; + } + if(s->x_res_225){ + s->x_res_list[++i] = 225; + } + if(s->x_res_300){ + s->x_res_list[++i] = 300; + } + if(s->x_res_600){ + s->x_res_list[++i] = 600; + } + s->x_res_list[0] = i; + + opt->name = SANE_NAME_SCAN_RESOLUTION; + opt->title = SANE_TITLE_SCAN_X_RESOLUTION; + opt->desc = SANE_DESC_SCAN_X_RESOLUTION; + opt->type = SANE_TYPE_INT; + opt->unit = SANE_UNIT_DPI; + if(i > 1){ + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + + opt->constraint_type = SANE_CONSTRAINT_WORD_LIST; + opt->constraint.word_list = s->x_res_list; + } + + /* "Geometry" group ---------------------------------------------------- */ + if(option==OPT_GEOMETRY_GROUP){ + opt->name = SANE_NAME_GEOMETRY; + opt->title = SANE_TITLE_GEOMETRY; + opt->desc = SANE_DESC_GEOMETRY; + opt->type = SANE_TYPE_GROUP; + opt->constraint_type = SANE_CONSTRAINT_NONE; + } + + /* top-left x */ + if(option==OPT_TL_X){ + /* values stored in 1200 dpi units */ + /* must be converted to MM for sane */ + s->tl_x_range.min = SCANNER_UNIT_TO_FIXED_MM(0); + s->tl_x_range.max = SCANNER_UNIT_TO_FIXED_MM(get_page_width(s)-s->min_x); + s->tl_x_range.quant = MM_PER_UNIT_FIX; + + opt->name = SANE_NAME_SCAN_TL_X; + opt->title = SANE_TITLE_SCAN_TL_X; + opt->desc = SANE_DESC_SCAN_TL_X; + opt->type = SANE_TYPE_FIXED; + opt->unit = SANE_UNIT_MM; + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &(s->tl_x_range); + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + opt->cap = SANE_CAP_INACTIVE; + } + + /* top-left y */ + if(option==OPT_TL_Y){ + /* values stored in 1200 dpi units */ + /* must be converted to MM for sane */ + s->tl_y_range.min = SCANNER_UNIT_TO_FIXED_MM(0); + s->tl_y_range.max = SCANNER_UNIT_TO_FIXED_MM(get_page_height(s)-s->min_y); + s->tl_y_range.quant = MM_PER_UNIT_FIX; + + opt->name = SANE_NAME_SCAN_TL_Y; + opt->title = SANE_TITLE_SCAN_TL_Y; + opt->desc = SANE_DESC_SCAN_TL_Y; + opt->type = SANE_TYPE_FIXED; + opt->unit = SANE_UNIT_MM; + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &(s->tl_y_range); + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + opt->cap = SANE_CAP_INACTIVE; + } + + /* bottom-right x */ + if(option==OPT_BR_X){ + /* values stored in 1200 dpi units */ + /* must be converted to MM for sane */ + s->br_x_range.min = SCANNER_UNIT_TO_FIXED_MM(s->min_x); + s->br_x_range.max = SCANNER_UNIT_TO_FIXED_MM(get_page_width(s)); + s->br_x_range.quant = MM_PER_UNIT_FIX; + + opt->name = SANE_NAME_SCAN_BR_X; + opt->title = SANE_TITLE_SCAN_BR_X; + opt->desc = SANE_DESC_SCAN_BR_X; + opt->type = SANE_TYPE_FIXED; + opt->unit = SANE_UNIT_MM; + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &(s->br_x_range); + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + opt->cap = SANE_CAP_INACTIVE; + } + + /* bottom-right y */ + if(option==OPT_BR_Y){ + /* values stored in 1200 dpi units */ + /* must be converted to MM for sane */ + s->br_y_range.min = SCANNER_UNIT_TO_FIXED_MM(s->min_y); + s->br_y_range.max = SCANNER_UNIT_TO_FIXED_MM(get_page_height(s)); + s->br_y_range.quant = MM_PER_UNIT_FIX; + + opt->name = SANE_NAME_SCAN_BR_Y; + opt->title = SANE_TITLE_SCAN_BR_Y; + opt->desc = SANE_DESC_SCAN_BR_Y; + opt->type = SANE_TYPE_FIXED; + opt->unit = SANE_UNIT_MM; + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &(s->br_y_range); + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + opt->cap = SANE_CAP_INACTIVE; + } + + /* page width */ + if(option==OPT_PAGE_WIDTH){ + /* values stored in 1200 dpi units */ + /* must be converted to MM for sane */ + s->paper_x_range.min = SCANNER_UNIT_TO_FIXED_MM(s->min_x); + s->paper_x_range.max = SCANNER_UNIT_TO_FIXED_MM(s->max_x); + s->paper_x_range.quant = MM_PER_UNIT_FIX; + + opt->name = SANE_NAME_PAGE_WIDTH; + opt->title = SANE_TITLE_PAGE_WIDTH; + opt->desc = SANE_DESC_PAGE_WIDTH; + opt->type = SANE_TYPE_FIXED; + opt->unit = SANE_UNIT_MM; + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &s->paper_x_range; + + if(s->has_adf){ + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + if(s->source == SOURCE_FLATBED){ + opt->cap |= SANE_CAP_INACTIVE; + } + } + else{ + opt->cap = SANE_CAP_INACTIVE; + } + opt->cap = SANE_CAP_INACTIVE; + } + + /* page height */ + if(option==OPT_PAGE_HEIGHT){ + /* values stored in 1200 dpi units */ + /* must be converted to MM for sane */ + s->paper_y_range.min = SCANNER_UNIT_TO_FIXED_MM(0); + s->paper_y_range.max = SCANNER_UNIT_TO_FIXED_MM(s->max_y); + s->paper_y_range.quant = MM_PER_UNIT_FIX; + + opt->name = SANE_NAME_PAGE_HEIGHT; + opt->title = SANE_TITLE_PAGE_HEIGHT; + opt->desc = "Specifies the height of the media, 0 will auto-detect."; + opt->type = SANE_TYPE_FIXED; + opt->unit = SANE_UNIT_MM; + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &s->paper_y_range; + + if(s->has_adf){ + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + if(s->source == SOURCE_FLATBED){ + opt->cap |= SANE_CAP_INACTIVE; + } + } + else{ + opt->cap = SANE_CAP_INACTIVE; + } + } + + /* "Enhancement" group ------------------------------------------------- */ + if(option==OPT_ENHANCEMENT_GROUP){ + opt->name = SANE_NAME_ENHANCEMENT; + opt->title = SANE_TITLE_ENHANCEMENT; + opt->desc = SANE_DESC_ENHANCEMENT; + opt->type = SANE_TYPE_GROUP; + opt->constraint_type = SANE_CONSTRAINT_NONE; + } + + /* brightness */ + if(option==OPT_BRIGHTNESS){ + opt->name = SANE_NAME_BRIGHTNESS; + opt->title = SANE_TITLE_BRIGHTNESS; + opt->desc = SANE_DESC_BRIGHTNESS; + opt->type = SANE_TYPE_INT; + opt->unit = SANE_UNIT_NONE; + + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &s->brightness_range; + s->brightness_range.quant=1; + s->brightness_range.min=-127; + s->brightness_range.max=127; + + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + + /* contrast */ + if(option==OPT_CONTRAST){ + opt->name = SANE_NAME_CONTRAST; + opt->title = SANE_TITLE_CONTRAST; + opt->desc = SANE_DESC_CONTRAST; + opt->type = SANE_TYPE_INT; + opt->unit = SANE_UNIT_NONE; + + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &s->contrast_range; + s->contrast_range.quant=1; + s->contrast_range.min=-127; + s->contrast_range.max=127; + + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + + /* gamma */ + if(option==OPT_GAMMA){ + opt->name = "gamma"; + opt->title = "Gamma function exponent"; + opt->desc = "Changes intensity of midtones"; + opt->type = SANE_TYPE_FIXED; + opt->unit = SANE_UNIT_NONE; + + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &s->gamma_range; + + /* value ranges from .3 to 5, should be log scale? */ + s->gamma_range.quant=SANE_FIX(0.01); + s->gamma_range.min=SANE_FIX(0.3); + s->gamma_range.max=SANE_FIX(5); + + /*if (s->num_download_gamma){ + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + }*/ + + opt->cap = SANE_CAP_INACTIVE; + } + + /*threshold*/ + if(option==OPT_THRESHOLD){ + opt->name = SANE_NAME_THRESHOLD; + opt->title = SANE_TITLE_THRESHOLD; + opt->desc = SANE_DESC_THRESHOLD; + opt->type = SANE_TYPE_INT; + opt->unit = SANE_UNIT_NONE; + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &s->threshold_range; + s->threshold_range.min=0; + s->threshold_range.max=255; + s->threshold_range.quant=1; + + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + if(s->mode != MODE_LINEART){ + opt->cap |= SANE_CAP_INACTIVE; + } + } + + if(option==OPT_THRESHOLD_CURVE){ + opt->name = "threshold-curve"; + opt->title = "Threshold curve"; + opt->desc = "Dynamic threshold curve, from light to dark, normally 50-65"; + opt->type = SANE_TYPE_INT; + opt->unit = SANE_UNIT_NONE; + + opt->constraint_type = SANE_CONSTRAINT_RANGE; + opt->constraint.range = &s->threshold_curve_range; + s->threshold_curve_range.min=0; + s->threshold_curve_range.max=127; + s->threshold_curve_range.quant=1; + + opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + if(s->mode != MODE_LINEART){ + opt->cap |= SANE_CAP_INACTIVE; + } + } + + /* "Sensor" group ------------------------------------------------------ */ + if(option==OPT_SENSOR_GROUP){ + opt->name = SANE_NAME_SENSORS; + opt->title = SANE_TITLE_SENSORS; + opt->desc = SANE_DESC_SENSORS; + opt->type = SANE_TYPE_GROUP; + opt->constraint_type = SANE_CONSTRAINT_NONE; + + /*flaming hack to get scanimage to hide group*/ + if (!s->has_adf) + opt->type = SANE_TYPE_BOOL; + } + + if(option==OPT_SCAN_SW){ + opt->name = SANE_NAME_SCAN; + opt->title = SANE_TITLE_SCAN; + opt->desc = SANE_DESC_SCAN; + opt->type = SANE_TYPE_BOOL; + opt->unit = SANE_UNIT_NONE; + if (s->has_adf) + opt->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; + else + opt->cap = SANE_CAP_INACTIVE; + } + + if(option==OPT_HOPPER){ + opt->name = SANE_NAME_PAGE_LOADED; + opt->title = SANE_TITLE_PAGE_LOADED; + opt->desc = SANE_DESC_PAGE_LOADED; + opt->type = SANE_TYPE_BOOL; + opt->unit = SANE_UNIT_NONE; + if (s->has_adf) + opt->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; + else + opt->cap = SANE_CAP_INACTIVE; + } + + if(option==OPT_TOP){ + opt->name = "top-edge"; + opt->title = "Top edge"; + opt->desc = "Paper is pulled partly into adf"; + opt->type = SANE_TYPE_BOOL; + opt->unit = SANE_UNIT_NONE; + if (s->has_adf) + opt->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; + else + opt->cap = SANE_CAP_INACTIVE; + } + + if(option==OPT_ADF_OPEN){ + opt->name = SANE_NAME_COVER_OPEN; + opt->title = SANE_TITLE_COVER_OPEN; + opt->desc = SANE_DESC_COVER_OPEN; + opt->type = SANE_TYPE_BOOL; + opt->unit = SANE_UNIT_NONE; + if (s->has_adf) + opt->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; + else + opt->cap = SANE_CAP_INACTIVE; + } + + if(option==OPT_SLEEP){ + opt->name = "power-save"; + opt->title = "Power saving"; + opt->desc = "Scanner in power saving mode"; + opt->type = SANE_TYPE_BOOL; + opt->unit = SANE_UNIT_NONE; + if (s->has_adf) + opt->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; + else + opt->cap = SANE_CAP_INACTIVE; + } + + return opt; +} + +/** + * Gets or sets an option value. + * + * From the SANE spec: + * This function is used to set or inquire the current value of option + * number n of the device represented by handle h. The manner in which + * the option is controlled is specified by parameter action. The + * possible values of this parameter are described in more detail + * below. The value of the option is passed through argument val. It + * is a pointer to the memory that holds the option value. The memory + * area pointed to by v must be big enough to hold the entire option + * value (determined by member size in the corresponding option + * descriptor). + * + * The only exception to this rule is that when setting the value of a + * string option, the string pointed to by argument v may be shorter + * since the backend will stop reading the option value upon + * encountering the first NUL terminator in the string. If argument i + * is not NULL, the value of *i will be set to provide details on how + * well the request has been met. + */ +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, + SANE_Action action, void *val, SANE_Int * info) +{ + struct scanner *s = (struct scanner *) handle; + SANE_Int dummy = 0; + + /* Make sure that all those statements involving *info cannot break (better + * than having to do "if (info) ..." everywhere!) + */ + if (info == 0) + info = &dummy; + + if (option >= NUM_OPTIONS) { + DBG (5, "sane_control_option: %d too big\n", option); + return SANE_STATUS_INVAL; + } + + if (!SANE_OPTION_IS_ACTIVE (s->opt[option].cap)) { + DBG (5, "sane_control_option: %d inactive\n", option); + return SANE_STATUS_INVAL; + } + + /* + * SANE_ACTION_GET_VALUE: We have to find out the current setting and + * return it in a human-readable form (often, text). + */ + if (action == SANE_ACTION_GET_VALUE) { + SANE_Word * val_p = (SANE_Word *) val; + + DBG (20, "sane_control_option: get value for '%s' (%d)\n", s->opt[option].name,option); + + switch (option) { + + case OPT_NUM_OPTS: + *val_p = NUM_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_SOURCE: + if(s->source == SOURCE_FLATBED){ + strcpy (val, STRING_FLATBED); + } + else if(s->source == SOURCE_ADF_FRONT){ + strcpy (val, STRING_ADFFRONT); + } + else if(s->source == SOURCE_ADF_BACK){ + strcpy (val, STRING_ADFBACK); + } + else if(s->source == SOURCE_ADF_DUPLEX){ + strcpy (val, STRING_ADFDUPLEX); + } + else{ + DBG(5,"missing option val for source\n"); + } + return SANE_STATUS_GOOD; + + case OPT_MODE: + if(s->mode == MODE_LINEART){ + strcpy (val, STRING_LINEART); + } + else if(s->mode == MODE_GRAYSCALE){ + strcpy (val, STRING_GRAYSCALE); + } + else if(s->mode == MODE_COLOR){ + strcpy (val, STRING_COLOR); + } + return SANE_STATUS_GOOD; + + case OPT_X_RES: + *val_p = s->resolution_x; + return SANE_STATUS_GOOD; + + case OPT_TL_X: + *val_p = SCANNER_UNIT_TO_FIXED_MM(s->tl_x); + return SANE_STATUS_GOOD; + + case OPT_TL_Y: + *val_p = SCANNER_UNIT_TO_FIXED_MM(s->tl_y); + return SANE_STATUS_GOOD; + + case OPT_BR_X: + *val_p = SCANNER_UNIT_TO_FIXED_MM(s->br_x); + return SANE_STATUS_GOOD; + + case OPT_BR_Y: + *val_p = SCANNER_UNIT_TO_FIXED_MM(s->br_y); + return SANE_STATUS_GOOD; + + case OPT_PAGE_WIDTH: + *val_p = SCANNER_UNIT_TO_FIXED_MM(s->page_width); + return SANE_STATUS_GOOD; + + case OPT_PAGE_HEIGHT: + *val_p = SCANNER_UNIT_TO_FIXED_MM(s->page_height); + return SANE_STATUS_GOOD; + + case OPT_BRIGHTNESS: + *val_p = s->brightness; + return SANE_STATUS_GOOD; + + case OPT_CONTRAST: + *val_p = s->contrast; + return SANE_STATUS_GOOD; + + case OPT_GAMMA: + *val_p = SANE_FIX(s->gamma); + return SANE_STATUS_GOOD; + + case OPT_THRESHOLD: + *val_p = s->threshold; + return SANE_STATUS_GOOD; + + case OPT_THRESHOLD_CURVE: + *val_p = s->threshold_curve; + return SANE_STATUS_GOOD; + + /* Sensor Group */ + case OPT_SCAN_SW: + get_hardware_status(s); + *val_p = s->hw_scan_sw; + return SANE_STATUS_GOOD; + + case OPT_HOPPER: + get_hardware_status(s); + *val_p = s->hw_hopper; + return SANE_STATUS_GOOD; + + case OPT_TOP: + get_hardware_status(s); + *val_p = s->hw_top; + return SANE_STATUS_GOOD; + + case OPT_ADF_OPEN: + get_hardware_status(s); + *val_p = s->hw_adf_open; + return SANE_STATUS_GOOD; + + case OPT_SLEEP: + get_hardware_status(s); + *val_p = s->hw_sleep; + return SANE_STATUS_GOOD; + } + } + else if (action == SANE_ACTION_SET_VALUE) { + int tmp; + SANE_Word val_c; + SANE_Status status; + + DBG (20, "sane_control_option: set value for '%s' (%d)\n", s->opt[option].name,option); + + if ( s->started ) { + DBG (5, "sane_control_option: cant set, device busy\n"); + return SANE_STATUS_DEVICE_BUSY; + } + + if (!SANE_OPTION_IS_SETTABLE (s->opt[option].cap)) { + DBG (5, "sane_control_option: not settable\n"); + return SANE_STATUS_INVAL; + } + + status = sanei_constrain_value (s->opt + option, val, info); + if (status != SANE_STATUS_GOOD) { + DBG (5, "sane_control_option: bad value\n"); + return status; + } + + /* may have been changed by constrain, so dont copy until now */ + val_c = *(SANE_Word *)val; + + /* + * Note - for those options which can assume one of a list of + * valid values, we can safely assume that they will have + * exactly one of those values because that's what + * sanei_constrain_value does. Hence no "else: invalid" branches + * below. + */ + switch (option) { + + /* Mode Group */ + case OPT_SOURCE: + if (!strcmp (val, STRING_ADFFRONT)) { + tmp = SOURCE_ADF_FRONT; + } + else if (!strcmp (val, STRING_ADFBACK)) { + tmp = SOURCE_ADF_BACK; + } + else if (!strcmp (val, STRING_ADFDUPLEX)) { + tmp = SOURCE_ADF_DUPLEX; + } + else{ + tmp = SOURCE_FLATBED; + } + + if (s->source == tmp) + return SANE_STATUS_GOOD; + + s->source = tmp; + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_MODE: + if (!strcmp (val, STRING_LINEART)) { + tmp = MODE_LINEART; + } + else if (!strcmp (val, STRING_GRAYSCALE)) { + tmp = MODE_GRAYSCALE; + } + else{ + tmp = MODE_COLOR; + } + + if (tmp == s->mode) + return SANE_STATUS_GOOD; + + s->mode = tmp; + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return change_params(s); + + case OPT_X_RES: + + if (s->resolution_x == val_c) + return SANE_STATUS_GOOD; + + s->resolution_x = val_c; + + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return change_params(s); + + /* Geometry Group */ + case OPT_TL_X: + if (s->tl_x == FIXED_MM_TO_SCANNER_UNIT(val_c)) + return SANE_STATUS_GOOD; + + s->tl_x = FIXED_MM_TO_SCANNER_UNIT(val_c); + + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_TL_Y: + if (s->tl_y == FIXED_MM_TO_SCANNER_UNIT(val_c)) + return SANE_STATUS_GOOD; + + s->tl_y = FIXED_MM_TO_SCANNER_UNIT(val_c); + + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_BR_X: + if (s->br_x == FIXED_MM_TO_SCANNER_UNIT(val_c)) + return SANE_STATUS_GOOD; + + s->br_x = FIXED_MM_TO_SCANNER_UNIT(val_c); + + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_BR_Y: + if (s->br_y == FIXED_MM_TO_SCANNER_UNIT(val_c)) + return SANE_STATUS_GOOD; + + s->br_y = FIXED_MM_TO_SCANNER_UNIT(val_c); + + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_PAGE_WIDTH: + if (s->page_width == FIXED_MM_TO_SCANNER_UNIT(val_c)) + return SANE_STATUS_GOOD; + + s->page_width = FIXED_MM_TO_SCANNER_UNIT(val_c); + *info |= SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_PAGE_HEIGHT: + if (s->page_height == FIXED_MM_TO_SCANNER_UNIT(val_c)) + return SANE_STATUS_GOOD; + + s->page_height = FIXED_MM_TO_SCANNER_UNIT(val_c); + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return change_params(s); + + /* Enhancement Group */ + case OPT_BRIGHTNESS: + s->brightness = val_c; + return SANE_STATUS_GOOD; + + case OPT_CONTRAST: + s->contrast = val_c; + return SANE_STATUS_GOOD; + + case OPT_GAMMA: + s->gamma = SANE_UNFIX(val_c); + return SANE_STATUS_GOOD; + + case OPT_THRESHOLD: + s->threshold = val_c; + return SANE_STATUS_GOOD; + + case OPT_THRESHOLD_CURVE: + s->threshold_curve = val_c; + return SANE_STATUS_GOOD; + + } /* switch */ + } /* else */ + + return SANE_STATUS_INVAL; +} + +/* use height and width to initialize rest of transfer vals */ +static void +update_transfer_totals(struct transfer * t) +{ + if (t->image == NULL) return; + + t->total_bytes = t->line_stride * t->image->height; + t->rx_bytes = 0; + t->done = 0; +} + +/* each model has various settings that differ based on X resolution */ +/* we hard-code the list (determined from usb snoops) here */ +struct model_res { + int model; + int x_res; + int y_res; + int usb_power; + + int max_x; + int min_x; + int max_y; + int min_y; + + int act_width; /* total data width output, in pixels per side (always 3 sides) */ + int req_width; /* stride in pixels per side between color planes (always 3 sides) */ + int head_width; + int pad_width; + + int block_height; + + int cal_width; + int cal_headwidth; + int cal_reqwidth; + + unsigned char * sw_coarsecal; + unsigned char * sw_finecal; + unsigned char * sw_sendcal; + + unsigned char * head_cal1; + unsigned char * head_cal2; + unsigned char * sw_scan; + +}; + +static struct model_res settings[] = { + + /*S300 AC*/ +/* model xres yres u mxx mnx mxy mny actw reqw hedw padw bh calw cal_hedw cal_reqw */ + { MODEL_S300, 150, 150, 0, 1296, 32, 2662, 32, 4256, 1480, 1296, 184, 41, 8512, 2592, 2960, + setWindowCoarseCal_S300_150, setWindowFineCal_S300_150, + setWindowSendCal_S300_150, sendCal1Header_S300_150, + sendCal2Header_S300_150, setWindowScan_S300_150 }, + + { MODEL_S300, 225, 200, 0, 1944, 32, 3993, 32, 6144, 2100, 1944, 156, 28, 8192, 2592, 2800, + setWindowCoarseCal_S300_225, setWindowFineCal_S300_225, + setWindowSendCal_S300_225, sendCal1Header_S300_225, + sendCal2Header_S300_225, setWindowScan_S300_225 }, + + { MODEL_S300, 300, 300, 0, 2592, 32, 5324, 32, 8192, 2800, 2592, 208, 21, 8192, 2592, 2800, + setWindowCoarseCal_S300_300, setWindowFineCal_S300_300, + setWindowSendCal_S300_300, sendCal1Header_S300_300, + sendCal2Header_S300_300, setWindowScan_S300_300 }, + + { MODEL_S300, 600, 600, 0, 5184, 32, 10648, 32, 16064, 5440, 5184, 256, 10, 16064, 5184, 5440, + setWindowCoarseCal_S300_600, setWindowFineCal_S300_600, + setWindowSendCal_S300_600, sendCal1Header_S300_600, + sendCal2Header_S300_600, setWindowScan_S300_600 }, + + /*S300 USB*/ +/* model xres yres u mxx mnx mxy mny actw reqw hedw padw bh calw cal_hedw cal_reqw */ + { MODEL_S300, 150, 150, 1, 1296, 32, 2662, 32, 7216, 2960, 1296, 1664, 24, 14432, 2592, 5920, + setWindowCoarseCal_S300_150_U, setWindowFineCal_S300_150_U, + setWindowSendCal_S300_150_U, sendCal1Header_S300_150_U, + sendCal2Header_S300_150_U, setWindowScan_S300_150_U }, + + { MODEL_S300, 225, 200, 1, 1944, 32, 3993, 32, 10584, 4320, 1944, 2376, 16, 14112, 2592, 5760, + setWindowCoarseCal_S300_225_U, setWindowFineCal_S300_225_U, + setWindowSendCal_S300_225_U, sendCal1Header_S300_225_U, + sendCal2Header_S300_225_U, setWindowScan_S300_225_U }, + + { MODEL_S300, 300, 300, 1, 2592, 32, 5324, 32, 15872, 6640, 2592, 4048, 11, 15872, 2592, 6640, + setWindowCoarseCal_S300_300_U, setWindowFineCal_S300_300_U, + setWindowSendCal_S300_300_U, sendCal1Header_S300_300_U, + sendCal2Header_S300_300_U, setWindowScan_S300_300_U }, + + { MODEL_S300, 600, 600, 1, 5184, 32, 10648, 32, 16064, 5440, 5184, 256, 10, 16064, 5184, 5440, + setWindowCoarseCal_S300_600, setWindowFineCal_S300_600, + setWindowSendCal_S300_600, sendCal1Header_S300_600, + sendCal2Header_S300_600, setWindowScan_S300_600 }, + + /*fi-60F*/ +/* model xres yres u mxx mnx mxy mny actw reqw hedw padw bh calw cal_hedw cal_reqw */ + { MODEL_FI60F, 150, 150, 0, 648, 32, 875, 32, 1480, 632, 216, 416, 41, 1480, 216, 632, + setWindowCoarseCal_FI60F_150, setWindowFineCal_FI60F_150, + setWindowSendCal_FI60F_150, sendCal1Header_FI60F_150, + sendCal2Header_FI60F_150, setWindowScan_FI60F_150 }, + + { MODEL_FI60F, 300, 300, 0, 1296, 32, 1749, 32, 2400, 958, 432, 526, 72, 2400, 432, 958, + setWindowCoarseCal_FI60F_300, setWindowFineCal_FI60F_300, + setWindowSendCal_FI60F_300, sendCal1Header_FI60F_300, + sendCal2Header_FI60F_300, setWindowScan_FI60F_300 }, + + { MODEL_FI60F, 600, 600, 0, 2592, 32, 3498, 32, 2848, 978, 864, 114, 61, 2848, 864, 978, + setWindowCoarseCal_FI60F_600, setWindowFineCal_FI60F_600, + setWindowSendCal_FI60F_600, sendCal1Header_FI60F_600, + sendCal2Header_FI60F_600, setWindowScan_FI60F_600 }, + + { MODEL_NONE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + NULL, NULL, NULL, NULL, NULL, NULL }, + +}; + +/* + * clean up scanner struct vals when user changes mode, res, etc + */ +static SANE_Status +change_params(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + int img_heads, img_pages, width; + int i=0; + + DBG (10, "change_params: start\n"); + + do { + if(settings[i].model == s->model + && settings[i].x_res == s->resolution_x + && settings[i].usb_power == s->usb_power){ + + /*pull in closest y resolution*/ + s->resolution_y = settings[i].y_res; + + /*1200 dpi*/ + s->max_x = settings[i].max_x * 1200/s->resolution_x; + s->min_x = settings[i].min_x * 1200/s->resolution_x; + s->max_y = settings[i].max_y * 1200/s->resolution_y; + s->min_y = settings[i].min_y * 1200/s->resolution_y; + + s->page_width = s->max_x; + s->br_x = s->max_x; + s->br_y = s->max_y; + + /*current dpi*/ + s->setWindowCoarseCal = settings[i].sw_coarsecal; + s->setWindowCoarseCalLen = SET_WINDOW_LEN; + + s->setWindowFineCal = settings[i].sw_finecal; + s->setWindowFineCalLen = SET_WINDOW_LEN; + + s->setWindowSendCal = settings[i].sw_sendcal; + s->setWindowSendCalLen = SET_WINDOW_LEN; + + s->sendCal1Header = settings[i].head_cal1; + s->sendCal1HeaderLen = 14; + + s->sendCal2Header = settings[i].head_cal2; + s->sendCal2HeaderLen = 7; + + s->setWindowScan = settings[i].sw_scan; + s->setWindowScanLen = SET_WINDOW_LEN; + + break; + } + i++; + } while (settings[i].model); + + if (!settings[i].model) + { + return SANE_STATUS_INVAL; + } + + if (s->model == MODEL_S300) + { + img_heads = 1; /* image width is the same as the plane width on the S300 */ + img_pages = 2; + } + else /* (s->model == MODEL_FI60F) */ + { + img_heads = 3; /* image width is 3* the plane width on the FI-60F */ + img_pages = 1; + } + + /* set up the transfer structs */ + s->cal_image.plane_width = settings[i].cal_headwidth; + s->cal_image.plane_stride = settings[i].cal_reqwidth * 3; + s->cal_image.line_stride = settings[i].cal_width * 3; + s->cal_image.raw_data = NULL; + s->cal_image.image = NULL; + + s->cal_data.plane_width = settings[i].cal_headwidth; /* width is the same, but there are 2 bytes per pixel component */ + s->cal_data.plane_stride = settings[i].cal_reqwidth * 6; + s->cal_data.line_stride = settings[i].cal_width * 6; + s->cal_data.raw_data = NULL; + s->cal_data.image = &s->sendcal; + + s->block_xfr.plane_width = settings[i].head_width; + s->block_xfr.plane_stride = settings[i].req_width * 3; + s->block_xfr.line_stride = settings[i].act_width * 3; + s->block_xfr.raw_data = NULL; + s->block_xfr.image = &s->block_img; + + /* set up the block image used during scanning operation */ + width = s->block_xfr.plane_width * img_heads; + s->block_img.width_pix = width; + s->block_img.width_bytes = width * 3; + s->block_img.height = settings[i].block_height; + s->block_img.pages = img_pages; + s->block_img.buffer = NULL; + + /* set up the calibration image blocks */ + width = s->cal_image.plane_width * img_heads; + s->coarsecal.width_pix = s->darkcal.width_pix = s->lightcal.width_pix = width; + s->coarsecal.width_bytes = s->darkcal.width_bytes = s->lightcal.width_bytes = width * 3; + s->coarsecal.height = 1; + s->darkcal.height = s->lightcal.height = 16; + s->coarsecal.pages = s->darkcal.pages = s->lightcal.pages = img_pages; + s->coarsecal.buffer = s->darkcal.buffer = s->lightcal.buffer = NULL; + + /* set up the calibration data block */ + width = s->cal_data.plane_width * img_heads; + s->sendcal.width_pix = width; + s->sendcal.width_bytes = width * 6; /* 2 bytes of cal data per pixel component */ + s->sendcal.height = 1; + s->sendcal.pages = img_pages; + s->sendcal.buffer = NULL; + + /* set up the fullscan parameters */ + s->fullscan.width_bytes = s->block_xfr.line_stride; + if(s->source == SOURCE_FLATBED || !s->page_height) + { + /* flatbed and adf in autodetect always ask for all*/ + s->fullscan.height = s->max_y * s->resolution_y / 1200; + } + else + { + /* adf with specified paper size requires padding (~1/2in) */ + s->fullscan.height = (s->page_height+600) * s->resolution_y / 1200; + } + + /* fill in front settings */ + s->front.width_pix = s->block_img.width_pix; + switch (s->mode) { + case MODE_COLOR: + s->front.width_bytes = s->front.width_pix*3; + break; + case MODE_GRAYSCALE: + s->front.width_bytes = s->front.width_pix; + break; + default: /*binary*/ + s->front.width_bytes = s->front.width_pix/8; + break; + } + /*output image might be taller than scan due to interpolation*/ + s->front.height = s->fullscan.height * s->resolution_x / s->resolution_y; + s->front.pages = 1; + s->front.buffer = NULL; + + /* back settings always same as front settings */ + s->back.width_pix = s->front.width_pix; + s->back.width_bytes = s->front.width_bytes; + s->back.height = s->front.height; + s->back.pages = 1; + s->back.buffer = NULL; + + /* dynamic threshold temp buffer, in gray */ + s->dt.width_pix = s->front.width_pix; + s->dt.width_bytes = s->front.width_pix; + s->dt.height = 1; + s->dt.pages = 1; + s->dt.buffer = NULL; + + /* set up the pointers to the page images in the page structs */ + s->pages[SIDE_FRONT].image = &s->front; + s->pages[SIDE_BACK].image = &s->back; + s->pages[SIDE_FRONT].done = 0; + s->pages[SIDE_BACK].done = 0; + + DBG (10, "change_params: finish\n"); + + return ret; +} + +/* Function to build a lookup table (LUT), often + used by scanners to implement brightness/contrast/gamma + or by backends to speed binarization/thresholding + + offset and slope inputs are -127 to +127 + + slope rotates line around central input/output val, + 0 makes horizontal line + + pos zero neg + . x . . x + . x . . x + out . x .xxxxxxxxxxx . x + . x . . x + ....x....... ............ .......x.... + in in in + + offset moves line vertically, and clamps to output range + 0 keeps the line crossing the center of the table + + high low + . xxxxxxxx . + . x . + out x . x + . . x + ............ xxxxxxxx.... + in in + + out_min/max provide bounds on output values, + useful when building thresholding lut. + 0 and 255 are good defaults otherwise. + */ +static SANE_Status +load_lut (unsigned char * lut, + int in_bits, int out_bits, + int out_min, int out_max, + int slope, int offset) +{ + SANE_Status ret = SANE_STATUS_GOOD; + int i, j; + double shift, rise; + int max_in_val = (1 << in_bits) - 1; + int max_out_val = (1 << out_bits) - 1; + unsigned char * lut_p = lut; + + DBG (10, "load_lut: start\n"); + + /* slope is converted to rise per unit run: + * first [-127,127] to [-1,1] + * then multiply by PI/2 to convert to radians + * then take the tangent (T.O.A) + * then multiply by the normal linear slope + * because the table may not be square, i.e. 1024x256*/ + rise = tan((double)slope/127 * M_PI/2) * max_out_val / max_in_val; + + /* line must stay vertically centered, so figure + * out vertical offset at central input value */ + shift = (double)max_out_val/2 - (rise*max_in_val/2); + + /* convert the user offset setting to scale of output + * first [-127,127] to [-1,1] + * then to [-max_out_val/2,max_out_val/2]*/ + shift += (double)offset / 127 * max_out_val / 2; + + for(i=0;i<=max_in_val;i++){ + j = rise*i + shift; + + if(j<out_min){ + j=out_min; + } + else if(j>out_max){ + j=out_max; + } + + *lut_p=j; + lut_p++; + } + + hexdump(5, "load_lut: ", lut, max_in_val+1); + + DBG (10, "load_lut: finish\n"); + return ret; +} + +/* + * @@ Section 4 - SANE scanning functions + */ +/* + * Called by SANE to retrieve information about the type of data + * that the current scan will return. + * + * From the SANE spec: + * This function is used to obtain the current scan parameters. The + * returned parameters are guaranteed to be accurate between the time + * a scan has been started (sane_start() has been called) and the + * completion of that request. Outside of that window, the returned + * values are best-effort estimates of what the parameters will be + * when sane_start() gets invoked. + * + * Calling this function before a scan has actually started allows, + * for example, to get an estimate of how big the scanned image will + * be. The parameters passed to this function are the handle h of the + * device for which the parameters should be obtained and a pointer p + * to a parameter structure. + */ +SANE_Status +sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) +{ + struct scanner *s = (struct scanner *) handle; + + DBG (10, "sane_get_parameters: start\n"); + + params->pixels_per_line = s->front.width_pix; + params->bytes_per_line = s->front.width_bytes; + if(!s->page_height){ + params->lines = -1; + } + else{ + params->lines = s->front.height; + } + params->last_frame = 1; + + if (s->mode == MODE_COLOR) { + params->format = SANE_FRAME_RGB; + params->depth = 8; + } + else if (s->mode == MODE_GRAYSCALE) { + params->format = SANE_FRAME_GRAY; + params->depth = 8; + } + else if (s->mode == MODE_LINEART) { + params->format = SANE_FRAME_GRAY; + params->depth = 1; + } + + DBG (15, "\tdepth %d\n", params->depth); + DBG (15, "\tlines %d\n", params->lines); + DBG (15, "\tpixels_per_line %d\n", params->pixels_per_line); + DBG (15, "\tbytes_per_line %d\n", params->bytes_per_line); + + DBG (10, "sane_get_parameters: finish\n"); + + return SANE_STATUS_GOOD; +} + +/* + * Called by SANE when a page acquisition operation is to be started. + * FIXME: wont handle SOURCE_ADF_BACK + */ +SANE_Status +sane_start (SANE_Handle handle) +{ + struct scanner *s = handle; + SANE_Status ret; + int i; + + DBG (10, "sane_start: start\n"); + + /* set side marker on first page */ + if(!s->started){ + if(s->source == SOURCE_ADF_BACK){ + s->side = SIDE_BACK; + } + else{ + s->side = SIDE_FRONT; + } + } + /* if already running, duplex needs to switch sides */ + else if(s->source == SOURCE_ADF_DUPLEX){ + s->side = !s->side; + } + + /* ingest paper with adf */ + if( s->source == SOURCE_ADF_BACK || s->source == SOURCE_ADF_FRONT + || (s->source == SOURCE_ADF_DUPLEX && s->side == SIDE_FRONT) ){ + ret = ingest(s); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to ingest\n"); + sane_cancel((SANE_Handle)s); + return ret; + } + } + + /* first page requires buffers, etc */ + if(!s->started){ + + DBG(15,"sane_start: first page\n"); + + s->started=1; + + ret = teardown_buffers(s); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to teardown buffers\n"); + sane_cancel((SANE_Handle)s); + return SANE_STATUS_NO_MEM; + } + + ret = change_params(s); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to change_params\n"); + sane_cancel((SANE_Handle)s); + return SANE_STATUS_NO_MEM; + } + + ret = setup_buffers(s); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to setup buffers\n"); + sane_cancel((SANE_Handle)s); + return SANE_STATUS_NO_MEM; + } + + ret = load_lut(s->dt_lut, 8, 8, 50, 205, + s->threshold_curve, s->threshold-127); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to load_lut for dt\n"); + sane_cancel((SANE_Handle)s); + return ret; + } + + ret = coarsecal(s); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to coarsecal\n"); + sane_cancel((SANE_Handle)s); + return ret; + } + + ret = finecal(s); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to finecal\n"); + sane_cancel((SANE_Handle)s); + return ret; + } + + ret = send_lut(s); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to send lut\n"); + sane_cancel((SANE_Handle)s); + return ret; + } + + ret = lamp(s,1); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to heat lamp\n"); + sane_cancel((SANE_Handle)s); + return ret; + } + + /*should this be between each page*/ + ret = set_window(s,WINDOW_SCAN); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to set window\n"); + sane_cancel((SANE_Handle)s); + return ret; + } + + } + + /* reset everything when starting any front, or just back */ + if(s->side == SIDE_FRONT || s->source == SOURCE_ADF_BACK){ + + DBG(15,"sane_start: reset counters\n"); + + /* reset scan */ + s->fullscan.done = 0; + s->fullscan.rx_bytes = 0; + s->fullscan.total_bytes = s->fullscan.width_bytes * s->fullscan.height; + + /* reset block */ + update_transfer_totals(&s->block_xfr); + + /* reset front and back page counters */ + for (i = 0; i < 2; i++) + { + struct image *page_img = s->pages[i].image; + s->pages[i].bytes_total = page_img->width_bytes * page_img->height; + s->pages[i].bytes_scanned = 0; + s->pages[i].bytes_read = 0; + s->pages[i].done = 0; + } + + ret = scan(s); + if (ret != SANE_STATUS_GOOD) { + DBG (5, "sane_start: ERROR: failed to start scan\n"); + sane_cancel((SANE_Handle)s); + return ret; + } + } + else{ + DBG(15,"sane_start: back side\n"); + } + + DBG (10, "sane_start: finish\n"); + + return SANE_STATUS_GOOD; +} + +/* the +8 on all the lengths is to makeup for potential block trailers */ +static SANE_Status +setup_buffers(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + DBG (10, "setup_buffers: start\n"); + + /* temporary cal data */ + s->coarsecal.buffer = calloc (1,s->coarsecal.width_bytes * s->coarsecal.height * s->coarsecal.pages); + if(!s->coarsecal.buffer){ + DBG (5, "setup_buffers: ERROR: failed to setup coarse cal buffer\n"); + return SANE_STATUS_NO_MEM; + } + + s->darkcal.buffer = calloc (1,s->darkcal.width_bytes * s->darkcal.height * s->darkcal.pages); + if(!s->darkcal.buffer){ + DBG (5, "setup_buffers: ERROR: failed to setup fine cal buffer\n"); + return SANE_STATUS_NO_MEM; + } + + s->lightcal.buffer = calloc (1,s->lightcal.width_bytes * s->lightcal.height * s->lightcal.pages); + if(!s->lightcal.buffer){ + DBG (5, "setup_buffers: ERROR: failed to setup fine cal buffer\n"); + return SANE_STATUS_NO_MEM; + } + + s->sendcal.buffer = calloc (1,s->sendcal.width_bytes * s->sendcal.height * s->sendcal.pages); + if(!s->sendcal.buffer){ + DBG (5, "setup_buffers: ERROR: failed to setup send cal buffer\n"); + return SANE_STATUS_NO_MEM; + } + + s->cal_image.raw_data = calloc(1, s->cal_image.line_stride * 16 + 8); /* maximum 16 lines input for fine calibration */ + if(!s->cal_image.raw_data){ + DBG (5, "setup_buffers: ERROR: failed to setup calibration input raw data buffer\n"); + return SANE_STATUS_NO_MEM; + } + + s->cal_data.raw_data = calloc(1, s->cal_data.line_stride); /* only 1 line of data is sent */ + if(!s->cal_data.raw_data){ + DBG (5, "setup_buffers: ERROR: failed to setup calibration output raw data buffer\n"); + return SANE_STATUS_NO_MEM; + } + + /* grab up to 512K at a time */ + s->block_img.buffer = calloc (1,s->block_img.width_bytes * s->block_img.height * s->block_img.pages); + if(!s->block_img.buffer){ + DBG (5, "setup_buffers: ERROR: failed to setup block image buffer\n"); + return SANE_STATUS_NO_MEM; + } + s->block_xfr.raw_data = calloc(1, s->block_xfr.line_stride * s->block_img.height + 8); + if(!s->block_xfr.raw_data){ + DBG (5, "setup_buffers: ERROR: failed to setup block raw data buffer\n"); + return SANE_STATUS_NO_MEM; + } + + /* one grayscale line for dynamic threshold */ + s->dt.buffer = calloc (1,s->dt.width_bytes * s->dt.height * s->dt.pages); + if(!s->dt.buffer){ + DBG (5, "setup_buffers: ERROR: failed to setup dt buffer\n"); + return SANE_STATUS_NO_MEM; + } + + /* make image buffer to hold frontside data */ + if(s->source != SOURCE_ADF_BACK){ + + s->front.buffer = calloc (1,s->front.width_bytes * s->front.height * s->front.pages); + if(!s->front.buffer){ + DBG (5, "setup_buffers: ERROR: failed to setup front buffer\n"); + return SANE_STATUS_NO_MEM; + } + } + + /* make image buffer to hold backside data */ + if(s->source == SOURCE_ADF_DUPLEX || s->source == SOURCE_ADF_BACK){ + + s->back.buffer = calloc (1,s->back.width_bytes * s->back.height * s->back.pages); + if(!s->back.buffer){ + DBG (5, "setup_buffers: ERROR: failed to setup back buffer\n"); + return SANE_STATUS_NO_MEM; + } + } + + DBG (10, "setup_buffers: finish\n"); + return ret; +} + +/* + coarse calibration consists of: + 1. turn lamp off (d0) + 2. set window for single line of data (d1) + 3. get line (d2) + 4. update dark coarse cal (c6) + 5. return to #3 if not dark enough + 6. turn lamp on (d0) + 7. get line (d2) + 8. update light coarse cal (c6) + 9. return to #7 if not light enough +*/ + +static SANE_Status +coarsecal(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + size_t cmdLen = 2; + unsigned char cmd[2]; + + size_t statLen = 1; + unsigned char stat[1]; + + size_t payLen = 28; + unsigned char pay[28]; + + int try_count, cal_good[2], x, i, j; + int param[2], zcount[2], high_param[2], low_param[2], avg[2], maxval[2]; + int rgb_avg[2][3], rgb_hicount[2][3]; + + DBG (10, "coarsecal: start\n"); + + if(s->model == MODEL_S300){ + memcpy(pay,coarseCalData_S300,payLen); + } + else{ + memcpy(pay,coarseCalData_FI60F,payLen); + } + + /* ask for 1 line */ + ret = set_window(s, WINDOW_COARSECAL); + if(ret){ + DBG (5, "coarsecal: error sending setwindow\n"); + return ret; + } + + /* dark cal, lamp off */ + ret = lamp(s,0); + if(ret){ + DBG (5, "coarsecal: error lamp off\n"); + return ret; + } + + try_count = 8; + param[0] = 63; + param[1] = 63; + low_param[0] = low_param[1] = -64; /* The S300 will accept coarse offsets from -128 to 127 */ + high_param[0] = high_param[1] = 63; /* By our range is limited to converge faster */ + cal_good[0] = cal_good[1] = 0; + + while (try_count > 0){ + try_count--; + + /* update the coarsecal payload to use our new dark offset parameters */ + if (s->model == MODEL_S300) + { + pay[5] = param[0]; + pay[7] = param[1]; + } + else /* (s->model == MODEL_FI60F) */ + { + pay[5] = param[0]; + pay[7] = param[0]; + pay[9] = param[0]; + } + + /* send coarse cal (c6) */ + cmd[0] = 0x1b; + cmd[1] = 0xc6; + stat[0] = 0; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "coarsecal: error sending c6 cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "coarsecal: cmd bad c6 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + /*send coarse cal payload*/ + stat[0] = 0; + statLen = 1; + + ret = do_cmd( + s, 0, + pay, payLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "coarsecal: error sending c6 payload\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "coarsecal: c6 payload bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + DBG(15, "coarsecal offset: parameter front: %i back: %i\n", param[0], param[1]); + + /* send scan d2 command */ + cmd[0] = 0x1b; + cmd[1] = 0xd2; + stat[0] = 0; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "coarsecal: error sending d2 cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "coarsecal: cmd bad d2 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + s->cal_image.image = &s->coarsecal; + update_transfer_totals(&s->cal_image); + + while(!s->cal_image.done){ + ret = read_from_scanner(s,&s->cal_image); + if(ret){ + DBG (5, "coarsecal: cant read from scanner\n"); + return ret; + } + } + /* convert the raw data into normal packed pixel data */ + descramble_raw(s, &s->cal_image); + + /* gather statistics: count the proportion of 0-valued pixels */ + /* since the lamp is off, there's no point in looking at the green or blue data - they're all from the same sensor anyway */ + zcount[0] = zcount[1] = 0; + avg[0] = avg[1] = 0; + maxval[0] = maxval[1] = 0; + for (j = 0; j < s->coarsecal.pages; j++) + { + int page_offset = j * s->coarsecal.width_bytes * s->coarsecal.height; + for (x = 0; x < s->coarsecal.width_bytes; x++) + { + int val = s->coarsecal.buffer[page_offset + x]; + avg[j] += val; + if (val == 0) zcount[j]++; + if (val > maxval[j]) maxval[j] = val; + } + } + /* convert the zero counts from a pixel count to a proportion in tenths of a percent */ + for (j = 0; j < s->coarsecal.pages; j++) + { + avg[j] /= s->coarsecal.width_bytes; + zcount[j] = zcount[j] * 1000 / s->coarsecal.width_bytes; + } + DBG(15, "coarsecal offset: average pixel values front: %i back: %i\n", avg[0], avg[1]); + DBG(15, "coarsecal offset: maximum pixel values front: %i back: %i\n", maxval[0], maxval[1]); + DBG(15, "coarsecal offset: 0-valued pixel count front: %f%% back: %f%%\n", zcount[0] / 10.0f, zcount[1] / 10.0f); + + /* check the values, adjust parameters if they are not within the target range */ + for (j = 0; j < s->coarsecal.pages; j++) + { + if (!cal_good[j]) + { + if (avg[j] > COARSE_OFFSET_TARGET) + { + high_param[j] = param[j]; + param[j] = (low_param[j] + high_param[j]) / 2; + } + else if (avg[j] < COARSE_OFFSET_TARGET) + { + low_param[j] = param[j]; + param[j] = (low_param[j] + high_param[j]) / 2; + } + else cal_good[j] = 1; + } + } + if (cal_good[0] + cal_good[1] == s->coarsecal.pages) break; + + } /* continue looping for up to 8 tries */ + + /* light cal, lamp on */ + ret = lamp(s,1); + if(ret){ + DBG (5, "coarsecal: error lamp on\n"); + return ret; + } + + try_count = 8; + param[0] = pay[11]; + param[1] = pay[13]; + low_param[0] = low_param[1] = 0; + high_param[0] = high_param[1] = 63; + cal_good[0] = cal_good[1] = 0; + + while (try_count > 0){ + try_count--; + + /* send coarse cal (c6) */ + cmd[0] = 0x1b; + cmd[1] = 0xc6; + stat[0] = 0; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "coarsecal: error sending c6 cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "coarsecal: cmd bad c6 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + /*send coarse cal payload*/ + stat[0] = 0; + statLen = 1; + + ret = do_cmd( + s, 0, + pay, payLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "coarsecal: error sending c6 payload\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "coarsecal: c6 payload bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + DBG(15, "coarsecal gain: parameter front: %i back: %i\n", param[0], param[1]); + + /* send scan d2 command */ + cmd[0] = 0x1b; + cmd[1] = 0xd2; + stat[0] = 0; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "coarsecal: error sending d2 cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "coarsecal: cmd bad d2 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + s->cal_image.image = &s->coarsecal; + update_transfer_totals(&s->cal_image); + + while(!s->cal_image.done){ + ret = read_from_scanner(s,&s->cal_image); + if(ret){ + DBG (5, "coarsecal: cant read from scanner\n"); + return ret; + } + } + /* convert the raw data into normal packed pixel data */ + descramble_raw(s, &s->cal_image); + + /* gather statistics: count the proportion of 255-valued pixels in each color channel */ + /* count the average pixel value in each color channel */ + for (i = 0; i < s->coarsecal.pages; i++) + for (j = 0; j < 3; j++) + rgb_avg[i][j] = rgb_hicount[i][j] = 0; + for (i = 0; i < s->coarsecal.pages; i++) + { + for (x = 0; x < s->coarsecal.width_pix; x++) + { + /* get color channel values and count of pixels pegged at 255 */ + unsigned char *rgbpix = s->coarsecal.buffer + (i * s->coarsecal.width_bytes * s->coarsecal.height) + x * 3; + for (j = 0; j < 3; j++) + { + rgb_avg[i][j] += rgbpix[j]; + if (rgbpix[j] == 255) + rgb_hicount[i][j]++; + } + } + } + /* apply the color correction factors to the averages */ + for (i = 0; i < s->coarsecal.pages; i++) + for (j = 0; j < 3; j++) + rgb_avg[i][j] *= white_factor[j]; + /* set the gain so that none of the color channels are clipping, ie take the highest channel values */ + for (i = 0; i < s->coarsecal.pages; i++) + { + avg[i] = MAX3(rgb_avg[i][0], rgb_avg[i][1], rgb_avg[i][2]) / s->coarsecal.width_pix; + for (j = 0; j < 3; j++) + rgb_avg[i][j] /= s->coarsecal.width_pix; + } + /* convert the 255-counts from a pixel count to a proportion in tenths of a percent */ + for (i = 0; i < s->coarsecal.pages; i++) + { + for (j = 0; j < 3; j++) + { + rgb_hicount[i][j] = rgb_hicount[i][j] * 1000 / s->coarsecal.width_pix; + } + zcount[i] = MAX3(rgb_hicount[i][0], rgb_hicount[i][1], rgb_hicount[i][2]); + } + DBG(15, "coarsecal gain: average RGB values front: (%i,%i,%i) back: (%i,%i,%i)\n", + rgb_avg[0][0], rgb_avg[0][1], rgb_avg[0][2], rgb_avg[1][0], rgb_avg[1][1], rgb_avg[1][2]); + DBG(15, "coarsecal gain: 255-valued pixel count front: (%g,%g,%g) back: (%g,%g,%g)\n", + rgb_hicount[0][0]/10.0f, rgb_hicount[0][1]/10.0f, rgb_hicount[0][2]/10.0f, + rgb_hicount[1][0]/10.0f, rgb_hicount[1][1]/10.0f, rgb_hicount[1][2]/10.0f); + + /* check the values, adjust parameters if they are not within the target range */ + for (x = 0; x < s->coarsecal.pages; x++) + { + if (!cal_good[x]) + { + if (zcount[x] > 9 || avg[x] > coarse_gain_max[x]) + { + high_param[x] = param[x]; + param[x] = (low_param[x] + high_param[x]) / 2; + } + else if (avg[x] < coarse_gain_min[x]) + { + low_param[x] = param[x]; + param[x] = (low_param[x] + high_param[x]) / 2; + } + else cal_good[x] = 1; + } + } + if (cal_good[0] + cal_good[1] == s->coarsecal.pages) break; + + /* update the coarsecal payload to use the new gain parameters */ + if (s->model == MODEL_S300) + { + pay[11] = param[0]; + pay[13] = param[1]; + } + else /* (s->model == MODEL_FI60F) */ + { + pay[11] = param[0]; + pay[13] = param[0]; + pay[15] = param[0]; + } + } + + DBG (10, "coarsecal: finish\n"); + return ret; +} + +static SANE_Status +finecal_send_cal(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + size_t cmdLen = 2; + unsigned char cmd[2]; + + size_t statLen = 1; + unsigned char stat[2]; + + int i, j, k; + unsigned short *p_out, *p_in = (unsigned short *) s->sendcal.buffer; + int planes = (s->model == MODEL_S300) ? 2 : 3; + + /* scramble the raster buffer data into scanner raw format */ + memset(s->cal_data.raw_data, 0, s->cal_data.line_stride); + for (i = 0; i < planes; i++) + for (j = 0; j < s->cal_data.plane_width; j++) + for (k = 0; k < 3; k++) + { + p_out = (unsigned short *) (s->cal_data.raw_data + k * s->cal_data.plane_stride + j * 6 + i * 2); + *p_out = *p_in++; /* dark offset, gain */ + } + + ret = set_window(s, WINDOW_SENDCAL); + if(ret){ + DBG (5, "finecal_send_cal: error sending setwindow\n"); + return ret; + } + + /*first unknown cal block*/ + cmd[0] = 0x1b; + cmd[1] = 0xc3; + stat[0] = 0; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "finecal_send_cal: error sending c3 cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "finecal_send_cal: cmd bad c3 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + /*send header*/ + /*send payload*/ + statLen = 1; + + ret = do_cmd( + s, 0, + s->sendCal1Header, s->sendCal1HeaderLen, + s->cal_data.raw_data, s->cal_data.line_stride, + stat, &statLen + ); + + if(ret){ + DBG (5, "finecal_send_cal: error sending c3 payload\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "finecal_send_cal: payload bad c3 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + /*second unknown cal block*/ + cmd[1] = 0xc4; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + + if(ret){ + DBG (5, "finecal_send_cal: error sending c4 cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "finecal_send_cal: cmd bad c4 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + /*send header*/ + /*send payload*/ + statLen = 1; + + ret = do_cmd( + s, 0, + s->sendCal2Header, s->sendCal2HeaderLen, + s->cal_data.raw_data, s->cal_data.line_stride, + stat, &statLen + ); + + if(ret){ + DBG (5, "finecal_send_cal: error sending c4 payload\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "finecal_send_cal: payload bad c4 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + return ret; +} + +static SANE_Status +finecal_get_line(struct scanner *s, struct image *img) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + size_t cmdLen = 2; + unsigned char cmd[2]; + + size_t statLen = 1; + unsigned char stat[2]; + + int round_offset = img->height / 2; + int i, j, k; + + /* ask for 16 lines */ + ret = set_window(s, WINDOW_FINECAL); + if(ret){ + DBG (5, "finecal_get_line: error sending setwindowcal\n"); + return ret; + } + + /* send scan d2 command */ + cmd[0] = 0x1b; + cmd[1] = 0xd2; + stat[0] = 0; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "finecal_get_line: error sending d2 cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "finecal_get_line: cmd bad d2 status?\n"); + return SANE_STATUS_IO_ERROR; + } + + s->cal_image.image = img; + update_transfer_totals(&s->cal_image); + + while(!s->cal_image.done){ + ret = read_from_scanner(s,&s->cal_image); + if(ret){ + DBG (5, "finecal_get_line: cant read from scanner\n"); + return ret; + } + } + /* convert the raw data into normal packed pixel data */ + descramble_raw(s, &s->cal_image); + + /* average the columns of pixels together and put the results in the top line(s) */ + for (i = 0; i < img->pages; i++) + { + unsigned char *linepix = img->buffer + i * img->width_bytes * img->height; + unsigned char *avgpix = img->buffer + i * img->width_bytes; + for (j = 0; j < img->width_bytes; j++) + { + int total = 0; + + for (k = 0; k < img->height; k++) + total += linepix[j + k * img->width_bytes]; + + avgpix[j] = (total + round_offset) / img->height; + } + } + return ret; +} + +/* roundf() is c99, so we provide our own, though this version wont return -0 */ +static float +round2(float x) +{ + return (float)(x >= 0.0) ? (int)(x+0.5) : (int)(x-0.5); +} + +static SANE_Status +finecal(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + const int max_pages = (s->model == MODEL_S300 ? 2 : 1); + int gain_delta = 0xff - 0xbf; + float *gain_slope, *last_error; + int i, j, k, idx, try_count, cal_good; + + DBG (10, "finecal: start\n"); + + /* set fine dark offset to 0 and fix all fine gains to lowest parameter (0xFF) */ + for (i = 0; i < s->sendcal.width_bytes * s->sendcal.pages / 2; i++) + { + s->sendcal.buffer[i*2] = 0; + s->sendcal.buffer[i*2+1] = 0xff; + } + ret = finecal_send_cal(s); + if(ret) return ret; + + /* grab rows with lamp on */ + ret = lamp(s,1); + if(ret){ + DBG (5, "finecal: error lamp on\n"); + return ret; + } + + /* read the low-gain average of 16 lines */ + ret = finecal_get_line(s, &s->darkcal); + if(ret) return ret; + + /* set fine dark offset to 0 and fine gain to a fixed higher-gain parameter (0xBF) */ + for (i = 0; i < s->sendcal.width_bytes * s->sendcal.pages / 2; i++) + { + s->sendcal.buffer[i*2] = 0; + s->sendcal.buffer[i*2+1] = 0xbf; + } + ret = finecal_send_cal(s); + if(ret) return ret; + + /* read the high-gain average of 16 lines */ + ret = finecal_get_line(s, &s->lightcal); + if(ret) return ret; + + /* calculate the per pixel slope of pixel value delta over gain delta */ + gain_slope = malloc(s->lightcal.width_bytes * s->lightcal.pages * sizeof(float)); + if (!gain_slope) + return SANE_STATUS_NO_MEM; + idx = 0; + for (i = 0; i < s->lightcal.pages; i++) + { + for (j = 0; j < s->lightcal.width_pix; j++) + { + for (k = 0; k < 3; k++) + { + int value_delta = s->lightcal.buffer[idx] - s->darkcal.buffer[idx]; + /* limit this slope to 1 or less, to avoid overshoot if the lightcal ref input is clipped at 255 */ + if (value_delta < gain_delta) + gain_slope[idx] = -1.0; + else + gain_slope[idx] = (float) -gain_delta / value_delta; + idx++; + } + } + } + + /* keep track of the last iteration's pixel error. If we overshoot, we can reduce the value of the gain slope */ + last_error = malloc(s->lightcal.width_bytes * s->lightcal.pages * sizeof(float)); + if (!last_error) + { + free(gain_slope); + return SANE_STATUS_NO_MEM; + } + for (i = 0; i < s->lightcal.width_bytes * s->lightcal.pages; i++) + last_error[i] = 0.0; + + /* fine calibration feedback loop */ + try_count = 8; + while (try_count > 0) + { + int min_value[2][3], max_value[2][3]; + float avg_value[2][3], variance[2][3]; + int high_pegs = 0, low_pegs = 0; + try_count--; + + /* clear statistics arrays */ + for (i = 0; i < max_pages; i++) + { + for (k = 0; k < 3; k++) + { + min_value[i][k] = 0xff; + max_value[i][k] = 0; + avg_value[i][k] = 0; + variance[i][k] = 0; + } + } + + /* gather statistics and calculate new fine gain parameters based on observed error and the value/gain slope */ + idx = 0; + for (i = 0; i < max_pages; i++) + { + for (j = 0; j < s->lightcal.width_pix; j++) + { + for (k = 0; k < 3; k++) + { + int pixvalue = s->lightcal.buffer[idx]; + float pixerror = (fine_gain_target[i] * white_factor[k] - pixvalue); + int oldgain = s->sendcal.buffer[idx * 2 + 1]; + int newgain; + /* if we overshot the last correction, reduce the gain_slope */ + if (pixerror * last_error[idx] < 0.0) + gain_slope[idx] *= 0.75; + last_error[idx] = pixerror; + /* set the new gain */ + newgain = oldgain + (int) round2(pixerror * gain_slope[idx]); + if (newgain < 0) + { + low_pegs++; + s->sendcal.buffer[idx * 2 + 1] = 0; + } + else if (newgain > 0xff) + { + high_pegs++; + s->sendcal.buffer[idx * 2 + 1] = 0xff; + } + else + s->sendcal.buffer[idx * 2 + 1] = newgain; + /* update statistics */ + if (pixvalue < min_value[i][k]) min_value[i][k] = pixvalue; + if (pixvalue > max_value[i][k]) max_value[i][k] = pixvalue; + avg_value[i][k] += pixerror; + variance[i][k] += (pixerror * pixerror); + idx++; + } + } + } + /* finish the statistics calculations */ + cal_good = 1; + for (i = 0; i < max_pages; i++) + { + for (k = 0; k < 3; k++) + { + float sum = avg_value[i][k]; + float sum2 = variance[i][k]; + avg_value[i][k] = sum / s->lightcal.width_pix; + variance[i][k] = ((sum2 - (sum * sum / s->lightcal.width_pix)) / s->lightcal.width_pix); + /* if any color channel is too far out of whack, set cal_good to 0 so we'll iterate again */ + if (fabs(avg_value[i][k]) > 1.0 || variance[i][k] > 3.0) + cal_good = 0; + } + } + + /* print debug info */ + DBG (15, "finecal: -------------------- Gain\n"); + DBG (15, "finecal: RGB Average Error - Front: (%.1f,%.1f,%.1f) - Back: (%.1f,%.1f,%.1f)\n", + avg_value[0][0], avg_value[0][1], avg_value[0][2], avg_value[1][0], avg_value[1][1], avg_value[1][2]); + DBG (15, "finecal: RGB Maximum - Front: (%i,%i,%i) - Back: (%i,%i,%i)\n", + max_value[0][0], max_value[0][1], max_value[0][2], max_value[1][0], max_value[1][1], max_value[1][2]); + DBG (15, "finecal: RGB Minimum - Front: (%i,%i,%i) - Back: (%i,%i,%i)\n", + min_value[0][0], min_value[0][1], min_value[0][2], min_value[1][0], min_value[1][1], min_value[1][2]); + DBG (15, "finecal: Variance - Front: (%.1f,%.1f,%.1f) - Back: (%.1f,%.1f,%.1f)\n", + variance[0][0], variance[0][1], variance[0][2], variance[1][0], variance[1][1], variance[1][2]); + DBG (15, "finecal: Pegged gain parameters - High (0xff): %i - Low (0): %i\n", high_pegs, low_pegs); + + /* break out of the loop if our calibration is done */ + if (cal_good) break; + + /* send the new calibration and read a new line */ + ret = finecal_send_cal(s); + if(ret) { free(gain_slope); free(last_error); return ret; } + ret = finecal_get_line(s, &s->lightcal); + if(ret) { free(gain_slope); free(last_error); return ret; } + } + + /* release the memory for the reference slope data */ + free(gain_slope); + free(last_error); + + DBG (10, "finecal: finish\n"); + return ret; +} + +static SANE_Status +lamp(struct scanner *s, unsigned char set) +{ + SANE_Status ret = SANE_STATUS_GOOD; + unsigned char cmd[2]; + size_t cmdLen = 2; + unsigned char stat[1]; + size_t statLen = 1; + + DBG (10, "lamp: start (%d)\n", set); + + /*send cmd*/ + cmd[0] = 0x1b; + cmd[1] = 0xd0; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "lamp: error sending cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "lamp: cmd bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + /*send payload*/ + cmd[0] = set; + cmdLen = 1; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "lamp: error sending payload\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "lamp: payload bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + DBG (10, "lamp: finish\n"); + return ret; +} + +static SANE_Status +set_window(struct scanner *s, int window) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + unsigned char cmd[] = {0x1b, 0xd1}; + size_t cmdLen = sizeof(cmd); + unsigned char stat[] = {0}; + size_t statLen = sizeof(stat); + unsigned char * payload; + size_t paylen = SET_WINDOW_LEN; + + DBG (10, "set_window: start, window %d\n",window); + + switch (window) { + case WINDOW_COARSECAL: + payload = s->setWindowCoarseCal; + paylen = s->setWindowCoarseCalLen; + break; + case WINDOW_FINECAL: + payload = s->setWindowFineCal; + paylen = s->setWindowFineCalLen; + break; + case WINDOW_SENDCAL: + payload = s->setWindowSendCal; + paylen = s->setWindowSendCalLen; + break; + case WINDOW_SCAN: + payload = s->setWindowScan; + paylen = s->setWindowScanLen; + set_SW_ypix(payload,s->fullscan.height); + break; + default: + DBG (5, "set_window: unknown window\n"); + return SANE_STATUS_INVAL; + } + + /*send cmd*/ + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "set_window: error sending cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "set_window: cmd bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + /*send payload*/ + statLen = 1; + + ret = do_cmd( + s, 0, + payload, paylen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "set_window: error sending payload\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "set_window: payload bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + DBG (10, "set_window: finish\n"); + return ret; +} + +/* instead of internal brightness/contrast/gamma + scanners uses 12bit x 12bit LUT + default is linear table of slope 1 + brightness and contrast inputs are -127 to +127 + + contrast rotates slope of line around central input val + + high low + . x . + . x . xx + out . x . xxxxxxxx + . x xx + ....x....... ............ + in in + + then brightness moves line vertically, and clamps to 8bit + + bright dark + . xxxxxxxx . + . x . + out x . x + . . x + ............ xxxxxxxx.... + in in + */ +static SANE_Status +send_lut (struct scanner *s) +{ + SANE_Status ret=SANE_STATUS_GOOD; + + unsigned char cmd[] = {0x1b, 0xc5}; + size_t cmdLen = 2; + unsigned char stat[1]; + size_t statLen = 1; + unsigned char out[0x6000]; + size_t outLen = 0x6000; + + int i, j; + double b, slope, offset; + int width = outLen / 6; /* 3 colors, 2 bytes */ + int height = width; /* square table */ + + DBG (10, "send_lut: start\n"); + + /* contrast is converted to a slope [0,90] degrees: + * first [-127,127] to [0,254] then to [0,1] + * then multiply by PI/2 to convert to radians + * then take the tangent to get slope (T.O.A) + * then multiply by the normal linear slope + * because the table may not be square, i.e. 1024x256*/ + slope = tan(((double)s->contrast+127)/254 * M_PI/2); + + /* contrast slope must stay centered, so figure + * out vertical offset at central input value */ + offset = height/2 - slope*width/2; + + /* convert the user brightness setting (-127 to +127) + * into a scale that covers the range required + * to slide the contrast curve entirely off the table */ + b = ((double)s->brightness/127) * (slope*(width-1) + offset); + + DBG (15, "send_lut: %d %f %d %f %f\n", s->brightness, b, + s->contrast, slope, offset); + + for(i=0;i<width;i++){ + j=slope*i + offset + b; + + if(j<0){ + j=0; + } + + if(j>(height-1)){ + j=height-1; + } + + /*first table, le order*/ + out[i*2] = j & 0xff; + out[i*2+1] = (j >> 8) & 0x0f; + + /*second table, le order*/ + out[width*2 + i*2] = j & 0xff; + out[width*2 + i*2+1] = (j >> 8) & 0x0f; + + /*third table, le order*/ + out[width*4 + i*2] = j & 0xff; + out[width*4 + i*2+1] = (j >> 8) & 0x0f; + } + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "send_lut: error sending cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "send_lut: cmd bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + statLen = 1; + ret = do_cmd( + s, 0, + out, outLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "send_lut: error sending out\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "send_lut: out bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + DBG (10, "send_lut: finish\n"); + + return ret; +} + +static SANE_Status +get_hardware_status (struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + DBG (10, "get_hardware_status: start\n"); + + /* only run this once every second */ + if (s->last_ghs < time(NULL)) { + + unsigned char cmd[2]; + size_t cmdLen = sizeof(cmd); + unsigned char pay[4]; + size_t payLen = sizeof(pay); + + DBG (15, "get_hardware_status: running\n"); + + cmd[0] = 0x1b; + cmd[1] = 0x33; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + pay, &payLen + ); + if(ret){ + DBG (5, "get_hardware_status: error sending cmd\n"); + return ret; + } + + hexdump(5,"ghspayload: ", pay, payLen); + + s->last_ghs = time(NULL); + + s->hw_top = ((pay[0] >> 7) & 0x01); + s->hw_hopper = !((pay[0] >> 6) & 0x01); + s->hw_adf_open = ((pay[0] >> 5) & 0x01); + + s->hw_sleep = ((pay[1] >> 7) & 0x01); + s->hw_scan_sw = ((pay[1] >> 0) & 0x01); + } + + DBG (10, "get_hardware_status: finish\n"); + + return ret; +} + +static SANE_Status +ingest(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + int i; + + unsigned char cmd[2]; + size_t cmdLen = sizeof(cmd); + unsigned char stat[1]; + size_t statLen = sizeof(stat); + unsigned char pay[2]; + size_t payLen = sizeof(pay); + + DBG (10, "ingest: start\n"); + + for(i=0;i<5;i++){ + + /*send paper load cmd*/ + cmd[0] = 0x1b; + cmd[1] = 0xd4; + statLen = 1; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "ingest: error sending cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "ingest: cmd bad status? %d\n",stat[0]); + continue; + } + + /*send payload*/ + statLen = 1; + payLen = 1; + pay[0] = 1; + + ret = do_cmd( + s, 0, + pay, payLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "ingest: error sending payload\n"); + return ret; + } + if(stat[0] == 6){ + DBG (5, "ingest: found paper?\n"); + break; + } + else if(stat[0] == 0x15 || stat[0] == 0){ + DBG (5, "ingest: no paper?\n"); + ret=SANE_STATUS_NO_DOCS; + continue; + } + else{ + DBG (5, "ingest: payload bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + } + + DBG (10, "ingest: finish\n"); + return ret; +} + +static SANE_Status +scan(struct scanner *s) +{ + SANE_Status ret=SANE_STATUS_GOOD; + unsigned char cmd[] = {0x1b, 0xd2}; + size_t cmdLen = 2; + unsigned char stat[1]; + size_t statLen = 1; + + DBG (10, "scan: start\n"); + + if(s->model == MODEL_S300){ + cmd[1] = 0xd6; + } + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "scan: error sending cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "scan: cmd bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + + DBG (10, "scan: finish\n"); + + return ret; +} + +/* + * Called by SANE to read data. + * + * From the SANE spec: + * This function is used to read image data from the device + * represented by handle h. Argument buf is a pointer to a memory + * area that is at least maxlen bytes long. The number of bytes + * returned is stored in *len. A backend must set this to zero when + * the call fails (i.e., when a status other than SANE_STATUS_GOOD is + * returned). + * + * When the call succeeds, the number of bytes returned can be + * anywhere in the range from 0 to maxlen bytes. + */ +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len) +{ + struct scanner *s = (struct scanner *) handle; + SANE_Status ret=SANE_STATUS_GOOD; + struct page * page; + + DBG (10, "sane_read: start si:%d len:%d max:%d\n",s->side,*len,max_len); + + *len = 0; + + /* cancelled? */ + if(!s->started){ + DBG (5, "sane_read: call sane_start first\n"); + return SANE_STATUS_CANCELLED; + } + + page = &s->pages[s->side]; + + /* have sent all of current buffer */ + if(page->done){ + DBG (10, "sane_read: returning eof\n"); + return SANE_STATUS_EOF; + } + + /* scan not finished, get more into block buffer */ + if(!s->fullscan.done) + { + /* block buffer currently empty, clean up */ + if(!s->block_xfr.rx_bytes) + { + /* block buffer bigger than remainder of scan, shrink block */ + int remainTotal = s->fullscan.total_bytes - s->fullscan.rx_bytes; + if(remainTotal < s->block_xfr.total_bytes) + { + DBG (15, "sane_read: shrinking block to %lu\n", (unsigned long)remainTotal); + s->block_xfr.total_bytes = remainTotal; + } + /* send d3 cmd for S300 */ + if(s->model == MODEL_S300) + { + unsigned char cmd[] = {0x1b, 0xd3}; + size_t cmdLen = 2; + unsigned char stat[1]; + size_t statLen = 1; + + DBG (15, "sane_read: d3\n"); + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + stat, &statLen + ); + if(ret){ + DBG (5, "sane_read: error sending d3 cmd\n"); + return ret; + } + if(stat[0] != 6){ + DBG (5, "sane_read: cmd bad status?\n"); + return SANE_STATUS_IO_ERROR; + } + } + } + + ret = read_from_scanner(s, &s->block_xfr); + if(ret){ + DBG (5, "sane_read: cant read from scanner\n"); + return ret; + } + + /* block filled, copy to front/back */ + if(s->block_xfr.done) + { + DBG (15, "sane_read: block buffer full\n"); + + /* convert the raw data into normal packed pixel data */ + descramble_raw(s, &s->block_xfr); + + s->block_xfr.done = 0; + + /* get the 0x43 cmd for the S300 */ + if(s->model == MODEL_S300){ + + unsigned char cmd[] = {0x1b, 0x43}; + size_t cmdLen = 2; + unsigned char in[10]; + size_t inLen = 10; + + ret = do_cmd( + s, 0, + cmd, cmdLen, + NULL, 0, + in, &inLen + ); + hexdump(15, "cmd 43: ", in, inLen); + + if(ret){ + DBG (5, "sane_read: error sending 43 cmd\n"); + return ret; + } + + /*copy backside data into buffer*/ + if( s->source == SOURCE_ADF_DUPLEX || s->source == SOURCE_ADF_BACK ) + ret = copy_block_to_page(s, SIDE_BACK); + + /*copy frontside data into buffer*/ + if( s->source != SOURCE_ADF_BACK ) + ret = copy_block_to_page(s, SIDE_FRONT); + + if(ret){ + DBG (5, "sane_read: cant copy to front/back\n"); + return ret; + } + + s->fullscan.rx_bytes += s->block_xfr.rx_bytes; + + /* autodetect mode, check for change length */ + if( s->source != SOURCE_FLATBED && !s->page_height ){ + int get = (in[6] << 8) | in[7]; + + /*always have to get full blocks*/ + if(get % s->block_img.height){ + get += s->block_img.height - (get % s->block_img.height); + } + + if(get < s->fullscan.height){ + DBG (15, "sane_read: paper out? %d\n",get); + s->fullscan.total_bytes = s->fullscan.width_bytes * get; + } + } + } + + else { /*fi-60f*/ + ret = copy_block_to_page(s, SIDE_FRONT); + if(ret){ + DBG (5, "sane_read: cant copy to front/back\n"); + return ret; + } + + s->fullscan.rx_bytes += s->block_xfr.rx_bytes; + } + + /* reset for next pass */ + update_transfer_totals(&s->block_xfr); + + /* scan now finished */ + if(s->fullscan.rx_bytes == s->fullscan.total_bytes){ + DBG (15, "sane_read: last block\n"); + s->fullscan.done = 1; + } + } + } + + *len = page->bytes_scanned - page->bytes_read; + if(*len > max_len){ + *len = max_len; + } + + if(*len){ + DBG (10, "sane_read: copy rx:%d tx:%d tot:%d len:%d\n", + page->bytes_scanned, page->bytes_read, page->bytes_total,*len); + + memcpy(buf, page->image->buffer + page->bytes_read, *len); + page->bytes_read += *len; + + /* sent it all, return eof on next read */ + if(s->fullscan.done && page->bytes_read == page->bytes_scanned){ + DBG (10, "sane_read: side done\n"); + page->done = 1; + } + } + + DBG (10, "sane_read: finish si:%d len:%d max:%d\n",s->side,*len,max_len); + + return ret; +} + +/* de-scrambles the raw data from the scanner into the image buffer */ +static SANE_Status +descramble_raw(struct scanner *s, struct transfer * tp) +{ + SANE_Status ret = SANE_STATUS_GOOD; + unsigned char *p_in, *p_out = tp->image->buffer; + int height = tp->total_bytes / tp->line_stride; + int i, j, k, l; + + if (s->model == MODEL_S300) + { + for (i = 0; i < 2; i++) /* page, front/back */ + for (j = 0; j < height; j++) /* row (y)*/ + for (k = 0; k < tp->plane_width; k++) /* column (x) */ + for (l = 0; l < 3; l++) /* color component */ + { + p_in = (unsigned char *) tp->raw_data + (j * tp->line_stride) + (l * tp->plane_stride) + k * 3 + i; + *p_out++ = *p_in; + } + } + else /* MODEL_FI60F */ + { + for (i = 0; i < height; i++) /* row (y)*/ + for (j = 0; j < 3; j++) /* read head */ + for (k = 0; k < tp->plane_width; k++) /* column within the read head */ + for (l = 0; l < 3; l++) /* color component */ + { + p_in = (unsigned char *) tp->raw_data + (i * tp->line_stride) + (l * tp->plane_stride) + k * 3 + j; + *p_out++ = *p_in; + } + } + + return ret; +} + +/* fills block buffer a little per pass */ +static SANE_Status +read_from_scanner(struct scanner *s, struct transfer * tp) +{ + SANE_Status ret=SANE_STATUS_GOOD; + size_t bytes = MAX_IMG_PASS; + size_t remainBlock = tp->total_bytes - tp->rx_bytes + 8; + + /* determine amount to ask for */ + if(bytes > remainBlock){ + bytes = remainBlock; + } + + if (tp->image == NULL) + { + DBG(5, "internal error: read_from_scanner called with no destination image.\n"); + return SANE_STATUS_INVAL; + } + + DBG (10, "read_from_scanner: start rB:%lu len:%lu\n", + (unsigned long)remainBlock, (unsigned long)bytes); + + if(!bytes){ + DBG(10, "read_from_scanner: no bytes!\n"); + return SANE_STATUS_INVAL; + } + + ret = do_cmd( + s, 0, + NULL, 0, + NULL, 0, + tp->raw_data + tp->rx_bytes, &bytes + ); + + /* full read or short read */ + if (ret == SANE_STATUS_GOOD || (ret == SANE_STATUS_EOF && bytes) ) { + + DBG(15,"read_from_scanner: got GOOD/EOF (%lu)\n",(unsigned long)bytes); + + if(bytes == remainBlock){ + DBG(15,"read_from_scanner: block done, ignoring trailer\n"); + bytes -= 8; + tp->done = 1; + } + + ret = SANE_STATUS_GOOD; + tp->rx_bytes += bytes; + } + else { + DBG(5, "read_from_scanner: error reading status = %d\n", ret); + } + + DBG (10, "read_from_scanner: finish rB:%lu len:%lu\n", + (unsigned long)(tp->total_bytes - tp->rx_bytes), (unsigned long)bytes); + + return ret; +} + +/* copies block buffer into front or back image buffer */ +/* converts pixel data from RGB Color to the output format */ +static SANE_Status +copy_block_to_page(struct scanner *s,int side) +{ + SANE_Status ret = SANE_STATUS_GOOD; + struct transfer * block = &s->block_xfr; + struct page * page = &s->pages[side]; + int height = block->total_bytes / block->line_stride; + int width = block->image->width_pix; + int block_page_stride = block->image->width_bytes * block->image->height; + int page_y_offset = page->bytes_scanned / page->image->width_bytes; + int line_reverse = (side == SIDE_BACK) || (s->model == MODEL_FI60F); + int i,j; + + DBG (10, "copy_block_to_page: start\n"); + + /* loop over all the lines in the block */ + for (i = 0; i < height; i++) + { + unsigned char * p_in = block->image->buffer + (side * block_page_stride) + (i * block->image->width_bytes); + unsigned char * p_out = page->image->buffer + ((i + page_y_offset) * page->image->width_bytes); + unsigned char * lineStart = p_out; + /* reverse order for back side or FI-60F scanner */ + if (line_reverse) + p_in += (width - 1) * 3; + /* convert all of the pixels in this row */ + for (j = 0; j < width; j++) + { + unsigned char r, g, b; + if (s->model == MODEL_S300) + { r = p_in[1]; g = p_in[2]; b = p_in[0]; } + else /* (s->model == MODEL_FI60F) */ + { r = p_in[0]; g = p_in[1]; b = p_in[2]; } + if (s->mode == MODE_COLOR) + { + *p_out++ = r; + *p_out++ = g; + *p_out++ = b; + } + else if (s->mode == MODE_GRAYSCALE) + { + *p_out++ = (r + g + b) / 3; + } + else if (s->mode == MODE_LINEART) + { + s->dt.buffer[j] = (r + g + b) / 3; + } + if (line_reverse) + p_in -= 3; + else + p_in += 3; + } + /* for MODE_LINEART, binarize the gray line stored in the temp image buffer */ + if (s->mode == MODE_LINEART) + binarize_line(s, lineStart, width); + /*add a periodic row because of non-square pixels*/ + /*FIXME: only works with 225x200*/ + if (s->resolution_x > s->resolution_y && (i + page_y_offset) % 9 == 8) + { + memcpy(lineStart + page->image->width_bytes, lineStart, page->image->width_bytes); + page_y_offset += 1; + page->bytes_scanned += page->image->width_bytes; + } + } + + /* update the page counter of bytes scanned */ + page->bytes_scanned += page->image->width_bytes * height; + + DBG (10, "copy_block_to_page: finish\n"); + + return ret; +} + +/*uses the threshold/threshold_curve to control binarization*/ +static SANE_Status +binarize_line(struct scanner *s, unsigned char *lineOut, int width) +{ + SANE_Status ret = SANE_STATUS_GOOD; + int j, windowX, sum = 0; + + /* ~1mm works best, but the window needs to have odd # of pixels */ + windowX = 6 * s->resolution_x / 150; + if (!(windowX % 2)) windowX++; + + /*second, prefill the sliding sum*/ + for (j = 0; j < windowX; j++) + sum += s->dt.buffer[j]; + + /* third, walk the dt buffer, update the sliding sum, */ + /* determine threshold, output bits */ + for (j = 0; j < width; j++) + { + /*output image location*/ + int offset = j % 8; + unsigned char mask = 0x80 >> offset; + int thresh = s->threshold; + + /* move sum/update threshold only if there is a curve*/ + if (s->threshold_curve) + { + int addCol = j + windowX/2; + int dropCol = addCol - windowX; + + if (dropCol >= 0 && addCol < width) + { + sum -= s->dt.buffer[dropCol]; + sum += s->dt.buffer[addCol]; + } + thresh = s->dt_lut[sum/windowX]; + } + + /*use average to lookup threshold*/ + if (s->dt.buffer[j] > thresh) + *lineOut &= ~mask; /* white */ + else + *lineOut |= mask; /* black */ + + if (offset == 7) + lineOut++; + } + + return ret; +} + +/* + * @@ Section 4 - SANE cleanup functions + */ +/* + * Cancels a scan. + * + * From the SANE spec: + * This function is used to immediately or as quickly as possible + * cancel the currently pending operation of the device represented by + * handle h. This function can be called at any time (as long as + * handle h is a valid handle) but usually affects long-running + * operations only (such as image is acquisition). It is safe to call + * this function asynchronously (e.g., from within a signal handler). + * It is important to note that completion of this operaton does not + * imply that the currently pending operation has been cancelled. It + * only guarantees that cancellation has been initiated. Cancellation + * completes only when the cancelled call returns (typically with a + * status value of SANE_STATUS_CANCELLED). Since the SANE API does + * not require any other operations to be re-entrant, this implies + * that a frontend must not call any other operation until the + * cancelled operation has returned. + */ +void +sane_cancel (SANE_Handle handle) +{ + /*FIXME: actually ask the scanner to stop?*/ + struct scanner * s = (struct scanner *) handle; + DBG (10, "sane_cancel: start\n"); + s->started = 0; + DBG (10, "sane_cancel: finish\n"); +} + +/* + * Ends use of the scanner. + * + * From the SANE spec: + * This function terminates the association between the device handle + * passed in argument h and the device it represents. If the device is + * presently active, a call to sane_cancel() is performed first. After + * this function returns, handle h must not be used anymore. + */ +void +sane_close (SANE_Handle handle) +{ + struct scanner * s = (struct scanner *) handle; + + DBG (10, "sane_close: start\n"); + + /* still connected- drop it */ + if(s->fd >= 0){ + sane_cancel(handle); + lamp(s, 0); + disconnect_fd(s); + } + + DBG (10, "sane_close: finish\n"); +} + +static SANE_Status +disconnect_fd (struct scanner *s) +{ + DBG (10, "disconnect_fd: start\n"); + + if(s->fd > -1){ + DBG (15, "disconnecting usb device\n"); + sanei_usb_close (s->fd); + s->fd = -1; + } + + DBG (10, "disconnect_fd: finish\n"); + + return SANE_STATUS_GOOD; +} + +static SANE_Status +destroy(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + DBG (10, "destroy: start\n"); + + teardown_buffers(s); + + if(s->sane.name){ + free(s->sane.name); + } + if(s->sane.vendor){ + free(s->sane.vendor); + } + if(s->sane.model){ + free(s->sane.model); + } + + free(s); + + DBG (10, "destroy: finish\n"); + return ret; +} + +static SANE_Status +teardown_buffers(struct scanner *s) +{ + SANE_Status ret = SANE_STATUS_GOOD; + + DBG (10, "teardown_buffers: start\n"); + + /* temporary cal data */ + if(s->coarsecal.buffer){ + free(s->coarsecal.buffer); + s->coarsecal.buffer = NULL; + } + + if(s->darkcal.buffer){ + free(s->darkcal.buffer); + s->darkcal.buffer = NULL; + } + + if(s->sendcal.buffer){ + free(s->sendcal.buffer); + s->sendcal.buffer = NULL; + } + + if(s->cal_image.raw_data){ + free(s->cal_image.raw_data); + s->cal_image.raw_data = NULL; + } + + if(s->cal_data.raw_data){ + free(s->cal_data.raw_data); + s->cal_data.raw_data = NULL; + } + + /* image slice */ + if(s->block_img.buffer){ + free(s->block_img.buffer); + s->block_img.buffer = NULL; + } + if(s->block_xfr.raw_data){ + free(s->block_xfr.raw_data); + s->block_xfr.raw_data = NULL; + } + + /* dynamic thresh slice */ + if(s->dt.buffer){ + free(s->dt.buffer); + s->dt.buffer = NULL; + } + + /* image buffer to hold frontside data */ + if(s->front.buffer){ + free(s->front.buffer); + s->front.buffer = NULL; + } + + /* image buffer to hold backside data */ + if(s->back.buffer){ + free(s->back.buffer); + s->back.buffer = NULL; + } + + DBG (10, "teardown_buffers: finish\n"); + return ret; +} + +/* + * Terminates the backend. + * + * From the SANE spec: + * This function must be called to terminate use of a backend. The + * function will first close all device handles that still might be + * open (it is recommended to close device handles explicitly through + * a call to sane_close(), but backends are required to release all + * resources upon a call to this function). After this function + * returns, no function other than sane_init() may be called + * (regardless of the status value returned by sane_exit(). Neglecting + * to call this function may result in some resources not being + * released properly. + */ +void +sane_exit (void) +{ + struct scanner *dev, *next; + + DBG (10, "sane_exit: start\n"); + + for (dev = scanner_devList; dev; dev = next) { + next = dev->next; + destroy(dev); + } + + if (sane_devArray) + free (sane_devArray); + + scanner_devList = NULL; + sane_devArray = NULL; + + DBG (10, "sane_exit: finish\n"); +} + +/* + * @@ Section 5 - misc helper functions + */ +/* + * take a bunch of pointers, send commands to scanner + */ +static SANE_Status +do_cmd(struct scanner *s, int shortTime, + unsigned char * cmdBuff, size_t cmdLen, + unsigned char * outBuff, size_t outLen, + unsigned char * inBuff, size_t * inLen +) +{ + /* sanei_usb overwrites the transfer size, so make some local copies */ + size_t loc_cmdLen = cmdLen; + size_t loc_outLen = outLen; + size_t loc_inLen = 0; + + int cmdTime = USB_COMMAND_TIME; + int outTime = USB_DATA_TIME; + int inTime = USB_DATA_TIME; + + int ret = 0; + + DBG (10, "do_cmd: start\n"); + + if(shortTime){ + cmdTime /= 20; + outTime /= 20; + inTime /= 20; + } + + /* this command has a cmd component, and a place to get it */ + if(cmdBuff && cmdLen && cmdTime){ + + /* change timeout */ + sanei_usb_set_timeout(cmdTime); + + /* write the command out */ + DBG(25, "cmd: writing %ld bytes, timeout %d\n", (long)cmdLen, cmdTime); + hexdump(30, "cmd: >>", cmdBuff, cmdLen); + ret = sanei_usb_write_bulk(s->fd, cmdBuff, &cmdLen); + DBG(25, "cmd: wrote %ld bytes, retVal %d\n", (long)cmdLen, ret); + + if(ret == SANE_STATUS_EOF){ + DBG(5,"cmd: got EOF, returning IO_ERROR\n"); + return SANE_STATUS_IO_ERROR; + } + if(ret != SANE_STATUS_GOOD){ + DBG(5,"cmd: return error '%s'\n",sane_strstatus(ret)); + return ret; + } + if(loc_cmdLen != cmdLen){ + DBG(5,"cmd: wrong size %ld/%ld\n", (long)loc_cmdLen, (long)cmdLen); + return SANE_STATUS_IO_ERROR; + } + } + + /* this command has a write component, and a place to get it */ + if(outBuff && outLen && outTime){ + + /* change timeout */ + sanei_usb_set_timeout(outTime); + + DBG(25, "out: writing %ld bytes, timeout %d\n", (long)outLen, outTime); + hexdump(30, "out: >>", outBuff, outLen); + ret = sanei_usb_write_bulk(s->fd, outBuff, &outLen); + DBG(25, "out: wrote %ld bytes, retVal %d\n", (long)outLen, ret); + + if(ret == SANE_STATUS_EOF){ + DBG(5,"out: got EOF, returning IO_ERROR\n"); + return SANE_STATUS_IO_ERROR; + } + if(ret != SANE_STATUS_GOOD){ + DBG(5,"out: return error '%s'\n",sane_strstatus(ret)); + return ret; + } + if(loc_outLen != outLen){ + DBG(5,"out: wrong size %ld/%ld\n", (long)loc_outLen, (long)outLen); + return SANE_STATUS_IO_ERROR; + } + } + + /* this command has a read component, and a place to put it */ + if(inBuff && inLen && inTime){ + + loc_inLen = *inLen; + DBG(25, "in: memset %ld bytes\n", (long)*inLen); + memset(inBuff,0,*inLen); + + /* change timeout */ + sanei_usb_set_timeout(inTime); + + DBG(25, "in: reading %ld bytes, timeout %d\n", (long)*inLen, inTime); + ret = sanei_usb_read_bulk(s->fd, inBuff, inLen); + DBG(25, "in: retVal %d\n", ret); + + if(ret == SANE_STATUS_EOF){ + DBG(5,"in: got EOF, continuing\n"); + } + else if(ret != SANE_STATUS_GOOD){ + DBG(5,"in: return error '%s'\n",sane_strstatus(ret)); + return ret; + } + + DBG(25, "in: read %ld bytes\n", (long)*inLen); + if(*inLen){ + hexdump(30, "in: <<", inBuff, *inLen); + } + + if(loc_inLen != *inLen){ + ret = SANE_STATUS_EOF; + DBG(5,"in: short read %ld/%ld\n", (long)loc_inLen, (long)*inLen); + } + } + + DBG (10, "do_cmd: finish\n"); + + return ret; +} + +/** + * Convenience method to determine longest string size in a list. + */ +static size_t +maxStringSize (const SANE_String_Const strings[]) +{ + size_t size, max_size = 0; + int i; + + for (i = 0; strings[i]; ++i) { + size = strlen (strings[i]) + 1; + if (size > max_size) + max_size = size; + } + + return max_size; +} + +/** + * Prints a hex dump of the given buffer onto the debug output stream. + */ +static void +hexdump (int level, char *comment, unsigned char *p, int l) +{ + int i; + char line[128]; + char *ptr; + + if(DBG_LEVEL < level) + return; + + DBG (level, "%s\n", comment); + ptr = line; + for (i = 0; i < l; i++, p++) + { + if ((i % 16) == 0) + { + if (ptr != line) + { + *ptr = '\0'; + DBG (level, "%s\n", line); + ptr = line; + } + sprintf (ptr, "%3.3x:", i); + ptr += 4; + } + sprintf (ptr, " %2.2x", *p); + ptr += 3; + } + *ptr = '\0'; + DBG (level, "%s\n", line); +} + +/** + * An advanced method we don't support but have to define. + */ +SANE_Status +sane_set_io_mode (SANE_Handle h, SANE_Bool non_blocking) +{ + DBG (10, "sane_set_io_mode\n"); + DBG (15, "%d %p\n", non_blocking, h); + return SANE_STATUS_UNSUPPORTED; +} + +/** + * An advanced method we don't support but have to define. + */ +SANE_Status +sane_get_select_fd (SANE_Handle h, SANE_Int *fdp) +{ + DBG (10, "sane_get_select_fd\n"); + DBG (15, "%p %d\n", h, *fdp); + return SANE_STATUS_UNSUPPORTED; +} + +/* s->page_width stores the user setting + * for the paper width in adf. sometimes, + * we need a value that differs from this + * due to using FB + */ +static int +get_page_width(struct scanner *s) +{ + /* scanner max for fb */ + if(s->source == SOURCE_FLATBED){ + return s->max_x; + } + + return s->page_width; +} + +/* s->page_height stores the user setting + * for the paper height in adf. sometimes, + * we need a value that differs from this + * due to using FB. + */ +static int +get_page_height(struct scanner *s) +{ + /* scanner max for fb */ + if(s->source == SOURCE_FLATBED){ + return s->max_y; + } + + return s->page_height; +} + |