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

genesys: Replace uses of SANE_Bool with bool

merge-requests/206/head
Povilas Kanapickas 2019-10-01 08:18:45 +03:00
rodzic 6da4e69d95
commit bf9d69d20d
13 zmienionych plików z 641 dodań i 799 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

235
backend/genesys.cc
Wyświetl plik

@ -485,7 +485,7 @@ SANE_Int sanei_genesys_create_slope_table3(Genesys_Device * dev,
SANE_Int genesys_create_slope_table2(Genesys_Device* dev, std::vector<uint16_t>& slope_table,
int steps,
int step_type, int exposure_time,
SANE_Bool same_speed, double yres)
bool same_speed, double yres)
{
double t, g;
SANE_Int sum = 0;
@ -601,7 +601,7 @@ SANE_Int genesys_create_slope_table2(Genesys_Device* dev, std::vector<uint16_t>&
/* todo: check details */
SANE_Int sanei_genesys_create_slope_table(Genesys_Device * dev, std::vector<uint16_t>& slope_table,
int steps, int step_type, int exposure_time,
SANE_Bool same_speed, double yres)
bool same_speed, double yres)
{
double t;
double start_speed;
@ -631,7 +631,7 @@ SANE_Int sanei_genesys_create_slope_table(Genesys_Device * dev, std::vector<uint
time_period =
(uint32_t) (yres * exposure_time / dev->motor.base_ydpi /*MOTOR_GEAR */ );
if ((time_period < 2000) && (same_speed))
same_speed = SANE_FALSE;
same_speed = false;
time_period = time_period / divider;
@ -1238,7 +1238,7 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
sensor.ccd_start_xoffset, left, top);
}
void sanei_genesys_calculate_zmod(SANE_Bool two_table,
void sanei_genesys_calculate_zmod(bool two_table,
uint32_t exposure_time,
const std::vector<uint16_t>& slope_table,
unsigned acceleration_steps,
@ -1507,7 +1507,7 @@ static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sens
dev->frontend.get_offset(2));
dev->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, SANE_FALSE);
dev->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, false);
sanei_genesys_read_data_from_scanner(dev, calibration_data.data(), size);
@ -1522,7 +1522,7 @@ static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sens
sanei_genesys_write_pnm_file("gl_coarse.pnm", all_data_8.data(), 8, channels, size / 6, 4);
}
dev->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
dev->cmd_set->end_scan(dev, &dev->calib_reg, true);
if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
{
@ -1595,7 +1595,6 @@ static void genesys_shading_calibration_impl(Genesys_Device* dev, const Genesys_
size_t size;
uint32_t pixels_per_line;
uint8_t channels;
SANE_Bool motor;
/* end pixel - start pixel */
pixels_per_line = dev->calib_pixels;
@ -1627,15 +1626,15 @@ static void genesys_shading_calibration_impl(Genesys_Device* dev, const Genesys_
std::vector<uint16_t> calibration_data(size / 2);
motor=SANE_TRUE;
bool motor = true;
if (dev->model->flags & GENESYS_FLAG_SHADING_NO_MOVE)
{
motor=SANE_FALSE;
motor = false;
}
// turn off motor and lamp power for flatbed scanners, but not for sheetfed scanners
// because they have a calibration sheet with a sufficient black strip
if (is_dark && dev->model->is_sheetfed == SANE_FALSE) {
if (is_dark && !dev->model->is_sheetfed) {
sanei_genesys_set_lamp_power(dev, sensor, dev->calib_reg, false);
sanei_genesys_set_motor_power(dev->calib_reg, motor);
} else {
@ -1654,12 +1653,13 @@ static void genesys_shading_calibration_impl(Genesys_Device* dev, const Genesys_
sanei_genesys_sleep_ms(500);
}
dev->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, is_dark ? SANE_FALSE : SANE_TRUE);
bool start_motor = !is_dark;
dev->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, start_motor);
sanei_genesys_read_data_from_scanner(dev, reinterpret_cast<std::uint8_t*>(calibration_data.data()),
size);
dev->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
dev->cmd_set->end_scan(dev, &dev->calib_reg, true);
if (dev->model->flags & GENESYS_FLAG_16BIT_DATA_INVERTED) {
for (std::size_t i = 0; i < size / 2; ++i) {
@ -1776,7 +1776,7 @@ static void genesys_repark_sensor_before_shading(Genesys_Device* dev)
if (dev->cmd_set->has_rewind()) {
dev->cmd_set->rewind(dev);
} else {
dev->cmd_set->slow_back_home(dev, SANE_TRUE);
dev->cmd_set->slow_back_home(dev, true);
}
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
@ -1790,7 +1790,7 @@ static void genesys_repark_sensor_before_shading(Genesys_Device* dev)
static void genesys_repark_sensor_after_white_shading(Genesys_Device* dev)
{
if (dev->model->flags & GENESYS_FLAG_SHADING_REPARK) {
dev->cmd_set->slow_back_home(dev, SANE_TRUE);
dev->cmd_set->slow_back_home(dev, true);
}
}
@ -1813,7 +1813,6 @@ static void genesys_dark_white_shading_calibration(Genesys_Device* dev,
int y;
uint32_t dark, white, dark_sum, white_sum, dark_count, white_count, col,
dif;
SANE_Bool motor;
pixels_per_line = dev->calib_pixels;
channels = dev->calib_channels;
@ -1835,10 +1834,10 @@ static void genesys_dark_white_shading_calibration(Genesys_Device* dev,
std::vector<uint8_t> calibration_data(size);
motor=SANE_TRUE;
bool motor = true;
if (dev->model->flags & GENESYS_FLAG_SHADING_NO_MOVE)
{
motor=SANE_FALSE;
motor = false;
}
// turn on motor and lamp power
@ -1847,11 +1846,11 @@ static void genesys_dark_white_shading_calibration(Genesys_Device* dev,
dev->write_registers(dev->calib_reg);
dev->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, SANE_FALSE);
dev->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, false);
sanei_genesys_read_data_from_scanner(dev, calibration_data.data(), size);
dev->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
dev->cmd_set->end_scan(dev, &dev->calib_reg, true);
if (DBG_LEVEL >= DBG_data)
{
@ -2708,7 +2707,7 @@ genesys_restore_calibration(Genesys_Device * dev, Genesys_Sensor& sensor)
* matching one */
for (auto& cache : dev->calibration_cache)
{
if (dev->cmd_set->is_compatible_calibration(dev, sensor, &cache, SANE_FALSE)) {
if (dev->cmd_set->is_compatible_calibration(dev, sensor, &cache, false)) {
dev->frontend = cache.frontend;
/* we don't restore the gamma fields */
sensor.exposure = cache.sensor.exposure;
@ -2744,7 +2743,7 @@ static void genesys_save_calibration(Genesys_Device* dev, const Genesys_Sensor&
for (auto cache_it = dev->calibration_cache.begin(); cache_it != dev->calibration_cache.end();
cache_it++)
{
if (dev->cmd_set->is_compatible_calibration(dev, sensor, &*cache_it, SANE_TRUE)) {
if (dev->cmd_set->is_compatible_calibration(dev, sensor, &*cache_it, true)) {
found_cache_it = cache_it;
break;
}
@ -2920,7 +2919,7 @@ static void genesys_flatbed_calibration(Genesys_Device* dev, Genesys_Sensor& sen
static void genesys_sheetfed_calibration(Genesys_Device* dev, Genesys_Sensor& sensor)
{
DBG_HELPER(dbg);
SANE_Bool forward = SANE_TRUE;
bool forward = true;
// first step, load document
dev->cmd_set->load_document(dev);
@ -2939,7 +2938,7 @@ static void genesys_sheetfed_calibration(Genesys_Device* dev, Genesys_Sensor& se
/* go to a white area */
try {
dev->cmd_set->search_strip(dev, sensor, forward, SANE_FALSE);
dev->cmd_set->search_strip(dev, sensor, forward, false);
} catch (...) {
catch_all_exceptions(__func__, [&](){ dev->cmd_set->eject_document(dev); });
throw;
@ -2974,7 +2973,7 @@ static void genesys_sheetfed_calibration(Genesys_Device* dev, Genesys_Sensor& se
{
/* seek black/white reverse/forward */
try {
dev->cmd_set->search_strip(dev, sensor, forward, SANE_TRUE);
dev->cmd_set->search_strip(dev, sensor, forward, true);
} catch (...) {
catch_all_exceptions(__func__, [&](){ dev->cmd_set->eject_document(dev); });
throw;
@ -2988,13 +2987,13 @@ static void genesys_sheetfed_calibration(Genesys_Device* dev, Genesys_Sensor& se
catch_all_exceptions(__func__, [&](){ dev->cmd_set->eject_document(dev); });
throw;
}
forward = SANE_FALSE;
forward = false;
}
/* go to a white area */
try {
dev->cmd_set->search_strip(dev, sensor, forward, SANE_FALSE);
dev->cmd_set->search_strip(dev, sensor, forward, false);
} catch (...) {
catch_all_exceptions(__func__, [&](){ dev->cmd_set->eject_document(dev); });
throw;
@ -3049,8 +3048,7 @@ static void genesys_sheetfed_calibration(Genesys_Device* dev, Genesys_Sensor& se
static void genesys_scanner_calibration(Genesys_Device* dev, Genesys_Sensor& sensor)
{
DBG_HELPER(dbg);
if (dev->model->is_sheetfed == SANE_FALSE)
{
if (!dev->model->is_sheetfed) {
genesys_flatbed_calibration(dev, sensor);
return;
}
@ -3086,7 +3084,8 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
do
{
DBG(DBG_info, "%s: one more loop\n", __func__);
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_FALSE);
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, false);
bool empty = false;
do
{
sanei_genesys_test_buffer_empty(dev, &empty);
@ -3100,12 +3099,12 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
}
dev->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE);
dev->cmd_set->end_scan(dev, &dev->reg, true);
sanei_genesys_sleep_ms(1000);
seconds++;
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_FALSE);
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, false);
do
{
sanei_genesys_test_buffer_empty(dev, &empty);
@ -3113,7 +3112,7 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
}
while (empty);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
dev->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE);
dev->cmd_set->end_scan(dev, &dev->reg, true);
/* compute difference between the two scans */
for (pixel = 0; pixel < total_size; pixel++)
@ -3180,21 +3179,19 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
// High-level start of scanning
static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
static void genesys_start_scan(Genesys_Device* dev, bool lamp_off)
{
DBG_HELPER(dbg);
unsigned int steps, expected;
SANE_Bool empty;
/* since not all scanners are set ot wait for head to park
* we check we are not still parking before starting a new scan */
if (dev->parking == SANE_TRUE)
{
if (dev->parking) {
sanei_genesys_wait_for_home(dev);
}
// disable power saving
dev->cmd_set->save_power(dev, SANE_FALSE);
dev->cmd_set->save_power(dev, false);
/* wait for lamp warmup : until a warmup for TRANSPARENCY is designed, skip
* it when scanning from XPA. */
@ -3205,16 +3202,15 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
}
/* set top left x and y values by scanning the internals if flatbed scanners */
if (dev->model->is_sheetfed == SANE_FALSE)
{
if (!dev->model->is_sheetfed) {
/* do the geometry detection only once */
if ((dev->model->flags & GENESYS_FLAG_SEARCH_START)
&& (dev->model->y_offset_calib_white == 0))
{
dev->cmd_set->search_start_position (dev);
dev->parking = SANE_FALSE;
dev->cmd_set->slow_back_home (dev, SANE_TRUE);
dev->parking = false;
dev->cmd_set->slow_back_home (dev, true);
dev->scanhead_position_in_steps = 0;
}
else
@ -3222,8 +3218,8 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
/* Go home */
/* TODO: check we can drop this since we cannot have the
scanner's head wandering here */
dev->parking = SANE_FALSE;
dev->cmd_set->slow_back_home (dev, SANE_TRUE);
dev->parking = false;
dev->cmd_set->slow_back_home (dev, true);
dev->scanhead_position_in_steps = 0;
}
@ -3254,10 +3250,8 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
{
/* calibration : sheetfed scanners can't calibrate before each scan */
/* and also those who have the NO_CALIBRATION flag */
if (!(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)
&&dev->model->is_sheetfed == SANE_FALSE)
{
genesys_scanner_calibration(dev, sensor);
if (!(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION) && !dev->model->is_sheetfed) {
genesys_scanner_calibration(dev, sensor);
genesys_save_calibration (dev, sensor);
}
else
@ -3267,8 +3261,7 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
}
/* build look up table for dynamic lineart */
if(dev->settings.dynamic_lineart==SANE_TRUE)
{
if (dev->settings.dynamic_lineart) {
sanei_genesys_load_lut(dev->lineart_lut, 8, 8, 50, 205, dev->settings.threshold_curve,
dev->settings.threshold-127);
}
@ -3276,7 +3269,7 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
dev->cmd_set->wait_for_motor_stop(dev);
if (dev->cmd_set->needs_home_before_init_regs_for_scan(dev)) {
dev->cmd_set->slow_back_home(dev, SANE_TRUE);
dev->cmd_set->slow_back_home(dev, true);
}
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
@ -3288,8 +3281,7 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
dev->cmd_set->init_regs_for_scan(dev, sensor);
/* no lamp during scan */
if(lamp_off == SANE_TRUE)
{
if (lamp_off) {
sanei_genesys_set_lamp_power(dev, sensor, dev->reg, false);
}
@ -3305,7 +3297,7 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
dev->write_registers(dev->reg);
// start effective scan
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, true);
/*do we really need this? the valid data check should be sufficent -- pierre*/
/* waits for head to reach scanning position */
@ -3320,6 +3312,7 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
}
while (steps < expected);
// wait for buffers to be filled
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
@ -3336,8 +3329,7 @@ static void genesys_start_scan(Genesys_Device* dev, SANE_Bool lamp_off)
/* then we wait for at least one word of valid scan data
this is also done in sanei_genesys_read_data_from_scanner -- pierre */
if (dev->model->is_sheetfed == SANE_FALSE)
{
if (!dev->model->is_sheetfed) {
do
{
sanei_genesys_sleep_ms(100);
@ -3358,8 +3350,7 @@ static void genesys_fill_read_buffer(Genesys_Device* dev)
/* for sheetfed scanner, we must check is document is shorter than
* the requested scan */
if (dev->model->is_sheetfed == SANE_TRUE)
{
if (dev->model->is_sheetfed) {
dev->cmd_set->detect_document_end(dev);
}
@ -3392,8 +3383,7 @@ static void genesys_read_ordered_data(Genesys_Device* dev, SANE_Byte* destinatio
uint8_t *work_buffer_src;
Genesys_Buffer *src_buffer;
if (dev->read_active != SANE_TRUE)
{
if (!dev->read_active) {
*len = 0;
throw SaneException("read is not active");
}
@ -3410,12 +3400,11 @@ static void genesys_read_ordered_data(Genesys_Device* dev, SANE_Byte* destinatio
{
/* issue park command immediatly in case scanner can handle it
* so we save time */
if (dev->model->is_sheetfed == SANE_FALSE
&& !(dev->model->flags & GENESYS_FLAG_MUST_WAIT)
&& dev->parking == SANE_FALSE)
if (!dev->model->is_sheetfed && !(dev->model->flags & GENESYS_FLAG_MUST_WAIT) &&
!dev->parking)
{
dev->cmd_set->slow_back_home(dev, SANE_FALSE);
dev->parking = SANE_TRUE;
dev->cmd_set->slow_back_home(dev, false);
dev->parking = true;
}
throw SaneException(SANE_STATUS_EOF, "nothing more to scan: EOF");
}
@ -3480,8 +3469,8 @@ Problems with the first approach:
/* end scan if all needed data have been read */
if(dev->total_bytes_read >= dev->total_bytes_to_read)
{
dev->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE);
if (dev->model->is_sheetfed == SANE_TRUE) {
dev->cmd_set->end_scan(dev, &dev->reg, true);
if (dev->model->is_sheetfed) {
dev->cmd_set->eject_document (dev);
}
}
@ -3546,7 +3535,7 @@ static void calc_parameters(Genesys_Scanner* s)
br_x = SANE_UNFIX(s->pos_bottom_right_x);
br_y = SANE_UNFIX(s->pos_bottom_right_y);
s->params.last_frame = SANE_TRUE; /* only single pass scanning supported */
s->params.last_frame = true; /* only single pass scanning supported */
if (s->mode == SANE_VALUE_SCAN_MODE_GRAY || s->mode == SANE_VALUE_SCAN_MODE_LINEART) {
s->params.format = SANE_FRAME_GRAY;
@ -3688,10 +3677,10 @@ static void calc_parameters(Genesys_Scanner* s)
}
/* dynamic lineart */
s->dev->settings.dynamic_lineart = SANE_FALSE;
s->dev->settings.dynamic_lineart = false;
s->dev->settings.threshold_curve=0;
if (!s->disable_dynamic_lineart && s->dev->settings.scan_mode == ScanColorMode::LINEART) {
s->dev->settings.dynamic_lineart = SANE_TRUE;
s->dev->settings.dynamic_lineart = true;
}
/* hardware lineart works only when we don't have interleave data
@ -3701,7 +3690,7 @@ static void calc_parameters(Genesys_Scanner* s)
s->dev->model->asic_type==AsicType::GL847 &&
s->dev->settings.scan_mode == ScanColorMode::LINEART)
{
s->dev->settings.dynamic_lineart = SANE_TRUE;
s->dev->settings.dynamic_lineart = true;
}
// threshold curve for dynamic rasterization
@ -3714,11 +3703,11 @@ static void calc_parameters(Genesys_Scanner* s)
&& (!s->preview)
&& (s->bit_depth <= 8))
{
s->dev->buffer_image=SANE_TRUE;
s->dev->buffer_image = true;
}
else
{
s->dev->buffer_image=SANE_FALSE;
s->dev->buffer_image = false;
}
/* brigthness and contrast only for for 8 bit scans */
@ -4497,19 +4486,19 @@ static void init_options(Genesys_Scanner* s)
calc_parameters(s);
}
static SANE_Bool present;
static bool present;
// this function is passed to C API, it must not throw
static SANE_Status
check_present (SANE_String_Const devname) noexcept
{
DBG_HELPER_ARGS(dbg, "%s detected.", devname);
present=SANE_TRUE;
present = true;
return SANE_STATUS_GOOD;
}
static SANE_Status
attach (SANE_String_Const devname, Genesys_Device ** devp, SANE_Bool may_wait)
attach (SANE_String_Const devname, Genesys_Device ** devp, bool may_wait)
{
DBG_HELPER_ARGS(dbg, "devp %s nullptr, may_wait = %d", devp ? "!=" : "==", may_wait);
@ -4547,11 +4536,11 @@ attach (SANE_String_Const devname, Genesys_Device ** devp, SANE_Bool may_wait)
/* KV-SS080 is an auxiliary device which requires a master device to be here */
if(vendor == 0x04da && product == 0x100f)
{
present=SANE_FALSE;
present = false;
sanei_usb_find_devices (vendor, 0x1006, check_present);
sanei_usb_find_devices (vendor, 0x1007, check_present);
sanei_usb_find_devices (vendor, 0x1010, check_present);
if (present == SANE_FALSE) {
if (present == false) {
throw SaneException("master device not present");
}
}
@ -4580,7 +4569,7 @@ attach (SANE_String_Const devname, Genesys_Device ** devp, SANE_Bool may_wait)
dev->vendorId = found_usb_dev->vendor;
dev->productId = found_usb_dev->product;
dev->usb_mode = 0; /* i.e. unset */
dev->already_initialized = SANE_FALSE;
dev->already_initialized = false;
DBG(DBG_info, "%s: found %s flatbed scanner %s at %s\n", __func__, dev->model->vendor,
dev->model->model, dev->file_name.c_str());
@ -4597,7 +4586,7 @@ static SANE_Status
attach_one_device_impl(SANE_String_Const devname)
{
Genesys_Device *dev;
SANE_Status status = attach(devname, &dev, SANE_FALSE);
SANE_Status status = attach(devname, &dev, false);
if (status != SANE_STATUS_GOOD) {
DBG(DBG_info, "%s: failed to attach: %s\n", __func__, sane_strstatus(status));
return status;
@ -4754,8 +4743,7 @@ static void genesys_buffer_image(Genesys_Scanner *s)
/* maximum bytes to read */
maximum = s->params.bytes_per_line * lines;
if(s->dev->settings.dynamic_lineart==SANE_TRUE)
{
if (s->dev->settings.dynamic_lineart) {
maximum *= 8;
}
@ -4800,17 +4788,14 @@ static void genesys_buffer_image(Genesys_Scanner *s)
* issue head parking command so that the head move while
* computing so we can save time
*/
if (dev->model->is_sheetfed == SANE_FALSE &&
dev->parking == SANE_FALSE)
{
if (!dev->model->is_sheetfed && !dev->parking) {
dev->cmd_set->slow_back_home(dev, dev->model->flags & GENESYS_FLAG_MUST_WAIT);
dev->parking = !(s->dev->model->flags & GENESYS_FLAG_MUST_WAIT);
}
/* in case of dynamic lineart, we have buffered gray data which
* must be converted to lineart first */
if(s->dev->settings.dynamic_lineart==SANE_TRUE)
{
if (s->dev->settings.dynamic_lineart) {
total/=8;
std::vector<uint8_t> lineart(total);
@ -4913,7 +4898,7 @@ void sane_exit()
SANE_Status
sane_get_devices_impl(const SANE_Device *** device_list, SANE_Bool local_only)
{
DBG_HELPER_ARGS(dbg, "local_only = %s", local_only == SANE_TRUE ? "true" : "false");
DBG_HELPER_ARGS(dbg, "local_only = %s", local_only ? "true" : "false");
/* hot-plug case : detection of newly connected scanners */
sanei_usb_scan_devices ();
@ -4927,7 +4912,7 @@ sane_get_devices_impl(const SANE_Device *** device_list, SANE_Bool local_only)
s_sane_devices_ptrs->reserve(s_devices->size() + 1);
for (auto dev_it = s_devices->begin(); dev_it != s_devices->end();) {
present = SANE_FALSE;
present = false;
sanei_usb_find_devices(dev_it->vendorId, dev_it->productId, check_present);
if (present) {
s_sane_devices->emplace_back();
@ -4982,7 +4967,7 @@ sane_open_impl(SANE_String_Const devicename, SANE_Handle * handle)
if (!dev)
{
DBG(DBG_info, "%s: couldn't find `%s' in devlist, trying attach\n", __func__, devicename);
SANE_Status status = attach(devicename, &dev, SANE_TRUE);
SANE_Status status = attach(devicename, &dev, true);
if (status != SANE_STATUS_GOOD) {
DBG(DBG_info, "%s: failed to attach: %s\n", __func__, sane_strstatus(status));
return status;
@ -5022,9 +5007,9 @@ sane_open_impl(SANE_String_Const devicename, SANE_Handle * handle)
auto* s = &s_scanners->back();
s->dev = dev;
s->scanning = SANE_FALSE;
s->dev->parking = SANE_FALSE;
s->dev->read_active = SANE_FALSE;
s->scanning = false;
s->dev->parking = false;
s->dev->read_active = false;
s->dev->force_calibration = 0;
s->dev->line_count = 0;
s->dev->binary = nullptr;
@ -5095,22 +5080,20 @@ sane_close_impl(SANE_Handle handle)
Genesys_Scanner* s = &*it;
/* eject document for sheetfed scanners */
if (s->dev->model->is_sheetfed == SANE_TRUE)
{
if (s->dev->model->is_sheetfed) {
catch_all_exceptions(__func__, [&](){ s->dev->cmd_set->eject_document(s->dev); });
}
else
{
/* in case scanner is parking, wait for the head
* to reach home position */
if(s->dev->parking==SANE_TRUE)
{
if (s->dev->parking) {
sanei_genesys_wait_for_home(s->dev);
}
}
// enable power saving before leaving
s->dev->cmd_set->save_power(s->dev, SANE_TRUE);
s->dev->cmd_set->save_power(s->dev, true);
// here is the place to store calibration cache
if (s->dev->force_calibration == 0) {
@ -5118,7 +5101,7 @@ sane_close_impl(SANE_Handle handle)
s->dev->calib_file); });
}
s->dev->already_initialized = SANE_FALSE;
s->dev->already_initialized = false;
/* for an handful of bytes .. */
free ((void *)(size_t)s->opt[OPT_RESOLUTION].constraint.word_list);
@ -5367,7 +5350,7 @@ get_option_value (Genesys_Scanner * s, int option, void *val)
*(SANE_Bool *) val = SANE_TRUE;
for (auto& cache : s->dev->calibration_cache)
{
if (s->dev->cmd_set->is_compatible_calibration(s->dev, *sensor, &cache, SANE_FALSE)) {
if (s->dev->cmd_set->is_compatible_calibration(s->dev, *sensor, &cache, false)) {
*(SANE_Bool *) val = SANE_FALSE;
}
}
@ -5735,12 +5718,12 @@ set_option_value (Genesys_Scanner * s, int option, void *val,
s->dev->settings.scan_method);
catch_all_exceptions(__func__, [&]()
{
s->dev->cmd_set->save_power(s->dev, SANE_FALSE);
s->dev->cmd_set->save_power(s->dev, false);
genesys_scanner_calibration(s->dev, sensor);
});
catch_all_exceptions(__func__, [&]()
{
s->dev->cmd_set->save_power(s->dev, SANE_TRUE);
s->dev->cmd_set->save_power(s->dev, true);
});
*myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
break;
@ -5871,8 +5854,7 @@ SANE_Status sane_get_parameters_impl(SANE_Handle handle, SANE_Parameters* params
Genesys_Scanner *s = (Genesys_Scanner*) handle;
/* don't recompute parameters once data reading is active, ie during scan */
if(s->dev->read_active == SANE_FALSE)
{
if (!s->dev->read_active) {
calc_parameters(s);
}
if (params)
@ -5884,10 +5866,9 @@ SANE_Status sane_get_parameters_impl(SANE_Handle handle, SANE_Parameters* params
* don't know the real document height.
* We don't do that doing buffering image for digital processing
*/
if (s->dev->model->is_sheetfed == SANE_TRUE
&& s->dev->buffer_image == SANE_FALSE
&& s->pos_bottom_right_y == s->opt[OPT_BR_Y].constraint.range->max)
{
if (s->dev->model->is_sheetfed && !s->dev->buffer_image &&
s->pos_bottom_right_y == s->opt[OPT_BR_Y].constraint.range->max)
{
params->lines = -1;
}
}
@ -5926,11 +5907,10 @@ SANE_Status sane_start_impl(SANE_Handle handle)
calc_parameters(s);
genesys_start_scan(s->dev, s->lamp_off);
s->scanning = SANE_TRUE;
s->scanning = true;
/* allocate intermediate buffer when doing dynamic lineart */
if(s->dev->settings.dynamic_lineart==SANE_TRUE)
{
if (s->dev->settings.dynamic_lineart) {
s->dev->binarize_buffer.clear();
s->dev->binarize_buffer.alloc(s->dev->settings.pixels);
s->dev->local_buffer.clear();
@ -5953,8 +5933,7 @@ SANE_Status sane_start_impl(SANE_Handle handle)
SANE_UNFIX(s->swskip));
if(status == SANE_STATUS_NO_DOCS)
{
if (s->dev->model->is_sheetfed == SANE_TRUE)
{
if (s->dev->model->is_sheetfed) {
DBG(DBG_info, "%s: blank page, recurse\n", __func__);
return sane_start(handle);
}
@ -6044,12 +6023,11 @@ sane_read_impl(SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int*
/* issue park command immediatly in case scanner can handle it
* so we save time */
if (dev->model->is_sheetfed == SANE_FALSE
&& !(dev->model->flags & GENESYS_FLAG_MUST_WAIT)
&& dev->parking == SANE_FALSE)
if (!dev->model->is_sheetfed && !(dev->model->flags & GENESYS_FLAG_MUST_WAIT) &&
!dev->parking)
{
dev->cmd_set->slow_back_home(dev, SANE_FALSE);
dev->parking = SANE_TRUE;
dev->cmd_set->slow_back_home(dev, false);
dev->parking = true;
}
return SANE_STATUS_EOF;
}
@ -6062,8 +6040,7 @@ sane_read_impl(SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int*
{
/* dynamic lineart is another kind of digital processing that needs
* another layer of buffering on top of genesys_read_ordered_data */
if(dev->settings.dynamic_lineart==SANE_TRUE)
{
if (dev->settings.dynamic_lineart) {
/* if buffer is empty, fill it with genesys_read_ordered_data */
if(dev->binarize_buffer.avail() == 0)
{
@ -6139,21 +6116,18 @@ void sane_cancel_impl(SANE_Handle handle)
s->dev->binary = nullptr;
}
s->scanning = SANE_FALSE;
s->dev->read_active = SANE_FALSE;
s->scanning = false;
s->dev->read_active = false;
s->dev->img_buffer.clear();
/* no need to end scan if we are parking the head */
if(s->dev->parking==SANE_FALSE)
{
s->dev->cmd_set->end_scan(s->dev, &s->dev->reg, SANE_TRUE);
if (!s->dev->parking) {
s->dev->cmd_set->end_scan(s->dev, &s->dev->reg, true);
}
/* park head if flatbed scanner */
if (s->dev->model->is_sheetfed == SANE_FALSE)
{
if(s->dev->parking==SANE_FALSE)
{
if (!s->dev->model->is_sheetfed) {
if (!s->dev->parking) {
s->dev->cmd_set->slow_back_home (s->dev, s->dev->model->flags &
GENESYS_FLAG_MUST_WAIT);
@ -6166,9 +6140,8 @@ void sane_cancel_impl(SANE_Handle handle)
}
/* enable power saving mode unless we are parking .... */
if(s->dev->parking==SANE_FALSE)
{
s->dev->cmd_set->save_power(s->dev, SANE_TRUE);
if (!s->dev->parking) {
s->dev->cmd_set->save_power(s->dev, true);
}
return;

2
backend/genesys.h
Wyświetl plik

@ -203,7 +203,7 @@ struct Genesys_Scanner
// SANE data
// We are currently scanning
SANE_Bool scanning;
bool scanning;
// Option descriptors
SANE_Option_Descriptor opt[NUM_OPTIONS];

16
backend/genesys_device.h
Wyświetl plik

@ -158,10 +158,10 @@ struct Genesys_Model
ColorOrder line_mode_color_order = ColorOrder::RGB;
// Is this a CIS or CCD scanner?
SANE_Bool is_cis = false;
bool is_cis = false;
// Is this sheetfed scanner?
SANE_Bool is_sheetfed = false;
bool is_sheetfed = false;
// sensor type
SensorId sensor_id = SensorId::UNKNOWN;
@ -275,17 +275,17 @@ struct Genesys_Device
std::vector<uint16_t> white_average_data;
std::vector<uint16_t> dark_average_data;
SANE_Bool already_initialized = 0;
bool already_initialized = false;
SANE_Int scanhead_position_in_steps = 0;
SANE_Bool read_active = 0;
bool read_active = false;
// signal wether the park command has been issued
SANE_Bool parking = 0;
bool parking = false;
// for sheetfed scanner's, is TRUE when there is a document in the scanner
SANE_Bool document = 0;
bool document = false;
SANE_Bool needs_home_ta = 0;
bool needs_home_ta = false;
Genesys_Buffer read_buffer;
@ -332,7 +332,7 @@ struct Genesys_Device
ImageBuffer pipeline_buffer;
// when true the scanned picture is first buffered to allow software image enhancements
SANE_Bool buffer_image = 0;
bool buffer_image = false;
// image buffer where the scanned picture is stored
std::vector<uint8_t> img_buffer;

53
backend/genesys_gl124.cc
Wyświetl plik

@ -80,16 +80,12 @@ bool CommandSetGl124::get_gain4_bit(Genesys_Register_Set* regs) const
bool CommandSetGl124::test_buffer_empty_bit(SANE_Byte val) const
{
if (val & BUFEMPTY)
return SANE_TRUE;
return SANE_FALSE;
return (val & BUFEMPTY);
}
bool CommandSetGl124::test_motor_flag_bit(SANE_Byte val) const
{
if (val & MOTORENB)
return SANE_TRUE;
return SANE_FALSE;
return (val & MOTORENB);
}
static void gl124_homsnr_gpio(Genesys_Device* dev)
@ -888,8 +884,7 @@ static void gl124_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
/* CIS scanners can do true gray by setting LEDADD */
/* we set up LEDADD only when asked */
if (dev->model->is_cis == SANE_TRUE)
{
if (dev->model->is_cis) {
r = sanei_genesys_get_address (reg, REG60);
r->value &= ~REG60_LEDADD;
if (session.enable_ledadd) {
@ -1019,7 +1014,7 @@ static void gl124_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
dev->read_buffer.clear();
dev->read_buffer.alloc(session.buffer_size_read);
dev->read_active = SANE_TRUE;
dev->read_active = true;
dev->session = session;
dev->current_setup.pixels = session.output_pixels;
@ -1268,7 +1263,7 @@ void CommandSetGl124::end_scan(Genesys_Device* dev, Genesys_Register_Set* reg,
(void) reg;
DBG_HELPER_ARGS(dbg, "check_stop = %d", check_stop);
if (dev->model->is_sheetfed != SANE_TRUE) {
if (!dev->model->is_sheetfed) {
gl124_stop_action(dev);
}
}
@ -1290,14 +1285,14 @@ void CommandSetGl124::rewind(Genesys_Device* dev) const
const auto& sensor = sanei_genesys_find_sensor_any(dev);
// and start scan, then wait completion
begin_scan(dev, sensor, &dev->reg, SANE_TRUE);
begin_scan(dev, sensor, &dev->reg, true);
do
{
sanei_genesys_sleep_ms(100);
byte = dev->read_register(REG100);
}
while(byte & REG100_MOTMFLG);
end_scan(dev, &dev->reg, SANE_TRUE);
end_scan(dev, &dev->reg, true);
// restore direction
byte = dev->read_register(0x02);
@ -1351,7 +1346,7 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// feed a little first
if (dev->model->model_id == ModelId::CANON_LIDE_210) {
gl124_feed(dev, 20, SANE_TRUE);
gl124_feed(dev, 20, true);
}
local_reg = dev->reg;
@ -1521,7 +1516,6 @@ void CommandSetGl124::search_start_position(Genesys_Device* dev) const
DBG_HELPER(dbg);
int size;
Genesys_Register_Set local_reg = dev->reg;
int steps;
int pixels = 600;
int dpi = 300;
@ -1560,12 +1554,13 @@ void CommandSetGl124::search_start_position(Genesys_Device* dev) const
std::vector<uint8_t> data(size);
begin_scan(dev, sensor, &local_reg, SANE_TRUE);
begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -1575,7 +1570,7 @@ void CommandSetGl124::search_start_position(Genesys_Device* dev) const
dev->model->search_lines);
}
end_scan(dev, &local_reg, SANE_TRUE);
end_scan(dev, &local_reg, true);
/* update regs to copy ASIC internal state */
dev->reg = local_reg;
@ -1733,7 +1728,7 @@ void CommandSetGl124::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
DBG (DBG_info, "%s: move=%f steps\n", __func__, move);
if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700) {
gl124_feed(dev, move-500, SANE_FALSE);
gl124_feed(dev, move-500, false);
move=500;
}
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
@ -1928,7 +1923,7 @@ static void move_to_calibration_area(Genesys_Device* dev, const Genesys_Sensor&
dev->write_registers(regs);
DBG (DBG_info, "%s: starting line reading\n", __func__);
dev->cmd_set->begin_scan(dev, sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), size);
// stop scanning
@ -1959,7 +1954,6 @@ SensorExposure CommandSetGl124::led_calibration(Genesys_Device* dev, const Genes
int avg[3];
int turn;
uint16_t exp[3],target;
SANE_Bool acceptable;
/* move to calibration area */
move_to_calibration_area(dev, sensor, regs);
@ -2012,6 +2006,7 @@ SensorExposure CommandSetGl124::led_calibration(Genesys_Device* dev, const Genes
/* no move during led calibration */
sanei_genesys_set_motor_power(regs, false);
bool acceptable = false;
do
{
// set up exposure
@ -2023,7 +2018,7 @@ SensorExposure CommandSetGl124::led_calibration(Genesys_Device* dev, const Genes
dev->write_registers(regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
// stop scanning
@ -2059,14 +2054,14 @@ SensorExposure CommandSetGl124::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info, "%s: average: %d,%d,%d\n", __func__, avg[0], avg[1], avg[2]);
/* check if exposure gives average within the boundaries */
acceptable = SANE_TRUE;
acceptable = true;
for(i=0;i<3;i++)
{
/* we accept +- 2% delta from target */
if(abs(avg[i]-target)>target/50)
{
exp[i]=(exp[i]*target)/avg[i];
acceptable = SANE_FALSE;
acceptable = false;
}
}
@ -2189,7 +2184,7 @@ void CommandSetGl124::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
{
@ -2209,7 +2204,7 @@ void CommandSetGl124::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
topavg = dark_average(second_line.data(), pixels, lines, channels, black_pixels);
@ -2229,7 +2224,7 @@ void CommandSetGl124::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
@ -2336,7 +2331,7 @@ void CommandSetGl124::coarse_gain_calibration(Genesys_Device* dev, const Genesys
std::vector<uint8_t> line(total_size);
set_fe(dev, sensor, AFE_SET);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
@ -2405,7 +2400,7 @@ void CommandSetGl124::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gl124_stop_action(dev);
slow_back_home(dev, SANE_TRUE);
slow_back_home(dev, true);
}
// wait for lamp warmup by scanning the same line until difference

275
backend/genesys_gl646.cc
Wyświetl plik

@ -88,7 +88,7 @@ void CommandSetGl646::bulk_read_data(Genesys_Device* dev, uint8_t addr, uint8_t*
{
DBG_HELPER(dbg);
sanei_genesys_bulk_read_data(dev, addr, data, len);
if (dev->model->is_sheetfed == SANE_TRUE) {
if (dev->model->is_sheetfed) {
detect_document_end(dev);
}
}
@ -96,55 +96,41 @@ void CommandSetGl646::bulk_read_data(Genesys_Device* dev, uint8_t addr, uint8_t*
bool CommandSetGl646::get_fast_feed_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x02);
if (r && (r->value & REG02_FASTFED))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG02_FASTFED));
}
bool CommandSetGl646::get_filter_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x04);
if (r && (r->value & REG04_FILTER))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_FILTER));
}
bool CommandSetGl646::get_lineart_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x04);
if (r && (r->value & REG04_LINEART))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_LINEART));
}
bool CommandSetGl646::get_bitset_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x04);
if (r && (r->value & REG04_BITSET))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_BITSET));
}
bool CommandSetGl646::get_gain4_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x06);
if (r && (r->value & REG06_GAIN4))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG06_GAIN4));
}
bool CommandSetGl646::test_buffer_empty_bit(SANE_Byte val) const
{
if (val & REG41_BUFEMPTY)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_BUFEMPTY);
}
bool CommandSetGl646::test_motor_flag_bit(SANE_Byte val) const
{
if (val & REG41_MOTMFLG)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_MOTMFLG);
}
/**
@ -369,10 +355,11 @@ static void gl646_setup_registers(Genesys_Device* dev,
/* now setup other registers for final scan (ie with shading enabled) */
/* watch dog + shading + scan enable */
regs->find_reg(0x01).value |= REG01_DOGENB | REG01_DVDSET | REG01_SCAN;
if (dev->model->is_cis == SANE_TRUE)
regs->find_reg(0x01).value |= REG01_CISSET;
else
regs->find_reg(0x01).value &= ~REG01_CISSET;
if (dev->model->is_cis) {
regs->find_reg(0x01).value |= REG01_CISSET;
} else {
regs->find_reg(0x01).value &= ~REG01_CISSET;
}
/* if device has no calibration, don't enable shading correction */
if (dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)
@ -386,10 +373,11 @@ static void gl646_setup_registers(Genesys_Device* dev,
/* R02 */
/* allow moving when buffer full by default */
if (dev->model->is_sheetfed == SANE_FALSE)
dev->reg.find_reg(0x02).value &= ~REG02_ACDCDIS;
else
dev->reg.find_reg(0x02).value |= REG02_ACDCDIS;
if (!dev->model->is_sheetfed) {
dev->reg.find_reg(0x02).value &= ~REG02_ACDCDIS;
} else {
dev->reg.find_reg(0x02).value |= REG02_ACDCDIS;
}
/* setup motor power and direction */
sanei_genesys_set_motor_power(*regs, true);
@ -418,14 +406,10 @@ static void gl646_setup_registers(Genesys_Device* dev,
break;
}
/* if sheetfed, no AGOHOME */
if (dev->model->is_sheetfed == SANE_TRUE)
{
regs->find_reg(0x02).value &= ~REG02_AGOHOME;
}
else
{
regs->find_reg(0x02).value |= REG02_AGOHOME;
if (dev->model->is_sheetfed) {
regs->find_reg(0x02).value &= ~REG02_AGOHOME;
} else {
regs->find_reg(0x02).value |= REG02_AGOHOME;
}
/* R03 */
@ -465,9 +449,7 @@ static void gl646_setup_registers(Genesys_Device* dev,
regs->find_reg(0x05).value &= ~REG05_GMMENB;
/* true CIS gray if needed */
if (dev->model->is_cis == SANE_TRUE && session.params.channels == 1 &&
dev->settings.true_gray)
{
if (dev->model->is_cis && session.params.channels == 1 && dev->settings.true_gray) {
regs->find_reg(0x05).value |= REG05_LEDADD;
}
else
@ -503,12 +485,9 @@ static void gl646_setup_registers(Genesys_Device* dev,
/* CIS scanners read one line per color channel
* since gray mode use 'add' we also read 3 channels even not in
* color mode */
if (dev->model->is_cis == SANE_TRUE)
{
if (dev->model->is_cis) {
regs->set24(REG_LINCNT, session.output_line_count * 3);
}
else
{
} else {
regs->set24(REG_LINCNT, session.output_line_count);
}
@ -650,8 +629,7 @@ static void gl646_setup_registers(Genesys_Device* dev,
move, motor->fwdbwd, &z1, &z2);
/* no z1/z2 for sheetfed scanners */
if (dev->model->is_sheetfed == SANE_TRUE)
{
if (dev->model->is_sheetfed) {
z1 = 0;
z2 = 0;
}
@ -675,7 +653,7 @@ static void gl646_setup_registers(Genesys_Device* dev,
/* scan bytes to read */
unsigned cis_channel_multiplier = dev->model->is_cis ? session.params.channels : 1;
dev->read_active = SANE_TRUE;
dev->read_active = true;
dev->session = session;
dev->current_setup.pixels = session.output_pixels;
@ -1210,7 +1188,7 @@ void CommandSetGl646::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
* enters or leaves power saving mode
* limited to AFE for now.
* @param dev scanner's device
* @param enable SANE_TRUE to enable power saving, SANE_FALSE to leave it
* @param enable true to enable power saving, false to leave it
*/
void CommandSetGl646::save_power(Genesys_Device* dev, bool enable) const
{
@ -1310,8 +1288,7 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
uint8_t val;
/* no need to load document is flatbed scanner */
if (dev->model->is_sheetfed == SANE_FALSE)
{
if (!dev->model->is_sheetfed) {
DBG(DBG_proc, "%s: nothing to load\n", __func__);
DBG(DBG_proc, "%s: end\n", __func__);
return;
@ -1398,7 +1375,7 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
}
/* when loading OK, document is here */
dev->document = SANE_TRUE;
dev->document = true;
/* set up to idle */
regs.set8(0x02, 0x71);
@ -1429,11 +1406,9 @@ void CommandSetGl646::detect_document_end(Genesys_Device* dev) const
/* detect document event. There one event when the document go in,
* then another when it leaves */
if ((dev->document == SANE_TRUE) && (gpio & 0x04)
&& (dev->total_bytes_read > 0))
{
if (dev->document && (gpio & 0x04) && (dev->total_bytes_read > 0)) {
DBG(DBG_info, "%s: no more document\n", __func__);
dev->document = SANE_FALSE;
dev->document = false;
/* adjust number of bytes to read:
* total_bytes_to_read is the number of byte to send to frontend
@ -1482,7 +1457,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
uint8_t gpio, state;
/* at the end there will be noe more document */
dev->document = SANE_FALSE;
dev->document = false;
// first check for document event
gl646_gpio_read(dev->usb_dev, &gpio);
@ -1501,7 +1476,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
/* HOMSNR=0 if no document inserted */
if ((state & REG41_HOMESNR) != 0)
{
dev->document = SANE_FALSE;
dev->document = false;
DBG(DBG_info, "%s: no more document to eject\n", __func__);
DBG(DBG_proc, "%s: end\n", __func__);
return;
@ -1599,16 +1574,15 @@ void CommandSetGl646::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
// Send the stop scan command
static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, SANE_Bool check_stop,
SANE_Bool eject)
static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, bool check_stop,
bool eject)
{
DBG_HELPER_ARGS(dbg, "check_stop = %d, eject = %d", check_stop, eject);
int i = 0;
uint8_t val, scanfsh = 0;
/* we need to compute scanfsh before cancelling scan */
if (dev->model->is_sheetfed == SANE_TRUE)
{
if (dev->model->is_sheetfed) {
sanei_genesys_get_status(dev, &val);
if (val & REG41_SCANFSH)
@ -1626,9 +1600,8 @@ static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, SANE_B
dev->write_register(0x01, val);
/* for sheetfed scanners, we may have to eject document */
if (dev->model->is_sheetfed == SANE_TRUE)
{
if (eject == SANE_TRUE && dev->document == SANE_TRUE)
if (dev->model->is_sheetfed) {
if (eject && dev->document)
{
dev->cmd_set->eject_document(dev);
}
@ -1694,7 +1667,7 @@ static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, SANE_B
void CommandSetGl646::end_scan(Genesys_Device* dev, Genesys_Register_Set* reg,
bool check_stop) const
{
end_scan_impl(dev, reg, check_stop, SANE_FALSE);
end_scan_impl(dev, reg, check_stop, false);
}
/**
@ -1767,12 +1740,12 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
const auto& sensor = sanei_genesys_find_sensor(dev, settings.xres, 3,
dev->model->default_method);
setup_for_scan(dev, sensor, &dev->reg, settings, SANE_TRUE, SANE_TRUE, SANE_TRUE);
setup_for_scan(dev, sensor, &dev->reg, settings, true, true, true);
/* backward , no actual data scanned TODO more setup flags to avoid this register manipulations ? */
dev->reg.find_reg(0x02).value |= REG02_MTRREV;
@ -1790,14 +1763,13 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
}
/* registers are restored to an iddl state, give up if no head to park */
if (dev->model->is_sheetfed == SANE_TRUE)
{
if (dev->model->is_sheetfed) {
DBG(DBG_proc, "%s: end \n", __func__);
return;
}
// starts scan
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, true);
/* loop until head parked */
if (wait_until_home)
@ -1820,8 +1792,7 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// when we come here then the scanner needed too much time for this, so we better
// stop the motor
catch_all_exceptions(__func__, [&](){ gl646_stop_motor (dev); });
catch_all_exceptions(__func__, [&](){ end_scan_impl(dev, &dev->reg, SANE_TRUE,
SANE_FALSE); });
catch_all_exceptions(__func__, [&](){ end_scan_impl(dev, &dev->reg, true, false); });
throw SaneException(SANE_STATUS_IO_ERROR, "timeout while waiting for scanhead to go home");
}
@ -1863,11 +1834,11 @@ void CommandSetGl646::search_start_position(Genesys_Device* dev) const
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
// scan the desired area
std::vector<uint8_t> data;
simple_scan(dev, sensor, settings, SANE_TRUE, SANE_TRUE, SANE_FALSE, data);
simple_scan(dev, sensor, settings, true, true, false, data);
/* handle stagger case : reorder gray data and thus loose some lines */
if (dev->current_setup.stagger > 0)
@ -1941,8 +1912,7 @@ void CommandSetGl646::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
settings.scan_method = dev->settings.scan_method;
settings.scan_mode = dev->settings.scan_mode;
if (dev->model->is_cis == SANE_FALSE)
{
if (!dev->model->is_cis) {
// FIXME: always a color scan, but why don't we set scan_mode to COLOR_SINGLE_PASS always?
settings.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
}
@ -1961,20 +1931,19 @@ void CommandSetGl646::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
settings.disable_interpolation = dev->settings.disable_interpolation;
settings.threshold = dev->settings.threshold;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
/* keep account of the movement for final scan move */
dev->scanhead_position_in_steps += settings.lines;
// we don't want top offset, but we need right margin to be the same than the one for the final
// scan
setup_for_scan(dev, calib_sensor, &dev->reg, settings, SANE_TRUE, SANE_FALSE, SANE_FALSE);
setup_for_scan(dev, calib_sensor, &dev->reg, settings, true, false, false);
/* used when sending shading calibration data */
dev->calib_pixels = settings.pixels;
dev->calib_channels = dev->session.params.channels;
if (dev->model->is_cis == SANE_FALSE)
{
if (!dev->model->is_cis) {
dev->calib_channels = 3;
}
@ -1987,8 +1956,7 @@ void CommandSetGl646::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
/* TODO another flag to setup regs ? */
/* enforce needed LINCNT, getting rid of extra lines for color reordering */
if (dev->model->is_cis == SANE_FALSE)
{
if (!dev->model->is_cis) {
dev->reg.set24(REG_LINCNT, dev->calib_lines);
}
else
@ -2021,7 +1989,7 @@ void CommandSetGl646::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
{
DBG_HELPER(dbg);
setup_for_scan(dev, sensor, &dev->reg, dev->settings, SANE_FALSE, SANE_TRUE, SANE_TRUE);
setup_for_scan(dev, sensor, &dev->reg, dev->settings, false, true, true);
/* gamma is only enabled at final scan time */
if (dev->settings.depth < 16)
@ -2034,7 +2002,7 @@ void CommandSetGl646::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
* @param dev scanner's device
* @param regs registers to set up
* @param settings settings of scan
* @param split SANE_TRUE if move to scan area is split from scan, SANE_FALSE is
* @param split true if move to scan area is split from scan, false is
* scan first moves to area
* @param xcorrection take x geometry correction into account (fixed and detected offsets)
* @param ycorrection take y geometry correction into account
@ -2043,9 +2011,9 @@ static void setup_for_scan(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set*regs,
Genesys_Settings settings,
SANE_Bool split,
SANE_Bool xcorrection,
SANE_Bool ycorrection)
bool split,
bool xcorrection,
bool ycorrection)
{
DBG_HELPER(dbg);
SANE_Int depth;
@ -2055,8 +2023,7 @@ static void setup_for_scan(Genesys_Device* dev,
depth=settings.depth;
if (settings.scan_mode == ScanColorMode::LINEART)
{
if (settings.dynamic_lineart == SANE_TRUE)
{
if (settings.dynamic_lineart) {
depth = 8;
}
else
@ -2069,20 +2036,20 @@ static void setup_for_scan(Genesys_Device* dev,
// compute distance to move
float move = 0;
// XXX STEF XXX MD5345 -> optical_ydpi, other base_ydpi => half/full step ? */
if (split == SANE_FALSE) {
if (dev->model->is_sheetfed == SANE_FALSE) {
if (ycorrection == SANE_TRUE) {
if (!split) {
if (!dev->model->is_sheetfed) {
if (ycorrection) {
move = SANE_UNFIX(dev->model->y_offset);
}
}
// add tl_y to base movement
}
}
move += settings.tl_y;
if (move < 0) {
DBG(DBG_error, "%s: overriding negative move value %f\n", __func__, move);
move = 0;
}
}
}
move = (move * dev->motor.optical_ydpi) / MM_PER_INCH;
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
@ -2199,8 +2166,6 @@ SensorExposure CommandSetGl646::led_calibration(Genesys_Device* dev, const Genes
Genesys_Settings settings;
SANE_Int resolution;
SANE_Bool acceptable = SANE_FALSE;
unsigned channels = dev->settings.get_channels();
/* get led calibration resolution */
@ -2228,7 +2193,7 @@ SensorExposure CommandSetGl646::led_calibration(Genesys_Device* dev, const Genes
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
/* colors * bytes_per_color * scan lines */
total_size = settings.pixels * channels * 2 * 1;
@ -2250,6 +2215,7 @@ SensorExposure CommandSetGl646::led_calibration(Genesys_Device* dev, const Genes
auto calib_sensor = sensor;
bool acceptable = false;
do {
calib_sensor.exposure.red = expr;
calib_sensor.exposure.green = expg;
@ -2257,7 +2223,7 @@ SensorExposure CommandSetGl646::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info, "%s: starting first line reading\n", __func__);
simple_scan(dev, calib_sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, line);
simple_scan(dev, calib_sensor, settings, false, true, false, line);
if (DBG_LEVEL >= DBG_data)
{
@ -2266,7 +2232,7 @@ SensorExposure CommandSetGl646::led_calibration(Genesys_Device* dev, const Genes
sanei_genesys_write_pnm_file(fn, line.data(), 16, channels, settings.pixels, 1);
}
acceptable = SANE_TRUE;
acceptable = true;
for (j = 0; j < channels; j++)
{
@ -2289,7 +2255,7 @@ SensorExposure CommandSetGl646::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info, "%s: average: %d,%d,%d\n", __func__, avg[0], avg[1], avg[2]);
acceptable = SANE_TRUE;
acceptable = true;
if (!acceptable)
{
@ -2398,7 +2364,7 @@ static void ad_fe_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
/* scan first line of data with no gain */
dev->frontend.set_gain(0, 0);
@ -2415,7 +2381,7 @@ static void ad_fe_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
dev->frontend.set_offset(0, bottom);
dev->frontend.set_offset(1, bottom);
dev->frontend.set_offset(2, bottom);
simple_scan(dev, calib_sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, line);
simple_scan(dev, calib_sensor, settings, false, true, false, line);
if (DBG_LEVEL >= DBG_data)
{
@ -2506,7 +2472,7 @@ void CommandSetGl646::offset_calibration(Genesys_Device* dev, const Genesys_Sens
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
/* scan first line of data with no gain, but with offset from
* last calibration */
@ -2522,7 +2488,7 @@ void CommandSetGl646::offset_calibration(Genesys_Device* dev, const Genesys_Sens
std::vector<uint8_t> first_line, second_line;
simple_scan(dev, calib_sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, first_line);
simple_scan(dev, calib_sensor, settings, false, true, false, first_line);
if (DBG_LEVEL >= DBG_data)
{
@ -2540,7 +2506,7 @@ void CommandSetGl646::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->frontend.set_offset(0, top);
dev->frontend.set_offset(1, top);
dev->frontend.set_offset(2, top);
simple_scan(dev, calib_sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, second_line);
simple_scan(dev, calib_sensor, settings, false, true, false, second_line);
if (DBG_LEVEL >= DBG_data)
{
@ -2564,7 +2530,7 @@ void CommandSetGl646::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->frontend.set_offset(2, (top + bottom) / 2);
// scan with no move
simple_scan(dev, calib_sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, second_line);
simple_scan(dev, calib_sensor, settings, false, true, false, second_line);
if (DBG_LEVEL >= DBG_data)
{
@ -2636,7 +2602,7 @@ static void ad_fe_coarse_gain_calibration(Genesys_Device* dev, const Genesys_Sen
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
size = channels * settings.pixels * settings.lines;
@ -2653,7 +2619,7 @@ static void ad_fe_coarse_gain_calibration(Genesys_Device* dev, const Genesys_Sen
// loop until each channel raises to acceptable level
while ((average < calib_sensor.gain_white_ref) && (pass < 30)) {
// scan with no move
simple_scan(dev, calib_sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, line);
simple_scan(dev, calib_sensor, settings, false, true, false, line);
/* log scanning data */
if (DBG_LEVEL >= DBG_data)
@ -2749,7 +2715,7 @@ void CommandSetGl646::coarse_gain_calibration(Genesys_Device* dev, const Genesys
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
/* start gain value */
dev->frontend.set_gain(0, 1);
@ -2786,7 +2752,7 @@ void CommandSetGl646::coarse_gain_calibration(Genesys_Device* dev, const Genesys
(average[2] < calib_sensor.gain_white_ref)) && (pass < 30))
{
// scan with no move
simple_scan(dev, calib_sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, line);
simple_scan(dev, calib_sensor, settings, false, true, false, line);
/* log scanning data */
if (DBG_LEVEL >= DBG_data)
@ -2892,10 +2858,10 @@ void CommandSetGl646::init_regs_for_warmup(Genesys_Device* dev, const Genesys_Se
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
// setup for scan
setup_for_scan(dev, local_sensor, &dev->reg, settings, SANE_TRUE, SANE_FALSE, SANE_FALSE);
setup_for_scan(dev, local_sensor, &dev->reg, settings, true, false, false);
/* we are not going to move, so clear these bits */
dev->reg.find_reg(0x02).value &= ~(REG02_FASTFED | REG02_AGOHOME);
@ -2945,12 +2911,12 @@ static void gl646_repark_head(Genesys_Device* dev)
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
const auto& sensor = sanei_genesys_find_sensor(dev, settings.xres, 3,
dev->model->default_method);
setup_for_scan(dev, sensor, &dev->reg, settings, SANE_FALSE, SANE_FALSE, SANE_FALSE);
setup_for_scan(dev, sensor, &dev->reg, settings, false, false, false);
/* TODO seems wrong ... no effective scan */
dev->reg.find_reg(0x01).value &= ~REG01_SCAN;
@ -2958,7 +2924,7 @@ static void gl646_repark_head(Genesys_Device* dev)
dev->write_registers(dev->reg);
// start scan
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, true);
expected = dev->reg.get24(REG_FEEDL);
do
@ -3113,8 +3079,7 @@ void CommandSetGl646::init(Genesys_Device* dev) const
}
/* ensure head is correctly parked, and check lock */
if (dev->model->is_sheetfed == SANE_FALSE)
{
if (!dev->model->is_sheetfed) {
if (dev->model->flags & GENESYS_FLAG_REPARK)
{
// FIXME: if repark fails, we should print an error message that the scanner is locked and
@ -3123,12 +3088,12 @@ void CommandSetGl646::init(Genesys_Device* dev) const
}
else
{
slow_back_home(dev, SANE_TRUE);
slow_back_home(dev, true);
}
}
/* here session and device are initialized */
dev->already_initialized = SANE_TRUE;
dev->already_initialized = true;
}
void CommandSetGl646::move_to_ta(Genesys_Device* dev) const
@ -3145,41 +3110,32 @@ void CommandSetGl646::move_to_ta(Genesys_Device* dev) const
* and must be freed by caller.
* @param dev device of the scanner
* @param settings parameters of the scan
* @param move SANE_TRUE if moving during scan
* @param forward SANE_TRUE if moving forward during scan
* @param shading SANE_TRUE to enable shading correction
* @param move true if moving during scan
* @param forward true if moving forward during scan
* @param shading true to enable shading correction
* @param data pointer for the data
*/
static void simple_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Settings settings, SANE_Bool move, SANE_Bool forward,
SANE_Bool shading, std::vector<uint8_t>& data)
Genesys_Settings settings, bool move, bool forward,
bool shading, std::vector<uint8_t>& data)
{
DBG_HELPER_ARGS(dbg, "move=%d, forward=%d, shading=%d", move, forward, shading);
unsigned int size, lines, x, y, bpp;
SANE_Bool empty, split;
bool empty, split;
int count;
uint8_t val;
/* round up to multiple of 3 in case of CIS scanner */
if (dev->model->is_cis == SANE_TRUE)
{
if (dev->model->is_cis) {
settings.lines = ((settings.lines + 2) / 3) * 3;
}
/* setup for move then scan */
if (move == SANE_TRUE && settings.tl_y > 0)
{
split = SANE_FALSE;
}
else
{
split = SANE_TRUE;
}
setup_for_scan(dev, sensor, &dev->reg, settings, split, SANE_FALSE, SANE_FALSE);
split = !(move && settings.tl_y > 0);
setup_for_scan(dev, sensor, &dev->reg, settings, split, false, false);
/* allocate memory fo scan : LINCNT may have been adjusted for CCD reordering */
if (dev->model->is_cis == SANE_TRUE)
{
if (dev->model->is_cis) {
lines = dev->reg.get24(REG_LINCNT) / 3;
}
else
@ -3206,8 +3162,7 @@ static void simple_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
/* no shading correction and not watch dog for simple scan */
dev->reg.find_reg(0x01).value &= ~(REG01_DVDSET | REG01_DOGENB);
if (shading == SANE_TRUE)
{
if (shading) {
dev->reg.find_reg(0x01).value |= REG01_DVDSET;
}
@ -3217,15 +3172,13 @@ static void simple_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
/* one table movement for simple scan */
dev->reg.find_reg(0x02).value &= ~REG02_FASTFED;
if (move == SANE_FALSE)
{
if (!move) {
sanei_genesys_set_motor_power(dev->reg, false);
/* no automatic go home if no movement */
dev->reg.find_reg(0x02).value &= ~REG02_AGOHOME;
}
if (forward == SANE_FALSE)
{
if (!forward) {
dev->reg.find_reg(0x02).value |= REG02_MTRREV;
}
else
@ -3268,9 +3221,7 @@ static void simple_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
/* in case of CIS scanner, we must reorder data */
if (dev->model->is_cis == SANE_TRUE
&& settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
{
if (dev->model->is_cis && settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS) {
/* alloc one line sized working buffer */
std::vector<uint8_t> buffer(settings.pixels * 3 * bpp);
@ -3313,7 +3264,7 @@ static void simple_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
}
// end scan , waiting the motor to stop if needed (if moving), but without ejecting doc
end_scan_impl(dev, &dev->reg, SANE_TRUE, SANE_FALSE);
end_scan_impl(dev, &dev->reg, true, false);
}
/**
@ -3347,10 +3298,10 @@ static void simple_move(Genesys_Device* dev, SANE_Int distance)
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
std::vector<uint8_t> data;
simple_scan(dev, sensor, settings, SANE_TRUE, SANE_TRUE, SANE_FALSE, data);
simple_scan(dev, sensor, settings, true, true, false, data);
}
/**
@ -3569,8 +3520,7 @@ bool CommandSetGl646::is_compatible_calibration(Genesys_Device* dev, const Genes
/* a calibration cache is compatible if color mode and x dpi match the user
* requested scan. In the case of CIS scanners, dpi isn't a criteria */
if (dev->model->is_cis == SANE_FALSE)
{
if (!dev->model->is_cis) {
compatible = (dev->session.params.channels == cache->params.channels) &&
(((int) dev->current_setup.xres) == ((int) cache->used_setup.xres));
} else {
@ -3593,12 +3543,9 @@ bool CommandSetGl646::is_compatible_calibration(Genesys_Device* dev, const Genes
/* a cache entry expires after 30 minutes for non sheetfed scanners */
/* this is not taken into account when overwriting cache entries */
#ifdef HAVE_SYS_TIME_H
if(for_overwrite == SANE_FALSE)
{
if (!for_overwrite) {
gettimeofday (&time, nullptr);
if ((time.tv_sec - cache->last_calibration > 30 * 60)
&& (dev->model->is_sheetfed == SANE_FALSE))
{
if ((time.tv_sec - cache->last_calibration > 30 * 60) && !dev->model->is_sheetfed) {
DBG(DBG_proc, "%s: expired entry, non compatible cache\n", __func__);
return false;
}
@ -3612,8 +3559,8 @@ bool CommandSetGl646::is_compatible_calibration(Genesys_Device* dev, const Genes
/**
* search for a full width black or white strip.
* @param dev scanner device
* @param forward SANE_TRUE if searching forward, SANE_FALSE if searching backward
* @param black SANE_TRUE if searching for a black strip, SANE_FALSE for a white strip
* @param forward true if searching forward, false if searching backward
* @param black true if searching for a black strip, false for a white strip
*/
void CommandSetGl646::search_strip(Genesys_Device* dev, const Genesys_Sensor& sensor, bool forward,
bool black) const
@ -3646,7 +3593,7 @@ void CommandSetGl646::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
settings.disable_interpolation = 0;
settings.threshold = 0;
settings.dynamic_lineart = SANE_FALSE;
settings.dynamic_lineart = false;
/* signals if a strip of the given color has been found */
found = 0;
@ -3660,7 +3607,7 @@ void CommandSetGl646::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
while (pass < 20 && !found)
{
// scan a full width strip
simple_scan(dev, calib_sensor, settings, SANE_TRUE, forward, SANE_FALSE, data);
simple_scan(dev, calib_sensor, settings, true, forward, false, data);
if (DBG_LEVEL >= DBG_data)
{

160
backend/genesys_gl646.h
Wyświetl plik

@ -68,9 +68,9 @@ static void setup_for_scan(Genesys_Device* device,
const Genesys_Sensor& sensor,
Genesys_Register_Set*regs,
Genesys_Settings settings,
SANE_Bool split,
SANE_Bool xcorrection,
SANE_Bool ycorrection);
bool split,
bool xcorrection,
bool ycorrection);
/**
* Does a simple move of the given distance by doing a scan at lowest resolution
@ -94,14 +94,14 @@ static void simple_move(Genesys_Device* dev, SANE_Int distance);
* @param data pointer that will point to the scanned data
*/
static void simple_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Settings settings, SANE_Bool move, SANE_Bool forward,
SANE_Bool shading, std::vector<uint8_t>& data);
Genesys_Settings settings, bool move, bool forward,
bool shading, std::vector<uint8_t>& data);
/**
* Send the stop scan command
* */
static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, SANE_Bool check_stop,
SANE_Bool eject);
static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, bool check_stop,
bool eject);
/**
* writes control data to an area behind the last motor table.
*/
@ -127,8 +127,8 @@ typedef struct
/* settings */
StepType steptype;
SANE_Bool fastmod; /* fast scanning 0/1 */
SANE_Bool fastfed; /* fast fed slope tables */
bool fastmod; // fast scanning
bool fastfed; // fast fed slope tables
SANE_Int mtrpwm;
SANE_Int steps1; /* table 1 informations */
SANE_Int vstart1;
@ -147,88 +147,88 @@ typedef struct
*/
static Motor_Master motor_master[] = {
/* HP3670 motor settings */
{MotorId::HP3670, 75, 3, StepType::FULL, SANE_FALSE, SANE_TRUE , 1, 200, 3429, 305, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 100, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 1, 143, 2905, 187, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 150, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 1, 73, 3429, 305, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 300, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 1, 11, 1055, 563, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 600, 3, StepType::FULL, SANE_FALSE, SANE_TRUE , 0, 3, 10687, 5126, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670,1200, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 0, 3, 15937, 6375, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670,2400, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 0, 3, 15937, 12750, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 75, 1, StepType::FULL, SANE_FALSE, SANE_TRUE , 1, 200, 3429, 305, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 100, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 1, 143, 2905, 187, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 150, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 1, 73, 3429, 305, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 300, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 1, 11, 1055, 563, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 600, 1, StepType::FULL, SANE_FALSE, SANE_TRUE , 0, 3, 10687, 5126, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670,1200, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 0, 3, 15937, 6375, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670,2400, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 0, 3, 15937, 12750, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 75, 3, StepType::FULL, false, true , 1, 200, 3429, 305, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 100, 3, StepType::HALF, false, true , 1, 143, 2905, 187, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 150, 3, StepType::HALF, false, true , 1, 73, 3429, 305, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 300, 3, StepType::HALF, false, true , 1, 11, 1055, 563, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 600, 3, StepType::FULL, false, true , 0, 3, 10687, 5126, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670,1200, 3, StepType::HALF, false, true , 0, 3, 15937, 6375, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670,2400, 3, StepType::HALF, false, true , 0, 3, 15937, 12750, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 75, 1, StepType::FULL, false, true , 1, 200, 3429, 305, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 100, 1, StepType::HALF, false, true , 1, 143, 2905, 187, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 150, 1, StepType::HALF, false, true , 1, 73, 3429, 305, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 300, 1, StepType::HALF, false, true , 1, 11, 1055, 563, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670, 600, 1, StepType::FULL, false, true , 0, 3, 10687, 5126, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670,1200, 1, StepType::HALF, false, true , 0, 3, 15937, 6375, 192, 3399, 337, 0.3, 0.4, 192},
{MotorId::HP3670,2400, 3, StepType::HALF, false, true , 0, 3, 15937, 12750, 192, 3399, 337, 0.3, 0.4, 192},
/* HP2400/G2410 motor settings base motor dpi = 600 */
{MotorId::HP2400, 50, 3, StepType::FULL, SANE_FALSE, SANE_TRUE , 63, 120, 8736, 601, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 100, 3, StepType::HALF, SANE_FALSE, SANE_TRUE, 63, 120, 8736, 601, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 150, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 67, 15902, 902, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 300, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 32, 16703, 2188, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 600, 3, StepType::FULL, SANE_FALSE, SANE_TRUE , 63, 3, 18761, 18761, 192, 4905, 627, 0.30, 0.4, 192},
{MotorId::HP2400,1200, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 3, 43501, 43501, 192, 4905, 627, 0.30, 0.4, 192},
{MotorId::HP2400, 50, 1, StepType::FULL, SANE_FALSE, SANE_TRUE , 63, 120, 8736, 601, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 100, 1, StepType::HALF, SANE_FALSE, SANE_TRUE, 63, 120, 8736, 601, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 150, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 67, 15902, 902, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 300, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 32, 16703, 2188, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 600, 1, StepType::FULL, SANE_FALSE, SANE_TRUE , 63, 3, 18761, 18761, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400,1200, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 3, 43501, 43501, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 50, 3, StepType::FULL, false, true , 63, 120, 8736, 601, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 100, 3, StepType::HALF, false, true, 63, 120, 8736, 601, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 150, 3, StepType::HALF, false, true , 63, 67, 15902, 902, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 300, 3, StepType::HALF, false, true , 63, 32, 16703, 2188, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 600, 3, StepType::FULL, false, true , 63, 3, 18761, 18761, 192, 4905, 627, 0.30, 0.4, 192},
{MotorId::HP2400,1200, 3, StepType::HALF, false, true , 63, 3, 43501, 43501, 192, 4905, 627, 0.30, 0.4, 192},
{MotorId::HP2400, 50, 1, StepType::FULL, false, true , 63, 120, 8736, 601, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 100, 1, StepType::HALF, false, true, 63, 120, 8736, 601, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 150, 1, StepType::HALF, false, true , 63, 67, 15902, 902, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 300, 1, StepType::HALF, false, true , 63, 32, 16703, 2188, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400, 600, 1, StepType::FULL, false, true , 63, 3, 18761, 18761, 192, 4905, 337, 0.30, 0.4, 192},
{MotorId::HP2400,1200, 1, StepType::HALF, false, true , 63, 3, 43501, 43501, 192, 4905, 337, 0.30, 0.4, 192},
/* XP 200 motor settings */
{MotorId::XP200, 75, 3, StepType::HALF, SANE_TRUE , SANE_FALSE, 0, 4, 6000, 2136, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 100, 3, StepType::HALF, SANE_TRUE , SANE_FALSE, 0, 4, 6000, 2850, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 200, 3, StepType::HALF, SANE_TRUE , SANE_FALSE, 0, 4, 6999, 5700, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 250, 3, StepType::HALF, SANE_TRUE , SANE_FALSE, 0, 4, 6999, 6999, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 300, 3, StepType::HALF, SANE_TRUE , SANE_FALSE, 0, 4, 13500, 13500, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 600, 3, StepType::HALF, SANE_TRUE , SANE_TRUE, 0, 4, 31998, 31998, 2, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 75, 1, StepType::HALF, SANE_TRUE , SANE_FALSE, 0, 4, 6000, 2000, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 100, 1, StepType::HALF, SANE_TRUE , SANE_FALSE, 0, 4, 6000, 1300, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 200, 1, StepType::HALF, SANE_TRUE , SANE_TRUE, 0, 4, 6000, 3666, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 300, 1, StepType::HALF, SANE_TRUE , SANE_FALSE, 0, 4, 6500, 6500, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 600, 1, StepType::HALF, SANE_TRUE , SANE_TRUE, 0, 4, 24000, 24000, 2, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 75, 3, StepType::HALF, true , false, 0, 4, 6000, 2136, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 100, 3, StepType::HALF, true , false, 0, 4, 6000, 2850, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 200, 3, StepType::HALF, true , false, 0, 4, 6999, 5700, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 250, 3, StepType::HALF, true , false, 0, 4, 6999, 6999, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 300, 3, StepType::HALF, true , false, 0, 4, 13500, 13500, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 600, 3, StepType::HALF, true , true, 0, 4, 31998, 31998, 2, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 75, 1, StepType::HALF, true , false, 0, 4, 6000, 2000, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 100, 1, StepType::HALF, true , false, 0, 4, 6000, 1300, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 200, 1, StepType::HALF, true , true, 0, 4, 6000, 3666, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 300, 1, StepType::HALF, true , false, 0, 4, 6500, 6500, 8, 12000, 1200, 0.3, 0.5, 1},
{MotorId::XP200, 600, 1, StepType::HALF, true , true, 0, 4, 24000, 24000, 2, 12000, 1200, 0.3, 0.5, 1},
/* HP scanjet 2300c */
{MotorId::HP2300, 75, 3, StepType::FULL, SANE_FALSE, SANE_TRUE , 63, 120, 8139, 560, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 150, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 67, 7903, 543, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 300, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 3, 2175, 1087, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 600, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 3, 8700, 4350, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300,1200, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 3, 17400, 8700, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 75, 1, StepType::FULL, SANE_FALSE, SANE_TRUE , 63, 120, 8139, 560, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 150, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 67, 7903, 543, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 300, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 3, 2175, 1087, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 600, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 3, 8700, 4350, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300,1200, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 3, 17400, 8700, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 75, 3, StepType::FULL, false, true , 63, 120, 8139, 560, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 150, 3, StepType::HALF, false, true , 63, 67, 7903, 543, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 300, 3, StepType::HALF, false, true , 63, 3, 2175, 1087, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 600, 3, StepType::HALF, false, true , 63, 3, 8700, 4350, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300,1200, 3, StepType::HALF, false, true , 63, 3, 17400, 8700, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 75, 1, StepType::FULL, false, true , 63, 120, 8139, 560, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 150, 1, StepType::HALF, false, true , 63, 67, 7903, 543, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 300, 1, StepType::HALF, false, true , 63, 3, 2175, 1087, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 600, 1, StepType::HALF, false, true , 63, 3, 8700, 4350, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300,1200, 1, StepType::HALF, false, true , 63, 3, 17400, 8700, 120, 4905, 337, 0.3, 0.4, 16},
/* non half ccd settings for 300 dpi
{MotorId::HP2300, 300, 3, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 44, 5386, 2175, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 300, 1, StepType::HALF, SANE_FALSE, SANE_TRUE , 63, 44, 5386, 2175, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 300, 3, StepType::HALF, false, true , 63, 44, 5386, 2175, 120, 4905, 337, 0.3, 0.4, 16},
{MotorId::HP2300, 300, 1, StepType::HALF, false, true , 63, 44, 5386, 2175, 120, 4905, 337, 0.3, 0.4, 16},
*/
/* MD5345/6471 motor settings */
/* vfinal=(exposure/(1200/dpi))/step_type */
{MotorId::MD_5345, 50, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 250, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 75, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 343, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 100, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 458, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 150, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 687, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 200, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 916, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 300, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 1375, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 400, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 0, 32, 2000, 1833, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 500, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 0, 32, 2291, 2291, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 600, 3, StepType::HALF , SANE_FALSE, SANE_TRUE , 0, 32, 2750, 2750, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 1200, 3, StepType::QUARTER, SANE_FALSE, SANE_TRUE , 0, 16, 2750, 2750, 255, 2000, 300, 0.3, 0.4, 146},
{MotorId::MD_5345, 2400, 3, StepType::QUARTER, SANE_FALSE, SANE_TRUE , 0, 16, 5500, 5500, 255, 2000, 300, 0.3, 0.4, 146},
{MotorId::MD_5345, 50, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 250, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 75, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 343, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 100, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 458, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 150, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 687, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 200, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 916, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 300, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 2, 255, 2500, 1375, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 400, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 0, 32, 2000, 1833, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 500, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 0, 32, 2291, 2291, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 600, 1, StepType::HALF , SANE_FALSE, SANE_TRUE , 0, 32, 2750, 2750, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 1200, 1, StepType::QUARTER, SANE_FALSE, SANE_TRUE , 0, 16, 2750, 2750, 255, 2000, 300, 0.3, 0.4, 146},
{MotorId::MD_5345, 2400, 1, StepType::QUARTER, SANE_FALSE, SANE_TRUE , 0, 16, 5500, 5500, 255, 2000, 300, 0.3, 0.4, 146}, /* 5500 guessed */
{MotorId::MD_5345, 50, 3, StepType::HALF , false, true , 2, 255, 2500, 250, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 75, 3, StepType::HALF , false, true , 2, 255, 2500, 343, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 100, 3, StepType::HALF , false, true , 2, 255, 2500, 458, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 150, 3, StepType::HALF , false, true , 2, 255, 2500, 687, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 200, 3, StepType::HALF , false, true , 2, 255, 2500, 916, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 300, 3, StepType::HALF , false, true , 2, 255, 2500, 1375, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 400, 3, StepType::HALF , false, true , 0, 32, 2000, 1833, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 500, 3, StepType::HALF , false, true , 0, 32, 2291, 2291, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 600, 3, StepType::HALF , false, true , 0, 32, 2750, 2750, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 1200, 3, StepType::QUARTER, false, true , 0, 16, 2750, 2750, 255, 2000, 300, 0.3, 0.4, 146},
{MotorId::MD_5345, 2400, 3, StepType::QUARTER, false, true , 0, 16, 5500, 5500, 255, 2000, 300, 0.3, 0.4, 146},
{MotorId::MD_5345, 50, 1, StepType::HALF , false, true , 2, 255, 2500, 250, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 75, 1, StepType::HALF , false, true , 2, 255, 2500, 343, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 100, 1, StepType::HALF , false, true , 2, 255, 2500, 458, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 150, 1, StepType::HALF , false, true , 2, 255, 2500, 687, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 200, 1, StepType::HALF , false, true , 2, 255, 2500, 916, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 300, 1, StepType::HALF , false, true , 2, 255, 2500, 1375, 255, 2000, 300, 0.3, 0.4, 64},
{MotorId::MD_5345, 400, 1, StepType::HALF , false, true , 0, 32, 2000, 1833, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 500, 1, StepType::HALF , false, true , 0, 32, 2291, 2291, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 600, 1, StepType::HALF , false, true , 0, 32, 2750, 2750, 255, 2000, 300, 0.3, 0.4, 32},
{MotorId::MD_5345, 1200, 1, StepType::QUARTER, false, true , 0, 16, 2750, 2750, 255, 2000, 300, 0.3, 0.4, 146},
{MotorId::MD_5345, 2400, 1, StepType::QUARTER, false, true , 0, 16, 5500, 5500, 255, 2000, 300, 0.3, 0.4, 146}, /* 5500 guessed */
};
class CommandSetGl646 : public CommandSet

177
backend/genesys_gl841.cc
Wyświetl plik

@ -85,55 +85,41 @@ static void gl841_set_buffer_address_gamma(Genesys_Device* dev, uint32_t addr)
bool CommandSetGl841::get_fast_feed_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x02);
if (r && (r->value & REG02_FASTFED))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG02_FASTFED));
}
bool CommandSetGl841::get_filter_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x04);
if (r && (r->value & REG04_FILTER))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_FILTER));
}
bool CommandSetGl841::get_lineart_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x04);
if (r && (r->value & REG04_LINEART))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_LINEART));
}
bool CommandSetGl841::get_bitset_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x04);
if (r && (r->value & REG04_BITSET))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_BITSET));
}
bool CommandSetGl841::get_gain4_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x06);
if (r && (r->value & REG06_GAIN4))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG06_GAIN4));
}
bool CommandSetGl841::test_buffer_empty_bit(SANE_Byte val) const
{
if (val & REG41_BUFEMPTY)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_BUFEMPTY);
}
bool CommandSetGl841::test_motor_flag_bit(SANE_Byte val) const
{
if (val & REG41_MOTORENB)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_MOTORENB);
}
/** copy sensor specific settings */
@ -171,7 +157,7 @@ other register settings depending on this:
*/
static void sanei_gl841_setup_sensor(Genesys_Device * dev, const Genesys_Sensor& sensor,
Genesys_Register_Set * regs,
SANE_Bool extended, unsigned ccd_size_divisor)
bool extended, unsigned ccd_size_divisor)
{
DBG(DBG_proc, "%s\n", __func__);
@ -536,7 +522,7 @@ gl841_init_registers (Genesys_Device * dev)
dev->reg.find_reg(0x01).value = 0x20; /* (enable shading), CCD, color, 1M */
if (dev->model->is_cis == SANE_TRUE) {
if (dev->model->is_cis) {
dev->reg.find_reg(0x01).value |= REG01_CISSET;
} else {
dev->reg.find_reg(0x01).value &= ~REG01_CISSET;
@ -1825,7 +1811,7 @@ dummy \ scanned lines
build_image_pipeline(dev, session);
dev->read_active = SANE_TRUE;
dev->read_active = true;
dev->session = session;
dev->current_setup.pixels = session.output_pixels;
@ -2157,13 +2143,13 @@ static void gl841_stop_action(Genesys_Device* dev)
throw SaneException(SANE_STATUS_IO_ERROR, "could not stop motor");
}
static void gl841_get_paper_sensor(Genesys_Device* dev, SANE_Bool * paper_loaded)
static bool gl841_get_paper_sensor(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val = dev->read_register(REG6D);
*paper_loaded = (val & 0x1) == 0;
return (val & 0x1) == 0;
}
void CommandSetGl841::eject_document(Genesys_Device* dev) const
@ -2171,13 +2157,11 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
DBG_HELPER(dbg);
Genesys_Register_Set local_reg;
uint8_t val;
SANE_Bool paper_loaded;
unsigned int init_steps;
float feed_mm;
int loop;
if (dev->model->is_sheetfed == SANE_FALSE)
{
if (!dev->model->is_sheetfed) {
DBG(DBG_proc, "%s: there is no \"eject sheet\"-concept for non sheet fed\n", __func__);
DBG(DBG_proc, "%s: finished\n", __func__);
return;
@ -2213,22 +2197,17 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
throw;
}
gl841_get_paper_sensor(dev, &paper_loaded);
if (paper_loaded)
{
if (gl841_get_paper_sensor(dev)) {
DBG(DBG_info, "%s: paper still loaded\n", __func__);
/* force document TRUE, because it is definitely present */
dev->document = SANE_TRUE;
dev->document = true;
dev->scanhead_position_in_steps = 0;
loop = 300;
while (loop > 0) /* do not wait longer then 30 seconds */
{
gl841_get_paper_sensor(dev, &paper_loaded);
if (!paper_loaded)
{
if (!gl841_get_paper_sensor(dev)) {
DBG(DBG_info, "%s: reached home position\n", __func__);
DBG(DBG_proc, "%s: finished\n", __func__);
break;
@ -2274,28 +2253,23 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
++loop;
}
gl841_stop_action(dev);
gl841_stop_action(dev);
dev->document = SANE_FALSE;
dev->document = false;
}
void CommandSetGl841::load_document(Genesys_Device* dev) const
{
DBG_HELPER(dbg);
SANE_Bool paper_loaded;
int loop = 300;
while (loop > 0) /* do not wait longer then 30 seconds */
{
gl841_get_paper_sensor(dev, &paper_loaded);
if (paper_loaded)
{
if (gl841_get_paper_sensor(dev)) {
DBG(DBG_info, "%s: document inserted\n", __func__);
/* when loading OK, document is here */
dev->document = SANE_TRUE;
dev->document = true;
// give user some time to place document correctly
sanei_genesys_sleep_ms(1000);
@ -2320,15 +2294,12 @@ void CommandSetGl841::load_document(Genesys_Device* dev) const
void CommandSetGl841::detect_document_end(Genesys_Device* dev) const
{
DBG_HELPER(dbg);
SANE_Bool paper_loaded;
gl841_get_paper_sensor(dev, &paper_loaded);
bool paper_loaded = gl841_get_paper_sensor(dev);
/* sheetfed scanner uses home sensor as paper present */
if ((dev->document == SANE_TRUE) && !paper_loaded)
{
if (dev->document && !paper_loaded) {
DBG(DBG_info, "%s: no more document\n", __func__);
dev->document = SANE_FALSE;
dev->document = false;
/* we can't rely on total_bytes_to_read since the frontend
* might have been slow to read data, so we re-evaluate the
@ -2420,7 +2391,7 @@ void CommandSetGl841::end_scan(Genesys_Device* dev, Genesys_Register_Set __sane_
{
DBG_HELPER_ARGS(dbg, "check_stop = %d", check_stop);
if (dev->model->is_sheetfed != SANE_TRUE) {
if (!dev->model->is_sheetfed) {
gl841_stop_action(dev);
}
}
@ -2487,8 +2458,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
GenesysRegister *r;
int loop = 0;
if (dev->model->is_sheetfed == SANE_TRUE)
{
if (dev->model->is_sheetfed) {
DBG(DBG_proc, "%s: there is no \"home\"-concept for sheet fed\n", __func__);
DBG(DBG_proc, "%s: finished\n", __func__);
return;
@ -2506,7 +2476,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
val = REG6B_GPO18 | REG6B_GPO17;
dev->write_register(REG6B, val);
}
dev->cmd_set->save_power(dev, SANE_FALSE);
dev->cmd_set->save_power(dev, false);
// first read gives HOME_SENSOR true
sanei_genesys_get_status(dev, &val);
@ -2603,7 +2573,6 @@ void CommandSetGl841::search_start_position(Genesys_Device* dev) const
DBG_HELPER(dbg);
int size;
Genesys_Register_Set local_reg;
int steps;
int pixels = 600;
int dpi = 300;
@ -2644,12 +2613,13 @@ void CommandSetGl841::search_start_position(Genesys_Device* dev) const
std::vector<uint8_t> data(size);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
// waits for valid data
bool empty;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -2659,7 +2629,7 @@ void CommandSetGl841::search_start_position(Genesys_Device* dev) const
dev->model->search_lines);
}
dev->cmd_set->end_scan(dev, &local_reg, SANE_TRUE);
dev->cmd_set->end_scan(dev, &local_reg, true);
/* update regs to copy ASIC internal state */
dev->reg = local_reg;
@ -2915,8 +2885,6 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
uint16_t exp[3], target;
int move;
SANE_Bool acceptable = SANE_FALSE;
/* these 2 boundaries should be per sensor */
uint16_t min_exposure=500;
uint16_t max_exposure;
@ -2987,6 +2955,7 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
auto calib_sensor = calib_sensor_base;
bool acceptable = false;
do {
calib_sensor.exposure.red = exp[0];
calib_sensor.exposure.green = exp[1];
@ -3003,7 +2972,7 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
dev->write_registers(regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
if (DBG_LEVEL >= DBG_data) {
@ -3034,7 +3003,7 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info,"%s: average: %d,%d,%d\n", __func__, avg[0], avg[1], avg[2]);
acceptable = SANE_TRUE;
acceptable = true;
/* exposure is acceptable if each color is in the %5 range
* of other color channels */
@ -3042,27 +3011,27 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
avg[0] < avg[2] * 0.95 || avg[2] < avg[0] * 0.95 ||
avg[1] < avg[2] * 0.95 || avg[2] < avg[1] * 0.95)
{
acceptable = SANE_FALSE;
acceptable = false;
}
/* led exposure is not acceptable if white level is too low
* ~80 hardcoded value for white level */
if(avg[0]<20000 || avg[1]<20000 || avg[2]<20000)
{
acceptable = SANE_FALSE;
acceptable = false;
}
/* for scanners using target value */
if(target>0)
{
acceptable = SANE_TRUE;
acceptable = true;
for(i=0;i<3;i++)
{
/* we accept +- 2% delta from target */
if(abs(avg[i]-target)>target/50)
{
exp[i]=(exp[i]*target)/avg[i];
acceptable = SANE_FALSE;
acceptable = false;
}
}
}
@ -3105,7 +3074,7 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info,"%s: acceptable exposure: %d,%d,%d\n", __func__, exp[0], exp[1], exp[2]);
dev->cmd_set->slow_back_home(dev, SANE_TRUE);
dev->cmd_set->slow_back_home(dev, true);
return calib_sensor.exposure;
}
@ -3186,7 +3155,7 @@ static void ad_fe_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
DBG(DBG_info, "%s: starting line reading\n", __func__);
dev->write_registers(regs);
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
gl841_stop_action (dev);
if (DBG_LEVEL >= DBG_data) {
@ -3247,7 +3216,6 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
int min1[3],min2[3];
int cmin[3],cmax[3];
int turn;
SANE_Bool acceptable = SANE_FALSE;
int mintgt = 0x400;
/* Analog Device fronted have a different calibration */
@ -3323,6 +3291,7 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
offl[2] = 0x00;
turn = 0;
bool acceptable = false;
do {
dev->write_registers(regs);
@ -3335,7 +3304,7 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
@ -3345,7 +3314,7 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
sanei_genesys_write_pnm_file(fn, first_line.data(), 16, channels, num_pixels, 1);
}
acceptable = SANE_TRUE;
acceptable = true;
for (j = 0; j < channels; j++)
{
@ -3374,14 +3343,14 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
cmin[j] -= 20;
if (cmin[j] > num_pixels/100) {
acceptable = SANE_FALSE;
acceptable = false;
if (dev->model->is_cis)
offl[0] = off[0];
else
offl[j] = off[j];
}
if (cmax[j] > num_pixels/100) {
acceptable = SANE_FALSE;
acceptable = false;
if (dev->model->is_cis)
offh[0] = off[0];
else
@ -3443,7 +3412,7 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
DBG(DBG_info, "%s: starting second line reading\n", __func__);
dev->write_registers(regs);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
if (DBG_LEVEL >= DBG_data) {
@ -3452,7 +3421,7 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
sanei_genesys_write_pnm_file(fn, second_line.data(), 16, channels, num_pixels, 1);
}
acceptable = SANE_TRUE;
acceptable = true;
for (j = 0; j < channels; j++)
{
@ -3476,14 +3445,14 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
}
if (cmin[j] > num_pixels/100) {
acceptable = SANE_FALSE;
acceptable = false;
if (dev->model->is_cis)
offl[0] = off[0];
else
offl[j] = off[j];
}
if (cmax[j] > num_pixels/100) {
acceptable = SANE_FALSE;
acceptable = false;
if (dev->model->is_cis)
offh[0] = off[0];
else
@ -3658,7 +3627,7 @@ void CommandSetGl841::coarse_gain_calibration(Genesys_Device* dev, const Genesys
std::vector<uint8_t> line(total_size);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
@ -3752,7 +3721,7 @@ void CommandSetGl841::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gl841_stop_action(dev);
dev->cmd_set->slow_back_home(dev, SANE_TRUE);
dev->cmd_set->slow_back_home(dev, true);
}
// wait for lamp warmup by scanning the same line until difference
@ -3817,7 +3786,7 @@ static void sanei_gl841_repark_head(Genesys_Device* dev)
gl841_feed(dev,232);
// toggle motor flag, put an huge step number and redo move backward
dev->cmd_set->slow_back_home(dev, SANE_TRUE);
dev->cmd_set->slow_back_home(dev, true);
}
bool CommandSetGl841::is_compatible_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
@ -3842,11 +3811,9 @@ bool CommandSetGl841::is_compatible_calibration(Genesys_Device* dev, const Genes
/* a cache entry expires after 30 minutes for non sheetfed scanners */
/* this is not taken into account when overwriting cache entries */
#ifdef HAVE_SYS_TIME_H
if(for_overwrite == SANE_FALSE)
{
if (!for_overwrite) {
gettimeofday (&time, nullptr);
if ((time.tv_sec - cache->last_calibration > 30 * 60)
&& (dev->model->is_sheetfed == SANE_FALSE))
if ((time.tv_sec - cache->last_calibration > 30 * 60) && (!dev->model->is_sheetfed))
{
DBG(DBG_proc, "%s: expired entry, non compatible cache\n", __func__);
return false;
@ -3910,7 +3877,7 @@ void CommandSetGl841::init(Genesys_Device* dev) const
dev->calib_reg = dev->reg;
// Move home
dev->cmd_set->slow_back_home(dev, SANE_TRUE);
dev->cmd_set->slow_back_home(dev, true);
// Init shading data
sanei_genesys_init_shading_data(dev, sensor, sensor.sensor_pixels);
@ -3965,7 +3932,7 @@ void CommandSetGl841::init(Genesys_Device* dev) const
std::vector<uint8_t> line(size);
DBG(DBG_info, "%s: starting dummy data reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
sanei_usb_set_timeout(1000);/* 1 second*/
@ -3974,13 +3941,13 @@ void CommandSetGl841::init(Genesys_Device* dev) const
sanei_usb_set_timeout(30 * 1000);/* 30 seconds*/
end_scan(dev, &regs, SANE_TRUE);
end_scan(dev, &regs, true);
regs = dev->reg;
// Set powersaving(default = 15 minutes)
set_powersaving(dev, 15);
dev->already_initialized = SANE_TRUE;
dev->already_initialized = true;
}
void CommandSetGl841::update_hardware_sensors(Genesys_Scanner* s) const
@ -4017,8 +3984,8 @@ void CommandSetGl841::update_hardware_sensors(Genesys_Scanner* s) const
* When searching backward, the searched area must completely be of the desired
* color since this area will be used for calibration which scans forward.
* @param dev scanner device
* @param forward SANE_TRUE if searching forward, SANE_FALSE if searching backward
* @param black SANE_TRUE if searching for a black strip, SANE_FALSE for a white strip
* @param forward true if searching forward, false if searching backward
* @param black true if searching for a black strip, false for a white strip
*/
void CommandSetGl841::search_strip(Genesys_Device* dev, const Genesys_Sensor& sensor, bool forward,
bool black) const
@ -4027,7 +3994,7 @@ void CommandSetGl841::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
unsigned int pixels, lines, channels;
Genesys_Register_Set local_reg;
size_t size;
int steps, depth;
int depth;
unsigned int pass, count, found, x, y, length;
char title[80];
GenesysRegister *r;
@ -4094,12 +4061,13 @@ void CommandSetGl841::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
dev->write_registers(local_reg);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -4121,12 +4089,13 @@ void CommandSetGl841::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
dev->write_registers(local_reg);
//now start scan
dev->cmd_set->begin_scan(dev, sensor, &local_reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);

114
backend/genesys_gl843.cc
Wyświetl plik

@ -103,41 +103,31 @@ static void write_data(Genesys_Device* dev, uint32_t addr, uint32_t size, uint8_
bool CommandSetGl843::get_fast_feed_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address (regs, REG02);
if (r && (r->value & REG02_FASTFED))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG02_FASTFED));
}
bool CommandSetGl843::get_filter_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_FILTER))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_FILTER));
}
bool CommandSetGl843::get_lineart_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_LINEART))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_LINEART));
}
bool CommandSetGl843::get_bitset_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_BITSET))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_BITSET));
}
bool CommandSetGl843::get_gain4_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address (regs, REG06);
if (r && (r->value & REG06_GAIN4))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG06_GAIN4));
}
/**
@ -168,16 +158,12 @@ gl843_get_step_multiplier (Genesys_Register_Set * regs)
bool CommandSetGl843::test_buffer_empty_bit(SANE_Byte val) const
{
if (val & REG41_BUFEMPTY)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_BUFEMPTY);
}
bool CommandSetGl843::test_motor_flag_bit(SANE_Byte val) const
{
if (val & REG41_MOTORENB)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_MOTORENB);
}
/** copy sensor specific settings */
@ -1046,7 +1032,7 @@ static void gl843_init_motor_regs_scan(Genesys_Device* dev,
* @param pixels logical number of pixels to use
* @param channels number of color channles used (1 or 3)
* @param depth bit depth of the scan (1, 8 or 16 bits)
* @param ccd_size_divisor SANE_TRUE specifies how much x coordinates must be shrunk
* @param ccd_size_divisor true specifies how much x coordinates must be shrunk
* @param color_filter to choose the color channel used in gray scans
* @param flags to drive specific settings such no calibration, XPA use ...
*/
@ -1313,7 +1299,7 @@ static void gl843_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
build_image_pipeline(dev, session);
dev->read_active = SANE_TRUE;
dev->read_active = true;
dev->session = session;
dev->current_setup.pixels = session.output_pixels;
@ -1510,13 +1496,13 @@ static void gl843_stop_action(Genesys_Device* dev)
throw SaneException(SANE_STATUS_IO_ERROR, "could not stop motor");
}
static void gl843_get_paper_sensor(Genesys_Device* dev, SANE_Bool * paper_loaded)
static bool gl843_get_paper_sensor(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val = dev->read_register(REG6D);
*paper_loaded = (val & 0x1) == 0;
return (val & 0x1) == 0;
}
void CommandSetGl843::eject_document(Genesys_Device* dev) const
@ -1540,15 +1526,12 @@ void CommandSetGl843::load_document(Genesys_Device* dev) const
void CommandSetGl843::detect_document_end(Genesys_Device* dev) const
{
DBG_HELPER(dbg);
SANE_Bool paper_loaded;
gl843_get_paper_sensor(dev, &paper_loaded);
bool paper_loaded = gl843_get_paper_sensor(dev);
/* sheetfed scanner uses home sensor as paper present */
if ((dev->document == SANE_TRUE) && !paper_loaded)
{
if (dev->document && !paper_loaded) {
DBG(DBG_info, "%s: no more document\n", __func__);
dev->document = SANE_FALSE;
dev->document = false;
unsigned scanned_lines = 0;
catch_all_exceptions(__func__, [&](){ sanei_genesys_read_scancnt(dev, &scanned_lines); });
@ -1798,7 +1781,7 @@ void CommandSetGl843::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
}
if (reg->state.is_xpa_on) {
dev->needs_home_ta = SANE_TRUE;
dev->needs_home_ta = true;
gl843_set_xpa_motor_power(dev, true);
}
@ -1811,7 +1794,7 @@ void CommandSetGl843::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
gl843_set_xpa_lamp_power(dev, true);
}
if (reg->state.is_xpa_on) {
dev->needs_home_ta = SANE_TRUE;
dev->needs_home_ta = true;
gl843_set_xpa_motor_power(dev, true);
}
break;
@ -1857,7 +1840,7 @@ void CommandSetGl843::end_scan(Genesys_Device* dev, Genesys_Register_Set* reg,
gl843_set_xpa_lamp_power(dev, false);
}
if (dev->model->is_sheetfed != SANE_TRUE) {
if (!dev->model->is_sheetfed) {
gl843_stop_action(dev);
}
}
@ -1918,7 +1901,7 @@ static void gl843_park_xpa_lamp(Genesys_Device* dev)
DBG(DBG_proc, "%s: finished\n", __func__);
gl843_set_xpa_motor_power(dev, false);
dev->needs_home_ta = SANE_FALSE;
dev->needs_home_ta = false;
return;
}
@ -2050,7 +2033,6 @@ void CommandSetGl843::search_start_position(Genesys_Device* dev) const
{
DBG_HELPER(dbg);
Genesys_Register_Set local_reg;
int steps;
int pixels = 600;
int dpi = 300;
@ -2087,12 +2069,13 @@ void CommandSetGl843::search_start_position(Genesys_Device* dev) const
// send to scanner
dev->write_registers(local_reg);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
Image image = read_unshuffled_image_from_scanner(dev, session, session.output_total_bytes_raw);
@ -2103,7 +2086,7 @@ void CommandSetGl843::search_start_position(Genesys_Device* dev) const
sanei_genesys_write_pnm_file("gl843_search_position.pnm", image);
}
dev->cmd_set->end_scan(dev, &local_reg, SANE_TRUE);
dev->cmd_set->end_scan(dev, &local_reg, true);
/* update regs to copy ASIC internal state */
dev->reg = local_reg;
@ -2463,8 +2446,6 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
int turn;
uint16_t expr, expg, expb;
SANE_Bool acceptable = SANE_FALSE;
// offset calibration is always done in color mode
unsigned channels = 3;
depth = 16;
@ -2514,6 +2495,7 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
turn = 0;
bool acceptable = false;
do
{
@ -2526,7 +2508,7 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
dev->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
auto image = read_unshuffled_image_from_scanner(dev, session,
session.output_total_bytes_raw);
gl843_stop_action_no_move(dev, &regs);
@ -2538,7 +2520,7 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
sanei_genesys_write_pnm_file(fn, image);
}
acceptable = SANE_TRUE;
acceptable = true;
for (unsigned ch = 0; ch < channels; ch++) {
avg[ch] = 0;
@ -2550,12 +2532,12 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info, "%s: average: %d,%d,%d\n", __func__, avg[0], avg[1], avg[2]);
acceptable = SANE_TRUE;
acceptable = true;
if (avg[0] < avg[1] * 0.95 || avg[1] < avg[0] * 0.95 ||
avg[0] < avg[2] * 0.95 || avg[2] < avg[0] * 0.95 ||
avg[1] < avg[2] * 0.95 || avg[2] < avg[1] * 0.95)
acceptable = SANE_FALSE;
acceptable = false;
if (!acceptable)
{
@ -2597,7 +2579,7 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info, "%s: acceptable exposure: %d,%d,%d\n", __func__, expr, expg, expb);
slow_back_home(dev, SANE_TRUE);
slow_back_home(dev, true);
return calib_sensor.exposure;
}
@ -2732,7 +2714,7 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
auto first_line = read_unshuffled_image_from_scanner(dev, session,
session.output_total_bytes_raw);
gl843_stop_action_no_move(dev, &regs);
@ -2761,7 +2743,7 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
auto second_line = read_unshuffled_image_from_scanner(dev, session,
session.output_total_bytes_raw);
gl843_stop_action_no_move(dev, &regs);
@ -2795,7 +2777,7 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
// scan with no move
dev->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
second_line = read_unshuffled_image_from_scanner(dev, session,
session.output_total_bytes_raw);
gl843_stop_action_no_move(dev, &regs);
@ -2938,7 +2920,7 @@ void CommandSetGl843::coarse_gain_calibration(Genesys_Device* dev, const Genesys
dev->write_registers(regs);
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
auto line = read_unshuffled_image_from_scanner(dev, session, session.output_total_bytes_raw);
gl843_stop_action_no_move(dev, &regs);
@ -2992,7 +2974,7 @@ void CommandSetGl843::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gl843_stop_action(dev);
slow_back_home(dev, SANE_TRUE);
slow_back_home(dev, true);
}
// wait for lamp warmup by scanning the same line until difference
@ -3222,8 +3204,8 @@ void CommandSetGl843::move_to_ta(Genesys_Device* dev) const
* When searching backward, the searched area must completely be of the desired
* color since this area will be used for calibration which scans forward.
* @param dev scanner device
* @param forward SANE_TRUE if searching forward, SANE_FALSE if searching backward
* @param black SANE_TRUE if searching for a black strip, SANE_FALSE for a white strip
* @param forward true if searching forward, false if searching backward
* @param black true if searching for a black strip, false for a white strip
*/
void CommandSetGl843::search_strip(Genesys_Device* dev, const Genesys_Sensor& sensor,
bool forward, bool black) const
@ -3231,7 +3213,7 @@ void CommandSetGl843::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
DBG_HELPER_ARGS(dbg, "%s %s", black ? "black" : "white", forward ? "forward" : "reverse");
unsigned int pixels, lines, channels;
Genesys_Register_Set local_reg;
int steps, depth, dpi;
int depth, dpi;
unsigned int pass, count, found, x, y;
GenesysRegister *r;
@ -3283,12 +3265,13 @@ void CommandSetGl843::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
dev->write_registers(local_reg);
dev->cmd_set->begin_scan(dev, calib_sensor, &local_reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &local_reg, true);
// waits for valid data
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
auto data = read_unshuffled_image_from_scanner(dev, session,
@ -3312,12 +3295,13 @@ void CommandSetGl843::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
dev->write_registers(local_reg);
// now start scan
dev->cmd_set->begin_scan(dev, calib_sensor, &local_reg, SANE_TRUE);
dev->cmd_set->begin_scan(dev, calib_sensor, &local_reg, true);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
data = read_unshuffled_image_from_scanner(dev, session, session.output_total_bytes_raw);

95
backend/genesys_gl846.cc
Wyświetl plik

@ -61,55 +61,41 @@
bool CommandSetGl846::get_fast_feed_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG02);
if (r && (r->value & REG02_FASTFED))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG02_FASTFED));
}
bool CommandSetGl846::get_filter_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG04);
if (r && (r->value & REG04_FILTER))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_FILTER));
}
bool CommandSetGl846::get_lineart_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG04);
if (r && (r->value & REG04_LINEART))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_LINEART));
}
bool CommandSetGl846::get_bitset_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG04);
if (r && (r->value & REG04_BITSET))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_BITSET));
}
bool CommandSetGl846::get_gain4_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x06);
if (r && (r->value & REG06_GAIN4))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG06_GAIN4));
}
bool CommandSetGl846::test_buffer_empty_bit(SANE_Byte val) const
{
if (val & REG41_BUFEMPTY)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_BUFEMPTY);
}
bool CommandSetGl846::test_motor_flag_bit(SANE_Byte val) const
{
if (val & REG41_MOTORENB)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_MOTORENB);
}
/**
@ -758,8 +744,7 @@ static void gl846_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
/* CIS scanners can do true gray by setting LEDADD */
/* we set up LEDADD only when asked */
if (dev->model->is_cis == SANE_TRUE)
{
if (dev->model->is_cis) {
r = sanei_genesys_get_address (reg, 0x87);
r->value &= ~REG87_LEDADD;
if (session.enable_ledadd) {
@ -881,7 +866,7 @@ static void gl846_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
dev->read_buffer.clear();
dev->read_buffer.alloc(session.buffer_size_read);
dev->read_active = SANE_TRUE;
dev->read_active = true;
dev->session = session;
dev->current_setup.pixels = session.output_pixels;
@ -1078,7 +1063,7 @@ void CommandSetGl846::end_scan(Genesys_Device* dev, Genesys_Register_Set* reg,
(void) reg;
DBG_HELPER_ARGS(dbg, "check_stop = %d", check_stop);
if (dev->model->is_sheetfed != SANE_TRUE) {
if (!dev->model->is_sheetfed) {
gl846_stop_action(dev);
}
}
@ -1212,7 +1197,6 @@ void CommandSetGl846::search_start_position(Genesys_Device* dev) const
DBG_HELPER(dbg);
int size;
Genesys_Register_Set local_reg;
int steps;
int pixels = 600;
int dpi = 300;
@ -1252,12 +1236,13 @@ void CommandSetGl846::search_start_position(Genesys_Device* dev) const
std::vector<uint8_t> data(size);
begin_scan(dev, sensor, &local_reg, SANE_TRUE);
begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -1267,7 +1252,7 @@ void CommandSetGl846::search_start_position(Genesys_Device* dev) const
dev->model->search_lines);
}
end_scan(dev, &local_reg, SANE_TRUE);
end_scan(dev, &local_reg, true);
/* update regs to copy ASIC internal state */
dev->reg = local_reg;
@ -1641,7 +1626,6 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
int turn;
uint16_t exp[3];
float move;
SANE_Bool acceptable;
move = SANE_UNFIX(dev->model->y_offset_calib_white);
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
@ -1701,6 +1685,7 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
/* no move during led calibration */
sanei_genesys_set_motor_power(regs, false);
bool acceptable = false;
do
{
// set up exposure
@ -1712,7 +1697,7 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
dev->write_registers(regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
// stop scanning
@ -1748,18 +1733,18 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info, "%s: average: %d,%d,%d\n", __func__, avg[0], avg[1], avg[2]);
/* check if exposure gives average within the boundaries */
acceptable = SANE_TRUE;
acceptable = true;
for(i=0;i<3;i++)
{
if(avg[i]<bottom[i])
{
exp[i]=(exp[i]*bottom[i])/avg[i];
acceptable = SANE_FALSE;
acceptable = false;
}
if(avg[i]>top[i])
{
exp[i]=(exp[i]*top[i])/avg[i];
acceptable = SANE_FALSE;
acceptable = false;
}
}
@ -1777,7 +1762,7 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
/* go back home */
if(move>20)
{
slow_back_home(dev, SANE_TRUE);
slow_back_home(dev, true);
}
return { exp[0], exp[1], exp[2] };
@ -1953,8 +1938,8 @@ void CommandSetGl846::update_hardware_sensors(Genesys_Scanner* s) const
* When searching backward, the searched area must completely be of the desired
* color since this area will be used for calibration which scans forward.
* @param dev scanner device
* @param forward SANE_TRUE if searching forward, SANE_FALSE if searching backward
* @param black SANE_TRUE if searching for a black strip, SANE_FALSE for a white strip
* @param forward true if searching forward, false if searching backward
* @param black true if searching for a black strip, false for a white strip
*/
void CommandSetGl846::search_strip(Genesys_Device* dev, const Genesys_Sensor& sensor, bool forward,
bool black) const
@ -1963,7 +1948,7 @@ void CommandSetGl846::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
unsigned int pixels, lines, channels;
Genesys_Register_Set local_reg;
size_t size;
int steps, depth;
int depth;
unsigned int pass, count, found, x, y;
char title[80];
GenesysRegister *r;
@ -2016,12 +2001,13 @@ void CommandSetGl846::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
dev->write_registers(local_reg);
begin_scan(dev, sensor, &local_reg, SANE_TRUE);
begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -2043,12 +2029,13 @@ void CommandSetGl846::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
dev->write_registers(local_reg);
// now start scan
begin_scan(dev, sensor, &local_reg, SANE_TRUE);
begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -2254,7 +2241,7 @@ void CommandSetGl846::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
{
@ -2274,7 +2261,7 @@ void CommandSetGl846::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
topavg = dark_average(second_line.data(), pixels, lines, channels, black_pixels);
@ -2294,7 +2281,7 @@ void CommandSetGl846::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
@ -2396,7 +2383,7 @@ void CommandSetGl846::coarse_gain_calibration(Genesys_Device* dev, const Genesys
std::vector<uint8_t> line(total_size);
set_fe(dev, sensor, AFE_SET);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
@ -2446,7 +2433,7 @@ void CommandSetGl846::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gl846_stop_action(dev);
slow_back_home(dev, SANE_TRUE);
slow_back_home(dev, true);
}
bool CommandSetGl846::needs_home_before_init_regs_for_scan(Genesys_Device* dev) const

97
backend/genesys_gl847.cc
Wyświetl plik

@ -56,55 +56,41 @@
bool CommandSetGl847::get_fast_feed_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG02);
if (r && (r->value & REG02_FASTFED))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG02_FASTFED));
}
bool CommandSetGl847::get_filter_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG04);
if (r && (r->value & REG04_FILTER))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_FILTER));
}
bool CommandSetGl847::get_lineart_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG04);
if (r && (r->value & REG04_LINEART))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_LINEART));
}
bool CommandSetGl847::get_bitset_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG04);
if (r && (r->value & REG04_BITSET))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG04_BITSET));
}
bool CommandSetGl847::get_gain4_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x06);
if (r && (r->value & REG06_GAIN4))
return SANE_TRUE;
return SANE_FALSE;
return (r && (r->value & REG06_GAIN4));
}
bool CommandSetGl847::test_buffer_empty_bit(SANE_Byte val) const
{
if (val & REG41_BUFEMPTY)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_BUFEMPTY);
}
bool CommandSetGl847::test_motor_flag_bit(SANE_Byte val) const
{
if (val & REG41_MOTORENB)
return SANE_TRUE;
return SANE_FALSE;
return (val & REG41_MOTORENB);
}
/**
@ -769,8 +755,7 @@ static void gl847_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
/* CIS scanners can do true gray by setting LEDADD */
/* we set up LEDADD only when asked */
if (dev->model->is_cis == SANE_TRUE)
{
if (dev->model->is_cis) {
r = sanei_genesys_get_address (reg, 0x87);
r->value &= ~REG87_LEDADD;
if (session.enable_ledadd) {
@ -883,7 +868,7 @@ static void gl847_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
dev->read_buffer.clear();
dev->read_buffer.alloc(session.buffer_size_read);
dev->read_active = SANE_TRUE;
dev->read_active = true;
dev->session = session;
dev->current_setup.pixels = session.output_pixels;
@ -1084,7 +1069,7 @@ void CommandSetGl847::end_scan(Genesys_Device* dev, Genesys_Register_Set* reg,
(void) reg;
DBG_HELPER_ARGS(dbg, "check_stop = %d", check_stop);
if (dev->model->is_sheetfed != SANE_TRUE) {
if (!dev->model->is_sheetfed) {
gl847_stop_action(dev);
}
}
@ -1106,14 +1091,14 @@ static void gl847_rewind(Genesys_Device* dev)
dev->write_register(0x02, byte);
// and start scan, then wait completion
gl847_begin_scan(dev, dev->reg, SANE_TRUE);
gl847_begin_scan(dev, dev->reg, true);
do
{
sanei_genesys_sleep_ms(100);
byte = dev->read_register(REG40);
}
while(byte & REG40_MOTMFLG);
gl847_end_scan(dev, dev->reg, SANE_TRUE);
gl847_end_scan(dev, dev->reg, true);
// restore direction
byte = dev->read_register(0x02);
@ -1254,7 +1239,6 @@ void CommandSetGl847::search_start_position(Genesys_Device* dev) const
DBG_HELPER(dbg);
int size;
Genesys_Register_Set local_reg;
int steps;
int pixels = 600;
int dpi = 300;
@ -1294,12 +1278,13 @@ void CommandSetGl847::search_start_position(Genesys_Device* dev) const
std::vector<uint8_t> data(size);
begin_scan(dev, sensor, &local_reg, SANE_TRUE);
begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -1309,7 +1294,7 @@ void CommandSetGl847::search_start_position(Genesys_Device* dev) const
dev->model->search_lines);
}
end_scan(dev, &local_reg, SANE_TRUE);
end_scan(dev, &local_reg, true);
/* update regs to copy ASIC internal state */
dev->reg = local_reg;
@ -1681,7 +1666,6 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
int turn;
uint16_t exp[3];
float move;
SANE_Bool acceptable;
move = SANE_UNFIX(dev->model->y_offset_calib_white);
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
@ -1740,6 +1724,7 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
turn = 0;
/* no move during led calibration */
bool acceptable = false;
sanei_genesys_set_motor_power(regs, false);
do
{
@ -1752,7 +1737,7 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
dev->write_registers(regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
// stop scanning
@ -1788,18 +1773,18 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
DBG(DBG_info, "%s: average: %d,%d,%d\n", __func__, avg[0], avg[1], avg[2]);
/* check if exposure gives average within the boundaries */
acceptable = SANE_TRUE;
acceptable = true;
for(i=0;i<3;i++)
{
if(avg[i]<bottom[i])
{
exp[i]=(exp[i]*bottom[i])/avg[i];
acceptable = SANE_FALSE;
acceptable = false;
}
if(avg[i]>top[i])
{
exp[i]=(exp[i]*top[i])/avg[i];
acceptable = SANE_FALSE;
acceptable = false;
}
}
@ -1816,7 +1801,7 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
// go back home
if (move>20) {
slow_back_home(dev, SANE_TRUE);
slow_back_home(dev, true);
}
return { exp[0], exp[1], exp[2] };
@ -2030,8 +2015,8 @@ void CommandSetGl847::update_hardware_sensors(Genesys_Scanner* s) const
* When searching backward, the searched area must completely be of the desired
* color since this area will be used for calibration which scans forward.
* @param dev scanner device
* @param forward SANE_TRUE if searching forward, SANE_FALSE if searching backward
* @param black SANE_TRUE if searching for a black strip, SANE_FALSE for a white strip
* @param forward true if searching forward, false if searching backward
* @param black true if searching for a black strip, false for a white strip
*/
void CommandSetGl847::search_strip(Genesys_Device* dev, const Genesys_Sensor& sensor, bool forward,
bool black) const
@ -2040,7 +2025,7 @@ void CommandSetGl847::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
unsigned int pixels, lines, channels;
Genesys_Register_Set local_reg;
size_t size;
int steps, depth;
int depth;
unsigned int pass, count, found, x, y;
char title[80];
GenesysRegister *r;
@ -2092,12 +2077,13 @@ void CommandSetGl847::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
dev->write_registers(local_reg);
begin_scan(dev, sensor, &local_reg, SANE_TRUE);
begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -2119,12 +2105,13 @@ void CommandSetGl847::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
dev->write_registers(local_reg);
// now start scan
begin_scan(dev, sensor, &local_reg, SANE_TRUE);
begin_scan(dev, sensor, &local_reg, true);
// waits for valid data
bool empty = false;
do {
sanei_genesys_test_buffer_empty(dev, &steps);
} while (steps);
sanei_genesys_test_buffer_empty(dev, &empty);
} while (empty);
// now we're on target, we can read data
sanei_genesys_read_data_from_scanner(dev, data.data(), size);
@ -2330,7 +2317,7 @@ void CommandSetGl847::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
{
@ -2350,7 +2337,7 @@ void CommandSetGl847::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
topavg = dark_average(second_line.data(), pixels, lines, channels, black_pixels);
@ -2370,7 +2357,7 @@ void CommandSetGl847::offset_calibration(Genesys_Device* dev, const Genesys_Sens
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
@ -2470,7 +2457,7 @@ void CommandSetGl847::coarse_gain_calibration(Genesys_Device* dev, const Genesys
std::vector<uint8_t> line(total_size);
set_fe(dev, sensor, AFE_SET);
begin_scan(dev, sensor, &regs, SANE_TRUE);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
if (DBG_LEVEL >= DBG_data)
@ -2539,7 +2526,7 @@ void CommandSetGl847::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gl847_stop_action(dev);
slow_back_home(dev, SANE_TRUE);
slow_back_home(dev, true);
}
bool CommandSetGl847::needs_home_before_init_regs_for_scan(Genesys_Device* dev) const

34
backend/genesys_low.cc
Wyświetl plik

@ -768,9 +768,9 @@ void sanei_genesys_read_scancnt(Genesys_Device* dev, unsigned int* words)
/** @brief Check if the scanner's internal data buffer is empty
* @param *dev device to test for data
* @param *empty return value
* @return empty will be set to SANE_TRUE if there is no scanned data.
* @return empty will be set to true if there is no scanned data.
**/
void sanei_genesys_test_buffer_empty(Genesys_Device* dev, SANE_Bool* empty)
void sanei_genesys_test_buffer_empty(Genesys_Device* dev, bool* empty)
{
DBG_HELPER(dbg);
uint8_t val = 0;
@ -784,11 +784,11 @@ void sanei_genesys_test_buffer_empty(Genesys_Device* dev, SANE_Bool* empty)
*/
sanei_genesys_sleep_ms(1);
DBG(DBG_io2, "%s: buffer is empty\n", __func__);
*empty = SANE_TRUE;
*empty = true;
return;
}
*empty = SANE_FALSE;
*empty = false;
DBG(DBG_io, "%s: buffer is filled\n", __func__);
}
@ -1903,12 +1903,12 @@ const SensorProfile& get_sensor_profile(AsicType asic_type, const Genesys_Sensor
* @param dev device to initialize
* @param max_regs umber of maximum used registers
*/
void sanei_genesys_asic_init(Genesys_Device* dev, int /*max_regs*/)
void sanei_genesys_asic_init(Genesys_Device* dev, bool /*max_regs*/)
{
DBG_HELPER(dbg);
uint8_t val;
SANE_Bool cold = SANE_TRUE;
bool cold = true;
// URB 16 control 0xc0 0x0c 0x8e 0x0b len 1 read 0x00 */
dev->usb_dev.control_msg(REQUEST_TYPE_IN, REQUEST_REGISTER, VALUE_GET_REGISTER, 0x00, 1, &val);
@ -1929,7 +1929,7 @@ void sanei_genesys_asic_init(Genesys_Device* dev, int /*max_regs*/)
so that following reads can detect power down/up cycle
*/
if (dev->read_register(0x06) & 0x10) {
cold = SANE_FALSE;
cold = false;
}
DBG (DBG_info, "%s: device is %s\n", __func__, cold ? "cold" : "warm");
@ -1958,10 +1958,10 @@ void sanei_genesys_asic_init(Genesys_Device* dev, int /*max_regs*/)
// Set analog frontend
dev->cmd_set->set_fe(dev, sensor, AFE_INIT);
dev->already_initialized = SANE_TRUE;
dev->already_initialized = true;
// Move to home if needed
dev->cmd_set->slow_back_home(dev, SANE_TRUE);
dev->cmd_set->slow_back_home(dev, true);
dev->scanhead_position_in_steps = 0;
// Set powersaving (default = 15 minutes)
@ -2014,7 +2014,7 @@ void sanei_genesys_wait_for_home(Genesys_Device* dev)
int max=300;
/* clear the parking status whatever the outcome of the function */
dev->parking=SANE_FALSE;
dev->parking = false;
// read initial status, if head isn't at home and motor is on we are parking, so we wait.
// gl847/gl124 need 2 reads for reliable results
@ -2238,7 +2238,7 @@ int sanei_genesys_get_lowest_dpi(Genesys_Device *dev)
/** @brief check is a cache entry may be used
* Compares current settings with the cache entry and return
* SANE_TRUE if they are compatible.
* true if they are compatible.
* A calibration cache is compatible if color mode and x dpi match the user
* requested scan. In the case of CIS scanners, dpi isn't a criteria.
* flatbed cache entries are considred too old and then expires if they
@ -2264,8 +2264,7 @@ bool sanei_genesys_is_compatible_calibration(Genesys_Device * dev, const Genesys
/* a calibration cache is compatible if color mode and x dpi match the user
* requested scan. In the case of CIS scanners, dpi isn't a criteria */
if (dev->model->is_cis == SANE_FALSE)
{
if (!dev->model->is_cis) {
compatible = (dev->settings.xres == ((int) cache->used_setup.xres));
}
else
@ -2296,11 +2295,11 @@ bool sanei_genesys_is_compatible_calibration(Genesys_Device * dev, const Genesys
/* a cache entry expires after afetr expiration time for non sheetfed scanners */
/* this is not taken into account when overwriting cache entries */
#ifdef HAVE_SYS_TIME_H
if(for_overwrite == SANE_FALSE && dev->settings.expiration_time >=0)
if (!for_overwrite && dev->settings.expiration_time >=0)
{
gettimeofday(&time, nullptr);
if ((time.tv_sec - cache->last_calibration > dev->settings.expiration_time*60)
&& (dev->model->is_sheetfed == SANE_FALSE)
&& !dev->model->is_sheetfed
&& (dev->settings.scan_method == ScanMethod::FLATBED))
{
DBG (DBG_proc, "%s: expired entry, non compatible cache\n", __func__);
@ -2445,8 +2444,9 @@ void sanei_genesys_load_lut(unsigned char* lut,
void sanei_genesys_usleep(unsigned int useconds)
{
if (sanei_usb_is_replay_mode_enabled() == SANE_TRUE)
return;
if (sanei_usb_is_replay_mode_enabled()) {
return;
}
usleep(useconds);
}

8
backend/genesys_low.h
Wyświetl plik

@ -348,7 +348,7 @@ void sanei_genesys_set_motor_power(Genesys_Register_Set& regs, bool set);
buffer_acceleration_steps, the number of steps for acceleration when buffer condition is met,
i.e. the number written to REG_FWDSTEP.
*/
void sanei_genesys_calculate_zmod(SANE_Bool two_table,
void sanei_genesys_calculate_zmod(bool two_table,
uint32_t exposure_time,
const std::vector<uint16_t>& slope_table,
unsigned acceleration_steps,
@ -384,7 +384,7 @@ SANE_Int sanei_genesys_generate_slope_table(std::vector<uint16_t>& slope_table,
SANE_Int sanei_genesys_create_slope_table(Genesys_Device * dev, std::vector<uint16_t>& slope_table,
int steps, int step_type, int exposure_time,
SANE_Bool same_speed, double yres);
bool same_speed, double yres);
SANE_Int sanei_genesys_create_slope_table3(Genesys_Device * dev,
std::vector<uint16_t>& slope_table, int max_step,
@ -418,7 +418,7 @@ void sanei_genesys_write_pnm_file(const char* filename, const Image& image);
extern void sanei_genesys_write_pnm_file16(const char* filename, const uint16_t *data, unsigned channels,
unsigned pixels_per_line, unsigned lines);
extern void sanei_genesys_test_buffer_empty(Genesys_Device* dev, SANE_Bool* empty);
void sanei_genesys_test_buffer_empty(Genesys_Device* dev, bool* empty);
extern void sanei_genesys_read_data_from_scanner(Genesys_Device* dev, uint8_t* data, size_t size);
@ -459,7 +459,7 @@ inline SensorExposure sanei_genesys_fixup_exposure(SensorExposure exposure)
extern void sanei_genesys_wait_for_home(Genesys_Device* dev);
extern void sanei_genesys_asic_init(Genesys_Device* dev, SANE_Bool cold);
extern void sanei_genesys_asic_init(Genesys_Device* dev, bool cold);
Motor_Profile* sanei_genesys_get_motor_profile(Motor_Profile *motors, MotorId motor_id,
int exposure);

174
backend/genesys_tables_model.cc
Wyświetl plik

@ -99,8 +99,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::BGR;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_UMAX;
model.adc_id = AdcId::WOLFSON_UMAX;
model.gpio_id = GpioId::UMAX;
@ -151,8 +151,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_35;
model.adc_id = AdcId::CANON_LIDE_35;
model.gpio_id = GpioId::CANON_LIDE_35;
@ -209,8 +209,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_KVSS080;
model.adc_id = AdcId::KVSS080;
model.gpio_id = GpioId::KVSS080;
@ -263,8 +263,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_G4050;
model.adc_id = AdcId::G4050;
model.gpio_id = GpioId::G4050;
@ -317,8 +317,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 48;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_G4050;
model.adc_id = AdcId::G4050;
model.gpio_id = GpioId::G4050;
@ -373,8 +373,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_G4050;
model.adc_id = AdcId::G4050;
model.gpio_id = GpioId::G4050;
@ -429,8 +429,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_CANON_4400F;
model.adc_id = AdcId::G4050;
model.gpio_id = GpioId::CANON_4400F;
@ -487,8 +487,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_CANON_8400F;
model.adc_id = AdcId::CANON_8400F;
model.gpio_id = GpioId::CANON_8400F;
@ -547,8 +547,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_CANON_8600F;
model.adc_id = AdcId::CANON_8600F;
model.gpio_id = GpioId::CANON_8600F;
@ -607,8 +607,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_100;
model.adc_id = AdcId::CANON_LIDE_200;
model.gpio_id = GpioId::CANON_LIDE_200;
@ -666,8 +666,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_110;
model.adc_id = AdcId::CANON_LIDE_110;
model.gpio_id = GpioId::CANON_LIDE_110;
@ -723,8 +723,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_g = 0;
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_120;
model.adc_id = AdcId::CANON_LIDE_120;
model.gpio_id = GpioId::CANON_LIDE_120;
@ -782,8 +782,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_210;
model.adc_id = AdcId::CANON_LIDE_110;
model.gpio_id = GpioId::CANON_LIDE_210;
@ -841,8 +841,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_220;
model.adc_id = AdcId::CANON_LIDE_110;
model.gpio_id = GpioId::CANON_LIDE_210;
@ -901,8 +901,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_200;
model.adc_id = AdcId::CANON_LIDE_200;
model.gpio_id = GpioId::CANON_LIDE_200;
@ -960,8 +960,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_700F;
model.adc_id = AdcId::CANON_LIDE_700F;
model.gpio_id = GpioId::CANON_LIDE_700F;
@ -1019,8 +1019,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_200;
model.adc_id = AdcId::CANON_LIDE_200;
model.gpio_id = GpioId::CANON_LIDE_200;
@ -1078,8 +1078,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_35;
model.adc_id = AdcId::CANON_LIDE_35;
model.gpio_id = GpioId::CANON_LIDE_35;
@ -1136,8 +1136,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = true;
model.is_sheetfed = false;
model.sensor_id = SensorId::CIS_CANON_LIDE_80;
model.adc_id = AdcId::CANON_LIDE_80;
model.gpio_id = GpioId::CANON_LIDE_80;
@ -1196,8 +1196,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_HP2300;
model.adc_id = AdcId::WOLFSON_HP2300;
model.gpio_id = GpioId::HP2300;
@ -1253,8 +1253,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_HP2400;
model.adc_id = AdcId::WOLFSON_HP2400;
model.gpio_id = GpioId::HP2400;
@ -1310,8 +1310,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CIS_XP200;
model.adc_id = AdcId::AD_XP200;
model.gpio_id = GpioId::XP200;
@ -1366,8 +1366,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_HP3670;
model.adc_id = AdcId::WOLFSON_HP3670;
model.gpio_id = GpioId::HP3670;
@ -1423,8 +1423,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::BGR;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_ST12;
model.adc_id = AdcId::WOLFSON_ST12;
model.gpio_id = GpioId::ST12;
@ -1474,8 +1474,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::BGR;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_ST24;
model.adc_id = AdcId::WOLFSON_ST24;
model.gpio_id = GpioId::ST24;
@ -1485,7 +1485,7 @@ void genesys_init_usb_device_tables()
GENESYS_FLAG_CUSTOM_GAMMA |
GENESYS_FLAG_SEARCH_START |
GENESYS_FLAG_OFFSET_CALIBRATION;
model.buttons = GENESYS_HAS_NO_BUTTONS,
model.buttons = GENESYS_HAS_NO_BUTTONS;
model.shading_lines = 20;
model.shading_ta_lines = 0;
model.search_lines = 200;
@ -1528,8 +1528,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_5345;
model.adc_id = AdcId::WOLFSON_5345;
model.gpio_id = GpioId::MD_5345;
@ -1589,8 +1589,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_XP300;
model.adc_id = AdcId::WOLFSON_XP300;
model.gpio_id = GpioId::XP300;
@ -1643,8 +1643,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_DP665;
model.adc_id = AdcId::WOLFSON_XP300;
model.gpio_id = GpioId::DP665;
@ -1697,8 +1697,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_ROADWARRIOR;
model.adc_id = AdcId::WOLFSON_XP300;
model.gpio_id = GpioId::DP665;
@ -1751,8 +1751,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_ROADWARRIOR;
model.adc_id = AdcId::WOLFSON_XP300;
model.gpio_id = GpioId::DP665;
@ -1806,8 +1806,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_ROADWARRIOR;
model.adc_id = AdcId::WOLFSON_XP300;
model.gpio_id = GpioId::DP665;
@ -1860,8 +1860,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_DSMOBILE600;
model.adc_id = AdcId::WOLFSON_DSM600;
model.gpio_id = GpioId::DP665;
@ -1915,8 +1915,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_DSMOBILE600;
model.adc_id = AdcId::WOLFSON_DSM600;
model.gpio_id = GpioId::DP665;
@ -1969,8 +1969,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_DP685;
model.adc_id = AdcId::WOLFSON_DSM600;
model.gpio_id = GpioId::DP685;
@ -2025,8 +2025,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_XP300;
model.adc_id = AdcId::WOLFSON_XP300;
model.gpio_id = GpioId::XP300;
@ -2080,8 +2080,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_XP300;
model.adc_id = AdcId::WOLFSON_XP300;
model.gpio_id = GpioId::XP300;
@ -2135,8 +2135,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_5345;
model.adc_id = AdcId::WOLFSON_5345;
model.gpio_id = GpioId::MD_5345;
@ -2195,8 +2195,8 @@ void genesys_init_usb_device_tables()
model.ld_shift_b = 0;
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_5345;
model.adc_id = AdcId::WOLFSON_5345;
model.gpio_id = GpioId::MD_5345;
@ -2256,8 +2256,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_TRUE;
model.is_sheetfed = SANE_TRUE;
model.is_cis = true;
model.is_sheetfed = true;
model.sensor_id = SensorId::CCD_ROADWARRIOR;
model.adc_id = AdcId::WOLFSON_XP300;
model.gpio_id = GpioId::DP665;
@ -2310,8 +2310,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_PLUSTEK_OPTICPRO_3600;
model.adc_id = AdcId::PLUSTEK_OPTICPRO_3600;
model.gpio_id = GpioId::PLUSTEK_OPTICPRO_3600;
@ -2427,8 +2427,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_HP_N6310;
model.adc_id = AdcId::CANON_LIDE_200; // Not defined yet for N6310
model.gpio_id = GpioId::HP_N6310;
@ -2486,8 +2486,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_PLUSTEK_OPTICBOOK_3800;
model.adc_id = AdcId::PLUSTEK_OPTICBOOK_3800;
model.gpio_id = GpioId::PLUSTEK_OPTICBOOK_3800;
@ -2540,8 +2540,8 @@ void genesys_init_usb_device_tables()
model.line_mode_color_order = ColorOrder::RGB;
model.is_cis = SANE_FALSE;
model.is_sheetfed = SANE_FALSE;
model.is_cis = false;
model.is_sheetfed = false;
model.sensor_id = SensorId::CCD_IMG101;
model.adc_id = AdcId::IMG101;
model.gpio_id = GpioId::IMG101;