Initial import of sane-backends version 1.0.24-1.2

1 files changed, 1137 insertions, 0 deletions

diff --git a/backend/v4l.c b/backend/v4l.c
new file mode 100644
index 0000000..38595ed
--- /dev/null
+++ b/backend/v4l.c
@@ -0,0 +1,1137 @@
+/* sane - Scanner Access Now Easy.
+   Copyright (C) 1999 Juergen G. Schimmer
+   Updates and bugfixes (C) 2002 - 2004 Henning Meier-Geinitz
+
+   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 v4l-Devices.
+*/
+
+#define BUILD 5
+
+#include "../include/sane/config.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <math.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/saneopts.h"
+
+#include <sys/ioctl.h>
+#include <asm/types.h>		/* XXX glibc */
+
+#define BACKEND_NAME v4l
+#include "../include/sane/sanei_backend.h"
+
+#ifndef PATH_MAX
+# define PATH_MAX       1024
+#endif
+
+#include "../include/sane/sanei_config.h"
+#define V4L_CONFIG_FILE "v4l.conf"
+
+#include <libv4l1.h>
+#include "v4l.h"
+
+static const SANE_Device **devlist = NULL;
+static int num_devices;
+static V4L_Device *first_dev;
+static V4L_Scanner *first_handle;
+static char *buffer;
+
+static const SANE_String_Const mode_list[] = {
+  SANE_VALUE_SCAN_MODE_GRAY, SANE_VALUE_SCAN_MODE_COLOR,
+  0
+};
+
+static const SANE_Range u8_range = {
+  /* min, max, quantization */
+  0, 255, 0
+};
+
+static SANE_Range x_range = { 0, 338, 2 };
+
+static SANE_Range odd_x_range = { 1, 339, 2 };
+
+static SANE_Range y_range = { 0, 249, 1 };
+
+static SANE_Range odd_y_range = { 1, 250, 1 };
+
+
+static SANE_Parameters parms = {
+  SANE_FRAME_RGB,
+  1,				/* 1 = Last Frame , 0 = More Frames to come */
+  0,				/* Number of bytes returned per scan line: */
+  0,				/* Number of pixels per scan line.  */
+  0,				/* Number of lines for the current scan.  */
+  8,				/* Number of bits per sample. */
+};
+
+static SANE_Status
+attach (const char *devname, V4L_Device ** devp)
+{
+  V4L_Device *dev;
+  static int v4lfd;
+  static struct video_capability capability;
+
+  errno = 0;
+
+  for (dev = first_dev; dev; dev = dev->next)
+    if (strcmp (dev->sane.name, devname) == 0)
+      {
+	if (devp)
+	  *devp = dev;
+	DBG (5, "attach: device %s is already known\n", devname);
+	return SANE_STATUS_GOOD;
+      }
+
+  DBG (3, "attach: trying to open %s\n", devname);
+  v4lfd = v4l1_open (devname, O_RDWR);
+  if (v4lfd != -1)
+    {
+      if (v4l1_ioctl (v4lfd, VIDIOCGCAP, &capability) == -1)
+	{
+	  DBG (1,
+	       "attach: ioctl (%d, VIDIOCGCAP,..) failed on `%s': %s\n",
+	       v4lfd, devname, strerror (errno));
+	  v4l1_close (v4lfd);
+	  return SANE_STATUS_INVAL;
+	}
+      if (!(VID_TYPE_CAPTURE & capability.type))
+	{
+	  DBG (1, "attach: device %s can't capture to memory -- exiting\n",
+	       devname);
+	  v4l1_close (v4lfd);
+	  return SANE_STATUS_UNSUPPORTED;
+	}
+      DBG (2, "attach: found videodev `%s' on `%s'\n", capability.name,
+	   devname);
+      v4l1_close (v4lfd);
+    }
+  else
+    {
+      DBG (1, "attach: failed to open device `%s': %s\n", devname,
+	   strerror (errno));
+      return SANE_STATUS_INVAL;
+    }
+
+  dev = malloc (sizeof (*dev));
+  if (!dev)
+    return SANE_STATUS_NO_MEM;
+
+  memset (dev, 0, sizeof (*dev));
+
+  dev->sane.name = strdup (devname);
+  if (!dev->sane.name)
+    return SANE_STATUS_NO_MEM;
+  dev->sane.vendor = "Noname";
+  dev->sane.model = strdup (capability.name);
+  if (!dev->sane.model)
+    return SANE_STATUS_NO_MEM;
+  dev->sane.type = "virtual device";
+
+  ++num_devices;
+  dev->next = first_dev;
+  first_dev = dev;
+
+  if (devp)
+    *devp = dev;
+  return SANE_STATUS_GOOD;
+}
+
+static void
+update_parameters (V4L_Scanner * s)
+{
+  /* ??? should be per-device */
+  x_range.min = 0;
+  x_range.max = s->capability.maxwidth - s->capability.minwidth;
+  x_range.quant = 1;
+
+  y_range.min = 0;
+  y_range.max = s->capability.maxheight - s->capability.minheight;
+  y_range.quant = 1;
+
+  odd_x_range.min = s->capability.minwidth;
+  odd_x_range.max = s->capability.maxwidth;
+  if (odd_x_range.max > 767)
+    {
+      odd_x_range.max = 767;
+      x_range.max = 767 - s->capability.minwidth;
+    };
+  odd_x_range.quant = 1;
+
+  odd_y_range.min = s->capability.minheight;
+  odd_y_range.max = s->capability.maxheight;
+  if (odd_y_range.max > 511)
+    {
+      odd_y_range.max = 511;
+      y_range.max = 511 - s->capability.minheight;
+    };
+  odd_y_range.quant = 1;
+
+  parms.lines = s->window.height;
+  parms.pixels_per_line = s->window.width;
+
+  switch (s->pict.palette)
+    {
+    case VIDEO_PALETTE_GREY:	/* Linear greyscale */
+      {
+	parms.format = SANE_FRAME_GRAY;
+	parms.depth = 8;
+	parms.bytes_per_line = s->window.width;
+	break;
+      }
+    case VIDEO_PALETTE_RGB24:	/* 24bit RGB */
+      {
+	parms.format = SANE_FRAME_RGB;
+	parms.depth = 8;
+	parms.bytes_per_line = s->window.width * 3;
+	break;
+      }
+    default:
+      {
+	parms.format = SANE_FRAME_GRAY;
+	parms.bytes_per_line = s->window.width;
+	break;
+      }
+    }
+}
+
+static SANE_Status
+init_options (V4L_Scanner * s)
+{
+  int i;
+
+  memset (s->opt, 0, sizeof (s->opt));
+  memset (s->val, 0, sizeof (s->val));
+
+  for (i = 0; i < NUM_OPTIONS; ++i)
+    {
+      s->opt[i].size = sizeof (SANE_Word);
+      s->opt[i].cap = (SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT);
+    }
+
+  /* Number of options */
+  s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+  s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+  s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+  /* "Mode" group: */
+  s->opt[OPT_MODE_GROUP].title = "Scan Mode";
+  s->opt[OPT_MODE_GROUP].desc = "";
+  s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_MODE_GROUP].cap = 0;
+  s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* mode */
+  s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
+  s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
+  s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
+  s->opt[OPT_MODE].type = SANE_TYPE_STRING;
+  s->opt[OPT_MODE].unit = SANE_UNIT_NONE;
+  s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_MODE].constraint.string_list = mode_list;
+  s->val[OPT_MODE].s = strdup (mode_list[0]);
+  if (!s->val[OPT_MODE].s)
+    return SANE_STATUS_NO_MEM;
+
+  /* channel */
+  s->opt[OPT_CHANNEL].name = "channel";
+  s->opt[OPT_CHANNEL].title = "Channel";
+  s->opt[OPT_CHANNEL].desc =
+    "Selects the channel of the v4l device (e.g. television " "or video-in.";
+  s->opt[OPT_CHANNEL].type = SANE_TYPE_STRING;
+  s->opt[OPT_CHANNEL].unit = SANE_UNIT_NONE;
+  s->opt[OPT_CHANNEL].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_CHANNEL].constraint.string_list = s->channel;
+  s->val[OPT_CHANNEL].s = strdup (s->channel[0]);
+  if (!s->val[OPT_CHANNEL].s)
+    return SANE_STATUS_NO_MEM;
+  if (s->channel[0] == 0 || s->channel[1] == 0)
+    s->opt[OPT_CHANNEL].cap |= SANE_CAP_INACTIVE;
+
+  /* "Geometry" group: */
+  s->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
+  s->opt[OPT_GEOMETRY_GROUP].desc = "";
+  s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
+  s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+/* top-left x *//* ??? first check if window is settable at all */
+  s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+  s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+  s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+  s->opt[OPT_TL_X].type = SANE_TYPE_INT;
+  s->opt[OPT_TL_X].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_TL_X].cap |= SANE_CAP_INACTIVE;
+  s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_X].constraint.range = &x_range;
+  s->val[OPT_TL_X].w = 0;
+
+  /* top-left y */
+  s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].type = SANE_TYPE_INT;
+  s->opt[OPT_TL_Y].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_TL_Y].cap |= SANE_CAP_INACTIVE;
+  s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_Y].constraint.range = &y_range;
+  s->val[OPT_TL_Y].w = 0;
+
+  /* bottom-right x */
+  s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+  s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+  s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+  s->opt[OPT_BR_X].type = SANE_TYPE_INT;
+  s->opt[OPT_BR_X].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_BR_X].cap |= SANE_CAP_INACTIVE;
+  s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_X].constraint.range = &odd_x_range;
+  s->val[OPT_BR_X].w = s->capability.maxwidth;
+  if (s->val[OPT_BR_X].w > 767)
+    s->val[OPT_BR_X].w = 767;
+
+  /* bottom-right y */
+  s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].type = SANE_TYPE_INT;
+  s->opt[OPT_BR_Y].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_BR_Y].cap |= SANE_CAP_INACTIVE;
+  s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_Y].constraint.range = &odd_y_range;
+  s->val[OPT_BR_Y].w = s->capability.maxheight;
+  if (s->val[OPT_BR_Y].w > 511)
+    s->val[OPT_BR_Y].w = 511;
+
+  /* "Enhancement" group: */
+  s->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
+  s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
+  s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* brightness */
+  s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
+  s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BRIGHTNESS].constraint.range = &u8_range;
+  s->val[OPT_BRIGHTNESS].w = s->pict.brightness / 256;
+
+  /* hue */
+  s->opt[OPT_HUE].name = SANE_NAME_HUE;
+  s->opt[OPT_HUE].title = SANE_TITLE_HUE;
+  s->opt[OPT_HUE].desc = SANE_DESC_HUE;
+  s->opt[OPT_HUE].type = SANE_TYPE_INT;
+  s->opt[OPT_HUE].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_HUE].constraint.range = &u8_range;
+  s->val[OPT_HUE].w = s->pict.hue / 256;
+
+  /* colour */
+  s->opt[OPT_COLOR].name = "color";
+  s->opt[OPT_COLOR].title = "Picture color";
+  s->opt[OPT_COLOR].desc = "Sets the picture's color.";
+  s->opt[OPT_COLOR].type = SANE_TYPE_INT;
+  s->opt[OPT_COLOR].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_COLOR].constraint.range = &u8_range;
+  s->val[OPT_COLOR].w = s->pict.colour / 256;
+
+  /* contrast */
+  s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
+  s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
+  s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
+  s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
+  s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_CONTRAST].constraint.range = &u8_range;
+  s->val[OPT_CONTRAST].w = s->pict.contrast / 256;
+
+  /* whiteness */
+  s->opt[OPT_WHITE_LEVEL].name = SANE_NAME_WHITE_LEVEL;
+  s->opt[OPT_WHITE_LEVEL].title = SANE_TITLE_WHITE_LEVEL;
+  s->opt[OPT_WHITE_LEVEL].desc = SANE_DESC_WHITE_LEVEL;
+  s->opt[OPT_WHITE_LEVEL].type = SANE_TYPE_INT;
+  s->opt[OPT_WHITE_LEVEL].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_WHITE_LEVEL].constraint.range = &u8_range;
+  s->val[OPT_WHITE_LEVEL].w = s->pict.whiteness / 256;
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  char dev_name[PATH_MAX], *str;
+  size_t len;
+  FILE *fp;
+
+  authorize = authorize;	/* stop gcc from complaining */
+  DBG_INIT ();
+
+  DBG (2, "SANE v4l backend version %d.%d build %d from %s\n", SANE_CURRENT_MAJOR,
+       V_MINOR, BUILD, PACKAGE_STRING);
+
+  if (version_code)
+    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD);
+
+  fp = sanei_config_open (V4L_CONFIG_FILE);
+  if (!fp)
+    {
+      DBG (2,
+	   "sane_init: file `%s' not accessible (%s), trying /dev/video0\n",
+	   V4L_CONFIG_FILE, strerror (errno));
+
+      return attach ("/dev/video0", 0);
+    }
+
+  while (sanei_config_read (dev_name, sizeof (dev_name), fp))
+    {
+      if (dev_name[0] == '#')	/* ignore line comments */
+	continue;
+      len = strlen (dev_name);
+
+      if (!len)
+	continue;		/* ignore empty lines */
+
+      /* Remove trailing space and trailing comments */
+      for (str = dev_name; *str && !isspace (*str) && *str != '#'; ++str);
+      attach (dev_name, 0);
+    }
+  fclose (fp);
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_exit (void)
+{
+  V4L_Device *dev, *next;
+
+  for (dev = first_dev; dev; dev = next)
+    {
+      next = dev->next;
+      free ((void *) dev->sane.name);
+      free ((void *) dev->sane.model);
+      free (dev);
+    }
+
+  if (NULL != devlist)
+    {
+      free (devlist);
+      devlist = NULL;
+    }
+  DBG (5, "sane_exit: all devices freed\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  V4L_Device *dev;
+  int i;
+
+  DBG (5, "sane_get_devices\n");
+  local_only = SANE_TRUE;	/* Avoid compile warning */
+
+  if (devlist)
+    free (devlist);
+
+  devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
+  if (!devlist)
+    return SANE_STATUS_NO_MEM;
+
+  i = 0;
+  for (dev = first_dev; i < num_devices; dev = dev->next)
+    devlist[i++] = &dev->sane;
+  devlist[i++] = 0;
+
+  *device_list = devlist;
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devname, SANE_Handle * handle)
+{
+  V4L_Device *dev;
+  V4L_Scanner *s;
+  static int v4lfd;
+  int i;
+  struct video_channel channel;
+  SANE_Status status;
+  int max_channels = MAX_CHANNELS;
+
+  if (!devname)
+    {
+      DBG (1, "sane_open: devname == 0\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  for (dev = first_dev; dev; dev = dev->next)
+    if (strcmp (dev->sane.name, devname) == 0)
+      {
+	DBG (5, "sane_open: device %s found in devlist\n", devname);
+	break;
+      }
+  if (!devname[0])
+    dev = first_dev;
+  if (!dev)
+    {
+      DBG (1, "sane_open: device %s doesn't seem to be a v4l "
+	   "device\n", devname);
+      return SANE_STATUS_INVAL;
+    }
+
+  v4lfd = v4l1_open (devname, O_RDWR);
+  if (v4lfd == -1)
+    {
+      DBG (1, "sane_open: can't open %s (%s)\n", devname, strerror (errno));
+      return SANE_STATUS_INVAL;
+    }
+  s = malloc (sizeof (*s));
+  if (!s)
+    return SANE_STATUS_NO_MEM;
+  memset (s, 0, sizeof (*s));
+  s->user_corner = 0;		/* ??? */
+  s->devicename = devname;
+  s->fd = v4lfd;
+
+  if (v4l1_ioctl (s->fd, VIDIOCGCAP, &s->capability) == -1)
+    {
+      DBG (1, "sane_open: ioctl (%d, VIDIOCGCAP,..) failed on `%s': %s\n",
+	   s->fd, devname, strerror (errno));
+      v4l1_close (s->fd);
+      return SANE_STATUS_INVAL;
+    }
+
+  DBG (5, "sane_open: %d channels, %d audio devices\n",
+       s->capability.channels, s->capability.audios);
+  DBG (5, "sane_open: minwidth=%d, minheight=%d, maxwidth=%d, "
+       "maxheight=%d\n", s->capability.minwidth, s->capability.minheight,
+       s->capability.maxwidth, s->capability.maxheight);
+  if (VID_TYPE_CAPTURE & s->capability.type)
+    DBG (5, "sane_open: V4L device can capture to memory\n");
+  if (VID_TYPE_TUNER & s->capability.type)
+    DBG (5, "sane_open: V4L device has a tuner of some form\n");
+  if (VID_TYPE_TELETEXT & s->capability.type)
+    DBG (5, "sane_open: V4L device supports teletext\n");
+  if (VID_TYPE_OVERLAY & s->capability.type)
+    DBG (5, "sane_open: V4L device can overlay its image onto the frame "
+	 "buffer\n");
+  if (VID_TYPE_CHROMAKEY & s->capability.type)
+    DBG (5, "sane_open: V4L device uses chromakey on overlay\n");
+  if (VID_TYPE_CLIPPING & s->capability.type)
+    DBG (5, "sane_open: V4L device supports overlay clipping\n");
+  if (VID_TYPE_FRAMERAM & s->capability.type)
+    DBG (5, "sane_open: V4L device overwrites frame buffer memory\n");
+  if (VID_TYPE_SCALES & s->capability.type)
+    DBG (5, "sane_open: V4L device supports hardware scaling\n");
+  if (VID_TYPE_MONOCHROME & s->capability.type)
+    DBG (5, "sane_open: V4L device is grey scale only\n");
+  if (VID_TYPE_SUBCAPTURE & s->capability.type)
+    DBG (5, "sane_open: V4L device can capture parts of the image\n");
+
+  if (s->capability.channels < max_channels)
+    max_channels = s->capability.channels;
+  for (i = 0; i < max_channels; i++)
+    {
+      channel.channel = i;
+      if (-1 == v4l1_ioctl (v4lfd, VIDIOCGCHAN, &channel))
+	{
+	  DBG (1, "sane_open: can't ioctl VIDIOCGCHAN %s: %s\n", devname,
+	       strerror (errno));
+	  return SANE_STATUS_INVAL;
+	}
+      DBG (5, "sane_open: channel %d (%s), tuners=%d, flags=0x%x, "
+	   "type=%d, norm=%d\n", channel.channel, channel.name,
+	   channel.tuners, channel.flags, channel.type, channel.norm);
+      if (VIDEO_VC_TUNER & channel.flags)
+	DBG (5, "sane_open: channel has tuner(s)\n");
+      if (VIDEO_VC_AUDIO & channel.flags)
+	DBG (5, "sane_open: channel has audio\n");
+      if (VIDEO_TYPE_TV == channel.type)
+	DBG (5, "sane_open: input is TV input\n");
+      if (VIDEO_TYPE_CAMERA == channel.type)
+	DBG (5, "sane_open: input is camera input\n");
+      s->channel[i] = strdup (channel.name);
+      if (!s->channel[i])
+	return SANE_STATUS_NO_MEM;
+    }
+  s->channel[i] = 0;
+  if (-1 == v4l1_ioctl (v4lfd, VIDIOCGPICT, &s->pict))
+    {
+      DBG (1, "sane_open: can't ioctl VIDIOCGPICT %s: %s\n", devname,
+	   strerror (errno));
+      return SANE_STATUS_INVAL;
+    }
+  DBG (5, "sane_open: brightness=%d, hue=%d, colour=%d, contrast=%d\n",
+       s->pict.brightness, s->pict.hue, s->pict.colour, s->pict.contrast);
+  DBG (5, "sane_open: whiteness=%d, depth=%d, palette=%d\n",
+       s->pict.whiteness, s->pict.depth, s->pict.palette);
+
+  /* ??? */
+  s->pict.palette = VIDEO_PALETTE_GREY;
+  if (-1 == v4l1_ioctl (s->fd, VIDIOCSPICT, &s->pict))
+    {
+      DBG (1, "sane_open: ioctl VIDIOCSPICT failed (%s)\n", strerror (errno));
+    }
+
+  if (-1 == v4l1_ioctl (s->fd, VIDIOCGWIN, &s->window))
+    {
+      DBG (1, "sane_open: can't ioctl VIDIOCGWIN %s: %s\n", devname,
+	   strerror (errno));
+      return SANE_STATUS_INVAL;
+    }
+  DBG (5, "sane_open: x=%d, y=%d, width=%d, height=%d\n",
+       s->window.x, s->window.y, s->window.width, s->window.height);
+
+  /* already done in sane_start 
+     if (-1 == v4l1_ioctl (v4lfd, VIDIOCGMBUF, &mbuf))
+     DBG (1, "sane_open: can't ioctl VIDIOCGMBUF (no Fbuffer?)\n");
+   */
+
+  status = init_options (s);
+  if (status != SANE_STATUS_GOOD)
+    return status;
+  update_parameters (s);
+
+  /* insert newly opened handle into list of open handles: */
+  s->next = first_handle;
+  first_handle = s;
+
+  *handle = s;
+
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+  V4L_Scanner *prev, *s;
+
+  DBG (2, "sane_close: trying to close handle %p\n", (void *) handle);
+  /* remove handle from list of open handles: */
+  prev = 0;
+  for (s = first_handle; s; s = s->next)
+    {
+      if (s == handle)
+	break;
+      prev = s;
+    }
+  if (!s)
+    {
+      DBG (1, "sane_close: bad handle %p\n", handle);
+      return;			/* oops, not a handle we know about */
+    }
+  if (prev)
+    prev->next = s->next;
+  else
+    first_handle = s->next;
+
+  if (s->scanning)
+    sane_cancel (handle);
+  v4l1_close (s->fd);
+  free (s);
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  V4L_Scanner *s = handle;
+
+  if ((unsigned) option >= NUM_OPTIONS || option < 0)
+    return 0;
+  DBG (4, "sane_get_option_descriptor: option %d (%s)\n", option,
+       s->opt[option].name ? s->opt[option].name : s->opt[option].title);
+  return s->opt + option;
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+		     SANE_Action action, void *val, SANE_Int * info)
+{
+  V4L_Scanner *s = handle;
+  SANE_Status status;
+  SANE_Word cap;
+
+  if (info)
+    *info = 0;
+
+  if (option >= NUM_OPTIONS || option < 0)
+    return SANE_STATUS_INVAL;
+
+  DBG (4, "sane_control_option: %s option %d (%s)\n",
+       action == SANE_ACTION_GET_VALUE ? "get" :
+       action == SANE_ACTION_SET_VALUE ? "set" :
+       action == SANE_ACTION_SET_AUTO ? "auto set" :
+       "(unknow action with)", option,
+       s->opt[option].name ? s->opt[option].name : s->opt[option].title);
+
+  cap = s->opt[option].cap;
+
+  if (!SANE_OPTION_IS_ACTIVE (cap))
+    {
+      DBG (1, "sane_control option: option is inactive\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (action == SANE_ACTION_GET_VALUE)
+    {
+      switch (option)
+	{
+	  /* word options: */
+	case OPT_NUM_OPTS:
+	case OPT_TL_X:
+	case OPT_TL_Y:
+	case OPT_BR_X:
+	case OPT_BR_Y:
+	case OPT_BRIGHTNESS:
+	case OPT_HUE:
+	case OPT_COLOR:
+	case OPT_CONTRAST:
+	case OPT_WHITE_LEVEL:
+	  *(SANE_Word *) val = s->val[option].w;
+	  return SANE_STATUS_GOOD;
+	case OPT_CHANNEL:	/* string list options */
+	case OPT_MODE:
+	  strcpy (val, s->val[option].s);
+	  return SANE_STATUS_GOOD;
+	default:
+	  DBG (1, "sane_control_option: option %d unknown\n", option);
+	}
+    }
+  else if (action == SANE_ACTION_SET_VALUE)
+    {
+      if (!SANE_OPTION_IS_SETTABLE (cap))
+	{
+	  DBG (1, "sane_control_option: option is not settable\n");
+	  return SANE_STATUS_INVAL;
+	}
+      status = sanei_constrain_value (s->opt + option, val, info);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG (1, "sane_control_option: sanei_constarin_value failed: %s\n",
+	       sane_strstatus (status));
+	  return status;
+	}
+      if (option >= OPT_TL_X && option <= OPT_BR_Y)
+	{
+	  s->user_corner |= 1 << (option - OPT_TL_X);
+	  if (-1 == v4l1_ioctl (s->fd, VIDIOCGWIN, &s->window))
+	    {
+	      DBG (1, "sane_control_option: ioctl VIDIOCGWIN failed "
+		   "(can not get window geometry)\n");
+	      return SANE_STATUS_INVAL;
+	    }
+	  s->window.clipcount = 0;
+	  s->window.clips = 0;
+	  s->window.height = parms.lines;
+	  s->window.width = parms.pixels_per_line;
+	}
+
+
+      switch (option)
+	{
+	  /* (mostly) side-effect-free word options: */
+	case OPT_TL_X:
+	  break;
+	case OPT_TL_Y:
+	  break;
+	case OPT_BR_X:
+	  s->window.width = *(SANE_Word *) val;
+	  parms.pixels_per_line = *(SANE_Word *) val;
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_PARAMS;
+	  break;
+	case OPT_BR_Y:
+	  s->window.height = *(SANE_Word *) val;
+	  parms.lines = *(SANE_Word *) val;
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_PARAMS;
+	  break;
+	case OPT_MODE:
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+	  s->val[option].s = strdup (val);
+	  if (!s->val[option].s)
+	    return SANE_STATUS_NO_MEM;
+	  if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_GRAY) == 0)
+	    s->pict.palette = VIDEO_PALETTE_GREY;
+	  else
+	    s->pict.palette = VIDEO_PALETTE_RGB24;
+	  update_parameters (s);
+	  break;
+	case OPT_BRIGHTNESS:
+	  s->pict.brightness = *(SANE_Word *) val *256;
+	  s->val[option].w = *(SANE_Word *) val;
+	  break;
+	case OPT_HUE:
+	  s->pict.hue = *(SANE_Word *) val *256;
+	  s->val[option].w = *(SANE_Word *) val;
+	  break;
+	case OPT_COLOR:
+	  s->pict.colour = *(SANE_Word *) val *256;
+	  s->val[option].w = *(SANE_Word *) val;
+	  break;
+	case OPT_CONTRAST:
+	  s->pict.contrast = *(SANE_Word *) val *256;
+	  s->val[option].w = *(SANE_Word *) val;
+	  break;
+	case OPT_WHITE_LEVEL:
+	  s->pict.whiteness = *(SANE_Word *) val *256;
+	  s->val[option].w = *(SANE_Word *) val;
+	  break;
+	case OPT_CHANNEL:
+	  {
+	    int i;
+	    struct video_channel channel;
+
+	    s->val[option].s = strdup (val);
+	    if (!s->val[option].s)
+	      return SANE_STATUS_NO_MEM;
+	    for (i = 0; i < MAX_CHANNELS; i++)
+	      {
+		if (strcmp (s->channel[i], val) == 0)
+		  {
+		    channel.channel = i;
+		    if (-1 == v4l1_ioctl (s->fd, VIDIOCGCHAN, &channel))
+		      {
+			DBG (1, "sane_open: can't ioctl VIDIOCGCHAN %s: %s\n",
+			     s->devicename, strerror (errno));
+			return SANE_STATUS_INVAL;
+		      }
+		    if (-1 == v4l1_ioctl (s->fd, VIDIOCSCHAN, &channel))
+		      {
+			DBG (1, "sane_open: can't ioctl VIDIOCSCHAN %s: %s\n",
+			     s->devicename, strerror (errno));
+			return SANE_STATUS_INVAL;
+		      }
+		    break;
+		  }
+	      }
+	    return SANE_STATUS_GOOD;
+	    break;
+	  }
+	default:
+	  DBG (1, "sane_control_option: option %d unknown\n", option);
+	  return SANE_STATUS_INVAL;
+	}
+      if (option >= OPT_TL_X && option <= OPT_BR_Y)
+	{
+	  if (-1 == v4l1_ioctl (s->fd, VIDIOCSWIN, &s->window))
+	    {
+	      DBG (1, "sane_control_option: ioctl VIDIOCSWIN failed (%s)\n",
+		   strerror (errno));
+	      /* return SANE_STATUS_INVAL; */
+	    }
+	  if (-1 == v4l1_ioctl (s->fd, VIDIOCGWIN, &s->window))
+	    {
+	      DBG (1, "sane_control_option: ioctl VIDIOCGWIN failed (%s)\n",
+		   strerror (errno));
+	      return SANE_STATUS_INVAL;
+	    }
+	}
+      if (option >= OPT_BRIGHTNESS && option <= OPT_WHITE_LEVEL)
+	{
+	  if (-1 == v4l1_ioctl (s->fd, VIDIOCSPICT, &s->pict))
+	    {
+	      DBG (1, "sane_control_option: ioctl VIDIOCSPICT failed (%s)\n",
+		   strerror (errno));
+	      /* return SANE_STATUS_INVAL; */
+	    }
+	}
+      return SANE_STATUS_GOOD;
+    }
+  else if (action == SANE_ACTION_SET_AUTO)
+    {
+      if (!(cap & SANE_CAP_AUTOMATIC))
+	{
+	  DBG (1, "sane_control_option: option can't be set automatically\n");
+	  return SANE_STATUS_INVAL;
+	}
+      switch (option)
+	{
+	case OPT_BRIGHTNESS:
+	  /* not implemented yet */
+	  return SANE_STATUS_GOOD;
+
+	default:
+	  break;
+	}
+    }
+  return SANE_STATUS_INVAL;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  V4L_Scanner *s = handle;
+
+  DBG (4, "sane_get_parameters\n");
+  update_parameters (s);
+  if (params == 0)
+    {
+      DBG (1, "sane_get_parameters: params == 0\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (-1 == v4l1_ioctl (s->fd, VIDIOCGWIN, &s->window))
+    {
+      DBG (1, "sane_control_option: ioctl VIDIOCGWIN failed "
+	   "(can not get window geometry)\n");
+      return SANE_STATUS_INVAL;
+    }
+  parms.pixels_per_line = s->window.width;
+  parms.bytes_per_line = s->window.width;
+  if (parms.format == SANE_FRAME_RGB)
+    parms.bytes_per_line = s->window.width * 3;
+  parms.lines = s->window.height;
+  *params = parms;
+  return SANE_STATUS_GOOD;
+
+}
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  int len, loop;
+  V4L_Scanner *s;
+  char data;
+
+  DBG (2, "sane_start\n");
+  for (s = first_handle; s; s = s->next)
+    {
+      if (s == handle)
+	break;
+    }
+  if (!s)
+    {
+      DBG (1, "sane_start: bad handle %p\n", handle);
+      return SANE_STATUS_INVAL;	/* oops, not a handle we know about */
+    }
+  len = v4l1_ioctl (s->fd, VIDIOCGCAP, &s->capability);
+  if (-1 == len)
+    {
+      DBG (1, "sane_start: can not get capabilities\n");
+      return SANE_STATUS_INVAL;
+    }
+  s->buffercount = 0;
+  if (-1 == v4l1_ioctl (s->fd, VIDIOCGMBUF, &s->mbuf))
+    {
+      s->is_mmap = SANE_FALSE;
+      buffer =
+	malloc (s->capability.maxwidth * s->capability.maxheight *
+		s->pict.depth);
+      if (0 == buffer)
+	return SANE_STATUS_NO_MEM;
+      DBG (3, "sane_start: V4L trying to read frame\n");
+      len = v4l1_read (s->fd, buffer, parms.bytes_per_line * parms.lines);
+      DBG (3, "sane_start: %d bytes read\n", len);
+    }
+  else
+    {
+      s->is_mmap = SANE_TRUE;
+      DBG (3,
+	   "sane_start: mmap frame, buffersize: %d bytes, buffers: %d, offset 0 %d\n",
+	   s->mbuf.size, s->mbuf.frames, s->mbuf.offsets[0]);
+      buffer =
+	v4l1_mmap (0, s->mbuf.size, PROT_READ | PROT_WRITE, MAP_SHARED, s->fd, 0);
+      if (buffer == (void *)-1)
+	{
+	  DBG (1, "sane_start: mmap failed: %s\n", strerror (errno));
+	  buffer = NULL;
+	  return SANE_STATUS_IO_ERROR;
+	}
+      DBG (3, "sane_start: mmapped frame, capture 1 pict into %p\n", buffer);
+      s->mmap.frame = 0;
+      s->mmap.width = s->window.width;
+      /*   s->mmap.width = parms.pixels_per_line;  ??? huh? */
+      s->mmap.height = s->window.height;
+      /*      s->mmap.height = parms.lines;  ??? huh? */
+      s->mmap.format = s->pict.palette;
+      DBG (2, "sane_start: mmapped frame %d x %d with palette %d\n",
+	   s->mmap.width, s->mmap.height, s->mmap.format);
+
+      /* We need to loop here to empty the read buffers, so we don't
+         get a stale image */
+      for (loop = 0; loop <= s->mbuf.frames; loop++)
+        {
+          len = v4l1_ioctl (s->fd, VIDIOCMCAPTURE, &s->mmap);
+          if (len == -1)
+	    {
+	      DBG (1, "sane_start: ioctl VIDIOCMCAPTURE failed: %s\n",
+	           strerror (errno));
+	      return SANE_STATUS_INVAL;
+	    }
+          DBG (3, "sane_start: waiting for frame %x, loop %d\n", s->mmap.frame, loop);
+          len = v4l1_ioctl (s->fd, VIDIOCSYNC, &(s->mmap.frame));
+          if (-1 == len)
+	    {
+	      DBG (1, "sane_start: call to ioctl(%d, VIDIOCSYNC, ..) failed\n",
+	           s->fd);
+	      return SANE_STATUS_INVAL;
+	    }
+        }
+      DBG (3, "sane_start: frame %x done\n", s->mmap.frame);
+    }
+
+  /* v4l1 actually returns BGR when we ask for RGB, so convert it */
+  if (s->pict.palette == VIDEO_PALETTE_RGB24)
+    {
+      DBG (3, "sane_start: converting from BGR to RGB\n");
+      for (loop = 0; loop < (s->window.width * s->window.height * 3); loop += 3)
+        {
+          data = *(buffer + loop);
+          *(buffer + loop) = *(buffer + loop + 2);
+          *(buffer + loop + 2) = data;
+        }
+    }
+
+  DBG (3, "sane_start: done\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
+	   SANE_Int * lenp)
+{
+  int i, min;
+  V4L_Scanner *s = handle;
+
+  DBG (4, "sane_read: max_len = %d\n", max_len);
+  if (!lenp)
+    {
+      DBG (1, "sane_read: lenp == 0\n");
+      return SANE_STATUS_INVAL;
+    }
+  if ((s->buffercount + 1) > (parms.lines * parms.bytes_per_line))
+    {
+      *lenp = 0;
+      return SANE_STATUS_EOF;
+    };
+  min = parms.lines * parms.bytes_per_line;
+  if (min > (max_len + s->buffercount))
+    min = (max_len + s->buffercount);
+  if (s->is_mmap == SANE_FALSE)
+    {
+      for (i = s->buffercount; i < (min + 0); i++)
+	{
+	  *(buf + i - s->buffercount) = *(buffer + i);
+	};
+      *lenp = (parms.lines * parms.bytes_per_line - s->buffercount);
+      if (max_len < *lenp)
+	*lenp = max_len;
+      DBG (3, "sane_read: transferred %d bytes (from %d to %d)\n", *lenp,
+	   s->buffercount, i);
+      s->buffercount = i;
+    }
+  else
+    {
+      for (i = s->buffercount; i < (min + 0); i++)
+	{
+	  *(buf + i - s->buffercount) = *(buffer + i);
+	};
+      *lenp = (parms.lines * parms.bytes_per_line - s->buffercount);
+      if ((i - s->buffercount) < *lenp)
+	*lenp = (i - s->buffercount);
+      DBG (3, "sane_read: transferred %d bytes (from %d to %d)\n", *lenp,
+	   s->buffercount, i);
+      s->buffercount = i;
+    }
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  V4L_Scanner *s = handle;
+
+  DBG (2, "sane_cancel\n");
+
+  /* ??? buffer isn't checked in sane_read? */
+  if (buffer)
+    {
+      if (s->is_mmap)
+	v4l1_munmap(buffer, s->mbuf.size);
+      else
+	free (buffer);
+
+      buffer = NULL;
+    }
+}
+
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  /* Avoid compile warning */
+  handle = 0;
+
+  if (non_blocking == SANE_FALSE)
+    return SANE_STATUS_GOOD;
+  return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+  /* Avoid compile warning */
+  handle = 0;
+  fd = 0;
+
+  return SANE_STATUS_UNSUPPORTED;
+}