From 6e9c41a892ed0e0da326e0278b3221ce3f5713b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Mon, 6 Oct 2014 14:00:40 +0200 Subject: Initial import of sane-backends version 1.0.24-1.2 --- frontend/scanimage.c | 2365 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2365 insertions(+) create mode 100644 frontend/scanimage.c (limited to 'frontend/scanimage.c') 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 +#include "lgetopt.h" +#include +#include +#include +#include +#include +#include + +#include +#include + +#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 ("", stdout); + break; + case SANE_TYPE_FIXED: + fputs ("", stdout); + break; + case SANE_TYPE_STRING: + fputs ("", 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 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; +} -- cgit v1.2.3