Merge branch 'release/debian/1.1.1-1'debian/1.1.1-1

1 files changed, 55 insertions, 141 deletions

diff --git a/backend/genesys/genesys.cpp b/backend/genesys/genesys.cpp
index 9552fa9..5aba58c 100644
--- a/backend/genesys/genesys.cpp
+++ b/backend/genesys/genesys.cpp
@@ -29,27 +29,6 @@
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-   As a special exception, the authors of SANE give permission for
-   additional uses of the libraries contained in this release of SANE.
-
-   The exception is that, if you link a SANE library with other files
-   to produce an executable, this does not by itself cause the
-   resulting executable to be covered by the GNU General Public
-   License.  Your use of that executable is in no way restricted on
-   account of linking the SANE library code into it.
-
-   This exception does not, however, invalidate any other reasons why
-   the executable file might be covered by the GNU General Public
-   License.
-
-   If you submit changes to SANE to the maintainers to be included in
-   a subsequent release, you agree by submitting the changes that
-   those changes may be distributed with this exception intact.
-
-   If you write modifications of your own for SANE, it is your choice
-   whether to permit this exception to apply to your modifications.
-   If you do not wish that, delete this exception notice.
 */
 
 /*
@@ -674,9 +653,9 @@ void scanner_setup_sensor(Genesys_Device& dev, const Genesys_Sensor& sensor,
         regs.set8(custom_reg.address, custom_reg.value);
     }
 
-    if (dev.model->asic_type != AsicType::GL841 &&
-        dev.model->asic_type != AsicType::GL843)
+    if (dev.model->asic_type != AsicType::GL843)
     {
+        // FIXME: remove the above check
         regs_set_exposure(dev.model->asic_type, regs, sensor.exposure);
     }
 
@@ -795,6 +774,8 @@ void scanner_move(Genesys_Device& dev, ScanMethod scan_method, unsigned steps, D
     session.params.scan_method = scan_method;
     session.params.scan_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::GREEN;
+    session.params.contrast_adjustment = dev.settings.contrast;
+    session.params.brightness_adjustment = dev.settings.brightness;
 
     session.params.flags = ScanFlag::DISABLE_SHADING |
                            ScanFlag::DISABLE_GAMMA |
@@ -959,6 +940,8 @@ void scanner_move_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::GREEN;
+    session.params.contrast_adjustment = dev.settings.contrast;
+    session.params.brightness_adjustment = dev.settings.brightness;
 
     session.params.flags =  ScanFlag::DISABLE_SHADING |
                             ScanFlag::DISABLE_GAMMA |
@@ -1100,6 +1083,8 @@ void scanner_move_back_home_ta(Genesys_Device& dev)
     session.params.scan_method = scan_method;
     session.params.scan_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::GREEN;
+    session.params.contrast_adjustment = dev.settings.contrast;
+    session.params.brightness_adjustment = dev.settings.brightness;
 
     session.params.flags =  ScanFlag::DISABLE_SHADING |
                             ScanFlag::DISABLE_GAMMA |
@@ -1210,6 +1195,8 @@ void scanner_search_strip(Genesys_Device& dev, bool forward, bool black)
     session.params.scan_method = dev.settings.scan_method;
     session.params.scan_mode = ScanColorMode::GRAY;
     session.params.color_filter = ColorFilter::RED;
+    session.params.contrast_adjustment = dev.settings.contrast;
+    session.params.brightness_adjustment = dev.settings.brightness;
     session.params.flags = ScanFlag::DISABLE_SHADING |
                            ScanFlag::DISABLE_GAMMA;
     if (dev.model->asic_type != AsicType::GL841 && !forward) {
@@ -1506,6 +1493,8 @@ void scanner_offset_calibration(Genesys_Device& dev, const Genesys_Sensor& senso
     session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
     session.params.color_filter = dev.model->asic_type == AsicType::GL843 ? ColorFilter::RED
                                                                           : dev.settings.color_filter;
+    session.params.contrast_adjustment = dev.settings.contrast;
+    session.params.brightness_adjustment = dev.settings.brightness;
     session.params.flags = flags;
     compute_session(&dev, session, *calib_sensor);
 
@@ -1815,6 +1804,8 @@ void scanner_coarse_gain_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.contrast_adjustment = dev.settings.contrast;
+    session.params.brightness_adjustment = dev.settings.brightness;
     session.params.flags = flags;
     compute_session(&dev, session, *calib_sensor);
 
@@ -1873,7 +1864,8 @@ void scanner_coarse_gain_calibration(Genesys_Device& dev, const Genesys_Sensor&
         float curr_output = 0;
         float target_value = 0;
 
-        if (dev.model->asic_type == AsicType::GL842 ||
+        if (dev.model->asic_type == AsicType::GL841 ||
+            dev.model->asic_type == AsicType::GL842 ||
             dev.model->asic_type == AsicType::GL843)
         {
             std::vector<uint16_t> values;
@@ -1889,18 +1881,6 @@ void scanner_coarse_gain_calibration(Genesys_Device& dev, const Genesys_Sensor&
             curr_output = static_cast<float>(values[unsigned((values.size() - 1) * 0.95)]);
             target_value = calib_sensor->gain_white_ref * coeff;
 
-        } else if (dev.model->asic_type == AsicType::GL841) {
-            // FIXME: use the GL843 approach
-            unsigned max = 0;
-            for (std::size_t x = 0; x < image.get_width(); x++) {
-                auto value = image.get_raw_channel(x, 0, ch);
-                if (value > max) {
-                    max = value;
-                }
-            }
-
-            curr_output = max;
-            target_value = 65535.0f;
         } else {
             // FIXME: use the GL843 approach
             auto width = image.get_width();
@@ -1998,7 +1978,8 @@ SensorExposure scanner_led_calibration(Genesys_Device& dev, const Genesys_Sensor
     const auto& calib_sensor = sanei_genesys_find_sensor(&dev, resolution, channels,
                                                          dev.settings.scan_method);
 
-    if (dev.model->asic_type == AsicType::GL845 ||
+    if (dev.model->asic_type == AsicType::GL841 ||
+        dev.model->asic_type == AsicType::GL845 ||
         dev.model->asic_type == AsicType::GL846 ||
         dev.model->asic_type == AsicType::GL847 ||
         dev.model->asic_type == AsicType::GL124)
@@ -2006,14 +1987,9 @@ SensorExposure scanner_led_calibration(Genesys_Device& dev, const Genesys_Sensor
         regs = dev.reg; // FIXME: apply this to all ASICs
     }
 
-    unsigned yres = resolution;
-    if (dev.model->asic_type == AsicType::GL841) {
-        yres = dev.settings.yres; // FIXME: remove this
-    }
-
     ScanSession session;
     session.params.xres = resolution;
-    session.params.yres = yres;
+    session.params.yres = resolution;
     session.params.startx = 0;
     session.params.starty = 0;
     session.params.pixels = dev.model->x_size_calib_mm * resolution / MM_PER_INCH;
@@ -2023,6 +1999,8 @@ SensorExposure scanner_led_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.contrast_adjustment = dev.settings.contrast;
+    session.params.brightness_adjustment = dev.settings.brightness;
     session.params.flags = ScanFlag::DISABLE_SHADING |
                            ScanFlag::DISABLE_GAMMA |
                            ScanFlag::SINGLE_LINE |
@@ -2032,27 +2010,14 @@ SensorExposure scanner_led_calibration(Genesys_Device& dev, const Genesys_Sensor
 
     dev.cmd_set->init_regs_for_scan_session(&dev, calib_sensor, &regs, session);
 
-    if (dev.model->asic_type == AsicType::GL841) {
-        dev.interface->write_registers(regs); // FIXME: remove this
-    }
-
     std::uint16_t exp[3];
 
-    if (dev.model->asic_type == AsicType::GL841) {
-        exp[0] = sensor.exposure.red;
-        exp[1] = sensor.exposure.green;
-        exp[2] = sensor.exposure.blue;
-    } else {
-        exp[0] = calib_sensor.exposure.red;
-        exp[1] = calib_sensor.exposure.green;
-        exp[2] = calib_sensor.exposure.blue;
-    }
+    exp[0] = calib_sensor.exposure.red;
+    exp[1] = calib_sensor.exposure.green;
+    exp[2] = calib_sensor.exposure.blue;
 
     std::uint16_t target = sensor.gain_white_ref * 256;
 
-    std::uint16_t min_exposure = 500; // only gl841
-    std::uint16_t max_exposure = ((exp[0] + exp[1] + exp[2]) / 3) * 2; // only gl841
-
     std::uint16_t top[3] = {};
     std::uint16_t bottom[3] = {};
 
@@ -2088,16 +2053,6 @@ SensorExposure scanner_led_calibration(Genesys_Device& dev, const Genesys_Sensor
     for (unsigned i_test = 0; i_test < 100 && !acceptable; ++i_test) {
         regs_set_exposure(dev.model->asic_type, regs, { exp[0], exp[1], exp[2] });
 
-        if (dev.model->asic_type == AsicType::GL841) {
-            // FIXME: remove
-            dev.interface->write_register(0x10, (exp[0] >> 8) & 0xff);
-            dev.interface->write_register(0x11, exp[0] & 0xff);
-            dev.interface->write_register(0x12, (exp[1] >> 8) & 0xff);
-            dev.interface->write_register(0x13, exp[1] & 0xff);
-            dev.interface->write_register(0x14, (exp[2] >> 8) & 0xff);
-            dev.interface->write_register(0x15, exp[2] & 0xff);
-        }
-
         dev.interface->write_registers(regs);
 
         dbg.log(DBG_info, "starting line reading");
@@ -2108,15 +2063,13 @@ SensorExposure scanner_led_calibration(Genesys_Device& dev, const Genesys_Sensor
             if (dev.model->asic_type == AsicType::GL841) {
                 scanner_stop_action(dev);
                 dev.cmd_set->move_back_home(&dev, true);
-                return { exp[0], exp[1], exp[2] };
             } else if (dev.model->asic_type == AsicType::GL124) {
                 scanner_stop_action(dev);
-                return calib_sensor.exposure;
             } else {
                 scanner_stop_action(dev);
                 dev.cmd_set->move_back_home(&dev, true);
-                return calib_sensor.exposure;
             }
+            return { exp[0], exp[1], exp[2] };
         }
 
         auto image = read_unshuffled_image_from_scanner(&dev, session, session.output_line_bytes);
@@ -2142,57 +2095,8 @@ SensorExposure scanner_led_calibration(Genesys_Device& dev, const Genesys_Sensor
 
         acceptable = true;
 
-        if (dev.model->asic_type == AsicType::GL841) {
-            if (avg[0] < avg[1] * 0.95 || avg[1] < avg[0] * 0.95 ||
-                avg[0] < avg[2] * 0.95 || avg[2] < avg[0] * 0.95 ||
-                avg[1] < avg[2] * 0.95 || avg[2] < avg[1] * 0.95)
-            {
-                acceptable = false;
-            }
-
-            // led exposure is not acceptable if white level is too low.
-            // ~80 hardcoded value for white level
-            if (avg[0] < 20000 || avg[1] < 20000 || avg[2] < 20000) {
-                acceptable = false;
-            }
-
-            // for scanners using target value
-            if (target > 0) {
-                acceptable = true;
-                for (unsigned i = 0; i < 3; i++) {
-                    // we accept +- 2% delta from target
-                    if (std::abs(avg[i] - target) > target / 50) {
-                        exp[i] = (exp[i] * target) / avg[i];
-                        acceptable = false;
-                    }
-                }
-            } else {
-                if (!acceptable) {
-                    unsigned avga = (avg[0] + avg[1] + avg[2]) / 3;
-                    exp[0] = (exp[0] * avga) / avg[0];
-                    exp[1] = (exp[1] * avga) / avg[1];
-                    exp[2] = (exp[2] * avga) / avg[2];
-                    /*  Keep the resulting exposures below this value. Too long exposure drives
-                        the ccd into saturation. We may fix this by relying on the fact that
-                        we get a striped scan without shading, by means of statistical calculation
-                    */
-                    unsigned avge = (exp[0] + exp[1] + exp[2]) / 3;
-
-                    if (avge > max_exposure) {
-                        exp[0] = (exp[0] * max_exposure) / avge;
-                        exp[1] = (exp[1] * max_exposure) / avge;
-                        exp[2] = (exp[2] * max_exposure) / avge;
-                    }
-                    if (avge < min_exposure) {
-                        exp[0] = (exp[0] * min_exposure) / avge;
-                        exp[1] = (exp[1] * min_exposure) / avge;
-                        exp[2] = (exp[2] * min_exposure) / avge;
-                    }
-
-                }
-            }
-        } else if (dev.model->asic_type == AsicType::GL845 ||
-                   dev.model->asic_type == AsicType::GL846)
+        if (dev.model->asic_type == AsicType::GL845 ||
+            dev.model->asic_type == AsicType::GL846)
         {
             for (unsigned i = 0; i < 3; i++) {
                 if (avg[i] < bottom[i]) {
@@ -2225,7 +2129,9 @@ SensorExposure scanner_led_calibration(Genesys_Device& dev, const Genesys_Sensor
                     acceptable = false;
                 }
             }
-        } else if (dev.model->asic_type == AsicType::GL124) {
+        } else if (dev.model->asic_type == AsicType::GL841 ||
+                   dev.model->asic_type == AsicType::GL124)
+        {
             for (unsigned i = 0; i < 3; i++) {
                 // we accept +- 2% delta from target
                 if (std::abs(avg[i] - target) > target / 50) {
@@ -4366,12 +4272,6 @@ static Genesys_Settings calculate_scan_settings(Genesys_Scanner* s)
         settings.color_filter = ColorFilter::NONE;
     }
 
-    if (s->color_filter == "None") {
-        settings.true_gray = 1;
-    } else {
-        settings.true_gray = 0;
-    }
-
     // brightness and contrast only for for 8 bit scans
     if (s->bit_depth == 8) {
         settings.contrast = (s->contrast * 127) / 100;
@@ -4992,16 +4892,28 @@ static void init_options(Genesys_Scanner* s)
     s->opt[OPT_POWER_SW].cap = SANE_CAP_INACTIVE;
 
   /* extra button */
-  s->opt[OPT_EXTRA_SW].name = "extra";
-  s->opt[OPT_EXTRA_SW].title = SANE_I18N ("Extra button");
-  s->opt[OPT_EXTRA_SW].desc = SANE_I18N ("Extra button");
-  s->opt[OPT_EXTRA_SW].type = SANE_TYPE_BOOL;
-  s->opt[OPT_EXTRA_SW].unit = SANE_UNIT_NONE;
-  if (model->buttons & GENESYS_HAS_EXTRA_SW)
-    s->opt[OPT_EXTRA_SW].cap =
-      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
-  else
-    s->opt[OPT_EXTRA_SW].cap = SANE_CAP_INACTIVE;
+    s->opt[OPT_EXTRA_SW].name = "extra";
+    s->opt[OPT_EXTRA_SW].title = SANE_I18N("Extra button");
+    s->opt[OPT_EXTRA_SW].desc = SANE_I18N("Extra button");
+    s->opt[OPT_EXTRA_SW].type = SANE_TYPE_BOOL;
+    s->opt[OPT_EXTRA_SW].unit = SANE_UNIT_NONE;
+    if (model->buttons & GENESYS_HAS_EXTRA_SW) {
+        s->opt[OPT_EXTRA_SW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+    } else {
+        s->opt[OPT_EXTRA_SW].cap = SANE_CAP_INACTIVE;
+    }
+
+    // transparency/scan_film button
+    s->opt[OPT_TRANSP_SW].name = "transparency";
+    s->opt[OPT_TRANSP_SW].title = SANE_I18N ("Transparency button");
+    s->opt[OPT_TRANSP_SW].desc = SANE_I18N ("Transparency button");
+    s->opt[OPT_TRANSP_SW].type = SANE_TYPE_BOOL;
+    s->opt[OPT_TRANSP_SW].unit = SANE_UNIT_NONE;
+    if (model->buttons & GENESYS_HAS_TRANSP_SW) {
+        s->opt[OPT_TRANSP_SW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+    } else {
+        s->opt[OPT_TRANSP_SW].cap = SANE_CAP_INACTIVE;
+    }
 
   /* calibration needed */
   s->opt[OPT_NEED_CALIBRATION_SW].name = "need-calibration";
@@ -5231,7 +5143,7 @@ static void probe_genesys_devices()
    of Genesys_Calibration_Cache as is.
 */
 static const char* CALIBRATION_IDENT = "sane_genesys";
-static const int CALIBRATION_VERSION = 31;
+static const int CALIBRATION_VERSION = 32;
 
 bool read_calibration(std::istream& str, Genesys_Device::Calibration& calibration,
                       const std::string& path)
@@ -5821,6 +5733,7 @@ static void get_option_value(Genesys_Scanner* s, int option, void* val)
     case OPT_OCR_SW:
     case OPT_POWER_SW:
     case OPT_EXTRA_SW:
+    case OPT_TRANSP_SW:
         s->dev->cmd_set->update_hardware_sensors(s);
         *reinterpret_cast<SANE_Bool*>(val) = s->buttons[genesys_option_to_button(option)].read();
         break;
@@ -6456,6 +6369,7 @@ GenesysButtonName genesys_option_to_button(int option)
     case OPT_OCR_SW: return BUTTON_OCR_SW;
     case OPT_POWER_SW: return BUTTON_POWER_SW;
     case OPT_EXTRA_SW: return BUTTON_EXTRA_SW;
+    case OPT_TRANSP_SW: return BUTTON_TRANSP_SW;
     default: throw std::runtime_error("Unknown option to convert to button index");
     }
 }