kopia lustrzana https://gitlab.com/sane-project/backends
2532 wiersze
107 KiB
C
2532 wiersze
107 KiB
C
/* sane - Scanner Access Now Easy.
|
|
|
|
pieusb_specific.c
|
|
|
|
Copyright (C) 2012-2015 Jan Vleeshouwers, Michael Rickmann, Klaus Kaempf
|
|
|
|
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, see <https://www.gnu.org/licenses/>.
|
|
|
|
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. */
|
|
|
|
/* =========================================================================
|
|
*
|
|
* Various Pieusb backend specific functions
|
|
*
|
|
* Option handling, configuration file handling, post-processing
|
|
*
|
|
* ========================================================================= */
|
|
|
|
#define DEBUG_DECLARE_ONLY
|
|
#include "pieusb.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include "../include/sane/sane.h"
|
|
#include "../include/sane/saneopts.h"
|
|
#include "../include/sane/sanei_config.h"
|
|
|
|
#include <errno.h>
|
|
#include <math.h>
|
|
#include <time.h>
|
|
|
|
#include "pieusb_usb.h"
|
|
#include "pieusb_scancmd.h"
|
|
#include "pieusb_buffer.h"
|
|
#include "pieusb_specific.h"
|
|
|
|
/* Pieusb specific */
|
|
|
|
/* sub to sanei_pieusb_find_device_callback() */
|
|
static SANE_Status pieusb_initialize_device_definition (Pieusb_Device_Definition* dev, Pieusb_Scanner_Properties* inq, const char* devicename, SANE_Word vendor_id, SANE_Word product_id);
|
|
static void pieusb_print_inquiry (Pieusb_Device_Definition * dev);
|
|
|
|
/* sub to sane_start() */
|
|
static void pieusb_calculate_shading(struct Pieusb_Scanner *scanner, SANE_Byte* buffer);
|
|
|
|
/* MR */
|
|
/* sub to sanei_pieusb_post() */
|
|
static SANE_Status pieusb_write_pnm_file (char *filename, uint16_t *data, int depth, int channels, int pixels_per_line, int lines);
|
|
|
|
/* Auxiliary */
|
|
static size_t max_string_size (SANE_String_Const const strings[]);
|
|
static double getGain(int gain);
|
|
static int getGainSetting(double gain);
|
|
/*
|
|
static void updateGain(Pieusb_Scanner *scanner, int color_index);
|
|
*/
|
|
static void updateGain2(Pieusb_Scanner *scanner, int color_index, double gain_increase);
|
|
|
|
/* --------------------------------------------------------------------------
|
|
*
|
|
* SPECIFIC PIEUSB
|
|
*
|
|
* --------------------------------------------------------------------------*/
|
|
|
|
/* Settings for byte order */
|
|
#define SCAN_IMG_FMT_OKLINE 0x08
|
|
#define SCAN_IMG_FMT_BLK_ONE 0x04
|
|
#define SCAN_IMG_FMT_MOTOROLA 0x02
|
|
#define SCAN_IMG_FMT_INTEL 0x01
|
|
|
|
/* Settings for scanner capabilities */
|
|
#define SCAN_CAP_PWRSAV 0x80
|
|
#define SCAN_CAP_EXT_CAL 0x40
|
|
#define SCAN_CAP_FAST_PREVIEW 0x10
|
|
#define SCAN_CAP_DISABLE_CAL 0x08
|
|
#define SCAN_CAP_SPEEDS 0x07
|
|
|
|
/* Available scanner options */
|
|
#define SCAN_OPT_DEV_MPCL 0x80
|
|
#define SCAN_OPT_DEV_TP1 0x04
|
|
#define SCAN_OPT_DEV_TP 0x02
|
|
#define SCAN_OPT_DEV_ADF 0x01
|
|
|
|
/* Options */
|
|
#define SANE_NAME_EXPOSURE_R "exposure-time-r"
|
|
#define SANE_TITLE_EXPOSURE_R "Exposure time red"
|
|
#define SANE_DESC_EXPOSURE_R "The time the red color filter of the CCD is exposed"
|
|
#define SANE_NAME_EXPOSURE_G "exposure-time-g"
|
|
#define SANE_TITLE_EXPOSURE_G "Exposure time green"
|
|
#define SANE_DESC_EXPOSURE_G "The time the green color filter of the CCD is exposed"
|
|
#define SANE_NAME_EXPOSURE_B "exposure-time-b"
|
|
#define SANE_TITLE_EXPOSURE_B "Exposure time blue"
|
|
#define SANE_DESC_EXPOSURE_B "The time the blue color filter of the CCD is exposed"
|
|
#define SANE_NAME_EXPOSURE_I "exposure-time-i"
|
|
#define SANE_TITLE_EXPOSURE_I "Exposure time infrared"
|
|
#define SANE_DESC_EXPOSURE_I "The time the infrared color filter of the CCD is exposed"
|
|
#define SANE_EXPOSURE_DEFAULT DEFAULT_EXPOSURE
|
|
#if 1
|
|
#define SANE_NAME_GAIN_R "gain-r"
|
|
#define SANE_TITLE_GAIN_R "Gain red"
|
|
#define SANE_DESC_GAIN_R "The gain of the signal processor for red"
|
|
#define SANE_NAME_GAIN_G "gain-g"
|
|
#define SANE_TITLE_GAIN_G "Gain green"
|
|
#define SANE_DESC_GAIN_G "The gain of the signal processor for green"
|
|
#define SANE_NAME_GAIN_B "gain-b"
|
|
#define SANE_TITLE_GAIN_B "Gain blue"
|
|
#define SANE_DESC_GAIN_B "The gain of the signal processor for blue"
|
|
#define SANE_NAME_GAIN_I "gain-i"
|
|
#define SANE_TITLE_GAIN_I "Gain infrared"
|
|
#define SANE_DESC_GAIN_I "The gain of the signal processor for infrared"
|
|
#define SANE_GAIN_DEFAULT DEFAULT_GAIN
|
|
|
|
#define SANE_NAME_OFFSET_R "offset-r"
|
|
#define SANE_TITLE_OFFSET_R "Offset red"
|
|
#define SANE_DESC_OFFSET_R "The offset of the signal processor for red"
|
|
#define SANE_NAME_OFFSET_G "offset-g"
|
|
#define SANE_TITLE_OFFSET_G "Offset greed"
|
|
#define SANE_DESC_OFFSET_G "The offset of the signal processor for green"
|
|
#define SANE_NAME_OFFSET_B "offset-b"
|
|
#define SANE_TITLE_OFFSET_B "Offset blue"
|
|
#define SANE_DESC_OFFSET_B "The offset of the signal processor for blue"
|
|
#define SANE_NAME_OFFSET_I "offset-i"
|
|
#define SANE_TITLE_OFFSET_I "Offset infrared"
|
|
#define SANE_DESC_OFFSET_I "The offset of the signal processor for infrared"
|
|
#define SANE_OFFSET_DEFAULT DEFAULT_OFFSET
|
|
#else
|
|
#define SANE_NAME_GAIN "gain"
|
|
#define SANE_TITLE_GAIN "Gain"
|
|
#define SANE_DESC_GAIN "The gain of the signal processor for the 4 CCD color filters (R,G,B,I)"
|
|
#define SANE_GAIN_DEFAULT 0x13
|
|
|
|
#define SANE_NAME_OFFSET "offset"
|
|
#define SANE_TITLE_OFFSET "Offset"
|
|
#define SANE_DESC_OFFSET "The offset of the signal processor for the 4 CCD color filters (R,G,B,I)"
|
|
#define SANE_OFFSET_DEFAULT 0
|
|
#endif
|
|
#define min(a,b) (((a)<(b))?(a):(b))
|
|
#define max(a,b) (((a)>(b))?(a):(b))
|
|
|
|
static const SANE_Range percentage_range_100 = {
|
|
0 << SANE_FIXED_SCALE_SHIFT, /* minimum */
|
|
100 << SANE_FIXED_SCALE_SHIFT, /* maximum */
|
|
0 << SANE_FIXED_SCALE_SHIFT /* quantization */
|
|
};
|
|
|
|
/* From the firmware disassembly */
|
|
static const SANE_Range gain_range = {
|
|
0, /* minimum */
|
|
63, /* maximum */
|
|
0 /* quantization */
|
|
};
|
|
|
|
/* From the firmware disassembly */
|
|
static const SANE_Range offset_range = {
|
|
0, /* minimum */
|
|
255, /* maximum */
|
|
0 /* quantization */
|
|
};
|
|
|
|
static const double gains[] = {
|
|
1.000, 1.075, 1.154, 1.251, 1.362, 1.491, 1.653, /* 0, 5, 10, 15, 20, 25, 30 */
|
|
1.858, 2.115, 2.458, 2.935, 3.638, 4.627 /* 35, 40, 45, 50, 55, 60 */
|
|
};
|
|
|
|
/**
|
|
* Callback called whenever a connected USB device reports a supported vendor
|
|
* and product id combination.
|
|
* Used by sane_init() and by sane_open().
|
|
*
|
|
* @param name Device name which has required vendor and product id
|
|
* @return SANE_STATUS_GOOD
|
|
*/
|
|
SANE_Status
|
|
sanei_pieusb_find_device_callback (const char *devicename)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
SANE_Status r;
|
|
Pieusb_Device_Definition *dev;
|
|
int device_number; /* index in usb devices list maintained by sani_usb */
|
|
Pieusb_Scanner_Properties inq;
|
|
int retry;
|
|
|
|
DBG (DBG_info_proc, "sanei_pieusb_find_device_callback: %s\n", devicename);
|
|
|
|
/* Check if device is present in the Pieusb device list */
|
|
for (dev = pieusb_definition_list_head; dev; dev = dev->next) {
|
|
if (strcmp (dev->sane.name, devicename) == 0) {
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
}
|
|
|
|
/* If not, create a new device struct */
|
|
dev = malloc (sizeof (*dev));
|
|
if (!dev) {
|
|
return SANE_STATUS_NO_MEM;
|
|
}
|
|
|
|
/* Get device number: index of the device in the sanei_usb devices list */
|
|
r = sanei_usb_open (devicename, &device_number);
|
|
if (r != SANE_STATUS_GOOD) {
|
|
free (dev);
|
|
DBG (DBG_error, "sanei_pieusb_find_device_callback: sanei_usb_open failed for device %s: %s\n",devicename,sane_strstatus(r));
|
|
return r;
|
|
}
|
|
|
|
/* Get device properties */
|
|
|
|
retry = 2;
|
|
while (retry > 0) {
|
|
retry--;
|
|
/* get inquiry data length */
|
|
sanei_pieusb_cmd_inquiry (device_number, &inq, 5, &status);
|
|
if (status.pieusb_status == PIEUSB_STATUS_GOOD) {
|
|
break;
|
|
}
|
|
else if (status.pieusb_status == PIEUSB_STATUS_IO_ERROR) {
|
|
if (retry > 0) {
|
|
DBG (DBG_info_proc, "inquiry failed, resetting usb\n");
|
|
if (sanei_pieusb_usb_reset(device_number) == SANE_STATUS_GOOD) {
|
|
continue; /* retry after IEEE1284 reset */
|
|
}
|
|
if (sanei_usb_reset(device_number) == SANE_STATUS_GOOD) {
|
|
continue; /* retry after USB reset */
|
|
}
|
|
}
|
|
}
|
|
free (dev);
|
|
DBG (DBG_error, "sanei_pieusb_find_device_callback: get scanner properties (5 bytes) failed with %d\n", status.pieusb_status);
|
|
sanei_usb_close (device_number);
|
|
return sanei_pieusb_convert_status (status.pieusb_status);
|
|
}
|
|
/* get full inquiry data */
|
|
sanei_pieusb_cmd_inquiry(device_number, &inq, inq.additionalLength+4, &status);
|
|
if (status.pieusb_status != PIEUSB_STATUS_GOOD) {
|
|
free (dev);
|
|
DBG (DBG_error, "sanei_pieusb_find_device_callback: get scanner properties failed\n");
|
|
sanei_usb_close (device_number);
|
|
return sanei_pieusb_convert_status (status.pieusb_status);
|
|
}
|
|
|
|
/* Close the device again */
|
|
sanei_usb_close(device_number);
|
|
|
|
/* Initialize device definition */
|
|
r = pieusb_initialize_device_definition(dev, &inq, devicename, pieusb_supported_usb_device.vendor, pieusb_supported_usb_device.product);
|
|
if (r != SANE_STATUS_GOOD) {
|
|
return r;
|
|
}
|
|
|
|
/* Output */
|
|
pieusb_print_inquiry (dev);
|
|
|
|
/* Check model number */
|
|
if (inq.model != pieusb_supported_usb_device.model) {
|
|
free (dev);
|
|
DBG (DBG_error, "sanei_pieusb_find_device_callback: wrong model number %d\n", inq.model);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
dev->flags = pieusb_supported_usb_device.flags;
|
|
|
|
/* Found a supported scanner, put it in the definitions list*/
|
|
DBG (DBG_info_proc, "sanei_pieusb_find_device_callback: success\n");
|
|
dev->next = pieusb_definition_list_head;
|
|
pieusb_definition_list_head = dev;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
* Full initialization of a Pieusb_Device structure from INQUIRY data.
|
|
* The function is used in find_device_callback(), so when sane_init() or
|
|
* sane_open() is called.
|
|
*
|
|
* @param dev
|
|
*/
|
|
static SANE_Status
|
|
pieusb_initialize_device_definition (Pieusb_Device_Definition* dev, Pieusb_Scanner_Properties* inq, const char* devicename,
|
|
SANE_Word vendor_id, SANE_Word product_id)
|
|
{
|
|
char *pp, *buf;
|
|
|
|
/* Initialize device definition */
|
|
dev->next = NULL;
|
|
dev->sane.name = strdup(devicename);
|
|
|
|
/* Create 0-terminated string without trailing spaces for vendor */
|
|
buf = malloc(9);
|
|
if (buf == NULL)
|
|
return SANE_STATUS_NO_MEM;
|
|
memcpy(buf, inq->vendor, 8);
|
|
pp = buf + 8;
|
|
*pp-- = '\0';
|
|
while (*pp == ' ') *pp-- = '\0';
|
|
dev->sane.vendor = buf;
|
|
|
|
/* Create 0-terminated string without trailing spaces for model */
|
|
buf = malloc(17);
|
|
if (buf == NULL)
|
|
return SANE_STATUS_NO_MEM;
|
|
memcpy(buf, inq->product, 16);
|
|
pp = buf + 16;
|
|
*pp-- = '\0';
|
|
while (*pp == ' ') *pp-- = '\0';
|
|
dev->sane.model = buf;
|
|
|
|
dev->sane.type = "film scanner";
|
|
dev->vendorId = vendor_id;
|
|
dev->productId = product_id;
|
|
|
|
/* Create 0-terminated strings without trailing spaces for revision */
|
|
buf = malloc(5);
|
|
if (buf == NULL)
|
|
return SANE_STATUS_NO_MEM;
|
|
memcpy(buf, inq->productRevision, 4);
|
|
pp = buf + 4;
|
|
*pp-- = '\0';
|
|
while (*pp == ' ') *pp-- = '\0';
|
|
dev->version = buf;
|
|
|
|
dev->model = inq->model;
|
|
|
|
/* Maximum resolution values */
|
|
dev->maximum_resolution_x = inq->maxResolutionX;
|
|
dev->maximum_resolution_y = inq->maxResolutionY;
|
|
if (dev->maximum_resolution_y < 256) {
|
|
/* y res is a multiplier */
|
|
dev->maximum_resolution = dev->maximum_resolution_x;
|
|
dev->maximum_resolution_x *= dev->maximum_resolution_y;
|
|
dev->maximum_resolution_y = dev->maximum_resolution_x;
|
|
} else {
|
|
/* y res really is resolution */
|
|
dev->maximum_resolution = min (dev->maximum_resolution_x, dev->maximum_resolution_y);
|
|
}
|
|
|
|
/* Geometry */
|
|
dev->scan_bed_width = (double) inq->maxScanWidth / dev->maximum_resolution;
|
|
dev->scan_bed_height = (double) inq->maxScanHeight / dev->maximum_resolution;
|
|
dev->slide_top_left_x = inq->x0;
|
|
dev->slide_top_left_y = inq->y0;
|
|
dev->slide_width = (double) (inq->x1 - inq->x0) / dev->maximum_resolution;
|
|
dev->slide_height = (double) (inq->y1 - inq->y0) / dev->maximum_resolution;
|
|
|
|
/* Integer and bit-encoded properties */
|
|
dev->halftone_patterns = inq->halftones & 0x0f;
|
|
dev->color_filters = inq->filters;
|
|
dev->color_depths = inq->colorDepths;
|
|
dev->color_formats = inq->colorFormat;
|
|
dev->image_formats = inq->imageFormat;
|
|
dev->scan_capabilities = inq->scanCapability;
|
|
dev->optional_devices = inq->optionalDevices;
|
|
dev->enhancements = inq->enhancements;
|
|
dev->gamma_bits = inq->gammaBits;
|
|
dev->fast_preview_resolution = inq->previewScanResolution;
|
|
dev->minimum_highlight = inq->minumumHighlight;
|
|
dev->maximum_shadow = inq->maximumShadow;
|
|
dev->calibration_equation = inq->calibrationEquation;
|
|
dev->minimum_exposure = inq->minimumExposure;
|
|
dev->maximum_exposure = inq->maximumExposure*4; /* *4 to solve the strange situation that the default value is out of range */
|
|
|
|
dev->x0 = inq->x0;
|
|
dev->y0 = inq->y0;
|
|
dev->x1 = inq->x1;
|
|
dev->y1 = inq->y1;
|
|
dev->production = strndup(inq->production, 4);
|
|
dev->timestamp = strndup(inq->timestamp, 20);
|
|
dev->signature = (char *)strndup((char *)inq->signature, 40);
|
|
|
|
/* Ranges for various quantities */
|
|
dev->x_range.min = SANE_FIX (0);
|
|
dev->x_range.quant = SANE_FIX (0);
|
|
dev->x_range.max = SANE_FIX (dev->scan_bed_width * MM_PER_INCH);
|
|
|
|
dev->y_range.min = SANE_FIX (0);
|
|
dev->y_range.quant = SANE_FIX (0);
|
|
dev->y_range.max = SANE_FIX (dev->scan_bed_height * MM_PER_INCH);
|
|
|
|
dev->dpi_range.min = SANE_FIX (25);
|
|
dev->dpi_range.quant = SANE_FIX (1);
|
|
dev->dpi_range.max = SANE_FIX (max (dev->maximum_resolution_x, dev->maximum_resolution_y));
|
|
|
|
dev->shadow_range.min = SANE_FIX (0);
|
|
dev->shadow_range.quant = SANE_FIX (1);
|
|
dev->shadow_range.max = SANE_FIX (dev->maximum_shadow);
|
|
|
|
dev->highlight_range.min = SANE_FIX (dev->minimum_highlight);
|
|
dev->highlight_range.quant = SANE_FIX (1);
|
|
dev->highlight_range.max = SANE_FIX (100);
|
|
|
|
dev->exposure_range.min = dev->minimum_exposure;
|
|
dev->exposure_range.quant = 1;
|
|
dev->exposure_range.max = dev->maximum_exposure;
|
|
|
|
dev->dust_range.min = 0;
|
|
dev->dust_range.quant = 1;
|
|
dev->dust_range.max = 100;
|
|
|
|
/* Enumerated ranges vor various quantities */
|
|
/*TODO: create from inq->filters */
|
|
dev->scan_mode_list[0] = SANE_VALUE_SCAN_MODE_LINEART;
|
|
dev->scan_mode_list[1] = SANE_VALUE_SCAN_MODE_HALFTONE;
|
|
dev->scan_mode_list[2] = SANE_VALUE_SCAN_MODE_GRAY;
|
|
dev->scan_mode_list[3] = SANE_VALUE_SCAN_MODE_COLOR;
|
|
dev->scan_mode_list[4] = SANE_VALUE_SCAN_MODE_RGBI;
|
|
dev->scan_mode_list[5] = 0;
|
|
|
|
dev->calibration_mode_list[0] = SCAN_CALIBRATION_DEFAULT;
|
|
dev->calibration_mode_list[1] = SCAN_CALIBRATION_AUTO;
|
|
dev->calibration_mode_list[2] = SCAN_CALIBRATION_PREVIEW;
|
|
dev->calibration_mode_list[3] = SCAN_CALIBRATION_OPTIONS;
|
|
dev->calibration_mode_list[4] = 0;
|
|
|
|
dev->gain_adjust_list[0] = SCAN_GAIN_ADJUST_03;
|
|
dev->gain_adjust_list[1] = SCAN_GAIN_ADJUST_05;
|
|
dev->gain_adjust_list[2] = SCAN_GAIN_ADJUST_08;
|
|
dev->gain_adjust_list[3] = SCAN_GAIN_ADJUST_10;
|
|
dev->gain_adjust_list[4] = SCAN_GAIN_ADJUST_12;
|
|
dev->gain_adjust_list[5] = SCAN_GAIN_ADJUST_16;
|
|
dev->gain_adjust_list[6] = SCAN_GAIN_ADJUST_19;
|
|
dev->gain_adjust_list[7] = SCAN_GAIN_ADJUST_24;
|
|
dev->gain_adjust_list[8] = SCAN_GAIN_ADJUST_30;
|
|
dev->gain_adjust_list[9] = 0;
|
|
|
|
/*TODO: create from inq->colorDepths? Maybe not: didn't experiment with
|
|
* 4 and 12 bit depths. Don;t know how they behave. */
|
|
dev->bpp_list[0] = 3; /* count */
|
|
dev->bpp_list[1] = 1;
|
|
dev->bpp_list[2] = 8;
|
|
dev->bpp_list[3] = 16;
|
|
|
|
/* Infrared */
|
|
dev->ir_sw_list[0] = "None";
|
|
dev->ir_sw_list[1] = "Reduce red overlap";
|
|
dev->ir_sw_list[2] = "Remove dirt";
|
|
dev->ir_sw_list[3] = 0;
|
|
|
|
dev->grain_sw_list[0] = 4;
|
|
dev->grain_sw_list[1] = 0;
|
|
dev->grain_sw_list[2] = 1;
|
|
dev->grain_sw_list[3] = 2;
|
|
dev->grain_sw_list[4] = 3;
|
|
dev->grain_sw_list[5] = 0;
|
|
|
|
dev->crop_sw_list[0] = "None";
|
|
dev->crop_sw_list[1] = "Outside";
|
|
dev->crop_sw_list[2] = "Inside";
|
|
dev->crop_sw_list[3] = 0;
|
|
|
|
/* halftone_list */
|
|
dev->halftone_list[0] = "53lpi 45d ROUND"; /* 8x8 pattern */
|
|
dev->halftone_list[1] = "70lpi 45d ROUND"; /* 6x6 pattern */
|
|
dev->halftone_list[2] = "75lpi Hori. Line"; /* 4x4 pattern */
|
|
dev->halftone_list[3] = "4X4 BAYER"; /* 4x4 pattern */
|
|
dev->halftone_list[4] = "4X4 SCROLL"; /* 4x4 pattern */
|
|
dev->halftone_list[5] = "5x5 26 Levels"; /* 5x5 pattern */
|
|
dev->halftone_list[6] = "4x4 SQUARE"; /* 4x4 pattern */
|
|
dev->halftone_list[7] = "5x5 TILE"; /* 5x5 pattern */
|
|
dev->halftone_list[8] = 0;
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
* Output device definition.
|
|
* The function is used in find_device_callback(), so when sane_init() or
|
|
* sane_open() is called.
|
|
*
|
|
* @param dev Device to output
|
|
*/
|
|
static void
|
|
pieusb_print_inquiry (Pieusb_Device_Definition * dev)
|
|
{
|
|
DBG (DBG_inquiry, "INQUIRY:\n");
|
|
DBG (DBG_inquiry, "========\n");
|
|
DBG (DBG_inquiry, "\n");
|
|
DBG (DBG_inquiry, "vendor........................: '%s'\n", dev->sane.vendor);
|
|
DBG (DBG_inquiry, "product.......................: '%s'\n", dev->sane.model);
|
|
DBG (DBG_inquiry, "model .......................: 0x%04x\n", dev->model);
|
|
DBG (DBG_inquiry, "version.......................: '%s'\n", dev->version);
|
|
|
|
DBG (DBG_inquiry, "X resolution..................: %d dpi\n",
|
|
dev->maximum_resolution_x);
|
|
DBG (DBG_inquiry, "Y resolution..................: %d dpi\n",
|
|
dev->maximum_resolution_y);
|
|
DBG (DBG_inquiry, "pixel resolution..............: %d dpi\n",
|
|
dev->maximum_resolution);
|
|
DBG (DBG_inquiry, "fb width......................: %f in\n",
|
|
dev->scan_bed_width);
|
|
DBG (DBG_inquiry, "fb length.....................: %f in\n",
|
|
dev->scan_bed_height);
|
|
|
|
DBG (DBG_inquiry, "transparency width............: %f in\n",
|
|
dev->slide_width);
|
|
DBG (DBG_inquiry, "transparency length...........: %f in\n",
|
|
dev->slide_height);
|
|
DBG (DBG_inquiry, "transparency offset...........: %d,%d\n",
|
|
dev->slide_top_left_x, dev->slide_top_left_y);
|
|
|
|
DBG (DBG_inquiry, "# of halftones................: %d\n",
|
|
dev->halftone_patterns);
|
|
|
|
DBG (DBG_inquiry, "One pass color................: %s\n",
|
|
dev->color_filters & SCAN_ONE_PASS_COLOR ? "yes" : "no");
|
|
|
|
DBG (DBG_inquiry, "Filters.......................: %s%s%s%s%s (%02x)\n",
|
|
dev->color_filters & SCAN_FILTER_INFRARED ? "Infrared " : "",
|
|
dev->color_filters & SCAN_FILTER_RED ? "Red " : "",
|
|
dev->color_filters & SCAN_FILTER_GREEN ? "Green " : "",
|
|
dev->color_filters & SCAN_FILTER_BLUE ? "Blue " : "",
|
|
dev->color_filters & SCAN_FILTER_NEUTRAL ? "Neutral " : "",
|
|
dev->color_filters);
|
|
|
|
DBG (DBG_inquiry, "Color depths..................: %s%s%s%s%s%s (%02x)\n",
|
|
dev->color_depths & SCAN_COLOR_DEPTH_16 ? "16 bit " : "",
|
|
dev->color_depths & SCAN_COLOR_DEPTH_12 ? "12 bit " : "",
|
|
dev->color_depths & SCAN_COLOR_DEPTH_10 ? "10 bit " : "",
|
|
dev->color_depths & SCAN_COLOR_DEPTH_8 ? "8 bit " : "",
|
|
dev->color_depths & SCAN_COLOR_DEPTH_4 ? "4 bit " : "",
|
|
dev->color_depths & SCAN_COLOR_DEPTH_1 ? "1 bit " : "",
|
|
dev->color_depths);
|
|
|
|
DBG (DBG_inquiry, "Color Format..................: %s%s%s (%02x)\n",
|
|
dev->color_formats & SCAN_COLOR_FORMAT_INDEX ? "Indexed " : "",
|
|
dev->color_formats & SCAN_COLOR_FORMAT_LINE ? "Line " : "",
|
|
dev->color_formats & SCAN_COLOR_FORMAT_PIXEL ? "Pixel " : "",
|
|
dev->color_formats);
|
|
|
|
DBG (DBG_inquiry, "Image Format..................: %s%s%s%s (%02x)\n",
|
|
dev->image_formats & SCAN_IMG_FMT_OKLINE ? "OKLine " : "",
|
|
dev->image_formats & SCAN_IMG_FMT_BLK_ONE ? "BlackOne " : "",
|
|
dev->image_formats & SCAN_IMG_FMT_MOTOROLA ? "Motorola " : "",
|
|
dev->image_formats & SCAN_IMG_FMT_INTEL ? "Intel" : "",
|
|
dev->image_formats);
|
|
|
|
DBG (DBG_inquiry,
|
|
"Scan Capability...............: %s%s%s%s%d speeds (%02x)\n",
|
|
dev->scan_capabilities & SCAN_CAP_PWRSAV ? "PowerSave " : "",
|
|
dev->scan_capabilities & SCAN_CAP_EXT_CAL ? "ExtCal " : "",
|
|
dev->scan_capabilities & SCAN_CAP_FAST_PREVIEW ? "FastPreview" :
|
|
"",
|
|
dev->scan_capabilities & SCAN_CAP_DISABLE_CAL ? "DisCal " : "",
|
|
dev->scan_capabilities & SCAN_CAP_SPEEDS,
|
|
dev->scan_capabilities);
|
|
|
|
DBG (DBG_inquiry, "Optional Devices..............: %s%s%s%s (%02x)\n",
|
|
dev->optional_devices & SCAN_OPT_DEV_MPCL ? "MultiPageLoad " :
|
|
"",
|
|
dev->optional_devices & SCAN_OPT_DEV_TP1 ? "TransModule1 " : "",
|
|
dev->optional_devices & SCAN_OPT_DEV_TP ? "TransModule " : "",
|
|
dev->optional_devices & SCAN_OPT_DEV_ADF ? "ADF " : "",
|
|
dev->optional_devices);
|
|
|
|
DBG (DBG_inquiry, "Enhancement...................: %02x\n",
|
|
dev->enhancements);
|
|
DBG (DBG_inquiry, "Gamma bits....................: %d\n",
|
|
dev->gamma_bits);
|
|
|
|
DBG (DBG_inquiry, "Fast Preview Resolution.......: %d\n",
|
|
dev->fast_preview_resolution);
|
|
DBG (DBG_inquiry, "Min Highlight.................: %d\n",
|
|
dev->minimum_highlight);
|
|
DBG (DBG_inquiry, "Max Shadow....................: %d\n",
|
|
dev->maximum_shadow);
|
|
DBG (DBG_inquiry, "Cal Eqn.......................: %d\n",
|
|
dev->calibration_equation);
|
|
DBG (DBG_inquiry, "Min Exposure..................: %d\n",
|
|
dev->minimum_exposure);
|
|
DBG (DBG_inquiry, "Max Exposure..................: %d\n",
|
|
dev->maximum_exposure);
|
|
|
|
DBG (DBG_inquiry, "x0,y0 x1,y1...................: %d,%d %d,%d\n",
|
|
dev->x0, dev->y0, dev->x1, dev->y1);
|
|
DBG (DBG_inquiry, "production....................: '%s'\n",
|
|
dev->production);
|
|
DBG (DBG_inquiry, "timestamp.....................: '%s'\n",
|
|
dev->timestamp);
|
|
DBG (DBG_inquiry, "signature.....................: '%s'\n",
|
|
dev->signature);
|
|
|
|
}
|
|
|
|
/**
|
|
* Initiaize scanner options from the device definition and from exposure,
|
|
* gain and offset defaults. The function is called by sane_open(), when no
|
|
* optimized settings are available yet. The scanner object is fully
|
|
* initialized in sane_start().
|
|
*
|
|
* @param scanner Scanner to initialize
|
|
* @return SANE_STATUS_GOOD
|
|
*/
|
|
SANE_Status
|
|
sanei_pieusb_init_options (Pieusb_Scanner* scanner)
|
|
{
|
|
int i;
|
|
|
|
DBG (DBG_info_proc, "sanei_pieusb_init_options\n");
|
|
|
|
memset (scanner->opt, 0, sizeof (scanner->opt));
|
|
memset (scanner->val, 0, sizeof (scanner->val));
|
|
|
|
for (i = 0; i < NUM_OPTIONS; ++i) {
|
|
scanner->opt[i].size = sizeof (SANE_Word);
|
|
scanner->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
|
|
}
|
|
|
|
/* Number of options (a pseudo-option) */
|
|
scanner->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
|
|
scanner->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
|
|
scanner->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
|
|
scanner->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
|
|
scanner->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
|
|
scanner->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
|
|
|
|
/* "Mode" group: */
|
|
scanner->opt[OPT_MODE_GROUP].title = "Scan Mode";
|
|
scanner->opt[OPT_MODE_GROUP].desc = "";
|
|
scanner->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
|
|
scanner->opt[OPT_MODE_GROUP].cap = 0;
|
|
scanner->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* scan mode */
|
|
scanner->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
|
|
scanner->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
|
|
scanner->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
|
|
scanner->opt[OPT_MODE].type = SANE_TYPE_STRING;
|
|
scanner->opt[OPT_MODE].size = max_string_size ((SANE_String_Const const *) scanner->device->scan_mode_list);
|
|
scanner->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
|
|
scanner->opt[OPT_MODE].constraint.string_list = (SANE_String_Const const *) scanner->device->scan_mode_list;
|
|
scanner->val[OPT_MODE].s = (SANE_Char *) strdup (scanner->device->scan_mode_list[3]); /* default RGB */
|
|
|
|
/* bit depth */
|
|
scanner->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH;
|
|
scanner->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
|
|
scanner->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH;
|
|
scanner->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT;
|
|
scanner->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
|
|
scanner->opt[OPT_BIT_DEPTH].size = sizeof (SANE_Word);
|
|
scanner->opt[OPT_BIT_DEPTH].constraint.word_list = scanner->device->bpp_list;
|
|
scanner->val[OPT_BIT_DEPTH].w = scanner->device->bpp_list[2];
|
|
|
|
/* resolution */
|
|
scanner->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
|
|
scanner->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
|
|
scanner->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
|
|
scanner->opt[OPT_RESOLUTION].type = SANE_TYPE_FIXED;
|
|
scanner->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
|
|
scanner->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[OPT_RESOLUTION].constraint.range = &scanner->device->dpi_range;
|
|
scanner->val[OPT_RESOLUTION].w = scanner->device->fast_preview_resolution << SANE_FIXED_SCALE_SHIFT;
|
|
|
|
/* halftone pattern */
|
|
scanner->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
|
|
scanner->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
|
|
scanner->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
|
|
scanner->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
|
|
scanner->opt[OPT_HALFTONE_PATTERN].size = max_string_size ((SANE_String_Const const *) scanner->device->halftone_list);
|
|
scanner->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_STRING_LIST;
|
|
scanner->opt[OPT_HALFTONE_PATTERN].constraint.string_list = (SANE_String_Const const *) scanner->device->halftone_list;
|
|
scanner->val[OPT_HALFTONE_PATTERN].s = (SANE_Char *) strdup (scanner->device->halftone_list[6]);
|
|
scanner->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; /* Not implemented, and only meaningful at depth 1 */
|
|
|
|
/* lineart threshold */
|
|
scanner->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
|
|
scanner->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
|
|
scanner->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
|
|
scanner->opt[OPT_THRESHOLD].type = SANE_TYPE_FIXED;
|
|
scanner->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT;
|
|
scanner->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[OPT_THRESHOLD].constraint.range = &percentage_range_100;
|
|
scanner->val[OPT_THRESHOLD].w = SANE_FIX (50);
|
|
/* scanner->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; Not implemented, and only meaningful at depth 1 */
|
|
|
|
/* create a sharper scan at the cost of scan time */
|
|
scanner->opt[OPT_SHARPEN].name = "sharpen";
|
|
scanner->opt[OPT_SHARPEN].title = "Sharpen scan";
|
|
scanner->opt[OPT_SHARPEN].desc = "Sharpen scan by taking more time to discharge the CCD.";
|
|
scanner->opt[OPT_SHARPEN].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_SHARPEN].unit = SANE_UNIT_NONE;
|
|
scanner->opt[OPT_SHARPEN].constraint_type = SANE_CONSTRAINT_NONE;
|
|
scanner->val[OPT_SHARPEN].b = SANE_FALSE;
|
|
scanner->opt[OPT_SHARPEN].cap |= SANE_CAP_SOFT_SELECT;
|
|
|
|
/* skip the auto-calibration phase before the scan */
|
|
scanner->opt[OPT_SHADING_ANALYSIS].name = "shading-analysis";
|
|
scanner->opt[OPT_SHADING_ANALYSIS].title = "Perform shading analysis";
|
|
scanner->opt[OPT_SHADING_ANALYSIS].desc = "Collect shading reference data before scanning the image. If set to 'no', this option may be overridden by the scanner.";
|
|
scanner->opt[OPT_SHADING_ANALYSIS].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_SHADING_ANALYSIS].unit = SANE_UNIT_NONE;
|
|
scanner->opt[OPT_SHADING_ANALYSIS].constraint_type = SANE_CONSTRAINT_NONE;
|
|
scanner->val[OPT_SHADING_ANALYSIS].b = SANE_FALSE;
|
|
scanner->opt[OPT_SHADING_ANALYSIS].cap |= SANE_CAP_SOFT_SELECT;
|
|
|
|
/* use auto-calibration settings for scan */
|
|
scanner->opt[OPT_CALIBRATION_MODE].name = "calibration";
|
|
scanner->opt[OPT_CALIBRATION_MODE].title = "Calibration mode";
|
|
scanner->opt[OPT_CALIBRATION_MODE].desc = "How to calibrate the scanner.";
|
|
scanner->opt[OPT_CALIBRATION_MODE].type = SANE_TYPE_STRING;
|
|
scanner->opt[OPT_CALIBRATION_MODE].size = max_string_size ((SANE_String_Const const *) scanner->device->calibration_mode_list);
|
|
scanner->opt[OPT_CALIBRATION_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
|
|
scanner->opt[OPT_CALIBRATION_MODE].constraint.string_list = (SANE_String_Const const *) scanner->device->calibration_mode_list;
|
|
scanner->val[OPT_CALIBRATION_MODE].s = (SANE_Char *) strdup (scanner->device->calibration_mode_list[1]); /* default auto */
|
|
|
|
/* OPT_GAIN_ADJUST */
|
|
scanner->opt[OPT_GAIN_ADJUST].name = "gain-adjust";
|
|
scanner->opt[OPT_GAIN_ADJUST].title = "Adjust gain";
|
|
scanner->opt[OPT_GAIN_ADJUST].desc = "Adjust gain determined by calibration procedure.";
|
|
scanner->opt[OPT_GAIN_ADJUST].type = SANE_TYPE_STRING;
|
|
scanner->opt[OPT_GAIN_ADJUST].size = max_string_size ((SANE_String_Const const *) scanner->device->gain_adjust_list);
|
|
scanner->opt[OPT_GAIN_ADJUST].constraint_type = SANE_CONSTRAINT_STRING_LIST;
|
|
scanner->opt[OPT_GAIN_ADJUST].constraint.string_list = (SANE_String_Const const *) scanner->device->gain_adjust_list;
|
|
scanner->val[OPT_GAIN_ADJUST].s = (SANE_Char *) strdup (scanner->device->gain_adjust_list[2]); /* x 1.0 (no change) */
|
|
|
|
/* scan infrared channel faster but less accurate */
|
|
scanner->opt[OPT_FAST_INFRARED].name = "fast-infrared";
|
|
scanner->opt[OPT_FAST_INFRARED].title = "Fast infrared scan";
|
|
scanner->opt[OPT_FAST_INFRARED].desc = "Do not reposition scan head before scanning infrared line. Results in an infrared offset which may deteriorate IR dust and scratch removal.";
|
|
scanner->opt[OPT_FAST_INFRARED].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_FAST_INFRARED].unit = SANE_UNIT_NONE;
|
|
scanner->opt[OPT_FAST_INFRARED].constraint_type = SANE_CONSTRAINT_NONE;
|
|
scanner->val[OPT_FAST_INFRARED].b = SANE_FALSE;
|
|
scanner->opt[OPT_FAST_INFRARED].cap |= SANE_CAP_SOFT_SELECT;
|
|
|
|
/* automatically advance to next slide after scan */
|
|
scanner->opt[OPT_ADVANCE_SLIDE].name = "advance";
|
|
scanner->opt[OPT_ADVANCE_SLIDE].title = "Advance slide";
|
|
scanner->opt[OPT_ADVANCE_SLIDE].desc = "Automatically advance to next slide after scan";
|
|
scanner->opt[OPT_ADVANCE_SLIDE].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_ADVANCE_SLIDE].unit = SANE_UNIT_NONE;
|
|
scanner->opt[OPT_ADVANCE_SLIDE].constraint_type = SANE_CONSTRAINT_NONE;
|
|
scanner->val[OPT_ADVANCE_SLIDE].w = SANE_TRUE;
|
|
scanner->opt[OPT_ADVANCE_SLIDE].cap |= SANE_CAP_SOFT_SELECT;
|
|
|
|
/* "Geometry" group: */
|
|
scanner->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
|
|
scanner->opt[OPT_GEOMETRY_GROUP].desc = "";
|
|
scanner->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
|
|
scanner->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
|
|
scanner->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* top-left x */
|
|
scanner->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
|
|
scanner->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
|
|
scanner->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
|
|
scanner->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
|
|
scanner->opt[OPT_TL_X].unit = SANE_UNIT_MM;
|
|
scanner->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[OPT_TL_X].constraint.range = &(scanner->device->x_range);
|
|
scanner->val[OPT_TL_X].w = 0;
|
|
|
|
/* top-left y */
|
|
scanner->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
|
|
scanner->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
|
|
scanner->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
|
|
scanner->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
|
|
scanner->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
|
|
scanner->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[OPT_TL_Y].constraint.range = &(scanner->device->y_range);
|
|
scanner->val[OPT_TL_Y].w = 0;
|
|
|
|
/* bottom-right x */
|
|
scanner->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
|
|
scanner->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
|
|
scanner->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
|
|
scanner->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
|
|
scanner->opt[OPT_BR_X].unit = SANE_UNIT_MM;
|
|
scanner->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[OPT_BR_X].constraint.range = &(scanner->device->x_range);
|
|
scanner->val[OPT_BR_X].w = scanner->device->x_range.max;
|
|
|
|
/* bottom-right y */
|
|
scanner->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
|
|
scanner->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
|
|
scanner->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
|
|
scanner->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
|
|
scanner->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
|
|
scanner->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[OPT_BR_Y].constraint.range = &(scanner->device->y_range);
|
|
scanner->val[OPT_BR_Y].w = scanner->device->y_range.max;
|
|
|
|
/* "Enhancement" group: */
|
|
scanner->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
|
|
scanner->opt[OPT_ENHANCEMENT_GROUP].desc = "";
|
|
scanner->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
|
|
scanner->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
|
|
scanner->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* correct data for lamp variations (shading) */
|
|
scanner->opt[OPT_CORRECT_SHADING].name = "correct-shading";
|
|
scanner->opt[OPT_CORRECT_SHADING].title = "Correct shading";
|
|
scanner->opt[OPT_CORRECT_SHADING].desc = "Correct data for lamp variations (shading)";
|
|
scanner->opt[OPT_CORRECT_SHADING].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_CORRECT_SHADING].unit = SANE_UNIT_NONE;
|
|
scanner->val[OPT_CORRECT_SHADING].w = SANE_TRUE;
|
|
|
|
/* correct infrared for red crosstalk */
|
|
scanner->opt[OPT_CORRECT_INFRARED].name = "correct-infrared";
|
|
scanner->opt[OPT_CORRECT_INFRARED].title = "Correct infrared";
|
|
scanner->opt[OPT_CORRECT_INFRARED].desc = "Correct infrared for red crosstalk";
|
|
scanner->opt[OPT_CORRECT_INFRARED].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_CORRECT_INFRARED].unit = SANE_UNIT_NONE;
|
|
scanner->val[OPT_CORRECT_INFRARED].w = SANE_FALSE;
|
|
|
|
/* detect and remove dust and scratch artifacts */
|
|
scanner->opt[OPT_CLEAN_IMAGE].name = "clean-image";
|
|
scanner->opt[OPT_CLEAN_IMAGE].title = "Clean image";
|
|
scanner->opt[OPT_CLEAN_IMAGE].desc = "Detect and remove dust and scratch artifacts";
|
|
scanner->opt[OPT_CLEAN_IMAGE].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_CLEAN_IMAGE].unit = SANE_UNIT_NONE;
|
|
scanner->val[OPT_CLEAN_IMAGE].w = SANE_FALSE;
|
|
|
|
/* strength of grain filtering */
|
|
scanner->opt[OPT_SMOOTH_IMAGE].name = "smooth";
|
|
scanner->opt[OPT_SMOOTH_IMAGE].title = "Attenuate film grain";
|
|
scanner->opt[OPT_SMOOTH_IMAGE].desc = "Amount of smoothening";
|
|
scanner->opt[OPT_SMOOTH_IMAGE].type = SANE_TYPE_INT;
|
|
scanner->opt[OPT_SMOOTH_IMAGE].constraint_type = SANE_CONSTRAINT_WORD_LIST;
|
|
scanner->opt[OPT_SMOOTH_IMAGE].size = sizeof (SANE_Word);
|
|
scanner->opt[OPT_SMOOTH_IMAGE].constraint.word_list = scanner->device->grain_sw_list;
|
|
scanner->val[OPT_SMOOTH_IMAGE].w = scanner->device->grain_sw_list[1];
|
|
if (scanner->opt[OPT_SMOOTH_IMAGE].constraint.word_list[0] < 2) {
|
|
scanner->opt[OPT_SMOOTH_IMAGE].cap |= SANE_CAP_INACTIVE;
|
|
}
|
|
|
|
/* gamma correction, to make image sRGB like */
|
|
scanner->opt[OPT_TRANSFORM_TO_SRGB].name = "srgb";
|
|
scanner->opt[OPT_TRANSFORM_TO_SRGB].title = "sRGB colors";
|
|
scanner->opt[OPT_TRANSFORM_TO_SRGB].desc = "Transform image to approximate sRGB color space";
|
|
scanner->opt[OPT_TRANSFORM_TO_SRGB].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_TRANSFORM_TO_SRGB].unit = SANE_UNIT_NONE;
|
|
scanner->val[OPT_TRANSFORM_TO_SRGB].w = SANE_FALSE;
|
|
scanner->opt[OPT_TRANSFORM_TO_SRGB].cap |= SANE_CAP_INACTIVE;
|
|
|
|
/* color correction for generic negative film */
|
|
scanner->opt[OPT_INVERT_IMAGE].name = "invert";
|
|
scanner->opt[OPT_INVERT_IMAGE].title = "Invert colors";
|
|
scanner->opt[OPT_INVERT_IMAGE].desc = "Correct for generic negative film";
|
|
scanner->opt[OPT_INVERT_IMAGE].type = SANE_TYPE_BOOL;
|
|
scanner->opt[OPT_INVERT_IMAGE].unit = SANE_UNIT_NONE;
|
|
scanner->val[OPT_INVERT_IMAGE].w = SANE_FALSE;
|
|
scanner->opt[OPT_INVERT_IMAGE].cap |= SANE_CAP_INACTIVE;
|
|
|
|
/* crop image */
|
|
scanner->opt[OPT_CROP_IMAGE].name = "crop";
|
|
scanner->opt[OPT_CROP_IMAGE].title = "Cropping";
|
|
scanner->opt[OPT_CROP_IMAGE].desc = "How to crop the image";
|
|
scanner->opt[OPT_CROP_IMAGE].type = SANE_TYPE_STRING;
|
|
scanner->opt[OPT_CROP_IMAGE].size = max_string_size ((SANE_String_Const const *)(void*) scanner->device->crop_sw_list);
|
|
scanner->opt[OPT_CROP_IMAGE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
|
|
scanner->opt[OPT_CROP_IMAGE].constraint.string_list = (SANE_String_Const const *)(void*) scanner->device->crop_sw_list;
|
|
scanner->val[OPT_CROP_IMAGE].s = (SANE_Char *) strdup (scanner->device->crop_sw_list[2]);
|
|
|
|
/* "Advanced" group: */
|
|
scanner->opt[OPT_ADVANCED_GROUP].title = "Advanced";
|
|
scanner->opt[OPT_ADVANCED_GROUP].desc = "";
|
|
scanner->opt[OPT_ADVANCED_GROUP].type = SANE_TYPE_GROUP;
|
|
scanner->opt[OPT_ADVANCED_GROUP].cap = SANE_CAP_ADVANCED;
|
|
scanner->opt[OPT_ADVANCED_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
|
|
|
|
/* preview */
|
|
scanner->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
|
|
scanner->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
|
|
scanner->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
|
|
scanner->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
|
|
scanner->val[OPT_PREVIEW].w = SANE_FALSE;
|
|
|
|
/* save shading data */
|
|
scanner->opt[OPT_SAVE_SHADINGDATA].name = "save-shading-data";
|
|
scanner->opt[OPT_SAVE_SHADINGDATA].title = "Save shading data";
|
|
scanner->opt[OPT_SAVE_SHADINGDATA].desc = "Save shading data in 'pieusb.shading'";
|
|
scanner->opt[OPT_SAVE_SHADINGDATA].type = SANE_TYPE_BOOL;
|
|
scanner->val[OPT_SAVE_SHADINGDATA].w = SANE_FALSE;
|
|
|
|
/* save CCD mask */
|
|
scanner->opt[OPT_SAVE_CCDMASK].name = "save-ccdmask";
|
|
scanner->opt[OPT_SAVE_CCDMASK].title = "Save CCD mask";
|
|
scanner->opt[OPT_SAVE_CCDMASK].desc = "Save CCD mask 'pieusb.ccd'";
|
|
scanner->opt[OPT_SAVE_CCDMASK].type = SANE_TYPE_BOOL;
|
|
scanner->val[OPT_SAVE_CCDMASK].w = SANE_FALSE;
|
|
|
|
scanner->opt[OPT_LIGHT].name = "light";
|
|
scanner->opt[OPT_LIGHT].title = "Light";
|
|
scanner->opt[OPT_LIGHT].desc = "Light";
|
|
scanner->opt[OPT_LIGHT].type = SANE_TYPE_INT;
|
|
scanner->opt[OPT_LIGHT].unit = SANE_UNIT_MICROSECOND;
|
|
scanner->opt[OPT_LIGHT].cap |= SANE_CAP_SOFT_SELECT;
|
|
scanner->opt[OPT_LIGHT].size = sizeof(SANE_Word);
|
|
scanner->val[OPT_LIGHT].w = DEFAULT_LIGHT;
|
|
|
|
scanner->opt[OPT_DOUBLE_TIMES].name = "double-times";
|
|
scanner->opt[OPT_DOUBLE_TIMES].title = "Double times";
|
|
scanner->opt[OPT_DOUBLE_TIMES].desc = "Double times";
|
|
scanner->opt[OPT_DOUBLE_TIMES].type = SANE_TYPE_INT;
|
|
scanner->opt[OPT_DOUBLE_TIMES].unit = SANE_UNIT_MICROSECOND;
|
|
scanner->opt[OPT_DOUBLE_TIMES].cap |= SANE_CAP_SOFT_SELECT;
|
|
scanner->opt[OPT_DOUBLE_TIMES].size = sizeof(SANE_Word);
|
|
scanner->val[OPT_DOUBLE_TIMES].w = DEFAULT_DOUBLE_TIMES;
|
|
|
|
/* exposure times for R, G, B and I */
|
|
scanner->opt[OPT_SET_EXPOSURE_R].name = SANE_NAME_EXPOSURE_R;
|
|
scanner->opt[OPT_SET_EXPOSURE_R].title = SANE_TITLE_EXPOSURE_R;
|
|
scanner->opt[OPT_SET_EXPOSURE_R].desc = SANE_DESC_EXPOSURE_R;
|
|
scanner->opt[OPT_SET_EXPOSURE_G].name = SANE_NAME_EXPOSURE_G;
|
|
scanner->opt[OPT_SET_EXPOSURE_G].title = SANE_TITLE_EXPOSURE_G;
|
|
scanner->opt[OPT_SET_EXPOSURE_G].desc = SANE_DESC_EXPOSURE_G;
|
|
scanner->opt[OPT_SET_EXPOSURE_B].name = SANE_NAME_EXPOSURE_B;
|
|
scanner->opt[OPT_SET_EXPOSURE_B].title = SANE_TITLE_EXPOSURE_B;
|
|
scanner->opt[OPT_SET_EXPOSURE_B].desc = SANE_DESC_EXPOSURE_B;
|
|
scanner->opt[OPT_SET_EXPOSURE_I].name = SANE_NAME_EXPOSURE_I;
|
|
scanner->opt[OPT_SET_EXPOSURE_I].title = SANE_TITLE_EXPOSURE_I;
|
|
scanner->opt[OPT_SET_EXPOSURE_I].desc = SANE_DESC_EXPOSURE_I;
|
|
for (i = OPT_SET_EXPOSURE_R; i <= OPT_SET_EXPOSURE_I; ++i) {
|
|
scanner->opt[i].type = SANE_TYPE_INT;
|
|
scanner->opt[i].unit = SANE_UNIT_MICROSECOND;
|
|
scanner->opt[i].cap |= SANE_CAP_SOFT_SELECT;
|
|
scanner->opt[i].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[i].constraint.range = &(scanner->device->exposure_range);
|
|
scanner->opt[i].size = sizeof(SANE_Word);
|
|
scanner->val[i].w = SANE_EXPOSURE_DEFAULT;
|
|
}
|
|
|
|
/* gain for R, G, B and I */
|
|
scanner->opt[OPT_SET_GAIN_R].name = SANE_NAME_GAIN_R;
|
|
scanner->opt[OPT_SET_GAIN_R].title = SANE_TITLE_GAIN_R;
|
|
scanner->opt[OPT_SET_GAIN_R].desc = SANE_DESC_GAIN_R;
|
|
scanner->opt[OPT_SET_GAIN_G].name = SANE_NAME_GAIN_G;
|
|
scanner->opt[OPT_SET_GAIN_G].title = SANE_TITLE_GAIN_G;
|
|
scanner->opt[OPT_SET_GAIN_G].desc = SANE_DESC_GAIN_G;
|
|
scanner->opt[OPT_SET_GAIN_B].name = SANE_NAME_GAIN_B;
|
|
scanner->opt[OPT_SET_GAIN_B].title = SANE_TITLE_GAIN_B;
|
|
scanner->opt[OPT_SET_GAIN_B].desc = SANE_DESC_GAIN_B;
|
|
scanner->opt[OPT_SET_GAIN_I].name = SANE_NAME_GAIN_I;
|
|
scanner->opt[OPT_SET_GAIN_I].title = SANE_TITLE_GAIN_I;
|
|
scanner->opt[OPT_SET_GAIN_I].desc = SANE_DESC_GAIN_I;
|
|
for (i = OPT_SET_GAIN_R; i <= OPT_SET_GAIN_I; ++i) {
|
|
scanner->opt[i].type = SANE_TYPE_INT;
|
|
scanner->opt[i].unit = SANE_UNIT_NONE;
|
|
scanner->opt[i].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[i].constraint.range = &gain_range;
|
|
scanner->opt[i].size = sizeof(SANE_Word);
|
|
scanner->val[i].w = SANE_GAIN_DEFAULT;
|
|
}
|
|
/* offsets for R, G, B and I */
|
|
scanner->opt[OPT_SET_OFFSET_R].name = SANE_NAME_OFFSET_R;
|
|
scanner->opt[OPT_SET_OFFSET_R].title = SANE_TITLE_OFFSET_R;
|
|
scanner->opt[OPT_SET_OFFSET_R].desc = SANE_DESC_OFFSET_R;
|
|
scanner->opt[OPT_SET_OFFSET_G].name = SANE_NAME_OFFSET_G;
|
|
scanner->opt[OPT_SET_OFFSET_G].title = SANE_TITLE_OFFSET_G;
|
|
scanner->opt[OPT_SET_OFFSET_G].desc = SANE_DESC_OFFSET_G;
|
|
scanner->opt[OPT_SET_OFFSET_B].name = SANE_NAME_OFFSET_B;
|
|
scanner->opt[OPT_SET_OFFSET_B].title = SANE_TITLE_OFFSET_B;
|
|
scanner->opt[OPT_SET_OFFSET_B].desc = SANE_DESC_OFFSET_B;
|
|
scanner->opt[OPT_SET_OFFSET_I].name = SANE_NAME_OFFSET_I;
|
|
scanner->opt[OPT_SET_OFFSET_I].title = SANE_TITLE_OFFSET_I;
|
|
scanner->opt[OPT_SET_OFFSET_I].desc = SANE_DESC_OFFSET_I;
|
|
for (i = OPT_SET_OFFSET_R; i <= OPT_SET_OFFSET_I; ++i) {
|
|
scanner->opt[i].type = SANE_TYPE_INT;
|
|
scanner->opt[i].unit = SANE_UNIT_NONE;
|
|
scanner->opt[i].constraint_type = SANE_CONSTRAINT_RANGE;
|
|
scanner->opt[i].constraint.range = &offset_range;
|
|
scanner->opt[i].size = sizeof(SANE_Word);
|
|
scanner->val[i].w = SANE_OFFSET_DEFAULT;
|
|
}
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
* Parse line from config file into a vendor id, product id, model number, and flags
|
|
*
|
|
* @param config_line Text to parse
|
|
* @param vendor_id
|
|
* @param product_id
|
|
* @param model_number
|
|
* @param flags
|
|
* @return SANE_STATUS_GOOD, or SANE_STATUS_INVAL in case of a parse error
|
|
*/
|
|
SANE_Status
|
|
sanei_pieusb_parse_config_line(const char* config_line,
|
|
SANE_Word* vendor_id,
|
|
SANE_Word* product_id,
|
|
SANE_Int* model_number,
|
|
SANE_Int* flags)
|
|
{
|
|
char *vendor_id_string, *product_id_string, *model_number_string, *flags_string;
|
|
|
|
if (strncmp (config_line, "usb ", 4) != 0) {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
/* Detect vendor-id */
|
|
config_line += 4;
|
|
config_line = sanei_config_skip_whitespace (config_line);
|
|
if (*config_line) {
|
|
config_line = sanei_config_get_string (config_line, &vendor_id_string);
|
|
if (vendor_id_string) {
|
|
*vendor_id = strtol (vendor_id_string, 0, 0);
|
|
free (vendor_id_string);
|
|
} else {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
config_line = sanei_config_skip_whitespace (config_line);
|
|
} else {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
/* Detect product-id */
|
|
config_line = sanei_config_skip_whitespace (config_line);
|
|
if (*config_line) {
|
|
config_line = sanei_config_get_string (config_line, &product_id_string);
|
|
if (product_id_string) {
|
|
*product_id = strtol (product_id_string, 0, 0);
|
|
free (product_id_string);
|
|
} else {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
config_line = sanei_config_skip_whitespace (config_line);
|
|
} else {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
/* Detect model number */
|
|
config_line = sanei_config_skip_whitespace (config_line);
|
|
if (*config_line) {
|
|
config_line = sanei_config_get_string (config_line, &model_number_string);
|
|
if (model_number_string) {
|
|
*model_number = (SANE_Int) strtol (model_number_string, 0, 0);
|
|
free (model_number_string);
|
|
} else {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
config_line = sanei_config_skip_whitespace (config_line);
|
|
} else {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
/* Detect (optional) flags */
|
|
*flags = 0;
|
|
config_line = sanei_config_skip_whitespace (config_line);
|
|
if (*config_line) {
|
|
config_line = sanei_config_get_string (config_line, &flags_string);
|
|
if (flags_string) {
|
|
*flags = (SANE_Int) strtol (flags_string, 0, 0);
|
|
free (flags_string);
|
|
}
|
|
}
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
* Check if current list of supported devices contains the given specifications.
|
|
*
|
|
* @param vendor_id
|
|
* @param product_id
|
|
* @param model_number
|
|
* @param flags
|
|
* @return
|
|
*/
|
|
SANE_Bool
|
|
sanei_pieusb_supported_device_list_contains(SANE_Word vendor_id, SANE_Word product_id, SANE_Int model_number, SANE_Int flags)
|
|
{
|
|
int i = 0;
|
|
while (pieusb_supported_usb_device_list[i].vendor != 0) {
|
|
if (pieusb_supported_usb_device_list[i].vendor == vendor_id
|
|
&& pieusb_supported_usb_device_list[i].product == product_id
|
|
&& pieusb_supported_usb_device_list[i].model == model_number
|
|
&& pieusb_supported_usb_device_list[i].flags == flags) {
|
|
return SANE_TRUE;
|
|
}
|
|
i++;
|
|
}
|
|
return SANE_FALSE;
|
|
}
|
|
|
|
/**
|
|
* Add the given specifications to the current list of supported devices
|
|
* @param vendor_id
|
|
* @param product_id
|
|
* @param model_number
|
|
* @param flags
|
|
* @return
|
|
*/
|
|
SANE_Status
|
|
sanei_pieusb_supported_device_list_add(SANE_Word vendor_id, SANE_Word product_id, SANE_Int model_number, SANE_Int flags)
|
|
{
|
|
int i = 0, k;
|
|
struct Pieusb_USB_Device_Entry* dl;
|
|
|
|
while (pieusb_supported_usb_device_list[i].vendor != 0) {
|
|
i++;
|
|
}
|
|
/* i is index of last entry */
|
|
for (k=0; k<=i; k++) {
|
|
DBG(DBG_info_proc,"sanei_pieusb_supported_device_list_add(): current %03d: %04x %04x %02x %02x\n", i,
|
|
pieusb_supported_usb_device_list[k].vendor,
|
|
pieusb_supported_usb_device_list[k].product,
|
|
pieusb_supported_usb_device_list[k].model,
|
|
pieusb_supported_usb_device_list[k].flags);
|
|
}
|
|
|
|
dl = realloc(pieusb_supported_usb_device_list,(i+2)*sizeof(struct Pieusb_USB_Device_Entry)); /* Add one entry to list */
|
|
if (dl == NULL) {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
/* Copy values */
|
|
pieusb_supported_usb_device_list = dl;
|
|
pieusb_supported_usb_device_list[i].vendor = vendor_id;
|
|
pieusb_supported_usb_device_list[i].product = product_id;
|
|
pieusb_supported_usb_device_list[i].model = model_number;
|
|
pieusb_supported_usb_device_list[i].flags = flags;
|
|
pieusb_supported_usb_device_list[i+1].vendor = 0;
|
|
pieusb_supported_usb_device_list[i+1].product = 0;
|
|
pieusb_supported_usb_device_list[i+1].model = 0;
|
|
pieusb_supported_usb_device_list[i+1].flags = 0;
|
|
for (k=0; k<=i+1; k++) {
|
|
DBG(DBG_info_proc,"sanei_pieusb_supported_device_list_add() add: %03d: %04x %04x %02x %02x\n", i,
|
|
pieusb_supported_usb_device_list[k].vendor,
|
|
pieusb_supported_usb_device_list[k].product,
|
|
pieusb_supported_usb_device_list[k].model,
|
|
pieusb_supported_usb_device_list[k].flags);
|
|
}
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
* Actions to perform when a cancel request has been received.
|
|
*
|
|
* @param scanner scanner to stop scanning
|
|
* @return SANE_STATUS_CANCELLED
|
|
*/
|
|
SANE_Status
|
|
sanei_pieusb_on_cancel (Pieusb_Scanner * scanner)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
|
|
DBG (DBG_info_proc, "sanei_pieusb_on_cancel()\n");
|
|
|
|
sanei_pieusb_cmd_stop_scan (scanner->device_number, &status);
|
|
sanei_pieusb_cmd_set_scan_head (scanner->device_number, 1, 0, &status);
|
|
sanei_pieusb_buffer_delete (&scanner->buffer);
|
|
scanner->scanning = SANE_FALSE;
|
|
return SANE_STATUS_CANCELLED;
|
|
}
|
|
|
|
/**
|
|
* Determine maximum length of a set of strings.
|
|
*
|
|
* @param strings Set of strings
|
|
* @return maximum length
|
|
*/
|
|
static size_t
|
|
max_string_size (SANE_String_Const const strings[])
|
|
{
|
|
size_t size, max_size = 0;
|
|
int i;
|
|
|
|
for (i = 0; strings[i]; ++i) {
|
|
size = strlen (strings[i]) + 1;
|
|
if (size > max_size) {
|
|
max_size = size;
|
|
}
|
|
}
|
|
|
|
return max_size;
|
|
}
|
|
|
|
/* From MR's pie.c */
|
|
|
|
/* ------------------------- PIEUSB_CORRECT_SHADING -------------------------- */
|
|
|
|
/**
|
|
* Correct the given buffer for shading using shading data in scanner.
|
|
* If the loop order is width->color->height, a 7200 dpi scan correction takes
|
|
* 45 minutes. If the loop order is color->height->width, this is less than 3
|
|
* minutes. So it is worthwhile to find the used pixels first (array width_to_loc).
|
|
*
|
|
* @param scanner Scanner
|
|
* @param buffer Buffer to correct
|
|
*/
|
|
void
|
|
sanei_pieusb_correct_shading(struct Pieusb_Scanner *scanner, struct Pieusb_Read_Buffer *buffer)
|
|
{
|
|
|
|
int i, j, c, k;
|
|
SANE_Uint val, val_org, *p;
|
|
int *width_to_loc;
|
|
|
|
DBG (DBG_info_proc, "sanei_pieusb_correct_shading()\n");
|
|
|
|
/* Loop through CCD-mask to find used pixels */
|
|
width_to_loc = calloc(buffer->width,sizeof(int));
|
|
j = 0;
|
|
for (i = 0; i < scanner->ccd_mask_size; i++) {
|
|
if (scanner->ccd_mask[i] == 0) {
|
|
width_to_loc[j++] = i;
|
|
}
|
|
}
|
|
/* Correct complete image */
|
|
for (c = 0; c < buffer->colors; c++) {
|
|
DBG(DBG_info,"sanei_pieusb_correct_shading() correct color %d\n",c);
|
|
for (k = 0; k < buffer->height; k++) {
|
|
/* DBG(DBG_info,"Correct line %d\n",k); */
|
|
p = buffer->data + c * buffer->width * buffer->height + k * buffer->width;
|
|
for (j = 0; j < buffer->width; j++) {
|
|
val_org = *p;
|
|
val = lround((double)scanner->shading_mean[c] / scanner->shading_ref[c][width_to_loc[j]] * val_org);
|
|
/* DBG(DBG_info,"Correct [%d,%d,%d] %d -> %d\n",k,j,c,val_org,val); */
|
|
*p++ = val;
|
|
}
|
|
}
|
|
}
|
|
/* Free memory */
|
|
free(width_to_loc);
|
|
}
|
|
|
|
/* === functions copied from MR's code === */
|
|
|
|
/**
|
|
*
|
|
* @param scanner
|
|
* @param in_img
|
|
* @param planes
|
|
* @param out_planes
|
|
* @return
|
|
*/
|
|
SANE_Status
|
|
sanei_pieusb_post (Pieusb_Scanner *scanner, uint16_t **in_img, int planes)
|
|
{
|
|
uint16_t *cplane[PLANES]; /* R, G, B, I gray scale planes */
|
|
SANE_Parameters parameters; /* describes the image */
|
|
int winsize_smooth; /* for adapting replaced pixels */
|
|
char filename[64];
|
|
SANE_Status status;
|
|
int smooth, i;
|
|
|
|
memcpy (¶meters, &scanner->scan_parameters, sizeof (SANE_Parameters));
|
|
parameters.format = SANE_FRAME_GRAY;
|
|
parameters.bytes_per_line = parameters.pixels_per_line;
|
|
if (parameters.depth > 8)
|
|
parameters.bytes_per_line *= 2;
|
|
parameters.last_frame = 0;
|
|
|
|
DBG (DBG_info, "pie_usb_post: %d ppl, %d lines, %d bits, %d planes, %d dpi\n",
|
|
parameters.pixels_per_line, parameters.lines,
|
|
parameters.depth, planes, scanner->mode.resolution);
|
|
|
|
if (planes > PLANES) {
|
|
DBG (DBG_error, "pie_usb_post: too many planes: %d (max %d)\n", planes, PLANES);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
for (i = 0; i < planes; i++)
|
|
cplane[i] = in_img[i];
|
|
|
|
/* dirt is rather resolution invariant, so
|
|
* setup resolution dependent parameters
|
|
*/
|
|
/* film grain reduction */
|
|
smooth = scanner->val[OPT_SMOOTH_IMAGE].w;
|
|
winsize_smooth = (scanner->mode.resolution / 540) | 1;
|
|
/* smoothen whole image or only replaced pixels */
|
|
if (smooth)
|
|
{
|
|
winsize_smooth += 2 * (smooth - 3); /* even */
|
|
if (winsize_smooth < 3)
|
|
smooth = 0;
|
|
}
|
|
if (winsize_smooth < 3)
|
|
winsize_smooth = 3;
|
|
DBG (DBG_info, "pie_usb_sw_post: winsize_smooth %d\n", winsize_smooth);
|
|
|
|
/* RGBI post-processing if selected:
|
|
* 1) remove spectral overlay from ired plane,
|
|
* 2) remove dirt, smoothen if, crop if */
|
|
if (scanner->val[OPT_CORRECT_INFRARED].b) /* (scanner->processing & POST_SW_IRED_MASK) */
|
|
{
|
|
/* remove spectral overlay from ired plane */
|
|
status = sanei_ir_spectral_clean (¶meters, scanner->ln_lut, cplane[0], cplane[3]);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
if (DBG_LEVEL >= 15)
|
|
{
|
|
snprintf (filename, 63, "/tmp/ir-spectral.pnm");
|
|
pieusb_write_pnm_file (filename, cplane[3],
|
|
parameters.depth, 1,
|
|
parameters.pixels_per_line, parameters.lines);
|
|
}
|
|
if (scanner->cancel_request) /* asynchronous cancel ? */
|
|
return SANE_STATUS_CANCELLED;
|
|
} /* scanner-> processing & POST_SW_IRED_MASK */
|
|
|
|
/* remove dirt, smoothen if, crop if */
|
|
if (scanner->val[OPT_CLEAN_IMAGE].b) /* (scanner->processing & POST_SW_DIRT) */
|
|
{
|
|
double *norm_histo;
|
|
uint16_t *thresh_data;
|
|
int static_thresh, too_thresh; /* static thresholds */
|
|
int winsize_filter; /* primary size of filtering window */
|
|
int size_dilate; /* the dirt mask */
|
|
|
|
/* size of filter detecting dirt */
|
|
winsize_filter = (int) (5.0 * (double) scanner->mode.resolution / 300.0) | 1;
|
|
if (winsize_filter < 3)
|
|
winsize_filter = 3;
|
|
/* dirt usually has smooth edges which also need correction */
|
|
size_dilate = scanner->mode.resolution / 1000 + 1;
|
|
|
|
/* first detect large dirt by a static threshold */
|
|
status = sanei_ir_create_norm_histogram (¶meters, cplane[3], &norm_histo);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
DBG (DBG_error, "pie_usb_sw_post: no buffer\n");
|
|
return SANE_STATUS_NO_MEM;
|
|
}
|
|
/* generate a "bimodal" static threshold */
|
|
status = sanei_ir_threshold_yen (¶meters, norm_histo, &static_thresh);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
/* generate traditional static threshold */
|
|
status = sanei_ir_threshold_otsu (¶meters, norm_histo, &too_thresh);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
/* choose lower one */
|
|
if (too_thresh < static_thresh)
|
|
static_thresh = too_thresh;
|
|
free (norm_histo);
|
|
|
|
/* then generate dirt mask with adaptive thresholding filter
|
|
* and add the dirt from the static threshold */
|
|
/* last two parameters: 10, 50 detects more, 20, 75 less */
|
|
status = sanei_ir_filter_madmean (¶meters, cplane[3], &thresh_data, winsize_filter, 20, 100);
|
|
if (status != SANE_STATUS_GOOD) {
|
|
free (thresh_data);
|
|
return status;
|
|
}
|
|
sanei_ir_add_threshold (¶meters, cplane[3], thresh_data, static_thresh);
|
|
if (DBG_LEVEL >= 15)
|
|
{
|
|
snprintf (filename, 63, "/tmp/ir-threshold.pnm");
|
|
pieusb_write_pnm_file (filename, thresh_data,
|
|
8, 1, parameters.pixels_per_line,
|
|
parameters.lines);
|
|
}
|
|
if (scanner->cancel_request) { /* asynchronous cancel ? */
|
|
free (thresh_data);
|
|
return SANE_STATUS_CANCELLED;
|
|
}
|
|
/* replace the dirt and smoothen film grain and crop if possible */
|
|
status = sanei_ir_dilate_mean (¶meters, cplane, thresh_data,
|
|
500, size_dilate, winsize_smooth, smooth,
|
|
0, NULL);
|
|
if (status != SANE_STATUS_GOOD) {
|
|
free (thresh_data);
|
|
return status;
|
|
}
|
|
smooth = 0;
|
|
free (thresh_data);
|
|
}
|
|
|
|
if (DBG_LEVEL >= 15)
|
|
{
|
|
pieusb_write_pnm_file ("/tmp/RGBi-img.pnm", scanner->buffer.data,
|
|
scanner->scan_parameters.depth, 3, scanner->scan_parameters.pixels_per_line,
|
|
scanner->scan_parameters.lines);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/* ------------------------------ PIE_USB_WRITE_PNM_FILE ------------------------------- */
|
|
static SANE_Status
|
|
pieusb_write_pnm_file (char *filename, SANE_Uint *data, int depth,
|
|
int channels, int pixels_per_line, int lines)
|
|
{
|
|
FILE *out;
|
|
int r, c, ch;
|
|
SANE_Uint val;
|
|
uint8_t b = 0;
|
|
|
|
DBG (DBG_info_proc,
|
|
"pie_usb_write_pnm_file: depth=%d, channels=%d, ppl=%d, lines=%d\n",
|
|
depth, channels, pixels_per_line, lines);
|
|
|
|
out = fopen (filename, "w");
|
|
if (!out)
|
|
{
|
|
DBG (DBG_error,
|
|
"pie_usb_write_pnm_file: could not open %s for writing: %s\n",
|
|
filename, strerror (errno));
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
switch (depth) {
|
|
case 1:
|
|
fprintf (out, "P4\n%d\n%d\n", pixels_per_line, lines);
|
|
for (r = 0; r < lines; r++) {
|
|
int i;
|
|
i = 0;
|
|
b = 0;
|
|
for (c = 0; c < pixels_per_line; c++) {
|
|
val = *(data + r * pixels_per_line + c);
|
|
if (val > 0) b |= (0x80 >> i);
|
|
i++;
|
|
if (i == 7) {
|
|
fputc(b, out);
|
|
i = 0;
|
|
b = 0;
|
|
}
|
|
}
|
|
if (i != 0) {
|
|
fputc(b, out);
|
|
}
|
|
}
|
|
break;
|
|
case 8:
|
|
fprintf (out, "P%c\n%d\n%d\n%d\n", channels == 1 ? '5' : '6', pixels_per_line, lines, 255);
|
|
for (r = 0; r < lines; r++) {
|
|
for (c = 0; c < pixels_per_line; c++) {
|
|
for (ch = 0; ch < channels; ch++) {
|
|
val = *(data + ch * lines * pixels_per_line + r * pixels_per_line + c);
|
|
b = val & 0xFF;
|
|
fputc(b, out);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 16:
|
|
fprintf (out, "P%c\n%d\n%d\n%d\n", channels == 1 ? '5' : '6', pixels_per_line, lines, 65535);
|
|
for (r = 0; r < lines; r++) {
|
|
for (c = 0; c < pixels_per_line; c++) {
|
|
for (ch = 0; ch < channels; ch++) {
|
|
val = *(data + ch * lines * pixels_per_line + r * pixels_per_line + c);
|
|
b = (val >> 8) & 0xFF;
|
|
fputc(b, out);
|
|
b = val & 0xFF;
|
|
fputc(b, out);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
DBG (DBG_error, "pie_usb_write_pnm_file: depth %d not implemented\n", depth);
|
|
}
|
|
fclose (out);
|
|
|
|
DBG (DBG_info, "pie_usb_write_pnm_file: finished\n");
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
* Check option inconsistencies.
|
|
* In most cases an inconsistency can be solved by ignoring an option setting.
|
|
* Message these situations and return 1 to indicate we can work with the
|
|
* current set op options. If the settings are really inconsistent, return 0.
|
|
*/
|
|
int
|
|
sanei_pieusb_analyse_options(struct Pieusb_Scanner *scanner)
|
|
{
|
|
/* Checks*/
|
|
if (scanner->val[OPT_TL_X].w > scanner->val[OPT_BR_X].w) {
|
|
DBG (DBG_error, "sane_start: %s (%.1f mm) is bigger than %s (%.1f mm) -- aborting\n",
|
|
scanner->opt[OPT_TL_X].title,
|
|
SANE_UNFIX (scanner->val[OPT_TL_X].w),
|
|
scanner->opt[OPT_BR_X].title,
|
|
SANE_UNFIX (scanner->val[OPT_BR_X].w));
|
|
return 0;
|
|
}
|
|
if (scanner->val[OPT_TL_Y].w > scanner->val[OPT_BR_Y].w) {
|
|
DBG (DBG_error, "sane_start: %s (%.1f mm) is bigger than %s (%.1f mm) -- aborting\n",
|
|
scanner->opt[OPT_TL_Y].title,
|
|
SANE_UNFIX (scanner->val[OPT_TL_Y].w),
|
|
scanner->opt[OPT_BR_Y].title,
|
|
SANE_UNFIX (scanner->val[OPT_BR_Y].w));
|
|
return 0;
|
|
}
|
|
/* Modes sometimes limit other choices */
|
|
if (scanner->val[OPT_PREVIEW].b) {
|
|
/* Preview uses its own specific settings */
|
|
if (scanner->val[OPT_RESOLUTION].w != (scanner->device->fast_preview_resolution << SANE_FIXED_SCALE_SHIFT)) {
|
|
DBG (DBG_info_sane, "Option %s = %f ignored during preview\n", scanner->opt[OPT_RESOLUTION].name, SANE_UNFIX(scanner->val[OPT_RESOLUTION].w));
|
|
}
|
|
if (scanner->val[OPT_SHARPEN].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored during preview\n", scanner->opt[OPT_SHARPEN].name, scanner->val[OPT_SHARPEN].b);
|
|
}
|
|
if (!scanner->val[OPT_FAST_INFRARED].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored during preview\n", scanner->opt[OPT_FAST_INFRARED].name, scanner->val[OPT_FAST_INFRARED].b);
|
|
}
|
|
if (scanner->val[OPT_CORRECT_INFRARED].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored during preview\n", scanner->opt[OPT_CORRECT_INFRARED].name, scanner->val[OPT_CORRECT_INFRARED].b);
|
|
}
|
|
if (scanner->val[OPT_CLEAN_IMAGE].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored during preview\n", scanner->opt[OPT_CLEAN_IMAGE].name, scanner->val[OPT_CLEAN_IMAGE].b);
|
|
}
|
|
if (scanner->val[OPT_SMOOTH_IMAGE].w != 0) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored during preview\n", scanner->opt[OPT_SMOOTH_IMAGE].name, scanner->val[OPT_SMOOTH_IMAGE].w);
|
|
}
|
|
if (strcmp(scanner->val[OPT_CROP_IMAGE].s, scanner->device->crop_sw_list[0]) != 0) {
|
|
DBG (DBG_info_sane, "Option %s = %s ignored during preview\n", scanner->opt[OPT_CROP_IMAGE].name, scanner->val[OPT_CROP_IMAGE].s);
|
|
}
|
|
if (scanner->val[OPT_TRANSFORM_TO_SRGB].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored during preview\n", scanner->opt[OPT_TRANSFORM_TO_SRGB].name, scanner->val[OPT_TRANSFORM_TO_SRGB].w);
|
|
}
|
|
if (scanner->val[OPT_INVERT_IMAGE].w) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored during preview\n", scanner->opt[OPT_INVERT_IMAGE].name, scanner->val[OPT_INVERT_IMAGE].w);
|
|
}
|
|
} else if (strcmp(scanner->val[OPT_MODE].s,SANE_VALUE_SCAN_MODE_LINEART)==0) {
|
|
/* Can we do any post processing in lineart? Needs testing to see what's possible */
|
|
if (scanner->val[OPT_BIT_DEPTH].w != 1) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in lineart mode (will use 1)\n", scanner->opt[OPT_BIT_DEPTH].name, scanner->val[OPT_BIT_DEPTH].w);
|
|
}
|
|
if (!scanner->val[OPT_FAST_INFRARED].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in lineart mode (irrelevant)\n", scanner->opt[OPT_FAST_INFRARED].name, scanner->val[OPT_FAST_INFRARED].b);
|
|
}
|
|
if (!scanner->val[OPT_CORRECT_SHADING].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in lineart mode (irrelevant)\n", scanner->opt[OPT_CORRECT_SHADING].name, scanner->val[OPT_CORRECT_SHADING].b);
|
|
}
|
|
if (!scanner->val[OPT_CORRECT_INFRARED].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in lineart mode (irrelevant)\n", scanner->opt[OPT_CORRECT_INFRARED].name, scanner->val[OPT_CORRECT_INFRARED].b);
|
|
}
|
|
if (scanner->val[OPT_CLEAN_IMAGE].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in lineart mode (irrelevant)\n", scanner->opt[OPT_CLEAN_IMAGE].name, scanner->val[OPT_CLEAN_IMAGE].b);
|
|
}
|
|
if (scanner->val[OPT_SMOOTH_IMAGE].w != 0) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in lineart mode (irrelevant)\n", scanner->opt[OPT_SMOOTH_IMAGE].name, scanner->val[OPT_SMOOTH_IMAGE].w);
|
|
}
|
|
if (strcmp(scanner->val[OPT_CROP_IMAGE].s, scanner->device->crop_sw_list[0]) != 0) {
|
|
DBG (DBG_info_sane, "Option %s = %s ignored in lineart mode (irrelevant)\n", scanner->opt[OPT_CROP_IMAGE].name, scanner->val[OPT_CROP_IMAGE].s);
|
|
}
|
|
if (scanner->val[OPT_TRANSFORM_TO_SRGB].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in lineart mode (irrelevant)\n", scanner->opt[OPT_TRANSFORM_TO_SRGB].name, scanner->val[OPT_TRANSFORM_TO_SRGB].w);
|
|
}
|
|
} else if (strcmp(scanner->val[OPT_MODE].s,SANE_VALUE_SCAN_MODE_HALFTONE)==0) {
|
|
/* Can we do any post processing in halftone? Needs testing to see what's possible */
|
|
if (scanner->val[OPT_BIT_DEPTH].w != 1) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in halftone mode (will use 1)\n", scanner->opt[OPT_BIT_DEPTH].name, scanner->val[OPT_BIT_DEPTH].w);
|
|
}
|
|
if (!scanner->val[OPT_FAST_INFRARED].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in halftone mode (irrelevant)\n", scanner->opt[OPT_FAST_INFRARED].name, scanner->val[OPT_FAST_INFRARED].b);
|
|
}
|
|
if (!scanner->val[OPT_CORRECT_SHADING].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in halftone mode (irrelevant)\n", scanner->opt[OPT_CORRECT_SHADING].name, scanner->val[OPT_CORRECT_SHADING].b);
|
|
}
|
|
if (!scanner->val[OPT_CORRECT_INFRARED].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in halftone mode (irrelevant)\n", scanner->opt[OPT_CORRECT_INFRARED].name, scanner->val[OPT_CORRECT_INFRARED].b);
|
|
}
|
|
if (scanner->val[OPT_CLEAN_IMAGE].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in halftone mode (irrelevant)\n", scanner->opt[OPT_CLEAN_IMAGE].name, scanner->val[OPT_CLEAN_IMAGE].b);
|
|
}
|
|
if (scanner->val[OPT_SMOOTH_IMAGE].w != 0) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in halftone mode (irrelevant)\n", scanner->opt[OPT_SMOOTH_IMAGE].name, scanner->val[OPT_SMOOTH_IMAGE].w);
|
|
}
|
|
if (strcmp(scanner->val[OPT_CROP_IMAGE].s, scanner->device->crop_sw_list[0]) != 0) {
|
|
DBG (DBG_info_sane, "Option %s = %s ignored in halftone mode (irrelevant)\n", scanner->opt[OPT_CROP_IMAGE].name, scanner->val[OPT_CROP_IMAGE].s);
|
|
}
|
|
if (scanner->val[OPT_TRANSFORM_TO_SRGB].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in halftone mode (irrelevant)\n", scanner->opt[OPT_TRANSFORM_TO_SRGB].name, scanner->val[OPT_TRANSFORM_TO_SRGB].w);
|
|
}
|
|
} else if (strcmp(scanner->val[OPT_MODE].s,SANE_VALUE_SCAN_MODE_GRAY)==0) {
|
|
/* Can we do any post processing in gray mode? */
|
|
/* Can we obtain a single color channel in this mode? How? */
|
|
/* Is this just RGB with luminance trasformation? */
|
|
/* Needs testing to see what's possible */
|
|
/* Only do 8 or 16 bit scans */
|
|
if (scanner->val[OPT_BIT_DEPTH].w == 1) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in gray mode (will use 8)\n", scanner->opt[OPT_BIT_DEPTH].name, scanner->val[OPT_BIT_DEPTH].w);
|
|
}
|
|
if (!scanner->val[OPT_FAST_INFRARED].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in gray mode (irrelevant)\n", scanner->opt[OPT_FAST_INFRARED].name, scanner->val[OPT_FAST_INFRARED].b);
|
|
}
|
|
if (!scanner->val[OPT_CORRECT_INFRARED].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in gray mode (irrelevant)\n", scanner->opt[OPT_CORRECT_INFRARED].name, scanner->val[OPT_CORRECT_INFRARED].b);
|
|
}
|
|
if (scanner->val[OPT_CLEAN_IMAGE].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in gray mode (irrelevant)\n", scanner->opt[OPT_CLEAN_IMAGE].name, scanner->val[OPT_CLEAN_IMAGE].b);
|
|
}
|
|
if (scanner->val[OPT_TRANSFORM_TO_SRGB].b) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in gray mode (irrelevant)\n", scanner->opt[OPT_TRANSFORM_TO_SRGB].name, scanner->val[OPT_TRANSFORM_TO_SRGB].w);
|
|
}
|
|
} else if (strcmp(scanner->val[OPT_MODE].s,SANE_VALUE_SCAN_MODE_COLOR)==0) {
|
|
/* Some options require infrared data to be obtained, so all infrared options are relevant */
|
|
/* Only do 8 or 16 bit scans */
|
|
if (scanner->val[OPT_BIT_DEPTH].w == 1) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in color mode (will use 8)\n", scanner->opt[OPT_BIT_DEPTH].name, scanner->val[OPT_BIT_DEPTH].w);
|
|
}
|
|
} else if (strcmp(scanner->val[OPT_MODE].s,SANE_VALUE_SCAN_MODE_RGBI)==0) {
|
|
/* Only do 8 or 16 bit scans */
|
|
if (scanner->val[OPT_BIT_DEPTH].w == 1) {
|
|
DBG (DBG_info_sane, "Option %s = %d ignored in color mode (will use 8)\n", scanner->opt[OPT_BIT_DEPTH].name, scanner->val[OPT_BIT_DEPTH].w);
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Print options
|
|
*
|
|
* @param scanner
|
|
*/
|
|
void
|
|
sanei_pieusb_print_options(struct Pieusb_Scanner *scanner)
|
|
{
|
|
int k;
|
|
/* List current options and values */
|
|
DBG (DBG_info, "Num options = %d\n", scanner->val[OPT_NUM_OPTS].w);
|
|
for (k = 1; k < scanner->val[OPT_NUM_OPTS].w; k++) {
|
|
switch (scanner->opt[k].type) {
|
|
case SANE_TYPE_BOOL:
|
|
DBG(DBG_info," Option %d: %s = %d\n", k, scanner->opt[k].name, scanner->val[k].b);
|
|
break;
|
|
case SANE_TYPE_INT:
|
|
DBG(DBG_info," Option %d: %s = %d\n", k, scanner->opt[k].name, scanner->val[k].w);
|
|
break;
|
|
case SANE_TYPE_FIXED:
|
|
DBG(DBG_info," Option %d: %s = %f\n", k, scanner->opt[k].name, SANE_UNFIX (scanner->val[k].w));
|
|
break;
|
|
case SANE_TYPE_STRING:
|
|
DBG(DBG_info," Option %d: %s = %s\n", k, scanner->opt[k].name, scanner->val[k].s);
|
|
break;
|
|
case SANE_TYPE_GROUP:
|
|
DBG(DBG_info," Option %d: %s = %s\n", k, scanner->opt[k].title, scanner->val[k].s);
|
|
break;
|
|
default:
|
|
DBG(DBG_info," Option %d: %s unknown type %d\n", k, scanner->opt[k].name, scanner->opt[k].type);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculate reference values for each pixel, line means and line maxima.
|
|
* We have got 45 lines for all four colors and for each CCD pixel.
|
|
* The reference value for each pixel is the 45-line average for that
|
|
* pixel, for each color separately.
|
|
*
|
|
* @param scanner
|
|
* @param buffer
|
|
*/
|
|
static void pieusb_calculate_shading(struct Pieusb_Scanner *scanner, SANE_Byte* buffer)
|
|
{
|
|
int k, m;
|
|
SANE_Byte* p;
|
|
SANE_Int ci, val;
|
|
SANE_Int shading_width = scanner->device->shading_parameters[0].pixelsPerLine;
|
|
SANE_Int shading_height = scanner->device->shading_parameters[0].nLines;
|
|
|
|
/* Initialize all to 0 */
|
|
for (k = 0; k < SHADING_PARAMETERS_INFO_COUNT; k++) {
|
|
scanner->shading_max[k] = 0;
|
|
scanner->shading_mean[k] = 0;
|
|
memset(scanner->shading_ref[k], 0, shading_width * sizeof (SANE_Int));
|
|
}
|
|
/* Process data from buffer */
|
|
p = buffer;
|
|
switch (scanner->mode.colorFormat) {
|
|
case 0x01: /* Pixel */
|
|
/* Process pixel by pixel */
|
|
for (k = 0; k < shading_height; k++) {
|
|
for (m = 0; m < shading_width; m++) {
|
|
for (ci = 0; ci < SHADING_PARAMETERS_INFO_COUNT; ci++) {
|
|
val = *(p) + *(p+1) * 256;
|
|
scanner->shading_ref[ci][m] += val;
|
|
scanner->shading_max[ci] = scanner->shading_max[ci] < val ? val : scanner->shading_max[ci];
|
|
p += 2;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 0x04: /* Indexed */
|
|
/* Process each line in the sequence found in the buffer */
|
|
for (k = 0; k < shading_height*4; k++) {
|
|
/* Save at right color */
|
|
switch (*p) {
|
|
case 'R': ci = 0; break;
|
|
case 'G': ci = 1; break;
|
|
case 'B': ci = 2; break;
|
|
case 'I': ci = 3; break;
|
|
default: ci = -1; break; /* ignore line */
|
|
}
|
|
/* Add scanned data to reference line and keep track of maximum */
|
|
if (ci != -1) {
|
|
for (m = 0; m < shading_width; m++) {
|
|
val = *(p+2+2*m) + *(p+2+2*m+1) * 256;
|
|
scanner->shading_ref[ci][m] += val;
|
|
scanner->shading_max[ci] = scanner->shading_max[ci] < val ? val : scanner->shading_max[ci];
|
|
/* DBG(DBG_error,"%02d Shading_ref[%d][%d] = %d\n",k,ci,m,scanner->shading_ref[ci][m]); */
|
|
}
|
|
}
|
|
/* Next line */
|
|
p += 2*shading_width+2;
|
|
}
|
|
break;
|
|
default:
|
|
DBG (DBG_error,"sane_start(): color format %d not implemented\n",scanner->mode.colorFormat);
|
|
return;
|
|
}
|
|
/* Mean reference value needs division */
|
|
for (k = 0; k < SHADING_PARAMETERS_INFO_COUNT; k++) {
|
|
for (m = 0; m < shading_width; m++) {
|
|
scanner->shading_ref[k][m] = lround((double)scanner->shading_ref[k][m]/shading_height);
|
|
/* DBG(DBG_error,"Shading_ref[%d][%d] = %d\n",k,m,scanner->shading_ref[k][m]); */
|
|
}
|
|
}
|
|
/* Overall means */
|
|
for (k = 0; k < SHADING_PARAMETERS_INFO_COUNT; k++) {
|
|
for (m=0; m<shading_width; m++) {
|
|
scanner->shading_mean[k] += scanner->shading_ref[k][m];
|
|
}
|
|
scanner->shading_mean[k] = lround((double)scanner->shading_mean[k]/shading_width);
|
|
DBG (DBG_error,"Shading_mean[%d] = %d\n",k,scanner->shading_mean[k]);
|
|
}
|
|
|
|
/* Set shading data present */
|
|
scanner->shading_data_present = SANE_TRUE;
|
|
|
|
/* Export shading data as TIFF */
|
|
#ifdef CAN_DO_4_CHANNEL_TIFF
|
|
if (scanner->val[OPT_SAVE_SHADINGDATA].b) {
|
|
struct Pieusb_Read_Buffer shading;
|
|
SANE_Byte* lboff = buffer;
|
|
SANE_Int bpl = shading_width*2;
|
|
SANE_Int n;
|
|
buffer_create(&shading, shading_width, shading_height, 0x0F, 16);
|
|
for (n=0; n<4*shading_height; n++) {
|
|
if (buffer_put_single_color_line(&shading, *lboff, lboff+2, bpl) == 0) {
|
|
break;
|
|
}
|
|
lboff += (bpl + 2);
|
|
}
|
|
FILE* fs = fopen("pieusb.shading", "w");
|
|
/* write_tiff_rgbi_header (fs, shading_width, shading_height, 16, 3600, NULL); */
|
|
fwrite(shading.data, 1, shading.image_size_bytes, fs);
|
|
fclose(fs);
|
|
buffer_delete(&shading);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/*
|
|
* Set frame (from scanner options)
|
|
*/
|
|
|
|
SANE_Status
|
|
sanei_pieusb_set_frame_from_options(Pieusb_Scanner * scanner)
|
|
{
|
|
double dpmm;
|
|
struct Pieusb_Command_Status status;
|
|
|
|
dpmm = (double) scanner->device->maximum_resolution / MM_PER_INCH;
|
|
scanner->frame.x0 = SANE_UNFIX(scanner->val[OPT_TL_X].w) * dpmm;
|
|
scanner->frame.y0 = SANE_UNFIX(scanner->val[OPT_TL_Y].w) * dpmm;
|
|
scanner->frame.x1 = SANE_UNFIX(scanner->val[OPT_BR_X].w) * dpmm;
|
|
scanner->frame.y1 = SANE_UNFIX(scanner->val[OPT_BR_Y].w) * dpmm;
|
|
scanner->frame.index = 0x80; /* 0x80: value from cyberview */
|
|
sanei_pieusb_cmd_set_scan_frame (scanner->device_number, scanner->frame.index, &(scanner->frame), &status);
|
|
DBG (DBG_info_sane, "sanei_pieusb_set_frame_from_options(): sanei_pieusb_cmd_set_scan_frame status %s\n", sane_strstatus (sanei_pieusb_convert_status (status.pieusb_status)));
|
|
return sanei_pieusb_convert_status (status.pieusb_status);
|
|
}
|
|
|
|
/*
|
|
* Set mode (from scanner options)
|
|
*/
|
|
|
|
SANE_Status
|
|
sanei_pieusb_set_mode_from_options(Pieusb_Scanner * scanner)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
const char *mode;
|
|
SANE_Status res;
|
|
|
|
mode = scanner->val[OPT_MODE].s;
|
|
if (strcmp (mode, SANE_VALUE_SCAN_MODE_LINEART) == 0) {
|
|
scanner->mode.passes = SCAN_FILTER_GREEN; /* G */
|
|
scanner->mode.colorFormat = SCAN_COLOR_FORMAT_PIXEL;
|
|
} else if(strcmp (mode, SANE_VALUE_SCAN_MODE_HALFTONE) == 0) {
|
|
scanner->mode.passes = SCAN_FILTER_GREEN; /* G */
|
|
scanner->mode.colorFormat = SCAN_COLOR_FORMAT_PIXEL;
|
|
} else if(strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY) == 0) {
|
|
scanner->mode.passes = SCAN_FILTER_GREEN; /* G=gray; unable to get R & B & I to work */
|
|
scanner->mode.colorFormat = SCAN_COLOR_FORMAT_PIXEL;
|
|
} else if(scanner->val[OPT_PREVIEW].b) {
|
|
/* Catch preview here, otherwise next ifs get complicated */
|
|
scanner->mode.passes = SCAN_ONE_PASS_COLOR;
|
|
scanner->mode.colorFormat = SCAN_COLOR_FORMAT_INDEX; /* pixel format might be an alternative */
|
|
} else if(strcmp (mode, SANE_VALUE_SCAN_MODE_RGBI) == 0) {
|
|
scanner->mode.passes = SCAN_ONE_PASS_RGBI;
|
|
scanner->mode.colorFormat = SCAN_COLOR_FORMAT_INDEX;
|
|
} else if(strcmp (mode, SANE_VALUE_SCAN_MODE_COLOR) == 0 && scanner->val[OPT_CLEAN_IMAGE].b) {
|
|
scanner->mode.passes = SCAN_ONE_PASS_RGBI; /* Need infrared for cleaning */
|
|
scanner->mode.colorFormat = SCAN_COLOR_FORMAT_INDEX;
|
|
} else { /* SANE_VALUE_SCAN_MODE_COLOR */
|
|
scanner->mode.passes = SCAN_ONE_PASS_COLOR;
|
|
scanner->mode.colorFormat = SCAN_COLOR_FORMAT_INDEX; /* pixel format might be an alternative */
|
|
}
|
|
/* Resolution */
|
|
if (scanner->val[OPT_PREVIEW].b) {
|
|
scanner->mode.resolution = scanner->device->fast_preview_resolution;
|
|
DBG (DBG_info_sane, "sanei_pieusb_set_mode_from_options(): resolution fast preview (%d)\n", scanner->mode.resolution);
|
|
} else {
|
|
scanner->mode.resolution = SANE_UNFIX (scanner->val[OPT_RESOLUTION].w);
|
|
DBG (DBG_info_sane, "sanei_pieusb_set_mode_from_options(): resolution from option setting (%d)\n", scanner->mode.resolution);
|
|
}
|
|
/* Bit depth: exit on untested values */
|
|
switch (scanner->val[OPT_BIT_DEPTH].w) {
|
|
case 1: scanner->mode.colorDepth = SCAN_COLOR_DEPTH_1; break;
|
|
case 8: scanner->mode.colorDepth = SCAN_COLOR_DEPTH_8; break;
|
|
case 16: scanner->mode.colorDepth = SCAN_COLOR_DEPTH_16; break;
|
|
default: /* 4, 10 & 12 */
|
|
DBG (DBG_error, "sanei_pieusb_set_mode_from_options(): sanei_pieusb_cmd_set_scan_frame untested bit depth %d\n", scanner->val[OPT_BIT_DEPTH].w);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
scanner->mode.byteOrder = 0x01; /* 0x01 = Intel; only bit 0 used */
|
|
scanner->mode.sharpen = scanner->val[OPT_SHARPEN].b && !scanner->val[OPT_PREVIEW].b;
|
|
scanner->mode.skipShadingAnalysis = !scanner->val[OPT_SHADING_ANALYSIS].b;
|
|
scanner->mode.fastInfrared = scanner->val[OPT_FAST_INFRARED].b && !scanner->val[OPT_PREVIEW].b;
|
|
if (strcmp (scanner->val[OPT_HALFTONE_PATTERN].s, "53lpi 45d ROUND") == 0) {
|
|
scanner->mode.halftonePattern = 0;
|
|
} else { /*TODO: the others */
|
|
scanner->mode.halftonePattern = 0;
|
|
}
|
|
scanner->mode.lineThreshold = SANE_UNFIX (scanner->val[OPT_THRESHOLD].w) / 100 * 0xFF; /* 0xFF = 100% */
|
|
sanei_pieusb_cmd_set_mode (scanner->device_number, &(scanner->mode), &status);
|
|
res = sanei_pieusb_convert_status(status.pieusb_status);
|
|
if (res == SANE_STATUS_GOOD) {
|
|
res = sanei_pieusb_wait_ready (scanner, 0);
|
|
}
|
|
DBG (DBG_info_sane, "sanei_pieusb_set_mode_from_options(): sanei_pieusb_cmd_set_mode status %s\n", sane_strstatus(res));
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Set gains, exposure and offset, to:
|
|
* - values default (pieusb_set_default_gain_offset)
|
|
* - values set by options
|
|
* - values set by auto-calibration procedure
|
|
* - values determined from preceding preview
|
|
*
|
|
* @param scanner
|
|
* @return
|
|
*/
|
|
SANE_Status
|
|
sanei_pieusb_set_gain_offset(Pieusb_Scanner * scanner, const char *calibration_mode)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
SANE_Status ret;
|
|
double gain;
|
|
|
|
DBG (DBG_info,"sanei_pieusb_set_gain_offset(): mode = %s\n", calibration_mode);
|
|
|
|
if (strcmp (calibration_mode, SCAN_CALIBRATION_DEFAULT) == 0) {
|
|
/* Default values */
|
|
DBG(DBG_info_sane,"sanei_pieusb_set_gain_offset(): get calibration data from defaults\n");
|
|
scanner->settings.exposureTime[0] = DEFAULT_EXPOSURE;
|
|
scanner->settings.exposureTime[1] = DEFAULT_EXPOSURE;
|
|
scanner->settings.exposureTime[2] = DEFAULT_EXPOSURE;
|
|
scanner->settings.exposureTime[3] = DEFAULT_EXPOSURE;
|
|
scanner->settings.offset[0] = DEFAULT_OFFSET;
|
|
scanner->settings.offset[1] = DEFAULT_OFFSET;
|
|
scanner->settings.offset[2] = DEFAULT_OFFSET;
|
|
scanner->settings.offset[3] = DEFAULT_OFFSET;
|
|
scanner->settings.gain[0] = DEFAULT_GAIN;
|
|
scanner->settings.gain[1] = DEFAULT_GAIN;
|
|
scanner->settings.gain[2] = DEFAULT_GAIN;
|
|
scanner->settings.gain[3] = DEFAULT_GAIN;
|
|
scanner->settings.light = DEFAULT_LIGHT;
|
|
scanner->settings.extraEntries = DEFAULT_ADDITIONAL_ENTRIES;
|
|
scanner->settings.doubleTimes = DEFAULT_DOUBLE_TIMES;
|
|
status.pieusb_status = PIEUSB_STATUS_GOOD;
|
|
} else if ((strcmp(calibration_mode, SCAN_CALIBRATION_PREVIEW) == 0)
|
|
&& scanner->preview_done) {
|
|
/* If no preview data available, do the auto-calibration. */
|
|
double dg, dgi;
|
|
DBG (DBG_info, "sanei_pieusb_set_gain_offset(): get calibration data from preview. scanner->mode.passes %d\n", scanner->mode.passes);
|
|
switch (scanner->mode.passes) {
|
|
case SCAN_ONE_PASS_RGBI:
|
|
dg = 3.00;
|
|
dgi = ((double)scanner->settings.saturationLevel[0] / 65536) / ((double)scanner->preview_upper_bound[0] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
dgi = ((double)scanner->settings.saturationLevel[1] / 65536) / ((double)scanner->preview_upper_bound[1] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
dgi = ((double)scanner->settings.saturationLevel[2] / 65536) / ((double)scanner->preview_upper_bound[2] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
updateGain2(scanner, 0, dg);
|
|
updateGain2(scanner, 1, dg);
|
|
updateGain2(scanner, 2, dg);
|
|
break;
|
|
case SCAN_ONE_PASS_COLOR:
|
|
dg = 3.00;
|
|
dgi = ((double)scanner->settings.saturationLevel[0] / 65536) / ((double)scanner->preview_upper_bound[0] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
dgi = ((double)scanner->settings.saturationLevel[1] / 65536) / ((double)scanner->preview_upper_bound[1] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
dgi = ((double)scanner->settings.saturationLevel[2] / 65536) / ((double)scanner->preview_upper_bound[2] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
updateGain2(scanner, 0, dg);
|
|
updateGain2(scanner, 1, dg);
|
|
updateGain2(scanner, 2, dg);
|
|
break;
|
|
case SCAN_FILTER_BLUE:
|
|
dg = 3.00;
|
|
dgi = ((double)scanner->settings.saturationLevel[2] / 65536) / ((double)scanner->preview_upper_bound[2] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
updateGain2(scanner, 2, dg);
|
|
break;
|
|
case SCAN_FILTER_GREEN:
|
|
dg = 3.00;
|
|
dgi = ((double)scanner->settings.saturationLevel[1] / 65536) / ((double)scanner->preview_upper_bound[1] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
updateGain2(scanner, 1, dg);
|
|
break;
|
|
case SCAN_FILTER_RED:
|
|
dg = 3.00;
|
|
dgi = ((double)scanner->settings.saturationLevel[0] / 65536) / ((double)scanner->preview_upper_bound[0] / HISTOGRAM_SIZE);
|
|
if (dgi < dg) dg = dgi;
|
|
updateGain2(scanner, 0, dg);
|
|
break;
|
|
case SCAN_FILTER_NEUTRAL:
|
|
break;
|
|
}
|
|
status.pieusb_status = PIEUSB_STATUS_GOOD;
|
|
} else if (strcmp (calibration_mode, SCAN_CALIBRATION_OPTIONS) == 0) {
|
|
DBG (DBG_info_sane, "sanei_pieusb_set_gain_offset(): get calibration data from options\n");
|
|
/* Exposure times */
|
|
scanner->settings.exposureTime[0] = scanner->val[OPT_SET_EXPOSURE_R].w;
|
|
scanner->settings.exposureTime[1] = scanner->val[OPT_SET_EXPOSURE_G].w;
|
|
scanner->settings.exposureTime[2] = scanner->val[OPT_SET_EXPOSURE_B].w;
|
|
scanner->settings.exposureTime[3] = scanner->val[OPT_SET_EXPOSURE_I].w; /* Infrared */
|
|
/* Offsets */
|
|
scanner->settings.offset[0] = scanner->val[OPT_SET_OFFSET_R].w;
|
|
scanner->settings.offset[1] = scanner->val[OPT_SET_OFFSET_G].w;
|
|
scanner->settings.offset[2] = scanner->val[OPT_SET_OFFSET_B].w;
|
|
scanner->settings.offset[3] = scanner->val[OPT_SET_OFFSET_I].w; /* Infrared */
|
|
/* Gains */
|
|
scanner->settings.gain[0] = scanner->val[OPT_SET_GAIN_R].w;
|
|
scanner->settings.gain[1] = scanner->val[OPT_SET_GAIN_G].w;
|
|
scanner->settings.gain[2] = scanner->val[OPT_SET_GAIN_B].w;
|
|
scanner->settings.gain[3] = scanner->val[OPT_SET_GAIN_I].w; /* Infrared */
|
|
/* Light, extra entries and doubling */
|
|
scanner->settings.light = scanner->val[OPT_LIGHT].w;
|
|
scanner->settings.extraEntries = DEFAULT_ADDITIONAL_ENTRIES;
|
|
scanner->settings.doubleTimes = scanner->val[OPT_DOUBLE_TIMES].w;
|
|
status.pieusb_status = PIEUSB_STATUS_GOOD;
|
|
} else { /* SCAN_CALIBRATION_AUTO */
|
|
DBG (DBG_info_sane, "sanei_pieusb_set_gain_offset(): get calibration data from scanner\n");
|
|
sanei_pieusb_cmd_get_gain_offset (scanner->device_number, &scanner->settings, &status);
|
|
}
|
|
/* Check status */
|
|
if (status.pieusb_status == PIEUSB_STATUS_DEVICE_BUSY) {
|
|
ret = sanei_pieusb_wait_ready (scanner, 0);
|
|
if (ret != SANE_STATUS_GOOD) {
|
|
DBG (DBG_error,"sanei_pieusb_set_gain_offset(): not ready after sanei_pieusb_cmd_get_gain_offset(): %d\n", ret);
|
|
return ret;
|
|
}
|
|
}
|
|
else if (status.pieusb_status != PIEUSB_STATUS_GOOD) {
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
/* Adjust gain */
|
|
gain = 1.0;
|
|
if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_03) == 0) {
|
|
gain = 0.3;
|
|
} else if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_05) == 0) {
|
|
gain = 0.5;
|
|
} else if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_08) == 0) {
|
|
gain = 0.8;
|
|
} else if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_10) == 0) {
|
|
gain = 1.0;
|
|
} else if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_12) == 0) {
|
|
gain = 1.2;
|
|
} else if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_16) == 0) {
|
|
gain = 1.6;
|
|
} else if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_19) == 0) {
|
|
gain = 1.9;
|
|
} else if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_24) == 0) {
|
|
gain = 2.4;
|
|
} else if (strcmp (scanner->val[OPT_GAIN_ADJUST].s, SCAN_GAIN_ADJUST_30) == 0) {
|
|
gain = 3.0;
|
|
}
|
|
switch (scanner->mode.passes) {
|
|
case SCAN_ONE_PASS_RGBI:
|
|
case SCAN_ONE_PASS_COLOR:
|
|
updateGain2 (scanner, 0, gain);
|
|
updateGain2 (scanner, 1, gain);
|
|
updateGain2 (scanner, 2, gain);
|
|
/* Don't correct IR, hampers cleaning process... */
|
|
break;
|
|
case SCAN_FILTER_INFRARED:
|
|
updateGain2 (scanner, 3, gain);
|
|
break;
|
|
case SCAN_FILTER_BLUE:
|
|
updateGain2 (scanner, 2, gain);
|
|
break;
|
|
case SCAN_FILTER_GREEN:
|
|
updateGain2 (scanner, 1, gain);
|
|
break;
|
|
case SCAN_FILTER_RED:
|
|
updateGain2 (scanner, 0, gain);
|
|
break;
|
|
case SCAN_FILTER_NEUTRAL:
|
|
break;
|
|
}
|
|
/* Now set values for gain, offset and exposure */
|
|
sanei_pieusb_cmd_set_gain_offset (scanner->device_number, &(scanner->settings), &status);
|
|
ret = sanei_pieusb_convert_status (status.pieusb_status);
|
|
DBG (DBG_info_sane, "sanei_pieusb_set_gain_offset(): status %s\n", sane_strstatus (ret));
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* get shading data
|
|
* must be called immediately after sanei_pieusb_set_gain_offset
|
|
*/
|
|
|
|
SANE_Status
|
|
sanei_pieusb_get_shading_data(Pieusb_Scanner * scanner)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
SANE_Int shading_width;
|
|
SANE_Int shading_height;
|
|
SANE_Byte* buffer;
|
|
SANE_Int lines;
|
|
SANE_Int cols;
|
|
SANE_Int size;
|
|
SANE_Status res = SANE_STATUS_GOOD;
|
|
|
|
DBG (DBG_info_sane, "sanei_pieusb_get_shading_data()\n");
|
|
shading_width = scanner->device->shading_parameters[0].pixelsPerLine;
|
|
shading_height = scanner->device->shading_parameters[0].nLines;
|
|
if (shading_height < 1) {
|
|
DBG (DBG_error, "shading_height < 1\n");
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
switch (scanner->mode.colorFormat) {
|
|
case SCAN_COLOR_FORMAT_PIXEL: /* Pixel */
|
|
lines = shading_height * 4;
|
|
cols = 2 * shading_width;
|
|
break;
|
|
case SCAN_COLOR_FORMAT_INDEX: /* Indexed */
|
|
lines = shading_height * 4;
|
|
cols = (2 * shading_width + 2);
|
|
break;
|
|
default:
|
|
DBG (DBG_error, "sanei_pieusb_get_shading_data(): color format %d not implemented\n", scanner->mode.colorFormat);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
size = cols * lines;
|
|
buffer = malloc (size);
|
|
if (buffer == NULL) {
|
|
return SANE_STATUS_NO_MEM;
|
|
}
|
|
sanei_pieusb_cmd_get_scanned_lines (scanner->device_number, buffer, 4, cols * 4, &status);
|
|
if (status.pieusb_status == PIEUSB_STATUS_GOOD) {
|
|
res = sanei_pieusb_wait_ready (scanner, 0);
|
|
if (res == SANE_STATUS_GOOD) {
|
|
sanei_pieusb_cmd_get_scanned_lines (scanner->device_number, buffer + cols*4, lines - 4, (lines - 4) * cols, &status);
|
|
if (status.pieusb_status == PIEUSB_STATUS_GOOD) {
|
|
pieusb_calculate_shading (scanner, buffer);
|
|
}
|
|
res = sanei_pieusb_convert_status (status.pieusb_status);
|
|
}
|
|
}
|
|
else {
|
|
res = sanei_pieusb_convert_status (status.pieusb_status);
|
|
}
|
|
free (buffer);
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
|
|
SANE_Status
|
|
sanei_pieusb_get_ccd_mask(Pieusb_Scanner * scanner)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
|
|
DBG(DBG_info_proc, "sanei_pieusb_get_ccd_mask()\n");
|
|
|
|
sanei_pieusb_cmd_get_ccd_mask(scanner->device_number, scanner->ccd_mask, scanner->ccd_mask_size, &status);
|
|
if (status.pieusb_status == PIEUSB_STATUS_GOOD) {
|
|
/* Save CCD mask */
|
|
if (scanner->val[OPT_SAVE_CCDMASK].b) {
|
|
FILE* fs = fopen ("pieusb.ccd", "w");
|
|
fwrite (scanner->ccd_mask, 1, scanner->ccd_mask_size, fs);
|
|
fclose (fs);
|
|
}
|
|
}
|
|
return sanei_pieusb_convert_status(status.pieusb_status);
|
|
|
|
}
|
|
|
|
/**
|
|
* Read parameters from scanner
|
|
* and initialize SANE parameters
|
|
*
|
|
* @param scanner
|
|
* @return parameter_bytes for use in get_scan_data()
|
|
*/
|
|
SANE_Status
|
|
sanei_pieusb_get_parameters(Pieusb_Scanner * scanner, SANE_Int *parameter_bytes)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
struct Pieusb_Scan_Parameters parameters;
|
|
const char *mode;
|
|
|
|
DBG (DBG_info_proc, "sanei_pieusb_get_parameters()\n");
|
|
|
|
sanei_pieusb_cmd_get_parameters (scanner->device_number, ¶meters, &status);
|
|
if (status.pieusb_status != PIEUSB_STATUS_GOOD) {
|
|
return sanei_pieusb_convert_status (status.pieusb_status);
|
|
}
|
|
*parameter_bytes = parameters.bytes;
|
|
/* Use response from sanei_pieusb_cmd_get_parameters() for initialization of SANE parameters.
|
|
* Note the weird values of the bytes-field: this is because of the colorFormat
|
|
* setting in sanei_pieusb_cmd_set_mode(). The single-color modes all use the pixel format,
|
|
* which makes sanei_pieusb_cmd_get_parameters() return a full color line although just
|
|
* one color actually contains data. For the index format, the bytes field
|
|
* gives the size of a single color line. */
|
|
mode = scanner->val[OPT_MODE].s;
|
|
if (strcmp (mode, SANE_VALUE_SCAN_MODE_LINEART) == 0) {
|
|
scanner->scan_parameters.format = SANE_FRAME_GRAY;
|
|
scanner->scan_parameters.depth = 1;
|
|
scanner->scan_parameters.bytes_per_line = parameters.bytes/3;
|
|
} else if (strcmp (mode, SANE_VALUE_SCAN_MODE_HALFTONE) == 0) {
|
|
scanner->scan_parameters.format = SANE_FRAME_GRAY;
|
|
scanner->scan_parameters.depth = 1;
|
|
scanner->scan_parameters.bytes_per_line = parameters.bytes/3;
|
|
} else if (strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY) == 0) {
|
|
scanner->scan_parameters.format = SANE_FRAME_GRAY;
|
|
scanner->scan_parameters.depth = scanner->val[OPT_BIT_DEPTH].w;
|
|
scanner->scan_parameters.bytes_per_line = parameters.bytes/3;
|
|
} else if (strcmp (mode, SANE_VALUE_SCAN_MODE_RGBI) == 0) {
|
|
scanner->scan_parameters.format = SANE_FRAME_RGB; /* was: SANE_FRAME_RGBI */
|
|
scanner->scan_parameters.depth = scanner->val[OPT_BIT_DEPTH].w;
|
|
scanner->scan_parameters.bytes_per_line = 4*parameters.bytes;
|
|
} else { /* SANE_VALUE_SCAN_MODE_COLOR, with and without option clean image set */
|
|
scanner->scan_parameters.format = SANE_FRAME_RGB;
|
|
scanner->scan_parameters.depth = scanner->val[OPT_BIT_DEPTH].w;
|
|
scanner->scan_parameters.bytes_per_line = 3*parameters.bytes;
|
|
}
|
|
scanner->scan_parameters.lines = parameters.lines;
|
|
scanner->scan_parameters.pixels_per_line = parameters.width;
|
|
scanner->scan_parameters.last_frame = SANE_TRUE;
|
|
|
|
DBG (DBG_info_sane,"sanei_pieusb_get_parameters(): mode '%s'\n", mode);
|
|
DBG (DBG_info_sane," format = %d\n", scanner->scan_parameters.format);
|
|
DBG (DBG_info_sane," depth = %d\n", scanner->scan_parameters.depth);
|
|
DBG (DBG_info_sane," bytes_per_line = %d\n", scanner->scan_parameters.bytes_per_line);
|
|
DBG (DBG_info_sane," lines = %d\n", scanner->scan_parameters.lines);
|
|
DBG (DBG_info_sane," pixels_per_line = %d\n", scanner->scan_parameters.pixels_per_line);
|
|
DBG (DBG_info_sane," last_frame = %d\n", scanner->scan_parameters.last_frame);
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sanei_pieusb_get_scan_data(Pieusb_Scanner * scanner, SANE_Int parameter_bytes)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
SANE_Parameters *parameters = &scanner->scan_parameters;
|
|
SANE_Int lines_to_read, lines_remaining;
|
|
SANE_Int ppl, bpl;
|
|
SANE_Byte *linebuf, *lboff;
|
|
SANE_Bool compress;
|
|
int n, k, i;
|
|
|
|
switch (scanner->mode.colorFormat) {
|
|
case SCAN_COLOR_FORMAT_PIXEL: /* Pixel */
|
|
lines_to_read = scanner->buffer.height;
|
|
break;
|
|
case SCAN_COLOR_FORMAT_INDEX: /* Indexed */
|
|
lines_to_read = scanner->buffer.colors * scanner->buffer.height;
|
|
break;
|
|
default:
|
|
DBG(DBG_error, "sanei_pieusb_get_scan_data(): color format %d not implemented\n",scanner->mode.colorFormat);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
lines_remaining = lines_to_read;
|
|
DBG (DBG_info_proc, "sanei_pieusb_get_scan_data(colorFormat %d), lines_to_read %d, bytes %d\n", scanner->mode.colorFormat, lines_to_read, parameter_bytes);
|
|
|
|
/*
|
|
fdraw = open("/tmp/pieusb.raw", O_WRONLY | O_CREAT | O_TRUNC, (mode_t)0600);
|
|
if (fdraw == -1) {
|
|
perror("error opening raw image buffer file");
|
|
}
|
|
*/
|
|
while (lines_remaining > 0) {
|
|
SANE_Int lines;
|
|
/* Read lines */
|
|
/* The amount of bytes_per_line varies with color format setting; only 'pixel' and 'index' implemented */
|
|
ppl = parameters->pixels_per_line;
|
|
switch (scanner->mode.colorFormat) {
|
|
case SCAN_COLOR_FORMAT_PIXEL: /* Pixel */
|
|
bpl = parameter_bytes;
|
|
break;
|
|
case SCAN_COLOR_FORMAT_INDEX: /* Indexed */
|
|
bpl = parameter_bytes + 2; /* Index bytes! */
|
|
break;
|
|
default:
|
|
DBG(DBG_error, "sanei_pieusb_get_scan_data(): color format %d not implemented\n", scanner->mode.colorFormat);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
lines = (lines_remaining < 256) ? lines_remaining : 255;
|
|
DBG(DBG_info_sane, "sanei_pieusb_get_scan_data(): reading lines: now %d, bytes per line = %d\n", lines, bpl);
|
|
linebuf = malloc(lines * bpl);
|
|
sanei_pieusb_cmd_get_scanned_lines(scanner->device_number, linebuf, lines, lines * bpl, &status);
|
|
if (status.pieusb_status != PIEUSB_STATUS_GOOD ) {
|
|
/* Error, return */
|
|
free(linebuf);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
/* Save raw data */
|
|
/*
|
|
if (fdraw != -1) {
|
|
wcnt = write(fdraw,linebuf,parameters.lines*bpl);
|
|
DBG(DBG_info_sane,"Raw written %d\n",wcnt);
|
|
}
|
|
*/
|
|
/* Copy into official buffer
|
|
* Sometimes the scanner returns too many lines. Take care not to
|
|
* overflow the buffer. */
|
|
lboff = linebuf;
|
|
switch (scanner->mode.colorFormat) {
|
|
case SCAN_COLOR_FORMAT_PIXEL:
|
|
/* The scanner may return lines with 3 colors even though only
|
|
* one color is actually scanned. Detect this situation and
|
|
* eliminate the excess samples from the line buffer before
|
|
* handing it to buffer_put_full_color_line(). */
|
|
compress = SANE_FALSE;
|
|
if (scanner->buffer.colors == 1
|
|
&& (bpl * scanner->buffer.packing_density / ppl) == (3 * scanner->buffer.packet_size_bytes)) {
|
|
compress = SANE_TRUE;
|
|
}
|
|
for (n = 0; n < lines; n++) {
|
|
if (compress) {
|
|
/* Move samples to fill up all unused locations */
|
|
int ps = scanner->buffer.packet_size_bytes;
|
|
for (k = 0; k < scanner->buffer.line_size_packets; k++) {
|
|
for (i = 0; i < ps; i++) {
|
|
lboff[ps*k+i] = lboff[3*ps*k+i];
|
|
}
|
|
}
|
|
}
|
|
if (sanei_pieusb_buffer_put_full_color_line(&scanner->buffer, lboff, bpl/3) == 0) {
|
|
/* Error, return */
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
lboff += bpl;
|
|
}
|
|
break;
|
|
case SCAN_COLOR_FORMAT_INDEX:
|
|
/* Indexed data */
|
|
for (n = 0; n < lines; n++) {
|
|
if (sanei_pieusb_buffer_put_single_color_line(&scanner->buffer, *lboff, lboff+2, bpl-2) == 0) {
|
|
/* Error, return */
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
lboff += bpl;
|
|
}
|
|
break;
|
|
default:
|
|
DBG(DBG_error, "sanei_pieusb_get_scan_data(): store color format %d not implemented\n", scanner->mode.colorFormat);
|
|
free(linebuf);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
free(linebuf);
|
|
lines_remaining -= lines; /* Note: excess discarded */
|
|
DBG(DBG_info_sane, "sanei_pieusb_get_scan_data(): reading lines: remaining %d\n", lines_remaining);
|
|
}
|
|
/*
|
|
if (fdraw != -1) close(fdraw);
|
|
*/
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
* Wait for scanner to get ready
|
|
*
|
|
* loop of test_ready/read_state
|
|
*
|
|
* @param scanner
|
|
* @param device_number, used if scanner == NULL
|
|
* @return SANE_Status
|
|
*/
|
|
|
|
SANE_Status
|
|
sanei_pieusb_wait_ready(Pieusb_Scanner * scanner, SANE_Int device_number)
|
|
{
|
|
struct Pieusb_Command_Status status;
|
|
struct Pieusb_Scanner_State state;
|
|
time_t start, elapsed;
|
|
|
|
DBG (DBG_info_proc, "sanei_pieusb_wait_ready()\n");
|
|
start = time(NULL);
|
|
if (scanner)
|
|
device_number = scanner->device_number;
|
|
|
|
for(;;) {
|
|
sanei_pieusb_cmd_test_unit_ready(device_number, &status);
|
|
DBG (DBG_info_proc, "-> sanei_pieusb_cmd_test_unit_ready: %d\n", status.pieusb_status);
|
|
if (status.pieusb_status == PIEUSB_STATUS_GOOD)
|
|
break;
|
|
if (status.pieusb_status == PIEUSB_STATUS_IO_ERROR)
|
|
break;
|
|
sanei_pieusb_cmd_read_state(device_number, &state, &status);
|
|
DBG (DBG_info_proc, "-> sanei_pieusb_cmd_read_state: %d\n", status.pieusb_status);
|
|
if (status.pieusb_status != PIEUSB_STATUS_DEVICE_BUSY)
|
|
break;
|
|
sleep(2);
|
|
elapsed = time(NULL) - start;
|
|
if (elapsed > 120) { /* 2 minute overall timeout */
|
|
DBG (DBG_error, "scanner not ready after 2 minutes\n");
|
|
break;
|
|
}
|
|
if (elapsed % 2) {
|
|
DBG (DBG_info, "still waiting for scanner to get ready\n");
|
|
}
|
|
}
|
|
return sanei_pieusb_convert_status(status.pieusb_status);
|
|
}
|
|
|
|
|
|
SANE_Status sanei_pieusb_analyze_preview(Pieusb_Scanner * scanner)
|
|
{
|
|
int k, n;
|
|
SANE_Parameters params;
|
|
SANE_Int N;
|
|
double *norm_histo;
|
|
double level;
|
|
|
|
DBG(DBG_info, "sanei_pieusb_analyze_preview(): saving preview data\n");
|
|
|
|
/* Settings */
|
|
scanner->preview_done = SANE_TRUE;
|
|
for (k = 0; k < 4; k++) {
|
|
scanner->preview_exposure[k] = scanner->settings.exposureTime[k];
|
|
scanner->preview_gain[k] = scanner->settings.gain[k];
|
|
scanner->preview_offset[k] = scanner->settings.offset[k];
|
|
}
|
|
/* Analyze color planes */
|
|
N = scanner->buffer.width * scanner->buffer.height;
|
|
params.format = SANE_FRAME_GRAY;
|
|
params.depth = scanner->buffer.depth;
|
|
params.pixels_per_line = scanner->buffer.width;
|
|
params.lines = scanner->buffer.height;
|
|
for (k = 0; k < scanner->buffer.colors; k++) {
|
|
/* Create histogram for color k */
|
|
sanei_ir_create_norm_histogram (¶ms, scanner->buffer.data + k * N, &norm_histo);
|
|
/* Find 1% and 99% limits */
|
|
level = 0;
|
|
for (n =0; n < HISTOGRAM_SIZE; n++) {
|
|
|
|
level += norm_histo[n];
|
|
if (level < 0.01) {
|
|
scanner->preview_lower_bound[k] = n;
|
|
}
|
|
if (level < 0.99) {
|
|
scanner->preview_upper_bound[k] = n;
|
|
}
|
|
}
|
|
DBG(DBG_info,"sanei_pieusb_analyze_preview(): 1%%-99%% levels for color %d: %d - %d\n", k, scanner->preview_lower_bound[k], scanner->preview_upper_bound[k]);
|
|
}
|
|
/* Disable remaining color planes */
|
|
for (k = scanner->buffer.colors; k < 4; k++) {
|
|
scanner->preview_lower_bound[k] = 0;
|
|
scanner->preview_upper_bound[k] = 0;
|
|
}
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return actual gain at given gain setting
|
|
*
|
|
* @param gain Gain setting (0 - 63)
|
|
* @return
|
|
*/
|
|
static double getGain(int gain)
|
|
{
|
|
int k;
|
|
|
|
/* Actually an error, but don't be picky */
|
|
if (gain <= 0) {
|
|
return gains[0];
|
|
}
|
|
/* A gain > 63 is also an error, but don't be picky */
|
|
if (gain >= 60) {
|
|
return (gain-55)*(gains[12]-gains[11])/5 + gains[11];
|
|
}
|
|
/* Interpolate other values */
|
|
k = gain/5; /* index of array value just below given gain */
|
|
return (gain-5*k)*(gains[k+1]-gains[k])/5 + gains[k];
|
|
}
|
|
|
|
static int getGainSetting(double gain)
|
|
{
|
|
int k, m;
|
|
|
|
/* Out of bounds */
|
|
if (gain < 1.0) {
|
|
return 0;
|
|
}
|
|
if (gain >= gains[12]) {
|
|
m = 60 + lround((gain-gains[11])/(gains[12]-gains[11])*5);
|
|
if (m > 63) m = 63;
|
|
return m;
|
|
}
|
|
/* Interpolate the rest */
|
|
m = 0;
|
|
for (k = 0; k <= 11; k++) {
|
|
if (gains[k] <= gain && gain < gains[k+1]) {
|
|
m = 5*k + lround((gain-gains[k])/(gains[k+1]-gains[k])*5);
|
|
}
|
|
}
|
|
return m;
|
|
}
|
|
|
|
/**
|
|
* Modify gain and exposure times in order to make maximal use of the scan depth.
|
|
* Each color treated separately, infrared excluded.
|
|
*
|
|
* This may be too aggressive => leads to a noisy whitish border instead of the orange.
|
|
* In a couuple of tries, gain was set to values of 60 and above, which introduces
|
|
* the noise?
|
|
* The whitish border is logical since the brightest parts of the negative, the
|
|
* unexposed borders, are amplified to values near CCD saturation, which is white.
|
|
* Maybe a uniform gain increase for each color is more appropriate? Somewhere
|
|
* between 2.5 and 3 seems worthwhile trying, see updateGain2().
|
|
*
|
|
switch (scanner->mode.passes) {
|
|
case SCAN_ONE_PASS_RGBI:
|
|
updateGain(scanner,0);
|
|
updateGain(scanner,1);
|
|
updateGain(scanner,2);
|
|
updateGain(scanner,3);
|
|
break;
|
|
case SCAN_ONE_PASS_COLOR:
|
|
updateGain(scanner,0);
|
|
updateGain(scanner,1);
|
|
updateGain(scanner,2);
|
|
break;
|
|
case SCAN_FILTER_INFRARED:
|
|
updateGain(scanner,3);
|
|
break;
|
|
case SCAN_FILTER_BLUE:
|
|
updateGain(scanner,2);
|
|
break;
|
|
case SCAN_FILTER_GREEN:
|
|
updateGain(scanner,1);
|
|
break;
|
|
case SCAN_FILTER_RED:
|
|
updateGain(scanner,0);
|
|
break;
|
|
case SCAN_FILTER_NEUTRAL:
|
|
break;
|
|
}
|
|
* @param scanner
|
|
*/
|
|
/*
|
|
static void updateGain(Pieusb_Scanner *scanner, int color_index)
|
|
{
|
|
double g, dg;
|
|
|
|
DBG(DBG_info_sane,"updateGain(): color %d preview used G=%d Exp=%d\n", color_index, scanner->preview_gain[color_index], scanner->preview_exposure[color_index]);
|
|
// Additional gain to obtain
|
|
dg = ((double)scanner->settings.saturationLevel[color_index] / 65536) / ((double)scanner->preview_upper_bound[color_index] / HISTOGRAM_SIZE);
|
|
DBG(DBG_info_sane,"updateGain(): additional gain %f\n", dg);
|
|
// Achieve this by modifying gain and exposure
|
|
// Gain used for preview
|
|
g = getGain(scanner->preview_gain[color_index]);
|
|
DBG(DBG_info_sane,"updateGain(): preview had gain %d => %f\n",scanner->preview_gain[color_index],g);
|
|
// Look up new gain setting g*sqrt(dg)
|
|
DBG(DBG_info_sane,"updateGain(): optimized gain * %f = %f\n",sqrt(dg),sqrt(dg)*g);
|
|
scanner->settings.gain[color_index] = getGainSetting(g*sqrt(dg));
|
|
DBG(DBG_info_sane,"updateGain(): optimized gain setting %d => %f\n",scanner->settings.gain[color_index],getGain(scanner->settings.gain[color_index]));
|
|
// Exposure change is straightforward
|
|
DBG(DBG_info_sane,"updateGain(): remains for exposure %f\n",dg/(getGain(scanner->settings.gain[color_index])/g));
|
|
scanner->settings.exposureTime[color_index] = lround( g / getGain(scanner->settings.gain[color_index]) * dg * scanner->preview_exposure[color_index] );
|
|
DBG(DBG_info_sane,"updateGain(): new setting G=%d Exp=%d\n", scanner->settings.gain[color_index], scanner->settings.exposureTime[color_index]);
|
|
}
|
|
*/
|
|
|
|
static void updateGain2(Pieusb_Scanner *scanner, int color_index, double gain_increase)
|
|
{
|
|
double g;
|
|
|
|
DBG(DBG_info,"updateGain2(): color %d preview used G=%d Exp=%d\n", color_index, scanner->settings.gain[color_index], scanner->settings.exposureTime[color_index]);
|
|
/* Additional gain to obtain */
|
|
DBG(DBG_info,"updateGain2(): additional gain %f\n", gain_increase);
|
|
/* Achieve this by modifying gain and exposure */
|
|
/* Gain used for preview */
|
|
g = getGain(scanner->settings.gain[color_index]);
|
|
DBG(DBG_info,"updateGain2(): preview had gain %d => %f\n", scanner->settings.gain[color_index], g);
|
|
/* Look up new gain setting g*sqrt(dg) */
|
|
DBG(DBG_info,"updateGain2(): optimized gain * %f = %f\n", sqrt(gain_increase), sqrt(gain_increase) * g);
|
|
scanner->settings.gain[color_index] = getGainSetting(g * sqrt(gain_increase));
|
|
DBG(DBG_info,"updateGain2(): optimized gain setting %d => %f\n", scanner->settings.gain[color_index], getGain(scanner->settings.gain[color_index]));
|
|
/* Exposure change is straightforward */
|
|
DBG(DBG_info,"updateGain2(): remains for exposure %f\n", gain_increase / (getGain(scanner->settings.gain[color_index]) / g));
|
|
scanner->settings.exposureTime[color_index] = lround( g / getGain(scanner->settings.gain[color_index]) * gain_increase * scanner->settings.exposureTime[color_index] );
|
|
DBG(DBG_info,"updateGain2(): new setting G=%d Exp=%d\n", scanner->settings.gain[color_index], scanner->settings.exposureTime[color_index]);
|
|
}
|