Initial import of sane-backends version 1.0.24-1.2

1 files changed, 456 insertions, 0 deletions

diff --git a/backend/kvs1025.c b/backend/kvs1025.c
new file mode 100644
index 0000000..c0e1fa3
--- /dev/null
+++ b/backend/kvs1025.c
@@ -0,0 +1,456 @@
+/*
+   Copyright (C) 2008, Panasonic Russia Ltd.
+   Copyright (C) 2010-2011, m. allan noah
+*/
+/* sane - Scanner Access Now Easy.
+   Panasonic KV-S1020C / KV-S1025C USB scanners.
+*/
+
+#define DEBUG_NOT_STATIC
+
+#include "../include/sane/config.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.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 "../include/sane/sane.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/sanei_usb.h"
+#include "../include/sane/sanei_backend.h"
+#include "../include/sane/sanei_config.h"
+#include "../include/lassert.h"
+
+#include "kvs1025.h"
+#include "kvs1025_low.h"
+
+#include "../include/sane/sanei_debug.h"
+
+/* SANE backend operations, see Sane standard 1.04 documents (sane_dev.pdf)
+   for details */
+
+/* Init the KV-S1025 SANE backend. This function must be called before any other
+   SANE function can be called. */
+SANE_Status
+sane_init (SANE_Int * version_code,
+	   SANE_Auth_Callback __sane_unused__ authorize)
+{
+  SANE_Status status;
+
+  DBG_INIT ();
+
+  DBG (DBG_sane_init, "sane_init\n");
+
+  DBG (DBG_error,
+       "This is panasonic KV-S1020C / KV-S1025C version %d.%d build %d\n",
+       V_MAJOR, V_MINOR, V_BUILD);
+
+  if (version_code)
+    {
+      *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, V_BUILD);
+    }
+
+  /* Initialize USB */
+  sanei_usb_init ();
+
+  status = kv_enum_devices ();
+  if (status)
+    return status;
+
+  DBG (DBG_proc, "sane_init: leave\n");
+  return SANE_STATUS_GOOD;
+}
+
+/* Terminate the KV-S1025 SANE backend */
+void
+sane_exit (void)
+{
+  DBG (DBG_proc, "sane_exit: enter\n");
+
+  kv_exit ();
+
+  DBG (DBG_proc, "sane_exit: exit\n");
+}
+
+/* Get device list */
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list,
+		  SANE_Bool __sane_unused__ local_only)
+{
+  DBG (DBG_proc, "sane_get_devices: enter\n");
+  kv_get_devices_list (device_list);
+  DBG (DBG_proc, "sane_get_devices: leave\n");
+  return SANE_STATUS_GOOD;
+}
+
+/* Open device, return the device handle */
+SANE_Status
+sane_open (SANE_String_Const devicename, SANE_Handle * handle)
+{
+  return kv_open_by_name (devicename, handle);
+}
+
+/* Close device */
+void
+sane_close (SANE_Handle handle)
+{
+  DBG (DBG_proc, "sane_close: enter\n");
+  kv_close ((PKV_DEV) handle);
+  DBG (DBG_proc, "sane_close: leave\n");
+}
+
+/* Get option descriptor */
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  return kv_get_option_descriptor ((PKV_DEV) handle, option);
+}
+
+/* Control option */
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+		     SANE_Action action, void *val, SANE_Int * info)
+{
+  return kv_control_option ((PKV_DEV) handle, option, action, val, info);
+}
+
+/* Get scan parameters */
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  PKV_DEV dev = (PKV_DEV) handle;
+
+  int side = dev->current_side == SIDE_FRONT ? 0 : 1;
+
+  DBG (DBG_proc, "sane_get_parameters: enter\n");
+
+  if (!(dev->scanning))
+    {
+      /* Setup the parameters for the scan. (guessed value) */
+      int resolution = dev->val[OPT_RESOLUTION].w;
+      int width, length, depth = kv_get_depth (kv_get_mode (dev));;
+
+      DBG (DBG_proc, "sane_get_parameters: initial settings\n");
+      kv_calc_paper_size (dev, &width, &length);
+
+      DBG (DBG_error, "Resolution = %d\n", resolution);
+      DBG (DBG_error, "Paper width = %d, height = %d\n", width, length);
+
+      /* Prepare the parameters for the caller. */
+      dev->params[0].format = kv_get_mode (dev) == SM_COLOR ?
+	SANE_FRAME_RGB : SANE_FRAME_GRAY;
+
+      dev->params[0].last_frame = SANE_TRUE;
+      dev->params[0].pixels_per_line = ((width * resolution) / 1200) & (~0xf);
+
+      dev->params[0].depth = depth > 8 ? 8 : depth;
+
+      dev->params[0].bytes_per_line =
+	(dev->params[0].pixels_per_line / 8) * depth;
+      dev->params[0].lines = (length * resolution) / 1200;
+
+      memcpy (&dev->params[1], &dev->params[0], sizeof (SANE_Parameters));
+    }
+
+  /* Return the current values. */
+  if (params)
+    *params = (dev->params[side]);
+
+  DBG (DBG_proc, "sane_get_parameters: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+/* Start scanning */
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  SANE_Status status;
+  PKV_DEV dev = (PKV_DEV) handle;
+  SANE_Bool dev_ready;
+  KV_CMD_RESPONSE rs;
+
+  DBG (DBG_proc, "sane_start: enter\n");
+  if (!dev->scanning)
+    {
+      /* open device */
+      if (!kv_already_open (dev))
+	{
+	  DBG (DBG_proc, "sane_start: need to open device\n");
+	  status = kv_open (dev);
+	  if (status)
+	    {
+	      return status;
+	    }
+	}
+      /* Begin scan */
+      DBG (DBG_proc, "sane_start: begin scan\n");
+
+      /* Get necessary parameters */
+      sane_get_parameters (dev, NULL);
+
+      dev->current_page = 0;
+      dev->current_side = SIDE_FRONT;
+
+      /* The scanner must be ready. */
+      status = CMD_test_unit_ready (dev, &dev_ready);
+      if (status || !dev_ready)
+	{
+	  return SANE_STATUS_DEVICE_BUSY;
+	}
+
+      if (!strcmp (dev->val[OPT_MANUALFEED].s, "off"))
+	{
+	  status = CMD_get_document_existanse (dev);
+	  if (status)
+	    {
+	      DBG (DBG_proc, "sane_start: exit with no more docs\n");
+	      return status;
+	    }
+	}
+
+      /* Set window */
+      status = CMD_reset_window (dev);
+      if (status)
+	{
+	  return status;
+	}
+
+      status = CMD_set_window (dev, SIDE_FRONT, &rs);
+      if (status)
+	{
+	  DBG (DBG_proc, "sane_start: error setting window\n");
+	  return status;
+	}
+
+      if (rs.status)
+	{
+	  DBG (DBG_proc, "sane_start: error setting window\n");
+	  DBG (DBG_proc,
+	       "sane_start: sense_key=0x%x, ASC=0x%x, ASCQ=0x%x\n",
+	       get_RS_sense_key (rs.sense),
+	       get_RS_ASC (rs.sense), get_RS_ASCQ (rs.sense));
+	  return SANE_STATUS_DEVICE_BUSY;
+	}
+
+      if (IS_DUPLEX (dev))
+	{
+	  status = CMD_set_window (dev, SIDE_BACK, &rs);
+
+	  if (status)
+	    {
+	      DBG (DBG_proc, "sane_start: error setting window\n");
+	      return status;
+	    }
+	  if (rs.status)
+	    {
+	      DBG (DBG_proc, "sane_start: error setting window\n");
+	      DBG (DBG_proc,
+		   "sane_start: sense_key=0x%x, "
+		   "ASC=0x%x, ASCQ=0x%x\n",
+		   get_RS_sense_key (rs.sense),
+		   get_RS_ASC (rs.sense), get_RS_ASCQ (rs.sense));
+	      return SANE_STATUS_INVAL;
+	    }
+	}
+
+      /* Scan */
+      status = CMD_scan (dev);
+      if (status)
+	{
+	  return status;
+	}
+
+      status = AllocateImageBuffer (dev);
+      if (status)
+	{
+	  return status;
+	}
+      dev->scanning = 1;
+    }
+  else
+    {
+      /* renew page */
+      if (IS_DUPLEX (dev))
+	{
+	  if (dev->current_side == SIDE_FRONT)
+	    {
+	      /* back image data already read, so just return */
+	      dev->current_side = SIDE_BACK;
+	      DBG (DBG_proc, "sane_start: duplex back\n");
+	      status = SANE_STATUS_GOOD;
+              goto cleanup;
+	    }
+	  else
+	    {
+	      dev->current_side = SIDE_FRONT;
+	      dev->current_page++;
+	    }
+	}
+      else
+	{
+	  dev->current_page++;
+	}
+    }
+  DBG (DBG_proc, "sane_start: NOW SCANNING page\n");
+
+  /* Read image data */
+  status = ReadImageData (dev, dev->current_page);
+  if (status)
+    {
+      dev->scanning = 0;
+      return status;
+    }
+
+  /* Get picture element size */
+  {
+    int width, height;
+    status = CMD_read_pic_elements (dev, dev->current_page,
+				    SIDE_FRONT, &width, &height);
+    if (status)
+      return status;
+  }
+
+  if (IS_DUPLEX (dev))
+    {
+      int width, height;
+      status = CMD_read_pic_elements (dev, dev->current_page,
+				      SIDE_BACK, &width, &height);
+      if (status)
+	return status;
+    }
+
+  /* software based enhancement functions from sanei_magic */
+  /* these will modify the image, and adjust the params */
+  /* at this point, we are only looking at the front image */
+  /* of simplex or duplex data, back side has already exited */
+  /* so, we do both sides now, if required */
+  if (dev->val[OPT_SWDESKEW].w){
+    buffer_deskew(dev,SIDE_FRONT);
+  }
+  if (dev->val[OPT_SWCROP].w){
+    buffer_crop(dev,SIDE_FRONT);
+  }
+  if (dev->val[OPT_SWDESPECK].w){
+    buffer_despeck(dev,SIDE_FRONT);
+  }
+  if (dev->val[OPT_SWDEROTATE].w || dev->val[OPT_ROTATE].w){
+    buffer_rotate(dev,SIDE_FRONT);
+  }
+
+  if (IS_DUPLEX (dev)){
+    if (dev->val[OPT_SWDESKEW].w){
+      buffer_deskew(dev,SIDE_BACK);
+    }
+    if (dev->val[OPT_SWCROP].w){
+      buffer_crop(dev,SIDE_BACK);
+    }
+    if (dev->val[OPT_SWDESPECK].w){
+      buffer_despeck(dev,SIDE_BACK);
+    }
+    if (dev->val[OPT_SWDEROTATE].w || dev->val[OPT_ROTATE].w){
+      buffer_rotate(dev,SIDE_BACK);
+    }
+  }
+
+  cleanup:
+
+  /* check if we need to skip this page */
+  if (dev->val[OPT_SWSKIP].w && buffer_isblank(dev,dev->current_side)){
+    DBG (DBG_proc, "sane_start: blank page, recurse\n");
+    return sane_start(handle);
+  }
+
+  DBG (DBG_proc, "sane_start: exit\n");
+  return status;
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf,
+	   SANE_Int max_len, SANE_Int * len)
+{
+  PKV_DEV dev = (PKV_DEV) handle;
+  int side = dev->current_side == SIDE_FRONT ? 0 : 1;
+
+  int size = max_len;
+  if (!dev->scanning)
+    return SANE_STATUS_EOF;
+
+  if (size > dev->img_size[side])
+    size = dev->img_size[side];
+
+  if (size == 0)
+    {
+      *len = size;
+      return SANE_STATUS_EOF;
+    }
+
+  if (dev->val[OPT_INVERSE].w &&
+      (kv_get_mode (dev) == SM_BINARY || kv_get_mode (dev) == SM_DITHER))
+    {
+      int i;
+      unsigned char *p = dev->img_pt[side];
+      for (i = 0; i < size; i++)
+	{
+	  buf[i] = ~p[i];
+	}
+    }
+  else
+    {
+      memcpy (buf, dev->img_pt[side], size);
+    }
+
+  /*hexdump(DBG_error, "img data", buf, 128); */
+
+  dev->img_pt[side] += size;
+  dev->img_size[side] -= size;
+
+  DBG (DBG_proc, "sane_read: %d bytes to read, "
+       "%d bytes read, EOF=%s  %d\n",
+       max_len, size, dev->img_size[side] == 0 ? "True" : "False", side);
+
+  if (len)
+    {
+      *len = size;
+    }
+  if (dev->img_size[side] == 0)
+    {
+      if (!strcmp (dev->val[OPT_FEEDER_MODE].s, "single"))
+	if ((IS_DUPLEX (dev) && side) || !IS_DUPLEX (dev))
+	  dev->scanning = 0;
+    }
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  PKV_DEV dev = (PKV_DEV) handle;
+  DBG (DBG_proc, "sane_cancel: scan canceled.\n");
+  dev->scanning = 0;
+
+  kv_close (dev);
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle h, SANE_Bool m)
+{
+  h=h;
+  m=m;
+  return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle h, SANE_Int * fd)
+{
+  h=h;
+  fd=fd;
+  return SANE_STATUS_UNSUPPORTED;
+}