mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Merge branch 'genesys-misc-cleanup' into 'master' 

genesys: Miscellaneous cleanup

See merge request sane-project/backends!208
merge-requests/207/merge
Povilas Kanapickas 2019-10-12 15:06:44 +00:00
rodzic 9ce4cb089f 497c9aeba2
commit 6959c2d14e
10 zmienionych plików z 724 dodań i 711 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

27
backend/genesys.cc
Wyświetl plik

@ -1208,9 +1208,9 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
/* bottom of black stripe is of fixed witdh, this hardcoded value
* will be moved into device struct if more such values are needed */
top += 10;
dev->model->y_offset_calib_white = SANE_FIX((top * MM_PER_INCH) / dpi);
dev->model->y_offset_calib_white = (top * MM_PER_INCH) / dpi;
DBG(DBG_info, "%s: black stripe y_offset = %f mm \n", __func__,
SANE_UNFIX(dev->model->y_offset_calib_white));
dev->model->y_offset_calib_white.value());
}
/* find white corner in dark area : TODO yet another flag */
@ -1229,9 +1229,9 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
count++;
}
top = top / count;
dev->model->y_offset_calib_white = SANE_FIX((top * MM_PER_INCH) / dpi);
dev->model->y_offset_calib_white = (top * MM_PER_INCH) / dpi;
DBG(DBG_info, "%s: white corner y_offset = %f mm\n", __func__,
SANE_UNFIX(dev->model->y_offset_calib_white));
dev->model->y_offset_calib_white.value());
}
DBG(DBG_proc, "%s: ccd_start_xoffset = %d, left = %d, top = %d\n", __func__,
@ -1404,11 +1404,9 @@ static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sens
unsigned channels = dev->settings.get_channels();
DBG(DBG_info, "channels %d y_size %d xres %d\n", channels, dev->model->y_size,
DBG(DBG_info, "channels %d y_size %f xres %d\n", channels, dev->model->y_size.value(),
dev->settings.xres);
size =
channels * 2 * SANE_UNFIX (dev->model->y_size) * dev->settings.xres /
25.4;
size = channels * 2 * dev->model->y_size * dev->settings.xres / 25.4;
/* 1 1 mm 1/inch inch/mm */
std::vector<uint8_t> calibration_data(size);
@ -2852,7 +2850,7 @@ static void genesys_flatbed_calibration(Genesys_Device* dev, Genesys_Sensor& sen
/* we always use sensor pixel number when the ASIC can't handle multi-segments sensor */
if (!(dev->model->flags & GENESYS_FLAG_SIS_SENSOR))
{
pixels_per_line = (SANE_UNFIX (dev->model->x_size) * dev->settings.xres) / MM_PER_INCH;
pixels_per_line = (dev->model->x_size * dev->settings.xres) / MM_PER_INCH;
}
else
{
@ -3764,12 +3762,12 @@ init_gamma_vector_option (Genesys_Scanner * scanner, int option)
* @param size maximum size of the range
* @return a pointer to a valid range or nullptr
*/
static SANE_Range *create_range(SANE_Fixed size)
static SANE_Range* create_range(float size)
{
SANE_Range* range = reinterpret_cast<SANE_Range*>(std::malloc(sizeof(SANE_Range)));
if (range != nullptr) {
range->min = SANE_FIX (0.0);
range->max = size;
range->max = SANE_FIX(size);
range->quant = SANE_FIX (0.0);
}
return range;
@ -3984,12 +3982,12 @@ static void init_options(Genesys_Scanner* s)
s->opt[OPT_GEOMETRY_GROUP].size = 0;
s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
x_range=create_range(model->x_size);
x_range = create_range(model->x_size);
if (x_range == nullptr) {
throw SaneException(SANE_STATUS_NO_MEM);
}
y_range=create_range(model->y_size);
y_range = create_range(model->y_size);
if (y_range == nullptr) {
throw SaneException(SANE_STATUS_NO_MEM);
}
@ -4725,8 +4723,7 @@ static void genesys_buffer_image(Genesys_Scanner *s)
}
else
{
lines =
(SANE_UNFIX (dev->model->y_size) * dev->settings.yres) / MM_PER_INCH;
lines = (dev->model->y_size * dev->settings.yres) / MM_PER_INCH;
}
DBG(DBG_info, "%s: buffering %d lines of %d bytes\n", __func__, lines,
s->params.bytes_per_line);

48
backend/genesys_device.h
Wyświetl plik

@ -74,6 +74,24 @@ struct Genesys_Gpo
GenesysRegisterSettingSet regs;
};
/// Stores a SANE_Fixed value which is automatically converted from and to floating-point values
class FixedFloat
{
public:
FixedFloat() = default;
FixedFloat(const FixedFloat&) = default;
FixedFloat(double number) : value_{SANE_FIX(number)} {}
FixedFloat& operator=(const FixedFloat&) = default;
FixedFloat& operator=(double number) { value_ = SANE_FIX(number); return *this; }
operator double() const { return value(); }
double value() const { return SANE_UNFIX(value_); }
private:
SANE_Fixed value_ = 0;
};
/** @brief structure to describe a scanner model
* This structure describes a model. It is composed of information on the
* sensor, the motor, scanner geometry and flags to drive operation.
@ -105,49 +123,49 @@ struct Genesys_Model
// All offsets below are with respect to the sensor home position
// Start of scan area in mm
SANE_Fixed x_offset = 0;
FixedFloat x_offset = 0;
// Start of scan area in mm (Amount of feeding needed to get to the medium)
SANE_Fixed y_offset = 0;
FixedFloat y_offset = 0;
// Size of scan area in mm
SANE_Fixed x_size = 0;
FixedFloat x_size = 0;
// Size of scan area in mm
SANE_Fixed y_size = 0;
FixedFloat y_size = 0;
// Start of white strip in mm
SANE_Fixed y_offset_calib_white = 0;
FixedFloat y_offset_calib_white = 0;
// Start of black mark in mm
SANE_Fixed x_offset_calib_black = 0;
FixedFloat x_offset_calib_black = 0;
// Start of scan area in transparency mode in mm
SANE_Fixed x_offset_ta = 0;
FixedFloat x_offset_ta = 0;
// Start of scan area in transparency mode in mm
SANE_Fixed y_offset_ta = 0;
FixedFloat y_offset_ta = 0;
// Size of scan area in transparency mode in mm
SANE_Fixed x_size_ta = 0;
FixedFloat x_size_ta = 0;
// Size of scan area in transparency mode in mm
SANE_Fixed y_size_ta = 0;
FixedFloat y_size_ta = 0;
// The position of the sensor when it's aligned with the lamp for transparency scanning
SANE_Fixed y_offset_sensor_to_ta = 0;
FixedFloat y_offset_sensor_to_ta = 0;
// Start of white strip in transparency mode in mm
SANE_Fixed y_offset_calib_white_ta = 0;
FixedFloat y_offset_calib_white_ta = 0;
// Start of black strip in transparency mode in mm
SANE_Fixed y_offset_calib_black_ta = 0;
FixedFloat y_offset_calib_black_ta = 0;
// Size of scan area after paper sensor stop sensing document in mm
SANE_Fixed post_scan = 0;
FixedFloat post_scan = 0;
// Amount of feeding needed to eject document after finishing scanning in mm
SANE_Fixed eject_feed = 0;
FixedFloat eject_feed = 0;
// Line-distance correction (in pixel at optical_ydpi) for CCD scanners
SANE_Int ld_shift_r = 0;

8
backend/genesys_gl124.cc
Wyświetl plik

@ -1044,7 +1044,7 @@ void CommandSetGl124::calculate_current_setup(Genesys_Device * dev,
debug_dump(DBG_info, dev->settings);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
@ -1649,7 +1649,7 @@ void CommandSetGl124::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
/* distance to move to reach white target at high resolution */
move=0;
if (dev->settings.yres >= 1200) {
move = SANE_UNFIX(dev->model->y_offset_calib_white);
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
}
DBG (DBG_io, "%s: move=%d steps\n", __func__, move);
@ -1718,7 +1718,7 @@ void CommandSetGl124::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
/* y (motor) distance to move to reach scanned area */
move_dpi = dev->motor.base_ydpi/4;
move = SANE_UNFIX (dev->model->y_offset);
move = dev->model->y_offset;
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
DBG (DBG_info, "%s: move=%f steps\n", __func__, move);
@ -1730,7 +1730,7 @@ void CommandSetGl124::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
start = dev->model->x_offset;
start += dev->settings.tl_x;
start /= sensor.get_ccd_size_divisor_for_dpi(dev->settings.xres);
start = (start * sensor.optical_res) / MM_PER_INCH;

16
backend/genesys_gl646.cc
Wyświetl plik

@ -1424,7 +1424,7 @@ void CommandSetGl646::detect_document_end(Genesys_Device* dev) const
unsigned lines_in_buffer = bytes_left / dev->session.output_line_bytes_raw;
// we add the number of lines needed to read the last part of the document in
unsigned lines_offset = (SANE_UNFIX(dev->model->y_offset) * dev->session.params.yres) /
unsigned lines_offset = (dev->model->y_offset * dev->session.params.yres) /
MM_PER_INCH;
unsigned remaining_lines = lines_in_buffer + lines_offset;
@ -2039,7 +2039,7 @@ static void setup_for_scan(Genesys_Device* dev,
if (!split) {
if (!dev->model->is_sheetfed) {
if (ycorrection) {
move = SANE_UNFIX(dev->model->y_offset);
move = dev->model->y_offset;
}
// add tl_y to base movement
@ -2057,9 +2057,9 @@ static void setup_for_scan(Genesys_Device* dev,
float start = settings.tl_x;
if (xcorrection) {
if (settings.scan_method == ScanMethod::FLATBED) {
start += SANE_UNFIX(dev->model->x_offset);
start += dev->model->x_offset;
} else {
start += SANE_UNFIX(dev->model->x_offset_ta);
start += dev->model->x_offset_ta;
}
}
start = (start * sensor.optical_res) / MM_PER_INCH;
@ -2705,8 +2705,8 @@ void CommandSetGl646::coarse_gain_calibration(Genesys_Device* dev, const Genesys
}
else
{
settings.tl_x = SANE_UNFIX (dev->model->x_offset_ta);
settings.pixels = (SANE_UNFIX (dev->model->x_size_ta) * resolution) / MM_PER_INCH;
settings.tl_x = dev->model->x_offset_ta;
settings.pixels = (dev->model->x_size_ta * resolution) / MM_PER_INCH;
}
settings.requested_pixels = settings.pixels;
settings.lines = CALIBRATION_LINES;
@ -3100,7 +3100,7 @@ void CommandSetGl646::move_to_ta(Genesys_Device* dev) const
{
DBG_HELPER(dbg);
simple_move(dev, SANE_UNFIX(dev->model->y_offset_sensor_to_ta));
simple_move(dev, dev->model->y_offset_sensor_to_ta);
}
@ -3563,7 +3563,7 @@ void CommandSetGl646::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
settings.yres = res;
settings.tl_x = 0;
settings.tl_y = 0;
settings.pixels = (SANE_UNFIX (dev->model->x_size) * res) / MM_PER_INCH;
settings.pixels = (dev->model->x_size * res) / MM_PER_INCH;
settings.pixels /= calib_sensor.get_ccd_size_divisor_for_dpi(res);
settings.requested_pixels = settings.pixels;

24
backend/genesys_gl841.cc
Wyświetl plik

@ -1843,7 +1843,7 @@ void CommandSetGl841::calculate_current_setup(Genesys_Device * dev,
debug_dump(DBG_info, dev->settings);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
start = dev->model->x_offset;
start += dev->settings.tl_x;
@ -2224,10 +2224,10 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
}
}
feed_mm = SANE_UNFIX(dev->model->eject_feed);
feed_mm = dev->model->eject_feed;
if (dev->document)
{
feed_mm += SANE_UNFIX(dev->model->post_scan);
feed_mm += dev->model->post_scan;
}
sanei_genesys_read_feed_steps(dev, &init_steps);
@ -2317,7 +2317,7 @@ void CommandSetGl841::detect_document_end(Genesys_Device* dev) const
std::size_t output_lines = dev->session.output_line_count;
std::size_t offset_lines = (SANE_UNFIX(dev->model->post_scan) / MM_PER_INCH) *
std::size_t offset_lines = (dev->model->post_scan / MM_PER_INCH) *
dev->settings.yres;
std::size_t scan_end_lines = scanned_lines + offset_lines;
@ -2763,9 +2763,9 @@ void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
assumption: steps are expressed at maximum motor resolution
we need:
SANE_Fixed y_offset;
SANE_Fixed y_size;
SANE_Fixed y_offset_calib;
float y_offset;
float y_size;
float y_offset_calib;
mm_to_steps()=motor dpi / 2.54 / 10=motor dpi / MM_PER_INCH */
/* if scanner uses GENESYS_FLAG_SEARCH_START y_offset is
@ -2775,12 +2775,12 @@ void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
move = 0;
if (dev->model->flags & GENESYS_FLAG_SEARCH_START) {
move += SANE_UNFIX(dev->model->y_offset_calib_white);
move += dev->model->y_offset_calib_white;
}
DBG(DBG_info, "%s move=%f steps\n", __func__, move);
move += SANE_UNFIX (dev->model->y_offset);
move += dev->model->y_offset;
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
move += dev->settings.tl_y;
@ -2789,7 +2789,7 @@ void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
move = (move * move_dpi) / MM_PER_INCH;
/* start */
start = SANE_UNFIX (dev->model->x_offset);
start = dev->model->x_offset;
start += dev->settings.tl_x;
@ -2885,7 +2885,7 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
/* feed to white strip if needed */
if (dev->model->y_offset_calib_white > 0) {
move = SANE_UNFIX(dev->model->y_offset_calib_white);
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi)) / MM_PER_INCH;
DBG(DBG_io, "%s: move=%d lines\n", __func__, move);
gl841_feed(dev, move);
@ -3578,7 +3578,7 @@ void CommandSetGl841::coarse_gain_calibration(Genesys_Device* dev, const Genesys
// feed to white strip if needed
if (dev->model->y_offset_calib_white > 0) {
move = SANE_UNFIX(dev->model->y_offset_calib_white);
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi)) / MM_PER_INCH;
DBG(DBG_io, "%s: move=%d lines\n", __func__, move);
gl841_feed(dev, move);

34
backend/genesys_gl843.cc
Wyświetl plik

@ -1333,9 +1333,9 @@ void CommandSetGl843::calculate_current_setup(Genesys_Device * dev,
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{
start = SANE_UNFIX(dev->model->x_offset_ta);
start = dev->model->x_offset_ta;
} else {
start = SANE_UNFIX(dev->model->x_offset);
start = dev->model->x_offset;
}
if (dev->model->model_id == ModelId::CANON_8400F ||
@ -1538,7 +1538,7 @@ void CommandSetGl843::detect_document_end(Genesys_Device* dev) const
std::size_t output_lines = dev->session.output_line_count;
std::size_t offset_lines = (SANE_UNFIX(dev->model->post_scan) * dev->session.params.yres) /
std::size_t offset_lines = (dev->model->post_scan * dev->session.params.yres) /
MM_PER_INCH;
std::size_t scan_end_lines = scanned_lines + offset_lines;
@ -2241,11 +2241,11 @@ void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
dev->model->model_id == ModelId::CANON_8600F &&
dev->settings.xres == 4800)
{
float offset = SANE_UNFIX(dev->model->x_offset_ta);
float offset = dev->model->x_offset_ta;
offset /= calib_sensor.get_ccd_size_divisor_for_dpi(resolution);
offset = (offset * calib_sensor.optical_res) / MM_PER_INCH;
float size = SANE_UNFIX(dev->model->x_size_ta);
float size = dev->model->x_size_ta;
size /= calib_sensor.get_ccd_size_divisor_for_dpi(resolution);
size = (size * calib_sensor.optical_res) / MM_PER_INCH;
@ -2270,12 +2270,11 @@ void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
{
// note: move_to_ta() function has already been called and the sensor is at the
// transparency adapter
move = SANE_UNFIX(dev->model->y_offset_calib_white_ta) -
SANE_UNFIX(dev->model->y_offset_sensor_to_ta);
move = dev->model->y_offset_calib_white_ta - dev->model->y_offset_sensor_to_ta;
flags |= SCAN_FLAG_USE_XPA;
}
else
move = SANE_UNFIX(dev->model->y_offset_calib_white);
} else {
move = dev->model->y_offset_calib_white;
}
move = (move * resolution) / MM_PER_INCH;
@ -2331,15 +2330,14 @@ void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
if (dev->ignore_offsets) {
move = 0;
} else {
move = SANE_UNFIX(dev->model->y_offset_ta) -
SANE_UNFIX(dev->model->y_offset_sensor_to_ta);
move = dev->model->y_offset_ta - dev->model->y_offset_sensor_to_ta;
}
flags |= SCAN_FLAG_USE_XPA;
} else {
if (dev->ignore_offsets) {
move = 0;
} else {
move = SANE_UNFIX(dev->model->y_offset);
move = dev->model->y_offset;
}
}
@ -2351,9 +2349,9 @@ void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
if (dev->settings.scan_method==ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{
start = SANE_UNFIX(dev->model->x_offset_ta);
start = dev->model->x_offset_ta;
} else {
start = SANE_UNFIX(dev->model->x_offset);
start = dev->model->x_offset;
}
if (dev->model->model_id == ModelId::CANON_8400F ||
@ -2652,11 +2650,11 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->model->model_id == ModelId::CANON_8600F &&
dev->settings.xres == 4800)
{
start_pixel = SANE_UNFIX(dev->model->x_offset_ta);
start_pixel = dev->model->x_offset_ta;
start_pixel /= calib_sensor.get_ccd_size_divisor_for_dpi(resolution);
start_pixel = (start_pixel * calib_sensor.optical_res) / MM_PER_INCH;
target_pixels = SANE_UNFIX(dev->model->x_size_ta);
target_pixels = dev->model->x_size_ta;
target_pixels /= calib_sensor.get_ccd_size_divisor_for_dpi(resolution);
target_pixels = (target_pixels * calib_sensor.optical_res) / MM_PER_INCH;
}
@ -3190,7 +3188,7 @@ void CommandSetGl843::move_to_ta(Genesys_Device* dev) const
unsigned int feed;
resolution=sanei_genesys_get_lowest_ydpi(dev);
feed = 16*(SANE_UNFIX (dev->model->y_offset_sensor_to_ta) * resolution) / MM_PER_INCH;
feed = 16 * (dev->model->y_offset_sensor_to_ta * resolution) / MM_PER_INCH;
gl843_feed(dev, feed);
}

14
backend/genesys_gl846.cc
Wyświetl plik

@ -896,7 +896,7 @@ void CommandSetGl846::calculate_current_setup(Genesys_Device* dev,
debug_dump(DBG_info, dev->settings);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
@ -1451,9 +1451,9 @@ void CommandSetGl846::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
assumption: steps are expressed at maximum motor resolution
we need:
SANE_Fixed y_offset;
SANE_Fixed y_size;
SANE_Fixed y_offset_calib;
float y_offset;
float y_size;
float y_offset_calib;
mm_to_steps()=motor dpi / 2.54 / 10=motor dpi / MM_PER_INCH */
/* if scanner uses GENESYS_FLAG_SEARCH_START y_offset is
@ -1461,7 +1461,7 @@ void CommandSetGl846::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
move_dpi = dev->motor.base_ydpi;
move = SANE_UNFIX (dev->model->y_offset);
move = dev->model->y_offset;
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
move -= dev->scanhead_position_in_steps;
@ -1482,7 +1482,7 @@ void CommandSetGl846::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
@ -1622,7 +1622,7 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
uint16_t exp[3];
float move;
move = SANE_UNFIX(dev->model->y_offset_calib_white);
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
if(move>20)
{

14
backend/genesys_gl847.cc
Wyświetl plik

@ -899,7 +899,7 @@ void CommandSetGl847::calculate_current_setup(Genesys_Device * dev,
debug_dump(DBG_info, dev->settings);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
@ -1492,9 +1492,9 @@ void CommandSetGl847::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
assumption: steps are expressed at maximum motor resolution
we need:
SANE_Fixed y_offset;
SANE_Fixed y_size;
SANE_Fixed y_offset_calib;
float y_offset;
float y_size;
float y_offset_calib;
mm_to_steps()=motor dpi / 2.54 / 10=motor dpi / MM_PER_INCH */
/* if scanner uses GENESYS_FLAG_SEARCH_START y_offset is
@ -1502,7 +1502,7 @@ void CommandSetGl847::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
move_dpi = dev->motor.base_ydpi;
move = SANE_UNFIX (dev->model->y_offset);
move = dev->model->y_offset;
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
move -= dev->scanhead_position_in_steps;
@ -1522,7 +1522,7 @@ void CommandSetGl847::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
@ -1662,7 +1662,7 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
uint16_t exp[3];
float move;
move = SANE_UNFIX(dev->model->y_offset_calib_white);
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
if(move>20)
{

16
backend/genesys_low.cc
Wyświetl plik

@ -2028,8 +2028,6 @@ void sanei_genesys_wait_for_home(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val;
int loop;
int max=300;
/* clear the parking status whatever the outcome of the function */
dev->parking = false;
@ -2048,23 +2046,25 @@ void sanei_genesys_wait_for_home(Genesys_Device* dev)
return;
}
/* loop for 30 s max, polling home sensor */
loop = 0;
unsigned timeout_ms = 200000;
unsigned elapsed_ms = 0;
do
{
sanei_genesys_sleep_ms(100);
elapsed_ms += 100;
val = sanei_genesys_get_status(dev);
if (DBG_LEVEL >= DBG_io2)
{
sanei_genesys_print_status (val);
}
++loop;
} while (loop < max && !(val & HOMESNR));
} while (elapsed_ms < timeout_ms && !(val & HOMESNR));
/* if after the timeout, head is still not parked, error out */
if (loop >= max && !(val & HOMESNR)) {
DBG (DBG_error, "%s: failed to reach park position in %dseconds\n", __func__, max/10);
if (elapsed_ms >= timeout_ms && !(val & HOMESNR)) {
DBG (DBG_error, "%s: failed to reach park position in %dseconds\n", __func__,
timeout_ms / 1000);
throw SaneException(SANE_STATUS_IO_ERROR, "failed to reach park position");
}
}

1234
backend/genesys_tables_model.cc
Wyświetl plik

Plik diff jest za duży Load Diff