Initial import of sane-backends version 1.0.24-1.2

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"