diff options
Diffstat (limited to 'backend/genesys.c')
| -rw-r--r-- | backend/genesys.c | 8047 |
1 files changed, 0 insertions, 8047 deletions
diff --git a/backend/genesys.c b/backend/genesys.c deleted file mode 100644 index db0a2b2..0000000 --- a/backend/genesys.c +++ /dev/null @@ -1,8047 +0,0 @@ -/* sane - Scanner Access Now Easy. - - Copyright (C) 2003, 2004 Henning Meier-Geinitz <henning@meier-geinitz.de> - Copyright (C) 2004, 2005 Gerhard Jaeger <gerhard@gjaeger.de> - Copyright (C) 2004-2016 Stéphane Voltz <stef.dev@free.fr> - Copyright (C) 2005-2009 Pierre Willenbrock <pierre@pirsoft.dnsalias.org> - Copyright (C) 2006 Laurent Charpentier <laurent_pubs@yahoo.com> - Copyright (C) 2007 Luke <iceyfor@gmail.com> - Copyright (C) 2010 Chris Berry <s0457957@sms.ed.ac.uk> and Michael Rickmann <mrickma@gwdg.de> - for Plustek Opticbook 3600 support - - Dynamic rasterization code was taken from the epjistsu backend by - m. allan noah <kitno455 at gmail dot com> - - Software processing for deskew, crop and dspeckle are inspired by allan's - noah work in the fujitsu backend - - 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. -*/ - -/* - * SANE backend for Genesys Logic GL646/GL841/GL842/GL843/GL846/GL847/GL124 based scanners - */ - -#define BUILD 2511 -#define BACKEND_NAME genesys - -#include "genesys.h" -#include "../include/sane/sanei_config.h" -#include "../include/sane/sanei_magic.h" -#include "genesys_devices.c" - -static SANE_Int num_devices = 0; -static Genesys_Device *first_dev = 0; -static Genesys_Scanner *first_handle = 0; -static const SANE_Device **devlist = 0; -/* Array of newly attached devices */ -static Genesys_Device **new_dev = 0; -/* Length of new_dev array */ -static SANE_Int new_dev_len = 0; -/* Number of entries alloced for new_dev */ -static SANE_Int new_dev_alloced = 0; - -static SANE_String_Const mode_list[] = { - SANE_VALUE_SCAN_MODE_COLOR, - SANE_VALUE_SCAN_MODE_GRAY, - /* SANE_TITLE_HALFTONE, currently unused */ - SANE_VALUE_SCAN_MODE_LINEART, - 0 -}; - -static SANE_String_Const color_filter_list[] = { - SANE_I18N ("Red"), - SANE_I18N ("Green"), - SANE_I18N ("Blue"), - 0 -}; - -static SANE_String_Const cis_color_filter_list[] = { - SANE_I18N ("Red"), - SANE_I18N ("Green"), - SANE_I18N ("Blue"), - SANE_I18N ("None"), - 0 -}; - -static SANE_String_Const source_list[] = { - SANE_I18N (FLATBED), - SANE_I18N (TRANSPARENCY_ADAPTER), - 0 -}; - -static SANE_Range swdespeck_range = { - 1, - 9, - 1 -}; - -static SANE_Range time_range = { - 0, /* minimum */ - 60, /* maximum */ - 0 /* quantization */ -}; - -static const SANE_Range u12_range = { - 0, /* minimum */ - 4095, /* maximum */ - 0 /* quantization */ -}; - -static const SANE_Range u14_range = { - 0, /* minimum */ - 16383, /* maximum */ - 0 /* quantization */ -}; - -static const SANE_Range u16_range = { - 0, /* minimum */ - 65535, /* maximum */ - 0 /* quantization */ -}; - -static const SANE_Range percentage_range = { - SANE_FIX (0), /* minimum */ - SANE_FIX (100), /* maximum */ - SANE_FIX (1) /* quantization */ -}; - -static const SANE_Range threshold_curve_range = { - 0, /* minimum */ - 127, /* maximum */ - 1 /* quantization */ -}; - -/** - * range for brightness and contrast - */ -static const SANE_Range enhance_range = { - -100, /* minimum */ - 100, /* maximum */ - 1 /* quantization */ -}; - -/** - * range for expiration time - */ -static const SANE_Range expiration_range = { - -1, /* minimum */ - 30000, /* maximum */ - 1 /* quantization */ -}; - -void -sanei_genesys_init_structs (Genesys_Device * dev) -{ - unsigned int i, sensor_ok = 0, gpo_ok = 0, motor_ok = 0; - - /* initialize the sensor data stuff */ - for (i = 0; i < sizeof (Sensor) / sizeof (Genesys_Sensor); i++) - { - if (dev->model->ccd_type == Sensor[i].sensor_id) - { - memcpy (&dev->sensor, &Sensor[i], sizeof (Genesys_Sensor)); - sensor_ok = 1; - } - } - - /* initialize the GPO data stuff */ - for (i = 0; i < sizeof (Gpo) / sizeof (Genesys_Gpo); i++) - { - if (dev->model->gpo_type == Gpo[i].gpo_id) - { - memcpy (&dev->gpo, &Gpo[i], sizeof (Genesys_Gpo)); - gpo_ok = 1; - } - } - - /* initialize the motor data stuff */ - for (i = 0; i < sizeof (Motor) / sizeof (Genesys_Motor); i++) - { - if (dev->model->motor_type == Motor[i].motor_id) - { - memcpy (&dev->motor, &Motor[i], sizeof (Genesys_Motor)); - motor_ok = 1; - } - } - - /* sanity check */ - if (sensor_ok == 0 || motor_ok == 0 || gpo_ok == 0) - { - DBG (DBG_error0, - "sanei_genesys_init_structs: bad description(s) for ccd/gpo/motor=%d/%d/%d\n", - dev->model->ccd_type, dev->model->gpo_type, - dev->model->motor_type); - } - - /* set up initial line distance shift */ - dev->ld_shift_r = dev->model->ld_shift_r; - dev->ld_shift_g = dev->model->ld_shift_g; - dev->ld_shift_b = dev->model->ld_shift_b; -} - -void -sanei_genesys_init_fe (Genesys_Device * dev) -{ - unsigned int i; - - DBGSTART; - for (i = 0; i < sizeof (Wolfson) / sizeof (Genesys_Frontend); i++) - { - if (dev->model->dac_type == Wolfson[i].fe_id) - { - memcpy (&dev->frontend, &Wolfson[i], sizeof (Genesys_Frontend)); - return; - } - } - DBG (DBG_error0, - "sanei_genesys_init_fe: failed to find description for dac_type %d\n", - dev->model->dac_type); - DBG (DBG_info, "sanei_genesys_init_fe: dac_type %d set up\n", - dev->model->dac_type); - DBGCOMPLETED; -} - -/* main function for slope creation */ -/** - * This function generates a slope table using the given slope - * truncated at the given exposure time or step count, whichever comes first. - * The reached step time is then stored in final_exposure and used for the rest - * of the table. The summed time of the acceleration steps is returned, and the - * number of accerelation steps is put into used_steps. - * - * @param slope_table Table to write to - * @param max_steps Size of slope_table in steps - * @param use_steps Maximum number of steps to use for acceleration - * @param stop_at Minimum step time to use - * @param vstart Start step time of default slope - * @param vend End step time of default slope - * @param steps Step count of default slope - * @param g Power for default slope - * @param used_steps Final number of steps is stored here - * @param vfinal Final step time is stored here - * @return Time for acceleration - * @note All times in pixel time. Correction for other motor timings is not - * done. - */ -SANE_Int -sanei_genesys_generate_slope_table (uint16_t * slope_table, - unsigned int max_steps, - unsigned int use_steps, - uint16_t stop_at, - uint16_t vstart, - uint16_t vend, - unsigned int steps, - double g, - unsigned int *used_steps, - unsigned int *vfinal) -{ - double t; - SANE_Int sum = 0; - unsigned int i; - unsigned int c = 0; - uint16_t t2; - unsigned int dummy; - unsigned int _vfinal; - if (!used_steps) - used_steps = &dummy; - if (!vfinal) - vfinal = &_vfinal; - - DBG (DBG_proc, "sanei_genesys_generate_slope_table: table size: %d\n", - max_steps); - - DBG (DBG_proc, - "sanei_genesys_generate_slope_table: stop at time: %d, use %d steps max\n", - stop_at, use_steps); - - DBG (DBG_proc, - "sanei_genesys_generate_slope_table: target slope: " - "vstart: %d, vend: %d, steps: %d, g: %g\n", vstart, vend, steps, g); - - sum = 0; - c = 0; - *used_steps = 0; - - if (use_steps < 1) - use_steps = 1; - - if (stop_at < vstart) - { - t2 = vstart; - for (i = 0; i < steps && i < use_steps - 1 && i < max_steps; i++, c++) - { - t = pow (((double) i) / ((double) (steps - 1)), g); - t2 = vstart * (1 - t) + t * vend; - if (t2 < stop_at) - break; - *slope_table++ = t2; - /* DBG (DBG_io, "slope_table[%3d] = %5d\n", c, t2); */ - sum += t2; - } - if (t2 > stop_at) - { - DBG (DBG_warn, "Can not reach target speed(%d) in %d steps.\n", - stop_at, use_steps); - DBG (DBG_warn, "Expect image to be distorted. " - "Ignore this if only feeding.\n"); - } - *vfinal = t2; - *used_steps += i; - max_steps -= i; - } - else - *vfinal = stop_at; - - for (i = 0; i < max_steps; i++, c++) - { - *slope_table++ = *vfinal; - /* DBG (DBG_io, "slope_table[%3d] = %5d\n", c, *vfinal); */ - } - - (*used_steps)++; - sum += *vfinal; - - DBG (DBG_proc, - "sanei_genesys_generate_slope_table: returns sum=%d, used %d steps, completed\n", - sum, *used_steps); - - return sum; -} - -/* Generate slope table for motor movement */ -/** - * This function generates a slope table using the slope from the motor struct - * truncated at the given exposure time or step count, whichever comes first. - * The reached step time is then stored in final_exposure and used for the rest - * of the table. The summed time of the acceleration steps is returned, and the - * number of accerelation steps is put into used_steps. - * - * @param dev Device struct - * @param slope_table Table to write to - * @param max_step Size of slope_table in steps - * @param use_steps Maximum number of steps to use for acceleration - * @param step_type Generate table for this step_type. 0=>full, 1=>half, - * 2=>quarter - * @param exposure_time Minimum exposure time of a scan line - * @param yres Resolution of a scan line - * @param used_steps Final number of steps is stored here - * @param final_exposure Final step time is stored here - * @param power_mode Power mode (related to the Vref used) of the motor - * @return Time for acceleration - * @note all times in pixel time - */ -SANE_Int -sanei_genesys_create_slope_table3 (Genesys_Device * dev, - uint16_t * slope_table, - int max_step, - unsigned int use_steps, - int step_type, - int exposure_time, - double yres, - unsigned int *used_steps, - unsigned int *final_exposure, - int power_mode) -{ - unsigned int sum_time = 0; - unsigned int vtarget; - unsigned int vend; - unsigned int vstart; - unsigned int vfinal; - - DBG (DBG_proc, - "%s: step_type = %d, " - "exposure_time = %d, yres = %g, power_mode = %d\n", __func__, step_type, - exposure_time, yres, power_mode); - - /* final speed */ - vtarget = (exposure_time * yres) / dev->motor.base_ydpi; - - vstart = dev->motor.slopes[power_mode][step_type].maximum_start_speed; - vend = dev->motor.slopes[power_mode][step_type].maximum_speed; - - vtarget >>= step_type; - if (vtarget > 65535) - vtarget = 65535; - - vstart >>= step_type; - if (vstart > 65535) - vstart = 65535; - - vend >>= step_type; - if (vend > 65535) - vend = 65535; - - sum_time = sanei_genesys_generate_slope_table (slope_table, - max_step, - use_steps, - vtarget, - vstart, - vend, - dev->motor.slopes[power_mode][step_type].minimum_steps << step_type, - dev->motor.slopes[power_mode][step_type].g, - used_steps, - &vfinal); - - if (final_exposure) - *final_exposure = (vfinal * dev->motor.base_ydpi) / yres; - - DBG (DBG_proc, - "sanei_genesys_create_slope_table: returns sum_time=%d, completed\n", - sum_time); - - return sum_time; -} - - -/* alternate slope table creation function */ -/* the hardcoded values (g and vstart) will go in a motor struct */ -static SANE_Int -genesys_create_slope_table2 (Genesys_Device * dev, - uint16_t * slope_table, int steps, - int step_type, int exposure_time, - SANE_Bool same_speed, double yres, - int power_mode) -{ - double t, g; - SANE_Int sum = 0; - int vstart, vend; - int i; - - DBG (DBG_proc, - "sanei_genesys_create_slope_table2: %d steps, step_type = %d, " - "exposure_time = %d, same_speed = %d, yres = %.2f, power_mode = %d\n", - steps, step_type, exposure_time, same_speed, yres, power_mode); - - /* start speed */ - if (dev->model->motor_type == MOTOR_5345) - { - if (yres < dev->motor.base_ydpi / 6) - vstart = 2500; - else - vstart = 2000; - } - else - { - if (steps == 2) - vstart = exposure_time; - else if (steps == 3) - vstart = 2 * exposure_time; - else if (steps == 4) - vstart = 1.5 * exposure_time; - else if (steps == 120) - vstart = 1.81674 * exposure_time; - else - vstart = exposure_time; - } - - /* final speed */ - vend = (exposure_time * yres) / (dev->motor.base_ydpi * (1 << step_type)); - - /* - type=1 : full - type=2 : half - type=4 : quarter - vend * type * base_ydpi / exposure = yres - */ - - /* acceleration */ - switch (steps) - { - case 255: - /* test for special case: fast moving slope */ - /* todo: a 'fast' boolean parameter should be better */ - if (vstart == 2000) - g = 0.2013; - else - g = 0.1677; - break; - case 120: - g = 0.5; - break; - case 67: - g = 0.5; - break; - case 64: - g = 0.2555; - break; - case 44: - g = 0.5; - break; - case 4: - g = 0.5; - break; - case 3: - g = 1; - break; - case 2: - vstart = vend; - g = 1; - break; - default: - g = 0.2635; - } - - /* if same speed, no 'g' */ - sum = 0; - if (same_speed) - { - for (i = 0; i < 255; i++) - { - slope_table[i] = vend; - sum += slope_table[i]; - DBG (DBG_io, "slope_table[%3d] = %5d\n", i, slope_table[i]); - } - } - else - { - for (i = 0; i < steps; i++) - { - t = pow (((double) i) / ((double) (steps - 1)), g); - slope_table[i] = vstart * (1 - t) + t * vend; - DBG (DBG_io, "slope_table[%3d] = %5d\n", i, slope_table[i]); - sum += slope_table[i]; - } - for (i = steps; i < 255; i++) - { - slope_table[i] = vend; - DBG (DBG_io, "slope_table[%3d] = %5d\n", i, slope_table[i]); - sum += slope_table[i]; - } - } - - DBG (DBG_proc, - "sanei_genesys_create_slope_table2: returns sum=%d, completed\n", sum); - - return sum; -} - -/* Generate slope table for motor movement */ -/* todo: check details */ -SANE_Int -sanei_genesys_create_slope_table (Genesys_Device * dev, - uint16_t * slope_table, int steps, - int step_type, int exposure_time, - SANE_Bool same_speed, double yres, - int power_mode) -{ - double t; - double start_speed; - double g; - uint32_t time_period; - int sum_time = 0; - int i, divider; - int same_step; - - if (dev->model->motor_type == MOTOR_5345 - || dev->model->motor_type == MOTOR_HP2300 - || dev->model->motor_type == MOTOR_HP2400) - return genesys_create_slope_table2 (dev, slope_table, steps, - step_type, exposure_time, - same_speed, yres, power_mode); - - DBG (DBG_proc, - "sanei_genesys_create_slope_table: %d steps, step_type = %d, " - "exposure_time = %d, same_speed =%d\n", steps, step_type, - exposure_time, same_speed); - DBG (DBG_proc, "sanei_genesys_create_slope_table: yres = %.2f\n", yres); - - g = 0.6; - start_speed = 0.01; - same_step = 4; - divider = 1 << step_type; - - time_period = - (uint32_t) (yres * exposure_time / dev->motor.base_ydpi /*MOTOR_GEAR */ ); - if ((time_period < 2000) && (same_speed)) - same_speed = SANE_FALSE; - - time_period = time_period / divider; - - if (same_speed) - { - for (i = 0; i < steps; i++) - { - slope_table[i] = (uint16_t) time_period; - sum_time += time_period; - - DBG (DBG_io, "slope_table[%d] = %d\n", i, time_period); - } - DBG (DBG_info, - "sanei_genesys_create_slope_table: returns sum_time=%d, completed\n", - sum_time); - return sum_time; - } - - if (time_period > MOTOR_SPEED_MAX * 5) - { - g = 1.0; - start_speed = 0.05; - same_step = 2; - } - else if (time_period > MOTOR_SPEED_MAX * 4) - { - g = 0.8; - start_speed = 0.04; - same_step = 2; - } - else if (time_period > MOTOR_SPEED_MAX * 3) - { - g = 0.7; - start_speed = 0.03; - same_step = 2; - } - else if (time_period > MOTOR_SPEED_MAX * 2) - { - g = 0.6; - start_speed = 0.02; - same_step = 3; - } - - if (dev->model->motor_type == MOTOR_ST24) - { - steps = 255; - switch ((int) yres) - { - case 2400: - g = 0.1672; - start_speed = 1.09; - break; - case 1200: - g = 1; - start_speed = 6.4; - break; - case 600: - g = 0.1672; - start_speed = 1.09; - break; - case 400: - g = 0.2005; - start_speed = 20.0 / 3.0 /*7.5 */ ; - break; - case 300: - g = 0.253; - start_speed = 2.182; - break; - case 150: - g = 0.253; - start_speed = 4.367; - break; - default: - g = 0.262; - start_speed = 7.29; - } - same_step = 1; - } - - if (steps <= same_step) - { - time_period = - (uint32_t) (yres * exposure_time / - dev->motor.base_ydpi /*MOTOR_GEAR */ ); - time_period = time_period / divider; - - if (time_period > 65535) - time_period = 65535; - - for (i = 0; i < same_step; i++) - { - slope_table[i] = (uint16_t) time_period; - sum_time += time_period; - - DBG (DBG_io, "slope_table[%d] = %d\n", i, time_period); - } - - DBG (DBG_proc, - "sanei_genesys_create_slope_table: returns sum_time=%d, completed\n", - sum_time); - return sum_time; - } - - for (i = 0; i < steps; i++) - { - double j = ((double) i) - same_step + 1; /* start from 1/16 speed */ - - if (j <= 0) - t = 0; - else - t = pow (j / (steps - same_step), g); - - time_period = /* time required for full steps */ - (uint32_t) (yres * exposure_time / - dev->motor.base_ydpi /*MOTOR_GEAR */ * - (start_speed + (1 - start_speed) * t)); - - time_period = time_period / divider; - if (time_period > 65535) - time_period = 65535; - - slope_table[i] = (uint16_t) time_period; - sum_time += time_period; - - DBG (DBG_io, "slope_table[%d] = %d\n", i, slope_table[i]); - } - - DBG (DBG_proc, - "sanei_genesys_create_slope_table: returns sum_time=%d, completed\n", - sum_time); - - return sum_time; -} - -/** @brief computes gamma table - * Generates a gamma table of the given length within 0 and the given - * maximum value - * @param gamma_table gamma table to fill - * @param size size of the table - * @param maximum value allowed for gamma - * @param gamma_max maximum gamma value - * @param gamma gamma to compute values - * @return a gamma table filled with the computed values - * */ -void -sanei_genesys_create_gamma_table (uint16_t * gamma_table, int size, - float maximum, float gamma_max, float gamma) -{ - int i; - float value; - - if(gamma_table==NULL) - { - DBG (DBG_proc, "sanei_genesys_create_gamma_table: gamma table is NULL\n"); - return; - } - DBG (DBG_proc, - "sanei_genesys_create_gamma_table: size = %d, " - "maximum = %g, gamma_max = %g, gamma = %g\n", - size, maximum, gamma_max, gamma); - for (i = 0; i < size; i++) - { - value = gamma_max * pow ((float) i / size, 1.0 / gamma); - if (value > maximum) - value = maximum; - gamma_table[i] = value; - } - DBG (DBG_proc, "sanei_genesys_create_gamma_table: completed\n"); -} - - -/* computes the exposure_time on the basis of the given vertical dpi, - the number of pixels the ccd needs to send, - the step_type and the corresponding maximum speed from the motor struct */ -/* - Currently considers maximum motor speed at given step_type, minimum - line exposure needed for conversion and led exposure time. - - TODO: Should also consider maximum transfer rate: ~6.5MB/s. - Note: The enhance option of the scanners does _not_ help. It only halves - the amount of pixels transfered. - */ -SANE_Int -sanei_genesys_exposure_time2 (Genesys_Device * dev, float ydpi, - int step_type, int endpixel, - int exposure_by_led, int power_mode) -{ - int exposure_by_ccd = endpixel + 32; - int exposure_by_motor = - (dev->motor.slopes[power_mode][step_type].maximum_speed - * dev->motor.base_ydpi) / ydpi; - - int exposure = exposure_by_ccd; - - if (exposure < exposure_by_motor) - exposure = exposure_by_motor; - - if (exposure < exposure_by_led && dev->model->is_cis) - exposure = exposure_by_led; - - DBG (DBG_info, "%s: ydpi=%d, step=%d, endpixel=%d led=%d, power=%d => exposure=%d\n", - __func__, (int)ydpi, step_type, endpixel, exposure_by_led, power_mode, exposure); - return exposure; -} - -/* computes the exposure_time on the basis of the given horizontal dpi */ -/* we will clean/simplify it by using constants from a future motor struct */ -SANE_Int -sanei_genesys_exposure_time (Genesys_Device * dev, Genesys_Register_Set * reg, - int xdpi) -{ - if (dev->model->motor_type == MOTOR_5345) - { - if (dev->model->cmd_set->get_filter_bit (reg)) - { - /* monochrome */ - switch (xdpi) - { - case 600: - return 8500; - case 500: - case 400: - case 300: - case 250: - case 200: - case 150: - return 5500; - case 100: - return 6500; - case 50: - return 12000; - default: - return 11000; - } - } - else - { - /* color scan */ - switch (xdpi) - { - case 300: - case 250: - case 200: - return 5500; - case 50: - return 12000; - default: - return 11000; - } - } - } - else if (dev->model->motor_type == MOTOR_HP2400) - { - if (dev->model->cmd_set->get_filter_bit (reg)) - { - /* monochrome */ - switch (xdpi) - { - case 200: - return 7210; - default: - return 11111; - } - } - else - { - /* color scan */ - switch (xdpi) - { - case 600: - return 8751; /*11902; 19200 */ - default: - return 11111; - } - } - } - else if (dev->model->motor_type == MOTOR_HP2300) - { - if (dev->model->cmd_set->get_filter_bit (reg)) - { - /* monochrome */ - switch (xdpi) - { - case 600: - return 8699; /* 3200; */ - case 300: - return 3200; /*10000;, 3200 -> too dark */ - case 150: - return 4480; /* 3200 ???, warmup needs 4480 */ - case 75: - return 5500; - default: - return 11111; - } - } - else - { - /* color scan */ - switch (xdpi) - { - case 600: - return 8699; - case 300: - return 4349; - case 150: - case 75: - return 4480; - default: - return 11111; - } - } - } - return dev->settings.exposure_time; -} - - - -/* Sends a block of shading information to the scanner. - The data is placed at address 0x0000 for color mode, gray mode and - unconditionally for the following CCD chips: HP2300, HP2400 and HP5345 - In the other cases (lineart, halftone on ccd chips not mentioned) the - addresses are 0x2a00 for dpihw==0, 0x5500 for dpihw==1 and 0xa800 for - dpihw==2. //Note: why this? - - The data needs to be of size "size", and in little endian byte order. - */ -#ifndef UNIT_TESTING -static -#endif - SANE_Status -genesys_send_offset_and_shading (Genesys_Device * dev, uint8_t * data, - int size) -{ - int dpihw; - int start_address; - SANE_Status status; - - DBG (DBG_proc, "%s: (size = %d)\n", __func__, size); - - /* ASIC higher than gl843 doesn't have register 2A/2B, so we route to - * a per ASIC shading data loading function if available. - * It is also used for scanners using SHDAREA */ - if(dev->model->cmd_set->send_shading_data!=NULL) - { - status=dev->model->cmd_set->send_shading_data(dev, data, size); - DBGCOMPLETED; - return status; - } - - /* gl646, gl84[123] case */ - dpihw = sanei_genesys_read_reg_from_set (dev->reg, 0x05) >> 6; - - /* TODO invert the test so only the 2 models behaving like that are - * tested instead of adding all the others */ - /* many scanners send coefficient for lineart/gray like in color mode */ - if (dev->settings.scan_mode < 2 - && dev->model->ccd_type != CCD_PLUSTEK3800 - && dev->model->ccd_type != CCD_KVSS080 - && dev->model->ccd_type != CCD_G4050 - && dev->model->ccd_type != CCD_CS4400F - && dev->model->ccd_type != CCD_CS8400F - && dev->model->ccd_type != CCD_DSMOBILE600 - && dev->model->ccd_type != CCD_XP300 - && dev->model->ccd_type != CCD_DP665 - && dev->model->ccd_type != CCD_DP685 - && dev->model->ccd_type != CIS_CANONLIDE80 - && dev->model->ccd_type != CCD_ROADWARRIOR - && dev->model->ccd_type != CCD_HP2300 - && dev->model->ccd_type != CCD_HP2400 - && dev->model->ccd_type != CCD_HP3670 - && dev->model->ccd_type != CCD_5345) /* lineart, halftone */ - { - if (dpihw == 0) /* 600 dpi */ - start_address = 0x02a00; - else if (dpihw == 1) /* 1200 dpi */ - start_address = 0x05500; - else if (dpihw == 2) /* 2400 dpi */ - start_address = 0x0a800; - else /* reserved */ - return SANE_STATUS_INVAL; - } - else /* color */ - start_address = 0x00; - - status = sanei_genesys_set_buffer_address (dev, start_address); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "%s: failed to set buffer address: %s\n", __func__, - sane_strstatus (status)); - return status; - } - - status = dev->model->cmd_set->bulk_write_data (dev, 0x3c, data, size); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "%s: failed to send shading table: %s\n", __func__, - sane_strstatus (status)); - return status; - } - - DBGCOMPLETED; - - return SANE_STATUS_GOOD; -} - -/* ? */ -SANE_Status -sanei_genesys_init_shading_data (Genesys_Device * dev, int pixels_per_line) -{ - SANE_Status status; - uint8_t *shading_data, *shading_data_ptr; - int channels; - int i; - - /* these models don't need to init shading data due to the use of specific send shading data - function */ - if (dev->model->ccd_type==CCD_KVSS080 - || dev->model->ccd_type==CCD_G4050 - || dev->model->ccd_type==CCD_CS4400F - || dev->model->ccd_type==CCD_CS8400F - || dev->model->cmd_set->send_shading_data!=NULL) - return SANE_STATUS_GOOD; - - DBG (DBG_proc, "sanei_genesys_init_shading_data (pixels_per_line = %d)\n", - pixels_per_line); - - if (dev->settings.scan_mode >= 2) /* 3 pass or single pass color */ - channels = 3; - else - channels = 1; - - shading_data = malloc (pixels_per_line * 4 * channels); /* 16 bit black, 16 bit white */ - if (!shading_data) - { - DBG (DBG_error, - "sanei_genesys_init_shading_data: failed to allocate memory\n"); - return SANE_STATUS_NO_MEM; - } - - shading_data_ptr = shading_data; - - for (i = 0; i < pixels_per_line * channels; i++) - { - *shading_data_ptr++ = 0x00; /* dark lo */ - *shading_data_ptr++ = 0x00; /* dark hi */ - *shading_data_ptr++ = 0x00; /* white lo */ - *shading_data_ptr++ = 0x40; /* white hi -> 0x4000 */ - } - - status = genesys_send_offset_and_shading (dev, - shading_data, - pixels_per_line * 4 * channels); - free (shading_data); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "%s: failed to send shading data: %s\n", __func__, - sane_strstatus (status)); - } - - DBGCOMPLETED; - return status; -} - - -/* Find the position of the reference point: - takes gray level 8 bits data and find - first CCD usable pixel and top of scanning area */ -SANE_Status -sanei_genesys_search_reference_point (Genesys_Device * dev, uint8_t * data, - int start_pixel, int dpi, int width, - int height) -{ - int x, y; - int current, left, top = 0; - uint8_t *image; - int size, count; - int level = 80; /* edge threshold level */ - - /*sanity check */ - if ((width < 3) || (height < 3)) - return SANE_STATUS_INVAL; - - /* transformed image data */ - size = width * height; - image = malloc (size); - if (!image) - { - DBG (DBG_error, - "sanei_genesys_search_reference_point: failed to allocate memory\n"); - return SANE_STATUS_NO_MEM; - } - - /* laplace filter to denoise picture */ - memcpy (image, data, size); /* to initialize unprocessed part of the image buffer */ - for (y = 1; y < height - 1; y++) - for (x = 1; x < width - 1; x++) - { - image[y * width + x] = - (data[(y - 1) * width + x + 1] + 2 * data[(y - 1) * width + x] + - data[(y - 1) * width + x - 1] + 2 * data[y * width + x + 1] + - 4 * data[y * width + x] + 2 * data[y * width + x - 1] + - data[(y + 1) * width + x + 1] + 2 * data[(y + 1) * width + x] + - data[(y + 1) * width + x - 1]) / 16; - } - - memcpy (data, image, size); - if (DBG_LEVEL >= DBG_data) - sanei_genesys_write_pnm_file ("laplace.pnm", image, 8, 1, width, height); - - /* apply X direction sobel filter - -1 0 1 - -2 0 2 - -1 0 1 - and finds threshold level - */ - level = 0; - for (y = 2; y < height - 2; y++) - for (x = 2; x < width - 2; x++) - { - current = - data[(y - 1) * width + x + 1] - data[(y - 1) * width + x - 1] + - 2 * data[y * width + x + 1] - 2 * data[y * width + x - 1] + - data[(y + 1) * width + x + 1] - data[(y + 1) * width + x - 1]; - if (current < 0) - current = -current; - if (current > 255) - current = 255; - image[y * width + x] = current; - if (current > level) - level = current; - } - if (DBG_LEVEL >= DBG_data) - sanei_genesys_write_pnm_file ("xsobel.pnm", image, 8, 1, width, height); - - /* set up detection level */ - level = level / 3; - - /* find left black margin first - todo: search top before left - we average the result of N searches */ - left = 0; - count = 0; - for (y = 2; y < 11; y++) - { - x = 8; - while ((x < width / 2) && (image[y * width + x] < level)) - { - image[y * width + x] = 255; - x++; - } - count++; - left += x; - } - if (DBG_LEVEL >= DBG_data) - sanei_genesys_write_pnm_file ("detected-xsobel.pnm", image, 8, 1, width, - height); - left = left / count; - - /* turn it in CCD pixel at full sensor optical resolution */ - dev->sensor.CCD_start_xoffset = - start_pixel + (left * dev->sensor.optical_res) / dpi; - - /* find top edge by detecting black strip */ - /* apply Y direction sobel filter - -1 -2 -1 - 0 0 0 - 1 2 1 - */ - level = 0; - for (y = 2; y < height - 2; y++) - for (x = 2; x < width - 2; x++) - { - current = - -data[(y - 1) * width + x + 1] - 2 * data[(y - 1) * width + x] - - data[(y - 1) * width + x - 1] + data[(y + 1) * width + x + 1] + - 2 * data[(y + 1) * width + x] + data[(y + 1) * width + x - 1]; - if (current < 0) - current = -current; - if (current > 255) - current = 255; - image[y * width + x] = current; - if (current > level) - level = current; - } - if (DBG_LEVEL >= DBG_data) - sanei_genesys_write_pnm_file ("ysobel.pnm", image, 8, 1, width, height); - - /* set up detection level */ - level = level / 3; - - /* search top of horizontal black stripe : TODO yet another flag */ - if (dev->model->ccd_type == CCD_5345 - && dev->model->motor_type == MOTOR_5345) - { - top = 0; - count = 0; - for (x = width / 2; x < width - 1; x++) - { - y = 2; - while ((y < height) && (image[x + y * width] < level)) - { - image[y * width + x] = 255; - y++; - } - count++; - top += y; - } - if (DBG_LEVEL >= DBG_data) - sanei_genesys_write_pnm_file ("detected-ysobel.pnm", image, 8, 1, - width, height); - top = top / count; - - /* bottom of black stripe is of fixed witdh, this hardcoded value - * will be moved into device struct if more such values are needed */ - top += 10; - dev->model->y_offset_calib = SANE_FIX ((top * MM_PER_INCH) / dpi); - DBG (DBG_info, - "sanei_genesys_search_reference_point: black stripe y_offset = %f mm \n", - SANE_UNFIX (dev->model->y_offset_calib)); - } - - /* find white corner in dark area : TODO yet another flag */ - if ((dev->model->ccd_type == CCD_HP2300 - && dev->model->motor_type == MOTOR_HP2300) - || (dev->model->ccd_type == CCD_HP2400 - && dev->model->motor_type == MOTOR_HP2400) - || (dev->model->ccd_type == CCD_HP3670 - && dev->model->motor_type == MOTOR_HP3670)) - { - top = 0; - count = 0; - for (x = 10; x < 60; x++) - { - y = 2; - while ((y < height) && (image[x + y * width] < level)) - y++; - top += y; - count++; - } - top = top / count; - dev->model->y_offset_calib = SANE_FIX ((top * MM_PER_INCH) / dpi); - DBG (DBG_info, - "sanei_genesys_search_reference_point: white corner y_offset = %f mm\n", - SANE_UNFIX (dev->model->y_offset_calib)); - } - - free (image); - DBG (DBG_proc, - "sanei_genesys_search_reference_point: CCD_start_xoffset = %d, left = %d, top = %d\n", - dev->sensor.CCD_start_xoffset, left, top); - - return SANE_STATUS_GOOD; -} - - -void -sanei_genesys_calculate_zmode2 (SANE_Bool two_table, - uint32_t exposure_time, - uint16_t * slope_table, - int reg21, - int move, int reg22, uint32_t * z1, - uint32_t * z2) -{ - int i; - int sum; - DBG (DBG_info, "sanei_genesys_calculate_zmode2: two_table=%d\n", two_table); - - /* acceleration total time */ - sum = 0; - for (i = 0; i < reg21; i++) - sum += slope_table[i]; - - /* compute Z1MOD */ - /* c=sum(slope_table;reg21) - d=reg22*cruising speed - Z1MOD=(c+d) % exposure_time */ - *z1 = (sum + reg22 * slope_table[reg21 - 1]) % exposure_time; - - /* compute Z2MOD */ - /* a=sum(slope_table;reg21), b=move or 1 if 2 tables */ - /* Z2MOD=(a+b) % exposure_time */ - if (!two_table) - sum = sum + (move * slope_table[reg21 - 1]); - else - sum = sum + slope_table[reg21 - 1]; - *z2 = sum % exposure_time; -} - - -/* huh? */ -/* todo: double check */ -/* Z1 and Z2 seem to be a time to synchronize with clock or a phase correction */ -/* steps_sum is the result of create_slope_table */ -/* last_speed is the last entry of the slope_table */ -/* feedl is registers 3d,3e,3f */ -/* fastfed is register 02 bit 3 */ -/* scanfed is register 1f */ -/* fwdstep is register 22 */ -/* tgtime is register 6c bit 6+7 >> 6 */ - -void -sanei_genesys_calculate_zmode (uint32_t exposure_time, - uint32_t steps_sum, uint16_t last_speed, - uint32_t feedl, uint8_t fastfed, - uint8_t scanfed, uint8_t fwdstep, - uint8_t tgtime, uint32_t * z1, uint32_t * z2) -{ - uint8_t exposure_factor; - - exposure_factor = pow (2, tgtime); /* todo: originally, this is always 2^0 ! */ - - /* Z1 is for buffer-full backward forward moving */ - *z1 = - exposure_factor * ((steps_sum + fwdstep * last_speed) % exposure_time); - - /* Z2 is for acceleration before scan */ - if (fastfed) /* two curve mode */ - { - *z2 = - exposure_factor * ((steps_sum + scanfed * last_speed) % - exposure_time); - } - else /* one curve mode */ - { - *z2 = - exposure_factor * ((steps_sum + feedl * last_speed) % exposure_time); - } -} - - -static void -genesys_adjust_gain (double *applied_multi, - uint8_t * new_gain, double multi, uint8_t gain) -{ - double voltage, original_voltage; - - DBG (DBG_proc, "genesys_adjust_gain: multi=%f, gain=%d\n", multi, gain); - - voltage = 0.5 + gain * 0.25; - original_voltage = voltage; - - voltage *= multi; - - *new_gain = (uint8_t) ((voltage - 0.5) * 4); - if (*new_gain > 0x0e) - *new_gain = 0x0e; - - voltage = 0.5 + (*new_gain) * 0.25; - - *applied_multi = voltage / original_voltage; - - DBG (DBG_proc, - "genesys_adjust_gain: orig voltage=%.2f, new voltage=%.2f, " - "*applied_multi=%f, *new_gain=%d\n", original_voltage, voltage, - *applied_multi, *new_gain); - return; -} - - -/* todo: is return status necessary (unchecked?) */ -static SANE_Status -genesys_average_white (Genesys_Device * dev, int channels, int channel, - uint8_t * data, int size, int *max_average) -{ - int gain_white_ref, sum, range; - int average; - int i; - - DBG (DBG_proc, - "genesys_average_white: channels=%d, channel=%d, size=%d\n", - channels, channel, size); - - range = size / 50; - - if (dev->settings.scan_method == SCAN_METHOD_TRANSPARENCY) /* transparency mode */ - gain_white_ref = dev->sensor.fau_gain_white_ref * 256; - else - gain_white_ref = dev->sensor.gain_white_ref * 256; - - if (range < 1) - range = 1; - - size = size / (2 * range * channels); - - data += (channel * 2); - - *max_average = 0; - - while (size--) - { - sum = 0; - for (i = 0; i < range; i++) - { - sum += (*data); - sum += *(data + 1) * 256; - data += (2 * channels); /* byte based */ - } - - average = (sum / range); - if (average > *max_average) - *max_average = average; - } - - DBG (DBG_proc, - "genesys_average_white: max_average=%d, gain_white_ref = %d, finished\n", - *max_average, gain_white_ref); - - if (*max_average >= gain_white_ref) - return SANE_STATUS_INVAL; - - return SANE_STATUS_GOOD; -} - -/* todo: understand, values are too high */ -static int -genesys_average_black (Genesys_Device * dev, int channel, - uint8_t * data, int pixels) -{ - int i; - int sum; - int pixel_step; - - DBG (DBG_proc, "genesys_average_black: channel=%d, pixels=%d\n", - channel, pixels); - - sum = 0; - - if (dev->settings.scan_mode == SCAN_MODE_COLOR) /* single pass color */ - { - data += (channel * 2); - pixel_step = 3 * 2; - } - else - { - pixel_step = 2; - } - - for (i = 0; i < pixels; i++) - { - sum += *data; - sum += *(data + 1) * 256; - - data += pixel_step; - } - - DBG (DBG_proc, "genesys_average_black = %d\n", sum / pixels); - - return (int) (sum / pixels); -} - - -/* todo: check; it works but the lines 1, 2, and 3 are too dark even with the - same offset and gain settings? */ -static SANE_Status -genesys_coarse_calibration (Genesys_Device * dev) -{ - int size; - int black_pixels; - int white_average; - int channels; - SANE_Status status; - uint8_t offset[4] = { 0xa0, 0x00, 0xa0, 0x40 }; /* first value isn't used */ - uint16_t white[12], dark[12]; - int i, j; - uint8_t *calibration_data, *all_data; - - DBG (DBG_info, "genesys_coarse_calibration (scan_mode = %d)\n", - dev->settings.scan_mode); - - black_pixels = dev->sensor.black_pixels - * dev->settings.xres / dev->sensor.optical_res; - - if (dev->settings.scan_mode == SCAN_MODE_COLOR) /* single pass color */ - channels = 3; - else - channels = 1; - - DBG (DBG_info, "channels %d y_size %d xres %d\n", - channels, dev->model->y_size, dev->settings.xres); - size = - channels * 2 * SANE_UNFIX (dev->model->y_size) * dev->settings.xres / - 25.4; - /* 1 1 mm 1/inch inch/mm */ - - calibration_data = malloc (size); - if (!calibration_data) - { - DBG (DBG_error, - "genesys_coarse_calibration: failed to allocate memory(%d bytes)\n", - size); - return SANE_STATUS_NO_MEM; - } - - all_data = calloc (1, size * 4); - - status = dev->model->cmd_set->set_fe (dev, AFE_INIT); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "%s: failed to set frontend: %s\n", __func__, - sane_strstatus (status)); - free(all_data); - free(calibration_data); - return status; - } - - dev->frontend.sign[0] = 0; - dev->frontend.sign[1] = 0; - dev->frontend.sign[2] = 0; - dev->frontend.gain[0] = 2; - dev->frontend.gain[1] = 2; - dev->frontend.gain[2] = 2; /* todo: ? was 2 */ - dev->frontend.offset[0] = offset[0]; - dev->frontend.offset[1] = offset[0]; - dev->frontend.offset[2] = offset[0]; - - for (i = 0; i < 4; i++) /* read 4 lines */ - { - if (i < 3) /* first 3 lines */ - { - dev->frontend.offset[0] = offset[i]; - dev->frontend.offset[1] = offset[i]; - dev->frontend.offset[2] = offset[i]; - } - - if (i == 1) /* second line */ - { - double applied_multi; - double gain_white_ref; - - if (dev->settings.scan_method == SCAN_METHOD_TRANSPARENCY) /* Transparency */ - gain_white_ref = dev->sensor.fau_gain_white_ref * 256; - else - gain_white_ref = dev->sensor.gain_white_ref * 256; - /* white and black are defined downwards */ - - genesys_adjust_gain (&applied_multi, - &dev->frontend.gain[0], - gain_white_ref / (white[0] - dark[0]), - dev->frontend.gain[0]); - genesys_adjust_gain (&applied_multi, - &dev->frontend.gain[1], - gain_white_ref / (white[1] - dark[1]), - dev->frontend.gain[1]); - genesys_adjust_gain (&applied_multi, - &dev->frontend.gain[2], - gain_white_ref / (white[2] - dark[2]), - dev->frontend.gain[2]); - - dev->frontend.gain[0] = dev->frontend.gain[1] = - dev->frontend.gain[2] = 2; - - status = - sanei_genesys_fe_write_data (dev, 0x28, dev->frontend.gain[0]); - if (status != SANE_STATUS_GOOD) /* todo: this was 0x28 + 3 ? */ - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to write gain[0]: %s\n", - sane_strstatus (status)); - return status; - } - - status = - sanei_genesys_fe_write_data (dev, 0x29, dev->frontend.gain[1]); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to write gain[1]: %s\n", - sane_strstatus (status)); - return status; - } - - status = - sanei_genesys_fe_write_data (dev, 0x2a, dev->frontend.gain[2]); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to write gain[2]: %s\n", - sane_strstatus (status)); - return status; - } - } - - if (i == 3) /* last line */ - { - double x, y, rate; - - for (j = 0; j < 3; j++) - { - - x = - (double) (dark[(i - 2) * 3 + j] - - dark[(i - 1) * 3 + j]) * 254 / (offset[i - 1] / 2 - - offset[i - 2] / 2); - y = x - x * (offset[i - 1] / 2) / 254 - dark[(i - 1) * 3 + j]; - rate = (x - DARK_VALUE - y) * 254 / x + 0.5; - - dev->frontend.offset[j] = (uint8_t) (rate); - - if (dev->frontend.offset[j] > 0x7f) - dev->frontend.offset[j] = 0x7f; - dev->frontend.offset[j] <<= 1; - } - } - status = - sanei_genesys_fe_write_data (dev, 0x20, dev->frontend.offset[0]); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to write offset[0]: %s\n", - sane_strstatus (status)); - return status; - } - - status = - sanei_genesys_fe_write_data (dev, 0x21, dev->frontend.offset[1]); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to write offset[1]: %s\n", - sane_strstatus (status)); - return status; - } - - status = - sanei_genesys_fe_write_data (dev, 0x22, dev->frontend.offset[2]); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to write offset[2]: %s\n", - sane_strstatus (status)); - return status; - } - - DBG (DBG_info, - "genesys_coarse_calibration: doing scan: sign: %d/%d/%d, gain: %d/%d/%d, offset: %d/%d/%d\n", - dev->frontend.sign[0], dev->frontend.sign[1], - dev->frontend.sign[2], dev->frontend.gain[0], - dev->frontend.gain[1], dev->frontend.gain[2], - dev->frontend.offset[0], dev->frontend.offset[1], - dev->frontend.offset[2]); - - status = - dev->model->cmd_set->begin_scan (dev, dev->calib_reg, SANE_FALSE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to begin scan: %s\n", - sane_strstatus (status)); - return status; - } - - status = - sanei_genesys_read_data_from_scanner (dev, calibration_data, size); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to read data: %s\n", - sane_strstatus (status)); - return status; - } - - memcpy (all_data + i * size, calibration_data, size); - if (i == 3) /* last line */ - { - SANE_Byte *all_data_8 = malloc (size * 4 / 2); - unsigned int count; - - for (count = 0; count < (unsigned int) (size * 4 / 2); count++) - all_data_8[count] = all_data[count * 2 + 1]; - status = - sanei_genesys_write_pnm_file ("coarse.pnm", all_data_8, 8, - channels, size / 6, 4); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: sanei_genesys_write_pnm_file failed: %s\n", - sane_strstatus (status)); - return status; - } - } - - status = dev->model->cmd_set->end_scan (dev, dev->calib_reg, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_coarse_calibration: Failed to end scan: %s\n", - sane_strstatus (status)); - return status; - } - if (dev->settings.scan_mode == SCAN_MODE_COLOR) /* single pass color */ - { - for (j = 0; j < 3; j++) - { - genesys_average_white (dev, 3, j, calibration_data, size, - &white_average); - white[i * 3 + j] = white_average; - dark[i * 3 + j] = - genesys_average_black (dev, j, calibration_data, - black_pixels); - DBG (DBG_info, - "genesys_coarse_calibration: white[%d]=%d, black[%d]=%d\n", - i * 3 + j, white[i * 3 + j], i * 3 + j, dark[i * 3 + j]); - } - } - else /* one color-component modes */ - { - genesys_average_white (dev, 1, 0, calibration_data, size, - &white_average); - white[i * 3 + 0] = white[i * 3 + 1] = white[i * 3 + 2] = - white_average; - dark[i * 3 + 0] = dark[i * 3 + 1] = dark[i * 3 + 2] = - genesys_average_black (dev, 0, calibration_data, black_pixels); - } - - if (i == 3) - { - if (dev->settings.scan_mode == SCAN_MODE_COLOR) /* single pass color */ - { - /* todo: huh? */ - dev->dark[0] = - (uint16_t) (1.6925 * dark[i * 3 + 0] + 0.1895 * 256); - dev->dark[1] = - (uint16_t) (1.4013 * dark[i * 3 + 1] + 0.3147 * 256); - dev->dark[2] = - (uint16_t) (1.2931 * dark[i * 3 + 2] + 0.1558 * 256); - } - else /* one color-component modes */ - { - switch (dev->settings.color_filter) - { - case 0: - default: - dev->dark[0] = - (uint16_t) (1.6925 * dark[i * 3 + 0] + - (1.1895 - 1.0) * 256); - dev->dark[1] = dev->dark[2] = dev->dark[0]; - break; - - case 1: - dev->dark[1] = - (uint16_t) (1.4013 * dark[i * 3 + 1] + - (1.3147 - 1.0) * 256); - dev->dark[0] = dev->dark[2] = dev->dark[1]; - break; - - case 2: - dev->dark[2] = - (uint16_t) (1.2931 * dark[i * 3 + 2] + - (1.1558 - 1.0) * 256); - dev->dark[0] = dev->dark[1] = dev->dark[2]; - break; - } - } - } - } /* for (i = 0; i < 4; i++) */ - - free(all_data); - DBG (DBG_info, - "genesys_coarse_calibration: final: sign: %d/%d/%d, gain: %d/%d/%d, offset: %d/%d/%d\n", - dev->frontend.sign[0], dev->frontend.sign[1], dev->frontend.sign[2], - dev->frontend.gain[0], dev->frontend.gain[1], dev->frontend.gain[2], - dev->frontend.offset[0], dev->frontend.offset[1], - dev->frontend.offset[2]); - DBGCOMPLETED; - - return status; -} - -/* Averages image data. - average_data and calibration_data are little endian 16 bit words. - */ -#ifndef UNIT_TESTING -static -#endif -void -genesys_average_data (uint8_t * average_data, - uint8_t * calibration_data, - uint32_t lines, - uint32_t pixel_components_per_line) -{ - uint32_t x, y; - uint32_t sum; - - for (x = 0; x < pixel_components_per_line; x++) - { - sum = 0; - for (y = 0; y < lines; y++) - { - sum += calibration_data[(x + y * pixel_components_per_line) * 2]; - sum += - calibration_data[(x + y * pixel_components_per_line) * 2 + - 1] * 256; - } - sum /= lines; - *average_data++ = sum & 255; - *average_data++ = sum / 256; - } -} - -/** - * scans a white area with motor and lamp off to get the per CCD pixel offset - * that will be used to compute shading coefficient - * @param dev scanner's device - * @return SANE_STATUS_GOOD if OK, else an error - */ -static SANE_Status -genesys_dark_shading_calibration (Genesys_Device * dev) -{ - SANE_Status status; - size_t size; - uint32_t pixels_per_line; - uint8_t channels; - uint8_t *calibration_data; - SANE_Bool motor; - - DBGSTART; - - /* end pixel - start pixel */ - pixels_per_line = dev->calib_pixels; - channels = dev->calib_channels; - - FREE_IFNOT_NULL (dev->dark_average_data); - - dev->average_size = channels * 2 * pixels_per_line; - - dev->dark_average_data = malloc (dev->average_size); - if (!dev->dark_average_data) - { - DBG (DBG_error, - "genesys_dark_shading_calibration: failed to allocate average memory\n"); - return SANE_STATUS_NO_MEM; - } - - /* size is size in bytes for scanarea: bytes_per_line * lines */ - size = channels * 2 * pixels_per_line * (dev->calib_lines + 1); - - calibration_data = malloc (size); - if (!calibration_data) - { - DBG (DBG_error, - "genesys_dark_shading_calibration: failed to allocate calibration data memory\n"); - return SANE_STATUS_NO_MEM; - } - - motor=SANE_TRUE; - if (dev->model->flags & GENESYS_FLAG_SHADING_NO_MOVE) - { - motor=SANE_FALSE; - } - - /* turn off motor and lamp power for flatbed scanners, but not for sheetfed scanners - * because they have a calibration sheet with a sufficient black strip */ - if (dev->model->is_sheetfed == SANE_FALSE) - { - dev->model->cmd_set->set_lamp_power (dev, dev->calib_reg, SANE_FALSE); - dev->model->cmd_set->set_motor_power (dev->calib_reg, motor); - } - else - { - dev->model->cmd_set->set_lamp_power (dev, dev->calib_reg, SANE_TRUE); - dev->model->cmd_set->set_motor_power (dev->calib_reg, motor); - } - - status = - dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, - dev->model-> - cmd_set->bulk_full_size ()); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, - "genesys_dark_shading_calibration: failed to bulk write registers: %s\n", - sane_strstatus (status)); - return status; - } - - usleep (200 * 1000); /* wait 200 ms: lamp needs some time to get dark */ - - status = dev->model->cmd_set->begin_scan (dev, dev->calib_reg, SANE_FALSE); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, - "genesys_dark_shading_calibration: Failed to begin scan: %s\n", - sane_strstatus (status)); - return status; - } - - status = sanei_genesys_read_data_from_scanner (dev, calibration_data, size); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, - "genesys_dark_shading_calibration: failed to read data: %s\n", - sane_strstatus (status)); - return status; - } - - status = dev->model->cmd_set->end_scan (dev, dev->calib_reg, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, - "genesys_dark_shading_calibration: failed to end scan: %s\n", - sane_strstatus (status)); - return status; - } - - genesys_average_data (dev->dark_average_data, calibration_data, - dev->calib_lines, - pixels_per_line * channels); - - if (DBG_LEVEL >= DBG_data) - { - sanei_genesys_write_pnm_file ("black_shading.pnm", calibration_data, 16, - channels, pixels_per_line, - dev->calib_lines); - sanei_genesys_write_pnm_file ("black_average.pnm", - dev->dark_average_data, 16, channels, - pixels_per_line, 1); - } - - free (calibration_data); - - DBGCOMPLETED; - - return SANE_STATUS_GOOD; -} - -/* - * this function builds dummy dark calibration data so that we can - * compute shading coefficient in a clean way - * todo: current values are hardcoded, we have to find if they - * can be computed from previous calibration data (when doing offset - * calibration ?) - */ -static SANE_Status -genesys_dummy_dark_shading (Genesys_Device * dev) -{ - uint32_t pixels_per_line; - uint8_t channels; - uint32_t x, skip, xend; - int dummy1, dummy2, dummy3; /* dummy black average per channel */ - - DBGSTART; - - pixels_per_line = dev->calib_pixels; - channels = dev->calib_channels; - - FREE_IFNOT_NULL (dev->dark_average_data); - - dev->average_size = channels * 2 * pixels_per_line; - dev->dark_average_data = malloc (dev->average_size); - if (!dev->dark_average_data) - { - DBG (DBG_error, - "genesys_dummy_dark_shading: failed to allocate average memory\n"); - return SANE_STATUS_NO_MEM; - } - memset (dev->dark_average_data, 0x00, channels * 2 * pixels_per_line); - - /* we average values on 'the left' where CCD pixels are under casing and - give darkest values. We then use these as dummy dark calibration */ - if (dev->settings.xres <= dev->sensor.optical_res / 2) - { - skip = 4; - xend = 36; - } - else - { - skip = 4; - xend = 68; - } - if (dev->model->ccd_type==CCD_G4050 - || dev->model->ccd_type==CCD_CS4400F - || dev->model->ccd_type==CCD_CS8400F - || dev->model->ccd_type==CCD_KVSS080) - { - skip = 2; - xend = dev->sensor.black_pixels; - } - - /* average each channels on half left margin */ - dummy1 = 0; - dummy2 = 0; - dummy3 = 0; - - for (x = skip + 1; x <= xend; x++) - { - dummy1 += - dev->white_average_data[channels * 2 * x] + - 256 * dev->white_average_data[channels * 2 * x + 1]; - if (channels > 1) - { - dummy2 += - (dev->white_average_data[channels * 2 * x + 2] + - 256 * dev->white_average_data[channels * 2 * x + 3]); - dummy3 += - (dev->white_average_data[channels * 2 * x + 4] + - 256 * dev->white_average_data[channels * 2 * x + 5]); - } - } - - dummy1 /= (xend - skip); - if (channels > 1) - { - dummy2 /= (xend - skip); - dummy3 /= (xend - skip); - } - DBG (DBG_proc, - "genesys_dummy_dark_shading: dummy1=%d, dummy2=%d, dummy3=%d \n", - dummy1, dummy2, dummy3); - - /* fill dark_average */ - for (x = 0; x < pixels_per_line; x++) - { - dev->dark_average_data[channels * 2 * x] = dummy1 & 0xff; - dev->dark_average_data[channels * 2 * x + 1] = dummy1 >> 8; - if (channels > 1) - { - dev->dark_average_data[channels * 2 * x + 2] = dummy2 & 0xff; - dev->dark_average_data[channels * 2 * x + 3] = dummy2 >> 8; - dev->dark_average_data[channels * 2 * x + 4] = dummy3 & 0xff; - dev->dark_average_data[channels * 2 * x + 5] = dummy3 >> 8; - } - } - - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - - -static SANE_Status -genesys_white_shading_calibration (Genesys_Device * dev) -{ - SANE_Status status; - size_t size; - uint32_t pixels_per_line; - uint8_t *calibration_data; - uint8_t channels; - SANE_Bool motor; - - DBG (DBG_proc, "genesys_white_shading_calibration (lines = %d)\n", - (unsigned int)dev->calib_lines); - - pixels_per_line = dev->calib_pixels; - channels = dev->calib_channels; - - if (dev->white_average_data) - free (dev->white_average_data); - - dev->white_average_data = malloc (channels * 2 * pixels_per_line); - if (!dev->white_average_data) - { - DBG (DBG_error, - "genesys_white_shading_calibration: failed to allocate average memory\n"); - return SANE_STATUS_NO_MEM; - } - - size = channels * 2 * pixels_per_line * (dev->calib_lines + 1); - - calibration_data = malloc (size); - if (!calibration_data) - { - DBG (DBG_error, - "genesys_white_shading_calibration: failed to allocate calibration memory\n"); - return SANE_STATUS_NO_MEM; - } - - motor=SANE_TRUE; - if (dev->model->flags & GENESYS_FLAG_SHADING_NO_MOVE) - { - motor=SANE_FALSE; - } - - /* turn on motor and lamp power */ - dev->model->cmd_set->set_lamp_power (dev, dev->calib_reg, SANE_TRUE); - dev->model->cmd_set->set_motor_power (dev->calib_reg, motor); - - /* if needed, go back before doin next scan, by using rewind, registers and - * slopes table are kept intact from previous scan */ - if (dev->model->flags & GENESYS_FLAG_SHADING_REPARK && dev->model->cmd_set->rewind) - { - status = dev->model->cmd_set->rewind (dev); - } - - status = - dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, - dev->model-> - cmd_set->bulk_full_size ()); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, - "genesys_white_shading_calibration: failed to bulk write registers: %s\n", - sane_strstatus (status)); - return status; - } - - if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION) - usleep (500 * 1000); /* wait 500ms to make sure lamp is bright again */ - - status = dev->model->cmd_set->begin_scan (dev, dev->calib_reg, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, - "genesys_white_shading_calibration: Failed to begin scan: %s\n", - sane_strstatus (status)); - return status; - } - - status = sanei_genesys_read_data_from_scanner (dev, calibration_data, size); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, - "genesys_white_shading_calibration: failed to read data: %s\n", - sane_strstatus (status)); - return status; - } - - status = dev->model->cmd_set->end_scan (dev, dev->calib_reg, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, - "genesys_white_shading_calibration: failed to end scan: %s\n", - sane_strstatus (status)); - return status; - } - - if (DBG_LEVEL >= DBG_data) - sanei_genesys_write_pnm_file ("white_shading.pnm", calibration_data, 16, - channels, pixels_per_line, - dev->calib_lines); - - genesys_average_data (dev->white_average_data, calibration_data, - dev->calib_lines, - pixels_per_line * channels); - - if (DBG_LEVEL >= DBG_data) - sanei_genesys_write_pnm_file ("white_average.pnm", - dev->white_average_data, 16, channels, - pixels_per_line, 1); - - free (calibration_data); - - /* in case we haven't done dark calibration, build dummy data from white_average */ - if (!(dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)) - { - status = genesys_dummy_dark_shading (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_white_shading_calibration: failed to do dummy dark shading calibration: %s\n", - sane_strstatus (status)); - return status; - } - } - - if (dev->model->flags & GENESYS_FLAG_SHADING_REPARK) - { - status = dev->model->cmd_set->slow_back_home (dev, SANE_TRUE); - } - - DBGCOMPLETED; - - return status; -} - -/* This calibration uses a scan over the calibration target, comprising a - * black and a white strip. (So the motor must be on.) - */ -#ifndef UNIT_TESTING -static -#endif -SANE_Status -genesys_dark_white_shading_calibration (Genesys_Device * dev) -{ - SANE_Status status; - size_t size; - uint32_t pixels_per_line; - uint8_t *calibration_data, *average_white, *average_dark; - uint8_t channels; - unsigned int x; - int y; - uint32_t dark, white, dark_sum, white_sum, dark_count, white_count, col, - dif; - SANE_Bool motor; - - - DBG (DBG_proc, "%s: (lines = %d)\n", __func__, (unsigned int)dev->calib_lines); - - pixels_per_line = dev->calib_pixels; - channels = dev->calib_channels; - - if (dev->white_average_data) - free (dev->white_average_data); - - dev->average_size = channels * 2 * pixels_per_line; - - dev->white_average_data = malloc (dev->average_size); - if (!dev->white_average_data) - { - DBG (DBG_error, "%s: failed to allocate white average memory\n", __func__); - return SANE_STATUS_NO_MEM; - } - - if (dev->dark_average_data) - free (dev->dark_average_data); - - dev->dark_average_data = malloc (channels * 2 * pixels_per_line); - if (!dev->dark_average_data) - { - DBG (DBG_error, "%s: failed to allocate dark average memory\n", __func__); - return SANE_STATUS_NO_MEM; - } - - size = channels * 2 * pixels_per_line * dev->calib_lines; - - calibration_data = malloc (size); - if (!calibration_data) - { - DBG (DBG_error, "%s: failed to allocate calibration memory\n", __func__); - return SANE_STATUS_NO_MEM; - } - - motor=SANE_TRUE; - if (dev->model->flags & GENESYS_FLAG_SHADING_NO_MOVE) - { - motor=SANE_FALSE; - } - - /* turn on motor and lamp power */ - dev->model->cmd_set->set_lamp_power (dev, dev->calib_reg, SANE_TRUE); - dev->model->cmd_set->set_motor_power (dev->calib_reg, motor); - - status = - dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, - dev->model-> - cmd_set->bulk_full_size ()); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __func__, - sane_strstatus (status)); - return status; - } - - status = dev->model->cmd_set->begin_scan (dev, dev->calib_reg, SANE_FALSE); - - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, "%s: failed to begin scan: %s\n", __func__, - sane_strstatus (status)); - return status; - } - - status = sanei_genesys_read_data_from_scanner (dev, calibration_data, size); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, "%s: failed to read data: %s\n", __func__, - sane_strstatus (status)); - return status; - } - - status = dev->model->cmd_set->end_scan (dev, dev->calib_reg, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - free (calibration_data); - DBG (DBG_error, "%s: Failed to end scan: %s\n", __func__, - sane_strstatus (status)); - return status; - } - - if (DBG_LEVEL >= DBG_data) - { - if (dev->model->is_cis) - { - sanei_genesys_write_pnm_file ("black_white_shading.pnm", calibration_data, - 16, 1, pixels_per_line*channels, - dev->calib_lines); - } - else - { - sanei_genesys_write_pnm_file ("black_white_shading.pnm", calibration_data, - 16, channels, pixels_per_line, - dev->calib_lines); - } - } - - - average_white = dev->white_average_data; - average_dark = dev->dark_average_data; - - for (x = 0; x < pixels_per_line * channels; x++) - { - dark = 0xffff; - white = 0; - - for (y = 0; y < (int)dev->calib_lines; y++) - { - col = calibration_data[(x + y * pixels_per_line * channels) * 2]; - col |= - calibration_data[(x + y * pixels_per_line * channels) * 2 + - 1] << 8; - - if (col > white) - white = col; - if (col < dark) - dark = col; - } - - dif = white - dark; - - dark = dark + dif / 8; - white = white - dif / 8; - - dark_count = 0; - dark_sum = 0; - - white_count = 0; - white_sum = 0; - - for (y = 0; y < (int)dev->calib_lines; y++) - { - col = calibration_data[(x + y * pixels_per_line * channels) * 2]; - col |= - calibration_data[(x + y * pixels_per_line * channels) * 2 + - 1] << 8; - - if (col >= white) - { - white_sum += col; - white_count++; - } - if (col <= dark) - { - dark_sum += col; - dark_count++; - } - - } - - dark_sum /= dark_count; - white_sum /= white_count; - - *average_dark++ = dark_sum & 255; - *average_dark++ = dark_sum >> 8; - - *average_white++ = white_sum & 255; - *average_white++ = white_sum >> 8; - } - - if (DBG_LEVEL >= DBG_data) - { - sanei_genesys_write_pnm_file ("white_average.pnm", - dev->white_average_data, 16, channels, - pixels_per_line, 1); - sanei_genesys_write_pnm_file ("dark_average.pnm", - dev->dark_average_data, 16, channels, - pixels_per_line, 1); - } - - free (calibration_data); - - DBGCOMPLETED; - - return SANE_STATUS_GOOD; -} - -/* computes one coefficient given bright-dark value - * @param coeff factor giving 1.00 gain - * @param target desired target code - * @param value brght-dark value - * */ -static unsigned int -compute_coefficient (unsigned int coeff, unsigned int target, unsigned int value) -{ - int result; - - if (value > 0) - { - result = (coeff * target) / value; - if (result >= 65535) - { - result = 65535; - } - } - else - { - result = coeff; - } - return result; -} - -/** @brief compute shading coefficients for LiDE scanners - * The dark/white shading is actually performed _after_ reducing - * resolution via averaging. only dark/white shading data for what would be - * first pixel at full resolution is used. - * - * scanner raw input to output value calculation: - * o=(i-off)*(gain/coeff) - * - * from datasheet: - * off=dark_average - * gain=coeff*bright_target/(bright_average-dark_average) - * works for dark_target==0 - * - * what we want is these: - * bright_target=(bright_average-off)*(gain/coeff) - * dark_target=(dark_average-off)*(gain/coeff) - * leading to - * off = (dark_average*bright_target - bright_average*dark_target)/(bright_target - dark_target) - * gain = (bright_target - dark_target)/(bright_average - dark_average)*coeff - * - * @param dev scanner's device - * @param shading_data memory area where to store the computed shading coefficients - * @param pixels_per_line number of pixels per line - * @param words_per_color memory words per color channel - * @param channels number of color channels (actually 1 or 3) - * @param o shading coefficients left offset - * @param coeff 4000h or 2000h depending on fast scan mode or not (GAIN4 bit) - * @param target_bright value of the white target code - * @param target_dark value of the black target code -*/ -#ifndef UNIT_TESTING -static -#endif -void -compute_averaged_planar (Genesys_Device * dev, - uint8_t * shading_data, - unsigned int pixels_per_line, - unsigned int words_per_color, - unsigned int channels, - unsigned int o, - unsigned int coeff, - unsigned int target_bright, - unsigned int target_dark) -{ - unsigned int x, i, j, br, dk, res, avgpixels, basepixels, val; - unsigned int fill,factor; - - DBG (DBG_info, "%s: pixels=%d, offset=%d\n", __func__, pixels_per_line, o); - - /* initialize result */ - memset (shading_data, 0xff, words_per_color * 3 * 2); - - /* - strangely i can write 0x20000 bytes beginning at 0x00000 without overwriting - slope tables - which begin at address 0x10000(for 1200dpi hw mode): - memory is organized in words(2 bytes) instead of single bytes. explains - quite some things - */ -/* - another one: the dark/white shading is actually performed _after_ reducing - resolution via averaging. only dark/white shading data for what would be - first pixel at full resolution is used. - */ -/* - scanner raw input to output value calculation: - o=(i-off)*(gain/coeff) - - from datasheet: - off=dark_average - gain=coeff*bright_target/(bright_average-dark_average) - works for dark_target==0 - - what we want is these: - bright_target=(bright_average-off)*(gain/coeff) - dark_target=(dark_average-off)*(gain/coeff) - leading to - off = (dark_average*bright_target - bright_average*dark_target)/(bright_target - dark_target) - gain = (bright_target - dark_target)/(bright_average - dark_average)*coeff - */ - res = dev->settings.xres; - - /* duplicate half-ccd logic */ - if ((dev->model->flags & GENESYS_FLAG_HALF_CCD_MODE) && - dev->settings.xres <= dev->sensor.optical_res / 2) - res *= 2; - - /* this should be evenly dividable */ - basepixels = dev->sensor.optical_res / res; - - /* gl841 supports 1/1 1/2 1/3 1/4 1/5 1/6 1/8 1/10 1/12 1/15 averaging */ - if (basepixels < 1) - avgpixels = 1; - else if (basepixels < 6) - avgpixels = basepixels; - else if (basepixels < 8) - avgpixels = 6; - else if (basepixels < 10) - avgpixels = 8; - else if (basepixels < 12) - avgpixels = 10; - else if (basepixels < 15) - avgpixels = 12; - else - avgpixels = 15; - - /* LiDE80 packs shading data */ - if(dev->model->ccd_type != CIS_CANONLIDE80) - { - factor=1; - fill=avgpixels; - } - else - { - factor=avgpixels; - fill=1; - } - - DBG (DBG_info, "%s: averaging over %d pixels\n", __func__, avgpixels); - DBG (DBG_info, "%s: packing factor is %d\n", __func__, factor); - DBG (DBG_info, "%s: fill length is %d\n", __func__, fill); - - for (x = 0; x <= pixels_per_line - avgpixels; x += avgpixels) - { - if ((x + o) * 2 * 2 + 3 > words_per_color * 2) - break; - - for (j = 0; j < channels; j++) - { - - dk = 0; - br = 0; - for (i = 0; i < avgpixels; i++) - { - /* dark data */ - dk += - (dev->dark_average_data[(x + i + - pixels_per_line * j) * - 2] | - (dev->dark_average_data - [(x + i + pixels_per_line * j) * 2 + 1] << 8)); - - /* white data */ - br += - (dev->white_average_data[(x + i + - pixels_per_line * j) * - 2] | - (dev->white_average_data - [(x + i + pixels_per_line * j) * 2 + 1] << 8)); - } - - br /= avgpixels; - dk /= avgpixels; - - if (br * target_dark > dk * target_bright) - val = 0; - else if (dk * target_bright - br * target_dark > - 65535 * (target_bright - target_dark)) - val = 65535; - else - { - val = (dk * target_bright - br * target_dark) / (target_bright - target_dark); - } - - /*fill all pixels, even if only the last one is relevant*/ - for (i = 0; i < fill; i++) - { - shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j] = val & 0xff; - shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 1] = val >> 8; - } - - val = br - dk; - - if (65535 * val > (target_bright - target_dark) * coeff) - { - val = (coeff * (target_bright - target_dark)) / val; - } - else - { - val = 65535; - } - - /*fill all pixels, even if only the last one is relevant*/ - for (i = 0; i < fill; i++) - { - shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 2] = val & 0xff; - shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 3] = val >> 8; - } - } - - /* fill remaining channels */ - for (j = channels; j < 3; j++) - { - for (i = 0; i < fill; i++) - { - shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j ] = shading_data[(x/factor + o + i) * 2 * 2 ]; - shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 1] = shading_data[(x/factor + o + i) * 2 * 2 + 1]; - shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 2] = shading_data[(x/factor + o + i) * 2 * 2 + 2]; - shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 3] = shading_data[(x/factor + o + i) * 2 * 2 + 3]; - } - } - } -} - -/** - * Computes shading coefficient using formula in data sheet. 16bit data values - * manipulated here are little endian. For now we assume deletion scanning type - * and that there is always 3 channels. - * @param dev scanner's device - * @param shading_data memory area where to store the computed shading coefficients - * @param pixels_per_line number of pixels per line - * @param channels number of color channels (actually 1 or 3) - * @param cmat color transposition matrix - * @param offset shading coefficients left offset - * @param coeff 4000h or 2000h depending on fast scan mode or not - * @param target value of the target code - */ -#ifndef UNIT_TESTING -static -#endif -void -compute_coefficients (Genesys_Device * dev, - uint8_t * shading_data, - unsigned int pixels_per_line, - unsigned int channels, - unsigned int cmat[3], - int offset, - unsigned int coeff, - unsigned int target) -{ - uint8_t *ptr; /* contain 16bit words in little endian */ - unsigned int x, c; - unsigned int val, br, dk; - unsigned int start, end; - - DBG (DBG_io, - "compute_coefficients: pixels_per_line=%d, coeff=0x%04x\n", pixels_per_line, coeff); - - /* compute start & end values depending of the offset */ - if (offset < 0) - { - start = -1 * offset; - end = pixels_per_line; - } - else - { - start = 0; - end = pixels_per_line - offset; - } - - for (c = 0; c < channels; c++) - { - for (x = start; x < end; x++) - { - /* TODO if channels=1 , use filter to know the base addr */ - ptr = shading_data + 4 * ((x + offset) * channels + cmat[c]); - - /* dark data */ - dk = dev->dark_average_data[x * 2 * channels + c * 2]; - dk += 256 * dev->dark_average_data[x * 2 * channels + c * 2 + 1]; - - /* white data */ - br = dev->white_average_data[x * 2 * channels + c * 2]; - br += 256 * dev->white_average_data[x * 2 * channels + c * 2 + 1]; - - /* compute coeff */ - val=compute_coefficient(coeff,target,br-dk); - - /* assign it */ - ptr[0] = dk & 255; - ptr[1] = dk / 256; - ptr[2] = val & 0xff; - ptr[3] = val / 256; - - } - } -} - -/** - * Computes shading coefficient using formula in data sheet. 16bit data values - * manipulated here are little endian. Data is in planar form, ie grouped by - * lines of the same color component. - * @param dev scanner's device - * @param shading_data memory area where to store the computed shading coefficients - * @param factor averaging factor when the calibration scan is done at a higher resolution - * than the final scan - * @param pixels_per_line number of pixels per line - * @param words_per_color total number of shading data words for one color element - * @param channels number of color channels (actually 1 or 3) - * @param cmat transcoding matrix for color channel order - * @param offset shading coefficients left offset - * @param coeff 4000h or 2000h depending on fast scan mode or not - * @param target white target value - */ -#ifndef UNIT_TESTING -static -#endif -void -compute_planar_coefficients (Genesys_Device * dev, - uint8_t * shading_data, - unsigned int factor, - unsigned int pixels_per_line, - unsigned int words_per_color, - unsigned int channels, - unsigned int cmat[3], - unsigned int offset, - unsigned int coeff, - unsigned int target) -{ - uint8_t *ptr; /* contains 16bit words in little endian */ - uint32_t x, c, i; - uint32_t val, dk, br; - - DBG (DBG_io, - "compute_planar_coefficients: factor=%d, pixels_per_line=%d, words=0x%X, coeff=0x%04x\n", factor, - pixels_per_line, words_per_color, coeff); - for (c = 0; c < channels; c++) - { - /* shading data is larger than pixels_per_line so offset can be neglected */ - for (x = 0; x < pixels_per_line; x+=factor) - { - /* x2 because of 16 bit values, and x2 since one coeff for dark - * and another for white */ - ptr = shading_data + words_per_color * cmat[c] * 2 + (x + offset) * 4; - - dk = 0; - br = 0; - - /* average case */ - for(i=0;i<factor;i++) - { - dk += - 256 * dev->dark_average_data[((x+i) + pixels_per_line * c) * 2 + 1]; - dk += dev->dark_average_data[((x+i) + pixels_per_line * c) * 2]; - br += - 256 * dev->white_average_data[((x+i) + pixels_per_line * c) * 2 + 1]; - br += dev->white_average_data[((x+i) + pixels_per_line * c) * 2]; - } - dk /= factor; - br /= factor; - - val = compute_coefficient (coeff, target, br - dk); - - /* we duplicate the information to have calibration data at optical resolution */ - for (i = 0; i < factor; i++) - { - ptr[0 + 4 * i] = dk & 255; - ptr[1 + 4 * i] = dk / 256; - ptr[2 + 4 * i] = val & 0xff; - ptr[3 + 4 * i] = val / 256; - } - } - } - /* in case of gray level scan, we duplicate shading information on all - * three color channels */ - if(channels==1) - { - memcpy(shading_data+cmat[1]*2*words_per_color, - shading_data+cmat[0]*2*words_per_color, - words_per_color*2); - memcpy(shading_data+cmat[2]*2*words_per_color, - shading_data+cmat[0]*2*words_per_color, - words_per_color*2); - } -} - -#ifndef UNIT_TESTING -static -#endif -void -compute_shifted_coefficients (Genesys_Device * dev, - uint8_t * shading_data, - unsigned int pixels_per_line, - unsigned int channels, - unsigned int cmat[3], - int offset, - unsigned int coeff, - unsigned int target_dark, - unsigned int target_bright, - unsigned int patch_size) /* contigous extent */ -{ - unsigned int x, avgpixels, basepixels, i, j, val1, val2; - unsigned int br_tmp [3], dk_tmp [3]; - uint8_t *ptr = shading_data + offset * 3 * 4; /* contain 16bit words in little endian */ - unsigned int patch_cnt = offset * 3; /* at start, offset of first patch */ - - x = dev->settings.xres; - if ((dev->model->flags & GENESYS_FLAG_HALF_CCD_MODE) && - (dev->settings.xres <= dev->sensor.optical_res / 2)) - x *= 2; /* scanner is using half-ccd mode */ - basepixels = dev->sensor.optical_res / x; /*this should be evenly dividable */ - - /* gl841 supports 1/1 1/2 1/3 1/4 1/5 1/6 1/8 1/10 1/12 1/15 averaging */ - if (basepixels < 1) - avgpixels = 1; - else if (basepixels < 6) - avgpixels = basepixels; - else if (basepixels < 8) - avgpixels = 6; - else if (basepixels < 10) - avgpixels = 8; - else if (basepixels < 12) - avgpixels = 10; - else if (basepixels < 15) - avgpixels = 12; - else - avgpixels = 15; - DBG (DBG_info, "compute_shifted_coefficients: pixels_per_line=%d, coeff=0x%04x, averaging over %d pixels\n", pixels_per_line, coeff, avgpixels); - - for (x = 0; x <= pixels_per_line - avgpixels; x += avgpixels) { - memset (&br_tmp, 0, sizeof(br_tmp)); - memset (&dk_tmp, 0, sizeof(dk_tmp)); - - for (i = 0; i < avgpixels; i++) { - for (j = 0; j < channels; j++) { - br_tmp[j] += (dev->white_average_data[((x + i) * channels + j) * 2] | - (dev->white_average_data[((x + i) * channels + j) * 2 + 1] << 8)); - dk_tmp[i] += (dev->dark_average_data[((x + i) * channels + j) * 2] | - (dev->dark_average_data[((x + i) * channels + j) * 2 + 1] << 8)); - } - } - for (j = 0; j < channels; j++) { - br_tmp[j] /= avgpixels; - dk_tmp[j] /= avgpixels; - - if (br_tmp[j] * target_dark > dk_tmp[j] * target_bright) - val1 = 0; - else if (dk_tmp[j] * target_bright - br_tmp[j] * target_dark > 65535 * (target_bright - target_dark)) - val1 = 65535; - else - val1 = (dk_tmp[j] * target_bright - br_tmp[j] * target_dark) / (target_bright - target_dark); - - val2 = br_tmp[j] - dk_tmp[j]; - if (65535 * val2 > (target_bright - target_dark) * coeff) - val2 = (coeff * (target_bright - target_dark)) / val2; - else - val2 = 65535; - - br_tmp[j] = val1; - dk_tmp[j] = val2; - } - for (i = 0; i < avgpixels; i++) { - for (j = 0; j < channels; j++) { - * ptr++ = br_tmp[ cmat[j] ] & 0xff; - * ptr++ = br_tmp[ cmat[j] ] >> 8; - * ptr++ = dk_tmp[ cmat[j] ] & 0xff; - * ptr++ = dk_tmp[ cmat[j] ] >> 8; - patch_cnt++; - if (patch_cnt == patch_size) { - patch_cnt = 0; - val1 = cmat[2]; - cmat[2] = cmat[1]; - cmat[1] = cmat[0]; - cmat[0] = val1; - } - } - } - } -} - -GENESYS_STATIC SANE_Status -genesys_send_shading_coefficient (Genesys_Device * dev) -{ - SANE_Status status; - uint32_t pixels_per_line; - uint8_t *shading_data; /**> contains 16bit words in little endian */ - uint8_t channels; - int o; - unsigned int length; /**> number of shading calibration data words */ - unsigned int factor; - unsigned int cmat[3]; /**> matrix of color channels */ - unsigned int coeff, target_code, words_per_color = 0; - - DBGSTART; - - pixels_per_line = dev->calib_pixels; - channels = dev->calib_channels; - - /* we always build data for three channels, even for gray - * we make the shading data such that each color channel data line is contiguous - * to the next one, which allow to write the 3 channels in 1 write - * during genesys_send_shading_coefficient, some values are words, other bytes - * hence the x2 factor */ - switch (sanei_genesys_read_reg_from_set (dev->reg, 0x05) >> 6) - { - /* 600 dpi */ - case 0: - words_per_color = 0x2a00; - break; - /* 1200 dpi */ - case 1: - words_per_color = 0x5500; - break; - /* 2400 dpi */ - case 2: - words_per_color = 0xa800; - break; - /* 4800 dpi */ - case 3: - words_per_color = 0x15000; - break; - } - - /* special case, memory is aligned on 0x5400, this has yet to be explained */ - /* could be 0xa800 because sensor is truly 2400 dpi, then halved because - * we only set 1200 dpi */ - if(dev->model->ccd_type==CIS_CANONLIDE80) - { - words_per_color = 0x5400; - } - - length = words_per_color * 3 * 2; - - /* allocate computed size */ - shading_data = malloc (length); - if (!shading_data) - { - DBG (DBG_error, "%s: failed to allocate memory\n", __func__); - return SANE_STATUS_NO_MEM; - } - memset (shading_data, 0, length); - - /* TARGET/(Wn-Dn) = white gain -> ~1.xxx then it is multiplied by 0x2000 - or 0x4000 to give an integer - Wn = white average for column n - Dn = dark average for column n - */ - if (dev->model->cmd_set->get_gain4_bit (dev->calib_reg)) - coeff = 0x4000; - else - coeff = 0x2000; - - /* compute avg factor */ - if(dev->settings.xres>dev->sensor.optical_res) - { - factor=1; - } - else - { - factor=dev->sensor.optical_res/dev->settings.xres; - } - - /* for GL646, shading data is planar if REG01_FASTMOD is set and - * chunky if not. For now we rely on the fact that we know that - * each sensor is used only in one mode. Currently only the CIS_XP200 - * sets REG01_FASTMOD. - */ - - /* TODO setup a struct in genesys_devices that - * will handle these settings instead of having this switch growing up */ - cmat[0] = 0; - cmat[1] = 1; - cmat[2] = 2; - switch (dev->model->ccd_type) - { - case CCD_XP300: - case CCD_ROADWARRIOR: - case CCD_DP665: - case CCD_DP685: - case CCD_DSMOBILE600: - target_code = 0xdc00; - o = 4; - compute_planar_coefficients (dev, - shading_data, - factor, - pixels_per_line, - words_per_color, - channels, - cmat, - o, - coeff, - target_code); - break; - case CIS_XP200: - target_code = 0xdc00; - o = 2; - cmat[0] = 2; /* red is last */ - cmat[1] = 0; /* green is first */ - cmat[2] = 1; /* blue is second */ - compute_planar_coefficients (dev, - shading_data, - 1, - pixels_per_line, - words_per_color, - channels, - cmat, - o, - coeff, - target_code); - break; - case CCD_HP2300: - target_code = 0xdc00; - o = 2; - if(dev->settings.xres<=dev->sensor.optical_res/2) - { - o = o - dev->sensor.dummy_pixel / 2; - } - compute_coefficients (dev, - shading_data, - pixels_per_line, - 3, - cmat, - o, - coeff, - target_code); - break; - case CCD_5345: - target_code = 0xe000; - o = 4; - if(dev->settings.xres<=dev->sensor.optical_res/2) - { - o = o - dev->sensor.dummy_pixel; - } - compute_coefficients (dev, - shading_data, - pixels_per_line, - 3, - cmat, - o, - coeff, - target_code); - break; - case CCD_HP3670: - case CCD_HP2400: - target_code = 0xe000; - /* offset is cksel dependent, but we can't use this in common code */ - if(dev->settings.xres<=300) - { - o = -10; /* OK for <=300 */ - } - else if(dev->settings.xres<=600) - { - o = -6; /* ok at 600 */ - } - else - { - o = +2; - } - compute_coefficients (dev, - shading_data, - pixels_per_line, - 3, - cmat, - o, - coeff, - target_code); - break; - case CCD_KVSS080: - case CCD_PLUSTEK3800: - case CCD_G4050: - case CCD_CS4400F: - case CCD_CS8400F: - target_code = 0xe000; - o = 0; - compute_coefficients (dev, - shading_data, - pixels_per_line, - 3, - cmat, - o, - coeff, - target_code); - break; - case CIS_CANONLIDE700: - case CIS_CANONLIDE100: - case CIS_CANONLIDE200: - case CIS_CANONLIDE110: - case CIS_CANONLIDE120: - case CIS_CANONLIDE210: - case CIS_CANONLIDE220: - /* TODO store this in a data struct so we avoid - * growing this switch */ - if(dev->model->ccd_type!=CIS_CANONLIDE110 - && dev->model->ccd_type!=CIS_CANONLIDE210 - && dev->model->ccd_type!=CIS_CANONLIDE120 - && dev->model->ccd_type!=CIS_CANONLIDE220) - target_code=0xdc00; - else - target_code=0xf000; - words_per_color=pixels_per_line*2; - length = words_per_color * 3 * 2; - free(shading_data); - shading_data = malloc (length); - if (!shading_data) - { - DBG (DBG_error, "%s: failed to allocate memory\n", __func__); - return SANE_STATUS_NO_MEM; - } - memset (shading_data, 0, length); - compute_planar_coefficients (dev, - shading_data, - 1, - pixels_per_line, - words_per_color, - channels, - cmat, - 0, - coeff, - target_code); - break; - case CCD_CANONLIDE35: - compute_averaged_planar (dev, - shading_data, - pixels_per_line, - words_per_color, - channels, - 4, - coeff, - 0xe000, - 0x0a00); - break; - case CIS_CANONLIDE80: - compute_averaged_planar (dev, - shading_data, - pixels_per_line, - words_per_color, - channels, - 0, - coeff, - 0xd000, - 0x0800); - break; - case CCD_PLUSTEK_3600: - compute_shifted_coefficients (dev, - shading_data, - pixels_per_line, - channels, - cmat, - 12, /* offset */ - coeff, - 0x0001, /* target_dark */ - 0xf900, /* target_bright */ - 256); /* patch_size: contigous extent */ - break; - default: - DBG (DBG_error, "%s: sensor %d not supported\n", __func__, dev->model->ccd_type); - return SANE_STATUS_UNSUPPORTED; - break; - } - - /* do the actual write of shading calibration data to the scanner */ - status = genesys_send_offset_and_shading (dev, shading_data, length); - free (shading_data); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "%s: failed to send shading data: %s\n", __func__, - sane_strstatus (status)); - } - - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - - -/** - * search calibration cache list for an entry matching required scan. - * If one is found, set device calibration with it - * @param dev scanner's device - * @return SANE_STATUS_UNSUPPORTED if no matching cache entry has been - * found, SANE_STATUS_GOOD if one has been found and used. - */ -static SANE_Status -genesys_restore_calibration (Genesys_Device * dev) -{ - SANE_Status status; - Genesys_Calibration_Cache *cache; - - DBGSTART; - - /* if no cache or no function to evaluate cache entry ther can be no match */ - if (!dev->model->cmd_set->is_compatible_calibration - || dev->calibration_cache == NULL) - return SANE_STATUS_UNSUPPORTED; - - /* we walk the link list of calibration cache in search for a - * matching one */ - for (cache = dev->calibration_cache; cache; cache = cache->next) - { - status = dev->model->cmd_set->is_compatible_calibration (dev, cache, SANE_FALSE); - /* SANE_STATUS_GOOD, a matching cache has been found - * so we use it to populate calibration data - */ - if (status == SANE_STATUS_GOOD) - { - memcpy (&dev->frontend, &cache->frontend, sizeof (dev->frontend)); - /* we don't restore the gamma fields */ - memcpy (dev->sensor.regs_0x10_0x1d, cache->sensor.regs_0x10_0x1d, 6); - free (dev->dark_average_data); - free (dev->white_average_data); - - dev->average_size = cache->average_size; - dev->calib_pixels = cache->calib_pixels; - dev->calib_channels = cache->calib_channels; - - dev->dark_average_data = (uint8_t *) malloc (cache->average_size); - dev->white_average_data = (uint8_t *) malloc (cache->average_size); - - if (!dev->dark_average_data || !dev->white_average_data) - return SANE_STATUS_NO_MEM; - - memcpy (dev->dark_average_data, - cache->dark_average_data, dev->average_size); - memcpy (dev->white_average_data, - cache->white_average_data, dev->average_size); - - - if(dev->model->cmd_set->send_shading_data==NULL) - { - status = genesys_send_shading_coefficient (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_restore_calibration: failed to send shading calibration coefficients: %s\n", - sane_strstatus (status)); - return status; - } - } - - DBG (DBG_proc, "genesys_restore_calibration: restored\n"); - return SANE_STATUS_GOOD; - } - - /* here status is either SANE_STATUS_UNSUPPORTED which mean tested cache - * entry doesn't match, or an fatal error */ - if (status != SANE_STATUS_UNSUPPORTED) - { - DBG (DBG_error, - "genesys_restore_calibration: fail while checking compatibility: %s\n", - sane_strstatus (status)); - return status; - } - } - DBG (DBG_proc, "genesys_restore_calibration: completed(nothing found)\n"); - return SANE_STATUS_UNSUPPORTED; -} - - -static SANE_Status -genesys_save_calibration (Genesys_Device * dev) -{ - SANE_Status status = SANE_STATUS_UNSUPPORTED; - Genesys_Calibration_Cache *cache = NULL; -#ifdef HAVE_SYS_TIME_H - struct timeval time; -#endif - - DBGSTART; - - if (!dev->model->cmd_set->is_compatible_calibration) - return SANE_STATUS_UNSUPPORTED; - - if (dev->calibration_cache != NULL) - { - for (cache = dev->calibration_cache; cache; cache = cache->next) - { - status = dev->model->cmd_set->is_compatible_calibration (dev, cache, SANE_TRUE); - if (status == SANE_STATUS_UNSUPPORTED) - { - continue; - } - else if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_save_calibration: fail while checking compatibility: %s\n", - sane_strstatus (status)); - return status; - } - break; - } - } - - /* if we found on overridable cache, we reuse it */ - if (cache) - { - free(cache->dark_average_data); - free(cache->white_average_data); - } - else - { - /* create a new cache entry and insert it in the linked list */ - cache = malloc (sizeof (Genesys_Calibration_Cache)); - if (!cache) - return SANE_STATUS_NO_MEM; - - memset (cache, 0, sizeof (Genesys_Calibration_Cache)); - - cache->next = dev->calibration_cache; - dev->calibration_cache = cache; - } - - cache->average_size = dev->average_size; - - cache->dark_average_data = (uint8_t *) malloc (cache->average_size); - if (!cache->dark_average_data) - return SANE_STATUS_NO_MEM; - cache->white_average_data = (uint8_t *) malloc (cache->average_size); - if (!cache->white_average_data) - return SANE_STATUS_NO_MEM; - - memcpy (&cache->used_setup, &dev->current_setup, sizeof (cache->used_setup)); - memcpy (&cache->frontend, &dev->frontend, sizeof (cache->frontend)); - memcpy (&cache->sensor, &dev->sensor, sizeof (cache->sensor)); - - cache->calib_pixels = dev->calib_pixels; - cache->calib_channels = dev->calib_channels; - memcpy (cache->dark_average_data, dev->dark_average_data, cache->average_size); - memcpy (cache->white_average_data, dev->white_average_data, cache->average_size); -#ifdef HAVE_SYS_TIME_H - gettimeofday(&time,NULL); - cache->last_calibration = time.tv_sec; -#endif - - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - -/** - * does the calibration process for a flatbed scanner - * - offset calibration - * - gain calibration - * - shading calibration - * @param dev device to calibrate - * @return SANE_STATUS_GOOD if everything when all right, else the error code. - */ -GENESYS_STATIC SANE_Status -genesys_flatbed_calibration (Genesys_Device * dev) -{ - SANE_Status status; - uint32_t pixels_per_line; - int yres; - - DBG (DBG_info, "genesys_flatbed_calibration\n"); - - yres = dev->sensor.optical_res; - if (dev->settings.yres <= dev->sensor.optical_res / 2) - yres /= 2; - - /* do offset calibration if needed */ - if (dev->model->flags & GENESYS_FLAG_OFFSET_CALIBRATION) - { - status = dev->model->cmd_set->offset_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: offset calibration failed: %s\n", - sane_strstatus (status)); - return status; - } - - /* since all the registers are set up correctly, just use them */ - status = dev->model->cmd_set->coarse_gain_calibration (dev, yres); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: coarse gain calibration: %s\n", - sane_strstatus (status)); - return status; - } - - } - else - /* since we have 2 gain calibration proc, skip second if first one was - used. */ - { - status = dev->model->cmd_set->init_regs_for_coarse_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to send calibration registers: %s\n", - sane_strstatus (status)); - return status; - } - - status = genesys_coarse_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to do coarse gain calibration: %s\n", - sane_strstatus (status)); - return status; - } - - } - - if (dev->model->is_cis) - { - /* the afe now sends valid data for doing led calibration */ - status = dev->model->cmd_set->led_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: led calibration failed: %s\n", - sane_strstatus (status)); - return status; - } - - /* calibrate afe again to match new exposure */ - if (dev->model->flags & GENESYS_FLAG_OFFSET_CALIBRATION) - { - status = dev->model->cmd_set->offset_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: offset calibration failed: %s\n", - sane_strstatus (status)); - return status; - } - - /* since all the registers are set up correctly, just use them */ - - status = dev->model->cmd_set->coarse_gain_calibration (dev, yres); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: coarse gain calibration: %s\n", - sane_strstatus (status)); - return status; - } - } - else - /* since we have 2 gain calibration proc, skip second if first one was - used. */ - { - status = - dev->model->cmd_set->init_regs_for_coarse_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to send calibration registers: %s\n", - sane_strstatus (status)); - return status; - } - - status = genesys_coarse_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to do static calibration: %s\n", - sane_strstatus (status)); - return status; - } - } - } - - /* we always use sensor pixel number when the ASIC can't handle multi-segments sensor */ - if (!(dev->model->flags & GENESYS_FLAG_SIS_SENSOR)) - { - pixels_per_line = (SANE_UNFIX (dev->model->x_size) * dev->settings.xres) / MM_PER_INCH; - } - else - { - pixels_per_line = dev->sensor.sensor_pixels; - } - - /* send default shading data */ - status = sanei_genesys_init_shading_data (dev, pixels_per_line); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to init shading process: %s\n", - sane_strstatus (status)); - return status; - } - - /* shading calibration */ - status = dev->model->cmd_set->init_regs_for_shading (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "genesys_flatbed_calibration: failed to send shading " - "registers: %s\n", sane_strstatus (status)); - return status; - } - - if (dev->model->flags & GENESYS_FLAG_DARK_WHITE_CALIBRATION) - { - status = genesys_dark_white_shading_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to do dark+white shading calibration: %s\n", - sane_strstatus (status)); - return status; - } - } - else - { - if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION) - { - status = genesys_dark_shading_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to do dark shading calibration: %s\n", - sane_strstatus (status)); - return status; - } - } - - status = genesys_white_shading_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to do white shading calibration: %s\n", - sane_strstatus (status)); - return status; - } - } - - if(dev->model->cmd_set->send_shading_data==NULL) - { - status = genesys_send_shading_coefficient (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_flatbed_calibration: failed to send shading calibration coefficients: %s\n", - sane_strstatus (status)); - return status; - } - } - - DBG (DBG_info, "genesys_flatbed_calibration: completed\n"); - - return SANE_STATUS_GOOD; -} - -/** - * Does the calibration process for a sheetfed scanner - * - offset calibration - * - gain calibration - * - shading calibration - * During calibration a predefined calibration sheet with specific black and white - * areas is used. - * @param dev device to calibrate - * @return SANE_STATUS_GOOD if everything when all right, else the error code. - */ -static SANE_Status -genesys_sheetfed_calibration (Genesys_Device * dev) -{ - SANE_Status status = SANE_STATUS_GOOD; - SANE_Bool forward = SANE_TRUE; - int xres; - - DBGSTART; - if (dev->model->cmd_set->search_strip == NULL) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: no strip searching function available\n"); - return SANE_STATUS_UNSUPPORTED; - } - - /* first step, load document */ - status = dev->model->cmd_set->load_document (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to load document: %s\n", - sane_strstatus (status)); - return status; - } - - - DBG (DBG_info, "genesys_sheetfed_calibration\n"); - - /* led, offset and gain calibration are influenced by scan - * settings. So we set it to sensor resolution */ - xres = dev->sensor.optical_res; - dev->settings.xres = dev->sensor.optical_res; - /* XP200 needs to calibrate a full and half sensor's resolution */ - if (dev->model->ccd_type == CIS_XP200 - && dev->settings.xres <= dev->sensor.optical_res / 2) - dev->settings.xres /= 2; - - /* the afe needs to sends valid data even before calibration */ - - /* go to a white area */ - status = dev->model->cmd_set->search_strip (dev, forward, SANE_FALSE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to find white strip: %s\n", - sane_strstatus (status)); - dev->model->cmd_set->eject_document (dev); - return status; - } - - if (dev->model->is_cis) - { - status = dev->model->cmd_set->led_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: led calibration failed: %s\n", - sane_strstatus (status)); - return status; - } - } - - /* calibrate afe */ - if (dev->model->flags & GENESYS_FLAG_OFFSET_CALIBRATION) - { - status = dev->model->cmd_set->offset_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: offset calibration failed: %s\n", - sane_strstatus (status)); - return status; - } - - /* since all the registers are set up correctly, just use them */ - - status = dev->model->cmd_set->coarse_gain_calibration (dev, xres); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: coarse gain calibration: %s\n", - sane_strstatus (status)); - return status; - } - } - else - /* since we have 2 gain calibration proc, skip second if first one was - used. */ - { - status = - dev->model->cmd_set->init_regs_for_coarse_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to send calibration registers: %s\n", - sane_strstatus (status)); - return status; - } - - status = genesys_coarse_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to do static calibration: %s\n", - sane_strstatus (status)); - return status; - } - } - - /* search for a full width black strip and then do a 16 bit scan to - * gather black shading data */ - if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION) - { - /* seek black/white reverse/forward */ - status = dev->model->cmd_set->search_strip (dev, forward, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to find black strip: %s\n", - sane_strstatus (status)); - dev->model->cmd_set->eject_document (dev); - return status; - } - - status = dev->model->cmd_set->init_regs_for_shading (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to do set up registers for shading calibration: %s\n", - sane_strstatus (status)); - return status; - } - status = genesys_dark_shading_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - dev->model->cmd_set->eject_document (dev); - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to do dark shading calibration: %s\n", - sane_strstatus (status)); - return status; - } - forward = SANE_FALSE; - } - - - /* go to a white area */ - status = dev->model->cmd_set->search_strip (dev, forward, SANE_FALSE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to find white strip: %s\n", - sane_strstatus (status)); - dev->model->cmd_set->eject_document (dev); - return status; - } - - status = dev->model->cmd_set->init_regs_for_shading (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to do set up registers for shading calibration: %s\n", - sane_strstatus (status)); - return status; - } - status = genesys_white_shading_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - dev->model->cmd_set->eject_document (dev); - DBG (DBG_error, "%s: failed eject target: %s\n", __func__, - sane_strstatus (status)); - return status; - } - - /* in case we haven't black shading data, build it from black pixels - * of white calibration */ - if (!(dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)) - { - FREE_IFNOT_NULL (dev->dark_average_data); - dev->dark_average_data = malloc (dev->average_size); - memset (dev->dark_average_data, 0x0f, dev->average_size); - /* XXX STEF XXX - * with black point in white shading, build an average black - * pixel and use it to fill the dark_average - * dev->calib_pixels - (dev->sensor.sensor_pixels * dev->settings.xres) / dev->sensor.optical_res, - dev->calib_lines, - */ - } - - /* send the shading coefficient when doing whole line shading - * but not when using SHDAREA like GL124 */ - if(dev->model->cmd_set->send_shading_data==NULL) - { - status = genesys_send_shading_coefficient (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to send shading calibration coefficients: %s\n", - sane_strstatus (status)); - return status; - } - } - - /* save the calibration data */ - genesys_save_calibration (dev); - - /* and finally eject calibration sheet */ - status = dev->model->cmd_set->eject_document (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_sheetfed_calibration: failed to eject document: %s\n", - sane_strstatus (status)); - return status; - } - - /* resotre settings */ - dev->settings.xres = xres; - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - -/** - * does the calibration process for a device - * @param dev device to calibrate - */ -static SANE_Status -genesys_scanner_calibration (Genesys_Device * dev) -{ - if (dev->model->is_sheetfed == SANE_FALSE) - { - return genesys_flatbed_calibration (dev); - } - return genesys_sheetfed_calibration (dev); -} - -/* unused function kept in case it may be usefull in the futur */ -#if 0 -static SANE_Status -genesys_wait_not_moving (Genesys_Device * dev, int mseconds) -{ - uint8_t value; - SANE_Status status; - - DBG (DBG_proc, - "genesys_wait_not_moving: waiting %d mseconds for motor to stop\n", - mseconds); - while (mseconds > 0) - { - RIE (sanei_genesys_get_status (dev, &value)); - - if (dev->model->cmd_set->test_motor_flag_bit (value)) - { - usleep (100 * 1000); - mseconds -= 100; - DBG (DBG_io, - "genesys_wait_not_moving: motor is moving, %d mseconds to go\n", - mseconds); - } - else - { - DBG (DBG_info, - "genesys_wait_not_moving: motor is not moving, exiting\n"); - return SANE_STATUS_GOOD; - } - - } - DBG (DBG_error, - "genesys_wait_not_moving: motor is still moving, timeout exceeded\n"); - return SANE_STATUS_DEVICE_BUSY; -} -#endif - - -/* ------------------------------------------------------------------------ */ -/* High level (exported) functions */ -/* ------------------------------------------------------------------------ */ - -/* - * wait lamp to be warm enough by scanning the same line until - * differences between two scans are below a threshold - */ -static SANE_Status -genesys_warmup_lamp (Genesys_Device * dev) -{ - uint8_t *first_line, *second_line; - int seconds = 0; - int pixel; - int channels, total_size; - double first_average = 0; - double second_average = 0; - int difference = 255; - int empty, lines = 3; - SANE_Status status = SANE_STATUS_IO_ERROR; - - DBGSTART; - - /* check if the current chipset implements warmup */ - if(dev->model->cmd_set->init_regs_for_warmup==NULL) - { - DBG (DBG_error, "%s: init_regs_for_warmup not implemented\n", __func__); - return status; - } - - dev->model->cmd_set->init_regs_for_warmup (dev, dev->reg, &channels, &total_size); - first_line = malloc (total_size); - if (!first_line) - return SANE_STATUS_NO_MEM; - - second_line = malloc (total_size); - if (!second_line) - { - free(first_line); - DBGCOMPLETED; - return SANE_STATUS_NO_MEM; - } - - do - { - DBG (DBG_info, "genesys_warmup_lamp: one more loop\n"); - RIEF2 (dev->model->cmd_set->begin_scan (dev, dev->reg, SANE_FALSE), first_line, second_line); - do - { - sanei_genesys_test_buffer_empty (dev, &empty); - } - while (empty); - - status = sanei_genesys_read_data_from_scanner (dev, first_line, total_size); - if (status != SANE_STATUS_GOOD) - { - RIEF2 (sanei_genesys_read_data_from_scanner - (dev, first_line, total_size), first_line, second_line); - } - - RIEF2 (dev->model->cmd_set->end_scan (dev, dev->reg, SANE_TRUE), first_line, second_line); - - sleep (1); /* sleep 1 s */ - seconds++; - - RIEF2 (dev->model->cmd_set->begin_scan (dev, dev->reg, SANE_FALSE), first_line, second_line); - do - { - sanei_genesys_test_buffer_empty (dev, &empty); - usleep (100 * 1000); - } - while (empty); - RIEF2 (sanei_genesys_read_data_from_scanner (dev, second_line, total_size), first_line, second_line); - RIEF2 (dev->model->cmd_set->end_scan (dev, dev->reg, SANE_TRUE), first_line, second_line); - - /* compute difference between the two scans */ - for (pixel = 0; pixel < total_size; pixel++) - { - /* 16 bit data */ - if (dev->model->cmd_set->get_bitset_bit (dev->reg)) - { - first_average += (first_line[pixel] + first_line[pixel + 1] * 256); - second_average += (second_line[pixel] + second_line[pixel + 1] * 256); - pixel++; - } - else - { - first_average += first_line[pixel]; - second_average += second_line[pixel]; - } - } - if (dev->model->cmd_set->get_bitset_bit (dev->reg)) - { - first_average /= pixel; - second_average /= pixel; - difference = fabs (first_average - second_average); - DBG (DBG_info, - "genesys_warmup_lamp: average = %.2f, diff = %.3f\n", - 100 * ((second_average) / (256 * 256)), - 100 * (difference / second_average)); - - if (second_average > (100 * 256) - && (difference / second_average) < 0.002) - break; - } - else - { - first_average /= pixel; - second_average /= pixel; - if (DBG_LEVEL >= DBG_data) - { - sanei_genesys_write_pnm_file ("warmup1.pnm", first_line, 8, - channels, - total_size / (lines * channels), - lines); - sanei_genesys_write_pnm_file ("warmup2.pnm", second_line, 8, - channels, - total_size / (lines * channels), - lines); - } - DBG (DBG_info, "genesys_warmup_lamp: average 1 = %.2f, average 2 = %.2f\n", first_average, second_average); - /* if delta below 15/255 ~= 5.8%, lamp is considred warm enough */ - if (fabs (first_average - second_average) < 15 - && second_average > 55) - break; - } - - /* sleep another second before next loop */ - sleep (1); - seconds++; - } - while (seconds < WARMUP_TIME); - - if (seconds >= WARMUP_TIME) - { - DBG (DBG_error, - "genesys_warmup_lamp: warmup timed out after %d seconds. Lamp defective?\n", - seconds); - status = SANE_STATUS_IO_ERROR; - } - else - { - DBG (DBG_info, - "genesys_warmup_lamp: warmup succeeded after %d seconds\n", - seconds); - } - - free (first_line); - free (second_line); - - DBGCOMPLETED; - - return status; -} - - -/* High-level start of scanning */ -static SANE_Status -genesys_start_scan (Genesys_Device * dev, SANE_Bool lamp_off) -{ - SANE_Status status; - unsigned int steps, expected; - SANE_Bool empty; - - DBGSTART; - - /* since not all scanners are set ot wait for head to park - * we check we are not still parking before starting a new scan */ - if (dev->parking == SANE_TRUE) - { - status = sanei_genesys_wait_for_home (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to wait for head to park: %s\n", - sane_strstatus (status)); - return status; - } - } - - /* disable power saving*/ - status = dev->model->cmd_set->save_power (dev, SANE_FALSE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to disable power saving mode: %s\n", - sane_strstatus (status)); - return status; - } - - /* wait for lamp warmup : until a warmup for TRANSPARENCY is designed, skip - * it when scanning from XPA. */ - if (!(dev->model->flags & GENESYS_FLAG_SKIP_WARMUP) - && (dev->settings.scan_method == SCAN_METHOD_FLATBED)) - { - RIE (genesys_warmup_lamp (dev)); - } - - /* set top left x and y values by scanning the internals if flatbed scanners */ - if (dev->model->is_sheetfed == SANE_FALSE) - { - /* do the geometry detection only once */ - if ((dev->model->flags & GENESYS_FLAG_SEARCH_START) - && (dev->model->y_offset_calib == 0)) - { - status = dev->model->cmd_set->search_start_position (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to search start position: %s\n", - sane_strstatus (status)); - return status; - } - - dev->parking = SANE_FALSE; - status = dev->model->cmd_set->slow_back_home (dev, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to move scanhead to " - "home position: %s\n", sane_strstatus (status)); - return status; - } - dev->scanhead_position_in_steps = 0; - } - else - { - /* Go home */ - /* TODO: check we can drop this since we cannot have the - scanner's head wandering here */ - dev->parking = SANE_FALSE; - status = dev->model->cmd_set->slow_back_home (dev, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to move scanhead to " - "home position: %s\n", sane_strstatus (status)); - return status; - } - dev->scanhead_position_in_steps = 0; - } - } - - /* move to calibration area for transparency adapter */ - if ((dev->settings.scan_method == SCAN_METHOD_TRANSPARENCY) - && dev->model->cmd_set->move_to_ta != NULL) - { - status=dev->model->cmd_set->move_to_ta(dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to move to start of transparency adapter: %s\n", - sane_strstatus (status)); - return status; - } - } - - /* load document if needed (for sheetfed scanner for instance) */ - if (dev->model->is_sheetfed == SANE_TRUE - && dev->model->cmd_set->load_document != NULL) - { - status = dev->model->cmd_set->load_document (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to load document: %s\n", - sane_strstatus (status)); - return status; - } - } - - /* send gamma tables. They have been set to device or user value - * when setting option value */ - status = dev->model->cmd_set->send_gamma_table (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to init gamma table: %s\n", - sane_strstatus (status)); - return status; - } - - /* try to use cached calibration first */ - status = genesys_restore_calibration (dev); - if (status == SANE_STATUS_UNSUPPORTED) - { - /* calibration : sheetfed scanners can't calibrate before each scan */ - /* and also those who have the NO_CALIBRATION flag */ - if (!(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION) - &&dev->model->is_sheetfed == SANE_FALSE) - { - status = genesys_scanner_calibration (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to do scanner calibration: %s\n", - sane_strstatus (status)); - return status; - } - - genesys_save_calibration (dev); - } - else - { - DBG (DBG_warn, "genesys_start_scan: no calibration done\n"); - } - } - else if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to restore calibration: %s\n", - sane_strstatus (status)); - return status; - } - - /* build look up table for dynamic lineart */ - if(dev->settings.dynamic_lineart==SANE_TRUE) - { - status = sanei_genesys_load_lut(dev->lineart_lut, 8, 8, 50, 205, - dev->settings.threshold_curve, - dev->settings.threshold-127); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "genesys_start_scan: failed to build lut\n"); - return status; - } - } - - status = dev->model->cmd_set->init_regs_for_scan (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to do init registers for scan: %s\n", - sane_strstatus (status)); - return status; - } - - /* no lamp during scan */ - if(lamp_off == SANE_TRUE) - { - dev->model->cmd_set->set_lamp_power (dev, dev->reg, SANE_FALSE); - } - - /* GL124 is using SHDAREA, so we have to wait for scan to be set up before - * sending shading data */ - if( (dev->model->cmd_set->send_shading_data!=NULL) - && !(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)) - { - status = genesys_send_shading_coefficient (dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to send shading calibration coefficients: %s\n", - sane_strstatus (status)); - return status; - } - } - - /* now send registers for scan */ - status = - dev->model->cmd_set->bulk_write_register (dev, dev->reg, - dev->model-> - cmd_set->bulk_full_size ()); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to bulk write registers, status = %d\n", - status); - return status; - } - - /* start effective scan */ - status = dev->model->cmd_set->begin_scan (dev, dev->reg, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to begin scan: %s\n", - sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - - /*do we really need this? the valid data check should be sufficent -- pierre*/ - /* waits for head to reach scanning position */ - expected = sanei_genesys_read_reg_from_set (dev->reg, 0x3d) * 65536 - + sanei_genesys_read_reg_from_set (dev->reg, 0x3e) * 256 - + sanei_genesys_read_reg_from_set (dev->reg, 0x3f); - do - { - /* wait 1/10th of second between each test to avoid - overloading USB and CPU */ - usleep (100 * 1000); - status = sanei_genesys_read_feed_steps (dev, &steps); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: Failed to read feed steps: %s\n", - sane_strstatus (status)); - return status; - } - } - while (steps < expected); - - /* wait for buffers to be filled */ - do - { - RIE (sanei_genesys_test_buffer_empty (dev, &empty)); - } - while (empty); - - /* when doing one or two-table movement, let the motor settle to scanning speed */ - /* and scanning start before reading data */ -/* the valid data check already waits until the scanner delivers data. this here leads to unnecessary buffer full conditions in the scanner. - if (dev->model->cmd_set->get_fast_feed_bit (dev->reg)) - usleep (1000 * 1000); - else - usleep (500 * 1000); -*/ - /* then we wait for at least one word of valid scan data - - this is also done in sanei_genesys_read_data_from_scanner -- pierre */ - if (dev->model->is_sheetfed == SANE_FALSE) - { - do - { - usleep (100 * 1000); - status = sanei_genesys_read_valid_words (dev, &steps); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_start_scan: failed to read valid words: %s\n", - sane_strstatus (status)); - return status; - } - } - while (steps < 1); - } - - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - -/* this is _not_ a ringbuffer. - if we need a block which does not fit at the end of our available data, - we move the available data to the beginning. - */ - -SANE_Status -sanei_genesys_buffer_alloc (Genesys_Buffer * buf, size_t size) -{ - buf->buffer = (SANE_Byte *) malloc (size); - if (!buf->buffer) - return SANE_STATUS_NO_MEM; - buf->avail = 0; - buf->pos = 0; - buf->size = size; - return SANE_STATUS_GOOD; -} - -SANE_Status -sanei_genesys_buffer_free (Genesys_Buffer * buf) -{ - SANE_Byte *tmp = buf->buffer; - buf->avail = 0; - buf->size = 0; - buf->pos = 0; - buf->buffer = NULL; - if (tmp) - free (tmp); - return SANE_STATUS_GOOD; -} - -SANE_Byte * -sanei_genesys_buffer_get_write_pos (Genesys_Buffer * buf, size_t size) -{ - if (buf->avail + size > buf->size) - return NULL; - if (buf->pos + buf->avail + size > buf->size) - { - memmove (buf->buffer, buf->buffer + buf->pos, buf->avail); - buf->pos = 0; - } - return buf->buffer + buf->pos + buf->avail; -} - -SANE_Byte * -sanei_genesys_buffer_get_read_pos (Genesys_Buffer * buf) -{ - return buf->buffer + buf->pos; -} - -SANE_Status -sanei_genesys_buffer_produce (Genesys_Buffer * buf, size_t size) -{ - if (size > buf->size - buf->avail) - return SANE_STATUS_INVAL; - buf->avail += size; - return SANE_STATUS_GOOD; -} - -SANE_Status -sanei_genesys_buffer_consume (Genesys_Buffer * buf, size_t size) -{ - if (size > buf->avail) - return SANE_STATUS_INVAL; - buf->avail -= size; - buf->pos += size; - return SANE_STATUS_GOOD; -} - - -#include "genesys_conv.c" - -static SANE_Status accurate_line_read(Genesys_Device * dev, - SANE_Byte *buffer, - size_t size) -{ - SANE_Status status; - status = dev->model->cmd_set->bulk_read_data (dev, 0x45, buffer, size); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "accurate_line_read: failed to read %lu bytes (%s)\n", - (u_long) size, sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - - /* done reading */ - dev->oe_buffer.avail = size; - dev->oe_buffer.pos = 0; - return status; -} - -/** @brief fill buffer while reducing vertical resolution - * This function fills a read buffer with scanned data from a sensor - * which puts odd and even pixels in 2 different data segment. So a complete - * must be read and bytes interleaved to get usable by the other stages - * of the backend - */ -static SANE_Status -genesys_fill_line_interp_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, size_t size) -{ - size_t count; - SANE_Status status; - - /* fill buffer if needed */ - if (dev->oe_buffer.avail == 0) - { - status = accurate_line_read(dev,dev->oe_buffer.buffer,dev->oe_buffer.size); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "%s: failed to read %lu bytes (%s)\n", __func__, - (u_long) dev->oe_buffer.size, sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - } - - /* copy size bytes of data, copying from a line when line count matches */ - count = 0; - while (count < size) - { - /* line counter */ - /* dev->line_interp holds the number of lines scanned for one line of data sent */ - if(((dev->line_count/dev->current_setup.channels) % dev->line_interp)==0) - { - /* copy pixel when line matches */ - work_buffer_dst[count] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos]; - count++; - } - - /* always update pointer so we skip uncopied data */ - dev->cur++; - - /* go to next line if needed */ - if (dev->cur == dev->len) - { - dev->oe_buffer.pos += dev->bpl; - dev->cur = 0; - dev->line_count++; - } - - /* read a new buffer if needed */ - if (dev->oe_buffer.pos >= dev->oe_buffer.avail) - { - status = accurate_line_read(dev,dev->oe_buffer.buffer,dev->oe_buffer.size); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "%s: failed to read %lu bytes (%s)\n", __func__, - (u_long) dev->oe_buffer.size, sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - } - } - - return SANE_STATUS_GOOD; -} - -/** @brief fill buffer for segmented sensors - * This function fills a read buffer with scanned data from a sensor segmented - * in several parts (multi-lines sensors). Data of the same valid area is read - * back to back and must be interleaved to get usable by the other stages - * of the backend - */ -static SANE_Status -genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, size_t size) -{ - size_t count; - SANE_Status status; - int depth,i,n,k; - - depth = dev->settings.depth; - if (dev->settings.scan_mode == SCAN_MODE_LINEART && dev->settings.dynamic_lineart==SANE_FALSE) - depth = 1; - - /* fill buffer if needed */ - if (dev->oe_buffer.avail == 0) - { - status = accurate_line_read(dev,dev->oe_buffer.buffer,dev->oe_buffer.size); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "%s: failed to read %lu bytes (%s)\n", __func__, - (u_long) dev->oe_buffer.size, sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - } - - /* copy size bytes of data, copying from a subwindow of each line - * when last line of buffer is exhausted, read another one */ - count = 0; - while (count < size) - { - if(dev->settings.double_xres==SANE_TRUE) - { - /* copy only even pixel */ - work_buffer_dst[count] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos]; - /* update counter and pointer */ - count++; - dev->cur++; - } - else - { - if(depth==1) - { - while (dev->cur < dev->len && count < size) - { - for(n=0;n<dev->segnb;n++) - { - work_buffer_dst[count+n] = 0; - } - /* interleaving is at bit level */ - for(i=0;i<8;i++) - { - k=count+(i*dev->segnb)/8; - for(n=0;n<dev->segnb;n++) - { - work_buffer_dst[k] = work_buffer_dst[k] << 1; - if((dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist*dev->order[n] + dev->oe_buffer.pos])&(128>>i)) - { - work_buffer_dst[k] |= 1; - } - } - } - - /* update counter and pointer */ - count += dev->segnb; - dev->cur++; - } - } - if(depth==8) - { - while (dev->cur < dev->len && count < size) - { - for(n=0;n<dev->segnb;n++) - { - work_buffer_dst[count+n] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist*dev->order[n] + dev->oe_buffer.pos]; - } - /* update counter and pointer */ - count += dev->segnb; - dev->cur++; - } - } - if(depth==16) - { - while (dev->cur < dev->len && count < size) - { - for(n=0;n<dev->segnb;n++) - { - work_buffer_dst[count+n*2] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist*dev->order[n] + dev->oe_buffer.pos]; - work_buffer_dst[count+n*2+1] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist*dev->order[n] + dev->oe_buffer.pos+1]; - } - /* update counter and pointer */ - count += dev->segnb*2; - dev->cur+=2; - } - } - } - - /* go to next line if needed */ - if (dev->cur == dev->len) - { - dev->oe_buffer.pos += dev->bpl; - dev->cur = 0; - } - - /* read a new buffer if needed */ - if (dev->oe_buffer.pos >= dev->oe_buffer.avail) - { - status = accurate_line_read(dev,dev->oe_buffer.buffer,dev->oe_buffer.size); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "%s: failed to read %lu bytes (%s)\n", __func__, - (u_long) dev->oe_buffer.size, sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - } - } - - return SANE_STATUS_GOOD; -} - -/** - * - */ -static SANE_Status -genesys_fill_read_buffer (Genesys_Device * dev) -{ - size_t size; - size_t space; - SANE_Status status; - uint8_t *work_buffer_dst; - - DBGSTART; - - /* for sheetfed scanner, we must check is document is shorter than - * the requested scan */ - if (dev->model->is_sheetfed == SANE_TRUE) - { - status = dev->model->cmd_set->detect_document_end (dev); - if (status != SANE_STATUS_GOOD) - return status; - } - - space = dev->read_buffer.size - dev->read_buffer.avail; - - work_buffer_dst = sanei_genesys_buffer_get_write_pos (&(dev->read_buffer), - space); - - size = space; - - /* never read an odd number. exception: last read - the chip internal counter does not count half words. */ - size &= ~1; - /* Some setups need the reads to be multiples of 256 bytes */ - size &= ~0xff; - - if (dev->read_bytes_left < size) - { - size = dev->read_bytes_left; - /*round up to a multiple of 256 bytes */ - size += (size & 0xff) ? 0x100 : 0x00; - size &= ~0xff; - } - - /* early out if our remaining buffer capacity is too low */ - if (size == 0) - return SANE_STATUS_GOOD; - - DBG (DBG_io, "genesys_fill_read_buffer: reading %lu bytes\n", - (u_long) size); - - /* size is already maxed to our needs. for most models bulk_read_data - will read as much data as requested. */ - - /* due to sensors and motors, not all data can be directly used. It - * may have to be read from another intermediate buffer and then processed. - * There are currently 3 intermediate stages: - * - handling of odd/even sensors - * - handling of line interpolation for motors that can't have low - * enough dpi - * - handling of multi-segments sensors - * - * This is also the place where full duplex data will be handled. - */ - if (dev->line_interp>0) - { - /* line interpolation */ - status = genesys_fill_line_interp_buffer (dev, work_buffer_dst, size); - } - else if (dev->segnb>1) - { - /* multi-segment sensors processing */ - status = genesys_fill_segmented_buffer (dev, work_buffer_dst, size); - } - else /* regular case with no extra copy */ - { - status = dev->model->cmd_set->bulk_read_data (dev, 0x45, work_buffer_dst, size); - } - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_fill_read_buffer: failed to read %lu bytes (%s)\n", - (u_long) size, sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - - if (size > dev->read_bytes_left) - size = dev->read_bytes_left; - - dev->read_bytes_left -= size; - - RIE (sanei_genesys_buffer_produce (&(dev->read_buffer), size)); - - DBGCOMPLETED; - - return SANE_STATUS_GOOD; -} - -/* this function does the effective data read in a manner that suits - the scanner. It does data reordering and resizing if need. - It also manages EOF and I/O errors, and line distance correction. - */ -static SANE_Status -genesys_read_ordered_data (Genesys_Device * dev, SANE_Byte * destination, - size_t * len) -{ - SANE_Status status; - size_t bytes, extra; - unsigned int channels, depth, src_pixels; - unsigned int ccd_shift[12], shift_count; - uint8_t *work_buffer_src; - uint8_t *work_buffer_dst; - unsigned int dst_lines; - unsigned int step_1_mode; - unsigned int needs_reorder; - unsigned int needs_ccd; - unsigned int needs_shrink; - unsigned int needs_reverse; - Genesys_Buffer *src_buffer; - Genesys_Buffer *dst_buffer; - - DBGSTART; - if (dev->read_active != SANE_TRUE) - { - DBG (DBG_error, "genesys_read_ordered_data: read not active!\n"); - *len = 0; - return SANE_STATUS_INVAL; - } - - - DBG (DBG_info, "genesys_read_ordered_data: dumping current_setup:\n" - "\tpixels: %d\n" - "\tlines: %d\n" - "\tdepth: %d\n" - "\tchannels: %d\n" - "\texposure_time: %d\n" - "\txres: %g\n" - "\tyres: %g\n" - "\thalf_ccd: %s\n" - "\tstagger: %d\n" - "\tmax_shift: %d\n", - dev->current_setup.pixels, - dev->current_setup.lines, - dev->current_setup.depth, - dev->current_setup.channels, - dev->current_setup.exposure_time, - dev->current_setup.xres, - dev->current_setup.yres, - dev->current_setup.half_ccd ? "yes" : "no", - dev->current_setup.stagger, dev->current_setup.max_shift); - - /* prepare conversion */ - /* current settings */ - channels = dev->current_setup.channels; - depth = dev->current_setup.depth; - - src_pixels = dev->current_setup.pixels; - - needs_reorder = 1; - if (channels != 3 && depth != 16) - needs_reorder = 0; -#ifndef WORDS_BIGENDIAN - if (channels != 3 && depth == 16) - needs_reorder = 0; - if (channels == 3 && depth == 16 && !dev->model->is_cis && - dev->model->line_mode_color_order == COLOR_ORDER_RGB) - needs_reorder = 0; -#endif - if (channels == 3 && depth == 8 && !dev->model->is_cis && - dev->model->line_mode_color_order == COLOR_ORDER_RGB) - needs_reorder = 0; - - needs_ccd = dev->current_setup.max_shift > 0; - needs_shrink = dev->settings.pixels != src_pixels; - needs_reverse = depth == 1; - - DBG (DBG_info, - "genesys_read_ordered_data: using filters:%s%s%s%s\n", - needs_reorder ? " reorder" : "", - needs_ccd ? " ccd" : "", - needs_shrink ? " shrink" : "", - needs_reverse ? " reverse" : ""); - - DBG (DBG_info, - "genesys_read_ordered_data: frontend requested %lu bytes\n", - (u_long) * len); - - DBG (DBG_info, - "genesys_read_ordered_data: bytes_to_read=%lu, total_bytes_read=%lu\n", - (u_long) dev->total_bytes_to_read, (u_long) dev->total_bytes_read); - /* is there data left to scan */ - if (dev->total_bytes_read >= dev->total_bytes_to_read) - { - DBG (DBG_proc, - "genesys_read_ordered_data: nothing more to scan: EOF\n"); - *len = 0; - - /* issue park command immediatly in case scanner can handle it - * so we save time */ - if (dev->model->is_sheetfed == SANE_FALSE - && !(dev->model->flags & GENESYS_FLAG_MUST_WAIT) - && dev->parking == SANE_FALSE) - { - dev->model->cmd_set->slow_back_home (dev, SANE_FALSE); - dev->parking = SANE_TRUE; - } - return SANE_STATUS_EOF; - } - - DBG (DBG_info, "genesys_read_ordered_data: %lu lines left by output\n", - ((dev->total_bytes_to_read - dev->total_bytes_read) * 8UL) / - (dev->settings.pixels * channels * depth)); - DBG (DBG_info, "genesys_read_ordered_data: %lu lines left by input\n", - ((dev->read_bytes_left + dev->read_buffer.avail) * 8UL) / - (src_pixels * channels * depth)); - - if (channels == 1) - { - ccd_shift[0] = 0; - ccd_shift[1] = dev->current_setup.stagger; - shift_count = 2; - } - else - { - ccd_shift[0] = - ((dev->ld_shift_r * dev->settings.yres) / - dev->motor.base_ydpi); - ccd_shift[1] = - ((dev->ld_shift_g * dev->settings.yres) / - dev->motor.base_ydpi); - ccd_shift[2] = - ((dev->ld_shift_b * dev->settings.yres) / - dev->motor.base_ydpi); - - ccd_shift[3] = ccd_shift[0] + dev->current_setup.stagger; - ccd_shift[4] = ccd_shift[1] + dev->current_setup.stagger; - ccd_shift[5] = ccd_shift[2] + dev->current_setup.stagger; - - shift_count = 6; - } - - -/* convert data */ -/* - 0. fill_read_buffer --------------- read_buffer ---------------------- - 1a). (opt)uncis (assumes color components to be laid out - planar) - 1b). (opt)reverse_RGB (assumes pixels to be BGR or BBGGRR)) --------------- lines_buffer ---------------------- - 2a). (opt)line_distance_correction (assumes RGB or RRGGBB) - 2b). (opt)unstagger (assumes pixels to be depth*channels/8 - bytes long, unshrinked) -------------- shrink_buffer --------------------- - 3. (opt)shrink_lines (assumes component separation in pixels) --------------- out_buffer ----------------------- - 4. memcpy to destination (for lineart with bit reversal) -*/ -/*FIXME: for lineart we need sub byte addressing in buffers, or conversion to - bytes at 0. and back to bits at 4. -Problems with the first approach: - - its not clear how to check if we need to output an incomplete byte - because it is the last one. - */ -/*FIXME: add lineart support for gl646. in the meantime add logic to convert - from gray to lineart at the end? would suffer the above problem, - total_bytes_to_read and total_bytes_read help in that case. - */ - - status = genesys_fill_read_buffer (dev); - - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_read_ordered_data: genesys_fill_read_buffer failed\n"); - return status; - } - - src_buffer = &(dev->read_buffer); - -/* maybe reorder components/bytes */ - if (needs_reorder) - { -/*not implemented for depth == 1.*/ - if (depth == 1) - { - DBG (DBG_error, "Can't reorder single bit data\n"); - return SANE_STATUS_INVAL; - } - - dst_buffer = &(dev->lines_buffer); - - work_buffer_src = sanei_genesys_buffer_get_read_pos (src_buffer); - bytes = src_buffer->avail; - -/*how many bytes can be processed here?*/ -/*we are greedy. we work as much as possible*/ - if (bytes > dst_buffer->size - dst_buffer->avail) - bytes = dst_buffer->size - dst_buffer->avail; - - dst_lines = (bytes * 8) / (src_pixels * channels * depth); - bytes = (dst_lines * src_pixels * channels * depth) / 8; - - work_buffer_dst = sanei_genesys_buffer_get_write_pos (dst_buffer, - bytes); - - DBG (DBG_info, "genesys_read_ordered_data: reordering %d lines\n", - dst_lines); - - if (dst_lines != 0) - { - - if (channels == 3) - { - step_1_mode = 0; - - if (depth == 16) - step_1_mode |= 1; - - if (dev->model->is_cis) - step_1_mode |= 2; - - if (dev->model->line_mode_color_order == COLOR_ORDER_BGR) - step_1_mode |= 4; - - switch (step_1_mode) - { - case 1: /* RGB, chunky, 16 bit */ -#ifdef WORDS_BIGENDIAN - status = - genesys_reorder_components_endian_16 (work_buffer_src, - work_buffer_dst, - dst_lines, - src_pixels, 3); - break; -#endif /*WORDS_BIGENDIAN */ - case 0: /* RGB, chunky, 8 bit */ - status = SANE_STATUS_GOOD; - break; - case 2: /* RGB, cis, 8 bit */ - status = - genesys_reorder_components_cis_8 (work_buffer_src, - work_buffer_dst, - dst_lines, src_pixels); - break; - case 3: /* RGB, cis, 16 bit */ - status = - genesys_reorder_components_cis_16 (work_buffer_src, - work_buffer_dst, - dst_lines, src_pixels); - break; - case 4: /* BGR, chunky, 8 bit */ - status = - genesys_reorder_components_bgr_8 (work_buffer_src, - work_buffer_dst, - dst_lines, src_pixels); - break; - case 5: /* BGR, chunky, 16 bit */ - status = - genesys_reorder_components_bgr_16 (work_buffer_src, - work_buffer_dst, - dst_lines, src_pixels); - break; - case 6: /* BGR, cis, 8 bit */ - status = - genesys_reorder_components_cis_bgr_8 (work_buffer_src, - work_buffer_dst, - dst_lines, - src_pixels); - break; - case 7: /* BGR, cis, 16 bit */ - status = - genesys_reorder_components_cis_bgr_16 (work_buffer_src, - work_buffer_dst, - dst_lines, - src_pixels); - break; - } - } - else - { -#ifdef WORDS_BIGENDIAN - if (depth == 16) - { - status = - genesys_reorder_components_endian_16 (work_buffer_src, - work_buffer_dst, - dst_lines, - src_pixels, 1); - } - else - { - status = SANE_STATUS_GOOD; - } -#else /*!WORDS_BIGENDIAN */ - status = SANE_STATUS_GOOD; -#endif /*WORDS_BIGENDIAN */ - } - - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_read_ordered_data: failed to convert byte ordering(%s)\n", - sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - - RIE (sanei_genesys_buffer_produce (dst_buffer, bytes)); - - RIE (sanei_genesys_buffer_consume (src_buffer, bytes)); - } - src_buffer = dst_buffer; - } - -/* maybe reverse effects of ccd layout */ - if (needs_ccd) - { -/*should not happen with depth == 1.*/ - if (depth == 1) - { - DBG (DBG_error, "Can't reverse ccd for single bit data\n"); - return SANE_STATUS_INVAL; - } - - dst_buffer = &(dev->shrink_buffer); - - work_buffer_src = sanei_genesys_buffer_get_read_pos (src_buffer); - bytes = src_buffer->avail; - - extra = - (dev->current_setup.max_shift * src_pixels * channels * depth) / 8; - -/*extra bytes are reserved, and should not be consumed*/ - if (bytes < extra) - bytes = 0; - else - bytes -= extra; - -/*how many bytes can be processed here?*/ -/*we are greedy. we work as much as possible*/ - if (bytes > dst_buffer->size - dst_buffer->avail) - bytes = dst_buffer->size - dst_buffer->avail; - - dst_lines = (bytes * 8) / (src_pixels * channels * depth); - bytes = (dst_lines * src_pixels * channels * depth) / 8; - - work_buffer_dst = - sanei_genesys_buffer_get_write_pos (dst_buffer, bytes); - - DBG (DBG_info, "genesys_read_ordered_data: un-ccd-ing %d lines\n", - dst_lines); - - if (dst_lines != 0) - { - - if (depth == 8) - status = genesys_reverse_ccd_8 (work_buffer_src, work_buffer_dst, - dst_lines, - src_pixels * channels, - ccd_shift, shift_count); - else - status = genesys_reverse_ccd_16 (work_buffer_src, work_buffer_dst, - dst_lines, - src_pixels * channels, - ccd_shift, shift_count); - - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_read_ordered_data: failed to reverse ccd effects(%s)\n", - sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - - RIE (sanei_genesys_buffer_produce (dst_buffer, bytes)); - - RIE (sanei_genesys_buffer_consume (src_buffer, bytes)); - } - src_buffer = dst_buffer; - } - -/* maybe shrink(or enlarge) lines */ - if (needs_shrink) - { - - dst_buffer = &(dev->out_buffer); - - work_buffer_src = sanei_genesys_buffer_get_read_pos (src_buffer); - bytes = src_buffer->avail; - -/*lines in input*/ - dst_lines = (bytes * 8) / (src_pixels * channels * depth); - - /* how many lines can be processed here? */ - /* we are greedy. we work as much as possible */ - bytes = dst_buffer->size - dst_buffer->avail; - - if (dst_lines > (bytes * 8) / (dev->settings.pixels * channels * depth)) - dst_lines = (bytes * 8) / (dev->settings.pixels * channels * depth); - - bytes = (dst_lines * dev->settings.pixels * channels * depth) / 8; - - work_buffer_dst = - sanei_genesys_buffer_get_write_pos (dst_buffer, bytes); - - DBG (DBG_info, "genesys_read_ordered_data: shrinking %d lines\n", - dst_lines); - - if (dst_lines != 0) - { - if (depth == 1) - status = genesys_shrink_lines_1 (work_buffer_src, - work_buffer_dst, - dst_lines, - src_pixels, - dev->settings.pixels, - channels); - else if (depth == 8) - status = genesys_shrink_lines_8 (work_buffer_src, - work_buffer_dst, - dst_lines, - src_pixels, - dev->settings.pixels, channels); - else - status = genesys_shrink_lines_16 (work_buffer_src, - work_buffer_dst, - dst_lines, - src_pixels, - dev->settings.pixels, channels); - - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_read_ordered_data: failed to shrink lines(%s)\n", - sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - - /* we just consumed this many bytes*/ - bytes = (dst_lines * src_pixels * channels * depth) / 8; - RIE (sanei_genesys_buffer_consume (src_buffer, bytes)); - - /* we just created this many bytes*/ - bytes = (dst_lines * dev->settings.pixels * channels * depth) / 8; - RIE (sanei_genesys_buffer_produce (dst_buffer, bytes)); - - } - src_buffer = dst_buffer; - } - - /* move data to destination */ - bytes = src_buffer->avail; - if (bytes > *len) - bytes = *len; - work_buffer_src = sanei_genesys_buffer_get_read_pos (src_buffer); - - if (needs_reverse) - { - status = genesys_reverse_bits (work_buffer_src, destination, bytes); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "genesys_read_ordered_data: failed to reverse bits(%s)\n", - sane_strstatus (status)); - return SANE_STATUS_IO_ERROR; - } - *len = bytes; - } - else - { - memcpy (destination, work_buffer_src, bytes); - *len = bytes; - } - - /* avoid signaling some extra data because we have treated a full block - * on the last block */ - if (dev->total_bytes_read + *len > dev->total_bytes_to_read) - *len = dev->total_bytes_to_read - dev->total_bytes_read; - - /* count bytes sent to frontend */ - dev->total_bytes_read += *len; - - RIE (sanei_genesys_buffer_consume (src_buffer, bytes)); - - /* end scan if all needed data have been read */ - if(dev->total_bytes_read >= dev->total_bytes_to_read) - { - dev->model->cmd_set->end_scan (dev, dev->reg, SANE_TRUE); - if (dev->model->is_sheetfed == SANE_TRUE) - { - dev->model->cmd_set->eject_document (dev); - } - } - - DBG (DBG_proc, "genesys_read_ordered_data: completed, %lu bytes read\n", - (u_long) bytes); - return SANE_STATUS_GOOD; -} - - - -/* ------------------------------------------------------------------------ */ -/* Start of higher level functions */ -/* ------------------------------------------------------------------------ */ - -static size_t -max_string_size (const SANE_String_Const strings[]) -{ - size_t size, max_size = 0; - SANE_Int i; - - for (i = 0; strings[i]; ++i) - { - size = strlen (strings[i]) + 1; - if (size > max_size) - max_size = size; - } - return max_size; -} - -static SANE_Status -calc_parameters (Genesys_Scanner * s) -{ - SANE_String mode, source, color_filter; - SANE_Status status = SANE_STATUS_GOOD; - SANE_Int depth = 0, resolution = 0; - double tl_x = 0, tl_y = 0, br_x = 0, br_y = 0; - - mode = s->val[OPT_MODE].s; - source = s->val[OPT_SOURCE].s; - color_filter = s->val[OPT_COLOR_FILTER].s; - depth = s->val[OPT_BIT_DEPTH].w; - resolution = s->val[OPT_RESOLUTION].w; - tl_x = SANE_UNFIX (s->val[OPT_TL_X].w); - tl_y = SANE_UNFIX (s->val[OPT_TL_Y].w); - br_x = SANE_UNFIX (s->val[OPT_BR_X].w); - br_y = SANE_UNFIX (s->val[OPT_BR_Y].w); - - s->params.last_frame = SANE_TRUE; /* only single pass scanning supported */ - - if (strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY) == 0 - || strcmp (mode, SANE_VALUE_SCAN_MODE_LINEART) == 0) - s->params.format = SANE_FRAME_GRAY; - else /* Color */ - s->params.format = SANE_FRAME_RGB; - - if (strcmp (mode, SANE_VALUE_SCAN_MODE_LINEART) == 0) - s->params.depth = 1; - else - s->params.depth = depth; - s->dev->settings.depth = depth; - - /* interpolation */ - s->dev->settings.disable_interpolation = - s->val[OPT_DISABLE_INTERPOLATION].w == SANE_TRUE; - - /* hardware settings */ - if (resolution > s->dev->sensor.optical_res && - s->dev->settings.disable_interpolation) - s->dev->settings.xres = s->dev->sensor.optical_res; - else - s->dev->settings.xres = resolution; - s->dev->settings.yres = resolution; - - s->params.lines = ((br_y - tl_y) * s->dev->settings.yres) / MM_PER_INCH; - s->params.pixels_per_line = - ((br_x - tl_x) * resolution) / MM_PER_INCH; - - /* we need an even pixels number - * TODO invert test logic or generalize behaviour across all ASICs */ - if ((s->dev->model->flags & GENESYS_FLAG_SIS_SENSOR) - || s->dev->model->asic_type == GENESYS_GL847 - || s->dev->model->asic_type == GENESYS_GL124 - || s->dev->model->asic_type == GENESYS_GL845 - || s->dev->model->asic_type == GENESYS_GL846 - || s->dev->model->asic_type == GENESYS_GL843) - { - if (s->dev->settings.xres <= 1200) - s->params.pixels_per_line = (s->params.pixels_per_line/4)*4; - else - s->params.pixels_per_line = (s->params.pixels_per_line/16)*16; - } - - /* corner case for true lineart for sensor with several segments - * or when xres is doubled to match yres */ - if (s->dev->settings.xres >= 1200 - && ( s->dev->model->asic_type == GENESYS_GL124 - || s->dev->model->asic_type == GENESYS_GL847 - || s->dev->current_setup.xres < s->dev->current_setup.yres - ) - ) - { - s->params.pixels_per_line = (s->params.pixels_per_line/16)*16; - } - - s->params.bytes_per_line = s->params.pixels_per_line; - if (s->params.depth > 8) - { - s->params.depth = 16; - s->params.bytes_per_line *= 2; - } - else if (s->params.depth == 1) - { - s->params.bytes_per_line /= 8; - /* round down pixel number - really? rounding down means loss of at most 7 pixels! -- pierre */ - s->params.pixels_per_line = 8 * s->params.bytes_per_line; - } - - if (s->params.format == SANE_FRAME_RGB) - s->params.bytes_per_line *= 3; - - if (strcmp (mode, SANE_VALUE_SCAN_MODE_COLOR) == 0) - s->dev->settings.scan_mode = SCAN_MODE_COLOR; - else if (strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY) == 0) - s->dev->settings.scan_mode = SCAN_MODE_GRAY; - else if (strcmp (mode, SANE_TITLE_HALFTONE) == 0) - s->dev->settings.scan_mode = SCAN_MODE_HALFTONE; - else /* Lineart */ - s->dev->settings.scan_mode = SCAN_MODE_LINEART; - - /* TODO: change and check */ - if (strcmp (source, FLATBED) == 0) - s->dev->settings.scan_method = SCAN_METHOD_FLATBED; - else /* transparency */ - s->dev->settings.scan_method = SCAN_METHOD_TRANSPARENCY; - - s->dev->settings.lines = s->params.lines; - s->dev->settings.pixels = s->params.pixels_per_line; - s->dev->settings.tl_x = tl_x; - s->dev->settings.tl_y = tl_y; - - /* threshold setting */ - s->dev->settings.threshold = 2.55 * (SANE_UNFIX (s->val[OPT_THRESHOLD].w)); - - /* color filter */ - if (strcmp (color_filter, "Red") == 0) - s->dev->settings.color_filter = 0; - else if (strcmp (color_filter, "Green") == 0) - s->dev->settings.color_filter = 1; - else if (strcmp (color_filter, "Blue") == 0) - s->dev->settings.color_filter = 2; - else - s->dev->settings.color_filter = 3; - - /* true gray */ - if (strcmp (color_filter, "None") == 0) - s->dev->settings.true_gray = 1; - else - s->dev->settings.true_gray = 0; - - /* dynamic lineart */ - s->dev->settings.dynamic_lineart = SANE_FALSE; - s->dev->settings.threshold_curve=0; - if(s->val[OPT_DISABLE_DYNAMIC_LINEART].w ==SANE_FALSE - &&s->dev->settings.scan_mode == SCAN_MODE_LINEART) - { - s->dev->settings.dynamic_lineart = SANE_TRUE; - } - - /* hardware lineart works only when we don't have interleave data - * for GL847 scanners, ie up to 600 DPI, then we have to rely on - * dynamic_lineart */ - if(s->dev->settings.xres > 600 - && s->dev->model->asic_type==GENESYS_GL847 - && s->dev->settings.scan_mode == SCAN_MODE_LINEART) - { - s->dev->settings.dynamic_lineart = SANE_TRUE; - } - - /* threshold curve for dynamic rasterization */ - s->dev->settings.threshold_curve=s->val[OPT_THRESHOLD_CURVE].w; - - /* some digital processing requires the whole picture to be buffered */ - /* no digital processing takes place when doing preview, or when bit depth is - * higher than 8 bits */ - if ((s->val[OPT_SWDESPECK].b - || s->val[OPT_SWCROP].b - || s->val[OPT_SWDESKEW].b - || s->val[OPT_SWDEROTATE].b - ||(SANE_UNFIX(s->val[OPT_SWSKIP].w)>0)) - && (!s->val[OPT_PREVIEW].b) - && (s->val[OPT_BIT_DEPTH].w <= 8)) - { - s->dev->buffer_image=SANE_TRUE; - } - else - { - s->dev->buffer_image=SANE_FALSE; - } - - /* brigthness and contrast only for for 8 bit scans */ - if(s->val[OPT_BIT_DEPTH].w <= 8) - { - s->dev->settings.contrast=(s->val[OPT_CONTRAST].w*127)/100; - s->dev->settings.brightness=(s->val[OPT_BRIGHTNESS].w*127)/100; - } - else - { - s->dev->settings.contrast=0; - s->dev->settings.brightness=0; - } - - /* cache expiration time */ - s->dev->settings.expiration_time=s->val[OPT_EXPIRATION_TIME].w; - - return status; -} - - -static SANE_Status -create_bpp_list (Genesys_Scanner * s, SANE_Int * bpp) -{ - int count; - - for (count = 0; bpp[count] != 0; count++) - ; - s->bpp_list[0] = count; - for (count = 0; bpp[count] != 0; count++) - { - s->bpp_list[s->bpp_list[0] - count] = bpp[count]; - } - return SANE_STATUS_GOOD; -} - -/** @brief this function initialize a gamma vector based on the ASIC: - * Set up a default gamma table vector based on device description - * gl646: 12 or 14 bits gamma table depending on GENESYS_FLAG_14BIT_GAMMA - * gl84x: 16 bits - * gl12x: 16 bits - * @param scanner pointer to scanner session to get options - * @param option option number of the gamma table to set - */ -static void -init_gamma_vector_option (Genesys_Scanner * scanner, int option) -{ - /* the option is inactive until the custom gamma control - * is enabled */ - scanner->opt[option].type = SANE_TYPE_INT; - scanner->opt[option].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED; - scanner->opt[option].unit = SANE_UNIT_NONE; - scanner->opt[option].constraint_type = SANE_CONSTRAINT_RANGE; - if (scanner->dev->model->asic_type == GENESYS_GL646) - { - if ((scanner->dev->model->flags & GENESYS_FLAG_14BIT_GAMMA) != 0) - { - scanner->opt[option].size = 16384 * sizeof (SANE_Word); - scanner->opt[option].constraint.range = &u14_range; - } - else - { /* 12 bits gamma tables */ - scanner->opt[option].size = 4096 * sizeof (SANE_Word); - scanner->opt[option].constraint.range = &u12_range; - } - } - else - { /* other asics have 16 bits words gamma table */ - scanner->opt[option].size = 256 * sizeof (SANE_Word); - scanner->opt[option].constraint.range = &u16_range; - } - /* default value is NULL */ - scanner->val[option].wa = NULL; -} - -/** - * allocate a geometry range - * @param size maximum size of the range - * @return a pointer to a valid range or NULL - */ -static SANE_Range *create_range(SANE_Fixed size) -{ -SANE_Range *range=NULL; - - range=(SANE_Range *)malloc(sizeof(SANE_Range)); - if(range!=NULL) - { - range->min = SANE_FIX (0.0); - range->max = size; - range->quant = SANE_FIX (0.0); - } - return range; -} - -/** @brief generate calibration cache file nam - * Generates the calibration cache file name to use. - * Tries to store the chache in $HOME/.sane or - * then fallbacks to $TMPDIR or TMP. The filename - * uses the model name if only one scanner is plugged - * else is uses the device name when several identical - * scanners are in use. - * @param currdev current scanner device - * @return an allocated string containing a file name - */ -GENESYS_STATIC char *calibration_filename(Genesys_Device *currdev) -{ - char *tmpstr; - char *ptr; - char filename[80]; - Genesys_Device *dev; - unsigned int count; - unsigned int i; - - /* allocate space for result */ - tmpstr=malloc(PATH_MAX); - if(tmpstr==NULL) - { - return NULL; - } - - /* first compute the DIR where we can store cache: - * 1 - home dir - * 2 - $TMPDIR - * 3 - $TMP - * 4 - tmp dir - * 5 - temp dir - * 6 - then resort to current dir - */ - ptr = getenv ("HOME"); - if(ptr==NULL) - { - ptr = getenv ("USERPROFILE"); - } - if(ptr==NULL) - { - ptr = getenv ("TMPDIR"); - } - if(ptr==NULL) - { - ptr = getenv ("TMP"); - } - - /* now choose filename: - * 1 - if only one scanner, name of the model - * 2 - if several scanners of the same model, use device name, - * replacing special chars - */ - count=0; - /* count models of the same names if several scanners attached */ - if(num_devices>1) - { - for (dev = first_dev; dev; dev = dev->next) - { - if(strcmp(dev->model->name,currdev->model->name)==0) - { - count++; - } - } - } - if(count>1) - { - snprintf(filename,sizeof(filename),"%s.cal",currdev->file_name); - for(i=0;i<strlen(filename);i++) - { - if(filename[i]==':'||filename[i]==PATH_SEP) - { - filename[i]='_'; - } - } - } - else - { - snprintf(filename,sizeof(filename),"%s.cal",currdev->model->name); - } - - /* build final final name : store dir + filename */ - if (NULL == ptr) - { - snprintf (tmpstr, PATH_MAX, "%s", filename); - } - else - { -#ifdef HAVE_MKDIR - /* make sure .sane directory exists in existing store dir */ - snprintf (tmpstr, PATH_MAX, "%s%c.sane", ptr, PATH_SEP); - mkdir(tmpstr,0700); -#endif - snprintf (tmpstr, PATH_MAX, "%s%c.sane%c%s", ptr, PATH_SEP, PATH_SEP, filename); - } - - DBG (DBG_info, "%s: calibration filename >%s<\n", __func__, tmpstr); - - return tmpstr; -} - - -static SANE_Status -init_options (Genesys_Scanner * s) -{ - SANE_Int option, count, min_dpi; - SANE_Status status; - SANE_Word *dpi_list; - Genesys_Model *model = s->dev->model; - SANE_Range *x_range, *y_range; - - DBGSTART; - - memset (s->opt, 0, sizeof (s->opt)); - memset (s->val, 0, sizeof (s->val)); - - for (option = 0; option < NUM_OPTIONS; ++option) - { - s->opt[option].size = sizeof (SANE_Word); - s->opt[option].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; - } - s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS; - s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; - s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; - s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; - s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; - s->val[OPT_NUM_OPTS].w = NUM_OPTIONS; - - /* "Mode" group: */ - s->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode"); - s->opt[OPT_MODE_GROUP].desc = ""; - s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; - s->opt[OPT_MODE_GROUP].size = 0; - s->opt[OPT_MODE_GROUP].cap = 0; - s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - - /* scan mode */ - s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; - s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; - s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; - s->opt[OPT_MODE].type = SANE_TYPE_STRING; - s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; - s->opt[OPT_MODE].size = max_string_size (mode_list); - s->opt[OPT_MODE].constraint.string_list = mode_list; - s->val[OPT_MODE].s = strdup (SANE_VALUE_SCAN_MODE_GRAY); - - /* scan source */ - s->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE; - s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE; - s->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE; - s->opt[OPT_SOURCE].type = SANE_TYPE_STRING; - s->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; - s->opt[OPT_SOURCE].size = max_string_size (source_list); - s->opt[OPT_SOURCE].constraint.string_list = source_list; - s->val[OPT_SOURCE].s = strdup (FLATBED); - if (model->flags & GENESYS_FLAG_HAS_UTA) - { - ENABLE (OPT_SOURCE); - } - else - { - DISABLE (OPT_SOURCE); - } - - /* preview */ - s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW; - s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; - s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; - s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL; - s->opt[OPT_PREVIEW].unit = SANE_UNIT_NONE; - s->opt[OPT_PREVIEW].constraint_type = SANE_CONSTRAINT_NONE; - s->val[OPT_PREVIEW].w = SANE_FALSE; - - /* bit depth */ - s->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH; - s->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH; - s->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH; - s->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT; - s->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST; - s->opt[OPT_BIT_DEPTH].size = sizeof (SANE_Word); - s->opt[OPT_BIT_DEPTH].constraint.word_list = 0; - s->opt[OPT_BIT_DEPTH].constraint.word_list = s->bpp_list; - create_bpp_list (s, model->bpp_gray_values); - s->val[OPT_BIT_DEPTH].w = 8; - if (s->opt[OPT_BIT_DEPTH].constraint.word_list[0] < 2) - DISABLE (OPT_BIT_DEPTH); - - /* resolution */ - min_dpi=200000; - for (count = 0; model->xdpi_values[count] != 0; count++) - { - if(model->xdpi_values[count]<min_dpi) - { - min_dpi=model->xdpi_values[count]; - } - } - dpi_list = malloc ((count + 1) * sizeof (SANE_Word)); - if (!dpi_list) - return SANE_STATUS_NO_MEM; - dpi_list[0] = count; - for (count = 0; model->xdpi_values[count] != 0; count++) - dpi_list[count + 1] = model->xdpi_values[count]; - s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; - s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; - s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; - s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; - s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; - s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; - s->opt[OPT_RESOLUTION].constraint.word_list = dpi_list; - s->val[OPT_RESOLUTION].w = min_dpi; - - /* "Geometry" group: */ - s->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry"); - s->opt[OPT_GEOMETRY_GROUP].desc = ""; - s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; - s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED; - s->opt[OPT_GEOMETRY_GROUP].size = 0; - s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - - x_range=create_range(model->x_size); - if(x_range==NULL) - { - return SANE_STATUS_NO_MEM; - } - - y_range=create_range(model->y_size); - if(y_range==NULL) - { - return SANE_STATUS_NO_MEM; - } - - /* top-left x */ - s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; - s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; - s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; - s->opt[OPT_TL_X].type = SANE_TYPE_FIXED; - s->opt[OPT_TL_X].unit = SANE_UNIT_MM; - s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_TL_X].constraint.range = x_range; - s->val[OPT_TL_X].w = 0; - - /* top-left y */ - s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; - s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; - s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; - s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; - s->opt[OPT_TL_Y].unit = SANE_UNIT_MM; - s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_TL_Y].constraint.range = y_range; - s->val[OPT_TL_Y].w = 0; - - /* bottom-right x */ - s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; - s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; - s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; - s->opt[OPT_BR_X].type = SANE_TYPE_FIXED; - s->opt[OPT_BR_X].unit = SANE_UNIT_MM; - s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_BR_X].constraint.range = x_range; - s->val[OPT_BR_X].w = x_range->max; - - /* bottom-right y */ - s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; - s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; - s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; - s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; - s->opt[OPT_BR_Y].unit = SANE_UNIT_MM; - s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_BR_Y].constraint.range = y_range; - s->val[OPT_BR_Y].w = y_range->max; - - /* "Enhancement" group: */ - s->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); - s->opt[OPT_ENHANCEMENT_GROUP].desc = ""; - s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; - s->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED; - s->opt[OPT_ENHANCEMENT_GROUP].size = 0; - s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - - /* custom-gamma table */ - s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA; - s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA; - s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA; - s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL; - s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_ADVANCED; - s->val[OPT_CUSTOM_GAMMA].b = SANE_FALSE; - - /* grayscale gamma vector */ - s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR; - s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR; - s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR; - init_gamma_vector_option (s, OPT_GAMMA_VECTOR); - - /* red gamma vector */ - s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R; - s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R; - s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R; - init_gamma_vector_option (s, OPT_GAMMA_VECTOR_R); - - /* green gamma vector */ - s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G; - s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G; - s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G; - init_gamma_vector_option (s, OPT_GAMMA_VECTOR_G); - - /* blue gamma vector */ - s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B; - s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B; - s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B; - init_gamma_vector_option (s, OPT_GAMMA_VECTOR_B); - - /* currently, there are only gamma table options in this group, - * so if the scanner doesn't support gamma table, disable the - * whole group */ - if (!(model->flags & GENESYS_FLAG_CUSTOM_GAMMA)) - { - s->opt[OPT_ENHANCEMENT_GROUP].cap |= SANE_CAP_INACTIVE; - s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; - DBG (DBG_info, "init_options: custom gamma disabled\n"); - } - - /* software base image enhancements, these are consuming as many - * memory than used by the full scanned image and may fail at high - * resolution - */ - /* software deskew */ - s->opt[OPT_SWDESKEW].name = "swdeskew"; - s->opt[OPT_SWDESKEW].title = "Software deskew"; - s->opt[OPT_SWDESKEW].desc = "Request backend to rotate skewed pages digitally"; - s->opt[OPT_SWDESKEW].type = SANE_TYPE_BOOL; - s->opt[OPT_SWDESKEW].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED; - s->val[OPT_SWDESKEW].b = SANE_FALSE; - - /* software deskew */ - s->opt[OPT_SWDESPECK].name = "swdespeck"; - s->opt[OPT_SWDESPECK].title = "Software despeck"; - s->opt[OPT_SWDESPECK].desc = "Request backend to remove lone dots digitally"; - s->opt[OPT_SWDESPECK].type = SANE_TYPE_BOOL; - s->opt[OPT_SWDESPECK].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED; - s->val[OPT_SWDESPECK].b = SANE_FALSE; - - /* software despeckle radius */ - s->opt[OPT_DESPECK].name = "despeck"; - s->opt[OPT_DESPECK].title = "Software despeckle diameter"; - s->opt[OPT_DESPECK].desc = "Maximum diameter of lone dots to remove from scan"; - s->opt[OPT_DESPECK].type = SANE_TYPE_INT; - s->opt[OPT_DESPECK].unit = SANE_UNIT_NONE; - s->opt[OPT_DESPECK].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_DESPECK].constraint.range = &swdespeck_range; - s->opt[OPT_DESPECK].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED | SANE_CAP_INACTIVE; - s->val[OPT_DESPECK].w = 1; - - /* crop by software */ - s->opt[OPT_SWCROP].name = "swcrop"; - s->opt[OPT_SWCROP].title = SANE_I18N ("Software crop"); - s->opt[OPT_SWCROP].desc = SANE_I18N ("Request backend to remove border from pages digitally"); - s->opt[OPT_SWCROP].type = SANE_TYPE_BOOL; - s->opt[OPT_SWCROP].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED; - s->opt[OPT_SWCROP].unit = SANE_UNIT_NONE; - s->val[OPT_SWCROP].b = SANE_FALSE; - - /* Software blank page skip */ - s->opt[OPT_SWSKIP].name = "swskip"; - s->opt[OPT_SWSKIP].title = SANE_I18N ("Software blank skip percentage"); - s->opt[OPT_SWSKIP].desc = SANE_I18N("Request driver to discard pages with low numbers of dark pixels"); - s->opt[OPT_SWSKIP].type = SANE_TYPE_FIXED; - s->opt[OPT_SWSKIP].unit = SANE_UNIT_PERCENT; - s->opt[OPT_SWSKIP].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_SWSKIP].constraint.range = &(percentage_range); - s->opt[OPT_SWSKIP].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED; - /* disable by default */ - s->val[OPT_SWSKIP].w = 0; - - /* Software Derotate */ - s->opt[OPT_SWDEROTATE].name = "swderotate"; - s->opt[OPT_SWDEROTATE].title = SANE_I18N ("Software derotate"); - s->opt[OPT_SWDEROTATE].desc = SANE_I18N("Request driver to detect and correct 90 degree image rotation"); - s->opt[OPT_SWDEROTATE].type = SANE_TYPE_BOOL; - s->opt[OPT_SWDEROTATE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED; - s->opt[OPT_SWDEROTATE].unit = SANE_UNIT_NONE; - s->val[OPT_SWDEROTATE].b = SANE_FALSE; - - /* Software brightness */ - s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; - s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; - s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; - s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; - s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; - s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_BRIGHTNESS].constraint.range = &(enhance_range); - s->opt[OPT_BRIGHTNESS].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; - /* disable by default */ - s->val[OPT_BRIGHTNESS].w = 0; - - /* Sowftware contrast */ - s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST; - s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; - s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; - s->opt[OPT_CONTRAST].type = SANE_TYPE_INT; - s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE; - s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_CONTRAST].constraint.range = &(enhance_range); - s->opt[OPT_CONTRAST].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; - /* disable by default */ - s->val[OPT_CONTRAST].w = 0; - - /* "Extras" group: */ - s->opt[OPT_EXTRAS_GROUP].title = SANE_I18N ("Extras"); - s->opt[OPT_EXTRAS_GROUP].desc = ""; - s->opt[OPT_EXTRAS_GROUP].type = SANE_TYPE_GROUP; - s->opt[OPT_EXTRAS_GROUP].cap = SANE_CAP_ADVANCED; - s->opt[OPT_EXTRAS_GROUP].size = 0; - s->opt[OPT_EXTRAS_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - - /* BW threshold */ - s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD; - s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD; - s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD; - s->opt[OPT_THRESHOLD].type = SANE_TYPE_FIXED; - s->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT; - s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_THRESHOLD].constraint.range = &percentage_range; - s->val[OPT_THRESHOLD].w = SANE_FIX (50); - - /* BW threshold curve */ - s->opt[OPT_THRESHOLD_CURVE].name = "threshold-curve"; - s->opt[OPT_THRESHOLD_CURVE].title = SANE_I18N ("Threshold curve"); - s->opt[OPT_THRESHOLD_CURVE].desc = SANE_I18N ("Dynamic threshold curve, from light to dark, normally 50-65"); - s->opt[OPT_THRESHOLD_CURVE].type = SANE_TYPE_INT; - s->opt[OPT_THRESHOLD_CURVE].unit = SANE_UNIT_NONE; - s->opt[OPT_THRESHOLD_CURVE].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_THRESHOLD_CURVE].constraint.range = &threshold_curve_range; - s->val[OPT_THRESHOLD_CURVE].w = 50; - - /* dynamic linart */ - s->opt[OPT_DISABLE_DYNAMIC_LINEART].name = "disable-dynamic-lineart"; - s->opt[OPT_DISABLE_DYNAMIC_LINEART].title = SANE_I18N ("Disable dynamic lineart"); - s->opt[OPT_DISABLE_DYNAMIC_LINEART].desc = - SANE_I18N ("Disable use of a software adaptive algorithm to generate lineart relying instead on hardware lineart."); - s->opt[OPT_DISABLE_DYNAMIC_LINEART].type = SANE_TYPE_BOOL; - s->opt[OPT_DISABLE_DYNAMIC_LINEART].unit = SANE_UNIT_NONE; - s->opt[OPT_DISABLE_DYNAMIC_LINEART].constraint_type = SANE_CONSTRAINT_NONE; - s->val[OPT_DISABLE_DYNAMIC_LINEART].w = SANE_FALSE; - - /* fastmod is required for hw lineart to work */ - if ((s->dev->model->asic_type == GENESYS_GL646) - &&(s->dev->model->motor_type != MOTOR_XP200)) - { - s->opt[OPT_DISABLE_DYNAMIC_LINEART].cap = SANE_CAP_INACTIVE; - } - - /* disable_interpolation */ - s->opt[OPT_DISABLE_INTERPOLATION].name = "disable-interpolation"; - s->opt[OPT_DISABLE_INTERPOLATION].title = - SANE_I18N ("Disable interpolation"); - s->opt[OPT_DISABLE_INTERPOLATION].desc = - SANE_I18N - ("When using high resolutions where the horizontal resolution is smaller " - "than the vertical resolution this disables horizontal interpolation."); - s->opt[OPT_DISABLE_INTERPOLATION].type = SANE_TYPE_BOOL; - s->opt[OPT_DISABLE_INTERPOLATION].unit = SANE_UNIT_NONE; - s->opt[OPT_DISABLE_INTERPOLATION].constraint_type = SANE_CONSTRAINT_NONE; - s->val[OPT_DISABLE_INTERPOLATION].w = SANE_FALSE; - - /* color filter */ - s->opt[OPT_COLOR_FILTER].name = "color-filter"; - s->opt[OPT_COLOR_FILTER].title = SANE_I18N ("Color filter"); - s->opt[OPT_COLOR_FILTER].desc = - SANE_I18N - ("When using gray or lineart this option selects the used color."); - s->opt[OPT_COLOR_FILTER].type = SANE_TYPE_STRING; - s->opt[OPT_COLOR_FILTER].constraint_type = SANE_CONSTRAINT_STRING_LIST; - /* true gray not yet supported for GL847 and GL124 scanners */ - if(!model->is_cis || model->asic_type==GENESYS_GL847 || model->asic_type==GENESYS_GL124) - { - s->opt[OPT_COLOR_FILTER].size = max_string_size (color_filter_list); - s->opt[OPT_COLOR_FILTER].constraint.string_list = color_filter_list; - s->val[OPT_COLOR_FILTER].s = strdup (s->opt[OPT_COLOR_FILTER].constraint.string_list[1]); - } - else - { - s->opt[OPT_COLOR_FILTER].size = max_string_size (cis_color_filter_list); - s->opt[OPT_COLOR_FILTER].constraint.string_list = cis_color_filter_list; - /* default to "None" ie true gray */ - s->val[OPT_COLOR_FILTER].s = strdup (s->opt[OPT_COLOR_FILTER].constraint.string_list[3]); - } - - /* no support for color filter for cis+gl646 scanners */ - if (model->asic_type == GENESYS_GL646 && model->is_cis) - { - DISABLE (OPT_COLOR_FILTER); - } - - /* calibration store file name */ - s->opt[OPT_CALIBRATION_FILE].name = "calibration-file"; - s->opt[OPT_CALIBRATION_FILE].title = SANE_I18N ("Calibration file"); - s->opt[OPT_CALIBRATION_FILE].desc = SANE_I18N ("Specify the calibration file to use"); - s->opt[OPT_CALIBRATION_FILE].type = SANE_TYPE_STRING; - s->opt[OPT_CALIBRATION_FILE].unit = SANE_UNIT_NONE; - s->opt[OPT_CALIBRATION_FILE].size = PATH_MAX; - s->opt[OPT_CALIBRATION_FILE].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED; - s->opt[OPT_CALIBRATION_FILE].constraint_type = SANE_CONSTRAINT_NONE; - s->val[OPT_CALIBRATION_FILE].s = NULL; - /* disable option if ran as root */ -#ifdef HAVE_GETUID - if(geteuid()==0) - { - DISABLE (OPT_CALIBRATION_FILE); - } -#endif - - /* expiration time for calibration cache entries */ - s->opt[OPT_EXPIRATION_TIME].name = "expiration-time"; - s->opt[OPT_EXPIRATION_TIME].title = SANE_I18N ("Calibration cache expiration time"); - s->opt[OPT_EXPIRATION_TIME].desc = SANE_I18N ("Time (in minutes) before a cached calibration expires. " - "A value of 0 means cache is not used. A negative value means cache never expires."); - s->opt[OPT_EXPIRATION_TIME].type = SANE_TYPE_INT; - s->opt[OPT_EXPIRATION_TIME].unit = SANE_UNIT_NONE; - s->opt[OPT_EXPIRATION_TIME].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_EXPIRATION_TIME].constraint.range = &expiration_range; - s->val[OPT_EXPIRATION_TIME].w = 60; /* 60 minutes by default */ - - /* Powersave time (turn lamp off) */ - s->opt[OPT_LAMP_OFF_TIME].name = "lamp-off-time"; - s->opt[OPT_LAMP_OFF_TIME].title = SANE_I18N ("Lamp off time"); - s->opt[OPT_LAMP_OFF_TIME].desc = - SANE_I18N - ("The lamp will be turned off after the given time (in minutes). " - "A value of 0 means, that the lamp won't be turned off."); - s->opt[OPT_LAMP_OFF_TIME].type = SANE_TYPE_INT; - s->opt[OPT_LAMP_OFF_TIME].unit = SANE_UNIT_NONE; - s->opt[OPT_LAMP_OFF_TIME].constraint_type = SANE_CONSTRAINT_RANGE; - s->opt[OPT_LAMP_OFF_TIME].constraint.range = &time_range; - s->val[OPT_LAMP_OFF_TIME].w = 15; /* 15 minutes */ - - /* turn lamp off during scan */ - s->opt[OPT_LAMP_OFF].name = "lamp-off-scan"; - s->opt[OPT_LAMP_OFF].title = SANE_I18N ("Lamp off during scan"); - s->opt[OPT_LAMP_OFF].desc = SANE_I18N ("The lamp will be turned off during scan. "); - s->opt[OPT_LAMP_OFF].type = SANE_TYPE_BOOL; - s->opt[OPT_LAMP_OFF].unit = SANE_UNIT_NONE; - s->opt[OPT_LAMP_OFF].constraint_type = SANE_CONSTRAINT_NONE; - s->val[OPT_LAMP_OFF].w = SANE_FALSE; - - s->opt[OPT_SENSOR_GROUP].title = SANE_TITLE_SENSORS; - s->opt[OPT_SENSOR_GROUP].desc = SANE_DESC_SENSORS; - s->opt[OPT_SENSOR_GROUP].type = SANE_TYPE_GROUP; - s->opt[OPT_SENSOR_GROUP].cap = SANE_CAP_ADVANCED; - s->opt[OPT_SENSOR_GROUP].size = 0; - s->opt[OPT_SENSOR_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - - s->opt[OPT_SCAN_SW].name = SANE_NAME_SCAN; - s->opt[OPT_SCAN_SW].title = SANE_TITLE_SCAN; - s->opt[OPT_SCAN_SW].desc = SANE_DESC_SCAN; - s->opt[OPT_SCAN_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_SCAN_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_SCAN_SW) - s->opt[OPT_SCAN_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_SCAN_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_SCAN_SW].b = 0; - s->last_val[OPT_SCAN_SW].b = 0; - - /* SANE_NAME_FILE is not for buttons */ - s->opt[OPT_FILE_SW].name = "file"; - s->opt[OPT_FILE_SW].title = SANE_I18N ("File button"); - s->opt[OPT_FILE_SW].desc = SANE_I18N ("File button"); - s->opt[OPT_FILE_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_FILE_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_FILE_SW) - s->opt[OPT_FILE_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_FILE_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_FILE_SW].b = 0; - s->last_val[OPT_FILE_SW].b = 0; - - s->opt[OPT_EMAIL_SW].name = SANE_NAME_EMAIL; - s->opt[OPT_EMAIL_SW].title = SANE_TITLE_EMAIL; - s->opt[OPT_EMAIL_SW].desc = SANE_DESC_EMAIL; - s->opt[OPT_EMAIL_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_EMAIL_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_EMAIL_SW) - s->opt[OPT_EMAIL_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_EMAIL_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_EMAIL_SW].b = 0; - s->last_val[OPT_EMAIL_SW].b = 0; - - s->opt[OPT_COPY_SW].name = SANE_NAME_COPY; - s->opt[OPT_COPY_SW].title = SANE_TITLE_COPY; - s->opt[OPT_COPY_SW].desc = SANE_DESC_COPY; - s->opt[OPT_COPY_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_COPY_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_COPY_SW) - s->opt[OPT_COPY_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_COPY_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_COPY_SW].b = 0; - s->last_val[OPT_COPY_SW].b = 0; - - s->opt[OPT_PAGE_LOADED_SW].name = SANE_NAME_PAGE_LOADED; - s->opt[OPT_PAGE_LOADED_SW].title = SANE_TITLE_PAGE_LOADED; - s->opt[OPT_PAGE_LOADED_SW].desc = SANE_DESC_PAGE_LOADED; - s->opt[OPT_PAGE_LOADED_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_PAGE_LOADED_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_PAGE_LOADED_SW) - s->opt[OPT_PAGE_LOADED_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_PAGE_LOADED_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_PAGE_LOADED_SW].b = 0; - s->last_val[OPT_PAGE_LOADED_SW].b = 0; - - /* OCR button */ - s->opt[OPT_OCR_SW].name = "ocr"; - s->opt[OPT_OCR_SW].title = SANE_I18N ("OCR button"); - s->opt[OPT_OCR_SW].desc = SANE_I18N ("OCR button"); - s->opt[OPT_OCR_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_OCR_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_OCR_SW) - s->opt[OPT_OCR_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_OCR_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_OCR_SW].b = 0; - s->last_val[OPT_OCR_SW].b = 0; - - /* power button */ - s->opt[OPT_POWER_SW].name = "power"; - s->opt[OPT_POWER_SW].title = SANE_I18N ("Power button"); - s->opt[OPT_POWER_SW].desc = SANE_I18N ("Power button"); - s->opt[OPT_POWER_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_POWER_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_POWER_SW) - s->opt[OPT_POWER_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_POWER_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_POWER_SW].b = 0; - s->last_val[OPT_POWER_SW].b = 0; - - /* extra button */ - s->opt[OPT_EXTRA_SW].name = "extra"; - s->opt[OPT_EXTRA_SW].title = SANE_I18N ("Extra button"); - s->opt[OPT_EXTRA_SW].desc = SANE_I18N ("Extra button"); - s->opt[OPT_EXTRA_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_EXTRA_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_EXTRA_SW) - s->opt[OPT_EXTRA_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_EXTRA_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_EXTRA_SW].b = 0; - s->last_val[OPT_EXTRA_SW].b = 0; - - /* calibration needed */ - s->opt[OPT_NEED_CALIBRATION_SW].name = "need-calibration"; - s->opt[OPT_NEED_CALIBRATION_SW].title = SANE_I18N ("Need calibration"); - s->opt[OPT_NEED_CALIBRATION_SW].desc = SANE_I18N ("The scanner needs calibration for the current settings"); - s->opt[OPT_NEED_CALIBRATION_SW].type = SANE_TYPE_BOOL; - s->opt[OPT_NEED_CALIBRATION_SW].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_CALIBRATE) - s->opt[OPT_NEED_CALIBRATION_SW].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; - else - s->opt[OPT_NEED_CALIBRATION_SW].cap = SANE_CAP_INACTIVE; - s->val[OPT_NEED_CALIBRATION_SW].b = 0; - s->last_val[OPT_NEED_CALIBRATION_SW].b = 0; - - /* button group */ - s->opt[OPT_BUTTON_GROUP].title = SANE_I18N ("Buttons"); - s->opt[OPT_BUTTON_GROUP].desc = ""; - s->opt[OPT_BUTTON_GROUP].type = SANE_TYPE_GROUP; - s->opt[OPT_BUTTON_GROUP].cap = SANE_CAP_ADVANCED; - s->opt[OPT_BUTTON_GROUP].size = 0; - s->opt[OPT_BUTTON_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - - /* calibrate button */ - s->opt[OPT_CALIBRATE].name = "calibrate"; - s->opt[OPT_CALIBRATE].title = SANE_I18N ("Calibrate"); - s->opt[OPT_CALIBRATE].desc = - SANE_I18N ("Start calibration using special sheet"); - s->opt[OPT_CALIBRATE].type = SANE_TYPE_BUTTON; - s->opt[OPT_CALIBRATE].unit = SANE_UNIT_NONE; - if (model->buttons & GENESYS_HAS_CALIBRATE) - s->opt[OPT_CALIBRATE].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED | - SANE_CAP_AUTOMATIC; - else - s->opt[OPT_CALIBRATE].cap = SANE_CAP_INACTIVE; - s->val[OPT_CALIBRATE].b = 0; - s->last_val[OPT_CALIBRATE].b = 0; - - /* clear calibration cache button */ - s->opt[OPT_CLEAR_CALIBRATION].name = "clear-calibration"; - s->opt[OPT_CLEAR_CALIBRATION].title = SANE_I18N ("Clear calibration"); - s->opt[OPT_CLEAR_CALIBRATION].desc = SANE_I18N ("Clear calibration cache"); - s->opt[OPT_CLEAR_CALIBRATION].type = SANE_TYPE_BUTTON; - s->opt[OPT_CLEAR_CALIBRATION].unit = SANE_UNIT_NONE; - s->opt[OPT_CLEAR_CALIBRATION].size = 0; - s->opt[OPT_CLEAR_CALIBRATION].constraint_type = SANE_CONSTRAINT_NONE; - s->opt[OPT_CLEAR_CALIBRATION].cap = - SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED; - s->val[OPT_CLEAR_CALIBRATION].b = 0; - s->last_val[OPT_CLEAR_CALIBRATION].b = 0; - - RIE (calc_parameters (s)); - - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - -static SANE_Bool present; -static SANE_Status -check_present (SANE_String_Const devname) -{ - present=SANE_TRUE; - DBG (DBG_io, "check_present: %s detected.\n",devname); - return SANE_STATUS_GOOD; -} - -/** @brief add a scanner device - * Insert the given device into the backend list of devices. - * @param dev device to add - */ -GENESYS_STATIC void add_device(Genesys_Device *dev) -{ - ++num_devices; - dev->next = first_dev; - first_dev = dev; -} - -static SANE_Status -attach (SANE_String_Const devname, Genesys_Device ** devp, SANE_Bool may_wait) -{ - Genesys_Device *dev = 0; - SANE_Int dn, vendor, product; - SANE_Status status; - unsigned int i; - - - DBG (DBG_proc, "attach: start: devp %s NULL, may_wait = %d\n", - devp ? "!=" : "==", may_wait); - - if (devp) - *devp = 0; - - if (!devname) - { - DBG (DBG_error, "attach: devname == NULL\n"); - return SANE_STATUS_INVAL; - } - - for (dev = first_dev; dev; dev = dev->next) - { - if (strcmp (dev->file_name, devname) == 0) - { - if (devp) - *devp = dev; - DBG (DBG_info, "attach: device `%s' was already in device list\n", - devname); - return SANE_STATUS_GOOD; - } - } - - DBG (DBG_info, "attach: trying to open device `%s'\n", devname); - - status = sanei_usb_open (devname, &dn); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_warn, "attach: couldn't open device `%s': %s\n", devname, - sane_strstatus (status)); - return status; - } - else - DBG (DBG_info, "attach: device `%s' successfully opened\n", devname); - - status = sanei_usb_get_vendor_product (dn, &vendor, &product); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "attach: couldn't get vendor and product ids of device `%s': %s\n", - devname, sane_strstatus (status)); - return status; - } - - /* KV-SS080 is an auxiliary device which requires a master device to be here */ - if(vendor == 0x04da && product == 0x100f) - { - present=SANE_FALSE; - sanei_usb_find_devices (vendor, 0x1006, check_present); - sanei_usb_find_devices (vendor, 0x1007, check_present); - sanei_usb_find_devices (vendor, 0x1010, check_present); - if(present==SANE_FALSE) - { - DBG (DBG_error,"attach: master device not present\n"); - return SANE_STATUS_INVAL; - } - } - - for (i = 0; i < MAX_SCANNERS && genesys_usb_device_list[i].model != 0; i++) - { - if (vendor == genesys_usb_device_list[i].vendor && - product == genesys_usb_device_list[i].product) - { - dev = malloc (sizeof (*dev)); - if (!dev) - return SANE_STATUS_NO_MEM; - break; - } - } - - if (!dev) - { - DBG (DBG_error, - "attach: vendor %d product %d is not supported by this backend\n", - vendor, product); - return SANE_STATUS_INVAL; - } - - dev->file_name = strdup (devname); - if (!dev->file_name) - { - free(dev); - return SANE_STATUS_NO_MEM; - } - - dev->model = genesys_usb_device_list[i].model; - dev->vendorId = genesys_usb_device_list[i].vendor; - dev->productId = genesys_usb_device_list[i].product; - dev->already_initialized = SANE_FALSE; - - DBG (DBG_info, "attach: found %s flatbed scanner %s at %s\n", - dev->model->vendor, dev->model->model, dev->file_name); - add_device(dev); - - if (devp) - *devp = dev; - sanei_usb_close (dn); - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - -static SANE_Status -attach_one_device (SANE_String_Const devname) -{ - Genesys_Device *dev; - SANE_Status status; - Genesys_Device **tmp_dev; - - RIE (attach (devname, &dev, SANE_FALSE)); - - if (dev) - { - /* Keep track of newly attached devices so we can set options as - necessary. */ - tmp_dev=NULL; - /* increase device list capacity if needed */ - if (new_dev_len >= new_dev_alloced) - { - new_dev_alloced += 4; - if (new_dev) - { - tmp_dev = new_dev; - new_dev = realloc (new_dev, new_dev_alloced * sizeof (new_dev[0])); - } - else - { - new_dev = malloc (new_dev_alloced * sizeof (new_dev[0])); - tmp_dev = NULL; - } - if (!new_dev) - { - FREE_IFNOT_NULL(tmp_dev) - DBG (DBG_error, "attach_one_device: out of memory\n"); - return SANE_STATUS_NO_MEM; - } - } - new_dev[new_dev_len++] = dev; - } - return SANE_STATUS_GOOD; -} - -/* configuration framework functions */ -static SANE_Status -config_attach_genesys (SANEI_Config __sane_unused__ *config, const char *devname) -{ - /* the devname has been processed and is ready to be used - * directly. Since the backend is an USB only one, we can - * call sanei_usb_attach_matching_devices straight */ - sanei_usb_attach_matching_devices (devname, attach_one_device); - - return SANE_STATUS_GOOD; -} - -/* probes for scanner to attach to the backend */ -#ifndef UNIT_TESTING -static -#endif -SANE_Status -probe_genesys_devices (void) -{ - SANEI_Config config; - SANE_Status status; - - DBGSTART; - - new_dev = 0; - new_dev_len = 0; - new_dev_alloced = 0; - - /* set configuration options structure : no option for this backend */ - config.descriptors = NULL; - config.values = NULL; - config.count = 0; - - /* generic configure and attach function */ - status = sanei_configure_attach (GENESYS_CONFIG_FILE, &config, - config_attach_genesys); - - if (new_dev_alloced > 0) - { - new_dev_len = new_dev_alloced = 0; - free (new_dev); - } - - DBG(DBG_info, "%s: %d devices currently attached\n", __func__, num_devices); - - DBGCOMPLETED; - - return status; -} - -/** - * This should be changed if one of the substructures of - Genesys_Calibration_Cache change, but it must be changed if there are - changes that don't change size -- at least for now, as we store most - of Genesys_Calibration_Cache as is. -*/ -#define CALIBRATION_VERSION 1 - -/** - * reads previously cached calibration data - * from file define in dev->calib_file - */ -SANE_Status -sanei_genesys_read_calibration (Genesys_Device * dev) -{ - FILE *fp; - uint8_t vers = 0; - uint32_t size = 0; - struct Genesys_Calibration_Cache *cache; - SANE_Status status=SANE_STATUS_GOOD; - - DBGSTART; - - /* open calibration cache file */ - fp = fopen (dev->calib_file, "rb"); - if (!fp) - { - DBG (DBG_info, "Calibration: Cannot open %s\n", dev->calib_file); - DBGCOMPLETED; - return SANE_STATUS_IO_ERROR; - } - - /* these two checks ensure that most bad things cannot happen */ - fread (&vers, 1, 1, fp); - if (vers != CALIBRATION_VERSION) - { - DBG (DBG_info, "Calibration: Bad version\n"); - fclose (fp); - DBGCOMPLETED; - return SANE_STATUS_INVAL; - } - fread (&size, 4, 1, fp); - if (size != sizeof (struct Genesys_Calibration_Cache)) - { - DBG (DBG_info, - "Calibration: Size of calibration cache struct differs\n"); - fclose (fp); - DBGCOMPLETED; - return SANE_STATUS_INVAL; - } - - /* clear device calibration cache */ - while(dev->calibration_cache!=NULL) - { - cache=dev->calibration_cache; - dev->calibration_cache=dev->calibration_cache->next; - free(cache); - } - - /* loop on cache records in file */ - while (!feof (fp) && status==SANE_STATUS_GOOD) - { - DBG (DBG_info, "sanei_genesys_read_calibration: reading one record\n"); - cache = (struct Genesys_Calibration_Cache *) malloc (sizeof (*cache)); - - if (!cache) - { - DBG (DBG_error, - "sanei_genesys_read_calibration: could not allocate cache struct\n"); - break; - } - -#define BILT1( x ) \ - do \ - { \ - if ((x) < 1) \ - { \ - free(cache); \ - DBG (DBG_warn, "sanei_genesys_read_calibration: partial calibration record\n"); \ - status=SANE_STATUS_EOF; \ - break; \ - } \ - } while(0) - - - if (fread (&cache->used_setup, sizeof (cache->used_setup), 1, fp) < 1) - { /* eof is only detected here */ - free (cache); - status=SANE_STATUS_GOOD; - break; - } - BILT1 (fread (&cache->last_calibration, sizeof (cache->last_calibration), 1, fp)); - BILT1 (fread (&cache->frontend, sizeof (cache->frontend), 1, fp)); - /* the gamma (and later) fields are not stored */ - BILT1 (fread (&cache->sensor, offsetof (Genesys_Sensor, gamma[0]), 1, fp)); - BILT1 (fread (&cache->calib_pixels, sizeof (cache->calib_pixels), 1, fp)); - BILT1 (fread (&cache->calib_channels, sizeof (cache->calib_channels), 1, fp)); - BILT1 (fread (&cache->average_size, sizeof (cache->average_size), 1, fp)); - - cache->white_average_data = (uint8_t *) malloc (cache->average_size); - cache->dark_average_data = (uint8_t *) malloc (cache->average_size); - - if (!cache->white_average_data || !cache->dark_average_data) - { - status=SANE_STATUS_NO_MEM; - FREE_IFNOT_NULL (cache->white_average_data); - FREE_IFNOT_NULL (cache->dark_average_data); - free (cache); - DBG (DBG_error, - "sanei_genesys_read_calibration: could not allocate space for average data\n"); - break; - } - - if (fread (cache->white_average_data, cache->average_size, 1, fp) < 1) - { - status=SANE_STATUS_EOF; - DBG (DBG_warn, "sanei_genesys_read_calibration: partial calibration record\n"); - free (cache->white_average_data); - free (cache->dark_average_data); - free (cache); - break; - } - if (fread (cache->dark_average_data, cache->average_size, 1, fp) < 1) - { - DBG (DBG_warn, "sanei_genesys_read_calibration: partial calibration record\n"); - free (cache->white_average_data); - free (cache->dark_average_data); - free (cache); - status=SANE_STATUS_EOF; - break; - } -#undef BILT1 - DBG (DBG_info, "sanei_genesys_read_calibration: adding record to list\n"); - cache->next = dev->calibration_cache; - dev->calibration_cache = cache; - } - - fclose (fp); - DBGCOMPLETED; - return status; -} - -static void -write_calibration (Genesys_Device * dev) -{ - FILE *fp; - uint8_t vers = 0; - uint32_t size = 0; - struct Genesys_Calibration_Cache *cache; - - DBGSTART; - fp = fopen (dev->calib_file, "wb"); - if (!fp) - { - DBG (DBG_info, "write_calibration: Cannot open %s for writing\n", dev->calib_file); - return; - } - - vers = CALIBRATION_VERSION; - fwrite (&vers, 1, 1, fp); - size = sizeof (struct Genesys_Calibration_Cache); - fwrite (&size, 4, 1, fp); - - for (cache = dev->calibration_cache; cache; cache = cache->next) - { - fwrite (&cache->used_setup, sizeof (cache->used_setup), 1, fp); - fwrite (&cache->last_calibration, sizeof (cache->last_calibration), 1, fp); - fwrite (&cache->frontend, sizeof (cache->frontend), 1, fp); - /* the gamma (and later) fields are not stored */ - fwrite (&cache->sensor, offsetof (Genesys_Sensor, gamma[0]), 1, fp); - - fwrite (&cache->calib_pixels, sizeof (cache->calib_pixels), 1, fp); - fwrite (&cache->calib_channels, sizeof (cache->calib_channels), 1, fp); - fwrite (&cache->average_size, sizeof (cache->average_size), 1, fp); - fwrite (cache->white_average_data, cache->average_size, 1, fp); - fwrite (cache->dark_average_data, cache->average_size, 1, fp); - } - DBGCOMPLETED; - fclose (fp); -} - -/** @brief buffer scanned picture - * In order to allow digital processing, we must be able to put all the - * scanned picture in a buffer. - */ -static SANE_Status -genesys_buffer_image(Genesys_Scanner *s) -{ - SANE_Status status = SANE_STATUS_GOOD; - size_t maximum; /**> maximum bytes size of the scan */ - size_t len; /**> length of scanned data read */ - size_t total; /**> total of butes read */ - size_t size; /**> size of image buffer */ - size_t read_size; /**> size of reads */ - int lines; /** number of lines of the scan */ - Genesys_Device *dev = s->dev; - SANE_Byte *lineart=NULL; - - /* compute maximum number of lines for the scan */ - if (s->params.lines > 0) - { - lines = s->params.lines; - } - else - { - lines = - (SANE_UNFIX (dev->model->y_size) * dev->settings.yres) / MM_PER_INCH; - } - DBG (DBG_info, "%s: buffering %d lines of %d bytes\n", __func__, lines, - s->params.bytes_per_line); - - /* maximum bytes to read */ - maximum = s->params.bytes_per_line * lines; - if(s->dev->settings.dynamic_lineart==SANE_TRUE) - { - maximum *= 8; - } - - /* initial size of the read buffer */ - size = - ((2048 * 2048) / s->params.bytes_per_line) * s->params.bytes_per_line; - - /* read size */ - read_size = size / 2; - - /* allocate memory */ - dev->img_buffer = (SANE_Byte *) malloc (size); - if (dev->img_buffer == NULL) - { - DBG (DBG_error, - "%s: digital processing requires too much memory.\nConsider disabling it\n", - __func__); - return SANE_STATUS_NO_MEM; - } - - /* loop reading data until we reach maximum or EOF */ - total = 0; - while (total < maximum && status != SANE_STATUS_EOF) - { - len = size - maximum; - if (len > read_size) - { - len = read_size; - } - status = genesys_read_ordered_data (dev, dev->img_buffer + total, &len); - if (status != SANE_STATUS_EOF && status != SANE_STATUS_GOOD) - { - free (s->dev->img_buffer); - DBG (DBG_error, "%s: %s buffering failed\n", __func__, - sane_strstatus (status)); - return status; - } - total += len; - - /* do we need to enlarge read buffer ? */ - if (total + read_size > size && status != SANE_STATUS_EOF) - { - size += read_size; - dev->img_buffer = (SANE_Byte *) realloc (dev->img_buffer, size); - if (dev->img_buffer == NULL) - { - DBG (DBG_error0, - "%s: digital processing requires too much memory.\nConsider disabling it\n", - __func__); - return SANE_STATUS_NO_MEM; - } - } - } - - /* since digital processing is going to take place, - * issue head parking command so that the head move while - * computing so we can save time - */ - if (dev->model->is_sheetfed == SANE_FALSE && - dev->parking == SANE_FALSE) - { - dev->model->cmd_set->slow_back_home (dev, dev->model->flags & GENESYS_FLAG_MUST_WAIT); - dev->parking = !(s->dev->model->flags & GENESYS_FLAG_MUST_WAIT); - } - - /* in case of dynamic lineart, we have buffered gray data which - * must be converted to lineart first */ - if(s->dev->settings.dynamic_lineart==SANE_TRUE) - { - total/=8; - lineart=(SANE_Byte *)malloc(total); - if (lineart == NULL) - { - DBG (DBG_error0, - "%s: digital processing requires too much memory.\nConsider disabling it\n", - __func__); - return SANE_STATUS_NO_MEM; - } - genesys_gray_lineart (dev, - dev->img_buffer, - lineart, - dev->settings.pixels, - (total*8)/dev->settings.pixels, - dev->settings.threshold); - free(dev->img_buffer); - dev->img_buffer = lineart; - } - - /* update counters */ - dev->total_bytes_to_read = total; - dev->total_bytes_read = 0; - - /* update params */ - s->params.lines = total / s->params.bytes_per_line; - if (DBG_LEVEL >= DBG_io2) - { - sanei_genesys_write_pnm_file ("unprocessed.pnm", - dev->img_buffer, - s->params.depth, - s->params.format==SANE_FRAME_RGB ? 3:1, - s->params.pixels_per_line, - s->params.lines); - } - - return SANE_STATUS_GOOD; -} - -/* -------------------------- SANE API functions ------------------------- */ - -SANE_Status -sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) -{ - SANE_Status status; - - DBG_INIT (); - DBG (DBG_init, "SANE Genesys backend version %d.%d build %d from %s\n", - SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING); -#ifdef HAVE_LIBUSB - DBG (DBG_init, "SANE Genesys backend built with libusb-1.0\n"); -#endif -#ifdef HAVE_LIBUSB_LEGACY - DBG (DBG_init, "SANE Genesys backend built with libusb\n"); -#endif - - if (version_code) - *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); - - DBG (DBG_proc, "sane_init: authorize %s null\n", authorize ? "!=" : "=="); - - /* init usb use */ - sanei_usb_init (); - - /* init sanei_magic */ - sanei_magic_init(); - - DBG (DBG_info, "sane_init: %s endian machine\n", -#ifdef WORDS_BIGENDIAN - "big" -#else - "little" -#endif - ); - - /* set up to no devices at first */ - num_devices = 0; - first_dev = 0; - first_handle = 0; - devlist = 0; - - /* cold-plug case :detection of allready connected scanners */ - status = probe_genesys_devices (); - - DBGCOMPLETED; - - return status; -} - -void -sane_exit (void) -{ - Genesys_Device *dev, *next; - - DBGSTART; - for (dev = first_dev; dev; dev = next) - { - /* sane_close() free many fields, not much things left to - * do here */ - next = dev->next; - free (dev->file_name); - free (dev); - } - first_dev = 0; - first_handle = 0; - if (devlist) - free (devlist); - devlist = 0; - - sanei_usb_exit(); - - DBGCOMPLETED; -} - -SANE_Status -sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) -{ - Genesys_Device *dev, *prev; - SANE_Int index; - SANE_Device *sane_device; - - DBG (DBG_proc, "sane_get_devices: start: local_only = %s\n", - local_only == SANE_TRUE ? "true" : "false"); - - /* hot-plug case : detection of newly connected scanners */ - sanei_usb_scan_devices (); - probe_genesys_devices (); - - if (devlist) - free (devlist); - - devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); - if (!devlist) - return SANE_STATUS_NO_MEM; - - prev = NULL; - index = 0; - dev = first_dev; - while (dev != NULL) - { - /* check if device removed */ - present = SANE_FALSE; - sanei_usb_find_devices (dev->vendorId, dev->productId, check_present); - if (present) - { - sane_device = malloc (sizeof (*sane_device)); - if (!sane_device) - return SANE_STATUS_NO_MEM; - sane_device->name = dev->file_name; - sane_device->vendor = dev->model->vendor; - sane_device->model = dev->model->model; - sane_device->type = strdup ("flatbed scanner"); - devlist[index] = sane_device; - index++; - prev = dev; - dev = dev->next; - } - else - { - /* remove device from internal list */ - /* case 1 : removed device is first_dev */ - if (prev == NULL) - { - /* test for another dev */ - if (dev->next == NULL) - { - /* empty the whole list */ - free (dev); - first_dev = NULL; - num_devices = 0; - dev = NULL; - } - else - { - /* assign new start */ - first_dev = dev->next; - num_devices--; - free (dev); - dev = first_dev; - } - } - /* case 2 : removed device is not first_dev */ - else - { - /* link previous dev to next dev */ - prev->next = dev->next; - free (dev); - num_devices--; - - /* next loop */ - dev = prev->next; - } - } - } - devlist[index] = 0; - - *device_list = devlist; - - DBGCOMPLETED; - - return SANE_STATUS_GOOD; -} - -SANE_Status -sane_open (SANE_String_Const devicename, SANE_Handle * handle) -{ - Genesys_Device *dev; - SANE_Status status; - Genesys_Scanner *s; - char *tmpstr; - - DBG (DBG_proc, "sane_open: start (devicename = `%s')\n", devicename); - - /* devicename="" or devicename="genesys" are default values that use - * first available device - */ - if (devicename[0] && strcmp ("genesys", devicename) != 0) - { - /* search for the given devicename in the device list */ - for (dev = first_dev; dev; dev = dev->next) - if (strcmp (dev->file_name, devicename) == 0) - break; - - if (!dev) - { - DBG (DBG_info, - "sane_open: couldn't find `%s' in devlist, trying attach\n", - devicename); - RIE (attach (devicename, &dev, SANE_TRUE)); - } - else - DBG (DBG_info, "sane_open: found `%s' in devlist\n", - dev->model->name); - } - else - { - /* empty devicename or "genesys" -> use first device */ - dev = first_dev; - if (dev) - { - devicename = dev->file_name; - DBG (DBG_info, "sane_open: empty devicename, trying `%s'\n", - devicename); - } - } - - if (!dev) - return SANE_STATUS_INVAL; - - if (dev->model->flags & GENESYS_FLAG_UNTESTED) - { - DBG (DBG_error0, - "WARNING: Your scanner is not fully supported or at least \n"); - DBG (DBG_error0, - " had only limited testing. Please be careful and \n"); - DBG (DBG_error0, " report any failure/success to \n"); - DBG (DBG_error0, - " sane-devel@lists.alioth.debian.org. Please provide as many\n"); - DBG (DBG_error0, - " details as possible, e.g. the exact name of your\n"); - DBG (DBG_error0, " scanner and what does (not) work.\n"); - } - - status = sanei_usb_open (dev->file_name, &dev->dn); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_warn, "sane_open: couldn't open device `%s': %s\n", - dev->file_name, sane_strstatus (status)); - return status; - } - - - s = malloc (sizeof (*s)); - if (!s) - return SANE_STATUS_NO_MEM; - - s->dev = dev; - s->scanning = SANE_FALSE; - s->dev->read_buffer.buffer = NULL; - s->dev->lines_buffer.buffer = NULL; - s->dev->shrink_buffer.buffer = NULL; - s->dev->out_buffer.buffer = NULL; - s->dev->binarize_buffer.buffer = NULL; - s->dev->local_buffer.buffer = NULL; - s->dev->parking = SANE_FALSE; - s->dev->read_active = SANE_FALSE; - s->dev->white_average_data = NULL; - s->dev->dark_average_data = NULL; - s->dev->calibration_cache = NULL; - s->dev->calib_file = NULL; - s->dev->img_buffer = NULL; - s->dev->line_interp = 0; - s->dev->line_count = 0; - s->dev->segnb = 0; - s->dev->oe_buffer.buffer=NULL; - s->dev->binary=NULL; - - /* insert newly opened handle into list of open handles: */ - s->next = first_handle; - first_handle = s; - *handle = s; - - if (!dev->already_initialized) - sanei_genesys_init_structs (dev); - - RIE (init_options (s)); - - if (sanei_genesys_init_cmd_set (s->dev) != SANE_STATUS_GOOD) - { - DBG (DBG_error0, "This device doesn't have a valid command set!!\n"); - return SANE_STATUS_IO_ERROR; - } - - RIE (dev->model->cmd_set->init (dev)); - - /* some hardware capabilities are detected through sensors */ - RIE (s->dev->model->cmd_set->update_hardware_sensors (s)); - - /* here is the place to fetch a stored calibration cache */ - tmpstr=calibration_filename(s->dev); - s->val[OPT_CALIBRATION_FILE].s = strdup (tmpstr); - s->dev->calib_file = strdup (tmpstr); - DBG (DBG_info, "%s: Calibration filename set to:\n", __func__); - DBG (DBG_info, "%s: >%s<\n", __func__, s->dev->calib_file); - free(tmpstr); - - /* now open file, fetch calibration records */ - - sanei_genesys_read_calibration (s->dev); - - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - -void -sane_close (SANE_Handle handle) -{ - Genesys_Scanner *prev, *s; - Genesys_Calibration_Cache *cache, *next_cache; - SANE_Status status; - - DBGSTART; - - /* remove handle from list of open handles: */ - prev = 0; - for (s = first_handle; s; s = s->next) - { - if (s == handle) - break; - prev = s; - } - if (!s) - { - DBG (DBG_error, "sane_close: invalid handle %p\n", handle); - return; /* oops, not a handle we know about */ - } - - /* eject document for sheetfed scanners */ - if (s->dev->model->is_sheetfed == SANE_TRUE) - { - s->dev->model->cmd_set->eject_document (s->dev); - } - else - { - /* in case scanner is parking, wait for the head - * to reach home position */ - if(s->dev->parking==SANE_TRUE) - { - status = sanei_genesys_wait_for_home (s->dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "sane_close: failed to wait for head to park: %s\n", - sane_strstatus (status)); - } - } - } - - /* enable power saving before leaving */ - status = s->dev->model->cmd_set->save_power (s->dev, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "sane_close: failed to enable power saving mode: %s\n", - sane_strstatus (status)); - } - - /* here is the place to store calibration cache */ - write_calibration (s->dev); - - for (cache = s->dev->calibration_cache; cache; cache = next_cache) - { - next_cache = cache->next; - free (cache->dark_average_data); - free (cache->white_average_data); - free (cache); - } - - sanei_genesys_buffer_free (&(s->dev->read_buffer)); - sanei_genesys_buffer_free (&(s->dev->lines_buffer)); - sanei_genesys_buffer_free (&(s->dev->shrink_buffer)); - sanei_genesys_buffer_free (&(s->dev->out_buffer)); - sanei_genesys_buffer_free (&(s->dev->binarize_buffer)); - sanei_genesys_buffer_free (&(s->dev->local_buffer)); - FREE_IFNOT_NULL (s->dev->white_average_data); - FREE_IFNOT_NULL (s->dev->dark_average_data); - FREE_IFNOT_NULL (s->dev->calib_file); - - /* free allocated gamma tables */ - FREE_IFNOT_NULL (s->dev->sensor.gamma_table[0]); - FREE_IFNOT_NULL (s->dev->sensor.gamma_table[1]); - FREE_IFNOT_NULL (s->dev->sensor.gamma_table[2]); - - s->dev->already_initialized = SANE_FALSE; - - /* for an handful of bytes .. */ - free ((void *)(size_t)s->opt[OPT_RESOLUTION].constraint.word_list); - free (s->val[OPT_SOURCE].s); - free (s->val[OPT_MODE].s); - free (s->val[OPT_COLOR_FILTER].s); - free ((void *)(size_t)s->opt[OPT_TL_X].constraint.range); - free ((void *)(size_t)s->opt[OPT_TL_Y].constraint.range); - - if (prev) - prev->next = s->next; - else - first_handle = s->next; - - /* LAMP OFF : same register across all the ASICs */ - sanei_genesys_write_register (s->dev, 0x03, 0x00); - - /* clear before closing */ - sanei_usb_clear_halt (s->dev->dn); - - /* we need this to avoid these ASIC getting stuck - * in bulk writes */ - sanei_usb_reset (s->dev->dn); - - sanei_usb_close (s->dev->dn); - free (s); - - DBGCOMPLETED; -} - -const SANE_Option_Descriptor * -sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) -{ - Genesys_Scanner *s = handle; - - if ((unsigned) option >= NUM_OPTIONS) - return 0; - DBG (DBG_io2, "sane_get_option_descriptor: option = %s (%d)\n", - s->opt[option].name, option); - return s->opt + option; -} - -/* gets an option , called by sane_control_option */ -static SANE_Status -get_option_value (Genesys_Scanner * s, int option, void *val) -{ - unsigned int i; - SANE_Word *table ,tmp; - uint16_t *gamma; - SANE_Status status = SANE_STATUS_GOOD; - Genesys_Calibration_Cache *cache; - - switch (option) - { - /* geometry */ - case OPT_TL_X: - case OPT_TL_Y: - case OPT_BR_X: - case OPT_BR_Y: - *(SANE_Word *) val = s->val[option].w; - /* switch coordinate to keep them coherent */ - if (s->val[OPT_TL_X].w >= s->val[OPT_BR_X].w) - { - tmp=s->val[OPT_BR_X].w; - s->val[OPT_BR_X].w=s->val[OPT_TL_X].w; - s->val[OPT_TL_X].w=tmp; - } - if (s->val[OPT_TL_Y].w >= s->val[OPT_BR_Y].w) - { - tmp=s->val[OPT_BR_Y].w; - s->val[OPT_BR_Y].w=s->val[OPT_TL_Y].w; - s->val[OPT_TL_Y].w=tmp; - } - break; - /* word options: */ - case OPT_NUM_OPTS: - case OPT_RESOLUTION: - case OPT_BIT_DEPTH: - case OPT_PREVIEW: - case OPT_THRESHOLD: - case OPT_THRESHOLD_CURVE: - case OPT_DISABLE_DYNAMIC_LINEART: - case OPT_DISABLE_INTERPOLATION: - case OPT_LAMP_OFF: - case OPT_LAMP_OFF_TIME: - case OPT_SWDESKEW: - case OPT_SWCROP: - case OPT_SWDESPECK: - case OPT_SWDEROTATE: - case OPT_SWSKIP: - case OPT_DESPECK: - case OPT_CONTRAST: - case OPT_BRIGHTNESS: - case OPT_EXPIRATION_TIME: - *(SANE_Word *) val = s->val[option].w; - break; - case OPT_CUSTOM_GAMMA: - *(SANE_Word *) val = s->val[option].w; - break; - - /* string options: */ - case OPT_MODE: - case OPT_COLOR_FILTER: - case OPT_CALIBRATION_FILE: - case OPT_SOURCE: - strcpy (val, s->val[option].s); - break; - - /* word array options */ - case OPT_GAMMA_VECTOR: - table = (SANE_Word *) val; - if (strcmp (s->val[OPT_COLOR_FILTER].s, "Red") == 0) - { - gamma = s->dev->sensor.gamma_table[GENESYS_RED]; - } - else if (strcmp (s->val[OPT_COLOR_FILTER].s, "Blue") == 0) - { - gamma = s->dev->sensor.gamma_table[GENESYS_BLUE]; - } - else - { - gamma = s->dev->sensor.gamma_table[GENESYS_GREEN]; - } - for (i = 0; i < s->opt[option].size / sizeof (SANE_Word); i++) - { - table[i] = gamma[i]; - } - break; - case OPT_GAMMA_VECTOR_R: - table = (SANE_Word *) val; - for (i = 0; i < s->opt[option].size / sizeof (SANE_Word); i++) - { - table[i] = s->dev->sensor.gamma_table[GENESYS_RED][i]; - } - break; - case OPT_GAMMA_VECTOR_G: - table = (SANE_Word *) val; - for (i = 0; i < s->opt[option].size / sizeof (SANE_Word); i++) - { - table[i] = s->dev->sensor.gamma_table[GENESYS_GREEN][i]; - } - break; - case OPT_GAMMA_VECTOR_B: - table = (SANE_Word *) val; - for (i = 0; i < s->opt[option].size / sizeof (SANE_Word); i++) - { - table[i] = s->dev->sensor.gamma_table[GENESYS_BLUE][i]; - } - break; - /* sensors */ - case OPT_SCAN_SW: - case OPT_FILE_SW: - case OPT_EMAIL_SW: - case OPT_COPY_SW: - case OPT_PAGE_LOADED_SW: - case OPT_OCR_SW: - case OPT_POWER_SW: - case OPT_EXTRA_SW: - RIE (s->dev->model->cmd_set->update_hardware_sensors (s)); - *(SANE_Bool *) val = s->val[option].b; - s->last_val[option].b = *(SANE_Bool *) val; - break; - case OPT_NEED_CALIBRATION_SW: - /* scanner needs calibration for current mode unless a matching - * calibration cache is found */ - *(SANE_Bool *) val = SANE_TRUE; - for (cache = s->dev->calibration_cache; cache; cache = cache->next) - { - if (s->dev->model-> - cmd_set->is_compatible_calibration (s->dev, cache, SANE_FALSE) == SANE_STATUS_GOOD) - { - *(SANE_Bool *) val = SANE_FALSE; - } - } - break; - default: - DBG (DBG_warn, "get_option_value: can't get unknown option %d\n", - option); - } - return status; -} - -/** @brief set calibration file value - * Set calibration file value. Load new cache values from file if it exists, - * else creates the file*/ -static SANE_Status set_calibration_value (Genesys_Scanner * s, int option, void *val) -{ - SANE_Status status=SANE_STATUS_GOOD; - char *tmp; - Genesys_Device *dev=s->dev; - - DBGSTART; - - /* try to load file */ - tmp=dev->calib_file; - dev->calib_file=val; - status=sanei_genesys_read_calibration (dev); - - /* file exists but is invalid, so fall back to previous cache file - * an re-read it */ - if (status!=SANE_STATUS_IO_ERROR && status!=SANE_STATUS_GOOD) - { - dev->calib_file=tmp; - status=sanei_genesys_read_calibration (dev); - return status; - } - - /* now we can set file name value */ - if (s->val[option].s) - free (s->val[option].s); - s->val[option].s = strdup (val); - if (tmp) - free (tmp); - dev->calib_file = strdup (val); - DBG (DBG_info, "%s: Calibration filename set to:\n", __func__); - DBG (DBG_info, "%s: >%s<\n", __func__, s->dev->calib_file); - - DBGCOMPLETED; - return SANE_STATUS_GOOD; -} - -/* sets an option , called by sane_control_option */ -static SANE_Status -set_option_value (Genesys_Scanner * s, int option, void *val, - SANE_Int * myinfo) -{ - SANE_Status status = SANE_STATUS_GOOD; - SANE_Word *table; - unsigned int i; - SANE_Range *x_range, *y_range; - Genesys_Calibration_Cache *cache, *next_cache; - - switch (option) - { - case OPT_TL_X: - case OPT_TL_Y: - case OPT_BR_X: - case OPT_BR_Y: - s->val[option].w = *(SANE_Word *) val; - RIE (calc_parameters (s)); - *myinfo |= SANE_INFO_RELOAD_PARAMS; - break; - case OPT_RESOLUTION: - case OPT_THRESHOLD: - case OPT_THRESHOLD_CURVE: - case OPT_DISABLE_DYNAMIC_LINEART: - case OPT_SWCROP: - case OPT_SWDESKEW: - case OPT_DESPECK: - case OPT_SWDEROTATE: - case OPT_SWSKIP: - case OPT_DISABLE_INTERPOLATION: - case OPT_LAMP_OFF: - case OPT_PREVIEW: - case OPT_BRIGHTNESS: - case OPT_CONTRAST: - s->val[option].w = *(SANE_Word *) val; - RIE (calc_parameters (s)); - *myinfo |= SANE_INFO_RELOAD_PARAMS; - break; - case OPT_SWDESPECK: - s->val[option].w = *(SANE_Word *) val; - if (s->val[OPT_SWDESPECK].b == SANE_TRUE) - { - ENABLE(OPT_DESPECK); - } - else - { - DISABLE(OPT_DESPECK); - } - RIE (calc_parameters (s)); - *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; - break; - /* software enhancement functions only apply to 8 or 1 bits data */ - case OPT_BIT_DEPTH: - s->val[option].w = *(SANE_Word *) val; - if(s->val[OPT_BIT_DEPTH].w>8) - { - DISABLE(OPT_SWDESKEW); - DISABLE(OPT_SWDESPECK); - DISABLE(OPT_SWCROP); - DISABLE(OPT_DESPECK); - DISABLE(OPT_SWDEROTATE); - DISABLE(OPT_SWSKIP); - DISABLE(OPT_CONTRAST); - DISABLE(OPT_BRIGHTNESS); - } - else - { - ENABLE(OPT_SWDESKEW); - ENABLE(OPT_SWDESPECK); - ENABLE(OPT_SWCROP); - ENABLE(OPT_DESPECK); - ENABLE(OPT_SWDEROTATE); - ENABLE(OPT_SWSKIP); - ENABLE(OPT_CONTRAST); - ENABLE(OPT_BRIGHTNESS); - } - RIE (calc_parameters (s)); - *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; - break; - case OPT_SOURCE: - if (strcmp (s->val[option].s, val) != 0) - { /* something changed */ - if (s->val[option].s) - free (s->val[option].s); - s->val[option].s = strdup (val); - - /* change geometry constraint to the new source value */ - if (strcmp (s->val[option].s, FLATBED) == 0) - { - x_range=create_range(s->dev->model->x_size); - y_range=create_range(s->dev->model->y_size); - } - else - { - x_range=create_range(s->dev->model->x_size_ta); - y_range=create_range(s->dev->model->y_size_ta); - } - if(x_range==NULL || y_range==NULL) - { - return SANE_STATUS_NO_MEM; - } - - /* assign new values */ - free((void *)(size_t)s->opt[OPT_TL_X].constraint.range); - free((void *)(size_t)s->opt[OPT_TL_Y].constraint.range); - s->opt[OPT_TL_X].constraint.range = x_range; - s->val[OPT_TL_X].w = 0; - s->opt[OPT_TL_Y].constraint.range = y_range; - s->val[OPT_TL_Y].w = 0; - s->opt[OPT_BR_X].constraint.range = x_range; - s->val[OPT_BR_Y].w = y_range->max; - s->opt[OPT_BR_Y].constraint.range = y_range; - s->val[OPT_BR_X].w = x_range->max; - - /* signals reload */ - *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; - } - break; - case OPT_MODE: - if (s->val[option].s) - free (s->val[option].s); - s->val[option].s = strdup (val); - - if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_LINEART) == 0) - { - ENABLE (OPT_THRESHOLD); - ENABLE (OPT_THRESHOLD_CURVE); - DISABLE (OPT_BIT_DEPTH); - if (s->dev->model->asic_type != GENESYS_GL646 || !s->dev->model->is_cis) - { - ENABLE (OPT_COLOR_FILTER); - } - ENABLE (OPT_DISABLE_DYNAMIC_LINEART); - } - else - { - DISABLE (OPT_THRESHOLD); - DISABLE (OPT_THRESHOLD_CURVE); - DISABLE (OPT_DISABLE_DYNAMIC_LINEART); - if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_GRAY) == 0) - { - if (s->dev->model->asic_type != GENESYS_GL646 || !s->dev->model->is_cis) - { - ENABLE (OPT_COLOR_FILTER); - } - create_bpp_list (s, s->dev->model->bpp_gray_values); - } - else - { - DISABLE (OPT_COLOR_FILTER); - create_bpp_list (s, s->dev->model->bpp_color_values); - } - if (s->bpp_list[0] < 2) - DISABLE (OPT_BIT_DEPTH); - else - ENABLE (OPT_BIT_DEPTH); - } - RIE (calc_parameters (s)); - - /* if custom gamma, toggle gamma table options according to the mode */ - if (s->val[OPT_CUSTOM_GAMMA].b == SANE_TRUE) - { - if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_COLOR) == 0) - { - DISABLE (OPT_GAMMA_VECTOR); - ENABLE (OPT_GAMMA_VECTOR_R); - ENABLE (OPT_GAMMA_VECTOR_G); - ENABLE (OPT_GAMMA_VECTOR_B); - } - else - { - ENABLE (OPT_GAMMA_VECTOR); - DISABLE (OPT_GAMMA_VECTOR_R); - DISABLE (OPT_GAMMA_VECTOR_G); - DISABLE (OPT_GAMMA_VECTOR_B); - } - } - - *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; - break; - case OPT_COLOR_FILTER: - if (s->val[option].s) - free (s->val[option].s); - s->val[option].s = strdup (val); - RIE (calc_parameters (s)); - break; - case OPT_CALIBRATION_FILE: - RIE(set_calibration_value (s, option, val)); - break; - case OPT_LAMP_OFF_TIME: - case OPT_EXPIRATION_TIME: - if (*(SANE_Word *) val != s->val[option].w) - { - s->val[option].w = *(SANE_Word *) val; - RIE (s->dev->model->cmd_set-> - set_powersaving (s->dev, s->val[option].w)); - } - break; - - case OPT_CUSTOM_GAMMA: - *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; - s->val[OPT_CUSTOM_GAMMA].b = *(SANE_Bool *) val; - - if (s->val[OPT_CUSTOM_GAMMA].b == SANE_TRUE) - { - if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0) - { - DISABLE (OPT_GAMMA_VECTOR); - ENABLE (OPT_GAMMA_VECTOR_R); - ENABLE (OPT_GAMMA_VECTOR_G); - ENABLE (OPT_GAMMA_VECTOR_B); - } - else - { - ENABLE (OPT_GAMMA_VECTOR); - DISABLE (OPT_GAMMA_VECTOR_R); - DISABLE (OPT_GAMMA_VECTOR_G); - DISABLE (OPT_GAMMA_VECTOR_B); - } - } - else - { - DISABLE (OPT_GAMMA_VECTOR); - DISABLE (OPT_GAMMA_VECTOR_R); - DISABLE (OPT_GAMMA_VECTOR_G); - DISABLE (OPT_GAMMA_VECTOR_B); - /* restore default sensor gamma table */ - /* currently there is no sensor's specific gamma table, - * tables are built by sanei_genesys_create_gamma_table */ - sanei_genesys_create_gamma_table (s->dev->sensor.gamma_table[GENESYS_RED], - s->opt[OPT_GAMMA_VECTOR_R].size / sizeof (SANE_Word), - s->opt[OPT_GAMMA_VECTOR_R].constraint.range->max, - s->opt[OPT_GAMMA_VECTOR_R].constraint.range->max, - s->dev->sensor.gamma[GENESYS_RED]); - sanei_genesys_create_gamma_table (s->dev->sensor.gamma_table[GENESYS_GREEN], - s->opt[OPT_GAMMA_VECTOR_G].size / sizeof (SANE_Word), - s->opt[OPT_GAMMA_VECTOR_G].constraint.range->max, - s->opt[OPT_GAMMA_VECTOR_G].constraint.range->max, - s->dev->sensor.gamma[GENESYS_GREEN]); - sanei_genesys_create_gamma_table (s->dev->sensor.gamma_table[GENESYS_BLUE], - s->opt[OPT_GAMMA_VECTOR_B].size / sizeof (SANE_Word), - s->opt[OPT_GAMMA_VECTOR_B].constraint.range->max, - s->opt[OPT_GAMMA_VECTOR_B].constraint.range->max, - s->dev->sensor.gamma[GENESYS_BLUE]); - } - break; - - case OPT_GAMMA_VECTOR: - table = (SANE_Word *) val; - for (i = 0; i < s->opt[option].size / sizeof (SANE_Word); i++) - { - s->dev->sensor.gamma_table[GENESYS_RED][i] = table[i]; - s->dev->sensor.gamma_table[GENESYS_GREEN][i] = table[i]; - s->dev->sensor.gamma_table[GENESYS_BLUE][i] = table[i]; - } - break; - case OPT_GAMMA_VECTOR_R: - table = (SANE_Word *) val; - for (i = 0; i < s->opt[option].size / sizeof (SANE_Word); i++) - { - s->dev->sensor.gamma_table[GENESYS_RED][i] = table[i]; - } - break; - case OPT_GAMMA_VECTOR_G: - table = (SANE_Word *) val; - for (i = 0; i < s->opt[option].size / sizeof (SANE_Word); i++) - { - s->dev->sensor.gamma_table[GENESYS_GREEN][i] = table[i]; - } - break; - case OPT_GAMMA_VECTOR_B: - table = (SANE_Word *) val; - for (i = 0; i < s->opt[option].size / sizeof (SANE_Word); i++) - { - s->dev->sensor.gamma_table[GENESYS_BLUE][i] = table[i]; - } - break; - case OPT_CALIBRATE: - status = s->dev->model->cmd_set->save_power (s->dev, SANE_FALSE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "%s: failed to disable power saving mode: %s\n", - __func__, sane_strstatus (status)); - } - else - status = genesys_scanner_calibration (s->dev); - /* not critical if this fails*/ - s->dev->model->cmd_set->save_power (s->dev, SANE_TRUE); - /* signals that sensors will have to be read again */ - *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; - break; - case OPT_CLEAR_CALIBRATION: - /* clear calibration cache */ - if (s->dev->calibration_cache != NULL) - { - for (cache = s->dev->calibration_cache; cache; cache = next_cache) - { - next_cache = cache->next; - free (cache->dark_average_data); - free (cache->white_average_data); - free (cache); - } - } - s->dev->calibration_cache = NULL; - /* remove file */ - unlink (s->dev->calib_file); - /* signals that sensors will have to be read again */ - *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; - break; - - default: - DBG (DBG_warn, "set_option_value: can't set unknown option %d\n", - option); - } - return status; -} - - -/* sets and gets scanner option values */ -SANE_Status -sane_control_option (SANE_Handle handle, SANE_Int option, - SANE_Action action, void *val, SANE_Int * info) -{ - Genesys_Scanner *s = handle; - SANE_Status status = SANE_STATUS_GOOD; - SANE_Word cap; - SANE_Int myinfo = 0; - - DBG (DBG_io2, - "sane_control_option: start: action = %s, option = %s (%d)\n", - (action == SANE_ACTION_GET_VALUE) ? "get" : (action == - SANE_ACTION_SET_VALUE) ? - "set" : (action == SANE_ACTION_SET_AUTO) ? "set_auto" : "unknown", - s->opt[option].name, option); - - if (info) - *info = 0; - - if (s->scanning) - { - DBG (DBG_warn, "sane_control_option: don't call this function while " - "scanning (option = %s (%d))\n", s->opt[option].name, option); - - return SANE_STATUS_DEVICE_BUSY; - } - if (option >= NUM_OPTIONS || option < 0) - { - DBG (DBG_warn, - "sane_control_option: option %d >= NUM_OPTIONS || option < 0\n", - option); - return SANE_STATUS_INVAL; - } - - cap = s->opt[option].cap; - - if (!SANE_OPTION_IS_ACTIVE (cap)) - { - DBG (DBG_warn, "sane_control_option: option %d is inactive\n", option); - return SANE_STATUS_INVAL; - } - - switch (action) - { - case SANE_ACTION_GET_VALUE: - status = get_option_value (s, option, val); - break; - - case SANE_ACTION_SET_VALUE: - if (!SANE_OPTION_IS_SETTABLE (cap)) - { - DBG (DBG_warn, "sane_control_option: option %d is not settable\n", - option); - return SANE_STATUS_INVAL; - } - - status = sanei_constrain_value (s->opt + option, val, &myinfo); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_warn, - "sane_control_option: sanei_constrain_value returned %s\n", - sane_strstatus (status)); - return status; - } - - status = set_option_value (s, option, val, &myinfo); - break; - - case SANE_ACTION_SET_AUTO: - DBG (DBG_error, - "sane_control_option: SANE_ACTION_SET_AUTO unsupported since no option has SANE_CAP_AUTOMATIC\n"); - status = SANE_STATUS_INVAL; - break; - - default: - DBG (DBG_warn, "sane_control_option: unknown action %d for option %d\n", - action, option); - status = SANE_STATUS_INVAL; - break; - } - - if (info) - *info = myinfo; - - DBG (DBG_io2, "sane_control_option: exit\n"); - return status; -} - - - -SANE_Status -sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) -{ - Genesys_Scanner *s = handle; - SANE_Status status; - - DBGSTART; - - /* don't recompute parameters once data reading is active, ie during scan */ - if(s->dev->read_active == SANE_FALSE) - { - RIE (calc_parameters (s)); - } - if (params) - { - *params = s->params; - - /* in the case of a sheetfed scanner, when full height is specified - * we override the computed line number with -1 to signal that we - * don't know the real document height. - * We don't do that doing buffering image for digital processing - */ - if (s->dev->model->is_sheetfed == SANE_TRUE - && s->dev->buffer_image == SANE_FALSE - && s->val[OPT_BR_Y].w == s->opt[OPT_BR_Y].constraint.range->max) - { - params->lines = -1; - } - } - - DBGCOMPLETED; - - return SANE_STATUS_GOOD; -} - -SANE_Status -sane_start (SANE_Handle handle) -{ - Genesys_Scanner *s = handle; - SANE_Status status=SANE_STATUS_GOOD; - - DBGSTART; - - if (s->val[OPT_TL_X].w >= s->val[OPT_BR_X].w) - { - DBG (DBG_error0, - "sane_start: top left x >= bottom right x --- exiting\n"); - return SANE_STATUS_INVAL; - } - if (s->val[OPT_TL_Y].w >= s->val[OPT_BR_Y].w) - { - DBG (DBG_error0, - "sane_start: top left y >= bottom right y --- exiting\n"); - return SANE_STATUS_INVAL; - } - - /* First make sure we have a current parameter set. Some of the - parameters will be overwritten below, but that's OK. */ - - RIE (calc_parameters (s)); - RIE (genesys_start_scan (s->dev, s->val[OPT_LAMP_OFF].w)); - - s->scanning = SANE_TRUE; - - /* allocate intermediate buffer when doing dynamic lineart */ - if(s->dev->settings.dynamic_lineart==SANE_TRUE) - { - RIE (sanei_genesys_buffer_free (&(s->dev->binarize_buffer))); - RIE (sanei_genesys_buffer_alloc (&(s->dev->binarize_buffer), s->dev->settings.pixels)); - RIE (sanei_genesys_buffer_free (&(s->dev->local_buffer))); - RIE (sanei_genesys_buffer_alloc (&(s->dev->local_buffer), s->dev->binarize_buffer.size * 8)); - } - - /* if one of the software enhancement option is selected, - * we do the scan internally, process picture then put it an internal - * buffer. Since cropping may change scan parameters, we recompute them - * at the end */ - if (s->dev->buffer_image) - { - RIE(genesys_buffer_image(s)); - - /* check if we need to skip this page, sheetfed scanners - * can go to next doc while flatbed ones can't */ - if (s->val[OPT_SWSKIP].w && IS_ACTIVE(OPT_SWSKIP)) - { - status = sanei_magic_isBlank(&s->params, - s->dev->img_buffer, - SANE_UNFIX(s->val[OPT_SWSKIP].w)); - if(status == SANE_STATUS_NO_DOCS) - { - if (s->dev->model->is_sheetfed == SANE_TRUE) - { - DBG (DBG_info, "sane_start: blank page, recurse\n"); - return sane_start(handle); - } - return status; - } - } - - /* deskew image if required */ - if(s->val[OPT_SWDESKEW].b == SANE_TRUE) - { - RIE(genesys_deskew(s)); - } - - /* despeck image if required */ - if(s->val[OPT_SWDESPECK].b == SANE_TRUE) - { - RIE(genesys_despeck(s)); - } - - /* crop image if required */ - if(s->val[OPT_SWCROP].b == SANE_TRUE) - { - RIE(genesys_crop(s)); - } - - /* de-rotate image if required */ - if(s->val[OPT_SWDEROTATE].b == SANE_TRUE) - { - RIE(genesys_derotate(s)); - } - } - - DBGCOMPLETED; - return status; -} - -SANE_Status -sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, - SANE_Int * len) -{ - Genesys_Scanner *s = handle; - Genesys_Device *dev; - SANE_Status status=SANE_STATUS_GOOD; - size_t local_len; - - if (!s) - { - DBG (DBG_error, "sane_read: handle is null!\n"); - return SANE_STATUS_INVAL; - } - - dev=s->dev; - if (!dev) - { - DBG (DBG_error, "sane_read: dev is null!\n"); - return SANE_STATUS_INVAL; - } - - if (!buf) - { - DBG (DBG_error, "sane_read: buf is null!\n"); - return SANE_STATUS_INVAL; - } - - if (!len) - { - DBG (DBG_error, "sane_read: len is null!\n"); - return SANE_STATUS_INVAL; - } - - *len = 0; - - if (!s->scanning) - { - DBG (DBG_warn, "sane_read: scan was cancelled, is over or has not been " - "initiated yet\n"); - return SANE_STATUS_CANCELLED; - } - - DBG (DBG_proc, "sane_read: start, %d maximum bytes required\n", max_len); - DBG (DBG_io2, "sane_read: bytes_to_read=%lu, total_bytes_read=%lu\n", - (u_long) dev->total_bytes_to_read, (u_long) dev->total_bytes_read); - DBG (DBG_io2, "sane_read: physical bytes to read = %lu\n", (u_long) dev->read_bytes_left); - - if(dev->total_bytes_read>=dev->total_bytes_to_read) - { - DBG (DBG_proc, "sane_read: nothing more to scan: EOF\n"); - - /* issue park command immediatly in case scanner can handle it - * so we save time */ - if (dev->model->is_sheetfed == SANE_FALSE - && !(dev->model->flags & GENESYS_FLAG_MUST_WAIT) - && dev->parking == SANE_FALSE) - { - dev->model->cmd_set->slow_back_home (dev, SANE_FALSE); - dev->parking = SANE_TRUE; - } - return SANE_STATUS_EOF; - } - - local_len = max_len; - - /* in case of image processing, all data has been stored in - * buffer_image. So read data from it if it exists, else from scanner */ - if(!dev->buffer_image) - { - /* dynamic lineart is another kind of digital processing that needs - * another layer of buffering on top of genesys_read_ordered_data */ - if(dev->settings.dynamic_lineart==SANE_TRUE) - { - /* if buffer is empty, fill it with genesys_read_ordered_data */ - if(dev->binarize_buffer.avail==0) - { - /* store gray data */ - local_len=dev->local_buffer.size; - status = genesys_read_ordered_data (dev, dev->local_buffer.buffer, &local_len); - - /* binarize data is read successful */ - if(status==SANE_STATUS_GOOD) - { - dev->local_buffer.avail=local_len; - dev->local_buffer.pos=0; - dev->binarize_buffer.avail=local_len/8; - dev->binarize_buffer.pos=0; - genesys_gray_lineart (dev, - dev->local_buffer.buffer, - dev->binarize_buffer.buffer, - dev->settings.pixels, - local_len/dev->settings.pixels, - dev->settings.threshold); - } - - } - - /* return data from lineart buffer if any, up to the available amount */ - local_len = max_len; - if((size_t)max_len>dev->binarize_buffer.avail) - { - local_len=dev->binarize_buffer.avail; - } - if(local_len) - { - memcpy(buf,sanei_genesys_buffer_get_read_pos (&(dev->binarize_buffer)),local_len); - RIE (sanei_genesys_buffer_consume (&(dev->binarize_buffer), local_len)); - } - } - else - { - /* most usual case, direct read of data from scanner */ - status = genesys_read_ordered_data (dev, buf, &local_len); - } - } - else /* read data from buffer */ - { - if(dev->total_bytes_read+local_len>dev->total_bytes_to_read) - { - local_len=dev->total_bytes_to_read-dev->total_bytes_read; - } - memcpy(buf,dev->img_buffer+dev->total_bytes_read,local_len); - dev->total_bytes_read+=local_len; - } - - *len = local_len; - if(local_len>(size_t)max_len) - { - fprintf (stderr, "[genesys] sane_read: returning incorrect length!!\n"); - } - DBG (DBG_proc, "sane_read: %d bytes returned\n", *len); - return status; -} - -void -sane_cancel (SANE_Handle handle) -{ - Genesys_Scanner *s = handle; - SANE_Status status = SANE_STATUS_GOOD; - - DBGSTART; - - /* end binary logging if needed */ - if (s->dev->binary!=NULL) - { - fclose(s->dev->binary); - s->dev->binary=NULL; - } - - s->scanning = SANE_FALSE; - s->dev->read_active = SANE_FALSE; - if(s->dev->img_buffer!=NULL) - { - free(s->dev->img_buffer); - s->dev->img_buffer=NULL; - } - - /* no need to end scan if we are parking the head */ - if(s->dev->parking==SANE_FALSE) - { - status = s->dev->model->cmd_set->end_scan (s->dev, s->dev->reg, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "sane_cancel: failed to end scan: %s\n", - sane_strstatus (status)); - return; - } - } - - /* park head if flatbed scanner */ - if (s->dev->model->is_sheetfed == SANE_FALSE) - { - if(s->dev->parking==SANE_FALSE) - { - status = s->dev->model->cmd_set->slow_back_home (s->dev, s->dev->model->flags & GENESYS_FLAG_MUST_WAIT); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, - "sane_cancel: failed to move scanhead to home position: %s\n", - sane_strstatus (status)); - return; - } - s->dev->parking = !(s->dev->model->flags & GENESYS_FLAG_MUST_WAIT); - } - } - else - { /* in case of sheetfed scanners, we have to eject the document if still present */ - status = s->dev->model->cmd_set->eject_document (s->dev); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "sane_cancel: failed to eject document: %s\n", - sane_strstatus (status)); - return; - } - } - - /* enable power saving mode unless we are parking .... */ - if(s->dev->parking==SANE_FALSE) - { - status = s->dev->model->cmd_set->save_power (s->dev, SANE_TRUE); - if (status != SANE_STATUS_GOOD) - { - DBG (DBG_error, "sane_cancel: failed to enable power saving mode: %s\n", - sane_strstatus (status)); - return; - } - } - - DBGCOMPLETED; - return; -} - -SANE_Status -sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) -{ - Genesys_Scanner *s = handle; - - DBG (DBG_proc, "sane_set_io_mode: handle = %p, non_blocking = %s\n", - handle, non_blocking == SANE_TRUE ? "true" : "false"); - - if (!s->scanning) - { - DBG (DBG_error, "sane_set_io_mode: not scanning\n"); - return SANE_STATUS_INVAL; - } - if (non_blocking) - return SANE_STATUS_UNSUPPORTED; - return SANE_STATUS_GOOD; -} - -SANE_Status -sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) -{ - Genesys_Scanner *s = handle; - - DBG (DBG_proc, "sane_get_select_fd: handle = %p, fd = %p\n", handle, - (void *) fd); - - if (!s->scanning) - { - DBG (DBG_error, "sane_get_select_fd: not scanning\n"); - return SANE_STATUS_INVAL; - } - return SANE_STATUS_UNSUPPORTED; -} - -/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */ |