summaryrefslogtreecommitdiff
path: root/backend/sharp.c
diff options
context:
space:
mode:
Diffstat (limited to 'backend/sharp.c')
-rw-r--r--backend/sharp.c4213
1 files changed, 4213 insertions, 0 deletions
diff --git a/backend/sharp.c b/backend/sharp.c
new file mode 100644
index 0000000..1225a57
--- /dev/null
+++ b/backend/sharp.c
@@ -0,0 +1,4213 @@
+/* sane - Scanner Access Now Easy.
+
+ Copyright (C) 1998, 1999
+ Kazuya Fukuda, Abel Deuring based on BYTEC GmbH Germany
+ Written by Helmut Koeberle previous Work on canon.c file from the
+ SANE package.
+
+ 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 Sharp flatbed scanners. */
+
+/*
+ Version 0.32
+ changes to version 0.31:
+ - support for JX320 added (Thanks to Isaac Wilcox for providind the
+ patch)
+
+ Version 0.31
+ changes to version 0.30:
+ - support for JX350 added (Thanks to Shuhei Tomita for providind the
+ patch)
+
+ changes to version 0.20
+ - support for the proposed extended open function in sanei_scsi.c added
+ - support for ADF and FSU (transparency adapter) added
+ - simple sense handler added
+ - preview added
+ - added several missing statements "s->fd = -1;" after
+ "sanei_scsi_close(s->fd)" to error returns in sane_start();
+ - maximum scan sizes are read from the scanner, if a JX330 or JX250
+ is used. (this avoids the guessing of scan sizes for the JX330)
+ - gamma table support added
+ - "Fixed gamma selection (1.0/2.2)", available for JX330 and JX610,
+ is now implemented for the JX250 by downloading a gamma table
+ - changed the calls to free() and strdup() in sane_control_option to
+ strcpy.
+ (I don't like too frequent unchecked malloc()s and strdups :) Abel)
+ - cleaned up some quirks in option handling, eg, that "threshold"
+ was initially enabled, while the initial scan mode is "color"
+ - cleaned up setting SANE_INFO_RELOAD_OPTIONS and SANE_INFO_RELOAD_PARAMS
+ bits in sane_control_option
+ - bi-level color scans now give useful (8 bit) output
+ - separate thresholds for red, green, blue (bi-level color scan) added
+*/
+#include "../include/sane/config.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <math.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_scsi.h"
+
+/* QUEUEDEBUG should be undefined unless you want to play
+ with the sanei_scsi.c under Linux and/or with the Linux's SG driver,
+ or your suspect problems with command queueing
+*/
+#if 0
+#define QUEUEDEBUG
+#define DEBUG
+#ifdef DEBUG
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+#endif
+
+/* USE_FORK: fork a special reader process
+*/
+
+#ifdef HAVE_SYS_SHM_H
+#ifndef HAVE_OS2_H
+#define USE_FORK
+#endif
+#endif
+
+#ifdef USE_FORK
+#include <signal.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#endif /* USE_FORK */
+
+/* xxx I'm not sure, if I understood the JX610 and JX330 manuals right,
+ that the data for the SEND command should be in ASCII format...
+ SEND commands with a data bock are used, if USE_CUSTOM_GAMMA
+ and / or USE_COLOR_THRESHOLD are enabled.
+ Abel
+*/
+#define USE_CUSTOM_GAMMA
+#define USE_COLOR_THRESHOLD
+/* enable a short list of some standard resolutions. XSane provides
+ its own resolution list; therefore its is generally not reasonable
+ to enable this list, if you mainly using XSane. But it might be handy
+ if you are working with xscanimage
+*/
+/* #define USE_RESOLUTION_LIST */
+
+/* enable separate specification of resolution in X and Y direction.
+ XSane will show the Y-resolution at a quite different place than
+ the X-resolution
+*/
+/* #define USE_SEPARATE_Y_RESOLUTION */
+
+
+#define BACKEND_NAME sharp
+#include "../include/sane/sanei_backend.h"
+
+#include <sharp.h>
+
+#ifndef PATH_MAX
+#define PATH_MAX 1024
+#endif
+
+#define DEFAULT_MUD_JX610 25
+#define DEFAULT_MUD_JX320 25
+#define DEFAULT_MUD_JX330 1200
+#define DEFAULT_MUD_JX250 1200
+
+#define PIX_TO_MM(x, mud) ((x) * 25.4 / mud)
+#define MM_TO_PIX(x, mud) ((x) * mud / 25.4)
+
+#include "../include/sane/sanei_config.h"
+#define SHARP_CONFIG_FILE "sharp.conf"
+
+static int num_devices = 0;
+static SHARP_Device *first_dev = NULL;
+static SHARP_Scanner *first_handle = NULL;
+
+typedef enum
+ {
+ MODES_LINEART = 0,
+ MODES_GRAY,
+ MODES_LINEART_COLOR,
+ MODES_COLOR
+ }
+Modes;
+
+#define M_LINEART SANE_VALUE_SCAN_MODE_LINEART
+#define M_GRAY SANE_VALUE_SCAN_MODE_GRAY
+#define M_LINEART_COLOR SANE_VALUE_SCAN_MODE_COLOR_LINEART
+#define M_COLOR SANE_VALUE_SCAN_MODE_COLOR
+static const SANE_String_Const mode_list[] =
+{
+ M_LINEART, M_GRAY, M_LINEART_COLOR, M_COLOR,
+ 0
+};
+
+#define M_BILEVEL "none"
+#define M_BAYER "Dither Bayer"
+#define M_SPIRAL "Dither Spiral"
+#define M_DISPERSED "Dither Dispersed"
+#define M_ERRDIFFUSION "Error Diffusion"
+
+static const SANE_String_Const halftone_list[] =
+{
+ M_BILEVEL, M_BAYER, M_SPIRAL, M_DISPERSED, M_ERRDIFFUSION,
+ 0
+};
+
+#define LIGHT_GREEN "green"
+#define LIGHT_RED "red"
+#define LIGHT_BLUE "blue"
+#define LIGHT_WHITE "white"
+
+#define MAX_RETRIES 50
+
+static const SANE_String_Const light_color_list[] =
+{
+ LIGHT_GREEN, LIGHT_RED, LIGHT_BLUE, LIGHT_WHITE,
+ 0
+};
+
+/* possible values for ADF/FSU selection */
+static SANE_String use_adf = "Automatic Document Feeder";
+static SANE_String use_fsu = "Transparency Adapter";
+static SANE_String use_simple = "Flatbed";
+
+/* auto selection of ADF and FSU, as described in the JX330 manual,
+ is a nice idea -- but I assume that the possible scan window
+ sizes depend not only for the JX250, but also for JX330 on the
+ usage of ADF or FSU. Thus, the user might be able to select scan
+ windows of an "illegal" size, which would have to be automatically
+ corrected, and I don't see, how the user could be informed about
+ this "window clipping". More important, I don't see, how the
+ frontend could be informed that the ADF is automatically enabled.
+
+ Insert a "#define ALLOW_AUTO_SELECT_ADF", if you want to play
+ with this feature.
+*/
+#ifdef ALLOW_AUTO_SELECT_ADF
+static SANE_String_Const use_auto = "AutoSelection";
+#endif
+
+#define HAVE_FSU 1
+#define HAVE_ADF 2
+
+/* The follow #defines are used in SHARP_Scanner.adf_fsu_mode
+ and as indexes for the arrays x_ranges, y_ranges in SHARP_Device
+*/
+#define SCAN_SIMPLE 0
+#define SCAN_WITH_FSU 1
+#define SCAN_WITH_ADF 2
+#ifdef ALLOW_AUTO_SELECT_ADF
+#define SCAN_ADF_FSU_AUTO 3
+#endif
+#define LOAD_PAPER 1
+#define UNLOAD_PAPER 0
+
+#define PAPER_MAX 10
+#define W_LETTER "11\"x17\""
+#define INVOICE "8.5\"x5.5\""
+static const SANE_String_Const paper_list_jx610[] =
+{
+ "A3", "A4", "A5", "A6", "B4", "B5",
+ W_LETTER, "Legal", "Letter", INVOICE,
+ 0
+};
+
+static const SANE_String_Const paper_list_jx330[] =
+{
+ "A4", "A5", "A6", "B5",
+ 0
+};
+
+#define GAMMA10 "1.0"
+#define GAMMA22 "2.2"
+
+static const SANE_String_Const gamma_list[] =
+{
+ GAMMA10, GAMMA22,
+ 0
+};
+
+#if 0
+#define SPEED_NORMAL "Normal"
+#define SPEED_FAST "Fast"
+static const SANE_String_Const speed_list[] =
+{
+ SPEED_NORMAL, SPEED_FAST,
+ 0
+};
+#endif
+
+#ifdef USE_RESOLUTION_LIST
+#define RESOLUTION_MAX_JX610 8
+static const SANE_String_Const resolution_list_jx610[] =
+{
+ "50", "75", "100", "150", "200", "300", "400", "600", "Select",
+ 0
+};
+
+#define RESOLUTION_MAX_JX250 7
+static const SANE_String_Const resolution_list_jx250[] =
+{
+ "50", "75", "100", "150", "200", "300", "400", "Select",
+ 0
+};
+#endif
+
+#define EDGE_NONE "None"
+#define EDGE_MIDDLE "Middle"
+#define EDGE_STRONG "Strong"
+#define EDGE_BLUR "Blur"
+static const SANE_String_Const edge_emphasis_list[] =
+{
+ EDGE_NONE, EDGE_MIDDLE, EDGE_STRONG, EDGE_BLUR,
+ 0
+};
+
+#ifdef USE_CUSTOM_GAMMA
+static const SANE_Range u8_range =
+ {
+ 0, /* minimum */
+ 255, /* maximum */
+ 0 /* quantization */
+ };
+#endif
+
+static SANE_Status
+sense_handler(int __sane_unused__ fd, u_char *sense_buffer, void *s)
+{
+ int sense_key;
+ SHARP_Sense_Data *sdat = (SHARP_Sense_Data *) s;
+
+#define add_sense_code sense_buffer[12]
+#define add_sense_qual sense_buffer[13]
+
+ memcpy(sdat->sb, sense_buffer, 16);
+
+ DBG(10, "sense code: %02x %02x %02x %02x %02x %02x %02x %02x "
+ "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+ sense_buffer[0], sense_buffer[1], sense_buffer[2], sense_buffer[3],
+ sense_buffer[4], sense_buffer[5], sense_buffer[6], sense_buffer[7],
+ sense_buffer[8], sense_buffer[9], sense_buffer[10], sense_buffer[11],
+ sense_buffer[12], sense_buffer[13], sense_buffer[14], sense_buffer[15]);
+
+ sense_key = sense_buffer[2] & 0x0F;
+ /* do we have additional information ? */
+ if (sense_buffer[7] >= 5)
+ {
+ if (sdat->model == JX610)
+ {
+ /* The JX610 uses somewhat different error codes */
+ switch (add_sense_code)
+ {
+ case 0x04:
+ DBG(5, "error: scanner not ready\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x08:
+ DBG(5, "error: scanner communication failure (time out?)\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x1A:
+ DBG(10, "error: parameter list length error\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x20:
+ DBG(10, "error: invalid command code\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x24:
+ DBG(10, "error: invalid field in CDB\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x25:
+ DBG(10, "error: LUN not supported\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x26:
+ DBG(10, "error: invalid field in parameter list\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x29:
+ DBG(10, "note: reset occured\n");
+ return SANE_STATUS_GOOD;
+ case 0x2a:
+ DBG(10, "note: mode parameter change\n");
+ return SANE_STATUS_GOOD;
+ case 0x37:
+ DBG(10, "note: rounded parameter\n");
+ return SANE_STATUS_GOOD;
+ case 0x39:
+ DBG(10, "error: saving parameter not supported\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x47:
+ DBG(10, "SCSI parity error\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x48:
+ DBG(10, "initiator detected error message received\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x60:
+ DBG(1, "error: lamp failure\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x62:
+ DBG(1, "scan head positioning error\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ }
+ else if (sdat->model == JX250 || sdat->model == JX330 ||
+ sdat->model == JX350 || sdat->model == JX320)
+ {
+ switch (sense_key)
+ {
+ case 0x02: /* not ready */
+ switch (add_sense_code)
+ {
+ case 0x80:
+ switch (add_sense_qual)
+ {
+ case 0:
+ DBG(1, "Scanner not ready: ADF cover open\n");
+ if (sdat->complain_on_errors & COMPLAIN_ON_ADF_ERROR)
+ return SANE_STATUS_COVER_OPEN;
+ else
+ return SANE_STATUS_GOOD;
+ case 1:
+ DBG(1, "Scanner not ready: ADF maintenance "
+ "cover open\n");
+ if (sdat->complain_on_errors & COMPLAIN_ON_ADF_ERROR)
+ return SANE_STATUS_COVER_OPEN;
+ else
+ return SANE_STATUS_GOOD;
+ default:
+ DBG(5, "Scanner not ready: undocumented reason\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ case 0x81:
+ /* NOT TESTED -- I don't have a FSU */
+ switch (add_sense_qual)
+ {
+ case 0:
+ DBG(1, "Scanner not ready: FSU cover open\n");
+ if (sdat->complain_on_errors & COMPLAIN_ON_FSU_ERROR)
+ return SANE_STATUS_COVER_OPEN;
+ else
+ return SANE_STATUS_GOOD;
+ case 1:
+ DBG(1, "Scanner not ready: FSU light dispersion "
+ "error\n");
+ if (sdat->complain_on_errors & COMPLAIN_ON_FSU_ERROR)
+ {
+ return SANE_STATUS_IO_ERROR;
+ }
+ else
+ return SANE_STATUS_GOOD;
+ default:
+ DBG(5, "Scanner not ready: undocumented reason\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ default:
+ DBG(5, "Scanner not ready: undocumented reason\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ case 0x03: /* medium error */
+ switch (add_sense_code)
+ {
+ case 0x3a:
+ DBG(1, "ADF is empty\n");
+ if (sdat->complain_on_errors & COMPLAIN_ON_ADF_ERROR)
+ return SANE_STATUS_NO_DOCS;
+ else
+ return SANE_STATUS_GOOD;
+ case 0x53:
+ DBG(1, "ADF paper jam\n"
+ "Open and close the maintenance cover to clear "
+ "this error\n");
+ if (sdat->complain_on_errors & COMPLAIN_ON_ADF_ERROR)
+ return SANE_STATUS_JAMMED;
+ else
+ return SANE_STATUS_GOOD;
+ default:
+ DBG(5, "medium error: undocumented reason\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ case 0x04: /* hardware error */
+ switch (add_sense_code)
+ {
+ case 0x08:
+ DBG(1, "hardware error: scanner communication failed\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x60:
+ DBG(1, "hardware error: lamp failure\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x62:
+ DBG(1, "hardware error: scan head positioning failed\n");
+ return SANE_STATUS_IO_ERROR;
+ default:
+ DBG(1, "general hardware error\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ case 0x05: /* illegal request */
+ DBG(10, "error: illegal request\n");
+ return SANE_STATUS_IO_ERROR;
+ case 0x06: /* unit attention */
+ switch (add_sense_code)
+ {
+ case 0x29:
+ DBG(5, "unit attention: reset occured\n");
+ return SANE_STATUS_GOOD;
+ case 0x2a:
+ DBG(5, "unit attention: parameter changed by "
+ "another initiator\n");
+ return SANE_STATUS_IO_ERROR;
+ default:
+ DBG(5, "unit attention: exact reason not documented\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ case 0x09: /* data remains */
+ DBG(5, "error: data remains\n");
+ return SANE_STATUS_IO_ERROR;
+ default:
+ DBG(5, "error: sense code not documented\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ }
+ }
+ return SANE_STATUS_IO_ERROR;
+}
+
+static SANE_Status
+test_unit_ready (int fd)
+{
+ static u_char cmd[] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
+ SANE_Status status;
+ DBG (11, "<< test_unit_ready ");
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+
+#if 0
+static SANE_Status
+request_sense (int fd, void *sense_buf, size_t *sense_size)
+{
+ static u_char cmd[] = {REQUEST_SENSE, 0, 0, 0, SENSE_LEN, 0};
+ SANE_Status status;
+ DBG (11, "<< request_sense ");
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), sense_buf, sense_size);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+#endif
+
+static SANE_Status
+inquiry (int fd, void *inq_buf, size_t *inq_size)
+{
+ static u_char cmd[] = {INQUIRY, 0, 0, 0, INQUIRY_LEN, 0};
+ SANE_Status status;
+ DBG (11, "<< inquiry ");
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), inq_buf, inq_size);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+
+static SANE_Status
+mode_select_mud (int fd, int mud)
+{
+ static u_char cmd[6 + MODEPARAM_LEN] =
+ {MODE_SELECT6, 0x10, 0, 0, MODEPARAM_LEN, 0};
+ mode_select_param *mp;
+ SANE_Status status;
+ DBG (11, "<< mode_select_mud ");
+
+ mp = (mode_select_param *)(cmd + 6);
+ memset (mp, 0, MODEPARAM_LEN);
+ mp->page_code = 3;
+ mp->page_length = 6;
+ mp->mud[0] = mud >> 8;
+ mp->mud[1] = mud & 0xFF;
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+
+static SANE_Status
+mode_select_adf_fsu (int fd, int mode)
+{
+ static u_char cmd[6 + MODE_SUBDEV_LEN] =
+ {MODE_SELECT6, 0x10, 0, 0, MODE_SUBDEV_LEN, 0};
+ mode_select_subdevice *mp;
+ SANE_Status status;
+ DBG (11, "<< mode_select_adf_fsu ");
+
+ mp = (mode_select_subdevice *)(cmd + 6);
+ memset (mp, 0, MODE_SUBDEV_LEN);
+ mp->page_code = 0x20;
+ mp->page_length = 26;
+ switch (mode)
+ {
+ case SCAN_SIMPLE:
+ mp->a_mode = 0x40;
+ mp->f_mode = 0x40;
+ break;
+ case SCAN_WITH_FSU:
+ mp->a_mode = 0;
+ mp->f_mode = 0x40;
+ break;
+ case SCAN_WITH_ADF:
+ mp->a_mode = 0x40;
+ mp->f_mode = 0;
+ break;
+#ifdef ALLOW_AUTO_SELECT_ADF
+ case: SCAN_ADF_FSU_AUTO:
+ mp->a_mode = 0;
+ mp->f_mode = 0;
+ break;
+#endif
+ }
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+
+static SANE_Status wait_ready(int fd);
+
+static SANE_Status
+object_position(int fd, int load)
+{
+ static u_char cmd[] = {OBJECT_POSITION, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ SANE_Status status;
+ DBG (11, "<< object_position ");
+
+ cmd[1] = load;
+
+ wait_ready(fd);
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+
+#if 0
+static SANE_Status
+reserve_unit (int fd)
+{
+ static u_char cmd[] = {RESERVE_UNIT, 0, 0, 0, 0, 0};
+ SANE_Status status;
+ DBG (11, "<< reserve_unit ");
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+#endif
+
+#if 0
+static SANE_Status
+release_unit (int fd)
+{
+ static u_char cmd[] = {RELEASE_UNIT, 0, 0, 0, 0, 0};
+ SANE_Status status;
+ DBG (11, "<< release_unit ");
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+#endif
+
+static SANE_Status
+mode_sense (int fd, void *modeparam_buf, size_t * modeparam_size,
+ int page)
+{
+ static u_char cmd[6];
+ SANE_Status status;
+ DBG (11, "<< mode_sense ");
+
+ memset (cmd, 0, sizeof (cmd));
+ cmd[0] = 0x1a;
+ cmd[2] = page;
+ cmd[4] = *modeparam_size;
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), modeparam_buf,
+ modeparam_size);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+
+static SANE_Status
+scan (int fd)
+{
+ static u_char cmd[] = {SCAN, 0, 0, 0, 0, 0};
+ SANE_Status status;
+ DBG (11, "<< scan ");
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+
+#if 0
+static SANE_Status
+send_diagnostics (int fd)
+{
+ static u_char cmd[] = {SEND_DIAGNOSTIC, 0x04, 0, 0, 0, 0};
+ SANE_Status status;
+ DBG (11, "<< send_diagnostics ");
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+#endif
+
+static SANE_Status
+send (int fd, SHARP_Send * ss)
+{
+ static u_char cmd[] = {SEND, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ SANE_Status status;
+ DBG (11, "<< send ");
+
+ cmd[2] = ss->dtc;
+ cmd[4] = ss->dtq >> 8;
+ cmd[5] = ss->dtq;
+ cmd[6] = ss->length >> 16;
+ cmd[7] = ss->length >> 8;
+ cmd[8] = ss->length >> 0;
+
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+
+}
+
+static SANE_Status
+set_window (int fd, window_param *wp, int len)
+{
+ static u_char cmd[10 + WINDOW_LEN] =
+ {SET_WINDOW, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ window_param *winp;
+ SANE_Status status;
+ DBG (11, "<< set_window ");
+
+ cmd[8] = len;
+ winp = (window_param *)(cmd + 10);
+ memset (winp, 0, WINDOW_LEN);
+ memcpy (winp, wp, len);
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+ DBG (11, ">>\n");
+ return (status);
+
+}
+
+static SANE_Status
+get_window (int fd, void *buf, size_t * buf_size)
+{
+
+ static u_char cmd[10] = {GET_WINDOW, 0, 0, 0, 0, 0, 0, 0, WINDOW_LEN, 0};
+ SANE_Status status;
+ DBG (11, "<< get_window ");
+
+ cmd[8] = *buf_size;
+ status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), buf, buf_size);
+
+ DBG (11, ">>\n");
+ return (status);
+}
+
+#ifdef USE_FORK
+
+/* the following four functions serve simply the purpose
+ to avoid "over-optimised" code when reader_process and
+ read_data wait for the buffer to become ready. The simple
+ while-loops in these functions which check the buffer
+ status may be optimised so that the machine code only
+ operates with registers instead of using the variable
+ values stored in memory. (This is only a workaround -
+ it would be better to set a compiler pragma, which ensures
+ that the program looks into the RAM in these while loops --
+ but unfortunately I could not find appropriate information
+ about this at least for gcc, not to speak about other
+ compilers...
+ Abel)
+*/
+
+static int
+cancel_requested(SHARP_Scanner *s)
+{
+ return s->rdr_ctl->cancel;
+}
+
+static SANE_Status
+rdr_status(SHARP_Scanner *s)
+{
+ return s->rdr_ctl->status;
+}
+
+static int
+buf_status(SHARP_shmem_ctl *s)
+{
+ return s->shm_status;
+}
+
+static int
+reader_running(SHARP_Scanner *s)
+{
+ return s->rdr_ctl->running;
+}
+
+static int
+reader_process(SHARP_Scanner *s)
+{
+ SANE_Status status;
+ sigset_t sigterm_set;
+ static u_char cmd[] = {READ, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ int full_count = 0, counted;
+ size_t waitindex, cmdindex;
+ size_t bytes_to_queue;
+ size_t nread;
+ size_t max_bytes_per_read;
+ int max_queue;
+ int i, retries = MAX_RETRIES;
+ SHARP_shmem_ctl *bc;
+
+ s->rdr_ctl->running = 1;
+ DBG(11, "<< reader_process\n");
+
+ sigemptyset (&sigterm_set);
+
+ bytes_to_queue = s->bytes_to_read;
+
+ /* it seems that some carriage stops can be avoided with the
+ JX-250, if the data of an integral number of scan lines is
+ read with one SCSI command
+ */
+ max_bytes_per_read = s->dev->info.bufsize / s->params.bytes_per_line;
+ if (max_bytes_per_read)
+ max_bytes_per_read *= s->params.bytes_per_line;
+ else
+ /* this is a really tiny buffer..*/
+ max_bytes_per_read = s->dev->info.bufsize;
+
+ /* wait_ready(s->fd); */
+
+ if (s->dev->info.queued_reads <= s->dev->info.buffers)
+ max_queue = s->dev->info.queued_reads;
+ else
+ max_queue = s->dev->info.buffers;
+ if (max_queue <= 0)
+ max_queue = 1;
+ for (i = 0; i < max_queue; i++)
+ {
+ bc = &s->rdr_ctl->buf_ctl[i];
+ if (bytes_to_queue)
+ {
+ nread = bytes_to_queue;
+ if (nread > max_bytes_per_read)
+ nread = max_bytes_per_read;
+ bc->used = nread;
+ cmd[6] = nread >> 16;
+ cmd[7] = nread >> 8;
+ cmd[8] = nread;
+#ifdef QUEUEDEBUG
+ DBG(2, "reader: req_enter...\n");
+#endif
+ status = sanei_scsi_req_enter (s->fd, cmd, sizeof (cmd),
+ bc->buffer,
+ &bc->used,
+ &bc->qid);
+#ifdef QUEUEDEBUG
+ DBG(2, "reader: req_enter ok\n");
+#endif
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG(1, "reader_process: read command failed: %s",
+ sane_strstatus(status));
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+ sanei_scsi_req_flush_all_extended(s->fd);
+#else
+ sanei_scsi_req_flush_all();
+#endif
+ s->rdr_ctl->status = status;
+ s->rdr_ctl->running = 0;
+ return 2;
+ }
+ bc->shm_status = SHM_BUSY;
+ bc->nreq = bc->used;
+ bytes_to_queue -= bc->nreq;
+ }
+ else
+ {
+ bc->used = 0;
+ bc->shm_status = SHM_EMPTY;
+ }
+ }
+ waitindex = 0;
+ cmdindex = i % s->dev->info.buffers;
+
+ while(s->bytes_to_read > 0)
+ {
+ if (cancel_requested(s))
+ {
+#ifdef QUEUEDEBUG
+ DBG(2, "reader: flushing requests...\n");
+#endif
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+ sanei_scsi_req_flush_all_extended(s->fd);
+#else
+ sanei_scsi_req_flush_all();
+#endif
+#ifdef QUEUEDEBUG
+ DBG(2, "reader: flushing requests ok\n");
+#endif
+ s->rdr_ctl->cancel = 0;
+ s->rdr_ctl->status = SANE_STATUS_CANCELLED;
+ s->rdr_ctl->running = 0;
+ DBG(11, " reader_process (cancelled) >>\n");
+ return 1;
+ }
+
+ bc = &s->rdr_ctl->buf_ctl[waitindex];
+ if (bc->shm_status == SHM_BUSY)
+ {
+#ifdef DEBUG
+ {
+ struct timeval t;
+ gettimeofday(&t, 0);
+ DBG(2, "rd: waiting for data %li.%06li\n", t.tv_sec, t.tv_usec);
+ }
+#endif
+#ifdef QUEUEDEBUG
+ DBG(2, "reader: req_wait...\n");
+#endif
+ status = sanei_scsi_req_wait(bc->qid);
+#ifdef QUEUEDEBUG
+ DBG(2, "reader: req_wait ok\n");
+#endif
+#ifdef DEBUG
+ {
+ struct timeval t;
+ gettimeofday(&t, 0);
+ DBG(2, "rd: data received %li.%06li\n", t.tv_sec, t.tv_usec);
+ }
+#endif
+ if (status == SANE_STATUS_DEVICE_BUSY && retries)
+ {
+ bc->used = 0;
+ retries--;
+ DBG(11, "reader: READ command returned BUSY\n");
+ status = SANE_STATUS_GOOD;
+ usleep(10000);
+ }
+ else if (status != SANE_STATUS_GOOD)
+ {
+ DBG(1, "reader_process: read command failed: %s\n",
+ sane_strstatus(status));
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+ sanei_scsi_req_flush_all_extended(s->fd);
+#else
+ sanei_scsi_req_flush_all();
+#endif
+ s->rdr_ctl->status = status;
+ s->rdr_ctl->running = 0;
+ return 2;
+ }
+ else
+ {
+ retries = MAX_RETRIES;
+ }
+#if 1
+ s->bytes_to_read -= bc->used;
+ bytes_to_queue += bc->nreq - bc->used;
+#else
+ /* xxxxxxxxxxxxxxxxxxx TEST xxxxxxxxxxxxxxx */
+ s->bytes_to_read -= bc->nreq;
+ /* memset(bc->buffer + bc->used, 0, bc->nreq - bc->used); */
+ bc->used = bc->nreq;
+ /* bytes_to_queue += bc->nreq - bc->used; */
+ DBG(1, "btr: %i btq: %i nreq: %i nrcv: %i\n",
+ s->bytes_to_read, bytes_to_queue, bc->nreq, bc->used);
+#endif
+ bc->start = 0;
+ bc->shm_status = SHM_FULL;
+
+ waitindex++;
+ if (waitindex == s->dev->info.buffers)
+ waitindex = 0;
+
+ }
+
+ if (bytes_to_queue)
+ {
+ /* wait until the next buffer is completely read via read_data */
+ bc = &s->rdr_ctl->buf_ctl[cmdindex];
+ counted = 0;
+ while (buf_status(bc) != SHM_EMPTY)
+ {
+ if (!counted)
+ {
+ counted = 1;
+ full_count++;
+ }
+ if (cancel_requested(s))
+ {
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+ sanei_scsi_req_flush_all_extended(s->fd);
+#else
+ sanei_scsi_req_flush_all();
+#endif
+ s->rdr_ctl->cancel = 0;
+ s->rdr_ctl->status = SANE_STATUS_CANCELLED;
+ s->rdr_ctl->running = 0;
+ DBG(11, " reader_process (cancelled) >>\n");
+ return 1;
+ }
+ }
+
+ nread = bytes_to_queue;
+ if (nread > max_bytes_per_read)
+ nread = max_bytes_per_read;
+ bc->used = nread;
+ cmd[6] = nread >> 16;
+ cmd[7] = nread >> 8;
+ cmd[8] = nread;
+ status = sanei_scsi_req_enter (s->fd, cmd, sizeof (cmd),
+ bc->buffer, &bc->used, &bc->qid);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG(1, "reader_process: read command failed: %s",
+ sane_strstatus(status));
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+ sanei_scsi_req_flush_all_extended(s->fd);
+#else
+ sanei_scsi_req_flush_all();
+#endif
+ s->rdr_ctl->status = status;
+ s->rdr_ctl->running = 0;
+ return 2;
+ }
+ bc->shm_status = SHM_BUSY;
+ bc->nreq = nread;
+ bytes_to_queue -= nread;
+
+ cmdindex++;
+ if (cmdindex == s->dev->info.buffers)
+ cmdindex = 0;
+ }
+
+ if (cancel_requested(s))
+ {
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+ sanei_scsi_req_flush_all_extended(s->fd);
+#else
+ sanei_scsi_req_flush_all();
+#endif
+ s->rdr_ctl->cancel = 0;
+ s->rdr_ctl->status = SANE_STATUS_CANCELLED;
+ s->rdr_ctl->running = 0;
+ DBG(11, " reader_process (cancelled) >>\n");
+ return 1;
+ }
+ }
+
+ DBG(1, "buffer full conditions: %i\n", full_count);
+ DBG(11, " reader_process>>\n");
+
+ s->rdr_ctl->running = 0;
+ return 0;
+}
+
+static SANE_Status
+read_data (SHARP_Scanner *s, SANE_Byte *buf, size_t * buf_size)
+{
+ size_t copysize, copied = 0;
+ SHARP_shmem_ctl *bc;
+
+ DBG(11, "<< read_data ");
+
+ bc = &s->rdr_ctl->buf_ctl[s->read_buff];
+
+ while (copied < *buf_size)
+ {
+ /* wait until the reader process delivers data or a scanner error occurs: */
+ while ( buf_status(bc) != SHM_FULL
+ && rdr_status(s) == SANE_STATUS_GOOD)
+ {
+ usleep(10); /* could perhaps be longer. make this user configurable?? */
+ }
+
+ if (rdr_status(s) != SANE_STATUS_GOOD)
+ {
+ return rdr_status(s);
+ DBG(11, ">>\n");
+ }
+
+ copysize = bc->used - bc->start;
+
+ if (copysize > *buf_size - copied )
+ copysize = *buf_size - copied;
+
+ memcpy(buf, &(bc->buffer[bc->start]), copysize);
+
+ copied += copysize;
+ buf = &buf[copysize];
+
+ bc->start += copysize;
+ if (bc->start >= bc->used)
+ {
+ bc->start = 0;
+ bc->shm_status = SHM_EMPTY;
+ s->read_buff++;
+ if (s->read_buff == s->dev->info.buffers)
+ s->read_buff = 0;
+ bc = &s->rdr_ctl->buf_ctl[s->read_buff];
+ }
+ }
+
+ DBG(11, ">>\n");
+ return SANE_STATUS_GOOD;
+}
+
+#else /* don't USE_FORK: */
+
+static SANE_Status
+read_data (SHARP_Scanner *s, SANE_Byte *buf, size_t * buf_size)
+{
+ static u_char cmd[] = {READ, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ SANE_Status status = SANE_STATUS_GOOD;
+ size_t remain = *buf_size;
+ size_t nread;
+ int retries = MAX_RETRIES;
+ DBG (11, "<< read_data ");
+
+ /* sane_read_shuffled requires that read_data returns
+ exactly *buf_size bytes, so it must be guaranteed here.
+ Further make sure that not more bytes are read in than
+ sanei_scsi_max_request_size allows, to avoid a failure
+ of the read command
+ */
+ while (remain > 0)
+ {
+ nread = remain;
+ if (nread > s->dev->info.bufsize)
+ nread = s->dev->info.bufsize;
+ cmd[6] = nread >> 16;
+ cmd[7] = nread >> 8;
+ cmd[8] = nread;
+ status = sanei_scsi_cmd (s->fd, cmd, sizeof (cmd),
+ &buf[*buf_size - remain], &nread);
+ if (status == SANE_STATUS_DEVICE_BUSY && retries)
+ {
+ retries--;
+ nread = 0;
+ usleep(10000);
+ }
+ else if (status != SANE_STATUS_GOOD)
+ {
+ DBG(11, ">>\n");
+ return(status);
+ }
+ else
+ {
+ retries = MAX_RETRIES;
+ }
+ remain -= nread;
+ }
+ DBG (11, ">>\n");
+ return (status);
+}
+#endif
+
+static size_t
+max_string_size (const SANE_String_Const strings[])
+{
+ size_t size, max_size = 0;
+ int i;
+ DBG (10, "<< max_string_size ");
+
+ for (i = 0; strings[i]; ++i)
+ {
+ size = strlen (strings[i]) + 1;
+ if (size > max_size)
+ max_size = size;
+ }
+
+ DBG (10, ">>\n");
+ return max_size;
+}
+
+static SANE_Status
+wait_ready(int fd)
+{
+ SANE_Status status;
+ int retry = 0;
+
+ while ((status = test_unit_ready (fd)) != SANE_STATUS_GOOD)
+ {
+ DBG (5, "wait_ready failed (%d)\n", retry);
+ if (retry++ > 15){
+ return SANE_STATUS_IO_ERROR;
+ }
+ sleep(3);
+ }
+ return (status);
+
+}
+
+/* ask the scanner for the maximum scan sizes with/without ADF and
+ FSU. The JX330 manual does mention the sizes.
+*/
+static SANE_Status
+get_max_scan_size(int fd, SHARP_Device *dev, int mode)
+{
+ SANE_Status status;
+ mode_sense_subdevice m_subdev;
+ size_t buf_size;
+
+ status = mode_select_adf_fsu(fd, mode);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "get_scan_sizes: MODE_SELECT/subdevice page failed\n");
+ sanei_scsi_close (fd);
+ return (SANE_STATUS_INVAL);
+ }
+
+ DBG (3, "get_scan_sizes: sending MODE SENSE/subdevice page\n");
+ memset (&m_subdev, 0, sizeof (m_subdev));
+ buf_size = sizeof (m_subdev);
+ status = mode_sense (fd, &m_subdev, &buf_size, 0x20);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "get_scan_sizes: MODE_SENSE/subdevice page failed\n");
+ sanei_scsi_close (fd);
+ return (SANE_STATUS_INVAL);
+ }
+
+ dev->info.tl_x_ranges[mode].min = 0;
+ dev->info.tl_x_ranges[mode].max = SANE_FIX(PIX_TO_MM(
+ (m_subdev.max_x[0] << 24) + (m_subdev.max_x[1] << 16) +
+ (m_subdev.max_x[2] << 8) + m_subdev.max_x[3] - 1, dev->info.mud));
+ dev->info.tl_x_ranges[mode].quant = 0;
+
+ dev->info.br_x_ranges[mode].min = SANE_FIX(PIX_TO_MM(1, dev->info.mud));
+ dev->info.br_x_ranges[mode].max = SANE_FIX(PIX_TO_MM(
+ (m_subdev.max_x[0] << 24) + (m_subdev.max_x[1] << 16) +
+ (m_subdev.max_x[2] << 8) + m_subdev.max_x[3], dev->info.mud));
+ dev->info.br_x_ranges[mode].quant = 0;
+
+ dev->info.tl_y_ranges[mode].min = 0;
+ if ((dev->sensedat.model != JX250 && dev->sensedat.model != JX350) ||
+ mode != SCAN_WITH_FSU)
+ dev->info.tl_y_ranges[mode].max = SANE_FIX(PIX_TO_MM(
+ (m_subdev.max_y[0] << 24) + (m_subdev.max_y[1] << 16) +
+ (m_subdev.max_y[2] << 8) + m_subdev.max_y[3] - 1, dev->info.mud));
+ else
+ /* The manual for the JX250 states on page 62 that the maximum
+ value for tl_y in FSU mode is 13199, while the max value for
+ br_y is 13900, which is (probably -- I don't have a FSU) returned
+ by mode sense/subdevice page. Therefore, we cannot simply
+ decrement that value and store it as max(tl_y).
+ */
+ dev->info.tl_y_ranges[mode].max = 13199;
+ dev->info.tl_y_ranges[mode].quant = 0;
+
+ dev->info.br_y_ranges[mode].min = SANE_FIX(PIX_TO_MM(1, dev->info.mud));
+ dev->info.br_y_ranges[mode].max = SANE_FIX(PIX_TO_MM(
+ (m_subdev.max_y[0] << 24) + (m_subdev.max_y[1] << 16) +
+ (m_subdev.max_y[2] << 8) + m_subdev.max_y[3], dev->info.mud));
+ dev->info.br_y_ranges[mode].quant = 0;
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach (const char *devnam, SHARP_Device ** devp)
+{
+ SANE_Status status;
+ SHARP_Device *dev;
+ SHARP_Sense_Data sensedat;
+
+ int fd;
+ char inquiry_data[INQUIRY_LEN];
+ const char *model_name;
+ mode_sense_param msp;
+ mode_sense_subdevice m_subdev;
+ size_t buf_size;
+ DBG (10, "<< attach ");
+
+ for (dev = first_dev; dev; dev = dev->next)
+ {
+ if (strcmp (dev->sane.name, devnam) == 0)
+ {
+ if (devp)
+ *devp = dev;
+ return (SANE_STATUS_GOOD);
+ }
+ }
+
+ sensedat.model = unknown;
+ sensedat.complain_on_errors = 0;
+ DBG (3, "attach: opening %s\n", devnam);
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+ {
+ int bufsize = 4096;
+ status = sanei_scsi_open_extended (devnam, &fd, &sense_handler, &sensedat, &bufsize);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "attach: open failed: %s\n", sane_strstatus (status));
+ return (status);
+ }
+ if (bufsize < 4096)
+ {
+ DBG(1, "attach: open failed. no memory\n");
+ sanei_scsi_close(fd);
+ return SANE_STATUS_NO_MEM;
+ }
+ }
+#else
+ status = sanei_scsi_open (devnam, &fd, &sense_handler, &sensedat);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "attach: open failed: %s\n", sane_strstatus (status));
+ return (status);
+ }
+#endif
+
+ DBG (3, "attach: sending INQUIRY\n");
+ memset (inquiry_data, 0, sizeof (inquiry_data));
+ buf_size = sizeof (inquiry_data);
+ status = inquiry (fd, inquiry_data, &buf_size);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "attach: inquiry failed: %s\n", sane_strstatus (status));
+ sanei_scsi_close (fd);
+ return (status);
+ }
+
+ if (inquiry_data[0] == 6 && strncmp (inquiry_data + 8, "SHARP", 5) == 0)
+ {
+ if (strncmp (inquiry_data + 16, "JX610", 5) == 0)
+ sensedat.model = JX610;
+ else if (strncmp (inquiry_data + 16, "JX250", 5) == 0)
+ sensedat.model = JX250;
+ else if (strncmp (inquiry_data + 16, "JX350", 5) == 0)
+ sensedat.model = JX350;
+ else if ( strncmp (inquiry_data + 16, "JX320", 5) == 0
+ || strncmp (inquiry_data + 16, "JX325", 5) == 0)
+ sensedat.model = JX320;
+ else if (strncmp (inquiry_data + 16, "JX330", 5) == 0)
+ sensedat.model = JX330;
+ }
+
+ if (sensedat.model == unknown)
+ {
+ DBG (1, "attach: device doesn't look like a Sharp scanner\n");
+ sanei_scsi_close (fd);
+ return (SANE_STATUS_INVAL);
+ }
+
+ DBG (3, "attach: sending TEST_UNIT_READY\n");
+ status = test_unit_ready (fd);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "attach: test unit ready failed (%s)\n",
+ sane_strstatus (status));
+ sanei_scsi_close (fd);
+ return (status);
+ }
+
+ DBG (3, "attach: sending MODE SELECT\n");
+ /* JX-610 probably supports only 25 MUD size
+ JX-320 only supports 25 MUD size
+ */
+ if (strncmp (inquiry_data + 16, "JX610", 5) == 0)
+ status = mode_select_mud (fd, DEFAULT_MUD_JX610);
+ else if (strncmp (inquiry_data + 16, "JX320", 5) == 0)
+ status = mode_select_mud (fd, DEFAULT_MUD_JX320);
+ else
+ status = mode_select_mud (fd, DEFAULT_MUD_JX330);
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "attach: MODE_SELECT6 failed\n");
+ sanei_scsi_close (fd);
+ return (SANE_STATUS_INVAL);
+ }
+
+ DBG (3, "attach: sending MODE SENSE/MUP page\n");
+ memset (&msp, 0, sizeof (msp));
+ buf_size = sizeof (msp);
+ status = mode_sense (fd, &msp, &buf_size, 3);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "attach: MODE_SENSE/MUP page failed\n");
+ sanei_scsi_close (fd);
+ return (SANE_STATUS_INVAL);
+ }
+
+ dev = malloc (sizeof (*dev));
+ if (!dev)
+ return (SANE_STATUS_NO_MEM);
+ memset (dev, 0, sizeof (*dev));
+
+ dev->sane.name = strdup (devnam);
+ dev->sane.vendor = "SHARP";
+ model_name = (char*) inquiry_data + 16;
+ dev->sane.model = strndup (model_name, 10);
+ dev->sane.type = "flatbed scanner";
+
+ dev->sensedat.model = sensedat.model;
+
+ DBG (5, "dev->sane.name = %s\n", dev->sane.name);
+ DBG (5, "dev->sane.vendor = %s\n", dev->sane.vendor);
+ DBG (5, "dev->sane.model = %s\n", dev->sane.model);
+ DBG (5, "dev->sane.type = %s\n", dev->sane.type);
+
+ dev->info.xres_range.quant = 0;
+ dev->info.yres_range.quant = 0;
+
+ dev->info.tl_x_ranges[SCAN_SIMPLE].min = SANE_FIX(0);
+ dev->info.br_x_ranges[SCAN_SIMPLE].min = SANE_FIX(1);
+ dev->info.tl_y_ranges[SCAN_SIMPLE].min = SANE_FIX(0);
+ dev->info.br_y_ranges[SCAN_SIMPLE].min = SANE_FIX(1);
+ dev->info.tl_x_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
+ dev->info.br_x_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
+ dev->info.tl_y_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
+ dev->info.br_y_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
+
+ dev->info.xres_default = 150;
+ dev->info.yres_default = 150;
+ dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(209);
+ dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(210);
+ dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(296);
+ dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(297);
+
+ dev->info.bmu = msp.bmu;
+ dev->info.mud = (msp.mud[0] << 8) + msp.mud[1];
+
+ dev->info.adf_fsu_installed = 0;
+ if (dev->sensedat.model == JX610)
+ {
+ dev->info.xres_range.max = 600;
+ dev->info.xres_range.min = 30;
+
+ dev->info.yres_range.max = 600;
+ dev->info.yres_range.min = 30;
+ dev->info.x_default = SANE_FIX(210);
+ dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(303); /* 304.8mm is the real max */
+ dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(304); /* 304.8mm is the real max */
+
+ dev->info.y_default = SANE_FIX(297);
+ dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(430); /* 431.8 is the real max */
+ dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(431); /* 431.8 is the real max */
+ }
+ else if (dev->sensedat.model == JX320)
+ {
+ dev->info.xres_range.max = 600;
+ dev->info.xres_range.min = 30;
+
+ dev->info.yres_range.max = 600;
+ dev->info.yres_range.min = 30;
+ dev->info.x_default = SANE_FIX(210);
+ dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(212);
+ dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(213);
+
+ dev->info.y_default = SANE_FIX(297);
+ dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(292);
+ dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(293);
+ }
+ else
+ {
+ /* ask the scanner, if ADF or FSU are installed, and ask for
+ the maximum scan sizes with/without ADF and FSU.
+ */
+
+ DBG (3, "attach: sending MODE SENSE/subdevice page\n");
+ memset (&m_subdev, 0, sizeof (m_subdev));
+ buf_size = sizeof (m_subdev);
+ status = mode_sense (fd, &m_subdev, &buf_size, 0x20);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "attach: MODE_SENSE/subdevice page failed\n");
+ sanei_scsi_close (fd);
+ return (SANE_STATUS_INVAL);
+ }
+
+ /* The JX330 manual is not very clear about the ADF- und FSU-Bits
+ returned by a JX320 and JX325 for the mode sense command:
+ Are these bits set to zero or not? To be on the safe side, let's
+ clear them.
+ */
+
+ if ( strncmp(inquiry_data + 16, "JX320", 5) == 0
+ || strncmp(inquiry_data + 16, "JX325", 5) == 0)
+ {
+ m_subdev.f_mode_type = 0;
+ m_subdev.a_mode_type = 0;
+ }
+
+ get_max_scan_size(fd, dev, SCAN_SIMPLE);
+
+ if (m_subdev.a_mode_type & 0x03)
+ {
+ dev->info.adf_fsu_installed = HAVE_ADF;
+ get_max_scan_size(fd, dev, SCAN_WITH_ADF);
+ }
+ if (m_subdev.f_mode_type & 0x07)
+ {
+ dev->info.adf_fsu_installed |= HAVE_FSU;
+ get_max_scan_size(fd, dev, SCAN_WITH_FSU);
+ }
+
+ if ( dev->sensedat.model == JX320
+ || dev->sensedat.model == JX330
+ || dev->sensedat.model == JX350)
+ {
+ dev->info.xres_range.max = 600;
+ dev->info.xres_range.min = 30;
+
+ dev->info.yres_range.max = 600;
+ dev->info.yres_range.min = 30;
+ dev->info.x_default = SANE_FIX(210);
+ dev->info.y_default = SANE_FIX(297);
+ }
+ else if (dev->sensedat.model == JX250)
+ {
+ dev->info.xres_range.max = 400;
+ dev->info.xres_range.min = 30;
+
+ dev->info.yres_range.max = 400;
+ dev->info.yres_range.min = 30;
+ dev->info.x_default = SANE_FIX(210);
+ dev->info.y_default = SANE_FIX(297);
+ }
+ }
+ sanei_scsi_close (fd);
+
+ dev->info.threshold_range.min = 1;
+ dev->info.threshold_range.max = 255;
+ dev->info.threshold_range.quant = 0;
+
+ DBG (5, "xres_default=%d\n", dev->info.xres_default);
+ DBG (5, "xres_range.max=%d\n", dev->info.xres_range.max);
+ DBG (5, "xres_range.min=%d\n", dev->info.xres_range.min);
+ DBG (5, "xres_range.quant=%d\n", dev->info.xres_range.quant);
+ DBG (5, "yres_default=%d\n", dev->info.yres_default);
+ DBG (5, "yres_range.max=%d\n", dev->info.yres_range.max);
+ DBG (5, "yres_range.min=%d\n", dev->info.yres_range.min);
+ DBG (5, "xres_range.quant=%d\n", dev->info.xres_range.quant);
+
+ DBG (5, "x_default=%f\n", SANE_UNFIX(dev->info.x_default));
+ DBG (5, "tl_x_range[0].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_SIMPLE].max));
+ DBG (5, "tl_x_range[0].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_SIMPLE].min));
+ DBG (5, "tl_x_range[0].quant=%d\n", dev->info.tl_x_ranges[SCAN_SIMPLE].quant);
+ DBG (5, "br_x_range[0].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_SIMPLE].max));
+ DBG (5, "br_x_range[0].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_SIMPLE].min));
+ DBG (5, "br_x_range[0].quant=%d\n", dev->info.br_x_ranges[SCAN_SIMPLE].quant);
+ DBG (5, "y_default=%f\n", SANE_UNFIX(dev->info.y_default));
+ DBG (5, "tl_y_range[0].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_SIMPLE].max));
+ DBG (5, "tl_y_range[0].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_SIMPLE].min));
+ DBG (5, "tl_y_range[0].quant=%d\n", dev->info.tl_y_ranges[SCAN_SIMPLE].quant);
+ DBG (5, "br_y_range[0].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_SIMPLE].max));
+ DBG (5, "br_y_range[0].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_SIMPLE].min));
+ DBG (5, "br_y_range[0].quant=%d\n", dev->info.br_y_ranges[SCAN_SIMPLE].quant);
+
+ if (dev->info.adf_fsu_installed & HAVE_FSU)
+ {
+ DBG (5, "tl_x_range[1].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_FSU].max));
+ DBG (5, "tl_x_range[1].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_FSU].min));
+ DBG (5, "tl_x_range[1].quant=%d\n", dev->info.tl_x_ranges[SCAN_WITH_FSU].quant);
+ DBG (5, "br_x_range[1].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_FSU].max));
+ DBG (5, "br_x_range[1].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_FSU].min));
+ DBG (5, "br_x_range[1].quant=%d\n", dev->info.br_x_ranges[SCAN_WITH_FSU].quant);
+ DBG (5, "tl_y_range[1].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_FSU].max));
+ DBG (5, "tl_y_range[1].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_FSU].min));
+ DBG (5, "tl_y_range[1].quant=%d\n", dev->info.tl_y_ranges[SCAN_WITH_FSU].quant);
+ DBG (5, "br_y_range[1].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_FSU].max));
+ DBG (5, "br_y_range[1].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_FSU].min));
+ DBG (5, "br_y_range[1].quant=%d\n", dev->info.br_y_ranges[SCAN_WITH_FSU].quant);
+ }
+
+ if (dev->info.adf_fsu_installed & HAVE_ADF)
+ {
+ DBG (5, "tl_x_range[2].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_ADF].max));
+ DBG (5, "tl_x_range[2].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_ADF].min));
+ DBG (5, "tl_x_range[2].quant=%d\n", dev->info.tl_x_ranges[SCAN_WITH_ADF].quant);
+ DBG (5, "br_x_range[2].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_ADF].max));
+ DBG (5, "br_x_range[2].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_ADF].min));
+ DBG (5, "br_x_range[2].quant=%d\n", dev->info.br_x_ranges[SCAN_WITH_ADF].quant);
+ DBG (5, "tl_y_range[2].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_ADF].max));
+ DBG (5, "tl_y_range[2].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_ADF].min));
+ DBG (5, "tl_y_range[2].quant=%d\n", dev->info.tl_y_ranges[SCAN_WITH_ADF].quant);
+ DBG (5, "br_y_range[2].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_ADF].max));
+ DBG (5, "br_y_range[2].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_ADF].min));
+ DBG (5, "br_y_range[2].quant=%d\n", dev->info.br_y_ranges[SCAN_WITH_ADF].quant);
+ }
+
+ DBG (5, "bmu=%d\n", dev->info.bmu);
+ DBG (5, "mud=%d\n", dev->info.mud);
+
+ ++num_devices;
+ dev->next = first_dev;
+ first_dev = dev;
+
+ if (devp)
+ *devp = dev;
+
+ DBG (10, ">>\n");
+ return (SANE_STATUS_GOOD);
+}
+
+/* Enabling / disabling of gamma options.
+ Depends on many user settable options, so lets put it into
+ one function to be called by init_options and by sane_control_option
+
+*/
+#ifdef USE_CUSTOM_GAMMA
+static void
+set_gamma_caps(SHARP_Scanner *s)
+{
+ /* neither fixed nor custom gamma for line art modes */
+ if ( strcmp(s->val[OPT_MODE].s, M_LINEART) == 0
+ || strcmp(s->val[OPT_MODE].s, M_LINEART_COLOR) == 0)
+ {
+ s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+ }
+ else if (strcmp(s->val[OPT_MODE].s, M_GRAY) == 0)
+ {
+ s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+ if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
+ {
+ s->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+ }
+ else
+ {
+ s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
+ }
+ s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+ }
+ else
+ {
+ /* color mode */
+ s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+ if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
+ {
+ s->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+ }
+ else
+ {
+ s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
+ }
+ }
+}
+#endif /* USE_CUSTOM_GAMMA */
+
+/* The next function is a slightly modified version of sanei_constrain_value
+ Instead of returning status information like STATUS_INVAL, it adjusts
+ an invaild value to the nearest allowed one.
+*/
+static void
+clip_value (const SANE_Option_Descriptor * opt, void * value)
+{
+ const SANE_String_Const * string_list;
+ const SANE_Word * word_list;
+ int i, num_matches, match;
+ const SANE_Range * range;
+ SANE_Word w, v;
+ size_t len;
+
+ switch (opt->constraint_type)
+ {
+ case SANE_CONSTRAINT_RANGE:
+ w = *(SANE_Word *) value;
+ range = opt->constraint.range;
+
+ if (w < range->min)
+ w = range->min;
+ else if (w > range->max)
+ w = range->max;
+
+ if (range->quant)
+ {
+ v = (w - range->min + range->quant/2) / range->quant;
+ w = v * range->quant + range->min;
+ *(SANE_Word*) value = w;
+ }
+ break;
+
+ case SANE_CONSTRAINT_WORD_LIST:
+ w = *(SANE_Word *) value;
+ word_list = opt->constraint.word_list;
+ for (i = 1; w != word_list[i]; ++i)
+ if (i >= word_list[0])
+ /* somewhat arbitrary... Would be better to have a default value
+ explicitly defined.
+ */
+ *(SANE_Word*) value = word_list[1];
+ break;
+
+ case SANE_CONSTRAINT_STRING_LIST:
+ /* Matching algorithm: take the longest unique match ignoring
+ case. If there is an exact match, it is admissible even if
+ the same string is a prefix of a longer option name. */
+ string_list = opt->constraint.string_list;
+ len = strlen (value);
+
+ /* count how many matches of length LEN characters we have: */
+ num_matches = 0;
+ match = -1;
+ for (i = 0; string_list[i]; ++i)
+ if (strncasecmp (value, string_list[i], len) == 0
+ && len <= strlen (string_list[i]))
+ {
+ match = i;
+ if (len == strlen (string_list[i]))
+ {
+ /* exact match... */
+ if (strcmp (value, string_list[i]) != 0)
+ /* ...but case differs */
+ strcpy (value, string_list[match]);
+ }
+ ++num_matches;
+ }
+
+ if (num_matches > 1)
+ /* xxx quite arbitrary... We could also choose the first match
+ */
+ strcpy(value, string_list[match]);
+ else if (num_matches == 1)
+ strcpy (value, string_list[match]);
+ else
+ strcpy (value, string_list[0]);
+
+ default:
+ break;
+ }
+}
+
+/* make sure that enough memory is allocated for each string,
+ so that the strcpy in sane_control_option / set value cannot
+ write behind the end of the allocated memory.
+*/
+static SANE_Status
+init_string_option(SHARP_Scanner *s, SANE_String_Const name,
+ SANE_String_Const title, SANE_String_Const desc,
+ const SANE_String_Const *string_list, int option, int default_index)
+{
+ int i;
+
+ s->opt[option].name = name;
+ s->opt[option].title = title;
+ s->opt[option].desc = desc;
+ s->opt[option].type = SANE_TYPE_STRING;
+ s->opt[option].size = max_string_size (string_list);
+ s->opt[option].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[option].constraint.string_list = string_list;
+ s->val[option].s = malloc(s->opt[option].size);
+ if (s->val[option].s == 0)
+ {
+ for (i = 1; i < NUM_OPTIONS; i++)
+ {
+ if (s->val[i].s && s->opt[i].type == SANE_TYPE_STRING)
+ free(s->val[i].s);
+ }
+ return SANE_STATUS_NO_MEM;
+ }
+ strcpy(s->val[option].s, string_list[default_index]);
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+init_options (SHARP_Scanner * s)
+{
+ int i, default_source, sourcename_index = 0;
+ SANE_Word scalar;
+ DBG (10, "<< init_options ");
+
+ memset (s->opt, 0, sizeof (s->opt));
+ memset (s->val, 0, sizeof (s->val));
+
+ for (i = 0; i < NUM_OPTIONS; ++i)
+ {
+ s->opt[i].size = sizeof (SANE_Word);
+ s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->val[i].s = 0;
+ }
+
+ 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].type = SANE_TYPE_INT;
+ s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+ s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+ /* Mode group: */
+ s->opt[OPT_MODE_GROUP].title = "Scan Mode";
+ s->opt[OPT_MODE_GROUP].desc = "";
+ s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_MODE_GROUP].cap = 0;
+ s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* scan mode */
+#if 0
+ s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
+ s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
+ s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
+ s->opt[OPT_MODE].type = SANE_TYPE_STRING;
+ s->opt[OPT_MODE].size = max_string_size (mode_list);
+ s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_MODE].constraint.string_list = mode_list;
+ s->val[OPT_MODE].s = strdup (mode_list[3]); /* color scan */
+#endif
+ init_string_option(s, SANE_NAME_SCAN_MODE, SANE_TITLE_SCAN_MODE,
+ SANE_DESC_SCAN_MODE, mode_list, OPT_MODE, 3);
+
+ /* half tone */
+#if 0
+ s->opt[OPT_HALFTONE].name = SANE_NAME_HALFTONE_PATTERN;
+ s->opt[OPT_HALFTONE].title = SANE_TITLE_HALFTONE_PATTERN;
+ s->opt[OPT_HALFTONE].desc = SANE_DESC_HALFTONE " (JX-330 only)";
+ s->opt[OPT_HALFTONE].type = SANE_TYPE_STRING;
+ s->opt[OPT_HALFTONE].size = max_string_size (halftone_list);
+ s->opt[OPT_HALFTONE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_HALFTONE].constraint.string_list = halftone_list;
+ s->val[OPT_HALFTONE].s = strdup (halftone_list[0]);
+#endif
+ init_string_option(s, SANE_NAME_HALFTONE_PATTERN, SANE_TITLE_HALFTONE_PATTERN,
+ SANE_DESC_HALFTONE " (JX-330 only)", halftone_list, OPT_HALFTONE, 0);
+
+ if (s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350 ||
+ s->dev->sensedat.model == JX610 || s->dev->sensedat.model == JX320)
+ s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
+
+ i = 0;
+ default_source = s->dev->info.default_scan_mode;
+
+#ifdef ALLOW_AUTO_SELECT_ADF
+ /* The JX330, but nut not the JX250 supports auto selection of ADF/FSU: */
+ if (s->dev->info.adf_fsu_installed && (s->dev->sensedat.model == JX330))
+ s->dev->info->scansources[i++] = use_auto;
+#endif
+ if (s->dev->info.adf_fsu_installed & HAVE_ADF)
+ {
+ if (default_source == -1)
+ default_source = SCAN_WITH_ADF;
+ if (default_source == SCAN_WITH_ADF)
+ sourcename_index = i;
+ s->dev->info.scansources[i++] = use_adf;
+ }
+ else
+ {
+ if (default_source == SCAN_WITH_ADF)
+ default_source = SCAN_SIMPLE;
+ }
+ if (s->dev->info.adf_fsu_installed & HAVE_FSU)
+ {
+ if (default_source == -1)
+ default_source = SCAN_WITH_FSU;
+ if (default_source == SCAN_WITH_FSU)
+ sourcename_index = i;
+ s->dev->info.scansources[i++] = use_fsu;
+ }
+ else
+ {
+ if (default_source == SCAN_WITH_FSU)
+ default_source = SCAN_SIMPLE;
+ }
+ if (default_source < 0)
+ default_source = SCAN_SIMPLE;
+ if (default_source == SCAN_SIMPLE)
+ sourcename_index = i;
+ s->dev->info.scansources[i++] = use_simple;
+ s->dev->info.scansources[i] = 0;
+
+#if 0
+ s->opt[OPT_SCANSOURCE].name = SANE_NAME_SCAN_SOURCE;
+ s->opt[OPT_SCANSOURCE].title = SANE_TITLE_SCAN_SOURCE;
+ s->opt[OPT_SCANSOURCE].desc = SANE_DESC_SCAN_SOURCE;
+ s->opt[OPT_SCANSOURCE].type = SANE_TYPE_STRING;
+ s->opt[OPT_SCANSOURCE].size = max_string_size (s->dev->info.scansources);
+ s->opt[OPT_SCANSOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_SCANSOURCE].constraint.string_list = (SANE_String_Const*)s->dev->info.scansources;
+ s->val[OPT_SCANSOURCE].s = strdup (s->dev->info.scansources[0]);
+#endif
+
+ init_string_option(s, SANE_NAME_SCAN_SOURCE, SANE_TITLE_SCAN_SOURCE,
+ SANE_DESC_SCAN_SOURCE, (SANE_String_Const*)s->dev->info.scansources,
+ OPT_SCANSOURCE, sourcename_index);
+
+ if (i < 2)
+ s->opt[OPT_SCANSOURCE].cap |= SANE_CAP_INACTIVE;
+
+#if 0
+ s->opt[OPT_PAPER].name = "Paper size";
+ s->opt[OPT_PAPER].title = "Paper size";
+ s->opt[OPT_PAPER].desc = "Paper size";
+ s->opt[OPT_PAPER].type = SANE_TYPE_STRING;
+ /* xxx the possible values for the paper size should be changeable,
+ to reflect the different maximum scan sizes with/without ADF and FSU
+ */
+ if (s->dev->sensedat.model == JX610)
+ {
+ s->opt[OPT_PAPER].size = max_string_size (paper_list_jx610);
+ s->opt[OPT_PAPER].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_PAPER].constraint.string_list = paper_list_jx610;
+ s->val[OPT_PAPER].s = strdup (paper_list_jx610[1]);
+ }
+ else
+ {
+ s->opt[OPT_PAPER].size = max_string_size (paper_list_jx330);
+ s->opt[OPT_PAPER].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_PAPER].constraint.string_list = paper_list_jx330;
+ s->val[OPT_PAPER].s = strdup (paper_list_jx330[0]);
+ }
+#endif
+
+ if (s->dev->sensedat.model == JX610)
+ init_string_option(s, "Paper size", "Paper size",
+ "Paper size", paper_list_jx610, OPT_PAPER, 1);
+ else
+ init_string_option(s, "Paper size", "Paper size",
+ "Paper size", paper_list_jx330, OPT_PAPER, 0);
+
+ /* gamma */
+#if 0
+ s->opt[OPT_GAMMA].name = "Gamma";
+ s->opt[OPT_GAMMA].title = "Gamma";
+ s->opt[OPT_GAMMA].desc = "Gamma";
+ s->opt[OPT_GAMMA].type = SANE_TYPE_STRING;
+ s->opt[OPT_GAMMA].size = max_string_size (gamma_list);
+ s->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_GAMMA].constraint.string_list = gamma_list;
+ s->val[OPT_GAMMA].s = strdup (gamma_list[1]);
+#endif
+
+ init_string_option(s, "Gamma", "Gamma", "Gamma", gamma_list, OPT_GAMMA, 1);
+
+ /* scan speed */
+ s->opt[OPT_SPEED].name = SANE_NAME_SCAN_SPEED;
+ s->opt[OPT_SPEED].title = "Scan speed [fast]";
+ s->opt[OPT_SPEED].desc = SANE_DESC_SCAN_SPEED;
+ s->opt[OPT_SPEED].type = SANE_TYPE_BOOL;
+ s->val[OPT_SPEED].w = SANE_TRUE;
+
+ /* Resolution Group */
+ s->opt[OPT_RESOLUTION_GROUP].title = "Resolution";
+ s->opt[OPT_RESOLUTION_GROUP].desc = "";
+ s->opt[OPT_RESOLUTION_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_RESOLUTION_GROUP].cap = 0;
+ s->opt[OPT_RESOLUTION_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* select resolution */
+#ifdef USE_RESOLUTION_LIST
+ if (s->dev->sensedat.model == JX610 || s->dev->sensedat.model == JX330 ||
+ s->dev->sensedat.model == JX350 || s->dev->sensedat.model == JX320)
+ init_string_option(s, "ResolutionList", "ResolutionList", "ResolutionList",
+ resolution_list_jx610, OPT_RESOLUTION_LIST, RESOLUTION_MAX_JX610);
+ else
+ init_string_option(s, "ResolutionList", "ResolutionList", "ResolutionList",
+ resolution_list_jx250, OPT_RESOLUTION_LIST, RESOLUTION_MAX_JX250);
+#endif
+ /* x resolution */
+ s->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+ s->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+ s->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+ s->opt[OPT_X_RESOLUTION].type = SANE_TYPE_INT;
+ s->opt[OPT_X_RESOLUTION].unit = SANE_UNIT_DPI;
+ s->opt[OPT_X_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_X_RESOLUTION].constraint.range = &s->dev->info.xres_range;
+ s->val[OPT_X_RESOLUTION].w = s->dev->info.xres_default;
+
+#ifdef USE_SEPARATE_Y_RESOLUTION
+ /* y resolution */
+ s->opt[OPT_Y_RESOLUTION].name = "Y" SANE_NAME_SCAN_RESOLUTION;
+ s->opt[OPT_Y_RESOLUTION].title = "Y " SANE_TITLE_SCAN_RESOLUTION;
+ s->opt[OPT_Y_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+ s->opt[OPT_Y_RESOLUTION].type = SANE_TYPE_INT;
+ s->opt[OPT_Y_RESOLUTION].unit = SANE_UNIT_DPI;
+ s->opt[OPT_Y_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_Y_RESOLUTION].constraint.range = &s->dev->info.yres_range;
+ s->val[OPT_Y_RESOLUTION].w = s->dev->info.yres_default;
+#endif
+
+ /* "Geometry" group: */
+ s->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
+ s->opt[OPT_GEOMETRY_GROUP].desc = "";
+ s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
+ s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* top-left x */
+ s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+ s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+ s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+ s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+ s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+ s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_TL_X].constraint.range = &s->dev->info.tl_x_ranges[default_source];
+ s->val[OPT_TL_X].w = s->dev->info.tl_x_ranges[default_source].min;
+
+ /* top-left y */
+ s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+ s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+ s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_TL_Y].constraint.range = &s->dev->info.tl_y_ranges[default_source];
+ s->val[OPT_TL_Y].w = s->dev->info.tl_y_ranges[default_source].min;
+
+ /* bottom-right x */
+ s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+ s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+ s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+ s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+ s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+ s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_BR_X].constraint.range = &s->dev->info.br_x_ranges[default_source];
+ scalar = s->dev->info.x_default;
+ clip_value (&s->opt[OPT_BR_X], &scalar);
+ s->val[OPT_BR_X].w = scalar;
+
+ /* bottom-right y */
+ s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+ s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+ s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_BR_Y].constraint.range = &s->dev->info.br_y_ranges[default_source];
+ /* The FSU for JX250 allows a maximum scan length of 11.5 inch,
+ which is less than the default value of 297 mm
+ */
+ scalar = s->dev->info.y_default;
+ clip_value (&s->opt[OPT_BR_X], &scalar);
+ s->val[OPT_BR_Y].w = scalar;
+
+ /* "Enhancement" group: */
+ s->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
+ s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
+ s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
+ s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* edge emphasis */
+#if 0
+ s->opt[OPT_EDGE_EMPHASIS].name = "Edge emphasis";
+ s->opt[OPT_EDGE_EMPHASIS].title = "Edge emphasis";
+ s->opt[OPT_EDGE_EMPHASIS].desc = "Edge emphasis";
+ s->opt[OPT_EDGE_EMPHASIS].type = SANE_TYPE_STRING;
+ s->opt[OPT_EDGE_EMPHASIS].size = max_string_size (edge_emphasis_list);
+ s->opt[OPT_EDGE_EMPHASIS].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_EDGE_EMPHASIS].constraint.string_list = edge_emphasis_list;
+ s->val[OPT_EDGE_EMPHASIS].s = strdup (edge_emphasis_list[0]);
+#endif
+ init_string_option(s, "Edge emphasis", "Edge emphasis",
+ "Edge emphasis", edge_emphasis_list,
+ OPT_EDGE_EMPHASIS, 0);
+
+ if ( s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350
+ || s->dev->sensedat.model == JX320)
+ s->opt[OPT_EDGE_EMPHASIS].cap |= SANE_CAP_INACTIVE;
+
+ /* threshold */
+ s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
+ s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
+ s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
+ s->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
+ s->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
+ s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_THRESHOLD].constraint.range = &s->dev->info.threshold_range;
+ s->val[OPT_THRESHOLD].w = 128;
+ s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+
+#ifdef USE_COLOR_THRESHOLD
+ s->opt[OPT_THRESHOLD_R].name = SANE_NAME_THRESHOLD "-red";
+ /* xxx the titles and decriptions are confusing:
+ "set white point (red)"
+ Any idea? maybe "threshold to get the red component on"
+ */
+ s->opt[OPT_THRESHOLD_R].title = SANE_TITLE_THRESHOLD " (red)";
+ s->opt[OPT_THRESHOLD_R].desc = SANE_DESC_THRESHOLD " (red)";
+ s->opt[OPT_THRESHOLD_R].type = SANE_TYPE_INT;
+ s->opt[OPT_THRESHOLD_R].unit = SANE_UNIT_NONE;
+ s->opt[OPT_THRESHOLD_R].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_THRESHOLD_R].constraint.range = &s->dev->info.threshold_range;
+ s->val[OPT_THRESHOLD_R].w = 128;
+ s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
+
+ s->opt[OPT_THRESHOLD_G].name = SANE_NAME_THRESHOLD "-green";
+ s->opt[OPT_THRESHOLD_G].title = SANE_TITLE_THRESHOLD " (green)";
+ s->opt[OPT_THRESHOLD_G].desc = SANE_DESC_THRESHOLD " (green)";
+ s->opt[OPT_THRESHOLD_G].type = SANE_TYPE_INT;
+ s->opt[OPT_THRESHOLD_G].unit = SANE_UNIT_NONE;
+ s->opt[OPT_THRESHOLD_G].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_THRESHOLD_G].constraint.range = &s->dev->info.threshold_range;
+ s->val[OPT_THRESHOLD_G].w = 128;
+ s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
+
+ s->opt[OPT_THRESHOLD_B].name = SANE_NAME_THRESHOLD "-blue";
+ s->opt[OPT_THRESHOLD_B].title = SANE_TITLE_THRESHOLD " (blue)";
+ s->opt[OPT_THRESHOLD_B].desc = SANE_DESC_THRESHOLD " (blue)";
+ s->opt[OPT_THRESHOLD_B].type = SANE_TYPE_INT;
+ s->opt[OPT_THRESHOLD_B].unit = SANE_UNIT_NONE;
+ s->opt[OPT_THRESHOLD_B].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_THRESHOLD_B].constraint.range = &s->dev->info.threshold_range;
+ s->val[OPT_THRESHOLD_B].w = 128;
+ s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
+
+#endif
+
+ /* light color (for gray scale and line art scans) */
+#if 0
+ s->opt[OPT_LIGHTCOLOR].name = "LightColor";
+ s->opt[OPT_LIGHTCOLOR].title = "Light Color";
+ s->opt[OPT_LIGHTCOLOR].desc = "Light Color";
+ s->opt[OPT_LIGHTCOLOR].type = SANE_TYPE_STRING;
+ s->opt[OPT_LIGHTCOLOR].size = max_string_size (light_color_list);
+ s->opt[OPT_LIGHTCOLOR].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_LIGHTCOLOR].constraint.string_list = light_color_list;
+ s->val[OPT_LIGHTCOLOR].s = strdup (light_color_list[3]);
+ s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
+#endif
+ init_string_option(s, "LightColor", "LightColor", "LightColor",
+ light_color_list, OPT_LIGHTCOLOR, 3);
+ s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
+
+ s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
+ s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+ s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
+ s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
+ s->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+ s->val[OPT_PREVIEW].w = SANE_FALSE;
+
+
+#ifdef USE_CUSTOM_GAMMA
+ /* custom-gamma table */
+ s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
+ s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
+ s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
+ s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
+ s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
+
+ /* grayscale gamma vector */
+ s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
+ s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
+ s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
+ s->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
+#if 0
+ s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+#endif
+ s->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA_VECTOR].size = 256 * sizeof (SANE_Word);
+ s->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA_VECTOR].constraint.range = &u8_range;
+ s->val[OPT_GAMMA_VECTOR].wa = &s->gamma_table[0][0];
+
+ /* red gamma vector */
+ s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
+ s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
+ s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
+ s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
+#if 0
+ s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+#endif
+ s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof (SANE_Word);
+ s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
+ s->val[OPT_GAMMA_VECTOR_R].wa = &s->gamma_table[1][0];
+
+ /* green gamma vector */
+ s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
+ s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
+ s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
+ s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
+#if 0
+ s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+#endif
+ s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof (SANE_Word);
+ s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
+ s->val[OPT_GAMMA_VECTOR_G].wa = &s->gamma_table[2][0];
+
+ /* blue gamma vector */
+ s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
+ s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
+ s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
+ s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
+#if 0
+ s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+#endif
+ s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof (SANE_Word);
+ s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
+ s->val[OPT_GAMMA_VECTOR_B].wa = &s->gamma_table[3][0];
+ set_gamma_caps(s);
+#endif
+
+ DBG (10, ">>\n");
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+do_cancel (SHARP_Scanner * s)
+{
+ static u_char cmd[] = {READ, 0, 0, 0, 0, 2, 0, 0, 0, 0};
+
+ DBG (10, "<< do_cancel ");
+
+#ifdef USE_FORK
+ if (s->reader_pid > 0)
+ {
+ int exit_status;
+ int count = 0;
+ /* ensure child knows it's time to stop: */
+
+ DBG(11, "stopping reader process\n");
+ s->rdr_ctl->cancel = 1;
+ while(reader_running(s) && count < 100)
+ {
+ usleep(100000);
+ count++;
+ };
+ if (reader_running(s))
+ {
+ /* be brutal...
+ !! The waiting time of 10 seconds might be far too short
+ !! if the resolution limit of the JX 250 is increased to
+ !! to more than 400 dpi: for these (interpolated) resolutions,
+ !! the JX 250 is awfully slow.
+ */
+ kill(s->reader_pid, SIGKILL);
+ }
+ wait(&exit_status);
+ DBG(11, "reader process stopped\n");
+
+ s->reader_pid = 0;
+ }
+
+#endif
+ if (s->scanning == SANE_TRUE)
+ {
+ wait_ready(s->fd);
+ sanei_scsi_cmd (s->fd, cmd, sizeof (cmd), 0, 0);
+ /* if (s->adf_scan) */
+ if ( s->dev->sensedat.model != JX610
+ && s->dev->sensedat.model != JX320)
+ object_position(s->fd, UNLOAD_PAPER);
+ }
+
+ s->scanning = SANE_FALSE;
+
+ if (s->fd >= 0)
+ {
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ }
+#ifdef USE_FORK
+ {
+ struct shmid_ds ds;
+ if (s->shmid != -1)
+ shmctl(s->shmid, IPC_RMID, &ds);
+ s->shmid = -1;
+ }
+#endif
+ if (s->buffer)
+ free(s->buffer);
+ s->buffer = 0;
+
+ DBG (10, ">>\n");
+ return (SANE_STATUS_CANCELLED);
+}
+
+static SHARP_New_Device *new_devs = 0;
+static SHARP_New_Device *new_dev_pool = 0;
+
+static SANE_Status
+attach_and_list(const char *devnam)
+{
+ SANE_Status res;
+ SHARP_Device *devp;
+ SHARP_New_Device *np;
+
+ res = attach(devnam, &devp);
+ if (res == SANE_STATUS_GOOD)
+ {
+ if (new_dev_pool)
+ {
+ np = new_dev_pool;
+ new_dev_pool = np->next;
+ }
+ else
+ {
+ np = malloc(sizeof(SHARP_New_Device));
+ if (np == 0)
+ return SANE_STATUS_NO_MEM;
+ }
+ np->next =new_devs;
+ np->dev = devp;
+ new_devs = np;
+ }
+ return res;
+}
+
+static int buffers[2] = {DEFAULT_BUFFERS, DEFAULT_BUFFERS};
+static int bufsize[2] = {DEFAULT_BUFSIZE, DEFAULT_BUFSIZE};
+static int queued_reads[2] = {DEFAULT_QUEUED_READS, DEFAULT_QUEUED_READS};
+static int stop_on_fsu_error[2] = {COMPLAIN_ON_FSU_ERROR | COMPLAIN_ON_ADF_ERROR,
+ COMPLAIN_ON_FSU_ERROR | COMPLAIN_ON_ADF_ERROR};
+static int default_scan_mode[2] = {-1, -1};
+
+SANE_Status
+sane_init (SANE_Int * version_code,
+ SANE_Auth_Callback __sane_unused__ authorize)
+{
+ char devnam[PATH_MAX] = "/dev/scanner";
+ char line[PATH_MAX];
+ const char *lp;
+ char *word;
+ char *end;
+ FILE *fp;
+ int opt_index = 0;
+ int linecount = 0;
+#if 1
+ SHARP_Device sd;
+ SHARP_Device *dp = &sd;
+#else
+ SHARP_Device *dp;
+#endif
+ SHARP_New_Device *np;
+ int i;
+
+ DBG_INIT ();
+ DBG (10, "<< sane_init ");
+
+#if defined PACKAGE && defined VERSION
+ DBG (2, "sane_init: " PACKAGE " " VERSION "\n");
+#endif
+
+ if (version_code)
+ *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+
+ fp = sanei_config_open (SHARP_CONFIG_FILE);
+ if (!fp)
+ {
+ /* use "/dev/scanner" as the default device name if no
+ config file is available
+ */
+ attach (devnam, &dp);
+ /* make sure that there are at least two buffers */
+ if (DEFAULT_BUFFERS < 2)
+ dp->info.buffers = DEFAULT_BUFFERS;
+ else
+ dp->info.buffers = 2;
+ dp->info.wanted_bufsize = DEFAULT_BUFSIZE;
+ dp->info.queued_reads = DEFAULT_QUEUED_READS;
+ dp->info.complain_on_errors = COMPLAIN_ON_ADF_ERROR | COMPLAIN_ON_FSU_ERROR;
+ dp->info.default_scan_mode = -1;
+ return SANE_STATUS_GOOD;
+ }
+
+ while (fgets(line, PATH_MAX, fp))
+ {
+ linecount++;
+ word = 0;
+ lp = sanei_config_get_string(line, &word);
+ if (word)
+ {
+ if (word[0] != '#')
+ {
+ if (strcmp(word, "option") == 0)
+ {
+ free(word);
+ word = 0;
+ lp = sanei_config_get_string(lp, &word);
+ if (strcmp(word, "buffers") == 0)
+ {
+ free(word);
+ word = 0;
+ sanei_config_get_string(lp, &word);
+ i = strtol(word, &end, 0);
+ if (end == word)
+ {
+ DBG(1, "error in config file, line %i: number expected:\n",
+ linecount);
+ DBG(1, "%s\n", line);
+ }
+ else
+ if (i > 2)
+ buffers[opt_index] = i;
+ else
+ buffers[opt_index] = 2;
+ }
+ else if (strcmp(word, "buffersize") == 0)
+ {
+ free(word);
+ word = 0;
+ sanei_config_get_string(lp, &word);
+ i = strtol(word, &end, 0);
+ if (word == end)
+ {
+ DBG(1, "error in config file, line %i: number expected:\n",
+ linecount);
+ DBG(1, "%s\n", line);
+ }
+ else
+ bufsize[opt_index] = i;
+ }
+ else if (strcmp(word, "readqueue") == 0)
+ {
+ free(word);
+ word = 0;
+ sanei_config_get_string(lp, &word);
+ i = strtol(word, &end, 0);
+ if (word == end)
+ {
+ DBG(1, "error in config file, line %i: number expected:\n",
+ linecount);
+ DBG(1, "%s\n", line);
+ }
+ else
+ queued_reads[opt_index] = i;
+ }
+ else if (strcmp(word, "stop_on_fsu_error") == 0)
+ {
+ free(word);
+ word = 0;
+ sanei_config_get_string(lp, &word);
+ i = strtol(word, &end, 0);
+ if (word == end)
+ {
+ DBG(1, "error in config file, line %i: number expected:\n",
+ linecount);
+ DBG(1, "%s\n", line);
+ }
+ else
+ stop_on_fsu_error[opt_index]
+ = i ? COMPLAIN_ON_FSU_ERROR : 0;
+ }
+ else if (strcmp(word, "default_scan_source") == 0)
+ {
+ free(word);
+ word = 0;
+ sanei_config_get_string(lp, &word);
+ if (strcmp(word, "auto") == 0)
+ default_scan_mode[opt_index] = -1;
+ else if (strcmp(word, "fsu") == 0)
+ default_scan_mode[opt_index] = SCAN_WITH_FSU;
+ else if (strcmp(word, "adf") == 0)
+ default_scan_mode[opt_index] = SCAN_WITH_ADF;
+ else if (strcmp(word, "flatbed") == 0)
+ default_scan_mode[opt_index] = SCAN_SIMPLE;
+ else
+ {
+ DBG(1, "error in config file, line %i: number expected:\n",
+ linecount);
+ DBG(1, "%s\n", line);
+ }
+ }
+ else
+ {
+ DBG(1, "error in config file, line %i: unknown option\n",
+ linecount);
+ DBG(1, "%s\n", line);
+ }
+ }
+ else
+ {
+ while (new_devs)
+ {
+ if (buffers[1] >= 2)
+ new_devs->dev->info.buffers = buffers[1];
+ else
+ new_devs->dev->info.buffers = 2;
+ if (bufsize[1] > 0)
+ new_devs->dev->info.wanted_bufsize = bufsize[1];
+ else
+ new_devs->dev->info.wanted_bufsize = DEFAULT_BUFSIZE;
+ if (queued_reads[1] >= 0)
+ new_devs->dev->info.queued_reads = queued_reads[1];
+ else
+ new_devs->dev->info.queued_reads = 0;
+ new_devs->dev->info.complain_on_errors = stop_on_fsu_error[1];
+ new_devs->dev->info.default_scan_mode = default_scan_mode[1];
+ np = new_devs->next;
+ new_devs->next = new_dev_pool;
+ new_dev_pool = new_devs;
+ new_devs = np;
+ }
+ if (line[strlen(line)-1] == '\n')
+ line[strlen(line)-1] = 0;
+ sanei_config_attach_matching_devices(line, &attach_and_list);
+ buffers[1] = buffers[0];
+ bufsize[1] = bufsize[0];
+ queued_reads[1] = queued_reads[0];
+ stop_on_fsu_error[1] = stop_on_fsu_error[0];
+ default_scan_mode[1] = default_scan_mode[0];
+ opt_index = 1;
+ }
+ }
+ if (word) free(word);
+ }
+ }
+
+ while (new_devs)
+ {
+ if (buffers[1] >= 2)
+ new_devs->dev->info.buffers = buffers[1];
+ else
+ new_devs->dev->info.buffers = 2;
+ if (bufsize[1] > 0)
+ new_devs->dev->info.wanted_bufsize = bufsize[1];
+ else
+ new_devs->dev->info.wanted_bufsize = DEFAULT_BUFSIZE;
+ if (queued_reads[1] >= 0)
+ new_devs->dev->info.queued_reads = queued_reads[1];
+ else
+ new_devs->dev->info.queued_reads = 0;
+ new_devs->dev->info.complain_on_errors = stop_on_fsu_error[1];
+ new_devs->dev->info.default_scan_mode = default_scan_mode[1];
+ if (line[strlen(line)-1] == '\n')
+ line[strlen(line)-1] = 0;
+ np = new_devs->next;
+ free(new_devs);
+ new_devs = np;
+ }
+ while (new_dev_pool)
+ {
+ np = new_dev_pool->next;
+ free(new_dev_pool);
+ new_dev_pool = np;
+ }
+ fclose(fp);
+ DBG (10, "sane_init >>\n");
+ return (SANE_STATUS_GOOD);
+}
+
+static const SANE_Device **devlist = 0;
+void
+sane_exit (void)
+{
+ SHARP_Device *dev, *next;
+ DBG (10, "<< sane_exit ");
+
+ for (dev = first_dev; dev; dev = next)
+ {
+ next = dev->next;
+ free ((void *) dev->sane.name);
+ free ((void *) dev->sane.model);
+ free (dev);
+ }
+
+ if (devlist)
+ free(devlist);
+ devlist = 0;
+ first_dev = 0;
+
+ DBG (10, ">>\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list,
+ SANE_Bool __sane_unused__ local_only)
+{
+ SHARP_Device *dev;
+ int i;
+ DBG (10, "<< sane_get_devices ");
+
+ if (devlist)
+ free (devlist);
+ devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
+ if (!devlist)
+ return (SANE_STATUS_NO_MEM);
+
+ i = 0;
+ for (dev = first_dev; dev; dev = dev->next)
+ devlist[i++] = &dev->sane;
+ devlist[i++] = 0;
+
+ *device_list = devlist;
+
+ DBG (10, ">>\n");
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devnam, SANE_Handle * handle)
+{
+ SANE_Status status;
+ SHARP_Device *dev;
+ SHARP_Scanner *s;
+#ifdef USE_CUSTOM_GAMMA
+ int i, j;
+#endif
+
+ DBG (10, "<< sane_open ");
+
+ if (devnam[0])
+ {
+ for (dev = first_dev; dev; dev = dev->next)
+ {
+ if (strcmp (dev->sane.name, devnam) == 0)
+ break;
+ }
+
+ if (!dev)
+ {
+ status = attach (devnam, &dev);
+ if (status != SANE_STATUS_GOOD)
+ return (status);
+ dev->info.buffers = buffers[0];
+ dev->info.wanted_bufsize = bufsize[0];
+ dev->info.queued_reads = queued_reads[0];
+ }
+ }
+ else
+ {
+ dev = first_dev;
+ }
+
+ if (!dev)
+ return (SANE_STATUS_INVAL);
+
+ s = malloc (sizeof (*s));
+ if (!s)
+ return SANE_STATUS_NO_MEM;
+ memset (s, 0, sizeof (*s));
+
+ s->fd = -1;
+ s->dev = dev;
+
+ s->buffer = 0;
+#ifdef USE_CUSTOM_GAMMA
+ for (i = 0; i < 4; ++i)
+ for (j = 0; j < 256; ++j)
+ s->gamma_table[i][j] = j;
+#endif
+ status = init_options (s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ /* xxx clean up mallocs */
+ return status;
+ }
+
+ s->next = first_handle;
+ first_handle = s;
+
+ *handle = s;
+
+ DBG (10, ">>\n");
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+ SHARP_Scanner *s = (SHARP_Scanner *) handle;
+ DBG (10, "<< sane_close ");
+
+ if (s->fd != -1)
+ sanei_scsi_close (s->fd);
+#ifdef USE_FORK
+ {
+ struct shmid_ds ds;
+ if (s->shmid != -1)
+ shmctl(s->shmid, IPC_RMID, &ds);
+ }
+#endif
+ if (s->buffer)
+ free(s->buffer);
+ free (s);
+
+ DBG (10, ">>\n");
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+ SHARP_Scanner *s = handle;
+ DBG (10, "<< sane_get_option_descriptor ");
+
+ if ((unsigned) option >= NUM_OPTIONS)
+ return (0);
+
+ DBG (10, ">>\n");
+ return (s->opt + option);
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+ SANE_Action action, void *val, SANE_Int * info)
+{
+ SHARP_Scanner *s = handle;
+ SANE_Status status;
+#ifdef USE_CUSTOM_GAMMA
+ SANE_Word w, cap;
+#else
+ SANE_Word cap;
+#endif
+#ifdef USE_RESOLUTION_LIST
+ int i;
+#endif
+ int range_index;
+ DBG (10, "<< sane_control_option %i", option);
+
+ if (info)
+ *info = 0;
+
+ if (s->scanning)
+ return (SANE_STATUS_DEVICE_BUSY);
+ if (option >= NUM_OPTIONS)
+ return (SANE_STATUS_INVAL);
+
+ cap = s->opt[option].cap;
+ if (!SANE_OPTION_IS_ACTIVE (cap))
+ return (SANE_STATUS_INVAL);
+
+ if (action == SANE_ACTION_GET_VALUE)
+ {
+ switch (option)
+ {
+ /* word options: */
+ case OPT_X_RESOLUTION:
+#ifdef USE_SEPARATE_Y_RESOLUTION
+ case OPT_Y_RESOLUTION:
+#endif
+ case OPT_TL_X:
+ case OPT_TL_Y:
+ case OPT_BR_X:
+ case OPT_BR_Y:
+ case OPT_NUM_OPTS:
+ case OPT_THRESHOLD:
+#ifdef USE_COLOR_THRESHOLD
+ case OPT_THRESHOLD_R:
+ case OPT_THRESHOLD_G:
+ case OPT_THRESHOLD_B:
+#endif
+ case OPT_SPEED:
+ case OPT_PREVIEW:
+#ifdef USE_CUSTOM_GAMMA
+ case OPT_CUSTOM_GAMMA:
+#endif
+ *(SANE_Word *) val = s->val[option].w;
+#if 0 /* here, values are read; reload should not be necessary */
+ if (info)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+#endif
+ return (SANE_STATUS_GOOD);
+
+#ifdef USE_CUSTOM_GAMMA
+ /* word-array options: */
+ case OPT_GAMMA_VECTOR:
+ case OPT_GAMMA_VECTOR_R:
+ case OPT_GAMMA_VECTOR_G:
+ case OPT_GAMMA_VECTOR_B:
+ memcpy (val, s->val[option].wa, s->opt[option].size);
+ return SANE_STATUS_GOOD;
+#endif
+
+ /* string options: */
+ case OPT_MODE:
+ case OPT_HALFTONE:
+ case OPT_PAPER:
+ case OPT_GAMMA:
+#ifdef USE_RESOLUTION_LIST
+ case OPT_RESOLUTION_LIST:
+#endif
+ case OPT_EDGE_EMPHASIS:
+ case OPT_LIGHTCOLOR:
+ case OPT_SCANSOURCE:
+ strcpy (val, s->val[option].s);
+#if 0
+ if (info)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+#endif
+
+ return (SANE_STATUS_GOOD);
+
+ }
+ }
+ else if (action == SANE_ACTION_SET_VALUE)
+ {
+ if (!SANE_OPTION_IS_SETTABLE (cap))
+ return (SANE_STATUS_INVAL);
+
+ status = sanei_constrain_value (s->opt + option, val, info);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ switch (option)
+ {
+ /* (mostly) side-effect-free word options: */
+ case OPT_X_RESOLUTION:
+#ifdef USE_SEPARATE_Y_RESOLUTION
+ case OPT_Y_RESOLUTION:
+#endif
+ case OPT_TL_X:
+ case OPT_TL_Y:
+ case OPT_BR_X:
+ case OPT_BR_Y:
+ if (info && s->val[option].w != *(SANE_Word *) val)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+ case OPT_NUM_OPTS:
+ case OPT_THRESHOLD:
+ /* xxx theoretically, we could use OPT_THRESHOLD in
+ bi-level color mode to adjust all three other
+ threshold together. But this would require to set
+ the bit SANE_INFO_RELOAD_OPTIONS in *info, and that
+ would unfortunately cause a crash in both xscanimage
+ and xsane... Therefore, OPT_THRESHOLD is disabled
+ for bi-level color scan right now.
+ */
+#ifdef USE_COLOR_THRESHOLD
+ case OPT_THRESHOLD_R:
+ case OPT_THRESHOLD_G:
+ case OPT_THRESHOLD_B:
+#endif
+ case OPT_SPEED:
+ case OPT_PREVIEW:
+ s->val[option].w = *(SANE_Word *) val;
+ return (SANE_STATUS_GOOD);
+
+
+ case OPT_MODE:
+ if (strcmp (val, M_LINEART) == 0)
+ {
+ s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
+#ifdef USE_COLOR_THRESHOLD
+ s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
+#endif
+ if (s->dev->sensedat.model == JX330)
+ s->opt[OPT_HALFTONE].cap &= ~SANE_CAP_INACTIVE;
+ }
+ else if (strcmp (val, M_LINEART_COLOR) == 0)
+ {
+ s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+#ifdef USE_COLOR_THRESHOLD
+ s->opt[OPT_THRESHOLD_R].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_THRESHOLD_G].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_THRESHOLD_B].cap &= ~SANE_CAP_INACTIVE;
+#endif
+ if (s->dev->sensedat.model == JX330)
+ s->opt[OPT_HALFTONE].cap &= ~SANE_CAP_INACTIVE;
+ }
+ else
+ {
+ s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+#ifdef USE_COLOR_THRESHOLD
+ s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
+#endif
+ s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
+ }
+
+ if ( strcmp (val, M_LINEART) == 0
+ || strcmp (val, M_GRAY) == 0)
+ {
+ s->opt[OPT_LIGHTCOLOR].cap &= ~SANE_CAP_INACTIVE;
+ }
+ else
+ {
+ s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
+ }
+
+ strcpy(s->val[option].s, val);
+#ifdef USE_CUSTOM_GAMMA
+ set_gamma_caps(s);
+#endif
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+ return (SANE_STATUS_GOOD);
+
+ case OPT_GAMMA:
+ case OPT_HALFTONE:
+ case OPT_EDGE_EMPHASIS:
+ case OPT_LIGHTCOLOR:
+#if 0
+ if (s->val[option].s)
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+#endif
+ strcpy(s->val[option].s, val);
+ return (SANE_STATUS_GOOD);
+
+ case OPT_SCANSOURCE:
+ if (info && strcmp (s->val[option].s, (SANE_String) val))
+ *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+#if 0
+ if (s->val[option].s)
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+#endif
+ strcpy(s->val[option].s, val);
+ if (strcmp(val, use_fsu) == 0)
+ range_index = SCAN_WITH_FSU;
+ else if (strcmp(val, use_adf) == 0)
+ range_index = SCAN_WITH_ADF;
+ else
+ range_index = SCAN_SIMPLE;
+
+ s->opt[OPT_TL_X].constraint.range
+ = &s->dev->info.tl_x_ranges[range_index];
+ clip_value (&s->opt[OPT_TL_X], &s->val[OPT_TL_X].w);
+
+ s->opt[OPT_TL_Y].constraint.range
+ = &s->dev->info.tl_y_ranges[range_index];
+ clip_value (&s->opt[OPT_TL_Y], &s->val[OPT_TL_Y].w);
+
+ s->opt[OPT_BR_X].constraint.range
+ = &s->dev->info.br_x_ranges[range_index];
+ clip_value (&s->opt[OPT_BR_X], &s->val[OPT_BR_X].w);
+
+ s->opt[OPT_BR_Y].constraint.range
+ = &s->dev->info.br_y_ranges[range_index];
+ clip_value (&s->opt[OPT_BR_Y], &s->val[OPT_BR_Y].w);
+
+ return (SANE_STATUS_GOOD);
+
+ case OPT_PAPER:
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+#if 0
+ if (s->val[option].s)
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+#endif
+ strcpy(s->val[option].s, val);
+ s->val[OPT_TL_X].w = SANE_FIX(0);
+ s->val[OPT_TL_Y].w = SANE_FIX(0);
+ if (strcmp (s->val[option].s, "A3") == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(297);
+ s->val[OPT_BR_Y].w = SANE_FIX(420);
+ }else if (strcmp (s->val[option].s, "A4") == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(210);
+ s->val[OPT_BR_Y].w = SANE_FIX(297);
+ }else if (strcmp (s->val[option].s, "A5") == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(148.5);
+ s->val[OPT_BR_Y].w = SANE_FIX(210);
+ }else if (strcmp (s->val[option].s, "A6") == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(105);
+ s->val[OPT_BR_Y].w = SANE_FIX(148.5);
+ }else if (strcmp (s->val[option].s, "B4") == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(250);
+ s->val[OPT_BR_Y].w = SANE_FIX(353);
+ }else if (strcmp (s->val[option].s, "B5") == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(182);
+ s->val[OPT_BR_Y].w = SANE_FIX(257);
+ }else if (strcmp (s->val[option].s, W_LETTER) == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(279.4);
+ s->val[OPT_BR_Y].w = SANE_FIX(431.8);
+ }else if (strcmp (s->val[option].s, "Legal") == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(215.9);
+ s->val[OPT_BR_Y].w = SANE_FIX(355.6);
+ }else if (strcmp (s->val[option].s, "Letter") == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(215.9);
+ s->val[OPT_BR_Y].w = SANE_FIX(279.4);
+ }else if (strcmp (s->val[option].s, INVOICE) == 0){
+ s->val[OPT_BR_X].w = SANE_FIX(215.9);
+ s->val[OPT_BR_Y].w = SANE_FIX(139.7);
+ }else{
+ }
+ return (SANE_STATUS_GOOD);
+
+#ifdef USE_RESOLUTION_LIST
+ case OPT_RESOLUTION_LIST:
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+ for (i = 0; s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]; i++) {
+ if (strcmp (val,
+ s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]) == 0){
+ s->val[OPT_X_RESOLUTION].w
+ = atoi(s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]);
+ s->val[OPT_Y_RESOLUTION].w
+ = atoi(s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]);
+ if (info)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+ break;
+ }
+ }
+ return (SANE_STATUS_GOOD);
+#endif
+#ifdef USE_CUSTOM_GAMMA
+ /* side-effect-free word-array options: */
+ case OPT_GAMMA_VECTOR:
+ case OPT_GAMMA_VECTOR_R:
+ case OPT_GAMMA_VECTOR_G:
+ case OPT_GAMMA_VECTOR_B:
+ memcpy (s->val[option].wa, val, s->opt[option].size);
+ return SANE_STATUS_GOOD;
+
+ case OPT_CUSTOM_GAMMA:
+ w = *(SANE_Word *) val;
+
+ if (w == s->val[OPT_CUSTOM_GAMMA].w)
+ return SANE_STATUS_GOOD; /* no change */
+
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+ s->val[OPT_CUSTOM_GAMMA].w = w;
+ set_gamma_caps(s);
+ return SANE_STATUS_GOOD;
+#endif
+ }
+ }
+
+ DBG (10, ">>\n");
+ return (SANE_STATUS_INVAL);
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+ int width, length, xres, yres;
+ const char *mode;
+ SHARP_Scanner *s = handle;
+ DBG (10, "<< sane_get_parameters ");
+
+ xres = s->val[OPT_X_RESOLUTION].w;
+#ifdef USE_SEPARATE_Y_RESOLUTION
+ yres = s->val[OPT_Y_RESOLUTION].w;
+#else
+ yres = xres;
+#endif
+ if (!s->scanning)
+ {
+ /* make best-effort guess at what parameters will look like once
+ scanning starts. */
+ memset (&s->params, 0, sizeof (s->params));
+
+ width = MM_TO_PIX( SANE_UNFIX(s->val[OPT_BR_X].w)
+ - SANE_UNFIX(s->val[OPT_TL_X].w),
+ s->dev->info.mud);
+ length = MM_TO_PIX( SANE_UNFIX(s->val[OPT_BR_Y].w)
+ - SANE_UNFIX(s->val[OPT_TL_Y].w),
+ s->dev->info.mud);
+
+ s->width = width;
+ s->length = length;
+ s->params.pixels_per_line = width * xres / s->dev->info.mud;
+ s->params.lines = length * yres / s->dev->info.mud;
+ s->unscanned_lines = s->params.lines;
+ }
+ else
+ {
+ static u_char cmd[] = {READ, 0, 0x81, 0, 0, 0, 0, 0, 4, 0};
+ static u_char buf[4];
+ size_t len = 4;
+ SANE_Status status;
+
+ /* if async reads are used, )ie. if USE_FORK is defined,
+ this command may only be issued immediately after the
+ "start scan" command. Later calls will confuse the
+ read queue.
+ */
+ if (!s->get_params_called)
+ {
+ wait_ready(s->fd);
+ status = sanei_scsi_cmd (s->fd, cmd, sizeof (cmd), buf, &len);
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ do_cancel(s);
+ return (status);
+ }
+ s->params.pixels_per_line = (buf[1] << 8) + buf[0];
+ s->params.lines = (buf[3] << 8) + buf[2];
+ s->get_params_called = 1;
+ }
+ }
+
+ xres = s->val[OPT_X_RESOLUTION].w;
+#ifdef USE_SEPARATE_Y_RESOLUTION
+ yres = s->val[OPT_Y_RESOLUTION].w;
+#else
+ yres = xres;
+#endif
+
+ mode = s->val[OPT_MODE].s;
+
+ if (strcmp (mode, M_LINEART) == 0)
+ {
+ s->params.format = SANE_FRAME_GRAY;
+ s->params.bytes_per_line = (s->params.pixels_per_line + 7) / 8;
+ s->params.depth = 1;
+ s->modes = MODES_LINEART;
+ }
+ else if (strcmp (mode, M_GRAY) == 0)
+ {
+ s->params.format = SANE_FRAME_GRAY;
+ s->params.bytes_per_line = s->params.pixels_per_line;
+ s->params.depth = 8;
+ s->modes = MODES_GRAY;
+ }
+ else
+ {
+ s->params.format = SANE_FRAME_RGB;
+ s->params.bytes_per_line = 3 * s->params.pixels_per_line;
+ s->params.depth = 8;
+ s->modes = MODES_COLOR;
+ }
+ s->params.last_frame = SANE_TRUE;
+
+ if (params)
+ *params = s->params;
+
+ DBG (10, ">>\n");
+ return (SANE_STATUS_GOOD);
+}
+
+#ifdef USE_CUSTOM_GAMMA
+
+static int
+sprint_gamma(Option_Value val, SANE_Byte *dst)
+{
+ int i;
+ SANE_Byte *p = dst;
+
+ p += sprintf((char *) p, "%i", val.wa[0] > 255 ? 255 : val.wa[0]);
+ /* val.wa[i] is over 255, so val.wa[i] is limitied to 255 */
+ for (i = 1; i < 256; i++)
+ p += sprintf((char *) p, ",%i", val.wa[i] > 255 ? 255 : val.wa[i]);
+ return p - dst;
+}
+
+static SANE_Status
+send_ascii_gamma_tables (SHARP_Scanner *s)
+{
+ SANE_Status status;
+ int i;
+
+ DBG(11, "<< send_ascii_gamma_tables ");
+
+ /* we need: 4 bytes for each gamma value (3 digits + delimiter)
+ + 10 bytes for the command header
+ i.e. 4 * 4 * 256 + 10 = 4106 bytes
+ */
+
+ if (s->dev->info.bufsize < 4106)
+ return SANE_STATUS_NO_MEM;
+
+ memset(s->buffer, 0, 4106);
+
+ i = sprint_gamma(s->val[OPT_GAMMA_VECTOR_R], &s->buffer[10]);
+ s->buffer[10+i++] = '/';
+ i += sprint_gamma(s->val[OPT_GAMMA_VECTOR_G], &s->buffer[10+i]);
+ s->buffer[10+i++] = '/';
+ i += sprint_gamma(s->val[OPT_GAMMA_VECTOR_B], &s->buffer[10+i]);
+ s->buffer[10+i++] = '/';
+ i += sprint_gamma(s->val[OPT_GAMMA_VECTOR], &s->buffer[10+i]);
+
+ DBG(11, "%s\n", &s->buffer[10]);
+
+ s->buffer[0] = SEND;
+ s->buffer[2] = 0x03;
+ s->buffer[7] = i >> 8;
+ s->buffer[8] = i & 0xff;
+
+ wait_ready(s->fd);
+ status = sanei_scsi_cmd (s->fd, s->buffer, i+10, 0, 0);
+
+ DBG(11, ">>\n");
+
+ return status;
+}
+#endif
+
+static SANE_Status
+send_binary_g_table(SHARP_Scanner *s, SANE_Word *a, int dtq)
+{
+ SANE_Status status;
+ int i;
+
+ DBG(11, "<< send_binary_g_table\n");
+
+ memset(s->buffer, 0, 522);
+
+ s->buffer[0] = SEND;
+ s->buffer[2] = 0x03;
+ s->buffer[5] = dtq;
+ s->buffer[7] = 2;
+ s->buffer[8] = 0;
+
+ for (i = 0; i < 256; i++)
+ {
+ s->buffer[2*i+11] = a[i] > 255 ? 255 : a[i];
+ }
+
+ for (i = 0; i < 256; i += 16)
+ {
+ DBG(11, "%02x %02x %02x %02x %02x %02x %02x %02x "
+ "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+ a[i ], a[i+1], a[i+2], a[i+3],
+ a[i+4], a[i+5], a[i+6], a[i+7],
+ a[i+8], a[i+9], a[i+10], a[i+11],
+ a[i+12], a[i+13], a[i+14], a[i+15]);
+ }
+
+ wait_ready(s->fd);
+ status = sanei_scsi_cmd (s->fd, s->buffer, 2*i+10, 0, 0);
+
+ DBG(11, ">>\n");
+
+ return status;
+}
+
+#ifdef USE_CUSTOM_GAMMA
+static SANE_Status
+send_binary_gamma_tables (SHARP_Scanner *s)
+{
+ SANE_Status status;
+
+ status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR].wa, 0x10);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_R].wa, 0x11);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_G].wa, 0x12);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_B].wa, 0x13);
+
+ return status;
+}
+
+static SANE_Status
+send_gamma_tables (SHARP_Scanner *s)
+{
+ if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
+ {
+ return send_ascii_gamma_tables(s);
+ }
+ else
+ {
+ return send_binary_gamma_tables(s);
+ }
+
+}
+#endif
+
+#ifdef USE_COLOR_THRESHOLD
+static SANE_Status
+send_threshold_data(SHARP_Scanner *s)
+{
+ SANE_Status status;
+ SANE_Byte cmd[26] = {SEND, 0, 0x82, 0, 0, 0, 0, 0, 0, 0};
+ int len;
+
+ memset(cmd, 0, sizeof(cmd));
+ /* maximum string length: 3 bytes for each number (they are
+ restricted to the range 0..255), 3 '/' and the null-byte,
+ total: 16 bytes.
+ */
+ len = sprintf((char *) &cmd[10], "%i/%i/%i/%i",
+ s->val[OPT_THRESHOLD_R].w,
+ s->val[OPT_THRESHOLD_G].w,
+ s->val[OPT_THRESHOLD_B].w,
+ s->val[OPT_THRESHOLD].w);
+ cmd[8] = len;
+
+ wait_ready(s->fd);
+ status = sanei_scsi_cmd(s->fd, cmd, len + 10, 0, 0);
+ return status;
+}
+#endif
+
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+ char *mode, *halftone, *paper, *gamma, *edge, *lightcolor, *adf_fsu;
+ SHARP_Scanner *s = handle;
+ SANE_Status status;
+ size_t buf_size;
+ SHARP_Send ss;
+ window_param wp;
+ mode_sense_subdevice m_subdev;
+
+ DBG (10, "<< sane_start ");
+
+ /* First make sure we have a current parameter set. Some of the
+ parameters will be overwritten below, but that's OK. */
+ status = sane_get_parameters (s, 0);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ s->dev->sensedat.complain_on_errors
+ = COMPLAIN_ON_ADF_ERROR | s->dev->info.complain_on_errors;
+
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+ s->dev->info.bufsize = s->dev->info.wanted_bufsize;
+ if (s->dev->info.bufsize < 32 * 1024)
+ s->dev->info.bufsize = 32 * 1024;
+ {
+ int bsize = s->dev->info.bufsize;
+ status = sanei_scsi_open_extended (s->dev->sane.name, &s->fd,
+ &sense_handler, &s->dev->sensedat, &bsize);
+ s->dev->info.bufsize = bsize;
+ }
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "open of %s failed: %s\n",
+ s->dev->sane.name, sane_strstatus (status));
+ return (status);
+ }
+
+ /* make sure that we got at least 32 kB. Even then, the scan will be
+ awfully slow.
+
+ NOTE: If you need to decrease this value, remember that s->buffer
+ is used in send_ascii_gamma_tables (JX330/JX610) and in
+ send_binary_g_table (JX250/JX350). send_ascii_gamma_tables needs 4106
+ bytes, and send_binary_g_table needs 522 bytes.
+ */
+ if (s->dev->info.bufsize < 32 * 1024)
+ {
+ sanei_scsi_close(s->fd);
+ s->fd = -1;
+ return SANE_STATUS_NO_MEM;
+ }
+#else
+ status = sanei_scsi_open(s->dev->sane.name, &s->fd, &sense_handler,
+ &s->dev->sensedat);
+ if (s->dev->info.wanted_bufsize < sanei_scsi_max_request_size)
+ s->dev->info.bufsize = s->dev->info.wanted_bufsize;
+ else
+ s->dev->info.bufsize = sanei_scsi_max_request_size;
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "open of %s failed: %s\n",
+ s->dev->sane.name, sane_strstatus (status));
+ return (status);
+ }
+#endif
+
+ s->buffer = malloc(s->dev->info.bufsize);
+ if (!s->buffer) {
+ sanei_scsi_close(s->fd);
+ s->fd = -1;
+ free(s);
+ return SANE_STATUS_NO_MEM;
+ }
+
+#ifdef USE_FORK
+ {
+ struct shmid_ds ds;
+ size_t n;
+
+ s->shmid = shmget(IPC_PRIVATE,
+ sizeof(SHARP_rdr_ctl)
+ + s->dev->info.buffers *
+ (sizeof(SHARP_shmem_ctl) + s->dev->info.bufsize),
+ IPC_CREAT | 0600);
+ if (s->shmid == -1)
+ {
+ free(s->buffer);
+ s->buffer = 0;
+ sanei_scsi_close(s->fd);
+ s->fd = -1;
+ return SANE_STATUS_NO_MEM;
+ }
+ s->rdr_ctl = (SHARP_rdr_ctl*) shmat(s->shmid, 0, 0);
+ if (s->rdr_ctl == (void *) -1)
+ {
+ shmctl(s->shmid, IPC_RMID, &ds);
+ free(s->buffer);
+ s->buffer = 0;
+ sanei_scsi_close(s->fd);
+ s->fd = -1;
+ return SANE_STATUS_NO_MEM;
+ }
+
+ s->rdr_ctl->buf_ctl = (SHARP_shmem_ctl*) &s->rdr_ctl[1];
+ for (n = 0; n < s->dev->info.buffers; n++)
+ {
+ s->rdr_ctl->buf_ctl[n].buffer =
+ (SANE_Byte*) &s->rdr_ctl->buf_ctl[s->dev->info.buffers]
+ + n * s->dev->info.bufsize;
+ }
+ }
+#endif /* USE_FORK */
+
+ DBG (5, "start: TEST_UNIT_READY\n");
+ status = test_unit_ready (s->fd);
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "TEST UNIT READY failed: %s\n", sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+
+ DBG (3, "start: sending MODE SELECT\n");
+ status = mode_select_mud (s->fd, s->dev->info.mud);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "start: MODE_SELECT6 failed\n");
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+
+ mode = s->val[OPT_MODE].s;
+ halftone = s->val[OPT_HALFTONE].s;
+ paper = s->val[OPT_PAPER].s;
+ gamma = s->val[OPT_GAMMA].s;
+ edge = s->val[OPT_EDGE_EMPHASIS].s;
+ lightcolor = s->val[OPT_LIGHTCOLOR].s;
+ adf_fsu = s->val[OPT_SCANSOURCE].s;
+ s->speed = s->val[OPT_SPEED].w;
+
+ s->xres = s->val[OPT_X_RESOLUTION].w;
+ if (s->val[OPT_PREVIEW].w == SANE_FALSE)
+ {
+#ifdef USE_SEPARATE_Y_RESOLUTION
+ s->yres = s->val[OPT_Y_RESOLUTION].w;
+#else
+ s->yres = s->val[OPT_X_RESOLUTION].w;
+#endif
+ s->speed = s->val[OPT_SPEED].w;
+ }
+ else
+ {
+ s->yres = s->val[OPT_X_RESOLUTION].w;
+ s->speed = SANE_TRUE;
+ }
+
+ s->ulx = MM_TO_PIX(SANE_UNFIX(s->val[OPT_TL_X].w), s->dev->info.mud);
+ s->uly = MM_TO_PIX(SANE_UNFIX(s->val[OPT_TL_Y].w), s->dev->info.mud);
+ s->threshold = s->val[OPT_THRESHOLD].w;
+ s->bpp = s->params.depth;
+
+ s->adf_fsu_mode = SCAN_SIMPLE; /* default: scan without ADF and FSU */
+#ifdef ALLOW_AUTO_SELECT_ADF
+ if (strcmp (adf_fsu, use_auto) == 0)
+ s->adf_fsu_mode = SCAN_ADF_FSU_AUTO;
+ else
+#endif
+ if (strcmp(adf_fsu, use_fsu) == 0)
+ s->adf_fsu_mode = SCAN_WITH_FSU;
+ else if (strcmp(adf_fsu, use_adf) == 0)
+ s->adf_fsu_mode = SCAN_WITH_ADF;
+ else if (strcmp(adf_fsu, use_adf) == 0)
+ s->adf_fsu_mode = SCAN_SIMPLE;
+
+ if (strcmp (mode, M_LINEART) == 0)
+ {
+ s->reverse = 0;
+ if (strcmp(halftone, M_BILEVEL) == 0)
+ {
+ s->halftone = 1;
+ s->image_composition = 0;
+ }
+ else if (strcmp(halftone, M_BAYER) == 0)
+ {
+ s->halftone = 2;
+ s->image_composition = 1;
+ }
+ else if (strcmp(halftone, M_SPIRAL) == 0)
+ {
+ s->halftone = 3;
+ s->image_composition = 1;
+ }
+ else if (strcmp(halftone, M_DISPERSED) == 0)
+ {
+ s->halftone = 4;
+ s->image_composition = 1;
+ }
+ else if (strcmp(halftone, M_ERRDIFFUSION) == 0)
+ {
+ s->halftone = 5;
+ s->image_composition = 1;
+ }
+ }
+ else if (strcmp (mode, M_GRAY) == 0)
+ {
+ s->image_composition = 2;
+ s->reverse = 1;
+ }
+ else if (strcmp (mode, M_LINEART_COLOR) == 0)
+ {
+ s->reverse = 1;
+ if (strcmp(halftone, M_BILEVEL) == 0)
+ {
+ s->halftone = 1;
+ s->image_composition = 3;
+ }
+ else if (strcmp(halftone, M_BAYER) == 0)
+ {
+ s->halftone = 2;
+ s->image_composition = 4;
+ }
+ else if (strcmp(halftone, M_SPIRAL) == 0)
+ {
+ s->halftone = 3;
+ s->image_composition = 4;
+ }
+ else if (strcmp(halftone, M_DISPERSED) == 0)
+ {
+ s->halftone = 4;
+ s->image_composition = 4;
+ }
+ else if (strcmp(halftone, M_ERRDIFFUSION) == 0)
+ {
+ s->halftone = 5;
+ s->image_composition = 4;
+ }
+ }
+ else if (strcmp (mode, M_COLOR) == 0)
+ {
+ s->image_composition = 5;
+ s->reverse = 1;
+ }
+
+ if (strcmp (edge, EDGE_NONE) == 0)
+ {
+ DBG (11, "EDGE EMPHASIS NONE\n");
+ s->edge = 0;
+ }
+ else if (strcmp (edge, EDGE_MIDDLE) == 0)
+ {
+ DBG (11, "EDGE EMPHASIS MIDDLE\n");
+ s->edge = 1;
+ }
+ else if (strcmp (edge, EDGE_STRONG) == 0)
+ {
+ DBG (11, "EDGE EMPHASIS STRONG\n");
+ s->edge = 2;
+ }
+ else if (strcmp (edge, EDGE_BLUR) == 0)
+ {
+ DBG (11, "EDGE EMPHASIS BLUR\n");
+ s->edge = 3;
+ }
+
+ s->lightcolor = 3;
+ if (strcmp(lightcolor, LIGHT_GREEN) == 0)
+ s->lightcolor = 0;
+ else if (strcmp(lightcolor, LIGHT_RED) == 0)
+ s->lightcolor = 1;
+ else if (strcmp(lightcolor, LIGHT_BLUE) == 0)
+ s->lightcolor = 2;
+ else if (strcmp(lightcolor, LIGHT_WHITE) == 0)
+ s->lightcolor = 3;
+
+ s->adf_scan = 0;
+ if ( s->dev->sensedat.model != JX610
+ && s->dev->sensedat.model != JX320)
+ {
+ status = mode_select_adf_fsu(s->fd, s->adf_fsu_mode);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (10, "sane_start: mode_select_adf_fsu failed: %s\n", sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ /* if the ADF is selected, check if it is ready */
+ memset (&m_subdev, 0, sizeof (m_subdev));
+ buf_size = sizeof (m_subdev);
+ status = mode_sense (s->fd, &m_subdev, &buf_size, 0x20);
+ DBG(11, "mode sense result a_mode: %x f_mode: %x\n",
+ m_subdev.a_mode_type, m_subdev.f_mode_type);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (10, "sane_start: MODE_SENSE/subdevice page failed\n");
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ if (s->adf_fsu_mode == SCAN_WITH_ADF)
+ s->adf_scan = 1;
+#ifdef ALLOW_AUTO_SELECT_ADF
+ else if (s->adf_fsu_mode == SCAN_ADF_FSU_AUTO)
+ {
+ if (m_subdev.a_mode_type & 0x80)
+ s->adf_scan = 1;
+ }
+#endif
+ }
+
+
+#ifdef USE_CUSTOM_GAMMA
+ if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
+ {
+#endif
+ if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
+ {
+ ss.dtc = 0x03;
+ if (strcmp (gamma, GAMMA10) == 0)
+ {
+ ss.dtq = 0x01;
+ }else{
+ ss.dtq = 0x02;
+ }
+ ss.length = 0;
+ DBG (5, "start: SEND\n");
+ status = send (s->fd, &ss);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "send failed: %s\n", sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ }
+ else
+ {
+ /* the JX250 does not support the "fixed gamma selection",
+ therefore, lets calculate & send gamma values
+ */
+ int i;
+ SANE_Word gtbl[256];
+ if (strcmp (gamma, GAMMA10) == 0)
+ for (i = 0; i < 256; i++)
+ gtbl[i] = i;
+ else
+ {
+ gtbl[0] = 0;
+ for (i = 1; i < 256; i++)
+ gtbl[i] = 255 * exp(0.45 * log(i/255.0));
+ }
+ send_binary_g_table(s, gtbl, 0x10);
+ send_binary_g_table(s, gtbl, 0x11);
+ send_binary_g_table(s, gtbl, 0x12);
+ send_binary_g_table(s, gtbl, 0x13);
+ }
+#ifdef USE_CUSTOM_GAMMA
+ }
+ else
+ status = send_gamma_tables(s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+#endif
+
+ if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350)
+ {
+ ss.dtc = 0x86;
+ ss.dtq = 0x05;
+ ss.length = 0;
+ DBG (5, "start: SEND\n");
+ status = send (s->fd, &ss);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "send failed: %s\n", sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+
+#ifdef USE_COLOR_THRESHOLD
+ status = send_threshold_data(s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "send threshold data failed: %s\n", sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+#endif
+ }
+
+ memset (&wp, 0, sizeof (wp));
+ /* every Sharp scanner seems to have a different
+ window descriptor block...
+ */
+ if ( s->dev->sensedat.model == JX610
+ || s->dev->sensedat.model == JX320)
+ {
+ buf_size = sizeof(WDB);
+ }
+ else if (s->dev->sensedat.model == JX330)
+ {
+ buf_size = sizeof (WDB) + sizeof(WDBX330);
+ }
+ else
+ {
+ buf_size = sizeof (WDB) + sizeof(WDBX330) + sizeof(WDBX250);
+ }
+
+ wp.wpdh.wdl[0] = buf_size >> 8;
+ wp.wpdh.wdl[1] = buf_size;
+ wp.wdb.x_res[0] = s->xres >> 8;
+ wp.wdb.x_res[1] = s->xres;
+ wp.wdb.y_res[0] = s->yres >> 8;
+ wp.wdb.y_res[1] = s->yres;
+ wp.wdb.x_ul[0] = s->ulx >> 24;
+ wp.wdb.x_ul[1] = s->ulx >> 16;
+ wp.wdb.x_ul[2] = s->ulx >> 8;
+ wp.wdb.x_ul[3] = s->ulx;
+ wp.wdb.y_ul[0] = s->uly >> 24;
+ wp.wdb.y_ul[1] = s->uly >> 16;
+ wp.wdb.y_ul[2] = s->uly >> 8;
+ wp.wdb.y_ul[3] = s->uly;
+ wp.wdb.width[0] = s->width >> 24;
+ wp.wdb.width[1] = s->width >> 16;
+ wp.wdb.width[2] = s->width >> 8;
+ wp.wdb.width[3] = s->width;
+ wp.wdb.length[0] = s->length >> 24;
+ wp.wdb.length[1] = s->length >> 16;
+ wp.wdb.length[2] = s->length >> 8;
+ wp.wdb.length[3] = s->length;
+ wp.wdb.brightness = 0;
+ wp.wdb.threshold = s->threshold;
+ wp.wdb.image_composition = s->image_composition;
+ if (s->image_composition <= 2 || s->image_composition >= 5)
+ wp.wdb.bpp = s->bpp;
+ else
+ wp.wdb.bpp = 1;
+ wp.wdb.ht_pattern[0] = 0;
+ if ( s->dev->sensedat.model == JX610
+ || s->dev->sensedat.model == JX320)
+ {
+ wp.wdb.ht_pattern[1] = 0;
+ }else{
+ wp.wdb.ht_pattern[1] = s->halftone;
+ }
+ wp.wdb.rif_padding = (s->reverse * 128) + 0;
+ wp.wdb.eletu = (!s->speed << 2) + (s->edge << 6) + (s->lightcolor << 4);
+
+ if (s->dev->sensedat.model == JX250 || s->dev->sensedat.model == JX350)
+ {
+ wp.wdbx250.threshold_red = s->val[OPT_THRESHOLD_R].w;
+ wp.wdbx250.threshold_green = s->val[OPT_THRESHOLD_G].w;
+ wp.wdbx250.threshold_blue = s->val[OPT_THRESHOLD_B].w;
+ }
+
+
+ DBG (5, "wdl=%d\n", (wp.wpdh.wdl[0] << 8) + wp.wpdh.wdl[1]);
+ DBG (5, "xres=%d\n", (wp.wdb.x_res[0] << 8) + wp.wdb.x_res[1]);
+ DBG (5, "yres=%d\n", (wp.wdb.y_res[0] << 8) + wp.wdb.y_res[1]);
+ DBG (5, "ulx=%d\n", (wp.wdb.x_ul[0] << 24) + (wp.wdb.x_ul[1] << 16) +
+ (wp.wdb.x_ul[2] << 8) + wp.wdb.x_ul[3]);
+ DBG (5, "uly=%d\n", (wp.wdb.y_ul[0] << 24) + (wp.wdb.y_ul[1] << 16) +
+ (wp.wdb.y_ul[2] << 8) + wp.wdb.y_ul[3]);
+ DBG (5, "width=%d\n", (wp.wdb.width[0] << 8) + (wp.wdb.width[1] << 16) +
+ (wp.wdb.width[2] << 8) + wp.wdb.width[3]);
+ DBG (5, "length=%d\n", (wp.wdb.length[0] << 16) + (wp.wdb.length[1] << 16) +
+ (wp.wdb.length[2] << 8) + wp.wdb.length[3]);
+
+ DBG (5, "threshold=%d\n", wp.wdb.threshold);
+ DBG (5, "image_composition=%d\n", wp.wdb.image_composition);
+ DBG (5, "bpp=%d\n", wp.wdb.bpp);
+ DBG (5, "rif_padding=%d\n", wp.wdb.rif_padding);
+ DBG (5, "eletu=%d\n", wp.wdb.eletu);
+
+#if 0
+ {
+ unsigned char *p = (unsigned char*) &wp.wdb;
+ int i;
+ DBG(11, "set window:\n");
+ for (i = 0; i < sizeof(wp.wdb) + + sizeof(wp.wdbx330) + sizeof(wp.wdbx250); i += 16)
+ {
+ DBG(1, "%2x %2x %2x %2x %2x %2x %2x %2x - %2x %2x %2x %2x %2x %2x %2x %2x\n",
+ p[i], p[i+1], p[i+2], p[i+3], p[i+4], p[i+5], p[i+6], p[i+7], p[i+8],
+ p[i+9], p[i+10], p[i+11], p[i+12], p[i+13], p[i+14], p[i+15]);
+ }
+ }
+#endif
+
+ buf_size += sizeof(WPDH);
+ DBG (5, "start: SET WINDOW\n");
+ status = set_window (s->fd, &wp, buf_size);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "SET WINDOW failed: %s\n", sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+
+ memset (&wp, 0, buf_size);
+ DBG (5, "start: GET WINDOW\n");
+ status = get_window (s->fd, &wp, &buf_size);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "GET WINDOW failed: %s\n", sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ DBG (5, "xres=%d\n", (wp.wdb.x_res[0] << 8) + wp.wdb.x_res[1]);
+ DBG (5, "yres=%d\n", (wp.wdb.y_res[0] << 8) + wp.wdb.y_res[1]);
+ DBG (5, "ulx=%d\n", (wp.wdb.x_ul[0] << 24) + (wp.wdb.x_ul[1] << 16) +
+ (wp.wdb.x_ul[2] << 8) + wp.wdb.x_ul[3]);
+ DBG (5, "uly=%d\n", (wp.wdb.y_ul[0] << 24) + (wp.wdb.y_ul[1] << 16) +
+ (wp.wdb.y_ul[2] << 8) + wp.wdb.y_ul[3]);
+ DBG (5, "width=%d\n", (wp.wdb.width[0] << 24) + (wp.wdb.width[1] << 16) +
+ (wp.wdb.width[2] << 8) + wp.wdb.width[3]);
+ DBG (5, "length=%d\n", (wp.wdb.length[0] << 24) + (wp.wdb.length[1] << 16) +
+ (wp.wdb.length[2] << 8) + wp.wdb.length[3]);
+
+ if (s->adf_scan)
+ {
+ status = object_position(s->fd, LOAD_PAPER);
+ if (status != SANE_STATUS_GOOD)
+ {
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ s->busy = SANE_FALSE;
+ s->cancel = SANE_FALSE;
+ return (status);
+ }
+ }
+
+ DBG (5, "start: SCAN\n");
+ s->scanning = SANE_TRUE;
+ s->busy = SANE_TRUE;
+ s->cancel = SANE_FALSE;
+ s->get_params_called = 0;
+
+ wait_ready(s->fd);
+ status = scan (s->fd);
+#ifdef DEBUG
+ {
+ struct timeval t;
+ gettimeofday(&t, 0);
+ DBG(2, "rd: scan started %li.%06li\n", t.tv_sec, t.tv_usec);
+ }
+#endif
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "start of scan failed: %s\n", sane_strstatus (status));
+ do_cancel(s);
+ return (status);
+ }
+
+ /* ask the scanner for the scan size */
+ /* wait_ready(s->fd); */
+#ifdef DEBUG
+ {
+ struct timeval t;
+ gettimeofday(&t, 0);
+ DBG(2, "rd: wait_ready ok %li.%06li\n", t.tv_sec, t.tv_usec);
+ }
+#endif
+ sane_get_parameters(s, 0);
+#ifdef DEBUG
+ {
+ struct timeval t;
+ gettimeofday(&t, 0);
+ DBG(2, "rd: get_params ok %li.%06li\n", t.tv_sec, t.tv_usec);
+ }
+#endif
+ if (strcmp (mode, M_LINEART_COLOR) != 0)
+ s->bytes_to_read = s->params.bytes_per_line * s->params.lines;
+ else
+ {
+ s->bytes_to_read = (s->params.pixels_per_line+7) / 8;
+ s->bytes_to_read *= 3 * s->params.lines;
+ }
+
+#ifdef USE_FORK
+ {
+ size_t i;
+ for (i = 0; i < s->dev->info.buffers; i++)
+ s->rdr_ctl->buf_ctl[i].shm_status = SHM_EMPTY;
+ s->read_buff = 0;
+ s->rdr_ctl->cancel = 0;
+ s->rdr_ctl->running = 0;
+ s->rdr_ctl->status = SANE_STATUS_GOOD;
+ }
+ s->reader_pid = fork();
+#ifdef DEBUG
+ {
+ struct timeval t;
+ gettimeofday(&t, 0);
+ DBG(2, "rd: forked %li.%06li %i\n", t.tv_sec, t.tv_usec,
+ s->reader_pid);
+ }
+#endif
+ if (s->reader_pid == 0)
+ {
+ sigset_t ignore_set;
+ struct SIGACTION act;
+
+ sigfillset (&ignore_set);
+ sigdelset (&ignore_set, SIGTERM);
+ sigprocmask (SIG_SETMASK, &ignore_set, 0);
+
+ memset (&act, 0, sizeof (act));
+ sigaction (SIGTERM, &act, 0);
+
+ /* don't use exit() since that would run the atexit() handlers... */
+ _exit (reader_process (s));
+ }
+ else if (s->reader_pid == -1)
+ {
+ s->busy = SANE_FALSE;
+ do_cancel(s);
+ return SANE_STATUS_NO_MEM;
+ }
+
+#endif /* USE_FORK */
+
+
+ DBG (1, "%d pixels per line, %d bytes, %d lines high, total %lu bytes, "
+ "dpi=%d\n", s->params.pixels_per_line, s->params.bytes_per_line,
+ s->params.lines, (u_long) s->bytes_to_read, s->val[OPT_X_RESOLUTION].w);
+
+ s->busy = SANE_FALSE;
+ s->buf_used = 0;
+ s->buf_pos = 0;
+
+ if (s->cancel == SANE_TRUE)
+ {
+ do_cancel(s);
+ DBG (10, ">>\n");
+ return(SANE_STATUS_CANCELLED);
+ }
+
+ DBG (10, ">>\n");
+ return (SANE_STATUS_GOOD);
+
+}
+
+static SANE_Status
+sane_read_direct (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
+ SANE_Int * len)
+{
+ SHARP_Scanner *s = handle;
+ SANE_Status status;
+ size_t nread;
+ DBG (10, "<< sane_read_direct ");
+
+ DBG (20, "remaining: %lu ", (u_long) s->bytes_to_read);
+ *len = 0;
+
+ if (s->bytes_to_read == 0)
+ {
+ do_cancel (s);
+ return (SANE_STATUS_EOF);
+ }
+
+ if (!s->scanning)
+ return (do_cancel (s));
+ nread = max_len;
+ if (nread > s->bytes_to_read)
+ nread = s->bytes_to_read;
+ if (nread > s->dev->info.bufsize)
+ nread = s->dev->info.bufsize;
+#ifdef USE_FORK
+ status = read_data(s, dst_buf, &nread);
+#else
+ wait_ready(s->fd);
+ status = read_data (s, dst_buf, &nread);
+#endif
+ if (status != SANE_STATUS_GOOD)
+ {
+ do_cancel (s);
+ return (SANE_STATUS_IO_ERROR);
+ }
+ *len = nread;
+ s->bytes_to_read -= nread;
+ DBG (20, "remaining: %lu ", (u_long) s->bytes_to_read);
+
+ DBG (10, ">>\n");
+ return (SANE_STATUS_GOOD);
+}
+
+static SANE_Status
+sane_read_shuffled (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
+ SANE_Int * len, int eight_bit_data)
+{
+ SHARP_Scanner *s = handle;
+ SANE_Status status;
+ SANE_Byte *dest, *red, *green, *blue, mask;
+ SANE_Int transfer;
+ size_t nread, ntest, pixel, max_pixel, line, max_line;
+ size_t start_input, bytes_per_line_in;
+ DBG (10, "<< sane_read_shuffled ");
+
+ *len = 0;
+ if (s->bytes_to_read == 0 && s->buf_pos == s->buf_used)
+ {
+ do_cancel (s);
+ DBG (10, ">>\n");
+ return (SANE_STATUS_EOF);
+ }
+
+ if (!s->scanning)
+ {
+ DBG (10, ">>\n");
+ return(do_cancel(s));
+ }
+
+ if (s->buf_pos < s->buf_used)
+ {
+ transfer = s->buf_used - s->buf_pos;
+ if (transfer > max_len)
+ transfer = max_len;
+
+ memcpy(dst_buf, &(s->buffer[s->buf_pos]), transfer);
+ s->buf_pos += transfer;
+ max_len -= transfer;
+ *len = transfer;
+ }
+
+ while (max_len > 0 && s->bytes_to_read > 0)
+ {
+ if (eight_bit_data)
+ {
+ nread = s->dev->info.bufsize / s->params.bytes_per_line - 1;
+ nread *= s->params.bytes_per_line;
+ if (nread > s->bytes_to_read)
+ nread = s->bytes_to_read;
+ max_line = nread / s->params.bytes_per_line;
+ start_input = s->params.bytes_per_line;
+ bytes_per_line_in = s->params.bytes_per_line;
+ }
+ else
+ {
+ bytes_per_line_in = (s->params.pixels_per_line + 7) / 8;
+ bytes_per_line_in *= 3;
+ max_line = s->params.bytes_per_line + bytes_per_line_in;
+ max_line = s->dev->info.bufsize / max_line;
+ nread = max_line * bytes_per_line_in;
+ if (nread > s->bytes_to_read)
+ {
+ nread = s->bytes_to_read;
+ max_line = nread / bytes_per_line_in;
+ }
+ start_input = s->dev->info.bufsize - nread;
+ }
+ ntest = nread;
+
+#ifdef USE_FORK
+ status = read_data (s, &(s->buffer[start_input]), &nread);
+#else
+ wait_ready(s->fd);
+ status = read_data (s, &(s->buffer[start_input]), &nread);
+#endif
+ if (status != SANE_STATUS_GOOD)
+ {
+ do_cancel (s);
+ DBG (10, ">>\n");
+ return (SANE_STATUS_IO_ERROR);
+ }
+
+ if (nread != ntest)
+ {
+ /* if this happens, something is wrong in the input buffer
+ management...
+ */
+ DBG(1, "Warning: could not read an integral number of scan lines\n");
+ DBG(1, " image will be scrambled\n");
+ }
+
+
+ s->buf_used = max_line * s->params.bytes_per_line;
+ s->buf_pos = 0;
+ s->bytes_to_read -= nread;
+ dest = s->buffer;
+ max_pixel = s->params.pixels_per_line;
+
+ if (eight_bit_data)
+ for (line = 1; line <= max_line; line++)
+ {
+ red = &(s->buffer[line * s->params.bytes_per_line]);
+ green = &(red[max_pixel]);
+ blue = &(green[max_pixel]);
+ for (pixel = 0; pixel < max_pixel; pixel++)
+ {
+ *dest++ = *red++;
+ *dest++ = *green++;
+ *dest++ = *blue++;
+ }
+ }
+ else
+ for (line = 0; line < max_line; line++)
+ {
+ red = &(s->buffer[start_input + line * bytes_per_line_in]);
+ green = &(red[(max_pixel+7)/8]);
+ blue = &(green[(max_pixel+7)/8]);
+ mask = 0x80;
+ for (pixel = 0; pixel < max_pixel; pixel++)
+ {
+ *dest++ = (*red & mask) ? 0xff : 0;
+ *dest++ = (*green & mask) ? 0xff : 0;
+ *dest++ = (*blue & mask) ? 0xff : 0;
+ mask = mask >> 1;
+ if (mask == 0)
+ {
+ mask = 0x80;
+ red++;
+ green++;
+ blue++;
+ }
+ }
+ }
+
+ transfer = max_len;
+ if (transfer > s->buf_used)
+ transfer = s->buf_used;
+ memcpy(&(dst_buf[*len]), s->buffer, transfer);
+
+ max_len -= transfer;
+ s->buf_pos += transfer;
+ *len += transfer;
+ }
+
+ if (s->bytes_to_read == 0 && s->buf_pos == s->buf_used)
+ do_cancel (s);
+ DBG (10, ">>\n");
+ return (SANE_STATUS_GOOD);
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
+ SANE_Int * len)
+{
+ SHARP_Scanner *s = handle;
+ SANE_Status status;
+
+ s->busy = SANE_TRUE;
+ if (s->cancel == SANE_TRUE)
+ {
+ do_cancel(s);
+ *len = 0;
+ return (SANE_STATUS_CANCELLED);
+ }
+
+ /* RGB scans with a JX 250 and bi-level color scans
+ must be handled differently: */
+ if (s->image_composition <= 2)
+ status = sane_read_direct(handle, dst_buf, max_len, len);
+ else if (s->image_composition <= 4)
+ status = sane_read_shuffled(handle, dst_buf, max_len, len, 0);
+ else if (s->dev->sensedat.model != JX250 && s->dev->sensedat.model != JX350 )
+ status = sane_read_direct(handle, dst_buf, max_len, len);
+ else
+ status = sane_read_shuffled(handle, dst_buf, max_len, len, 1);
+
+ s->busy = SANE_FALSE;
+ if (s->cancel == SANE_TRUE)
+ {
+ do_cancel(s);
+ return (SANE_STATUS_CANCELLED);
+ }
+
+ return (status);
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+ SHARP_Scanner *s = handle;
+ DBG (10, "<< sane_cancel ");
+
+ s->cancel = SANE_TRUE;
+ if (s->busy == SANE_FALSE)
+ do_cancel(s);
+
+ DBG (10, ">>\n");
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle __sane_unused__ handle,
+ SANE_Bool __sane_unused__ non_blocking)
+{
+ DBG (10, "<< sane_set_io_mode");
+ DBG (10, ">>\n");
+
+ return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle __sane_unused__ handle,
+ SANE_Int __sane_unused__ * fd)
+{
+ DBG (10, "<< sane_get_select_fd");
+ DBG (10, ">>\n");
+
+ return SANE_STATUS_UNSUPPORTED;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-15 11:41:51 +0000