Initial import of sane-backends version 1.0.24-1.2

1 files changed, 313 insertions, 0 deletions

diff --git a/backend/sm3600-color.c b/backend/sm3600-color.c
new file mode 100644
index 0000000..9b3c540
--- /dev/null
+++ b/backend/sm3600-color.c
@@ -0,0 +1,313 @@
+/* sane - Scanner Access Now Easy.
+   Copyright (C) Marian Eichholz 2001
+   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.
+*/
+
+/* ======================================================================
+
+Userspace scan tool for the Microtek 3600 scanner
+
+color scan routine
+
+(C) Marian Eichholz 2001
+
+====================================================================== */
+
+#include "sm3600-scantool.h"
+
+#define ORDER_RGB             "012"
+#define ORDER_BRG             "120"
+
+/* **********************************************************************
+
+ReadNextColorLine()
+
+********************************************************************** */
+
+static TState ReadNextColorLine(PTInstance this)
+{
+  int           iWrite,i;
+  int           iRead; /* read position in raw line */
+  int           nInterpolator;
+  int           iOffsetR,iOffsetG,iOffsetB;
+  short        *pchLineSwap;
+  TBool         bVisible;
+
+  bVisible=false;
+  do {
+      iWrite=0;
+      while (iWrite<3*this->state.cxMax) /* max 1 time in reality */
+	{
+	  while (iWrite<3*this->state.cxMax &&
+		 this->state.iBulkReadPos<this->state.cchBulk)
+	    this->state.ppchLines[0][iWrite++] =
+	      this->state.pchBuf[this->state.iBulkReadPos++];
+	  if (iWrite<3*this->state.cxMax) /* we need an additional chunk */
+	    {
+	      if (this->state.bLastBulk)
+		return SANE_STATUS_EOF;
+	      this->state.cchBulk=BulkReadBuffer(this,this->state.pchBuf,
+						 USB_CHUNK_SIZE);
+	      dprintf(DEBUG_SCAN,"bulk read: %d byte(s), line #%d\n",
+		      this->state.cchBulk, this->state.iLine);
+	      if (this->bWriteRaw)
+		fwrite(this->state.pchBuf,1,this->state.cchBulk,this->fhScan);
+	      INST_ASSERT();
+	      if (this->state.cchBulk!=USB_CHUNK_SIZE)
+		this->state.bLastBulk=true;
+	      this->state.iBulkReadPos=0;
+	    }
+	} /* while raw line buffer acquiring */
+      this->state.iLine++;
+      if (this->state.iLine>2*this->state.ySensorSkew)
+	{
+	  bVisible=true;
+	  iOffsetR=(this->state.szOrder[0]-'0')*this->state.cxMax;
+	  iOffsetG=(this->state.szOrder[1]-'0')*this->state.cxMax;
+	  iOffsetB=(this->state.szOrder[2]-'0')*this->state.cxMax;
+	  for (nInterpolator=100, iWrite=0, iRead=0;
+	       iRead<3*this->state.cxMax && iWrite<this->state.cchLineOut;
+	       iRead++)
+	    {
+	      nInterpolator+=this->state.nFixAspect;
+	      if (nInterpolator<100) continue; /* res. reduction */
+	      nInterpolator-=100;
+	      /* dprintf(DEBUG_SCAN," i=%d",iTo); */
+	      /* the first scan lines only fill the line backlog buffer */
+	      {
+		/* dprintf(DEBUG_SCAN,"assembling line %d\n",++this->state.iLine); */
+		this->state.pchLineOut[iWrite++]=
+		  this->state.ppchLines[2*this->state.ySensorSkew][iRead+iOffsetR];
+		this->state.pchLineOut[iWrite++]=
+		  this->state.ppchLines[1*this->state.ySensorSkew][iRead+iOffsetG];
+		this->state.pchLineOut[iWrite++]=
+		  this->state.ppchLines[0*this->state.ySensorSkew][iRead+iOffsetB];
+	      }
+	    }
+	} /* if visible line */
+      /* cycle backlog buffers */
+      pchLineSwap=this->state.ppchLines[this->state.cBacklog-1];
+      for (i=this->state.cBacklog-2; i>=0; i--)
+	this->state.ppchLines[i+1]=this->state.ppchLines[i];
+      this->state.ppchLines[0]=pchLineSwap;
+  } while (!bVisible);
+  return SANE_STATUS_GOOD;
+}
+
+/* ======================================================================
+
+StartScanColor()
+
+====================================================================== */
+
+/* Parameter are in resolution units! */
+__SM3600EXPORT__
+TState StartScanColor(TInstance *this)
+{
+
+  /* live could be easy: Simple calculate a window, start the scan,
+     get the data and get off. It dimply does not work.  We have to
+     deal with the fact, that the pixels are reported with color scan
+     line by color scan line, and have to be rearranged to RGB
+     triples. They even ar enot always in RGB order, but mostly in BRG
+     order. And they have a skew of 2/300 inch , given by the slider
+     construction.  Thus, we have to deal with several buffers, some
+     interpolation, and related management stuff. */
+  int             i;
+  if (this->state.bScanning)
+    return SetError(this,SANE_STATUS_DEVICE_BUSY,"scan active");
+  memset(&(this->state),0,sizeof(this->state));
+  this->state.ReadProc  =ReadNextColorLine;
+  this->state.ySensorSkew=0;
+
+  GetAreaSize(this);
+
+  switch (this->param.res)
+    {
+    case 200: this->state.ySensorSkew=1; break;
+    case 300: this->state.ySensorSkew=2; break;
+    case 600: this->state.ySensorSkew=4; break;
+    default: break;
+    }
+  /* since we need 2*this->state.ySensorSkew additional scan lines for de-skewing of
+     the sensor lines, we enlarge the window and shorten the initial movement
+     accordingly */
+  this->state.cyTotalPath =
+    this->param.y/2-(2*this->state.ySensorSkew)*600/this->param.res;
+  DoJog(this,this->state.cyTotalPath); INST_ASSERT();
+  this->state.cyTotalPath += 
+    (this->state.cyPixel+2*this->state.ySensorSkew)
+    *600/this->param.res; /* for jogging back */
+
+  /*
+    regular scan is asynchronously, that is,
+    the scanning is issued, and the driver does bulk reads,
+    until there are no data left.
+    Each line has a full R, G and B subline, 8bit each sample.
+  */
+  {
+    unsigned char uchRegs[]={
+      0xFC /*!!R_SPOS!!*/, 0x00 /*R_SPOSH*/, 0x24 /*!!0x03!!*/,
+      0xB0 /*!!R_SWID!!*/, 0xC4 /*!!R_SWIDH!!*/,
+      1,0,
+      0xFF /*!!0x08!!*/, 0xFF /*!!0x09!!*/,
+      0x22 /*!!R_LEN!!*/, 0x07 /*!!R_LENH!!*/, 0x6D /*0x0C*/,
+      0x70 /*0x0D*/, 0x69 /*0x0E*/, 0xD0 /*0x0F*/,
+      0x00 /*0x10*/, 0x00 /*0x11*/, 0x42 /*!!0x12!!*/,
+      0x15 /*0x13*/, 0x84 /*!!0x14!!*/, 0x2A /*0x15*/,
+      0xC5 /*!!0x16!!*/, 0x40 /*0x17*/, 0xC5 /*!!0x18!!*/,
+      0x40 /*0x19*/, 0xFF /*0x1A*/, 0x01 /*0x1B*/,
+      0x88 /*0x1C*/, 0x40 /*0x1D*/, 0x4C /*0x1E*/,
+      0x50 /*0x1F*/, 0x00 /*0x20*/, 0x0C /*0x21*/,
+      0x21 /*0x22*/, 0xF0 /*0x23*/, 0x40 /*0x24*/,
+      0x00 /*0x25*/, 0x0A /*0x26*/, 0xF0 /*0x27*/,
+      0x00 /*0x28*/, 0x00 /*0x29*/, 0x4E /*0x2A*/,
+      0xF0 /*0x2B*/, 0x00 /*0x2C*/, 0x00 /*0x2D*/,
+      0x4E /*0x2E*/, 0x80 /*R_CCAL*/, 0x80 /*R_CCAL2*/,
+      0x80 /*R_CCAL3*/, 0x0B /*0x32*/, 0x2D /*0x33*/,
+      0x43 /*!!0x34!!*/, 0x29 /*0x35*/, 0x00 /*0x36*/,
+      0x00 /*0x37*/, 0x00 /*0x38*/, 0x00 /*0x39*/,
+      0x00 /*0x3A*/, 0x00 /*0x3B*/, 0xFF /*0x3C*/,
+      0x0F /*0x3D*/, 0x00 /*0x3E*/, 0x00 /*0x3F*/,
+      0x01 /*0x40*/, 0x00 /*0x41*/, 0x80 /*R_CSTAT*/,
+      0x03 /*0x43*/, 0x01 /*R_LMP*/, 0x00 /*0x45*/,
+      0x39 /*R_CTL*/, 0xC5 /*!!0x47!!*/, 0x40 /*0x48*/,
+      0x9E /*0x49*/, 0x8C /*0x4A*/ };
+    RegWriteArray(this,R_ALL, NUM_SCANREGS, uchRegs);
+    RegWrite(this,R_SPOS, 2, this->param.x/2 + this->calibration.xMargin);
+    RegWrite(this,R_SLEN, 2,
+	     this->state.cyWindow+
+	     (2*this->state.ySensorSkew)*600/this->param.res);
+    this->state.szOrder=ORDER_BRG; 
+    RegWrite(this,R_CCAL, 3, this->calibration.rgbBias); INST_ASSERT(); /* 0xBBGGRR */
+    switch (this->param.res)
+      {
+      case 75:
+	RegWrite(this,R_XRES,1, 0x20); /* ups, can  do only 100 dpi horizontal */
+	RegWrite(this,R_SWID, 2, 0xC000 | this->state.cxWindow);
+	RegWrite(this,0x34, 1, 0x83); /* halfs the vertical resolution */
+	RegWrite(this,0x47,1,0xC0); /* reduces the speed a bit */
+	break;
+      case 100:
+	RegWrite(this,R_XRES,1, 0x20);
+	RegWrite(this,R_SWID, 2, 0xC000 | this->state.cxWindow);
+	RegWrite(this,0x34, 1, 0x63); /* halfs the vertical resolution */
+	RegWrite(this,0x47,1,0xC0); /* reduces the speed a bit */
+	/* I have no idea, what these differences are good for. The seem to produce
+	   a slight blue presence.
+	   RegWrite(this,0x16, 1, 0xC0);  RegWrite(this,0x18, 1, 0xC0);
+	   RegWrite(this,0x12, 1, 0x40);  RegWrite(this,0x10, 2, 0x0728);
+	   RegWrite(this,0x14, 1, 0x80); */
+	break;
+      case 200:
+	RegWrite(this,R_XRES,1, 0x24);
+	RegWrite(this,R_SWID, 2, 0xC000 | this->state.cxWindow);
+	break;
+      case 300:
+	RegWrite(this,0x08,2, 0x6A6A);
+	RegWrite(this,R_XRES,1, 0x2A);
+	RegWrite(this,R_SWID, 2, 0x4000 | this->state.cxWindow);
+	RegWrite(this,0x34, 1, 0x03); /* halfs the vertical resolution */
+	RegWrite(this,0x47,1,0xC0); /* reduces the speed a bit */
+	this->state.szOrder=ORDER_RGB;
+	break;
+      case 600:
+	RegWrite(this,R_XRES,1, 0x3F);
+	RegWrite(this,R_SWID, 2, 0xC000 | this->state.cxWindow);
+	RegWrite(this,0x34, 1, 0x03); /* halfs the vertical resolution */
+	RegWrite(this,0x47,1,0xC2); /* reduces the speed a bit */
+	break;
+      case 1200:
+	/* not supported, since the driver supports only 600 dpi in color */
+	break;
+      }
+  }
+
+  /* setup gamma tables */
+  RegWrite(this,0x41,1,0x03); /* gamma, RGB */
+  RegWrite(this,0x40,1,0x28); /* offset FIFO 8*3 (GAMMA)+16 KB(gain) spared */
+  /*
+    hey, surprise: Although the color lines are sent in a strange order,
+    the gamma tables are mapped constantly to the sensors (i.e. RGB)
+  */
+  UploadGammaTable(this,0x0000,this->agammaR);
+  UploadGammaTable(this,0x2000,this->agammaG);
+  UploadGammaTable(this,0x4000,this->agammaB);
+  INST_ASSERT();
+
+  UploadGainCorrection(this,0x6000);
+  INST_ASSERT();
+
+  /* enough for 1/100 inch sensor distance */
+  this->state.cBacklog=1+2*this->state.ySensorSkew;
+
+  /* allocate raw line buffers */
+  this->state.ppchLines=calloc(this->state.cBacklog,sizeof(short*));
+  this->state.pchBuf=malloc(0x8000);
+  if (!this->state.ppchLines || !this->state.pchBuf)
+    return FreeState(this,SetError(this,
+				   SANE_STATUS_NO_MEM,"no buffers available"));
+
+  for (i=0; i<this->state.cBacklog; i++)
+  {
+    this->state.ppchLines[i]=calloc(1,3*this->state.cxMax*sizeof(short)); /* must be less than 0x8000 */
+    if (!this->state.ppchLines[i])
+      return FreeState(this,
+		       SetError(this,SANE_STATUS_NO_MEM,
+				"no line buffer available"));
+  }
+
+  /* calculate and prepare intermediate line transfer buffer */
+  
+  this->state.cchLineOut=3*this->state.cxPixel;
+  this->state.pchLineOut = malloc(this->state.cchLineOut);
+  if (!this->state.pchLineOut)
+    return FreeState(this,SetError(this,
+				   SANE_STATUS_NO_MEM,
+				   "no buffers available"));
+
+  RegWrite(this,R_CTL, 1, 0x39);    /* #1532[005.0] */
+  RegWrite(this,R_CTL, 1, 0x79);    /* #1533[005.0] */
+  RegWrite(this,R_CTL, 1, 0xF9);    /* #1534[005.0] */
+  INST_ASSERT();
+
+  this->state.bScanning = true;
+  return SANE_STATUS_GOOD;
+}
+