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

genesys: Make scan flags an enum

merge-requests/228/merge
Povilas Kanapickas 2019-11-23 12:38:51 +02:00
rodzic 05e3091d5f
commit 837ec33c7f
12 zmienionych plików z 297 dodań i 251 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

7
backend/genesys/enums.cpp
Wyświetl plik

@ -45,6 +45,7 @@
#include "enums.h" #include "enums.h"
#include "genesys.h" #include "genesys.h"
#include <iomanip>
namespace genesys { namespace genesys {
@ -120,5 +121,11 @@ std::ostream& operator<<(std::ostream& out, StepType type)
return out; return out;
} }
std::ostream& operator<<(std::ostream& out, ScanFlag flags)
{
StreamStateSaver state_saver{out};
out << "0x" << std::hex << static_cast<unsigned>(flags);
return out;
}
} // namespace genesys } // namespace genesys

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

@ -410,6 +410,59 @@ enum class AsicType : unsigned
GL124, GL124,
}; };
enum class ScanFlag : unsigned
{
NONE = 0,
SINGLE_LINE = 1 << 0,
DISABLE_SHADING = 1 << 1,
DISABLE_GAMMA = 1 << 2,
DISABLE_BUFFER_FULL_MOVE = 1 << 3,
IGNORE_LINE_DISTANCE = 1 << 4,
DISABLE_LAMP = 1 << 5,
CALIBRATION = 1 << 6,
FEEDING = 1 << 7,
USE_XPA = 1 << 8,
ENABLE_LEDADD = 1 << 9,
USE_XCORRECTION = 1 << 10,
};
inline ScanFlag operator|(ScanFlag left, ScanFlag right)
{
return static_cast<ScanFlag>(static_cast<unsigned>(left) | static_cast<unsigned>(right));
}
inline ScanFlag& operator|=(ScanFlag& left, ScanFlag right)
{
left = left | right;
return left;
}
inline ScanFlag operator&(ScanFlag left, ScanFlag right)
{
return static_cast<ScanFlag>(static_cast<unsigned>(left) & static_cast<unsigned>(right));
}
inline bool has_flag(ScanFlag flags, ScanFlag which)
{
return (flags & which) == which;
}
inline void serialize(std::istream& str, ScanFlag& x)
{
unsigned value;
serialize(str, value);
x = static_cast<ScanFlag>(value);
}
inline void serialize(std::ostream& str, ScanFlag& x)
{
unsigned value = static_cast<unsigned>(x);
serialize(str, value);
}
std::ostream& operator<<(std::ostream& out, ScanFlag flags);
} // namespace genesys } // namespace genesys
#endif // BACKEND_GENESYS_ENUMS_H #endif // BACKEND_GENESYS_ENUMS_H

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

@ -756,7 +756,7 @@ static void gl124_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
/* enable shading */ /* enable shading */
r = sanei_genesys_get_address (reg, REG_0x01); r = sanei_genesys_get_address (reg, REG_0x01);
r->value &= ~REG_0x01_SCAN; r->value &= ~REG_0x01_SCAN;
if ((session.params.flags & SCAN_FLAG_DISABLE_SHADING) || if (has_flag(session.params.flags, ScanFlag::DISABLE_SHADING) ||
(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)) (dev->model->flags & GENESYS_FLAG_NO_CALIBRATION))
{ {
r->value &= ~REG_0x01_DVDSET; r->value &= ~REG_0x01_DVDSET;
@ -777,7 +777,7 @@ static void gl124_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
} }
sanei_genesys_set_lamp_power(dev, sensor, *reg, sanei_genesys_set_lamp_power(dev, sensor, *reg,
!(session.params.flags & SCAN_FLAG_DISABLE_LAMP)); !has_flag(session.params.flags, ScanFlag::DISABLE_LAMP));
// BW threshold // BW threshold
dev->interface->write_register(REG_0x114, dev->settings.threshold); dev->interface->write_register(REG_0x114, dev->settings.threshold);
@ -902,7 +902,7 @@ static void gl124_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
slope_dpi = session.params.yres; slope_dpi = session.params.yres;
} }
if(session.params.flags & SCAN_FLAG_FEEDING) { if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
exposure_time = 2304; exposure_time = 2304;
} else { } else {
exposure_time = get_sensor_profile(dev->model->asic_type, sensor, session.params.xres, exposure_time = get_sensor_profile(dev->model->asic_type, sensor, session.params.xres,
@ -927,10 +927,10 @@ static void gl124_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
DBG(DBG_info, "%s: move=%d steps\n", __func__, move); DBG(DBG_info, "%s: move=%d steps\n", __func__, move);
mflags = 0; mflags = 0;
if (session.params.flags & SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE) { if (has_flag(session.params.flags, ScanFlag::DISABLE_BUFFER_FULL_MOVE)) {
mflags |= MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE; mflags |= MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE;
} }
if (session.params.flags & SCAN_FLAG_FEEDING) { if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
mflags |= MOTOR_FLAG_FEED; mflags |= MOTOR_FLAG_FEED;
} }
gl124_init_motor_regs_scan(dev, sensor, reg, motor_profile, exposure_time, slope_dpi, gl124_init_motor_regs_scan(dev, sensor, reg, motor_profile, exposure_time, slope_dpi,
@ -981,7 +981,7 @@ ScanSession CommandSetGl124::calculate_scan_session(const Genesys_Device* dev,
session.params.scan_method = settings.scan_method; session.params.scan_method = settings.scan_method;
session.params.scan_mode = settings.scan_mode; session.params.scan_mode = settings.scan_mode;
session.params.color_filter = settings.color_filter; session.params.color_filter = settings.color_filter;
session.params.flags = 0; session.params.flags = ScanFlag::NONE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
@ -1258,9 +1258,9 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, &local_reg, session); gl124_init_scan_regs(dev, sensor, &local_reg, session);
@ -1351,11 +1351,11 @@ static void gl124_feed(Genesys_Device* dev, unsigned int steps, int reverse)
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_FEEDING | ScanFlag::FEEDING |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE | ScanFlag::DISABLE_BUFFER_FULL_MOVE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, &local_reg, session); gl124_init_scan_regs(dev, sensor, &local_reg, session);
@ -1442,10 +1442,10 @@ void CommandSetGl124::search_start_position(Genesys_Device* dev) const
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::GREEN; session.params.color_filter = ColorFilter::GREEN;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE | ScanFlag::IGNORE_LINE_DISTANCE |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE; ScanFlag::DISABLE_BUFFER_FULL_MOVE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, &local_reg, session); gl124_init_scan_regs(dev, sensor, &local_reg, session);
@ -1509,11 +1509,11 @@ void CommandSetGl124::init_regs_for_coarse_calibration(Genesys_Device* dev,
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode; session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_FEEDING | ScanFlag::FEEDING |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, &regs, session); gl124_init_scan_regs(dev, sensor, &regs, session);
@ -1576,10 +1576,10 @@ void CommandSetGl124::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE | ScanFlag::DISABLE_BUFFER_FULL_MOVE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
try { try {
@ -1657,7 +1657,7 @@ void CommandSetGl124::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode; session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = 0; session.params.flags = ScanFlag::NONE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, &dev->reg, session); gl124_init_scan_regs(dev, sensor, &dev->reg, session);
@ -1798,10 +1798,10 @@ static void move_to_calibration_area(Genesys_Device* dev, const Genesys_Sensor&
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, &regs, session); gl124_init_scan_regs(dev, sensor, &regs, session);
@ -1881,10 +1881,10 @@ SensorExposure CommandSetGl124::led_calibration(Genesys_Device* dev, const Genes
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, &regs, session); gl124_init_scan_regs(dev, sensor, &regs, session);
@ -2056,10 +2056,10 @@ void CommandSetGl124::offset_calibration(Genesys_Device* dev, const Genesys_Sens
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, &regs, session); gl124_init_scan_regs(dev, sensor, &regs, session);
@ -2216,10 +2216,10 @@ void CommandSetGl124::coarse_gain_calibration(Genesys_Device* dev, const Genesys
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
try { try {
@ -2332,10 +2332,10 @@ void CommandSetGl124::init_regs_for_warmup(Genesys_Device* dev, const Genesys_Se
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl124_init_scan_regs(dev, sensor, reg, session); gl124_init_scan_regs(dev, sensor, reg, session);

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

@ -342,10 +342,10 @@ static void gl646_setup_registers(Genesys_Device* dev,
/* select XPA */ /* select XPA */
regs->find_reg(0x03).value &= ~REG_0x03_XPASEL; regs->find_reg(0x03).value &= ~REG_0x03_XPASEL;
if (session.params.flags & SCAN_FLAG_USE_XPA) { if ((session.params.flags & ScanFlag::USE_XPA) != ScanFlag::NONE) {
regs->find_reg(0x03).value |= REG_0x03_XPASEL; regs->find_reg(0x03).value |= REG_0x03_XPASEL;
} }
regs->state.is_xpa_on = session.params.flags & SCAN_FLAG_USE_XPA; regs->state.is_xpa_on = (session.params.flags & ScanFlag::USE_XPA) != ScanFlag::NONE;
/* R04 */ /* R04 */
/* monochrome / color scan */ /* monochrome / color scan */
@ -1911,12 +1911,12 @@ static void setup_for_scan(Genesys_Device* dev,
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = settings.scan_mode; session.params.scan_mode = settings.scan_mode;
session.params.color_filter = settings.color_filter; session.params.color_filter = settings.color_filter;
session.params.flags = 0; session.params.flags = ScanFlag::NONE;
if (settings.scan_method == ScanMethod::TRANSPARENCY) { if (settings.scan_method == ScanMethod::TRANSPARENCY) {
session.params.flags |= SCAN_FLAG_USE_XPA; session.params.flags |= ScanFlag::USE_XPA;
} }
if (xcorrection) { if (xcorrection) {
session.params.flags |= SCAN_FLAG_USE_XCORRECTION; session.params.flags |= ScanFlag::USE_XCORRECTION;
} }
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
@ -3510,9 +3510,9 @@ ScanSession CommandSetGl646::calculate_scan_session(const Genesys_Device* dev,
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = settings.scan_mode; session.params.scan_mode = settings.scan_mode;
session.params.color_filter = settings.color_filter; session.params.color_filter = settings.color_filter;
session.params.flags = SCAN_FLAG_USE_XCORRECTION; session.params.flags = ScanFlag::USE_XCORRECTION;
if (settings.scan_method == ScanMethod::TRANSPARENCY) { if (settings.scan_method == ScanMethod::TRANSPARENCY) {
session.params.flags |= SCAN_FLAG_USE_XPA; session.params.flags |= ScanFlag::USE_XPA;
} }
compute_session(dev, session, sensor); compute_session(dev, session, sensor);

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

@ -1346,7 +1346,7 @@ static void gl841_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
/* enable shading */ /* enable shading */
r = sanei_genesys_get_address (reg, 0x01); r = sanei_genesys_get_address (reg, 0x01);
r->value |= REG_0x01_SCAN; r->value |= REG_0x01_SCAN;
if ((session.params.flags & SCAN_FLAG_DISABLE_SHADING) || if (has_flag(session.params.flags, ScanFlag::DISABLE_SHADING) ||
(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)) { (dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)) {
r->value &= ~REG_0x01_DVDSET; r->value &= ~REG_0x01_DVDSET;
} else { } else {
@ -1359,7 +1359,7 @@ static void gl841_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
r = sanei_genesys_get_address (reg, 0x03); r = sanei_genesys_get_address (reg, 0x03);
r->value |= REG_0x03_AVEENB; r->value |= REG_0x03_AVEENB;
sanei_genesys_set_lamp_power(dev, sensor, *reg, sanei_genesys_set_lamp_power(dev, sensor, *reg,
!(session.params.flags & SCAN_FLAG_DISABLE_LAMP)); !has_flag(session.params.flags, ScanFlag::DISABLE_LAMP));
/* BW threshold */ /* BW threshold */
r = sanei_genesys_get_address (reg, 0x2e); r = sanei_genesys_get_address (reg, 0x2e);
@ -1383,7 +1383,7 @@ static void gl841_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
/* AFEMOD should depend on FESET, and we should set these /* AFEMOD should depend on FESET, and we should set these
* bits separately */ * bits separately */
r->value &= ~(REG_0x04_FILTER | REG_0x04_AFEMOD); r->value &= ~(REG_0x04_FILTER | REG_0x04_AFEMOD);
if (session.params.flags & SCAN_FLAG_ENABLE_LEDADD) { if (has_flag(session.params.flags, ScanFlag::ENABLE_LEDADD)) {
r->value |= 0x10; /* no filter */ r->value |= 0x10; /* no filter */
} }
else if (session.params.channels == 1) else if (session.params.channels == 1)
@ -1418,7 +1418,7 @@ static void gl841_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
/* CIS scanners can do true gray by setting LEDADD */ /* CIS scanners can do true gray by setting LEDADD */
r = sanei_genesys_get_address (reg, 0x87); r = sanei_genesys_get_address (reg, 0x87);
r->value &= ~REG_0x87_LEDADD; r->value &= ~REG_0x87_LEDADD;
if (session.params.flags & SCAN_FLAG_ENABLE_LEDADD) { if (has_flag(session.params.flags, ScanFlag::ENABLE_LEDADD)) {
r->value |= REG_0x87_LEDADD; r->value |= REG_0x87_LEDADD;
expr = reg->get16(REG_EXPR); expr = reg->get16(REG_EXPR);
expg = reg->get16(REG_EXPG); expg = reg->get16(REG_EXPG);
@ -1642,7 +1642,7 @@ dummy \ scanned lines
/* move = ((move + dummy) / (dummy + 1)) * (dummy + 1); /* move = ((move + dummy) / (dummy + 1)) * (dummy + 1);
DBG(DBG_info, "%s: move=%d steps\n", __func__, move);*/ DBG(DBG_info, "%s: move=%d steps\n", __func__, move);*/
if (session.params.flags & SCAN_FLAG_SINGLE_LINE) { if (has_flag(session.params.flags, ScanFlag::SINGLE_LINE)) {
gl841_init_motor_regs_off(reg, dev->model->is_cis ? session.output_line_count * session.params.channels gl841_init_motor_regs_off(reg, dev->model->is_cis ? session.output_line_count * session.params.channels
: session.output_line_count); : session.output_line_count);
} else { } else {
@ -1650,7 +1650,7 @@ dummy \ scanned lines
dev->model->is_cis ? session.output_line_count * session.params.channels dev->model->is_cis ? session.output_line_count * session.params.channels
: session.output_line_count, : session.output_line_count,
dummy, move, dummy, move,
(session.params.flags & SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE) ? has_flag(session.params.flags, ScanFlag::DISABLE_BUFFER_FULL_MOVE) ?
MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE : 0); MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE : 0);
} }
@ -1697,7 +1697,7 @@ ScanSession CommandSetGl841::calculate_scan_session(const Genesys_Device* dev,
session.params.scan_method = settings.scan_method; session.params.scan_method = settings.scan_method;
session.params.scan_mode = settings.scan_mode; session.params.scan_mode = settings.scan_mode;
session.params.color_filter = settings.color_filter; session.params.color_filter = settings.color_filter;
session.params.flags = 0; session.params.flags = ScanFlag::NONE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
@ -2389,10 +2389,10 @@ void CommandSetGl841::search_start_position(Genesys_Device* dev) const
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::GREEN; session.params.color_filter = ColorFilter::GREEN;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE | ScanFlag::IGNORE_LINE_DISTANCE |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE; ScanFlag::DISABLE_BUFFER_FULL_MOVE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl841_init_scan_regs(dev, sensor, &local_reg, session); gl841_init_scan_regs(dev, sensor, &local_reg, session);
@ -2456,10 +2456,10 @@ void CommandSetGl841::init_regs_for_coarse_calibration(Genesys_Device* dev,
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode; session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl841_init_scan_regs(dev, sensor, &regs, session); gl841_init_scan_regs(dev, sensor, &regs, session);
@ -2528,10 +2528,10 @@ void CommandSetGl841::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
/*SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |*/ /*ScanFlag::DISABLE_BUFFER_FULL_MOVE |*/
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, calib_sensor); compute_session(dev, session, calib_sensor);
gl841_init_scan_regs(dev, calib_sensor, &regs, session); gl841_init_scan_regs(dev, calib_sensor, &regs, session);
@ -2545,7 +2545,6 @@ void CommandSetGl841::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sensor& sensor) const void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sensor& sensor) const
{ {
DBG_HELPER(dbg); DBG_HELPER(dbg);
int flags;
float move; float move;
int move_dpi; int move_dpi;
float start; float start;
@ -2598,7 +2597,7 @@ void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
/* we enable true gray for cis scanners only, and just when doing /* we enable true gray for cis scanners only, and just when doing
* scan since color calibration is OK for this mode * scan since color calibration is OK for this mode
*/ */
flags = 0; ScanFlag flags = ScanFlag::NONE;
/* true gray (led add for cis scanners) */ /* true gray (led add for cis scanners) */
if(dev->model->is_cis && dev->settings.true_gray if(dev->model->is_cis && dev->settings.true_gray
@ -2607,7 +2606,7 @@ void CommandSetGl841::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
{ {
// on Lide 80 the LEDADD bit results in only red LED array being lit // on Lide 80 the LEDADD bit results in only red LED array being lit
DBG(DBG_io, "%s: activating LEDADD\n", __func__); DBG(DBG_io, "%s: activating LEDADD\n", __func__);
flags |= SCAN_FLAG_ENABLE_LEDADD; flags |= ScanFlag::ENABLE_LEDADD;
} }
ScanSession session; ScanSession session;
@ -2701,10 +2700,10 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, calib_sensor_base); compute_session(dev, session, calib_sensor_base);
gl841_init_scan_regs(dev, calib_sensor_base, &regs, session); gl841_init_scan_regs(dev, calib_sensor_base, &regs, session);
@ -2912,10 +2911,10 @@ static void ad_fe_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, calib_sensor); compute_session(dev, session, calib_sensor);
gl841_init_scan_regs(dev, calib_sensor, &regs, session); gl841_init_scan_regs(dev, calib_sensor, &regs, session);
@ -3041,11 +3040,11 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE | ScanFlag::IGNORE_LINE_DISTANCE |
SCAN_FLAG_DISABLE_LAMP; ScanFlag::DISABLE_LAMP;
compute_session(dev, session, calib_sensor); compute_session(dev, session, calib_sensor);
gl841_init_scan_regs(dev, calib_sensor, &regs, session); gl841_init_scan_regs(dev, calib_sensor, &regs, session);
@ -3412,10 +3411,10 @@ void CommandSetGl841::coarse_gain_calibration(Genesys_Device* dev, const Genesys
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, calib_sensor); compute_session(dev, session, calib_sensor);
gl841_init_scan_regs(dev, calib_sensor, &regs, session); gl841_init_scan_regs(dev, calib_sensor, &regs, session);
@ -3565,10 +3564,10 @@ void CommandSetGl841::init_regs_for_warmup(Genesys_Device* dev, const Genesys_Se
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
} }
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl841_init_scan_regs(dev, sensor, local_reg, session); gl841_init_scan_regs(dev, sensor, local_reg, session);
@ -3684,10 +3683,10 @@ void CommandSetGl841::init(Genesys_Device* dev) const
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, calib_sensor); compute_session(dev, session, calib_sensor);
gl841_init_scan_regs(dev, calib_sensor, &regs, session); gl841_init_scan_regs(dev, calib_sensor, &regs, session);
@ -3814,7 +3813,7 @@ void CommandSetGl841::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | SCAN_FLAG_DISABLE_GAMMA; session.params.flags = ScanFlag::DISABLE_SHADING | ScanFlag::DISABLE_GAMMA;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
size = pixels * channels * lines * (session.params.depth / 8); size = pixels * channels * lines * (session.params.depth / 8);

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

@ -1045,7 +1045,7 @@ static void gl843_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
/* enable shading */ /* enable shading */
r = sanei_genesys_get_address (reg, REG_0x01); r = sanei_genesys_get_address (reg, REG_0x01);
r->value &= ~REG_0x01_SCAN; r->value &= ~REG_0x01_SCAN;
if ((session.params.flags & SCAN_FLAG_DISABLE_SHADING) || if (has_flag(session.params.flags, ScanFlag::DISABLE_SHADING) ||
(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION || (dev->model->flags & GENESYS_FLAG_NO_CALIBRATION ||
(dev->model->flags & GENESYS_FLAG_CALIBRATION_HOST_SIDE))) (dev->model->flags & GENESYS_FLAG_CALIBRATION_HOST_SIDE)))
{ {
@ -1074,14 +1074,14 @@ static void gl843_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
// FIXME: we probably don't need to set exposure to registers at this point. It was this way // FIXME: we probably don't need to set exposure to registers at this point. It was this way
// before a refactor. // before a refactor.
sanei_genesys_set_lamp_power(dev, sensor, *reg, sanei_genesys_set_lamp_power(dev, sensor, *reg,
!(session.params.flags & SCAN_FLAG_DISABLE_LAMP)); !has_flag(session.params.flags, ScanFlag::DISABLE_LAMP));
/* select XPA */ /* select XPA */
r->value &= ~REG_0x03_XPASEL; r->value &= ~REG_0x03_XPASEL;
if (session.params.flags & SCAN_FLAG_USE_XPA) { if (has_flag(session.params.flags, ScanFlag::USE_XPA)) {
r->value |= REG_0x03_XPASEL; r->value |= REG_0x03_XPASEL;
} }
reg->state.is_xpa_on = session.params.flags & SCAN_FLAG_USE_XPA; reg->state.is_xpa_on = has_flag(session.params.flags, ScanFlag::USE_XPA);
/* BW threshold */ /* BW threshold */
r = sanei_genesys_get_address(reg, REG_0x2E); r = sanei_genesys_get_address(reg, REG_0x2E);
@ -1211,13 +1211,13 @@ static void gl843_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
/*** motor parameters ***/ /*** motor parameters ***/
mflags = 0; mflags = 0;
if (session.params.flags & SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE) { if (has_flag(session.params.flags, ScanFlag::DISABLE_BUFFER_FULL_MOVE)) {
mflags |= MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE; mflags |= MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE;
} }
if (session.params.flags & SCAN_FLAG_FEEDING) { if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
mflags |= MOTOR_FLAG_FEED; mflags |= MOTOR_FLAG_FEED;
} }
if (session.params.flags & SCAN_FLAG_USE_XPA) { if (has_flag(session.params.flags, ScanFlag::USE_XPA)) {
mflags |= MOTOR_FLAG_USE_XPA; mflags |= MOTOR_FLAG_USE_XPA;
} }
@ -1284,7 +1284,7 @@ ScanSession CommandSetGl843::calculate_scan_session(const Genesys_Device* dev,
session.params.scan_method = settings.scan_method; session.params.scan_method = settings.scan_method;
session.params.scan_mode = settings.scan_mode; session.params.scan_mode = settings.scan_mode;
session.params.color_filter = settings.color_filter; session.params.color_filter = settings.color_filter;
session.params.flags = 0; session.params.flags = ScanFlag::NONE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
@ -1856,10 +1856,10 @@ void CommandSetGl843::slow_back_home(Genesys_Device* dev, bool wait_until_home)
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::LINEART; session.params.scan_mode = ScanColorMode::LINEART;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE | ScanFlag::DISABLE_BUFFER_FULL_MOVE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl843_init_scan_regs(dev, sensor, &local_reg, session); gl843_init_scan_regs(dev, sensor, &local_reg, session);
@ -1954,10 +1954,10 @@ void CommandSetGl843::search_start_position(Genesys_Device* dev) const
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::GREEN; session.params.color_filter = ColorFilter::GREEN;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE | ScanFlag::IGNORE_LINE_DISTANCE |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE; ScanFlag::DISABLE_BUFFER_FULL_MOVE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl843_init_scan_regs(dev, sensor, &local_reg, session); gl843_init_scan_regs(dev, sensor, &local_reg, session);
@ -2006,14 +2006,14 @@ void CommandSetGl843::init_regs_for_coarse_calibration(Genesys_Device* dev,
{ {
DBG_HELPER(dbg); DBG_HELPER(dbg);
int flags = SCAN_FLAG_DISABLE_SHADING | ScanFlag flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY || if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) { dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) {
flags |= SCAN_FLAG_USE_XPA; flags |= ScanFlag::USE_XPA;
} }
ScanSession session; ScanSession session;
@ -2072,10 +2072,10 @@ static void gl843_feed(Genesys_Device* dev, unsigned int steps)
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_FEEDING | ScanFlag::FEEDING |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl843_init_scan_regs(dev, sensor, &local_reg, session); gl843_init_scan_regs(dev, sensor, &local_reg, session);
@ -2169,10 +2169,10 @@ void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
dev->calib_resolution = resolution; dev->calib_resolution = resolution;
int flags = SCAN_FLAG_DISABLE_SHADING | ScanFlag flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE | ScanFlag::DISABLE_BUFFER_FULL_MOVE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY || if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
@ -2180,7 +2180,7 @@ 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 // note: move_to_ta() function has already been called and the sensor is at the
// transparency adapter // transparency adapter
move = static_cast<int>(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; flags |= ScanFlag::USE_XPA;
} else { } else {
move = static_cast<int>(dev->model->y_offset_calib_white); move = static_cast<int>(dev->model->y_offset_calib_white);
} }
@ -2220,7 +2220,6 @@ void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sensor& sensor) const void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sensor& sensor) const
{ {
DBG_HELPER(dbg); DBG_HELPER(dbg);
int flags;
float move; float move;
int move_dpi; int move_dpi;
float start; float start;
@ -2229,7 +2228,7 @@ void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
move_dpi = dev->motor.base_ydpi; move_dpi = dev->motor.base_ydpi;
flags = 0; ScanFlag flags = ScanFlag::NONE;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY || if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
@ -2241,7 +2240,7 @@ void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
} else { } else {
move = static_cast<float>(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; flags |= ScanFlag::USE_XPA;
} else { } else {
if (dev->ignore_offsets) { if (dev->ignore_offsets) {
move = 0; move = 0;
@ -2362,10 +2361,10 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, calib_sensor); compute_session(dev, session, calib_sensor);
gl843_init_scan_regs(dev, calib_sensor, &regs, session); gl843_init_scan_regs(dev, calib_sensor, &regs, session);
@ -2562,15 +2561,15 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
target_pixels = static_cast<int>((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 | ScanFlag flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY || if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{ {
flags |= SCAN_FLAG_USE_XPA; flags |= ScanFlag::USE_XPA;
} }
ScanSession session; ScanSession session;
@ -2782,15 +2781,15 @@ void CommandSetGl843::coarse_gain_calibration(Genesys_Device* dev, const Genesys
lines=10; lines=10;
int target_pixels = sensor.sensor_pixels / factor; int target_pixels = sensor.sensor_pixels / factor;
int flags = SCAN_FLAG_DISABLE_SHADING | ScanFlag flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY || if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{ {
flags |= SCAN_FLAG_USE_XPA; flags |= ScanFlag::USE_XPA;
} }
const auto& calib_sensor = sanei_genesys_find_sensor(dev, resolution, channels, const auto& calib_sensor = sanei_genesys_find_sensor(dev, resolution, channels,
@ -2924,10 +2923,10 @@ void CommandSetGl843::init_regs_for_warmup(Genesys_Device* dev, const Genesys_Se
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, calib_sensor); compute_session(dev, session, calib_sensor);
gl843_init_scan_regs(dev, calib_sensor, reg, session); gl843_init_scan_regs(dev, calib_sensor, reg, session);
@ -3171,7 +3170,7 @@ void CommandSetGl843::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | SCAN_FLAG_DISABLE_SHADING; session.params.flags = ScanFlag::DISABLE_SHADING | ScanFlag::DISABLE_SHADING;
compute_session(dev, session, calib_sensor); compute_session(dev, session, calib_sensor);
gl843_init_scan_regs(dev, calib_sensor, &local_reg, session); gl843_init_scan_regs(dev, calib_sensor, &local_reg, session);

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

@ -633,7 +633,7 @@ static void gl846_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
r = sanei_genesys_get_address(reg, REG_0x01); r = sanei_genesys_get_address(reg, REG_0x01);
r->value &= ~REG_0x01_SCAN; r->value &= ~REG_0x01_SCAN;
r->value |= REG_0x01_SHDAREA; r->value |= REG_0x01_SHDAREA;
if ((session.params.flags & SCAN_FLAG_DISABLE_SHADING) || if (has_flag(session.params.flags, ScanFlag::DISABLE_SHADING) ||
(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)) (dev->model->flags & GENESYS_FLAG_NO_CALIBRATION))
{ {
r->value &= ~REG_0x01_DVDSET; r->value &= ~REG_0x01_DVDSET;
@ -647,7 +647,7 @@ static void gl846_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
r->value &= ~REG_0x03_AVEENB; r->value &= ~REG_0x03_AVEENB;
sanei_genesys_set_lamp_power(dev, sensor, *reg, sanei_genesys_set_lamp_power(dev, sensor, *reg,
!(session.params.flags & SCAN_FLAG_DISABLE_LAMP)); !has_flag(session.params.flags, ScanFlag::DISABLE_LAMP));
/* BW threshold */ /* BW threshold */
r = sanei_genesys_get_address (reg, 0x2e); r = sanei_genesys_get_address (reg, 0x2e);
@ -783,10 +783,10 @@ static void gl846_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
DBG(DBG_info, "%s: move=%d steps\n", __func__, move); DBG(DBG_info, "%s: move=%d steps\n", __func__, move);
mflags = 0; mflags = 0;
if (session.params.flags & SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE) { if (has_flag(session.params.flags, ScanFlag::DISABLE_BUFFER_FULL_MOVE)) {
mflags |= MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE; mflags |= MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE;
} }
if (session.params.flags & SCAN_FLAG_FEEDING) { if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
mflags |= MOTOR_FLAG_FEED; mflags |= MOTOR_FLAG_FEED;
} }
@ -837,7 +837,7 @@ ScanSession CommandSetGl846::calculate_scan_session(const Genesys_Device* dev,
session.params.scan_method = settings.scan_method; session.params.scan_method = settings.scan_method;
session.params.scan_mode = settings.scan_mode; session.params.scan_mode = settings.scan_mode;
session.params.color_filter = settings.color_filter; session.params.color_filter = settings.color_filter;
session.params.flags = 0; session.params.flags = ScanFlag::NONE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
@ -1016,9 +1016,9 @@ void CommandSetGl846::slow_back_home(Genesys_Device* dev, bool wait_until_home)
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &local_reg, session); gl846_init_scan_regs(dev, sensor, &local_reg, session);
@ -1114,9 +1114,9 @@ void CommandSetGl846::search_start_position(Genesys_Device* dev) const
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::GREEN; session.params.color_filter = ColorFilter::GREEN;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &local_reg, session); gl846_init_scan_regs(dev, sensor, &local_reg, session);
@ -1182,10 +1182,10 @@ void CommandSetGl846::init_regs_for_coarse_calibration(Genesys_Device* dev,
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode; session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &regs, session); gl846_init_scan_regs(dev, sensor, &regs, session);
@ -1225,10 +1225,10 @@ static void gl846_feed(Genesys_Device* dev, unsigned int steps)
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_FEEDING | ScanFlag::FEEDING |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &local_reg, session); gl846_init_scan_regs(dev, sensor, &local_reg, session);
@ -1319,10 +1319,10 @@ void CommandSetGl846::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE | ScanFlag::DISABLE_BUFFER_FULL_MOVE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &regs, session); gl846_init_scan_regs(dev, sensor, &regs, session);
@ -1404,7 +1404,7 @@ void CommandSetGl846::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
session.params.scan_mode = dev->settings.scan_mode; session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
// backtracking isn't handled well, so don't enable it // backtracking isn't handled well, so don't enable it
session.params.flags = SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE; session.params.flags = ScanFlag::DISABLE_BUFFER_FULL_MOVE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &dev->reg, session); gl846_init_scan_regs(dev, sensor, &dev->reg, session);
@ -1537,10 +1537,10 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &regs, session); gl846_init_scan_regs(dev, sensor, &regs, session);
@ -1870,8 +1870,8 @@ void CommandSetGl846::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
session.params.channels = channels; session.params.channels = channels;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA; ScanFlag::DISABLE_GAMMA;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &local_reg, session); gl846_init_scan_regs(dev, sensor, &local_reg, session);
@ -2097,10 +2097,10 @@ void CommandSetGl846::offset_calibration(Genesys_Device* dev, const Genesys_Sens
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl846_init_scan_regs(dev, sensor, &regs, session); gl846_init_scan_regs(dev, sensor, &regs, session);
@ -2251,10 +2251,10 @@ void CommandSetGl846::coarse_gain_calibration(Genesys_Device* dev, const Genesys
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
try { try {

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

@ -642,7 +642,7 @@ static void gl847_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
r->value &= ~REG_0x01_SCAN; r->value &= ~REG_0x01_SCAN;
r->value |= REG_0x01_SHDAREA; r->value |= REG_0x01_SHDAREA;
if ((session.params.flags & SCAN_FLAG_DISABLE_SHADING) || if (has_flag(session.params.flags, ScanFlag::DISABLE_SHADING) ||
(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)) (dev->model->flags & GENESYS_FLAG_NO_CALIBRATION))
{ {
r->value &= ~REG_0x01_DVDSET; r->value &= ~REG_0x01_DVDSET;
@ -656,7 +656,7 @@ static void gl847_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
r->value &= ~REG_0x03_AVEENB; r->value &= ~REG_0x03_AVEENB;
sanei_genesys_set_lamp_power(dev, sensor, *reg, sanei_genesys_set_lamp_power(dev, sensor, *reg,
!(session.params.flags & SCAN_FLAG_DISABLE_LAMP)); !has_flag(session.params.flags, ScanFlag::DISABLE_LAMP));
/* BW threshold */ /* BW threshold */
r = sanei_genesys_get_address (reg, 0x2e); r = sanei_genesys_get_address (reg, 0x2e);
@ -790,10 +790,10 @@ static void gl847_init_scan_regs(Genesys_Device* dev, const Genesys_Sensor& sens
DBG(DBG_info, "%s: move=%d steps\n", __func__, move); DBG(DBG_info, "%s: move=%d steps\n", __func__, move);
mflags=0; mflags=0;
if (session.params.flags & SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE) { if (has_flag(session.params.flags, ScanFlag::DISABLE_BUFFER_FULL_MOVE)) {
mflags |= MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE; mflags |= MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE;
} }
if (session.params.flags & SCAN_FLAG_FEEDING) { if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
mflags |= MOTOR_FLAG_FEED; mflags |= MOTOR_FLAG_FEED;
} }
@ -842,7 +842,7 @@ ScanSession CommandSetGl847::calculate_scan_session(const Genesys_Device* dev,
session.params.scan_method = settings.scan_method; session.params.scan_method = settings.scan_method;
session.params.scan_mode = settings.scan_mode; session.params.scan_mode = settings.scan_mode;
session.params.color_filter = settings.color_filter; session.params.color_filter = settings.color_filter;
session.params.flags = 0; session.params.flags = ScanFlag::NONE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
@ -1061,9 +1061,9 @@ void CommandSetGl847::slow_back_home(Genesys_Device* dev, bool wait_until_home)
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl847_init_scan_regs(dev, sensor, &local_reg, session); gl847_init_scan_regs(dev, sensor, &local_reg, session);
@ -1157,9 +1157,9 @@ void CommandSetGl847::search_start_position(Genesys_Device* dev) const
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::GREEN; session.params.color_filter = ColorFilter::GREEN;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl847_init_scan_regs(dev, sensor, &local_reg, session); gl847_init_scan_regs(dev, sensor, &local_reg, session);
@ -1225,10 +1225,10 @@ void CommandSetGl847::init_regs_for_coarse_calibration(Genesys_Device* dev,
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode; session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl847_init_scan_regs(dev, sensor, &regs, session); gl847_init_scan_regs(dev, sensor, &regs, session);
@ -1267,10 +1267,10 @@ static void gl847_feed(Genesys_Device* dev, unsigned int steps)
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_FEEDING | ScanFlag::FEEDING |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl847_init_scan_regs(dev, sensor, &local_reg, session); gl847_init_scan_regs(dev, sensor, &local_reg, session);
@ -1352,10 +1352,10 @@ void CommandSetGl847::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE | ScanFlag::DISABLE_BUFFER_FULL_MOVE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl847_init_scan_regs(dev, sensor, &regs, session); gl847_init_scan_regs(dev, sensor, &regs, session);
@ -1436,7 +1436,7 @@ void CommandSetGl847::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
session.params.scan_mode = dev->settings.scan_mode; session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
// backtracking isn't handled well, so don't enable it // backtracking isn't handled well, so don't enable it
session.params.flags = SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE; session.params.flags = ScanFlag::DISABLE_BUFFER_FULL_MOVE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl847_init_scan_regs(dev, sensor, &dev->reg, session); gl847_init_scan_regs(dev, sensor, &dev->reg, session);
@ -1570,10 +1570,10 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl847_init_scan_regs(dev, sensor, &regs, session); gl847_init_scan_regs(dev, sensor, &regs, session);
@ -1934,8 +1934,8 @@ void CommandSetGl847::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::GRAY; session.params.scan_mode = ScanColorMode::GRAY;
session.params.color_filter = ColorFilter::RED; session.params.color_filter = ColorFilter::RED;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA; ScanFlag::DISABLE_GAMMA;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
size = pixels * channels * lines * (session.params.depth / 8); size = pixels * channels * lines * (session.params.depth / 8);
@ -2162,10 +2162,10 @@ void CommandSetGl847::offset_calibration(Genesys_Device* dev, const Genesys_Sens
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
gl847_init_scan_regs(dev, sensor, &regs, session); gl847_init_scan_regs(dev, sensor, &regs, session);
@ -2315,10 +2315,10 @@ void CommandSetGl847::coarse_gain_calibration(Genesys_Device* dev, const Genesys
session.params.scan_method = dev->settings.scan_method; session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS; session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter; session.params.color_filter = dev->settings.color_filter;
session.params.flags = SCAN_FLAG_DISABLE_SHADING | session.params.flags = ScanFlag::DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA | ScanFlag::DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE | ScanFlag::SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE; ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor); compute_session(dev, session, sensor);
try { try {

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

@ -600,7 +600,7 @@ void sanei_genesys_set_motor_power(Genesys_Register_Set& regs, bool set)
bool should_enable_gamma(const ScanSession& session, const Genesys_Sensor& sensor) bool should_enable_gamma(const ScanSession& session, const Genesys_Sensor& sensor)
{ {
if (session.params.flags & SCAN_FLAG_DISABLE_GAMMA) { if ((session.params.flags & ScanFlag::DISABLE_GAMMA) != ScanFlag::NONE) {
return false; return false;
} }
if (sensor.gamma[0] == 1.0f || sensor.gamma[1] == 1.0f || sensor.gamma[2] == 1.0f) { if (sensor.gamma[0] == 1.0f || sensor.gamma[1] == 1.0f || sensor.gamma[2] == 1.0f) {
@ -851,7 +851,7 @@ void compute_session_pixel_offsets(const Genesys_Device* dev, ScanSession& s,
// startx cannot be below dummy pixel value // startx cannot be below dummy pixel value
s.pixel_startx = sensor.dummy_pixel; s.pixel_startx = sensor.dummy_pixel;
if ((s.params.flags & SCAN_FLAG_USE_XCORRECTION) && sensor.ccd_start_xoffset > 0) { if (has_flag(s.params.flags, ScanFlag::USE_XCORRECTION) && sensor.ccd_start_xoffset > 0) {
s.pixel_startx = sensor.ccd_start_xoffset; s.pixel_startx = sensor.ccd_start_xoffset;
} }
s.pixel_startx += s.params.startx; s.pixel_startx += s.params.startx;
@ -1045,7 +1045,7 @@ void compute_session(const Genesys_Device* dev, ScanSession& s, const Genesys_Se
if (dev->model->asic_type == AsicType::GL843) { if (dev->model->asic_type == AsicType::GL843) {
if ((s.params.yres > 1200) && // FIXME: maybe ccd_size_divisor is the one that controls this? if ((s.params.yres > 1200) && // FIXME: maybe ccd_size_divisor is the one that controls this?
((s.params.flags & SCAN_FLAG_IGNORE_LINE_DISTANCE) == 0) && !has_flag(s.params.flags, ScanFlag::IGNORE_LINE_DISTANCE) &&
(dev->model->flags & GENESYS_FLAG_STAGGERED_LINE)) (dev->model->flags & GENESYS_FLAG_STAGGERED_LINE))
{ {
s.num_staggered_lines = (4 * s.params.yres) / dev->motor.base_ydpi; s.num_staggered_lines = (4 * s.params.yres) / dev->motor.base_ydpi;
@ -1068,7 +1068,7 @@ void compute_session(const Genesys_Device* dev, ScanSession& s, const Genesys_Se
s.color_shift_lines_b = (s.color_shift_lines_b * s.params.yres) / dev->motor.base_ydpi; s.color_shift_lines_b = (s.color_shift_lines_b * s.params.yres) / dev->motor.base_ydpi;
s.max_color_shift_lines = 0; s.max_color_shift_lines = 0;
if (s.params.channels > 1 && !(s.params.flags & SCAN_FLAG_IGNORE_LINE_DISTANCE)) { if (s.params.channels > 1 && !has_flag(s.params.flags, ScanFlag::IGNORE_LINE_DISTANCE)) {
s.max_color_shift_lines = std::max(s.color_shift_lines_r, std::max(s.color_shift_lines_g, s.max_color_shift_lines = std::max(s.color_shift_lines_r, std::max(s.color_shift_lines_g,
s.color_shift_lines_b)); s.color_shift_lines_b));
} }
@ -1182,7 +1182,7 @@ void compute_session(const Genesys_Device* dev, ScanSession& s, const Genesys_Se
{ {
// no 16 bit gamma for this ASIC // no 16 bit gamma for this ASIC
if (s.params.depth == 16) { if (s.params.depth == 16) {
s.params.flags |= SCAN_FLAG_DISABLE_GAMMA; s.params.flags |= ScanFlag::DISABLE_GAMMA;
} }
} }

11
backend/genesys/low.h
Wyświetl plik

@ -242,17 +242,6 @@ extern StaticInit<std::vector<Motor_Profile>> gl124_motor_profiles;
constexpr unsigned SLOPE_TABLE_SIZE = 1024; constexpr unsigned SLOPE_TABLE_SIZE = 1024;
#define SCAN_FLAG_SINGLE_LINE 0x001
#define SCAN_FLAG_DISABLE_SHADING 0x002
#define SCAN_FLAG_DISABLE_GAMMA 0x004
#define SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE 0x008
#define SCAN_FLAG_IGNORE_LINE_DISTANCE 0x010
#define SCAN_FLAG_DISABLE_LAMP 0x040
#define SCAN_FLAG_CALIBRATION 0x100
#define SCAN_FLAG_FEEDING 0x200
#define SCAN_FLAG_USE_XPA 0x400
#define SCAN_FLAG_ENABLE_LEDADD 0x800
#define SCAN_FLAG_USE_XCORRECTION 0x1000
#define MOTOR_FLAG_AUTO_GO_HOME 0x01 #define MOTOR_FLAG_AUTO_GO_HOME 0x01
#define MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE 0x02 #define MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE 0x02
#define MOTOR_FLAG_FEED 0x04 #define MOTOR_FLAG_FEED 0x04

2
backend/genesys/settings.cpp
Wyświetl plik

@ -82,7 +82,7 @@ std::ostream& operator<<(std::ostream& out, const SetupParams& params)
<< " startx: " << params.startx << " starty: " << params.starty << '\n' << " startx: " << params.startx << " starty: " << params.starty << '\n'
<< " scan_mode: " << params.scan_mode << '\n' << " scan_mode: " << params.scan_mode << '\n'
<< " color_filter: " << params.color_filter << '\n' << " color_filter: " << params.color_filter << '\n'
<< " flags: 0x" << std::hex << params.flags << std::dec << '\n' << " flags: " << params.flags << '\n'
<< "}"; << "}";
return out; return out;
} }

5
backend/genesys/settings.h
Wyświetl plik

@ -144,7 +144,7 @@ struct SetupParams {
ColorFilter color_filter = static_cast<ColorFilter>(NOT_SET); ColorFilter color_filter = static_cast<ColorFilter>(NOT_SET);
unsigned flags = NOT_SET; ScanFlag flags;
unsigned get_requested_pixels() const unsigned get_requested_pixels() const
{ {
@ -160,8 +160,7 @@ struct SetupParams {
pixels == NOT_SET || lines == NOT_SET ||depth == NOT_SET || channels == NOT_SET || pixels == NOT_SET || lines == NOT_SET ||depth == NOT_SET || channels == NOT_SET ||
scan_method == static_cast<ScanMethod>(NOT_SET) || scan_method == static_cast<ScanMethod>(NOT_SET) ||
scan_mode == static_cast<ScanColorMode>(NOT_SET) || scan_mode == static_cast<ScanColorMode>(NOT_SET) ||
color_filter == static_cast<ColorFilter>(NOT_SET) || color_filter == static_cast<ColorFilter>(NOT_SET))
flags == NOT_SET)
{ {
throw std::runtime_error("SetupParams are not valid"); throw std::runtime_error("SetupParams are not valid");
} }