diff options
Diffstat (limited to 'backend/pint.c')
| -rw-r--r-- | backend/pint.c | 987 |
1 files changed, 987 insertions, 0 deletions
diff --git a/backend/pint.c b/backend/pint.c new file mode 100644 index 0000000..f0cc697 --- /dev/null +++ b/backend/pint.c @@ -0,0 +1,987 @@ +/* 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 "../include/sane/config.h" + +#include <limits.h> +#include <stdlib.h> +#include <string.h> +extern int errno; + +#include "../include/sane/sane.h" +#include "../include/sane/saneopts.h" + +#include <unistd.h> +#include <fcntl.h> + +#include "../include/sane/sanei_backend.h" + +#ifndef PATH_MAX +# define PATH_MAX 1024 +#endif + +#include "../include/sane/sanei_config.h" +#define PINT_CONFIG_FILE "pint.conf" + +#include "pint.h" + +#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, SANE_VALUE_SCAN_MODE_LINEART); + CHECK_MODE(SIM_DITHERED_MONOCHROME, SANE_VALUE_SCAN_MODE_HALFTONE); + CHECK_MODE(SIM_GRAYSCALE, SANE_VALUE_SCAN_MODE_GRAY); + CHECK_MODE(SIM_COLOR, SANE_VALUE_SCAN_MODE_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].type = SANE_TYPE_INT; + s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + s->val[OPT_NUM_OPTS].w = NUM_OPTIONS; + + /* "Mode" group: */ + s->opt[OPT_MODE_GROUP].title = "Scan Mode"; + s->opt[OPT_MODE_GROUP].desc = ""; + s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + s->opt[OPT_MODE_GROUP].cap = 0; + s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* scan mode */ + 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 (SANE_CURRENT_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 (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 */ + + 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->next; + + 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, SANE_VALUE_SCAN_MODE_LINEART)) + { + s->params.format = SANE_FRAME_GRAY; + scanio.scan_image_mode = SIM_BINARY_MONOCHROME; + } + else if (!strcmp (mode, SANE_VALUE_SCAN_MODE_HALFTONE)) + { + s->params.format = SANE_FRAME_GRAY; + scanio.scan_image_mode = SIM_DITHERED_MONOCHROME; + } + else if (!strcmp (mode, SANE_VALUE_SCAN_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; +} |