Merge branch 'genesys_gl845_crash' into 'master'

genesys: GL845 has vector size 257 as well

See merge request sane-project/backends!688

backend/genesys/genesys.cpp

@@ -345,6 +345,7 @@ void sanei_genesys_create_default_gamma_table(Genesys_Device* dev,
         }
         max = size - 1;
     } else if (dev->model->asic_type == AsicType::GL124 ||
+               dev->model->asic_type == AsicType::GL845 ||
                dev->model->asic_type == AsicType::GL846 ||
                dev->model->asic_type == AsicType::GL847) {
         size = 257;

backend/genesys/gl646.cpp

@@ -1857,10 +1857,7 @@ void CommandSetGl646::send_gamma_table(Genesys_Device* dev, const Genesys_Sensor
       bits = 12;
     }
 
-    // allocate temporary gamma tables: 16 bits words, 3 channels */
-    std::vector<std::uint8_t> gamma(size * 2 * 3);
-
-    sanei_genesys_generate_gamma_buffer(dev, sensor, bits, size-1, size, gamma.data());
+    auto gamma = generate_gamma_buffer(dev, sensor, bits, size-1, size);
 
   /* table address */
   switch (dev->reg.find_reg(0x05).value >> 6)

backend/genesys/gl841.cpp

@@ -1534,10 +1534,7 @@ void CommandSetGl841::send_gamma_table(Genesys_Device* dev, const Genesys_Sensor
 
   size = 256;
 
-    // allocate temporary gamma tables: 16 bits words, 3 channels
-    std::vector<std::uint8_t> gamma(size * 2 * 3);
-
-    sanei_genesys_generate_gamma_buffer(dev, sensor, 16, 65535, size, gamma.data());
+    auto gamma = generate_gamma_buffer(dev, sensor, 16, 65535, size);
 
     dev->interface->write_gamma(0x28, 0x0000, gamma.data(), size * 2 * 3);
 }

backend/genesys/low.cpp

@@ -654,20 +654,35 @@ std::vector<std::uint16_t> get_gamma_table(Genesys_Device* dev, const Genesys_Se
  * @param bits number of bits used by gamma
  * @param max value for gamma
  * @param size of the gamma table
- * @param gamma allocated gamma buffer to fill
  */
-void sanei_genesys_generate_gamma_buffer(Genesys_Device* dev,
+std::vector<std::uint8_t> generate_gamma_buffer(Genesys_Device* dev,
                                                 const Genesys_Sensor& sensor,
-                                                int bits,
-                                                int max,
-                                                int size,
-                                         std::uint8_t* gamma)
+                                                int bits, int max, int size)
 {
     DBG_HELPER(dbg);
+
+    // the gamma tables are 16 bits words and contain 3 channels
+    std::vector<std::uint8_t> gamma_buf(size * 2 * 3);
+
     std::vector<std::uint16_t> rgamma = get_gamma_table(dev, sensor, GENESYS_RED);
     std::vector<std::uint16_t> ggamma = get_gamma_table(dev, sensor, GENESYS_GREEN);
     std::vector<std::uint16_t> bgamma = get_gamma_table(dev, sensor, GENESYS_BLUE);
 
+    auto get_gamma_value = [](const std::vector<std::uint16_t>& array,
+                              std::size_t index) -> std::uint16_t
+    {
+        if (index < array.size())
+            return array[index];
+        return 0xffff;
+    };
+
+    auto set_gamma_buf_value = [](std::vector<std::uint8_t>& array, std::size_t pos,
+                                  std::uint16_t value)
+    {
+        array[pos * 2 + 0] = value & 0xff;
+        array[pos * 2 + 1] = (value >> 8) & 0xff;
+    };
+
   if(dev->settings.contrast!=0 || dev->settings.brightness!=0)
     {
         std::vector<std::uint16_t> lut(65536);
@@ -680,39 +695,21 @@ void sanei_genesys_generate_gamma_buffer(Genesys_Device* dev,
                              dev->settings.brightness);
       for (int i = 0; i < size; i++)
         {
-            std::uint16_t value = rgamma[i];
-          value=lut[value];
-          gamma[i * 2 + size * 0 + 0] = value & 0xff;
-          gamma[i * 2 + size * 0 + 1] = (value >> 8) & 0xff;
-
-          value=ggamma[i];
-          value=lut[value];
-          gamma[i * 2 + size * 2 + 0] = value & 0xff;
-          gamma[i * 2 + size * 2 + 1] = (value >> 8) & 0xff;
-
-          value=bgamma[i];
-          value=lut[value];
-          gamma[i * 2 + size * 4 + 0] = value & 0xff;
-          gamma[i * 2 + size * 4 + 1] = (value >> 8) & 0xff;
+            set_gamma_buf_value(gamma_buf, i + size * 0, lut[get_gamma_value(rgamma, i)]);
+            set_gamma_buf_value(gamma_buf, i + size * 1, lut[get_gamma_value(ggamma, i)]);
+            set_gamma_buf_value(gamma_buf, i + size * 2, lut[get_gamma_value(bgamma, i)]);
         }
     }
   else
     {
       for (int i = 0; i < size; i++)
         {
-            std::uint16_t value=rgamma[i];
-          gamma[i * 2 + size * 0 + 0] = value & 0xff;
-          gamma[i * 2 + size * 0 + 1] = (value >> 8) & 0xff;
-
-          value=ggamma[i];
-          gamma[i * 2 + size * 2 + 0] = value & 0xff;
-          gamma[i * 2 + size * 2 + 1] = (value >> 8) & 0xff;
-
-          value=bgamma[i];
-          gamma[i * 2 + size * 4 + 0] = value & 0xff;
-          gamma[i * 2 + size * 4 + 1] = (value >> 8) & 0xff;
+            set_gamma_buf_value(gamma_buf, i + size * 0, get_gamma_value(rgamma, i));
+            set_gamma_buf_value(gamma_buf, i + size * 1, get_gamma_value(ggamma, i));
+            set_gamma_buf_value(gamma_buf, i + size * 2, get_gamma_value(bgamma, i));
         }
     }
+    return gamma_buf;
 }
 
 
@@ -730,10 +727,7 @@ void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& s
 
   size = 256 + 1;
 
-    // allocate temporary gamma tables: 16 bits words, 3 channels
-    std::vector<std::uint8_t> gamma(size * 2 * 3, 255);
-
-    sanei_genesys_generate_gamma_buffer(dev, sensor, 16, 65535, size, gamma.data());
+    auto gamma = generate_gamma_buffer(dev, sensor, 16, 65535, size);
 
     // loop sending gamma tables NOTE: 0x01000000 not 0x10000000
     for (i = 0; i < 3; i++) {

backend/genesys/low.h

@@ -392,12 +392,9 @@ extern void sanei_genesys_load_lut(unsigned char* lut,
                                    int out_min, int out_max,
                                    int slope, int offset);
 
-void sanei_genesys_generate_gamma_buffer(Genesys_Device* dev,
-                                         const Genesys_Sensor& sensor,
-                                         int bits,
-                                         int max,
-                                         int size,
-                                         std::uint8_t* gamma);
+std::vector<std::uint8_t> generate_gamma_buffer(Genesys_Device* dev,
+                                                const Genesys_Sensor& sensor,
+                                                int bits, int max, int size);
 
 unsigned session_adjust_output_pixels(unsigned output_pixels,
                                       const Genesys_Device& dev, const Genesys_Sensor& sensor,

newsfragments/genesys_gl845_gamma_crash.backend

@@ -0,0 +1 @@
+Fixed crash when loading gamma tables on Plustek 8200i and other gl845 scanners.