kopia lustrzana https://gitlab.com/sane-project/backends
4195 wiersze
116 KiB
C
4195 wiersze
116 KiB
C
/* ------------------------------------------------------------------------- */
|
|
/* 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 "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 "sane/sane.h"
|
|
#include "sane/sanei.h"
|
|
#include "sane/saneopts.h"
|
|
#include "sane/sanei_scsi.h"
|
|
#include "sane/sanei_debug.h"
|
|
#include "sane/sanei_thread.h"
|
|
|
|
#include "sane/sanei_config.h"
|
|
#define COOLSCAN_CONFIG_FILE "coolscan.conf"
|
|
#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 (s->buffer, vendor);
|
|
get_inquiry_product (s->buffer, product);
|
|
get_inquiry_version (s->buffer, version);
|
|
|
|
if (strncmp ("Nikon ", 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 (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(s->buffer+5,"Strip",5)==0)
|
|
{ s->feeder=STRIP_FEEDER;
|
|
s->autofeeder = 1;
|
|
}
|
|
if(strncmp(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"
|
|
"\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"
|
|
"\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->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,
|
|
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,
|
|
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 (inquiry_block, s->vendor);
|
|
s->vendor[8] = '\0';
|
|
get_inquiry_product (inquiry_block, s->product);
|
|
s->product[16] = '\0';
|
|
get_inquiry_version (inquiry_block, 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);
|
|
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
#define MM_PER_INCH 25.4
|
|
/* 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[] = "Color";
|
|
static const char grayStr[] = "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 > 0)
|
|
{
|
|
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 = 0;
|
|
}
|
|
|
|
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 (V_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 < 0)
|
|
{
|
|
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 > 0)
|
|
{
|
|
sanei_thread_kill ( s->reader_pid );
|
|
sanei_thread_waitpid( s->reader_pid, NULL );
|
|
s->reader_pid = 0;
|
|
}
|
|
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;
|
|
}
|