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 --- backend/snapscan-options.c | 1922 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1922 insertions(+) create mode 100644 backend/snapscan-options.c (limited to 'backend/snapscan-options.c') diff --git a/backend/snapscan-options.c b/backend/snapscan-options.c new file mode 100644 index 0000000..15f3a4a --- /dev/null +++ b/backend/snapscan-options.c @@ -0,0 +1,1922 @@ +/* sane - Scanner Access Now Easy. + + Copyright (C) 1997, 1998, 2001, 2013 Franck Schnefra, Michel Roelofs, + Emmanuel Blot, Mikko Tyolajarvi, David Mosberger-Tang, Wolfgang Goeller, + Petter Reinholdtsen, Gary Plewa, Sebastien Sable, Mikael Magnusson, + Andrew Goodbody, Oliver Schwartz and Kevin Charter + + This file is part of the SANE package. + + 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., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + This file is a component of the implementation of a backend for many + of the the AGFA SnapScan and Acer Vuego/Prisa flatbed scanners. */ + +/* $Id$ + SANE SnapScan backend */ + +/* default option values */ + +#define DEFAULT_RES 300 +#define DEFAULT_PREVIEW SANE_FALSE +#define DEFAULT_HIGHQUALITY SANE_FALSE +#define DEFAULT_BRIGHTNESS 0 +#define DEFAULT_CONTRAST 0 +#define DEFAULT_GAMMA SANE_FIX(1.8) +#define DEFAULT_HALFTONE SANE_FALSE +#define DEFAULT_NEGATIVE SANE_FALSE +#define DEFAULT_THRESHOLD 50 +#define DEFAULT_QUALITY SANE_TRUE +#define DEFAULT_CUSTOM_GAMMA SANE_FALSE +#define DEFAULT_GAMMA_BIND SANE_FALSE + +static SANE_Int def_rgb_lpr = 4; +static SANE_Int def_gs_lpr = 12; +static SANE_Int def_bpp = 8; +static SANE_Int def_frame_no = 1; + + +/* predefined preview mode name */ +static char md_auto[] = "Auto"; + +/* predefined focus mode name */ +static char md_manual[] = "Manual"; + +/* predefined scan mode names */ +static char md_colour[] = SANE_VALUE_SCAN_MODE_COLOR; +static char md_bilevelcolour[] = SANE_VALUE_SCAN_MODE_HALFTONE; +static char md_greyscale[] = SANE_VALUE_SCAN_MODE_GRAY; +static char md_lineart[] = SANE_VALUE_SCAN_MODE_LINEART; + +/* predefined scan source names */ +static char src_flatbed[] = SANE_I18N("Flatbed"); +static char src_tpo[] = SANE_I18N("Transparency Adapter"); +static char src_adf[] = SANE_I18N("Document Feeder"); + +/* predefined scan window setting names */ +static char pdw_none[] = SANE_I18N("None"); +static char pdw_6X4[] = SANE_I18N("6x4 (inch)"); +static char pdw_8X10[] = SANE_I18N("8x10 (inch)"); +static char pdw_85X11[] = SANE_I18N("8.5x11 (inch)"); + +/* predefined dither matrix names */ +static char dm_none[] = SANE_I18N("Halftoning Unsupported"); +static char dm_dd8x8[] = SANE_I18N("DispersedDot8x8"); +static char dm_dd16x16[] = SANE_I18N("DispersedDot16x16"); + +/* strings */ +static char lpr_desc[] = SANE_I18N( + "Number of scan lines to request in a SCSI read. " + "Changing this parameter allows you to tune the speed at which " + "data is read from the scanner during scans. If this is set too " + "low, the scanner will have to stop periodically in the middle of " + "a scan; if it's set too high, X-based frontends may stop responding " + "to X events and your system could bog down."); + +static char frame_desc[] = SANE_I18N( + "Frame number of media holder that should be scanned."); + +static char focus_mode_desc[] = SANE_I18N( + "Use manual or automatic selection of focus point."); + +static char focus_desc[] = SANE_I18N( + "Focus point for scanning."); + +/* ranges */ +static const SANE_Range x_range_fb = +{ + SANE_FIX (0.0), SANE_FIX (216.0), 0 +}; /* mm */ +static const SANE_Range y_range_fb = +{ + SANE_FIX (0.0), SANE_FIX (297.0), 0 +}; /* mm */ + +/* default TPO range (shortest y_range + to avoid tray collision. +*/ +static const SANE_Range x_range_tpo_default = +{ + SANE_FIX (0.0), SANE_FIX (129.0), 0 +}; /* mm */ +static const SANE_Range y_range_tpo_default = +{ + SANE_FIX (0.0), SANE_FIX (180.0), 0 +}; /* mm */ + +/* TPO range for the Agfa 1236 */ +static const SANE_Range x_range_tpo_1236 = +{ + SANE_FIX (0.0), SANE_FIX (203.0), 0 +}; /* mm */ +static const SANE_Range y_range_tpo_1236 = +{ + SANE_FIX (0.0), SANE_FIX (254.0), 0 +}; /* mm */ + +/* TPO range for the Agfa e50 */ +static const SANE_Range x_range_tpo_e50 = +{ + SANE_FIX (0.0), SANE_FIX (40.0), 0 +}; /* mm */ +static const SANE_Range y_range_tpo_e50 = +{ + SANE_FIX (0.0), SANE_FIX (240.0), 0 +}; /* mm */ + +/* TPO range for the Epson 1670 */ +static const SANE_Range x_range_tpo_1670 = +{ + SANE_FIX (0.0), SANE_FIX (101.0), 0 +}; /* mm */ +static const SANE_Range y_range_tpo_1670 = +{ + SANE_FIX (0.0), SANE_FIX (228.0), 0 +}; /* mm */ + +/* TPO range for the Epson 2480 */ +static const SANE_Range x_range_tpo_2480 = +{ + SANE_FIX (0.0), SANE_FIX (55.0), 0 +}; /* mm */ +static const SANE_Range y_range_tpo_2480 = +{ + SANE_FIX (0.0), SANE_FIX (125.0), 0 +}; /* mm */ +/* TPO range for the Epson 2580 */ +static const SANE_Range x_range_tpo_2580 = +{ + SANE_FIX (0.0), SANE_FIX (55.0), 0 +}; /* mm */ +static const SANE_Range y_range_tpo_2580 = +{ + SANE_FIX (0.0), SANE_FIX (80.0), 0 +}; /* mm */ + +/* TPO range for the Scanwit 2720S */ +static const SANE_Range x_range_tpo_2720s = +{ + SANE_FIX (0.0), SANE_FIX (23.6), 0 +}; /* mm */ +static const SANE_Range y_range_tpo_2720s = +{ + SANE_FIX (0.0), SANE_FIX (35.7), 0 +}; /* mm */ + +/* TPO range for the Epson 3490 */ +static const SANE_Range x_range_tpo_3490 = +{ + SANE_FIX (0.0), SANE_FIX (33.0), 0 +}; /* mm */ +static const SANE_Range y_range_tpo_3490 = +{ + SANE_FIX (0.0), SANE_FIX (162.0), 0 +}; /* mm */ + +static SANE_Range x_range_tpo; +static SANE_Range y_range_tpo; +static const SANE_Range gamma_range = +{ + SANE_FIX (0.0), SANE_FIX (4.0), 0 +}; +static const SANE_Range gamma_vrange = +{ + 0, 65535, 1 +}; +static const SANE_Range lpr_range = +{ + 1, 50, 1 +}; +static const SANE_Range frame_range = +{ + 1, 6, 1 +}; +static const SANE_Range focus_range = +{ + 0, 0x300, 6 +}; + +static const SANE_Range brightness_range = +{ + -400 << SANE_FIXED_SCALE_SHIFT, + 400 << SANE_FIXED_SCALE_SHIFT, + 1 << SANE_FIXED_SCALE_SHIFT +}; + +static const SANE_Range contrast_range = +{ + -100 << SANE_FIXED_SCALE_SHIFT, + 400 << SANE_FIXED_SCALE_SHIFT, + 1 << SANE_FIXED_SCALE_SHIFT +}; + +static const SANE_Range positive_percent_range = +{ + 0 << SANE_FIXED_SCALE_SHIFT, + 100 << SANE_FIXED_SCALE_SHIFT, + 1 << SANE_FIXED_SCALE_SHIFT +}; + +static void control_options(SnapScan_Scanner *pss); + +/* init_options -- initialize the option set for a scanner; expects the + scanner structure's hardware configuration byte (hconfig) to be valid. + + ARGS: a pointer to an existing scanner structure + RET: nothing + SIDE: the option set of *ps is initialized; this includes both + the option descriptors and the option values themselves */ +static void init_options (SnapScan_Scanner * ps) +{ + static SANE_Word resolutions_300[] = + {6, 50, 75, 100, 150, 200, 300}; + static SANE_Word resolutions_600[] = + {8, 50, 75, 100, 150, 200, 300, 450, 600}; + static SANE_Word resolutions_1200[] = + {10, 50, 75, 100, 150, 200, 300, 450, 600, 900, 1200}; + static SANE_Word resolutions_1200_5000e[] = + {9, 50, 75, 100, 150, 200, 300, 450, 600, 1200}; + static SANE_Word resolutions_1600[] = + {10, 50, 75, 100, 150, 200, 300, 400, 600, 800, 1600}; + static SANE_Word resolutions_2400[] = + {10, 50, 75, 100, 150, 200, 300, 400, 600, 1200, 2400}; + static SANE_Word resolutions_2700[] = + {4, 337, 675, 1350, 2700}; + static SANE_Word resolutions_3200[] = + {15, 50, 150, 200, 240, 266, 300, 350, 360, 400, 600, 720, 800, 1200, 1600, 3200}; + static SANE_String_Const names_all[] = + {md_colour, md_bilevelcolour, md_greyscale, md_lineart, NULL}; + static SANE_String_Const names_basic[] = + {md_colour, md_greyscale, md_lineart, NULL}; + static SANE_String_Const preview_names_all[] = + {md_auto, md_colour, md_bilevelcolour, md_greyscale, md_lineart, NULL}; + static SANE_String_Const preview_names_basic[] = + {md_auto, md_colour, md_greyscale, md_lineart, NULL}; + static SANE_String_Const focus_modes[] = + {md_auto, md_manual, NULL}; + static SANE_Int bit_depth_list[4]; + int bit_depths; + SANE_Option_Descriptor *po = ps->options; + + /* Initialize TPO range */ + switch (ps->pdev->model) + { + case SNAPSCAN1236: + x_range_tpo = x_range_tpo_1236; + y_range_tpo = y_range_tpo_1236; + break; + case SNAPSCANE20: + case SNAPSCANE50: + case SNAPSCANE52: + x_range_tpo = x_range_tpo_e50; + y_range_tpo = y_range_tpo_e50; + break; + case PERFECTION1270: + case PERFECTION1670: + x_range_tpo = x_range_tpo_1670; + y_range_tpo = y_range_tpo_1670; + break; + case PERFECTION2480: + if (ps->hconfig_epson & 0x20) + { + x_range_tpo = x_range_tpo_2580; + y_range_tpo = y_range_tpo_2580; + } + else + { + x_range_tpo = x_range_tpo_2480; + y_range_tpo = y_range_tpo_2480; + } + break; + case SCANWIT2720S: + x_range_tpo = x_range_tpo_2720s; + y_range_tpo = y_range_tpo_2720s; + break; + case PERFECTION3490: + x_range_tpo = x_range_tpo_3490; + y_range_tpo = y_range_tpo_3490; + break; + default: + x_range_tpo = x_range_tpo_default; + y_range_tpo = y_range_tpo_default; + break; + } + + /* Initialize option descriptors */ + po[OPT_COUNT].name = SANE_NAME_NUM_OPTIONS; + po[OPT_COUNT].title = SANE_TITLE_NUM_OPTIONS; + po[OPT_COUNT].desc = SANE_DESC_NUM_OPTIONS; + po[OPT_COUNT].type = SANE_TYPE_INT; + po[OPT_COUNT].unit = SANE_UNIT_NONE; + po[OPT_COUNT].size = sizeof (SANE_Word); + po[OPT_COUNT].cap = SANE_CAP_SOFT_DETECT; + { + static SANE_Range count_range = + {NUM_OPTS, NUM_OPTS, 0}; + po[OPT_COUNT].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_COUNT].constraint.range = &count_range; + } + + po[OPT_MODE_GROUP].title = SANE_I18N("Scan Mode"); + po[OPT_MODE_GROUP].desc = ""; + po[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + po[OPT_MODE_GROUP].cap = 0; + po[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + ps->res = DEFAULT_RES; + po[OPT_SCANRES].name = SANE_NAME_SCAN_RESOLUTION; + po[OPT_SCANRES].title = SANE_TITLE_SCAN_RESOLUTION; + po[OPT_SCANRES].desc = SANE_DESC_SCAN_RESOLUTION; + po[OPT_SCANRES].type = SANE_TYPE_INT; + po[OPT_SCANRES].unit = SANE_UNIT_DPI; + po[OPT_SCANRES].size = sizeof (SANE_Word); + po[OPT_SCANRES].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_AUTOMATIC; + po[OPT_SCANRES].constraint_type = SANE_CONSTRAINT_WORD_LIST; + switch (ps->pdev->model) + { + case SNAPSCAN310: + case PRISA310: /* WG changed */ + po[OPT_SCANRES].constraint.word_list = resolutions_300; + break; + case SNAPSCANE50: + case SNAPSCANE52: + case PRISA5300: + case PRISA1240: + case ARCUS1200: + po[OPT_SCANRES].constraint.word_list = resolutions_1200; + break; + case PRISA5000E: + case PRISA5000: + case PRISA5150: + po[OPT_SCANRES].constraint.word_list = resolutions_1200_5000e; + break; + case PERFECTION1670: + po[OPT_SCANRES].constraint.word_list = resolutions_1600; + break; + case PERFECTION2480: + po[OPT_SCANRES].constraint.word_list = resolutions_2400; + break; + case PERFECTION3490: + po[OPT_SCANRES].constraint.word_list = resolutions_3200; + break; + case SCANWIT2720S: + po[OPT_SCANRES].constraint.word_list = resolutions_2700; + ps->val[OPT_SCANRES].w = 1350; + ps->res = 1350; + break; + default: + po[OPT_SCANRES].constraint.word_list = resolutions_600; + break; + } + DBG (DL_OPTION_TRACE, + "sane_init_options resolution is %d\n", ps->res); + + po[OPT_PREVIEW].name = SANE_NAME_PREVIEW; + po[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; + po[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; + po[OPT_PREVIEW].type = SANE_TYPE_BOOL; + po[OPT_PREVIEW].unit = SANE_UNIT_NONE; + po[OPT_PREVIEW].size = sizeof (SANE_Word); + po[OPT_PREVIEW].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_AUTOMATIC; + po[OPT_PREVIEW].constraint_type = SANE_CONSTRAINT_NONE; + ps->preview = DEFAULT_PREVIEW; + + po[OPT_HIGHQUALITY].name = "high-quality"; + po[OPT_HIGHQUALITY].title = SANE_I18N("Quality scan"); + po[OPT_HIGHQUALITY].desc = SANE_I18N("Highest quality but lower speed"); + po[OPT_HIGHQUALITY].type = SANE_TYPE_BOOL; + po[OPT_HIGHQUALITY].unit = SANE_UNIT_NONE; + po[OPT_HIGHQUALITY].size = sizeof (SANE_Word); + po[OPT_HIGHQUALITY].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_AUTOMATIC; + po[OPT_HIGHQUALITY].constraint_type = SANE_CONSTRAINT_NONE; + ps->highquality = DEFAULT_HIGHQUALITY; + if (ps->pdev->model == PERFECTION1270) + { + po[OPT_HIGHQUALITY].cap |= SANE_CAP_INACTIVE; + ps->val[OPT_HIGHQUALITY].b = SANE_TRUE; + ps->highquality=SANE_TRUE; + } + + po[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; + po[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; + po[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + po[OPT_BRIGHTNESS].type = SANE_TYPE_FIXED; + po[OPT_BRIGHTNESS].unit = SANE_UNIT_PERCENT; + po[OPT_BRIGHTNESS].size = sizeof (int); + po[OPT_BRIGHTNESS].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + po[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_BRIGHTNESS].constraint.range = &brightness_range; + ps->bright = DEFAULT_BRIGHTNESS; + + po[OPT_CONTRAST].name = SANE_NAME_CONTRAST; + po[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; + po[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; + po[OPT_CONTRAST].type = SANE_TYPE_FIXED; + po[OPT_CONTRAST].unit = SANE_UNIT_PERCENT; + po[OPT_CONTRAST].size = sizeof (int); + po[OPT_CONTRAST].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + po[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_CONTRAST].constraint.range = &contrast_range; + ps->contrast = DEFAULT_CONTRAST; + + po[OPT_MODE].name = SANE_NAME_SCAN_MODE; + po[OPT_MODE].title = SANE_TITLE_SCAN_MODE; + po[OPT_MODE].desc = SANE_DESC_SCAN_MODE; + po[OPT_MODE].type = SANE_TYPE_STRING; + po[OPT_MODE].unit = SANE_UNIT_NONE; + po[OPT_MODE].size = 32; + po[OPT_MODE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_AUTOMATIC; + po[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + switch (ps->pdev->model) + { + case SNAPSCAN310: + case PRISA310: + case PERFECTION3490: + po[OPT_MODE].constraint.string_list = names_basic; + break; + default: + po[OPT_MODE].constraint.string_list = names_all; + break; + } + ps->mode_s = md_colour; + ps->mode = MD_COLOUR; + + po[OPT_PREVIEW_MODE].name = "preview-mode"; + po[OPT_PREVIEW_MODE].title = SANE_I18N("Preview mode"); + po[OPT_PREVIEW_MODE].desc = SANE_I18N( + "Select the mode for previews. Greyscale previews usually give " + "the best combination of speed and detail."); + po[OPT_PREVIEW_MODE].type = SANE_TYPE_STRING; + po[OPT_PREVIEW_MODE].unit = SANE_UNIT_NONE; + po[OPT_PREVIEW_MODE].size = 32; + po[OPT_PREVIEW_MODE].cap = SANE_CAP_SOFT_SELECT + | SANE_CAP_SOFT_DETECT + | SANE_CAP_ADVANCED + | SANE_CAP_AUTOMATIC; + po[OPT_PREVIEW_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + switch (ps->pdev->model) + { + case SNAPSCAN310: + case PRISA310: + case PERFECTION3490: + po[OPT_PREVIEW_MODE].constraint.string_list = preview_names_basic; + break; + default: + po[OPT_PREVIEW_MODE].constraint.string_list = preview_names_all; + break; + } + ps->preview_mode_s = md_auto; + ps->preview_mode = ps->mode; + + /* source */ + po[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE; + po[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE; + po[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE; + po[OPT_SOURCE].type = SANE_TYPE_STRING; + po[OPT_SOURCE].cap = SANE_CAP_SOFT_SELECT + | SANE_CAP_SOFT_DETECT + | SANE_CAP_INACTIVE + | SANE_CAP_AUTOMATIC; + po[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + { + static SANE_String_Const source_list[3]; + int i = 0; + + source_list[i++]= src_flatbed; + if (ps->hconfig & HCFG_TPO) + { + source_list[i++] = src_tpo; + po[OPT_SOURCE].cap &= ~SANE_CAP_INACTIVE; + } + if (ps->hconfig & HCFG_ADF) + { + source_list[i++] = src_adf; + po[OPT_SOURCE].cap &= ~SANE_CAP_INACTIVE; + } + source_list[i] = 0; + po[OPT_SOURCE].size = max_string_size(source_list); + po[OPT_SOURCE].constraint.string_list = source_list; + if (ps->pdev->model == SCANWIT2720S) + { + ps->source = SRC_TPO; + ps->source_s = (SANE_Char *) strdup(src_tpo); + ps->pdev->x_range.max = x_range_tpo.max; + ps->pdev->y_range.max = y_range_tpo.max; + } + else + { + ps->source = SRC_FLATBED; + ps->source_s = (SANE_Char *) strdup(src_flatbed); + } + } + + po[OPT_GEOMETRY_GROUP].title = SANE_I18N("Geometry"); + po[OPT_GEOMETRY_GROUP].desc = ""; + po[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; + po[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED; + po[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + po[OPT_TLX].name = SANE_NAME_SCAN_TL_X; + po[OPT_TLX].title = SANE_TITLE_SCAN_TL_X; + po[OPT_TLX].desc = SANE_DESC_SCAN_TL_X; + po[OPT_TLX].type = SANE_TYPE_FIXED; + po[OPT_TLX].unit = SANE_UNIT_MM; + po[OPT_TLX].size = sizeof (SANE_Word); + po[OPT_TLX].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_AUTOMATIC; + po[OPT_TLX].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_TLX].constraint.range = &(ps->pdev->x_range); + ps->tlx = ps->pdev->x_range.min; + + po[OPT_TLY].name = SANE_NAME_SCAN_TL_Y; + po[OPT_TLY].title = SANE_TITLE_SCAN_TL_Y; + po[OPT_TLY].desc = SANE_DESC_SCAN_TL_Y; + po[OPT_TLY].type = SANE_TYPE_FIXED; + po[OPT_TLY].unit = SANE_UNIT_MM; + po[OPT_TLY].size = sizeof (SANE_Word); + po[OPT_TLY].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_AUTOMATIC; + po[OPT_TLY].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_TLY].constraint.range = &(ps->pdev->y_range); + ps->tly = ps->pdev->y_range.min; + + po[OPT_BRX].name = SANE_NAME_SCAN_BR_X; + po[OPT_BRX].title = SANE_TITLE_SCAN_BR_X; + po[OPT_BRX].desc = SANE_DESC_SCAN_BR_X; + po[OPT_BRX].type = SANE_TYPE_FIXED; + po[OPT_BRX].unit = SANE_UNIT_MM; + po[OPT_BRX].size = sizeof (SANE_Word); + po[OPT_BRX].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_AUTOMATIC; + po[OPT_BRX].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_BRX].constraint.range = &(ps->pdev->x_range); + ps->brx = ps->pdev->x_range.max; + + po[OPT_BRY].name = SANE_NAME_SCAN_BR_Y; + po[OPT_BRY].title = SANE_TITLE_SCAN_BR_Y; + po[OPT_BRY].desc = SANE_DESC_SCAN_BR_Y; + po[OPT_BRY].type = SANE_TYPE_FIXED; + po[OPT_BRY].unit = SANE_UNIT_MM; + po[OPT_BRY].size = sizeof (SANE_Word); + po[OPT_BRY].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_AUTOMATIC; + po[OPT_BRY].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_BRY].constraint.range = &(ps->pdev->y_range); + ps->bry = ps->pdev->y_range.max; + + po[OPT_PREDEF_WINDOW].name = "predef-window"; + po[OPT_PREDEF_WINDOW].title = SANE_I18N("Predefined settings"); + po[OPT_PREDEF_WINDOW].desc = SANE_I18N( + "Provides standard scanning areas for photographs, printed pages " + "and the like."); + po[OPT_PREDEF_WINDOW].type = SANE_TYPE_STRING; + po[OPT_PREDEF_WINDOW].unit = SANE_UNIT_NONE; + po[OPT_PREDEF_WINDOW].size = 32; + po[OPT_PREDEF_WINDOW].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + { + static SANE_String_Const names[] = + {pdw_none, pdw_6X4, pdw_8X10, pdw_85X11, NULL}; + po[OPT_PREDEF_WINDOW].constraint_type = SANE_CONSTRAINT_STRING_LIST; + po[OPT_PREDEF_WINDOW].constraint.string_list = names; + } + ps->predef_window = pdw_none; + + po[OPT_ENHANCEMENT_GROUP].title = SANE_I18N("Enhancement"); + po[OPT_ENHANCEMENT_GROUP].desc = ""; + po[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; + po[OPT_ENHANCEMENT_GROUP].cap = 0; + po[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + /* bit depth */ + po[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH; + po[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH; + po[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH; + po[OPT_BIT_DEPTH].type = SANE_TYPE_INT; + po[OPT_BIT_DEPTH].unit = SANE_UNIT_BIT; + po[OPT_BIT_DEPTH].size = sizeof (SANE_Word); + po[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST; + po[OPT_BIT_DEPTH].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + bit_depths = 0; + bit_depth_list[++bit_depths] = def_bpp; + switch (ps->pdev->model) + { + case PERFECTION2480: + case PERFECTION3490: + bit_depth_list[++bit_depths] = 16; + break; + case SCANWIT2720S: + bit_depth_list[bit_depths] = 12; + break; + default: + break; + } + bit_depth_list[0] = bit_depths; + po[OPT_BIT_DEPTH].constraint.word_list = bit_depth_list; + if (ps->pdev->model == SCANWIT2720S) + { + ps->val[OPT_BIT_DEPTH].w = 12; + ps->bpp_scan = 12; + } + else + { + ps->val[OPT_BIT_DEPTH].w = def_bpp; + ps->bpp_scan = def_bpp; + } + + po[OPT_QUALITY_CAL].name = SANE_NAME_QUALITY_CAL; + po[OPT_QUALITY_CAL].title = SANE_TITLE_QUALITY_CAL; + po[OPT_QUALITY_CAL].desc = SANE_DESC_QUALITY_CAL; + po[OPT_QUALITY_CAL].type = SANE_TYPE_BOOL; + po[OPT_QUALITY_CAL].unit = SANE_UNIT_NONE; + po[OPT_QUALITY_CAL].size = sizeof (SANE_Bool); + po[OPT_QUALITY_CAL].constraint_type = SANE_CONSTRAINT_NONE; + po[OPT_QUALITY_CAL].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + ps->val[OPT_QUALITY_CAL].b = DEFAULT_QUALITY; + /* Disable quality calibration option if not supported + Note: Snapscan e52 and Prisa5300 do not support quality calibration, + although HCFG_CAL_ALLOWED is set. */ + if ((!(ps->hconfig & HCFG_CAL_ALLOWED)) + || (ps->pdev->model == SNAPSCANE52) + || (ps->pdev->model == PERFECTION1670) + || (ps->pdev->model == PRISA5150) + || (ps->pdev->model == PRISA5300)) { + po[OPT_QUALITY_CAL].cap |= SANE_CAP_INACTIVE; + ps->val[OPT_QUALITY_CAL].b = SANE_FALSE; + } + + if ((ps->pdev->model == PRISA5150) || + (ps->pdev->model == STYLUS_CX1500)) + { + po[OPT_QUALITY_CAL].cap |= SANE_CAP_INACTIVE; + ps->val[OPT_QUALITY_CAL].b = SANE_TRUE; + } + + po[OPT_GAMMA_BIND].name = SANE_NAME_ANALOG_GAMMA_BIND; + po[OPT_GAMMA_BIND].title = SANE_TITLE_ANALOG_GAMMA_BIND; + po[OPT_GAMMA_BIND].desc = SANE_DESC_ANALOG_GAMMA_BIND; + po[OPT_GAMMA_BIND].type = SANE_TYPE_BOOL; + po[OPT_GAMMA_BIND].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_BIND].size = sizeof (SANE_Bool); + po[OPT_GAMMA_BIND].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + po[OPT_GAMMA_BIND].constraint_type = SANE_CONSTRAINT_NONE; + ps->val[OPT_GAMMA_BIND].b = DEFAULT_GAMMA_BIND; + + po[OPT_GAMMA_GS].name = SANE_NAME_ANALOG_GAMMA; + po[OPT_GAMMA_GS].title = SANE_TITLE_ANALOG_GAMMA; + po[OPT_GAMMA_GS].desc = SANE_DESC_ANALOG_GAMMA; + po[OPT_GAMMA_GS].type = SANE_TYPE_FIXED; + po[OPT_GAMMA_GS].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_GS].size = sizeof (SANE_Word); + po[OPT_GAMMA_GS].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + po[OPT_GAMMA_GS].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GAMMA_GS].constraint.range = &gamma_range; + ps->gamma_gs = DEFAULT_GAMMA; + + po[OPT_GAMMA_R].name = SANE_NAME_ANALOG_GAMMA_R; + po[OPT_GAMMA_R].title = SANE_TITLE_ANALOG_GAMMA_R; + po[OPT_GAMMA_R].desc = SANE_DESC_ANALOG_GAMMA_R; + po[OPT_GAMMA_R].type = SANE_TYPE_FIXED; + po[OPT_GAMMA_R].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_R].size = sizeof (SANE_Word); + po[OPT_GAMMA_R].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_GAMMA_R].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GAMMA_R].constraint.range = &gamma_range; + ps->gamma_r = DEFAULT_GAMMA; + + po[OPT_GAMMA_G].name = SANE_NAME_ANALOG_GAMMA_G; + po[OPT_GAMMA_G].title = SANE_TITLE_ANALOG_GAMMA_G; + po[OPT_GAMMA_G].desc = SANE_DESC_ANALOG_GAMMA_G; + po[OPT_GAMMA_G].type = SANE_TYPE_FIXED; + po[OPT_GAMMA_G].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_G].size = sizeof (SANE_Word); + po[OPT_GAMMA_G].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_GAMMA_G].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GAMMA_G].constraint.range = &gamma_range; + ps->gamma_g = DEFAULT_GAMMA; + + po[OPT_GAMMA_B].name = SANE_NAME_ANALOG_GAMMA_B; + po[OPT_GAMMA_B].title = SANE_TITLE_ANALOG_GAMMA_B; + po[OPT_GAMMA_B].desc = SANE_DESC_ANALOG_GAMMA_B; + po[OPT_GAMMA_B].type = SANE_TYPE_FIXED; + po[OPT_GAMMA_B].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_B].size = sizeof (SANE_Word); + po[OPT_GAMMA_B].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_GAMMA_B].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GAMMA_B].constraint.range = &gamma_range; + ps->gamma_b = DEFAULT_GAMMA; + + po[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA; + po[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA; + po[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA; + po[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL; + po[OPT_CUSTOM_GAMMA].unit = SANE_UNIT_NONE; + po[OPT_CUSTOM_GAMMA].size = sizeof (SANE_Bool); + po[OPT_CUSTOM_GAMMA].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + ps->val[OPT_CUSTOM_GAMMA].b = DEFAULT_CUSTOM_GAMMA; + + po[OPT_GAMMA_VECTOR_GS].name = SANE_NAME_GAMMA_VECTOR; + po[OPT_GAMMA_VECTOR_GS].title = SANE_TITLE_GAMMA_VECTOR; + po[OPT_GAMMA_VECTOR_GS].desc = SANE_DESC_GAMMA_VECTOR; + po[OPT_GAMMA_VECTOR_GS].type = SANE_TYPE_INT; + po[OPT_GAMMA_VECTOR_GS].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_VECTOR_GS].size = ps->gamma_length * sizeof (SANE_Word); + po[OPT_GAMMA_VECTOR_GS].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_GAMMA_VECTOR_GS].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GAMMA_VECTOR_GS].constraint.range = &gamma_vrange; + ps->val[OPT_GAMMA_VECTOR_GS].wa = ps->gamma_table_gs; + + po[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R; + po[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R; + po[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R; + po[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT; + po[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_VECTOR_R].size = ps->gamma_length * sizeof (SANE_Word); + po[OPT_GAMMA_VECTOR_R].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_vrange; + ps->val[OPT_GAMMA_VECTOR_R].wa = ps->gamma_table_r; + + po[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G; + po[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G; + po[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G; + po[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT; + po[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_VECTOR_G].size = ps->gamma_length * sizeof (SANE_Word); + po[OPT_GAMMA_VECTOR_G].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_vrange; + ps->val[OPT_GAMMA_VECTOR_G].wa = ps->gamma_table_g; + + po[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B; + po[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B; + po[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B; + po[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT; + po[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE; + po[OPT_GAMMA_VECTOR_B].size = ps->gamma_length * sizeof (SANE_Word); + po[OPT_GAMMA_VECTOR_B].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_vrange; + ps->val[OPT_GAMMA_VECTOR_B].wa = ps->gamma_table_b; + + po[OPT_HALFTONE].name = SANE_NAME_HALFTONE; + po[OPT_HALFTONE].title = SANE_TITLE_HALFTONE; + po[OPT_HALFTONE].desc = SANE_DESC_HALFTONE; + po[OPT_HALFTONE].type = SANE_TYPE_BOOL; + po[OPT_HALFTONE].unit = SANE_UNIT_NONE; + po[OPT_HALFTONE].size = sizeof (SANE_Bool); + po[OPT_HALFTONE].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_HALFTONE].constraint_type = SANE_CONSTRAINT_NONE; + ps->halftone = DEFAULT_HALFTONE; + + po[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN; + po[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN; + po[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN; + po[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING; + po[OPT_HALFTONE_PATTERN].unit = SANE_UNIT_NONE; + po[OPT_HALFTONE_PATTERN].size = 32; + po[OPT_HALFTONE_PATTERN].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_STRING_LIST; + switch (ps->hconfig & HCFG_HT) + { + case HCFG_HT: + /* both 16x16, 8x8 matrices */ + { + static SANE_String_Const names[] = {dm_dd8x8, dm_dd16x16, NULL}; + + po[OPT_HALFTONE_PATTERN].constraint.string_list = names; + ps->dither_matrix = dm_dd8x8; + } + break; + case HCFG_HT16: + /* 16x16 matrices only */ + { + static SANE_String_Const names[] = {dm_dd16x16, NULL}; + + po[OPT_HALFTONE_PATTERN].constraint.string_list = names; + ps->dither_matrix = dm_dd16x16; + } + break; + case HCFG_HT8: + /* 8x8 matrices only */ + { + static SANE_String_Const names[] = {dm_dd8x8, NULL}; + + po[OPT_HALFTONE_PATTERN].constraint.string_list = names; + ps->dither_matrix = dm_dd8x8; + } + break; + default: + /* no halftone matrices */ + { + static SANE_String_Const names[] = {dm_none, NULL}; + + po[OPT_HALFTONE_PATTERN].constraint.string_list = names; + ps->dither_matrix = dm_none; + } + } + + po[OPT_NEGATIVE].name = SANE_NAME_NEGATIVE; + po[OPT_NEGATIVE].title = SANE_TITLE_NEGATIVE; + po[OPT_NEGATIVE].desc = SANE_DESC_NEGATIVE; + po[OPT_NEGATIVE].type = SANE_TYPE_BOOL; + po[OPT_NEGATIVE].unit = SANE_UNIT_NONE; + po[OPT_NEGATIVE].size = sizeof (SANE_Bool); + po[OPT_NEGATIVE].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE | SANE_CAP_AUTOMATIC; + po[OPT_NEGATIVE].constraint_type = SANE_CONSTRAINT_NONE; + ps->negative = DEFAULT_NEGATIVE; + + po[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD; + po[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD; + po[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD; + po[OPT_THRESHOLD].type = SANE_TYPE_FIXED; + po[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT; + po[OPT_THRESHOLD].size = sizeof (SANE_Int); + po[OPT_THRESHOLD].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + po[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_THRESHOLD].constraint.range = &positive_percent_range; + ps->threshold = DEFAULT_THRESHOLD; + + po[OPT_FRAME_NO].name = SANE_I18N("Frame"); + po[OPT_FRAME_NO].title = SANE_I18N("Frame to be scanned"); + po[OPT_FRAME_NO].desc = frame_desc; + po[OPT_FRAME_NO].type = SANE_TYPE_INT; + po[OPT_FRAME_NO].unit = SANE_UNIT_NONE; + po[OPT_FRAME_NO].size = sizeof (SANE_Int); + po[OPT_FRAME_NO].cap = SANE_CAP_SOFT_SELECT + | SANE_CAP_SOFT_DETECT + | SANE_CAP_INACTIVE; + po[OPT_FRAME_NO].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_FRAME_NO].constraint.range = &frame_range; + ps->frame_no = def_frame_no; + + po[OPT_FOCUS_MODE].name = SANE_I18N("Focus-mode"); + po[OPT_FOCUS_MODE].title = SANE_I18N("Auto or manual focus"); + po[OPT_FOCUS_MODE].desc = focus_mode_desc; + po[OPT_FOCUS_MODE].type = SANE_TYPE_STRING; + po[OPT_FOCUS_MODE].unit = SANE_UNIT_NONE; + po[OPT_FOCUS_MODE].size = 16; + po[OPT_FOCUS_MODE].cap = SANE_CAP_SOFT_SELECT + | SANE_CAP_SOFT_DETECT + | SANE_CAP_INACTIVE; + po[OPT_FOCUS_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + po[OPT_FOCUS_MODE].constraint.string_list = focus_modes; + ps->focus_mode_s= md_auto; + ps->focus_mode = MD_AUTO; + + po[OPT_FOCUS_POINT].name = SANE_I18N("Focus-point"); + po[OPT_FOCUS_POINT].title = SANE_I18N("Focus point"); + po[OPT_FOCUS_POINT].desc = focus_desc; + po[OPT_FOCUS_POINT].type = SANE_TYPE_INT; + po[OPT_FOCUS_POINT].unit = SANE_UNIT_NONE; + po[OPT_FOCUS_POINT].size = sizeof (SANE_Int); + po[OPT_FOCUS_POINT].cap = SANE_CAP_SOFT_SELECT + | SANE_CAP_SOFT_DETECT + | SANE_CAP_INACTIVE; + po[OPT_FOCUS_POINT].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_FOCUS_POINT].constraint.range = &focus_range; + + po[OPT_ADVANCED_GROUP].title = SANE_I18N("Advanced"); + po[OPT_ADVANCED_GROUP].desc = ""; + po[OPT_ADVANCED_GROUP].type = SANE_TYPE_GROUP; + po[OPT_ADVANCED_GROUP].cap = SANE_CAP_ADVANCED; + po[OPT_ADVANCED_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + + po[OPT_RGB_LPR].name = "rgb-lpr"; + po[OPT_RGB_LPR].title = SANE_I18N("Colour lines per read"); + po[OPT_RGB_LPR].desc = lpr_desc; + po[OPT_RGB_LPR].type = SANE_TYPE_INT; + po[OPT_RGB_LPR].unit = SANE_UNIT_NONE; + po[OPT_RGB_LPR].size = sizeof (SANE_Word); + po[OPT_RGB_LPR].cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED | SANE_CAP_AUTOMATIC; + po[OPT_RGB_LPR].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_RGB_LPR].constraint.range = &lpr_range; + ps->rgb_lpr = def_rgb_lpr; + + po[OPT_GS_LPR].name = "gs-lpr"; + po[OPT_GS_LPR].title = SANE_I18N("Greyscale lines per read"); + po[OPT_GS_LPR].desc = lpr_desc; + po[OPT_GS_LPR].type = SANE_TYPE_INT; + po[OPT_GS_LPR].unit = SANE_UNIT_NONE; + po[OPT_GS_LPR].size = sizeof (SANE_Word); + po[OPT_GS_LPR].cap = SANE_CAP_SOFT_SELECT + | SANE_CAP_SOFT_DETECT + | SANE_CAP_ADVANCED + | SANE_CAP_INACTIVE + | SANE_CAP_AUTOMATIC; + po[OPT_GS_LPR].constraint_type = SANE_CONSTRAINT_RANGE; + po[OPT_GS_LPR].constraint.range = &lpr_range; + ps->gs_lpr = def_gs_lpr; + control_options(ps); +} + +const SANE_Option_Descriptor *sane_get_option_descriptor (SANE_Handle h, + SANE_Int n) +{ + DBG (DL_OPTION_TRACE, + "sane_snapscan_get_option_descriptor (%p, %ld)\n", + (void *) h, + (long) n); + + if ((n >= 0) && (n < NUM_OPTS)) + return ((SnapScan_Scanner *) h)->options + n; + return NULL; +} + +/* Activates or deactivates options depending on mode */ +static void control_options(SnapScan_Scanner *pss) +{ + /* first deactivate all options */ + pss->options[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_BIND].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_GS].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_R].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_G].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_B].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_VECTOR_GS].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE; + + if ((pss->mode == MD_COLOUR) || + ((pss->mode == MD_BILEVELCOLOUR) && (pss->hconfig & HCFG_HT) && + pss->halftone)) + { + pss->options[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_BIND].cap &= ~SANE_CAP_INACTIVE; + if (pss->val[OPT_CUSTOM_GAMMA].b) + { + if (pss->val[OPT_GAMMA_BIND].b) + { + pss->options[OPT_GAMMA_VECTOR_GS].cap &= ~SANE_CAP_INACTIVE; + } + else + { + pss->options[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + } + } + else + { + pss->options[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE; + if (pss->val[OPT_GAMMA_BIND].b) + { + pss->options[OPT_GAMMA_GS].cap &= ~SANE_CAP_INACTIVE; + } + else + { + pss->options[OPT_GAMMA_R].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_G].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_B].cap &= ~SANE_CAP_INACTIVE; + } + } + } + else if ((pss->mode == MD_GREYSCALE) || + ((pss->mode == MD_LINEART) && (pss->hconfig & HCFG_HT) && + pss->halftone)) + { + pss->options[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE; + + if (pss->val[OPT_CUSTOM_GAMMA].b) + { + pss->options[OPT_GAMMA_VECTOR_GS].cap &= ~SANE_CAP_INACTIVE; + } + else + { + pss->options[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_GAMMA_GS].cap &= ~SANE_CAP_INACTIVE; + } + } + if ((pss->mode == MD_GREYSCALE) || (pss->mode == MD_COLOUR)) + { + switch(pss->pdev->model) + { + case PERFECTION2480: + case PERFECTION3490: + pss->options[OPT_BIT_DEPTH].cap &= ~SANE_CAP_INACTIVE; + break; + default: + break; + } + } + if (pss->pdev->model == SCANWIT2720S) + { + pss->options[OPT_FRAME_NO].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_FOCUS_MODE].cap &= ~SANE_CAP_INACTIVE; + if (pss->focus_mode == MD_MANUAL) + { + pss->options[OPT_FOCUS_POINT].cap &= ~SANE_CAP_INACTIVE; + } + } +} + +SANE_Status sane_control_option (SANE_Handle h, + SANE_Int n, + SANE_Action a, + void *v, + SANE_Int *i) +{ + static const char *me = "sane_snapscan_control_option"; + SnapScan_Scanner *pss = h; + SnapScan_Device *pdev = pss->pdev; + static SANE_Status status; + + DBG (DL_OPTION_TRACE, + "%s (%p, %ld, %ld, %p, %p)\n", + me, + (void *) h, + (long) n, + (long) a, + v, + (void *) i); + + switch (a) + { + case SANE_ACTION_GET_VALUE: + /* prevent getting of inactive options */ + if (!SANE_OPTION_IS_ACTIVE(pss->options[n].cap)) { + return SANE_STATUS_INVAL; + } + switch (n) + { + case OPT_COUNT: + *(SANE_Int *) v = NUM_OPTS; + break; + case OPT_SCANRES: + *(SANE_Int *) v = pss->res; + break; + case OPT_PREVIEW: + *(SANE_Bool *) v = pss->preview; + break; + case OPT_HIGHQUALITY: + *(SANE_Bool *) v = pss->highquality; + break; + case OPT_MODE: + DBG (DL_VERBOSE, + "%s: writing \"%s\" to location %p\n", + me, + pss->mode_s, + (SANE_String) v); + strcpy ((SANE_String) v, pss->mode_s); + break; + case OPT_PREVIEW_MODE: + DBG (DL_VERBOSE, + "%s: writing \"%s\" to location %p\n", + me, + pss->preview_mode_s, + (SANE_String) v); + strcpy ((SANE_String) v, pss->preview_mode_s); + break; + case OPT_SOURCE: + strcpy (v, pss->source_s); + break; + case OPT_TLX: + *(SANE_Fixed *) v = pss->tlx; + break; + case OPT_TLY: + *(SANE_Fixed *) v = pss->tly; + break; + case OPT_BRX: + *(SANE_Fixed *) v = pss->brx; + break; + case OPT_BRY: + *(SANE_Fixed *) v = pss->bry; + break; + case OPT_BRIGHTNESS: + *(SANE_Int *) v = pss->bright << SANE_FIXED_SCALE_SHIFT; + break; + case OPT_CONTRAST: + *(SANE_Int *) v = pss->contrast << SANE_FIXED_SCALE_SHIFT; + break; + case OPT_PREDEF_WINDOW: + DBG (DL_VERBOSE, + "%s: writing \"%s\" to location %p\n", + me, + pss->predef_window, + (SANE_String) v); + strcpy ((SANE_String) v, pss->predef_window); + break; + case OPT_GAMMA_GS: + *(SANE_Fixed *) v = pss->gamma_gs; + break; + case OPT_GAMMA_R: + *(SANE_Fixed *) v = pss->gamma_r; + break; + case OPT_GAMMA_G: + *(SANE_Fixed *) v = pss->gamma_g; + break; + case OPT_GAMMA_B: + *(SANE_Fixed *) v = pss->gamma_b; + break; + case OPT_CUSTOM_GAMMA: + case OPT_GAMMA_BIND: + case OPT_QUALITY_CAL: + *(SANE_Bool *) v = pss->val[n].b; + break; + + case OPT_GAMMA_VECTOR_GS: + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + memcpy (v, pss->val[n].wa, pss->options[n].size); + break; + case OPT_HALFTONE: + *(SANE_Bool *) v = pss->halftone; + break; + case OPT_HALFTONE_PATTERN: + DBG (DL_VERBOSE, + "%s: writing \"%s\" to location %p\n", + me, + pss->dither_matrix, + (SANE_String) v); + strcpy ((SANE_String) v, pss->dither_matrix); + break; + case OPT_NEGATIVE: + *(SANE_Bool *) v = pss->negative; + break; + case OPT_THRESHOLD: + *(SANE_Int *) v = pss->threshold << SANE_FIXED_SCALE_SHIFT; + break; + case OPT_RGB_LPR: + *(SANE_Int *) v = pss->rgb_lpr; + break; + case OPT_GS_LPR: + *(SANE_Int *) v = pss->gs_lpr; + break; + case OPT_BIT_DEPTH: + *(SANE_Int *) v = pss->val[OPT_BIT_DEPTH].w; + break; + case OPT_FRAME_NO: + *(SANE_Int *) v = pss->frame_no; + break; + case OPT_FOCUS_MODE: + strcpy ((SANE_String) v, pss->focus_mode_s); + break; + case OPT_FOCUS_POINT: + *(SANE_Int *) v = pss->focus; + break; + default: + DBG (DL_MAJOR_ERROR, + "%s: invalid option number %ld\n", + me, + (long) n); + return SANE_STATUS_UNSUPPORTED; + } + break; + case SANE_ACTION_SET_VALUE: + if (i) + *i = 0; + /* prevent setting of inactive options */ + if ((!SANE_OPTION_IS_SETTABLE(pss->options[n].cap)) || + (!SANE_OPTION_IS_ACTIVE(pss->options[n].cap))) { + return SANE_STATUS_INVAL; + } + /* prevent setting of options during a scan */ + if ((pss->state==ST_SCAN_INIT) || (pss->state==ST_SCANNING)) { + DBG(DL_INFO, + "set value for option %s ignored: scanner is still scanning (status %d)\n", + pss->options[n].name, + pss->state + ); + return SANE_STATUS_DEVICE_BUSY; + } + status = sanei_constrain_value(&pss->options[n], v, i); + if (status != SANE_STATUS_GOOD) { + return status; + } + switch (n) + { + case OPT_COUNT: + return SANE_STATUS_UNSUPPORTED; + case OPT_SCANRES: + pss->res = *(SANE_Int *) v; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_PREVIEW: + pss->preview = *(SANE_Bool *) v; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_HIGHQUALITY: + pss->highquality = *(SANE_Bool *) v; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_MODE: + { + char *s = (SANE_String) v; + if (strcmp (s, md_colour) == 0) + { + pss->mode_s = md_colour; + pss->mode = MD_COLOUR; + if (pss->preview_mode_s == md_auto) + pss->preview_mode = MD_COLOUR; + pss->options[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GS_LPR].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_RGB_LPR].cap &= ~SANE_CAP_INACTIVE; + } + else if (strcmp (s, md_bilevelcolour) == 0) + { + int ht_cap = pss->hconfig & HCFG_HT; + pss->mode_s = md_bilevelcolour; + pss->mode = MD_BILEVELCOLOUR; + if (pss->preview_mode_s == md_auto) + pss->preview_mode = MD_BILEVELCOLOUR; + if (ht_cap) + pss->options[OPT_HALFTONE].cap &= ~SANE_CAP_INACTIVE; + if (ht_cap && pss->halftone) + { + pss->options[OPT_HALFTONE_PATTERN].cap &= + ~SANE_CAP_INACTIVE; + } + else + { + pss->options[OPT_HALFTONE_PATTERN].cap |= + SANE_CAP_INACTIVE; + } + pss->options[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GS_LPR].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_RGB_LPR].cap &= ~SANE_CAP_INACTIVE; + } + else if (strcmp (s, md_greyscale) == 0) + { + pss->mode_s = md_greyscale; + pss->mode = MD_GREYSCALE; + if (pss->preview_mode_s == md_auto) + pss->preview_mode = MD_GREYSCALE; + pss->options[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GS_LPR].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_RGB_LPR].cap |= SANE_CAP_INACTIVE; + } + else if (strcmp (s, md_lineart) == 0) + { + int ht_cap = pss->hconfig & HCFG_HT; + pss->mode_s = md_lineart; + pss->mode = MD_LINEART; + if (pss->preview_mode_s == md_auto) + pss->preview_mode = MD_LINEART; + if (ht_cap) + pss->options[OPT_HALFTONE].cap &= ~SANE_CAP_INACTIVE; + if (ht_cap && pss->halftone) + { + pss->options[OPT_HALFTONE_PATTERN].cap &= + ~SANE_CAP_INACTIVE; + pss->options[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + } + else + { + pss->options[OPT_HALFTONE_PATTERN].cap |= + SANE_CAP_INACTIVE; + pss->options[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + } + pss->options[OPT_NEGATIVE].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_GS_LPR].cap &= ~SANE_CAP_INACTIVE; + pss->options[OPT_RGB_LPR].cap |= SANE_CAP_INACTIVE; + } + else + { + DBG (DL_MAJOR_ERROR, + "%s: internal error: given illegal mode " + "string \"%s\"\n", + me, + s); + } + } + control_options (pss); + if (i) + *i |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + break; + case OPT_PREVIEW_MODE: + { + char *s = (SANE_String) v; + if (strcmp (s, md_auto) == 0) + { + pss->preview_mode_s = md_auto; + pss->preview_mode = pss->mode; + } + else if (strcmp (s, md_colour) == 0) + { + pss->preview_mode_s = md_colour; + pss->preview_mode = MD_COLOUR; + } + else if (strcmp (s, md_bilevelcolour) == 0) + { + pss->preview_mode_s = md_bilevelcolour; + pss->preview_mode = MD_BILEVELCOLOUR; + } + else if (strcmp (s, md_greyscale) == 0) + { + pss->preview_mode_s = md_greyscale; + pss->preview_mode = MD_GREYSCALE; + } + else if (strcmp (s, md_lineart) == 0) + { + pss->preview_mode_s = md_lineart; + pss->preview_mode = MD_LINEART; + } + else + { + DBG (DL_MAJOR_ERROR, + "%s: internal error: given illegal mode string " + "\"%s\"\n", + me, + s); + } + break; + } + case OPT_SOURCE: + if (strcmp(v, src_flatbed) == 0) + { + pss->source = SRC_FLATBED; + pss->pdev->x_range.max = x_range_fb.max; + pss->pdev->y_range.max = y_range_fb.max; + } + else if (strcmp(v, src_tpo) == 0) + { + pss->source = SRC_TPO; + pss->pdev->x_range.max = x_range_tpo.max; + pss->pdev->y_range.max = y_range_tpo.max; + } + else if (strcmp(v, src_adf) == 0) + { + pss->source = SRC_ADF; + pss->pdev->x_range.max = x_range_fb.max; + pss->pdev->y_range.max = y_range_fb.max; + } + else + { + DBG (DL_MAJOR_ERROR, + "%s: internal error: given illegal source string " + "\"%s\"\n", + me, + (char *) v); + } + /* Adjust actual range values to new max values */ + if (pss->brx > pss->pdev->x_range.max) + pss->brx = pss->pdev->x_range.max; + if (pss->bry > pss->pdev->y_range.max) + pss->bry = pss->pdev->y_range.max; + pss->predef_window = pdw_none; + if (pss->source_s) + free (pss->source_s); + pss->source_s = (SANE_Char *) strdup(v); + if (i) + *i |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + break; + case OPT_TLX: + pss->tlx = *(SANE_Fixed *) v; + pss->predef_window = pdw_none; + if (pss->tlx > pdev->x_range.max) { + pss->tlx = pdev->x_range.max; + } + if (pss->brx < pss->tlx) { + pss->brx = pss->tlx; + } + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_TLY: + pss->tly = *(SANE_Fixed *) v; + pss->predef_window = pdw_none; + if (pss->tly > pdev->y_range.max){ + pss->tly = pdev->y_range.max; + } + if (pss->bry < pss->tly) { + pss->bry = pss->tly; + } + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_BRX: + pss->brx = *(SANE_Fixed *) v; + pss->predef_window = pdw_none; + if (pss->brx < pdev->x_range.min) { + pss->brx = pdev->x_range.min; + } + if (pss->brx < pss->tlx) { + pss->tlx = pss->brx; + } + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_BRY: + pss->bry = *(SANE_Fixed *) v; + pss->predef_window = pdw_none; + if (pss->bry < pdev->y_range.min) { + pss->bry = pdev->y_range.min; + } + if (pss->bry < pss->tly) { + pss->tly = pss->bry; + } + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_BRIGHTNESS: + pss->bright = *(SANE_Int *) v >> SANE_FIXED_SCALE_SHIFT; + break; + case OPT_CONTRAST: + pss->contrast = *(SANE_Int *) v >> SANE_FIXED_SCALE_SHIFT; + break; + case OPT_PREDEF_WINDOW: + { + char *s = (SANE_String) v; + if (strcmp (s, pdw_none) != 0) + { + pss->tlx = 0; + pss->tly = 0; + + if (strcmp (s, pdw_6X4) == 0) + { + pss->predef_window = pdw_6X4; + pss->brx = SANE_FIX (6.0*MM_PER_IN); + pss->bry = SANE_FIX (4.0*MM_PER_IN); + } + else if (strcmp (s, pdw_8X10) == 0) + { + pss->predef_window = pdw_8X10; + pss->brx = SANE_FIX (8.0*MM_PER_IN); + pss->bry = SANE_FIX (10.0*MM_PER_IN); + } + else if (strcmp (s, pdw_85X11) == 0) + { + pss->predef_window = pdw_85X11; + pss->brx = SANE_FIX (8.5*MM_PER_IN); + pss->bry = SANE_FIX (11.0*MM_PER_IN); + } + else + { + DBG (DL_MAJOR_ERROR, + "%s: trying to set predef window with " + "garbage value.", me); + pss->predef_window = pdw_none; + pss->brx = SANE_FIX (6.0*MM_PER_IN); + pss->bry = SANE_FIX (4.0*MM_PER_IN); + } + } + else + { + pss->predef_window = pdw_none; + } + } + if (i) + *i |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + break; + case OPT_GAMMA_GS: + pss->gamma_gs = *(SANE_Fixed *) v; + break; + case OPT_GAMMA_R: + pss->gamma_r = *(SANE_Fixed *) v; + break; + case OPT_GAMMA_G: + pss->gamma_g = *(SANE_Fixed *) v; + break; + case OPT_GAMMA_B: + pss->gamma_b = *(SANE_Fixed *) v; + break; + case OPT_QUALITY_CAL: + pss->val[n].b = *(SANE_Bool *)v; + break; + + case OPT_CUSTOM_GAMMA: + case OPT_GAMMA_BIND: + { + SANE_Bool b = *(SANE_Bool *) v; + if (b == pss->val[n].b) { break; } + pss->val[n].b = b; + control_options (pss); + if (i) + { + *i |= SANE_INFO_RELOAD_OPTIONS; + } + break; + } + + case OPT_GAMMA_VECTOR_GS: + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + memcpy(pss->val[n].wa, v, pss->options[n].size); + break; + case OPT_HALFTONE: + pss->halftone = *(SANE_Bool *) v; + if (pss->halftone) + { + switch (pss->mode) + { + case MD_BILEVELCOLOUR: + break; + case MD_LINEART: + pss->options[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + break; + default: + break; + } + pss->options[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; + } + else + { + pss->options[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + if (pss->mode == MD_LINEART) + pss->options[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + } + control_options (pss); + if (i) + *i = SANE_INFO_RELOAD_OPTIONS; + break; + case OPT_HALFTONE_PATTERN: + { + char *s = (SANE_String) v; + if (strcmp (s, dm_dd8x8) == 0) + { + pss->dither_matrix = dm_dd8x8; + } + else if (strcmp (s, dm_dd16x16) == 0) + { + pss->dither_matrix = dm_dd16x16; + } + else + { + DBG (DL_MAJOR_ERROR, + "%s: internal error: given illegal halftone pattern " + "string \"%s\"\n", + me, + s); + } + } + break; + case OPT_NEGATIVE: + pss->negative = *(SANE_Bool *) v; + break; + case OPT_THRESHOLD: + pss->threshold = *(SANE_Int *) v >> SANE_FIXED_SCALE_SHIFT; + break; + case OPT_RGB_LPR: + pss->rgb_lpr = *(SANE_Int *) v; + break; + case OPT_GS_LPR: + pss->gs_lpr = *(SANE_Int *) v; + break; + case OPT_BIT_DEPTH: + pss->val[OPT_BIT_DEPTH].w = *(SANE_Int *) v; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_FRAME_NO: + pss->frame_no = *(SANE_Int *) v; + break; + case OPT_FOCUS_MODE: + { + char *s = (SANE_String) v; + if (strcmp (s, md_manual) == 0) + { + pss->focus_mode_s = md_manual; + pss->focus_mode = MD_MANUAL; + pss->options[OPT_FOCUS_POINT].cap &= ~SANE_CAP_INACTIVE; + } + else + { + pss->focus_mode_s = md_auto; + pss->focus_mode = MD_AUTO; + pss->options[OPT_FOCUS_POINT].cap |= SANE_CAP_INACTIVE; + } + if (i) + *i = SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + break; + } + case OPT_FOCUS_POINT: + pss->focus = *(SANE_Int *) v; + break; + default: + DBG (DL_MAJOR_ERROR, + "%s: invalid option number %ld\n", + me, + (long) n); + return SANE_STATUS_UNSUPPORTED; + } + DBG (DL_OPTION_TRACE, "%s: option %s set to value ", + me, pss->options[n].name); + switch (pss->options[n].type) + { + case SANE_TYPE_INT: + DBG (DL_OPTION_TRACE, "%ld\n", (long) (*(SANE_Int *) v)); + break; + case SANE_TYPE_BOOL: + { + char *valstr = (*(SANE_Bool *) v == SANE_TRUE) ? "TRUE" : "FALSE"; + DBG (DL_OPTION_TRACE, "%s\n", valstr); + } + break; + default: + DBG (DL_OPTION_TRACE, "other than an integer or boolean.\n"); + break; + } + break; + case SANE_ACTION_SET_AUTO: + if (i) + *i = 0; + switch (n) + { + case OPT_SCANRES: + if (pss->pdev->model == SCANWIT2720S) + { + pss->res = 1350; + } + else + { + pss->res = 300; + } + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_PREVIEW: + pss->preview = SANE_FALSE; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_HIGHQUALITY: + pss->highquality = SANE_FALSE; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_MODE: + pss->mode_s = md_colour; + pss->mode = MD_COLOUR; + pss->options[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_GS_LPR].cap |= SANE_CAP_INACTIVE; + pss->options[OPT_RGB_LPR].cap &= ~SANE_CAP_INACTIVE; + control_options (pss); + if (i) + *i = SANE_INFO_RELOAD_OPTIONS; + break; + case OPT_PREVIEW_MODE: + pss->preview_mode_s = md_greyscale; + pss->preview_mode = MD_GREYSCALE; + break; + case OPT_SOURCE: + if (pss->pdev->model == SCANWIT2720S) + { + pss->source = SRC_TPO; + pss->pdev->x_range.max = x_range_tpo.max; + pss->pdev->y_range.max = y_range_tpo.max; + pss->predef_window = pdw_none; + if (pss->source_s) + free (pss->source_s); + pss->source_s = (SANE_Char *) strdup(src_tpo); + } + else + { + pss->source = SRC_FLATBED; + pss->pdev->x_range.max = x_range_fb.max; + pss->pdev->y_range.max = y_range_fb.max; + pss->predef_window = pdw_none; + if (pss->source_s) + free (pss->source_s); + pss->source_s = (SANE_Char *) strdup(src_flatbed); + } + if (i) + *i |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + break; + case OPT_TLX: + pss->tlx = pss->pdev->x_range.min; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_TLY: + pss->tly = pss->pdev->y_range.min; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_BRX: + pss->brx = pss->pdev->x_range.max; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_BRY: + pss->bry = pss->pdev->y_range.max; + if (i) + *i |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_NEGATIVE: + pss->negative = DEFAULT_NEGATIVE; + break; + case OPT_RGB_LPR: + pss->rgb_lpr = def_rgb_lpr; + break; + case OPT_GS_LPR: + pss->gs_lpr = def_gs_lpr; + break; + case OPT_BIT_DEPTH: + if (pss->pdev->model == SCANWIT2720S) + { + pss->val[OPT_BIT_DEPTH].w = 12; + } + else + { + pss->val[OPT_BIT_DEPTH].w = def_bpp; + } + break; + case OPT_FRAME_NO: + pss->frame_no = def_frame_no; + break; + case OPT_FOCUS_MODE: + pss->focus_mode_s = md_auto; + pss->focus_mode = MD_AUTO; + if (i) + *i = SANE_INFO_RELOAD_OPTIONS; + break; + case OPT_FOCUS_POINT: + pss->focus = 0x13e; + break; + default: + DBG (DL_MAJOR_ERROR, + "%s: invalid option number %ld\n", + me, + (long) n); + return SANE_STATUS_UNSUPPORTED; + } + break; + default: + DBG (DL_MAJOR_ERROR, "%s: invalid action code %ld\n", me, (long) a); + return SANE_STATUS_UNSUPPORTED; + } + return SANE_STATUS_GOOD; +} + +/* + * $Log$ + * Revision 1.35 2006/01/06 20:59:17 oliver-guest + * Some fixes for the Epson Stylus CX 1500 + * + * Revision 1.34 2006/01/01 22:57:01 oliver-guest + * Added calibration data for Benq 5150 / 5250, preliminary support for Epson Stylus CX 1500 + * + * Revision 1.33 2005/12/04 15:03:00 oliver-guest + * Some fixes for Benq 5150 + * + * Revision 1.32 2005/11/23 20:57:01 oliver-guest + * Disable bilevel colour / halftoning for Epson 3490 + * + * Revision 1.31 2005/11/17 23:47:10 oliver-guest + * Revert previous 'fix', disable 2400 dpi for Epson 3490, use 1600 dpi instead + * + * Revision 1.30 2005/11/15 20:11:18 oliver-guest + * Enabled quality calibration for the Epson 3490 + * + * Revision 1.29 2005/10/31 21:08:47 oliver-guest + * Distinguish between Benq 5000/5000E/5000U + * + * Revision 1.28 2005/10/24 19:46:40 oliver-guest + * Preview and range fix for Epson 2480/2580 + * + * Revision 1.27 2005/10/13 22:43:30 oliver-guest + * Fixes for 16 bit scan mode from Simon Munton + * + * Revision 1.26 2005/10/11 18:47:07 oliver-guest + * Fixes for Epson 3490 and 16 bit scan mode + * + * Revision 1.25 2005/09/28 22:09:26 oliver-guest + * Reenabled enhanced inquiry command for Epson scanners (duh\!) + * + * Revision 1.24 2005/09/28 21:33:10 oliver-guest + * Added 16 bit option for Epson scanners (untested) + * + * Revision 1.23 2005/08/16 20:15:10 oliver-guest + * Removed C++-style comment + * + * Revision 1.22 2005/08/15 18:06:37 oliver-guest + * Added support for Epson 3490/3590 (thanks to Matt Judge) + * + * Revision 1.21 2005/07/20 21:37:29 oliver-guest + * Changed TPO scanning area for 2480/2580, reenabled 2400 DPI for 2480/2580 + * + * Revision 1.20 2005/05/22 11:50:24 oliver-guest + * Disabled 2400 DPI for Epson 2480 + * + * Revision 1.19 2004/12/09 23:21:47 oliver-guest + * Added quality calibration for Epson 2480 (by Simon Munton) + * + * Revision 1.18 2004/12/01 22:12:02 oliver-guest + * Added support for Epson 1270 + * + * Revision 1.17 2004/09/02 20:59:11 oliver-guest + * Added support for Epson 2480 + * + * Revision 1.16 2004/04/08 21:53:10 oliver-guest + * Use sanei_thread in snapscan backend + * + * Revision 1.15 2004/04/02 20:19:23 oliver-guest + * Various bugfixes for gamma corretion (thanks to Robert Tsien) + * + * Revision 1.14 2004/02/01 13:32:26 oliver-guest + * Fixed resolutions for Epson 1670 + * + * Revision 1.13 2003/11/28 23:23:18 oliver-guest + * Correct length of wordlist for resolutions_1600 + * + * Revision 1.12 2003/11/09 21:43:45 oliver-guest + * Disabled quality calibration for Epson Perfection 1670 + * + * Revision 1.11 2003/11/08 09:50:27 oliver-guest + * Fix TPO scanning range for Epson 1670 + * + * Revision 1.10 2003/10/21 20:43:25 oliver-guest + * Bugfixes for SnapScan backend + * + * Revision 1.9 2003/10/07 18:29:20 oliver-guest + * Initial support for Epson 1670, minor bugfix + * + * Revision 1.8 2003/08/19 21:05:08 oliverschwartz + * Scanner ID cleanup + * + * Revision 1.7 2003/04/30 20:49:39 oliverschwartz + * SnapScan backend 1.4.26 + * + * Revision 1.8 2003/04/30 20:42:18 oliverschwartz + * Added support for Agfa Arcus 1200 (supplied by Valtteri Vuorikoski) + * + * Revision 1.7 2003/04/02 21:17:12 oliverschwartz + * Fix for 1200 DPI with Acer 5000 + * + * Revision 1.6 2002/07/12 23:23:06 oliverschwartz + * Disable quality calibration for 5300 + * + * Revision 1.5 2002/06/06 20:40:00 oliverschwartz + * Changed default scan area for transparancy unit of SnapScan e50 + * + * Revision 1.4 2002/05/02 18:28:44 oliverschwartz + * Added ADF support + * + * Revision 1.3 2002/04/27 14:43:59 oliverschwartz + * - Remove SCSI debug options + * - Fix option handling (errors detected by tstbackend) + * + * Revision 1.2 2002/04/23 22:50:24 oliverschwartz + * Improve handling of scan area options + * + * Revision 1.1 2002/03/24 12:07:15 oliverschwartz + * Moved option functions from snapscan.c to snapscan-options.c + * + * + * */ -- cgit v1.2.3