summaryrefslogtreecommitdiff
path: root/backend/hp-option.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/hp-option.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/hp-option.c')
-rw-r--r--backend/hp-option.c4087
1 files changed, 4087 insertions, 0 deletions
diff --git a/backend/hp-option.c b/backend/hp-option.c
new file mode 100644
index 0000000..10bcb3e
--- /dev/null
+++ b/backend/hp-option.c
@@ -0,0 +1,4087 @@
+/* sane - Scanner Access Now Easy.
+ Copyright (C) 1997 Geoffrey T. Dairiki
+ 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 part of a SANE backend for HP Scanners supporting
+ HP Scanner Control Language (SCL).
+*/
+
+/*
+ $Log$
+ Revision 1.13 2005/04/13 12:50:07 ellert-guest
+ Add missing SANE_I18N, Regenerate .po files accordingly, Update Swedish translations
+
+ Revision 1.12 2003/10/09 19:32:50 kig-guest
+ Bug #300241: fix invers image on 3c/4c/6100C at 10 bit depth
+
+
+*/
+
+/* pwd.h not available ? */
+#if (defined(__IBMC__) || defined(__IBMCPP__))
+#ifndef _AIX
+# define SANE_HOME_HP "SANE_HOME_HP"
+#endif
+#endif
+
+/* To be done: dont reallocate choice accessors */
+/* #define HP_ALLOC_CHOICEACC_ONCE 1 */
+/*
+#define HP_EXPERIMENTAL
+*/ /*
+#define STUBS
+extern int sanei_debug_hp; */
+#define DEBUG_DECLARE_ONLY
+#include "../include/sane/config.h"
+#include "../include/sane/sanei_backend.h"
+#include "../include/lalloca.h"
+
+#include <stdio.h>
+#include <string.h>
+#include "../include/lassert.h"
+#ifndef SANE_HOME_HP
+#include <pwd.h>
+#endif
+#include <sys/types.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei.h"
+#include "hp.h"
+#include "hp-option.h"
+#include "hp-accessor.h"
+#include "hp-scsi.h"
+#include "hp-scl.h"
+#include "hp-device.h"
+
+
+/* FIXME: descriptors should be static? */
+
+typedef SANE_Option_Descriptor * _HpSaneOption;
+typedef struct hp_option_descriptor_s * _HpOptionDescriptor;
+typedef struct hp_option_s * _HpOption;
+
+typedef struct hp_data_info_s * HpDataInfo;
+typedef struct hp_data_info_s * _HpDataInfo;
+
+typedef HpAccessor HpAccessorOptd;
+
+
+static hp_bool_t hp_optset_isEnabled (HpOptSet this, HpData data,
+ const char *name, const HpDeviceInfo *info);
+static HpOption hp_optset_get (HpOptSet this, HpOptionDescriptor optd);
+static HpOption hp_optset_getByName (HpOptSet this, const char * name);
+static SANE_Status hp_download_calib_file (HpScsi scsi);
+static SANE_Status hp_probe_parameter_support_table (enum hp_device_compat_e
+ compat, HpScl scl, int value);
+
+#define HP_EOL -9999
+
+/* Dont need requiries for commands that are probed */
+#define HP_PROBE_SCL_COMMAND 1
+
+/* Scale factor for vectors (gtk seems not to like vectors/curves
+ * in y-range 0.0,...,1.0)
+ */
+#define HP_VECTOR_SCALE (256.0)
+/*
+ *
+ */
+struct hp_option_s
+{
+ HpOptionDescriptor descriptor;
+ HpAccessorOptd optd_acsr;
+ HpAccessor data_acsr;
+ void * extra;
+};
+
+struct hp_option_descriptor_s
+{
+ const char * name;
+ const char * title;
+ const char * desc;
+ SANE_Value_Type type;
+ SANE_Unit unit;
+ SANE_Int cap;
+
+ enum hp_device_compat_e requires; /* model dependent support flags */
+
+ /* probe for option support */
+ SANE_Status (*probe) (_HpOption this, HpScsi scsi, HpOptSet optset,
+ HpData data);
+ SANE_Status (*program) (HpOption this, HpScsi scsi, HpOptSet optset,
+ HpData data);
+ hp_bool_t (*enable) (HpOption this, HpOptSet optset, HpData data,
+ const HpDeviceInfo *info);
+
+ hp_bool_t has_global_effect;
+ hp_bool_t affects_scan_params;
+ hp_bool_t program_immediate;
+ hp_bool_t suppress_for_scan;
+ hp_bool_t may_change;
+
+
+ /* This stuff should really be in a subclasses: */
+ HpScl scl_command;
+ int minval, maxval, startval; /* for simulation */
+ HpChoice choices;
+};
+
+struct hp_data_info_s
+{
+ HpScl scl;
+};
+
+static const struct hp_option_descriptor_s
+ NUM_OPTIONS[1], PREVIEW_MODE[1], SCAN_MODE[1], SCAN_RESOLUTION[1],
+
+ CUSTOM_GAMMA[1], GAMMA_VECTOR_8x8[1],
+#ifdef ENABLE_7x12_TONEMAPS
+ GAMMA_VECTOR_7x12[1],
+ RGB_TONEMAP[1], GAMMA_VECTOR_R[1], GAMMA_VECTOR_G[1], GAMMA_VECTOR_B[1],
+#endif
+ HALFTONE_PATTERN[1], MEDIA[1], OUT8[1], BIT_DEPTH[1], SCAN_SOURCE[1],
+#ifdef FAKE_COLORSEP_MATRIXES
+ SEPMATRIX[1],
+#endif
+ MATRIX_TYPE[1];
+
+
+/* Check if a certain scanner model supports a command with a given parameter
+ * value. The function returns SANE_STATUS_GOOD if the command and the
+ * value is found in the support table of that scanner.
+ * It returns SANE_STATUS_UNSUPPORTED if the command is found in the support
+ * table of that scanner, but the value is not included in the table.
+ * It returns SANE_STATUS_EOF if there is no information about that command
+ * and that scanner in the support table.
+ */
+static SANE_Status
+hp_probe_parameter_support_table (enum hp_device_compat_e compat,
+ HpScl scl, int value)
+
+{int k, j;
+ char *eptr;
+ static int photosmart_output_type[] =
+ /* HP Photosmart: only b/w, gray, color is supported */
+ { HP_COMPAT_PS, SCL_OUTPUT_DATA_TYPE, 0, 4, 5, HP_EOL };
+
+ static int *support_table[] =
+ {
+ photosmart_output_type
+ };
+
+ eptr = getenv ("SANE_HP_CHK_TABLE");
+ if ((eptr != NULL) && (*eptr == '0'))
+ return SANE_STATUS_EOF;
+
+ for (k = 0; k < (int)(sizeof (support_table)/sizeof (support_table[0])); k++)
+ {
+ if ((scl == support_table[k][1]) && (support_table[k][0] & compat))
+ {
+ for (j = 2; support_table[k][j] != HP_EOL; j++)
+ if (support_table[k][j] == value) return SANE_STATUS_GOOD;
+ return SANE_STATUS_UNSUPPORTED;
+ }
+ }
+ return SANE_STATUS_EOF;
+}
+
+
+/*
+ * class HpChoice
+ */
+typedef struct hp_choice_s * _HpChoice;
+
+static hp_bool_t
+hp_choice_isSupported (HpChoice choice, int minval, int maxval)
+{
+ return ( choice->is_emulated
+ || ( choice->val >= minval && choice->val <= maxval ) );
+}
+
+static hp_bool_t
+hp_probed_choice_isSupported (HpScsi scsi, HpScl scl,
+ HpChoice choice, int minval, int maxval)
+{
+ hp_bool_t isSupported;
+ SANE_Status status;
+ enum hp_device_compat_e compat;
+
+ if ( choice->is_emulated )
+ {
+ DBG(3, "probed_choice: value %d is emulated\n", choice->val);
+ return ( 1 );
+ }
+ if ( choice->val < minval || choice->val > maxval )
+ {
+ DBG(3, "probed_choice: value %d out of range (%d,%d)\n", choice->val,
+ minval, maxval);
+ return ( 0 );
+ }
+
+ if (sanei_hp_device_probe (&compat, scsi) != SANE_STATUS_GOOD)
+ {
+ DBG(1, "probed_choice: Could not get compatibilities for scanner\n");
+ return ( 0 );
+ }
+
+ status = hp_probe_parameter_support_table (compat, scl, choice->val);
+ if (status == SANE_STATUS_GOOD)
+ {
+ DBG(3, "probed_choice: command/value found in support table\n");
+ return ( 1 );
+ }
+ else if (status == SANE_STATUS_UNSUPPORTED)
+ {
+ DBG(3, "probed_choice: command found in support table, but value n.s.\n");
+ return ( 0 );
+ }
+
+ /* Not in the support table. Try to inquire */
+ /* Fix me: It seems that the scanner does not raise a parameter error */
+ /* after specifiying an unsupported command-value. */
+
+ sanei_hp_scl_clearErrors (scsi);
+ sanei_hp_scl_set (scsi, scl, choice->val);
+
+ isSupported = ( sanei_hp_scl_errcheck (scsi) == SANE_STATUS_GOOD );
+
+ DBG(3, "probed_choice: value %d %s\n", choice->val,
+ isSupported ? "supported" : "not supported");
+ return isSupported;
+}
+
+hp_bool_t
+sanei_hp_choice_isEnabled (HpChoice this, HpOptSet optset, HpData data,
+ const HpDeviceInfo *info)
+{
+ if (!this->enable)
+ return 1;
+ return (*this->enable)(this, optset, data, info);
+}
+
+static hp_bool_t
+_cenable_incolor (HpChoice UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{
+ return sanei_hp_optset_scanmode(optset, data) == HP_SCANMODE_COLOR;
+}
+
+static hp_bool_t
+_cenable_notcolor (HpChoice UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{
+ return sanei_hp_optset_scanmode(optset, data) != HP_SCANMODE_COLOR;
+}
+
+/*
+ * class HpAccessorOptd
+ */
+static HpAccessorOptd
+hp_accessor_optd_new (HpData data)
+{
+ return sanei_hp_accessor_new(data, sizeof(SANE_Option_Descriptor));
+}
+
+static _HpSaneOption
+hp_accessor_optd_data (HpAccessorOptd this, HpData data)
+{
+ return sanei__hp_accessor_data(this, data);
+}
+
+
+
+/*
+ * class OptionDescriptor
+ */
+
+static SANE_Status
+hp_option_descriptor_probe (HpOptionDescriptor desc, HpScsi scsi,
+ HpOptSet optset, HpData data, HpOption * newoptp)
+{
+ _HpOption new;
+ SANE_Status status;
+ _HpSaneOption optd;
+
+ new = sanei_hp_alloc(sizeof(*new));
+ new->descriptor = desc;
+ if (!(new->optd_acsr = hp_accessor_optd_new(data)))
+ return SANE_STATUS_NO_MEM;
+ new->data_acsr = 0;
+ optd = hp_accessor_optd_data(new->optd_acsr, data);
+
+ memset(optd, 0, sizeof(*optd));
+ optd->name = desc->name;
+ optd->title = desc->title;
+ optd->desc = desc->desc;
+ optd->type = desc->type;
+ optd->unit = desc->unit;
+ optd->cap = desc->cap;
+
+ /*
+ * Probe function will set optd->size, optd->constraint_type,
+ * and optd->constraint.
+ * and also new->accessor
+ * and possibly new->extra
+ */
+ if (desc->probe)
+ {
+ if (FAILED( status = (*desc->probe)(new, scsi, optset, data) ))
+ {
+ /* hp_accessor_optd_destoy(new->optd_acsr) */
+ sanei_hp_free(new);
+ return status;
+ }
+ }
+
+ *newoptp = new;
+ return SANE_STATUS_GOOD;
+}
+
+
+/*
+ * class Option
+ */
+static HpSaneOption
+hp_option_saneoption (HpOption this, HpData data)
+{
+ return hp_accessor_optd_data(this->optd_acsr, data);
+}
+
+static _HpSaneOption
+_hp_option_saneoption (HpOption this, HpData data)
+{
+ return hp_accessor_optd_data(this->optd_acsr, data);
+}
+
+static SANE_Status
+hp_option_download (HpOption this, HpData data, HpOptSet optset, HpScsi scsi)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int value;
+
+ if (IS_SCL_CONTROL(scl))
+ {
+ value = sanei_hp_accessor_getint(this->data_acsr, data);
+ if ( (scl == SCL_DATA_WIDTH)
+ && (sanei_hp_optset_scanmode (optset, data) == HP_SCANMODE_COLOR) )
+ {
+ value *= 3;
+ }
+ return sanei_hp_scl_set(scsi, scl, value);
+ }
+ else if (IS_SCL_DATA_TYPE(scl))
+ return sanei_hp_scl_download(scsi, scl,
+ sanei_hp_accessor_data(this->data_acsr, data),
+ sanei_hp_accessor_size(this->data_acsr));
+ assert(!scl);
+ return SANE_STATUS_INVAL;
+}
+
+static SANE_Status
+hp_option_upload (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int val;
+
+ if (IS_SCL_CONTROL(scl))
+ {
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, &val, 0, 0) );
+ if ( (scl == SCL_DATA_WIDTH)
+ && (sanei_hp_optset_scanmode (optset, data) == HP_SCANMODE_COLOR) )
+ {
+ val /= 3;
+ }
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+ return SANE_STATUS_GOOD;
+ }
+ else if (IS_SCL_DATA_TYPE(scl))
+ return sanei_hp_scl_upload(scsi, scl,
+ sanei__hp_accessor_data(this->data_acsr, data),
+ sanei_hp_accessor_size(this->data_acsr));
+ assert(!scl);
+ return SANE_STATUS_INVAL;
+}
+
+static SANE_Status
+hp_option_program (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ const HpDeviceInfo *info;
+
+ DBG(10, "hp_option_program: name=%s, enable=0x%08lx, program=0x%08lx\n",
+ this->descriptor->name, (long)this->descriptor->enable,
+ (long)this->descriptor->program);
+
+ /* Replaced by flag suppress_for_scan
+ * if (this->descriptor->program_immediate)
+ * {
+ * DBG(10, "hp_option_program: is program_immediate. Dont program now.\n");
+ * return SANE_STATUS_GOOD;
+ * }
+ */
+
+ if (!this->descriptor->program)
+ return SANE_STATUS_GOOD;
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ if (this->descriptor->enable
+ && !(*this->descriptor->enable)(this, optset, data, info))
+ return SANE_STATUS_GOOD;
+
+ return (*this->descriptor->program)(this, scsi, optset, data);
+}
+
+static SANE_Status
+hp_option_get (HpOption this, HpData data, void * valp)
+{
+ if (!this->data_acsr)
+ return SANE_STATUS_INVAL;
+ return sanei_hp_accessor_get(this->data_acsr, data, valp);
+}
+
+static hp_bool_t
+_values_are_equal (HpOption this, HpData data,
+ const void * val1, const void * val2)
+{
+ HpSaneOption optd = hp_option_saneoption(this, data);
+
+ if (optd->type == SANE_TYPE_STRING)
+ return strncmp((const char *)val1, (const char *)val2, optd->size) == 0;
+ else
+ return memcmp(val1, val2, optd->size) == 0;
+}
+
+static hp_bool_t
+hp_option_isImmediate (HpOption this)
+{
+ return ( this->descriptor->program_immediate
+ && this->descriptor->program );
+}
+
+static SANE_Status
+hp_option_imm_set (HpOptSet optset, HpOption this, HpData data,
+ void * valp, SANE_Int * info, HpScsi scsi)
+{
+ HpSaneOption optd = hp_option_saneoption(this, data);
+ hp_byte_t * old_val = alloca(optd->size);
+ SANE_Status status;
+
+ assert (this->descriptor->program_immediate && this->descriptor->program);
+
+ if (!SANE_OPTION_IS_SETTABLE(optd->cap))
+ return SANE_STATUS_INVAL;
+
+ DBG(10,"hp_option_imm_set: %s\n", this->descriptor->name);
+
+ if ( this->descriptor->type == SANE_TYPE_BUTTON )
+ {
+ status = (*this->descriptor->program)(this, scsi, optset, data);
+ if ( !FAILED(status) && info )
+ {
+ if (this->descriptor->has_global_effect)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+ if (this->descriptor->affects_scan_params)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+ }
+ return status;
+ }
+
+ if ( !this->data_acsr )
+ return SANE_STATUS_INVAL;
+
+ if (!old_val)
+ return SANE_STATUS_NO_MEM;
+
+ if (FAILED( status = sanei_constrain_value(optd, valp, info) ))
+ {
+ DBG(1, "option_imm_set: %s: constrain_value failed :%s\n",
+ this->descriptor->name, sane_strstatus(status));
+ return status;
+ }
+
+ RETURN_IF_FAIL( sanei_hp_accessor_get(this->data_acsr, data, old_val) );
+
+ if (_values_are_equal(this, data, old_val, valp))
+ {
+ DBG(3, "option_imm_set: value unchanged\n");
+ return SANE_STATUS_GOOD;
+ }
+
+ if (info)
+ memcpy(old_val, valp, optd->size); /* Save requested value */
+
+ RETURN_IF_FAIL( sanei_hp_accessor_set(this->data_acsr, data, valp) );
+
+ if ( this->descriptor->type == SANE_TYPE_STRING )
+ RETURN_IF_FAIL( (*this->descriptor->program)(this, scsi, optset, data) );
+
+ if (info)
+ {
+ if (!_values_are_equal(this, data, old_val, valp))
+ *info |= SANE_INFO_INEXACT;
+ if (this->descriptor->has_global_effect)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+ if (this->descriptor->affects_scan_params)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+hp_option_set (HpOption this, HpData data, void * valp, SANE_Int * info)
+{
+ HpSaneOption optd = hp_option_saneoption(this, data);
+ hp_byte_t * old_val = alloca(optd->size);
+ SANE_Status status;
+ char sval[64];
+
+
+ if (!SANE_OPTION_IS_SETTABLE(optd->cap) || !this->data_acsr)
+ return SANE_STATUS_INVAL;
+ if (!old_val)
+ return SANE_STATUS_NO_MEM;
+
+ sval[0] = '\0';
+ if (this->descriptor->type == SANE_TYPE_INT)
+ sprintf (sval," value=%d", *(int*)valp);
+
+ DBG(10,"hp_option_set: %s%s\n", this->descriptor->name, sval);
+
+ if (FAILED( status = sanei_constrain_value(optd, valp, info) ))
+ {
+ DBG(1, "option_set: %s: constrain_value failed :%s\n",
+ this->descriptor->name, sane_strstatus(status));
+ return status;
+ }
+
+ RETURN_IF_FAIL( sanei_hp_accessor_get(this->data_acsr, data, old_val) );
+
+ if (_values_are_equal(this, data, old_val, valp))
+ {
+ DBG(3, "option_set: %s: value unchanged\n",this->descriptor->name);
+ return SANE_STATUS_GOOD;
+ }
+
+ if (info)
+ memcpy(old_val, valp, optd->size); /* Save requested value */
+
+ RETURN_IF_FAIL( sanei_hp_accessor_set(this->data_acsr, data, valp) );
+
+ if (info)
+ {
+ if (!_values_are_equal(this, data, old_val, valp))
+ *info |= SANE_INFO_INEXACT;
+ if (this->descriptor->has_global_effect)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+ if (this->descriptor->affects_scan_params)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+
+ DBG(3, "option_set: %s: info=0x%lx\n",this->descriptor->name,
+ (long)*info);
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+static int
+hp_option_getint (HpOption this, HpData data)
+{
+ return sanei_hp_accessor_getint(this->data_acsr, data);
+}
+
+static SANE_Status
+hp_option_imm_control (HpOptSet optset, HpOption this, HpData data,
+ SANE_Action action, void * valp, SANE_Int *infop,
+ HpScsi scsi)
+{
+ HpSaneOption optd = hp_option_saneoption(this, data);
+
+ if (!SANE_OPTION_IS_ACTIVE(optd->cap))
+ return SANE_STATUS_INVAL;
+
+ switch (action) {
+ case SANE_ACTION_GET_VALUE:
+ return hp_option_get(this, data, valp);
+ case SANE_ACTION_SET_VALUE:
+ return hp_option_imm_set(optset, this, data, valp, infop, scsi);
+ case SANE_ACTION_SET_AUTO:
+ default:
+ return SANE_STATUS_INVAL;
+ }
+}
+
+static SANE_Status
+hp_option_control (HpOption this, HpData data,
+ SANE_Action action, void * valp, SANE_Int *infop)
+{
+ HpSaneOption optd = hp_option_saneoption(this, data);
+
+ if (!SANE_OPTION_IS_ACTIVE(optd->cap))
+ return SANE_STATUS_INVAL;
+
+ switch (action) {
+ case SANE_ACTION_GET_VALUE:
+ return hp_option_get(this, data, valp);
+ case SANE_ACTION_SET_VALUE:
+ return hp_option_set(this, data, valp, infop);
+ case SANE_ACTION_SET_AUTO:
+ default:
+ return SANE_STATUS_INVAL;
+ }
+}
+
+
+static void
+hp_option_reprogram (HpOption this, HpOptSet optset, HpData data, HpScsi scsi)
+{
+ if (this->descriptor->may_change)
+ {
+ DBG(5, "hp_option_reprogram: %s\n", this->descriptor->name);
+
+ hp_option_program (this, scsi, optset, data);
+ }
+}
+
+
+static void
+hp_option_reprobe (HpOption this, HpOptSet optset, HpData data, HpScsi scsi)
+{
+ if (this->descriptor->may_change)
+ {
+ DBG(5, "hp_option_reprobe: %s\n", this->descriptor->name);
+
+ (*this->descriptor->probe)((_HpOption)this, scsi, optset, data);
+ }
+}
+
+static void
+hp_option_updateEnable (HpOption this, HpOptSet optset, HpData data,
+ const HpDeviceInfo *info)
+{
+ hp_bool_t (*f)(HpOption, HpOptSet, HpData, const HpDeviceInfo *)
+ = this->descriptor->enable;
+ _HpSaneOption optd = _hp_option_saneoption(this, data);
+
+ if (!f || (*f)(this, optset, data, info))
+ optd->cap &= ~SANE_CAP_INACTIVE;
+ else
+ optd->cap |= SANE_CAP_INACTIVE;
+}
+
+static hp_bool_t
+hp_option_isInternal (HpOption this)
+{
+ return this->descriptor->name[0] == '_';
+}
+
+
+/*
+ * Option probe functions
+ */
+
+static SANE_Status
+_set_range (HpOption opt, HpData data,
+ SANE_Word min, SANE_Word quant, SANE_Word max)
+{
+ _HpSaneOption optd = _hp_option_saneoption(opt, data);
+ SANE_Range * range = sanei_hp_alloc(sizeof(*range)); /* FIXME: leak? */
+
+ if (! range)
+ return SANE_STATUS_NO_MEM;
+
+ range->min = min;
+ range->max = max;
+ range->quant = quant;
+ optd->constraint.range = range;
+ optd->constraint_type = SANE_CONSTRAINT_RANGE;
+
+ return SANE_STATUS_GOOD;
+}
+
+static void
+_set_size (HpOption opt, HpData data, SANE_Int size)
+{
+ _hp_option_saneoption(opt, data)->size = size;
+}
+
+/* #ifdef HP_EXPERIMENTAL */
+static SANE_Status
+_probe_int (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset, HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int minval, maxval;
+ int val = 0;
+
+ assert(scl);
+
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, &val, &minval, &maxval) );
+
+ if (minval >= maxval)
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_int_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+ _set_size(this, data, sizeof(SANE_Int));
+ return _set_range(this, data, minval, 1, maxval);
+}
+/* #endif */
+
+static SANE_Status
+_probe_int_brightness (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int minval, maxval;
+ int val = 0;
+ hp_bool_t simulate;
+
+ assert(scl);
+
+ simulate = ( sanei_hp_device_support_get (
+ sanei_hp_scsi_devicename (scsi), scl, 0, 0)
+ != SANE_STATUS_GOOD );
+
+ if ( simulate )
+ {
+ val = this->descriptor->startval;
+ minval = this->descriptor->minval;
+ maxval = this->descriptor->maxval;
+ }
+ else
+ {
+ RETURN_IF_FAIL ( sanei_hp_scl_inquire(scsi,scl,&val,&minval,&maxval) );
+ }
+
+ if (minval >= maxval)
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_int_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+ _set_size(this, data, sizeof(SANE_Int));
+ return _set_range(this, data, minval, 1, maxval);
+}
+
+static SANE_Status
+_probe_resolution (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ int minval, maxval, min2, max2;
+ int val = 0, val2;
+ int quant = 1;
+ enum hp_device_compat_e compat;
+
+ /* Check for supported resolutions in both directions */
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, SCL_X_RESOLUTION, &val,
+ &minval, &maxval) );
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, SCL_Y_RESOLUTION, &val2, &min2, &max2));
+ if ( min2 > minval ) minval = min2;
+ if ( max2 < maxval ) maxval = max2;
+
+ if (minval >= maxval)
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_int_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+ _set_size(this, data, sizeof(SANE_Int));
+
+ /* The HP OfficeJet Pro 1150C crashes the scan head when scanning at
+ * resolutions less than 42 dpi. Set a safe minimum resolution.
+ * Hopefully 50 dpi is safe enough. */
+ if ((sanei_hp_device_probe(&compat,scsi)==SANE_STATUS_GOOD) &&
+ ((compat&(HP_COMPAT_OJ_1150C|HP_COMPAT_OJ_1170C))==HP_COMPAT_OJ_1150C)) {
+ if (minval<50) minval=50;
+ }
+
+ /* HP Photosmart scanner does not allow scanning at arbitrary resolutions */
+ /* for slides/negatives. Must be multiple of 300 dpi. Set quantization. */
+
+ if ( (sanei_hp_device_probe (&compat, scsi) == SANE_STATUS_GOOD)
+ && (compat & HP_COMPAT_PS) )
+ {int val, mi, ma;
+
+ if ( (sanei_hp_scl_inquire(scsi, SCL_MEDIA, &val, &mi, &ma)
+ == SANE_STATUS_GOOD)
+ && ((val == HP_MEDIA_SLIDE) || (val == HP_MEDIA_NEGATIVE)) )
+ quant = 300;
+ minval = (minval+quant-1)/quant;
+ minval *= quant;
+ maxval = (maxval+quant-1)/quant;
+ maxval *= quant;
+ }
+ DBG(5, "_probe_resolution: set range %d..%d, quant=%d\n",minval,maxval,quant);
+
+ return _set_range(this, data, minval, quant, maxval);
+}
+
+static SANE_Status
+_probe_bool (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int val = 0;
+
+ if (scl)
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, &val, 0, 0) );
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_bool_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+ _set_size(this, data, sizeof(SANE_Bool));
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+_probe_change_doc (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+
+{SANE_Status status;
+ int cap = 0;
+
+ DBG(2, "probe_change_doc: inquire ADF capability\n");
+
+ status = sanei_hp_scl_inquire(scsi, SCL_ADF_CAPABILITY, &cap, 0, 0);
+ if ( (status != SANE_STATUS_GOOD) || (cap == 0))
+ return SANE_STATUS_UNSUPPORTED;
+
+ DBG(2, "probe_change_doc: check if change document is supported\n");
+
+ status = sanei_hp_scl_inquire(scsi, SCL_CHANGE_DOC, &cap, 0, 0);
+ if ( status != SANE_STATUS_GOOD )
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_bool_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, cap);
+ _set_size(this, data, sizeof(SANE_Bool));
+
+ return SANE_STATUS_GOOD;
+}
+
+/* The OfficeJets support SCL_UNLOAD even when no ADF is installed, so
+ * this function was added to check for SCL_ADF_CAPABILITY, similar to
+ * _probe_change_doc(), to hide the unnecessary "Unload" button on
+ * non-ADF OfficeJets. */
+static SANE_Status
+_probe_unload (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+
+{SANE_Status status;
+ int cap = 0;
+
+ DBG(2, "probe_unload: inquire ADF capability\n");
+
+ status = sanei_hp_scl_inquire(scsi, SCL_ADF_CAPABILITY, &cap, 0, 0);
+ if ( (status != SANE_STATUS_GOOD) || (cap == 0))
+ return SANE_STATUS_UNSUPPORTED;
+
+ DBG(2, "probe_unload: check if unload is supported\n");
+
+ status = sanei_hp_scl_inquire(scsi, SCL_UNLOAD, &cap, 0, 0);
+ if ( status != SANE_STATUS_GOOD )
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_bool_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, cap);
+ _set_size(this, data, sizeof(SANE_Bool));
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_probe_calibrate (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ int val = 0; /* Always false */
+ int minval, maxval;
+ int media;
+ int download_calib_file = 1;
+ enum hp_device_compat_e compat;
+
+ /* The OfficeJets don't seem to support calibration, so we'll
+ * remove it from the option list to reduce frontend clutter. */
+ if ((sanei_hp_device_probe (&compat, scsi) == SANE_STATUS_GOOD) &&
+ (compat & HP_COMPAT_OJ_1150C)) {
+ return SANE_STATUS_UNSUPPORTED;
+ }
+
+ /* If we have a Photosmart scanner, we only download the calibration file */
+ /* when medium is set to prints */
+ media = -1;
+ if (sanei_hp_scl_inquire(scsi, SCL_MEDIA, &val, &minval, &maxval)
+ == SANE_STATUS_GOOD)
+ media = val; /* 3: prints, 2: slides, 1: negatives */
+
+ if ( (sanei_hp_device_probe (&compat, scsi) == SANE_STATUS_GOOD)
+ && (compat & HP_COMPAT_PS)
+ && (media != HP_MEDIA_PRINT))
+ download_calib_file = 0;
+
+ /* Recalibrate can not be probed, because it has no inquire ID. */
+ /* And the desired ID of 10963 does not work. So we have to trust */
+ /* the evaluated HP model number. */
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_bool_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+ _set_size(this, data, sizeof(SANE_Bool));
+
+ /* Try to download calibration map */
+ if (download_calib_file)
+ hp_download_calib_file ( scsi );
+
+ return SANE_STATUS_GOOD;
+}
+
+
+static HpChoice
+_make_choice_list (HpChoice choice, int minval, int maxval)
+{
+ static struct hp_choice_s bad = { 0, 0, 0, 0, 0 }; /* FIXME: hack */
+
+ /* FIXME: Another memory leak */
+
+ if (!choice->name)
+ return 0;
+ else if (hp_choice_isSupported(choice, minval, maxval))
+ {
+ _HpChoice new = sanei_hp_memdup(choice, sizeof(*new));
+ if (!new)
+ return &bad;
+ new->next = _make_choice_list(choice + 1, minval, maxval);
+ return new;
+ }
+ else
+ return _make_choice_list(choice + 1, minval, maxval);
+}
+
+static HpChoice
+_make_probed_choice_list (HpScsi scsi, HpScl scl, HpChoice choice,
+ int minval, int maxval)
+{
+ static struct hp_choice_s bad = { 0, 0, 0, 0, 0 }; /* FIXME: hack */
+
+ /* FIXME: Another memory leak */
+
+ if (!choice->name)
+ return 0;
+ else if (hp_probed_choice_isSupported(scsi, scl, choice, minval, maxval))
+ {
+ _HpChoice new = sanei_hp_memdup(choice, sizeof(*new));
+ if (!new)
+ return &bad;
+ new->next = _make_probed_choice_list(scsi, scl, choice + 1, minval, maxval);
+ return new;
+ }
+ else
+ return _make_probed_choice_list(scsi, scl, choice + 1, minval, maxval);
+}
+
+static void
+_set_stringlist (HpOption this, HpData data, SANE_String_Const * strlist)
+{
+ _HpSaneOption optd = _hp_option_saneoption(this, data);
+ optd->constraint.string_list = strlist;
+ optd->constraint_type = SANE_CONSTRAINT_STRING_LIST;
+}
+
+static SANE_Status
+_probe_choice (_HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int minval, maxval, val;
+ HpChoice choices;
+ const HpDeviceInfo *info;
+ enum hp_device_compat_e compat;
+
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, &val, &minval, &maxval) );
+ DBG(3, "choice_option_probe: '%s': val, min, max = %d, %d, %d\n",
+ this->descriptor->name, val, minval, maxval);
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+
+ /* Datawidth needs a special handling. The choicelist consists of */
+ /* values of bits per sample. But the minval/maxval uses bits per pixel */
+ if ( scl == SCL_DATA_WIDTH )
+ {
+ enum hp_scanmode_e scanmode = sanei_hp_optset_scanmode (optset, data);
+
+ /* The data width inquiries seem not to work properly on PhotoSmart */
+ /* Sometimes they report just 24 bits, but support 30 bits too. */
+ /* Sometimes they report min/max to be 24/8. Assume they all support */
+ /* at least 10 bits per channel for RGB. Grayscale is only supported */
+ /* with 8 bits. */
+ if ( (sanei_hp_device_probe (&compat, scsi) == SANE_STATUS_GOOD)
+ && (compat & HP_COMPAT_PS))
+ {
+ if (scanmode == HP_SCANMODE_GRAYSCALE)
+ {
+ minval = 8; if (maxval < 8) maxval = 8;
+ }
+ else if (scanmode == HP_SCANMODE_COLOR)
+ {
+ minval = 24; if (maxval < 30) maxval = 30;
+ }
+ DBG(1, "choice_option_probe: set max. datawidth to %d for photosmart\n",
+ maxval);
+ }
+
+ if ( scanmode == HP_SCANMODE_COLOR )
+ {
+ minval /= 3; if ( minval <= 0) minval = 1;
+ maxval /= 3; if ( maxval <= 0) maxval = 1;
+ val /= 3; if (val <= 0) val = 1;
+ }
+
+#if 0
+ /* The OfficeJets claim to support >8 bits per color, but it may not
+ * work on some models. This code (if not commented out) disables it. */
+ if ((sanei_hp_device_probe (&compat, scsi) == SANE_STATUS_GOOD) &&
+ (compat & HP_COMPAT_OJ_1150C)) {
+ if (maxval>8) maxval=8;
+ }
+#endif
+ }
+
+ choices = _make_choice_list(this->descriptor->choices, minval, maxval);
+ if (choices && !choices->name) /* FIXME: hack */
+ return SANE_STATUS_NO_MEM;
+ if (!choices)
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If no accessor, create one here. */
+#ifdef HP_ALLOC_CHOICEACC_ONCE
+ if (!(this->data_acsr))
+#endif
+ this->data_acsr = sanei_hp_accessor_choice_new(data, choices,
+ this->descriptor->may_change);
+
+ if (!(this->data_acsr))
+ return SANE_STATUS_NO_MEM;
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+
+ _set_stringlist(this, data,
+ sanei_hp_accessor_choice_strlist((HpAccessorChoice)this->data_acsr,
+ 0, 0, info));
+ _set_size(this, data,
+ sanei_hp_accessor_choice_maxsize((HpAccessorChoice)this->data_acsr));
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_probe_each_choice (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int minval, maxval, val;
+ HpChoice choices;
+ const HpDeviceInfo *info;
+
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, &val, &minval, &maxval) );
+ DBG(3, "choice_option_probe_each: '%s': val, min, max = %d, %d, %d\n",
+ this->descriptor->name, val, minval, maxval);
+ DBG(3, "choice_option_probe_each: test all values for '%s' separately\n",
+ this->descriptor->name);
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ choices = _make_probed_choice_list(scsi, scl, this->descriptor->choices,
+ minval, maxval);
+
+ DBG(3, "choice_option_probe_each: restore previous value %d for '%s'\n",
+ val, this->descriptor->name);
+ /* Restore current value */
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, scl, val) );
+
+ if (choices && !choices->name) /* FIXME: hack */
+ return SANE_STATUS_NO_MEM;
+ if (!choices)
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If we dont have an accessor, get one */
+#ifdef HP_ALLOC_CHOICEACC_ONCE
+ if (!this->data_acsr)
+#endif
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_choice_new(data, choices,
+ this->descriptor->may_change )))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+
+ _set_stringlist(this, data,
+ sanei_hp_accessor_choice_strlist((HpAccessorChoice)this->data_acsr,
+ 0, 0, info));
+ _set_size(this, data,
+ sanei_hp_accessor_choice_maxsize((HpAccessorChoice)this->data_acsr));
+ return SANE_STATUS_GOOD;
+}
+
+/* pseudo probe for exposure times in Photosmart */
+static SANE_Status
+_probe_ps_exposure_time (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ int minval = 0, maxval = 9, val = 0;
+ HpChoice choices;
+ const HpDeviceInfo *info;
+
+ choices = _make_choice_list(this->descriptor->choices, minval, maxval);
+ if (choices && !choices->name) /* FIXME: hack */
+ return SANE_STATUS_NO_MEM;
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+
+ /* If we dont have an accessor, get one */
+#ifdef HP_ALLOC_CHOICEACC_ONCE
+ if (!this->data_acsr)
+#endif
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_choice_new(data, choices,
+ this->descriptor->may_change )))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+
+ _set_stringlist(this, data,
+ sanei_hp_accessor_choice_strlist((HpAccessorChoice)this->data_acsr,
+ 0, 0, info));
+ _set_size(this, data,
+ sanei_hp_accessor_choice_maxsize((HpAccessorChoice)this->data_acsr));
+ return SANE_STATUS_GOOD;
+}
+
+/* probe scan type (normal, adf, xpa) */
+static SANE_Status
+_probe_scan_type (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ int val;
+ int numchoices = 0;
+ HpChoice choices;
+ SANE_Status status;
+ const HpDeviceInfo *info;
+ struct hp_choice_s scan_types[4];
+ struct hp_choice_s nch = { 0, 0, 0, 0, 0 };
+ enum hp_device_compat_e compat;
+
+ /* We always have normal scan mode */
+ scan_types[numchoices++] = this->descriptor->choices[0];
+
+ if ( sanei_hp_device_probe (&compat, scsi) != SANE_STATUS_GOOD )
+ compat = 0;
+
+ /* Inquire ADF Capability. PhotoSmart scanner reports ADF capability, */
+ /* but it makes no sense. */
+ if ((compat & HP_COMPAT_PS) == 0)
+ {
+ status = sanei_hp_scl_inquire(scsi, SCL_ADF_CAPABILITY, &val, 0, 0);
+ if ( (status == SANE_STATUS_GOOD) && (val == 1) )
+ {
+ scan_types[numchoices++] = this->descriptor->choices[1];
+ }
+ }
+
+ /* Inquire XPA capability is supported only by IIcx and 6100c/4c/3c. */
+ /* But more devices support XPA scan window. So dont inquire XPA cap. */
+ if ( compat & ( HP_COMPAT_2CX | HP_COMPAT_4C | HP_COMPAT_4P
+ | HP_COMPAT_5P | HP_COMPAT_5100C | HP_COMPAT_6200C) &&
+ !(compat&HP_COMPAT_OJ_1150C) )
+ {
+ scan_types[numchoices++] = this->descriptor->choices[2];
+ }
+
+ /* Only normal scan type available ? No need to display choice */
+ if (numchoices <= 1) return SANE_STATUS_UNSUPPORTED;
+
+ scan_types[numchoices] = nch;
+ val = 0;
+
+ choices = _make_choice_list(scan_types, 0, numchoices);
+ if (choices && !choices->name) /* FIXME: hack */
+ return SANE_STATUS_NO_MEM;
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+
+ /* If we dont have an accessor, get one */
+#ifdef HP_ALLOC_CHOICEACC_ONCE
+ if (!this->data_acsr)
+#endif
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_choice_new(data, choices,
+ this->descriptor->may_change )))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+
+ _set_stringlist(this, data,
+ sanei_hp_accessor_choice_strlist((HpAccessorChoice)this->data_acsr,
+ 0, 0, info));
+ _set_size(this, data,
+ sanei_hp_accessor_choice_maxsize((HpAccessorChoice)this->data_acsr));
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_probe_mirror_horiz (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int minval, maxval, val, sec_dir;
+ HpChoice choices;
+ const HpDeviceInfo *info;
+
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, &val, &minval, &maxval) );
+ DBG(3, "probe_mirror_horiz: '%s': val, min, max = %d, %d, %d\n",
+ this->descriptor->name, val, minval, maxval);
+
+ /* Look if the device supports the (?) inquire secondary scan-direction */
+ if ( sanei_hp_scl_inquire(scsi, SCL_SECONDARY_SCANDIR, &sec_dir, 0, 0)
+ == SANE_STATUS_GOOD )
+ minval = HP_MIRROR_HORIZ_CONDITIONAL;
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ choices = _make_choice_list(this->descriptor->choices, minval, maxval);
+ if (choices && !choices->name) /* FIXME: hack */
+ return SANE_STATUS_NO_MEM;
+ if (!choices)
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If we dont have an accessor, get one */
+#ifdef HP_ALLOC_CHOICEACC_ONCE
+ if (!this->data_acsr)
+#endif
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_choice_new(data, choices,
+ this->descriptor->may_change )))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+
+ _set_stringlist(this, data,
+ sanei_hp_accessor_choice_strlist((HpAccessorChoice)this->data_acsr,
+ 0, 0, info));
+ _set_size(this, data,
+ sanei_hp_accessor_choice_maxsize((HpAccessorChoice)this->data_acsr));
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_probe_mirror_vert (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ int minval = HP_MIRROR_VERT_OFF,
+ maxval = HP_MIRROR_VERT_ON,
+ val = HP_MIRROR_VERT_OFF;
+ int sec_dir;
+ HpChoice choices;
+ const HpDeviceInfo *info;
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+
+ /* Look if the device supports the (?) inquire secondary scan-direction */
+ if ( sanei_hp_scl_inquire(scsi, SCL_SECONDARY_SCANDIR, &sec_dir, 0, 0)
+ == SANE_STATUS_GOOD )
+ maxval = HP_MIRROR_VERT_CONDITIONAL;
+
+ choices = _make_choice_list(this->descriptor->choices, minval, maxval);
+ if (choices && !choices->name) /* FIXME: hack */
+ return SANE_STATUS_NO_MEM;
+ if (!choices)
+ return SANE_STATUS_UNSUPPORTED;
+
+ /* If we dont have an accessor, get one */
+#ifdef HP_ALLOC_CHOICEACC_ONCE
+ if (!this->data_acsr)
+#endif
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_choice_new(data, choices,
+ this->descriptor->may_change )))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+
+ _set_stringlist(this, data,
+ sanei_hp_accessor_choice_strlist((HpAccessorChoice)this->data_acsr,
+ 0, 0, info));
+ _set_size(this, data,
+ sanei_hp_accessor_choice_maxsize((HpAccessorChoice)this->data_acsr));
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status _probe_front_button(_HpOption this, HpScsi scsi,
+ HpOptSet UNUSEDARG optset, HpData data)
+{
+ int val = 0;
+
+ if ( sanei_hp_scl_inquire(scsi, SCL_FRONT_BUTTON, &val, 0, 0)
+ != SANE_STATUS_GOOD )
+ return SANE_STATUS_UNSUPPORTED;
+
+ _set_size(this, data, sizeof(SANE_Bool));
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if ( !(this->data_acsr = sanei_hp_accessor_bool_new(data)) )
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, 0);
+
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+_probe_geometry (_HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ hp_bool_t is_tl = 0;
+ hp_bool_t active_xpa = sanei_hp_is_active_xpa ( scsi );
+ int minval, maxval;
+ SANE_Fixed fval;
+
+ /* There might have been a reason for inquiring the extent */
+ /* by using the maxval of the position. But this does not work */
+ /* when scanning from ADF. The Y-pos is then inquired with -1..0. */
+ /* First try to get the values with SCL_X/Y_POS. If this is not ok, */
+ /* use SCL_X/Y_EXTENT */
+ if (scl == SCL_X_EXTENT)
+ {
+ scl = SCL_X_POS;
+ }
+ else if (scl == SCL_Y_EXTENT)
+ {
+ scl = SCL_Y_POS;
+ }
+ else
+ is_tl = 1;
+
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, 0, &minval, &maxval) );
+ if (minval >= maxval)
+ return SANE_STATUS_INVAL;
+
+ /* Bad maximum value for extent-inquiry ? */
+ if ( (!is_tl) && (maxval <= 0) )
+ {
+ scl = (scl == SCL_X_POS) ? SCL_X_EXTENT : SCL_Y_EXTENT;
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, 0, &minval, &maxval) );
+ if (minval >= maxval)
+ return SANE_STATUS_INVAL;
+ }
+
+ if ((scl == SCL_X_EXTENT) || (scl == SCL_Y_EXTENT))
+ {
+ /* Max. extent is larger than max. position. Reduce extent */
+ maxval--;
+ DBG(3, "probe_geometry: Inquiry by extent. Reduced maxval to %lu\n",
+ (unsigned long)maxval);
+ }
+
+ /* Need a new accessor ? */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_fixed_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ /* The active xpa is only 5x5 inches */
+ if ( (!is_tl) && active_xpa
+ && (sanei_hp_optset_scan_type (optset, data) == SCL_XPA_SCAN) )
+ {
+ DBG(3,"Set maxval to 1500 because of active XPA\n");
+ maxval = 1500;
+ }
+
+ fval = is_tl ? SANE_FIX(0.0) : maxval * SANE_FIX(MM_PER_DEVPIX);
+ RETURN_IF_FAIL( sanei_hp_accessor_set(this->data_acsr, data, &fval) );
+
+ _set_size(this, data, sizeof(SANE_Fixed));
+ return _set_range(this, data,
+ minval * SANE_FIX(MM_PER_DEVPIX),
+ 1,
+ maxval * SANE_FIX(MM_PER_DEVPIX));
+}
+
+static SANE_Status
+_probe_download_type (HpScl scl, HpScsi scsi)
+{
+ SANE_Status status;
+
+ sanei_hp_scl_clearErrors (scsi);
+ sanei_hp_scl_set (scsi, SCL_DOWNLOAD_TYPE, SCL_INQ_ID(scl));
+
+ status = sanei_hp_scl_errcheck (scsi);
+
+ DBG(3, "probe_download_type: Download type %d %ssupported\n", SCL_INQ_ID(scl),
+ (status == SANE_STATUS_GOOD) ? "" : "not ");
+
+ return status;
+}
+
+static SANE_Status
+_probe_custom_gamma (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ HpScl scl_tonemap = SCL_8x8TONE_MAP;
+ SANE_Status status;
+ hp_bool_t simulate;
+ int val = 0, minval, maxval;
+ int id = SCL_INQ_ID(scl_tonemap);
+
+ /* Check if download type supported */
+ status = sanei_hp_device_support_get ( sanei_hp_scsi_devicename (scsi),
+ SCL_DOWNLOAD_TYPE, &minval, &maxval);
+
+ simulate = (status != SANE_STATUS_GOOD) || (id < minval) || (id > maxval);
+
+ if (simulate)
+ {
+ DBG(3, "probe_custom_gamma: Download type 2 not supported. Simulate\n");
+ }
+ else
+ {
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, &val, 0, 0) );
+ }
+
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_bool_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, val);
+ _set_size(this, data, sizeof(SANE_Bool));
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_probe_vector (_HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ static struct vector_type_s {
+ HpScl scl;
+ unsigned length, depth;
+ HpAccessor (*creator)(HpData data, unsigned length, unsigned depth);
+ } types[] = {
+ { SCL_8x8TONE_MAP, 256, 8, sanei_hp_accessor_gamma_vector_new },
+#ifdef ENABLE_7x12_TONEMAPS
+ { SCL_BW7x12TONE_MAP, 129, 12, sanei_hp_accessor_gamma_vector_new },
+ { SCL_7x12TONE_MAP, 3 * 129, 12, sanei_hp_accessor_gamma_vector_new },
+#endif
+#ifdef ENABLE_16x16_DITHERS
+ { SCL_BW16x16DITHER, 256, 8, sanei_hp_accessor_vector_new },
+#endif
+ { SCL_BW8x8DITHER, 64, 8, sanei_hp_accessor_vector_new },
+
+ { SCL_8x9MATRIX_COEFF, 9, 8, sanei_hp_accessor_matrix_vector_new },
+#ifdef ENABLE_10BIT_MATRIXES
+ { SCL_10x9MATRIX_COEFF, 9, 10, sanei_hp_accessor_matrix_vector_new },
+ { SCL_10x3MATRIX_COEFF, 3, 10, sanei_hp_accessor_matrix_vector_new },
+#endif
+ { 0, 0, 0, 0 }
+ };
+ static struct subvector_type_s {
+ HpOptionDescriptor desc;
+ unsigned nchan, chan;
+ HpOptionDescriptor super;
+ } subvec_types[] = {
+#ifdef ENABLE_7x12_TONEMAPS
+ { GAMMA_VECTOR_R, 3, 0, RGB_TONEMAP },
+ { GAMMA_VECTOR_G, 3, 1, RGB_TONEMAP },
+ { GAMMA_VECTOR_B, 3, 2, RGB_TONEMAP },
+#endif
+ { 0, 0, 0, 0 },
+ };
+
+ HpScl scl = this->descriptor->scl_command;
+ HpAccessorVector vec;
+
+ if (scl)
+ {
+ struct vector_type_s *type;
+ for (type = types; type->scl; type++)
+ if (type->scl == scl)
+ break;
+ assert(type->scl);
+
+ RETURN_IF_FAIL ( _probe_download_type (scl, scsi) );
+ /* If we dont have an accessor, get one */
+#ifdef HP_ALLOC_CHOICEACC_ONCE
+ if (!this->data_acsr)
+#endif
+ {
+ this->data_acsr = (*type->creator)(data, type->length, type->depth);
+ }
+ }
+ else
+ {
+ struct subvector_type_s *type;
+ HpOption super;
+
+ for (type = subvec_types; type->desc; type++)
+ if (type->desc == this->descriptor)
+ break;
+ assert(type->desc);
+
+ super = hp_optset_get(optset, type->super);
+ assert(super);
+
+ /* If we dont have an accessor, get one */
+#ifdef HP_ALLOC_CHOICEACC_ONCE
+ if (!this->data_acsr)
+#endif
+ {
+ this->data_acsr = sanei_hp_accessor_subvector_new(
+ (HpAccessorVector) super->data_acsr, type->nchan, type->chan);
+ }
+ }
+
+ if (!this->data_acsr)
+ return SANE_STATUS_NO_MEM;
+
+ vec = (HpAccessorVector)this->data_acsr;
+
+ _set_size(this, data, sizeof(SANE_Fixed)
+ * sanei_hp_accessor_vector_length(vec));
+
+ return _set_range(this, data,
+ sanei_hp_accessor_vector_minval(vec),
+ 1,
+ sanei_hp_accessor_vector_maxval(vec));
+}
+
+static SANE_Status
+_probe_gamma_vector (_HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ SANE_Fixed * buf;
+ int i;
+ size_t size, length;
+
+ RETURN_IF_FAIL( _probe_vector(this, scsi, optset, data) );
+
+ /* Initialize to linear map */
+ size = hp_option_saneoption(this, data)->size;
+ if (!(buf = alloca(size)))
+ return SANE_STATUS_NO_MEM;
+ length = size / sizeof(SANE_Fixed);
+ for (i = 0; i < (int)length; i++)
+ buf[i] = (SANE_FIX(HP_VECTOR_SCALE* 1.0) * i + (length-1) / 2) / length;
+ return sanei_hp_accessor_set(this->data_acsr, data, buf);
+}
+
+
+static SANE_Status
+_probe_horiz_dither (_HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ int dim = 8;
+ size_t size;
+ int i, j;
+ SANE_Fixed * buf;
+
+ if (this->descriptor->scl_command == SCL_BW16x16DITHER)
+ dim = 16;
+
+ RETURN_IF_FAIL( _probe_vector(this, scsi, optset, data) );
+
+ /* Select vertical dither pattern, and upload it */
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_BW_DITHER, HP_DITHER_VERTICAL) );
+ RETURN_IF_FAIL( hp_option_upload(this, scsi, optset, data) );
+
+ /* Flip it to get a horizontal dither pattern */
+ size = hp_option_saneoption(this, data)->size;
+ assert(size == dim * dim * sizeof(SANE_Fixed));
+ if (!(buf = alloca(size)))
+ return SANE_STATUS_NO_MEM;
+
+#define SWAP_FIXED(x,y) do { SANE_Fixed tmp = x; x = y; y = tmp; } while(0)
+ RETURN_IF_FAIL( sanei_hp_accessor_get(this->data_acsr, data, buf) );
+ for (i = 0; i < dim; i++) for (j = i + 1; j < dim; j++)
+ SWAP_FIXED(buf[i * dim + j], buf[j * dim + i]);
+ return sanei_hp_accessor_set(this->data_acsr, data, buf);
+}
+
+static SANE_Status
+_probe_matrix (_HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ RETURN_IF_FAIL( _probe_vector(this, scsi, optset, data) );
+
+ /* Initial value: select RGB matrix, and upload it. */
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_MATRIX, HP_MATRIX_RGB) );
+ return hp_option_upload(this, scsi, optset, data);
+}
+
+static SANE_Status
+_probe_num_options (_HpOption this, HpScsi UNUSEDARG scsi,
+ HpOptSet UNUSEDARG optset, HpData data)
+{
+ /* If we dont have an accessor, get one */
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_int_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+ _set_size(this, data, sizeof(SANE_Int));
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_probe_devpix (_HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int resolution;
+
+ if (FAILED( sanei_hp_scl_inquire(scsi, scl, &resolution, 0, 0) ))
+ {
+ DBG(1, "probe_devpix: inquiry failed, assume 300 ppi\n");
+ resolution = 300;
+ }
+
+ if (!this->data_acsr)
+ {
+ if (!(this->data_acsr = sanei_hp_accessor_int_new(data)))
+ return SANE_STATUS_NO_MEM;
+ }
+
+ sanei_hp_accessor_setint(this->data_acsr, data, resolution);
+ _set_size(this, data, sizeof(SANE_Int));
+ return SANE_STATUS_GOOD;
+}
+
+
+/*
+ * Simulate functions
+ */
+static SANE_Status
+_simulate_brightness (HpOption this, HpData data, HpScsi scsi)
+{
+ int k, val, newval;
+ unsigned char *brightness_map;
+ HpDeviceInfo *info;
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ assert (info);
+
+ val = sanei_hp_accessor_getint(this->data_acsr, data);
+
+ DBG(3, "simulate_brightness: value = %d\n", val);
+
+ /* Update brightness map in info structure */
+ brightness_map = &(info->simulate.brightness_map[0]);
+ val *= 2; /* A value of 127 should give a totally white image */
+ for (k = 0; k < 256; k++)
+ {
+ newval = k + val;
+ if (newval < 0) newval = 0; else if (newval > 255) newval = 255;
+ brightness_map[k] = (unsigned char)newval;
+ }
+ return SANE_STATUS_GOOD;
+}
+
+static int
+hp_contrast (int x, int g)
+
+{int y = 0;
+
+ if (g < -127) g = -127; else if (g > 127) g = 127;
+ if (x < 0) x = 0; else if (x > 255) x = 255;
+
+ if (g == 0)
+ {
+ y = x;
+ }
+ else if (g < 0)
+ {
+ g = -g;
+ y = x * (255 - 2*g);
+ y = y/255 + g;
+ }
+ else
+ {
+ if (x <= g) y = 0;
+ else if (x >= 255-g) y = 255;
+ else
+ {
+ y = (x - g)*255;
+ y /= (255 - 2*g);
+ }
+ }
+
+ return y;
+}
+
+static SANE_Status
+_simulate_contrast (HpOption this, HpData data, HpScsi scsi)
+{
+ int k, val, newval;
+ unsigned char *contrast_map;
+ HpDeviceInfo *info;
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ assert (info);
+
+ val = sanei_hp_accessor_getint(this->data_acsr, data);
+
+ DBG(3, "simulate_contrast: value = %d\n", val);
+
+ /* Update contrast map in info structure */
+ contrast_map = &(info->simulate.contrast_map[0]);
+
+ for (k = 0; k < 256; k++)
+ {
+ newval = hp_contrast (k, val);
+ if (newval < 0) newval = 0; else if (newval > 255) newval = 255;
+ contrast_map[k] = (unsigned char)newval;
+ }
+ return SANE_STATUS_GOOD;
+}
+
+/*
+ * Option download functions
+ */
+static SANE_Status
+_program_generic (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ return hp_option_download(this, data, optset, scsi);
+}
+
+static SANE_Status
+_program_geometry (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+/* #define HP_LIMIT_ADF_WINDOW */
+#ifndef HP_LIMIT_ADF_WINDOW
+
+ return hp_option_download(this, data, optset, scsi);
+
+#else
+
+ HpScl scl = this->descriptor->scl_command;
+ int value;
+ SANE_Status Status;
+
+ if (sanei_hp_optset_scan_type (optset, data) != SCL_ADF_SCAN)
+ return hp_option_download(this, data, optset, scsi);
+
+ /* ADF may crash when scanning only a window ? */
+ if ( (scl == SCL_X_POS) || (scl == SCL_Y_POS) )
+ {
+ value = 0;
+ DBG(3,"program_geometry: set %c-pos to %d\n",
+ (scl == SCL_X_POS) ? 'x' : 'y', value);
+ }
+ else if ( scl == SCL_X_EXTENT )
+ {
+ value = 2550;
+ DBG(3,"program_geometry: set x-extent to %d\n", value);
+ }
+ else
+ {
+ value = 4200;
+ DBG(3,"program_geometry: set y-extent to %d\n", value);
+ }
+
+ Status = sanei_hp_scl_set(scsi, scl, value);
+ return Status;
+
+#endif
+}
+
+static SANE_Status
+_program_data_width (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ int value = sanei_hp_accessor_getint(this->data_acsr, data);
+ SANE_Status status;
+
+ if ( sanei_hp_optset_scanmode (optset, data) == HP_SCANMODE_COLOR )
+ {
+ value *= 3;
+ if (value < 24)
+ {
+ DBG(3,"program_data_width: map datawith from %d to 24\n", (int)value);
+ value = 24;
+ }
+ }
+ status = sanei_hp_scl_set(scsi, scl, value);
+ return status;
+}
+
+static SANE_Status
+_program_generic_simulate (HpOption this, HpScsi scsi, HpOptSet optset,
+ HpData data)
+{
+ HpScl scl = this->descriptor->scl_command;
+ const char *devname = sanei_hp_scsi_devicename (scsi);
+ int simulate;
+
+ /* Check if command is supported */
+ simulate = ( sanei_hp_device_support_get (devname, scl, 0, 0)
+ != SANE_STATUS_GOOD );
+
+ /* Save simulate flag */
+ sanei_hp_device_simulate_set (devname, scl, simulate);
+
+ if ( !simulate ) /* Let the device do it */
+ return hp_option_download(this, data, optset, scsi);
+
+ DBG(3, "program_generic: %lu not programmed. Will be simulated\n",
+ (unsigned long)(SCL_INQ_ID(scl)));
+
+ switch (scl)
+ {
+ case SCL_BRIGHTNESS:
+ _simulate_brightness (this, data, scsi);
+ break;
+
+ case SCL_CONTRAST:
+ _simulate_contrast (this, data,scsi);
+ break;
+
+ default:
+ DBG(1, "program_generic: No simulation for %lu\n",
+ (unsigned long)(SCL_INQ_ID(scl)));
+ break;
+ }
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_simulate_custom_gamma (HpOption gvector, HpScsi scsi, HpData data)
+{
+ size_t size = sanei_hp_accessor_size(gvector->data_acsr);
+ const unsigned char *vector_data =
+ (const unsigned char *)sanei_hp_accessor_data(gvector->data_acsr, data);
+ HpDeviceInfo *info;
+ int k, newval;
+
+ DBG(3,"program_custom_gamma_simulate: save gamma map\n");
+ if (size != 256)
+ {
+ DBG(1,"program_custom_gamma_simulate: size of vector is %d.\
+ Should be 256.\n", (int)size);
+ return SANE_STATUS_INVAL;
+ }
+
+ RETURN_IF_FAIL (sanei_hp_scl_set(scsi, SCL_TONE_MAP, 0));
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ info->simulate.gamma_simulate = 1;
+
+ for (k = 0; k < 256; k++)
+ {
+ newval = 255 - vector_data[255-k];
+ if (newval < 0) newval = 0; else if (newval > 255) newval = 255;
+ info->simulate.gamma_map[k] = newval;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_program_tonemap (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ hp_bool_t use_custom_map = hp_option_getint(this, data);
+ HpOption gvector = 0;
+ int type = 0;
+
+ if (!use_custom_map)
+ return sanei_hp_scl_set(scsi, SCL_TONE_MAP, 0);
+
+#ifdef ENABLE_7x12_TONEMAPS
+ /* Try to find the appropriate 5P style tonemap. */
+ if (sanei_hp_optset_scanmode(optset, data) == HP_SCANMODE_COLOR)
+ {
+ type = -1;
+ gvector = hp_optset_get(optset, RGB_TONEMAP);
+ }
+ else
+ {
+ type = -2;
+ gvector = hp_optset_get(optset, GAMMA_VECTOR_7x12);
+ }
+#endif
+
+ /* If that failed, just use 8x8 tonemap */
+ if (!gvector)
+ {
+ HpScl scl_tonemap = SCL_8x8TONE_MAP;
+ hp_bool_t simulate;
+ int id = SCL_INQ_ID(scl_tonemap);
+ int minval, maxval;
+ SANE_Status status;
+
+ type = -1;
+ gvector = hp_optset_get(optset, GAMMA_VECTOR_8x8);
+
+ /* Check if download type supported */
+ status = sanei_hp_device_support_get ( sanei_hp_scsi_devicename (scsi),
+ SCL_DOWNLOAD_TYPE, &minval, &maxval);
+
+ simulate = (status != SANE_STATUS_GOOD) || (id < minval)
+ || (id > maxval);
+ if (simulate)
+ return _simulate_custom_gamma (gvector, scsi, data);
+ }
+
+ assert(gvector != 0);
+
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_TONE_MAP, type) );
+ return hp_option_download(gvector, data, optset, scsi);
+}
+
+
+static SANE_Status
+_program_dither (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ enum hp_dither_type_e type = hp_option_getint(this, data);
+ HpOption dither;
+
+ switch (type) {
+ case HP_DITHER_CUSTOM:
+ dither = hp_optset_getByName(optset, SANE_NAME_HALFTONE_PATTERN);
+ assert(dither != 0);
+ break;
+ case HP_DITHER_HORIZONTAL:
+ dither = hp_optset_getByName(optset, HP_NAME_HORIZONTAL_DITHER);
+ type = HP_DITHER_CUSTOM;
+ assert(dither != 0);
+ break;
+ default:
+ dither = 0;
+ break;
+ }
+
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_BW_DITHER, type) );
+ if (!dither)
+ return SANE_STATUS_GOOD;
+ return hp_option_download(dither, data, optset, scsi);
+}
+
+#ifdef FAKE_COLORSEP_MATRIXES
+static HpOption
+_get_sepmatrix (HpOptSet optset, HpData data, enum hp_matrix_type_e type)
+{
+ SANE_Fixed buf[9];
+ HpOption matrix = hp_optset_get(optset, SEPMATRIX);
+
+ memset(buf, 0, sizeof(buf));
+ if (type == HP_MATRIX_RED)
+ buf[1] = SANE_FIX(1.0);
+ else if (type == HP_MATRIX_GREEN)
+ buf[4] = SANE_FIX(1.0);
+ else if (type == HP_MATRIX_BLUE)
+ buf[7] = SANE_FIX(1.0);
+ else
+ {
+ assert(!"Bad colorsep type");
+ return 0;
+ }
+ sanei_hp_accessor_set(matrix->data_acsr, data, buf);
+ return matrix;
+}
+#endif
+
+static SANE_Status
+_program_matrix (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ enum hp_matrix_type_e type = hp_option_getint(this, data);
+ HpOption matrix = 0;
+
+ if (type == HP_MATRIX_AUTO)
+ return SANE_STATUS_GOOD; /* Default to matrix set by mode */
+
+ /* Download custom matrix, if we need it. */
+ if (type == HP_MATRIX_CUSTOM)
+ {
+ matrix = hp_optset_getByName(optset, SANE_NAME_MATRIX_RGB);
+ assert(matrix);
+ }
+#ifdef FAKE_COLORSEP_MATRIXES
+ else if (type == HP_MATRIX_RED
+ || type == HP_MATRIX_BLUE
+ || type == HP_MATRIX_GREEN)
+ {
+ matrix = _get_sepmatrix(optset, data, type);
+ type = HP_MATRIX_CUSTOM;
+ assert(matrix);
+ }
+#else
+ else if (type == HP_MATRIX_GREEN)
+ type = HP_MATRIX_PASS;
+#endif
+
+
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_MATRIX, type) );
+ if (matrix)
+ RETURN_IF_FAIL( hp_option_download(matrix, data, optset, scsi) );
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_program_resolution (HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+
+ int xresolution = hp_option_getint(this, data);
+ int yresolution = xresolution;
+ int xscale = 100, yscale = 100;
+
+#ifdef FIX_PHOTOSMART
+ int minval, maxval, media;
+ enum hp_device_compat_e compat;
+
+ /* HP Photosmart scanner has problems with scanning slides/negatives */
+ /* at arbitrary resolutions. The following tests did not work: */
+ /* xres = yres = next lower multiple of 300, xscale = yscale > 100: */
+ /* xres = yres = next higher multiple of 300, xscale = yscale < 100: */
+ /* xres = next lower multiple of 300, xscale > 100 */
+ /* xres = next higher multiple of 300, xscale < 100 */
+ /* yres = next lower multiple of 300, yscale > 100 */
+ /* yres = next higher multiple of 300, yscale < 100 */
+ /* The image extent was ok, but the content was streched in y-direction */
+
+ if (xresolution > 300)
+ {
+ if ( (sanei_hp_device_probe (&compat, scsi) == SANE_STATUS_GOOD)
+ && (compat & HP_COMPAT_PS)
+ && (sanei_hp_scl_inquire(scsi, SCL_MEDIA, &media, &minval, &maxval)
+ == SANE_STATUS_GOOD)
+ && ((media == HP_MEDIA_SLIDE) || (media == HP_MEDIA_NEGATIVE)))
+ {int next_resolution;
+ next_resolution = (xresolution % 300) * 300;
+ if (next_resolution < 300) next_resolution = 300;
+ yresolution = next_resolution;
+ yscale = (int)(100.0 * xresolution / yresolution);
+ }
+ }
+#endif
+
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_X_SCALE, xscale) );
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_Y_SCALE, yscale) );
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_X_RESOLUTION, xresolution) );
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_Y_RESOLUTION, yresolution) );
+
+ return SANE_STATUS_GOOD;
+}
+
+static char *
+get_home_dir (void)
+{
+#ifdef SANE_HOME_HP
+
+ return getenv (SANE_HOME_HP);
+
+#else
+
+ struct passwd *pw;
+
+ pw = getpwuid (getuid ()); /* Look if we can find our home directory */
+ return pw ? pw->pw_dir : NULL;
+
+#endif
+}
+
+static char *
+get_calib_filename (HpScsi scsi)
+{
+ char *homedir;
+ char *calib_filename, *cf;
+ const char *devname = sanei_hp_scsi_devicename (scsi);
+ int name_len;
+
+ homedir = get_home_dir (); /* Look if we can find our home directory */
+ if (!homedir) return NULL;
+
+ name_len = strlen (homedir) + 33;
+ if ( devname ) name_len += strlen (devname);
+ calib_filename = sanei_hp_allocz (name_len);
+ if (!calib_filename) return NULL;
+
+ strcpy (calib_filename, homedir);
+ strcat (calib_filename, "/.sane/calib-hp");
+ if ( devname && devname[0] ) /* Replace '/' by "+-" */
+ {
+ cf = calib_filename + strlen (calib_filename);
+ *(cf++) = ':';
+ while (*devname)
+ {
+ if (*devname == '/') *(cf++) = '+', *(cf++) = '-';
+ else *(cf++) = *devname;
+ devname++;
+ }
+ }
+ strcat (calib_filename, ".dat");
+
+ return calib_filename;
+}
+
+static SANE_Status
+read_calib_file (int *nbytes, char **calib_data, HpScsi scsi)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ char *calib_filename;
+ FILE *calib_file;
+ int err, c1, c2, c3, c4;
+
+ *nbytes = 0;
+ *calib_data = NULL;
+
+ calib_filename = get_calib_filename ( scsi );
+ if (!calib_filename) return SANE_STATUS_NO_MEM;
+
+ calib_file = fopen (calib_filename, "rb");
+ if ( calib_file )
+ {
+ err = ((c1 = getc (calib_file)) == EOF);
+ err |= ((c2 = getc (calib_file)) == EOF);
+ err |= ((c3 = getc (calib_file)) == EOF);
+ err |= ((c4 = getc (calib_file)) == EOF);
+ *nbytes = (c1 << 24) | (c2 << 16) | (c3 << 8) | c4;
+ if ( err )
+ {
+ DBG(1, "read_calib_file: Error reading calibration data size\n");
+ status = SANE_STATUS_EOF;
+ }
+ else
+ {
+ *calib_data = sanei_hp_alloc ( *nbytes );
+ if ( !*calib_data )
+ {
+ status = SANE_STATUS_NO_MEM;
+ }
+ else
+ {
+ err |= ((int)fread (*calib_data,1,*nbytes,calib_file) != *nbytes);
+ if ( err )
+ {
+ DBG(1, "read_calib_file: Error reading calibration data\n");
+ sanei_hp_free ( *calib_data );
+ status = SANE_STATUS_EOF;
+ }
+ }
+ }
+ fclose ( calib_file );
+ }
+ else
+ {
+ DBG(1, "read_calib_file: Error opening calibration file %s\
+ for reading\n", calib_filename);
+ status = SANE_STATUS_EOF;
+ }
+
+ sanei_hp_free (calib_filename);
+
+ return ( status );
+}
+
+static SANE_Status
+write_calib_file (int nbytes, char *data, HpScsi scsi)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ char *calib_filename;
+ int err;
+ FILE *calib_file;
+
+ calib_filename = get_calib_filename ( scsi );
+ if (!calib_filename) return SANE_STATUS_NO_MEM;
+
+ calib_file = fopen (calib_filename, "wb");
+ if ( calib_file )
+ {
+ err = (putc ((nbytes >> 24) & 0xff, calib_file) == EOF);
+ err |= (putc ((nbytes >> 16) & 0xff, calib_file) == EOF);
+ err |= (putc ((nbytes >> 8) & 0xff, calib_file) == EOF);
+ err |= (putc (nbytes & 0xff, calib_file) == EOF);
+ err |= ((int)fwrite (data, 1, nbytes, calib_file) != nbytes);
+ fclose (calib_file);
+ if ( err )
+ {
+ DBG(1, "write_calib_file: Error writing calibration data\n");
+ unlink (calib_filename);
+ status = SANE_STATUS_EOF;
+ }
+ }
+ else
+ {
+ DBG(1, "write_calib_file: Error opening calibration file %s\
+ for writing\n", calib_filename);
+ status = SANE_STATUS_EOF;
+ }
+
+ sanei_hp_free (calib_filename);
+ return (status);
+}
+
+static SANE_Status
+_program_media (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ int req_media, minval, maxval, current_media;
+ HpScl scl = this->descriptor->scl_command;
+
+ req_media = sanei_hp_accessor_getint(this->data_acsr, data);
+
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, scl, &current_media,
+ &minval, &maxval) );
+ if (current_media == req_media)
+ return SANE_STATUS_GOOD;
+
+ /* Unload scanner */
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_UNLOAD, 0) );
+
+ /* Select new media */
+ RETURN_IF_FAIL( hp_option_download(this, data, optset, scsi));
+
+ /* Update support list */
+ sanei_hp_device_support_probe (scsi);
+
+ if (req_media == HP_MEDIA_PRINT)
+ hp_download_calib_file (scsi);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_program_unload_after_scan (HpOption this, HpScsi scsi,
+ HpOptSet UNUSEDARG optset, HpData data)
+{ HpDeviceInfo *info;
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ assert (info);
+ info->unload_after_scan = sanei_hp_accessor_getint(this->data_acsr, data);
+
+ DBG(3,"program_unload_after_scan: flag = %lu\n",
+ (unsigned long)info->unload_after_scan);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_program_lamp_off (HpOption UNUSEDARG this, HpScsi scsi,
+ HpOptSet UNUSEDARG optset, HpData UNUSEDARG data)
+{
+ DBG(3,"program_lamp_off: shut off lamp\n");
+
+ return sanei_hp_scl_set(scsi, SCL_LAMPTEST, 0);
+}
+
+static SANE_Status
+_program_scan_type (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+
+{ int req_scan_type;
+
+ req_scan_type = sanei_hp_accessor_getint(this->data_acsr, data);
+
+ if ( req_scan_type == HP_SCANTYPE_XPA )
+ {
+ enum hp_scanmode_e scan_mode = sanei_hp_optset_scanmode(optset, data);
+ static unsigned char xpa_matrix_coeff[] = {
+0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
+0x00,0x80
+ };
+ static unsigned char xpa_tone_map[] = {
+0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0xfe,0x0f,
+0xe1,0x0f,0xd3,0x0f,0xc4,0x0f,0xb5,0x0f,0xa6,0x0f,0x97,0x0f,0x88,0x0f,0x79,0x0f,
+0x6a,0x0f,0x5b,0x0f,0x4b,0x0f,0x3c,0x0f,0x2c,0x0f,0x1d,0x0f,0x0d,0x0e,0xfe,0x0e,
+0xee,0x0e,0xde,0x0e,0xce,0x0e,0xbe,0x0e,0xae,0x0e,0x9e,0x0e,0x8e,0x0e,0x7d,0x0e,
+0x6d,0x0e,0x5c,0x0e,0x4c,0x0e,0x3b,0x0e,0x2a,0x0e,0x19,0x0e,0x08,0x0d,0xf7,0x0d,
+0xe6,0x0d,0xd5,0x0d,0xc4,0x0d,0xb2,0x0d,0xa1,0x0d,0x8f,0x0d,0x7d,0x0d,0x6b,0x0d,
+0x59,0x0d,0x47,0x0d,0x35,0x0d,0x22,0x0d,0x10,0x0c,0xfd,0x0c,0xeb,0x0c,0xd8,0x0c,
+0xc5,0x0c,0xb2,0x0c,0x9e,0x0c,0x8b,0x0c,0x77,0x0c,0x64,0x0c,0x50,0x0c,0x3c,0x0c,
+0x28,0x0c,0x14,0x0b,0xff,0x0b,0xeb,0x0b,0xd6,0x0b,0xc1,0x0b,0xac,0x0b,0x96,0x0b,
+0x81,0x0b,0x6b,0x0b,0x55,0x0b,0x3f,0x0b,0x29,0x0b,0x12,0x0a,0xfc,0x0a,0xe5,0x0a,
+0xce,0x0a,0xb6,0x0a,0x9e,0x0a,0x87,0x0a,0x6e,0x0a,0x56,0x0a,0x3d,0x0a,0x24,0x0a,
+0x0b,0x09,0xf1,0x09,0xd8,0x09,0xbd,0x09,0xa3,0x09,0x88,0x09,0x6d,0x09,0x51,0x09,
+0x35,0x09,0x19,0x08,0xfc,0x08,0xdf,0x08,0xc1,0x08,0xa3,0x08,0x84,0x08,0x65,0x08,
+0x45,0x08,0x24,0x08,0x03,0x07,0xe1,0x07,0xbe,0x07,0x9b,0x07,0x78,0x07,0x53,0x07,
+0x2d,0x07,0x07,0x06,0xdf,0x06,0xb7,0x06,0x8d,0x06,0x62,0x06,0x36,0x06,0x07,0x05,
+0xd8,0x05,0xa6,0x05,0x72,0x05,0x3c,0x04,0xfc,0x04,0x7c,0x03,0xfc,0x03,0x7c,0x02,
+0xfc,0x02,0x7c,0x01,0xfc,0x01,0x7c,0x00,0xfc,0x00,0x7c,0x00,0x00,0x0f,0xfe,0x0f,
+0xe1,0x0f,0xd3,0x0f,0xc4,0x0f,0xb5,0x0f,0xa6,0x0f,0x97,0x0f,0x88,0x0f,0x79,0x0f,
+0x6a,0x0f,0x5b,0x0f,0x4b,0x0f,0x3c,0x0f,0x2c,0x0f,0x1d,0x0f,0x0d,0x0e,0xfe,0x0e,
+0xee,0x0e,0xde,0x0e,0xce,0x0e,0xbe,0x0e,0xae,0x0e,0x9e,0x0e,0x8e,0x0e,0x7d,0x0e,
+0x6d,0x0e,0x5c,0x0e,0x4c,0x0e,0x3b,0x0e,0x2a,0x0e,0x19,0x0e,0x08,0x0d,0xf7,0x0d,
+0xe6,0x0d,0xd5,0x0d,0xc4,0x0d,0xb2,0x0d,0xa1,0x0d,0x8f,0x0d,0x7d,0x0d,0x6b,0x0d,
+0x59,0x0d,0x47,0x0d,0x35,0x0d,0x22,0x0d,0x10,0x0c,0xfd,0x0c,0xeb,0x0c,0xd8,0x0c,
+0xc5,0x0c,0xb2,0x0c,0x9e,0x0c,0x8b,0x0c,0x77,0x0c,0x64,0x0c,0x50,0x0c,0x3c,0x0c,
+0x28,0x0c,0x14,0x0b,0xff,0x0b,0xeb,0x0b,0xd6,0x0b,0xc1,0x0b,0xac,0x0b,0x96,0x0b,
+0x81,0x0b,0x6b,0x0b,0x55,0x0b,0x3f,0x0b,0x29,0x0b,0x12,0x0a,0xfc,0x0a,0xe5,0x0a,
+0xce,0x0a,0xb6,0x0a,0x9e,0x0a,0x87,0x0a,0x6e,0x0a,0x56,0x0a,0x3d,0x0a,0x24,0x0a,
+0x0b,0x09,0xf1,0x09,0xd8,0x09,0xbd,0x09,0xa3,0x09,0x88,0x09,0x6d,0x09,0x51,0x09,
+0x35,0x09,0x19,0x08,0xfc,0x08,0xdf,0x08,0xc1,0x08,0xa3,0x08,0x84,0x08,0x65,0x08,
+0x45,0x08,0x24,0x08,0x03,0x07,0xe1,0x07,0xbe,0x07,0x9b,0x07,0x78,0x07,0x53,0x07,
+0x2d,0x07,0x07,0x06,0xdf,0x06,0xb7,0x06,0x8d,0x06,0x62,0x06,0x36,0x06,0x07,0x05,
+0xd8,0x05,0xa6,0x05,0x72,0x05,0x3c,0x04,0xfc,0x04,0x7c,0x03,0xfc,0x03,0x7c,0x02,
+0xfc,0x02,0x7c,0x01,0xfc,0x01,0x7c,0x00,0xfc,0x00,0x7c,0x00,0x00,0x0f,0xfe,0x0f,
+0xe1,0x0f,0xd3,0x0f,0xc4,0x0f,0xb5,0x0f,0xa6,0x0f,0x97,0x0f,0x88,0x0f,0x79,0x0f,
+0x6a,0x0f,0x5b,0x0f,0x4b,0x0f,0x3c,0x0f,0x2c,0x0f,0x1d,0x0f,0x0d,0x0e,0xfe,0x0e,
+0xee,0x0e,0xde,0x0e,0xce,0x0e,0xbe,0x0e,0xae,0x0e,0x9e,0x0e,0x8e,0x0e,0x7d,0x0e,
+0x6d,0x0e,0x5c,0x0e,0x4c,0x0e,0x3b,0x0e,0x2a,0x0e,0x19,0x0e,0x08,0x0d,0xf7,0x0d,
+0xe6,0x0d,0xd5,0x0d,0xc4,0x0d,0xb2,0x0d,0xa1,0x0d,0x8f,0x0d,0x7d,0x0d,0x6b,0x0d,
+0x59,0x0d,0x47,0x0d,0x35,0x0d,0x22,0x0d,0x10,0x0c,0xfd,0x0c,0xeb,0x0c,0xd8,0x0c,
+0xc5,0x0c,0xb2,0x0c,0x9e,0x0c,0x8b,0x0c,0x77,0x0c,0x64,0x0c,0x50,0x0c,0x3c,0x0c,
+0x28,0x0c,0x14,0x0b,0xff,0x0b,0xeb,0x0b,0xd6,0x0b,0xc1,0x0b,0xac,0x0b,0x96,0x0b,
+0x81,0x0b,0x6b,0x0b,0x55,0x0b,0x3f,0x0b,0x29,0x0b,0x12,0x0a,0xfc,0x0a,0xe5,0x0a,
+0xce,0x0a,0xb6,0x0a,0x9e,0x0a,0x87,0x0a,0x6e,0x0a,0x56,0x0a,0x3d,0x0a,0x24,0x0a,
+0x0b,0x09,0xf1,0x09,0xd8,0x09,0xbd,0x09,0xa3,0x09,0x88,0x09,0x6d,0x09,0x51,0x09,
+0x35,0x09,0x19,0x08,0xfc,0x08,0xdf,0x08,0xc1,0x08,0xa3,0x08,0x84,0x08,0x65,0x08,
+0x45,0x08,0x24,0x08,0x03,0x07,0xe1,0x07,0xbe,0x07,0x9b,0x07,0x78,0x07,0x53,0x07,
+0x2d,0x07,0x07,0x06,0xdf,0x06,0xb7,0x06,0x8d,0x06,0x62,0x06,0x36,0x06,0x07,0x05,
+0xd8,0x05,0xa6,0x05,0x72,0x05,0x3c,0x04,0xfc,0x04,0x7c,0x03,0xfc,0x03,0x7c,0x02,
+0xfc,0x02,0x7c,0x01,0xfc,0x01,0x7c,0x00,0xfc,0x00,0x7c,0x00,0x00
+ };
+
+ sanei_hp_scl_set(scsi, SCL_RESERVED1, 0); /* dont know */
+ sanei_hp_scl_set(scsi, SCL_10952, 0); /* Calibration mode */
+
+ if ( sanei_hp_is_active_xpa (scsi)
+ && ( (scan_mode==HP_SCANMODE_COLOR)
+ || (scan_mode==HP_SCANMODE_GRAYSCALE)) )
+ {
+ DBG (3,"program_scan_type: set tone map for active XPA\n");
+ sanei_hp_scl_download (scsi, SCL_10x9MATRIX_COEFF, xpa_matrix_coeff,
+ sizeof (xpa_matrix_coeff));
+ sanei_hp_scl_set(scsi, SCL_MATRIX, -1); /* Set matrix coefficient */
+
+ sanei_hp_scl_download (scsi, SCL_7x12TONE_MAP, xpa_tone_map,
+ sizeof (xpa_tone_map));
+ sanei_hp_scl_set(scsi, SCL_TONE_MAP, -1); /* Select tone map */
+ }
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+_program_change_doc (HpOption UNUSEDARG this, HpScsi scsi,
+ HpOptSet UNUSEDARG optset, HpData UNUSEDARG data)
+{
+ int istat;
+
+ DBG(2, "program_change_doc: inquire ADF ready\n");
+
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, SCL_ADF_READY, &istat, 0, 0) );
+ if ( istat != 1 ) /* ADF not ready */
+ {
+ DBG(2, "program_change_doc: ADF not ready\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ DBG(2, "program_change_doc: inquire paper in ADF\n");
+
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, SCL_ADF_BIN, &istat, 0, 0) );
+ if ( istat == 0 ) /* Nothing in ADF BIN */
+ {
+ DBG(2, "program_change_doc: nothing in ADF BIN. Just Unload.\n");
+ return sanei_hp_scl_set(scsi, SCL_UNLOAD, 0);
+ }
+
+ DBG(2, "program_change_doc: Clear errors and change document.\n");
+
+ RETURN_IF_FAIL( sanei_hp_scl_clearErrors (scsi) );
+
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_CHANGE_DOC, 0) );
+
+ return sanei_hp_scl_errcheck (scsi);
+}
+
+static SANE_Status
+_program_unload (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ hp_bool_t adfscan = ( sanei_hp_optset_scan_type (optset, data)
+ == SCL_ADF_SCAN );
+
+ /* If we have an ADF, try to see if it is ready to unload */
+ if (adfscan)
+ {int val;
+
+ if ( sanei_hp_scl_inquire(scsi, SCL_ADF_RDY_UNLOAD, &val, 0, 0)
+ == SANE_STATUS_GOOD )
+ {
+ DBG(3, "program_unload: ADF is%sready to unload\n", val ? " " : " not ");
+ }
+ else
+ {
+ DBG(3, "program_unload: Command 'Ready to unload' not supported\n");
+ }
+ }
+ return hp_option_download(this, data, optset, scsi);
+}
+
+static SANE_Status
+_program_calibrate (HpOption UNUSEDARG this, HpScsi scsi,
+ HpOptSet UNUSEDARG optset, HpData UNUSEDARG data)
+{
+ struct passwd *pw;
+ SANE_Status status = SANE_STATUS_GOOD;
+ size_t calib_size;
+ char *calib_buf;
+
+ RETURN_IF_FAIL ( sanei_hp_scl_calibrate(scsi) ); /* Start calibration */
+
+ pw = getpwuid (getuid ()); /* Look if we can find our home directory */
+ if (!pw) return SANE_STATUS_GOOD;
+
+ DBG(3, "_program_calibrate: Read calibration data\n");
+
+ RETURN_IF_FAIL ( sanei_hp_scl_upload_binary (scsi, SCL_CALIB_MAP,
+ &calib_size, &calib_buf) );
+
+ DBG(3, "_program_calibrate: Got %lu bytes of calibration data\n",
+ (unsigned long) calib_size);
+
+ write_calib_file (calib_size, calib_buf, scsi);
+
+ sanei_hp_free (calib_buf);
+
+ return (status);
+}
+
+/* The exposure time of the HP Photosmart can be changed by overwriting
+ * some headers of the calibration data. The scanner uses a slower stepping
+ * speed for higher exposure times */
+static SANE_Status
+_program_ps_exposure_time (HpOption this, HpScsi scsi,
+ HpOptSet UNUSEDARG optset, HpData data)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ size_t calib_size = 0;
+ char *calib_buf = NULL;
+ int i;
+ int option = hp_option_getint(this, data);
+ static char *exposure[] =
+ {"\x00\x64\x00\x64\x00\x64", /* 100% */
+ "\x00\x7d\x00\x7d\x00\x7d", /* 125% */
+ "\x00\x96\x00\x96\x00\x96", /* 150% */
+ "\x00\xaf\x00\xaf\x00\xaf", /* 175% */
+ "\x00\xc0\x00\xc0\x00\xc0", /* 200% */
+ "\x00\xe1\x00\xe1\x00\xe1", /* 225% */
+ "\x00\xfa\x00\xfa\x00\xfa", /* 250% */
+ "\x01\x13\x01\x13\x01\x13", /* 275% */
+ "\x01\x24\x01\x24\x01\x24", /* 300% */
+ "\x00\x64\x00\xc0\x01\x24"}; /* Negatives */
+ /* Negatives get some extra blue to penetrate the orange mask and less
+ red to not saturate the red channel; R:G:B = 100:200:300 */
+
+ /* We dont use the 100% case. It may cause mechanical problems */
+ if ((option < 1) || (option > 9)) return 0;
+ RETURN_IF_FAIL ( sanei_hp_scl_upload_binary (scsi, SCL_CALIB_MAP,
+ &calib_size, &calib_buf) );
+
+ DBG(3, "_program_ps_exposure_time: Got %lu bytes of calibration data\n",
+ (unsigned long) calib_size);
+
+ for (i = 0; i < 6; i++)
+ calib_buf[24 + i] = exposure[option][i];
+
+ status = sanei_hp_scl_download ( scsi, SCL_CALIB_MAP, calib_buf,
+ (size_t)calib_size);
+
+ /* see what the scanner did to our alterations */
+ /*
+ * RETURN_IF_FAIL ( sanei_hp_scl_upload_binary (scsi, SCL_CALIB_MAP,
+ * &calib_size, &calib_buf) );
+ *
+ * for (i = 0; i < 9; i++)
+ * DBG(1, ">%x ", (unsigned char) calib_buf[24 + i]);
+ */
+
+ sanei_hp_free (calib_buf);
+
+ return (status);
+}
+
+static SANE_Status
+_program_scanmode (HpOption this, HpScsi scsi, HpOptSet optset, HpData data)
+{
+ enum hp_scanmode_e new_mode = hp_option_getint(this, data);
+ int invert = 0;
+ int fw_invert = 0; /* Flag: does firmware do inversion ? */
+ int is_model_4c = 0;
+ enum hp_device_compat_e compat;
+ hp_bool_t disable_xpa = ( sanei_hp_optset_scan_type (optset, data)
+ != SCL_XPA_SCAN );
+
+ /* Seems that models 3c/4c/6100C invert image data at 10 bit by themself. */
+ /* So we must not invert it by the invert command. */
+ if ( (sanei_hp_device_probe (&compat,scsi) == SANE_STATUS_GOOD)
+ && (compat & HP_COMPAT_4C) )
+ {
+ is_model_4c = 1;
+ DBG(3, "program_scanmode: model 3c/4c/6100C recognized\n");
+ }
+
+ if (is_model_4c)
+ {
+ const HpDeviceInfo *info;
+ int data_width;
+ HpOption option;
+ int is_preview = 0;
+
+ /* Preview uses maximum 8 bit. So we don't need to check data width */
+ option = hp_optset_getByName (optset, SANE_NAME_PREVIEW);
+ if ( option )
+ is_preview = hp_option_getint (option, data);
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+
+ if ( (!is_preview)
+ && hp_optset_isEnabled (optset, data, SANE_NAME_BIT_DEPTH, info))
+ {
+ data_width = sanei_hp_optset_data_width (optset, data);
+ if ((data_width == 10) || (data_width == 30))
+ {
+ fw_invert = 1;
+ DBG(3, "program_scanmode: firmware is doing inversion\n");
+ }
+ }
+ }
+
+ /* Disabling XPA resets some settings in the scanner. */
+ /* Scanmode is the first we program. So set XPA prior to scanmode */
+ DBG(3, "program_scanmode: disable XPA = %d\n", (int)disable_xpa);
+ sanei_hp_scl_set(scsi, SCL_XPA_DISABLE, disable_xpa);
+
+ RETURN_IF_FAIL( hp_option_download(this, data, optset, scsi) );
+
+ switch (new_mode) {
+ case HP_SCANMODE_GRAYSCALE:
+ /* Make sure that it is not b/w. Correct data width will be set later */
+ RETURN_IF_FAIL( sanei_hp_scl_set(scsi, SCL_DATA_WIDTH, 8) );
+ invert = 1;
+ if (fw_invert) invert = 0;
+ /* For active XPA we use a tone map. Dont invert */
+ if ( (!disable_xpa) && sanei_hp_is_active_xpa (scsi) ) invert = 0;
+ break;
+ case HP_SCANMODE_COLOR:
+ invert = 1;
+ if (fw_invert) invert = 0;
+ /* For active XPA we use a tone map. Dont invert */
+ if ( (!disable_xpa) && sanei_hp_is_active_xpa (scsi) ) invert = 0;
+ break;
+ default:
+ break;
+ }
+
+ return sanei_hp_scl_set(scsi, SCL_INVERSE_IMAGE, invert);
+}
+
+static SANE_Status
+_program_mirror_horiz (HpOption this, HpScsi scsi, HpOptSet UNUSEDARG optset,
+ HpData data)
+{
+ int sec_dir, mirror = hp_option_getint(this, data);
+
+ if ( mirror == HP_MIRROR_HORIZ_CONDITIONAL )
+ {
+ RETURN_IF_FAIL( sanei_hp_scl_inquire(scsi, SCL_SECONDARY_SCANDIR,
+ &sec_dir, 0, 0) );
+ mirror = (sec_dir == 1);
+ }
+
+ return sanei_hp_scl_set(scsi, SCL_MIRROR_IMAGE, mirror);
+}
+
+/*
+ * Option enable predicates
+ */
+static hp_bool_t
+_enable_choice (HpOption this, HpOptSet optset, HpData data,
+ const HpDeviceInfo *info)
+{
+ SANE_String_Const * strlist
+ = sanei_hp_accessor_choice_strlist((HpAccessorChoice) this->data_acsr,
+ optset, data, info);
+
+ _set_stringlist(this, data, strlist);
+
+ assert(strlist[0]);
+ return strlist[0] != 0;
+}
+
+#ifdef ENABLE_7x12_TONEMAPS
+static hp_bool_t
+_enable_rgb_maps (HpOption this, HpOptSet optset, HpData data,
+ const HpDeviceInfo *info)
+{
+ HpOption cgam = hp_optset_get(optset, CUSTOM_GAMMA);
+
+ return (cgam && hp_option_getint(cgam, data)
+ && sanei_hp_optset_scanmode(optset, data) == HP_SCANMODE_COLOR);
+}
+#endif
+
+static hp_bool_t
+_enable_mono_map (HpOption UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{
+ HpOption cgam = hp_optset_get(optset, CUSTOM_GAMMA);
+
+ return (cgam && hp_option_getint(cgam, data)
+ && ( sanei_hp_optset_scanmode(optset, data) != HP_SCANMODE_COLOR
+ || ! hp_optset_getByName(optset, SANE_NAME_GAMMA_VECTOR_R) ));
+}
+
+static hp_bool_t
+_enable_rgb_matrix (HpOption UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{
+ HpOption type = hp_optset_get(optset, MATRIX_TYPE);
+
+ return type && hp_option_getint(type, data) == HP_MATRIX_CUSTOM;
+}
+
+static hp_bool_t
+_enable_brightness (HpOption this, HpOptSet optset, HpData data,
+ const HpDeviceInfo *info)
+{
+ HpOption cgam = hp_optset_get(optset, CUSTOM_GAMMA);
+ HpScl scl = this->descriptor->scl_command;
+ int simulate;
+
+ simulate = ( sanei_hp_device_support_get ( info->devname, scl, 0, 0 )
+ != SANE_STATUS_GOOD );
+ /* If brightness is simulated, we only do it for gray/color */
+ if ( simulate )
+ {HpOption mode = hp_optset_get(optset, SCAN_MODE);
+ int val = hp_option_getint (mode, data);
+ int disable;
+
+ disable = (val != HP_SCANMODE_GRAYSCALE) && (val != HP_SCANMODE_COLOR);
+ if (disable)
+ {
+ if ( cgam ) /* Disable custom gamma. */
+ {
+ val = 0;
+ hp_option_set (cgam, data, &val, 0);
+ }
+ return 0;
+ }
+ }
+
+ return !cgam || !hp_option_getint(cgam, data);
+}
+
+static hp_bool_t
+_enable_autoback (HpOption UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{
+ return sanei_hp_optset_scanmode(optset, data) == HP_SCANMODE_LINEART;
+}
+
+static hp_bool_t
+_enable_custom_gamma (HpOption this, HpOptSet optset, HpData data,
+ const HpDeviceInfo *info)
+{
+ HpScl scl_tonemap = SCL_8x8TONE_MAP;
+ int id = SCL_INQ_ID(scl_tonemap);
+ int simulate, minval, maxval;
+ SANE_Status status;
+
+ /* Check if download type supported */
+ status = sanei_hp_device_support_get ( info->devname,
+ SCL_DOWNLOAD_TYPE, &minval, &maxval);
+
+ simulate = (status != SANE_STATUS_GOOD) || (id < minval) || (id > maxval);
+
+ /* If custom gamma is simulated, we only do it for gray/color */
+ if ( simulate )
+ {HpOption mode = hp_optset_get(optset, SCAN_MODE);
+ int val;
+
+ if ( mode )
+ {
+ val = hp_option_getint (mode, data);
+ if ((val != HP_SCANMODE_GRAYSCALE) && (val != HP_SCANMODE_COLOR))
+ {
+ val = 0;
+ hp_option_set (this, data, &val, 0);
+ return 0;
+ }
+ }
+ }
+
+ return 1;
+}
+
+static hp_bool_t
+_enable_halftone (HpOption UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{
+ return sanei_hp_optset_scanmode(optset, data) == HP_SCANMODE_HALFTONE;
+}
+
+static hp_bool_t
+_enable_halftonevec (HpOption UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{
+ if (sanei_hp_optset_scanmode(optset, data) == HP_SCANMODE_HALFTONE)
+ {
+ HpOption dither = hp_optset_get(optset, HALFTONE_PATTERN);
+
+ return dither && hp_option_getint(dither, data) == HP_DITHER_CUSTOM;
+ }
+ return 0;
+}
+
+static hp_bool_t
+_enable_data_width (HpOption UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{enum hp_scanmode_e mode;
+
+ mode = sanei_hp_optset_scanmode (optset, data);
+ return ( (mode == HP_SCANMODE_GRAYSCALE) || (mode == HP_SCANMODE_COLOR) );
+}
+
+static hp_bool_t
+_enable_out8 (HpOption UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo *info)
+{
+ if (hp_optset_isEnabled (optset, data, SANE_NAME_BIT_DEPTH, info))
+ {
+ int data_width = sanei_hp_optset_data_width (optset, data);
+ return (((data_width > 8) && (data_width <= 16)) || (data_width > 24));
+ }
+ return 0;
+}
+
+static hp_bool_t
+_enable_calibrate (HpOption UNUSEDARG this, HpOptSet optset, HpData data,
+ const HpDeviceInfo UNUSEDARG *info)
+{
+ HpOption media = hp_optset_get(optset, MEDIA);
+
+ /* If we dont have the media button, we should have calibrate */
+ if ( !media ) return 1;
+
+ return hp_option_getint(media, data) == HP_MEDIA_PRINT;
+}
+
+static SANE_Status
+hp_download_calib_file (HpScsi scsi)
+{
+ int nbytes;
+ char *calib_data;
+ SANE_Status status;
+
+ RETURN_IF_FAIL ( read_calib_file ( &nbytes, &calib_data, scsi ) );
+
+ DBG(3, "hp_download_calib_file: Got %d bytes calibration data\n", nbytes);
+
+ status = sanei_hp_scl_download ( scsi, SCL_CALIB_MAP, calib_data,
+ (size_t) nbytes);
+ sanei_hp_free ( calib_data );
+
+ DBG(3, "hp_download_calib_file: download %s\n", (status == SANE_STATUS_GOOD) ?
+ "successful" : "failed");
+
+ return status;
+}
+
+
+/*
+ * The actual option descriptors.
+ */
+
+#if (defined(__IBMC__) || defined(__IBMCPP__))
+#ifndef _AIX
+ #define INT INT
+#endif
+#endif
+
+#define SCANNER_OPTION(name,type,unit) \
+ PASTE(SANE_NAME_,name), \
+ PASTE(SANE_TITLE_,name), \
+ PASTE(SANE_DESC_,name), \
+ PASTE(SANE_TYPE_,type), \
+ PASTE(SANE_UNIT_,unit), \
+ SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT
+
+#define CONSTANT_OPTION(name,type,unit) \
+ PASTE(SANE_NAME_,name), \
+ PASTE(SANE_TITLE_,name), \
+ PASTE(SANE_DESC_,name), \
+ PASTE(SANE_TYPE_,type), \
+ PASTE(SANE_UNIT_,unit), \
+ SANE_CAP_SOFT_DETECT
+
+#define INTERNAL_OPTION(name,type,unit) \
+ PASTE(HP_NAME_,name), "", "", \
+ PASTE(SANE_TYPE_,type), \
+ PASTE(SANE_UNIT_,unit), \
+ SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT
+
+#define OPTION_GROUP(name) "", name, "", SANE_TYPE_GROUP, SANE_UNIT_NONE, 0
+
+#define ADVANCED_GROUP(name) \
+ "", name, "", SANE_TYPE_GROUP, SANE_UNIT_NONE, SANE_CAP_ADVANCED
+
+
+#define REQUIRES(req) req
+#define NO_REQUIRES REQUIRES(0)
+
+static const struct hp_option_descriptor_s NUM_OPTIONS[1] = {{
+ CONSTANT_OPTION(NUM_OPTIONS, INT, NONE),
+ NO_REQUIRES,
+ _probe_num_options,
+ 0,0,0,0,0,0,0,0,0,0,0,0 /* for gcc-s sake */
+}};
+
+static const struct hp_option_descriptor_s SCAN_MODE_GROUP[1] = {{
+ OPTION_GROUP(SANE_I18N("Scan Mode")),
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* for gcc-s sake */
+}};
+
+/* Preview stuff */
+static const struct hp_option_descriptor_s PREVIEW_MODE[1] = {{
+ SCANNER_OPTION(PREVIEW, BOOL, NONE),
+ NO_REQUIRES,
+ _probe_bool,
+ 0,0,0,0,0,0,0,0,0,0,0,0 /* for gcc-s sake */
+}};
+
+static const struct hp_choice_s _scanmode_choices[] = {
+ { HP_SCANMODE_LINEART, SANE_VALUE_SCAN_MODE_LINEART, 0, 0, 0 },
+ { HP_SCANMODE_HALFTONE, SANE_VALUE_SCAN_MODE_HALFTONE, 0, 0, 0 },
+ { HP_SCANMODE_GRAYSCALE, SANE_VALUE_SCAN_MODE_GRAY, 0, 0, 0 },
+ { HP_SCANMODE_COLOR, SANE_VALUE_SCAN_MODE_COLOR, 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+static const struct hp_option_descriptor_s SCAN_MODE[1] = {{
+ SCANNER_OPTION(SCAN_MODE, STRING, NONE),
+ NO_REQUIRES,
+ _probe_each_choice, _program_scanmode, 0,
+ 1, 1, 1, 0, 0, SCL_OUTPUT_DATA_TYPE, 0, 0, 0, _scanmode_choices
+}};
+static const struct hp_option_descriptor_s SCAN_RESOLUTION[1] = {{
+ SCANNER_OPTION(SCAN_RESOLUTION, INT, DPI),
+ NO_REQUIRES,
+ _probe_resolution, _program_resolution, 0,
+ 0, 1, 0, 0, 1, SCL_X_RESOLUTION, 0, 0, 0, 0
+}};
+static const struct hp_option_descriptor_s DEVPIX_RESOLUTION[1] = {{
+ INTERNAL_OPTION(DEVPIX_RESOLUTION, INT, DPI),
+ NO_REQUIRES,
+ _probe_devpix, 0, 0,
+ 0, 0, 0, 0, 1, SCL_DEVPIX_RESOLUTION, 0, 0, 0, 0
+}};
+
+static const struct hp_option_descriptor_s ENHANCEMENT_GROUP[1] = {{
+ OPTION_GROUP(SANE_I18N("Enhancement")),
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* for gcc-s sake */
+}};
+static const struct hp_option_descriptor_s BRIGHTNESS[1] = {{
+ SCANNER_OPTION(BRIGHTNESS, INT, NONE),
+ NO_REQUIRES,
+ _probe_int_brightness, _program_generic_simulate, _enable_brightness,
+ 0, 0, 0, 0, 0, SCL_BRIGHTNESS, -127, 127, 0, 0
+}};
+static const struct hp_option_descriptor_s CONTRAST[1] = {{
+ SCANNER_OPTION(CONTRAST, INT, NONE),
+ NO_REQUIRES,
+ _probe_int_brightness, _program_generic_simulate, _enable_brightness,
+ 0, 0, 0, 0, 0, SCL_CONTRAST, -127, 127, 0, 0
+}};
+#ifdef SCL_SHARPENING
+static const struct hp_option_descriptor_s SHARPENING[1] = {{
+ SCANNER_OPTION(SHARPENING, INT, NONE),
+ NO_REQUIRES,
+ _probe_int, _program_generic, 0,
+ 0, 0, 0, 0, 0, SCL_SHARPENING, -127, 127, 0, 0
+}};
+#endif
+static const struct hp_option_descriptor_s AUTO_THRESHOLD[1] = {{
+ SCANNER_OPTION(AUTO_THRESHOLD, BOOL, NONE),
+ NO_REQUIRES,
+ _probe_bool, _program_generic, _enable_autoback,
+ 0, 0, 0, 0, 0, SCL_AUTO_BKGRND, 0, 0, 0, 0
+}};
+
+static const struct hp_option_descriptor_s ADVANCED_GROUP[1] = {{
+ ADVANCED_GROUP(SANE_I18N("Advanced Options")),
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* for gcc-s sake */
+}};
+/* FIXME: make this a choice? (BW or RGB custom) */
+static const struct hp_option_descriptor_s CUSTOM_GAMMA[1] = {{
+ SCANNER_OPTION(CUSTOM_GAMMA, BOOL, NONE),
+ NO_REQUIRES,
+ _probe_custom_gamma, _program_tonemap, _enable_custom_gamma,
+ 1, 0, 0, 0, 0, SCL_TONE_MAP, 0, 0, 0, 0
+}};
+static const struct hp_option_descriptor_s GAMMA_VECTOR_8x8[1] = {{
+ SCANNER_OPTION(GAMMA_VECTOR, FIXED, NONE),
+ NO_REQUIRES,
+ _probe_gamma_vector, 0, _enable_mono_map,
+ 0, 0, 0, 0, 0, SCL_8x8TONE_MAP, 0, 0, 0, 0
+}};
+
+#ifdef ENABLE_7x12_TONEMAPS
+static const struct hp_option_descriptor_s GAMMA_VECTOR_7x12[1] = {{
+ SCANNER_OPTION(GAMMA_VECTOR, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_5100C | HP_COMPAT_PS | HP_COMPAT_6200C
+ |HP_COMPAT_5200C|HP_COMPAT_6300C),
+ _probe_gamma_vector, 0, _enable_mono_map,
+ 0, 0, 0, 0, 0, SCL_BW7x12TONE_MAP, 0, 0, 0, 0
+}};
+
+static const struct hp_option_descriptor_s RGB_TONEMAP[1] = {{
+ INTERNAL_OPTION(RGB_TONEMAP, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_5100C | HP_COMPAT_PS | HP_COMPAT_6200C
+ |HP_COMPAT_5200C|HP_COMPAT_6300C),
+ _probe_gamma_vector, 0, 0,
+ 0, 0, 0, 0, 0, SCL_7x12TONE_MAP, 0, 0, 0, 0
+}};
+static const struct hp_option_descriptor_s GAMMA_VECTOR_R[1] = {{
+ SCANNER_OPTION(GAMMA_VECTOR_R, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_5100C | HP_COMPAT_PS | HP_COMPAT_6200C
+ |HP_COMPAT_5200C|HP_COMPAT_6300C),
+ _probe_gamma_vector, 0, _enable_rgb_maps,
+ 0,0,0,0,0,0,0,0,0,0
+}};
+static const struct hp_option_descriptor_s GAMMA_VECTOR_G[1] = {{
+ SCANNER_OPTION(GAMMA_VECTOR_G, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_5100C | HP_COMPAT_PS | HP_COMPAT_6200C
+ |HP_COMPAT_5200C|HP_COMPAT_6300C),
+ _probe_gamma_vector, 0, _enable_rgb_maps,
+ 0,0,0,0,0,0,0,0,0,0
+}};
+static const struct hp_option_descriptor_s GAMMA_VECTOR_B[1] = {{
+ SCANNER_OPTION(GAMMA_VECTOR_B, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_5100C | HP_COMPAT_PS | HP_COMPAT_6200C
+ |HP_COMPAT_5200C|HP_COMPAT_6300C),
+ _probe_gamma_vector, 0, _enable_rgb_maps,
+ 0,0,0,0,0,0,0,0,0,0
+}};
+#endif
+
+static const struct hp_choice_s _halftone_choices[] = {
+ { HP_DITHER_COARSE, SANE_I18N("Coarse"), 0, 0, 0 },
+ { HP_DITHER_FINE, SANE_I18N("Fine"), 0, 0, 0 },
+ { HP_DITHER_BAYER, SANE_I18N("Bayer"), 0, 0, 0 },
+ { HP_DITHER_VERTICAL, SANE_I18N("Vertical"), 0, 0, 0 },
+ { HP_DITHER_HORIZONTAL, SANE_I18N("Horizontal"), 0, 1, 0 },
+ { HP_DITHER_CUSTOM, SANE_I18N("Custom"), 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+static const struct hp_option_descriptor_s HALFTONE_PATTERN[1] = {{
+ SCANNER_OPTION(HALFTONE_PATTERN, STRING, NONE),
+ NO_REQUIRES,
+ _probe_each_choice, _program_dither, _enable_halftone,
+ 1, 0, 0, 0, 0, SCL_BW_DITHER, 0, 0, 0, _halftone_choices
+}};
+/* FIXME: Halftone dimension? */
+
+#ifdef ENABLE_16X16_DITHERS
+static const struct hp_option_descriptor_s HALFTONE_PATTERN_16x16[1] = {{
+ SCANNER_OPTION(HALFTONE_PATTERN, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_4P | HP_COMPAT_4C | HP_COMPAT_5100C
+ | HP_COMPAT_6200C | HP_COMPAT_5200C | HP_COMPAT_6300C),
+ _probe_horiz_dither, 0, _enable_halftonevec,
+ 0, 0, 0, 0, 0, SCL_BW16x16DITHER
+}};
+static const struct hp_option_descriptor_s HORIZONTAL_DITHER_16x16[1] = {{
+ INTERNAL_OPTION(HORIZONTAL_DITHER, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_4P | HP_COMPAT_4C | HP_COMPAT_5100C
+ | HP_COMPAT_6200C | HP_COMPAT_5200C | HP_COMPAT_6300C),
+ _probe_horiz_dither, 0, 0,
+ 0, 0, 0, 0, 0, SCL_BW16x16DITHER
+}};
+#endif
+static const struct hp_option_descriptor_s HALFTONE_PATTERN_8x8[1] = {{
+ SCANNER_OPTION(HALFTONE_PATTERN, FIXED, NONE),
+ NO_REQUIRES,
+ _probe_horiz_dither, 0, _enable_halftonevec,
+ 0, 0, 0, 0, 0, SCL_BW8x8DITHER, 0, 0, 0, 0
+}};
+static const struct hp_option_descriptor_s HORIZONTAL_DITHER_8x8[1] = {{
+ INTERNAL_OPTION(HORIZONTAL_DITHER, FIXED, NONE),
+ NO_REQUIRES,
+ _probe_horiz_dither, 0, 0,
+ 0, 0, 0, 0, 0, SCL_BW8x8DITHER, 0, 0, 0, 0
+}};
+
+static const struct hp_choice_s _matrix_choices[] = {
+ { HP_MATRIX_AUTO, SANE_I18N("Auto"), 0, 1, 0 },
+ { HP_MATRIX_RGB, SANE_I18N("NTSC RGB"), _cenable_incolor, 0, 0 },
+ { HP_MATRIX_XPA_RGB, SANE_I18N("XPA RGB"), _cenable_incolor, 0, 0 },
+ { HP_MATRIX_PASS, SANE_I18N("Pass-through"), _cenable_incolor, 0, 0 },
+ { HP_MATRIX_BW, SANE_I18N("NTSC Gray"), _cenable_notcolor, 0, 0 },
+ { HP_MATRIX_XPA_BW, SANE_I18N("XPA Gray"), _cenable_notcolor, 0, 0 },
+ { HP_MATRIX_RED, SANE_I18N("Red"), _cenable_notcolor, 0, 0 },
+ { HP_MATRIX_GREEN, SANE_I18N("Green"), _cenable_notcolor, 1, 0 },
+ { HP_MATRIX_BLUE, SANE_I18N("Blue"), _cenable_notcolor, 0, 0 },
+#ifdef ENABLE_CUSTOM_MATRIX
+ { HP_MATRIX_CUSTOM, SANE_I18N("Custom"), 0, 0, 0 },
+#endif
+ { 0, 0, 0, 0, 0 }
+};
+
+static const struct hp_option_descriptor_s MATRIX_TYPE[1] = {{
+ SCANNER_OPTION(MATRIX_TYPE, STRING, NONE),
+ NO_REQUIRES,
+ _probe_each_choice, _program_matrix, _enable_choice,
+ 1, 0, 0, 0, 0, SCL_MATRIX, 0, 0, 0, _matrix_choices
+}};
+
+static const struct hp_option_descriptor_s MATRIX_RGB[1] = {{
+ SCANNER_OPTION(MATRIX_RGB, FIXED, NONE),
+ NO_REQUIRES,
+ _probe_matrix, 0, _enable_rgb_matrix,
+ 0, 0, 0, 0, 0, SCL_8x9MATRIX_COEFF, 0, 0, 0, 0
+}};
+#ifdef FAKE_COLORSEP_MATRIXES
+static const struct hp_option_descriptor_s SEPMATRIX[1] = {{
+ INTERNAL_OPTION(SEPMATRIX, FIXED, NONE),
+ NO_REQUIRES,
+ _probe_vector, 0, 0,
+ 0, 0, 0, 0, 0, SCL_8x9MATRIX_COEFF, 0, 0, 0, 0
+}};
+#endif
+#ifdef ENABLE_10BIT_MATRIXES
+static const struct hp_option_descriptor_s MATRIX_RGB10[1] = {{
+ SCANNER_OPTION(MATRIX_RGB, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_5100C | HP_COMPAT_6200C
+ | HP_COMPAT_5200C | HP_COMPAT_6300C),
+ _probe_matrix, 0, _enable_rgb_matrix,
+ 0, 0, 0, 0, 0, SCL_10x9MATRIX_COEFF, 0, 0, 0, 0
+}};
+#endif
+#ifdef NotYetSupported
+static const struct hp_option_descriptor_s BWMATRIX_GRAY10[1] = {{
+ SCANNER_OPTION(MATRIX_GRAY, FIXED, NONE),
+ REQUIRES(HP_COMPAT_5P | HP_COMPAT_5100C | HP_COMPAT_6200C
+ | HP_COMPAT_5200C | HP_COMPAT_6300C),
+ _probe_matrix, 0, _enable_gray_matrix,
+ 0, 0, 0, 0, 0, SCL_10x3MATRIX_COEFF, 0, 0, 0, 0
+}};
+#endif
+
+static const struct hp_choice_s _scan_speed_choices[] = {
+ { 0, SANE_I18N("Auto"), 0, 0, 0 },
+ { 1, SANE_I18N("Slow"), 0, 0, 0 },
+ { 2, SANE_I18N("Normal"), 0, 0, 0 },
+ { 3, SANE_I18N("Fast"), 0, 0, 0 },
+ { 4, SANE_I18N("Extra Fast"), 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+static const struct hp_option_descriptor_s SCAN_SPEED[1] = {{
+ SCANNER_OPTION(SCAN_SPEED, STRING, NONE),
+ NO_REQUIRES,
+ _probe_each_choice, _program_generic, 0,
+ 0, 0, 0, 0, 1, SCL_SPEED, 0, 0, 0, _scan_speed_choices
+}};
+
+static const struct hp_choice_s _smoothing_choices[] = {
+ { 0, SANE_I18N("Auto"), 0, 0, 0 },
+ { 3, SANE_I18N("Off"), 0, 0, 0 },
+ { 1, SANE_I18N("2-pixel"), 0, 0, 0 },
+ { 2, SANE_I18N("4-pixel"), 0, 0, 0 },
+ { 4, SANE_I18N("8-pixel"), 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+static const struct hp_option_descriptor_s SMOOTHING[1] = {{
+ SCANNER_OPTION(SMOOTHING, STRING, NONE),
+ NO_REQUIRES,
+ _probe_each_choice, _program_generic, 0,
+ 0, 0, 0, 0, 0, SCL_FILTER, 0, 0, 0, _smoothing_choices
+}};
+
+static const struct hp_choice_s _media_choices[] = {
+ { HP_MEDIA_PRINT, SANE_I18N("Print"), 0, 0, 0 },
+ { HP_MEDIA_SLIDE, SANE_I18N("Slide"), 0, 0, 0 },
+ { HP_MEDIA_NEGATIVE, SANE_I18N("Film-strip"), 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+static const struct hp_option_descriptor_s MEDIA[1] = {{
+ SCANNER_OPTION(MEDIA, STRING, NONE),
+ NO_REQUIRES,
+ _probe_choice, _program_media, 0,
+ 1, 1, 1, 1, 0, SCL_MEDIA, 0, 0, 0, _media_choices
+}};
+
+static const struct hp_choice_s _data_widths[] = {
+ {1, "1", 0, 0, 0},
+ {8, "8", 0, 0, 0},
+ {10, "10", 0, 0, 0},
+ {12, "12", 0, 0, 0},
+ {14, "14", 0, 0, 0},
+ {16, "16", 0, 0, 0},
+ {0, 0, 0, 0, 0}
+};
+
+static const struct hp_option_descriptor_s BIT_DEPTH[1] = {{
+ SCANNER_OPTION(BIT_DEPTH, STRING, NONE),
+ NO_REQUIRES,
+ _probe_choice, _program_data_width, _enable_data_width,
+ 1, 1, 1, 0, 1, SCL_DATA_WIDTH, 0, 0, 0, _data_widths
+}};
+
+static const struct hp_option_descriptor_s OUT8[1] =
+{
+ {
+ SCANNER_OPTION(OUTPUT_8BIT, BOOL, NONE),
+ NO_REQUIRES, /* enum hp_device_compat_e requires */
+ _probe_bool, /* SANE_Status (*probe)() */
+ 0, /* SANE_Status (*program)() */
+ _enable_out8, /* hp_bool_t (*enable)() */
+ 0, /* hp_bool_t has_global_effect */
+ 0, /* hp_bool_t affects_scan_params */
+ 0, /* hp_bool_t program_immediate */
+ 0, /* hp_bool_t suppress_for_scan */
+ 0, /* hp_bool_t may_change */
+ 0, /* HpScl scl_command */
+ 0, /* int minval */
+ 0, /* int maxval */
+ 0, /* int startval */
+ 0 /* HpChoice choices */
+ }
+};
+
+/* The 100% setting may cause problems within the scanner */
+static const struct hp_choice_s _ps_exposure_times[] = {
+ /* {0, "100%", 0, 0, 0}, */
+ { 0, SANE_I18N("Default"), 0, 0, 0 },
+ {1, "125%", 0, 0, 0},
+ {2, "150%", 0, 0, 0},
+ {3, "175%", 0, 0, 0},
+ {4, "200%", 0, 0, 0},
+ {5, "225%", 0, 0, 0},
+ {6, "250%", 0, 0, 0},
+ {7, "275%", 0, 0, 0},
+ {8, "300%", 0, 0, 0},
+ {9, SANE_I18N("Negative"), 0, 0, 0},
+ {0, 0, 0, 0, 0}
+};
+
+/* Photosmart exposure time */
+static const struct hp_option_descriptor_s PS_EXPOSURE_TIME[1] = {{
+ SCANNER_OPTION(PS_EXPOSURE_TIME, STRING, NONE),
+ REQUIRES( HP_COMPAT_PS ),
+ _probe_ps_exposure_time, _program_ps_exposure_time, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, _ps_exposure_times
+}};
+
+/* Normal, ADF or XPA scanning. Because scanning from ADF can change */
+/* the extent of the scanning area, this option is marked to change */
+/* global settings. The user should switch to ADF scanning after */
+/* placing paper in the ADF. */
+static const struct hp_choice_s _scan_types[] = {
+ { HP_SCANTYPE_NORMAL, SANE_I18N("Normal"), 0, 0, 0 },
+ { HP_SCANTYPE_ADF, SANE_I18N("ADF"), 0, 0, 0 },
+ { HP_SCANTYPE_XPA, SANE_I18N("XPA"), 0, 0, 0 },
+ {0, 0, 0, 0, 0 }
+};
+
+static const struct hp_option_descriptor_s SCAN_SOURCE[1] = {{
+ SCANNER_OPTION(SCAN_SOURCE, STRING, NONE),
+ NO_REQUIRES,
+ _probe_scan_type, _program_scan_type, 0,
+ 1, 1, 1, 0, 0, SCL_START_SCAN, 0, 0, 0, _scan_types
+}};
+
+/* Unload after is only necessary for PhotoScanner */
+static const struct hp_option_descriptor_s UNLOAD_AFTER_SCAN[1] = {{
+ SCANNER_OPTION(UNLOAD_AFTER_SCAN, BOOL, NONE),
+ REQUIRES(HP_COMPAT_PS),
+ _probe_bool, _program_unload_after_scan, 0,
+ 0, 0, 0, 1, 0, SCL_UNLOAD, 0, 0, 0, 0
+}};
+
+static const struct hp_option_descriptor_s CHANGE_DOC[1] = {{
+ SCANNER_OPTION(CHANGE_DOC, BUTTON, NONE),
+ NO_REQUIRES,
+ _probe_change_doc, _program_change_doc, 0,
+ 1, 1, 1, 1, 0, SCL_CHANGE_DOC, 0, 0, 0, 0
+}};
+
+static const struct hp_option_descriptor_s UNLOAD[1] = {{
+ SCANNER_OPTION(UNLOAD, BUTTON, NONE),
+ NO_REQUIRES,
+ _probe_unload, _program_unload, 0,
+ 0, 0, 1, 1, 0, SCL_UNLOAD, 0, 0, 0, 0
+}};
+
+/* There is no inquire ID-for the calibrate command. */
+/* So here we need the requiries. */
+static const struct hp_option_descriptor_s CALIBRATE[1] = {{
+ SCANNER_OPTION(CALIBRATE, BUTTON, NONE),
+ REQUIRES(HP_COMPAT_PS),
+ _probe_calibrate, _program_calibrate, _enable_calibrate,
+ 0, 0, 1, 1, 0, SCL_CALIBRATE, 0, 0, 0, 0
+}};
+
+static const struct hp_option_descriptor_s GEOMETRY_GROUP[1] = {{
+ ADVANCED_GROUP(SANE_I18N("Geometry")),
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* for gcc-s sake */
+}};
+static const struct hp_option_descriptor_s SCAN_TL_X[1] = {{
+ SCANNER_OPTION(SCAN_TL_X, FIXED, MM),
+ NO_REQUIRES,
+ _probe_geometry, _program_geometry, 0,
+ 0, 1, 0, 0, 1, SCL_X_POS, 0, 0, 0, 0
+}};
+static const struct hp_option_descriptor_s SCAN_TL_Y[1] = {{
+ SCANNER_OPTION(SCAN_TL_Y, FIXED, MM),
+ NO_REQUIRES,
+ _probe_geometry, _program_geometry, 0,
+ 0, 1, 0, 0, 1, SCL_Y_POS, 0, 0, 0, 0
+}};
+static const struct hp_option_descriptor_s SCAN_BR_X[1] = {{
+ SCANNER_OPTION(SCAN_BR_X, FIXED, MM),
+ NO_REQUIRES,
+ _probe_geometry, _program_geometry, 0,
+ 0, 1, 0, 0, 1, SCL_X_EXTENT, 0, 0, 0, 0
+}};
+static const struct hp_option_descriptor_s SCAN_BR_Y[1] = {{
+ SCANNER_OPTION(SCAN_BR_Y, FIXED, MM),
+ NO_REQUIRES,
+ _probe_geometry, _program_geometry, 0,
+ 0, 1, 0, 0, 1, SCL_Y_EXTENT, 0, 0, 0, 0
+}};
+
+static const struct hp_choice_s _mirror_horiz_choices[] = {
+ { HP_MIRROR_HORIZ_OFF, SANE_I18N("Off"), 0, 0, 0 },
+ { HP_MIRROR_HORIZ_ON, SANE_I18N("On"), 0, 0, 0 },
+ { HP_MIRROR_HORIZ_CONDITIONAL, SANE_I18N("Conditional"), 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+static const struct hp_option_descriptor_s MIRROR_HORIZ[1] = {{
+ SCANNER_OPTION(MIRROR_HORIZ, STRING, NONE),
+ NO_REQUIRES,
+ _probe_mirror_horiz, _program_mirror_horiz, 0,
+ 0, 0, 0, 0, 0, SCL_MIRROR_IMAGE, 0, 0, 0, _mirror_horiz_choices
+}};
+
+static const struct hp_choice_s _mirror_vert_choices[] = {
+ { HP_MIRROR_VERT_OFF, SANE_I18N("Off"), 0, 0, 0 },
+ { HP_MIRROR_VERT_ON, SANE_I18N("On"), 0, 0, 0 },
+ { HP_MIRROR_VERT_CONDITIONAL, SANE_I18N("Conditional"), 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+static const struct hp_option_descriptor_s MIRROR_VERT[1] = {{
+ SCANNER_OPTION(MIRROR_VERT, STRING, NONE),
+ NO_REQUIRES,
+ _probe_mirror_vert, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, _mirror_vert_choices
+}};
+
+static const struct hp_option_descriptor_s BUTTON_WAIT[1] =
+{
+ {
+ SCANNER_OPTION(BUTTON_WAIT, BOOL, NONE),
+ NO_REQUIRES, /* enum hp_device_compat_e requires */
+ _probe_front_button, /* SANE_Status (*probe)() */
+ 0, /* SANE_Status (*program)() */
+ 0, /* hp_bool_t (*enable)() */
+ 0, /* hp_bool_t has_global_effect */
+ 0, /* hp_bool_t affects_scan_params */
+ 0, /* hp_bool_t program_immediate */
+ 0, /* hp_bool_t suppress_for_scan */
+ 0, /* hp_bool_t may_change */
+ 0, /* HpScl scl_command */
+ 0, /* int minval */
+ 0, /* int maxval */
+ 0, /* int startval */
+ 0 /* HpChoice choices */
+ }
+};
+
+
+static const struct hp_option_descriptor_s LAMP_OFF[1] =
+{
+ {
+ SCANNER_OPTION(LAMP_OFF, BUTTON, NONE),
+ /* Lamp off instruction not supported by Photosmart */
+ REQUIRES( HP_COMPAT_PLUS | HP_COMPAT_2C | HP_COMPAT_2P | HP_COMPAT_2CX
+ | HP_COMPAT_4C | HP_COMPAT_3P | HP_COMPAT_4P | HP_COMPAT_5P
+ | HP_COMPAT_5100C | HP_COMPAT_6200C | HP_COMPAT_5200C
+ | HP_COMPAT_6300C), /* enum hp_device_compat_e requires */
+ _probe_bool, /* SANE_Status (*probe)() */
+ _program_lamp_off, /* SANE_Status (*program)() */
+ 0, /* hp_bool_t (*enable)() */
+ 0, /* hp_bool_t has_global_effect */
+ 0, /* hp_bool_t affects_scan_params */
+ 1, /* hp_bool_t program_immediate */
+ 1, /* hp_bool_t suppress_for_scan */
+ 0, /* hp_bool_t may_change */
+ SCL_LAMPTEST, /* HpScl scl_command */
+ 0, /* int minval */
+ 0, /* int maxval */
+ 0, /* int startval */
+ 0 /* HpChoice choices */
+ }
+};
+
+#ifdef HP_EXPERIMENTAL
+
+static const struct hp_choice_s _range_choices[] = {
+ { 0, "0", 0, 0, 0 },
+ { 1, "1", 0, 0, 0 },
+ { 2, "2", 0, 0, 0 },
+ { 3, "3", 0, 0, 0 },
+ { 4, "4", 0, 0, 0 },
+ { 5, "5", 0, 0, 0 },
+ { 6, "6", 0, 0, 0 },
+ { 7, "7", 0, 0, 0 },
+ { 8, "8", 0, 0, 0 },
+ { 9, "9", 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+static const struct hp_option_descriptor_s EXPERIMENT_GROUP[1] = {{
+ ADVANCED_GROUP(SANE_I18N("Experiment"))
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* for gcc-s sake */
+}};
+static const struct hp_option_descriptor_s PROBE_10470[1] = {{
+ SCANNER_OPTION(10470, STRING, NONE),
+ NO_REQUIRES,
+ _probe_each_choice, _program_generic, 0,
+ 0, 0, 0, 0, 0, SCL_10470, 0, 0, 0, _range_choices
+}};
+static const struct hp_option_descriptor_s PROBE_10485[1] = {{
+ SCANNER_OPTION(10485, STRING, NONE),
+ NO_REQUIRES,
+ _probe_each_choice, _program_generic, 0,
+ 0, 0, 0, 0, 0, SCL_10485, 0, 0, 0, _range_choices
+}};
+static const struct hp_option_descriptor_s PROBE_10952[1] = {{
+ SCANNER_OPTION(10952, STRING, NONE),
+ NO_REQUIRES,
+ _probe_each_choice, _program_generic, 0,
+ 0, 0, 0, 0, 0, SCL_10952, 0, 0, 0, _range_choices
+}};
+static const struct hp_option_descriptor_s PROBE_10967[1] = {{
+ SCANNER_OPTION(10967, INT, NONE),
+ NO_REQUIRES,
+ _probe_int, _program_generic, 0,
+ 0, 0, 0, 0, 0, SCL_10967, 0, 0, 0, 0
+}};
+
+#endif
+
+static HpOptionDescriptor hp_options[] = {
+ NUM_OPTIONS,
+
+ SCAN_MODE_GROUP,
+ PREVIEW_MODE,
+ SCAN_MODE, SCAN_RESOLUTION, DEVPIX_RESOLUTION,
+
+ ENHANCEMENT_GROUP,
+ BRIGHTNESS, CONTRAST,
+#ifdef SCL_SHARPENING
+ SHARPENING,
+#endif
+ AUTO_THRESHOLD,
+
+ ADVANCED_GROUP,
+ CUSTOM_GAMMA,
+#ifdef ENABLE_7x12_TONEMAPS
+ GAMMA_VECTOR_7x12,
+ RGB_TONEMAP, GAMMA_VECTOR_R, GAMMA_VECTOR_G, GAMMA_VECTOR_B,
+#endif
+ GAMMA_VECTOR_8x8,
+
+ MATRIX_TYPE,
+#ifdef FAKE_COLORSEP_MATRIXES
+ SEPMATRIX,
+#endif
+#ifdef ENABLE_10BIT_MATRIXES
+ MATRIX_RGB10, /* FIXME: unsupported: MATRIX_GRAY10, */
+#endif
+ MATRIX_RGB,
+
+ HALFTONE_PATTERN,
+#ifdef ENABLE_16X16_DITHERS
+ HALFTONE_PATTERN_16x16, HORIZONTAL_DITHER_16x16,
+#endif
+ HALFTONE_PATTERN_8x8, HORIZONTAL_DITHER_8x8,
+
+ SCAN_SPEED, SMOOTHING, MEDIA, PS_EXPOSURE_TIME, BIT_DEPTH, OUT8,
+ SCAN_SOURCE, BUTTON_WAIT, LAMP_OFF, UNLOAD_AFTER_SCAN,
+ CHANGE_DOC, UNLOAD, CALIBRATE,
+
+ GEOMETRY_GROUP,
+ SCAN_TL_X, SCAN_TL_Y, SCAN_BR_X, SCAN_BR_Y,
+ MIRROR_HORIZ, MIRROR_VERT,
+
+#ifdef HP_EXPERIMENTAL
+
+ EXPERIMENT_GROUP,
+ PROBE_10470,
+ PROBE_10485,
+ PROBE_10952,
+ PROBE_10967,
+
+#endif
+
+ 0
+};
+
+
+
+/*
+ * class HpOptSet
+ */
+
+struct hp_optset_s
+{
+#define OPTION_LIST_MAX sizeof(hp_options)/sizeof(hp_options[0])
+ HpOption options[OPTION_LIST_MAX];
+ size_t num_sane_opts;
+ size_t num_opts;
+
+ /* Magic accessors to get coord in actual scan pixels: */
+ HpAccessor tl_x, tl_y, br_x, br_y;
+};
+
+static HpOption
+hp_optset_get (HpOptSet this, HpOptionDescriptor optd)
+{
+ HpOption * optp = this->options;
+ int i = this->num_opts;
+
+ while (i--)
+ {
+ if ((*optp)->descriptor == optd)
+ return *optp;
+ optp++;
+ }
+ return 0;
+}
+
+static HpOption
+hp_optset_getByIndex (HpOptSet this, int optnum)
+{
+ if ((optnum < 0) || (optnum >= (int)this->num_sane_opts))
+ return 0;
+ return this->options[optnum];
+}
+
+static HpOption
+hp_optset_getByName (HpOptSet this, const char * name)
+{
+ HpOption * optp = this->options;
+ int i = this->num_opts;
+
+ while (i--)
+ {
+ if (strcmp((*optp)->descriptor->name, name) == 0)
+ return *optp;
+ optp++;
+ }
+ return 0;
+}
+
+static _HpOption
+_hp_optset_get (HpOptSet this, HpOptionDescriptor opt)
+{
+ /* Cast away const-ness */
+ return (_HpOption) hp_optset_get(this, opt);
+}
+
+enum hp_scanmode_e
+sanei_hp_optset_scanmode (HpOptSet this, HpData data)
+{
+ HpOption mode = hp_optset_get(this, SCAN_MODE);
+ assert(mode);
+ return hp_option_getint(mode, data);
+}
+
+
+hp_bool_t
+sanei_hp_optset_output_8bit (HpOptSet this, HpData data)
+{
+ HpOption option_out8;
+ int out8;
+
+ option_out8 = hp_optset_get(this, OUT8);
+ if (option_out8)
+ {
+ out8 = hp_option_getint(option_out8, data);
+ return out8;
+ }
+ return 0;
+}
+
+
+/* Returns the data width that is send to the scanner, depending */
+/* on the scanmode. (b/w: 1, gray: 8..12, color: 24..36 */
+int
+sanei_hp_optset_data_width (HpOptSet this, HpData data)
+{
+ enum hp_scanmode_e mode = sanei_hp_optset_scanmode (this, data);
+ int datawidth = 0;
+ HpOption opt_dwidth;
+
+ switch (mode)
+ {
+ case HP_SCANMODE_LINEART:
+ case HP_SCANMODE_HALFTONE:
+ datawidth = 1;
+ break;
+
+ case HP_SCANMODE_GRAYSCALE:
+ opt_dwidth = hp_optset_get(this, BIT_DEPTH);
+ if (opt_dwidth)
+ datawidth = hp_option_getint (opt_dwidth, data);
+ else
+ datawidth = 8;
+ break;
+
+ case HP_SCANMODE_COLOR:
+ opt_dwidth = hp_optset_get(this, BIT_DEPTH);
+ if (opt_dwidth)
+ datawidth = 3 * hp_option_getint (opt_dwidth, data);
+ else
+ datawidth = 24;
+ break;
+ }
+ return datawidth;
+}
+
+hp_bool_t
+sanei_hp_optset_mirror_vert (HpOptSet this, HpData data, HpScsi scsi)
+{
+ HpOption mode;
+ int mirror, sec_dir;
+
+ mode = hp_optset_get(this, MIRROR_VERT);
+ assert(mode);
+ mirror = hp_option_getint(mode, data);
+
+ if (mirror == HP_MIRROR_VERT_CONDITIONAL)
+ {
+ mirror = HP_MIRROR_VERT_OFF;
+ if ( ( sanei_hp_scl_inquire(scsi, SCL_SECONDARY_SCANDIR, &sec_dir, 0, 0)
+ == SANE_STATUS_GOOD ) && ( sec_dir == 1 ) )
+ mirror = HP_MIRROR_VERT_ON;
+ }
+ return mirror == HP_MIRROR_VERT_ON;
+}
+
+hp_bool_t sanei_hp_optset_start_wait(HpOptSet this, HpData data)
+{
+ HpOption mode;
+ int wait;
+
+ if ((mode = hp_optset_get(this, BUTTON_WAIT)) == 0)
+ return(0);
+
+ wait = hp_option_getint(mode, data);
+
+ return(wait);
+}
+
+HpScl
+sanei_hp_optset_scan_type (HpOptSet this, HpData data)
+{
+ HpOption mode;
+ HpScl scl = SCL_START_SCAN;
+ int scantype;
+
+ mode = hp_optset_get(this, SCAN_SOURCE);
+ if (mode)
+ {
+ scantype = hp_option_getint(mode, data);
+ DBG(5, "sanei_hp_optset_scan_type: scantype=%d\n", scantype);
+
+ switch (scantype)
+ {
+ case 1: scl = SCL_ADF_SCAN; break;
+ case 2: scl = SCL_XPA_SCAN; break;
+ default: scl = SCL_START_SCAN; break;
+ }
+ }
+ return scl;
+}
+
+static void
+hp_optset_add (HpOptSet this, HpOption opt)
+{
+ assert(this->num_opts < OPTION_LIST_MAX);
+
+ /*
+ * Keep internal options at the end of the list.
+ */
+ if (hp_option_isInternal(opt))
+ this->options[this->num_opts] = opt;
+ else
+ {
+ if (this->num_opts != this->num_sane_opts)
+ memmove(&this->options[this->num_sane_opts + 1],
+ &this->options[this->num_sane_opts],
+ ( (this->num_opts - this->num_sane_opts)
+ * sizeof(*this->options) ));
+ this->options[this->num_sane_opts++] = opt;
+ }
+ this->num_opts++;
+}
+
+static SANE_Status
+hp_optset_fix_geometry_options (HpOptSet this)
+{
+ _HpOption tl_x = _hp_optset_get(this, SCAN_TL_X);
+ _HpOption tl_y = _hp_optset_get(this, SCAN_TL_Y);
+ _HpOption br_x = _hp_optset_get(this, SCAN_BR_X);
+ _HpOption br_y = _hp_optset_get(this, SCAN_BR_Y);
+ HpOption scanres = hp_optset_get(this, SCAN_RESOLUTION);
+ HpOption devpix = hp_optset_get(this, DEVPIX_RESOLUTION);
+
+ HpAccessor tl_xa, tl_ya, br_xa, br_ya;
+
+ assert(tl_x && tl_y && br_x && br_y); /* Geometry options missing */
+
+ tl_xa = tl_x->data_acsr;
+ tl_ya = tl_y->data_acsr;
+ br_xa = br_x->data_acsr;
+ br_ya = br_y->data_acsr;
+
+ assert(tl_xa && tl_ya && br_xa && br_ya);
+ assert(scanres->data_acsr && devpix->data_acsr);
+
+ /* Magic accessors that will read out in device pixels */
+ tl_x->data_acsr = sanei_hp_accessor_geometry_new(tl_xa, br_xa, 0,
+ devpix->data_acsr);
+ tl_y->data_acsr = sanei_hp_accessor_geometry_new(tl_ya, br_ya, 0,
+ devpix->data_acsr);
+ br_x->data_acsr = sanei_hp_accessor_geometry_new(br_xa, tl_xa, 1,
+ devpix->data_acsr);
+ br_y->data_acsr = sanei_hp_accessor_geometry_new(br_ya, tl_ya, 1,
+ devpix->data_acsr);
+
+ if (!tl_x->data_acsr || !tl_y->data_acsr
+ || !br_x->data_acsr || !br_y->data_acsr)
+ return SANE_STATUS_NO_MEM;
+
+ /* Magic accessors that will read out in scan pixels */
+ this->tl_x = sanei_hp_accessor_geometry_new(tl_xa, br_xa, 0,
+ scanres->data_acsr);
+ this->tl_y = sanei_hp_accessor_geometry_new(tl_ya, br_ya, 0,
+ scanres->data_acsr);
+ this->br_x = sanei_hp_accessor_geometry_new(br_xa, tl_xa, 1,
+ scanres->data_acsr);
+ this->br_y = sanei_hp_accessor_geometry_new(br_ya, tl_ya, 1,
+ scanres->data_acsr);
+ if (!this->tl_x || !this->tl_y || !this->br_x || !this->br_y)
+ return SANE_STATUS_NO_MEM;
+
+ return SANE_STATUS_GOOD;
+}
+
+static void
+hp_optset_reprogram (HpOptSet this, HpData data, HpScsi scsi)
+{
+ int i;
+
+ DBG(5, "hp_optset_reprogram: %lu options\n",
+ (unsigned long) this->num_opts);
+
+ for (i = 0; i < (int)this->num_opts; i++)
+ hp_option_reprogram(this->options[i], this, data, scsi);
+
+ DBG(5, "hp_optset_reprogram: finished\n");
+}
+
+static void
+hp_optset_reprobe (HpOptSet this, HpData data, HpScsi scsi)
+{
+ int i;
+
+ DBG(5, "hp_optset_reprobe: %lu options\n",
+ (unsigned long) this->num_opts);
+
+ for (i = 0; i < (int)this->num_opts; i++)
+ hp_option_reprobe(this->options[i], this, data, scsi);
+
+ DBG(5, "hp_optset_reprobe: finished\n");
+}
+
+static void
+hp_optset_updateEnables (HpOptSet this, HpData data, const HpDeviceInfo *info)
+{
+ int i;
+
+ DBG(5, "hp_optset_updateEnables: %lu options\n",
+ (unsigned long) this->num_opts);
+
+ for (i = 0; i < (int)this->num_opts; i++)
+ hp_option_updateEnable(this->options[i], this, data, info);
+}
+
+static hp_bool_t
+hp_optset_isEnabled (HpOptSet this, HpData data, const char *name,
+ const HpDeviceInfo *info)
+{
+ HpOption optpt;
+
+ optpt = hp_optset_getByName (this, name);
+
+ if (!optpt) /* Not found ? Not enabled */
+ return 0;
+
+ if (!(optpt->descriptor->enable)) /* No enable necessary ? Enabled */
+ return 1;
+
+ return (*optpt->descriptor->enable)(optpt, this, data, info);
+}
+
+/* This function is only called from sanei_hp_handle_startScan() */
+SANE_Status
+sanei_hp_optset_download (HpOptSet this, HpData data, HpScsi scsi)
+{
+ int i, errcount = 0;
+
+ DBG(3, "Start downloading parameters to scanner\n");
+
+ /* Reset scanner to wake it up */
+
+ /* Reset would switch off XPA lamp and switch on scanner lamp. */
+ /* Only do a reset if not in active XPA mode */
+ if ( (sanei_hp_optset_scan_type (this, data) != SCL_XPA_SCAN)
+ || (!sanei_hp_is_active_xpa (scsi)) )
+ {
+ RETURN_IF_FAIL(sanei_hp_scl_reset (scsi));
+ }
+ RETURN_IF_FAIL(sanei_hp_scl_clearErrors (scsi));
+
+ sanei_hp_device_simulate_clear ( sanei_hp_scsi_devicename (scsi) );
+
+ for (i = 0; i < (int)this->num_opts; i++)
+ {
+ if ( (this->options[i])->descriptor->suppress_for_scan )
+ {
+ DBG(3,"sanei_hp_optset_download: %s suppressed for scan\n",
+ (this->options[i])->descriptor->name);
+ }
+ else
+ {
+ RETURN_IF_FAIL( hp_option_program(this->options[i], scsi, this, data) );
+
+ if ( sanei_hp_scl_errcheck (scsi) != SANE_STATUS_GOOD )
+ {
+ errcount++;
+ DBG(3, "Option %s generated scanner error\n",
+ this->options[i]->descriptor->name);
+
+ RETURN_IF_FAIL(sanei_hp_scl_clearErrors (scsi));
+ }
+ }
+ }
+ DBG(3, "Downloading parameters finished.\n");
+
+ /* Check preview */
+ {HpOption option;
+ int is_preview, data_width;
+ const HpDeviceInfo *info;
+
+ option = hp_optset_getByName (this, SANE_NAME_PREVIEW);
+ if ( option )
+ {
+ is_preview = hp_option_getint (option, data);
+ if ( is_preview )
+ {
+ /* For preview we only use 8 bit per channel */
+
+ DBG(3, "sanei_hp_optset_download: Set up preview options\n");
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+
+ if (hp_optset_isEnabled (this, data, SANE_NAME_BIT_DEPTH, info))
+ {
+ data_width = sanei_hp_optset_data_width (this, data);
+ if (data_width > 24)
+ {
+ sanei_hp_scl_set(scsi, SCL_DATA_WIDTH, 24);
+ }
+ else if ((data_width > 8) && (data_width <= 16))
+ {
+ sanei_hp_scl_set(scsi, SCL_DATA_WIDTH, 8);
+ }
+ }
+ }
+ }
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sanei_hp_optset_new(HpOptSet * newp, HpScsi scsi, HpDevice dev)
+{
+ HpOptionDescriptor * ptr;
+ HpOptSet this = sanei_hp_allocz(sizeof(*this));
+ SANE_Status status;
+ HpOption option;
+ const HpDeviceInfo *info;
+
+ if (!this)
+ return SANE_STATUS_NO_MEM;
+
+ /* FIXME: more DBG's */
+ for (ptr = hp_options; *ptr; ptr++)
+ {
+ HpOptionDescriptor desc = *ptr;
+
+ DBG(8, "sanei_hp_optset_new: %s\n", desc->name);
+ if (desc->requires && !sanei_hp_device_compat(dev, desc->requires))
+ continue;
+ if (desc->type != SANE_TYPE_GROUP
+ && hp_optset_getByName(this, desc->name))
+ continue;
+
+ status = hp_option_descriptor_probe(desc, scsi, this,
+ dev->data, &option);
+ if (UNSUPPORTED(status))
+ continue;
+ if (FAILED(status))
+ {
+ DBG(1, "Option '%s': probe failed: %s\n", desc->name,
+ sane_strstatus(status));
+ sanei_hp_free(this);
+ return status;
+ }
+ hp_optset_add(this, option);
+ }
+
+ /* Set NUM_OPTIONS */
+ assert(this->options[0]->descriptor == NUM_OPTIONS);
+ sanei_hp_accessor_setint(this->options[0]->data_acsr, dev->data,
+ this->num_sane_opts);
+
+ /* Now for some kludges */
+ status = hp_optset_fix_geometry_options(this);
+ if (FAILED(status))
+ {
+ sanei_hp_free(this);
+ return status;
+ }
+
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ hp_optset_updateEnables(this, dev->data, info);
+
+ *newp = this;
+ return SANE_STATUS_GOOD;
+}
+
+hp_bool_t
+sanei_hp_optset_isImmediate (HpOptSet this, int optnum)
+{
+ HpOption opt = hp_optset_getByIndex(this, optnum);
+
+ if (!opt)
+ return 0;
+
+ return hp_option_isImmediate (opt);
+}
+
+SANE_Status
+sanei_hp_optset_control (HpOptSet this, HpData data,
+ int optnum, SANE_Action action,
+ void * valp, SANE_Int *infop, HpScsi scsi,
+ hp_bool_t immediate)
+{
+ HpOption opt = hp_optset_getByIndex(this, optnum);
+ SANE_Int my_info = 0, my_val = 0;
+
+ DBG(3,"sanei_hp_optset_control: %s\n", opt ? opt->descriptor->name : "");
+
+ if (infop)
+ *infop = 0;
+ else
+ infop = &my_info;
+
+ if (!opt)
+ return SANE_STATUS_INVAL;
+
+ /* There are problems with SANE_ACTION_GET_VALUE and valp == 0. */
+ /* Check if we really need valp. */
+ if ((action == SANE_ACTION_GET_VALUE) && (!valp))
+ {
+ /* Options without a value ? */
+ if ( (opt->descriptor->type == SANE_TYPE_BUTTON)
+ || (opt->descriptor->type == SANE_TYPE_GROUP))
+ {
+ valp = &my_val; /* Just simulate a return value locally. */
+ }
+ else /* Others must return a value. So this is invalid */
+ {
+ DBG(1, "sanei_hp_optset_control: get value, but valp == 0\n");
+ return SANE_STATUS_INVAL;
+ }
+ }
+
+ if (immediate)
+ RETURN_IF_FAIL( hp_option_imm_control(this, opt, data, action, valp, infop,
+ scsi) );
+ else
+ RETURN_IF_FAIL( hp_option_control(opt, data, action, valp, infop ) );
+
+ if ((*infop & SANE_INFO_RELOAD_OPTIONS) != 0)
+ {const HpDeviceInfo *info;
+
+ DBG(3,"sanei_hp_optset_control: reprobe\n");
+
+ /* At first we try to reprogram the parameters that may have changed */
+ /* by an option that had a global effect. This is necessary to */
+ /* specify options in an arbitrary order. Example: */
+ /* Changing scan mode resets scan resolution in the scanner. */
+ /* If resolution is set from the API before scan mode, we must */
+ /* reprogram the resolution afterwards. */
+ hp_optset_reprogram(this, data, scsi);
+ hp_optset_reprobe(this, data, scsi);
+ info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) );
+ hp_optset_updateEnables(this, data, info);
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sanei_hp_optset_guessParameters (HpOptSet this, HpData data,
+ SANE_Parameters * p)
+{
+ /* These are magic accessors which actually get the extent, not the
+ * absolute position... */
+ int xextent = sanei_hp_accessor_getint(this->br_x, data);
+ int yextent = sanei_hp_accessor_getint(this->br_y, data);
+ int data_width;
+
+ assert(xextent > 0 && yextent > 0);
+ p->last_frame = SANE_TRUE;
+ p->pixels_per_line = xextent;
+ p->lines = yextent;
+
+ switch (sanei_hp_optset_scanmode(this, data)) {
+ case HP_SCANMODE_LINEART: /* Lineart */
+ case HP_SCANMODE_HALFTONE: /* Halftone */
+ p->format = SANE_FRAME_GRAY;
+ p->depth = 1;
+ p->bytes_per_line = (p->pixels_per_line + 7) / 8;
+ break;
+ case HP_SCANMODE_GRAYSCALE: /* Grayscale */
+ p->format = SANE_FRAME_GRAY;
+ p->depth = 8;
+ p->bytes_per_line = p->pixels_per_line;
+ if ( !sanei_hp_optset_output_8bit (this, data) )
+ {
+ data_width = sanei_hp_optset_data_width (this, data);
+ if ( data_width > 8 )
+ {
+ p->depth *= 2;
+ p->bytes_per_line *= 2;
+ }
+ }
+ break;
+ case HP_SCANMODE_COLOR: /* RGB */
+ p->format = SANE_FRAME_RGB;
+ p->depth = 8;
+ p->bytes_per_line = 3 * p->pixels_per_line;
+ if ( !sanei_hp_optset_output_8bit (this, data) )
+ {
+ data_width = sanei_hp_optset_data_width (this, data);
+ if ( data_width > 24 )
+ {
+ p->depth *= 2;
+ p->bytes_per_line *= 2;
+ }
+ }
+ break;
+ default:
+ assert(!"Bad scan mode?");
+ return SANE_STATUS_INVAL;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+const SANE_Option_Descriptor *
+sanei_hp_optset_saneoption (HpOptSet this, HpData data, int optnum)
+{
+ HpOption opt = hp_optset_getByIndex(this, optnum);
+
+ if (!opt)
+ return 0;
+ return hp_option_saneoption(opt, data);
+}