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

genesys: Resolve various floating-point conversion warnings

merge-requests/215/head
Povilas Kanapickas 2019-10-13 06:18:51 +03:00
rodzic f4a2957541
commit 0ab82e9f86
10 zmienionych plików z 256 dodań i 250 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

83
backend/genesys/genesys.cpp
Wyświetl plik

@ -372,8 +372,8 @@ SANE_Int sanei_genesys_generate_slope_table(std::vector<uint16_t>& slope_table,
t2 = vstart;
for (i = 0; i < steps && i < use_steps - 1 && i < max_steps; i++, c++)
{
t = std::pow(static_cast<double>(i) / static_cast<double>(steps - 1), g);
t2 = vstart * (1 - t) + t * vend;
t = std::pow(static_cast<double>(i) / static_cast<double>(steps - 1), g);
t2 = static_cast<std::uint16_t>(vstart * (1 - t) + t * vend);
if (t2 < stop_at) {
break;
}
@ -448,7 +448,7 @@ SANE_Int sanei_genesys_create_slope_table3(Genesys_Device * dev,
step_type, exposure_time, yres);
/* final speed */
vtarget = (exposure_time * yres) / dev->motor.base_ydpi;
vtarget = static_cast<unsigned>((exposure_time * yres) / dev->motor.base_ydpi);
vstart = dev->motor.slopes[step_type].maximum_start_speed;
vend = dev->motor.slopes[step_type].maximum_speed;
@ -476,8 +476,9 @@ SANE_Int sanei_genesys_create_slope_table3(Genesys_Device * dev,
used_steps,
&vfinal);
if (final_exposure)
*final_exposure = (vfinal * dev->motor.base_ydpi) / yres;
if (final_exposure) {
*final_exposure = static_cast<unsigned>((vfinal * dev->motor.base_ydpi) / yres);
}
DBG(DBG_proc, "%s: returns sum_time=%d, completed\n", __func__, sum_time);
@ -510,20 +511,21 @@ SANE_Int genesys_create_slope_table2(Genesys_Device* dev, std::vector<uint16_t>&
}
else
{
if (steps == 2)
vstart = exposure_time;
else if (steps == 3)
vstart = 2 * exposure_time;
else if (steps == 4)
vstart = 1.5 * exposure_time;
else if (steps == 120)
vstart = 1.81674 * exposure_time;
else
vstart = exposure_time;
if (steps == 2) {
vstart = exposure_time;
} else if (steps == 3) {
vstart = 2 * exposure_time;
} else if (steps == 4) {
vstart = static_cast<int>(1.5 * exposure_time);
} else if (steps == 120) {
vstart = static_cast<int>(1.81674 * exposure_time);
} else {
vstart = exposure_time;
}
}
/* final speed */
vend = (exposure_time * yres) / (dev->motor.base_ydpi * (1 << step_type));
vend = static_cast<int>((exposure_time * yres) / (dev->motor.base_ydpi * (1 << step_type)));
/*
type=1 : full
@ -585,7 +587,7 @@ SANE_Int genesys_create_slope_table2(Genesys_Device* dev, std::vector<uint16_t>&
for (i = 0; i < steps; i++)
{
t = std::pow(static_cast<double>(i) / static_cast<double>(steps - 1), g);
slope_table[i] = vstart * (1 - t) + t * vend;
slope_table[i] = static_cast<std::uint16_t>(vstart * (1 - t) + t * vend);
DBG (DBG_io, "slope_table[%3d] = %5d\n", i, slope_table[i]);
sum += slope_table[i];
}
@ -789,10 +791,11 @@ sanei_genesys_create_gamma_table (std::vector<uint16_t>& gamma_table, int size,
maximum, gamma_max, gamma);
for (i = 0; i < size; i++)
{
value = gamma_max * std::pow(static_cast<double>(i) / size, 1.0 / gamma);
if (value > maximum)
value = maximum;
gamma_table[i] = value;
value = static_cast<float>(gamma_max * std::pow(static_cast<double>(i) / size, 1.0 / gamma));
if (value > maximum) {
value = maximum;
}
gamma_table[i] = static_cast<std::uint16_t>(value);
}
DBG(DBG_proc, "%s: completed\n", __func__);
}
@ -832,7 +835,8 @@ sanei_genesys_exposure_time2 (Genesys_Device * dev, float ydpi,
int step_type, int endpixel, int exposure_by_led)
{
int exposure_by_ccd = endpixel + 32;
int exposure_by_motor = (dev->motor.slopes[step_type].maximum_speed * dev->motor.base_ydpi) / ydpi;
int exposure_by_motor = static_cast<int>((dev->motor.slopes[step_type].maximum_speed *
dev->motor.base_ydpi) / ydpi);
int exposure = exposure_by_ccd;
@ -1295,7 +1299,6 @@ genesys_average_black (Genesys_Device * dev, int channel,
static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sensor)
{
DBG_HELPER_ARGS(dbg, "scan_mode = %d", static_cast<unsigned>(dev->settings.scan_mode));
int size;
int black_pixels;
int white_average;
uint8_t offset[4] = { 0xa0, 0x00, 0xa0, 0x40 }; /* first value isn't used */
@ -1309,7 +1312,8 @@ static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sens
DBG(DBG_info, "channels %d y_size %f xres %d\n", channels, dev->model->y_size.value(),
dev->settings.xres);
size = channels * 2 * dev->model->y_size * dev->settings.xres / 25.4;
unsigned size = static_cast<unsigned>(channels * 2 * dev->model->y_size * dev->settings.xres /
MM_PER_INCH);
/* 1 1 mm 1/inch inch/mm */
std::vector<uint8_t> calibration_data(size);
@ -2754,7 +2758,8 @@ static void genesys_flatbed_calibration(Genesys_Device* dev, Genesys_Sensor& sen
/* we always use sensor pixel number when the ASIC can't handle multi-segments sensor */
if (!(dev->model->flags & GENESYS_FLAG_SIS_SENSOR))
{
pixels_per_line = (dev->model->x_size * dev->settings.xres) / MM_PER_INCH;
pixels_per_line = static_cast<std::uint32_t>((dev->model->x_size * dev->settings.xres) /
MM_PER_INCH);
}
else
{
@ -3027,7 +3032,7 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
if (dev->session.params.depth == 16) {
first_average /= pixel;
second_average /= pixel;
difference = fabs (first_average - second_average);
difference = static_cast<int>(std::fabs(first_average - second_average));
DBG(DBG_info, "%s: average = %.2f, diff = %.3f\n", __func__,
100 * ((second_average) / (256 * 256)),
100 * (difference / second_average));
@ -3428,7 +3433,9 @@ static void calc_parameters(Genesys_Scanner* s)
const auto& sensor = sanei_genesys_find_sensor_any(s->dev);
// hardware settings
if (s->resolution > sensor.optical_res && s->dev->settings.disable_interpolation) {
if (static_cast<unsigned>(s->resolution) > sensor.optical_res &&
s->dev->settings.disable_interpolation)
{
s->dev->settings.xres = sensor.optical_res;
} else {
s->dev->settings.xres = s->resolution;
@ -3438,8 +3445,10 @@ static void calc_parameters(Genesys_Scanner* s)
s->dev->settings.xres = pick_resolution(s->dev->model->xdpi_values, s->dev->settings.xres, "X");
s->dev->settings.yres = pick_resolution(s->dev->model->ydpi_values, s->dev->settings.yres, "Y");
s->params.lines = ((br_y - tl_y) * s->dev->settings.yres) / MM_PER_INCH;
unsigned pixels_per_line = ((br_x - tl_x) * s->dev->settings.xres) / MM_PER_INCH;
s->params.lines = static_cast<unsigned>(((br_y - tl_y) * s->dev->settings.yres) /
MM_PER_INCH);
unsigned pixels_per_line = static_cast<unsigned>(((br_x - tl_x) * s->dev->settings.xres) /
MM_PER_INCH);
/* we need an even pixels number
* TODO invert test logic or generalize behaviour across all ASICs */
@ -3526,7 +3535,7 @@ static void calc_parameters(Genesys_Scanner* s)
s->dev->settings.tl_y = tl_y;
// threshold setting
s->dev->settings.threshold = 2.55 * (SANE_UNFIX(s->threshold));
s->dev->settings.threshold = static_cast<int>(2.55 * (SANE_UNFIX(s->threshold)));
// color filter
if (s->color_filter == "Red") {
@ -3845,12 +3854,12 @@ static void init_options(Genesys_Scanner* s)
s->opt[OPT_GEOMETRY_GROUP].size = 0;
s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
x_range = create_range(model->x_size);
x_range = create_range(static_cast<float>(model->x_size));
if (x_range == nullptr) {
throw SaneException(SANE_STATUS_NO_MEM);
}
y_range = create_range(model->y_size);
y_range = create_range(static_cast<float>(model->y_size));
if (y_range == nullptr) {
throw SaneException(SANE_STATUS_NO_MEM);
}
@ -4569,7 +4578,7 @@ static void genesys_buffer_image(Genesys_Scanner *s)
}
else
{
lines = (dev->model->y_size * dev->settings.yres) / MM_PER_INCH;
lines = static_cast<int>((dev->model->y_size * dev->settings.yres) / MM_PER_INCH);
}
DBG(DBG_info, "%s: buffering %d lines of %d bytes\n", __func__, lines,
s->params.bytes_per_line);
@ -5362,13 +5371,13 @@ set_option_value (Genesys_Scanner * s, int option, void *val,
// change geometry constraint to the new source value
if (s->source == STR_FLATBED)
{
x_range=create_range(s->dev->model->x_size);
y_range=create_range(s->dev->model->y_size);
x_range = create_range(static_cast<float>(s->dev->model->x_size));
y_range = create_range(static_cast<float>(s->dev->model->y_size));
}
else
{
x_range=create_range(s->dev->model->x_size_ta);
y_range=create_range(s->dev->model->y_size_ta);
x_range = create_range(static_cast<float>(s->dev->model->x_size_ta));
y_range = create_range(static_cast<float>(s->dev->model->y_size_ta));
}
if (x_range == nullptr || y_range == nullptr) {
return SANE_STATUS_NO_MEM;

40
backend/genesys/gl124.cpp
Wyświetl plik

@ -1006,9 +1006,9 @@ void CommandSetGl124::calculate_current_setup(Genesys_Device * dev,
debug_dump(DBG_info, dev->settings);
/* start */
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<int>(dev->model->x_offset);
start += static_cast<int>(dev->settings.tl_x);
start = static_cast<int>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
@ -1275,7 +1275,6 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
Genesys_Register_Set local_reg;
GenesysRegister *r;
uint8_t val;
float resolution;
int loop = 0;
// post scan gpio : without that HOMSNR is unreliable
@ -1312,7 +1311,7 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
}
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_dpi(dev);
unsigned resolution = sanei_genesys_get_lowest_dpi(dev);
const auto& sensor = sanei_genesys_find_sensor_any(dev);
@ -1396,13 +1395,12 @@ static void gl124_feed(Genesys_Device* dev, unsigned int steps, int reverse)
DBG_HELPER_ARGS(dbg, "steps=%d", steps);
Genesys_Register_Set local_reg;
GenesysRegister *r;
float resolution;
uint8_t val;
/* prepare local registers */
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_ydpi(dev);
unsigned resolution = sanei_genesys_get_lowest_ydpi(dev);
const auto& sensor = sanei_genesys_find_sensor(dev, resolution, 3, dev->model->default_method);
ScanSession session;
@ -1611,8 +1609,8 @@ void CommandSetGl124::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
/* distance to move to reach white target at high resolution */
move=0;
if (dev->settings.yres >= 1200) {
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
move = static_cast<int>(dev->model->y_offset_calib_white);
move = static_cast<int>((move * (dev->motor.base_ydpi/4)) / MM_PER_INCH);
}
DBG (DBG_io, "%s: move=%d steps\n", __func__, move);
@ -1679,28 +1677,28 @@ void CommandSetGl124::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
/* y (motor) distance to move to reach scanned area */
move_dpi = dev->motor.base_ydpi/4;
move = dev->model->y_offset;
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
move = static_cast<float>(dev->model->y_offset);
move += static_cast<float>(dev->settings.tl_y);
move = static_cast<float>((move * move_dpi) / MM_PER_INCH);
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, false);
gl124_feed(dev, static_cast<unsigned>(move - 500), false);
move=500;
}
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = static_cast<float>(dev->model->x_offset);
start += static_cast<float>(dev->settings.tl_x);
start /= sensor.get_ccd_size_divisor_for_dpi(dev->settings.xres);
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<float>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = start;
session.params.starty = move;
session.params.startx = static_cast<unsigned>(start);
session.params.starty = static_cast<unsigned>(move);
session.params.pixels = dev->settings.pixels;
session.params.requested_pixels = dev->settings.requested_pixels;
session.params.lines = dev->settings.lines;
@ -2223,9 +2221,9 @@ void CommandSetGl124::coarse_gain_calibration(Genesys_Device* dev, const Genesys
if(dev->settings.xres<sensor.optical_res)
{
coeff=0.9;
coeff = 0.9f;
} else {
coeff=1.0;
coeff = 1.0f;
}
lines=10;
pixels = (sensor.sensor_pixels * sensor.optical_res) / sensor.optical_res;
@ -2291,7 +2289,7 @@ void CommandSetGl124::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gain[j] = (static_cast<float>(sensor.gain_white_ref) * coeff) / max[j];
/* turn logical gain value into gain code, checking for overflow */
code = 283 - 208 / gain[j];
code = static_cast<int>(283 - 208 / gain[j]);
if (code > 255)
code = 255;
else if (code < 0)

34
backend/genesys/gl646.cpp
Wyświetl plik

@ -1393,8 +1393,8 @@ void CommandSetGl646::detect_document_end(Genesys_Device* dev) const
unsigned lines_in_buffer = bytes_left / dev->session.output_line_bytes_raw;
// we add the number of lines needed to read the last part of the document in
unsigned lines_offset = (dev->model->y_offset * dev->session.params.yres) /
MM_PER_INCH;
unsigned lines_offset = static_cast<unsigned>(
(dev->model->y_offset * dev->session.params.yres) / MM_PER_INCH);
unsigned remaining_lines = lines_in_buffer + lines_offset;
@ -1991,36 +1991,36 @@ static void setup_for_scan(Genesys_Device* dev,
if (!split) {
if (!dev->model->is_sheetfed) {
if (ycorrection) {
move = dev->model->y_offset;
move = static_cast<float>(dev->model->y_offset);
}
// add tl_y to base movement
}
move += settings.tl_y;
move += static_cast<float>(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;
move = static_cast<float>((move * dev->motor.optical_ydpi) / MM_PER_INCH);
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
float start = settings.tl_x;
float start = static_cast<float>(settings.tl_x);
if (xcorrection) {
if (settings.scan_method == ScanMethod::FLATBED) {
start += dev->model->x_offset;
start += static_cast<float>(dev->model->x_offset);
} else {
start += dev->model->x_offset_ta;
start += static_cast<float>(dev->model->x_offset_ta);
}
}
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<float>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = settings.xres;
session.params.yres = settings.yres;
session.params.startx = start;
session.params.starty = move;
session.params.startx = static_cast<unsigned>(start);
session.params.starty = static_cast<unsigned>(move);
session.params.pixels = settings.pixels;
session.params.requested_pixels = settings.requested_pixels;
session.params.lines = settings.lines;
@ -2654,7 +2654,7 @@ void CommandSetGl646::coarse_gain_calibration(Genesys_Device* dev, const Genesys
else
{
settings.tl_x = dev->model->x_offset_ta;
settings.pixels = (dev->model->x_size_ta * resolution) / MM_PER_INCH;
settings.pixels = static_cast<unsigned>((dev->model->x_size_ta * resolution) / MM_PER_INCH);
}
settings.requested_pixels = settings.pixels;
settings.lines = CALIBRATION_LINES;
@ -2729,7 +2729,7 @@ void CommandSetGl646::coarse_gain_calibration(Genesys_Device* dev, const Genesys
}
/* threshold */
maximum *= 0.9;
maximum = static_cast<int>(maximum * 0.9);
/* computes white average */
average[k] = 0;
@ -3045,7 +3045,7 @@ void CommandSetGl646::move_to_ta(Genesys_Device* dev) const
{
DBG_HELPER(dbg);
simple_move(dev, dev->model->y_offset_sensor_to_ta);
simple_move(dev, static_cast<int>(dev->model->y_offset_sensor_to_ta));
}
@ -3218,7 +3218,7 @@ static void simple_move(Genesys_Device* dev, SANE_Int distance)
settings.tl_x = 0;
settings.pixels = (sensor.sensor_pixels * settings.xres) / sensor.optical_res;
settings.requested_pixels = settings.pixels;
settings.lines = (distance * settings.xres) / MM_PER_INCH;
settings.lines = static_cast<unsigned>((distance * settings.xres) / MM_PER_INCH);
settings.depth = 8;
settings.color_filter = ColorFilter::RED;
@ -3507,12 +3507,12 @@ void CommandSetGl646::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
settings.yres = res;
settings.tl_x = 0;
settings.tl_y = 0;
settings.pixels = (dev->model->x_size * res) / MM_PER_INCH;
settings.pixels = static_cast<unsigned>((dev->model->x_size * res) / MM_PER_INCH);
settings.pixels /= calib_sensor.get_ccd_size_divisor_for_dpi(res);
settings.requested_pixels = settings.pixels;
/* 15 mm at at time */
settings.lines = (15 * settings.yres) / MM_PER_INCH; /* may become a parameter from genesys_devices.c */
settings.lines = static_cast<unsigned>((15 * settings.yres) / MM_PER_INCH);
settings.depth = 8;
settings.color_filter = ColorFilter::RED;

142
backend/genesys/gl646.h
Wyświetl plik

@ -149,88 +149,88 @@ typedef struct
*/
static Motor_Master motor_master[] = {
/* HP3670 motor settings */
{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},
{MotorId::HP3670, 75, 3, StepType::FULL, false, true , 1, 200, 3429, 305, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 100, 3, StepType::HALF, false, true , 1, 143, 2905, 187, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 150, 3, StepType::HALF, false, true , 1, 73, 3429, 305, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 300, 3, StepType::HALF, false, true , 1, 11, 1055, 563, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 600, 3, StepType::FULL, false, true , 0, 3, 10687, 5126, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670,1200, 3, StepType::HALF, false, true , 0, 3, 15937, 6375, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670,2400, 3, StepType::HALF, false, true , 0, 3, 15937, 12750,192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 75, 1, StepType::FULL, false, true , 1, 200, 3429, 305, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 100, 1, StepType::HALF, false, true , 1, 143, 2905, 187, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 150, 1, StepType::HALF, false, true , 1, 73, 3429, 305, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 300, 1, StepType::HALF, false, true , 1, 11, 1055, 563, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670, 600, 1, StepType::FULL, false, true , 0, 3, 10687, 5126, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670,1200, 1, StepType::HALF, false, true , 0, 3, 15937, 6375, 192, 3399, 337, 0.3f, 0.4f, 192},
{MotorId::HP3670,2400, 3, StepType::HALF, false, true , 0, 3, 15937, 12750,192, 3399, 337, 0.3f, 0.4f, 192},
/* HP2400/G2410 motor settings base motor dpi = 600 */
{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},
{MotorId::HP2400, 50, 3, StepType::FULL, false, true , 63, 120, 8736, 601, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400, 100, 3, StepType::HALF, false, true, 63, 120, 8736, 601, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400, 150, 3, StepType::HALF, false, true , 63, 67, 15902, 902, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400, 300, 3, StepType::HALF, false, true , 63, 32, 16703, 2188, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400, 600, 3, StepType::FULL, false, true , 63, 3, 18761, 18761, 192, 4905, 627, 0.3f, 0.4f, 192},
{MotorId::HP2400,1200, 3, StepType::HALF, false, true , 63, 3, 43501, 43501, 192, 4905, 627, 0.3f, 0.4f, 192},
{MotorId::HP2400, 50, 1, StepType::FULL, false, true , 63, 120, 8736, 601, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400, 100, 1, StepType::HALF, false, true, 63, 120, 8736, 601, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400, 150, 1, StepType::HALF, false, true , 63, 67, 15902, 902, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400, 300, 1, StepType::HALF, false, true , 63, 32, 16703, 2188, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400, 600, 1, StepType::FULL, false, true , 63, 3, 18761, 18761, 192, 4905, 337, 0.3f, 0.4f, 192},
{MotorId::HP2400,1200, 1, StepType::HALF, false, true , 63, 3, 43501, 43501, 192, 4905, 337, 0.3f, 0.4f, 192},
/* XP 200 motor settings */
{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},
{MotorId::XP200, 75, 3, StepType::HALF, true , false, 0, 4, 6000, 2136, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 100, 3, StepType::HALF, true , false, 0, 4, 6000, 2850, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 200, 3, StepType::HALF, true , false, 0, 4, 6999, 5700, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 250, 3, StepType::HALF, true , false, 0, 4, 6999, 6999, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 300, 3, StepType::HALF, true , false, 0, 4, 13500, 13500, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 600, 3, StepType::HALF, true , true, 0, 4, 31998, 31998, 2, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 75, 1, StepType::HALF, true , false, 0, 4, 6000, 2000, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 100, 1, StepType::HALF, true , false, 0, 4, 6000, 1300, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 200, 1, StepType::HALF, true , true, 0, 4, 6000, 3666, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 300, 1, StepType::HALF, true , false, 0, 4, 6500, 6500, 8, 12000, 1200, 0.3f, 0.5f, 1},
{MotorId::XP200, 600, 1, StepType::HALF, true , true, 0, 4, 24000, 24000, 2, 12000, 1200, 0.3f, 0.5f, 1},
/* HP scanjet 2300c */
{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},
{MotorId::HP2300, 75, 3, StepType::FULL, false, true , 63, 120, 8139, 560, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300, 150, 3, StepType::HALF, false, true , 63, 67, 7903, 543, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300, 300, 3, StepType::HALF, false, true , 63, 3, 2175, 1087, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300, 600, 3, StepType::HALF, false, true , 63, 3, 8700, 4350, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300,1200, 3, StepType::HALF, false, true , 63, 3, 17400, 8700, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300, 75, 1, StepType::FULL, false, true , 63, 120, 8139, 560, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300, 150, 1, StepType::HALF, false, true , 63, 67, 7903, 543, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300, 300, 1, StepType::HALF, false, true , 63, 3, 2175, 1087, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300, 600, 1, StepType::HALF, false, true , 63, 3, 8700, 4350, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300,1200, 1, StepType::HALF, false, true , 63, 3, 17400, 8700, 120, 4905, 337, 0.3f, 0.4f, 16},
/* non half ccd settings for 300 dpi
{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},
{MotorId::HP2300, 300, 3, StepType::HALF, false, true , 63, 44, 5386, 2175, 120, 4905, 337, 0.3f, 0.4f, 16},
{MotorId::HP2300, 300, 1, StepType::HALF, false, true , 63, 44, 5386, 2175, 120, 4905, 337, 0.3f, 0.4f, 16},
*/
/* MD5345/6471 motor settings */
/* vfinal=(exposure/(1200/dpi))/step_type */
{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 */
{MotorId::MD_5345, 50, 3, StepType::HALF , false, true , 2, 255, 2500, 250, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 75, 3, StepType::HALF , false, true , 2, 255, 2500, 343, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 100, 3, StepType::HALF , false, true , 2, 255, 2500, 458, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 150, 3, StepType::HALF , false, true , 2, 255, 2500, 687, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 200, 3, StepType::HALF , false, true , 2, 255, 2500, 916, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 300, 3, StepType::HALF , false, true , 2, 255, 2500, 1375, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 400, 3, StepType::HALF , false, true , 0, 32, 2000, 1833, 255, 2000, 300, 0.3f, 0.4f, 32},
{MotorId::MD_5345, 500, 3, StepType::HALF , false, true , 0, 32, 2291, 2291, 255, 2000, 300, 0.3f, 0.4f, 32},
{MotorId::MD_5345, 600, 3, StepType::HALF , false, true , 0, 32, 2750, 2750, 255, 2000, 300, 0.3f, 0.4f, 32},
{MotorId::MD_5345, 1200, 3, StepType::QUARTER, false, true , 0, 16, 2750, 2750, 255, 2000, 300, 0.3f, 0.4f, 146},
{MotorId::MD_5345, 2400, 3, StepType::QUARTER, false, true , 0, 16, 5500, 5500, 255, 2000, 300, 0.3f, 0.4f, 146},
{MotorId::MD_5345, 50, 1, StepType::HALF , false, true , 2, 255, 2500, 250, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 75, 1, StepType::HALF , false, true , 2, 255, 2500, 343, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 100, 1, StepType::HALF , false, true , 2, 255, 2500, 458, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 150, 1, StepType::HALF , false, true , 2, 255, 2500, 687, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 200, 1, StepType::HALF , false, true , 2, 255, 2500, 916, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 300, 1, StepType::HALF , false, true , 2, 255, 2500, 1375, 255, 2000, 300, 0.3f, 0.4f, 64},
{MotorId::MD_5345, 400, 1, StepType::HALF , false, true , 0, 32, 2000, 1833, 255, 2000, 300, 0.3f, 0.4f, 32},
{MotorId::MD_5345, 500, 1, StepType::HALF , false, true , 0, 32, 2291, 2291, 255, 2000, 300, 0.3f, 0.4f, 32},
{MotorId::MD_5345, 600, 1, StepType::HALF , false, true , 0, 32, 2750, 2750, 255, 2000, 300, 0.3f, 0.4f, 32},
{MotorId::MD_5345, 1200, 1, StepType::QUARTER, false, true , 0, 16, 2750, 2750, 255, 2000, 300, 0.3f, 0.4f, 146},
{MotorId::MD_5345, 2400, 1, StepType::QUARTER, false, true , 0, 16, 5500, 5500, 255, 2000, 300, 0.3f, 0.4f, 146}, /* 5500 guessed */
};
class CommandSetGl646 : public CommandSet

55
backend/genesys/gl841.cpp
Wyświetl plik

@ -1795,11 +1795,10 @@ void CommandSetGl841::calculate_current_setup(Genesys_Device * dev,
debug_dump(DBG_info, dev->settings);
/* start */
start = dev->model->x_offset;
start = static_cast<int>(dev->model->x_offset);
start += static_cast<int>(dev->settings.tl_x);
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<int>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
@ -2175,10 +2174,10 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
}
}
feed_mm = dev->model->eject_feed;
feed_mm = static_cast<float>(dev->model->eject_feed);
if (dev->document)
{
feed_mm += dev->model->post_scan;
feed_mm += static_cast<float>(dev->model->post_scan);
}
sanei_genesys_read_feed_steps(dev, &init_steps);
@ -2268,8 +2267,8 @@ void CommandSetGl841::detect_document_end(Genesys_Device* dev) const
std::size_t output_lines = dev->session.output_line_count;
std::size_t offset_lines = (dev->model->post_scan / MM_PER_INCH) *
dev->settings.yres;
std::size_t offset_lines = static_cast<std::size_t>(
(dev->model->post_scan / MM_PER_INCH) * dev->settings.yres);
std::size_t scan_end_lines = scanned_lines + offset_lines;
@ -2631,7 +2630,7 @@ void CommandSetGl841::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
{
DBG_HELPER_ARGS(dbg, "lines = %zu", dev->calib_lines);
SANE_Int ydpi;
float starty=0;
unsigned starty = 0;
/* initial calibration reg values */
regs = dev->reg;
@ -2726,25 +2725,25 @@ void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
move = 0;
if (dev->model->flags & GENESYS_FLAG_SEARCH_START) {
move += dev->model->y_offset_calib_white;
move += static_cast<float>(dev->model->y_offset_calib_white);
}
DBG(DBG_info, "%s move=%f steps\n", __func__, move);
move += dev->model->y_offset;
move += static_cast<float>(dev->model->y_offset);
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
move += dev->settings.tl_y;
move += static_cast<float>(dev->settings.tl_y);
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
move = (move * move_dpi) / MM_PER_INCH;
move = static_cast<float>((move * move_dpi) / MM_PER_INCH);
/* start */
start = dev->model->x_offset;
start = static_cast<float>(dev->model->x_offset);
start += dev->settings.tl_x;
start += static_cast<float>(dev->settings.tl_x);
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<float>((start * sensor.optical_res) / MM_PER_INCH);
/* we enable true gray for cis scanners only, and just when doing
* scan since color calibration is OK for this mode
@ -2764,8 +2763,8 @@ void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = start;
session.params.starty = move;
session.params.startx = static_cast<unsigned>(start);
session.params.starty = static_cast<unsigned>(move);
session.params.pixels = dev->settings.pixels;
session.params.requested_pixels = dev->settings.requested_pixels;
session.params.lines = dev->settings.lines;
@ -2827,8 +2826,8 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
/* feed to white strip if needed */
if (dev->model->y_offset_calib_white > 0) {
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi)) / MM_PER_INCH;
move = static_cast<int>(dev->model->y_offset_calib_white);
move = static_cast<int>((move * (dev->motor.base_ydpi)) / MM_PER_INCH);
DBG(DBG_io, "%s: move=%d lines\n", __func__, move);
gl841_feed(dev, move);
}
@ -3520,8 +3519,8 @@ void CommandSetGl841::coarse_gain_calibration(Genesys_Device* dev, const Genesys
// feed to white strip if needed
if (dev->model->y_offset_calib_white > 0) {
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi)) / MM_PER_INCH;
move = static_cast<int>(dev->model->y_offset_calib_white);
move = static_cast<int>((move * (dev->motor.base_ydpi)) / MM_PER_INCH);
DBG(DBG_io, "%s: move=%d lines\n", __func__, move);
gl841_feed(dev, move);
}
@ -3590,7 +3589,7 @@ void CommandSetGl841::coarse_gain_calibration(Genesys_Device* dev, const Genesys
max[j] = val;
}
gain[j] = 65535.0/max[j];
gain[j] = 65535.0f / max[j];
uint8_t out_gain = 0;
@ -3598,15 +3597,15 @@ void CommandSetGl841::coarse_gain_calibration(Genesys_Device* dev, const Genesys
dev->model->adc_id == AdcId::WOLFSON_XP300 ||
dev->model->adc_id == AdcId::WOLFSON_DSM600)
{
gain[j] *= 0.69;/*seems we don't get the real maximum. empirically derived*/
gain[j] *= 0.69f; // seems we don't get the real maximum. empirically derived
if (283 - 208/gain[j] > 255)
out_gain = 255;
else if (283 - 208/gain[j] < 0)
out_gain = 0;
else
out_gain = 283 - 208/gain[j];
out_gain = static_cast<std::uint8_t>(283 - 208 / gain[j]);
} else if (dev->model->adc_id == AdcId::CANON_LIDE_80) {
out_gain = gain[j]*12;
out_gain = static_cast<std::uint8_t>(gain[j] * 12);
}
dev->frontend.set_gain(j, out_gain);
@ -3955,12 +3954,12 @@ void CommandSetGl841::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
/* shading calibation is done with dev->motor.base_ydpi */
/* lines = (dev->model->shading_lines * dpi) / dev->motor.base_ydpi; */
lines = (10*dpi)/MM_PER_INCH;
lines = static_cast<unsigned>((10 * dpi) / MM_PER_INCH);
pixels = (sensor.sensor_pixels * dpi) / sensor.optical_res;
/* 20 cm max length for calibration sheet */
length = ((200 * dpi) / MM_PER_INCH)/lines;
length = static_cast<unsigned>(((200 * dpi) / MM_PER_INCH) / lines);
dev->scanhead_position_in_steps = 0;

60
backend/genesys/gl843.cpp
Wyświetl plik

@ -1322,9 +1322,9 @@ void CommandSetGl843::calculate_current_setup(Genesys_Device * dev,
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{
start = dev->model->x_offset_ta;
start = static_cast<int>(dev->model->x_offset_ta);
} else {
start = dev->model->x_offset;
start = static_cast<int>(dev->model->x_offset);
}
if (dev->model->model_id == ModelId::CANON_8400F ||
@ -1334,8 +1334,8 @@ void CommandSetGl843::calculate_current_setup(Genesys_Device * dev,
start /= ccd_size_divisor;
}
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
start += static_cast<int>(dev->settings.tl_x);
start = static_cast<int>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
@ -1527,8 +1527,8 @@ void CommandSetGl843::detect_document_end(Genesys_Device* dev) const
std::size_t output_lines = dev->session.output_line_count;
std::size_t offset_lines = (dev->model->post_scan * dev->session.params.yres) /
MM_PER_INCH;
std::size_t offset_lines = static_cast<std::size_t>(
(dev->model->post_scan * dev->session.params.yres) / MM_PER_INCH);
std::size_t scan_end_lines = scanned_lines + offset_lines;
@ -2238,16 +2238,16 @@ void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
dev->model->model_id == ModelId::CANON_8600F &&
dev->settings.xres == 4800)
{
float offset = dev->model->x_offset_ta;
float offset = static_cast<float>(dev->model->x_offset_ta);
offset /= calib_sensor.get_ccd_size_divisor_for_dpi(resolution);
offset = (offset * calib_sensor.optical_res) / MM_PER_INCH;
offset = static_cast<float>((offset * calib_sensor.optical_res) / MM_PER_INCH);
float size = dev->model->x_size_ta;
float size = static_cast<float>(dev->model->x_size_ta);
size /= calib_sensor.get_ccd_size_divisor_for_dpi(resolution);
size = (size * calib_sensor.optical_res) / MM_PER_INCH;
size = static_cast<float>((size * calib_sensor.optical_res) / MM_PER_INCH);
dev->calib_pixels_offset = offset;
dev->calib_pixels = size;
dev->calib_pixels_offset = static_cast<std::size_t>(offset);
dev->calib_pixels = static_cast<std::size_t>(size);
}
else
{
@ -2267,13 +2267,13 @@ void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
{
// note: move_to_ta() function has already been called and the sensor is at the
// transparency adapter
move = dev->model->y_offset_calib_white_ta - dev->model->y_offset_sensor_to_ta;
move = static_cast<int>(dev->model->y_offset_calib_white_ta - dev->model->y_offset_sensor_to_ta);
flags |= SCAN_FLAG_USE_XPA;
} else {
move = dev->model->y_offset_calib_white;
move = static_cast<int>(dev->model->y_offset_calib_white);
}
move = (move * resolution) / MM_PER_INCH;
move = static_cast<int>((move * resolution) / MM_PER_INCH);
ScanSession session;
session.params.xres = resolution;
@ -2327,28 +2327,28 @@ void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
if (dev->ignore_offsets) {
move = 0;
} else {
move = dev->model->y_offset_ta - dev->model->y_offset_sensor_to_ta;
move = static_cast<float>(dev->model->y_offset_ta - dev->model->y_offset_sensor_to_ta);
}
flags |= SCAN_FLAG_USE_XPA;
} else {
if (dev->ignore_offsets) {
move = 0;
} else {
move = dev->model->y_offset;
move = static_cast<float>(dev->model->y_offset);
}
}
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
move += static_cast<float>(dev->settings.tl_y);
move = static_cast<float>((move * move_dpi) / MM_PER_INCH);
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
if (dev->settings.scan_method==ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{
start = dev->model->x_offset_ta;
start = static_cast<float>(dev->model->x_offset_ta);
} else {
start = dev->model->x_offset;
start = static_cast<float>(dev->model->x_offset);
}
if (dev->model->model_id == ModelId::CANON_8400F ||
@ -2358,8 +2358,8 @@ void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
start /= sensor.get_ccd_size_divisor_for_dpi(dev->settings.xres);
}
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<float>(start + dev->settings.tl_x);
start = static_cast<float>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
@ -2637,13 +2637,13 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->model->model_id == ModelId::CANON_8600F &&
dev->settings.xres == 4800)
{
start_pixel = dev->model->x_offset_ta;
start_pixel = static_cast<int>(dev->model->x_offset_ta);
start_pixel /= calib_sensor.get_ccd_size_divisor_for_dpi(resolution);
start_pixel = (start_pixel * calib_sensor.optical_res) / MM_PER_INCH;
start_pixel = static_cast<int>((start_pixel * calib_sensor.optical_res) / MM_PER_INCH);
target_pixels = dev->model->x_size_ta;
target_pixels = static_cast<int>(dev->model->x_size_ta);
target_pixels /= calib_sensor.get_ccd_size_divisor_for_dpi(resolution);
target_pixels = (target_pixels * calib_sensor.optical_res) / MM_PER_INCH;
target_pixels = static_cast<int>((target_pixels * calib_sensor.optical_res) / MM_PER_INCH);
}
int flags = SCAN_FLAG_DISABLE_SHADING |
@ -2844,7 +2844,7 @@ void CommandSetGl843::coarse_gain_calibration(Genesys_Device* dev, const Genesys
if (dev->model->sensor_id == SensorId::CCD_KVSS080) {
if(dev->settings.xres<sensor.optical_res)
{
coeff=0.9;
coeff = 0.9f;
}
else
{
@ -3177,10 +3177,10 @@ void CommandSetGl843::move_to_ta(Genesys_Device* dev) const
{
DBG_HELPER(dbg);
float resolution;
unsigned int feed;
resolution=sanei_genesys_get_lowest_ydpi(dev);
feed = 16 * (dev->model->y_offset_sensor_to_ta * resolution) / MM_PER_INCH;
unsigned feed = static_cast<unsigned>(16 * (dev->model->y_offset_sensor_to_ta * resolution) /
MM_PER_INCH);
gl843_feed(dev, feed);
}

37
backend/genesys/gl846.cpp
Wyświetl plik

@ -855,9 +855,9 @@ void CommandSetGl846::calculate_current_setup(Genesys_Device* dev,
debug_dump(DBG_info, dev->settings);
/* start */
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<int>(dev->model->x_offset);
start += static_cast<int>(dev->settings.tl_x);
start = static_cast<int>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
@ -1363,7 +1363,7 @@ void CommandSetGl846::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
session.params.xres = dev->calib_resolution;
session.params.yres = dev->calib_resolution;
session.params.startx = 0;
session.params.starty = move;
session.params.starty = static_cast<unsigned>(move);
session.params.pixels = dev->calib_pixels;
session.params.lines = dev->calib_lines;
session.params.depth = 16;
@ -1417,9 +1417,9 @@ void CommandSetGl846::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
move_dpi = dev->motor.base_ydpi;
move = dev->model->y_offset;
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
move = static_cast<float>(dev->model->y_offset);
move = static_cast<float>(move + dev->settings.tl_y);
move = static_cast<float>((move * move_dpi) / MM_PER_INCH);
move -= dev->scanhead_position_in_steps;
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
@ -1430,7 +1430,7 @@ void CommandSetGl846::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
* move tuning */
if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700)
{
gl846_feed(dev, move-500);
gl846_feed(dev, static_cast<unsigned>(move - 500));
move=500;
}
@ -1438,15 +1438,15 @@ void CommandSetGl846::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<float>(dev->model->x_offset);
start = static_cast<float>(start + dev->settings.tl_x);
start = static_cast<float>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = start;
session.params.starty = move;
session.params.startx = static_cast<unsigned>(start);
session.params.starty = static_cast<unsigned>(move);
session.params.pixels = dev->settings.pixels;
session.params.requested_pixels = dev->settings.requested_pixels;
session.params.lines = dev->settings.lines;
@ -1554,13 +1554,12 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
int avg[3], top[3], bottom[3];
int turn;
uint16_t exp[3];
float move;
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
float move = static_cast<float>(dev->model->y_offset_calib_white);
move = static_cast<float>((move * (dev->motor.base_ydpi / 4)) / MM_PER_INCH);
if(move>20)
{
gl846_feed(dev, move);
gl846_feed(dev, static_cast<unsigned>(move));
}
DBG(DBG_io, "%s: move=%f steps\n", __func__, move);
@ -2260,7 +2259,7 @@ void CommandSetGl846::coarse_gain_calibration(Genesys_Device* dev, const Genesys
/* follow CKSEL */
if(dev->settings.xres<sensor.optical_res)
{
coeff=0.9;
coeff = 0.9f;
}
else
{
@ -2329,7 +2328,7 @@ void CommandSetGl846::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gain[j] = (static_cast<float>(sensor.gain_white_ref) * coeff) / max[j];
/* turn logical gain value into gain code, checking for overflow */
code = 283 - 208 / gain[j];
code = static_cast<int>(283 - 208 / gain[j]);
if (code > 255)
code = 255;
else if (code < 0)

41
backend/genesys/gl847.cpp
Wyświetl plik

@ -857,9 +857,9 @@ void CommandSetGl847::calculate_current_setup(Genesys_Device * dev,
debug_dump(DBG_info, dev->settings);
/* start */
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<int>(dev->model->x_offset);
start = static_cast<int>(start + dev->settings.tl_x);
start = static_cast<int>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
@ -1403,7 +1403,7 @@ void CommandSetGl847::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
session.params.xres = dev->calib_resolution;
session.params.yres = dev->calib_resolution;
session.params.startx = 0;
session.params.starty = move;
session.params.starty = static_cast<unsigned>(move);
session.params.pixels = dev->calib_pixels;
session.params.lines = dev->calib_lines;
session.params.depth = 16;
@ -1457,9 +1457,9 @@ void CommandSetGl847::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
move_dpi = dev->motor.base_ydpi;
move = dev->model->y_offset;
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
move = static_cast<float>(dev->model->y_offset);
move = static_cast<float>(move + dev->settings.tl_y);
move = static_cast<float>((move * move_dpi) / MM_PER_INCH);
move -= dev->scanhead_position_in_steps;
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
@ -1469,7 +1469,7 @@ void CommandSetGl847::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
* resolution. So leave a remainder for it so scan makes the final
* move tuning */
if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700) {
gl847_feed(dev, move-500);
gl847_feed(dev, static_cast<unsigned>(move - 500));
move=500;
}
@ -1477,15 +1477,15 @@ void CommandSetGl847::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
DBG(DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
start = dev->model->x_offset;
start += dev->settings.tl_x;
start = (start * sensor.optical_res) / MM_PER_INCH;
start = static_cast<float>(dev->model->x_offset);
start = static_cast<float>(start + dev->settings.tl_x);
start = static_cast<float>((start * sensor.optical_res) / MM_PER_INCH);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = start;
session.params.starty = move;
session.params.startx = static_cast<unsigned>(start);
session.params.starty = static_cast<unsigned>(move);
session.params.pixels = dev->settings.pixels;
session.params.requested_pixels = dev->settings.requested_pixels;
session.params.lines = dev->settings.lines;
@ -1595,11 +1595,11 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
uint16_t exp[3];
float move;
move = dev->model->y_offset_calib_white;
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
move = static_cast<float>(dev->model->y_offset_calib_white);
move = static_cast<float>((move * (dev->motor.base_ydpi / 4)) / MM_PER_INCH);
if(move>20)
{
gl847_feed(dev, move);
gl847_feed(dev, static_cast<unsigned>(move));
}
DBG(DBG_io, "%s: move=%f steps\n", __func__, move);
@ -2040,8 +2040,9 @@ void CommandSetGl847::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
if (DBG_LEVEL >= DBG_data)
{
sprintf(title, "gl847_search_strip_%s_%s%02d.pnm",
black ? "black" : "white", forward ? "fwd" : "bwd", (int)pass);
std::sprintf(title, "gl847_search_strip_%s_%s%02d.pnm",
black ? "black" : "white",
forward ? "fwd" : "bwd", static_cast<int>(pass));
sanei_genesys_write_pnm_file(title, data.data(), session.params.depth,
channels, pixels, lines);
}
@ -2334,7 +2335,7 @@ void CommandSetGl847::coarse_gain_calibration(Genesys_Device* dev, const Genesys
/* follow CKSEL */
if(dev->settings.xres<sensor.optical_res)
{
coeff=0.9;
coeff = 0.9f;
}
else
{
@ -2404,7 +2405,7 @@ void CommandSetGl847::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gain[j] = (static_cast<float>(sensor.gain_white_ref) * coeff) / max[j];
/* turn logical gain value into gain code, checking for overflow */
code = 283 - 208 / gain[j];
code = static_cast<int>(283 - 208 / gain[j]);
if (code > 255)
code = 255;
else if (code < 0)

10
backend/genesys/image_pixel.cpp
Wyświetl plik

@ -205,17 +205,17 @@ void set_pixel_to_row(std::uint8_t* data, std::size_t x, Pixel pixel, PixelForma
}
case PixelFormat::I8: {
float val = (pixel.r >> 8) * 0.3f;
val += (pixel.g >> 8) * 0.59;
val += (pixel.b >> 8) * 0.11;
val += (pixel.g >> 8) * 0.59f;
val += (pixel.b >> 8) * 0.11f;
data[x] = static_cast<std::uint16_t>(val);
return;
}
case PixelFormat::I16: {
x *= 2;
float val = pixel.r * 0.3f;
val += pixel.g * 0.59;
val += pixel.b * 0.11;
std::uint16_t val16 = val;
val += pixel.g * 0.59f;
val += pixel.b * 0.11f;
auto val16 = static_cast<std::uint16_t>(val);
data[x] = val16 & 0xff;
data[x + 1] = (val16 >> 8) & 0xff;
return;

4
backend/genesys/low.cpp
Wyświetl plik

@ -1833,7 +1833,7 @@ std::uint8_t compute_frontend_gain_wolfson(float value, float target_value)
{PGA} = 283 * (1 - {value} / {target_value})
*/
float gain = value / target_value;
int code = 283 * (1 - gain);
int code = static_cast<int>(283 * (1 - gain));
return clamp(code, 0, 255);
}
@ -2435,7 +2435,7 @@ void sanei_genesys_load_lut(unsigned char* lut,
for (i = 0; i <= max_in_val; i++)
{
j = rise * i + shift;
j = static_cast<int>(rise * i + shift);
/* cap data to required range */
if (j < out_min)