diff options
Diffstat (limited to 'backend/coolscan.c')
| -rw-r--r-- | backend/coolscan.c | 4195 |
1 files changed, 4195 insertions, 0 deletions
diff --git a/backend/coolscan.c b/backend/coolscan.c new file mode 100644 index 0000000..00a12e4 --- /dev/null +++ b/backend/coolscan.c @@ -0,0 +1,4195 @@ +/* ------------------------------------------------------------------------- */ +/* sane - Scanner Access Now Easy. + coolscan.c , version 0.4.4 + + 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 COOLSCAN flatbed scanners. */ + +/* ------------------------------------------------------------------------- */ + + +/* SANE-FLOW-DIAGRAMM + + - sane_init() : initialize backend, attach scanners + . - sane_get_devices() : query list of scanner-devices + . - sane_open() : open a particular scanner-device + . . - sane_set_io_mode : set blocking-mode + . . - sane_get_select_fd : get scanner-fd + . . - sane_get_option_descriptor() : get option informations + . . - sane_control_option() : change option values + . . + . . - sane_start() : start image aquisition + . . - sane_get_parameters() : returns actual scan-parameters + . . - sane_read() : read image-data (from pipe) + . . + . . - sane_cancel() : cancel operation + . - sane_close() : close opened scanner-device + - sane_exit() : terminate use of backend + */ + +#ifdef _AIX +# include "lalloca.h" /* MUST come first for AIX! */ +#endif + +#include "../include/sane/config.h" +#include "lalloca.h" + +#include <errno.h> +#include <math.h> +#include <fcntl.h> +#include <limits.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <sys/types.h> +#include <unistd.h> + +#include "../include/sane/sane.h" +#include "../include/sane/sanei.h" +#include "../include/sane/saneopts.h" +#include "../include/sane/sanei_scsi.h" +#include "../include/sane/sanei_debug.h" +#include "../include/sane/sanei_thread.h" + +#include "../include/sane/sanei_config.h" +#define COOLSCAN_CONFIG_FILE "coolscan.conf" +#include "../include/sane/sanei_backend.h" + +#include "coolscan.h" +#include "coolscan-scsidef.h" + + +#ifndef PATH_MAX +#define PATH_MAX 1024 +#endif + +/* ------------------------------------------------------------------------- */ +static const SANE_Int resolution_list[] = +{ + 25, + 2700, 1350, 900, 675, 540, 450, 385, 337, 300, 270, 245, 225, 207, + 192, 180, 168, 158, 150, 142, 135, 128, 122, 117, 112, 108 +}; + + +#define coolscan_do_scsi_open(dev, fd, handler) sanei_scsi_open(dev, fd, handler) +#define coolscan_do_scsi_close(fd) sanei_scsi_close(fd) + +#define COOLSCAN_MAX_RETRY 25 + + +static SANE_Status sense_handler (int scsi_fd, unsigned char * result, void *arg); +static int coolscan_check_values (Coolscan_t * s); +static int get_internal_info (Coolscan_t *); +static void coolscan_get_inquiry_values (Coolscan_t *); +static void hexdump (int level, char *comment, unsigned char *p, int l); +static int swap_res (Coolscan_t * s); +/* --------------------------- COOLSCAN_DO_SCSI_CMD ----------------------- */ +static int +do_scsi_cmd (int fd, unsigned char *cmd, int cmd_len, unsigned char *out, size_t out_len) +{ + int ret; + size_t ol = out_len; + + hexdump (20, "", cmd, cmd_len); + + ret = sanei_scsi_cmd (fd, cmd, cmd_len, out, &ol); + if ((out_len != 0) && (out_len != ol)) + { + DBG (1, "sanei_scsi_cmd: asked %lu bytes, got %lu\n", + (u_long) out_len, (u_long) ol); + } + if (ret) + { + DBG (1, "sanei_scsi_cmd: returning 0x%08x\n", ret); + } + DBG (10, "sanei_scsi_cmd: returning %lu bytes:\n", (u_long) ol); + if (out != NULL && out_len != 0) + hexdump (15, "", out, (out_len > 0x60) ? 0x60 : out_len); + + return ret; +} + + +static int +request_sense_parse (unsigned char *sensed_data) +{ + int ret, sense, asc, ascq; + sense = get_RS_sense_key (sensed_data); + asc = get_RS_ASC (sensed_data); + ascq = get_RS_ASCQ (sensed_data); + + ret = SANE_STATUS_IO_ERROR; + + switch (sense) + { + case 0x0: + DBG (5, "\t%d/%d/%d: Scanner ready\n", sense, asc, ascq); + return SANE_STATUS_GOOD; + + case 0x1: + if ((0x37 == asc) && (0x00 == ascq)) { + DBG (1, "\t%d/%d/%d: Rounded Parameter\n", sense, asc, ascq); + ret = SANE_STATUS_GOOD; + } + else if ((0x61 == asc) && (0x02 == ascq)) + DBG (1, "\t%d/%d/%d: Out Of Focus\n", sense, asc, ascq); + else + DBG (1, "\tUnknown - Sense=%d, ASC=%d, ASCQ=%d\n", sense, asc, ascq); + break; + + case 0x2: + if ((0x4 == asc) && (0x1 == ascq)) { + DBG (10, "\t%d/%d/%d: Logical unit is in process of becomming ready\n", + sense, asc, ascq); + ret = SANE_STATUS_DEVICE_BUSY; + } + else if ((0x3A == asc) && (0x00 == ascq)) + { + DBG (1, "\t%d/%d/%d: No Diapo inserted\n", sense, asc, ascq); + ret = SANE_STATUS_GOOD; + } + else if ((0x60 == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Lamp Failure\n", sense, asc, ascq); + else + { + DBG (1, "\tUnknown - Sense=%d, ASC=%d, ASCQ=%d\n", sense, asc, ascq); + ret = SANE_STATUS_GOOD; + } + break; + + case 0x3: + if ((0x3b == asc) && (0xe == ascq)) + DBG (1, "\t%d/%d/%d: Medium source element empty\n", sense, asc, ascq); + else if ((0x53 == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Media Load of Eject Failed\n", sense, asc, ascq); + else + DBG (1, "\tUnknown - Sense=%d, ASC=%d, ASCQ=%d\n", sense, asc, ascq); + break; + + case 0x4: + if ((0x15 == asc) && (0x1 == ascq)) + DBG (1, "\t%d/%d/%d: Mechanical Positioning Error\n", sense, asc, ascq); + else + DBG (1, "\tUnknown - Sense=%d, ASC=%d, ASCQ=%d\n", sense, asc, ascq); + break; + + case 0x5: + if ((0x00 == asc) && (0x5 == ascq)) + DBG (1, "\t%d/%d/%d: End-Of-Data Detected\n", sense, asc, ascq); + else if ((0x1a == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Parameter List Length Error\n", sense, asc, ascq); + else if ((0x20 == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Invalid Command Operation Code\n", sense, asc, ascq); + else if ((0x24 == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Invalid Field In CDB\n", sense, asc, ascq); + else if ((0x25 == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Logical Unit Not Supported\n", sense, asc, ascq); + else if ((0x26 == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Invalid Field in Parameter List\n", sense, asc, ascq); + else if ((0x2c == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Command Sequence Error\n", sense, asc, ascq); + else if ((0x39 == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Saving Parameters Not Supported\n", sense, asc, ascq); + else if ((0x3d == asc) && (0x00 == ascq)) + DBG (1, "\t%d/%d/%d: Invalid Bits In Identify Message\n", sense, asc, ascq); + else + DBG (1, "\tUnknown - Sense=%d, ASC=%d, ASCQ=%d\n", sense, asc, ascq); + break; + + case 0x6: + if ((0x29 == asc) && (0x0 == ascq)) + DBG (1, "\t%d/%d/%d: Power On, Reset, or Bus Device Reset Occured\n", sense, asc, ascq); + else if ((0x2a == asc) && (0x1 == ascq)) + DBG (1, "\t%d/%d/%d: Mode Parameters Changed\n", sense, asc, ascq); + else + DBG (1, "\tUnknown - Sense=%d, ASC=%d, ASCQ=%d\n", sense, asc, ascq); + break; + + case 0xb: + if ((0x43 == asc) && (0x0 == ascq)) + DBG (1, "\t%d/%d/%d: Message Error\n", sense, asc, ascq); + else if ((0x47 == asc) && (0x0 == ascq)) + DBG (1, "\t%d/%d/%d: SCSI Parity Error\n", sense, asc, ascq); + else if ((0x48 == asc) && (0x0 == ascq)) + DBG (1, "\t%d/%d/%d: Initiator Detected Error Message Received\n", sense, asc, ascq); + else if ((0x49 == asc) && (0x0 == ascq)) + DBG (1, "\t%d/%d/%d: Invalid Message Error\n", sense, asc, ascq); + else if ((0x4e == asc) && (0x0 == ascq)) + DBG (1, "\t%d/%d/%d: Overlapped Commands Attempted\n", sense, asc, ascq); + else + DBG (1, "\tUnknown - Sense=%d, ASC=%d, ASCQ=%d\n", sense, asc, ascq); + break; + + default: + DBG (1, "\tUnknown - Sense=%d, ASC=%d, ASCQ=%d\n", sense, asc, ascq); + break; + } /* switch */ + return ret; +} + +/* + * wait_scanner should spin until TEST_UNIT_READY returns 0 (GOOD) + * returns 0 on success, + * returns -1 on error. + */ +static int +wait_scanner (Coolscan_t * s) +{ + int ret = -1; + int cnt = 0; + DBG (10, "wait_scanner: Testing if scanner is ready\n"); + + while (ret != 0) + { + ret = do_scsi_cmd (s->sfd, test_unit_ready.cmd, + test_unit_ready.size, 0, 0); + + if (ret == SANE_STATUS_DEVICE_BUSY) + { + usleep (500000); /* wait 0.5 seconds */ + if (cnt++ > 40) + { /* 20 sec. max (prescan takes up to 15 sec. */ + DBG (1, "wait_scanner: scanner does NOT get ready\n"); + return -1; + } + } + else if (ret == SANE_STATUS_GOOD) + { + DBG (10, "wait_scanner: scanner is ready\n"); + return ret; + } + else + { + DBG (1, "wait_scanner: test unit ready failed (%s)\n", + sane_strstatus (ret)); + } + } + return 0; +} + +/* ------------------------- COOLSCAN GRAB SCANNER ----------------------------- */ + + +/* coolscan_grab_scanner should go through the following command sequence: + * TEST UNIT READY + * CHECK CONDITION \ + * REQUEST SENSE > These should be handled automagically by + * UNIT ATTENTION / the kernel if they happen (powerup/reset) + * TEST UNIT READY + * GOOD + * RESERVE UNIT + * GOOD + * + * It is then responsible for installing appropriate signal handlers + * to call emergency_give_scanner() if user aborts. + */ + +static int +coolscan_grab_scanner (Coolscan_t * s) +{ + int ret; + + DBG (10, "grabbing scanner\n"); + + wait_scanner (s); /* wait for scanner ready, if not print + sense and return 1 */ + ret = do_scsi_cmd (s->sfd, reserve_unit.cmd, reserve_unit.size, NULL, 0); + if (ret) + return ret; + + DBG (10, "scanner reserved\n"); + return 0; +} + +/* + * Convert a size in ilu to the units expected by the scanner + */ + +static int +resDivToVal (int res_div) +{ + if (res_div < 1 || res_div > resolution_list[0]) + { + DBG (1, "Invalid resolution divisor %d \n", res_div); + return 2700; + } + else + { + return resolution_list[res_div]; + } +} + +static int +resValToDiv (int res_val) +{ + int res_div; + int max_res = resolution_list[0]; + for (res_div = 1; res_div <= max_res; res_div++) + { + if (resolution_list[res_div] == res_val) + break; + } + if (res_div > max_res) + { + DBG (1, "Invalid resolution value\n"); + return 1; + } + else + { + return res_div; + } +} +/* + * use mode select to force a mesurement divisor of 2700 + */ +static unsigned char mode_select[] = +{ + MODE_SELECT, 0x10, 0, 0, 20, 0, + 0, 0, 0, 8, + 0, 0, 0, 0, 0, 0, 0, 1, + 3, 6, 0, 0, 0xA, 0x8C, 0, 0}; + +static int +select_MUD (Coolscan_t * s) +{ + return do_scsi_cmd (s->sfd, mode_select, 26, NULL, 0); +} + +static int +coolscan_autofocus_LS30 (Coolscan_t * s) +{ + int x, y; + + wait_scanner(s); + memcpy(s->buffer, autofocusLS30.cmd, autofocusLS30.size); + memcpy(s->buffer+ autofocusLS30.size, autofocuspos, 9); + + x = s->xmaxpix - (s->brx + s->tlx) / 2; + y = (s->bry + s->tly) / 2; + + DBG (10, "Attempting AutoFocus at x=%d, y=%d\n", x, y); + + do_scsi_cmd (s->sfd, s->buffer, + autofocusLS30.size + 9, NULL, 0); + /* Trashes when used in combination with scsi-driver AM53C974.o */ + do_scsi_cmd (s->sfd, command_c1.cmd, + command_c1.size, NULL, 0); + + DBG (10, "\tWaiting end of Autofocus\n"); + wait_scanner (s); + DBG (10, "AutoFocused.\n"); + return 0; +} + +static int +coolscan_autofocus (Coolscan_t * s) +{ + int x, y; + + if(s->LS>=2) + { return coolscan_autofocus_LS30(s); + } + + wait_scanner(s); + memcpy(s->buffer, autofocus.cmd, autofocus.size); + + x = s->xmaxpix - (s->brx + s->tlx) / 2; + y = (s->bry + s->tly) / 2; + + DBG (10, "Attempting AutoFocus at x=%d, y=%d\n", x, y); + + set_AF_XPoint (s->buffer, x); + set_AF_YPoint (s->buffer, y); + + set_AF_transferlength (s->buffer, 0); /* should be 8 !*/ + do_scsi_cmd (s->sfd, s->buffer, + autofocus.size + AF_Point_length, NULL, 0); + + sleep(5); /* autofocus takes a minimum of 5 sec. */ + + DBG (10, "\tWaiting end of Autofocus\n"); + wait_scanner (s); + DBG (10, "AutoFocused.\n"); + return 0; +} + +/* + static int + coolscan_abort_scan (Coolscan_t * s) + { + int ret; + + DBG (5, "Aborting scan...\n"); + ret = do_scsi_cmd (s->sfd, sabort.cmd, sabort.size, NULL, 0); + if (ret) + DBG (5, "Scan Aborted\n"); + else + DBG (5, "Not scanning\n"); + return 0; + } + */ +static int +coolscan_mode_sense (Coolscan_t * s) +{ + int ret, len; + + DBG (10, "Mode Sense...\n"); + len = 12; + set_MS_DBD (mode_sense.cmd, 1); + set_MS_len (mode_sense.cmd, len); + ret = do_scsi_cmd (s->sfd, mode_sense.cmd, mode_sense.size, + s->buffer, len); + + if (ret == 0) + { + s->MUD = get_MS_MUD (s->buffer); + DBG (10, "\tMode Sensed (MUD is %d)\n", s->MUD); + } + return ret; +} + +static int +coolscan_object_discharge (Coolscan_t * s) +{ + int ret; + + DBG (10, "Trying to discharge object...\n"); + + memcpy (s->buffer, object_position.cmd, object_position.size); + set_OP_autofeed (s->buffer, OP_Discharge); + ret = do_scsi_cmd (s->sfd, s->buffer, + object_position.size, NULL, 0); + wait_scanner (s); + DBG (10, "Object discharged.\n"); + return ret; +} + +static int +coolscan_object_feed (Coolscan_t * s) +{ + int ret; + DBG (10, "Trying to feed object...\n"); + if (!s->asf) + { + DBG (10, "\tAutofeeder not present.\n"); + return 0; + } + memcpy (s->buffer, object_position.cmd, object_position.size); + set_OP_autofeed (s->buffer, OP_Feed); + ret = do_scsi_cmd (s->sfd, s->buffer, + object_position.size, NULL, 0); + wait_scanner (s); + DBG (10, "Object fed.\n"); + return ret; +} + +/* coolscan_give_scanner should go through the following sequence: + * OBJECT POSITION DISCHARGE + * GOOD + * RELEASE UNIT + * GOOD + */ +static int +coolscan_give_scanner (Coolscan_t * s) +{ + DBG (10, "trying to release scanner ...\n"); + coolscan_object_discharge (s); + wait_scanner (s); + do_scsi_cmd (s->sfd, release_unit.cmd, release_unit.size, NULL, 0); + DBG (10, "scanner released\n"); + return 0; +} + + +static int +coolscan_set_window_param_LS20 (Coolscan_t * s, int prescan) +{ + unsigned char buffer_r[max_WDB_size]; + int ret; + + wait_scanner (s); + memset (buffer_r, '\0', max_WDB_size); /* clear buffer */ + memcpy (buffer_r, window_descriptor_block.cmd, + window_descriptor_block.size); /* copy preset data */ + + set_WD_wid (buffer_r, WD_wid_all); /* window identifier */ + set_WD_auto (buffer_r, s->set_auto); /* 0 or 1: don't know what it is */ + + set_WD_negative (buffer_r, s->negative); /* Negative/positive slide */ + + if (prescan) + { + set_WD_scanmode (buffer_r, WD_Prescan); + } + else + { + set_WD_scanmode (buffer_r, WD_Scan); + + /* geometry */ + set_WD_Xres (buffer_r, resDivToVal (s->x_nres)); /* x resolution in dpi */ + set_WD_Yres (buffer_r, resDivToVal (s->y_nres)); /* y resolution in dpi */ + + /* the coolscan uses the upper right corner as the origin of coordinates */ + /* xmax and ymax are given in 1200 dpi */ + set_WD_ULX (buffer_r, (s->xmaxpix - s->brx)); + set_WD_ULY (buffer_r, s->tly); /* upper_edge y */ + set_WD_width (buffer_r, (s->brx - s->tlx + 1)); + set_WD_length (buffer_r, (s->bry - s->tly + 1)); + + /* BTC */ + if (s->brightness == 128) + { + set_WD_brightness (buffer_r, 0); + } + else + { + set_WD_brightness (buffer_r, s->brightness); /* brightness */ + } + + if (s->contrast == 128) + { + set_WD_contrast (buffer_r, 0); + } + else + { + set_WD_contrast (buffer_r, s->contrast); /* contrast */ + } + + /* scanmode */ + if (s->colormode == GREYSCALE) + set_WD_composition (buffer_r, WD_comp_grey); /* GRAY composition */ + else + set_WD_composition (buffer_r, WD_comp_rgb_full); /* RGB composition */ + + set_WD_dropoutcolor (buffer_r, s->dropoutcolor); /* Which color to scan with when grayscale scan */ + set_WD_transfermode (buffer_r, WD_LineSequence); + set_WD_gammaselection (buffer_r, s->gammaselection); /* monitor/linear */ + + set_WD_shading (buffer_r, WD_Shading_ON); /* default for non-manufacturing */ + + if (1 == s->LS) + { /* Analog gamma reserved on LS-1000 */ + set_WD_analog_gamma_R (buffer_r, 0); + set_WD_analog_gamma_G (buffer_r, 0); + set_WD_analog_gamma_R (buffer_r, 0); + } + else + { + /* Quote spec: "It is recomended that analog gamma bits 5, 4 and 3 be + * set to 1 (OFF) when the object type of byte 48 is positive and the + * gamma specificateion of byte 51 is linear, and to 0 (ON) in all + * other cases." */ + /* + int foo; + if ((buffer_r[48] == WD_Positive) && (buffer_r[51] == WD_Linear)) + foo = WD_Analog_Gamma_OFF; + else + foo = WD_Analog_Gamma_ON; + set_WD_analog_gamma_R (buffer_r, foo); + set_WD_analog_gamma_G (buffer_r, foo); + set_WD_analog_gamma_B (buffer_r, foo); + */ + set_WD_analog_gamma_R (buffer_r, s->analog_gamma_r); + set_WD_analog_gamma_G (buffer_r, s->analog_gamma_g); + set_WD_analog_gamma_B (buffer_r, s->analog_gamma_b); + if (s->gamma_bind) + { + set_WD_LUT_R (buffer_r, 1); + set_WD_LUT_G (buffer_r, 1); + set_WD_LUT_B (buffer_r, 1); + } + else + { + set_WD_LUT_R (buffer_r, 1); + set_WD_LUT_G (buffer_r, 2); + set_WD_LUT_B (buffer_r, 3); + } + } + set_WD_averaging (buffer_r, s->averaging); + + set_WD_brightness_R (buffer_r, s->brightness_R); + set_WD_brightness_G (buffer_r, s->brightness_G); + set_WD_brightness_B (buffer_r, s->brightness_B); + + set_WD_contrast_R (buffer_r, s->contrast_R); + set_WD_contrast_G (buffer_r, s->contrast_G); + set_WD_contrast_B (buffer_r, s->contrast_B); + + set_WD_exposure_R (buffer_r, s->exposure_R); + set_WD_exposure_G (buffer_r, s->exposure_G); + set_WD_exposure_B (buffer_r, s->exposure_B); + set_WD_shift_R (buffer_r, s->shift_R); + set_WD_shift_G (buffer_r, s->shift_G); + set_WD_shift_B (buffer_r, s->shift_B); + + + /* FIXME: LUT-[RGB] */ + /* FIXME: stop on/off */ + } + + DBG (10, "\tx_nres=%d, y_nres=%d, upper left-x=%d, upper left-y=%d\n", + s->x_nres, s->y_nres, s->tlx, s->tly); + DBG (10, "\twindow width=%d, MUD=%d, brx=%d\n", + s->brx - s->tlx, s->MUD, s->brx); + DBG (10, "\tcolormode=%d, bits per pixel=%d\n", + s->colormode, s->bits_per_color); + DBG (10, "\tnegative=%d, dropoutcolor=%d, preview=%d, transfermode=%d, gammasel=%d\n", + s->negative, s->dropoutcolor, s->preview, s->transfermode, + s->gammaselection); + + /* prepare SCSI-BUFFER */ + memcpy (s->buffer, set_window.cmd, set_window.size); /* SET-WINDOW cmd */ + memcpy ((s->buffer + set_window.size), /* add WPDB */ + window_parameter_data_block.cmd, + window_parameter_data_block.size); + set_WPDB_wdblen ((s->buffer + set_window.size), used_WDB_size); /* set WD_len */ + memcpy (s->buffer + set_window.size + window_parameter_data_block.size, + buffer_r, window_descriptor_block.size); + + hexdump (15, "Window set", buffer_r, s->wdb_len); + + set_SW_xferlen (s->buffer, (window_parameter_data_block.size + + window_descriptor_block.size)); + + ret = do_scsi_cmd (s->sfd, s->buffer, set_window.size + + window_parameter_data_block.size + + window_descriptor_block.size, + NULL, 0); + DBG (10, "window set.\n"); + return ret; +} + +static int +coolscan_set_window_param_LS30 (Coolscan_t * s, int wid, int prescan) +{ + unsigned char buffer_r[max_WDB_size]; + int ret; + + wait_scanner (s); + memset (buffer_r, '\0', max_WDB_size); /* clear buffer */ + memcpy (buffer_r, window_descriptor_block_LS30.cmd, + window_descriptor_block_LS30.size); /* copy preset data */ + + set_WD_wid (buffer_r, wid); /* window identifier */ + set_WD_auto (buffer_r, s->set_auto); /* 0 or 1: don't know what it is */ + + /* geometry */ + set_WD_Xres (buffer_r, resDivToVal (s->x_nres)); /* x resolution in dpi */ + set_WD_Yres (buffer_r, resDivToVal (s->y_nres)); /* y resolution in dpi */ + + if (prescan) + { + set_WD_scanmode_LS30 (buffer_r, WD_Prescan); + set_WD_Xres (buffer_r, resDivToVal (1)); /* x res. in dpi */ + set_WD_Yres (buffer_r, resDivToVal (1)); /* y res. in dpi */ + buffer_r[0x29]=0x81; + buffer_r[0x2a]=0x04; + buffer_r[0x2b]=0x02; + buffer_r[0x2c]=0x01; + buffer_r[0x2d]=0xff; + buffer_r[0x30]=0x00; + buffer_r[0x31]=0x00; + buffer_r[0x32]=0x00; + buffer_r[0x33]=0x00; + set_WD_width (buffer_r,(2592)); + set_WD_length (buffer_r,(3894)); + } + else + { + set_WD_scanmode_LS30 (buffer_r, WD_Scan); + + /* the coolscan LS-30 uses the upper left corner + as the origin of coordinates */ + /* xmax and ymax are given in 1200 dpi */ + set_WD_ULX (buffer_r, s->tlx); + set_WD_ULY (buffer_r, s->tly); /* upper_edge y */ + set_WD_width (buffer_r, (s->brx - s->tlx+1)); + set_WD_length (buffer_r, (s->bry - s->tly+1)); + + /* BTC */ + if (s->brightness == 128) + { + buffer_r[0x32]=0x00; + } + else + { + buffer_r[0x32]=s->brightness; /* brightness */ + } + + if (s->contrast == 128) + { + buffer_r[0x33]=0x00; + } + else + { + buffer_r[0x33]=s->contrast; /* contrast */ + } + + /* scanmode */ + if (s->colormode == GREYSCALE) + set_WD_composition (buffer_r, WD_comp_grey); /* GRAY composition */ + else + set_WD_composition (buffer_r, WD_comp_rgb_full); /* RGB composition */ + + set_WD_composition (buffer_r, WD_comp_rgb_full); /* allways RGB composition */ + + /* Bits per pixel */ + set_WD_bitsperpixel(buffer_r, s->bits_per_color); + + buffer_r[0x29]=0x81; + buffer_r[0x2a]=0x01; + buffer_r[0x2b]=0x02; + buffer_r[0x2c]=0x01; + buffer_r[0x2d]=0xff; + buffer_r[0x30]=0x00; + + } + set_WD_negative_LS30(buffer_r, s->negative); /* Negative/positive slide */ + + switch(wid) + { case 1: set_gain_LS30(buffer_r,(s->exposure_R*s->pretv_r)/50); + break; + case 2: set_gain_LS30(buffer_r,(s->exposure_G*s->pretv_g)/50); + break; + case 3: set_gain_LS30(buffer_r,(s->exposure_B*s->pretv_b)/50); + break; + } + + DBG (10, "\texpo_r=%d, expo_g=%d, expob=%d\n", + s->exposure_R, s->exposure_G, s->exposure_B); + DBG (10, "\tpre_r=%d, pre_g=%d, preb=%d\n", + s->pretv_r, s->pretv_g, s->pretv_b); + DBG (10, "\tx_nres=%d, y_nres=%d, upper left-x=%d, upper left-y=%d\n", + s->x_nres, s->y_nres, s->tlx, s->tly); + DBG (10, "\twindow width=%d, MUD=%d, brx=%d\n", + s->brx - s->tlx, s->MUD, s->brx); + DBG (10, "\tcolormode=%d, bits per pixel=%d\n", + s->colormode, s->bits_per_color); + DBG (10, "\tnegative=%d, dropoutcolor=%d, preview=%d, transfermode=%d, gammasel=%d\n", + s->negative, s->dropoutcolor, s->preview, s->transfermode, + s->gammaselection); + + /* prepare SCSI-BUFFER */ + memcpy (s->buffer, set_window.cmd, set_window.size); /* SET-WINDOW cmd */ + memcpy ((s->buffer + set_window.size), /* add WPDB */ + window_parameter_data_block.cmd, + window_parameter_data_block.size); + set_WPDB_wdblen ((s->buffer + set_window.size), used_WDB_size_LS30); /* set WD_len */ + memcpy (s->buffer + set_window.size + window_parameter_data_block.size, + buffer_r, window_descriptor_block_LS30.size); + + hexdump (15, "Window set", buffer_r, s->wdb_len); + + set_SW_xferlen (s->buffer, (window_parameter_data_block.size + + window_descriptor_block_LS30.size)); + + ret = do_scsi_cmd (s->sfd, s->buffer, set_window.size + + window_parameter_data_block.size + + window_descriptor_block_LS30.size, + NULL, 0); + DBG (10, "window set.\n"); + return ret; +} + +static int +coolscan_set_window_param (Coolscan_t * s, int prescan) +{ + int ret; + ret=0; + DBG (10, "set_window_param\n"); + + if(s->LS<2) /* distinquish between old and new scanners */ + { ret=coolscan_set_window_param_LS20 (s,prescan); + } + else + { do_scsi_cmd (s->sfd,commande1.cmd,commande1.size,s->buffer,0x0d); + wait_scanner (s); + wait_scanner (s); + coolscan_set_window_param_LS30(s,1,prescan); + ret=coolscan_set_window_param_LS30(s,2,prescan); + ret=coolscan_set_window_param_LS30(s,3,prescan); + if(s->colormode&0x08) + { ret=coolscan_set_window_param_LS30(s,9,prescan); + } + } + return ret; +} + + +/* + * The only purpose of get_window is debugging. None of the return parameters + * is currently used. + */ +static int +coolscan_get_window_param_LS30 (Coolscan_t * s, int wid,int prescanok) +{ + int translen; + unsigned char *buf; + + DBG (10, "GET_WINDOW_PARAM\n"); + /* wait_scanner (s); */ + + translen = window_parameter_data_block.size + window_descriptor_block_LS30.size; + + /* prepare SCSI-BUFFER */ + memset (s->buffer, '\0', max_WDB_size); /* clear buffer */ + + set_SW_xferlen (get_window.cmd, translen); /* Transfer length */ + get_window.cmd[5]= wid; /* window identifier */ + + hexdump (15, "Get window cmd", get_window.cmd, get_window.size); + do_scsi_cmd (s->sfd, get_window.cmd, get_window.size, + s->buffer, translen); + + buf = s->buffer + window_parameter_data_block.size; + hexdump (10, "Window get", buf, 117); + + s->brightness = buf[0x32]; /* brightness */ + s->contrast = buf[0x33]; /* contrast */ + DBG (10, "\tbrightness=%d, contrast=%d\n", s->brightness, s->contrast); + + /* Useful? */ + s->bits_per_color = get_WD_bitsperpixel (buf); /* bits/pixel (8) */ + + DBG (10, "\tcolormode=%d, bits per pixel=%d\n", + s->colormode, s->bits_per_color); + + if(prescanok) + { switch(wid) + { case 1: s->pretv_r = get_gain_LS30(buf); + break; + case 2: s->pretv_g = get_gain_LS30(buf); + break; + case 3: s->pretv_b = get_gain_LS30(buf); + break; + } + } + + /* Should this one be set at all, here? */ + s->transfermode = get_WD_transfermode (buf); + + s->gammaselection = get_WD_gammaselection (buf); /* monitor/linear */ + DBG (10, "\tpre_r=%d, pre_g=%d, preb=%d\n", + s->pretv_r, s->pretv_g, s->pretv_b); + + DBG (5, "\tnegative=%d, dropoutcolor=%d, preview=%d, transfermode=%d, gammasel=%d\n", + s->negative, s->dropoutcolor, s->preview, s->transfermode, + s->gammaselection); + + DBG (10, "get_window_param - return\n"); + return 0; +} + +/* + * The only purpose of get_window is debugging. None of the return parameters + * is currently used. + */ +static int +coolscan_get_window_param_LS20 (Coolscan_t * s) +{ + int translen; + unsigned char *buf; + + DBG (10, "GET_WINDOW_PARAM\n"); + wait_scanner (s); + + translen = window_parameter_data_block.size + window_descriptor_block.size; + + /* prepare SCSI-BUFFER */ + memset (s->buffer, '\0', max_WDB_size); /* clear buffer */ + + set_SW_xferlen (get_window.cmd, translen); /* Transfer length */ + + hexdump (15, "Get window cmd", get_window.cmd, get_window.size); + do_scsi_cmd (s->sfd, get_window.cmd, get_window.size, + s->buffer, translen); + + buf = s->buffer + window_parameter_data_block.size; + hexdump (10, "Window get", buf, 117); + + /* BTC */ + s->brightness = get_WD_brightness (buf); /* brightness */ + s->contrast = get_WD_contrast (buf); /* contrast */ + DBG (10, "\tbrightness=%d, contrast=%d\n", s->brightness, s->contrast); + + if (WD_comp_gray == get_WD_composition (buf)) + s->colormode = GREYSCALE; + else + s->colormode = RGB; + + /* Useful? */ + s->bits_per_color = get_WD_bitsperpixel (buf); /* bits/pixel (8) */ + + DBG (10, "\tcolormode=%d, bits per pixel=%d\n", + s->colormode, s->bits_per_color); + + + s->dropoutcolor = get_WD_dropoutcolor (buf); /* Which color to scan with when grayscale scan */ + + /* Should this one be set at all, here? */ + s->transfermode = get_WD_transfermode (buf); + + s->gammaselection = get_WD_gammaselection (buf); /* monitor/linear */ + + DBG (5, "\tnegative=%d, dropoutcolor=%d, preview=%d, transfermode=%d, gammasel=%d\n", + s->negative, s->dropoutcolor, s->preview, s->transfermode, + s->gammaselection); + + /* Should this one be set at all? */ + s->shading = get_WD_shading (buf); + s->averaging = get_WD_averaging (buf); + DBG (10, "get_window_param - return\n"); + return 0; +} + +/* + * The only purpose of get_window is debugging. None of the return parameters + * is currently used. + */ +static int +coolscan_get_window_param (Coolscan_t * s, int prescanok) +{ + int ret; + DBG (10, "get_window_param\n"); + + ret=0; + if(s->LS<2) /* distinquish between old and new scanners */ + { ret=coolscan_get_window_param_LS20 (s); + } + else + { + ret=coolscan_get_window_param_LS30(s,1,prescanok); + ret=coolscan_get_window_param_LS30(s,2,prescanok); + ret=coolscan_get_window_param_LS30(s,3,prescanok); + if(s->colormode&0x08) + { ret=coolscan_get_window_param_LS30(s,9,prescanok); + } + } + return ret; +} + +static int +coolscan_start_scanLS30 (Coolscan_t * s) +{ int channels; + DBG (10, "starting scan\n"); + + channels=1; + memcpy (s->buffer, scan.cmd, scan.size); + switch(s->colormode) + { case RGB: + case GREYSCALE: + channels=s->buffer[4]=0x03; /* window 1 */ + s->buffer[6]=0x01; /* window 1 */ + s->buffer[7]=0x02; /* window 2 */ + s->buffer[8]=0x03; /* window 3 */ + + break; + case RGBI: + channels=s->buffer[4]=0x04; /* window 1 */ + s->buffer[6]=0x01; /* window 1 */ + s->buffer[7]=0x02; /* window 2 */ + s->buffer[8]=0x03; /* window 3 */ + s->buffer[9]=0x09; /* window 3 */ + break; + case IRED: + channels=s->buffer[4]=0x01; /* window 1 */ + s->buffer[8]=0x09; /* window 3 */ + break; + } + + return do_scsi_cmd (s->sfd, s->buffer, scan.size+channels, NULL, 0); +} + +static int +coolscan_start_scan (Coolscan_t * s) +{ + DBG (10, "starting scan\n"); + if(s->LS>=2) + { return coolscan_start_scanLS30(s); + } + return do_scsi_cmd (s->sfd, scan.cmd, scan.size, NULL, 0); +} + + +static int +prescan (Coolscan_t * s) +{ + int ret; + + DBG (10, "Starting prescan...\n"); + if(s->LS<2) + { coolscan_set_window_param (s, 1); + } + else + { + do_scsi_cmd (s->sfd,commande1.cmd,commande1.size,s->buffer,0x0d); + wait_scanner (s); + wait_scanner (s); + coolscan_set_window_param_LS30 (s,1,1); + coolscan_set_window_param_LS30 (s,2,1); + coolscan_set_window_param_LS30 (s,3,1); + + } + ret = coolscan_start_scan(s); + + sleep(8); /* prescan takes a minimum of 10 sec. */ + wait_scanner (s); + DBG (10, "Prescan done\n"); + return ret; +} + +static SANE_Status +do_prescan_now (Coolscan_t * scanner) +{ + + DBG (10, "do_prescan_now \n"); + if (scanner->scanning == SANE_TRUE) + return SANE_STATUS_DEVICE_BUSY; + + if (scanner->sfd < 0) + { /* first call */ + if (sanei_scsi_open (scanner->sane.name, + &(scanner->sfd), + sense_handler, 0) != SANE_STATUS_GOOD) + { + DBG (1, "do_prescan_now: open of %s failed:\n", + scanner->sane.name); + return SANE_STATUS_INVAL; + } + } + scanner->scanning = SANE_TRUE; + + + if (coolscan_check_values (scanner) != 0) + { /* Verify values */ + DBG (1, "ERROR: invalid scan-values\n"); + scanner->scanning = SANE_FALSE; + coolscan_give_scanner (scanner); + sanei_scsi_close (scanner->sfd); + scanner->sfd = -1; + return SANE_STATUS_INVAL; + } + + if (coolscan_grab_scanner (scanner)) + { + sanei_scsi_close (scanner->sfd); + scanner->sfd = -1; + DBG (5, "WARNING: unable to reserve scanner: device busy\n"); + scanner->scanning = SANE_FALSE; + return SANE_STATUS_DEVICE_BUSY; + } + + prescan (scanner); + if(scanner->LS<2) + { get_internal_info(scanner); + } + coolscan_get_window_param (scanner,1); + scanner->scanning = SANE_FALSE; + coolscan_give_scanner (scanner); + return SANE_STATUS_GOOD; +} + + +static int +send_one_LUT (Coolscan_t * s, SANE_Word * LUT, int reg) +{ + int i; + short lutval; + short bytesperval; + unsigned char *gamma, *gamma_p; + unsigned short *gamma_s; + + DBG (10, "send LUT\n"); + + if(s->LS<2) + { set_S_datatype_code (send.cmd, R_user_reg_gamma); + bytesperval=1; + } + else + { + send.cmd[0x02]=3; + send.cmd[0x05]=1; + bytesperval=2; + } + + set_S_xfer_length (send.cmd, s->lutlength*bytesperval); + set_S_datatype_qual_upper (send.cmd, reg); + + gamma = alloca (send.size + s->lutlength*2); + memcpy (gamma, send.cmd, send.size); + if(s->LS<2) + { gamma_p = &gamma[send.size]; + for (i = 0; i < s->lutlength; i++) + { + if (LUT[i] > 255) + LUT[i] = 255; /* broken gtk */ + *gamma_p++ = (unsigned char) LUT[i]; + } + } + else if(s->LS==2) + { gamma_s = (unsigned short*)( &gamma[send.size]); + for (i = 0; i < s->lutlength; i++) + { + if(s->negative) + { + lutval=(unsigned short)(LUT[(s->lutlength-i)]); + } + else + { + lutval=(unsigned short)(LUT[i]); + } + if (LUT[i] >= s->max_lut_val) + LUT[i] = s->max_lut_val-1; /* broken gtk */ + if(s->low_byte_first) /* if on little endian machine: */ + { + lutval=((lutval&0x00ff)<<8)+((lutval&0xff00)>>8); /* inverse byteorder */ + } + *gamma_s++ = lutval; + } + } + else if(s->LS==3) + { gamma_s = (unsigned short*)( &gamma[send.size]); + for (i = 0; i < s->lutlength; i++) + { + if(s->negative) + { + lutval=(unsigned short)(LUT[s->lutlength-i]); + } + else + { + lutval=(unsigned short)(LUT[i]); + } + if (LUT[i] >= s->max_lut_val) + LUT[i] = s->max_lut_val-1; /* broken gtk */ + if(s->low_byte_first) /* if on little endian machine: */ + { lutval=((lutval&0x00ff)<<8)+((lutval&0xff00)>>8); /* inverse byteorder */ + } + *gamma_s++ = lutval; + } + } + return do_scsi_cmd (s->sfd, gamma, send.size + s->lutlength*bytesperval, NULL, 0); +} + + +static int +send_LUT (Coolscan_t * s) +{ + wait_scanner (s); + if (s->gamma_bind) + { + send_one_LUT (s, s->gamma, S_DQ_Reg1); + if(s->LS>=2) + { send_one_LUT (s, s->gamma, S_DQ_Reg2); + send_one_LUT (s, s->gamma, S_DQ_Reg3); + if(s->colormode&0x08) + { send_one_LUT (s, s->gamma, S_DQ_Reg9); + } + + } + } + else + { + send_one_LUT (s, s->gamma_r, S_DQ_Reg1); + send_one_LUT (s, s->gamma_g, S_DQ_Reg2); + send_one_LUT (s, s->gamma_b, S_DQ_Reg3); + if(s->colormode&0x08) + { send_one_LUT (s, s->gamma_r, S_DQ_Reg9); + } + } + return 0; +} + + +static int +coolscan_read_data_block (Coolscan_t * s, unsigned int datatype, unsigned int length) +{ + int r; + + DBG (10, "read_data_block (type= %x length = %d)\n",datatype,length); + /*wait_scanner(s); */ + + set_R_datatype_code (sread.cmd, datatype); + sread.cmd[4]=00; + sread.cmd[5]=00; + set_R_xfer_length (sread.cmd, length); + + r = do_scsi_cmd (s->sfd, sread.cmd, sread.size, s->buffer, length); + return ((r != 0) ? -1 : (int) length); +} + + +static void +coolscan_do_inquiry (Coolscan_t * s) +{ + int size; + + DBG (10, "do_inquiry\n"); + memset (s->buffer, '\0', 256); /* clear buffer */ + size = 36; /* Hardcoded, and as specified by Nikon */ + /* then get inquiry with actual size */ + set_inquiry_return_size (inquiry.cmd, size); + do_scsi_cmd (s->sfd, inquiry.cmd, inquiry.size, s->buffer, size); +} + +static int +coolscan_identify_scanner (Coolscan_t * s) +{ + unsigned char vendor[9]; + unsigned char product[0x11]; + unsigned char version[5]; + unsigned char *pp; + int i; + + vendor[8] = product[0x10] = version[4] = 0; + DBG (10, "identify_scanner\n"); + coolscan_do_inquiry (s); /* get inquiry */ + if (get_inquiry_periph_devtype (s->buffer) != IN_periph_devtype_scanner) + { + DBG (5, "identify_scanner: not a scanner\n"); + return 1; + } /* no, continue searching */ + + coolscan_get_inquiry_values (s); + + get_inquiry_vendor ((char *)s->buffer, (char *)vendor); + get_inquiry_product ((char *)s->buffer, (char *)product); + get_inquiry_version ((char *)s->buffer, (char *)version); + + if (strncmp ("Nikon ", (char *)vendor, 8)) + { + DBG (5, "identify_scanner: \"%s\" isn't a Nikon product\n", vendor); + return 1; + } /* Not a Nikon product */ + + pp = &vendor[8]; + vendor[8] = ' '; + while (*pp == ' ') + { + *pp-- = '\0'; + } + + pp = &product[0x10]; + product[0x10] = ' '; + while (*(pp - 1) == ' ') + { + *pp-- = '\0'; + } /* leave one blank at the end! */ + + pp = &version[4]; + version[4] = ' '; + while (*pp == ' ') + { + *pp-- = '\0'; + } + + DBG (10, "Found Nikon scanner %sversion %s on device %s\n", + product, version, s->devicename); + + /* look for scanners that do not give all inquiry-informations */ + /* and if possible use driver-known inquiry-data */ + if (get_inquiry_additional_length (s->buffer) >= 0x1f) + { + /* Now identify full supported scanners */ + for (i = 0; i < known_scanners; i++) + { + if (!strncmp ((char *)product, scanner_str[i], strlen (scanner_str[i]))) + { + s->LS = i; + return 0; + } + } + if (s->cont) + return 0; + else + return 1; + } + else + return 1; +} + +static int +pixels_per_line (Coolscan_t * s) +{ + int pic_dot; + if(s->LS<2) + { pic_dot = (s->brx - s->tlx + s->x_nres) / s->x_nres; + } + else + { pic_dot = (s->brx - s->tlx + 1) / s->x_nres; + } + DBG (10, "pic_dot=%d\n", pic_dot); + return pic_dot; +} + +static int +lines_per_scan (Coolscan_t * s) +{ + int pic_line; + if(s->LS<2) + { pic_line = (s->bry - s->tly + s->y_nres) / s->y_nres; + } + else + { pic_line = (( s->bry - s->tly + 1.0 ) / s->y_nres); + } + DBG (10, "pic_line=%d\n", pic_line); + return pic_line; +} + +static int +scan_bytes_per_line (Coolscan_t * s) +{ int bpl; + switch(s->colormode) + { case RGB: + case GREYSCALE: + bpl=pixels_per_line (s) * 3; + if(s->bits_per_color>8) bpl=bpl*2; + return bpl; + break; + case RGBI: + case IRED: + bpl=pixels_per_line (s) * 4; + if(s->bits_per_color>8) bpl=bpl*2; + return bpl; + break; + } + return 0; +} + +static int +write_bytes_per_line (Coolscan_t * s) +{ int bpl; + switch(s->colormode) + { case RGB: + bpl=pixels_per_line (s) * 3; + if(s->bits_per_color>8) bpl=bpl*2; + return bpl; + break; + case RGBI: + bpl=pixels_per_line (s) * 4; + if(s->bits_per_color>8) bpl=bpl*2; + return bpl; + break; + case IRED: + case GREYSCALE: + bpl= pixels_per_line (s) ; + if(s->bits_per_color>8) bpl=bpl*2; + return bpl; + break; + } + return 0; +} + + +static void +coolscan_trim_rowbufsize (Coolscan_t * s) +{ + unsigned int row_len; + row_len = scan_bytes_per_line (s); + s->row_bufsize = (s->row_bufsize < row_len) ? s->row_bufsize + : s->row_bufsize - (s->row_bufsize % row_len); + DBG (10, "trim_bufsize to %d\n", s->row_bufsize); +} + +static int +coolscan_check_values (Coolscan_t * s) +{ + DBG (10, "check_values\n"); + /* -------------------------- asf --------------------------------- */ + if (s->asf != 0) + { + if (s->autofeeder == 0) + { + DBG (1, "ERROR: ASF-MODE NOT SUPPORTED BY SCANNER, ABORTING\n"); + return (1); + } + } + + return (0); +} + +/* test_little_endian */ + +static SANE_Bool +coolscan_test_little_endian(void) +{ + SANE_Int testvalue = 255; + unsigned char *firstbyte = (unsigned char *) &testvalue; + + if (*firstbyte == 255) + { return SANE_TRUE; + } + return SANE_FALSE; +} + +static int +get_inquiery_part_LS30 (Coolscan_t * s, unsigned char part) +{ + int size; + int ret; + + /* Get length of reponse */ + inquiry.cmd[1]=0x01; + inquiry.cmd[2]=part; + size=4; + set_inquiry_return_size (inquiry.cmd, size); + ret = do_scsi_cmd (s->sfd, inquiry.cmd, inquiry.size, + s->buffer, size); + size=get_inquiry_length(s->buffer); + size+=4; + /* then get inquiry with actual size */ + set_inquiry_return_size (inquiry.cmd, size); + ret = do_scsi_cmd (s->sfd, inquiry.cmd, inquiry.size, + s->buffer, size); + return size; +} + +static int +coolscan_read_var_data_block (Coolscan_t * s,int datatype) +{ + int r; + int size; + + DBG (10, "read_data_block (type= %x)\n",datatype); + /*wait_scanner(s); */ + + sread.cmd[2]=datatype; + sread.cmd[4]=00; + sread.cmd[5]=03; + size=6; + set_R_xfer_length (sread.cmd, size); + r = do_scsi_cmd (s->sfd, sread.cmd, sread.size, + s->buffer, size); + size=s->buffer[5]; + set_R_xfer_length (sread.cmd, size); + r = do_scsi_cmd (s->sfd, sread.cmd, sread.size, + s->buffer, size); + return ((r != 0) ? -1 : size); +} + +static int +get_inquiery_LS30 (Coolscan_t * s) +{ + unsigned char part; + unsigned char parts[5]; + int size; + int i; + + /* Get vector of inquiery parts */ + size=get_inquiery_part_LS30(s, (unsigned char) 0); + /* Get the parts of inquiery */ + for(i=0;i<5;i++) + { parts[i]=((unsigned char *)s->buffer)[4+11+i]; + } + for(i=0;i<5;i++) + { part=parts[i]; + size=get_inquiery_part_LS30 (s, part); + switch(part) + { case 0x0c1:/* max size and resolution */ + s->adbits = 8; + s->outputbits = 8; + s->maxres = getnbyte(s->buffer+0x12,2)-1; + s->xmaxpix = getnbyte(s->buffer+0x53,2)-1; + s->ymaxpix = getnbyte(s->buffer+0x3c,2)-1; + break; + case 0x0d1: + break; + case 0x0e1: + break; + case 0x0f0: + break; + case 0x0f8: + break; + } + } + + /* get windows */ + coolscan_get_window_param_LS30 (s,0,0); + s->xmax = get_WD_width(s->buffer); + s->ymax = get_WD_length(s->buffer); + coolscan_get_window_param_LS30 (s,1,0); + coolscan_get_window_param_LS30 (s,2,0); + coolscan_get_window_param_LS30 (s,3,0); + coolscan_get_window_param_LS30 (s,4,0); + coolscan_get_window_param_LS30 (s,9,0); + + s->analoggamma = 0; + return 1; +} + +static int +get_feeder_type_LS30 (Coolscan_t * s) +{ + int size; + unsigned char *ptr; + int ima; + + /* find out about Film-strip-feeder or Mount-Feeder */ + size=get_inquiery_part_LS30(s, (unsigned char) 1); + if(strncmp((char *)s->buffer+5,"Strip",5)==0) + { s->feeder=STRIP_FEEDER; + s->autofeeder = 1; + } + if(strncmp((char *)s->buffer+5,"Mount",5)==0) + { s->feeder=MOUNT_FEEDER; + } + /* find out about Film-strip-feeder positions*/ + if(s->feeder==STRIP_FEEDER) + { size=coolscan_read_var_data_block (s,(int)0x88); + if(size>=4) + { s->numima=s->buffer[3]; + if(s->numima>6) s->numima=6; /* limit to 6 images for now */ + if(s->numima>(size-4)/16) s->numima=(size-4)/16; + ptr=s->buffer+4; + for(ima=0;ima<s->numima;ima++) + { s->ipos[ima].start=getnbyte(ptr,4); + s->ipos[ima].offset=getnbyte(ptr+4,4); + s->ipos[ima].end=getnbyte(ptr+8,4); + s->ipos[ima].height=getnbyte(ptr+12,4); + ptr+=16; + } + } + s->posima=0; + } + return 1; +} + + +static int +get_internal_info_LS20 (Coolscan_t * s) +{ + int ret; + + DBG (10, "get_internal_info\n"); + wait_scanner (s); + memset (s->buffer, '\0', DI_length); /* clear buffer */ + + set_R_datatype_code (sread.cmd, R_device_internal_info); + set_R_datatype_qual_upper (sread.cmd, R_DQ_none); + set_R_xfer_length (sread.cmd, DI_length); + /* then get inquiry with actual size */ + ret = do_scsi_cmd (s->sfd, sread.cmd, sread.size, + s->buffer, DI_length); + + s->adbits = get_DI_ADbits (s->buffer); + s->outputbits = get_DI_Outputbits (s->buffer); + s->maxres = get_DI_MaxResolution (s->buffer); + s->xmax = get_DI_Xmax (s->buffer); + s->ymax = get_DI_Ymax (s->buffer); + s->xmaxpix = get_DI_Xmaxpixel (s->buffer); + s->ymaxpix = get_DI_Ymaxpixel (s->buffer); + s->ycurrent = get_DI_currentY (s->buffer); + s->currentfocus = get_DI_currentFocus (s->buffer); + s->currentscanpitch = get_DI_currentscanpitch (s->buffer); + s->autofeeder = get_DI_autofeeder (s->buffer); + s->analoggamma = get_DI_analoggamma (s->buffer); + s->derr[0] = get_DI_deviceerror0 (s->buffer); + s->derr[1] = get_DI_deviceerror1 (s->buffer); + s->derr[2] = get_DI_deviceerror2 (s->buffer); + s->derr[3] = get_DI_deviceerror3 (s->buffer); + s->derr[4] = get_DI_deviceerror4 (s->buffer); + s->derr[5] = get_DI_deviceerror5 (s->buffer); + s->derr[6] = get_DI_deviceerror6 (s->buffer); + s->derr[7] = get_DI_deviceerror7 (s->buffer); + s->wbetr_r = get_DI_WBETR_R (s->buffer); + s->webtr_g = get_DI_WBETR_G (s->buffer); + s->webtr_b = get_DI_WBETR_B (s->buffer); + s->pretv_r = get_DI_PRETV_R (s->buffer); + s->pretv_g = get_DI_PRETV_G (s->buffer); + s->pretv_r = get_DI_PRETV_R (s->buffer); + s->cetv_r = get_DI_CETV_R (s->buffer); + s->cetv_g = get_DI_CETV_G (s->buffer); + s->cetv_b = get_DI_CETV_B (s->buffer); + s->ietu_r = get_DI_IETU_R (s->buffer); + s->ietu_g = get_DI_IETU_G (s->buffer); + s->ietu_b = get_DI_IETU_B (s->buffer); + s->limitcondition = get_DI_limitcondition (s->buffer); + s->offsetdata_r = get_DI_offsetdata_R (s->buffer); + s->offsetdata_g = get_DI_offsetdata_G (s->buffer); + s->offsetdata_b = get_DI_offsetdata_B (s->buffer); + get_DI_poweron_errors (s->buffer, s->power_on_errors); + + DBG (10, + "\tadbits=%d\toutputbits=%d\tmaxres=%d\txmax=%d\tymax=%d\n" + "\txmaxpix=%d\tymaxpix=%d\tycurrent=%d\tcurrentfocus=%d\n" + "\tautofeeder=%s\tanaloggamma=%s\tcurrentscanpitch=%d\n", + s->adbits, s->outputbits, s->maxres, s->xmax, s->ymax, + s->xmaxpix, s->ymaxpix, s->ycurrent, s->currentfocus, + s->autofeeder ? "Yes" : "No", s->analoggamma ? "Yes" : "No", + s->currentscanpitch); + DBG (10, + "\tWhite balance exposure time var [RGB]=\t%d %d %d\n" + "\tPrescan result exposure time var [RGB]=\t%d %d %d\n" + "\tCurrent exposure time var.[RGB]=\t%d %d %d\n" + "\tInternal exposure time unit[RGB]=\t%d %d %d\n", + s->wbetr_r, s->webtr_g, s->webtr_b, s->pretv_r, s->pretv_g, + s->pretv_r, s->cetv_r, s->cetv_g, s->cetv_b, s->ietu_r, + s->ietu_g, s->ietu_b); + DBG (10, + "\toffsetdata_[rgb]=\t0x%x 0x%x 0x%x\n" + "\tlimitcondition=0x%x\n" + "\tdevice error code = 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n" + "\tpower-on errors = 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", + s->offsetdata_r, s->offsetdata_g, s->offsetdata_b, + s->limitcondition, + s->derr[0], s->derr[1], s->derr[2], s->derr[3], s->derr[4], + s->derr[5], s->derr[6], s->derr[7], + s->power_on_errors[0], s->power_on_errors[1], + s->power_on_errors[2], s->power_on_errors[3], + s->power_on_errors[4], s->power_on_errors[5], + s->power_on_errors[6], s->power_on_errors[7]); + + return ret; +} + +static int +get_internal_info (Coolscan_t * s) +{ + int ret; + + DBG (10, "get_internal_info\n"); + + if(s->LS<2) /* distinquish between old and new scanners */ + { ret=get_internal_info_LS20 (s); + } + else + { ret=get_inquiery_LS30 (s); + } + return ret; +} + +static void +coolscan_get_inquiry_values (Coolscan_t * s) +{ + unsigned char *inquiry_block; + + DBG (10, "get_inquiry_values\n"); + + inquiry_block = (unsigned char *) s->buffer; + s->inquiry_len = 36; + + get_inquiry_vendor ((char *)inquiry_block, (char *)s->vendor); + s->vendor[8] = '\0'; + get_inquiry_product ((char *)inquiry_block, (char *)s->product); + s->product[16] = '\0'; + get_inquiry_version ((char *)inquiry_block, (char *)s->version); + s->version[4] = '\0'; + + if (s->inquiry_len < 36) + { + DBG (1, "WARNING: inquiry return block is unexpected short (%d instead of 36).\n", s->inquiry_len); + } + s->inquiry_wdb_len = 117; + return; +} + +static void +coolscan_initialize_values (Coolscan_t * s) +{ + int i; + DBG (10, "initialize_values\n"); + /* Initialize us structure */ + if(s->LS<2) /* LS-20 or LS-10000 */ + { select_MUD (s); /* must be before mode_sense - not for LS-30*/ + coolscan_mode_sense (s); /* Obtain MUD (Measurement Unit Divisor) */ + get_internal_info (s); /* MUST be called first. */ + s->wdb_len = 117; + } + if(s->LS>=2) /* LS-30 */ + { + get_inquiery_LS30(s); /* Info about scanner*/ + select_MUD (s); /* must be before mode_sense */ + get_feeder_type_LS30(s); + s->wdb_len = 117; + } + + s->cont = 0; /* do not continue if scanner is unknown */ + s->verbose = 2; /* 1=verbose,2=very verbose */ + + + s->x_nres = s->y_nres = 2; /* 2 => 1350 dpi */ + s->x_p_nres = s->y_p_nres = 9; /* 9 => 300 dpi */ + s->tlx = 0; + s->tly = 0; + s->brx = s->xmaxpix; /* 2700 / 1200; */ + s->bry = s->ymaxpix; /* 2700 / 1200; */ + + + s->set_auto = 0; /* Always 0 on Nikon LS-{100|2}0 */ + s->preview = 0; /* 1 for preview */ + s->colormode = RGB; /* GREYSCALE or RGB */ + s->colormode_p = RGB; /* GREYSCALE or RGB for preview*/ + s->asf = 0; /* 1 if asf shall be used */ + s->gammaselection = WD_Linear; + + s->brightness = 128; + s->brightness_R = 128; + s->brightness_G = 128; + s->brightness_B = 128; + s->contrast = 128; + s->contrast_R = 128; + s->contrast_G = 128; + s->contrast_B = 128; + + s->exposure_R = 50; + s->exposure_G = 50; + s->exposure_B = 50; + + s->pretv_r=40000; + s->pretv_g=40000; + s->pretv_b=40000; + + s->shift_R = 128; + s->shift_G = 128; + s->shift_B = 128; + + s->ired_red=60; + s->ired_green=1; + s->ired_blue=1; + + s->prescan = 1; + s->bits_per_color = 8; + s->rgb_control = 0; + s->gamma_bind = 1; + switch(s->LS) + { case 0:s->lutlength=2048; + s->max_lut_val=256; + break; + case 1:s->lutlength=512; + s->max_lut_val=512; + break; + case 2:s->lutlength=1024; + s->max_lut_val=1024; + break; + case 3:s->lutlength=4096; + s->max_lut_val=4096; + break; + } + for (i = 0; i < s->lutlength; i++) + { + s->gamma[i] =((short)((((double)i)/s->lutlength)*s->max_lut_val)); + s->gamma_r[i] = s->gamma[i]; + s->gamma_g[i] = s->gamma[i]; + s->gamma_b[i] = s->gamma[i]; + } + + if (coolscan_test_little_endian() == SANE_TRUE) + { + s->low_byte_first = 1; /* in 2 byte mode send lowbyte first */ + DBG(10,"backend runs on little endian machine\n"); + } + else + { + s->low_byte_first = 0; /* in 2 byte mode send highbyte first */ + DBG(10,"backend runs on big endian machine\n"); + } +} + +static void +hexdump (int level, char *comment, unsigned char *p, int l) +{ + int i; + char line[128]; + char *ptr; + + DBG (level, "%s\n", comment); + ptr = line; + for (i = 0; i < l; i++, p++) + { + if ((i % 16) == 0) + { + if (ptr != line) + { + *ptr = '\0'; + DBG (level, "%s\n", line); + ptr = line; + } + sprintf (ptr, "%3.3d:", i); + ptr += 4; + } + sprintf (ptr, " %2.2x", *p); + ptr += 3; + } + *ptr = '\0'; + DBG (level, "%s\n", line); +} + + +static SANE_Status +sense_handler (int scsi_fd, unsigned char * result, void *arg) +{ + scsi_fd = scsi_fd; + arg = arg; + + if (result[0] != 0x70) + { + return SANE_STATUS_IO_ERROR; /* we only know about this one */ + } + return request_sense_parse(result); + +} + + +/* ------------------------------------------------------------------------- */ + + +/* ilu per mm */ + +#define length_quant SANE_UNFIX(SANE_FIX(MM_PER_INCH / 2700.0)) +#define mmToIlu(mm) ((mm) / length_quant) +#define iluToMm(ilu) ((ilu) * length_quant) + +#define P_200_TO_255(per) SANE_UNFIX((per + 100) * 255/200 ) +#define P_100_TO_255(per) SANE_UNFIX(per * 255/100 ) + +static const char negativeStr[] = "Negative"; +static const char positiveStr[] = "Positive"; +static SANE_String_Const type_list[] = +{ + positiveStr, + negativeStr, + 0 +}; + +static const char colorStr[] = SANE_VALUE_SCAN_MODE_COLOR; +static const char grayStr[] = SANE_VALUE_SCAN_MODE_GRAY; +static const char rgbiStr[] = "RGBI"; +static const char iredStr[] = "Infrared"; + +static SANE_String_Const scan_mode_list_LS20[] = +{ + colorStr, + grayStr, + NULL +}; + +static SANE_String_Const scan_mode_list_LS30[] = +{ + colorStr, + grayStr, +#ifdef HAS_IRED + rgbiStr, +#endif /* HAS_IRED */ + NULL +}; + +static SANE_Int bit_depth_list[9]; + +static const char neverStr[] = "never"; +static const char previewStr[] = "before preview"; +static const char scanStr[] = "before scan"; +static const char preandscanStr[] = "before preview and scan"; +static SANE_String_Const autofocus_mode_list[] = +{ + neverStr, + previewStr, + scanStr, + preandscanStr, + NULL +}; + +static SANE_String_Const source_list[4] = +{NULL, NULL, NULL, NULL}; + +static const SANE_Range gamma_range_8 = +{ + 0, /* minimum */ + 255, /* maximum */ + 1 /* quantization */ +}; + + +static const SANE_Range gamma_range_9 = +{ + 0, /* minimum */ + 511, /* maximum */ + 1 /* quantization */ +}; + +static const SANE_Range gamma_range_10 = +{ + 0, /* minimum */ + 1023, /* maximum */ + 1 /* quantization */ +}; + +static const SANE_Range gamma_range_12 = +{ + 0, /* minimum */ + 4096, /* maximum */ + 1 /* quantization */ +}; + +static const SANE_Range brightness_range = +{ + -5, + +5, + 1 +}; + +static const SANE_Range contrast_range = +{ + -5, + +5, + 0 +}; + +static const SANE_Range exposure_range = +{ + 24, + 400, + 2 +}; + +static const SANE_Range shift_range = +{ + -15, + +15, + 0 +}; + +static int num_devices; +static Coolscan_t *first_dev; + + +static size_t +max_string_size (const SANE_String_Const strings[]) +{ + size_t size, max_size = 0; + int i; + + for (i = 0; strings[i]; ++i) + { + size = strlen (strings[i]) + 1; + if (size > max_size) + max_size = size; + } + return max_size; +} + +static SANE_Status +do_eof (Coolscan_t * scanner) +{ + DBG (10, "do_eof\n"); + + if (scanner->pipe >= 0) + { + close (scanner->pipe); + scanner->pipe = -1; + } + return SANE_STATUS_EOF; +} + +static SANE_Status +do_cancel (Coolscan_t * scanner) +{ + DBG (10, "do_cancel\n"); + swap_res (scanner); + scanner->scanning = SANE_FALSE; + + do_eof (scanner); /* close pipe and reposition scanner */ + + if (scanner->reader_pid != -1) + { + int exit_status; + + DBG (10, "do_cancel: kill reader_process\n"); + + /* ensure child knows it's time to stop: */ + sanei_thread_kill (scanner->reader_pid); + while (sanei_thread_waitpid(scanner->reader_pid, &exit_status) != + scanner->reader_pid ); + scanner->reader_pid = -1; + } + + if (scanner->sfd >= 0) + { + coolscan_give_scanner (scanner); + DBG (10, "do_cancel: close filedescriptor\n"); + sanei_scsi_close (scanner->sfd); + scanner->sfd = -1; + } + + return SANE_STATUS_CANCELLED; +} + +static SANE_Status +attach_scanner (const char *devicename, Coolscan_t ** devp) +{ + Coolscan_t *dev; + int sfd; + + DBG (10, "attach_scanner: %s\n", devicename); + + for (dev = first_dev; dev; dev = dev->next) + { + if (strcmp (dev->sane.name, devicename) == 0) + { + if (devp) + { + *devp = dev; + } + DBG (5, "attach_scanner: scanner already attached (is ok)!\n"); + return SANE_STATUS_GOOD; + } + } + + DBG (10, "attach_scanner: opening %s\n", devicename); + if (sanei_scsi_open (devicename, &sfd, sense_handler, 0) != 0) + { + DBG (1, "attach_scanner: open failed\n"); + return SANE_STATUS_INVAL; + } + + if (NULL == (dev = malloc (sizeof (*dev)))) + return SANE_STATUS_NO_MEM; + + + dev->row_bufsize = (sanei_scsi_max_request_size < (64 * 1024)) ? + sanei_scsi_max_request_size : 64 * 1024; + + if ((dev->buffer = malloc (dev->row_bufsize)) == NULL) +/* if ((dev->buffer = malloc (sanei_scsi_max_request_size)) == NULL)*/ + return SANE_STATUS_NO_MEM; + + if ((dev->obuffer = malloc (dev->row_bufsize)) == NULL) + return SANE_STATUS_NO_MEM; + + dev->devicename = strdup (devicename); + dev->sfd = sfd; + + /* Nikon manual: Step 1 */ + if (coolscan_identify_scanner (dev) != 0) + { + DBG (1, "attach_scanner: scanner-identification failed\n"); + sanei_scsi_close (dev->sfd); + free (dev->buffer); + free (dev); + return SANE_STATUS_INVAL; + } + + /* Get MUD (via mode_sense), internal info (via get_internal_info), and + * initialize values */ + coolscan_initialize_values (dev); + + /* Why? */ + sanei_scsi_close (dev->sfd); + dev->sfd = -1; + + dev->sane.name = dev->devicename; + dev->sane.vendor = dev->vendor; + dev->sane.model = dev->product; + dev->sane.type = "slide scanner"; + + dev->x_range.min = SANE_FIX (0); + dev->x_range.quant = SANE_FIX (length_quant); + dev->x_range.max = SANE_FIX ((double) ((dev->xmaxpix) * length_quant)); + + dev->y_range.min = SANE_FIX (0.0); + dev->y_range.quant = SANE_FIX (length_quant); + dev->y_range.max = SANE_FIX ((double) ((dev->ymaxpix) * length_quant)); + + /* ...and this?? */ + dev->dpi_range.min = SANE_FIX (108); + dev->dpi_range.quant = SANE_FIX (0); + dev->dpi_range.max = SANE_FIX (dev->maxres); + DBG (10, "attach: dev->dpi_range.max = %f\n", + SANE_UNFIX (dev->dpi_range.max)); + + ++num_devices; + dev->next = first_dev; + first_dev = dev; + + if (devp) + { + *devp = dev; + } + + DBG (10, "attach_scanner done\n"); + + return SANE_STATUS_GOOD; +} + +static SANE_Status +attach_one (const char *devName) +{ + return attach_scanner(devName, 0); +} + +static RETSIGTYPE +sigterm_handler (int signal) +{ + signal = signal; + sanei_scsi_req_flush_all (); /* flush SCSI queue */ + _exit (SANE_STATUS_GOOD); +} + + +typedef struct Color_correct_s +{ int sum; /* number of pixels summed so far */ + double sumr; /* sum of red pixel values*/ + double sumi; /* sum of infrared pixel values*/ + double sumri; /* sum of red*ired pixel values*/ + double sumii; /* sum of ired*ired pixel values*/ + double sumrr; /* sum of ired*ired pixel values*/ + int mr; /* factor between red and ired values (*256) */ + int br; /* offset of ired values */ +} ColorCorrect; + +/* --------------------------------------------------------------- + + function: RGBIfix + + taks: Correct the infrared channel + + import: unsigned char * rgbimat - RGBI - matrix from scanner + int size - number of pixels to correct + int *lutr - lookup table for red correction + int *lutg - lookup table for red correction + int *lutb - lookup table for red correction + int *lutr - lookup table for red correction + + export: unsigned char * orgbimat - RGBI - corrected matrix + + written by: Andreas RICK 19.6.1999 + + ----------------------------------------------------------------*/ + +static int Calc_fix_LUT(Coolscan_t * s) +{ int uselutr,uselutg,uselutb,useluti; +/* static int irmulr= -34*25; */ + int irmulr= -64*25; + int irmulg= -1*25; + int irmulb= -0*25; + int irmuli= 256*25; + int div; + int i; + + irmulr=s->ired_red*(25); + irmulg=s->ired_green*(25); + irmulb=s->ired_blue*(25); + irmuli=25*256; + + if(s->LS==2) /* TODO: right conversion factors for 10 and 12 bit */ + { div=4; + } + else if(s->LS==3) + { div=16; + } + else + { return 0; + } + + memset(s->lutr, 0,256*4); + memset(s->lutg, 0,256*4); + memset(s->lutb, 0,256*4); + memset(s->luti, 0,256*4); + + for(i=0;i<s->lutlength;i++) + { if(s->gamma_bind) + { uselutr=uselutg=uselutb=useluti=s->gamma[i]/div; + } + else + { uselutr=s->gamma_r[i]/div; + uselutg=s->gamma_g[i]/div; + uselutb=s->gamma_b[i]/div; + useluti=s->gamma_r[i]/div; + } + s->lutr[uselutr]=(int)(irmulr*pow((double)i,(double)0.333333)); + s->lutg[uselutg]=(int)(irmulg*pow((double)i,(double)0.333333)); + s->lutb[uselutb]=(int)(irmulb*pow((double)i,(double)0.333333)); + s->luti[useluti]=(int)(irmuli*pow((double)i,(double)0.333333)); + if(uselutr<255) + { if(s->lutr[uselutr+1]==0) s->lutr[uselutr+1]=s->lutr[uselutr]; + } + if(uselutg<255) + { if(s->lutg[uselutg+1]==0) s->lutg[uselutg+1]=s->lutg[uselutg]; + } + if(uselutb<255) + { if(s->lutb[uselutb+1]==0) s->lutb[uselutb+1]=s->lutb[uselutb]; + } + if(useluti<255) + { if(s->luti[useluti+1]==0) s->luti[useluti+1]=s->luti[useluti]; + } + } + /* DEBUG + for(i=0;i<255;i++) + { fprintf(stderr,"%d %d %d %d\n" + ,s->lutr[i],s->lutg[i],s->lutb[i],s->luti[i]); + } + */ + return 1; +} + + + +/* --------------------------------------------------------------- + + function: RGBIfix + + taks: Correct the infrared channel + + import: unsigned char * rgbimat - RGBI - matrix from scanner + int size - number of pixels to correct + int *lutr - lookup table for red correction + int *lutg - lookup table for red correction + int *lutb - lookup table for red correction + int *lutr - lookup table for red correction + + export: unsigned char * orgbimat - RGBI - corrected matrix + + written by: Andreas RICK 19.6.1999 + + ----------------------------------------------------------------*/ + +static int RGBIfix(Coolscan_t * scanner, + unsigned char* rgbimat, + unsigned char* orgbimat, + int size, + int *lutr, + int *lutg, + int *lutb, + int *luti) + +{ + unsigned char *pr,*pg,*pb,*pi; + unsigned char *opr,*opg,*opb,*opi; + + int r,g,b,i; + int ii; + int x; + for(x=0;x<size;x++) + { + pr=rgbimat+x*4; + pg=pr+1; + pb=pg+1; + pi=pb+1; + opr=orgbimat+x*4; + opg=opr+1; + opb=opg+1; + opi=opb+1; + r=lutr[(*pr)]; + g=lutg[(*pg)]; + b=lutb[(*pb)]; + i=luti[(*pi)]; + ii= i-r-g-b; + (*opr)=(*pr); + (*opg)=(*pg); + (*opb)=(*pb); + if(ii<0)ii=0; + if(ii>255*256)ii=255*256; + if(scanner->negative) + { + (*opi)=(unsigned char)(255-(ii>>8)); + } + else + { + (*opi)=(unsigned char)(ii>>8); + } + } + return 1; +} + +/* --------------------------------------------------------------- + + function: RGBIfix16 + + taks: Correct the infrared channel for 16 bit images + (doesn't do anything for now) + + import: unsigned char * rgbimat - RGBI - matrix from scanner + int size - number of pixels to correct + int *lutr - lookup table for red correction + int *lutg - lookup table for red correction + int *lutb - lookup table for red correction + int *lutr - lookup table for red correction + + export: unsigned char * orgbimat - RGBI - corrected matrix + + written by: Andreas RICK 19.6.1999 + + ----------------------------------------------------------------*/ + +static int RGBIfix16(Coolscan_t * scanner, + unsigned short* rgbimat, + unsigned short* orgbimat, + int size, + int *lutr, + int *lutg, + int *lutb, + int *luti) + +{ + unsigned short *pr,*pg,*pb,*pi; + unsigned short *opr,*opg,*opb,*opi; + int x; + + scanner = scanner; lutr = lutr; lutg = lutg; lutb = lutb; luti = luti; + + for(x=0;x<size;x++) + { + pr=rgbimat+x*4; + pg=pr+1; + pb=pg+1; + pi=pb+1; + opr=orgbimat+x*4; + opg=opr+1; + opb=opg+1; + opi=opb+1; + (*opr)=(((*pr)&0x00ff)<<8)+(((*pr)&0xff00)>>8); + (*opg)=(((*pg)&0x00ff)<<8)+(((*pg)&0xff00)>>8); + (*opb)=(((*pb)&0x00ff)<<8)+(((*pb)&0xff00)>>8); + (*opi)=(((*pi)&0x00ff)<<8)+(((*pi)&0xff00)>>8); + } + return 1; +} + + +/* --------------------------------------------------------------- + + function: rgb2g + + taks: Convert RGB data to grey + + import: unsigned char * rgbimat - RGB - matrix from scanner + int size - size of input data (num pixel) + + export: unsigned char * gomat - Grey matrix + + written by: Andreas RICK 13.7.1999 + + ----------------------------------------------------------------*/ +#define RtoG ((int)(0.27*256)) +#define GtoG ((int)(0.54*256)) +#define BtoG ((int)(0.19*256)) + +static int rgb2g(unsigned char* rgbimat,unsigned char* gomat, + int size) + +{ unsigned char *pr,*pg,*pb; + unsigned char *opg; + + int g; + int x; + for(x=0;x<size;x++) + { + pr=rgbimat+x*3; + pg=pr+1; + pb=pg+1; + opg=gomat+x; + g= RtoG*(*pr) + GtoG*(*pg) + BtoG*(*pb); + (*opg)=(unsigned char)(g>>8); + } + return 1; +} + + +/* --------------------------------------------------------------- + + function: RGBIfix1 + + taks: Correct the infrared channel. + The input image data is the output of scaning + with LUT. To calculate the original values + the lutr and luti is applied. + The infrared values is corrected by: + + Ir=mr*lutr(r)+luti(i) + + import: unsigned char * rgbimat - RGBI - matrix from scanner + int size - number of pixels to correct + ColorCorrect *cc, + int *lutr - lookup table for red correction + int *luti - lookup table for ired correction + + export: unsigned char * orgbimat - RGBI - corrected matrix + + written by: Andreas RICK 3.7.1999 + + ----------------------------------------------------------------*/ +#if 0 +static int RGBIfix1(unsigned char* rgbimat,unsigned char* orgbimat, + int size, + int *lutr, + int *lutg, + int *lutb, + int *luti) + +{ unsigned char *pr,*pg,*pb,*pi; + unsigned char *opr,*opg,*opb,*opi; + ColorCorrect cc; + int r,i; + static int thresi=100; + int ii; + int x; + + lutg = lutg; lutb = lutb; + + /* calculate regression between r and ir */ + cc.sum=0; + cc.sumr=cc.sumii=cc.sumrr=cc.sumi=cc.sumri=0.0; + for(x=0;x<size;x++) + { pr=rgbimat+x*4; + pi=pr+3; + r=lutr[(*pr)]; + i=luti[(*pi)]; + /* r=(*pr); + i=(*pi); */ + if((*pi)>thresi) + { cc.sum++; + cc.sumr+=r; + cc.sumii+=(i*i); + cc.sumrr+=(r*r); + cc.sumi+=i; + cc.sumri+=(i*r); + } + } + if((cc.sumii!=0)&&(cc.sum!=0)) + { double dn,dz,dm; + dz=(cc.sumri-cc.sumr*cc.sumi/cc.sum); + dn=(cc.sumrr-cc.sumr*cc.sumr/cc.sum); + DBG (2, "Reg:dz:%e dn:%e\n",dz,dn); + if(dn!=0) + { dm=(dz/dn); + cc.mr=(int)(dm*1024); + } + else + { cc.mr=0; + dm=0; + } + cc.br=(int)((cc.sumi-dm*cc.sumr)/cc.sum); + } + else + { cc.mr=0; + } + DBG (2, "Regression: size:%d I=%d/1024*R b:%d s:%d sr:%e si:%e sii:%e sri:%e srr:%e\n", + size,cc.mr,cc.br,cc.sum,cc.sumr,cc.sumi,cc.sumii,cc.sumri,cc.sumrr); + for(x=0;x<size;x++) + { + + pr=rgbimat+x*4; + pg=pr+1; + pb=pg+1; + pi=pb+1; + opr=orgbimat+x*4; + opg=opr+1; + opb=opg+1; + opi=opb+1; + r=lutr[(*pr)]; + i=luti[(*pi)]; + /* r=(*pr); + i=(*pi); */ + ii= ((i-((r*cc.mr)>>10)-cc.br)>>2) +128; + (*opr)=(*pr); + (*opg)=(*pg); + (*opb)=(*pb); + if(ii<0) ii=0; + if(ii>255) ii=255; + (*opi)=(unsigned char)(ii); + } + return 1; +} + +#endif +/* This function is executed as a child process. */ +static int +reader_process (void *data ) +{ + int status; + unsigned int i; + unsigned char h; + unsigned int data_left; + unsigned int data_to_read; + unsigned int data_to_write; + FILE *fp; + sigset_t sigterm_set, ignore_set; + struct SIGACTION act; + unsigned int bpl, linesPerBuf, lineOffset; + unsigned char r_data, g_data, b_data; + unsigned int j, line; + Coolscan_t * scanner = (Coolscan_t*)data; + + if (sanei_thread_is_forked ()) + { + DBG (10, "reader_process started (forked)\n"); + close (scanner->pipe); + scanner->pipe = -1; + + sigfillset ( &ignore_set ); + sigdelset ( &ignore_set, SIGTERM ); +#if defined (__APPLE__) && defined (__MACH__) + sigdelset ( &ignore_set, SIGUSR2 ); +#endif + sigprocmask( SIG_SETMASK, &ignore_set, 0 ); + + memset (&act, 0, sizeof (act)); + sigaction (SIGTERM, &act, 0); + } + else + { + DBG (10, "reader_process started (as thread)\n"); + } + + sigemptyset (&sigterm_set); + sigaddset (&sigterm_set, SIGTERM); + + fp = fdopen ( scanner->reader_fds, "w"); + if (!fp) + { + DBG (1, "reader_process: couldn't open pipe!\n"); + return 1; + } + + DBG (10, "reader_process: starting to READ data\n"); + + data_left = scan_bytes_per_line (scanner) * + lines_per_scan (scanner); + + /*scanner->row_bufsize = sanei_scsi_max_request_size;*/ + coolscan_trim_rowbufsize (scanner); /* trim bufsize */ + + DBG (10, "reader_process: reading %u bytes in blocks of %u bytes\n", + data_left, scanner->row_bufsize); + + memset (&act, 0, sizeof (act)); + act.sa_handler = sigterm_handler; + sigaction (SIGTERM, &act, 0); + /* wait_scanner(scanner); */ + do + { + data_to_read = (data_left < scanner->row_bufsize) ? + data_left : scanner->row_bufsize; + + data_to_write=data_to_read; + + status = coolscan_read_data_block (scanner + ,R_datatype_imagedata,data_to_read); + if (status == 0) + { + continue; + } + if (status == -1) + { + DBG (1, "reader_process: unable to get image data from scanner!\n"); + fclose (fp); + return (-1); + } + + if (scanner->LS == 1) { /* mirror image for LS-1000 */ + bpl = scan_bytes_per_line(scanner); + linesPerBuf = data_to_read / bpl; + + for (line = 0, lineOffset = 0; line < linesPerBuf; + line++, lineOffset += bpl ) { + + if (scanner->colormode == RGB) { + for (j = 0; j < bpl/2 ; j += 3) { + r_data=scanner->buffer[lineOffset + j]; + g_data=scanner->buffer[lineOffset + j + 1]; + b_data=scanner->buffer[lineOffset + j + 2]; + + scanner->buffer[lineOffset + j] = + scanner->buffer[lineOffset + bpl -1 - j - 2 ]; + scanner->buffer[lineOffset + j + 1] = + scanner->buffer[lineOffset + bpl -1 - j - 1 ]; + scanner->buffer[lineOffset + j + 2] = + scanner->buffer[lineOffset + bpl -1 - j ]; + + scanner->buffer[lineOffset + bpl -1 - j - 2 ] = r_data; + scanner->buffer[lineOffset + bpl -1 - j - 1] = g_data; + scanner->buffer[lineOffset + bpl -1 - j] = b_data; + } + } + else { + for (j = 0; j < bpl/2; j++) { + r_data=scanner->buffer[lineOffset + j]; + scanner->buffer[lineOffset + j] = + scanner->buffer[lineOffset + bpl - 1 - j]; + scanner->buffer[lineOffset + bpl - 1 - j] = r_data; + } + } + } + } + if(scanner->colormode==RGBI) + { /* Correct Infrared Channel */ + if(scanner->bits_per_color>8) + { + RGBIfix16(scanner, (unsigned short * ) scanner->buffer, + (unsigned short * )scanner->obuffer, + data_to_read/8,scanner->lutr, + scanner->lutg,scanner->lutb,scanner->luti); + } + else + { + RGBIfix(scanner,scanner->buffer,scanner->obuffer, + data_to_read/4,scanner->lutr, + scanner->lutg,scanner->lutb,scanner->luti); + } + } + else if((scanner->colormode==GREYSCALE)&&(scanner->LS>=2)) + { /* Convert to Grey */ + data_to_write/=3; + rgb2g(scanner->buffer,scanner->obuffer,data_to_write); + } + else + { /* or just copy */ + memcpy (scanner->obuffer, scanner->buffer,data_to_read); + } + if((!scanner->low_byte_first)&&(scanner->bits_per_color>8)) + { for(i=0;i<data_to_write;i++) /* inverse byteorder */ + { h=scanner->obuffer[i]; + scanner->obuffer[i]=scanner->obuffer[i+1]; + i++; + scanner->obuffer[i]=h; + } + } + fwrite (scanner->obuffer, 1, data_to_write, fp); + fflush (fp); + data_left -= data_to_read; + DBG (10, "reader_process: buffer of %d bytes read; %d bytes to go\n", + data_to_read, data_left); + } + while (data_left); + + fclose (fp); + + DBG (10, "reader_process: finished reading data\n"); + + return 0; +} + +static SANE_Status +init_options (Coolscan_t * scanner) +{ + int i; + int bit_depths; + + DBG (10, "init_options\n"); + + memset (scanner->opt, 0, sizeof (scanner->opt)); + + for (i = 0; i < NUM_OPTIONS; ++i) + { + scanner->opt[i].size = sizeof (SANE_Word); + scanner->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + + scanner->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; + scanner->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; + scanner->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; + scanner->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + + /* "Mode" group: */ + scanner->opt[OPT_MODE_GROUP].title = "Scan Mode"; + scanner->opt[OPT_MODE_GROUP].desc = ""; + scanner->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + scanner->opt[OPT_MODE_GROUP].cap = 0; + scanner->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* scan mode */ + scanner->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; + scanner->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; + scanner->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; + scanner->opt[OPT_MODE].type = SANE_TYPE_STRING; + if(scanner->LS<2) + { scanner->opt[OPT_MODE].size = max_string_size (scan_mode_list_LS20); + scanner->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + scanner->opt[OPT_MODE].constraint.string_list = scan_mode_list_LS20; + } + else + { scanner->opt[OPT_MODE].size = max_string_size (scan_mode_list_LS30); + scanner->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + scanner->opt[OPT_MODE].constraint.string_list = scan_mode_list_LS30; + } + + /* source */ + source_list[0] = "Slide"; + source_list[1] = "Automatic Slide Feeder"; + source_list[2] = NULL; + if (!scanner->autofeeder) + { + scanner->opt[OPT_SOURCE].cap = SANE_CAP_INACTIVE; + } + + scanner->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE; + scanner->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE; + scanner->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE; + scanner->opt[OPT_SOURCE].type = SANE_TYPE_STRING; + scanner->opt[OPT_SOURCE].size = max_string_size (source_list); + scanner->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + scanner->opt[OPT_SOURCE].constraint.string_list = source_list; + + /* negative */ + scanner->opt[OPT_TYPE].name = "type"; + scanner->opt[OPT_TYPE].title = "Film type"; + scanner->opt[OPT_TYPE].desc = + "Select the film type (positive (slide) or negative)"; + scanner->opt[OPT_TYPE].type = SANE_TYPE_STRING; + scanner->opt[OPT_TYPE].size = max_string_size (type_list); + scanner->opt[OPT_TYPE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + scanner->opt[OPT_TYPE].constraint.string_list = type_list; + + scanner->opt[OPT_PRESCAN].name = "prescan"; + scanner->opt[OPT_PRESCAN].title = "Prescan"; + scanner->opt[OPT_PRESCAN].desc = + "Perform a prescan during preview"; + scanner->opt[OPT_PRESCAN].type = SANE_TYPE_BOOL; + scanner->opt[OPT_PRESCAN].unit = SANE_UNIT_NONE; + + scanner->opt[OPT_PRESCAN_NOW].name = "prescan now"; + scanner->opt[OPT_PRESCAN_NOW].title = "Prescan now"; + scanner->opt[OPT_PRESCAN_NOW].desc = + "Perform a prescan now"; + scanner->opt[OPT_PRESCAN_NOW].type = SANE_TYPE_BUTTON; + scanner->opt[OPT_PRESCAN_NOW].unit = SANE_UNIT_NONE; + scanner->opt[OPT_PRESCAN_NOW].size = 0; + scanner->opt[OPT_PRESCAN_NOW].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + scanner->opt[OPT_PRESCAN_NOW].constraint_type = SANE_CONSTRAINT_NONE; + scanner->opt[OPT_PRESCAN_NOW].constraint.string_list = 0; + + /* bit depth */ + + bit_depths=0; + bit_depth_list[++bit_depths] = 8; + if (scanner->LS==2) + { + bit_depth_list[++bit_depths] = 10; + } + if (scanner->LS==3) + { + bit_depth_list[++bit_depths] = 12; + } + + bit_depth_list[0] = bit_depths; + + scanner->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH; + scanner->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH; + scanner->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH; + scanner->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT; + scanner->opt[OPT_BIT_DEPTH].unit = SANE_UNIT_BIT; + scanner->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST; + scanner->opt[OPT_BIT_DEPTH].constraint.word_list = bit_depth_list; + + /* resolution */ + scanner->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + scanner->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; + scanner->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + scanner->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; + scanner->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; + scanner->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; + scanner->opt[OPT_RESOLUTION].constraint.word_list = resolution_list; + + scanner->opt[OPT_PREVIEW_RESOLUTION].name = "preview-resolution"; + scanner->opt[OPT_PREVIEW_RESOLUTION].title = "Preview resolution"; + scanner->opt[OPT_PREVIEW_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + scanner->opt[OPT_PREVIEW_RESOLUTION].type = SANE_TYPE_INT; + scanner->opt[OPT_PREVIEW_RESOLUTION].unit = SANE_UNIT_DPI; + scanner->opt[OPT_PREVIEW_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; + scanner->opt[OPT_PREVIEW_RESOLUTION].constraint.word_list = resolution_list; + + /* "Geometry" group: */ + scanner->opt[OPT_GEOMETRY_GROUP].title = "Geometry"; + scanner->opt[OPT_GEOMETRY_GROUP].desc = ""; + scanner->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; + scanner->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED; + scanner->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* top-left x */ + scanner->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; + scanner->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; + scanner->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; + scanner->opt[OPT_TL_X].type = SANE_TYPE_FIXED; + scanner->opt[OPT_TL_X].unit = SANE_UNIT_MM; + scanner->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_TL_X].constraint.range = &(scanner->x_range); + + /* top-left y */ + scanner->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; + scanner->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; + scanner->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; + scanner->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; + scanner->opt[OPT_TL_Y].unit = SANE_UNIT_MM; + scanner->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_TL_Y].constraint.range = &(scanner->y_range); + + /* bottom-right x */ + scanner->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; + scanner->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; + scanner->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; + scanner->opt[OPT_BR_X].type = SANE_TYPE_FIXED; + scanner->opt[OPT_BR_X].unit = SANE_UNIT_MM; + scanner->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_BR_X].constraint.range = &(scanner->x_range); + + /* bottom-right y */ + scanner->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; + scanner->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; + scanner->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; + scanner->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; + scanner->opt[OPT_BR_Y].unit = SANE_UNIT_MM; + scanner->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_BR_Y].constraint.range = &(scanner->y_range); + + + /* ------------------------------ */ + + /* "Enhancement" group: */ + scanner->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement"; + scanner->opt[OPT_ENHANCEMENT_GROUP].desc = ""; + scanner->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; + scanner->opt[OPT_ENHANCEMENT_GROUP].cap = 0; + scanner->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + + scanner->opt[OPT_GAMMA_BIND].name = "gamma-bind"; + scanner->opt[OPT_GAMMA_BIND].title = "Gamma bind"; + scanner->opt[OPT_GAMMA_BIND].desc = + "Use same gamma correction for all colours"; + scanner->opt[OPT_GAMMA_BIND].type = SANE_TYPE_BOOL; + scanner->opt[OPT_GAMMA_BIND].unit = SANE_UNIT_NONE; + + + scanner->opt[OPT_ANALOG_GAMMA].name = "analog_gamma"; + scanner->opt[OPT_ANALOG_GAMMA].title = "Analog Gamma"; + scanner->opt[OPT_ANALOG_GAMMA].desc = "Analog Gamma"; + scanner->opt[OPT_ANALOG_GAMMA].type = SANE_TYPE_BOOL; + scanner->opt[OPT_ANALOG_GAMMA].unit = SANE_UNIT_NONE; + if (!scanner->analoggamma) + { + scanner->opt[OPT_ANALOG_GAMMA].cap = SANE_CAP_INACTIVE; + } + + scanner->opt[OPT_AVERAGING].name = "averaging"; + scanner->opt[OPT_AVERAGING].title = "Averaging"; + scanner->opt[OPT_AVERAGING].desc = "Averaging"; + scanner->opt[OPT_AVERAGING].type = SANE_TYPE_BOOL; + scanner->opt[OPT_AVERAGING].unit = SANE_UNIT_NONE; + + + scanner->opt[OPT_RGB_CONTROL].name = "rgb-control"; + scanner->opt[OPT_RGB_CONTROL].title = "RGB control"; + scanner->opt[OPT_RGB_CONTROL].desc = + "toggles brightness/contrast control over individual colours"; + scanner->opt[OPT_RGB_CONTROL].type = SANE_TYPE_BOOL; + scanner->opt[OPT_RGB_CONTROL].unit = SANE_UNIT_NONE; + if(scanner->LS>=2) + { scanner->opt[OPT_RGB_CONTROL].cap |= SANE_CAP_INACTIVE; + } + + + + /* brightness */ + scanner->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; + scanner->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; + scanner->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + scanner->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; + scanner->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; + scanner->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_BRIGHTNESS].constraint.range = &brightness_range; + if(scanner->LS>=2) + { scanner->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + } + + + scanner->opt[OPT_R_BRIGHTNESS].name = "red-brightness"; + scanner->opt[OPT_R_BRIGHTNESS].title = "Red brightness"; + scanner->opt[OPT_R_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + scanner->opt[OPT_R_BRIGHTNESS].type = SANE_TYPE_INT; + scanner->opt[OPT_R_BRIGHTNESS].unit = SANE_UNIT_NONE; + scanner->opt[OPT_R_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_R_BRIGHTNESS].constraint.range = &brightness_range; + scanner->opt[OPT_R_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_G_BRIGHTNESS].name = "green-brightness"; + scanner->opt[OPT_G_BRIGHTNESS].title = "Green brightness"; + scanner->opt[OPT_G_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + scanner->opt[OPT_G_BRIGHTNESS].type = SANE_TYPE_INT; + scanner->opt[OPT_G_BRIGHTNESS].unit = SANE_UNIT_NONE; + scanner->opt[OPT_G_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_G_BRIGHTNESS].constraint.range = &brightness_range; + scanner->opt[OPT_G_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_B_BRIGHTNESS].name = "blue-brightness"; + scanner->opt[OPT_B_BRIGHTNESS].title = "Blue brightness"; + scanner->opt[OPT_B_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + scanner->opt[OPT_B_BRIGHTNESS].type = SANE_TYPE_INT; + scanner->opt[OPT_B_BRIGHTNESS].unit = SANE_UNIT_NONE; + scanner->opt[OPT_B_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_B_BRIGHTNESS].constraint.range = &brightness_range; + scanner->opt[OPT_B_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + + /* contrast */ + scanner->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST; + scanner->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; + scanner->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; + scanner->opt[OPT_CONTRAST].type = SANE_TYPE_INT; + scanner->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE; + scanner->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_CONTRAST].constraint.range = &contrast_range; + if(scanner->LS>=2) + { scanner->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; + } + + + scanner->opt[OPT_R_CONTRAST].name = "red-contrast"; + scanner->opt[OPT_R_CONTRAST].title = "Red contrast"; + scanner->opt[OPT_R_CONTRAST].desc = SANE_DESC_CONTRAST; + scanner->opt[OPT_R_CONTRAST].type = SANE_TYPE_INT; + scanner->opt[OPT_R_CONTRAST].unit = SANE_UNIT_NONE; + scanner->opt[OPT_R_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_R_CONTRAST].constraint.range = &contrast_range; + scanner->opt[OPT_R_CONTRAST].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_G_CONTRAST].name = "green-contrast"; + scanner->opt[OPT_G_CONTRAST].title = "Green contrast"; + scanner->opt[OPT_G_CONTRAST].desc = SANE_DESC_CONTRAST; + scanner->opt[OPT_G_CONTRAST].type = SANE_TYPE_INT; + scanner->opt[OPT_G_CONTRAST].unit = SANE_UNIT_NONE; + scanner->opt[OPT_G_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_G_CONTRAST].constraint.range = &contrast_range; + scanner->opt[OPT_G_CONTRAST].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_B_CONTRAST].name = "blue-contrast"; + scanner->opt[OPT_B_CONTRAST].title = "Blue contrast"; + scanner->opt[OPT_B_CONTRAST].desc = SANE_DESC_CONTRAST; + scanner->opt[OPT_B_CONTRAST].type = SANE_TYPE_INT; + scanner->opt[OPT_B_CONTRAST].unit = SANE_UNIT_NONE; + scanner->opt[OPT_B_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_B_CONTRAST].constraint.range = &contrast_range; + scanner->opt[OPT_B_CONTRAST].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_EXPOSURE].name = "exposure"; + scanner->opt[OPT_EXPOSURE].title = "Exposure"; + scanner->opt[OPT_EXPOSURE].desc = ""; + scanner->opt[OPT_EXPOSURE].type = SANE_TYPE_INT; + scanner->opt[OPT_EXPOSURE].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_EXPOSURE].unit = SANE_UNIT_PERCENT; + scanner->opt[OPT_EXPOSURE].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_EXPOSURE].constraint.range = &exposure_range; + + scanner->opt[OPT_R_EXPOSURE].name = "red-exposure"; + scanner->opt[OPT_R_EXPOSURE].title = "Red exposure"; + scanner->opt[OPT_R_EXPOSURE].desc = ""; + scanner->opt[OPT_R_EXPOSURE].type = SANE_TYPE_INT; + scanner->opt[OPT_R_EXPOSURE].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_R_EXPOSURE].unit = SANE_UNIT_PERCENT; + scanner->opt[OPT_R_EXPOSURE].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_R_EXPOSURE].constraint.range = &exposure_range; + + scanner->opt[OPT_G_EXPOSURE].name = "green-exposure"; + scanner->opt[OPT_G_EXPOSURE].title = "Green exposure"; + scanner->opt[OPT_G_EXPOSURE].desc = ""; + scanner->opt[OPT_G_EXPOSURE].type = SANE_TYPE_INT; + scanner->opt[OPT_G_EXPOSURE].unit = SANE_UNIT_PERCENT; + scanner->opt[OPT_G_EXPOSURE].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_G_EXPOSURE].constraint.range = &exposure_range; + scanner->opt[OPT_G_EXPOSURE].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_B_EXPOSURE].name = "blue-exposure"; + scanner->opt[OPT_B_EXPOSURE].title = "Blue exposre"; + scanner->opt[OPT_B_EXPOSURE].desc = ""; + scanner->opt[OPT_B_EXPOSURE].type = SANE_TYPE_INT; + scanner->opt[OPT_B_EXPOSURE].unit = SANE_UNIT_PERCENT; + scanner->opt[OPT_B_EXPOSURE].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_B_EXPOSURE].constraint.range = &exposure_range; + scanner->opt[OPT_B_EXPOSURE].cap |= SANE_CAP_INACTIVE; + if(scanner->LS>=2) + { scanner->opt[OPT_R_EXPOSURE].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_G_EXPOSURE].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_B_EXPOSURE].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_EXPOSURE].cap |= SANE_CAP_INACTIVE; + } + + scanner->opt[OPT_R_SHIFT].name = "red-shift"; + scanner->opt[OPT_R_SHIFT].title = "Red shift"; + scanner->opt[OPT_R_SHIFT].desc = ""; + scanner->opt[OPT_R_SHIFT].type = SANE_TYPE_INT; + scanner->opt[OPT_R_SHIFT].unit = SANE_UNIT_NONE; + scanner->opt[OPT_R_SHIFT].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_R_SHIFT].constraint.range = &shift_range; + if(scanner->LS>=2) + { scanner->opt[OPT_R_SHIFT].cap |= SANE_CAP_INACTIVE; + } + + + scanner->opt[OPT_G_SHIFT].name = "green-shift"; + scanner->opt[OPT_G_SHIFT].title = "Green shift"; + scanner->opt[OPT_G_SHIFT].desc = ""; + scanner->opt[OPT_G_SHIFT].type = SANE_TYPE_INT; + scanner->opt[OPT_G_SHIFT].unit = SANE_UNIT_NONE; + scanner->opt[OPT_G_SHIFT].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_G_SHIFT].constraint.range = &shift_range; + if(scanner->LS>=2) + { scanner->opt[OPT_G_SHIFT].cap |= SANE_CAP_INACTIVE; + } + + + scanner->opt[OPT_B_SHIFT].name = "blue-shift"; + scanner->opt[OPT_B_SHIFT].title = "Blue shift"; + scanner->opt[OPT_B_SHIFT].desc = ""; + scanner->opt[OPT_B_SHIFT].type = SANE_TYPE_INT; + scanner->opt[OPT_B_SHIFT].unit = SANE_UNIT_NONE; + scanner->opt[OPT_B_SHIFT].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_B_SHIFT].constraint.range = &shift_range; + if(scanner->LS>=2) + { scanner->opt[OPT_B_SHIFT].cap |= SANE_CAP_INACTIVE; + } + + /* R+G+B gamma vector */ + scanner->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR; + scanner->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR; + scanner->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR; + scanner->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT; + if (scanner->LS == 1) + { + scanner->opt[OPT_GAMMA_VECTOR].cap = SANE_CAP_INACTIVE; + } + scanner->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE; + switch(scanner->LS) + { case 0: + scanner->opt[OPT_GAMMA_VECTOR].constraint.range = &gamma_range_8; + scanner->lutlength=2048; + break; + case 1: + scanner->opt[OPT_GAMMA_VECTOR].constraint.range = &gamma_range_9; + scanner->lutlength=512; + break; + case 2: + scanner->opt[OPT_GAMMA_VECTOR].constraint.range = &gamma_range_10; + scanner->lutlength=1024; + break; + case 3: + scanner->opt[OPT_GAMMA_VECTOR].constraint.range = &gamma_range_12; + scanner->lutlength=4096; + break; + } + scanner->opt[OPT_GAMMA_VECTOR].size = scanner->lutlength * sizeof (SANE_Word); + scanner->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE; + + /* red gamma vector */ + scanner->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R; + scanner->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R; + scanner->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R; + scanner->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT; + scanner->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE; + switch(scanner->LS) + { case 0: + scanner->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range_8; + scanner->lutlength=2048; + break; + case 1: + scanner->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range_9; + scanner->lutlength=512; + break; + case 2: + scanner->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range_10; + scanner->lutlength=1024; + break; + case 3: + scanner->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range_12; + scanner->lutlength=4096; + break; + } + scanner->opt[OPT_GAMMA_VECTOR_R].size = scanner->lutlength * sizeof (SANE_Word); + scanner->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE; + + /* green gamma vector */ + scanner->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G; + scanner->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G; + scanner->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G; + scanner->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT; + scanner->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE; + switch(scanner->LS) + { case 0: + scanner->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range_8; + scanner->lutlength=2048; + break; + case 1: + scanner->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range_9; + scanner->lutlength=512; + break; + case 2: + scanner->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range_10; + scanner->lutlength=1024; + break; + case 3: + scanner->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range_12; + scanner->lutlength=4096; + break; + } + scanner->opt[OPT_GAMMA_VECTOR_G].size = scanner->lutlength * sizeof (SANE_Word); + scanner->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE; + + /* blue gamma vector */ + scanner->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B; + scanner->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B; + scanner->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B; + scanner->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT; + scanner->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE; + switch(scanner->LS) + { case 0: + scanner->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range_8; + scanner->lutlength=2048; + break; + case 1: + scanner->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range_9; + scanner->lutlength=512; + break; + case 2: + scanner->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range_10; + scanner->lutlength=1024; + break; + case 3: + scanner->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range_12; + scanner->lutlength=4096; + break; + } + scanner->opt[OPT_GAMMA_VECTOR_B].size = scanner->lutlength * sizeof (SANE_Word); + scanner->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE; + + + /* ------------------------------ */ + + /* "Advanced" group: */ + scanner->opt[OPT_ADVANCED_GROUP].title = "Advanced"; + scanner->opt[OPT_ADVANCED_GROUP].desc = ""; + scanner->opt[OPT_ADVANCED_GROUP].type = SANE_TYPE_GROUP; + scanner->opt[OPT_ADVANCED_GROUP].cap = SANE_CAP_ADVANCED; + scanner->opt[OPT_ADVANCED_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* preview */ + scanner->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW; + scanner->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; + scanner->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; + scanner->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL; + + /* Autofocus */ + scanner->opt[OPT_AUTOFOCUS].name = "Autofocus"; + scanner->opt[OPT_AUTOFOCUS].title ="Autofocus"; + scanner->opt[OPT_AUTOFOCUS].desc = "When to do autofocussing"; + scanner->opt[OPT_AUTOFOCUS].type = SANE_TYPE_STRING; + scanner->opt[OPT_AUTOFOCUS].size = max_string_size (autofocus_mode_list); + scanner->opt[OPT_AUTOFOCUS].constraint_type = SANE_CONSTRAINT_STRING_LIST; + scanner->opt[OPT_AUTOFOCUS].constraint.string_list = autofocus_mode_list; + + scanner->opt[OPT_IRED_RED].name = "IRED cor. red"; + scanner->opt[OPT_IRED_RED].title ="IRED cor. red"; + scanner->opt[OPT_IRED_RED].desc = "Correction of infrared from red"; + scanner->opt[OPT_IRED_RED].type = SANE_TYPE_INT; + scanner->opt[OPT_IRED_RED].unit = SANE_UNIT_NONE; + scanner->opt[OPT_IRED_RED].constraint_type = SANE_CONSTRAINT_RANGE; + scanner->opt[OPT_IRED_RED].constraint.range = &gamma_range_8; + scanner->opt[OPT_IRED_RED].cap |= SANE_CAP_ADVANCED; + if(scanner->LS<2) + { scanner->opt[OPT_IRED_RED].cap |= SANE_CAP_INACTIVE; + } + + + + /* scanner->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT; */ + return SANE_STATUS_GOOD; +} + + +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) +{ + char dev_name[PATH_MAX]; + size_t len; + FILE *fp; + + authorize = authorize; + + DBG_INIT (); + sanei_thread_init (); + + DBG (10, "sane_init\n"); + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); + + fp = sanei_config_open (COOLSCAN_CONFIG_FILE); + if (!fp) + { + attach_scanner ("/dev/scanner", 0); /* no config-file: /dev/scanner */ + return SANE_STATUS_GOOD; + } + + while (sanei_config_read (dev_name, sizeof (dev_name), fp)) + { + if (dev_name[0] == '#') + continue; /* ignore line comments */ + len = strlen (dev_name); + + if (!len) + continue; /* ignore empty lines */ + + sanei_config_attach_matching_devices (dev_name, attach_one); + /*attach_scanner (dev_name, 0);*/ + } + fclose (fp); + return SANE_STATUS_GOOD; +} + +void +sane_exit (void) +{ + Coolscan_t *dev, *next; + + DBG (10, "sane_exit\n"); + + for (dev = first_dev; dev; dev = next) + { + next = dev->next; + free (dev->devicename); + free (dev->buffer); + free (dev->obuffer); + free (dev); + } +} + +/* ----------------------------- SANE GET DEVICES -------------------------- */ +SANE_Status +sane_get_devices (const SANE_Device *** device_list, + SANE_Bool local_only) +{ + + static const SANE_Device **devlist = 0; + Coolscan_t *dev; + int i; + + local_only = local_only; + + DBG (10, "sane_get_devices\n"); + + if (devlist) + free (devlist); + + devlist = calloc (num_devices + 1, sizeof (devlist[0])); + if (!devlist) + return SANE_STATUS_NO_MEM; + + i = 0; + + for (dev = first_dev; i < num_devices; dev = dev->next) + devlist[i++] = &dev->sane; + + devlist[i++] = 0; + + *device_list = devlist; + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_open (SANE_String_Const devicename, SANE_Handle * handle) +{ + Coolscan_t *dev; + SANE_Status status; + + DBG (10, "sane_open\n"); + + if (devicename[0]) + { /* search for devicename */ + for (dev = first_dev; dev; dev = dev->next) + { + if (strcmp (dev->sane.name, devicename) == 0) + { + break; + } + } + + if (!dev) + { + status = attach_scanner (devicename, &dev); + if (status != SANE_STATUS_GOOD) + { + return status; + } + } + } + else + { + dev = first_dev; /* empty devicname -> use first device */ + } + + if (!dev) + return SANE_STATUS_INVAL; + + dev->sfd = -1; + dev->pipe = -1; + dev->scanning = SANE_FALSE; + + init_options (dev); + *handle = dev; + return SANE_STATUS_GOOD; +} + +void +sane_close (SANE_Handle handle) +{ + DBG (10, "sane_close\n"); + if (((Coolscan_t *) handle)->scanning) + do_cancel (handle); +} + +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) +{ + Coolscan_t *scanner = handle; + + DBG (10, "sane_get_option_descriptor %d\n", option); + + if ((unsigned) option >= NUM_OPTIONS) + return 0; + return &scanner->opt[option]; +} + +/* + static void + worddump(char *comment, SANE_Word * p, int l) + { + int i; + char line[128]; + char *ptr; + + DBG (5, "%s\n", comment); + ptr = line; + for (i = 0; i < l; i++, p++) + { + if ((i % 8) == 0) + { + if (ptr != line) + { + *ptr = '\0'; + DBG (5, "%s\n", line); + ptr = line; + } + sprintf (ptr, "%3.3d:", i); + ptr += 4; + } + sprintf (ptr, " %4.4d", *p); + ptr += 5; + } + *ptr = '\0'; + DBG (5, "%s\n", line); + } + */ +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, + SANE_Action action, void *val, + SANE_Int * info) +{ + Coolscan_t *scanner = handle; + SANE_Status status; + SANE_Word cap; + + if (info) + *info = 0; + + if (scanner->scanning) + return SANE_STATUS_DEVICE_BUSY; + + if (option >= NUM_OPTIONS) + return SANE_STATUS_INVAL; + + cap = scanner->opt[option].cap; + + + if (action == SANE_ACTION_GET_VALUE) + { + DBG (10, "sane_control_option %d, get value\n", option); + switch (option) + { + /* word options: */ + case OPT_TL_X: + *(SANE_Word *) val = SANE_FIX (iluToMm (scanner->tlx)); + return SANE_STATUS_GOOD; + + case OPT_TL_Y: + *(SANE_Word *) val = SANE_FIX (iluToMm (scanner->tly)); + return SANE_STATUS_GOOD; + + case OPT_BR_X: + *(SANE_Word *) val = SANE_FIX (iluToMm (scanner->brx)); + return SANE_STATUS_GOOD; + + case OPT_BR_Y: + *(SANE_Word *) val = SANE_FIX (iluToMm (scanner->bry)); + return SANE_STATUS_GOOD; + + case OPT_PREVIEW: + *(SANE_Word *) val = scanner->preview; + return SANE_STATUS_GOOD; + + case OPT_AUTOFOCUS: + switch(scanner->autofocus) + { case AF_NEVER: strcpy (val,neverStr); + break; + case AF_PREVIEW:strcpy (val,previewStr); + break; + case AF_SCAN:if(scanner->LS>=2) strcpy (val,scanStr); + break; + case AF_PREANDSCAN:if(scanner->LS>=2) strcpy (val,preandscanStr); + break; + } + return SANE_STATUS_GOOD; + + case OPT_NUM_OPTS: + *(SANE_Word *) val = NUM_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_RESOLUTION: + *(SANE_Word *) val = resDivToVal (scanner->x_nres); + return SANE_STATUS_GOOD; + + case OPT_PREVIEW_RESOLUTION: + *(SANE_Word *) val = resDivToVal (scanner->x_p_nres); + return SANE_STATUS_GOOD; + + case OPT_BIT_DEPTH: + *(SANE_Word *) val = scanner->bits_per_color; + return SANE_STATUS_GOOD; + + case OPT_CONTRAST: + *(SANE_Word *) val = scanner->contrast - 128; + return SANE_STATUS_GOOD; + + case OPT_R_CONTRAST: + *(SANE_Word *) val = scanner->contrast_R - 128; + return SANE_STATUS_GOOD; + + case OPT_G_CONTRAST: + *(SANE_Word *) val = scanner->contrast_G - 128; + return SANE_STATUS_GOOD; + + case OPT_B_CONTRAST: + *(SANE_Word *) val = scanner->contrast_B - 128; + return SANE_STATUS_GOOD; + + case OPT_BRIGHTNESS: + *(SANE_Word *) val = scanner->brightness - 128; + return SANE_STATUS_GOOD; + + case OPT_R_BRIGHTNESS: + *(SANE_Word *) val = scanner->brightness_R - 128; + return SANE_STATUS_GOOD; + + case OPT_G_BRIGHTNESS: + *(SANE_Word *) val = scanner->brightness_G - 128; + return SANE_STATUS_GOOD; + + case OPT_B_BRIGHTNESS: + *(SANE_Word *) val = scanner->brightness_B - 128; + return SANE_STATUS_GOOD; + + case OPT_EXPOSURE: + *(SANE_Word *) val = scanner->exposure_R * 2; + return SANE_STATUS_GOOD; + + case OPT_R_EXPOSURE: + *(SANE_Word *) val = scanner->exposure_R * 2; + return SANE_STATUS_GOOD; + + case OPT_G_EXPOSURE: + *(SANE_Word *) val = scanner->exposure_G * 2; + return SANE_STATUS_GOOD; + + case OPT_B_EXPOSURE: + *(SANE_Word *) val = scanner->exposure_B * 2; + return SANE_STATUS_GOOD; + + case OPT_R_SHIFT: + *(SANE_Word *) val = scanner->shift_R - 128; + return SANE_STATUS_GOOD; + + case OPT_G_SHIFT: + *(SANE_Word *) val = scanner->shift_G - 128; + return SANE_STATUS_GOOD; + + case OPT_B_SHIFT: + *(SANE_Word *) val = scanner->shift_B - 128; + return SANE_STATUS_GOOD; + + + case OPT_IRED_RED: + *(SANE_Word *) val = scanner->ired_red; + return SANE_STATUS_GOOD; + + /* string options: */ + case OPT_TYPE: + strcpy (val, ((scanner->negative) ? negativeStr : positiveStr)); + return SANE_STATUS_GOOD; + + case OPT_MODE: + switch(scanner->colormode) + { case RGB: strcpy (val,colorStr); + break; + case GREYSCALE:strcpy (val,grayStr); + break; + case RGBI:if(scanner->LS>=2) strcpy (val,rgbiStr); + else strcpy (val,colorStr); + break; + case IRED:if(scanner->LS>=2) strcpy (val,iredStr); + else strcpy (val,grayStr); + break; + } + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + + return SANE_STATUS_GOOD; + + case OPT_PRESCAN: + *(SANE_Word *) val = (scanner->prescan) ? SANE_TRUE : SANE_FALSE; + return SANE_STATUS_GOOD; + + case OPT_PRESCAN_NOW: + return SANE_STATUS_GOOD; + + case OPT_RGB_CONTROL: + *(SANE_Word *) val = (scanner->rgb_control) ? SANE_TRUE : SANE_FALSE; + return SANE_STATUS_GOOD; + + case OPT_GAMMA_BIND: + *(SANE_Word *) val = (scanner->gamma_bind) ? SANE_TRUE : SANE_FALSE; + return SANE_STATUS_GOOD; + + case OPT_ANALOG_GAMMA: + *(SANE_Word *) val = + (scanner->analog_gamma_r) ? SANE_TRUE : SANE_FALSE; + return SANE_STATUS_GOOD; + + case OPT_AVERAGING: + *(SANE_Word *) val = (scanner->averaging) ? SANE_TRUE : SANE_FALSE; + return SANE_STATUS_GOOD; + + case OPT_GAMMA_VECTOR: + memcpy (val, scanner->gamma, scanner->opt[option].size); + return SANE_STATUS_GOOD; + case OPT_GAMMA_VECTOR_R: + memcpy (val, scanner->gamma_r, scanner->opt[option].size); + return SANE_STATUS_GOOD; + case OPT_GAMMA_VECTOR_G: + memcpy (val, scanner->gamma_g, scanner->opt[option].size); + return SANE_STATUS_GOOD; + case OPT_GAMMA_VECTOR_B: + memcpy (val, scanner->gamma_b, scanner->opt[option].size); + return SANE_STATUS_GOOD; + + case OPT_SOURCE: + if (strcmp (val, "Automatic Slide Feeder") == 0) + { + /* Feed/Discharge/update filename/etc */ + } + else + { + /* Reset above */ + } + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + } + + } + else if (action == SANE_ACTION_SET_VALUE) + { + DBG (10, "sane_control_option %d, set value\n", option); + + if (!SANE_OPTION_IS_ACTIVE (cap)) + return SANE_STATUS_INVAL; + + if (!SANE_OPTION_IS_SETTABLE (cap)) + return SANE_STATUS_INVAL; + + status = sanei_constrain_value (scanner->opt + option, val, info); + if (status != SANE_STATUS_GOOD) + return status; + + switch (option) + { + case OPT_GAMMA_BIND: + scanner->gamma_bind = (*(SANE_Word *) val == SANE_TRUE); + if (scanner->LS != 1) + { + if (scanner->gamma_bind) + { + scanner->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + + } + else + { + scanner->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + + } + } + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS; + } + return SANE_STATUS_GOOD; + + case OPT_ANALOG_GAMMA: + scanner->analog_gamma_r = scanner->analog_gamma_g = + scanner->analog_gamma_b = (*(SANE_Word *) val == SANE_TRUE); + return SANE_STATUS_GOOD; + + case OPT_AVERAGING: + scanner->averaging = (*(SANE_Word *) val == SANE_TRUE); + return SANE_STATUS_GOOD; + + case OPT_PRESCAN: + scanner->prescan = (*(SANE_Word *) val == SANE_TRUE); + return SANE_STATUS_GOOD; + + case OPT_PRESCAN_NOW: + do_prescan_now(scanner); + return SANE_STATUS_GOOD; + + case OPT_BIT_DEPTH: + scanner->bits_per_color=(*(SANE_Word *)val); + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + return SANE_STATUS_GOOD; + + + case OPT_RGB_CONTROL: + scanner->rgb_control = (*(SANE_Word *) val == SANE_TRUE); + if (scanner->rgb_control) + { + scanner->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_EXPOSURE].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_R_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_G_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_B_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; + + scanner->opt[OPT_R_CONTRAST].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_G_CONTRAST].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_B_CONTRAST].cap &= ~SANE_CAP_INACTIVE; + + scanner->opt[OPT_R_EXPOSURE].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_G_EXPOSURE].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_B_EXPOSURE].cap &= ~SANE_CAP_INACTIVE; + + scanner->contrast_R = 128; + scanner->contrast_G = 128; + scanner->contrast_B = 128; + scanner->brightness_R = 128; + scanner->brightness_G = 128; + scanner->brightness_B = 128; + scanner->exposure_R = 50; + scanner->exposure_G = 50; + scanner->exposure_B = 50; + } + else + { + scanner->opt[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE; + scanner->opt[OPT_EXPOSURE].cap &= ~SANE_CAP_INACTIVE; + + scanner->contrast = 128; + scanner->brightness = 128; + scanner->exposure_R = 50; + scanner->exposure_G = 50; + scanner->exposure_B = 50; + + scanner->opt[OPT_R_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_G_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_B_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_R_CONTRAST].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_G_CONTRAST].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_B_CONTRAST].cap |= SANE_CAP_INACTIVE; + + scanner->opt[OPT_R_EXPOSURE].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_G_EXPOSURE].cap |= SANE_CAP_INACTIVE; + scanner->opt[OPT_B_EXPOSURE].cap |= SANE_CAP_INACTIVE; + } + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS; + } + return SANE_STATUS_GOOD; + + case OPT_RESOLUTION: + scanner->y_nres = scanner->x_nres = + resValToDiv (*(SANE_Word *) val); + + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + return SANE_STATUS_GOOD; + + case OPT_PREVIEW_RESOLUTION: + scanner->y_p_nres = scanner->x_p_nres = + resValToDiv (*(SANE_Word *) val); + + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + return SANE_STATUS_GOOD; + + case OPT_TL_X: + scanner->tlx = mmToIlu (SANE_UNFIX (*(SANE_Word *) val)); + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + + return SANE_STATUS_GOOD; + + case OPT_TL_Y: + scanner->tly = mmToIlu (SANE_UNFIX (*(SANE_Word *) val)); + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + return SANE_STATUS_GOOD; + + case OPT_BR_X: + scanner->brx = mmToIlu (SANE_UNFIX (*(SANE_Word *) val)); + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + return SANE_STATUS_GOOD; + + case OPT_BR_Y: + scanner->bry = mmToIlu (SANE_UNFIX (*(SANE_Word *) val)); + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + return SANE_STATUS_GOOD; + + case OPT_NUM_OPTS: + return SANE_STATUS_GOOD; + + case OPT_PREVIEW: + scanner->preview = *(SANE_Word *) val; + return SANE_STATUS_GOOD; + + case OPT_AUTOFOCUS: + if(strcmp(val,neverStr)==0) + { scanner->autofocus=AF_NEVER; + } + if(strcmp(val,previewStr)==0) + { scanner->autofocus=AF_PREVIEW; + } + if(strcmp(val,scanStr)==0) + { scanner->autofocus=AF_SCAN; + } + if(strcmp(val,preandscanStr)==0) + { scanner->autofocus=AF_PREANDSCAN;; + } + return SANE_STATUS_GOOD; + + case OPT_CONTRAST: + scanner->contrast = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + case OPT_R_CONTRAST: + scanner->contrast_R = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + case OPT_G_CONTRAST: + scanner->contrast_G = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + case OPT_B_CONTRAST: + scanner->contrast_B = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + + case OPT_BRIGHTNESS: + scanner->brightness = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + case OPT_R_BRIGHTNESS: + scanner->brightness_R = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + case OPT_G_BRIGHTNESS: + scanner->brightness_G = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + case OPT_B_BRIGHTNESS: + scanner->brightness_B = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + + case OPT_EXPOSURE: + scanner->exposure_R = *(SANE_Word *) val / 2; + scanner->exposure_G = *(SANE_Word *) val / 2; + scanner->exposure_B = *(SANE_Word *) val / 2; + return SANE_STATUS_GOOD; + case OPT_R_EXPOSURE: + scanner->exposure_R = *(SANE_Word *) val / 2; + return SANE_STATUS_GOOD; + case OPT_G_EXPOSURE: + scanner->exposure_G = *(SANE_Word *) val / 2; + return SANE_STATUS_GOOD; + case OPT_B_EXPOSURE: + scanner->exposure_B = *(SANE_Word *) val / 2; + return SANE_STATUS_GOOD; + + case OPT_R_SHIFT: + scanner->shift_R = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + case OPT_G_SHIFT: + scanner->shift_G = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + case OPT_B_SHIFT: + scanner->shift_B = *(SANE_Word *) val + 128; + return SANE_STATUS_GOOD; + + case OPT_IRED_RED: + scanner->ired_red= *(SANE_Word *) val; + return SANE_STATUS_GOOD; + + case OPT_SOURCE: + scanner->asf = (strcmp (val, "Automatic...") == 0); + return SANE_STATUS_GOOD; + + case OPT_TYPE: + scanner->negative = (strcmp (val, negativeStr) == 0); + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + return SANE_STATUS_GOOD; + case OPT_MODE: + if(strcmp(val,colorStr)==0) + { scanner->colormode=RGB; + scanner->colormode_p=RGB; + } + if(strcmp(val,grayStr)==0) + { scanner->colormode=GREYSCALE; + scanner->colormode_p=GREYSCALE; + } + if(strcmp(val,rgbiStr)==0) + { scanner->colormode=RGBI; + scanner->colormode_p=RGB; + } + if(strcmp(val,iredStr)==0) + { scanner->colormode=IRED; + scanner->colormode_p=GREYSCALE; + } + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + } + return SANE_STATUS_GOOD; + + case OPT_GAMMA_VECTOR: + memcpy (scanner->gamma, val, scanner->opt[option].size); + if(scanner->LS>2) Calc_fix_LUT(scanner); + return SANE_STATUS_GOOD; + + case OPT_GAMMA_VECTOR_R: + memcpy (scanner->gamma_r, val, scanner->opt[option].size); + if(scanner->LS>2) Calc_fix_LUT(scanner); + return SANE_STATUS_GOOD; + + case OPT_GAMMA_VECTOR_G: + memcpy (scanner->gamma_g, val, scanner->opt[option].size); + if(scanner->LS>2) Calc_fix_LUT(scanner); + return SANE_STATUS_GOOD; + + case OPT_GAMMA_VECTOR_B: + memcpy (scanner->gamma_b, val, scanner->opt[option].size); + if(scanner->LS>2) Calc_fix_LUT(scanner); + return SANE_STATUS_GOOD; + + } /* switch */ + } /* else */ + return SANE_STATUS_INVAL; +} + +SANE_Status +sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) +{ + Coolscan_t *scanner = handle; + + DBG (10, "sane_get_parameters"); + switch(scanner->colormode) + { case RGB: + params->format = SANE_FRAME_RGB; + break; +#ifdef HAS_IRED + case RGBI: + params->format = SANE_FRAME_RGBA; + break; +#endif /* HAS_RGBI */ + case GREYSCALE: + params->format = SANE_FRAME_GRAY; + break; + } + + params->depth = scanner->bits_per_color>8?16:8; + params->pixels_per_line = pixels_per_line (scanner); + params->lines = lines_per_scan (scanner); + params->bytes_per_line = write_bytes_per_line (scanner); + params->last_frame = 1; + return SANE_STATUS_GOOD; +} +static int +swap_res (Coolscan_t * s) +{ + if (s->preview) + { + /* swap preview/scan resolutions */ + int xres, yres, cmode; + xres = s->x_nres; + yres = s->y_nres; + s->x_nres = s->x_p_nres; + s->y_nres = s->y_p_nres; + + s->x_p_nres = xres; + s->y_p_nres = yres; + cmode=s->colormode; + s->colormode=s->colormode_p; + s->colormode_p=cmode; + } + return 0; +} +SANE_Status +sane_start (SANE_Handle handle) +{ + Coolscan_t *scanner = handle; + int fds[2]; + + DBG (10, "sane_start\n"); + if (scanner->scanning == SANE_TRUE) + return SANE_STATUS_DEVICE_BUSY; + + if (scanner->sfd < 0) + { /* first call */ + if (sanei_scsi_open (scanner->sane.name, + &(scanner->sfd), + sense_handler, 0) != SANE_STATUS_GOOD) + { + DBG (1, "sane_start: open of %s failed:\n", + scanner->sane.name); + return SANE_STATUS_INVAL; + } + } + scanner->scanning = SANE_TRUE; + + + if (coolscan_check_values (scanner) != 0) + { /* Verify values */ + DBG (1, "ERROR: invalid scan-values\n"); + scanner->scanning = SANE_FALSE; + coolscan_give_scanner (scanner); + sanei_scsi_close (scanner->sfd); + scanner->sfd = -1; + return SANE_STATUS_INVAL; + } + + if (coolscan_grab_scanner (scanner)) + { + sanei_scsi_close (scanner->sfd); + scanner->sfd = -1; + DBG (5, "WARNING: unable to reserve scanner: device busy\n"); + scanner->scanning = SANE_FALSE; + return SANE_STATUS_DEVICE_BUSY; + } + + /* hoho, step 2c, -perm */ + coolscan_object_feed (scanner); + + swap_res (scanner); + if (!scanner->preview) + { if(scanner->autofocus & 0x02) + { coolscan_autofocus (scanner); + } + } + else + { + if(scanner->autofocus & 0x01) + { coolscan_autofocus (scanner); + } + if (scanner->prescan) { + prescan (scanner); + if(scanner->LS<2) + { get_internal_info(scanner); + } + coolscan_get_window_param (scanner,1); + } + } + /*read_LUT(scanner); */ + if(scanner->LS<2) + { send_LUT (scanner); + coolscan_set_window_param (scanner, 0); + coolscan_get_window_param (scanner,0); + coolscan_start_scan (scanner); + } + else + { coolscan_set_window_param (scanner, 0); + send_LUT (scanner); + Calc_fix_LUT(scanner); + coolscan_start_scan (scanner); + wait_scanner (scanner); + coolscan_get_window_param (scanner,0); + } + + DBG (10, "bytes per line = %d\n", scan_bytes_per_line (scanner)); + DBG (10, "pixels_per_line = %d\n", pixels_per_line (scanner)); + DBG (10, "lines = %d\n", lines_per_scan (scanner)); + DBG (10, "negative = %d\n", scanner->negative); + DBG (10, "brightness (halftone) = %d\n", scanner->brightness); + DBG (10, "contrast (halftone) = %d\n", scanner->contrast); + DBG (10, "fast preview function = %d\n", scanner->preview); + + /* create a pipe, fds[0]=read-fd, fds[1]=write-fd */ + if (pipe (fds) < 0) + { + DBG (1, "ERROR: could not create pipe\n"); + + swap_res (scanner); + scanner->scanning = SANE_FALSE; + coolscan_give_scanner (scanner); + sanei_scsi_close (scanner->sfd); + scanner->sfd = -1; + return SANE_STATUS_IO_ERROR; + } + + scanner->pipe = fds[0]; + scanner->reader_fds = fds[1]; + scanner->reader_pid = sanei_thread_begin( reader_process, (void*)scanner ); + if (scanner->reader_pid == -1) + { + DBG (1, "sane_start: sanei_thread_begin failed (%s)\n", + strerror (errno)); + return SANE_STATUS_NO_MEM; + } + + if (sanei_thread_is_forked ()) + { + close (scanner->reader_fds); + scanner->reader_fds = -1; + } + + return SANE_STATUS_GOOD; +} + + +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte * buf, + SANE_Int max_len, SANE_Int * len) +{ + Coolscan_t *scanner = handle; + ssize_t nread; + + *len = 0; + + nread = read (scanner->pipe, buf, max_len); + DBG (10, "sane_read: read %ld bytes\n", (long) nread); + + if (!(scanner->scanning)) + { + return do_cancel (scanner); + } + + if (nread < 0) + { + if (errno == EAGAIN) + { + return SANE_STATUS_GOOD; + } + else + { + do_cancel (scanner); + return SANE_STATUS_IO_ERROR; + } + } + + *len = nread; + + if (nread == 0) + return do_eof (scanner); /* close pipe */ + + return SANE_STATUS_GOOD; +} + +void +sane_cancel (SANE_Handle handle) +{ + Coolscan_t *s = handle; + + if (s->reader_pid != -1) + { + sanei_thread_kill ( s->reader_pid ); + sanei_thread_waitpid( s->reader_pid, NULL ); + s->reader_pid = -1; + } + swap_res (s); + s->scanning = SANE_FALSE; +} + + +SANE_Status +sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) +{ + Coolscan_t *scanner = handle; + + DBG (10, "sane_set_io_mode: non_blocking=%d\n", non_blocking); + + if (!scanner->scanning) + return SANE_STATUS_INVAL; + + if (fcntl (scanner->pipe, F_SETFL, non_blocking ? O_NONBLOCK : 0) < 0) + return SANE_STATUS_IO_ERROR; + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) +{ + Coolscan_t *scanner = handle; + + DBG (10, "sane_get_select_fd\n"); + + if (!scanner->scanning) + { + return SANE_STATUS_INVAL; + } + *fd = scanner->pipe; + + return SANE_STATUS_GOOD; +} |