diff --git a/backend/genesys/enums.cpp b/backend/genesys/enums.cpp
index c84fa3ccc..f515cfdd0 100644
--- a/backend/genesys/enums.cpp
+++ b/backend/genesys/enums.cpp
@@ -45,6 +45,7 @@
 
 #include "enums.h"
 #include "genesys.h"
+#include <iomanip>
 
 namespace genesys {
 
@@ -120,5 +121,11 @@ std::ostream& operator<<(std::ostream& out, StepType type)
     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
diff --git a/backend/genesys/enums.h b/backend/genesys/enums.h
index 552b37a71..15a5e2fa9 100644
--- a/backend/genesys/enums.h
+++ b/backend/genesys/enums.h
@@ -410,6 +410,59 @@ enum class AsicType : unsigned
     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
 
 #endif // BACKEND_GENESYS_ENUMS_H
diff --git a/backend/genesys/gl124.cpp b/backend/genesys/gl124.cpp
index 3a39dbe23..5b0bd208e 100644
--- a/backend/genesys/gl124.cpp
+++ b/backend/genesys/gl124.cpp
@@ -756,7 +756,7 @@ static void gl124_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
   /* enable shading */
     r = sanei_genesys_get_address (reg, REG_0x01);
     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))
     {
         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,
-                                 !(session.params.flags & SCAN_FLAG_DISABLE_LAMP));
+                                 !has_flag(session.params.flags, ScanFlag::DISABLE_LAMP));
 
     // BW 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;
     }
 
-    if(session.params.flags & SCAN_FLAG_FEEDING) {
+    if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
         exposure_time = 2304;
     } else {
         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);
 
     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;
     }
-    if (session.params.flags & SCAN_FLAG_FEEDING) {
+    if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
         mflags |= MOTOR_FLAG_FEED;
     }
     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_mode = settings.scan_mode;
     session.params.color_filter = settings.color_filter;
-    session.params.flags = 0;
+    session.params.flags = ScanFlag::NONE;
 
     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_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::RED;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_FEEDING |
-                           SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::FEEDING |
+                           ScanFlag::DISABLE_BUFFER_FULL_MOVE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::GREEN;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE |
-                           SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::IGNORE_LINE_DISTANCE |
+                           ScanFlag::DISABLE_BUFFER_FULL_MOVE;
     compute_session(dev, session, sensor);
 
     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_mode = dev->settings.scan_mode;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_FEEDING |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::FEEDING |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = ColorFilter::RED;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::DISABLE_BUFFER_FULL_MOVE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = dev->settings.scan_mode;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = 0;
+    session.params.flags = ScanFlag::NONE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     gl124_init_scan_regs(dev, sensor, reg, session);
diff --git a/backend/genesys/gl646.cpp b/backend/genesys/gl646.cpp
index a6300f482..672b0cf6f 100644
--- a/backend/genesys/gl646.cpp
+++ b/backend/genesys/gl646.cpp
@@ -342,10 +342,10 @@ static void gl646_setup_registers(Genesys_Device* dev,
 
   /* select XPA */
     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->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 */
   /* 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_mode = settings.scan_mode;
     session.params.color_filter = settings.color_filter;
-    session.params.flags = 0;
+    session.params.flags = ScanFlag::NONE;
     if (settings.scan_method == ScanMethod::TRANSPARENCY) {
-        session.params.flags |= SCAN_FLAG_USE_XPA;
+        session.params.flags |= ScanFlag::USE_XPA;
     }
     if (xcorrection) {
-        session.params.flags |= SCAN_FLAG_USE_XCORRECTION;
+        session.params.flags |= ScanFlag::USE_XCORRECTION;
     }
     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_mode = settings.scan_mode;
     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) {
-        session.params.flags |= SCAN_FLAG_USE_XPA;
+        session.params.flags |= ScanFlag::USE_XPA;
     }
     compute_session(dev, session, sensor);
 
diff --git a/backend/genesys/gl841.cpp b/backend/genesys/gl841.cpp
index f807d1285..ad908ca35 100644
--- a/backend/genesys/gl841.cpp
+++ b/backend/genesys/gl841.cpp
@@ -1346,7 +1346,7 @@ static void gl841_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
     /* enable shading */
     r = sanei_genesys_get_address (reg, 0x01);
     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)) {
         r->value &= ~REG_0x01_DVDSET;
     } 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->value |= REG_0x03_AVEENB;
     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 */
     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
      * bits separately */
     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 */
     }
     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 */
     r = sanei_genesys_get_address (reg, 0x87);
     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;
         expr = reg->get16(REG_EXPR);
         expg = reg->get16(REG_EXPG);
@@ -1642,7 +1642,7 @@ dummy \ scanned lines
 /*  move = ((move + dummy) / (dummy + 1)) * (dummy + 1);
     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
                                                           : session.output_line_count);
     } else {
@@ -1650,7 +1650,7 @@ dummy \ scanned lines
                                    dev->model->is_cis ? session.output_line_count * session.params.channels
                                                       : session.output_line_count,
                                    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);
   }
 
@@ -1697,7 +1697,7 @@ ScanSession CommandSetGl841::calculate_scan_session(const Genesys_Device* dev,
     session.params.scan_method = settings.scan_method;
     session.params.scan_mode = settings.scan_mode;
     session.params.color_filter = settings.color_filter;
-    session.params.flags = 0;
+    session.params.flags = ScanFlag::NONE;
 
     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_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::GREEN;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE |
-                           SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::IGNORE_LINE_DISTANCE |
+                           ScanFlag::DISABLE_BUFFER_FULL_MOVE;
     compute_session(dev, session, sensor);
 
     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_mode = dev->settings.scan_mode;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           /*SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |*/
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           /*ScanFlag::DISABLE_BUFFER_FULL_MOVE |*/
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, calib_sensor);
 
     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
 {
     DBG_HELPER(dbg);
-  int flags;
   float move;
   int move_dpi;
   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
    * scan since color calibration is OK for this mode
    */
-  flags = 0;
+    ScanFlag flags = ScanFlag::NONE;
 
   /* true gray (led add for cis scanners) */
   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
       DBG(DBG_io, "%s: activating LEDADD\n", __func__);
-      flags |= SCAN_FLAG_ENABLE_LEDADD;
+        flags |= ScanFlag::ENABLE_LEDADD;
     }
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, calib_sensor_base);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, calib_sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE |
-                           SCAN_FLAG_DISABLE_LAMP;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE |
+                           ScanFlag::DISABLE_LAMP;
     compute_session(dev, session, calib_sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, calib_sensor);
 
     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.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = ColorFilter::RED;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, calib_sensor);
 
     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_mode = ScanColorMode::GRAY;
     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);
 
     size = pixels * channels * lines * (session.params.depth / 8);
diff --git a/backend/genesys/gl843.cpp b/backend/genesys/gl843.cpp
index 57c00ebd5..45cc5172a 100644
--- a/backend/genesys/gl843.cpp
+++ b/backend/genesys/gl843.cpp
@@ -1045,7 +1045,7 @@ static void gl843_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
   /* enable shading */
     r = sanei_genesys_get_address (reg, REG_0x01);
     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_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
     // before a refactor.
     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 */
     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;
     }
-    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 */
     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 ***/
     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;
     }
-    if (session.params.flags & SCAN_FLAG_FEEDING) {
+    if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
         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;
     }
 
@@ -1284,7 +1284,7 @@ ScanSession CommandSetGl843::calculate_scan_session(const Genesys_Device* dev,
     session.params.scan_method = settings.scan_method;
     session.params.scan_mode = settings.scan_mode;
     session.params.color_filter = settings.color_filter;
-    session.params.flags = 0;
+    session.params.flags = ScanFlag::NONE;
 
     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_mode = ScanColorMode::LINEART;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags =  SCAN_FLAG_DISABLE_SHADING |
-                            SCAN_FLAG_DISABLE_GAMMA |
-                            SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |
-                            SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags =  ScanFlag::DISABLE_SHADING |
+                            ScanFlag::DISABLE_GAMMA |
+                            ScanFlag::DISABLE_BUFFER_FULL_MOVE |
+                            ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::GREEN;
-    session.params.flags =  SCAN_FLAG_DISABLE_SHADING |
-                            SCAN_FLAG_DISABLE_GAMMA |
-                            SCAN_FLAG_IGNORE_LINE_DISTANCE |
-                            SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE;
+    session.params.flags =  ScanFlag::DISABLE_SHADING |
+                            ScanFlag::DISABLE_GAMMA |
+                            ScanFlag::IGNORE_LINE_DISTANCE |
+                            ScanFlag::DISABLE_BUFFER_FULL_MOVE;
     compute_session(dev, session, sensor);
 
     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);
 
-  int flags = SCAN_FLAG_DISABLE_SHADING |
-              SCAN_FLAG_DISABLE_GAMMA |
-              SCAN_FLAG_SINGLE_LINE |
-              SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    ScanFlag flags = ScanFlag::DISABLE_SHADING |
+                     ScanFlag::DISABLE_GAMMA |
+                     ScanFlag::SINGLE_LINE |
+                     ScanFlag::IGNORE_LINE_DISTANCE;
 
     if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
         dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) {
-        flags |= SCAN_FLAG_USE_XPA;
+        flags |= ScanFlag::USE_XPA;
     }
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = ColorFilter::RED;
-    session.params.flags =  SCAN_FLAG_DISABLE_SHADING |
-                            SCAN_FLAG_DISABLE_GAMMA |
-                            SCAN_FLAG_FEEDING |
-                            SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags =  ScanFlag::DISABLE_SHADING |
+                            ScanFlag::DISABLE_GAMMA |
+                            ScanFlag::FEEDING |
+                            ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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;
 
-  int flags = SCAN_FLAG_DISABLE_SHADING |
-              SCAN_FLAG_DISABLE_GAMMA |
-              SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |
-              SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    ScanFlag flags = ScanFlag::DISABLE_SHADING |
+                     ScanFlag::DISABLE_GAMMA |
+                     ScanFlag::DISABLE_BUFFER_FULL_MOVE |
+                     ScanFlag::IGNORE_LINE_DISTANCE;
 
     if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
         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
         // transparency adapter
         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 {
         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
 {
     DBG_HELPER(dbg);
-  int flags;
   float move;
   int move_dpi;
   float start;
@@ -2229,7 +2228,7 @@ void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
 
   move_dpi = dev->motor.base_ydpi;
 
-  flags = 0;
+    ScanFlag flags = ScanFlag::NONE;
 
     if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
         dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
@@ -2241,7 +2240,7 @@ void CommandSetGl843::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
         } else {
             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 {
         if (dev->ignore_offsets) {
             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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags =  SCAN_FLAG_DISABLE_SHADING |
-                            SCAN_FLAG_DISABLE_GAMMA |
-                            SCAN_FLAG_SINGLE_LINE |
-                            SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags =  ScanFlag::DISABLE_SHADING |
+                            ScanFlag::DISABLE_GAMMA |
+                            ScanFlag::SINGLE_LINE |
+                            ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, calib_sensor);
 
     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);
     }
 
-  int flags = SCAN_FLAG_DISABLE_SHADING |
-              SCAN_FLAG_DISABLE_GAMMA |
-              SCAN_FLAG_SINGLE_LINE |
-              SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    ScanFlag flags = ScanFlag::DISABLE_SHADING |
+                     ScanFlag::DISABLE_GAMMA |
+                     ScanFlag::SINGLE_LINE |
+                     ScanFlag::IGNORE_LINE_DISTANCE;
 
     if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
         dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
     {
-        flags |= SCAN_FLAG_USE_XPA;
+        flags |= ScanFlag::USE_XPA;
     }
 
     ScanSession session;
@@ -2782,15 +2781,15 @@ void CommandSetGl843::coarse_gain_calibration(Genesys_Device* dev, const Genesys
   lines=10;
   int target_pixels = sensor.sensor_pixels / factor;
 
-  int flags = SCAN_FLAG_DISABLE_SHADING |
-              SCAN_FLAG_DISABLE_GAMMA |
-              SCAN_FLAG_SINGLE_LINE |
-              SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    ScanFlag flags = ScanFlag::DISABLE_SHADING |
+                     ScanFlag::DISABLE_GAMMA |
+                     ScanFlag::SINGLE_LINE |
+                     ScanFlag::IGNORE_LINE_DISTANCE;
 
     if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
         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,
@@ -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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags =  SCAN_FLAG_DISABLE_SHADING |
-                            SCAN_FLAG_DISABLE_GAMMA |
-                            SCAN_FLAG_SINGLE_LINE |
-                            SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags =  ScanFlag::DISABLE_SHADING |
+                            ScanFlag::DISABLE_GAMMA |
+                            ScanFlag::SINGLE_LINE |
+                            ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, calib_sensor);
 
     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_mode = ScanColorMode::GRAY;
     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);
 
     gl843_init_scan_regs(dev, calib_sensor, &local_reg, session);
diff --git a/backend/genesys/gl846.cpp b/backend/genesys/gl846.cpp
index 6cb815ebf..c0ef21043 100644
--- a/backend/genesys/gl846.cpp
+++ b/backend/genesys/gl846.cpp
@@ -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->value &= ~REG_0x01_SCAN;
     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))
     {
         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;
 
     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 */
   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);
 
     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;
     }
-    if (session.params.flags & SCAN_FLAG_FEEDING) {
+    if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
         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_mode = settings.scan_mode;
     session.params.color_filter = settings.color_filter;
-    session.params.flags = 0;
+    session.params.flags = ScanFlag::NONE;
 
     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_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::RED;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::GREEN;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = dev->settings.scan_mode;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_FEEDING |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::FEEDING |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                   SCAN_FLAG_DISABLE_GAMMA |
-                   SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |
-                   SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                   ScanFlag::DISABLE_GAMMA |
+                   ScanFlag::DISABLE_BUFFER_FULL_MOVE |
+                   ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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.color_filter = dev->settings.color_filter;
     // 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);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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.scan_mode = ScanColorMode::GRAY;
     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);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     try {
diff --git a/backend/genesys/gl847.cpp b/backend/genesys/gl847.cpp
index 1bd95596f..c9e67417e 100644
--- a/backend/genesys/gl847.cpp
+++ b/backend/genesys/gl847.cpp
@@ -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_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))
     {
         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;
 
     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 */
     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);
 
   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;
     }
-    if (session.params.flags & SCAN_FLAG_FEEDING) {
+    if (has_flag(session.params.flags, ScanFlag::FEEDING)) {
         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_mode = settings.scan_mode;
     session.params.color_filter = settings.color_filter;
-    session.params.flags = 0;
+    session.params.flags = ScanFlag::NONE;
 
     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_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::RED;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::GREEN;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = dev->settings.scan_mode;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_FEEDING |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::FEEDING |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::DISABLE_BUFFER_FULL_MOVE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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.color_filter = dev->settings.color_filter;
     // 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);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::GRAY;
     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);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     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_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev->settings.color_filter;
-    session.params.flags = SCAN_FLAG_DISABLE_SHADING |
-                           SCAN_FLAG_DISABLE_GAMMA |
-                           SCAN_FLAG_SINGLE_LINE |
-                           SCAN_FLAG_IGNORE_LINE_DISTANCE;
+    session.params.flags = ScanFlag::DISABLE_SHADING |
+                           ScanFlag::DISABLE_GAMMA |
+                           ScanFlag::SINGLE_LINE |
+                           ScanFlag::IGNORE_LINE_DISTANCE;
     compute_session(dev, session, sensor);
 
     try {
diff --git a/backend/genesys/low.cpp b/backend/genesys/low.cpp
index 8483a9b85..53ef44cd6 100644
--- a/backend/genesys/low.cpp
+++ b/backend/genesys/low.cpp
@@ -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)
 {
-    if (session.params.flags & SCAN_FLAG_DISABLE_GAMMA) {
+    if ((session.params.flags & ScanFlag::DISABLE_GAMMA) != ScanFlag::NONE) {
         return false;
     }
     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
         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 += 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 ((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))
         {
             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.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.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
         if (s.params.depth == 16) {
-            s.params.flags |= SCAN_FLAG_DISABLE_GAMMA;
+            s.params.flags |= ScanFlag::DISABLE_GAMMA;
         }
     }
 
diff --git a/backend/genesys/low.h b/backend/genesys/low.h
index 7916c75dc..312efe643 100644
--- a/backend/genesys/low.h
+++ b/backend/genesys/low.h
@@ -242,17 +242,6 @@ extern StaticInit<std::vector<Motor_Profile>> gl124_motor_profiles;
 
 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_DISABLE_BUFFER_FULL_MOVE 0x02
 #define MOTOR_FLAG_FEED                     0x04
diff --git a/backend/genesys/settings.cpp b/backend/genesys/settings.cpp
index 7e52f28b2..41c66de78 100644
--- a/backend/genesys/settings.cpp
+++ b/backend/genesys/settings.cpp
@@ -82,7 +82,7 @@ std::ostream& operator<<(std::ostream& out, const SetupParams& params)
         << "    startx: " << params.startx << " starty: " << params.starty << '\n'
         << "    scan_mode: " << params.scan_mode << '\n'
         << "    color_filter: " << params.color_filter << '\n'
-        << "    flags: 0x" << std::hex << params.flags << std::dec << '\n'
+        << "    flags: " << params.flags << '\n'
         << "}";
     return out;
 }
diff --git a/backend/genesys/settings.h b/backend/genesys/settings.h
index 1cb83e60c..a697e604a 100644
--- a/backend/genesys/settings.h
+++ b/backend/genesys/settings.h
@@ -144,7 +144,7 @@ struct SetupParams {
 
     ColorFilter color_filter = static_cast<ColorFilter>(NOT_SET);
 
-    unsigned flags = NOT_SET;
+    ScanFlag flags;
 
     unsigned get_requested_pixels() const
     {
@@ -160,8 +160,7 @@ struct SetupParams {
             pixels == NOT_SET || lines == NOT_SET ||depth == NOT_SET || channels == NOT_SET ||
             scan_method == static_cast<ScanMethod>(NOT_SET) ||
             scan_mode == static_cast<ScanColorMode>(NOT_SET) ||
-            color_filter == static_cast<ColorFilter>(NOT_SET) ||
-            flags == NOT_SET)
+            color_filter == static_cast<ColorFilter>(NOT_SET))
         {
             throw std::runtime_error("SetupParams are not valid");
         }