summaryrefslogtreecommitdiff
path: root/frontend/scanimage.c
diff options
context:
space:
mode:
Diffstat (limited to 'frontend/scanimage.c')
-rw-r--r--frontend/scanimage.c2365
1 files changed, 2365 insertions, 0 deletions
diff --git a/frontend/scanimage.c b/frontend/scanimage.c
new file mode 100644
index 0000000..d41c849
--- /dev/null
+++ b/frontend/scanimage.c
@@ -0,0 +1,2365 @@
+/* scanimage -- command line scanning utility
+ Uses the SANE library.
+ Copyright (C) 1996, 1997, 1998 Andreas Beck and David Mosberger
+
+ Copyright (C) 1999 - 2009 by the SANE Project -- See AUTHORS and ChangeLog
+ for details.
+
+ For questions and comments contact the sane-devel mailinglist (see
+ http://www.sane-project.org/mailing-lists.html).
+
+ 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 "../include/lalloca.h" /* MUST come first for AIX! */
+#endif
+
+#include "../include/sane/config.h"
+#include "../include/lalloca.h"
+
+#include <assert.h>
+#include "lgetopt.h"
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdarg.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "../include/_stdint.h"
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/saneopts.h"
+
+#include "stiff.h"
+
+#include "../include/md5.h"
+
+#ifndef PATH_MAX
+#define PATH_MAX 1024
+#endif
+
+#ifndef HAVE_ATEXIT
+# define atexit(func) on_exit(func, 0) /* works for SunOS, at least */
+#endif
+
+typedef struct
+{
+ uint8_t *data;
+ int width; /*WARNING: this is in bytes, get pixel width from param*/
+ int height;
+ int x;
+ int y;
+}
+Image;
+
+#define OPTION_FORMAT 1001
+#define OPTION_MD5 1002
+#define OPTION_BATCH_COUNT 1003
+#define OPTION_BATCH_START_AT 1004
+#define OPTION_BATCH_DOUBLE 1005
+#define OPTION_BATCH_INCREMENT 1006
+#define OPTION_BATCH_PROMPT 1007
+
+#define BATCH_COUNT_UNLIMITED -1
+
+static struct option basic_options[] = {
+ {"device-name", required_argument, NULL, 'd'},
+ {"list-devices", no_argument, NULL, 'L'},
+ {"formatted-device-list", required_argument, NULL, 'f'},
+ {"help", no_argument, NULL, 'h'},
+ {"verbose", no_argument, NULL, 'v'},
+ {"progress", no_argument, NULL, 'p'},
+ {"test", no_argument, NULL, 'T'},
+ {"all-options", no_argument, NULL, 'A'},
+ {"version", no_argument, NULL, 'V'},
+ {"buffer-size", optional_argument, NULL, 'B'},
+ {"batch", optional_argument, NULL, 'b'},
+ {"batch-count", required_argument, NULL, OPTION_BATCH_COUNT},
+ {"batch-start", required_argument, NULL, OPTION_BATCH_START_AT},
+ {"batch-double", no_argument, NULL, OPTION_BATCH_DOUBLE},
+ {"batch-increment", required_argument, NULL, OPTION_BATCH_INCREMENT},
+ {"batch-prompt", no_argument, NULL, OPTION_BATCH_PROMPT},
+ {"format", required_argument, NULL, OPTION_FORMAT},
+ {"accept-md5-only", no_argument, NULL, OPTION_MD5},
+ {"icc-profile", required_argument, NULL, 'i'},
+ {"dont-scan", no_argument, NULL, 'n'},
+ {0, 0, NULL, 0}
+};
+
+#define OUTPUT_PNM 0
+#define OUTPUT_TIFF 1
+
+#define BASE_OPTSTRING "d:hi:Lf:B::nvVTAbp"
+#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 progress = 0;
+static int test;
+static int all;
+static int output_format = OUTPUT_PNM;
+static int help;
+static int dont_scan = 0;
+static const char *prog_name;
+static int resolution_optind = -1, resolution_value = 0;
+
+/* window (area) related options */
+static SANE_Option_Descriptor window_option[4]; /*updated descs for x,y,l,t*/
+static int window[4]; /*index into backend options for x,y,l,t*/
+static SANE_Word window_val[2]; /*the value for x,y options*/
+static int window_val_user[2]; /* is x,y user-specified? */
+
+static int accept_only_md5_auth = 0;
+static const char *icc_profile = NULL;
+
+static void fetch_options (SANE_Device * device);
+static void scanimage_exit (void);
+
+static SANE_Word tl_x = 0;
+static SANE_Word tl_y = 0;
+static SANE_Word br_x = 0;
+static SANE_Word br_y = 0;
+static SANE_Byte *buffer;
+static size_t buffer_size;
+
+
+static void
+auth_callback (SANE_String_Const resource,
+ SANE_Char * username, SANE_Char * password)
+{
+ char tmp[3 + 128 + SANE_MAX_USERNAME_LEN + SANE_MAX_PASSWORD_LEN], *wipe;
+ unsigned char md5digest[16];
+ int md5mode = 0, len, query_user = 1;
+ FILE *pass_file;
+ struct stat stat_buf;
+
+ *tmp = 0;
+
+ if (getenv ("HOME") != NULL)
+ {
+ if (strlen (getenv ("HOME")) < 500)
+ {
+ sprintf (tmp, "%s/.sane/pass", getenv ("HOME"));
+ }
+ }
+
+ if ((strlen (tmp) > 0) && (stat (tmp, &stat_buf) == 0))
+ {
+
+ if ((stat_buf.st_mode & 63) != 0)
+ {
+ fprintf (stderr, "%s has wrong permissions (use at least 0600)\n",
+ tmp);
+ }
+ else
+ {
+
+ if ((pass_file = fopen (tmp, "r")) != NULL)
+ {
+
+ if (strstr (resource, "$MD5$") != NULL)
+ len = (strstr (resource, "$MD5$") - resource);
+ else
+ len = strlen (resource);
+
+ while (fgets (tmp, sizeof(tmp), pass_file))
+ {
+
+ if ((strlen (tmp) > 0) && (tmp[strlen (tmp) - 1] == '\n'))
+ tmp[strlen (tmp) - 1] = 0;
+ if ((strlen (tmp) > 0) && (tmp[strlen (tmp) - 1] == '\r'))
+ tmp[strlen (tmp) - 1] = 0;
+
+ if (strchr (tmp, ':') != NULL)
+ {
+
+ if (strchr (strchr (tmp, ':') + 1, ':') != NULL)
+ {
+
+ if ((strncmp
+ (strchr (strchr (tmp, ':') + 1, ':') + 1,
+ resource, len) == 0)
+ &&
+ ((int) strlen
+ (strchr (strchr (tmp, ':') + 1, ':') + 1) ==
+ len))
+ {
+
+ if ((strchr (tmp, ':') - tmp) <
+ SANE_MAX_USERNAME_LEN)
+ {
+
+ if ((strchr (strchr (tmp, ':') + 1, ':') -
+ (strchr (tmp, ':') + 1)) <
+ SANE_MAX_PASSWORD_LEN)
+ {
+
+ strncpy (username, tmp,
+ strchr (tmp, ':') - tmp);
+
+ username[strchr (tmp, ':') - tmp] = 0;
+
+ strncpy (password,
+ strchr (tmp, ':') + 1,
+ strchr (strchr (tmp, ':') + 1,
+ ':') -
+ (strchr (tmp, ':') + 1));
+ password[strchr
+ (strchr (tmp, ':') + 1,
+ ':') - (strchr (tmp,
+ ':') + 1)] =
+ 0;
+
+ query_user = 0;
+ break;
+ }
+ }
+
+ }
+ }
+ }
+ }
+
+ fclose (pass_file);
+ }
+ }
+ }
+
+ if (strstr (resource, "$MD5$") != NULL)
+ {
+ md5mode = 1;
+ len = (strstr (resource, "$MD5$") - resource);
+ if (query_user == 1)
+ fprintf (stderr, "Authentification required for resource %*.*s. "
+ "Enter username: ", len, len, resource);
+ }
+ else
+ {
+
+ if (accept_only_md5_auth != 0)
+ {
+ fprintf (stderr, "ERROR: backend requested plain-text password\n");
+ return;
+ }
+ else
+ {
+ fprintf (stderr,
+ "WARNING: backend requested plain-text password\n");
+ query_user = 1;
+ }
+
+ if (query_user == 1)
+ fprintf (stderr,
+ "Authentification required for resource %s. Enter username: ",
+ resource);
+ }
+
+ if (query_user == 1)
+ fgets (username, SANE_MAX_USERNAME_LEN, stdin);
+
+ if ((strlen (username)) && (username[strlen (username) - 1] == '\n'))
+ username[strlen (username) - 1] = 0;
+
+ if (query_user == 1)
+ {
+#ifdef HAVE_GETPASS
+ strcpy (password, (wipe = getpass ("Enter password: ")));
+ memset (wipe, 0, strlen (password));
+#else
+ printf("OS has no getpass(). User Queries will not work\n");
+#endif
+ }
+
+ if (md5mode)
+ {
+
+ sprintf (tmp, "%.128s%.*s", (strstr (resource, "$MD5$")) + 5,
+ SANE_MAX_PASSWORD_LEN - 1, password);
+
+ md5_buffer (tmp, strlen (tmp), md5digest);
+
+ memset (password, 0, SANE_MAX_PASSWORD_LEN);
+
+ sprintf (password, "$MD5$%02x%02x%02x%02x%02x%02x%02x%02x"
+ "%02x%02x%02x%02x%02x%02x%02x%02x",
+ md5digest[0], md5digest[1],
+ md5digest[2], md5digest[3],
+ md5digest[4], md5digest[5],
+ md5digest[6], md5digest[7],
+ md5digest[8], md5digest[9],
+ md5digest[10], md5digest[11],
+ md5digest[12], md5digest[13], md5digest[14], md5digest[15]);
+ }
+}
+
+static RETSIGTYPE
+sighandler (int signum)
+{
+ static SANE_Bool first_time = SANE_TRUE;
+
+ if (device)
+ {
+ fprintf (stderr, "%s: received signal %d\n", prog_name, signum);
+ if (first_time)
+ {
+ first_time = SANE_FALSE;
+ fprintf (stderr, "%s: trying to stop scanner\n", prog_name);
+ sane_cancel (device);
+ }
+ else
+ {
+ fprintf (stderr, "%s: aborting\n", prog_name);
+ _exit (0);
+ }
+ }
+}
+
+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, const SANE_Option_Descriptor *opt)
+{
+ const char *str, *last_break, *start;
+ SANE_Bool not_first = SANE_FALSE;
+ int i, column;
+
+ if (opt->type == SANE_TYPE_GROUP){
+ printf (" %s:\n", opt->title);
+ return;
+ }
+
+ /* if both of these are set, option is invalid */
+ if(opt->cap & SANE_CAP_SOFT_SELECT && opt->cap & SANE_CAP_HARD_SELECT){
+ fprintf (stderr, "%s: invalid option caps, SS+HS\n", prog_name);
+ return;
+ }
+
+ /* invalid to select but not detect */
+ if(opt->cap & SANE_CAP_SOFT_SELECT && !(opt->cap & SANE_CAP_SOFT_DETECT)){
+ fprintf (stderr, "%s: invalid option caps, SS!SD\n", prog_name);
+ return;
+ }
+ /* standard allows this, though it makes little sense
+ if(opt->cap & SANE_CAP_HARD_SELECT && !(opt->cap & SANE_CAP_SOFT_DETECT)){
+ fprintf (stderr, "%s: invalid option caps, HS!SD\n", prog_name);
+ return;
+ }*/
+
+ /* if one of these three is not set, option is useless, skip it */
+ if(!(opt->cap &
+ (SANE_CAP_SOFT_SELECT | SANE_CAP_HARD_SELECT | SANE_CAP_SOFT_DETECT)
+ )){
+ return;
+ }
+
+ /* print the option */
+ if ( !strcmp (opt->name, "x")
+ || !strcmp (opt->name, "y")
+ || !strcmp (opt->name, "t")
+ || !strcmp (opt->name, "l"))
+ printf (" -%s", opt->name);
+ else
+ printf (" --%s", opt->name);
+
+ /* print the option choices */
+ 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 > (SANE_Int) sizeof (SANE_Word))
+ fputs (",...", stdout);
+ break;
+
+ case SANE_CONSTRAINT_RANGE:
+ if (opt->type == SANE_TYPE_INT)
+ {
+ if (!strcmp (opt->name, "x"))
+ {
+ printf ("%d..%d",
+ opt->constraint.range->min,
+ opt->constraint.range->max - tl_x);
+ }
+ else if (!strcmp (opt->name, "y"))
+ {
+ printf ("%d..%d",
+ opt->constraint.range->min,
+ opt->constraint.range->max - tl_y);
+ }
+ else
+ {
+ printf ("%d..%d",
+ opt->constraint.range->min,
+ opt->constraint.range->max);
+ }
+ print_unit (opt->unit);
+ if (opt->size > (SANE_Int) sizeof (SANE_Word))
+ fputs (",...", stdout);
+ if (opt->constraint.range->quant)
+ printf (" (in steps of %d)", opt->constraint.range->quant);
+ }
+ else
+ {
+ if (!strcmp (opt->name, "x"))
+ {
+ printf ("%g..%g",
+ SANE_UNFIX (opt->constraint.range->min),
+ SANE_UNFIX (opt->constraint.range->max - tl_x));
+ }
+ else if (!strcmp (opt->name, "y"))
+ {
+ printf ("%g..%g",
+ SANE_UNFIX (opt->constraint.range->min),
+ SANE_UNFIX (opt->constraint.range->max - tl_y));
+ }
+ else
+ {
+ printf ("%g..%g",
+ SANE_UNFIX (opt->constraint.range->min),
+ SANE_UNFIX (opt->constraint.range->max));
+ }
+ print_unit (opt->unit);
+ if (opt->size > (SANE_Int) 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 > (SANE_Int) 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;
+ }
+ }
+
+ /* print current option value */
+ if (opt->type == SANE_TYPE_STRING || opt->size == sizeof (SANE_Word))
+ {
+ if (SANE_OPTION_IS_ACTIVE (opt->cap))
+ {
+ void *val = alloca (opt->size);
+ sane_control_option (device, opt_num, SANE_ACTION_GET_VALUE, val,
+ 0);
+ fputs (" [", stdout);
+ switch (opt->type)
+ {
+ case SANE_TYPE_BOOL:
+ fputs (*(SANE_Bool *) val ? "yes" : "no", stdout);
+ break;
+
+ case SANE_TYPE_INT:
+ if (strcmp (opt->name, "l") == 0)
+ {
+ tl_x = (*(SANE_Fixed *) val);
+ printf ("%d", tl_x);
+ }
+ else if (strcmp (opt->name, "t") == 0)
+ {
+ tl_y = (*(SANE_Fixed *) val);
+ printf ("%d", tl_y);
+ }
+ else if (strcmp (opt->name, "x") == 0)
+ {
+ br_x = (*(SANE_Fixed *) val);
+ printf ("%d", br_x - tl_x);
+ }
+ else if (strcmp (opt->name, "y") == 0)
+ {
+ br_y = (*(SANE_Fixed *) val);
+ printf ("%d", br_y - tl_y);
+ }
+ else
+ printf ("%d", *(SANE_Int *) val);
+ break;
+
+ case SANE_TYPE_FIXED:
+
+ if (strcmp (opt->name, "l") == 0)
+ {
+ tl_x = (*(SANE_Fixed *) val);
+ printf ("%g", SANE_UNFIX (tl_x));
+ }
+ else if (strcmp (opt->name, "t") == 0)
+ {
+ tl_y = (*(SANE_Fixed *) val);
+ printf ("%g", SANE_UNFIX (tl_y));
+ }
+ else if (strcmp (opt->name, "x") == 0)
+ {
+ br_x = (*(SANE_Fixed *) val);
+ printf ("%g", SANE_UNFIX (br_x - tl_x));
+ }
+ else if (strcmp (opt->name, "y") == 0)
+ {
+ br_y = (*(SANE_Fixed *) val);
+ printf ("%g", SANE_UNFIX (br_y - tl_y));
+ }
+ else
+ printf ("%g", SANE_UNFIX (*(SANE_Fixed *) val));
+
+ break;
+
+ case SANE_TYPE_STRING:
+ fputs ((char *) val, stdout);
+ break;
+
+ default:
+ break;
+ }
+ fputc (']', stdout);
+ }
+ }
+
+ if (!SANE_OPTION_IS_ACTIVE (opt->cap))
+ fputs (" [inactive]", stdout);
+
+ else if(opt->cap & SANE_CAP_HARD_SELECT)
+ fputs (" [hardware]", stdout);
+
+ else if(!(opt->cap & SANE_CAP_SOFT_SELECT) && opt->cap & SANE_CAP_SOFT_DETECT)
+ fputs (" [read-only]", stdout);
+
+ fputs ("\n ", stdout);
+
+ column = 8;
+ last_break = 0;
+ start = opt->desc;
+ for (str = opt->desc; *str; ++str)
+ {
+ ++column;
+ if (*str == ' ')
+ last_break = str;
+ else if (*str == '\n'){
+ column=80;
+ 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);
+ 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;
+ }
+
+ if(v < 0){
+ *value = v - 0.5;
+ }
+ else{
+ *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);
+ exit (1);
+ }
+ str = end + 1;
+ }
+ else
+ ++index;
+
+ if (index < 0 || index >= (int) vector_length)
+ {
+ fprintf (stderr,
+ "%s: option --%s: index %d out of range [0..%ld]\n",
+ prog_name, opt->name, index, (long) vector_length - 1);
+ exit (1);
+ }
+
+ /* read value */
+ str = parse_scalar (opt, str, &value);
+ if (!str)
+ exit (1);
+
+ if (*str && *str != '-' && *str != ',')
+ {
+ fprintf (stderr,
+ "%s: option --%s: illegal separator (rest of option: %s)\n",
+ prog_name, opt->name, str);
+ 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 < (int) 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);
+ }
+}
+
+static void
+fetch_options (SANE_Device * device)
+{
+ const SANE_Option_Descriptor *opt;
+ SANE_Int num_dev_options;
+ int i, option_count;
+ SANE_Status status;
+
+ 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);
+ }
+
+ /* build the full table of long options */
+ 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);
+ }
+
+ /* create command line option only for settable options */
+ if (!SANE_OPTION_IS_SETTABLE (opt->cap) || opt->type == SANE_TYPE_GROUP)
+ continue;
+
+ option_number[option_count] = i;
+
+ all_options[option_count].name = (const 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;
+
+ /* Look for scan resolution */
+ if ((opt->type == SANE_TYPE_FIXED || opt->type == SANE_TYPE_INT)
+ && opt->size == sizeof (SANE_Int)
+ && (opt->unit == SANE_UNIT_DPI)
+ && (strcmp (opt->name, SANE_NAME_SCAN_RESOLUTION) == 0))
+ resolution_optind = 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_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 scan-area.";
+ window_option[0].name = "x";
+ }
+ 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 scan-area.";
+ window_option[1].name = "y";
+ }
+ else if (strcmp (opt->name, SANE_NAME_SCAN_TL_X) == 0)
+ {
+ window[2] = i;
+ all_options[option_count].val = 'l';
+ window_option[2] = *opt;
+ window_option[2].name = "l";
+ }
+ else if (strcmp (opt->name, SANE_NAME_SCAN_TL_Y) == 0)
+ {
+ window[3] = i;
+ all_options[option_count].val = 't';
+ window_option[3] = *opt;
+ window_option[3].name = "t";
+ }
+ }
+ ++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_val_user[i])
+ {
+ sane_control_option (device, window[i],
+ SANE_ACTION_GET_VALUE, &window_val[i], 0);
+ if (window[i + 2]){
+ SANE_Word pos;
+ sane_control_option (device, window[i + 2],
+ SANE_ACTION_GET_VALUE, &pos, 0);
+ window_val[i] -= pos;
+ }
+ }
+ }
+}
+
+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 = 0;
+
+ opt = sane_get_option_descriptor (device, optnum);
+ if (opt && (!SANE_OPTION_IS_ACTIVE (opt->cap)))
+ {
+ if (verbose > 0)
+ fprintf (stderr, "%s: ignored request to set inactive option %s\n",
+ prog_name, opt->name);
+ return;
+ }
+
+ 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));
+ 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);
+ exit (1);
+ }
+
+ if ((opt->cap & SANE_CAP_AUTOMATIC) && optarg &&
+ 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));
+ 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);
+ 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);
+ exit (1);
+ }
+ }
+ parse_vector (opt, optarg, vector, vector_length);
+ valuep = vector;
+ break;
+
+ case SANE_TYPE_STRING:
+ valuep = malloc (opt->size);
+ if (!valuep)
+ {
+ fprintf (stderr, "%s: out of memory\n", prog_name);
+ exit (1);
+ }
+ strncpy (valuep, optarg, opt->size);
+ ((char *) valuep)[opt->size - 1] = 0;
+ 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 (SANE_Frame format, int width, int height, int depth)
+{
+ /* The netpbm-package does not define raw image data with maxval > 255. */
+ /* But writing maxval 65535 for 16bit data gives at least a chance */
+ /* to read the image. */
+ switch (format)
+ {
+ case SANE_FRAME_RED:
+ case SANE_FRAME_GREEN:
+ case SANE_FRAME_BLUE:
+ case SANE_FRAME_RGB:
+ printf ("P6\n# SANE data follows\n%d %d\n%d\n", width, height,
+ (depth <= 8) ? 255 : 65535);
+ break;
+
+ default:
+ if (depth == 1)
+ printf ("P4\n# SANE data follows\n%d %d\n", width, height);
+ else
+ printf ("P5\n# SANE data follows\n%d %d\n%d\n", width, height,
+ (depth <= 8) ? 255 : 65535);
+ break;
+ }
+#ifdef __EMX__ /* OS2 - write in binary mode. */
+ _fsetmode (stdout, "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->height += STRIP_HEIGHT;
+ new_size = image->height * image->width;
+
+ 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_Status
+scan_it (void)
+{
+ int i, len, first_frame = 1, offset = 0, must_buffer = 0, hundred_percent;
+ SANE_Byte min = 0xff, max = 0;
+ SANE_Parameters parm;
+ SANE_Status status;
+ Image image = { 0, 0, 0, 0, 0 };
+ static const char *format_name[] = {
+ "gray", "RGB", "red", "green", "blue"
+ };
+ SANE_Word total_bytes = 0, expected_bytes;
+ SANE_Int hang_over = -1;
+
+ do
+ {
+ if (!first_frame)
+ {
+#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)
+ {
+ 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 (verbose)
+ {
+ if (first_frame)
+ {
+ 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);
+ }
+
+ fprintf (stderr, "%s: acquiring %s frame\n", prog_name,
+ parm.format <= SANE_FRAME_BLUE ? format_name[parm.format]:"Unknown");
+ }
+
+ 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) || (parm.depth == 16));
+ case SANE_FRAME_GRAY:
+ assert ((parm.depth == 1) || (parm.depth == 8)
+ || (parm.depth == 16));
+ if (parm.lines < 0)
+ {
+ must_buffer = 1;
+ offset = 0;
+ }
+ else
+ {
+ if (output_format == OUTPUT_TIFF)
+ sanei_write_tiff_header (parm.format,
+ parm.pixels_per_line, parm.lines,
+ parm.depth, resolution_value,
+ icc_profile);
+ else
+ write_pnm_header (parm.format, parm.pixels_per_line,
+ parm.lines, parm.depth);
+ }
+ break;
+
+ default:
+ 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.bytes_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.x = image.width - 1;
+ image.y = -1;
+ if (!advance (&image))
+ {
+ status = SANE_STATUS_NO_MEM;
+ 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;
+ }
+ hundred_percent = parm.bytes_per_line * parm.lines
+ * ((parm.format == SANE_FRAME_RGB || parm.format == SANE_FRAME_GRAY) ? 1:3);
+
+ while (1)
+ {
+ double progr;
+ status = sane_read (device, buffer, buffer_size, &len);
+ total_bytes += (SANE_Word) len;
+ progr = ((total_bytes * 100.) / (double) hundred_percent);
+ if (progr > 100.)
+ progr = 100.;
+ if (progress)
+ fprintf (stderr, "Progress: %3.1f%%\r", progr);
+
+ 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));
+ return status;
+ }
+ 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))
+ {
+ status = SANE_STATUS_NO_MEM;
+ goto cleanup;
+ }
+ }
+ offset += 3 * len;
+ break;
+
+ case SANE_FRAME_RGB:
+ for (i = 0; i < len; ++i)
+ {
+ image.data[offset + i] = buffer[i];
+ if (!advance (&image))
+ {
+ status = SANE_STATUS_NO_MEM;
+ goto cleanup;
+ }
+ }
+ offset += len;
+ break;
+
+ case SANE_FRAME_GRAY:
+ for (i = 0; i < len; ++i)
+ {
+ image.data[offset + i] = buffer[i];
+ if (!advance (&image))
+ {
+ status = SANE_STATUS_NO_MEM;
+ goto cleanup;
+ }
+ }
+ offset += len;
+ break;
+
+ default:
+ break;
+ }
+ }
+ else /* ! must_buffer */
+ {
+ if ((output_format == OUTPUT_TIFF) || (parm.depth != 16))
+ fwrite (buffer, 1, len, stdout);
+ else
+ {
+#if !defined(WORDS_BIGENDIAN)
+ int i, start = 0;
+
+ /* check if we have saved one byte from the last sane_read */
+ if (hang_over > -1)
+ {
+ if (len > 0)
+ {
+ fwrite (buffer, 1, 1, stdout);
+ buffer[0] = (SANE_Byte) hang_over;
+ hang_over = -1;
+ start = 1;
+ }
+ }
+ /* now do the byte-swapping */
+ for (i = start; i < (len - 1); i += 2)
+ {
+ unsigned char LSB;
+ LSB = buffer[i];
+ buffer[i] = buffer[i + 1];
+ buffer[i + 1] = LSB;
+ }
+ /* check if we have an odd number of bytes */
+ if (((len - start) % 2) != 0)
+ {
+ hang_over = buffer[len - 1];
+ len--;
+ }
+#endif
+ fwrite (buffer, 1, len, stdout);
+ }
+ }
+
+ 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 (output_format == OUTPUT_TIFF)
+ sanei_write_tiff_header (parm.format, parm.pixels_per_line,
+ image.height, parm.depth, resolution_value,
+ icc_profile);
+ else
+ write_pnm_header (parm.format, parm.pixels_per_line,
+ image.height, parm.depth);
+
+#if !defined(WORDS_BIGENDIAN)
+ /* multibyte pnm file may need byte swap to LE */
+ /* FIXME: other bit depths? */
+ if (output_format != OUTPUT_TIFF && parm.depth == 16)
+ {
+ int i;
+ for (i = 0; i < image.height * image.width; i += 2)
+ {
+ unsigned char LSB;
+ LSB = image.data[i];
+ image.data[i] = image.data[i + 1];
+ image.data[i + 1] = LSB;
+ }
+ }
+#endif
+
+ fwrite (image.data, 1, image.height * image.width, stdout);
+ }
+
+ /* flush the output buffer */
+ fflush( stdout );
+
+cleanup:
+ if (image.data)
+ free (image.data);
+
+
+ expected_bytes = parm.bytes_per_line * parm.lines *
+ ((parm.format == SANE_FRAME_RGB
+ || parm.format == SANE_FRAME_GRAY) ? 1 : 3);
+ if (parm.lines < 0)
+ expected_bytes = 0;
+ if (total_bytes > expected_bytes && expected_bytes != 0)
+ {
+ fprintf (stderr,
+ "%s: WARNING: read more data than announced by backend "
+ "(%u/%u)\n", prog_name, total_bytes, expected_bytes);
+ }
+ else if (verbose)
+ fprintf (stderr, "%s: read %u bytes in total\n", prog_name, total_bytes);
+
+ return status;
+}
+
+#define clean_buffer(buf,size) memset ((buf), 0x23, size)
+
+static void
+pass_fail (int max, int len, SANE_Byte * buffer, SANE_Status status)
+{
+ if (status != SANE_STATUS_GOOD)
+ fprintf (stderr, "FAIL Error: %s\n", sane_strstatus (status));
+ else if (buffer[len] != 0x23)
+ {
+ while (len <= max && buffer[len] != 0x23)
+ ++len;
+ fprintf (stderr, "FAIL Cheat: %d bytes\n", len);
+ }
+ else if (len > max)
+ fprintf (stderr, "FAIL Overflow: %d bytes\n", len);
+ else if (len == 0)
+ fprintf (stderr, "FAIL No data\n");
+ else
+ fprintf (stderr, "PASS\n");
+}
+
+static SANE_Status
+test_it (void)
+{
+ int i, len;
+ SANE_Parameters parm;
+ SANE_Status status;
+ Image image = { 0, 0, 0, 0, 0 };
+ static const char *format_name[] =
+ { "gray", "RGB", "red", "green", "blue" };
+
+#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)
+ {
+ 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 (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);
+ fprintf (stderr, "%s: acquiring %s frame, %d bits/sample\n", prog_name,
+ parm.format <= SANE_FRAME_BLUE ? format_name[parm.format]:"Unknown",
+ parm.depth);
+
+ image.data = malloc (parm.bytes_per_line * 2);
+
+ clean_buffer (image.data, parm.bytes_per_line * 2);
+ fprintf (stderr, "%s: reading one scanline, %d bytes...\t", prog_name,
+ parm.bytes_per_line);
+ status = sane_read (device, image.data, parm.bytes_per_line, &len);
+ pass_fail (parm.bytes_per_line, len, image.data, status);
+ if (status != SANE_STATUS_GOOD)
+ goto cleanup;
+
+ clean_buffer (image.data, parm.bytes_per_line * 2);
+ fprintf (stderr, "%s: reading one byte...\t\t", prog_name);
+ status = sane_read (device, image.data, 1, &len);
+ pass_fail (1, len, image.data, status);
+ if (status != SANE_STATUS_GOOD)
+ goto cleanup;
+
+ for (i = 2; i < parm.bytes_per_line * 2; i *= 2)
+ {
+ clean_buffer (image.data, parm.bytes_per_line * 2);
+ fprintf (stderr, "%s: stepped read, %d bytes... \t", prog_name, i);
+ status = sane_read (device, image.data, i, &len);
+ pass_fail (i, len, image.data, status);
+ if (status != SANE_STATUS_GOOD)
+ goto cleanup;
+ }
+
+ for (i /= 2; i > 2; i /= 2)
+ {
+ clean_buffer (image.data, parm.bytes_per_line * 2);
+ fprintf (stderr, "%s: stepped read, %d bytes... \t", prog_name, i - 1);
+ status = sane_read (device, image.data, i - 1, &len);
+ pass_fail (i - 1, len, image.data, status);
+ if (status != SANE_STATUS_GOOD)
+ goto cleanup;
+ }
+
+cleanup:
+ sane_cancel (device);
+ if (image.data)
+ free (image.data);
+ return status;
+}
+
+
+static int
+get_resolution (void)
+{
+ const SANE_Option_Descriptor *resopt;
+ int resol = 0;
+ void *val;
+
+ if (resolution_optind < 0)
+ return 0;
+ resopt = sane_get_option_descriptor (device, resolution_optind);
+ if (!resopt)
+ return 0;
+
+ val = alloca (resopt->size);
+ if (!val)
+ return 0;
+
+ sane_control_option (device, resolution_optind, SANE_ACTION_GET_VALUE, val,
+ 0);
+ if (resopt->type == SANE_TYPE_INT)
+ resol = *(SANE_Int *) val;
+ else
+ resol = (int) (SANE_UNFIX (*(SANE_Fixed *) val) + 0.5);
+
+ return resol;
+}
+
+static void
+scanimage_exit (void)
+{
+ 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");
+}
+
+/** @brief print device options to stdout
+ *
+ * @param device struct of the opened device to describe
+ * @param num_dev_options number of device options
+ * @param ro SANE_TRUE to print read-only options
+ */
+static void print_options(SANE_Device * device, SANE_Int num_dev_options, SANE_Bool ro)
+{
+ int i, j;
+ const SANE_Option_Descriptor *opt;
+
+ for (i = 1; i < num_dev_options; ++i)
+ {
+ opt = 0;
+
+ /* scan area uses modified option struct */
+ for (j = 0; j < 4; ++j)
+ if (i == window[j])
+ opt = window_option + j;
+
+ if (!opt)
+ opt = sane_get_option_descriptor (device, i);
+
+ if (ro || SANE_OPTION_IS_SETTABLE (opt->cap)
+ || opt->type == SANE_TYPE_GROUP)
+ print_option (device, i, opt);
+ }
+ if (num_dev_options)
+ fputc ('\n', stdout);
+}
+
+int
+main (int argc, char **argv)
+{
+ int ch, i, index, all_options_len;
+ const SANE_Device **device_list;
+ SANE_Int num_dev_options = 0;
+ const char *devname = 0;
+ const char *defdevname = 0;
+ const char *format = 0;
+ char readbuf[2];
+ char *readbuf2;
+ int batch = 0;
+ int batch_prompt = 0;
+ int batch_count = BATCH_COUNT_UNLIMITED;
+ int batch_start_at = 1;
+ int batch_increment = 1;
+ SANE_Status status;
+ char *full_optstring;
+ SANE_Int version_code;
+
+ atexit (scanimage_exit);
+
+ buffer_size = (32 * 1024); /* default size */
+
+ prog_name = strrchr (argv[0], '/');
+ if (prog_name)
+ ++prog_name;
+ else
+ prog_name = argv[0];
+
+ defdevname = getenv ("SANE_DEFAULT_DEVICE");
+
+ sane_init (&version_code, auth_callback);
+
+ /* 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 'b':
+ /* This may have already been set by the batch-count flag */
+ batch = 1;
+ format = optarg;
+ break;
+ case 'h':
+ help = 1;
+ break;
+ case 'i': /* icc profile */
+ icc_profile = optarg;
+ break;
+ case 'v':
+ ++verbose;
+ break;
+ case 'p':
+ progress = 1;
+ break;
+ case 'B':
+ if (optarg)
+ buffer_size = 1024 * atoi(optarg);
+ else
+ buffer_size = (1024 * 1024);
+ break;
+ case 'T':
+ test = 1;
+ break;
+ case 'A':
+ all = 1;
+ break;
+ case 'n':
+ dont_scan = 1;
+ break;
+ case OPTION_BATCH_PROMPT:
+ batch_prompt = 1;
+ break;
+ case OPTION_BATCH_INCREMENT:
+ batch_increment = atoi (optarg);
+ break;
+ case OPTION_BATCH_START_AT:
+ batch_start_at = atoi (optarg);
+ break;
+ case OPTION_BATCH_DOUBLE:
+ batch_increment = 2;
+ break;
+ case OPTION_BATCH_COUNT:
+ batch_count = atoi (optarg);
+ batch = 1;
+ break;
+ case OPTION_FORMAT:
+ if (strcmp (optarg, "tiff") == 0)
+ output_format = OUTPUT_TIFF;
+ else
+ output_format = OUTPUT_PNM;
+ break;
+ case OPTION_MD5:
+ accept_only_md5_auth = 1;
+ break;
+ case 'L':
+ case 'f':
+ {
+ int i = 0;
+
+ 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));
+ exit (1);
+ }
+
+ if (ch == 'L')
+ {
+ 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);
+ }
+ }
+ else
+ {
+ int i = 0, int_arg = 0;
+ char *percent, *start, *fmt;
+ const char *text_arg = 0;
+ char cc, ftype;
+
+ fmt = malloc (strlen (optarg) + 1);
+ if (fmt == 0)
+ {
+ fprintf (stderr, "%s: not enough memory\n", prog_name);
+ exit (1);
+ }
+
+ for (i = 0; device_list[i]; ++i)
+ {
+ strcpy (fmt, optarg);
+ start = fmt;
+ while (*start && (percent = strchr (start, '%')))
+ {
+ percent++;
+ if (*percent)
+ {
+ switch (*percent)
+ {
+ case 'd':
+ text_arg = device_list[i]->name;
+ ftype = *percent = 's';
+ break;
+ case 'v':
+ text_arg = device_list[i]->vendor;
+ ftype = *percent = 's';
+ break;
+ case 'm':
+ text_arg = device_list[i]->model;
+ ftype = *percent = 's';
+ break;
+ case 't':
+ text_arg = device_list[i]->type;
+ ftype = *percent = 's';
+ break;
+ case 'i':
+ int_arg = i;
+ ftype = 'i';
+ break;
+ case 'n':
+ text_arg = "\n";
+ ftype = *percent = 's';
+ break;
+ case '%':
+ ftype = 0;
+ break;
+ default:
+ fprintf (stderr,
+ "%s: unknown format specifier %%%c\n",
+ prog_name, *percent);
+ *percent = '%';
+ ftype = 0;
+ }
+ percent++;
+ cc = *percent;
+ *percent = 0;
+ switch (ftype)
+ {
+ case 's':
+ printf (start, text_arg);
+ break;
+ case 'i':
+ printf (start, int_arg);
+ break;
+ case 0:
+ printf (start);
+ break;
+ }
+ *percent = cc;
+ start = percent;
+ }
+ else
+ {
+ /* last char of the string is a '%', suppress it */
+ *start = 0;
+ break;
+ }
+ }
+ if (*start)
+ printf (start);
+ }
+ }
+ if (i == 0 && ch != 'f')
+ printf ("\nNo scanners were identified. If you were expecting "
+ "something different,\ncheck that the scanner is plugged "
+ "in, turned on and detected by the\nsane-find-scanner tool "
+ "(if appropriate). Please read the documentation\nwhich came "
+ "with this software (README, FAQ, manpages).\n");
+
+ if (defdevname)
+ printf ("default device is `%s'\n", defdevname);
+ exit (0);
+ }
+
+ case 'V':
+ printf ("scanimage (%s) %s; backend version %d.%d.%d\n", PACKAGE,
+ VERSION, SANE_VERSION_MAJOR (version_code),
+ SANE_VERSION_MINOR (version_code),
+ SANE_VERSION_BUILD (version_code));
+ exit (0);
+
+ default:
+ break; /* ignore device specific options for now */
+ }
+ }
+
+ if (help)
+ {
+ printf ("Usage: %s [OPTION]...\n\
+\n\
+Start image acquisition on a scanner device and write image data to\n\
+standard output.\n\
+\n\
+Parameters are separated by a blank from single-character options (e.g.\n\
+-d epson) and by a \"=\" from multi-character options (e.g. --device-name=epson).\n\
+-d, --device-name=DEVICE use a given scanner device (e.g. hp:/dev/scanner)\n\
+ --format=pnm|tiff file format of output file\n\
+-i, --icc-profile=PROFILE include this ICC profile into TIFF file\n", prog_name);
+ printf ("\
+-L, --list-devices show available scanner devices\n\
+-f, --formatted-device-list=FORMAT similar to -L, but the FORMAT of the output\n\
+ can be specified: %%d (device name), %%v (vendor),\n\
+ %%m (model), %%t (type), %%i (index number), and\n\
+ %%n (newline)\n\
+-b, --batch[=FORMAT] working in batch mode, FORMAT is `out%%d.pnm' or\n\
+ `out%%d.tif' by default depending on --format\n");
+ printf ("\
+ --batch-start=# page number to start naming files with\n\
+ --batch-count=# how many pages to scan in batch mode\n\
+ --batch-increment=# increase page number in filename by #\n\
+ --batch-double increment page number by two, same as\n\
+ --batch-increment=2\n\
+ --batch-prompt ask for pressing a key before scanning a page\n\
+ --accept-md5-only only accept authorization requests using md5\n");
+ printf ("\
+-p, --progress print progress messages\n\
+-n, --dont-scan only set options, don't actually scan\n\
+-T, --test test backend thoroughly\n\
+-A, --all-options list all available backend options\n\
+-h, --help display this help message and exit\n\
+-v, --verbose give even more status messages\n\
+-B, --buffer-size=# change input buffer size (in kB, default 32)\n\
+-V, --version print version information\n");
+ }
+
+ if (!devname)
+ {
+ /* If no device name was specified explicitly, we look at the
+ environment variable SANE_DEFAULT_DEVICE. If this variable
+ is not set, we open the first device we find (if any): */
+ devname = defdevname;
+ if (!devname)
+ {
+ 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));
+ exit (1);
+ }
+ if (!device_list[0])
+ {
+ fprintf (stderr, "%s: no SANE devices found\n", prog_name);
+ 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 (devname[0] == '/')
+ fprintf (stderr, "\nYou seem to have specified a UNIX device name, "
+ "or filename instead of selecting\nthe SANE scanner or "
+ "image acquisition device you want to use. As an example,\n"
+ "you might want \"epson:/dev/sg0\" or "
+ "\"hp:/dev/usbscanner0\". If any supported\ndevices are "
+ "installed in your system, you should be able to see a "
+ "list with\n\"scanimage --list-devices\".\n");
+ if (help)
+ device = 0;
+ else
+ exit (1);
+ }
+
+ if (device)
+ {
+ const SANE_Option_Descriptor * desc_ptr;
+
+ /* Good form to always get the descriptor once before value */
+ desc_ptr = sane_get_option_descriptor(device, 0);
+ if (!desc_ptr)
+ {
+ fprintf (stderr, "%s: unable to get option count descriptor\n",
+ prog_name);
+ exit (1);
+ }
+
+ /* 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);
+ exit (1);
+ }
+
+ /* malloc global option lists */
+ 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 main()\n",
+ prog_name);
+ exit (1);
+ }
+
+ /* load global option lists */
+ 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);
+ exit (1);
+ }
+
+ strcpy (full_optstring, BASE_OPTSTRING);
+ strcat (full_optstring, larg);
+ strcat (full_optstring, targ);
+ strcat (full_optstring, xarg);
+ strcat (full_optstring, yarg);
+ }
+
+ /* re-run argument processing with backend-specific options included
+ * this time, enable error printing and arg permutation */
+ optind = 0;
+ opterr = 1;
+ while ((ch = getopt_long (argc, argv, full_optstring, all_options,
+ &index)) != EOF)
+ {
+ switch (ch)
+ {
+ case ':':
+ case '?':
+ exit (1); /* error message is printed by getopt_long() */
+
+ case 'd':
+ case 'h':
+ case 'p':
+ case 'v':
+ case 'V':
+ case 'T':
+ case 'B':
+ /* 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;
+ }
+ }
+ if (optind < argc)
+ {
+ fprintf (stderr, "%s: argument without option: `%s'; ", prog_name,
+ argv[argc - 1]);
+ fprintf (stderr, "try %s --help\n", prog_name);
+ exit (1);
+ }
+
+ free (full_optstring);
+
+ /* convert x/y to br_x/br_y */
+ for (index = 0; index < 2; ++index)
+ if (window[index])
+ {
+ SANE_Word pos = 0;
+ SANE_Word val = window_val[index];
+
+ if (window[index + 2])
+ {
+ sane_control_option (device, window[index + 2],
+ SANE_ACTION_GET_VALUE, &pos, 0);
+ val += pos;
+ }
+ set_option (device, window[index], &val);
+ }
+
+ /* output device-specific help */
+ if (help)
+ {
+ printf ("\nOptions specific to device `%s':\n", devname);
+ print_options(device, num_dev_options, SANE_FALSE);
+ }
+
+ /* list all device-specific options */
+ if (all)
+ {
+ printf ("\nAll options specific to device `%s':\n", devname);
+ print_options(device, num_dev_options, SANE_TRUE);
+ exit (0);
+ }
+ }
+
+ /* output device list */
+ if (help)
+ {
+ printf ("\
+Type ``%s --help -d DEVICE'' to get list of all options for DEVICE.\n\
+\n\
+List of available devices:", prog_name);
+ 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);
+ exit (0);
+ }
+
+ if (dont_scan)
+ exit (0);
+
+ if (output_format != OUTPUT_PNM)
+ resolution_value = get_resolution ();
+
+#ifdef SIGHUP
+ signal (SIGHUP, sighandler);
+#endif
+#ifdef SIGPIPE
+ signal (SIGPIPE, sighandler);
+#endif
+ signal (SIGINT, sighandler);
+ signal (SIGTERM, sighandler);
+
+ if (test == 0)
+ {
+ int n = batch_start_at;
+
+ if (batch && NULL == format)
+ {
+ if (output_format == OUTPUT_TIFF)
+ format = "out%d.tif";
+ else
+ format = "out%d.pnm";
+ }
+
+ if (batch)
+ fprintf (stderr,
+ "Scanning %d pages, incrementing by %d, numbering from %d\n",
+ batch_count, batch_increment, batch_start_at);
+
+ else if(isatty(fileno(stdout))){
+ fprintf (stderr,"%s: output is not a file, exiting\n", prog_name);
+ exit (1);
+ }
+
+ buffer = malloc (buffer_size);
+
+ do
+ {
+ char path[PATH_MAX];
+ char part_path[PATH_MAX];
+ if (batch) /* format is NULL unless batch mode */
+ {
+ sprintf (path, format, n); /* love --(C++) */
+ strcpy (part_path, path);
+ strcat (part_path, ".part");
+ }
+
+
+ if (batch)
+ {
+ if (batch_prompt)
+ {
+ fprintf (stderr, "Place document no. %d on the scanner.\n",
+ n);
+ fprintf (stderr, "Press <RETURN> to continue.\n");
+ fprintf (stderr, "Press Ctrl + D to terminate.\n");
+ readbuf2 = fgets (readbuf, 2, stdin);
+
+ if (readbuf2 == NULL)
+ {
+ fprintf (stderr, "Batch terminated, %d pages scanned\n",
+ (n - batch_increment));
+ fclose (stdout);
+ break; /* get out of this loop */
+ }
+ }
+ fprintf (stderr, "Scanning page %d\n", n);
+ }
+
+#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)
+ {
+ fprintf (stderr, "%s: sane_start: %s\n",
+ prog_name, sane_strstatus (status));
+ fclose (stdout);
+ break;
+ }
+
+ /* write to .part file while scanning is in progress */
+ if (batch && NULL == freopen (part_path, "w", stdout))
+ {
+ fprintf (stderr, "cannot open %s\n", part_path);
+ sane_cancel (device);
+ return SANE_STATUS_ACCESS_DENIED;
+ }
+
+ status = scan_it ();
+ if (batch)
+ {
+ fprintf (stderr, "Scanned page %d.", n);
+ fprintf (stderr, " (scanner status = %d)\n", status);
+ }
+
+ switch (status)
+ {
+ case SANE_STATUS_GOOD:
+ case SANE_STATUS_EOF:
+ status = SANE_STATUS_GOOD;
+ if (batch)
+ {
+ /* close output file by redirecting, do not close
+ stdout here! */
+ if (NULL == freopen ("/dev/null", "w", stdout))
+ {
+ fprintf (stderr, "cannot open /dev/null\n");
+ sane_cancel (device);
+ return SANE_STATUS_ACCESS_DENIED;
+ }
+ else
+ {
+ /* let the fully scanned file show up */
+ if (rename (part_path, path))
+ {
+ fprintf (stderr, "cannot rename %s to %s\n",
+ part_path, path);
+ sane_cancel (device);
+ return SANE_STATUS_ACCESS_DENIED;
+ }
+ }
+ }
+ break;
+ default:
+ if (batch)
+ {
+ fclose (stdout);
+ unlink (part_path);
+ }
+ break;
+ } /* switch */
+ n += batch_increment;
+ }
+ while ((batch
+ && (batch_count == BATCH_COUNT_UNLIMITED || --batch_count))
+ && SANE_STATUS_GOOD == status);
+
+ sane_cancel (device);
+ }
+ else
+ status = test_it ();
+
+ return status;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 07:43:08 +0000