diff options
Diffstat (limited to 'backend/kvs1025_opt.c')
| -rw-r--r-- | backend/kvs1025_opt.c | 1581 |
1 files changed, 1581 insertions, 0 deletions
diff --git a/backend/kvs1025_opt.c b/backend/kvs1025_opt.c new file mode 100644 index 0000000..b7581f9 --- /dev/null +++ b/backend/kvs1025_opt.c @@ -0,0 +1,1581 @@ +/* + Copyright (C) 2008, Panasonic Russia Ltd. +*/ +/* sane - Scanner Access Now Easy. + Panasonic KV-S1020C / KV-S1025C USB scanners. +*/ + +#define DEBUG_DECLARE_ONLY + +#include "../include/sane/config.h" + +#include <errno.h> +#include <fcntl.h> +#include <limits.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> + +#include "../include/sane/sane.h" +#include "../include/sane/saneopts.h" +#include "../include/sane/sanei.h" +#include "../include/sane/sanei_usb.h" +#include "../include/sane/sanei_backend.h" +#include "../include/sane/sanei_config.h" +#include "../include/lassert.h" + +#include "kvs1025.h" +#include "kvs1025_low.h" + +#include "../include/sane/sanei_debug.h" + +/* Option lists */ + +static SANE_String_Const go_scan_mode_list[] = { + SANE_I18N ("bw"), + SANE_I18N ("halftone"), + SANE_I18N ("gray"), + SANE_I18N ("color"), + NULL +}; + +/* +static int go_scan_mode_val[] = { + 0x00, + 0x01, + 0x02, + 0x05 +};*/ + +static const SANE_Word go_resolutions_list[] = { + 11, /* list size */ + 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600 +}; + +/* List of scan sources */ +static SANE_String_Const go_scan_source_list[] = { + SANE_I18N ("adf"), + SANE_I18N ("fb"), + NULL +}; +static const int go_scan_source_val[] = { + 0, + 0x1 +}; + +/* List of feeder modes */ +static SANE_String_Const go_feeder_mode_list[] = { + SANE_I18N ("single"), + SANE_I18N ("continuous"), + NULL +}; +static const int go_feeder_mode_val[] = { + 0x00, + 0xff +}; + +/* List of manual feed mode */ +static SANE_String_Const go_manual_feed_list[] = { + SANE_I18N ("off"), + SANE_I18N ("wait_doc"), + SANE_I18N ("wait_key"), + NULL +}; +static const int go_manual_feed_val[] = { + 0x00, + 0x01, + 0x02 +}; + +/* List of paper sizes */ +static SANE_String_Const go_paper_list[] = { + SANE_I18N ("user_def"), + SANE_I18N ("business_card"), + SANE_I18N ("Check"), + /*SANE_I18N ("A3"), */ + SANE_I18N ("A4"), + SANE_I18N ("A5"), + SANE_I18N ("A6"), + SANE_I18N ("Letter"), + /*SANE_I18N ("Double letter 11x17 in"), + SANE_I18N ("B4"), */ + SANE_I18N ("B5"), + SANE_I18N ("B6"), + SANE_I18N ("Legal"), + NULL +}; +static const int go_paper_val[] = { + 0x00, + 0x01, + 0x02, + /*0x03, *//* A3 : not supported */ + 0x04, + 0x05, + 0x06, + 0x07, + /*0x09, + 0x0C, *//* Dbl letter and B4 : not supported */ + 0x0D, + 0x0E, + 0x0F +}; + +static const KV_PAPER_SIZE go_paper_sizes[] = { + {210, 297}, /* User defined, default=A4 */ + {54, 90}, /* Business card */ + {80, 170}, /* Check (China business) */ + /*{297, 420}, *//* A3 */ + {210, 297}, /* A4 */ + {148, 210}, /* A5 */ + {105, 148}, /* A6 */ + {216, 280}, /* US Letter 8.5 x 11 in */ + /*{280, 432}, *//* Double Letter 11 x 17 in */ + /*{250, 353}, *//* B4 */ + {176, 250}, /* B5 */ + {125, 176}, /* B6 */ + {216, 356} /* US Legal */ +}; + +static const int default_paper_size_idx = 3; /* A4 */ +static const int go_paper_max_width = 216; /* US letter */ + +/* Lists of supported halftone. They are only valid with + * for the Black&White mode. */ +static SANE_String_Const go_halftone_pattern_list[] = { + SANE_I18N ("bayer_64"), + SANE_I18N ("bayer_16"), + SANE_I18N ("halftone_32"), + SANE_I18N ("halftone_64"), + SANE_I18N ("diffusion"), + NULL +}; +static const int go_halftone_pattern_val[] = { + 0x00, + 0x01, + 0x02, + 0x03, + 0x04 +}; + +/* List of automatic threshold options */ +static SANE_String_Const go_automatic_threshold_list[] = { + SANE_I18N ("normal"), + SANE_I18N ("light"), + SANE_I18N ("dark"), + NULL +}; +static const int go_automatic_threshold_val[] = { + 0, + 0x11, + 0x1f +}; + +/* List of white level base. */ +static SANE_String_Const go_white_level_list[] = { + SANE_I18N ("From scanner"), + SANE_I18N ("From paper"), + SANE_I18N ("Automatic"), + NULL +}; +static const int go_white_level_val[] = { + 0x00, + 0x80, + 0x81 +}; + +/* List of noise reduction options. */ +static SANE_String_Const go_noise_reduction_list[] = { + SANE_I18N ("default"), + "1x1", + "2x2", + "3x3", + "4x4", + "5x5", + NULL +}; +static const int go_noise_reduction_val[] = { + 0x00, + 0x01, + 0x02, + 0x03, + 0x04, + 0x05 +}; + +/* List of image emphasis options, 5 steps */ +static SANE_String_Const go_image_emphasis_list[] = { + SANE_I18N ("smooth"), + SANE_I18N ("none"), + SANE_I18N ("low"), + SANE_I18N ("medium"), /* default */ + SANE_I18N ("high"), + NULL +}; +static const int go_image_emphasis_val[] = { + 0x14, + 0x00, + 0x11, + 0x12, + 0x13 +}; + +/* List of gamma */ +static SANE_String_Const go_gamma_list[] = { + SANE_I18N ("normal"), + SANE_I18N ("crt"), + SANE_I18N ("linier"), + NULL +}; +static const int go_gamma_val[] = { + 0x00, + 0x01, + 0x02 +}; + +/* List of lamp color dropout */ +static SANE_String_Const go_lamp_list[] = { + SANE_I18N ("normal"), + SANE_I18N ("red"), + SANE_I18N ("green"), + SANE_I18N ("blue"), + NULL +}; +static const int go_lamp_val[] = { + 0x00, + 0x01, + 0x02, + 0x03 +}; + +static SANE_Range go_value_range = { 0, 255, 0 }; + +static SANE_Range go_jpeg_compression_range = { 0, 0x64, 0 }; + +static SANE_Range go_rotate_range = { 0, 270, 90 }; + +static SANE_Range go_swdespeck_range = { 0, 9, 1 }; + +static SANE_Range go_swskip_range = { SANE_FIX(0), SANE_FIX(100), 1 }; + +static const char *go_option_name[] = { + "OPT_NUM_OPTS", + + /* General options */ + "OPT_MODE_GROUP", + "OPT_MODE", /* scanner modes */ + "OPT_RESOLUTION", /* X and Y resolution */ + "OPT_DUPLEX", /* Duplex mode */ + "OPT_SCAN_SOURCE", /* Scan source, fixed to ADF */ + "OPT_FEEDER_MODE", /* Feeder mode, fixed to Continous */ + "OPT_LONGPAPER", /* Long paper mode */ + "OPT_LENGTHCTL", /* Length control mode */ + "OPT_MANUALFEED", /* Manual feed mode */ + "OPT_FEED_TIMEOUT", /* Feed timeout */ + "OPT_DBLFEED", /* Double feed detection mode */ + "OPT_FIT_TO_PAGE", /* Scanner shrinks image to fit scanned page */ + + /* Geometry group */ + "OPT_GEOMETRY_GROUP", + "OPT_PAPER_SIZE", /* Paper size */ + "OPT_LANDSCAPE", /* true if landscape */ + "OPT_TL_X", /* upper left X */ + "OPT_TL_Y", /* upper left Y */ + "OPT_BR_X", /* bottom right X */ + "OPT_BR_Y", /* bottom right Y */ + + "OPT_ENHANCEMENT_GROUP", + "OPT_BRIGHTNESS", /* Brightness */ + "OPT_CONTRAST", /* Contrast */ + "OPT_AUTOMATIC_THRESHOLD", /* Binary threshold */ + "OPT_HALFTONE_PATTERN", /* Halftone pattern */ + "OPT_AUTOMATIC_SEPARATION", /* Automatic separation */ + "OPT_WHITE_LEVEL", /* White level */ + "OPT_NOISE_REDUCTION", /* Noise reduction */ + "OPT_IMAGE_EMPHASIS", /* Image emphasis */ + "OPT_GAMMA", /* Gamma */ + "OPT_LAMP", /* Lamp -- color drop out */ + "OPT_INVERSE", /* Inverse image */ + "OPT_MIRROR", /* Mirror image */ + "OPT_JPEG", /* JPEG Compression */ + "OPT_ROTATE", /* Rotate image */ + + "OPT_SWDESKEW", /* Software deskew */ + "OPT_SWDESPECK", /* Software despeckle */ + "OPT_SWDEROTATE", /* Software detect/correct 90 deg. rotation */ + "OPT_SWCROP", /* Software autocrop */ + "OPT_SWSKIP", /* Software blank page skip */ + + /* must come last: */ + "OPT_NUM_OPTIONS" +}; + + +/* Round to boundry, return 1 if value modified */ +static int +round_to_boundry (SANE_Word * pval, SANE_Word boundry, + SANE_Word minv, SANE_Word maxv) +{ + SANE_Word lower, upper, k, v; + + v = *pval; + k = v / boundry; + lower = k * boundry; + upper = (k + 1) * boundry; + + if (v - lower <= upper - v) + { + *pval = lower; + } + else + { + *pval = upper; + } + + if ((*pval) < minv) + *pval = minv; + if ((*pval) > maxv) + *pval = maxv; + + return ((*pval) != v); +} + +/* Returns the length of the longest string, including the terminating + * character. */ +static size_t +max_string_size (SANE_String_Const * strings) +{ + size_t size, max_size = 0; + int i; + + for (i = 0; strings[i]; ++i) + { + size = strlen (strings[i]) + 1; + if (size > max_size) + { + max_size = size; + } + } + + return max_size; +} + +/* Lookup a string list from one array and return its index. */ +static int +get_string_list_index (const SANE_String_Const * list, SANE_String_Const name) +{ + int index; + + index = 0; + while (list[index] != NULL) + { + if (strcmp (list[index], name) == 0) + { + return (index); + } + index++; + } + + DBG (DBG_error, "System bug: option %s not found in list\n", name); + + return (-1); /* not found */ +} + + +/* Lookup a string list from one array and return the correnpond value. */ +int +get_optval_list (const PKV_DEV dev, int idx, + const SANE_String_Const * str_list, const int *val_list) +{ + int index; + + index = get_string_list_index (str_list, dev->val[idx].s); + + if (index < 0) + index = 0; + + return val_list[index]; +} + + +/* Get device mode from device options */ +KV_SCAN_MODE +kv_get_mode (const PKV_DEV dev) +{ + int i; + + i = get_string_list_index (go_scan_mode_list, dev->val[OPT_MODE].s); + + switch (i) + { + case 0: + return SM_BINARY; + case 1: + return SM_DITHER; + case 2: + return SM_GRAYSCALE; + case 3: + return SM_COLOR; + default: + assert (0 == 1); + return 0; + } +} + +void +kv_calc_paper_size (const PKV_DEV dev, int *w, int *h) +{ + int i = get_string_list_index (go_paper_list, + dev->val[OPT_PAPER_SIZE].s); + if (i == 0) + { /* Non-standard document */ + int x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w)); + int y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w)); + int x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w)); + int y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w)); + *w = x_br - x_tl; + *h = y_br - y_tl; + } + else + { + if (dev->val[OPT_LANDSCAPE].s) + { + *h = mmToIlu (go_paper_sizes[i].width); + *w = mmToIlu (go_paper_sizes[i].height); + } + else + { + *w = mmToIlu (go_paper_sizes[i].width); + *h = mmToIlu (go_paper_sizes[i].height); + } + } +} + +/* Get bit depth from scan mode */ +int +kv_get_depth (KV_SCAN_MODE mode) +{ + switch (mode) + { + case SM_BINARY: + case SM_DITHER: + return 1; + case SM_GRAYSCALE: + return 8; + case SM_COLOR: + return 24; + default: + assert (0 == 1); + return 0; + } +} + +const SANE_Option_Descriptor * +kv_get_option_descriptor (PKV_DEV dev, SANE_Int option) +{ + DBG (DBG_proc, "sane_get_option_descriptor: enter, option %s\n", + go_option_name[option]); + + if ((unsigned) option >= OPT_NUM_OPTIONS) + { + return NULL; + } + + DBG (DBG_proc, "sane_get_option_descriptor: exit\n"); + + return dev->opt + option; +} + +/* Reset the options for that scanner. */ +void +kv_init_options (PKV_DEV dev) +{ + int i; + + if (dev->option_set) + return; + + DBG (DBG_proc, "kv_init_options: enter\n"); + + /* Pre-initialize the options. */ + memset (dev->opt, 0, sizeof (dev->opt)); + memset (dev->val, 0, sizeof (dev->val)); + + for (i = 0; i < OPT_NUM_OPTIONS; ++i) + { + dev->opt[i].size = sizeof (SANE_Word); + dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + + /* Number of options. */ + dev->opt[OPT_NUM_OPTS].name = ""; + dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; + dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; + dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; + dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS; + + /* Mode group */ + dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode"); + dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_MODE_GROUP].cap = 0; + dev->opt[OPT_MODE_GROUP].size = 0; + dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* Scanner supported modes */ + dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; + dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; + dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; + dev->opt[OPT_MODE].type = SANE_TYPE_STRING; + dev->opt[OPT_MODE].size = max_string_size (go_scan_mode_list); + dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_MODE].constraint.string_list = go_scan_mode_list; + dev->val[OPT_MODE].s = strdup (""); /* will be set later */ + + /* X and Y resolution */ + dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; + dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; + dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; + dev->opt[OPT_RESOLUTION].constraint.word_list = go_resolutions_list; + dev->val[OPT_RESOLUTION].w = go_resolutions_list[3]; + + /* Duplex */ + dev->opt[OPT_DUPLEX].name = SANE_NAME_DUPLEX; + dev->opt[OPT_DUPLEX].title = SANE_TITLE_DUPLEX; + dev->opt[OPT_DUPLEX].desc = SANE_DESC_DUPLEX; + dev->opt[OPT_DUPLEX].type = SANE_TYPE_BOOL; + dev->opt[OPT_DUPLEX].unit = SANE_UNIT_NONE; + dev->val[OPT_DUPLEX].w = SANE_FALSE; + if (!dev->support_info.support_duplex) + dev->opt[OPT_DUPLEX].cap |= SANE_CAP_INACTIVE; + + /* Scan source */ + dev->opt[OPT_SCAN_SOURCE].name = SANE_NAME_SCAN_SOURCE; + dev->opt[OPT_SCAN_SOURCE].title = SANE_TITLE_SCAN_SOURCE; + dev->opt[OPT_SCAN_SOURCE].desc = SANE_I18N ("Sets the scan source"); + dev->opt[OPT_SCAN_SOURCE].type = SANE_TYPE_STRING; + dev->opt[OPT_SCAN_SOURCE].size = max_string_size (go_scan_source_list); + dev->opt[OPT_SCAN_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_SCAN_SOURCE].constraint.string_list = go_scan_source_list; + dev->val[OPT_SCAN_SOURCE].s = strdup (go_scan_source_list[0]); + dev->opt[OPT_SCAN_SOURCE].cap &= ~SANE_CAP_SOFT_SELECT; + /* for KV-S1020C / KV-S1025C, scan source is fixed to ADF */ + + /* Feeder mode */ + dev->opt[OPT_FEEDER_MODE].name = "feeder-mode"; + dev->opt[OPT_FEEDER_MODE].title = SANE_I18N ("Feeder mode"); + dev->opt[OPT_FEEDER_MODE].desc = SANE_I18N ("Sets the feeding mode"); + dev->opt[OPT_FEEDER_MODE].type = SANE_TYPE_STRING; + dev->opt[OPT_FEEDER_MODE].size = max_string_size (go_feeder_mode_list); + dev->opt[OPT_FEEDER_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_FEEDER_MODE].constraint.string_list = go_feeder_mode_list; + dev->val[OPT_FEEDER_MODE].s = strdup (go_feeder_mode_list[1]); + + /* Long paper */ + dev->opt[OPT_LONGPAPER].name = SANE_NAME_LONGPAPER; + dev->opt[OPT_LONGPAPER].title = SANE_TITLE_LONGPAPER; + dev->opt[OPT_LONGPAPER].desc = SANE_I18N ("Enable/Disable long paper mode"); + dev->opt[OPT_LONGPAPER].type = SANE_TYPE_BOOL; + dev->opt[OPT_LONGPAPER].unit = SANE_UNIT_NONE; + dev->val[OPT_LONGPAPER].w = SANE_FALSE; + + /* Length control */ + dev->opt[OPT_LENGTHCTL].name = SANE_NAME_LENGTHCTL; + dev->opt[OPT_LENGTHCTL].title = SANE_TITLE_LENGTHCTL; + dev->opt[OPT_LENGTHCTL].desc = + SANE_I18N ("Enable/Disable length control mode"); + dev->opt[OPT_LENGTHCTL].type = SANE_TYPE_BOOL; + dev->opt[OPT_LENGTHCTL].unit = SANE_UNIT_NONE; + dev->val[OPT_LENGTHCTL].w = SANE_TRUE; + + /* Manual feed */ + dev->opt[OPT_MANUALFEED].name = SANE_NAME_MANUALFEED; + dev->opt[OPT_MANUALFEED].title = SANE_TITLE_MANUALFEED; + dev->opt[OPT_MANUALFEED].desc = SANE_I18N ("Sets the manual feed mode"); + dev->opt[OPT_MANUALFEED].type = SANE_TYPE_STRING; + dev->opt[OPT_MANUALFEED].size = max_string_size (go_manual_feed_list); + dev->opt[OPT_MANUALFEED].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_MANUALFEED].constraint.string_list = go_manual_feed_list; + dev->val[OPT_MANUALFEED].s = strdup (go_manual_feed_list[0]); + + /*Manual feed timeout */ + dev->opt[OPT_FEED_TIMEOUT].name = SANE_NAME_FEED_TIMEOUT; + dev->opt[OPT_FEED_TIMEOUT].title = SANE_TITLE_FEED_TIMEOUT; + dev->opt[OPT_FEED_TIMEOUT].desc = + SANE_I18N ("Sets the manual feed timeout in seconds"); + dev->opt[OPT_FEED_TIMEOUT].type = SANE_TYPE_INT; + dev->opt[OPT_FEED_TIMEOUT].unit = SANE_UNIT_NONE; + dev->opt[OPT_FEED_TIMEOUT].size = sizeof (SANE_Int); + dev->opt[OPT_FEED_TIMEOUT].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_FEED_TIMEOUT].constraint.range = &(go_value_range); + dev->opt[OPT_FEED_TIMEOUT].cap |= SANE_CAP_INACTIVE; + dev->val[OPT_FEED_TIMEOUT].w = 30; + + /* Double feed */ + dev->opt[OPT_DBLFEED].name = SANE_NAME_DBLFEED; + dev->opt[OPT_DBLFEED].title = SANE_TITLE_DBLFEED; + dev->opt[OPT_DBLFEED].desc = + SANE_I18N ("Enable/Disable double feed detection"); + dev->opt[OPT_DBLFEED].type = SANE_TYPE_BOOL; + dev->opt[OPT_DBLFEED].unit = SANE_UNIT_NONE; + dev->val[OPT_DBLFEED].w = SANE_FALSE; + + /* Fit to page */ + dev->opt[OPT_FIT_TO_PAGE].name = SANE_I18N ("fit-to-page"); + dev->opt[OPT_FIT_TO_PAGE].title = SANE_I18N ("Fit to page"); + dev->opt[OPT_FIT_TO_PAGE].desc = + SANE_I18N ("Scanner shrinks image to fit scanned page"); + dev->opt[OPT_FIT_TO_PAGE].type = SANE_TYPE_BOOL; + dev->opt[OPT_FIT_TO_PAGE].unit = SANE_UNIT_NONE; + dev->val[OPT_FIT_TO_PAGE].w = SANE_FALSE; + + /* Geometry group */ + dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry"); + dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_GEOMETRY_GROUP].cap = 0; + dev->opt[OPT_GEOMETRY_GROUP].size = 0; + dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* Paper sizes list */ + dev->opt[OPT_PAPER_SIZE].name = SANE_NAME_PAPER_SIZE; + dev->opt[OPT_PAPER_SIZE].title = SANE_TITLE_PAPER_SIZE; + dev->opt[OPT_PAPER_SIZE].desc = SANE_DESC_PAPER_SIZE; + dev->opt[OPT_PAPER_SIZE].type = SANE_TYPE_STRING; + dev->opt[OPT_PAPER_SIZE].size = max_string_size (go_paper_list); + dev->opt[OPT_PAPER_SIZE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_PAPER_SIZE].constraint.string_list = go_paper_list; + dev->val[OPT_PAPER_SIZE].s = strdup (""); /* will be set later */ + + /* Landscape */ + dev->opt[OPT_LANDSCAPE].name = SANE_NAME_LANDSCAPE; + dev->opt[OPT_LANDSCAPE].title = SANE_TITLE_LANDSCAPE; + dev->opt[OPT_LANDSCAPE].desc = + SANE_I18N ("Set paper position : " + "true for landscape, false for portrait"); + dev->opt[OPT_LANDSCAPE].type = SANE_TYPE_BOOL; + dev->opt[OPT_LANDSCAPE].unit = SANE_UNIT_NONE; + dev->val[OPT_LANDSCAPE].w = SANE_FALSE; + + /* Upper left X */ + dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; + dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; + dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; + dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED; + dev->opt[OPT_TL_X].unit = SANE_UNIT_MM; + dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_TL_X].constraint.range = &(dev->x_range); + + /* Upper left Y */ + dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; + dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; + dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; + dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; + dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM; + dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_TL_Y].constraint.range = &(dev->y_range); + + /* Bottom-right x */ + dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; + dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; + dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; + dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED; + dev->opt[OPT_BR_X].unit = SANE_UNIT_MM; + dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BR_X].constraint.range = &(dev->x_range); + + /* Bottom-right y */ + dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; + dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; + dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; + dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; + dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM; + dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BR_Y].constraint.range = &(dev->y_range); + + /* Enhancement group */ + dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); + dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED; + dev->opt[OPT_ENHANCEMENT_GROUP].size = 0; + dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* Brightness */ + dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; + dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; + dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; + dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; + dev->opt[OPT_BRIGHTNESS].size = sizeof (SANE_Int); + dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BRIGHTNESS].constraint.range = &(go_value_range); + dev->val[OPT_BRIGHTNESS].w = 128; + + /* Contrast */ + dev->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST; + dev->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; + dev->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; + dev->opt[OPT_CONTRAST].type = SANE_TYPE_INT; + dev->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE; + dev->opt[OPT_CONTRAST].size = sizeof (SANE_Int); + dev->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_CONTRAST].constraint.range = &(go_value_range); + dev->val[OPT_CONTRAST].w = 128; + + /* Automatic threshold */ + dev->opt[OPT_AUTOMATIC_THRESHOLD].name = "automatic-threshold"; + dev->opt[OPT_AUTOMATIC_THRESHOLD].title = SANE_I18N ("Automatic threshold"); + dev->opt[OPT_AUTOMATIC_THRESHOLD].desc = + SANE_I18N + ("Automatically sets brightness, contrast, white level, " + "gamma, noise reduction and image emphasis"); + dev->opt[OPT_AUTOMATIC_THRESHOLD].type = SANE_TYPE_STRING; + dev->opt[OPT_AUTOMATIC_THRESHOLD].size = + max_string_size (go_automatic_threshold_list); + dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint_type = + SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint.string_list = + go_automatic_threshold_list; + dev->val[OPT_AUTOMATIC_THRESHOLD].s = + strdup (go_automatic_threshold_list[0]); + + /* Halftone pattern */ + dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING; + dev->opt[OPT_HALFTONE_PATTERN].size = + max_string_size (go_halftone_pattern_list); + dev->opt[OPT_HALFTONE_PATTERN].constraint_type = + SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list = + go_halftone_pattern_list; + dev->val[OPT_HALFTONE_PATTERN].s = strdup (go_halftone_pattern_list[0]); + + /* Automatic separation */ + dev->opt[OPT_AUTOMATIC_SEPARATION].name = SANE_NAME_AUTOSEP; + dev->opt[OPT_AUTOMATIC_SEPARATION].title = SANE_TITLE_AUTOSEP; + dev->opt[OPT_AUTOMATIC_SEPARATION].desc = SANE_DESC_AUTOSEP; + dev->opt[OPT_AUTOMATIC_SEPARATION].type = SANE_TYPE_BOOL; + dev->opt[OPT_AUTOMATIC_SEPARATION].unit = SANE_UNIT_NONE; + dev->val[OPT_AUTOMATIC_SEPARATION].w = SANE_FALSE; + + /* White level base */ + dev->opt[OPT_WHITE_LEVEL].name = SANE_NAME_WHITE_LEVEL; + dev->opt[OPT_WHITE_LEVEL].title = SANE_TITLE_WHITE_LEVEL; + dev->opt[OPT_WHITE_LEVEL].desc = SANE_DESC_WHITE_LEVEL; + dev->opt[OPT_WHITE_LEVEL].type = SANE_TYPE_STRING; + dev->opt[OPT_WHITE_LEVEL].size = max_string_size (go_white_level_list); + dev->opt[OPT_WHITE_LEVEL].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_WHITE_LEVEL].constraint.string_list = go_white_level_list; + dev->val[OPT_WHITE_LEVEL].s = strdup (go_white_level_list[0]); + + /* Noise reduction */ + dev->opt[OPT_NOISE_REDUCTION].name = "noise-reduction"; + dev->opt[OPT_NOISE_REDUCTION].title = SANE_I18N ("Noise reduction"); + dev->opt[OPT_NOISE_REDUCTION].desc = + SANE_I18N ("Reduce the isolated dot noise"); + dev->opt[OPT_NOISE_REDUCTION].type = SANE_TYPE_STRING; + dev->opt[OPT_NOISE_REDUCTION].size = + max_string_size (go_noise_reduction_list); + dev->opt[OPT_NOISE_REDUCTION].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_NOISE_REDUCTION].constraint.string_list = + go_noise_reduction_list; + dev->val[OPT_NOISE_REDUCTION].s = strdup (go_noise_reduction_list[0]); + + /* Image emphasis */ + dev->opt[OPT_IMAGE_EMPHASIS].name = "image-emphasis"; + dev->opt[OPT_IMAGE_EMPHASIS].title = SANE_I18N ("Image emphasis"); + dev->opt[OPT_IMAGE_EMPHASIS].desc = SANE_I18N ("Sets the image emphasis"); + dev->opt[OPT_IMAGE_EMPHASIS].type = SANE_TYPE_STRING; + dev->opt[OPT_IMAGE_EMPHASIS].size = + max_string_size (go_image_emphasis_list); + dev->opt[OPT_IMAGE_EMPHASIS].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_IMAGE_EMPHASIS].constraint.string_list = + go_image_emphasis_list; + dev->val[OPT_IMAGE_EMPHASIS].s = strdup (SANE_I18N ("medium")); + + /* Gamma */ + dev->opt[OPT_GAMMA].name = "gamma"; + dev->opt[OPT_GAMMA].title = SANE_I18N ("Gamma"); + dev->opt[OPT_GAMMA].desc = SANE_I18N ("Gamma"); + dev->opt[OPT_GAMMA].type = SANE_TYPE_STRING; + dev->opt[OPT_GAMMA].size = max_string_size (go_gamma_list); + dev->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_GAMMA].constraint.string_list = go_gamma_list; + dev->val[OPT_GAMMA].s = strdup (go_gamma_list[0]); + + /* Lamp color dropout */ + dev->opt[OPT_LAMP].name = "lamp-color"; + dev->opt[OPT_LAMP].title = SANE_I18N ("Lamp color"); + dev->opt[OPT_LAMP].desc = SANE_I18N ("Sets the lamp color (color dropout)"); + dev->opt[OPT_LAMP].type = SANE_TYPE_STRING; + dev->opt[OPT_LAMP].size = max_string_size (go_lamp_list); + dev->opt[OPT_LAMP].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_LAMP].constraint.string_list = go_lamp_list; + dev->val[OPT_LAMP].s = strdup (go_lamp_list[0]); + if (!dev->support_info.support_lamp) + dev->opt[OPT_LAMP].cap |= SANE_CAP_INACTIVE; + + /* Inverse image */ + dev->opt[OPT_INVERSE].name = SANE_NAME_INVERSE; + dev->opt[OPT_INVERSE].title = SANE_TITLE_INVERSE; + dev->opt[OPT_INVERSE].desc = + SANE_I18N ("Inverse image in B/W or halftone mode"); + dev->opt[OPT_INVERSE].type = SANE_TYPE_BOOL; + dev->opt[OPT_INVERSE].unit = SANE_UNIT_NONE; + dev->val[OPT_INVERSE].w = SANE_FALSE; + + /* Mirror image (left/right flip) */ + dev->opt[OPT_MIRROR].name = SANE_NAME_MIRROR; + dev->opt[OPT_MIRROR].title = SANE_TITLE_MIRROR; + dev->opt[OPT_MIRROR].desc = SANE_I18N ("Mirror image (left/right flip)"); + dev->opt[OPT_MIRROR].type = SANE_TYPE_BOOL; + dev->opt[OPT_MIRROR].unit = SANE_UNIT_NONE; + dev->val[OPT_MIRROR].w = SANE_FALSE; + + /* JPEG Image Compression */ + dev->opt[OPT_JPEG].name = "jpeg"; + dev->opt[OPT_JPEG].title = SANE_I18N ("jpeg compression"); + dev->opt[OPT_JPEG].desc = + SANE_I18N + ("JPEG Image Compression with Q parameter, '0' - no compression"); + dev->opt[OPT_JPEG].type = SANE_TYPE_INT; + dev->opt[OPT_JPEG].unit = SANE_UNIT_NONE; + dev->opt[OPT_JPEG].size = sizeof (SANE_Int); + dev->opt[OPT_JPEG].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_JPEG].constraint.range = &(go_jpeg_compression_range); + dev->val[OPT_JPEG].w = 0; + + /* Image Rotation */ + dev->opt[OPT_ROTATE].name = "rotate"; + dev->opt[OPT_ROTATE].title = SANE_I18N ("Rotate image clockwise"); + dev->opt[OPT_ROTATE].desc = + SANE_I18N("Request driver to rotate pages by a fixed amount"); + dev->opt[OPT_ROTATE].type = SANE_TYPE_INT; + dev->opt[OPT_ROTATE].unit = SANE_UNIT_NONE; + dev->opt[OPT_ROTATE].size = sizeof (SANE_Int); + dev->opt[OPT_ROTATE].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_ROTATE].constraint.range = &(go_rotate_range); + dev->val[OPT_ROTATE].w = 0; + + /* Software Deskew */ + dev->opt[OPT_SWDESKEW].name = "swdeskew"; + dev->opt[OPT_SWDESKEW].title = SANE_I18N ("Software deskew"); + dev->opt[OPT_SWDESKEW].desc = + SANE_I18N("Request driver to rotate skewed pages digitally"); + dev->opt[OPT_SWDESKEW].type = SANE_TYPE_BOOL; + dev->opt[OPT_SWDESKEW].unit = SANE_UNIT_NONE; + dev->val[OPT_SWDESKEW].w = SANE_FALSE; + + /* Software Despeckle */ + dev->opt[OPT_SWDESPECK].name = "swdespeck"; + dev->opt[OPT_SWDESPECK].title = SANE_I18N ("Software despeckle diameter"); + dev->opt[OPT_SWDESPECK].desc = + SANE_I18N("Maximum diameter of lone dots to remove from scan"); + dev->opt[OPT_SWDESPECK].type = SANE_TYPE_INT; + dev->opt[OPT_SWDESPECK].unit = SANE_UNIT_NONE; + dev->opt[OPT_SWDESPECK].size = sizeof (SANE_Int); + dev->opt[OPT_SWDESPECK].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_SWDESPECK].constraint.range = &(go_swdespeck_range); + dev->val[OPT_SWDESPECK].w = 0; + + /* Software Derotate */ + dev->opt[OPT_SWDEROTATE].name = "swderotate"; + dev->opt[OPT_SWDEROTATE].title = SANE_I18N ("Software derotate"); + dev->opt[OPT_SWDEROTATE].desc = + SANE_I18N("Request driver to detect and correct 90 degree image rotation"); + dev->opt[OPT_SWDEROTATE].type = SANE_TYPE_BOOL; + dev->opt[OPT_SWDEROTATE].unit = SANE_UNIT_NONE; + dev->val[OPT_SWDEROTATE].w = SANE_FALSE; + + /* Software Autocrop*/ + dev->opt[OPT_SWCROP].name = "swcrop"; + dev->opt[OPT_SWCROP].title = SANE_I18N ("Software automatic cropping"); + dev->opt[OPT_SWCROP].desc = + SANE_I18N("Request driver to remove border from pages digitally"); + dev->opt[OPT_SWCROP].type = SANE_TYPE_BOOL; + dev->opt[OPT_SWCROP].unit = SANE_UNIT_NONE; + dev->val[OPT_SWCROP].w = SANE_FALSE; + + /* Software blank page skip */ + dev->opt[OPT_SWSKIP].name = "swskip"; + dev->opt[OPT_SWSKIP].title = SANE_I18N ("Software blank skip percentage"); + dev->opt[OPT_SWSKIP].desc + = SANE_I18N("Request driver to discard pages with low numbers of dark pixels"); + dev->opt[OPT_SWSKIP].type = SANE_TYPE_FIXED; + dev->opt[OPT_SWSKIP].unit = SANE_UNIT_PERCENT; + dev->opt[OPT_SWSKIP].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_SWSKIP].constraint.range = &(go_swskip_range); + + /* Lastly, set the default scan mode. This might change some + * values previously set here. */ + sane_control_option (dev, OPT_PAPER_SIZE, SANE_ACTION_SET_VALUE, + (void *) go_paper_list[default_paper_size_idx], NULL); + sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE, + (void *) go_scan_mode_list[0], NULL); + + DBG (DBG_proc, "kv_init_options: exit\n"); + + dev->option_set = 1; +} + + +SANE_Status +kv_control_option (PKV_DEV dev, SANE_Int option, + SANE_Action action, void *val, SANE_Int * info) +{ + SANE_Status status; + SANE_Word cap; + SANE_String_Const name; + int i; + SANE_Word value; + + DBG (DBG_proc, "sane_control_option: enter, option %s, action %s\n", + go_option_name[option], action == SANE_ACTION_GET_VALUE ? "R" : "W"); + + if (info) + { + *info = 0; + } + + if (dev->scanning) + { + return SANE_STATUS_DEVICE_BUSY; + } + + if (option < 0 || option >= OPT_NUM_OPTIONS) + { + return SANE_STATUS_UNSUPPORTED; + } + + cap = dev->opt[option].cap; + if (!SANE_OPTION_IS_ACTIVE (cap)) + { + return SANE_STATUS_UNSUPPORTED; + } + + name = dev->opt[option].name; + if (!name) + { + name = "(no name)"; + } + if (action == SANE_ACTION_GET_VALUE) + { + switch (option) + { + /* word options */ + case OPT_NUM_OPTS: + case OPT_LONGPAPER: + case OPT_LENGTHCTL: + case OPT_DBLFEED: + case OPT_RESOLUTION: + case OPT_TL_Y: + case OPT_BR_Y: + case OPT_TL_X: + case OPT_BR_X: + case OPT_BRIGHTNESS: + case OPT_CONTRAST: + case OPT_DUPLEX: + case OPT_LANDSCAPE: + case OPT_AUTOMATIC_SEPARATION: + case OPT_INVERSE: + case OPT_MIRROR: + case OPT_FEED_TIMEOUT: + case OPT_JPEG: + case OPT_ROTATE: + case OPT_SWDESKEW: + case OPT_SWDESPECK: + case OPT_SWDEROTATE: + case OPT_SWCROP: + case OPT_SWSKIP: + case OPT_FIT_TO_PAGE: + *(SANE_Word *) val = dev->val[option].w; + DBG (DBG_error, "opt value = %d\n", *(SANE_Word *) val); + return SANE_STATUS_GOOD; + + /* string options */ + case OPT_MODE: + case OPT_FEEDER_MODE: + case OPT_SCAN_SOURCE: + case OPT_MANUALFEED: + case OPT_HALFTONE_PATTERN: + case OPT_PAPER_SIZE: + case OPT_AUTOMATIC_THRESHOLD: + case OPT_WHITE_LEVEL: + case OPT_NOISE_REDUCTION: + case OPT_IMAGE_EMPHASIS: + case OPT_GAMMA: + case OPT_LAMP: + + strcpy (val, dev->val[option].s); + DBG (DBG_error, "opt value = %s\n", (char *) val); + return SANE_STATUS_GOOD; + + default: + return SANE_STATUS_UNSUPPORTED; + } + } + else if (action == SANE_ACTION_SET_VALUE) + { + if (!SANE_OPTION_IS_SETTABLE (cap)) + { + DBG (DBG_error, + "could not set option %s, not settable\n", + go_option_name[option]); + return SANE_STATUS_INVAL; + } + + status = sanei_constrain_value (dev->opt + option, val, info); + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_error, "could not set option, invalid value\n"); + return status; + } + + switch (option) + { + /* Side-effect options */ + case OPT_TL_Y: + case OPT_BR_Y: + case OPT_RESOLUTION: + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + + dev->val[option].w = *(SANE_Word *) val; + + if (option == OPT_RESOLUTION) + { + if (round_to_boundry (&(dev->val[option].w), + dev->support_info. + step_resolution, 100, 600)) + { + if (info) + { + *info |= SANE_INFO_INEXACT; + } + } + } + else if (option == OPT_TL_Y) + { + if (dev->val[option].w > dev->val[OPT_BR_Y].w) + { + dev->val[option].w = dev->val[OPT_BR_Y].w; + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_INEXACT; + } + } + } + else + { + if (dev->val[option].w < dev->val[OPT_TL_Y].w) + { + dev->val[option].w = dev->val[OPT_TL_Y].w; + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_INEXACT; + } + } + } + + DBG (DBG_error, + "option %s, input = %d, value = %d\n", + go_option_name[option], (*(SANE_Word *) val), + dev->val[option].w); + + return SANE_STATUS_GOOD; + + /* The length of X must be rounded (up). */ + case OPT_TL_X: + case OPT_BR_X: + { + SANE_Word xr = dev->val[OPT_RESOLUTION].w; + SANE_Word tl_x = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w)) * xr; + SANE_Word br_x = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w)) * xr; + value = mmToIlu (SANE_UNFIX (*(SANE_Word *) val)) * xr; /* XR * W */ + + if (option == OPT_TL_X) + { + SANE_Word max = KV_PIXEL_MAX * xr - KV_PIXEL_ROUND; + if (br_x < max) + max = br_x; + if (round_to_boundry (&value, KV_PIXEL_ROUND, 0, max)) + { + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_INEXACT; + } + } + } + else + { + if (round_to_boundry + (&value, KV_PIXEL_ROUND, tl_x, KV_PIXEL_MAX * xr)) + { + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_INEXACT; + } + } + } + + dev->val[option].w = SANE_FIX (iluToMm ((double) value / xr)); + + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + + DBG (DBG_error, + "option %s, input = %d, value = %d\n", + go_option_name[option], (*(SANE_Word *) val), + dev->val[option].w); + return SANE_STATUS_GOOD; + } + case OPT_LANDSCAPE: + dev->val[option].w = *(SANE_Word *) val; + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + return SANE_STATUS_GOOD; + + /* Side-effect free options */ + case OPT_CONTRAST: + case OPT_BRIGHTNESS: + case OPT_DUPLEX: + case OPT_LONGPAPER: + case OPT_LENGTHCTL: + case OPT_DBLFEED: + case OPT_INVERSE: + case OPT_MIRROR: + case OPT_AUTOMATIC_SEPARATION: + case OPT_JPEG: + case OPT_ROTATE: + case OPT_SWDESKEW: + case OPT_SWDESPECK: + case OPT_SWDEROTATE: + case OPT_SWCROP: + case OPT_SWSKIP: + case OPT_FIT_TO_PAGE: + dev->val[option].w = *(SANE_Word *) val; + return SANE_STATUS_GOOD; + + case OPT_FEED_TIMEOUT: + dev->val[option].w = *(SANE_Word *) val; + return CMD_set_timeout (dev, *(SANE_Word *) val); + + /* String mode */ + case OPT_SCAN_SOURCE: + case OPT_WHITE_LEVEL: + case OPT_NOISE_REDUCTION: + case OPT_IMAGE_EMPHASIS: + case OPT_GAMMA: + case OPT_LAMP: + case OPT_HALFTONE_PATTERN: + case OPT_FEEDER_MODE: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; + free (dev->val[option].s); + dev->val[option].s = (SANE_String) strdup (val); + + if (option == OPT_FEEDER_MODE && + get_string_list_index (go_feeder_mode_list, + dev->val[option].s) == 1) + /* continuous mode */ + { + free (dev->val[OPT_SCAN_SOURCE].s); + dev->val[OPT_SCAN_SOURCE].s = strdup (go_scan_source_list[0]); + dev->opt[OPT_LONGPAPER].cap &= ~SANE_CAP_INACTIVE; + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + } + else + { + dev->opt[OPT_LONGPAPER].cap |= SANE_CAP_INACTIVE; + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + } + + if (option == OPT_SCAN_SOURCE && + get_string_list_index (go_scan_source_list, + dev->val[option].s) == 1) + /* flatbed */ + { + free (dev->val[OPT_FEEDER_MODE].s); + dev->val[OPT_FEEDER_MODE].s = strdup (go_feeder_mode_list[0]); + } + + return SANE_STATUS_GOOD; + + case OPT_MODE: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; + free (dev->val[OPT_MODE].s); + dev->val[OPT_MODE].s = (SANE_String) strdup (val); + + /* Set default options for the scan modes. */ + dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_INVERSE].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_JPEG].cap &= ~SANE_CAP_INACTIVE; + + if (strcmp (dev->val[OPT_MODE].s, go_scan_mode_list[0]) == 0) + /* binary */ + { + dev->opt[OPT_AUTOMATIC_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_INVERSE].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_JPEG].cap |= SANE_CAP_INACTIVE; + } + else if (strcmp (dev->val[OPT_MODE].s, go_scan_mode_list[1]) == 0) + /* halftone */ + { + dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_INVERSE].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_JPEG].cap |= SANE_CAP_INACTIVE; + } + else if (strcmp (dev->val[OPT_MODE].s, go_scan_mode_list[2]) == 0) + /* grayscale */ + { + dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE; + } + + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + } + + return SANE_STATUS_GOOD; + + case OPT_MANUALFEED: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; + free (dev->val[option].s); + dev->val[option].s = (SANE_String) strdup (val); + + if (strcmp (dev->val[option].s, go_manual_feed_list[0]) == 0) /* off */ + dev->opt[OPT_FEED_TIMEOUT].cap |= SANE_CAP_INACTIVE; + else + dev->opt[OPT_FEED_TIMEOUT].cap &= ~SANE_CAP_INACTIVE; + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + + return SANE_STATUS_GOOD; + + case OPT_PAPER_SIZE: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; + + free (dev->val[OPT_PAPER_SIZE].s); + dev->val[OPT_PAPER_SIZE].s = (SANE_Char *) strdup (val); + + i = get_string_list_index (go_paper_list, + dev->val[OPT_PAPER_SIZE].s); + if (i == 0) + { /*user def */ + dev->opt[OPT_TL_X].cap &= + dev->opt[OPT_TL_Y].cap &= + dev->opt[OPT_BR_X].cap &= + dev->opt[OPT_BR_Y].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_LANDSCAPE].cap |= SANE_CAP_INACTIVE; + dev->val[OPT_LANDSCAPE].w = 0; + } + else + { + dev->opt[OPT_TL_X].cap |= + dev->opt[OPT_TL_Y].cap |= + dev->opt[OPT_BR_X].cap |= + dev->opt[OPT_BR_Y].cap |= SANE_CAP_INACTIVE; + if (i == 4 || i == 5 || i == 7) + { /*A5, A6 or B6 */ + dev->opt[OPT_LANDSCAPE].cap &= ~SANE_CAP_INACTIVE; + } + else + { + dev->opt[OPT_LANDSCAPE].cap |= SANE_CAP_INACTIVE; + dev->val[OPT_LANDSCAPE].w = 0; + } + } + + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + + return SANE_STATUS_GOOD; + + + case OPT_AUTOMATIC_THRESHOLD: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; + + free (dev->val[option].s); + dev->val[option].s = (SANE_Char *) strdup (val); + + /* If the threshold is not set to none, some option must + * disappear. */ + + dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_IMAGE_EMPHASIS].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + + if (strcmp (val, go_automatic_threshold_list[0]) == 0) + { + dev->opt[OPT_WHITE_LEVEL].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_IMAGE_EMPHASIS].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE; + if (strcmp (dev->val[OPT_MODE].s, go_scan_mode_list[1]) == 0) + { + dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; + } + } + + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + } + return SANE_STATUS_GOOD; + + default: + return SANE_STATUS_INVAL; + } + } + + DBG (DBG_proc, "sane_control_option: exit, bad\n"); + + return SANE_STATUS_UNSUPPORTED; +} + +/* Display a buffer in the log. */ +void +hexdump (int level, const char *comment, unsigned char *p, int l) +{ + int i; + char line[128]; + char *ptr; + + DBG (level, "%s\n", comment); + ptr = line; + for (i = 0; i < l; i++, p++) + { + if ((i % 16) == 0) + { + if (ptr != line) + { + *ptr = '\0'; + DBG (level, "%s\n", line); + ptr = line; + } + sprintf (ptr, "%3.3d:", i); + ptr += 4; + } + sprintf (ptr, " %2.2x", *p); + ptr += 3; + } + *ptr = '\0'; + DBG (level, "%s\n", line); +} + +/* Set window data */ +void +kv_set_window_data (PKV_DEV dev, + KV_SCAN_MODE scan_mode, + int side, unsigned char *windowdata) +{ + int paper = go_paper_val[get_string_list_index (go_paper_list, + dev->val[OPT_PAPER_SIZE]. + s)]; + + /* Page side */ + windowdata[0] = side; + + /* X and Y resolution */ + Ito16 (dev->val[OPT_RESOLUTION].w, &windowdata[2]); + Ito16 (dev->val[OPT_RESOLUTION].w, &windowdata[4]); + + /* Width and length */ + if (paper == 0) + { /* Non-standard document */ + int x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w)); + int y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w)); + int x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w)); + int y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w)); + int width = x_br - x_tl; + int length = y_br - y_tl; + /* Upper Left (X,Y) */ + Ito32 (x_tl, &windowdata[6]); + Ito32 (y_tl, &windowdata[10]); + + Ito32 (width, &windowdata[14]); + Ito32 (length, &windowdata[18]); + Ito32 (width, &windowdata[48]); /* device specific */ + Ito32 (length, &windowdata[52]); /* device specific */ + } + + /* Brightness */ + windowdata[22] = 255 - GET_OPT_VAL_W (dev, OPT_BRIGHTNESS); + windowdata[23] = windowdata[22]; /* threshold, same as brightness. */ + + /* Contrast */ + windowdata[24] = GET_OPT_VAL_W (dev, OPT_CONTRAST); + + /* Image Composition */ + windowdata[25] = (unsigned char) scan_mode; + + /* Depth */ + windowdata[26] = kv_get_depth (scan_mode); + + /* Halftone pattern. */ + if (scan_mode == SM_DITHER) + { + windowdata[28] = GET_OPT_VAL_L (dev, OPT_HALFTONE_PATTERN, + halftone_pattern); + } + + /* Inverse */ + if (scan_mode == SM_BINARY || scan_mode == SM_DITHER) + { + windowdata[29] = GET_OPT_VAL_W (dev, OPT_INVERSE); + } + + /* Bit ordering */ + windowdata[31] = 1; + + /*Compression Type */ + if (!(dev->opt[OPT_JPEG].cap & SANE_CAP_INACTIVE) + && GET_OPT_VAL_W (dev, OPT_JPEG)) + { + windowdata[32] = 0x81; /*jpeg */ + /*Compression Argument */ + windowdata[33] = GET_OPT_VAL_W (dev, OPT_JPEG); + } + + /* Gamma */ + if (scan_mode == SM_DITHER || scan_mode == SM_GRAYSCALE) + { + windowdata[44] = GET_OPT_VAL_L (dev, OPT_GAMMA, gamma); + } + + /* Feeder mode */ + windowdata[57] = GET_OPT_VAL_L (dev, OPT_FEEDER_MODE, feeder_mode); + + /* Stop skew -- disabled */ + windowdata[41] = 0; + + /* Scan source */ + if (GET_OPT_VAL_L (dev, OPT_SCAN_SOURCE, scan_source)) + { /* flatbed */ + windowdata[41] |= 0x80; + } + else + { + windowdata[41] &= 0x7f; + } + + /* Paper size */ + windowdata[47] = paper; + + if (paper) /* Standard Document */ + windowdata[47] |= 1 << 7; + + /* Long paper */ + if (GET_OPT_VAL_W (dev, OPT_LONGPAPER)) + { + windowdata[47] |= 0x20; + } + + /* Length control */ + if (GET_OPT_VAL_W (dev, OPT_LENGTHCTL)) + { + windowdata[47] |= 0x40; + } + + /* Landscape */ + if (GET_OPT_VAL_W (dev, OPT_LANDSCAPE)) + { + windowdata[47] |= 1 << 4; + } + /* Double feed */ + if (GET_OPT_VAL_W (dev, OPT_DBLFEED)) + { + windowdata[56] = 0x10; + } + + /* Fit to page */ + if (GET_OPT_VAL_W (dev, OPT_FIT_TO_PAGE)) + { + windowdata[56] |= 1 << 2; + } + + /* Manual feed */ + windowdata[62] = GET_OPT_VAL_L (dev, OPT_MANUALFEED, manual_feed) << 6; + + /* Mirror image */ + if (GET_OPT_VAL_W (dev, OPT_MIRROR)) + { + windowdata[42] = 0x80; + } + + /* Image emphasis */ + windowdata[43] = GET_OPT_VAL_L (dev, OPT_IMAGE_EMPHASIS, image_emphasis); + + /* White level */ + windowdata[60] = GET_OPT_VAL_L (dev, OPT_WHITE_LEVEL, white_level); + + if (scan_mode == SM_BINARY || scan_mode == SM_DITHER) + { + /* Noise reduction */ + windowdata[61] = GET_OPT_VAL_L (dev, OPT_NOISE_REDUCTION, + noise_reduction); + + /* Automatic separation */ + if (scan_mode == SM_DITHER && GET_OPT_VAL_W (dev, + OPT_AUTOMATIC_SEPARATION)) + { + windowdata[59] = 0x80; + } + } + + /* Automatic threshold. Must be last because it may override + * some previous options. */ + if (scan_mode == SM_BINARY) + { + windowdata[58] = + GET_OPT_VAL_L (dev, OPT_AUTOMATIC_THRESHOLD, automatic_threshold); + } + + if (windowdata[58] != 0) + { + /* Automatic threshold is enabled. */ + windowdata[22] = 0; /* brightness. */ + windowdata[23] = 0; /* threshold, same as brightness. */ + windowdata[24] = 0; /* contrast */ + windowdata[27] = windowdata[28] = 0; /* Halftone pattern. */ + windowdata[43] = 0; /* Image emphasis */ + windowdata[59] = 0; /* Automatic separation */ + windowdata[60] = 0; /* White level */ + windowdata[61] = 0; /* Noise reduction */ + } + + /* lamp -- color dropout */ + windowdata[45] = GET_OPT_VAL_L (dev, OPT_LAMP, lamp) << 4; + + /*Stop Mode: After 1 page */ + windowdata[63] = 1; +} |