kopia lustrzana https://gitlab.com/sane-project/backends
2080 wiersze
52 KiB
C
2080 wiersze
52 KiB
C
/* sane - Scanner Access Now Easy.
|
|
|
|
Copyright (C) 2002 Frank Zago (fzago at greshamstorage com)
|
|
Copyright (C) 2002 Other SANE contributors
|
|
|
|
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.
|
|
*/
|
|
|
|
/*
|
|
$Id$
|
|
Sceptre S1200 SCSI scanner (sometimes also called S120)
|
|
*/
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
#define BUILD 9 /* 2002-03-19 */
|
|
#define BACKEND_NAME sceptre
|
|
#define SCEPTRE_CONFIG_FILE "sceptre.conf"
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
|
#include "../include/sane/config.h"
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <limits.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
|
|
#include "../include/sane/sane.h"
|
|
#include "../include/sane/sanei.h"
|
|
#include "../include/sane/saneopts.h"
|
|
#include "../include/sane/sanei_scsi.h"
|
|
#include "../include/sane/sanei_debug.h"
|
|
#include "../include/sane/sanei_backend.h"
|
|
#include "../include/sane/sanei_config.h"
|
|
#include "../include/lassert.h"
|
|
|
|
#include "sceptre.h"
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
static const SANE_String scan_mode_list[] = { LINEART_STR, HALFTONE_STR,
|
|
GRAY_STR, COLOR_STR, NULL
|
|
};
|
|
|
|
static const SANE_Range gamma_range = {
|
|
0, /* minimum */
|
|
255, /* maximum */
|
|
0 /* quantization */
|
|
};
|
|
|
|
static const SANE_Range threshold_range = {
|
|
0, /* minimum */
|
|
255, /* maximum */
|
|
0 /* quantization */
|
|
};
|
|
|
|
static const SANE_Range halftone_range = {
|
|
1, /* minimum */
|
|
4, /* maximum */
|
|
0 /* quantization */
|
|
};
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
#define NUM_OF_RES 15
|
|
/* Table of supported resolution and number of lines of color shifting. */
|
|
static const SANE_Word resolutions_list[NUM_OF_RES + 1] = {
|
|
NUM_OF_RES, 10, 25, 30, 45, 75, 90, 150, 300, 450, 600, 750, 900, 1050,
|
|
1125, 1200
|
|
};
|
|
|
|
static const SANE_Word color_shift_list[NUM_OF_RES + 1] = {
|
|
NUM_OF_RES, 0, 0, 0, 0, 1, 1, 2, 0, 6, 8, 10, 12, 14, 15, 16
|
|
};
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/* Define the supported scanners and their characteristics. */
|
|
static const struct scanners_supported scanners[] = {
|
|
/* { 6, "KINPO ", "Vividscan S600 ", "KINPO", "S600" }, */
|
|
{6, "KINPO ", "Vividscan S120 ", "Sceptre", "S1200"}
|
|
};
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/* List of scanner attached. */
|
|
static Sceptre_Scanner *first_dev = NULL;
|
|
static int num_devices = 0;
|
|
static const SANE_Device **devlist = NULL;
|
|
|
|
|
|
/* Local functions. */
|
|
|
|
/* Display a buffer in the log. */
|
|
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);
|
|
}
|
|
|
|
/* Initialize a scanner entry. Return an allocated scanner with some
|
|
* preset values. */
|
|
static Sceptre_Scanner *
|
|
sceptre_init (void)
|
|
{
|
|
Sceptre_Scanner *dev;
|
|
|
|
DBG (DBG_proc, "sceptre_init: enter\n");
|
|
|
|
/* Allocate a new scanner entry. */
|
|
dev = malloc (sizeof (Sceptre_Scanner));
|
|
if (dev == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
memset (dev, 0, sizeof (Sceptre_Scanner));
|
|
|
|
/* Allocate the buffer used to transfer the SCSI data. */
|
|
dev->buffer_size = 64 * 1024;
|
|
dev->buffer = malloc (dev->buffer_size);
|
|
if (dev->buffer == NULL)
|
|
{
|
|
free (dev);
|
|
return NULL;
|
|
}
|
|
|
|
dev->sfd = -1;
|
|
|
|
DBG (DBG_proc, "sceptre_init: exit\n");
|
|
|
|
return (dev);
|
|
}
|
|
|
|
/* Closes an open scanner. */
|
|
static void
|
|
sceptre_close (Sceptre_Scanner * dev)
|
|
{
|
|
DBG (DBG_proc, "sceptre_close: enter\n");
|
|
|
|
if (dev->sfd != -1)
|
|
{
|
|
sanei_scsi_close (dev->sfd);
|
|
dev->sfd = -1;
|
|
}
|
|
|
|
DBG (DBG_proc, "sceptre_close: exit\n");
|
|
}
|
|
|
|
/* Frees the memory used by a scanner. */
|
|
static void
|
|
sceptre_free (Sceptre_Scanner * dev)
|
|
{
|
|
int i;
|
|
|
|
DBG (DBG_proc, "sceptre_free: enter\n");
|
|
|
|
if (dev == NULL)
|
|
return;
|
|
|
|
sceptre_close (dev);
|
|
if (dev->devicename)
|
|
{
|
|
free (dev->devicename);
|
|
}
|
|
if (dev->buffer)
|
|
{
|
|
free (dev->buffer);
|
|
}
|
|
if (dev->image)
|
|
{
|
|
free (dev->image);
|
|
}
|
|
for (i = 1; i < OPT_NUM_OPTIONS; i++)
|
|
{
|
|
if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s)
|
|
{
|
|
free (dev->val[i].s);
|
|
}
|
|
}
|
|
|
|
free (dev);
|
|
|
|
DBG (DBG_proc, "sceptre_free: exit\n");
|
|
}
|
|
|
|
/* Inquiry a device and returns TRUE if is supported. */
|
|
static int
|
|
sceptre_identify_scanner (Sceptre_Scanner * dev)
|
|
{
|
|
CDB cdb;
|
|
SANE_Status status;
|
|
size_t size;
|
|
int i;
|
|
|
|
DBG (DBG_proc, "sceptre_identify_scanner: enter\n");
|
|
|
|
size = 36;
|
|
MKSCSI_INQUIRY (cdb, size);
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
|
|
NULL, 0, dev->buffer, &size);
|
|
|
|
if (status)
|
|
{
|
|
DBG (DBG_error,
|
|
"sceptre_identify_scanner: inquiry failed with status %s\n",
|
|
sane_strstatus (status));
|
|
return (SANE_FALSE);
|
|
}
|
|
|
|
if (size < 36)
|
|
{
|
|
DBG (DBG_error,
|
|
"sceptre_identify_scanner: not enough data to identify device\n");
|
|
return (SANE_FALSE);
|
|
}
|
|
|
|
dev->scsi_type = dev->buffer[0] & 0x1f;
|
|
strncpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08);
|
|
dev->scsi_vendor[0x08] = 0;
|
|
strncpy (dev->scsi_product, dev->buffer + 0x10, 0x010);
|
|
dev->scsi_product[0x10] = 0;
|
|
strncpy (dev->scsi_version, dev->buffer + 0x20, 0x04);
|
|
dev->scsi_version[0x04] = 0;
|
|
|
|
DBG (DBG_info, "device is \"%s\" \"%s\" \"%s\"\n",
|
|
dev->scsi_vendor, dev->scsi_product, dev->scsi_version);
|
|
|
|
/* Lookup through the supported scanners table to find if this
|
|
* backend supports that one. */
|
|
for (i = 0; i < NELEMS (scanners); i++)
|
|
{
|
|
if (dev->scsi_type == scanners[i].scsi_type &&
|
|
strcmp (dev->scsi_vendor, scanners[i].scsi_vendor) == 0 &&
|
|
strcmp (dev->scsi_product, scanners[i].scsi_product) == 0)
|
|
{
|
|
|
|
DBG (DBG_error, "sceptre_identify_scanner: scanner supported\n");
|
|
|
|
dev->scnum = i;
|
|
|
|
return (SANE_TRUE);
|
|
}
|
|
}
|
|
|
|
DBG (DBG_proc, "sceptre_identify_scanner: exit\n");
|
|
|
|
return (SANE_FALSE);
|
|
}
|
|
|
|
/* Return the number of bytes left to read. */
|
|
static SANE_Status
|
|
sceptre_get_status (Sceptre_Scanner * dev, size_t * data_left)
|
|
{
|
|
size_t size;
|
|
CDB cdb;
|
|
SANE_Status status;
|
|
|
|
DBG (DBG_proc, "sceptre_get_status: enter\n");
|
|
|
|
/* Get status. */
|
|
size = 0x10;
|
|
MKSCSI_GET_DATA_BUFFER_STATUS (cdb, 1, size);
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
|
|
NULL, 0, dev->buffer, &size);
|
|
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
DBG (DBG_error, "sceptre_get_status: cannot get buffer status\n");
|
|
*data_left = 0;
|
|
return (SANE_STATUS_IO_ERROR);
|
|
}
|
|
|
|
assert (size == 16);
|
|
|
|
hexdump (DBG_info2, "GET BUFFER STATUS result", dev->buffer, 16);
|
|
|
|
/* Read the size left. The scanner returns the rest of the
|
|
* bytes to read, not just what's in its buffers. */
|
|
*data_left = B32TOI (&dev->buffer[8]);
|
|
|
|
assert (dev->params.lines <= B16TOI (&dev->buffer[12]));
|
|
assert (dev->params.pixels_per_line == B16TOI (&dev->buffer[14]));
|
|
|
|
if (dev->raster_real == 0)
|
|
{
|
|
dev->raster_real = B16TOI (&dev->buffer[12]) * 3;
|
|
}
|
|
|
|
DBG (DBG_proc, "sceptre_get_status: exit, data_left=%ld\n",
|
|
(long) *data_left);
|
|
|
|
return (SANE_STATUS_GOOD);
|
|
}
|
|
|
|
/*
|
|
* Adjust the rasters. This function is used during a color scan,
|
|
* because the scanner does not present a format sane can interpret
|
|
* directly.
|
|
*
|
|
* The scanner sends the colors by rasters (R then G then B), whereas
|
|
* sane is waiting for a group of 3 bytes per color. To make things
|
|
* funnier, the rasters are shifted. This shift factor depends on the
|
|
* resolution used. The format of those raster is:
|
|
* R...R RG...RG RGB...RGB BG...GB B...B
|
|
*
|
|
* So this function reorders all that mess. It gets the input from
|
|
* dev->buffer and write the output in dev->image. size_in the the
|
|
* length of the valid data in dev->buffer.
|
|
*/
|
|
static void
|
|
sceptre_adjust_raster (Sceptre_Scanner * dev, size_t size_in)
|
|
{
|
|
int nb_rasters; /* number of rasters in dev->buffer */
|
|
|
|
int raster; /* current raster number in buffer */
|
|
int line; /* line number for that raster */
|
|
int colour; /* colour for that raster */
|
|
size_t offset;
|
|
|
|
DBG (DBG_proc, "sceptre_adjust_raster: enter\n");
|
|
|
|
assert (dev->scan_mode == SCEPTRE_COLOR);
|
|
assert ((size_in % dev->params.bytes_per_line) == 0);
|
|
|
|
if (size_in == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* The color coding is one line for each color (in the RGB order).
|
|
* Recombine that stuff to create a RGB value for each pixel.
|
|
*/
|
|
|
|
nb_rasters = size_in / dev->raster_size;
|
|
|
|
for (raster = 0; raster < nb_rasters; raster++)
|
|
{
|
|
|
|
/*
|
|
* Find the color to which this raster belongs to.
|
|
* 0 = red
|
|
* 1 = green
|
|
* 2 = blue
|
|
*
|
|
* When blue comes, it always finishes the current line;
|
|
*/
|
|
line = 0;
|
|
if (dev->raster_num < dev->color_shift)
|
|
{
|
|
colour = 0; /* Red */
|
|
line = dev->raster_num;
|
|
}
|
|
else if (dev->raster_num < (3 * dev->color_shift))
|
|
{
|
|
/* even = red, odd = green */
|
|
colour = (dev->raster_num - dev->color_shift) % 2;
|
|
if (colour)
|
|
{
|
|
/* Green */
|
|
line = (dev->raster_num - dev->color_shift) / 2;
|
|
}
|
|
else
|
|
{
|
|
/* Red */
|
|
line = (dev->raster_num + dev->color_shift) / 2;
|
|
}
|
|
}
|
|
else if (dev->raster_num >= dev->raster_real - dev->color_shift)
|
|
{
|
|
/* Blue */
|
|
colour = 2;
|
|
line = dev->line;
|
|
}
|
|
else if (dev->raster_num >= dev->raster_real - 3 * dev->color_shift)
|
|
{
|
|
/* Green or Blue */
|
|
colour =
|
|
(dev->raster_real - dev->raster_num - dev->color_shift) % 2 + 1;
|
|
if (colour == 1)
|
|
{
|
|
/* Green */
|
|
line = dev->line + dev->color_shift;
|
|
}
|
|
else
|
|
{
|
|
/* Blue */
|
|
line = dev->line;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
colour = (dev->raster_num - 3 * dev->color_shift) % 3;
|
|
switch (colour)
|
|
{
|
|
case 0:
|
|
/* Red */
|
|
line = (dev->raster_num + 3 * dev->color_shift) / 3;
|
|
break;
|
|
case 1:
|
|
/* Green */
|
|
line = dev->raster_num / 3;
|
|
break;
|
|
case 2:
|
|
/* Blue */
|
|
line = (dev->raster_num - 3 * dev->color_shift) / 3;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Adjust the line number relative to the image. */
|
|
line -= dev->line;
|
|
|
|
offset = dev->image_end + line * dev->params.bytes_per_line;
|
|
|
|
assert (offset <= (dev->image_size - dev->raster_size));
|
|
|
|
/* Copy the raster to the temporary image. */
|
|
{
|
|
int i;
|
|
unsigned char *src = dev->buffer + raster * dev->raster_size;
|
|
unsigned char *dest = dev->image + offset + colour;
|
|
|
|
for (i = 0; i < dev->raster_size; i++)
|
|
{
|
|
*dest = *src;
|
|
src++;
|
|
dest += 3;
|
|
}
|
|
}
|
|
|
|
if (colour == 2)
|
|
{
|
|
/* This blue raster completes a new line */
|
|
dev->line++;
|
|
dev->image_end += dev->params.bytes_per_line;
|
|
}
|
|
|
|
dev->raster_num++;
|
|
}
|
|
|
|
DBG (DBG_proc, "sceptre_adjust_raster: exit\n");
|
|
}
|
|
|
|
/* SCSI sense handler. Callback for SANE.
|
|
*
|
|
* Since this scanner does not have REQUEST SENSE, it is always an
|
|
* error if this function is called.*/
|
|
static SANE_Status
|
|
sceptre_sense_handler (int scsi_fd, unsigned char *result, void *arg)
|
|
{
|
|
DBG (DBG_proc, "sceptre_sense_handler (scsi_fd = %d)\n", scsi_fd);
|
|
|
|
result = result; /* silence gcc */
|
|
arg = arg; /* silence gcc */
|
|
|
|
return SANE_STATUS_IO_ERROR;
|
|
}
|
|
|
|
/* Attach a scanner to this backend. */
|
|
static SANE_Status
|
|
attach_scanner (const char *devicename, Sceptre_Scanner ** devp)
|
|
{
|
|
Sceptre_Scanner *dev;
|
|
int sfd;
|
|
|
|
DBG (DBG_sane_proc, "attach_scanner: %s\n", devicename);
|
|
|
|
if (devp)
|
|
*devp = NULL;
|
|
|
|
/* Check if we know this device name. */
|
|
for (dev = first_dev; dev; dev = dev->next)
|
|
{
|
|
if (strcmp (dev->sane.name, devicename) == 0)
|
|
{
|
|
if (devp)
|
|
{
|
|
*devp = dev;
|
|
}
|
|
DBG (DBG_info, "device is already known\n");
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
}
|
|
|
|
/* Allocate a new scanner entry. */
|
|
dev = sceptre_init ();
|
|
if (dev == NULL)
|
|
{
|
|
DBG (DBG_error, "ERROR: not enough memory\n");
|
|
return SANE_STATUS_NO_MEM;
|
|
}
|
|
|
|
DBG (DBG_info, "attach_scanner: opening %s\n", devicename);
|
|
|
|
if (sanei_scsi_open (devicename, &sfd, sceptre_sense_handler, dev) != 0)
|
|
{
|
|
DBG (DBG_error, "ERROR: attach_scanner: open failed\n");
|
|
sceptre_free (dev);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
/* Fill some scanner specific values. */
|
|
dev->devicename = strdup (devicename);
|
|
dev->sfd = sfd;
|
|
|
|
/* Now, check that it is a scanner we support. */
|
|
if (sceptre_identify_scanner (dev) == SANE_FALSE)
|
|
{
|
|
DBG (DBG_error,
|
|
"ERROR: attach_scanner: scanner-identification failed\n");
|
|
sceptre_free (dev);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
sceptre_close (dev);
|
|
|
|
/* Set the default options for that scanner. */
|
|
dev->sane.name = dev->devicename;
|
|
dev->sane.vendor = scanners[dev->scnum].real_vendor;
|
|
dev->sane.model = scanners[dev->scnum].real_product;
|
|
dev->sane.type = SANE_I18N ("flatbed scanner");
|
|
|
|
dev->resolution_range.min = SANE_FIX (50);
|
|
dev->resolution_range.max = SANE_FIX (1200);
|
|
dev->resolution_range.quant = SANE_FIX (1);
|
|
|
|
/*
|
|
* The S1200 has an area of 8.5 inches / 11.7 inches. (A4 like)
|
|
* That's roughly 215*297 mm
|
|
* The values are coded by
|
|
* size in inch * 600 dpi.
|
|
* The maximums are:
|
|
* X: 8.5 inches * 600 = 5100 dots
|
|
* Y: 11.7 inches * 600 = 7020
|
|
* (although the windows driver stops at 7019)
|
|
*
|
|
* The values are stored in mm. Inches sucks anyway.
|
|
* X: 5078 dots (22 dots lost)
|
|
* Y: 7015 dots (5 dots lost)
|
|
*
|
|
* There seems to be a minimum area, but yet to be determined.
|
|
*/
|
|
dev->x_range.min = SANE_FIX (0);
|
|
dev->x_range.max = SANE_FIX (215.90); /* in mm */
|
|
dev->x_range.quant = 0;
|
|
|
|
dev->y_range.min = SANE_FIX (0);
|
|
dev->y_range.max = SANE_FIX (297.14); /* in mm */
|
|
dev->y_range.quant = SANE_FIX (0);
|
|
|
|
/* Link the scanner with the others. */
|
|
dev->next = first_dev;
|
|
first_dev = dev;
|
|
|
|
if (devp)
|
|
{
|
|
*devp = dev;
|
|
}
|
|
|
|
num_devices++;
|
|
|
|
DBG (DBG_proc, "attach_scanner: exit\n");
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
static SANE_Status
|
|
attach_one (const char *dev)
|
|
{
|
|
attach_scanner (dev, NULL);
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/* Reset the options for that scanner. */
|
|
static void
|
|
sceptre_init_options (Sceptre_Scanner * dev)
|
|
{
|
|
int i;
|
|
|
|
DBG (DBG_proc, "sceptre_init_options: enter\n");
|
|
|
|
/* Pre-initialize the options. */
|
|
memset (dev->opt, 0, sizeof (dev->opt));
|
|
memset (dev->val, 0, sizeof (dev->val));
|
|
|
|
for (i = 0; i < OPT_NUM_OPTIONS; ++i)
|
|
{
|
|
dev->opt[i].size = sizeof (SANE_Word);
|
|
dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
|
|
}
|
|
|
|
/* Number of options. */
|
|
dev->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
|
|
dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
|
|
dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
|
|
dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
|
|
dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
|
|
dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
|
|
|
|
/* Mode group */
|
|
dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
|
|
dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
|
|
dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
|
|
dev->opt[OPT_MODE_GROUP].cap = 0;
|
|
dev->opt[OPT_MODE_GROUP].size = 0;
|
|
dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* Scanner supported modes */
|
|
dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
|
|
dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
|
|
dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
|
|
dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
|
|
dev->opt[OPT_MODE].size = 30; /* should define yet another max_string_size() */
|
|
dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
|
|
dev->opt[OPT_MODE].constraint.string_list =
|
|
(SANE_String_Const *) scan_mode_list;
|
|
dev->val[OPT_MODE].s = (SANE_Char *) strdup (scan_mode_list[0]);
|
|
|
|
/* Common resolution */
|
|
dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
|
|
dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
|
|
dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
|
|
dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
|
|
dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
|
|
dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
|
|
dev->opt[OPT_RESOLUTION].constraint.word_list = resolutions_list;
|
|
dev->val[OPT_RESOLUTION].w = 150;
|
|
|
|
/* Geometry group */
|
|
dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
|
|
dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */
|
|
dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
|
|
dev->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
|
|
dev->opt[OPT_GEOMETRY_GROUP].size = 0;
|
|
dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* Upper left X */
|
|
dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
|
|
dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
|
|
dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
|
|
dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
|
|
dev->opt[OPT_TL_X].unit = SANE_UNIT_MM;
|
|
dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_TL_X].constraint.range = &(dev->x_range);
|
|
dev->val[OPT_TL_X].w = dev->x_range.min;
|
|
|
|
/* Upper left Y */
|
|
dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
|
|
dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
|
|
dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
|
|
dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
|
|
dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
|
|
dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_TL_Y].constraint.range = &(dev->y_range);
|
|
dev->val[OPT_TL_Y].w = dev->y_range.min;
|
|
|
|
/* bottom-right x */
|
|
dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
|
|
dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
|
|
dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
|
|
dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
|
|
dev->opt[OPT_BR_X].unit = SANE_UNIT_MM;
|
|
dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_BR_X].constraint.range = &(dev->x_range);
|
|
dev->val[OPT_BR_X].w = dev->x_range.max;
|
|
|
|
/* bottom-right y */
|
|
dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
|
|
dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
|
|
dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
|
|
dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
|
|
dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
|
|
dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_BR_Y].constraint.range = &(dev->y_range);
|
|
dev->val[OPT_BR_Y].w = dev->y_range.max;
|
|
|
|
/* Enhancement group */
|
|
dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
|
|
dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
|
|
dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
|
|
dev->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
|
|
dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
|
|
dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* custom-gamma table */
|
|
dev->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
|
|
dev->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
|
|
dev->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
|
|
dev->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
|
|
dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
|
|
dev->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
|
|
|
|
/* red gamma vector */
|
|
dev->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
|
|
dev->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
|
|
dev->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
|
|
dev->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
|
|
dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
|
|
dev->opt[OPT_GAMMA_VECTOR_R].size = GAMMA_LENGTH * sizeof (SANE_Word);
|
|
dev->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range;
|
|
dev->val[OPT_GAMMA_VECTOR_R].wa = dev->gamma_R;
|
|
|
|
/* green gamma vector */
|
|
dev->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].size = GAMMA_LENGTH * sizeof (SANE_Word);
|
|
dev->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range;
|
|
dev->val[OPT_GAMMA_VECTOR_G].wa = dev->gamma_G;
|
|
|
|
/* blue gamma vector */
|
|
dev->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].size = GAMMA_LENGTH * sizeof (SANE_Word);
|
|
dev->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range;
|
|
dev->val[OPT_GAMMA_VECTOR_B].wa = dev->gamma_B;
|
|
|
|
/* Threshold */
|
|
dev->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
|
|
dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
|
|
dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
|
|
dev->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
|
|
dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
|
|
dev->opt[OPT_THRESHOLD].size = sizeof (SANE_Int);
|
|
dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_THRESHOLD].constraint.range = &threshold_range;
|
|
dev->val[OPT_THRESHOLD].w = 128;
|
|
|
|
/* Halftone pattern */
|
|
dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
|
|
dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
|
|
dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
|
|
dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_INT;
|
|
dev->opt[OPT_HALFTONE_PATTERN].size = sizeof (SANE_Int);
|
|
dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
dev->opt[OPT_HALFTONE_PATTERN].constraint.range = &halftone_range;
|
|
dev->val[OPT_HALFTONE_PATTERN].w = 1;
|
|
|
|
/* preview */
|
|
dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
|
|
dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
|
|
dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
|
|
dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
|
|
dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
|
|
dev->val[OPT_PREVIEW].w = SANE_FALSE;
|
|
|
|
/* Lastly, set the default mode. This might change some values
|
|
* previously set here. */
|
|
sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
|
|
(SANE_String *) COLOR_STR, NULL);
|
|
|
|
DBG (DBG_proc, "sceptre_init_options: leave\n");
|
|
}
|
|
|
|
/* Wait until the scanner is ready.
|
|
*
|
|
* The only reason I know the scanner is not ready is because it is
|
|
* moving the CCD.
|
|
*/
|
|
static SANE_Status
|
|
sceptre_wait_scanner (Sceptre_Scanner * dev)
|
|
{
|
|
SANE_Status status;
|
|
int timeout;
|
|
CDB cdb;
|
|
size_t size;
|
|
|
|
DBG (DBG_proc, "sceptre_wait_scanner: enter\n");
|
|
|
|
MKSCSI_TEST_UNIT_READY (cdb);
|
|
cdb.data[4] = 1; /* returns one byte. Non standard SCSI. */
|
|
|
|
/* Set the timeout to 120 seconds. */
|
|
timeout = 120;
|
|
|
|
while (timeout > 0)
|
|
{
|
|
|
|
/* test unit ready */
|
|
size = 1; /* read one info byte */
|
|
status =
|
|
sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
|
|
NULL, 0, dev->buffer, &size);
|
|
|
|
if (status != SANE_STATUS_GOOD || size != 1)
|
|
{
|
|
DBG (DBG_error, "sceptre_wait_scanner: TUR failed\n");
|
|
return (SANE_STATUS_IO_ERROR);
|
|
}
|
|
|
|
/* Apparently the scanner returns only 2 values:
|
|
* 0x00 - ready
|
|
* 0xff - not ready
|
|
*/
|
|
if (dev->buffer[0] != 0x00)
|
|
{
|
|
sleep (1); /* wait 1 seconds */
|
|
timeout--;
|
|
}
|
|
else
|
|
{
|
|
return (SANE_STATUS_GOOD);
|
|
}
|
|
};
|
|
|
|
DBG (DBG_proc, "sceptre_wait_scanner: scanner not ready\n");
|
|
return (SANE_STATUS_IO_ERROR);
|
|
}
|
|
|
|
/* Diagnostic the scanner. */
|
|
static SANE_Status
|
|
sceptre_do_diag (Sceptre_Scanner * dev)
|
|
{
|
|
SANE_Status status;
|
|
CDB cdb;
|
|
size_t size;
|
|
|
|
DBG (DBG_proc, "sceptre_receive_diag enter\n");
|
|
|
|
/* SEND DIAGNOSTIC. */
|
|
MKSCSI_SEND_DIAG (cdb, 0);
|
|
|
|
/* The windows driver sets that field. This is non standard. */
|
|
cdb.data[2] = 0x80;
|
|
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
DBG (DBG_error, "sceptre_do_diag: exit, status=%d\n", status);
|
|
return (status);
|
|
}
|
|
|
|
/* RECEIVE DIAGNOSTIC */
|
|
|
|
/* The windows driver ask for 3 byte. This is non standard
|
|
* SCSI. The page returned should be at least 4 bytes. */
|
|
size = 3;
|
|
MKSCSI_RECEIVE_DIAG (cdb, 0, size);
|
|
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
|
|
NULL, 0, dev->buffer, &size);
|
|
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
DBG (DBG_error, "sceptre_do_diag: exit, status=%d\n", status);
|
|
return (status);
|
|
}
|
|
|
|
DBG (DBG_proc, "sceptre_receive_diag exit\n");
|
|
|
|
return (status);
|
|
}
|
|
|
|
/* I'm not sure if the command sent is really set mode. The SCSI
|
|
* command used is MODE SELECT, but no data is sent. Again, this is
|
|
* not standard. */
|
|
static SANE_Status
|
|
sceptre_set_mode (Sceptre_Scanner * dev)
|
|
{
|
|
SANE_Status status;
|
|
CDB cdb;
|
|
size_t size;
|
|
|
|
DBG (DBG_proc, "sceptre_set_mode: enter\n");
|
|
|
|
size = 0x18;
|
|
MKSCSI_MODE_SELECT (cdb, 1, 0, size);
|
|
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
|
|
|
|
DBG (DBG_proc, "sceptre_set_mode: exit, status=%d\n", status);
|
|
|
|
return (status);
|
|
}
|
|
|
|
/* Start a scan. */
|
|
static SANE_Status
|
|
sceptre_scan (Sceptre_Scanner * dev)
|
|
{
|
|
CDB cdb;
|
|
SANE_Status status;
|
|
|
|
DBG (DBG_proc, "sceptre_scan: enter\n");
|
|
|
|
MKSCSI_SCAN (cdb);
|
|
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
|
|
|
|
DBG (DBG_proc, "sceptre_scan: exit, status=%d\n", status);
|
|
|
|
return status;
|
|
}
|
|
|
|
/* Set a window. */
|
|
static SANE_Status
|
|
sceptre_set_window (Sceptre_Scanner * dev)
|
|
{
|
|
size_t size;
|
|
CDB cdb;
|
|
unsigned char window[82];
|
|
SANE_Status status;
|
|
|
|
DBG (DBG_proc, "sceptre_set_window: enter\n");
|
|
|
|
size = sizeof (window);
|
|
MKSCSI_SET_WINDOW (cdb, size);
|
|
|
|
memset (window, 0, size);
|
|
|
|
/* size of the parameters (74 = 0x4a bytes) */
|
|
window[7] = sizeof (window) - 8;
|
|
|
|
/* X and Y resolution */
|
|
Ito16 (dev->resolution, &window[10]);
|
|
Ito16 (dev->resolution, &window[12]);
|
|
|
|
/* Upper Left (X,Y) */
|
|
Ito32 (dev->x_tl, &window[14]);
|
|
Ito32 (dev->y_tl, &window[18]);
|
|
|
|
/* Width and length */
|
|
Ito32 (dev->width, &window[22]);
|
|
Ito32 (dev->length, &window[26]);
|
|
|
|
/* Image Composition, Halftone and Depth */
|
|
switch (dev->scan_mode)
|
|
{
|
|
case SCEPTRE_LINEART:
|
|
window[31] = dev->val[OPT_THRESHOLD].w;
|
|
window[33] = 0;
|
|
window[34] = 1;
|
|
window[36] = 0;
|
|
break;
|
|
case SCEPTRE_HALFTONE:
|
|
window[31] = 0x80;
|
|
window[33] = 0;
|
|
window[34] = 1;
|
|
window[36] = dev->val[OPT_HALFTONE_PATTERN].w;
|
|
break;
|
|
case SCEPTRE_GRAYSCALE:
|
|
window[31] = 0x80;
|
|
window[33] = 2;
|
|
window[34] = 8;
|
|
window[36] = 0;
|
|
break;
|
|
case SCEPTRE_COLOR:
|
|
window[31] = 0x80;
|
|
window[33] = 5;
|
|
window[34] = 24;
|
|
window[36] = 0;
|
|
break;
|
|
}
|
|
|
|
/* Unknown parameters. They look constant in the windows driver. */
|
|
window[30] = 0x04;
|
|
window[32] = 0x04;
|
|
window[37] = 0x80; /* RIF, although it looks unused. */
|
|
|
|
hexdump (DBG_info2, "windows", window, sizeof (window));
|
|
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
|
|
&window, sizeof (window), NULL, NULL);
|
|
|
|
DBG (DBG_proc, "sceptre_set_window: exit, status=%d\n", status);
|
|
|
|
return status;
|
|
}
|
|
|
|
/* Read the image from the scanner and fill the temporary buffer with it. */
|
|
static SANE_Status
|
|
sceptre_fill_image (Sceptre_Scanner * dev)
|
|
{
|
|
SANE_Status status;
|
|
size_t size;
|
|
CDB cdb;
|
|
size_t data_left;
|
|
|
|
DBG (DBG_proc, "sceptre_fill_image: enter\n");
|
|
|
|
assert (dev->image_begin == dev->image_end);
|
|
assert (dev->real_bytes_left > 0);
|
|
|
|
/* Copy the complete lines, plus the imcompletes
|
|
* ones. We don't keep the real end of data used
|
|
* in image, so we copy the biggest possible.
|
|
*
|
|
* This is a no-op for non color images.
|
|
*/
|
|
memmove (dev->image, dev->image + dev->image_begin, dev->raster_ahead);
|
|
dev->image_begin = 0;
|
|
dev->image_end = 0;
|
|
|
|
while (dev->real_bytes_left)
|
|
{
|
|
|
|
if ((status = sceptre_get_status (dev, &data_left)) != SANE_STATUS_GOOD)
|
|
{
|
|
return (status);
|
|
}
|
|
|
|
/*
|
|
* Try to read the maximum number of bytes.
|
|
*/
|
|
size = data_left;
|
|
if (size > dev->real_bytes_left)
|
|
{
|
|
size = dev->real_bytes_left;
|
|
}
|
|
if (size > dev->image_size - dev->raster_ahead - dev->image_end)
|
|
{
|
|
size = dev->image_size - dev->raster_ahead - dev->image_end;
|
|
}
|
|
if (size > dev->buffer_size)
|
|
{
|
|
size = dev->buffer_size;
|
|
}
|
|
|
|
/* Round down to a multiple of line size. */
|
|
size = size - (size % dev->params.bytes_per_line);
|
|
|
|
if (size == 0)
|
|
{
|
|
/* Probably reached the end of the buffer.
|
|
* Check, just in case. */
|
|
assert (dev->image_end != 0);
|
|
return (SANE_STATUS_GOOD);
|
|
}
|
|
|
|
DBG (DBG_info, "sceptre_fill_image: to read = %ld bytes (bpl=%d)\n",
|
|
(long) size, dev->params.bytes_per_line);
|
|
|
|
MKSCSI_READ_10 (cdb, 0, 0, size);
|
|
|
|
hexdump (DBG_info2, "sceptre_fill_image: READ_10 CDB", cdb.data, 10);
|
|
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
|
|
NULL, 0, dev->buffer, &size);
|
|
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
DBG (DBG_error,
|
|
"sceptre_fill_image: cannot read from the scanner\n");
|
|
return status;
|
|
}
|
|
|
|
DBG (DBG_info, "sceptre_fill_image: real bytes left = %d\n",
|
|
dev->real_bytes_left);
|
|
|
|
switch (dev->scan_mode)
|
|
{
|
|
case SCEPTRE_COLOR:
|
|
sceptre_adjust_raster (dev, size);
|
|
break;
|
|
case SCEPTRE_LINEART:
|
|
case SCEPTRE_HALFTONE:
|
|
{
|
|
/* Invert black and white. */
|
|
unsigned char *src = dev->buffer;
|
|
unsigned char *dest = dev->image + dev->image_end;
|
|
size_t i;
|
|
for (i = 0; i < size; i++)
|
|
{
|
|
*dest = *src ^ 0xff;
|
|
dest++;
|
|
src++;
|
|
}
|
|
dev->image_end += size;
|
|
}
|
|
break;
|
|
default:
|
|
memcpy (dev->image + dev->image_end, dev->buffer, size);
|
|
dev->image_end += size;
|
|
}
|
|
|
|
dev->real_bytes_left -= size;
|
|
}
|
|
|
|
return (SANE_STATUS_GOOD); /* unreachable */
|
|
}
|
|
|
|
/* Copy from the raw buffer to the buffer given by the backend.
|
|
*
|
|
* len in input is the maximum length available in buf, and, in
|
|
* output, is the length written into buf.
|
|
*/
|
|
static void
|
|
sceptre_copy_raw_to_frontend (Sceptre_Scanner * dev, SANE_Byte * buf,
|
|
size_t * len)
|
|
{
|
|
size_t size;
|
|
|
|
size = dev->image_end - dev->image_begin;
|
|
if (size > *len)
|
|
{
|
|
size = *len;
|
|
}
|
|
*len = size;
|
|
|
|
memcpy (buf, dev->image + dev->image_begin, size);
|
|
|
|
dev->image_begin += size;
|
|
}
|
|
|
|
/* Stop a scan. */
|
|
static SANE_Status
|
|
do_cancel (Sceptre_Scanner * dev)
|
|
{
|
|
DBG (DBG_sane_proc, "do_cancel enter\n");
|
|
|
|
if (dev->scanning == SANE_TRUE)
|
|
{
|
|
|
|
/* Reposition the CCD. */
|
|
dev->x_tl = 0;
|
|
dev->x_tl = 0;
|
|
dev->width = 0;
|
|
dev->length = 0;
|
|
sceptre_set_window (dev);
|
|
sceptre_scan (dev);
|
|
|
|
sceptre_close (dev);
|
|
}
|
|
|
|
dev->scanning = SANE_FALSE;
|
|
|
|
DBG (DBG_sane_proc, "do_cancel exit\n");
|
|
|
|
return SANE_STATUS_CANCELLED;
|
|
}
|
|
|
|
/* Start a scan. */
|
|
static const SANE_Word gamma_init[GAMMA_LENGTH] = {
|
|
0x00, 0x06, 0x0A, 0x0D, 0x10, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F,
|
|
0x21, 0x23, 0x25, 0x27,
|
|
0x28, 0x2A, 0x2C, 0x2D, 0x2F, 0x30, 0x32, 0x33, 0x35, 0x36, 0x38, 0x39,
|
|
0x3A, 0x3C, 0x3D, 0x3F,
|
|
0x40, 0x41, 0x43, 0x44, 0x45, 0x46, 0x48, 0x49, 0x4A, 0x4B, 0x4D, 0x4E,
|
|
0x4F, 0x50, 0x51, 0x53,
|
|
0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60,
|
|
0x61, 0x62, 0x63, 0x64,
|
|
0x65, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
|
|
0x72, 0x73, 0x74, 0x75,
|
|
0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7D, 0x7E, 0x7F, 0x80,
|
|
0x81, 0x82, 0x83, 0x84,
|
|
0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
|
|
0x90, 0x91, 0x92, 0x92,
|
|
0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
|
|
0x9E, 0x9F, 0x9F, 0xA0,
|
|
0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xA9, 0xAA,
|
|
0xAB, 0xAC, 0xAD, 0xAD,
|
|
0xAE, 0xAF, 0xB0, 0xB1, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB5, 0xB6, 0xB7,
|
|
0xB8, 0xB9, 0xB9, 0xBA,
|
|
0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC0, 0xC1, 0xC2, 0xC3, 0xC3,
|
|
0xC4, 0xC5, 0xC6, 0xC6,
|
|
0xC7, 0xC8, 0xC9, 0xC9, 0xCA, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCF, 0xCF,
|
|
0xD0, 0xD1, 0xD2, 0xD2,
|
|
0xD3, 0xD4, 0xD5, 0xD5, 0xD6, 0xD7, 0xD7, 0xD8, 0xD9, 0xDA, 0xDA, 0xDB,
|
|
0xDC, 0xDC, 0xDD, 0xDE,
|
|
0xDF, 0xDF, 0xE0, 0xE1, 0xE1, 0xE2, 0xE3, 0xE4, 0xE4, 0xE5, 0xE6, 0xE6,
|
|
0xE7, 0xE8, 0xE8, 0xE9,
|
|
0xEA, 0xEB, 0xEB, 0xEC, 0xED, 0xED, 0xEE, 0xEF, 0xEF, 0xF0, 0xF1, 0xF1,
|
|
0xF2, 0xF3, 0xF4, 0xF4,
|
|
0xF5, 0xF6, 0xF6, 0xF7, 0xF8, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC, 0xFC,
|
|
0xFD, 0xFE, 0xFE, 0xFF
|
|
};
|
|
|
|
static SANE_Status
|
|
sceptre_send_gamma (Sceptre_Scanner * dev)
|
|
{
|
|
CDB cdb;
|
|
int i;
|
|
struct
|
|
{
|
|
unsigned char gamma_R[GAMMA_LENGTH];
|
|
unsigned char gamma_G[GAMMA_LENGTH];
|
|
unsigned char gamma_B[GAMMA_LENGTH];
|
|
}
|
|
param;
|
|
size_t size;
|
|
SANE_Status status;
|
|
|
|
DBG (DBG_proc, "sceptre_send_gamma: enter\n");
|
|
|
|
size = sizeof (param);
|
|
|
|
assert (size == 0x300);
|
|
|
|
MKSCSI_SEND_10 (cdb, 0x03, 0x02, size);
|
|
|
|
if (dev->val[OPT_CUSTOM_GAMMA].w)
|
|
{
|
|
/* Use the custom gamma. */
|
|
for (i = 0; i < GAMMA_LENGTH; i++)
|
|
{
|
|
param.gamma_R[i] = dev->gamma_R[i];
|
|
param.gamma_G[i] = dev->gamma_G[i];
|
|
param.gamma_B[i] = dev->gamma_B[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < GAMMA_LENGTH; i++)
|
|
{
|
|
param.gamma_R[i] = gamma_init[i];
|
|
param.gamma_G[i] = gamma_init[i];
|
|
param.gamma_B[i] = gamma_init[i];
|
|
}
|
|
}
|
|
|
|
hexdump (DBG_info2, "gamma", param.gamma_R, 3 * GAMMA_LENGTH);
|
|
|
|
status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
|
|
¶m, sizeof (param), NULL, NULL);
|
|
|
|
DBG (DBG_proc, "sceptre_send_gamma: exit, status=%d\n", status);
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/* Entry points */
|
|
|
|
SANE_Status
|
|
sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
|
|
{
|
|
FILE *fp;
|
|
char dev_name[PATH_MAX];
|
|
size_t len;
|
|
|
|
DBG_INIT ();
|
|
|
|
DBG (DBG_proc, "sane_init: enter\n");
|
|
|
|
authorize = authorize; /* silence gcc */
|
|
|
|
DBG (DBG_error, "This is sane-sceptre version %d.%d-%d\n", V_MAJOR,
|
|
V_MINOR, BUILD);
|
|
DBG (DBG_error, "(C) 2002 by Frank Zago\n");
|
|
|
|
if (version_code)
|
|
{
|
|
*version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD);
|
|
}
|
|
|
|
fp = sanei_config_open (SCEPTRE_CONFIG_FILE);
|
|
if (!fp)
|
|
{
|
|
/* default to /dev/scanner instead of insisting on config file */
|
|
attach_scanner ("/dev/scanner", 0);
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
while (sanei_config_read (dev_name, sizeof (dev_name), fp))
|
|
{
|
|
if (dev_name[0] == '#') /* ignore line comments */
|
|
continue;
|
|
len = strlen (dev_name);
|
|
|
|
if (!len)
|
|
continue; /* ignore empty lines */
|
|
|
|
sanei_config_attach_matching_devices (dev_name, attach_one);
|
|
}
|
|
|
|
fclose (fp);
|
|
|
|
DBG (DBG_proc, "sane_init: leave\n");
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
|
|
{
|
|
Sceptre_Scanner *dev;
|
|
int i;
|
|
|
|
DBG (DBG_proc, "sane_get_devices: enter\n");
|
|
|
|
local_only = local_only; /* silence gcc */
|
|
|
|
if (devlist)
|
|
free (devlist);
|
|
|
|
devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
|
|
if (!devlist)
|
|
return SANE_STATUS_NO_MEM;
|
|
|
|
i = 0;
|
|
for (dev = first_dev; i < num_devices; dev = dev->next)
|
|
devlist[i++] = &dev->sane;
|
|
devlist[i++] = 0;
|
|
|
|
*device_list = devlist;
|
|
|
|
DBG (DBG_proc, "sane_get_devices: exit\n");
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_open (SANE_String_Const devicename, SANE_Handle * handle)
|
|
{
|
|
Sceptre_Scanner *dev;
|
|
SANE_Status status;
|
|
|
|
DBG (DBG_proc, "sane_open: enter\n");
|
|
|
|
/* search for devicename */
|
|
if (devicename[0])
|
|
{
|
|
DBG (DBG_info, "sane_open: devicename=%s\n", 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
|
|
{
|
|
DBG (DBG_sane_info, "sane_open: no devicename, opening first device\n");
|
|
dev = first_dev; /* empty devicename -> use first device */
|
|
}
|
|
|
|
if (!dev)
|
|
{
|
|
DBG (DBG_error, "No scanner found\n");
|
|
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
sceptre_init_options (dev);
|
|
|
|
/* Initialize the gamma table. */
|
|
memcpy (dev->gamma_R, gamma_init, dev->opt[OPT_GAMMA_VECTOR_R].size);
|
|
memcpy (dev->gamma_G, gamma_init, dev->opt[OPT_GAMMA_VECTOR_G].size);
|
|
memcpy (dev->gamma_B, gamma_init, dev->opt[OPT_GAMMA_VECTOR_B].size);
|
|
|
|
*handle = dev;
|
|
|
|
DBG (DBG_proc, "sane_open: exit\n");
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
const SANE_Option_Descriptor *
|
|
sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
|
|
{
|
|
Sceptre_Scanner *dev = handle;
|
|
|
|
DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option);
|
|
|
|
if ((unsigned) option >= OPT_NUM_OPTIONS)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
DBG (DBG_proc, "sane_get_option_descriptor: exit\n");
|
|
|
|
return dev->opt + option;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_control_option (SANE_Handle handle, SANE_Int option,
|
|
SANE_Action action, void *val, SANE_Int * info)
|
|
{
|
|
Sceptre_Scanner *dev = handle;
|
|
SANE_Status status;
|
|
SANE_Word cap;
|
|
|
|
DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n",
|
|
option, action);
|
|
|
|
if (info)
|
|
{
|
|
*info = 0;
|
|
}
|
|
|
|
if (dev->scanning)
|
|
{
|
|
return SANE_STATUS_DEVICE_BUSY;
|
|
}
|
|
|
|
if (option < 0 || option >= OPT_NUM_OPTIONS)
|
|
{
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
cap = dev->opt[option].cap;
|
|
if (!SANE_OPTION_IS_ACTIVE (cap))
|
|
{
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
assert (dev->opt[option].name);
|
|
|
|
if (action == SANE_ACTION_GET_VALUE)
|
|
{
|
|
|
|
switch (option)
|
|
{
|
|
/* word options */
|
|
case OPT_NUM_OPTS:
|
|
case OPT_RESOLUTION:
|
|
case OPT_TL_X:
|
|
case OPT_TL_Y:
|
|
case OPT_BR_X:
|
|
case OPT_BR_Y:
|
|
case OPT_THRESHOLD:
|
|
case OPT_CUSTOM_GAMMA:
|
|
case OPT_HALFTONE_PATTERN:
|
|
case OPT_PREVIEW:
|
|
|
|
*(SANE_Word *) val = dev->val[option].w;
|
|
return SANE_STATUS_GOOD;
|
|
|
|
/* string options */
|
|
case OPT_MODE:
|
|
strcpy (val, dev->val[option].s);
|
|
return SANE_STATUS_GOOD;
|
|
|
|
case OPT_GAMMA_VECTOR_R:
|
|
case OPT_GAMMA_VECTOR_G:
|
|
case OPT_GAMMA_VECTOR_B:
|
|
memcpy (val, dev->val[option].wa, dev->opt[option].size);
|
|
return SANE_STATUS_GOOD;
|
|
|
|
default:
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
}
|
|
else if (action == SANE_ACTION_SET_VALUE)
|
|
{
|
|
|
|
if (!SANE_OPTION_IS_SETTABLE (cap))
|
|
{
|
|
DBG (DBG_error, "could not set option, not settable\n");
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
status = sanei_constrain_value (dev->opt + option, val, info);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
DBG (DBG_error, "could not set option, invalid value\n");
|
|
return status;
|
|
}
|
|
|
|
switch (option)
|
|
{
|
|
|
|
/* Side-effect options */
|
|
case OPT_TL_X:
|
|
case OPT_TL_Y:
|
|
case OPT_BR_X:
|
|
case OPT_BR_Y:
|
|
case OPT_RESOLUTION:
|
|
if (info)
|
|
{
|
|
*info |= SANE_INFO_RELOAD_PARAMS;
|
|
}
|
|
dev->val[option].w = *(SANE_Word *) val;
|
|
return SANE_STATUS_GOOD;
|
|
|
|
/* Side-effect free options */
|
|
case OPT_THRESHOLD:
|
|
case OPT_HALFTONE_PATTERN:
|
|
case OPT_PREVIEW:
|
|
dev->val[option].w = *(SANE_Word *) val;
|
|
return SANE_STATUS_GOOD;
|
|
|
|
case OPT_MODE:
|
|
free (dev->val[OPT_MODE].s);
|
|
dev->val[OPT_MODE].s = (SANE_Char *) strdup (val);
|
|
|
|
/* Set default options for the scan modes. */
|
|
dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
|
|
|
|
if (strcmp (dev->val[OPT_MODE].s, LINEART_STR) == 0)
|
|
{
|
|
dev->scan_mode = SCEPTRE_LINEART;
|
|
dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
|
|
}
|
|
else if (strcmp (dev->val[OPT_MODE].s, HALFTONE_STR) == 0)
|
|
{
|
|
dev->scan_mode = SCEPTRE_HALFTONE;
|
|
dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
|
|
}
|
|
else if (strcmp (dev->val[OPT_MODE].s, GRAY_STR) == 0)
|
|
{
|
|
dev->scan_mode = SCEPTRE_GRAYSCALE;
|
|
}
|
|
else if (strcmp (dev->val[OPT_MODE].s, COLOR_STR) == 0)
|
|
{
|
|
dev->scan_mode = SCEPTRE_COLOR;
|
|
dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
|
|
if (dev->val[OPT_CUSTOM_GAMMA].w)
|
|
{
|
|
dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
|
|
}
|
|
}
|
|
|
|
if (info)
|
|
{
|
|
*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
|
|
}
|
|
return SANE_STATUS_GOOD;
|
|
|
|
case OPT_GAMMA_VECTOR_R:
|
|
case OPT_GAMMA_VECTOR_G:
|
|
case OPT_GAMMA_VECTOR_B:
|
|
memcpy (dev->val[option].wa, val, dev->opt[option].size);
|
|
return SANE_STATUS_GOOD;
|
|
|
|
case OPT_CUSTOM_GAMMA:
|
|
dev->val[OPT_CUSTOM_GAMMA].w = *(SANE_Word *) val;
|
|
if (dev->val[OPT_CUSTOM_GAMMA].w)
|
|
{
|
|
/* use custom_gamma_table */
|
|
dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
|
|
}
|
|
else
|
|
{
|
|
dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
|
|
dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
|
|
}
|
|
if (info)
|
|
{
|
|
*info |= SANE_INFO_RELOAD_OPTIONS;
|
|
}
|
|
return SANE_STATUS_GOOD;
|
|
|
|
default:
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
}
|
|
|
|
DBG (DBG_proc, "sane_control_option: exit, bad\n");
|
|
|
|
return SANE_STATUS_UNSUPPORTED;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
|
|
{
|
|
Sceptre_Scanner *dev = handle;
|
|
int x_dpi; /* X-Resolution */
|
|
|
|
DBG (DBG_proc, "sane_get_parameters: enter\n");
|
|
|
|
if (!(dev->scanning))
|
|
{
|
|
/* Prepare the parameters for the caller. */
|
|
memset (&dev->params, 0, sizeof (SANE_Parameters));
|
|
|
|
if (dev->val[OPT_PREVIEW].w == SANE_TRUE)
|
|
{
|
|
dev->resolution = 30; /* Windows TWAIN does 32 */
|
|
dev->x_tl = 0;
|
|
dev->y_tl = 0;
|
|
dev->x_br = mmToIlu (SANE_UNFIX (dev->x_range.max));
|
|
dev->y_br = mmToIlu (SANE_UNFIX (dev->y_range.max));
|
|
}
|
|
else
|
|
{
|
|
/* Setup the parameters for the scan. These values will be re-used
|
|
* in the SET WINDOWS command. */
|
|
dev->resolution = dev->val[OPT_RESOLUTION].w;
|
|
|
|
dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w));
|
|
dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w));
|
|
dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w));
|
|
dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w));
|
|
}
|
|
|
|
/* Check the corners are OK. */
|
|
if (dev->x_tl > dev->x_br)
|
|
{
|
|
int s;
|
|
s = dev->x_tl;
|
|
dev->x_tl = dev->x_br;
|
|
dev->x_br = s;
|
|
}
|
|
if (dev->y_tl > dev->y_br)
|
|
{
|
|
int s;
|
|
s = dev->y_tl;
|
|
dev->y_tl = dev->y_br;
|
|
dev->y_br = s;
|
|
}
|
|
|
|
dev->width = dev->x_br - dev->x_tl;
|
|
dev->length = dev->y_br - dev->y_tl;
|
|
|
|
/*
|
|
* Adjust the "X Resolution". The sceptre S1200 ignores the
|
|
* Y-Resolution parameter in the windows block. X-Resolution
|
|
* is used instead. However the limits are not the same for X
|
|
* (600 dpi) and Y (1200 dpi).
|
|
*/
|
|
x_dpi = dev->resolution;
|
|
if (x_dpi > 600)
|
|
{
|
|
x_dpi = 600;
|
|
}
|
|
|
|
/* Set depth */
|
|
switch (dev->scan_mode)
|
|
{
|
|
case SCEPTRE_LINEART:
|
|
dev->params.format = SANE_FRAME_GRAY;
|
|
dev->depth = 1;
|
|
break;
|
|
case SCEPTRE_HALFTONE:
|
|
dev->params.format = SANE_FRAME_GRAY;
|
|
dev->depth = 1;
|
|
break;
|
|
case SCEPTRE_GRAYSCALE:
|
|
dev->params.format = SANE_FRAME_GRAY;
|
|
dev->depth = 8;
|
|
break;
|
|
case SCEPTRE_COLOR:
|
|
dev->params.format = SANE_FRAME_RGB;
|
|
dev->depth = 8;
|
|
break;
|
|
}
|
|
|
|
/* this scanner does only one pass */
|
|
dev->params.last_frame = SANE_TRUE;
|
|
dev->params.depth = dev->depth;
|
|
|
|
/* Compute the number of pixels, bytes per lines and lines. */
|
|
switch (dev->scan_mode)
|
|
{
|
|
case SCEPTRE_LINEART:
|
|
case SCEPTRE_HALFTONE:
|
|
dev->params.pixels_per_line = (dev->width * x_dpi) / 600;
|
|
dev->params.pixels_per_line &= ~0x7; /* round down to 8 */
|
|
|
|
dev->params.bytes_per_line = (dev->params.pixels_per_line) / 8;
|
|
|
|
dev->params.lines = ((dev->length * dev->resolution) / 600);
|
|
if ((dev->params.lines) * 600 != (dev->length * dev->resolution))
|
|
{
|
|
/* Round up lines to 2. */
|
|
dev->params.lines &= ~1;
|
|
dev->params.lines += 2;
|
|
}
|
|
|
|
break;
|
|
|
|
case SCEPTRE_GRAYSCALE:
|
|
case SCEPTRE_COLOR:
|
|
/* pixels_per_line rounding rules:
|
|
* 2n + [0.0 .. 1.0] -> round to 2n
|
|
* 2n + ]1.0 .. 2.0] -> round to 2n + 2
|
|
*/
|
|
dev->params.pixels_per_line = (dev->width * x_dpi) / 600;
|
|
if (dev->params.pixels_per_line & 1)
|
|
{
|
|
if ((dev->params.pixels_per_line * 600) == (dev->width * x_dpi))
|
|
{
|
|
/* 2n */
|
|
dev->params.pixels_per_line--;
|
|
}
|
|
else
|
|
{
|
|
/* 2n+2 */
|
|
dev->params.pixels_per_line++;
|
|
}
|
|
}
|
|
|
|
dev->params.bytes_per_line = dev->params.pixels_per_line;
|
|
if (dev->scan_mode == SCEPTRE_COLOR)
|
|
dev->params.bytes_per_line *= 3;
|
|
|
|
/* lines number rounding rules:
|
|
* 2n + [0.0 .. 2.0[ -> round to 2n
|
|
*
|
|
* Note: the rounding is often incorrect at high
|
|
* resolution (ag more than 300dpi)
|
|
*/
|
|
dev->params.lines = (dev->length * dev->resolution) / 600;
|
|
dev->params.lines &= ~1;
|
|
|
|
break;
|
|
}
|
|
|
|
/* Find the proper color shifting parameter. */
|
|
if (dev->scan_mode == SCEPTRE_COLOR)
|
|
{
|
|
int i = 1;
|
|
while (resolutions_list[i] != dev->resolution)
|
|
{
|
|
i++;
|
|
}
|
|
dev->color_shift = color_shift_list[i];
|
|
}
|
|
else
|
|
{
|
|
dev->color_shift = 0;
|
|
}
|
|
|
|
DBG (DBG_proc, "color_shift = %d\n", dev->color_shift);
|
|
|
|
dev->bytes_left = dev->params.lines * dev->params.bytes_per_line;
|
|
}
|
|
|
|
/* Return the current values. */
|
|
if (params)
|
|
{
|
|
*params = (dev->params);
|
|
}
|
|
|
|
DBG (DBG_proc, "sane_get_parameters: exit\n");
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_start (SANE_Handle handle)
|
|
{
|
|
Sceptre_Scanner *dev = handle;
|
|
SANE_Status status;
|
|
|
|
DBG (DBG_proc, "sane_start: enter\n");
|
|
|
|
if (!(dev->scanning))
|
|
{
|
|
|
|
sane_get_parameters (dev, NULL);
|
|
|
|
if (dev->image)
|
|
{
|
|
free (dev->image);
|
|
}
|
|
/* Compute the length necessary in image. The first part will store
|
|
* the complete lines, and the rest is used to stored ahead
|
|
* rasters.
|
|
*/
|
|
dev->raster_ahead =
|
|
(2 * dev->color_shift + 1) * dev->params.bytes_per_line;
|
|
dev->image_size = dev->buffer_size + dev->raster_ahead;
|
|
dev->image = malloc (dev->image_size);
|
|
if (dev->image == NULL)
|
|
{
|
|
return SANE_STATUS_NO_MEM;
|
|
}
|
|
dev->image_begin = 0;
|
|
dev->image_end = 0;
|
|
|
|
dev->raster_size = dev->params.bytes_per_line / 3;
|
|
dev->raster_num = 0;
|
|
dev->raster_real = 0;
|
|
dev->line = 0;
|
|
|
|
/* Open again the scanner. */
|
|
if (sanei_scsi_open
|
|
(dev->devicename, &(dev->sfd), sceptre_sense_handler, dev) != 0)
|
|
{
|
|
DBG (DBG_error, "ERROR: sane_start: open failed\n");
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
/* The scanner must be ready. */
|
|
status = sceptre_wait_scanner (dev);
|
|
if (status)
|
|
{
|
|
sceptre_close (dev);
|
|
return status;
|
|
}
|
|
|
|
status = sceptre_do_diag (dev);
|
|
if (status)
|
|
{
|
|
sceptre_close (dev);
|
|
return status;
|
|
}
|
|
|
|
status = sceptre_set_mode (dev);
|
|
if (status)
|
|
{
|
|
sceptre_close (dev);
|
|
return status;
|
|
}
|
|
|
|
status = sceptre_set_window (dev);
|
|
if (status)
|
|
{
|
|
sceptre_close (dev);
|
|
return status;
|
|
}
|
|
|
|
status = sceptre_send_gamma (dev);
|
|
if (status)
|
|
{
|
|
sceptre_close (dev);
|
|
return status;
|
|
}
|
|
|
|
status = sceptre_scan (dev);
|
|
if (status)
|
|
{
|
|
sceptre_close (dev);
|
|
return status;
|
|
}
|
|
}
|
|
|
|
dev->bytes_left = dev->params.bytes_per_line * dev->params.lines;
|
|
if ((status =
|
|
sceptre_get_status (dev, &dev->real_bytes_left)) != SANE_STATUS_GOOD)
|
|
{
|
|
return (status);
|
|
}
|
|
|
|
dev->scanning = SANE_TRUE;
|
|
|
|
DBG (DBG_proc, "sane_start: exit\n");
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
|
|
SANE_Int * len)
|
|
{
|
|
SANE_Status status;
|
|
Sceptre_Scanner *dev = handle;
|
|
size_t size;
|
|
int buf_offset; /* offset into buf */
|
|
|
|
DBG (DBG_proc, "sane_read: enter\n");
|
|
|
|
*len = 0;
|
|
|
|
if (!(dev->scanning))
|
|
{
|
|
/* OOPS, not scanning */
|
|
return do_cancel (dev);
|
|
}
|
|
|
|
if (dev->bytes_left <= 0)
|
|
{
|
|
return (SANE_STATUS_EOF);
|
|
}
|
|
|
|
buf_offset = 0;
|
|
|
|
do
|
|
{
|
|
if (dev->image_begin == dev->image_end)
|
|
{
|
|
/* Fill image */
|
|
status = sceptre_fill_image (dev);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
return (status);
|
|
}
|
|
}
|
|
|
|
/* Something must have been read */
|
|
assert (dev->image_begin != dev->image_end);
|
|
|
|
/* Copy the data to the frontend buffer. */
|
|
size = max_len - buf_offset;
|
|
if (size > dev->bytes_left)
|
|
{
|
|
size = dev->bytes_left;
|
|
}
|
|
sceptre_copy_raw_to_frontend (dev, buf + buf_offset, &size);
|
|
|
|
buf_offset += size;
|
|
|
|
dev->bytes_left -= size;
|
|
*len += size;
|
|
|
|
}
|
|
while ((buf_offset != max_len) && dev->bytes_left);
|
|
|
|
DBG (DBG_info, "sane_read: leave, bytes_left=%d\n", dev->bytes_left);
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
|
|
{
|
|
DBG (DBG_proc, "sane_set_io_mode: enter\n");
|
|
|
|
handle = handle; /* silence gcc */
|
|
non_blocking = non_blocking; /* silence gcc */
|
|
|
|
DBG (DBG_proc, "sane_set_io_mode: exit\n");
|
|
|
|
return SANE_STATUS_UNSUPPORTED;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
|
|
{
|
|
DBG (DBG_proc, "sane_get_select_fd: enter\n");
|
|
|
|
handle = handle; /* silence gcc */
|
|
fd = fd; /* silence gcc */
|
|
|
|
DBG (DBG_proc, "sane_get_select_fd: exit\n");
|
|
|
|
return SANE_STATUS_UNSUPPORTED;
|
|
}
|
|
|
|
void
|
|
sane_cancel (SANE_Handle handle)
|
|
{
|
|
Sceptre_Scanner *dev = handle;
|
|
|
|
DBG (DBG_proc, "sane_cancel: enter\n");
|
|
|
|
do_cancel (dev);
|
|
|
|
DBG (DBG_proc, "sane_cancel: exit\n");
|
|
}
|
|
|
|
void
|
|
sane_close (SANE_Handle handle)
|
|
{
|
|
Sceptre_Scanner *dev = handle;
|
|
Sceptre_Scanner *dev_tmp;
|
|
|
|
DBG (DBG_proc, "sane_close: enter\n");
|
|
|
|
do_cancel (dev);
|
|
sceptre_close (dev);
|
|
|
|
/* Unlink dev. */
|
|
if (first_dev == dev)
|
|
{
|
|
first_dev = dev->next;
|
|
}
|
|
else
|
|
{
|
|
dev_tmp = first_dev;
|
|
while (dev_tmp->next && dev_tmp->next != dev)
|
|
{
|
|
dev_tmp = dev_tmp->next;
|
|
}
|
|
if (dev_tmp->next != NULL)
|
|
{
|
|
dev_tmp->next = dev_tmp->next->next;
|
|
}
|
|
}
|
|
|
|
sceptre_free (dev);
|
|
num_devices--;
|
|
|
|
DBG (DBG_proc, "sane_close: exit\n");
|
|
}
|
|
|
|
void
|
|
sane_exit (void)
|
|
{
|
|
DBG (DBG_proc, "sane_exit: enter\n");
|
|
|
|
while (first_dev)
|
|
{
|
|
sane_close (first_dev);
|
|
}
|
|
|
|
if (devlist)
|
|
{
|
|
free (devlist);
|
|
devlist = NULL;
|
|
}
|
|
|
|
DBG (DBG_proc, "sane_exit: exit\n");
|
|
}
|