backend for sharp-scanners

This backend supports the Sharp scanners JX-250, JX-330, JX-350 and JX-610. Please remember the early state of this backend; the authors do not expect it to work without problems under every condition. Especially must be pointed out that we are only able to test the backend with a JX-250 and JX-610, thus the current version of the backend might not work "out of the box" with a JX-330. Therefore, we would appreciate to receive reports, how the backend works with a JX-330.

Please send comments, bug reports and bug fixes to
Abel Deuring, or
Kazuya Fukuda, or to the
Sane developer mailing list.

Download source code:

For general information on Sane, please see http://www.mostang.com/sane/

Differences between version 0.32 and version 0.31:

support for JX-320 added. (Thanks to Isaac Wilcox for providing the patch)

Differences between version 0.31 and version 0.30:

support for JX-350 added. (Thanks to Shuhei Tomita for providing the patch)

Differences between version 0.30 and version 0.20:

support for the proposed extended open function in sanei_scsi.c added
support for ADF and FSU (transparency adapter) added
simple sense handler added
preview added
added several missing statements "s->fd = -1;" after "sanei_scsi_close(s->fd)" to error returns in sane_start();
maximum scan sizes are read from the scanner, if a JX330 or JX250 is used. (this avoids the guessing of scan sizes for the JX330)
gamma table support added
"Fixed gamma selection (1.0/2.2)", up to now only available for the JX330 and JX610, is now implemented for the JX250 by downloading a gamma table
changed the calls to free() and strdup() in sane_control_option to strcpy.
cleaned up some quirks in option handling, eg, that "threshold" was initially enabled, while the initial scan mode is "color"
cleaned up setting SANE_INFO_RELOAD_OPTIONS and SANE_INFO_RELOAD_PARAMS bits in sane_control_option
bi-level color scans now give useful (8 bit) output
separate thresholds for red, green, blue (bi-level color scan) added

Differences between version 0.20 and version 0.15:

Added support of a config file. For details, see the copy of the man page below.
The backend can be compiled so that a separate reader process is forked. This should avoid most carriage stops which can happen especially for high resolution gray scale scans with a JX-250. In contrast to other backends, the data transfer between the reader process and its parent is done via shared memory.
We are only able to test the backend with Linux and FreeBSD. If you encounter difficulties with forking, disable the line #define USE_FORK in sharp.c.
Improved detection of JX-330 series scanners. The backend should now detect the models JX-320, JX-325 and JX-330.

Restrictions and known Bugs:

For the JX-610, lineart and color lineart scans do not work
For the JX-610, threshold adjustment does not work
With the JX-610, the light color selection "white" gives blue-red light (the JX-610 cannot produce gray scale and lineart scans with white light)
Usage of a transparency adapter (Film Scan Unit) is not tested.
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.

Man page

DESCRIPTION

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.

DEVICE NAMES

This backend expects device names of the form:

special

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 OPTIONS

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:
- none
- 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:
- Flatbed
- 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 settings:
- 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:
- 1.0
- 2.2
The default value is 2.2. (The JX-250 has no built in gamma correction; for this 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 scans.
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 and JX-610)
- 30..400 (JX-250)
The default value is 150.
Scan Window
The possible settings depend on the scanner model and, for the JX-250, 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 commands:
- 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 scanimage);
- bottom right y position of scan area (parameter -y for scanimage);
Edge emphasis (parameter --Edge emphasis for scanimage). This option is not available for the JX-250. Possible settings:
- None
- Middle
- Strong
- Blur
The default value is None.
Threshold (parameter --threshold for scanimage). Sets the threshold for black and white pixels in lineart mode. Possible values:
- 1..255
The default value is 128. This option is only available in scan mode lineart.
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:
- 1..255
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:
- 1..255
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:
- 1..255
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:
- white
- red
- green
- blue
The default value is white. This option is only available in scan modes lineart color and color.

ADF USAGE

If a paper jam occured, 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.

CONFIGURATION

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 listed in this file; 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 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.

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 aquired by the backend too slow.

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 carirage 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".)

For a more detailed discussion of the influence of command queueing and buffer size on the scan performance, see here.

FILES

<CONFIGDIR>/sharp.conf: The backend configuration file.
<LIBDIR>/libsane-sharp.a: The static library implementing this backend.
<LIBDIR>/libsane-sharp.so: The shared library implementing this backend (present on systems that support dynamic loading).

ENVIRONMENT

SANE_DEBUG_SHARP: 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.

Acknowledgments

This backend is based on Helmut Koeberle's backend for Canon scanners.

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

Kazuya Fukuda
Abel Deuring

Last modified: Nov 21 2000