Sane->get_version

  join('.',Sane->get_version)

Sane->get_version_scalar

Sane->get_devices

If argument local_only is true, only local devices are returned (devices directly attached to the machine that SANE is running on). If it is false, the device list includes all remote devices that are accessible to the SANE library.

  my @devices = Sane->get_devices;
  if ($Sane::STATUS == SANE_STATUS_GOOD) {
   print "Name: $devices[0]->{name}\n";
   print "Vendor: $devices[0]->{vendor}\n";
   print "Model: $devices[0]->{model}\n";
   print "Type: $devices[0]->{type}\n";
  }

Sane::Device->open

  my $device = Sane::Device->open($device_name);

Sane::Device->get_option_descriptor

  my $option = $device->get_option_descriptor($n);
  if ($Sane::STATUS == SANE_STATUS_GOOD) {
   print "Name: $option->{name}\n";
   print "Name: $option->{title}\n";
   print "Name: $option->{desc}\n";
   print "Name: $option->{type}\n";
   print "Name: $option->{unit}\n";
   print "Name: $option->{cap}\n";
   print "Name: $option->{max_values}\n";
   print "Name: $option->{constraint_type}\n";
  }

The contents of the name, title, desc, type, unit, cap and constraint_type are as the C API description (<http://www.sane-project.org/html>). There is a further constraint key that either contains an array with the possible option values, or a hash with max, min, and quant keys.

The max_values key replaced the size key in the C API, and contains the maximum number of values that the option may contain.

Sane::Device->get_option

  my $value = $device->get_option($n);
  if ($Sane::STATUS == SANE_STATUS_GOOD) {
   print "value: $value\n";
  }

For $option->{max_values} > 1, $value is a reference to an array.

Sane::Device->set_auto

  $device->set_auto($n);

Sane::Device->set_option

  $orig = $device->get_option($n);
  $info = $device->set_option($n, $value);
  if ($info & SANE_INFO_INEXACT) {
   $value = $device->get_option($n);
   print "rounded value of $opt->{name} from $orig to $value\n";
  }

For $option->{max_values} > 1, $value can be a reference to an array.

Sane::Device->get_parameters

  $param = $device->get_parameters;
  if ($Sane::STATUS == SANE_STATUS_GOOD) {
   print "format $param->{format}\n";
   print "last_frame $param->{last_frame}\n";
   print "bytes_per_line $param->{bytes_per_line}\n";
   print "pixels_per_line $param->{pixels_per_line}\n";
   print "lines $param->{lines}\n";
   print "depth $param->{depth}\n";
  }

Please see the C documentation (<http://www.sane-project.org/html>) for details of the above values.

Sane::Device->start

  $device->start;

Sane::Device->read

  $param = $device->get_parameters;
  $maxlen = $param->{bytes_per_line};
  ($buf, $len) = $test->read ($maxlen);

If this function is called when no data is available, one of two things may happen, depending on the I/O mode that is in effect for the device.

1. If the device is in blocking I/O mode (the default mode), the call blocks until at least one data byte is available (or until some error occurs).

2. If the device is in non-blocking I/O mode, the call returns immediately with status SANE_STATUS_GOOD and with $len set to zero.

The I/O mode of the device can be set via a call to Sane::Device->set_io_mode().

Sane::Device->cancel

  $device->cancel;

This function can be called at any time (as long as $device is valid) but usually affects long-running operations only (such as image is acquisition). It is safe to call this function asynchronously (e.g., from within a signal handler). It is important to note that completion of this operaton does not imply that the currently pending operation has been cancelled. It only guarantees that cancellation has been initiated. Cancellation completes only when the cancelled call returns (typically with a status value of SANE_STATUS_CANCELLED). Since the SANE API does not require any other operations to be re-entrant, this implies that a frontend must not call any other operation until the cancelled operation has returned.

Sane::Device->set_io_mode

  $device->set_io_mode ($bool);

By default, newly opened handles operate in blocking mode. A backend may elect not to support non-blocking I/O mode. In such a case the status value SANE_STATUS_UNSUPPORTED is returned. Blocking I/O must be supported by all backends, so calling this function with SANE_FALSE is guaranteed to complete successfully.

Sane::Device->get_select_fd

  $fd = $device->get_select_fd;

This function can be called only after a call to Sane::Device->start() has been performed and the returned file-descriptor is guaranteed to remain valid for the duration of the current image acquisition (i.e., until Sane::Device->cancel() or Sane::Device->start() get called again or until Sane::Device->read() returns with status SANE_STATUS_EOF). Indeed, a backend must guarantee to close the returned select file descriptor at the point when the next Sane::Device->read() call would return SANE_STATUS_EOF. This is necessary to ensure the application can detect when this condition occurs without actually having to call Sane::Device->read().

A backend may elect not to support this operation. In such a case, the function returns with status code SANE_STATUS_UNSUPPORTED.

Note that the only operation supported by the returned file-descriptor is a host operating-system dependent test whether the file-descriptor is readable (e.g., this test can be implemented using select() or poll() under UNIX). If any other operation is performed on the file descriptor, the behavior of the backend becomes unpredictable. Once the file-descriptor signals ``readable'' status, it will remain in that state until a call to sane_read() is performed. Since many input devices are very slow, support for this operation is strongly encouraged as it permits an application to do other work while image acquisition is in progress.

Sane::Device->write_pnm_header

 $device->write_pnm_header($fh);

or

 $parm = $device->get_parameters;
 $device->write_pnm_header ($fh, $parm->{format}, 
                                 $parm->{pixels_per_line},
                                 $parm->{lines}, $parm->{depth});