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

Merge branch 'genesys-remove-unused-code' into 'master' 

genesys: Remove unused code

See merge request sane-project/backends!338
merge-requests/340/head
Povilas Kanapickas 2020-02-16 23:05:26 +00:00
rodzic 494aa15141 4c395182be
commit 50f02fc3f2
16 zmienionych plików z 21 dodań i 599 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

2
backend/genesys/command_set.h
Wyświetl plik

@ -70,8 +70,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const = 0;
virtual void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const = 0;
virtual void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const = 0;
virtual void init_regs_for_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,

3
backend/genesys/enums.h
Wyświetl plik

@ -445,9 +445,6 @@ enum class ModelFlag : unsigned
// skip lamp warmup (genesys_warmup())
SKIP_WARMUP = 1 << 4,
// the scanner does offset and gain calibration
OFFSET_CALIBRATION = 1 << 5,
// search start point befor scanning
SEARCH_START = 1 << 6,

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

@ -1276,301 +1276,6 @@ void sanei_genesys_calculate_zmod(bool two_table,
*out_z2 = sum % exposure_time;
}
static uint8_t genesys_adjust_gain(double* applied_multi, double multi, uint8_t gain)
{
double voltage, original_voltage;
uint8_t new_gain = 0;
DBG(DBG_proc, "%s: multi=%f, gain=%d\n", __func__, multi, gain);
voltage = 0.5 + gain * 0.25;
original_voltage = voltage;
voltage *= multi;
new_gain = static_cast<std::uint8_t>((voltage - 0.5) * 4);
if (new_gain > 0x0e)
new_gain = 0x0e;
voltage = 0.5 + (new_gain) * 0.25;
*applied_multi = voltage / original_voltage;
DBG(DBG_proc, "%s: orig voltage=%.2f, new voltage=%.2f, *applied_multi=%f, new_gain=%d\n",
__func__, original_voltage, voltage, *applied_multi, new_gain);
return new_gain;
}
// todo: is return status necessary (unchecked?)
static void genesys_average_white(Genesys_Device* dev, Genesys_Sensor& sensor, int channels,
int channel, uint8_t* data, int size, int *max_average)
{
DBG_HELPER_ARGS(dbg, "channels=%d, channel=%d, size=%d", channels, channel, size);
int gain_white_ref, sum, range;
int average;
int i;
range = size / 50;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{
gain_white_ref = sensor.fau_gain_white_ref * 256;
} else {
gain_white_ref = sensor.gain_white_ref * 256;
}
if (range < 1)
range = 1;
size = size / (2 * range * channels);
data += (channel * 2);
*max_average = 0;
while (size--)
{
sum = 0;
for (i = 0; i < range; i++)
{
sum += (*data);
sum += *(data + 1) * 256;
data += (2 * channels); /* byte based */
}
average = (sum / range);
if (average > *max_average)
*max_average = average;
}
DBG(DBG_proc, "%s: max_average=%d, gain_white_ref = %d, finished\n", __func__, *max_average,
gain_white_ref);
if (*max_average >= gain_white_ref)
throw SaneException(SANE_STATUS_INVAL);
}
/* todo: understand, values are too high */
static int
genesys_average_black (Genesys_Device * dev, int channel,
uint8_t * data, int pixels)
{
int i;
int sum;
int pixel_step;
DBG(DBG_proc, "%s: channel=%d, pixels=%d\n", __func__, channel, pixels);
sum = 0;
if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
{
data += (channel * 2);
pixel_step = 3 * 2;
}
else
{
pixel_step = 2;
}
for (i = 0; i < pixels; i++)
{
sum += *data;
sum += *(data + 1) * 256;
data += pixel_step;
}
DBG(DBG_proc, "%s = %d\n", __func__, sum / pixels);
return sum / pixels;
}
// todo: check; it works but the lines 1, 2, and 3 are too dark even with the
// same offset and gain settings?
static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sensor,
Genesys_Register_Set& local_reg)
{
DBG_HELPER_ARGS(dbg, "scan_mode = %d", static_cast<unsigned>(dev->settings.scan_mode));
dev->cmd_set->init_regs_for_coarse_calibration(dev, sensor, local_reg);
if (dev->model->asic_type != AsicType::GL646) {
dev->interface->write_registers(local_reg);
}
int black_pixels;
int white_average;
uint8_t offset[4] = { 0xa0, 0x00, 0xa0, 0x40 }; /* first value isn't used */
uint16_t white[12], dark[12];
int i, j;
black_pixels = sensor.black_pixels
* dev->settings.xres / sensor.optical_res;
unsigned channels = dev->settings.get_channels();
DBG(DBG_info, "channels %d y_size %f xres %d\n", channels, dev->model->y_size,
dev->settings.xres);
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);
std::vector<uint8_t> all_data(size * 4, 1);
dev->cmd_set->set_fe(dev, sensor, AFE_INIT);
dev->frontend.set_gain(0, 2);
dev->frontend.set_gain(1, 2);
dev->frontend.set_gain(2, 2); // TODO: ? was 2
dev->frontend.set_offset(0, offset[0]);
dev->frontend.set_offset(1, offset[0]);
dev->frontend.set_offset(2, offset[0]);
for (i = 0; i < 4; i++) /* read 4 lines */
{
if (i < 3) /* first 3 lines */
{
dev->frontend.set_offset(0, offset[i]);
dev->frontend.set_offset(1, offset[i]);
dev->frontend.set_offset(2, offset[i]);
}
if (i == 1) /* second line */
{
double applied_multi;
double gain_white_ref;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{
gain_white_ref = sensor.fau_gain_white_ref * 256;
} else {
gain_white_ref = sensor.gain_white_ref * 256;
}
// white and black are defined downwards
uint8_t gain0 = genesys_adjust_gain(&applied_multi,
gain_white_ref / (white[0] - dark[0]),
dev->frontend.get_gain(0));
uint8_t gain1 = genesys_adjust_gain(&applied_multi,
gain_white_ref / (white[1] - dark[1]),
dev->frontend.get_gain(1));
uint8_t gain2 = genesys_adjust_gain(&applied_multi,
gain_white_ref / (white[2] - dark[2]),
dev->frontend.get_gain(2));
// FIXME: looks like overwritten data. Are the above calculations doing
// anything at all?
dev->frontend.set_gain(0, gain0);
dev->frontend.set_gain(1, gain1);
dev->frontend.set_gain(2, gain2);
dev->frontend.set_gain(0, 2);
dev->frontend.set_gain(1, 2);
dev->frontend.set_gain(2, 2);
dev->interface->write_fe_register(0x28, dev->frontend.get_gain(0));
dev->interface->write_fe_register(0x29, dev->frontend.get_gain(1));
dev->interface->write_fe_register(0x2a, dev->frontend.get_gain(2));
}
if (i == 3) /* last line */
{
double x, y, rate;
for (j = 0; j < 3; j++)
{
x = static_cast<double>(dark[(i - 2) * 3 + j] -
dark[(i - 1) * 3 + j]) * 254 / (offset[i - 1] / 2 -
offset[i - 2] / 2);
y = x - x * (offset[i - 1] / 2) / 254 - dark[(i - 1) * 3 + j];
rate = (x - DARK_VALUE - y) * 254 / x + 0.5;
uint8_t curr_offset = static_cast<uint8_t>(rate);
if (curr_offset > 0x7f) {
curr_offset = 0x7f;
}
curr_offset <<= 1;
dev->frontend.set_offset(j, curr_offset);
}
}
dev->interface->write_fe_register(0x20, dev->frontend.get_offset(0));
dev->interface->write_fe_register(0x21, dev->frontend.get_offset(1));
dev->interface->write_fe_register(0x22, dev->frontend.get_offset(2));
DBG(DBG_info,
"%s: doing scan: gain: %d/%d/%d, offset: %d/%d/%d\n", __func__,
dev->frontend.get_gain(0),
dev->frontend.get_gain(1),
dev->frontend.get_gain(2),
dev->frontend.get_offset(0),
dev->frontend.get_offset(1),
dev->frontend.get_offset(2));
dev->cmd_set->begin_scan(dev, sensor, &local_reg, false);
if (is_testing_mode()) {
dev->interface->test_checkpoint("coarse_calibration");
dev->cmd_set->end_scan(dev, &local_reg, true);
return;
}
sanei_genesys_read_data_from_scanner(dev, calibration_data.data(), size);
std::memcpy(all_data.data() + i * size, calibration_data.data(), size);
if (i == 3) /* last line */
{
std::vector<uint8_t> all_data_8(size * 4 / 2);
unsigned int count;
for (count = 0; count < static_cast<unsigned>(size * 4 / 2); count++) {
all_data_8[count] = all_data[count * 2 + 1];
}
sanei_genesys_write_pnm_file("gl_coarse.pnm", all_data_8.data(), 8, channels, size / 6, 4);
}
dev->cmd_set->end_scan(dev, &local_reg, true);
if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
{
for (j = 0; j < 3; j++)
{
genesys_average_white(dev, sensor, 3, j, calibration_data.data(), size, &white_average);
white[i * 3 + j] = white_average;
dark[i * 3 + j] =
genesys_average_black (dev, j, calibration_data.data(),
black_pixels);
DBG(DBG_info, "%s: white[%d]=%d, black[%d]=%d\n", __func__,
i * 3 + j, white[i * 3 + j], i * 3 + j, dark[i * 3 + j]);
}
}
else /* one color-component modes */
{
genesys_average_white(dev, sensor, 1, 0, calibration_data.data(), size, &white_average);
white[i * 3 + 0] = white[i * 3 + 1] = white[i * 3 + 2] =
white_average;
dark[i * 3 + 0] = dark[i * 3 + 1] = dark[i * 3 + 2] =
genesys_average_black (dev, 0, calibration_data.data(), black_pixels);
}
} /* for (i = 0; i < 4; i++) */
DBG(DBG_info, "%s: final: gain: %d/%d/%d, offset: %d/%d/%d\n", __func__,
dev->frontend.get_gain(0),
dev->frontend.get_gain(1),
dev->frontend.get_gain(2),
dev->frontend.get_offset(0),
dev->frontend.get_offset(1),
dev->frontend.get_offset(2));
}
/**
* scans a white area with motor and lamp off to get the per CCD pixel offset
* that will be used to compute shading coefficient
@ -2873,19 +2578,12 @@ static void genesys_flatbed_calibration(Genesys_Device* dev, Genesys_Sensor& sen
auto local_reg = dev->initial_regs;
/* do offset calibration if needed */
if (has_flag(dev->model->flags, ModelFlag::OFFSET_CALIBRATION)) {
dev->interface->record_progress_message("offset_calibration");
dev->cmd_set->offset_calibration(dev, sensor, local_reg);
// do offset calibration if needed
dev->interface->record_progress_message("offset_calibration");
dev->cmd_set->offset_calibration(dev, sensor, local_reg);
/* since all the registers are set up correctly, just use them */
dev->interface->record_progress_message("coarse_gain_calibration");
dev->cmd_set->coarse_gain_calibration(dev, sensor, local_reg, coarse_res);
} else {
// since we have 2 gain calibration proc, skip second if first one was used.
dev->interface->record_progress_message("genesys_coarse_calibration");
genesys_coarse_calibration(dev, sensor, local_reg);
}
dev->interface->record_progress_message("coarse_gain_calibration");
dev->cmd_set->coarse_gain_calibration(dev, sensor, local_reg, coarse_res);
if (dev->model->is_cis)
{
@ -2910,20 +2608,12 @@ static void genesys_flatbed_calibration(Genesys_Device* dev, Genesys_Sensor& sen
}
/* calibrate afe again to match new exposure */
if (has_flag(dev->model->flags, ModelFlag::OFFSET_CALIBRATION)) {
dev->interface->record_progress_message("offset_calibration");
dev->cmd_set->offset_calibration(dev, sensor, local_reg);
// calibrate afe again to match new exposure
dev->interface->record_progress_message("offset_calibration");
dev->cmd_set->offset_calibration(dev, sensor, local_reg);
// since all the registers are set up correctly, just use them
dev->interface->record_progress_message("coarse_gain_calibration");
dev->cmd_set->coarse_gain_calibration(dev, sensor, local_reg, coarse_res);
} else {
// since we have 2 gain calibration proc, skip second if first one was used
dev->interface->record_progress_message("genesys_coarse_calibration");
genesys_coarse_calibration(dev, sensor, local_reg);
}
dev->interface->record_progress_message("coarse_gain_calibration");
dev->cmd_set->coarse_gain_calibration(dev, sensor, local_reg, coarse_res);
}
/* we always use sensor pixel number when the ASIC can't handle multi-segments sensor */
@ -3020,18 +2710,9 @@ static void genesys_sheetfed_calibration(Genesys_Device* dev, Genesys_Sensor& se
dev->cmd_set->led_calibration(dev, sensor, local_reg);
}
/* calibrate afe */
if (has_flag(dev->model->flags, ModelFlag::OFFSET_CALIBRATION)) {
dev->cmd_set->offset_calibration(dev, sensor, local_reg);
dev->cmd_set->offset_calibration(dev, sensor, local_reg);
/* since all the registers are set up correctly, just use them */
dev->cmd_set->coarse_gain_calibration(dev, sensor, local_reg, sensor.optical_res);
} else {
// since we have 2 gain calibration proc, skip second if first one was used
dev->interface->record_progress_message("genesys_coarse_calibration");
genesys_coarse_calibration(dev, sensor, local_reg);
}
dev->cmd_set->coarse_gain_calibration(dev, sensor, local_reg, sensor.optical_res);
/* search for a full width black strip and then do a 16 bit scan to
* gather black shading data */

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

@ -1134,43 +1134,6 @@ void CommandSetGl124::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl124::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::FEEDING |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
sanei_genesys_set_motor_power(regs, false);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
// init registers for shading calibration shading calibration is done at dpihw
void CommandSetGl124::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const

3
backend/genesys/gl124.h
Wyświetl plik

@ -125,9 +125,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

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

@ -1643,20 +1643,6 @@ void CommandSetGl646::search_start_position(Genesys_Device* dev) const
}
}
/**
* internally overriden during effective calibration
* sets up register for coarse gain calibration
*/
void CommandSetGl646::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
(void) dev;
(void) sensor;
(void) regs;
}
/**
* init registers for shading calibration

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

@ -449,9 +449,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

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

@ -2296,40 +2296,6 @@ void CommandSetGl841::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl841::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
// init registers for shading calibration
void CommandSetGl841::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const

3
backend/genesys/gl841.h
Wyświetl plik

@ -63,9 +63,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

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

@ -1555,48 +1555,6 @@ void CommandSetGl843::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl843::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanFlag flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) {
flags |= ScanFlag::USE_XPA;
}
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = flags;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
sanei_genesys_set_motor_power(regs, false);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
static bool should_calibrate_only_active_area(const Genesys_Device& dev,
const Genesys_Settings& settings)
{

3
backend/genesys/gl843.h
Wyświetl plik

@ -63,9 +63,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

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

@ -909,39 +909,6 @@ void CommandSetGl846::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl846::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
// init registers for shading calibration
void CommandSetGl846::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const

3
backend/genesys/gl846.h
Wyświetl plik

@ -138,9 +138,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

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

@ -915,39 +915,6 @@ void CommandSetGl847::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl847::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
// init registers for shading calibration
void CommandSetGl847::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const

3
backend/genesys/gl847.h
Wyświetl plik

@ -126,9 +126,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

61
backend/genesys/tables_model.cpp
Wyświetl plik

@ -191,7 +191,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::CANON_LIDE_35;
model.motor_id = MotorId::CANON_LIDE_35;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_WHITE_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW |
@ -246,7 +245,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::KVSS080;
model.motor_id = MotorId::KVSS080;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW;
model.search_lines = 100;
@ -296,8 +294,7 @@ void genesys_init_usb_device_tables()
model.adc_id = AdcId::G4050;
model.gpio_id = GpioId::G4050;
model.motor_id = MotorId::G4050;
model.flags = ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SHADING_REPARK |
model.flags = ModelFlag::SHADING_REPARK |
ModelFlag::SKIP_WARMUP |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_FILE_SW | GENESYS_HAS_COPY_SW;
@ -346,8 +343,7 @@ void genesys_init_usb_device_tables()
model.adc_id = AdcId::G4050;
model.gpio_id = GpioId::G4050;
model.motor_id = MotorId::G4050;
model.flags = ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SKIP_WARMUP |
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_FILE_SW | GENESYS_HAS_COPY_SW;
@ -398,8 +394,7 @@ void genesys_init_usb_device_tables()
model.adc_id = AdcId::G4050;
model.gpio_id = GpioId::G4050;
model.motor_id = MotorId::G4050;
model.flags = ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SKIP_WARMUP |
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_FILE_SW | GENESYS_HAS_COPY_SW;
@ -463,8 +458,7 @@ void genesys_init_usb_device_tables()
model.adc_id = AdcId::CANON_4400F;
model.gpio_id = GpioId::CANON_4400F;
model.motor_id = MotorId::CANON_4400F;
model.flags = ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SKIP_WARMUP |
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::FULL_HWDPI_MODE |
ModelFlag::CUSTOM_GAMMA |
@ -536,8 +530,7 @@ void genesys_init_usb_device_tables()
model.adc_id = AdcId::CANON_8400F;
model.gpio_id = GpioId::CANON_8400F;
model.motor_id = MotorId::CANON_8400F;
model.flags = ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SKIP_WARMUP |
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::FULL_HWDPI_MODE |
ModelFlag::CUSTOM_GAMMA |
@ -603,8 +596,7 @@ void genesys_init_usb_device_tables()
model.adc_id = AdcId::CANON_8600F;
model.gpio_id = GpioId::CANON_8600F;
model.motor_id = MotorId::CANON_8600F;
model.flags = ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SKIP_WARMUP |
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::FULL_HWDPI_MODE |
ModelFlag::CUSTOM_GAMMA |
@ -661,7 +653,6 @@ void genesys_init_usb_device_tables()
ModelFlag::SIS_SENSOR |
ModelFlag::DARK_CALIBRATION |
ModelFlag::SHADING_REPARK |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW |
GENESYS_HAS_COPY_SW |
@ -714,7 +705,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::CANON_LIDE_110;
model.motor_id = MotorId::CANON_LIDE_110;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::SHADING_REPARK |
ModelFlag::CUSTOM_GAMMA;
@ -768,7 +758,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::CANON_LIDE_120;
model.motor_id = MotorId::CANON_LIDE_120;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::SHADING_REPARK |
ModelFlag::CUSTOM_GAMMA;
@ -825,7 +814,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::CANON_LIDE_210;
model.motor_id = MotorId::CANON_LIDE_210;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::SHADING_REPARK |
ModelFlag::CUSTOM_GAMMA;
@ -882,7 +870,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::CANON_LIDE_210;
model.motor_id = MotorId::CANON_LIDE_210;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::SHADING_REPARK |
ModelFlag::CUSTOM_GAMMA;
@ -942,7 +929,6 @@ void genesys_init_usb_device_tables()
ModelFlag::SKIP_WARMUP |
ModelFlag::SIS_SENSOR |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW |
GENESYS_HAS_COPY_SW |
@ -997,7 +983,6 @@ void genesys_init_usb_device_tables()
model.motor_id = MotorId::CANON_LIDE_700;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::SIS_SENSOR |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::SHADING_REPARK |
ModelFlag::CUSTOM_GAMMA;
@ -1053,7 +1038,6 @@ void genesys_init_usb_device_tables()
model.motor_id = MotorId::CANON_LIDE_200;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::SIS_SENSOR |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::SHADING_REPARK |
ModelFlag::CUSTOM_GAMMA;
@ -1110,7 +1094,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::CANON_LIDE_35;
model.motor_id = MotorId::CANON_LIDE_35;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_WHITE_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
@ -1166,7 +1149,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::CANON_LIDE_80;
model.motor_id = MotorId::CANON_LIDE_80;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_WHITE_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW |
@ -1223,7 +1205,6 @@ void genesys_init_usb_device_tables()
ModelFlag::SKIP_WARMUP |
ModelFlag::SEARCH_START |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_COPY_SW;
model.search_lines = 132;
@ -1275,7 +1256,6 @@ void genesys_init_usb_device_tables()
model.motor_id = MotorId::HP2400;
model.flags = ModelFlag::GAMMA_14BIT |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SKIP_WARMUP |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_COPY_SW | GENESYS_HAS_EMAIL_SW | GENESYS_HAS_SCAN_SW;
@ -1329,8 +1309,7 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::GAMMA_14BIT |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION;
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
model.search_lines = 132;
@ -1381,7 +1360,6 @@ void genesys_init_usb_device_tables()
model.motor_id = MotorId::HP3670;
model.flags = ModelFlag::GAMMA_14BIT |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_COPY_SW | GENESYS_HAS_EMAIL_SW | GENESYS_HAS_SCAN_SW;
model.search_lines = 200;
@ -1482,8 +1460,7 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::UNTESTED |
ModelFlag::GAMMA_14BIT |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::SEARCH_START |
ModelFlag::OFFSET_CALIBRATION;
ModelFlag::SEARCH_START;
model.buttons = GENESYS_HAS_NO_BUTTONS;
model.search_lines = 200;
@ -1533,7 +1510,6 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::GAMMA_14BIT |
ModelFlag::SEARCH_START |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SHADING_NO_MOVE |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_COPY_SW |
@ -1588,7 +1564,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::XP300;
model.motor_id = MotorId::XP300;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -1639,7 +1614,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::DP665;
model.motor_id = MotorId::DP665;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -1690,7 +1664,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::DP665;
model.motor_id = MotorId::ROADWARRIOR;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -1793,7 +1766,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::DP665;
model.motor_id = MotorId::ROADWARRIOR;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -1844,7 +1816,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::DP665;
model.motor_id = MotorId::DSMOBILE_600;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -1896,7 +1867,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::DP665;
model.motor_id = MotorId::DSMOBILE_600;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -1947,7 +1917,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::DP685;
model.motor_id = MotorId::XP300;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -2000,7 +1969,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::XP300;
model.motor_id = MotorId::XP300;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -2053,7 +2021,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::XP300;
model.motor_id = MotorId::XP300;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::DARK_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::UNTESTED;
@ -2107,7 +2074,6 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::GAMMA_14BIT |
ModelFlag::SEARCH_START |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_COPY_SW |
GENESYS_HAS_EMAIL_SW |
@ -2163,7 +2129,6 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::GAMMA_14BIT |
ModelFlag::SEARCH_START |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_COPY_SW |
GENESYS_HAS_EMAIL_SW |
@ -2218,7 +2183,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::DP665;
model.motor_id = MotorId::ROADWARRIOR;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_SCAN_SW | GENESYS_HAS_PAGE_LOADED_SW | GENESYS_HAS_CALIBRATE;
@ -2272,8 +2236,7 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::UNTESTED | // not fully working yet
ModelFlag::CUSTOM_GAMMA |
ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION;
ModelFlag::DARK_CALIBRATION;
model.buttons = GENESYS_HAS_NO_BUTTONS;
model.search_lines = 200;
@ -2338,7 +2301,6 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::CUSTOM_GAMMA |
ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SHADING_REPARK |
ModelFlag::INVERTED_16BIT_DATA;
@ -2404,7 +2366,6 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::CUSTOM_GAMMA |
ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SHADING_REPARK;
model.search_lines = 200;
@ -2469,7 +2430,6 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::CUSTOM_GAMMA |
ModelFlag::SKIP_WARMUP |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::SHADING_REPARK;
model.search_lines = 200;
@ -2521,7 +2481,6 @@ void genesys_init_usb_device_tables()
model.flags = ModelFlag::UNTESTED |
ModelFlag::GAMMA_14BIT |
ModelFlag::DARK_CALIBRATION |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::SKIP_WARMUP |
ModelFlag::NO_CALIBRATION;
@ -2575,7 +2534,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::PLUSTEK_OPTICBOOK_3800;
model.motor_id = MotorId::PLUSTEK_OPTICBOOK_3800;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA;
model.buttons = GENESYS_HAS_NO_BUTTONS; // TODO there are 4 buttons to support
model.search_lines = 100;
@ -2626,7 +2584,6 @@ void genesys_init_usb_device_tables()
model.gpio_id = GpioId::IMG101;
model.motor_id = MotorId::IMG101;
model.flags = ModelFlag::SKIP_WARMUP |
ModelFlag::OFFSET_CALIBRATION |
ModelFlag::CUSTOM_GAMMA |
ModelFlag::UNTESTED;
model.buttons = GENESYS_HAS_NO_BUTTONS ;