mirror
/
sane-project-frontends
kopia lustrzana https://gitlab.com/sane-project/frontends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
sane-project-frontends/src/scanadf.c

1720 wiersze
42 KiB
C
Czysty Bezpośredni odnośnik Wina Historia

/* saneadf - a SANE front end for document scanning
based on
bnhscan by tummy.com and
scanimage by Andreas Beck and David Mosberger
Copyright (C) 1999 Tom Martone
Copyright (C) 2005 Rene Rebe ([ -p | --pipe] script option)
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
#ifdef _AIX
# include <lalloca.h> /* MUST come first for AIX! */
#endif
#include "sane/config.h"
#include <lalloca.h>
#include <assert.h>
#include <getopt.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include "sane/sane.h"
#include "sane/sanei.h"
#include "sane/saneopts.h"
#ifndef PATH_MAX
#define PATH_MAX 1024
#endif
const char*
sane_strframe (SANE_Frame f)
{
switch (f)
{
case SANE_FRAME_GRAY:
return "gray";
case SANE_FRAME_RGB:
return "RBG";
case SANE_FRAME_RED:
return "red";
case SANE_FRAME_GREEN:
return "green";
case SANE_FRAME_BLUE:
return "blue";
#if 0 // Not currently support by SANE
case SANE_FRAME_TEXT:
return "text";
case SANE_FRAME_JPEG:
return "jpeg";
case SANE_FRAME_G31D:
return "g31d";
case SANE_FRAME_G32D:
return "g32d";
case SANE_FRAME_G42D:
return "g42d";
#endif
default:
return "unknown";
}
}
#define sane_isbasicframe(f) ( (f) == SANE_FRAME_GRAY || \
(f) == SANE_FRAME_RGB || \
(f) == SANE_FRAME_RED || \
(f) == SANE_FRAME_GREEN || \
(f) == SANE_FRAME_BLUE )
#ifndef HAVE_ATEXIT
# define atexit(func) on_exit(func, 0) /* works for SunOS, at least */
#endif
typedef struct
{
u_char *data;
int Bpp; /* bytes/pixel */
int width;
int height;
int x;
int y;
}
Image;
static struct option basic_options[] =
{
{"device-name", required_argument, NULL, 'd'},
{"list-devices", no_argument, NULL, 'L'},
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'},
{"version", no_argument, NULL, 'V'},
{"no-overwrite", no_argument, NULL, 'N'},
{ "output-file", required_argument, 0, 'o' },
{ "start-count", required_argument, 0, 's' },
{ "end-count", required_argument, 0, 'e' },
{ "scan-script", required_argument, 0, 'S' },
{ "script-wait", no_argument, 0, 128 },
{ "raw", no_argument, 0, 'r' },
{ "pipe", no_argument, 0, 'p' },
{0, }
};
#define BASE_OPTSTRING "d:hLvVNTo:s:e:S:pr"
#define STRIP_HEIGHT 256 /* # lines we increment image height */
static struct option * all_options;
static int option_number_len;
static int * option_number;
static SANE_Handle device;
static int verbose;
static int help;
static const char * prog_name;
static SANE_Option_Descriptor window_option[2];
static int window[4];
static int resolution_opt = -1, x_resolution_opt = -1, y_resolution_opt = -1;
static SANE_Word window_val[2];
static int window_val_user[2]; /* is width/height user-specified? */
static void scanadf_exit (int);
static const char usage[] = "Usage: %s [OPTION]...\n\
\n\
Start image acquisition on a scanner device and write image data to\n\
output files.\n\
\n\
[ -d | --device-name <device> ] use a given scanner device.\n\
[ -h | --help ] display this help message and exit.\n\
[ -L | --list-devices ] show available scanner devices.\n\
[ -v | --verbose ] give even more status messages.\n\
[ -V | --version ] print version information.\n\
[ -N | --no-overwrite ] don't overwrite existing files.\n\
\n\
[ -o | --output-file <name> ] name of file to write image data\n\
(%%d replacement in output file name).\n\
[ -S | --scan-script <name> ] name of script to run after every scan.\n\
[ --script-wait ] wait for scripts to finish before exit\n\
[ -s | --start-count <num> ] page count of first scanned image.\n\
[ -e | --end-count <num> ] last page number to scan.\n\
[ -r | --raw ] write raw image data to file.\n";
static RETSIGTYPE
sighandler (int signum)
{
if (device)
{
fprintf (stderr, "%s: stopping scanner...\n", prog_name);
sane_cancel (device);
}
}
static void
print_unit (SANE_Unit unit)
{
switch (unit)
{
case SANE_UNIT_NONE: break;
case SANE_UNIT_PIXEL: fputs ("pel", stdout); break;
case SANE_UNIT_BIT: fputs ("bit", stdout); break;
case SANE_UNIT_MM: fputs ("mm", stdout); break;
case SANE_UNIT_DPI: fputs ("dpi", stdout); break;
case SANE_UNIT_PERCENT: fputc ('%', stdout); break;
case SANE_UNIT_MICROSECOND: fputs ("us", stdout); break;
}
}
static void
print_option (SANE_Device *device, int opt_num, char short_name)
{
const char *str, *last_break, *start;
const SANE_Option_Descriptor *opt;
SANE_Bool not_first = SANE_FALSE;
int i, column;
opt = sane_get_option_descriptor (device, opt_num);
if (short_name)
printf (" -%c", short_name);
else
printf (" --%s", opt->name);
if (opt->type == SANE_TYPE_BOOL)
{
fputs ("[=(", stdout);
if (opt->cap & SANE_CAP_AUTOMATIC)
fputs ("auto|", stdout);
fputs ("yes|no)]", stdout);
}
else if (opt->type != SANE_TYPE_BUTTON)
{
fputc (' ', stdout);
if (opt->cap & SANE_CAP_AUTOMATIC)
{
fputs ("auto|", stdout);
not_first = SANE_TRUE;
}
switch (opt->constraint_type)
{
case SANE_CONSTRAINT_NONE:
switch (opt->type)
{
case SANE_TYPE_INT: fputs ("<int>", stdout); break;
case SANE_TYPE_FIXED: fputs ("<float>", stdout); break;
case SANE_TYPE_STRING: fputs ("<string>", stdout); break;
default:
break;
}
if (opt->type != SANE_TYPE_STRING && opt->size > sizeof (SANE_Word))
fputs (",...", stdout);
break;
case SANE_CONSTRAINT_RANGE:
if (opt->type == SANE_TYPE_INT)
{
printf ("%d..%d",
opt->constraint.range->min, opt->constraint.range->max);
print_unit (opt->unit);
if (opt->size > sizeof (SANE_Word))
fputs (",...", stdout);
if (opt->constraint.range->quant)
printf (" (in steps of %d)",
opt->constraint.range->quant);
}
else
{
printf ("%g..%g",
SANE_UNFIX(opt->constraint.range->min),
SANE_UNFIX(opt->constraint.range->max));
print_unit (opt->unit);
if (opt->size > sizeof (SANE_Word))
fputs (",...", stdout);
if (opt->constraint.range->quant)
printf (" (in steps of %g)",
SANE_UNFIX(opt->constraint.range->quant));
}
break;
case SANE_CONSTRAINT_WORD_LIST:
for (i = 0; i < opt->constraint.word_list[0]; ++i)
{
if (not_first)
fputc ('|', stdout);
not_first = SANE_TRUE;
if (opt->type == SANE_TYPE_INT)
printf ("%d", opt->constraint.word_list[i + 1]);
else
printf ("%g",
SANE_UNFIX(opt->constraint.word_list[i + 1]));
}
print_unit (opt->unit);
if (opt->size > sizeof (SANE_Word))
fputs (",...", stdout);
break;
case SANE_CONSTRAINT_STRING_LIST:
for (i = 0; opt->constraint.string_list[i]; ++i)
{
if (i > 0)
fputc ('|', stdout);
fputs (opt->constraint.string_list[i], stdout);
}
break;
}
}
if (opt->type == SANE_TYPE_STRING ||
opt->type == SANE_TYPE_BOOL ||
opt->type == SANE_TYPE_INT ||
opt->type == SANE_TYPE_FIXED)
{
/* print current option value */
fputs (" [", stdout);
if (SANE_OPTION_IS_ACTIVE(opt->cap))
{
void * val = alloca (opt->size);
sane_control_option (device, opt_num, SANE_ACTION_GET_VALUE, val, 0);
switch (opt->type)
{
case SANE_TYPE_BOOL:
fputs (*(SANE_Bool *)val ? "yes" : "no", stdout);
break;
case SANE_TYPE_INT:
printf ("%d", *(SANE_Int *)val);
break;
case SANE_TYPE_FIXED:
printf ("%g", SANE_UNFIX(*(SANE_Fixed *)val));
break;
case SANE_TYPE_STRING:
fputs ((char *) val, stdout);
break;
default:
break;
}
}
else
fputs ("inactive", stdout);
fputc (']', stdout);
}
fputs ("\n ", stdout);
switch (short_name)
{
case 'x':
fputs ("Width of scan-area.", stdout);
break;
case 'y':
fputs ("Height of scan-area.", stdout);
break;
default:
column = 8; last_break = 0; start = opt->desc;
for (str = opt->desc; *str; ++str)
{
++column;
if (*str == ' ')
last_break = str;
if (column >= 79 && last_break)
{
while (start < last_break)
fputc (*start++, stdout);
start = last_break + 1; /* skip blank */
fputs ("\n ", stdout);
column = 8 + (str - start);
}
}
while (*start)
fputc (*start++, stdout);
}
fputc ('\n', stdout);
}
/* A scalar has the following syntax:
V [ U ]
V is the value of the scalar. It is either an integer or a
floating point number, depending on the option type.
U is an optional unit. If not specified, the default unit is used.
The following table lists which units are supported depending on
what the option's default unit is:
Option's unit: Allowed units:
SANE_UNIT_NONE:
SANE_UNIT_PIXEL: pel
SANE_UNIT_BIT: b (bit), B (byte)
SANE_UNIT_MM: mm (millimeter), cm (centimeter), in or " (inches),
SANE_UNIT_DPI: dpi
SANE_UNIT_PERCENT: %
SANE_UNIT_PERCENT: us
*/
static const char *
parse_scalar (const SANE_Option_Descriptor * opt, const char * str,
SANE_Word * value)
{
char * end;
double v;
if (opt->type == SANE_TYPE_FIXED)
v = strtod (str, &end) * (1 << SANE_FIXED_SCALE_SHIFT);
else
v = strtol (str, &end, 10);
if (str == end)
{
fprintf (stderr,
"%s: option --%s: bad option value (rest of option: %s)\n",
prog_name, opt->name, str);
scanadf_exit (1);
}
str = end;
switch (opt->unit)
{
case SANE_UNIT_NONE:
case SANE_UNIT_PIXEL:
break;
case SANE_UNIT_BIT:
if (*str == 'b' || *str == 'B')
{
if (*str++ == 'B')
v *= 8;
}
break;
case SANE_UNIT_MM:
if (str[0] == '\0')
v *= 1.0; /* default to mm */
else if (strcmp (str, "mm") == 0)
str += sizeof ("mm") - 1;
else if (strcmp (str, "cm") == 0)
{
str += sizeof ("cm") - 1;
v *= 10.0;
}
else if (strcmp (str, "in") == 0 || *str == '"')
{
if (*str++ != '"')
++str;
v *= 25.4; /* 25.4 mm/inch */
}
else
{
fprintf (stderr,
"%s: option --%s: illegal unit (rest of option: %s)\n",
prog_name, opt->name, str);
return 0;
}
break;
case SANE_UNIT_DPI:
if (strcmp (str, "dpi") == 0)
str += sizeof ("dpi") - 1;
break;
case SANE_UNIT_PERCENT:
if (*str == '%')
++str;
break;
case SANE_UNIT_MICROSECOND:
if (strcmp (str, "us") == 0)
str += sizeof ("us") - 1;
break;
}
*value = v + 0.5;
return str;
}
/* A vector has the following syntax:
[ '[' I ']' ] S { [','|'-'] [ '[' I ']' S }
The number in brackets (I), if present, determines the index of the
vector element to be set next. If I is not present, the value of
last index used plus 1 is used. The first index value used is 0
unless I is present.
S is a scalar value as defined by parse_scalar().
If two consecutive value specs are separated by a comma (,) their
values are set independently. If they are separated by a dash (-),
they define the endpoints of a line and all vector values between
the two endpoints are set according to the value of the
interpolated line. For example, [0]15-[255]15 defines a vector of
256 elements whose value is 15. Similarly, [0]0-[255]255 defines a
vector of 256 elements whose value starts at 0 and increases to
255. */
static void
parse_vector (const SANE_Option_Descriptor * opt, const char * str,
SANE_Word * vector, size_t vector_length)
{
SANE_Word value, prev_value = 0;
int index = -1, prev_index = 0;
char * end, separator = '\0';
/* initialize vector to all zeroes: */
memset (vector, 0, vector_length * sizeof (SANE_Word));
do {
if (*str == '[')
{
/* read index */
index = strtol (++str, &end, 10);
if (str == end || *end != ']')
{
fprintf (stderr, "%s: option --%s: closing bracket missing "
"(rest of option: %s)\n", prog_name, opt->name, str);
scanadf_exit (1);
}
str = end + 1;
}
else
++index;
if (index < 0 || index >= vector_length)
{
fprintf (stderr, "%s: option --%s: index %d out of range [0..%ld]\n",
prog_name, opt->name, index, (long) vector_length - 1);
scanadf_exit (1);
}
/* read value */
str = parse_scalar (opt, str, &value);
if (!str)
scanadf_exit (1);
if (*str && *str != '-' && *str != ',')
{
fprintf (stderr,
"%s: option --%s: illegal separator (rest of option: %s)\n",
prog_name, opt->name, str);
scanadf_exit (1);
}
/* store value: */
vector[index] = value;
if (separator == '-')
{
/* interpolate */
double v, slope;
int i;
v = (double) prev_value;
slope = ((double) value - v) / (index - prev_index);
for (i = prev_index + 1; i < index; ++i)
{
v += slope;
vector[i] = (SANE_Word) v;
}
}
prev_index = index;
prev_value = value;
separator = *str++;
} while (separator == ',' || separator == '-');
if (verbose > 2)
{
int i;
fprintf (stderr, "%s: value for --%s is: ", prog_name, opt->name);
for (i = 0; i < vector_length; ++i)
if (opt->type == SANE_TYPE_FIXED)
fprintf (stderr, "%g ", SANE_UNFIX(vector[i]));
else
fprintf (stderr, "%d ", vector[i]);
fputc ('\n', stderr);
}
}
void
fetch_options (SANE_Device * device)
{
const SANE_Option_Descriptor * opt;
SANE_Int num_dev_options;
int i, option_count;
SANE_Status status;
/* and now build the full table of long options: */
opt = sane_get_option_descriptor (device, 0);
if (opt == NULL)
{
fprintf (stderr, "Could not get option descriptor for option 0\n");
exit (1);
}
status = sane_control_option (device, 0, SANE_ACTION_GET_VALUE, &num_dev_options, 0);
if (status != SANE_STATUS_GOOD)
{
fprintf (stderr, "Could not get value for option 0: %s\n", sane_strstatus (status));
exit (1);
}
option_count = 0;
for (i = 1; i < num_dev_options; ++i)
{
opt = sane_get_option_descriptor (device, i);
if (opt == NULL)
{
fprintf (stderr, "Could not get option descriptor for option %d\n", i);
exit (1);
}
if (!SANE_OPTION_IS_SETTABLE (opt->cap))
continue;
option_number[option_count] = i;
all_options[option_count].name = (char *) opt->name;
all_options[option_count].flag = 0;
all_options[option_count].val = 0;
if (opt->type == SANE_TYPE_BOOL)
all_options[option_count].has_arg = optional_argument;
else if (opt->type == SANE_TYPE_BUTTON)
all_options[option_count].has_arg = no_argument;
else
all_options[option_count].has_arg = required_argument;
/* Keep track of resolution options */
if (strcmp (opt->name, SANE_NAME_SCAN_RESOLUTION) == 0)
{
resolution_opt = i;
}
else if (strcmp (opt->name, SANE_NAME_SCAN_X_RESOLUTION) == 0)
{
x_resolution_opt = i;
}
if (strcmp (opt->name, SANE_NAME_SCAN_Y_RESOLUTION) == 0)
{
y_resolution_opt = i;
}
/* Keep track of top-left corner options (if they exist at
all) and replace the bottom-right corner options by a
width/height option (if they exist at all). */
if ((opt->type == SANE_TYPE_FIXED || opt->type == SANE_TYPE_INT)
&& opt->size == sizeof (SANE_Int)
&& (opt->unit == SANE_UNIT_MM || opt->unit == SANE_UNIT_PIXEL))
{
if (strcmp (opt->name, SANE_NAME_SCAN_TL_X) == 0)
{
window[2] = i;
all_options[option_count].val = 'l';
}
else if (strcmp (opt->name, SANE_NAME_SCAN_TL_Y) == 0)
{
window[3] = i;
all_options[option_count].val = 't';
}
else if (strcmp (opt->name, SANE_NAME_SCAN_BR_X) == 0)
{
window[0] = i;
all_options[option_count].name = "width";
all_options[option_count].val = 'x';
window_option[0] = *opt;
window_option[0].title = "Scan width";
window_option[0].desc = "Width of scanning area.";
if (!window_val_user[0])
sane_control_option (device, i, SANE_ACTION_GET_VALUE,
&window_val[0], 0);
}
else if (strcmp (opt->name, SANE_NAME_SCAN_BR_Y) == 0)
{
window[1] = i;
all_options[option_count].name = "height";
all_options[option_count].val = 'y';
window_option[1] = *opt;
window_option[1].title = "Scan height";
window_option[1].desc = "Height of scanning area.";
if (!window_val_user[1])
sane_control_option (device, i, SANE_ACTION_GET_VALUE,
&window_val[1], 0);
}
}
++option_count;
}
memcpy (all_options + option_count, basic_options, sizeof (basic_options));
option_count += NELEMS(basic_options);
memset (all_options + option_count, 0, sizeof (all_options[0]));
/* Initialize width & height options based on backend default
values for top-left x/y and bottom-right x/y: */
for (i = 0; i < 2; ++i)
{
if (window[i] && window[i + 2] && !window_val_user[i])
{
SANE_Word pos;
sane_control_option (device, window[i + 2],
SANE_ACTION_GET_VALUE, &pos, 0);
window_val[i] = window_val[i] - pos + 1;
}
}
}
static void
scanadf_exit (int status)
{
if (device)
{
if (verbose > 1)
fprintf (stderr, "Closing device\n");
sane_close (device);
}
if (verbose > 1)
fprintf (stderr, "Calling sane_exit\n");
sane_exit ();
if (all_options)
free (all_options);
if (option_number)
free (option_number);
if (verbose > 1)
fprintf (stderr, "scanimage: finished\n");
exit (status);
}
static void
set_option (SANE_Handle device, int optnum, void * valuep)
{
const SANE_Option_Descriptor * opt;
SANE_Status status;
SANE_Word orig = 0;
SANE_Int info;
opt = sane_get_option_descriptor (device, optnum);
if (opt->size == sizeof (SANE_Word) && opt->type != SANE_TYPE_STRING)
orig = *(SANE_Word *) valuep;
status = sane_control_option (device, optnum, SANE_ACTION_SET_VALUE,
valuep, &info);
if (status != SANE_STATUS_GOOD)
{
fprintf (stderr, "%s: setting of option --%s failed (%s)\n",
prog_name, opt->name, sane_strstatus (status));
scanadf_exit (1);
}
if ((info & SANE_INFO_INEXACT) && opt->size == sizeof (SANE_Word))
{
if (opt->type == SANE_TYPE_INT)
fprintf (stderr, "%s: rounded value of %s from %d to %d\n",
prog_name, opt->name, orig, *(SANE_Word *) valuep);
else if (opt->type == SANE_TYPE_FIXED)
fprintf (stderr, "%s: rounded value of %s from %g to %g\n",
prog_name, opt->name,
SANE_UNFIX(orig), SANE_UNFIX(*(SANE_Word *) valuep));
}
if (info & SANE_INFO_RELOAD_OPTIONS)
fetch_options (device);
}
static void
process_backend_option (SANE_Handle device, int optnum, const char * optarg)
{
static SANE_Word * vector = 0;
static size_t vector_size = 0;
const SANE_Option_Descriptor * opt;
size_t vector_length;
SANE_Status status;
SANE_Word value;
void * valuep;
opt = sane_get_option_descriptor (device, optnum);
if (!SANE_OPTION_IS_ACTIVE(opt->cap))
{
fprintf (stderr, "%s: attempted to set inactive option %s\n",
prog_name, opt->name);
scanadf_exit (1);
}
if ((opt->cap & SANE_CAP_AUTOMATIC) && strncasecmp (optarg, "auto", 4) == 0)
{
status = sane_control_option (device, optnum, SANE_ACTION_SET_AUTO,
0, 0);
if (status != SANE_STATUS_GOOD)
{
fprintf (stderr, "%s: failed to set option --%s to automatic (%s)\n",
prog_name, opt->name, sane_strstatus (status));
scanadf_exit (1);
}
return;
}
valuep = &value;
switch (opt->type)
{
case SANE_TYPE_BOOL:
value = 1; /* no argument means option is set */
if (optarg)
{
if (strncasecmp (optarg, "yes", strlen (optarg)) == 0)
value = 1;
else if (strncasecmp (optarg, "no", strlen (optarg)) == 0)
value = 0;
else
{
fprintf (stderr, "%s: option --%s: bad option value `%s'\n",
prog_name, opt->name, optarg);
scanadf_exit (1);
}
}
break;
case SANE_TYPE_INT:
case SANE_TYPE_FIXED:
/* ensure vector is long enough: */
vector_length = opt->size / sizeof (SANE_Word);
if (vector_size < vector_length)
{
vector_size = vector_length;
vector = realloc (vector, vector_length * sizeof (SANE_Word));
if (!vector)
{
fprintf (stderr, "%s: out of memory\n", prog_name);
scanadf_exit (1);
}
}
parse_vector (opt, optarg, vector, vector_length);
valuep = vector;
break;
case SANE_TYPE_STRING:
valuep = (void *) optarg;
break;
case SANE_TYPE_BUTTON:
value = 0; /* value doesn't matter */
break;
default:
fprintf (stderr, "%s: duh, got unknown option type %d\n",
prog_name, opt->type);
return;
}
set_option (device, optnum, valuep);
}
static void
write_pnm_header_to_file (FILE *fp, SANE_Frame format, int width, int height, int depth)
{
switch (format)
{
case SANE_FRAME_RED:
case SANE_FRAME_GREEN:
case SANE_FRAME_BLUE:
case SANE_FRAME_RGB:
fprintf (fp, "P6\n# SANE data follows\n%d %d\n255\n", width, height);
break;
case SANE_FRAME_GRAY:
if (depth == 1)
fprintf (fp, "P4\n# SANE data follows\n%d %d\n", width, height);
else
fprintf (fp, "P5\n# SANE data follows\n%d %d\n255\n", width, height);
break;
default:
/* default action for unknown frametypes; don't write a header */
break;
}
#ifdef __EMX__ /* OS2 - write in binary mode. */
_fsetmode(fp, "b");
#endif
}
static void *
advance (Image *image)
{
if (++image->x >= image->width)
{
image->x = 0;
if (++image->y >= image->height || !image->data)
{
size_t old_size = 0, new_size;
if (image->data)
old_size = image->height * image->width * image->Bpp;
image->height += STRIP_HEIGHT;
new_size = image->height * image->width * image->Bpp;
if (image->data)
image->data = realloc (image->data, new_size);
else
image->data = malloc (new_size);
if (image->data)
memset (image->data + old_size, 0, new_size - old_size);
}
}
if (!image->data)
fprintf (stderr, "%s: can't allocate image buffer (%dx%d)\n",
prog_name, image->width, image->height);
return image->data;
}
static SANE_Int
get_resolution(SANE_Device *device)
{
SANE_Int res = 200;
SANE_Word val;
const SANE_Option_Descriptor *opt;
if (resolution_opt >= 0)
{
opt = sane_get_option_descriptor (device, resolution_opt);
sane_control_option (device, resolution_opt,
SANE_ACTION_GET_VALUE, &val, 0);
switch (opt->type)
{
case SANE_TYPE_INT:
res = val;
break;
case SANE_TYPE_FIXED:
res = (SANE_Int) SANE_UNFIX(val);
break;
case SANE_TYPE_STRING:
case SANE_TYPE_BOOL:
default:
if (verbose)
fprintf(stderr,
"Peculiar option data type for resolution, "
"using default value.\n");
break;
}
}
else
{
if (verbose)
fprintf(stderr, "No resolution option found, using default value.\n");
}
return res;
}
static int
exec_script (const char *script, const char* fname, SANE_Bool use_pipe,
SANE_Parameters *parm, int *fd)
{
static char cmd[PATH_MAX * 2];
static char env[7][PATH_MAX * 2];
int pid;
SANE_Int res;
SANE_Frame format;
extern char **environ;
int pipefd[2];
res = get_resolution(device);
format = parm->format;
if (format == SANE_FRAME_RED ||
format == SANE_FRAME_GREEN ||
format == SANE_FRAME_BLUE)
{
/* the resultant format is RGB */
format = SANE_FRAME_RGB;
}
snprintf (env[0], sizeof(env[0]), "SCAN_RES=%d", res);
if (putenv (env[0]))
fprintf (stderr, "putenv:failed\n");
snprintf (env[1], sizeof(env[1]), "SCAN_WIDTH=%d", parm->pixels_per_line);
if (putenv (env[1]))
fprintf (stderr, "putenv:failed\n");
snprintf (env[2], sizeof(env[2]), "SCAN_HEIGHT=%d", parm->lines);
if (putenv (env[2]))
fprintf (stderr, "putenv:failed\n");
snprintf (env[3], sizeof(env[3]), "SCAN_FORMAT_ID=%d", (int) parm->format);
if (putenv (env[3]))
fprintf (stderr, "putenv:failed\n");
snprintf (env[4], sizeof(env[4]), "SCAN_FORMAT=%s",
sane_strframe (parm->format));
if (putenv (env[4]))
fprintf (stderr, "putenv:failed\n");
snprintf (env[5], sizeof(env[5]), "SCAN_DEPTH=%d", parm->depth);
if (putenv (env[5]))
fprintf (stderr, "putenv:failed\n");
snprintf (env[6], sizeof(env[6]), "SCAN_PIPE=%d", use_pipe);
if (putenv (env[6]))
fprintf (stderr, "putenv:failed\n");
if (use_pipe) {
pipe(pipefd);
}
/*signal(SIGCHLD, SIG_IGN);*/
switch ((pid = fork()))
{
case -1:
/* fork failed */
fprintf(stderr, "Error forking: %s (%d)\n", strerror(errno), errno);
break;
case 0:
/* in child process */
if (use_pipe) {
dup2(pipefd[0],0); close(pipefd[0]); close(pipefd[1]);
}
sprintf(cmd, "%s '%s'", script, fname);
execle(script, script, fname, NULL, environ);
exit(0);
default:
if (verbose)
fprintf(stderr, "Started script `%s' as pid=%d\n", script, pid);
break;
}
if (use_pipe) {
close(pipefd[0]);
*fd = pipefd[1];
}
return pid;
}
static SANE_Status
scan_it_raw (const char *fname, SANE_Bool raw, const char *script,
SANE_Bool use_pipe)
{
int i, len, first_frame = 1, offset = 0, must_buffer = 0;
SANE_Byte buffer[32*1024], min = 0xff, max = 0;
SANE_Parameters parm;
SANE_Status status;
Image image = {0, };
FILE *fp = NULL;
int pid = 0;
do
{
#ifdef SANE_STATUS_WARMING_UP
do
{
status = sane_start (device);
} while (status == SANE_STATUS_WARMING_UP);
#else
status = sane_start (device);
#endif
if (status != SANE_STATUS_GOOD)
{
if (status != SANE_STATUS_NO_DOCS)
{
fprintf (stderr, "%s: sane_start: %s\n",
prog_name, sane_strstatus (status));
}
goto cleanup;
}
status = sane_get_parameters (device, &parm);
if (status != SANE_STATUS_GOOD)
{
fprintf (stderr, "%s: sane_get_parameters: %s\n",
prog_name, sane_strstatus (status));
goto cleanup;
}
if (script && use_pipe)
{
int fd = 0;
pid = exec_script(script, fname, use_pipe, &parm, &fd);
fp = fdopen (fd, "wb");
}
else
fp = fopen(fname, "wb");
if (!fp) {
fprintf(stderr, "Error opening output `%s': %s (%d)\n",
fname, strerror(errno), errno);
status = SANE_STATUS_IO_ERROR;
goto cleanup;
}
if (verbose)
{
if (first_frame)
{
if (sane_isbasicframe(parm.format))
{
if (parm.lines >= 0)
fprintf (stderr, "%s: scanning image of size %dx%d pixels"
" at %d bits/pixel\n",
prog_name, parm.pixels_per_line, parm.lines,
8 * parm.bytes_per_line / parm.pixels_per_line);
else
fprintf (stderr, "%s: scanning image %d pixels wide and "
"variable height at %d bits/pixel\n",
prog_name, parm.pixels_per_line,
8 * parm.bytes_per_line / parm.pixels_per_line);
}
else
{
fprintf (stderr, "%s: receiving %s frame "
"bytes/line=%d, "
"pixels/line=%d, "
"lines=%d, "
"depth=%d\n",
prog_name, sane_strframe(parm.format),
parm.bytes_per_line,
parm.pixels_per_line,
parm.lines,
parm.depth);
}
}
fprintf (stderr, "%s: acquiring %s frame\n", prog_name,
sane_strframe(parm.format));
}
if (first_frame)
{
switch (parm.format)
{
case SANE_FRAME_RED:
case SANE_FRAME_GREEN:
case SANE_FRAME_BLUE:
assert (parm.depth == 8);
must_buffer = 1;
offset = parm.format - SANE_FRAME_RED;
break;
case SANE_FRAME_RGB:
assert (parm.depth == 8);
case SANE_FRAME_GRAY:
assert (parm.depth == 1 || parm.depth == 8);
/* if we're writing raw, we skip the header and never
* have to buffer a single frame format.
*/
if (raw == SANE_FALSE)
{
if (parm.lines < 0)
{
must_buffer = 1;
offset = 0;
}
else
{
write_pnm_header_to_file (fp, parm.format,
parm.pixels_per_line,
parm.lines, parm.depth);
}
}
break;
#if 0 // Not currently supported by SANE
case SANE_FRAME_TEXT:
case SANE_FRAME_JPEG:
case SANE_FRAME_G31D:
case SANE_FRAME_G32D:
case SANE_FRAME_G42D:
if (!parm.last_frame)
{
status = SANE_STATUS_INVAL;
fprintf (stderr, "%s: bad %s frame: must be last_frame\n",
prog_name, sane_strframe (parm.format));
goto cleanup;
}
/* write them out without a header; don't buffer */
break;
#endif
default:
/* Default action for unknown frametypes; write them out
* without a header; issue a warning in verbose mode.
* Since we're not writing a header, there's no need to
* buffer.
*/
if (verbose)
{
fprintf(stderr, "scanadf: unknown frame format %d\n",
(int) parm.format);
}
if (!parm.last_frame)
{
status = SANE_STATUS_INVAL;
fprintf (stderr, "%s: bad %s frame: must be last_frame\n",
prog_name, sane_strframe (parm.format));
goto cleanup;
}
break;
}
if (must_buffer)
{
/* We're either scanning a multi-frame image or the
scanner doesn't know what the eventual image height
will be (common for hand-held scanners). In either
case, we need to buffer all data before we can write
the image. */
image.width = parm.pixels_per_line;
if (parm.lines >= 0)
/* See advance(); we allocate one extra line so we
don't end up realloc'ing in when the image has been
filled in. */
image.height = parm.lines - STRIP_HEIGHT + 1;
else
image.height = 0;
image.Bpp = 3;
if (parm.format == SANE_FRAME_GRAY ||
!sane_isbasicframe(parm.format))
image.Bpp = 1;
image.x = image.width - 1;
image.y = -1;
if (!advance (&image))
goto cleanup;
}
}
else
{
assert (parm.format >= SANE_FRAME_RED
&& parm.format <= SANE_FRAME_BLUE);
offset = parm.format - SANE_FRAME_RED;
image.x = image.y = 0;
}
while (1)
{
status = sane_read (device, buffer, sizeof (buffer), &len);
if (status != SANE_STATUS_GOOD)
{
if (verbose && parm.depth == 8)
fprintf (stderr, "%s: min/max graylevel value = %d/%d\n",
prog_name, min, max);
if (status != SANE_STATUS_EOF)
{
fprintf (stderr, "%s: sane_read: %s\n",
prog_name, sane_strstatus (status));
goto cleanup;
}
break;
}
if (must_buffer)
{
switch (parm.format)
{
case SANE_FRAME_RED:
case SANE_FRAME_GREEN:
case SANE_FRAME_BLUE:
for (i = 0; i < len; ++i)
{
image.data[offset + 3*i] = buffer[i];
if (!advance (&image))
goto cleanup;
}
offset += 3*len;
break;
case SANE_FRAME_RGB:
for (i = 0; i < len; ++i)
{
image.data[offset + i] = buffer[i];
if ((offset + i) % 3 == 0 && !advance (&image))
goto cleanup;
}
offset += len;
break;
case SANE_FRAME_GRAY:
for (i = 0; i < len; ++i)
{
image.data[offset + i] = buffer[i];
if (!advance (&image))
goto cleanup;
}
offset += len;
break;
default:
/* optional frametypes are never buffered */
fprintf(stderr, "%s: ERROR: trying to buffer %s"
" frametype\n",
prog_name,
sane_strframe(parm.format));
break;
}
}
else
fwrite (buffer, 1, len, fp);
if (verbose && parm.depth == 8)
{
for (i = 0; i < len; ++i)
if (buffer[i] >= max)
max = buffer[i];
else if (buffer[i] < min)
min = buffer[i];
}
}
first_frame = 0;
}
while (!parm.last_frame);
if (must_buffer)
{
image.height = image.y;
if (raw == SANE_FALSE)
{
/* if we're writing raw, we skip the header */
write_pnm_header_to_file (fp, parm.format, image.width,
image.height, parm.depth);
}
fwrite (image.data, image.Bpp, image.height * image.width, fp);
}
if (fp)
{
fclose(fp);
fp = NULL;
}
if (script && !use_pipe)
pid = exec_script (script, fname, use_pipe, &parm, NULL);
if (script) {
int exit_status = 0;
waitpid (pid, &exit_status, 0);
if (exit_status && verbose)
fprintf(stderr, "%s: WARNING: child exited with %d\n",
prog_name, exit_status);
}
cleanup:
if (image.data)
free (image.data);
if (fp) fclose(fp);
return status;
}
static SANE_Int
scan_docs (int start, int end, int no_overwrite, SANE_Bool raw,
const char *outfmt, const char *script, SANE_Bool use_pipe)
{
SANE_Status status = SANE_STATUS_GOOD;
SANE_Int scannedPages = 0;
SANE_Char fname[PATH_MAX];
struct stat statbuf;
int res;
while (end < 0 || start <= end)
{
snprintf(fname, sizeof (fname), outfmt, start);
/* does the filename already exist? */
if (no_overwrite)
{
res = stat (fname, &statbuf);
if (res == 0)
{
status = SANE_STATUS_INVAL;
fprintf (stderr, "Filename %s already exists; will not overwrite\n", fname);
}
}
/* Scan the document */
if (status == SANE_STATUS_GOOD)
status = scan_it_raw(fname, raw, script, use_pipe);
/* Any scan errors? */
if (status == SANE_STATUS_NO_DOCS)
{
/* out of paper in the hopper; this is our normal exit */
status = SANE_STATUS_GOOD;
break;
}
else if (status == SANE_STATUS_EOF)
{
/* done with this doc */
status = SANE_STATUS_GOOD;
fprintf(stderr, "Scanned document %s\n", fname);
scannedPages++;
start++;
}
else
{
/* unexpected error */
fprintf(stderr, "%s\n", sane_strstatus(status));
break;
}
}
fprintf(stderr, "Scanned %d pages\n", scannedPages);
return status;
}
int
main (int argc, char **argv)
{
int ch, i, index, all_options_len;
const SANE_Option_Descriptor * opt;
const SANE_Device ** device_list;
SANE_Int num_dev_options = 0;
const char * devname = 0;
SANE_Status status;
char *full_optstring;
SANE_Bool raw = SANE_FALSE;
SANE_Bool use_pipe = SANE_FALSE;
const char *scanScript = NULL; /* script to run at end of scan */
int scriptWait = 0;
const char *outputFile = "image-%04d"; /* file name(format) to write output to */
int startNum = 1, endNum = -1; /* start/end numbers of pages to scan */
int no_overwrite = 0;
atexit (sane_exit);
prog_name = strrchr (argv[0], '/');
if (prog_name)
++prog_name;
else
prog_name = argv[0];
sane_init (0, 0);
/* make a first pass through the options with error printing and argument
permutation disabled: */
opterr = 0;
while ((ch = getopt_long (argc, argv, "-" BASE_OPTSTRING, basic_options,
&index))
!= EOF)
{
switch (ch)
{
case ':':
case '?':
break; /* may be an option that we'll parse later on */
case 'd': devname = optarg; break;
case 'h': help = 1; break;
case 'N': no_overwrite = 1; break;
case 'v': ++verbose; break;
case 'L':
{
int i;
status = sane_get_devices (&device_list, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
fprintf (stderr, "%s: sane_get_devices() failed: %s\n",
prog_name, sane_strstatus (status));
scanadf_exit (1);
}
for (i = 0; device_list[i]; ++i)
{
printf ("device `%s' is a %s %s %s\n",
device_list[i]->name, device_list[i]->vendor,
device_list[i]->model, device_list[i]->type);
}
scanadf_exit (0);
}
case 'o': outputFile = optarg; break;
case 'S': scanScript = optarg; break;
case 128: scriptWait = 1; break;
case 's': startNum = atoi(optarg); break;
case 'e': endNum = atoi(optarg); break;
case 'r': raw = SANE_TRUE; break;
case 'p': use_pipe = SANE_TRUE; break;
case 'V':
printf ("scanadf (%s) %s\n", PACKAGE, VERSION);
exit (0);
default:
break; /* ignore device specific options for now */
}
}
if (scriptWait && !scanScript)
scriptWait = 0;
if (help)
printf (usage, prog_name);
if (!devname)
{
/* If no device name was specified explicitly, we open the first
device we find (if any): */
status = sane_get_devices (&device_list, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
fprintf (stderr, "%s: sane_get_devices() failed: %s\n",
prog_name, sane_strstatus (status));
scanadf_exit (1);
}
if (!device_list[0])
{
fprintf (stderr, "%s: no SANE devices found\n", prog_name);
scanadf_exit (1);
}
devname = device_list[0]->name;
}
status = sane_open (devname, &device);
if (status != SANE_STATUS_GOOD)
{
fprintf (stderr, "%s: open of device %s failed: %s\n",
prog_name, devname, sane_strstatus (status));
if (help)
device = 0;
else
scanadf_exit (1);
}
if (device)
{
/* We got a device, find out how many options it has: */
status = sane_control_option (device, 0, SANE_ACTION_GET_VALUE,
&num_dev_options, 0);
if (status != SANE_STATUS_GOOD)
{
fprintf (stderr, "%s: unable to determine option count\n",
prog_name);
scanadf_exit (1);
}
all_options_len = num_dev_options + NELEMS(basic_options) + 1;
all_options = malloc (all_options_len * sizeof (all_options[0]));
option_number_len = num_dev_options;
option_number = malloc (option_number_len * sizeof (option_number[0]));
if (!all_options || !option_number)
{
fprintf (stderr, "%s: out of memory in fetch_options()\n",
prog_name);
scanadf_exit (1);
}
fetch_options (device);
{
char *larg, *targ, *xarg, *yarg;
larg = targ = xarg = yarg = "";
/* Maybe accept t, l, x, and y options. */
if (window[0])
xarg = "x:";
if (window[1])
yarg = "y:";
if (window[2])
larg = "l:";
if (window[3])
targ = "t:";
/* Now allocate the full option list. */
full_optstring = malloc (strlen (BASE_OPTSTRING)
+ strlen (larg) + strlen (targ)
+ strlen (xarg) + strlen (yarg) + 1);
if (!full_optstring)
{
fprintf (stderr, "%s: out of memory\n", prog_name);
scanadf_exit (1);
}
strcpy (full_optstring, BASE_OPTSTRING);
strcat (full_optstring, larg);
strcat (full_optstring, targ);
strcat (full_optstring, xarg);
strcat (full_optstring, yarg);
}
optind = 0;
opterr = 1; /* re-enable error printing and arg permutation */
while ((ch = getopt_long (argc, argv, full_optstring, all_options,
&index))
!= EOF)
{
switch (ch)
{
case ':':
case '?':
scanadf_exit (1); /* error message is printed by getopt_long() */
case 'd': case 'h': case 'v': case 'V': case 'T':
case 'o': case 'S': case 's': case 'e': case 'p': case 'r':
/* previously handled options */
break;
case 'x':
window_val_user[0] = 1;
parse_vector (&window_option[0], optarg, &window_val[0], 1);
break;
case 'y':
window_val_user[1] = 1;
parse_vector (&window_option[1], optarg, &window_val[1], 1);
break;
case 'l': /* tl-x */
process_backend_option (device, window[2], optarg);
break;
case 't': /* tl-y */
process_backend_option (device, window[3], optarg);
break;
case 0:
process_backend_option (device, option_number[index], optarg);
break;
}
}
free (full_optstring);
for (index = 0; index < 2; ++index)
if (window[index])
{
SANE_Word val, pos;
if (window[index + 2])
sane_control_option (device, window[index + 2],
SANE_ACTION_GET_VALUE, &pos, 0);
val = pos + window_val[index] - 1;
set_option (device, window[index], &val);
}
if (help)
{
printf ("\nOptions specific to device `%s':\n", devname);
for (i = 0; i < num_dev_options; ++i)
{
char short_name = '\0';
int j;
opt = 0;
for (j = 0; j < 4; ++j)
if (i == window[j])
{
short_name = "xylt"[j];
if (j < 2)
opt = window_option + j;
}
if (!opt)
opt = sane_get_option_descriptor (device, i);
if (opt->type == SANE_TYPE_GROUP)
printf (" %s:\n", opt->title);
if (!SANE_OPTION_IS_SETTABLE (opt->cap))
continue;
print_option (device, i, short_name);
}
if (num_dev_options)
fputc ('\n', stdout);
}
}
if (help)
{
printf ("\
Type ``%s --help -d DEVICE'' to get list of all options for DEVICE.\n\
\n\
List of available devices:", prog_name);
if (device)
sane_close(device);
status = sane_get_devices (&device_list, SANE_FALSE);
if (status == SANE_STATUS_GOOD)
{
int column = 80;
for (i = 0; device_list[i]; ++i)
{
if (column + strlen (device_list[i]->name) + 1 >= 80)
{
printf ("\n ");
column = 4;
}
if (column > 4)
{
fputc (' ', stdout);
column += 1;
}
fputs (device_list[i]->name, stdout);
column += strlen (device_list[i]->name);
}
}
fputc ('\n', stdout);
scanadf_exit (0);
}
signal (SIGHUP, sighandler);
signal (SIGINT, sighandler);
signal (SIGPIPE, sighandler);
signal (SIGTERM, sighandler);
status = scan_docs (startNum, endNum, no_overwrite, raw,
outputFile, scanScript, use_pipe);
sane_cancel (device);
sane_close (device);
sane_exit();
if (scriptWait)
while (wait(NULL) != -1);
return (status == SANE_STATUS_GOOD) ? 0 : 1;
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik