summaryrefslogtreecommitdiff
path: root/backend/mustek_pp.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/mustek_pp.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/mustek_pp.c')
-rw-r--r--backend/mustek_pp.c1958
1 files changed, 1958 insertions, 0 deletions
diff --git a/backend/mustek_pp.c b/backend/mustek_pp.c
new file mode 100644
index 0000000..cd86bb9
--- /dev/null
+++ b/backend/mustek_pp.c
@@ -0,0 +1,1958 @@
+/* sane - Scanner Access Now Easy.
+ Copyright (C) 2000-2003 Jochen Eisinger <jochen.eisinger@gmx.net>
+ This file is part of the SANE package.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA.
+
+ As a special exception, the authors of SANE give permission for
+ additional uses of the libraries contained in this release of SANE.
+
+ The exception is that, if you link a SANE library with other files
+ to produce an executable, this does not by itself cause the
+ resulting executable to be covered by the GNU General Public
+ License. Your use of that executable is in no way restricted on
+ account of linking the SANE library code into it.
+
+ This exception does not, however, invalidate any other reasons why
+ the executable file might be covered by the GNU General Public
+ License.
+
+ If you submit changes to SANE to the maintainers to be included in
+ a subsequent release, you agree by submitting the changes that
+ those changes may be distributed with this exception intact.
+
+ If you write modifications of your own for SANE, it is your choice
+ whether to permit this exception to apply to your modifications.
+ If you do not wish that, delete this exception notice.
+
+ This file implements a SANE backend for Mustek PP flatbed scanners. */
+
+#include "../include/sane/config.h"
+
+#if defined(HAVE_STDLIB_H)
+# include <stdlib.h>
+#endif
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#if defined(HAVE_STRING_H)
+# include <string.h>
+#elif defined(HAVE_STRINGS_H)
+# include <strings.h>
+#endif
+#if defined(HAVE_UNISTD_H)
+# include <unistd.h>
+#endif
+#include <math.h>
+#include <fcntl.h>
+#include <time.h>
+#if defined(HAVE_SYS_TIME_H)
+# include <sys/time.h>
+#endif
+#if defined(HAVE_SYS_TYPES_H)
+# include <sys/types.h>
+#endif
+#include <sys/wait.h>
+
+#define BACKEND_NAME mustek_pp
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/saneopts.h"
+
+#include "../include/sane/sanei_backend.h"
+
+#include "../include/sane/sanei_config.h"
+#define MUSTEK_PP_CONFIG_FILE "mustek_pp.conf"
+
+#include "../include/sane/sanei_pa4s2.h"
+
+#include "mustek_pp.h"
+#include "mustek_pp_drivers.h"
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+
+/* converts millimeter to pixels at a given resolution */
+#define MM_TO_PIXEL(mm, dpi) (((float )mm * 5.0 / 127.0) * (float)dpi)
+ /* and back */
+#define PIXEL_TO_MM(pixel, dpi) (((float )pixel / (float )dpi) * 127.0 / 5.0)
+
+/* if you change the source, please set MUSTEK_PP_STATE to "devel". Do *not*
+ * change the MUSTEK_PP_BUILD. */
+#define MUSTEK_PP_BUILD 13
+#define MUSTEK_PP_STATE "beta"
+
+
+/* auth callback... since basic user authentication is done by saned, this
+ * callback mechanism isn't used */
+SANE_Auth_Callback sane_auth;
+
+/* count of present devices */
+static int num_devices = 0;
+
+/* list of present devices */
+static Mustek_pp_Device *devlist = NULL;
+
+/* temporary array of configuration options used during device attachment */
+static Mustek_pp_config_option *cfgoptions = NULL;
+static int numcfgoptions = 0;
+
+/* list of pointers to the SANE_Device structures of the Mustek_pp_Devices */
+static SANE_Device **devarray = NULL;
+
+/* currently active Handles */
+static Mustek_pp_Handle *first_hndl = NULL;
+
+static SANE_String_Const mustek_pp_modes[4] = {SANE_VALUE_SCAN_MODE_LINEART, SANE_VALUE_SCAN_MODE_GRAY, SANE_VALUE_SCAN_MODE_COLOR, NULL};
+static SANE_Word mustek_pp_modes_size = 10;
+
+static SANE_String_Const mustek_pp_speeds[6] = {"Slowest", "Slower", "Normal", "Faster", "Fastest", NULL};
+static SANE_Word mustek_pp_speeds_size = 8;
+static SANE_Word mustek_pp_depths[5] = {4, 8, 10, 12, 16};
+
+/* prototypes */
+static void free_cfg_options(int *numoptions, Mustek_pp_config_option** options);
+static SANE_Status do_eof(Mustek_pp_Handle *hndl);
+static SANE_Status do_stop(Mustek_pp_Handle *hndl);
+static int reader_process (Mustek_pp_Handle * hndl, int pipe);
+static SANE_Status sane_attach(SANE_String_Const port, SANE_String_Const name,
+ SANE_Int driver, SANE_Int info);
+static void init_options(Mustek_pp_Handle *hndl);
+static void attach_device(SANE_String *driver, SANE_String *name,
+ SANE_String *port, SANE_String *option_ta);
+
+
+/*
+ * Auxiliary function for freeing arrays of configuration options,
+ */
+static void
+free_cfg_options(int *numoptions, Mustek_pp_config_option** options)
+{
+ int i;
+ if (*numoptions)
+ {
+ for (i=0; i<*numoptions; ++i)
+ {
+ free ((*options)[i].name);
+ free ((*options)[i].value);
+ }
+ free (*options);
+ }
+ *options = NULL;
+ *numoptions = 0;
+}
+
+/* do_eof:
+ * closes the pipeline
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * closes the pipe (read-only end)
+ */
+static SANE_Status
+do_eof (Mustek_pp_Handle *hndl)
+{
+ if (hndl->pipe >= 0) {
+
+ close (hndl->pipe);
+ hndl->pipe = -1;
+ }
+
+ return SANE_STATUS_EOF;
+}
+
+/* do_stop:
+ * ends the reader_process and stops the scanner
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * kills the reader process with a SIGTERM and cancels the scanner
+ */
+static SANE_Status
+do_stop(Mustek_pp_Handle *hndl)
+{
+
+ int exit_status;
+
+ do_eof (hndl);
+
+ if (hndl->reader > 0) {
+
+ DBG (3, "do_stop: terminating reader process\n");
+ kill (hndl->reader, SIGTERM);
+
+ while (wait (&exit_status) != hndl->reader);
+
+ DBG ((exit_status == SANE_STATUS_GOOD ? 3 : 1),
+ "do_stop: reader_process terminated with status ``%s''\n",
+ sane_strstatus(exit_status));
+ hndl->reader = 0;
+ hndl->dev->func->stop (hndl);
+
+ return exit_status;
+
+ }
+
+ hndl->dev->func->stop (hndl);
+
+ return SANE_STATUS_GOOD;
+}
+
+/* sigterm_handler:
+ * cancel scanner when receiving a SIGTERM
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * just exit... reader_process takes care that nothing bad will happen
+ *
+ * EDG - Jan 14, 2004:
+ * Make sure that the parport is released again by the child process
+ * under all circumstances, because otherwise the parent process may no
+ * longer be able to claim it (they share the same file descriptor, and
+ * the kernel doesn't release the child's claim because the file
+ * descriptor isn't cleaned up). If that would happen, the lamp may stay
+ * on and may not return to its home position, unless the scanner
+ * frontend is restarted.
+ * (This happens only when sanei_pa4s2 uses libieee1284 AND
+ * libieee1284 goes via /dev/parportX).
+ *
+ */
+static int fd_to_release = 0;
+/*ARGSUSED*/
+static RETSIGTYPE
+sigterm_handler (int signal __UNUSED__)
+{
+ sanei_pa4s2_enable(fd_to_release, SANE_FALSE);
+ _exit (SANE_STATUS_GOOD);
+}
+
+/* reader_process:
+ * receives data from the scanner and stuff it into the pipeline
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * The signal handle for SIGTERM is initialized.
+ *
+ */
+static int
+reader_process (Mustek_pp_Handle * hndl, int pipe)
+{
+ sigset_t sigterm_set;
+ struct SIGACTION act;
+ FILE *fp;
+ SANE_Status status;
+ int line;
+ int size, elem;
+
+ SANE_Byte *buffer;
+
+ sigemptyset (&sigterm_set);
+ sigaddset (&sigterm_set, SIGTERM);
+
+ if (!(buffer = malloc (hndl->params.bytes_per_line)))
+ return SANE_STATUS_NO_MEM;
+
+ if (!(fp = fdopen(pipe, "w")))
+ return SANE_STATUS_IO_ERROR;
+
+ fd_to_release = hndl->fd;
+ memset (&act, 0, sizeof(act));
+ act.sa_handler = sigterm_handler;
+ sigaction (SIGTERM, &act, NULL);
+
+ if ((status = hndl->dev->func->start (hndl)) != SANE_STATUS_GOOD)
+ return status;
+
+ size = hndl->params.bytes_per_line;
+ elem = 1;
+
+ for (line=0; line<hndl->params.lines ; line++) {
+
+ sigprocmask (SIG_BLOCK, &sigterm_set, NULL);
+
+ hndl->dev->func->read (hndl, buffer);
+
+ if (getppid() == 1) {
+ /* The parent process has died. Stop the scan (to make
+ sure that the lamp is off and returns home). This is
+ a safety measure to make sure that we don't break
+ the scanner in case the frontend crashes. */
+ DBG (1, "reader_process: front-end died; aborting.\n");
+ hndl->dev->func->stop (hndl);
+ return SANE_STATUS_CANCELLED;
+ }
+
+ sigprocmask (SIG_UNBLOCK, &sigterm_set, NULL);
+
+ fwrite (buffer, size, elem, fp);
+ }
+
+ fclose (fp);
+
+ free (buffer);
+
+ return SANE_STATUS_GOOD;
+}
+
+
+
+/* sane_attach:
+ * adds a new entry to the Mustek_pp_Device *devlist list
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * After memory for a new device entry is allocated, the
+ * parameters for the device are determined by a call to
+ * capabilities().
+ *
+ * Afterwards the new device entry is inserted into the
+ * devlist
+ *
+ */
+static SANE_Status
+sane_attach (SANE_String_Const port, SANE_String_Const name, SANE_Int driver, SANE_Int info)
+{
+ Mustek_pp_Device *dev;
+
+ DBG (3, "sane_attach: attaching device ``%s'' to port %s (driver %s v%s by %s)\n",
+ name, port, Mustek_pp_Drivers[driver].driver,
+ Mustek_pp_Drivers[driver].version,
+ Mustek_pp_Drivers[driver].author);
+
+ if ((dev = malloc (sizeof (Mustek_pp_Device))) == NULL) {
+
+ DBG (1, "sane_attach: not enough free memory\n");
+ return SANE_STATUS_NO_MEM;
+
+ }
+
+ memset (dev, 0, sizeof (Mustek_pp_Device));
+
+ memset (&dev->sane, 0, sizeof (SANE_Device));
+
+ dev->func = &Mustek_pp_Drivers[driver];
+
+ dev->sane.name = dev->name = strdup (name);
+ dev->port = strdup (port);
+ dev->info = info; /* Modified by EDG */
+
+ /* Transfer the options parsed from the configuration file */
+ dev->numcfgoptions = numcfgoptions;
+ dev->cfgoptions = cfgoptions;
+ numcfgoptions = 0;
+ cfgoptions = NULL;
+
+ dev->func->capabilities (info, &dev->model, &dev->vendor, &dev->type,
+ &dev->maxres, &dev->minres, &dev->maxhsize, &dev->maxvsize,
+ &dev->caps);
+
+ dev->sane.model = dev->model;
+ dev->sane.vendor = dev->vendor;
+ dev->sane.type = dev->type;
+
+ dev->next = devlist;
+ devlist = dev;
+
+ num_devices++;
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* init_options:
+ * Sets up the option descriptors for a device
+ *
+ * ChangeLog:
+ *
+ * Description:
+ */
+static void
+init_options(Mustek_pp_Handle *hndl)
+{
+ int i;
+
+ memset (hndl->opt, 0, sizeof (hndl->opt));
+ memset (hndl->val, 0, sizeof (hndl->val));
+
+ for (i = 0; i < NUM_OPTIONS; ++i)
+ {
+ hndl->opt[i].size = sizeof (SANE_Word);
+ hndl->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ }
+
+ hndl->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
+ hndl->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+ hndl->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+ hndl->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+ hndl->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+ hndl->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+ /* "Mode" group: */
+
+ hndl->opt[OPT_MODE_GROUP].title = "Scan Mode";
+ hndl->opt[OPT_MODE_GROUP].desc = "";
+ hndl->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
+ hndl->opt[OPT_MODE_GROUP].cap = 0;
+ hndl->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+ hndl->opt[OPT_MODE_GROUP].size = 0;
+
+ /* scan mode */
+ hndl->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
+ hndl->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
+ hndl->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
+ hndl->opt[OPT_MODE].type = SANE_TYPE_STRING;
+ hndl->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ hndl->opt[OPT_MODE].size = mustek_pp_modes_size;
+ hndl->opt[OPT_MODE].constraint.string_list = mustek_pp_modes;
+ hndl->val[OPT_MODE].s = strdup (mustek_pp_modes[2]);
+
+ /* resolution */
+ hndl->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+ hndl->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+ hndl->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+ hndl->opt[OPT_RESOLUTION].type = SANE_TYPE_FIXED;
+ hndl->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
+ hndl->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_RESOLUTION].constraint.range = &hndl->dpi_range;
+ hndl->val[OPT_RESOLUTION].w = SANE_FIX (hndl->dev->minres);
+ hndl->dpi_range.min = SANE_FIX (hndl->dev->minres);
+ hndl->dpi_range.max = SANE_FIX (hndl->dev->maxres);
+ hndl->dpi_range.quant = SANE_FIX (1);
+
+ /* speed */
+ hndl->opt[OPT_SPEED].name = SANE_NAME_SCAN_SPEED;
+ hndl->opt[OPT_SPEED].title = SANE_TITLE_SCAN_SPEED;
+ hndl->opt[OPT_SPEED].desc = SANE_DESC_SCAN_SPEED;
+ hndl->opt[OPT_SPEED].type = SANE_TYPE_STRING;
+ hndl->opt[OPT_SPEED].size = mustek_pp_speeds_size;
+ hndl->opt[OPT_SPEED].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ hndl->opt[OPT_SPEED].constraint.string_list = mustek_pp_speeds;
+ hndl->val[OPT_SPEED].s = strdup (mustek_pp_speeds[2]);
+
+ if (! (hndl->dev->caps & CAP_SPEED_SELECT))
+ hndl->opt[OPT_SPEED].cap |= SANE_CAP_INACTIVE;
+
+ /* preview */
+ hndl->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
+ hndl->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+ hndl->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
+ hndl->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+ hndl->val[OPT_PREVIEW].w = SANE_FALSE;
+
+ /* gray preview */
+ hndl->opt[OPT_GRAY_PREVIEW].name = SANE_NAME_GRAY_PREVIEW;
+ hndl->opt[OPT_GRAY_PREVIEW].title = SANE_TITLE_GRAY_PREVIEW;
+ hndl->opt[OPT_GRAY_PREVIEW].desc = SANE_DESC_GRAY_PREVIEW;
+ hndl->opt[OPT_GRAY_PREVIEW].type = SANE_TYPE_BOOL;
+ hndl->val[OPT_GRAY_PREVIEW].w = SANE_FALSE;
+
+ /* color dept */
+ hndl->opt[OPT_DEPTH].name = SANE_NAME_BIT_DEPTH;
+ hndl->opt[OPT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
+ hndl->opt[OPT_DEPTH].desc =
+ "Number of bits per sample for color scans, typical values are 8 for truecolor (24bpp)"
+ "up to 16 for far-to-many-color (48bpp).";
+ hndl->opt[OPT_DEPTH].type = SANE_TYPE_INT;
+ hndl->opt[OPT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+ hndl->opt[OPT_DEPTH].constraint.word_list = mustek_pp_depths;
+ hndl->opt[OPT_DEPTH].unit = SANE_UNIT_BIT;
+ hndl->opt[OPT_DEPTH].size = sizeof(SANE_Word);
+ hndl->val[OPT_DEPTH].w = 8;
+
+ if ( !(hndl->dev->caps & CAP_DEPTH))
+ hndl->opt[OPT_DEPTH].cap |= SANE_CAP_INACTIVE;
+
+
+ /* "Geometry" group: */
+
+ hndl->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
+ hndl->opt[OPT_GEOMETRY_GROUP].desc = "";
+ hndl->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+ hndl->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
+ hndl->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+ hndl->opt[OPT_GEOMETRY_GROUP].size = 0;
+
+ /* top-left x */
+ hndl->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+ hndl->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+ hndl->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+ hndl->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+ hndl->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+ hndl->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_TL_X].constraint.range = &hndl->x_range;
+ hndl->x_range.min = SANE_FIX (0);
+ hndl->x_range.max = SANE_FIX (PIXEL_TO_MM(hndl->dev->maxhsize,hndl->dev->maxres));
+ hndl->x_range.quant = 0;
+ hndl->val[OPT_TL_X].w = hndl->x_range.min;
+
+ /* top-left y */
+ hndl->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+ hndl->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+ hndl->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+ hndl->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+ hndl->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+ hndl->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_TL_Y].constraint.range = &hndl->y_range;
+ hndl->y_range.min = SANE_FIX(0);
+ hndl->y_range.max = SANE_FIX(PIXEL_TO_MM(hndl->dev->maxvsize,hndl->dev->maxres));
+ hndl->y_range.quant = 0;
+ hndl->val[OPT_TL_Y].w = hndl->y_range.min;
+
+ /* bottom-right x */
+ hndl->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+ hndl->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+ hndl->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+ hndl->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+ hndl->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+ hndl->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_BR_X].constraint.range = &hndl->x_range;
+ hndl->val[OPT_BR_X].w = hndl->x_range.max;
+
+ /* bottom-right y */
+ hndl->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+ hndl->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+ hndl->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+ hndl->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+ hndl->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+ hndl->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_BR_Y].constraint.range = &hndl->y_range;
+ hndl->val[OPT_BR_Y].w = hndl->y_range.max;
+
+ /* "Enhancement" group: */
+
+ hndl->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
+ hndl->opt[OPT_ENHANCEMENT_GROUP].desc = "";
+ hndl->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
+ hndl->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
+ hndl->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+ hndl->opt[OPT_ENHANCEMENT_GROUP].size = 0;
+
+
+ /* custom-gamma table */
+ hndl->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
+ hndl->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
+ hndl->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
+ hndl->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
+ hndl->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
+
+ if ( !(hndl->dev->caps & CAP_GAMMA_CORRECT))
+ hndl->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
+
+ /* grayscale gamma vector */
+ hndl->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
+ hndl->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
+ hndl->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
+ hndl->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
+ hndl->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
+ hndl->opt[OPT_GAMMA_VECTOR].size = 256 * sizeof (SANE_Word);
+ hndl->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_GAMMA_VECTOR].constraint.range = &hndl->gamma_range;
+ hndl->val[OPT_GAMMA_VECTOR].wa = &hndl->gamma_table[0][0];
+
+ /* red gamma vector */
+ hndl->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
+ hndl->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
+ hndl->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
+ hndl->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
+ hndl->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
+ hndl->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof (SANE_Word);
+ hndl->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_GAMMA_VECTOR_R].constraint.range = &hndl->gamma_range;
+ hndl->val[OPT_GAMMA_VECTOR_R].wa = &hndl->gamma_table[1][0];
+
+ /* green gamma vector */
+ hndl->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
+ hndl->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
+ hndl->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
+ hndl->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
+ hndl->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
+ hndl->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof (SANE_Word);
+ hndl->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_GAMMA_VECTOR_G].constraint.range = &hndl->gamma_range;
+ hndl->val[OPT_GAMMA_VECTOR_G].wa = &hndl->gamma_table[2][0];
+
+ /* blue gamma vector */
+ hndl->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
+ hndl->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
+ hndl->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
+ hndl->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
+ hndl->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
+ hndl->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof (SANE_Word);
+ hndl->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
+ hndl->opt[OPT_GAMMA_VECTOR_B].constraint.range = &hndl->gamma_range;
+ hndl->val[OPT_GAMMA_VECTOR_B].wa = &hndl->gamma_table[3][0];
+
+ hndl->gamma_range.min = 0;
+ hndl->gamma_range.max = 255;
+ hndl->gamma_range.quant = 1;
+
+ hndl->opt[OPT_INVERT].name = SANE_NAME_NEGATIVE;
+ hndl->opt[OPT_INVERT].title = SANE_TITLE_NEGATIVE;
+ hndl->opt[OPT_INVERT].desc = SANE_DESC_NEGATIVE;
+ hndl->opt[OPT_INVERT].type = SANE_TYPE_BOOL;
+ hndl->val[OPT_INVERT].w = SANE_FALSE;
+
+ if (! (hndl->dev->caps & CAP_INVERT))
+ hndl->opt[OPT_INVERT].cap |= SANE_CAP_INACTIVE;
+
+
+}
+
+/* attach_device:
+ * Attempts to attach a device to the list after parsing of a section
+ * of the configuration file.
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * After parsing a scanner section of the config file, this function
+ * is called to look for a driver with a matching name. When found,
+ * this driver is called to initialize the device.
+ */
+static void
+attach_device(SANE_String *driver, SANE_String *name,
+ SANE_String *port, SANE_String *option_ta)
+{
+ int found = 0, driver_no, port_no;
+ const char **ports;
+
+ if (!strcmp (*port, "*"))
+ {
+ ports = sanei_pa4s2_devices();
+ DBG (3, "sanei_init: auto probing port\n");
+ }
+ else
+ {
+ ports = malloc (sizeof(char *) * 2);
+ ports[0] = *port;
+ ports[1] = NULL;
+ }
+
+ for (port_no=0; ports[port_no] != NULL; port_no++)
+ {
+ for (driver_no=0 ; driver_no<MUSTEK_PP_NUM_DRIVERS ; driver_no++)
+ {
+ if (strcasecmp (Mustek_pp_Drivers[driver_no].driver, *driver) == 0)
+ {
+ Mustek_pp_Drivers[driver_no].init (
+ (*option_ta == 0 ? CAP_NOTHING : CAP_TA),
+ ports[port_no], *name, sane_attach);
+ found = 1;
+ break;
+ }
+ }
+ }
+
+ free (ports);
+
+ if (found == 0)
+ {
+ DBG (1, "sane_init: no scanner detected\n");
+ DBG (3, "sane_init: either the driver name ``%s'' is invalid, or no scanner was detected\n", *driver);
+ }
+
+ free (*name);
+ free (*port);
+ free (*driver);
+ if (*option_ta)
+ free (*option_ta);
+ *name = *port = *driver = *option_ta = 0;
+
+ /* In case of a successful initialization, the configuration options
+ should have been transfered to the device, but this function can
+ deal with that. */
+ free_cfg_options(&numcfgoptions, &cfgoptions);
+}
+
+/* sane_init:
+ * Reads configuration file and registers hardware driver
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * in *version_code the SANE version this backend was compiled with and the
+ * version of the backend is returned. The value of authorize is stored in
+ * the global variable sane_auth.
+ *
+ * Next the configuration file is read. If it isn't present, all drivers
+ * are auto-probed with default values (port 0x378, with and without TA).
+ *
+ * The configuration file is expected to contain lines of the form
+ *
+ * scanner <name> <port> <driver> [<option_ta>]
+ *
+ * where <name> is a arbitrary name to identify this entry
+ * <port> is the port where the scanner is attached to
+ * <driver> is the name of the driver to use
+ *
+ * if the optional argument "option_ta" is present the driver uses special
+ * parameters fitting for a trasparency adapter.
+ */
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+ FILE *fp;
+ char config_line[1024];
+ const char *config_line_ptr;
+ int line=0, driver_no;
+ char *driver = 0, *port = 0, *name = 0, *option_ta = 0;
+
+ DBG_INIT ();
+ DBG (3, "sane-mustek_pp, version 0.%d-%s. build for SANE %s\n",
+ MUSTEK_PP_BUILD, MUSTEK_PP_STATE, VERSION);
+ DBG (3, "backend by Jochen Eisinger <jochen.eisinger@gmx.net>\n");
+
+ if (version_code != NULL)
+ *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, MUSTEK_PP_BUILD);
+
+ sane_auth = authorize;
+
+
+ fp = sanei_config_open (MUSTEK_PP_CONFIG_FILE);
+
+ if (fp == NULL)
+ {
+ char driver_name[64];
+ const char **devices = sanei_pa4s2_devices();
+ int device_no;
+
+ DBG (2, "sane_init: could not open configuration file\n");
+
+ for (device_no = 0; devices[device_no] != NULL; device_no++)
+ {
+ DBG (3, "sane_init: trying ``%s''\n", devices[device_no]);
+ for (driver_no=0 ; driver_no<MUSTEK_PP_NUM_DRIVERS ; driver_no++)
+ {
+ Mustek_pp_Drivers[driver_no].init(CAP_NOTHING, devices[device_no],
+ Mustek_pp_Drivers[driver_no].driver, sane_attach);
+
+ snprintf (driver_name, 64, "%s-ta",
+ Mustek_pp_Drivers[driver_no].driver);
+
+ Mustek_pp_Drivers[driver_no].init(CAP_TA, devices[device_no],
+ driver_name, sane_attach);
+ }
+ }
+
+ free (devices);
+ return SANE_STATUS_GOOD;
+ }
+
+ while (sanei_config_read (config_line, 1023, fp))
+ {
+ line++;
+ if ((!*config_line) || (*config_line == '#'))
+ continue;
+
+ config_line_ptr = config_line;
+
+ if (strncmp(config_line_ptr, "scanner", 7) == 0)
+ {
+ config_line_ptr += 7;
+
+ if (name)
+ {
+ /* Parsing of previous scanner + options is finished. Attach
+ the device before we parse the next section. */
+ attach_device(&driver, &name, &port, &option_ta);
+ }
+
+ config_line_ptr = sanei_config_skip_whitespace (config_line_ptr);
+ if (!*config_line_ptr)
+ {
+ DBG (1, "sane_init: parse error in line %d after ``scanner''\n",
+ line);
+ continue;
+ }
+
+ config_line_ptr = sanei_config_get_string (config_line_ptr, &name);
+ if ((name == NULL) || (!*name))
+ {
+ DBG (1, "sane_init: parse error in line %d after ``scanner''\n",
+ line);
+ if (name != NULL)
+ free (name);
+ name = 0;
+ continue;
+ }
+
+ config_line_ptr = sanei_config_skip_whitespace (config_line_ptr);
+ if (!*config_line_ptr)
+ {
+ DBG (1, "sane_init: parse error in line %d after "
+ "``scanner %s''\n", line, name);
+ free (name);
+ name = 0;
+ continue;
+ }
+
+ config_line_ptr = sanei_config_get_string (config_line_ptr, &port);
+ if ((port == NULL) || (!*port))
+ {
+ DBG (1, "sane_init: parse error in line %d after "
+ "``scanner %s''\n", line, name);
+ free (name);
+ name = 0;
+ if (port != NULL)
+ free (port);
+ port = 0;
+ continue;
+ }
+
+ config_line_ptr = sanei_config_skip_whitespace (config_line_ptr);
+ if (!*config_line_ptr)
+ {
+ DBG (1, "sane_init: parse error in line %d after "
+ "``scanner %s %s''\n", line, name, port);
+ free (name);
+ free (port);
+ name = 0;
+ port = 0;
+ continue;
+ }
+
+ config_line_ptr = sanei_config_get_string (config_line_ptr, &driver);
+ if ((driver == NULL) || (!*driver))
+ {
+ DBG (1, "sane_init: parse error in line %d after "
+ "``scanner %s %s''\n", line, name, port);
+ free (name);
+ name = 0;
+ free (port);
+ port = 0;
+ if (driver != NULL)
+ free (driver);
+ driver = 0;
+ continue;
+ }
+
+ config_line_ptr = sanei_config_skip_whitespace (config_line_ptr);
+
+ if (*config_line_ptr)
+ {
+ config_line_ptr = sanei_config_get_string (config_line_ptr,
+ &option_ta);
+
+ if ((option_ta == NULL) || (!*option_ta) ||
+ (strcasecmp (option_ta, "use_ta") != 0))
+ {
+ DBG (1, "sane_init: parse error in line %d after "
+ "``scanner %s %s %s''\n", line, name, port, driver);
+ free (name);
+ free (port);
+ free (driver);
+ if (option_ta)
+ free (option_ta);
+ name = port = driver = option_ta = 0;
+ continue;
+ }
+ }
+
+ if (*config_line_ptr)
+ {
+ DBG (1, "sane_init: parse error in line %d after "
+ "``scanner %s %s %s %s\n", line, name, port, driver,
+ (option_ta == 0 ? "" : option_ta));
+ free (name);
+ free (port);
+ free (driver);
+ if (option_ta)
+ free (option_ta);
+ name = port = driver = option_ta = 0;
+ continue;
+ }
+ }
+ else if (strncmp(config_line_ptr, "option", 6) == 0)
+ {
+ /* Format for options: option <name> [<value>]
+ Note that the value is optional. */
+ char *optname, *optval = 0;
+ Mustek_pp_config_option *tmpoptions;
+
+ config_line_ptr += 6;
+ config_line_ptr = sanei_config_skip_whitespace (config_line_ptr);
+ if (!*config_line_ptr)
+ {
+ DBG (1, "sane_init: parse error in line %d after ``option''\n",
+ line);
+ continue;
+ }
+
+ config_line_ptr = sanei_config_get_string (config_line_ptr, &optname);
+ if ((optname == NULL) || (!*optname))
+ {
+ DBG (1, "sane_init: parse error in line %d after ``option''\n",
+ line);
+ if (optname != NULL)
+ free (optname);
+ continue;
+ }
+
+ config_line_ptr = sanei_config_skip_whitespace (config_line_ptr);
+ if (*config_line_ptr)
+ {
+ /* The option has a value.
+ No need to check the value; that's up to the backend */
+ config_line_ptr = sanei_config_get_string (config_line_ptr,
+ &optval);
+
+ config_line_ptr = sanei_config_skip_whitespace (config_line_ptr);
+ }
+
+ if (*config_line_ptr)
+ {
+ DBG (1, "sane_init: parse error in line %d after "
+ "``option %s %s''\n", line, optname,
+ (optval == 0 ? "" : optval));
+ free (optname);
+ if (optval)
+ free (optval);
+ continue;
+ }
+
+ if (!strcmp (optname, "no_epp"))
+ {
+ u_int pa4s2_options;
+ if (name)
+ DBG (2, "sane_init: global option found in local scope, "
+ "executing anyway\n");
+ free (optname);
+ if (optval)
+ {
+ DBG (1, "sane_init: unexpected value for option no_epp\n");
+ free (optval);
+ continue;
+ }
+ DBG (3, "sane_init: disabling mode EPP\n");
+ sanei_pa4s2_options (&pa4s2_options, SANE_FALSE);
+ pa4s2_options |= SANEI_PA4S2_OPT_NO_EPP;
+ sanei_pa4s2_options (&pa4s2_options, SANE_TRUE);
+ continue;
+ }
+ else if (!name)
+ {
+ DBG (1, "sane_init: parse error in line %d: unexpected "
+ " ``option''\n", line);
+ free (optname);
+ if (optval)
+ free (optval);
+ continue;
+ }
+
+
+ /* Extend the (global) array of options */
+ tmpoptions = realloc(cfgoptions,
+ (numcfgoptions+1)*sizeof(cfgoptions[0]));
+ if (!tmpoptions)
+ {
+ DBG (1, "sane_init: not enough memory for device options\n");
+ free_cfg_options(&numcfgoptions, &cfgoptions);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ cfgoptions = tmpoptions;
+ cfgoptions[numcfgoptions].name = optname;
+ cfgoptions[numcfgoptions].value = optval;
+ ++numcfgoptions;
+ }
+ else
+ {
+ DBG (1, "sane_init: parse error at beginning of line %d\n", line);
+ continue;
+ }
+
+ }
+
+ /* If we hit the end of the file, we still may have to process the
+ last driver */
+ if (name)
+ attach_device(&driver, &name, &port, &option_ta);
+
+ fclose(fp);
+ return SANE_STATUS_GOOD;
+
+}
+
+/* sane_exit:
+ * Unloads all drivers and frees allocated memory
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * All open devices are closed first. Then all registered devices
+ * are removed.
+ *
+ */
+
+void
+sane_exit (void)
+{
+ Mustek_pp_Handle *hndl;
+ Mustek_pp_Device *dev;
+
+ if (first_hndl)
+ DBG (3, "sane_exit: closing open devices\n");
+
+ while (first_hndl)
+ {
+ hndl = first_hndl;
+ sane_close (hndl);
+ }
+
+ dev = devlist;
+ num_devices = 0;
+ devlist = NULL;
+
+ while (dev) {
+
+ free (dev->port);
+ free (dev->name);
+ free (dev->vendor);
+ free (dev->model);
+ free (dev->type);
+ free_cfg_options (&dev->numcfgoptions, &dev->cfgoptions);
+ dev = dev->next;
+
+ }
+
+ if (devarray != NULL)
+ free (devarray);
+ devarray = NULL;
+
+ DBG (3, "sane_exit: all drivers unloaded\n");
+
+}
+
+/* sane_get_devices:
+ * Returns a list of registered devices
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * A possible present old device_list is removed first. A new
+ * devarray is allocated and filled with pointers to the
+ * SANE_Device structures of the Mustek_pp_Devices
+ */
+/*ARGSUSED*/
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list,
+ SANE_Bool local_only __UNUSED__)
+{
+ int ctr;
+ Mustek_pp_Device *dev;
+
+ if (devarray != NULL)
+ free (devarray);
+
+ devarray = malloc ((num_devices + 1) * sizeof (devarray[0]));
+
+ if (devarray == NULL)
+ {
+ DBG (1, "sane_get_devices: not enough memory for device list\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+ dev = devlist;
+
+ for (ctr=0 ; ctr<num_devices ; ctr++) {
+ devarray[ctr] = &dev->sane;
+ dev = dev->next;
+ }
+
+ devarray[num_devices] = NULL;
+ *device_list = (const SANE_Device **)devarray;
+
+ return SANE_STATUS_GOOD;
+}
+
+/* sane_open:
+ * opens a device and prepares it for operation
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * The device identified by ``devicename'' is looked
+ * up in the list, or if devicename is zero, the
+ * first device from the list is taken.
+ *
+ * open is called for the selected device.
+ *
+ * The handel is set up with default values, and the
+ * option descriptors are initialized
+ */
+
+SANE_Status
+sane_open (SANE_String_Const devicename, SANE_Handle * handle)
+{
+
+ Mustek_pp_Handle *hndl;
+ Mustek_pp_Device *dev;
+ SANE_Status status;
+ int fd, i;
+
+ if (devicename[0]) {
+
+ dev = devlist;
+
+ while (dev) {
+
+ if (strcmp (dev->name, devicename) == 0)
+ break;
+
+ dev = dev->next;
+
+ }
+
+ if (!dev) {
+
+ DBG (1, "sane_open: unknown devicename ``%s''\n", devicename);
+ return SANE_STATUS_INVAL;
+
+ }
+ } else
+ dev = devlist;
+
+ if (!dev) {
+ DBG (1, "sane_open: no devices present...\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ DBG (3, "sane_open: Using device ``%s'' (driver %s v%s by %s)\n",
+ dev->name, dev->func->driver, dev->func->version, dev->func->author);
+
+ if ((hndl = malloc (sizeof (Mustek_pp_Handle))) == NULL) {
+
+ DBG (1, "sane_open: not enough free memory for the handle\n");
+ return SANE_STATUS_NO_MEM;
+
+ }
+
+ if ((status = dev->func->open (dev->port, dev->caps, &fd)) != SANE_STATUS_GOOD) {
+
+ DBG (1, "sane_open: could not open device (%s)\n",
+ sane_strstatus (status));
+ return status;
+
+ }
+
+ hndl->next = first_hndl;
+ hndl->dev = dev;
+ hndl->fd = fd;
+ hndl->state = STATE_IDLE;
+ hndl->pipe = -1;
+
+ init_options (hndl);
+
+ dev->func->setup (hndl);
+
+ /* Initialize driver-specific configuration options. This must be
+ done after calling the setup() function because only then the
+ driver is guaranteed to be fully initialized */
+ for (i = 0; i<dev->numcfgoptions; ++i)
+ {
+ status = dev->func->config (hndl,
+ dev->cfgoptions[i].name,
+ dev->cfgoptions[i].value);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_open: could not set option %s for device (%s)\n",
+ dev->cfgoptions[i].name, sane_strstatus (status));
+
+ /* Question: should the initialization be aborted when an
+ option cannot be handled ?
+ The driver should have reasonable built-in defaults, so
+ an illegal option value or an unknown option should not
+ be fatal. Therefore, it's probably ok to ignore the error. */
+ }
+ }
+
+ first_hndl = hndl;
+
+ *handle = hndl;
+
+ return SANE_STATUS_GOOD;
+}
+
+/* sane_close:
+ * closes a given device and frees all resources
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * The handle is searched in the list of active handles.
+ * If it's found, the handle is removed.
+ *
+ * If the associated device is still scanning, the process
+ * is cancelled.
+ *
+ * Then the backend makes sure, the lamp was at least
+ * 2 seconds on.
+ *
+ * Afterwards the selected handel is closed
+ */
+void
+sane_close (SANE_Handle handle)
+{
+ Mustek_pp_Handle *prev, *hndl;
+
+ prev = NULL;
+
+ for (hndl = first_hndl; hndl; hndl = hndl->next)
+ {
+ if (hndl == handle)
+ break;
+ prev = hndl;
+ }
+
+ if (hndl == NULL)
+ {
+ DBG (2, "sane_close: unknown device handle\n");
+ return;
+ }
+
+ if (hndl->state == STATE_SCANNING) {
+ sane_cancel (handle);
+ do_eof (handle);
+ }
+
+ if (prev != NULL)
+ prev->next = hndl->next;
+ else
+ first_hndl = hndl->next;
+
+ DBG (3, "sane_close: maybe waiting for lamp...\n");
+ if (hndl->lamp_on)
+ while (time (NULL) - hndl->lamp_on < 2)
+ sleep (1);
+
+ hndl->dev->func->close (hndl);
+
+ DBG (3, "sane_close: device closed\n");
+
+ free (handle);
+
+}
+
+/* sane_get_option_descriptor:
+ * does what it says
+ *
+ * ChangeLog:
+ *
+ * Description:
+ *
+ */
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+ Mustek_pp_Handle *hndl = handle;
+
+ if ((unsigned) option >= NUM_OPTIONS)
+ {
+ DBG (2, "sane_get_option_descriptor: option %d doesn't exist\n", option);
+ return NULL;
+ }
+
+ return hndl->opt + option;
+}
+
+
+/* sane_control_option:
+ * Reads or writes an option
+ *
+ * ChangeLog:
+ *
+ * Desription:
+ * If a pointer to info is given, the value is initialized to zero
+ * while scanning options cannot be read or written. next a basic
+ * check whether the request is valid is done.
+ *
+ * Depending on ``action'' the value of the option is either read
+ * (in the first block) or written (in the second block). auto
+ * values aren't supported.
+ *
+ * before a value is written, some checks are performed. Depending
+ * on the option, that is written, other options also change
+ *
+ */
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+ SANE_Action action, void *val, SANE_Int * info)
+{
+ Mustek_pp_Handle *hndl = handle;
+ SANE_Status status;
+ SANE_Word w, cap;
+
+ if (info)
+ *info = 0;
+
+ if (hndl->state == STATE_SCANNING)
+ {
+ DBG (2, "sane_control_option: device is scanning\n");
+ return SANE_STATUS_DEVICE_BUSY;
+ }
+
+ if ((unsigned int) option >= NUM_OPTIONS)
+ {
+ DBG (2, "sane_control_option: option %d doesn't exist\n", option);
+ return SANE_STATUS_INVAL;
+ }
+
+ cap = hndl->opt[option].cap;
+
+ if (!SANE_OPTION_IS_ACTIVE (cap))
+ {
+ DBG (2, "sane_control_option: option %d isn't active\n", option);
+ return SANE_STATUS_INVAL;
+ }
+
+ if (action == SANE_ACTION_GET_VALUE)
+ {
+
+ switch (option)
+ {
+ /* word options: */
+ case OPT_PREVIEW:
+ case OPT_GRAY_PREVIEW:
+ 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_CUSTOM_GAMMA:
+ case OPT_INVERT:
+ case OPT_DEPTH:
+
+ *(SANE_Word *) val = hndl->val[option].w;
+ return SANE_STATUS_GOOD;
+
+ /* word-array options: */
+ case OPT_GAMMA_VECTOR:
+ case OPT_GAMMA_VECTOR_R:
+ case OPT_GAMMA_VECTOR_G:
+ case OPT_GAMMA_VECTOR_B:
+
+ memcpy (val, hndl->val[option].wa, hndl->opt[option].size);
+ return SANE_STATUS_GOOD;
+
+ /* string options: */
+ case OPT_MODE:
+ case OPT_SPEED:
+
+ strcpy (val, hndl->val[option].s);
+ return SANE_STATUS_GOOD;
+ }
+ }
+ else if (action == SANE_ACTION_SET_VALUE)
+ {
+
+ if (!SANE_OPTION_IS_SETTABLE (cap))
+ {
+ DBG (2, "sane_control_option: option can't be set (%s)\n",
+ hndl->opt[option].name);
+ return SANE_STATUS_INVAL;
+ }
+
+ status = sanei_constrain_value (hndl->opt + option, val, info);
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (2, "sane_control_option: constrain_value failed (%s)\n",
+ sane_strstatus (status));
+ return status;
+ }
+
+ switch (option)
+ {
+ /* (mostly) side-effect-free word options: */
+ case OPT_RESOLUTION:
+ case OPT_TL_X:
+ case OPT_BR_X:
+ case OPT_TL_Y:
+ case OPT_BR_Y:
+ case OPT_PREVIEW:
+ case OPT_GRAY_PREVIEW:
+ case OPT_INVERT:
+ case OPT_DEPTH:
+
+ if (info)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+
+ hndl->val[option].w = *(SANE_Word *) val;
+ return SANE_STATUS_GOOD;
+
+ /* side-effect-free word-array options: */
+ case OPT_GAMMA_VECTOR:
+ case OPT_GAMMA_VECTOR_R:
+ case OPT_GAMMA_VECTOR_G:
+ case OPT_GAMMA_VECTOR_B:
+
+ memcpy (hndl->val[option].wa, val, hndl->opt[option].size);
+ return SANE_STATUS_GOOD;
+
+ /* side-effect-free string options: */
+ case OPT_SPEED:
+
+ if (hndl->val[option].s)
+ free (hndl->val[option].s);
+
+ hndl->val[option].s = strdup (val);
+ return SANE_STATUS_GOOD;
+
+
+ /* options with side-effects: */
+
+ case OPT_CUSTOM_GAMMA:
+ w = *(SANE_Word *) val;
+
+ if (w == hndl->val[OPT_CUSTOM_GAMMA].w)
+ return SANE_STATUS_GOOD; /* no change */
+
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+
+ hndl->val[OPT_CUSTOM_GAMMA].w = w;
+
+ if (w == SANE_TRUE)
+ {
+ const char *mode = hndl->val[OPT_MODE].s;
+
+ if (strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY) == 0)
+ hndl->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
+ else if (strcmp (mode, SANE_VALUE_SCAN_MODE_COLOR) == 0)
+ {
+ hndl->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
+ }
+ }
+ else
+ {
+ hndl->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+ }
+
+ return SANE_STATUS_GOOD;
+
+ case OPT_MODE:
+ {
+ char *old_val = hndl->val[option].s;
+
+ if (old_val)
+ {
+ if (strcmp (old_val, val) == 0)
+ return SANE_STATUS_GOOD; /* no change */
+
+ free (old_val);
+ }
+
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+
+ hndl->val[option].s = strdup (val);
+
+ hndl->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+
+ hndl->opt[OPT_DEPTH].cap |= SANE_CAP_INACTIVE;
+
+ if ((hndl->dev->caps & CAP_DEPTH) && (strcmp(val, SANE_VALUE_SCAN_MODE_COLOR) == 0))
+ hndl->opt[OPT_DEPTH].cap &= ~SANE_CAP_INACTIVE;
+
+ if (!(hndl->dev->caps & CAP_GAMMA_CORRECT))
+ return SANE_STATUS_GOOD;
+
+ if (strcmp (val, SANE_VALUE_SCAN_MODE_LINEART) != 0)
+ hndl->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+
+ if (hndl->val[OPT_CUSTOM_GAMMA].w == SANE_TRUE)
+ {
+ if (strcmp (val, SANE_VALUE_SCAN_MODE_GRAY) == 0)
+ hndl->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
+ else if (strcmp (val, SANE_VALUE_SCAN_MODE_COLOR) == 0)
+ {
+ hndl->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
+ hndl->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
+ }
+ }
+
+ return SANE_STATUS_GOOD;
+ }
+ }
+ }
+
+ DBG (2, "sane_control_option: unknown action\n");
+ return SANE_STATUS_INVAL;
+}
+
+
+/* sane_get_parameters:
+ * returns the set of parameters, that is used for the next scan
+ *
+ * ChangeLog:
+ *
+ * Description:
+ *
+ * First of all it is impossible to change the parameter set
+ * while scanning.
+ *
+ * sane_get_parameters not only returns the parameters for
+ * the next scan, it also sets them, i.e. converts the
+ * options in actuall parameters.
+ *
+ * The following parameters are set:
+ *
+ * scanmode: according to the option SCANMODE, but
+ * 24bit color, if PREVIEW is selected and
+ * grayscale if GRAY_PREVIEW is selected
+ * depth: the bit depth for color modes (if
+ * supported) or 24bit by default
+ * (ignored in bw/grayscale or if not
+ * supported)
+ * dpi: resolution
+ * invert: if supported else defaults to false
+ * gamma: if supported and selected
+ * ta: if supported by the device
+ * speed: selected speed (or fastest if not
+ * supported)
+ * scanarea: the scanarea is calculated from the
+ * selections the user has mode. note
+ * that the area may slightly differ from
+ * the scanarea selected due to rounding
+ * note also, that a scanarea of
+ * (0,0)-(100,100) will include all pixels
+ * where 0 <= x < 100 and 0 <= y < 100
+ * afterwards, all values are copied into the SANE_Parameters
+ * structure.
+ */
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+ Mustek_pp_Handle *hndl = handle;
+ char *mode;
+ int dpi, ctr;
+
+ if (hndl->state != STATE_SCANNING)
+ {
+
+
+ memset (&hndl->params, 0, sizeof (hndl->params));
+
+
+ if ((hndl->dev->caps & CAP_DEPTH) && (hndl->mode == MODE_COLOR))
+ hndl->depth = hndl->val[OPT_DEPTH].w;
+ else
+ hndl->depth = 8;
+
+ dpi = (int) (SANE_UNFIX (hndl->val[OPT_RESOLUTION].w) + 0.5);
+
+ hndl->res = dpi;
+
+ if (hndl->dev->caps & CAP_INVERT)
+ hndl->invert = hndl->val[OPT_INVERT].w;
+ else
+ hndl->invert = SANE_FALSE;
+
+ if (hndl->dev->caps & CAP_TA)
+ hndl->use_ta = SANE_TRUE;
+ else
+ hndl->use_ta = SANE_FALSE;
+
+ if ((hndl->dev->caps & CAP_GAMMA_CORRECT) && (hndl->val[OPT_CUSTOM_GAMMA].w == SANE_TRUE))
+ hndl->do_gamma = SANE_TRUE;
+ else
+ hndl->do_gamma = SANE_FALSE;
+
+ if (hndl->dev->caps & CAP_SPEED_SELECT) {
+
+ for (ctr=SPEED_SLOWEST; ctr<=SPEED_FASTEST; ctr++)
+ if (strcmp(mustek_pp_speeds[ctr], hndl->val[OPT_SPEED].s) == 0)
+ hndl->speed = ctr;
+
+
+
+ } else
+ hndl->speed = SPEED_NORMAL;
+
+ mode = hndl->val[OPT_MODE].s;
+
+ if (strcmp (mode, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+ hndl->mode = MODE_BW;
+ else if (strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY) == 0)
+ hndl->mode = MODE_GRAYSCALE;
+ else
+ hndl->mode = MODE_COLOR;
+
+ if (hndl->val[OPT_PREVIEW].w == SANE_TRUE)
+ {
+
+ hndl->speed = SPEED_FASTEST;
+ hndl->depth = 8;
+ if (! hndl->use_ta)
+ hndl->invert = SANE_FALSE;
+ hndl->do_gamma = SANE_FALSE;
+
+ if (hndl->val[OPT_GRAY_PREVIEW].w == SANE_TRUE)
+ hndl->mode = MODE_GRAYSCALE;
+ else {
+ hndl->mode = MODE_COLOR;
+ }
+
+ }
+
+ hndl->topX =
+ MIN ((int)
+ (MM_TO_PIXEL (SANE_UNFIX(hndl->val[OPT_TL_X].w), hndl->dev->maxres) +
+ 0.5), hndl->dev->maxhsize);
+ hndl->topY =
+ MIN ((int)
+ (MM_TO_PIXEL (SANE_UNFIX(hndl->val[OPT_TL_Y].w), hndl->dev->maxres) +
+ 0.5), hndl->dev->maxvsize);
+
+ hndl->bottomX =
+ MIN ((int)
+ (MM_TO_PIXEL (SANE_UNFIX(hndl->val[OPT_BR_X].w), hndl->dev->maxres) +
+ 0.5), hndl->dev->maxhsize);
+ hndl->bottomY =
+ MIN ((int)
+ (MM_TO_PIXEL (SANE_UNFIX(hndl->val[OPT_BR_Y].w), hndl->dev->maxres) +
+ 0.5), hndl->dev->maxvsize);
+
+ /* If necessary, swap the upper and lower boundaries to avoid negative
+ distances. */
+ if (hndl->topX > hndl->bottomX) {
+ SANE_Int tmp = hndl->topX;
+ hndl->topX = hndl->bottomX;
+ hndl->bottomX = tmp;
+ }
+ if (hndl->topY > hndl->bottomY) {
+ SANE_Int tmp = hndl->topY;
+ hndl->topY = hndl->bottomY;
+ hndl->bottomY = tmp;
+ }
+
+ hndl->params.pixels_per_line = (hndl->bottomX - hndl->topX) * hndl->res
+ / hndl->dev->maxres;
+
+ hndl->params.bytes_per_line = hndl->params.pixels_per_line;
+
+ switch (hndl->mode)
+ {
+
+ case MODE_BW:
+ hndl->params.bytes_per_line /= 8;
+
+ if ((hndl->params.pixels_per_line % 8) != 0)
+ hndl->params.bytes_per_line++;
+
+ hndl->params.depth = 1;
+ break;
+
+ case MODE_GRAYSCALE:
+ hndl->params.depth = 8;
+ hndl->params.format = SANE_FRAME_GRAY;
+ break;
+
+ case MODE_COLOR:
+ hndl->params.depth = hndl->depth;
+ hndl->params.bytes_per_line *= 3;
+ if (hndl->depth > 8)
+ hndl->params.bytes_per_line *= 2;
+ hndl->params.format = SANE_FRAME_RGB;
+ break;
+
+ }
+
+ hndl->params.last_frame = SANE_TRUE;
+
+ hndl->params.lines = (hndl->bottomY - hndl->topY) * hndl->res /
+ hndl->dev->maxres;
+ }
+ else
+ DBG (2, "sane_get_parameters: can't set parameters while scanning\n");
+
+ if (params != NULL)
+ *params = hndl->params;
+
+ return SANE_STATUS_GOOD;
+
+}
+
+
+/* sane_start:
+ * starts the scan. data aquisition will start immedially
+ *
+ * ChangeLog:
+ *
+ * Description:
+ *
+ */
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+ Mustek_pp_Handle *hndl = handle;
+ int pipeline[2];
+
+ if (hndl->state == STATE_SCANNING) {
+ DBG (2, "sane_start: device is already scanning\n");
+ return SANE_STATUS_DEVICE_BUSY;
+
+ }
+
+ sane_get_parameters (hndl, NULL);
+
+ if (pipe(pipeline) < 0) {
+ DBG (1, "sane_start: could not initialize pipe (%s)\n",
+ strerror(errno));
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ hndl->reader = fork();
+
+ if (hndl->reader == 0) {
+
+ sigset_t ignore_set;
+ struct SIGACTION act;
+
+ close (pipeline[0]);
+
+ sigfillset (&ignore_set);
+ sigdelset (&ignore_set, SIGTERM);
+ sigprocmask (SIG_SETMASK, &ignore_set, NULL);
+
+ memset (&act, 0, sizeof(act));
+ sigaction (SIGTERM, &act, NULL);
+
+ _exit (reader_process (hndl, pipeline[1]));
+
+ }
+
+ close (pipeline[1]);
+
+ hndl->pipe = pipeline[0];
+
+ hndl->state = STATE_SCANNING;
+
+ return SANE_STATUS_GOOD;
+
+}
+
+
+/* sane_read:
+ * receives data from pipeline and passes it to the caller
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * ditto
+ */
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
+ SANE_Int * len)
+{
+ Mustek_pp_Handle *hndl = handle;
+ SANE_Int nread;
+
+
+ if (hndl->state == STATE_CANCELLED) {
+ DBG (2, "sane_read: device already cancelled\n");
+ do_eof (hndl);
+ hndl->state = STATE_IDLE;
+ return SANE_STATUS_CANCELLED;
+ }
+
+ if (hndl->state != STATE_SCANNING) {
+ DBG (1, "sane_read: device isn't scanning\n");
+ return SANE_STATUS_INVAL;
+ }
+
+
+ *len = nread = 0;
+
+ while (*len < max_len) {
+
+ nread = read(hndl->pipe, buf + *len, max_len - *len);
+
+ if (hndl->state == STATE_CANCELLED) {
+
+ *len = 0;
+ DBG(3, "sane_read: scan was cancelled\n");
+
+ do_eof (hndl);
+ hndl->state = STATE_IDLE;
+ return SANE_STATUS_CANCELLED;
+
+ }
+
+ if (nread < 0) {
+
+ if (errno == EAGAIN) {
+
+ if (*len == 0)
+ DBG(3, "sane_read: no data at the moment\n");
+ else
+ DBG(3, "sane_read: %d bytes read\n", *len);
+
+ return SANE_STATUS_GOOD;
+
+ } else {
+
+ DBG(1, "sane_read: IO error (%s)\n", strerror(errno));
+
+ hndl->state = STATE_IDLE;
+ do_stop(hndl);
+
+ do_eof (hndl);
+
+ *len = 0;
+ return SANE_STATUS_IO_ERROR;
+
+ }
+ }
+
+ *len += nread;
+
+ if (nread == 0) {
+
+ if (*len == 0) {
+
+ DBG (3, "sane_read: read finished\n");
+ do_stop(hndl);
+
+ hndl->state = STATE_IDLE;
+
+ return do_eof(hndl);
+
+ }
+
+ DBG(3, "sane_read: read last buffer of %d bytes\n",
+ *len);
+
+ return SANE_STATUS_GOOD;
+
+ }
+
+ }
+
+ DBG(3, "sane_read: read full buffer of %d bytes\n", *len);
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* sane_cancel:
+ * stops a scan and ends the reader process
+ *
+ * ChangeLog:
+ *
+ * Description:
+ *
+ */
+void
+sane_cancel (SANE_Handle handle)
+{
+ Mustek_pp_Handle *hndl = handle;
+
+ if (hndl->state != STATE_SCANNING)
+ return;
+
+ hndl->state = STATE_CANCELLED;
+
+ do_stop (hndl);
+
+}
+
+
+/* sane_set_io_mode:
+ * toggles between blocking and non-blocking reading
+ *
+ * ChangeLog:
+ *
+ * Description:
+ *
+ */
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+
+ Mustek_pp_Handle *hndl=handle;
+
+ if (hndl->state != STATE_SCANNING)
+ return SANE_STATUS_INVAL;
+
+
+ if (fcntl (hndl->pipe, F_SETFL, non_blocking ? O_NONBLOCK : 0) < 0) {
+
+ DBG(1, "sane_set_io_mode: can't set io mode\n");
+
+ return SANE_STATUS_IO_ERROR;
+
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* sane_get_select_fd:
+ * returns the pipeline fd for direct reading
+ *
+ * ChangeLog:
+ *
+ * Description:
+ * to allow the frontend to receive the data directly it
+ * can read from the pipeline itself
+ */
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+ Mustek_pp_Handle *hndl=handle;
+
+ if (hndl->state != STATE_SCANNING)
+ return SANE_STATUS_INVAL;
+
+ *fd = hndl->pipe;
+
+ return SANE_STATUS_GOOD;
+}
+
+/* include drivers */
+#include "mustek_pp_decl.h"
+#include "mustek_pp_null.c"
+#include "mustek_pp_cis.h"
+#include "mustek_pp_cis.c"
+#include "mustek_pp_ccd300.h"
+#include "mustek_pp_ccd300.c"