sane-sharp - SANE backend for SHARP scanners


   The  sane-sharp  library  implements  a  SANE (Scanner Access Now Easy)
   backend that provides access to  Sharp  SCSI  scanners.   This  backend
   should be considered beta-quality software!  In the current state it is
   known to work with JX-610 and JX-250 scanners. It is prepared for usage
   with  the  JX-330  series scanners, but we are not able to test it with
   these devices.

   For other Sharp scanners, it may or may not work.

   At present, the following scanners are known to work with this backend.

          Vendor  Product id:
          -----   -----------
          Sharp   JX-610
          Sharp   JX-250
          Sharp   JX-320
          Sharp   JX-330
          Sharp   JX-350

   The following scanners are detected by the backend, but not tested:

          Vendor  Product id:
          -----   -----------
          Sharp   JX-325


   This backend expects device names of the form:


   Where special is either the  path-name  for  the  special  device  that
   corresponds  to  a  SCSI  scanner.  The  special  device name must be a
   generic SCSI device or a symlink to such a device.  Under Linux, such a
   device   name   could  be  /dev/sga  or  /dev/sge,  for  example.   See
   sane-scsi(5) for details.


   Scan Mode (parameter --mode for scanimage). Possible settings:
          Lineart (1 bit black & white scans),
          Gray (8 bit gray scale scans),
          Lineart Color (bi-level color scans),
          Color (8 bit RGB scans).
   The default value is Color.

   Halftone  Pattern   (parameter   --halftone-pattern   for   scanimage).
   Available only for the JX-330 series scanners.  Possible settings:
          Dither Bayer
          Dither Spiral
          Dither Dispersed
          Error Diffusion
   The default value is none.

   Paper  Source  (parameter  --source for scanimage). This option is only
   available, if an automatic document feeder or a transparency adapter is
   installed. Possible settings:
          Automatic Document Feeder
          Transparency Adapter
   If  an  ADF  or  a  transparency  adapter is installed, using it is the
   default selection.

   Custom Gamma (parameter  --custom-gamma  for  scanimage).  This  option
   determines  whether a builtin or a custom gamma-table is used. Possible
          yes enables custom gamma tables
          no enables a built gamma table

   Gamma (parameter --Gamma for scanimage). This option is only available,
   if Custom Gamma is set to no.  Possible values:
   The default value is 2.2. (The JX-250 and JX-350 have no built in gamma
   correction; for these scanner, a  gamma  table  is  downloaded  to  the
   scanner by the backend.)

   Gamma  Table  (parameter  --gamma-table for scanimage). Allowed values:
   0..255; 256 numbers must be defined.  The default values are 0,  1,  2,
   ..  255  (i.e.,  gamma  ==  1).  This table is only used for gray scale

   Red Gamma Table (parameter --red-gamma-table  for  scanimage).  Allowed
   values: 0..255; 256 numbers must be defined.  The default values are 0,
   1, 2, .. 255 (i.e., gamma == 1).

   Green  Gamma  Table  (parameter  --green-gamma-table  for   scanimage).
   Allowed  values:  0..255;  256  numbers  must  be defined.  The default
   values are 0, 1, 2, .. 255 (i.e., gamma == 1).

   Blue Gamma Table (parameter --blue-gamma-table for scanimage).  Allowed
   values: 0..255; 256 numbers must be defined.  The default values are 0,
   1, 2, .. 255 (i.e., gamma == 1).

   Resolution in pixel per inch (parameter  --resolution  for  scanimage).
   Selects the resolution of the scanned image. Allowed values:
          30..600 (JX-330, JX-350 and JX-610) resp.  30..400 (JX-250)
   The default value is 150.

   Scan Window

   The  possible  settings depend on the scanner model and, for the JX-250
   and the JX-350, also on the usage  of  the  automatic  document  feeder
   resp.  the  transparency adapter. Please refer to the values allowed by
   xscanimage, or xsane.  With  scanimage,  enter  one  of  the  following

          scanimage -d sharp --source "Automatic Document Feeder" --help

          scanimage -d sharp --source Flatbed --help

          scanimage -d sharp --source "Transparency Adapter" --help

   in order to see the allowed parameter values for the scan window.

   The scan window parameters are:

          Top-left x position of scan area (parameter -l for scanimage);
          Top-left y position of scan area (parameter -t for scanimage);
          bottom   right  x  position  of  scan  area  (parameter  -x  for
          bottom  right  y  position  of  scan  area  (parameter  -y   for

   Edge emphasis (parameter --Edge emphasis for scanimage). This option is
   not available for the JX-250 and the JX-350.  Possible settings:
   The default value is None.

   Threshold (parameter --threshold for scanimage). Sets the threshold for
   black and white pixels in lineart mode. Possible values:
   The  default  value is 128.  This option is only available in scan mode

   Threshold Red  (parameter  --threshold-red  for  scanimage).  Sets  the
   threshold  for  the  red  component of a pixel in in lineart color scan
   mode. Possible values:
   The default value is 128.  This option is only available in  scan  mode
   color lineart.

   Threshold  Green  (parameter --threshold-green for scanimage). Sets the
   threshold for the green component of a pixel in in lineart  color  scan
   mode. Possible values:
   The  default  value is 128.  This option is only available in scan mode
   color lineart.

   Threshold Blue (parameter --threshold-blue  for  scanimage).  Sets  the
   threshold  for  the  blue component of a pixel in in lineart color scan
   mode. Possible values:
   The default value is 128.  This option is only available in  scan  mode
   color lineart.

   Light  Color  (parameter --LightColor for scanimage). Sets the color of
   the light source. Possible values:
   The default value is white.  This option  is  only  available  in  scan
   modes lineart color and color.


   If  a  paper  jam  occurred,  the  maintenance cover must be opened and
   closed, even if the jammed paper can be  removed  without  opening  the
   maintenance cover. Otherwise, the error condition cannot be cleared.


   The  contents  of  the  sharp.conf file is a list of options and device
   names  that  correspond  to  Sharp  scanners.  Empty  lines  and  lines
   beginning  with  a  hash  mark  (#)  are  ignored. See sane-scsi(5) for
   details about device names.

   Lines setting an option start with the key word option, followed by the
   option's  name  and  the  option's value. At present, three options are
   defined: buffers, buffersize, and readqueue.

   Options defined at the  start  of  sharp.conf  apply  to  all  devices;
   options defined after a device name apply to this device.

   The  options  buffers and readqueue are only significant if the backend
   has been compiled so that for each scan  a  second  process  is  forked
   (switch  USE_FORK  in  sharp.c ). This process reads the scan data from
   the scanner and writes this data into a block of  shared  memory.   The
   parent process reads the data from this memory block and delivers it to
   the frontend. The options control the size and  usage  of  this  shared
   memory block.

   option  buffers defines the number of buffers used. The smallest number
   allowed is 2.

   option buffersize defines the size of one buffer. Since each buffer  is
   filled  with  a  single  read  command sent to the scanner, its size is
   limited automatically to the size allowed by the operating system or by
   the  Sane  SCSI library for SCSI read commands. A buffer size of 128 kB
   or 256 kB is recommended for scan resolutions of 300 dpi and above.

   option readqueue defines how many read  commands  to  be  sent  to  the
   scanner  are  queued. At present, the Sane SCSI library supports queued
   read commands only for for Linux. For other operating  systems,  option
   readqueue should be set to 0. For Linux, option readqueue should be set
   to 2. Larger values than 2 for option readqueue are not  reasonable  in
   most cases.  option buffers should be greater than option readqueue.

Performance Considerations

   This  section focuses on the problem of stops of the scanner's carriage
   during a scan. Carriage stops  happen  mainly  with  the  JX-250.  This
   scanner  has  obviously  only  a  small internal buffer compared to its
   speed. That means that the backend  must  read  the  data  as  fast  as
   possible from the scanner in order to avoid carriage stops.

   Even  the  JX-250 needs only less than 10 seconds for a 400 dpi A4 gray
   scale scan, which results in a data transfer rate of more than  1.6  MB
   per  second.  This  means that the data produced by the scanner must be
   processed fairly fast. Due to the small internal buffer of the  JX-250,
   the  backend  must issue a read request for the next data block as soon
   as possible after reading a block of data in order  to  avoid  carriage

   Stops of the carriage can be caused by the following reasons:

          - too much "traffic" on the SCSI bus
          - slow responses by the backend to the scanner,
          - a program which processes the data acquired by the backend too

   Too much "traffic" on the SCSI bus: This happens for example,  if  hard
   disks  are connected to the same SCSI bus as the scanner, and when data
   transfer from/to these hard disks requires a considerable part  of  the
   SCSI  bandwidth during a scan. If this is the case, you should consider
   to connect the scanner to a separate SCSI adapter.

   Slow responses by the backend to the scanner: Unfortunately,  Unix-like
   operating systems generally have no real time capabilities.  Thus there
   is no guarantee that the backend is under  any  circumstances  able  to
   communicate  with  the  scanner  as  fast as required. To minimize this
   problem, the backend should be  compiled  so  that  a  separate  reader
   process  is forked: Make sure that USE_FORK is defined when you compile
   sharp.c.  If slow responses of the backend remain to  be  problem,  you
   could  try to reduce the load of the system. Even while the backend and
   the reader process need only a minor amount of  processor  time,  other
   running  processes  can cause an increase in the time delay between two
   time slices given to the reader process. On  slower  systems,  such  an
   increased delay can be enough to cause a carriage stop with the JX-250.
   For Linux, the usage of the  SG  driver  version  2.1.36  or  above  is
   recommended,  because it supports, in combination with the SCSI library
   of Sane version  1.0.2,  command  queueing  within  the  kernel.   This
   queueing  implementation,  combined  with a buffer size of at least 128
   kB, should avoid most carriage stops.

   Slow processing of the scan data: An example for this situation is  the
   access  to  the scanner via a 10 MBit Ethernet, which is definitely too
   slow to transfer the scan data as fast as  they  are  produced  by  the
   scanner.  If  you have enough memory available, you can increase option
   buffers, so that an entire image can be stored in these buffers.

   In order to see,  if  the  backend  is  too  slow  or  if  the  further
   processing  of  the  data  is  too  slow,  set the environment variable
   SANE_DEBUG_SHARP to 1. When a scan is finished, the backend writes  the
   line  "buffer  full  conditions: nn" to stderr. If nn is zero, carriage
   stops are caused by too slow responses  of  the  backend  or  too  much
   "traffic"  on the SCSI bus. If nn is greater than zero, the backend had
   to wait nn times until a buffer has been  processed  by  the  frontend.
   (Please  note that option buffers must be greater than option readqueue
   in order to get useful output for "buffer full conditions".)


          The backend configuration file.

          The static library implementing this backend.

          The shared library implementing this backend (present on systems
          that support dynamic loading).


          If  the  library  was  compiled with debug support enabled, this
          environment variable controls the debug level for this  backend.
          E.g.,  a  value  of 128 requests all debug output to be printed.
          Smaller levels reduce verbosity.


   1. ADF Mode
          After several ADF scans, the scanner moves the carriage back  to
          the  idle  position and back to ADF scan position, before a scan
          starts. We do not know, if this is a problem of the scanner,  or
          if  this  is  a bug of the backend. At present, the scanner must
          power off and on to stop this annoying behaviour.

   2. Threshold level does not work (only JX-610)

   3. The maximum resolution is limited to  600  dpi(JX-610  supported  to
   1200 dpi) resp. 400 dpi (JX-250)

   4. If the JX250 is used with an ADF, the following situation can occur:
   After several scans, the scanner moves, after loading a  new  sheet  of
   paper, the carriage to the idle position, and then back to the position
   used for ADF scans. This happens for every scan,  in  contrast  to  the
   calibration,  which  is  done after 10 scans. (For the calibration, the
   carriage is also moved to the idle position.) We do not know,  if  this
   behavior is caused by the backend, or if it is a bug in the firmware of
   the scanner.

   5. Usage of a transparency adapter (film scan unit) is  supported,  but
   not tested.


   sane(7), sane-scsi(5)


   Kazuya Fukuda, Abel Deuring


   The  Sharp  backend  is  based  on  the Canon backend written by Helmut

   Parts of this man page are a plain  copy  of  sane-mustek(5)  by  David
   Mosberger-Tang, Andreas Czechanowski and Andreas Bolsch

                              11 Jul 2008                    sane-sharp(5)


Personal Opportunity - Free software gives you access to billions of dollars of software at no cost. Use this software for your business, personal use or to develop a profitable skill. Access to source code provides access to a level of capabilities/information that companies protect though copyrights. Open source is a core component of the Internet and it is available to you. Leverage the billions of dollars in resources and capabilities to build a career, establish a business or change the world. The potential is endless for those who understand the opportunity.

Business Opportunity - Goldman Sachs, IBM and countless large corporations are leveraging open source to reduce costs, develop products and increase their bottom lines. Learn what these companies know about open source and how open source can give you the advantage.

Free Software

Free Software provides computer programs and capabilities at no cost but more importantly, it provides the freedom to run, edit, contribute to, and share the software. The importance of free software is a matter of access, not price. Software at no cost is a benefit but ownership rights to the software and source code is far more significant.

Free Office Software - The Libre Office suite provides top desktop productivity tools for free. This includes, a word processor, spreadsheet, presentation engine, drawing and flowcharting, database and math applications. Libre Office is available for Linux or Windows.

Free Books

The Free Books Library is a collection of thousands of the most popular public domain books in an online readable format. The collection includes great classical literature and more recent works where the U.S. copyright has expired. These books are yours to read and use without restrictions.

Source Code - Want to change a program or know how it works? Open Source provides the source code for its programs so that anyone can use, modify or learn how to write those programs themselves. Visit the GNU source code repositories to download the source.


Study at Harvard, Stanford or MIT - Open edX provides free online courses from Harvard, MIT, Columbia, UC Berkeley and other top Universities. Hundreds of courses for almost all major subjects and course levels. Open edx also offers some paid courses and selected certifications.

Linux Manual Pages - A man or manual page is a form of software documentation found on Linux/Unix operating systems. Topics covered include computer programs (including library and system calls), formal standards and conventions, and even abstract concepts.