kopia lustrzana https://gitlab.com/sane-project/backends
990 wiersze
25 KiB
C
990 wiersze
25 KiB
C
/* sane - Scanner Access Now Easy.
|
|
Copyright (C) 1997 Gordon Matzigkeit
|
|
Copyright (C) 1997 David Mosberger-Tang
|
|
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. */
|
|
|
|
#include <sane/config.h>
|
|
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
extern int errno;
|
|
|
|
#include <sane/sane.h>
|
|
#include <sane/saneopts.h>
|
|
|
|
#include "pint.h"
|
|
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
|
|
#include <sane/sanei_backend.h>
|
|
|
|
#ifndef PATH_MAX
|
|
# define PATH_MAX 1024
|
|
#endif
|
|
|
|
#include <sane/sanei_config.h>
|
|
#define PINT_CONFIG_FILE "pint.conf"
|
|
|
|
#define MM_PER_INCH 25.4
|
|
#define DECIPOINTS_PER_MM (720.0 / MM_PER_INCH)
|
|
#define TWELVEHUNDS_PER_MM (1200.0 / MM_PER_INCH)
|
|
|
|
|
|
static int num_devices;
|
|
static PINT_Device *first_dev;
|
|
static PINT_Scanner *first_handle;
|
|
|
|
/* A zero-terminated list of valid scanner modes. */
|
|
static SANE_String_Const mode_list[8];
|
|
|
|
static const SANE_Range s7_range =
|
|
{
|
|
-127, /* minimum */
|
|
127, /* maximum */
|
|
1 /* quantization */
|
|
};
|
|
|
|
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
|
|
attach (const char *devname, PINT_Device **devp)
|
|
{
|
|
int fd;
|
|
long lastguess, inc;
|
|
PINT_Device *dev;
|
|
struct scan_io scanio;
|
|
|
|
for (dev = first_dev; dev; dev = dev->next)
|
|
if (strcmp (dev->sane.name, devname) == 0)
|
|
{
|
|
if (devp)
|
|
*devp = dev;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
DBG(3, "attach: opening %s\n", devname);
|
|
fd = open (devname, O_RDONLY, 0);
|
|
if (fd < 0)
|
|
{
|
|
DBG(1, "attach: open failed (%s)\n", strerror (errno));
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
DBG(3, "attach: sending SCIOCGET\n");
|
|
if (ioctl (fd, SCIOCGET, &scanio) < 0)
|
|
{
|
|
DBG(1, "attach: get status failed (%s)\n", strerror (errno));
|
|
close (fd);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
dev = malloc (sizeof (*dev));
|
|
if (!dev)
|
|
return SANE_STATUS_NO_MEM;
|
|
|
|
memset(dev, 0, sizeof (*dev));
|
|
|
|
/* Copy the original scanner state to the device structure. */
|
|
memcpy (&dev->scanio, &scanio, sizeof (dev->scanio));
|
|
|
|
/* FIXME: PINT currently has no good way to determine maxima and minima.
|
|
So, do binary searches to find out what limits the driver has. */
|
|
|
|
/* Assume that minimum range of x and y is 0. */
|
|
dev->x_range.min = SANE_FIX (0);
|
|
dev->y_range.min = SANE_FIX (0);
|
|
dev->x_range.quant = 0;
|
|
dev->y_range.quant = 0;
|
|
|
|
/* x range */
|
|
inc = 8.5 * 1200;
|
|
|
|
/* Converge on the maximum scan width. */
|
|
while ((inc /= 2) != 0)
|
|
{
|
|
/* Move towards the extremum until we overflow. */
|
|
do
|
|
{
|
|
lastguess = scanio.scan_width;
|
|
scanio.scan_width += inc;
|
|
}
|
|
while (ioctl (fd, SCIOCSET, &scanio) >= 0);
|
|
|
|
/* Pick the last valid guess, divide by two, and try again. */
|
|
scanio.scan_width = lastguess;
|
|
}
|
|
dev->x_range.max = SANE_FIX (scanio.scan_width / TWELVEHUNDS_PER_MM);
|
|
|
|
/* y range */
|
|
inc = 11 * 1200;
|
|
while ((inc /= 2) != 0)
|
|
{
|
|
do
|
|
{
|
|
lastguess = scanio.scan_height;
|
|
scanio.scan_height += inc;
|
|
}
|
|
while (ioctl (fd, SCIOCSET, &scanio) >= 0);
|
|
scanio.scan_height = lastguess;
|
|
}
|
|
dev->y_range.max = SANE_FIX (scanio.scan_height / TWELVEHUNDS_PER_MM);
|
|
|
|
/* Converge on the minimum scan resolution. */
|
|
dev->dpi_range.quant = 1;
|
|
|
|
if (scanio.scan_x_resolution > scanio.scan_y_resolution)
|
|
scanio.scan_x_resolution = scanio.scan_y_resolution;
|
|
else
|
|
scanio.scan_y_resolution = scanio.scan_x_resolution;
|
|
|
|
inc = -scanio.scan_x_resolution;
|
|
while ((inc /= 2) != 0)
|
|
{
|
|
do
|
|
{
|
|
lastguess = scanio.scan_x_resolution;
|
|
scanio.scan_x_resolution = scanio.scan_y_resolution += inc;
|
|
}
|
|
while (ioctl (fd, SCIOCSET, &scanio) >= 0);
|
|
scanio.scan_x_resolution = scanio.scan_y_resolution = lastguess;
|
|
}
|
|
dev->dpi_range.min = scanio.scan_x_resolution;
|
|
|
|
/* Converge on the maximum scan resolution. */
|
|
inc = 600;
|
|
while ((inc /= 2) != 0)
|
|
{
|
|
do
|
|
{
|
|
lastguess = scanio.scan_x_resolution;
|
|
scanio.scan_x_resolution = scanio.scan_y_resolution += inc;
|
|
}
|
|
while (ioctl (fd, SCIOCSET, &scanio) >= 0);
|
|
scanio.scan_x_resolution = scanio.scan_y_resolution = lastguess;
|
|
}
|
|
dev->dpi_range.max = scanio.scan_x_resolution;
|
|
|
|
/* Determine the valid scan modes for mode_list. */
|
|
lastguess = 0;
|
|
#define CHECK_MODE(flag,modename) \
|
|
scanio.scan_image_mode = flag; \
|
|
if (ioctl (fd, SCIOCSET, &scanio) >= 0) \
|
|
mode_list[lastguess ++] = modename
|
|
|
|
CHECK_MODE(SIM_BINARY_MONOCHROME, "Lineart");
|
|
CHECK_MODE(SIM_DITHERED_MONOCHROME, "Halftone");
|
|
CHECK_MODE(SIM_GRAYSCALE, "Gray");
|
|
CHECK_MODE(SIM_COLOR, "Color");
|
|
CHECK_MODE(SIM_RED, "Red");
|
|
CHECK_MODE(SIM_GREEN, "Green");
|
|
CHECK_MODE(SIM_BLUE, "Blue");
|
|
#undef CHECK_MODE
|
|
|
|
/* Zero-terminate the list of modes. */
|
|
mode_list[lastguess] = 0;
|
|
|
|
/* Restore the scanner state. */
|
|
if (ioctl (fd, SCIOCSET, &dev->scanio))
|
|
DBG (2, "cannot reset original scanner state: %s\n", strerror (errno));
|
|
close (fd);
|
|
|
|
dev->sane.name = strdup (devname);
|
|
|
|
/* Determine vendor. */
|
|
switch (scanio.scan_scanner_type)
|
|
{
|
|
case EPSON_ES300C:
|
|
dev->sane.vendor = "Epson";
|
|
break;
|
|
|
|
case FUJITSU_M3096G:
|
|
dev->sane.vendor = "Fujitsu";
|
|
break;
|
|
|
|
case HP_SCANJET_IIC:
|
|
dev->sane.vendor = "HP";
|
|
break;
|
|
|
|
case IBM_2456:
|
|
dev->sane.vendor = "IBM";
|
|
break;
|
|
|
|
case MUSTEK_06000CX:
|
|
case MUSTEK_12000CX:
|
|
dev->sane.vendor = "Mustek";
|
|
break;
|
|
|
|
case RICOH_FS1:
|
|
case RICOH_IS410:
|
|
case RICOH_IS50:
|
|
dev->sane.vendor = "Ricoh";
|
|
break;
|
|
|
|
case SHARP_JX600:
|
|
dev->sane.vendor = "Sharp";
|
|
break;
|
|
|
|
case UMAX_UC630:
|
|
case UMAX_UG630:
|
|
dev->sane.vendor = "UMAX";
|
|
break;
|
|
|
|
default:
|
|
dev->sane.vendor = "PINT";
|
|
}
|
|
|
|
/* Determine model. */
|
|
switch (scanio.scan_scanner_type)
|
|
{
|
|
case EPSON_ES300C:
|
|
dev->sane.vendor = "Epson";
|
|
break;
|
|
|
|
case FUJITSU_M3096G:
|
|
dev->sane.model = "M3096G";
|
|
break;
|
|
|
|
case HP_SCANJET_IIC:
|
|
dev->sane.model = "ScanJet IIc";
|
|
break;
|
|
|
|
case IBM_2456:
|
|
dev->sane.vendor = "IBM";
|
|
break;
|
|
|
|
case MUSTEK_06000CX:
|
|
case MUSTEK_12000CX:
|
|
dev->sane.vendor = "Mustek";
|
|
break;
|
|
|
|
case RICOH_FS1:
|
|
dev->sane.model = "FS1";
|
|
break;
|
|
|
|
case RICOH_IS410:
|
|
dev->sane.model = "IS-410";
|
|
break;
|
|
|
|
case RICOH_IS50:
|
|
dev->sane.vendor = "Ricoh";
|
|
break;
|
|
|
|
case SHARP_JX600:
|
|
dev->sane.vendor = "Sharp";
|
|
break;
|
|
|
|
case UMAX_UC630:
|
|
case UMAX_UG630:
|
|
dev->sane.vendor = "UMAX";
|
|
break;
|
|
|
|
default:
|
|
dev->sane.model = "unknown";
|
|
}
|
|
|
|
/* Determine the scanner type. */
|
|
switch (scanio.scan_scanner_type)
|
|
{
|
|
case HP_SCANJET_IIC:
|
|
dev->sane.type = "flatbed scanner";
|
|
|
|
/* FIXME: which of these are flatbed or handhelds? */
|
|
case EPSON_ES300C:
|
|
case FUJITSU_M3096G:
|
|
case IBM_2456:
|
|
case MUSTEK_06000CX:
|
|
case MUSTEK_12000CX:
|
|
case RICOH_FS1:
|
|
case RICOH_IS410:
|
|
case RICOH_IS50:
|
|
case SHARP_JX600:
|
|
case UMAX_UC630:
|
|
case UMAX_UG630:
|
|
default:
|
|
dev->sane.type = "generic scanner";
|
|
}
|
|
|
|
DBG(1, "attach: found %s %s, x=%g-%gmm, y=%g-%gmm, "
|
|
"resolution=%d-%ddpi\n", dev->sane.vendor, dev->sane.model,
|
|
SANE_UNFIX (dev->x_range.min), SANE_UNFIX (dev->x_range.max),
|
|
SANE_UNFIX (dev->y_range.min), SANE_UNFIX (dev->y_range.max),
|
|
dev->dpi_range.min, dev->dpi_range.max);
|
|
|
|
++num_devices;
|
|
dev->next = first_dev;
|
|
first_dev = dev;
|
|
|
|
if (devp)
|
|
*devp = dev;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
static SANE_Status
|
|
init_options (PINT_Scanner *s)
|
|
{
|
|
int i;
|
|
int x0, x1, y0, y1;
|
|
|
|
memset (s->opt, 0, sizeof (s->opt));
|
|
memset (s->val, 0, sizeof (s->val));
|
|
|
|
for (i = 0; i < NUM_OPTIONS; ++i)
|
|
{
|
|
s->opt[i].size = sizeof (SANE_Word);
|
|
s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
|
|
}
|
|
|
|
s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
|
|
s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
|
|
s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
|
|
s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
|
|
|
|
/* "Mode" group: */
|
|
s->opt[OPT_MODE_GROUP].title = "Scan Mode";
|
|
s->opt[OPT_MODE_GROUP].desc = "";
|
|
s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
|
|
s->opt[OPT_MODE_GROUP].cap = 0;
|
|
s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* scan mode */
|
|
s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
|
|
s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
|
|
s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
|
|
s->opt[OPT_MODE].type = SANE_TYPE_STRING;
|
|
s->opt[OPT_MODE].size = max_string_size (mode_list);
|
|
s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
|
|
s->opt[OPT_MODE].constraint.string_list = mode_list;
|
|
|
|
/* Translate the current PINT mode into a string. */
|
|
switch (s->hw->scanio.scan_image_mode)
|
|
{
|
|
case SIM_BINARY_MONOCHROME:
|
|
s->val[OPT_MODE].s = strdup (mode_list[0]);
|
|
break;
|
|
|
|
case SIM_DITHERED_MONOCHROME:
|
|
s->val[OPT_MODE].s = strdup (mode_list[1]);
|
|
break;
|
|
|
|
case SIM_COLOR:
|
|
s->val[OPT_MODE].s = strdup (mode_list[3]);
|
|
break;
|
|
|
|
case SIM_RED:
|
|
s->val[OPT_MODE].s = strdup (mode_list[4]);
|
|
break;
|
|
|
|
case SIM_GREEN:
|
|
s->val[OPT_MODE].s = strdup (mode_list[5]);
|
|
break;
|
|
|
|
case SIM_BLUE:
|
|
s->val[OPT_MODE].s = strdup (mode_list[6]);
|
|
break;
|
|
|
|
case SIM_GRAYSCALE:
|
|
default:
|
|
s->val[OPT_MODE].s = strdup (mode_list[2]);
|
|
}
|
|
|
|
/* resolution */
|
|
s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
|
|
s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
|
|
s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
|
|
s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
|
|
s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
|
|
s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
s->opt[OPT_RESOLUTION].constraint.range = &s->hw->dpi_range;
|
|
s->val[OPT_RESOLUTION].w =
|
|
(s->hw->scanio.scan_x_resolution > s->hw->scanio.scan_y_resolution) ?
|
|
s->hw->scanio.scan_x_resolution : s->hw->scanio.scan_y_resolution;
|
|
|
|
/* "Geometry" group: */
|
|
|
|
s->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
|
|
s->opt[OPT_GEOMETRY_GROUP].desc = "";
|
|
s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
|
|
s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
|
|
s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* Calculate the x and y millimetre coordinates from the scanio. */
|
|
x0 = SANE_FIX (s->hw->scanio.scan_x_origin / TWELVEHUNDS_PER_MM);
|
|
y0 = SANE_FIX (s->hw->scanio.scan_y_origin / TWELVEHUNDS_PER_MM);
|
|
x1 = SANE_FIX ((s->hw->scanio.scan_x_origin + s->hw->scanio.scan_width)
|
|
/ TWELVEHUNDS_PER_MM);
|
|
y1 = SANE_FIX ((s->hw->scanio.scan_y_origin + s->hw->scanio.scan_height)
|
|
/ TWELVEHUNDS_PER_MM);
|
|
|
|
/* top-left x */
|
|
s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
|
|
s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
|
|
s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
|
|
s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
|
|
s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
|
|
s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
s->opt[OPT_TL_X].constraint.range = &s->hw->x_range;
|
|
s->val[OPT_TL_X].w = x0;
|
|
|
|
/* top-left y */
|
|
s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
|
|
s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
|
|
s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
|
|
s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
|
|
s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
|
|
s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
s->opt[OPT_TL_Y].constraint.range = &s->hw->y_range;
|
|
s->val[OPT_TL_Y].w = y0;
|
|
|
|
/* bottom-right x */
|
|
s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
|
|
s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
|
|
s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
|
|
s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
|
|
s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
|
|
s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
s->opt[OPT_BR_X].constraint.range = &s->hw->x_range;
|
|
s->val[OPT_BR_X].w = x1;
|
|
|
|
/* bottom-right y */
|
|
s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
|
|
s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
|
|
s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
|
|
s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
|
|
s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
|
|
s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
s->opt[OPT_BR_Y].constraint.range = &s->hw->y_range;
|
|
s->val[OPT_BR_Y].w = y1;
|
|
|
|
/* "Enhancement" group: */
|
|
|
|
s->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
|
|
s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
|
|
s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
|
|
s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
|
|
s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* brightness */
|
|
s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
|
|
s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
|
|
s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
|
|
s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
|
|
s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
|
|
s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
s->opt[OPT_BRIGHTNESS].constraint.range = &s7_range;
|
|
s->val[OPT_BRIGHTNESS].w = s->hw->scanio.scan_brightness - 128;
|
|
|
|
/* contrast */
|
|
s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
|
|
s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
|
|
s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
|
|
s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
|
|
s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
|
|
s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
s->opt[OPT_CONTRAST].constraint.range = &s7_range;
|
|
s->val[OPT_CONTRAST].w = s->hw->scanio.scan_contrast - 128;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
static SANE_Status
|
|
do_cancel (PINT_Scanner *s)
|
|
{
|
|
/* FIXME: PINT doesn't have any good way to cancel ScanJets right now. */
|
|
#define gobble_up_buf_len 1024
|
|
char buf[gobble_up_buf_len];
|
|
|
|
/* Send the restart code. */
|
|
buf[0] = ioctl (s->fd, SCIOCRESTART, 0);
|
|
|
|
if (!s->scanning)
|
|
return SANE_STATUS_CANCELLED;
|
|
|
|
s->scanning = SANE_FALSE;
|
|
|
|
/* Read to the end of the file. */
|
|
while (read (s->fd, buf, gobble_up_buf_len) > 0)
|
|
;
|
|
#undef gobble_up_buf_len
|
|
|
|
/* Finally, close the file descriptor. */
|
|
if (s->fd >= 0)
|
|
{
|
|
close (s->fd);
|
|
s->fd = -1;
|
|
}
|
|
return SANE_STATUS_CANCELLED;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_init (SANE_Int *version_code, SANE_Auth_Callback authorize)
|
|
{
|
|
char dev_name[PATH_MAX];
|
|
size_t len;
|
|
FILE *fp;
|
|
|
|
DBG_INIT();
|
|
|
|
if (version_code)
|
|
*version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, 0);
|
|
|
|
fp = sanei_config_open (PINT_CONFIG_FILE);
|
|
if (!fp)
|
|
{
|
|
/* default to /dev/scanner instead of insisting on config file */
|
|
attach ("/dev/scanner", 0);
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
while (fgets (dev_name, sizeof (dev_name), fp))
|
|
{
|
|
if (dev_name[0] == '#') /* ignore line comments */
|
|
continue;
|
|
len = strlen (dev_name);
|
|
if (dev_name[len - 1] == '\n')
|
|
dev_name[--len] = '\0';
|
|
|
|
if (!len)
|
|
continue; /* ignore empty lines */
|
|
|
|
attach (dev_name, 0);
|
|
}
|
|
fclose (fp);
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
void
|
|
sane_exit (void)
|
|
{
|
|
PINT_Device *dev, *next;
|
|
|
|
for (dev = first_dev; dev; dev = next)
|
|
{
|
|
next = dev->next;
|
|
free ((void *) dev->sane.name);
|
|
free (dev);
|
|
}
|
|
}
|
|
|
|
SANE_Status
|
|
sane_get_devices (const SANE_Device ***device_list, SANE_Bool local_only)
|
|
{
|
|
static const SANE_Device **devlist = 0;
|
|
PINT_Device *dev;
|
|
int i;
|
|
|
|
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;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_open (SANE_String_Const devicename, SANE_Handle *handle)
|
|
{
|
|
SANE_Status status;
|
|
PINT_Device *dev;
|
|
PINT_Scanner *s;
|
|
|
|
if (devicename[0])
|
|
{
|
|
for (dev = first_dev; dev; dev = dev->next)
|
|
if (strcmp (dev->sane.name, devicename) == 0)
|
|
break;
|
|
|
|
if (!dev)
|
|
{
|
|
status = attach (devicename, &dev);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
}
|
|
}
|
|
else
|
|
/* empty devicename -> use first device */
|
|
dev = first_dev;
|
|
|
|
if (!dev)
|
|
return SANE_STATUS_INVAL;
|
|
|
|
s = malloc (sizeof (*s));
|
|
if (!s)
|
|
return SANE_STATUS_NO_MEM;
|
|
memset (s, 0, sizeof (*s));
|
|
s->hw = dev;
|
|
s->fd = -1;
|
|
|
|
init_options (s);
|
|
|
|
/* insert newly opened handle into list of open handles: */
|
|
s->next = first_handle;
|
|
first_handle = s;
|
|
|
|
*handle = s;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
void
|
|
sane_close (SANE_Handle handle)
|
|
{
|
|
PINT_Scanner *prev, *s;
|
|
|
|
/* remove handle from list of open handles: */
|
|
prev = 0;
|
|
for (s = first_handle; s; s = s->next)
|
|
{
|
|
if (s == handle)
|
|
break;
|
|
prev = s;
|
|
}
|
|
if (!s)
|
|
{
|
|
DBG(1, "close: invalid handle %p\n", handle);
|
|
return; /* oops, not a handle we know about */
|
|
}
|
|
|
|
if (s->scanning)
|
|
do_cancel (handle);
|
|
|
|
if (prev)
|
|
prev->next = s->next;
|
|
else
|
|
first_handle = s;
|
|
|
|
free (handle);
|
|
}
|
|
|
|
const SANE_Option_Descriptor *
|
|
sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
|
|
{
|
|
PINT_Scanner *s = handle;
|
|
|
|
if ((unsigned) option >= NUM_OPTIONS)
|
|
return 0;
|
|
return s->opt + option;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_control_option (SANE_Handle handle, SANE_Int option,
|
|
SANE_Action action, void *val, SANE_Int *info)
|
|
{
|
|
PINT_Scanner *s = handle;
|
|
SANE_Status status;
|
|
SANE_Word cap;
|
|
|
|
if (info)
|
|
*info = 0;
|
|
|
|
if (s->scanning)
|
|
return SANE_STATUS_DEVICE_BUSY;
|
|
|
|
if (option >= NUM_OPTIONS)
|
|
return SANE_STATUS_INVAL;
|
|
|
|
cap = s->opt[option].cap;
|
|
|
|
if (!SANE_OPTION_IS_ACTIVE (cap))
|
|
return SANE_STATUS_INVAL;
|
|
|
|
if (action == SANE_ACTION_GET_VALUE)
|
|
{
|
|
switch (option)
|
|
{
|
|
/* word options: */
|
|
case OPT_RESOLUTION:
|
|
case OPT_TL_X:
|
|
case OPT_TL_Y:
|
|
case OPT_BR_X:
|
|
case OPT_BR_Y:
|
|
case OPT_NUM_OPTS:
|
|
case OPT_BRIGHTNESS:
|
|
case OPT_CONTRAST:
|
|
*(SANE_Word *) val = s->val[option].w;
|
|
return SANE_STATUS_GOOD;
|
|
|
|
/* string options: */
|
|
case OPT_MODE:
|
|
strcpy (val, s->val[option].s);
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
}
|
|
else if (action == SANE_ACTION_SET_VALUE)
|
|
{
|
|
if (!SANE_OPTION_IS_SETTABLE (cap))
|
|
return SANE_STATUS_INVAL;
|
|
|
|
status = sanei_constrain_value (s->opt + option, val, info);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
|
|
switch (option)
|
|
{
|
|
/* (mostly) side-effect-free word options: */
|
|
case OPT_RESOLUTION:
|
|
case OPT_TL_X:
|
|
case OPT_TL_Y:
|
|
case OPT_BR_X:
|
|
case OPT_BR_Y:
|
|
if (info)
|
|
*info |= SANE_INFO_RELOAD_PARAMS;
|
|
/* fall through */
|
|
case OPT_NUM_OPTS:
|
|
case OPT_BRIGHTNESS:
|
|
case OPT_CONTRAST:
|
|
s->val[option].w = *(SANE_Word *) val;
|
|
return SANE_STATUS_GOOD;
|
|
|
|
case OPT_MODE:
|
|
if (s->val[option].s)
|
|
free (s->val[option].s);
|
|
s->val[option].s = strdup (val);
|
|
if (info)
|
|
*info |= SANE_INFO_RELOAD_PARAMS;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
}
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_get_parameters (SANE_Handle handle, SANE_Parameters *params)
|
|
{
|
|
PINT_Scanner *s = handle;
|
|
struct scan_io scanio;
|
|
|
|
if (!s->scanning)
|
|
{
|
|
u_long x0, y0, width, height;
|
|
const char *mode;
|
|
|
|
/* Grab the scanio for this device. */
|
|
if (s->fd < 0)
|
|
{
|
|
s->fd = open (s->hw->sane.name, O_RDONLY, 0);
|
|
if (s->fd < 0)
|
|
{
|
|
DBG(1, "open of %s failed: %s\n",
|
|
s->hw->sane.name, strerror (errno));
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
}
|
|
|
|
if (ioctl (s->fd, SCIOCGET, &scanio) < 0)
|
|
{
|
|
DBG(1, "getting scanner state failed: %s", strerror (errno));
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
memset (&s->params, 0, sizeof (s->params));
|
|
|
|
/* FIXME: there is some lossage here: the parameters change due to
|
|
roundoff errors between converting to fixed point millimetres
|
|
and back. */
|
|
x0 = SANE_UNFIX (s->val[OPT_TL_X].w * TWELVEHUNDS_PER_MM);
|
|
y0 = SANE_UNFIX (s->val[OPT_TL_Y].w * TWELVEHUNDS_PER_MM);
|
|
width = SANE_UNFIX ((s->val[OPT_BR_X].w - s->val[OPT_TL_X].w)
|
|
* TWELVEHUNDS_PER_MM);
|
|
height = SANE_UNFIX ((s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w)
|
|
* TWELVEHUNDS_PER_MM);
|
|
|
|
/* x and y dpi: */
|
|
scanio.scan_x_resolution = s->val[OPT_RESOLUTION].w;
|
|
scanio.scan_y_resolution = s->val[OPT_RESOLUTION].w;
|
|
|
|
/* set scan extents, in 1/1200'ths of an inch */
|
|
scanio.scan_x_origin = x0;
|
|
scanio.scan_y_origin = y0;
|
|
scanio.scan_width = width;
|
|
scanio.scan_height = height;
|
|
|
|
/* brightness and contrast */
|
|
scanio.scan_brightness = s->val[OPT_BRIGHTNESS].w + 128;
|
|
scanio.scan_contrast = s->val[OPT_CONTRAST].w + 128;
|
|
|
|
/* set the scan image mode */
|
|
mode = s->val[OPT_MODE].s;
|
|
if (!strcmp (mode, "Lineart"))
|
|
{
|
|
s->params.format = SANE_FRAME_GRAY;
|
|
scanio.scan_image_mode = SIM_BINARY_MONOCHROME;
|
|
}
|
|
else if (!strcmp (mode, "Halftone"))
|
|
{
|
|
s->params.format = SANE_FRAME_GRAY;
|
|
scanio.scan_image_mode = SIM_DITHERED_MONOCHROME;
|
|
}
|
|
else if (!strcmp (mode, "Gray"))
|
|
{
|
|
s->params.format = SANE_FRAME_GRAY;
|
|
scanio.scan_image_mode = SIM_GRAYSCALE;
|
|
}
|
|
else if (!strcmp (mode, "Red"))
|
|
{
|
|
s->params.format = SANE_FRAME_RED;
|
|
scanio.scan_image_mode = SIM_RED;
|
|
}
|
|
else if (!strcmp (mode, "Green"))
|
|
{
|
|
s->params.format = SANE_FRAME_GREEN;
|
|
scanio.scan_image_mode = SIM_GREEN;
|
|
}
|
|
else if (!strcmp (mode, "Blue"))
|
|
{
|
|
s->params.format = SANE_FRAME_BLUE;
|
|
scanio.scan_image_mode = SIM_BLUE;
|
|
}
|
|
else
|
|
{
|
|
s->params.format = SANE_FRAME_RGB;
|
|
scanio.scan_image_mode = SIM_COLOR;
|
|
}
|
|
|
|
/* inquire resulting size of image after setting it up */
|
|
if (ioctl (s->fd, SCIOCSET, &scanio) < 0)
|
|
{
|
|
DBG(1, "setting scan parameters failed: %s", strerror (errno));
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
if (ioctl (s->fd, SCIOCGET, &scanio) < 0)
|
|
{
|
|
DBG(1, "getting scan parameters failed: %s", strerror (errno));
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
/* Save all the PINT-computed values. */
|
|
s->params.pixels_per_line = scanio.scan_pixels_per_line;
|
|
s->params.bytes_per_line =
|
|
(scanio.scan_bits_per_pixel * scanio.scan_pixels_per_line + 7) / 8;
|
|
s->params.lines = scanio.scan_lines;
|
|
s->params.depth = (scanio.scan_image_mode == SIM_COLOR) ?
|
|
scanio.scan_bits_per_pixel / 3 : scanio.scan_bits_per_pixel;
|
|
|
|
/* FIXME: this will need to be different for hand scanners. */
|
|
s->params.last_frame = SANE_TRUE;
|
|
}
|
|
if (params)
|
|
*params = s->params;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_start (SANE_Handle handle)
|
|
{
|
|
PINT_Scanner *s = handle;
|
|
SANE_Status status;
|
|
|
|
/* First make sure we have a current parameter set. This call actually
|
|
uses the PINT driver to do the calculations, so we trust its results. */
|
|
status = sane_get_parameters (s, 0);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
|
|
DBG(1, "%d pixels per line, %d bytes, %d lines high, dpi=%d\n",
|
|
s->params.pixels_per_line, s->params.bytes_per_line, s->params.lines,
|
|
s->val[OPT_RESOLUTION].w);
|
|
|
|
/* The scan is triggered in sane_read. */
|
|
s->scanning = SANE_TRUE;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_read (SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len, SANE_Int *len)
|
|
{
|
|
PINT_Scanner *s = handle;
|
|
ssize_t nread;
|
|
|
|
*len = 0;
|
|
|
|
if (!s->scanning)
|
|
return do_cancel (s);
|
|
|
|
/* Verrry simple. Just suck up all the data PINT passes to us. */
|
|
nread = read (s->fd, buf, max_len);
|
|
if (nread <= 0)
|
|
{
|
|
do_cancel (s);
|
|
return (nread == 0) ? SANE_STATUS_EOF : SANE_STATUS_IO_ERROR;
|
|
}
|
|
|
|
*len = nread;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
void
|
|
sane_cancel (SANE_Handle handle)
|
|
{
|
|
PINT_Scanner *s = handle;
|
|
do_cancel (s);
|
|
}
|
|
|
|
SANE_Status
|
|
sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
|
|
{
|
|
return SANE_STATUS_UNSUPPORTED;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_get_select_fd (SANE_Handle handle, SANE_Int *fd)
|
|
{
|
|
return SANE_STATUS_UNSUPPORTED;
|
|
}
|