Merge branch 'genesys-fix-search-reference-point' into 'master'

genesys: Fix search reference point to update all sensors

See merge request sane-project/backends!118

backend/genesys.cc

@@ -230,6 +230,28 @@ Genesys_Sensor& sanei_genesys_find_sensor_for_write(Genesys_Device* dev, int dpi
 }
 
 
+std::vector<std::reference_wrapper<const Genesys_Sensor>>
+    sanei_genesys_find_sensors_all(Genesys_Device* dev, ScanMethod scan_method)
+{
+    std::vector<std::reference_wrapper<const Genesys_Sensor>> ret;
+    for (const Genesys_Sensor& sensor : sanei_genesys_find_sensors_all_for_write(dev, scan_method)) {
+        ret.push_back(sensor);
+    }
+    return ret;
+}
+
+std::vector<std::reference_wrapper<Genesys_Sensor>>
+    sanei_genesys_find_sensors_all_for_write(Genesys_Device* dev, ScanMethod scan_method)
+{
+    std::vector<std::reference_wrapper<Genesys_Sensor>> ret;
+    for (auto& sensor : *s_sensors) {
+        if (dev->model->ccd_type == sensor.sensor_id && sensor.method == scan_method) {
+            ret.push_back(sensor);
+        }
+    }
+    return ret;
+}
+
 void
 sanei_genesys_init_structs (Genesys_Device * dev)
 {
@@ -1053,8 +1075,8 @@ void sanei_genesys_init_shading_data(Genesys_Device* dev, const Genesys_Sensor&
 // Find the position of the reference point: takes gray level 8 bits data and find
 // first CCD usable pixel and top of scanning area
 void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& sensor,
-                                          uint8_t* data, int start_pixel, int dpi, int width,
+                                          const uint8_t* src_data, int start_pixel, int dpi,
-                                          int height)
+                                          int width, int height)
 {
     DBG_HELPER(dbg);
   int x, y;
@@ -1069,22 +1091,25 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
 
   /* transformed image data */
   size = width * height;
+  std::vector<uint8_t> image2(size, 0);
   std::vector<uint8_t> image(size, 0);
 
   /* laplace filter to denoise picture */
-  memcpy(image.data(), data, size);	// to initialize unprocessed part of the image buffer
+    std::memcpy(image2.data(), src_data, size);
-  for (y = 1; y < height - 1; y++)
+    std::memcpy(image.data(), src_data, size);	// to initialize unprocessed part of the image buffer
-    for (x = 1; x < width - 1; x++)
+
-      {
+    for (y = 1; y < height - 1; y++) {
+        for (x = 1; x < width - 1; x++) {
             image[y * width + x] =
-	  (data[(y - 1) * width + x + 1] + 2 * data[(y - 1) * width + x] +
+                (image2[(y - 1) * width + x + 1] + 2 * image2[(y - 1) * width + x] +
-	   data[(y - 1) * width + x - 1] + 2 * data[y * width + x + 1] +
+                image2[(y - 1) * width + x - 1] + 2 * image2[y * width + x + 1] +
-	   4 * data[y * width + x] + 2 * data[y * width + x - 1] +
+                4 * image2[y * width + x] + 2 * image2[y * width + x - 1] +
-	   data[(y + 1) * width + x + 1] + 2 * data[(y + 1) * width + x] +
+                image2[(y + 1) * width + x + 1] + 2 * image2[(y + 1) * width + x] +
-	   data[(y + 1) * width + x - 1]) / 16;
+                image2[(y + 1) * width + x - 1]) / 16;
+        }
     }
 
-  memcpy (data, image.data(), size);
+    image2 = image;
   if (DBG_LEVEL >= DBG_data)
     sanei_genesys_write_pnm_file("gl_laplace.pnm", image.data(), 8, 1, width, height);
 
@@ -1095,13 +1120,11 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
      and finds threshold level
    */
   level = 0;
-  for (y = 2; y < height - 2; y++)
+    for (y = 2; y < height - 2; y++) {
-    for (x = 2; x < width - 2; x++)
+        for (x = 2; x < width - 2; x++) {
-      {
+            current = image2[(y - 1) * width + x + 1] - image2[(y - 1) * width + x - 1] +
-	current =
+                      2 * image2[y * width + x + 1] - 2 * image2[y * width + x - 1] +
-	  data[(y - 1) * width + x + 1] - data[(y - 1) * width + x - 1] +
+                      image2[(y + 1) * width + x + 1] - image2[(y + 1) * width + x - 1];
-	  2 * data[y * width + x + 1] - 2 * data[y * width + x - 1] +
-	  data[(y + 1) * width + x + 1] - data[(y + 1) * width + x - 1];
 	if (current < 0)
 	  current = -current;
 	if (current > 255)
@@ -1110,6 +1133,7 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
 	if (current > level)
 	  level = current;
         }
+    }
   if (DBG_LEVEL >= DBG_data)
     sanei_genesys_write_pnm_file("gl_xsobel.pnm", image.data(), 8, 1, width, height);
 
@@ -1146,13 +1170,11 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
      1  2  1
    */
   level = 0;
-  for (y = 2; y < height - 2; y++)
+    for (y = 2; y < height - 2; y++) {
-    for (x = 2; x < width - 2; x++)
+        for (x = 2; x < width - 2; x++) {
-      {
+            current = -image2[(y - 1) * width + x + 1] - 2 * image2[(y - 1) * width + x] -
-	current =
+                      image2[(y - 1) * width + x - 1] + image2[(y + 1) * width + x + 1] +
-	  -data[(y - 1) * width + x + 1] - 2 * data[(y - 1) * width + x] -
+                      2 * image2[(y + 1) * width + x] + image2[(y + 1) * width + x - 1];
-	  data[(y - 1) * width + x - 1] + data[(y + 1) * width + x + 1] +
-	  2 * data[(y + 1) * width + x] + data[(y + 1) * width + x - 1];
 	if (current < 0)
 	  current = -current;
 	if (current > 255)
@@ -1161,6 +1183,7 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
 	if (current > level)
 	  level = current;
       }
+    }
   if (DBG_LEVEL >= DBG_data)
     sanei_genesys_write_pnm_file("gl_ysobel.pnm", image.data(), 8, 1, width, height);
 

backend/genesys_gl124.cc

@@ -1939,8 +1939,10 @@ static void gl124_search_start_position(Genesys_Device* dev)
   /* update regs to copy ASIC internal state */
   dev->reg = local_reg;
 
-    sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
+    for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
+        sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
                                              dev->model->search_lines);
+    }
 }
 
 // sets up register for coarse gain calibration

backend/genesys_gl646.cc

@@ -375,6 +375,9 @@ static void gl646_setup_registers(Genesys_Device* dev,
     DBG_HELPER(dbg);
     session.assert_computed();
 
+    debug_dump(DBG_info, sensor);
+    debug_dump(DBG_info, session);
+
     int resolution = session.params.xres;
     uint32_t move = session.params.starty;
     uint32_t linecnt = session.params.lines;
@@ -2180,8 +2183,10 @@ static void gl646_search_start_position(Genesys_Device* dev)
       }
 
     // now search reference points on the data
-    sanei_genesys_search_reference_point(dev, sensor, data.data(), sensor.CCD_start_xoffset,
+    for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
+        sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0,
                                              resolution, settings.pixels, settings.lines);
+    }
 }
 
 /**
@@ -2888,13 +2893,6 @@ static void gl646_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
 	}
     }
 
-    // in case of debug do a final scan to get result
-    if (DBG_LEVEL >= DBG_data) {
-        simple_scan(dev, sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, second_line);
-        sanei_genesys_write_pnm_file("gl646_offset-final.pnm", second_line.data(), 8, channels,
-                                     settings.pixels, settings.lines);
-    }
-
   DBG(DBG_info, "%s: offset=(%d,%d,%d)\n", __func__,
       dev->frontend.get_offset(0),
       dev->frontend.get_offset(1),

backend/genesys_gl841.cc

@@ -2991,10 +2991,10 @@ static void gl841_search_start_position(Genesys_Device* dev)
   /* update regs to copy ASIC internal state */
   dev->reg = local_reg;
 
-    // TODO: find out where sanei_genesys_search_reference_point stores information,
+    for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
-    // and use that correctly
+        sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
-    sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
                                              dev->model->search_lines);
+    }
 }
 
 // sets up register for coarse gain calibration

backend/genesys_gl843.cc

@@ -2351,8 +2351,10 @@ static void gl843_search_start_position(Genesys_Device* dev)
   /* update regs to copy ASIC internal state */
   dev->reg = local_reg;
 
-    sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
+    for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
+        sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
                                              dev->model->search_lines);
+    }
 }
 
 // sets up register for coarse gain calibration

backend/genesys_gl846.cc

@@ -1632,8 +1632,10 @@ static void gl846_search_start_position(Genesys_Device* dev)
 
     // TODO: find out where sanei_genesys_search_reference_point stores information,
     // and use that correctly
-    sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
+    for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
+        sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
                                              dev->model->search_lines);
+    }
 }
 
 // sets up register for coarse gain calibration

backend/genesys_gl847.cc

@@ -1688,8 +1688,10 @@ static void gl847_search_start_position(Genesys_Device* dev)
 
     // TODO: find out where sanei_genesys_search_reference_point stores information,
     // and use that correctly
-    sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
+    for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
+        sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
                                              dev->model->search_lines);
+    }
 }
 
 // sets up register for coarse gain calibration

backend/genesys_low.cc

@@ -1705,13 +1705,30 @@ void debug_dump(unsigned level, const SetupParams& params)
         params.flags);
 }
 
+void debug_dump(unsigned level, const ScanSession& session)
+{
+    DBG(level, "session:\n");
+    DBG(level, "    computed : %d\n", session.computed);
+    DBG(level, "    ccd_size_divisor : %d\n", session.ccd_size_divisor);
+    DBG(level, "    optical_resolution : %d\n", session.optical_resolution);
+    DBG(level, "    optical_pixels : %d\n", session.optical_pixels);
+    DBG(level, "    optical_line_bytes : %d\n", session.optical_line_bytes);
+    DBG(level, "    output_resolution : %d\n", session.output_resolution);
+    DBG(level, "    output_pixels : %d\n", session.output_pixels);
+    DBG(level, "    output_line_bytes : %d\n", session.output_line_bytes);
+    DBG(level, "    output_line_count : %d\n", session.output_line_count);
+    DBG(level, "    num_staggered_lines : %d\n", session.num_staggered_lines);
+    DBG(level, "    max_color_shift_lines : %d\n", session.max_color_shift_lines);
+    debug_dump(level, session.params);
+}
+
 void debug_dump(unsigned level, const Genesys_Current_Setup& setup)
 {
     DBG(level, "current_setup:\n"
         "Pixels: %d\n"
         "Lines: %d\n"
         "exposure_time: %d\n"
-        "Resolution X/Y: %g\n"
+        "Resolution X: %g\n"
         "ccd_size_divisor: %d\n"
         "stagger: %d\n"
         "max_shift: %d\n",
@@ -1731,3 +1748,39 @@ void debug_dump(unsigned level, const Genesys_Register_Set& regs)
         DBG(level, "    %04x=%02x\n", reg.address, reg.value);
     }
 }
+
+void debug_dump(unsigned level, const GenesysRegisterSettingSet& regs)
+{
+    DBG(level, "register_setting_set:\n");
+    for (const auto& reg : regs) {
+        DBG(level, "    %04x=%02x & %02x\n", reg.address, reg.value, reg.mask);
+    }
+}
+
+void debug_dump(unsigned level, const Genesys_Sensor& sensor)
+{
+    DBG(level, "sensor:\n");
+    DBG(level, "    sensor_id : %d\n", sensor.sensor_id);
+    DBG(level, "    optical_res : %d\n", sensor.optical_res);
+    DBG(level, "    min_resolution : %d\n", sensor.min_resolution);
+    DBG(level, "    max_resolution : %d\n", sensor.max_resolution);
+    DBG(level, "    method : %d\n", static_cast<unsigned>(sensor.method));
+    DBG(level, "    ccd_size_divisor : %d\n", sensor.ccd_size_divisor);
+    DBG(level, "    black_pixels : %d\n", sensor.black_pixels);
+    DBG(level, "    dummy_pixel : %d\n", sensor.dummy_pixel);
+    DBG(level, "    CCD_start_xoffset : %d\n", sensor.CCD_start_xoffset);
+    DBG(level, "    sensor_pixels : %d\n", sensor.sensor_pixels);
+    DBG(level, "    fau_gain_white_ref : %d\n", sensor.fau_gain_white_ref);
+    DBG(level, "    gain_white_ref : %d\n", sensor.gain_white_ref);
+    DBG(level, "    exposure.red : %d\n", sensor.exposure.red);
+    DBG(level, "    exposure.green : %d\n", sensor.exposure.green);
+    DBG(level, "    exposure.blue : %d\n", sensor.exposure.blue);
+    DBG(level, "    exposure_lperiod : %d\n", sensor.exposure_lperiod);
+    DBG(level, "    custom_regs\n");
+    debug_dump(level, sensor.custom_regs);
+    DBG(level, "    custom_fe_regs\n");
+    debug_dump(level, sensor.custom_fe_regs);
+    DBG(level, "    gamma.red : %f\n", sensor.gamma[0]);
+    DBG(level, "    gamma.green : %f\n", sensor.gamma[1]);
+    DBG(level, "    gamma.blue : %f\n", sensor.gamma[2]);
+}

backend/genesys_low.h

@@ -439,6 +439,11 @@ const Genesys_Sensor& sanei_genesys_find_sensor(Genesys_Device* dev, int dpi,
 Genesys_Sensor& sanei_genesys_find_sensor_for_write(Genesys_Device* dev, int dpi,
                                                     ScanMethod scan_method);
 
+std::vector<std::reference_wrapper<const Genesys_Sensor>>
+    sanei_genesys_find_sensors_all(Genesys_Device* dev, ScanMethod scan_method);
+std::vector<std::reference_wrapper<Genesys_Sensor>>
+    sanei_genesys_find_sensors_all_for_write(Genesys_Device* dev, ScanMethod scan_method);
+
 extern void sanei_genesys_init_shading_data(Genesys_Device* dev, const Genesys_Sensor& sensor,
                                             int pixels_per_line);
 
@@ -525,8 +530,8 @@ void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& s
 extern void sanei_genesys_stop_motor(Genesys_Device* dev);
 
 extern void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& sensor,
-                                                 uint8_t* data, int start_pixel, int dpi, int width,
+                                                 const uint8_t* src_data, int start_pixel, int dpi,
-                                                 int height);
+                                                 int width, int height);
 
 extern void sanei_genesys_write_file(const char* filename, uint8_t* data, size_t length);
 
@@ -683,7 +688,10 @@ void genesys_init_usb_device_tables();
 
 void debug_dump(unsigned level, const Genesys_Settings& settings);
 void debug_dump(unsigned level, const SetupParams& params);
+void debug_dump(unsigned level, const ScanSession& session);
 void debug_dump(unsigned level, const Genesys_Current_Setup& setup);
 void debug_dump(unsigned level, const Genesys_Register_Set& regs);
+void debug_dump(unsigned level, const GenesysRegisterSettingSet& regs);
+void debug_dump(unsigned level, const Genesys_Sensor& sensor);
 
 #endif /* not GENESYS_LOW_H */