Merge branch 'feature/upstream' into develop

1 files changed, 7580 insertions, 0 deletions

diff --git a/backend/genesys.cc b/backend/genesys.cc
new file mode 100644
index 0000000..0368e21
--- /dev/null
+++ b/backend/genesys.cc
@@ -0,0 +1,7580 @@
+/* sane - Scanner Access Now Easy.
+
+   Copyright (C) 2003, 2004 Henning Meier-Geinitz <henning@meier-geinitz.de>
+   Copyright (C) 2004, 2005 Gerhard Jaeger <gerhard@gjaeger.de>
+   Copyright (C) 2004-2016 Stéphane Voltz <stef.dev@free.fr>
+   Copyright (C) 2005-2009 Pierre Willenbrock <pierre@pirsoft.dnsalias.org>
+   Copyright (C) 2006 Laurent Charpentier <laurent_pubs@yahoo.com>
+   Copyright (C) 2007 Luke <iceyfor@gmail.com>
+   Copyright (C) 2010 Chris Berry <s0457957@sms.ed.ac.uk> and Michael Rickmann <mrickma@gwdg.de>
+                 for Plustek Opticbook 3600 support
+
+   Dynamic rasterization code was taken from the epjistsu backend by
+   m. allan noah <kitno455 at gmail dot com>
+
+   Software processing for deskew, crop and dspeckle are inspired by allan's
+   noah work in the fujitsu backend
+
+   This file is part of the SANE package.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA.
+
+   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.
+*/
+
+/*
+ * SANE backend for Genesys Logic GL646/GL841/GL842/GL843/GL846/GL847/GL124 based scanners
+ */
+
+#define DEBUG_NOT_STATIC
+
+#include "genesys.h"
+#include "genesys_sanei.h"
+#include "../include/sane/sanei_config.h"
+#include "../include/sane/sanei_magic.h"
+#include "genesys_devices.cc"
+
+#include <cstring>
+#include <fstream>
+#include <list>
+#include <exception>
+#include <vector>
+
+StaticInit<std::list<Genesys_Scanner>> s_scanners;
+StaticInit<std::vector<SANE_Device>> s_sane_devices;
+StaticInit<std::vector<SANE_Device*>> s_sane_devices_ptrs;
+StaticInit<std::list<Genesys_Device>> s_devices;
+
+static SANE_String_Const mode_list[] = {
+  SANE_VALUE_SCAN_MODE_COLOR,
+  SANE_VALUE_SCAN_MODE_GRAY,
+  /* SANE_TITLE_HALFTONE,  currently unused */
+  SANE_VALUE_SCAN_MODE_LINEART,
+  0
+};
+
+static SANE_String_Const color_filter_list[] = {
+  SANE_I18N ("Red"),
+  SANE_I18N ("Green"),
+  SANE_I18N ("Blue"),
+  0
+};
+
+static SANE_String_Const cis_color_filter_list[] = {
+  SANE_I18N ("Red"),
+  SANE_I18N ("Green"),
+  SANE_I18N ("Blue"),
+  SANE_I18N ("None"),
+  0
+};
+
+static SANE_String_Const source_list[] = {
+  SANE_I18N (STR_FLATBED),
+  SANE_I18N (STR_TRANSPARENCY_ADAPTER),
+  0
+};
+
+static const char* source_list_infrared[] = {
+    SANE_I18N(STR_FLATBED),
+    SANE_I18N(STR_TRANSPARENCY_ADAPTER),
+    SANE_I18N(STR_TRANSPARENCY_ADAPTER_INFRARED),
+    0
+};
+
+static SANE_Range swdespeck_range = {
+  1,
+  9,
+  1
+};
+
+static SANE_Range time_range = {
+  0,				/* minimum */
+  60,				/* maximum */
+  0				/* quantization */
+};
+
+static const SANE_Range u12_range = {
+  0,				/* minimum */
+  4095,				/* maximum */
+  0				/* quantization */
+};
+
+static const SANE_Range u14_range = {
+  0,				/* minimum */
+  16383,			/* maximum */
+  0				/* quantization */
+};
+
+static const SANE_Range u16_range = {
+  0,				/* minimum */
+  65535,			/* maximum */
+  0				/* quantization */
+};
+
+static const SANE_Range percentage_range = {
+  SANE_FIX (0),			/* minimum */
+  SANE_FIX (100),		/* maximum */
+  SANE_FIX (1)			/* quantization */
+};
+
+static const SANE_Range threshold_curve_range = {
+  0,			/* minimum */
+  127,		        /* maximum */
+  1			/* quantization */
+};
+
+/**
+ * range for brightness and contrast
+ */
+static const SANE_Range enhance_range = {
+  -100,	/* minimum */
+  100,		/* maximum */
+  1		/* quantization */
+};
+
+/**
+ * range for expiration time
+ */
+static const SANE_Range expiration_range = {
+  -1,	        /* minimum */
+  30000,	/* maximum */
+  1		/* quantization */
+};
+
+Genesys_Sensor& sanei_genesys_find_sensor_any_for_write(Genesys_Device* dev)
+{
+    for (auto& sensor : *s_sensors) {
+        if (dev->model->ccd_type == sensor.sensor_id) {
+            return sensor;
+        }
+    }
+    throw std::runtime_error("Given device does not have sensor defined");
+}
+
+const Genesys_Sensor& sanei_genesys_find_sensor_any(Genesys_Device* dev)
+{
+    for (const auto& sensor : *s_sensors) {
+        if (dev->model->ccd_type == sensor.sensor_id) {
+            return sensor;
+        }
+    }
+    throw std::runtime_error("Given device does not have sensor defined");
+}
+
+const Genesys_Sensor& sanei_genesys_find_sensor(Genesys_Device* dev, int dpi,
+                                                ScanMethod scan_method)
+{
+    for (const auto& sensor : *s_sensors) {
+        if (dev->model->ccd_type == sensor.sensor_id &&
+                (sensor.min_resolution == -1 || dpi >= sensor.min_resolution) &&
+                (sensor.max_resolution == -1 || dpi <= sensor.max_resolution) &&
+                sensor.method == scan_method) {
+            return sensor;
+        }
+    }
+    throw std::runtime_error("Given device does not have sensor defined");
+}
+
+Genesys_Sensor& sanei_genesys_find_sensor_for_write(Genesys_Device* dev, int dpi,
+                                                    ScanMethod scan_method)
+{
+    for (auto& sensor : *s_sensors) {
+        if (dev->model->ccd_type == sensor.sensor_id &&
+                (sensor.min_resolution == -1 || dpi >= sensor.min_resolution) &&
+                (sensor.max_resolution == -1 || dpi <= sensor.max_resolution) &&
+                sensor.method == scan_method) {
+            return sensor;
+        }
+    }
+    throw std::runtime_error("Given device does not have sensor defined");
+}
+
+
+void
+sanei_genesys_init_structs (Genesys_Device * dev)
+{
+  unsigned int i, gpo_ok = 0, motor_ok = 0;
+    bool fe_ok = false;
+
+  /* initialize the GPO data stuff */
+  for (i = 0; i < sizeof (Gpo) / sizeof (Genesys_Gpo); i++)
+    {
+      if (dev->model->gpo_type == Gpo[i].gpo_id)
+	{
+          dev->gpo = Gpo[i];
+	  gpo_ok = 1;
+	}
+    }
+
+  /* initialize the motor data stuff */
+  for (i = 0; i < sizeof (Motor) / sizeof (Genesys_Motor); i++)
+    {
+      if (dev->model->motor_type == Motor[i].motor_id)
+	{
+          dev->motor = Motor[i];
+	  motor_ok = 1;
+	}
+    }
+
+    for (const auto& frontend : *s_frontends) {
+        if (dev->model->dac_type == frontend.fe_id) {
+            dev->frontend_initial = frontend;
+            fe_ok = true;
+            break;
+        }
+    }
+
+  /* sanity check */
+  if (motor_ok == 0 || gpo_ok == 0 || !fe_ok)
+    {
+      DBG(DBG_error0, "%s: bad description(s) for fe/gpo/motor=%d/%d/%d\n", __func__,
+          dev->model->ccd_type, dev->model->gpo_type, dev->model->motor_type);
+    }
+
+  /* set up initial line distance shift */
+  dev->ld_shift_r = dev->model->ld_shift_r;
+  dev->ld_shift_g = dev->model->ld_shift_g;
+  dev->ld_shift_b = dev->model->ld_shift_b;
+}
+
+/* main function for slope creation */
+/**
+ * This function generates a slope table using the given slope
+ * truncated at the given exposure time or step count, whichever comes first.
+ * The reached step time is then stored in final_exposure and used for the rest
+ * of the table. The summed time of the acceleration steps is returned, and the
+ * number of accerelation steps is put into used_steps.
+ *
+ * @param slope_table    Table to write to
+ * @param max_steps      Size of slope_table in steps
+ * @param use_steps      Maximum number of steps to use for acceleration
+ * @param stop_at        Minimum step time to use
+ * @param vstart         Start step time of default slope
+ * @param vend           End step time of default slope
+ * @param steps          Step count of default slope
+ * @param g              Power for default slope
+ * @param used_steps     Final number of steps is stored here
+ * @param vfinal         Final step time is stored here
+ * @return               Time for acceleration
+ * @note  All times in pixel time. Correction for other motor timings is not
+ *        done.
+ */
+SANE_Int
+sanei_genesys_generate_slope_table (uint16_t * slope_table,
+				    unsigned int max_steps,
+				    unsigned int use_steps,
+                                    uint16_t stop_at,
+				    uint16_t vstart,
+                                    uint16_t vend,
+				    unsigned int steps,
+                                    double g,
+				    unsigned int *used_steps,
+				    unsigned int *vfinal)
+{
+  double t;
+  SANE_Int sum = 0;
+  unsigned int i;
+  unsigned int c = 0;
+  uint16_t t2;
+  unsigned int dummy;
+  unsigned int _vfinal;
+  if (!used_steps)
+    used_steps = &dummy;
+  if (!vfinal)
+    vfinal = &_vfinal;
+
+  DBG(DBG_proc, "%s: table size: %d\n", __func__, max_steps);
+
+  DBG(DBG_proc, "%s: stop at time: %d, use %d steps max\n", __func__, stop_at, use_steps);
+
+  DBG(DBG_proc, "%s: target slope: vstart: %d, vend: %d, steps: %d, g: %g\n", __func__, vstart,
+      vend, steps, g);
+
+  sum = 0;
+  c = 0;
+  *used_steps = 0;
+
+  if (use_steps < 1)
+    use_steps = 1;
+
+  if (stop_at < vstart)
+    {
+      t2 = vstart;
+      for (i = 0; i < steps && i < use_steps - 1 && i < max_steps; i++, c++)
+	{
+	  t = pow (((double) i) / ((double) (steps - 1)), g);
+	  t2 = vstart * (1 - t) + t * vend;
+	  if (t2 < stop_at)
+	    break;
+	  *slope_table++ = t2;
+	  /* DBG (DBG_io, "slope_table[%3d] = %5d\n", c, t2); */
+	  sum += t2;
+	}
+      if (t2 > stop_at)
+	{
+	  DBG(DBG_warn, "Can not reach target speed(%d) in %d steps.\n", stop_at, use_steps);
+	  DBG(DBG_warn, "Expect image to be distorted. Ignore this if only feeding.\n");
+	}
+      *vfinal = t2;
+      *used_steps += i;
+      max_steps -= i;
+    }
+  else
+    *vfinal = stop_at;
+
+  for (i = 0; i < max_steps; i++, c++)
+    {
+      *slope_table++ = *vfinal;
+      /* DBG (DBG_io, "slope_table[%3d] = %5d\n", c, *vfinal); */
+    }
+
+  (*used_steps)++;
+  sum += *vfinal;
+
+  DBG(DBG_proc, "%s: returns sum=%d, used %d steps, completed\n", __func__, sum, *used_steps);
+
+  return sum;
+}
+
+/* Generate slope table for motor movement */
+/**
+ * This function generates a slope table using the slope from the motor struct
+ * truncated at the given exposure time or step count, whichever comes first.
+ * The reached step time is then stored in final_exposure and used for the rest
+ * of the table. The summed time of the acceleration steps is returned, and the
+ * number of accerelation steps is put into used_steps.
+ *
+ * @param dev            Device struct
+ * @param slope_table    Table to write to
+ * @param max_step       Size of slope_table in steps
+ * @param use_steps      Maximum number of steps to use for acceleration
+ * @param step_type      Generate table for this step_type. 0=>full, 1=>half,
+ *                       2=>quarter
+ * @param exposure_time  Minimum exposure time of a scan line
+ * @param yres           Resolution of a scan line
+ * @param used_steps     Final number of steps is stored here
+ * @param final_exposure Final step time is stored here
+ * @param power_mode     Power mode (related to the Vref used) of the motor
+ * @return               Time for acceleration
+ * @note  all times in pixel time
+ */
+SANE_Int
+sanei_genesys_create_slope_table3 (Genesys_Device * dev,
+				   uint16_t * slope_table,
+                                   int max_step,
+				   unsigned int use_steps,
+				   int step_type,
+                                   int exposure_time,
+				   double yres,
+				   unsigned int *used_steps,
+				   unsigned int *final_exposure,
+				   int power_mode)
+{
+  unsigned int sum_time = 0;
+  unsigned int vtarget;
+  unsigned int vend;
+  unsigned int vstart;
+  unsigned int vfinal;
+
+  DBG(DBG_proc, "%s: step_type = %d, exposure_time = %d, yres = %g, power_mode = %d\n", __func__,
+      step_type, exposure_time, yres, power_mode);
+
+  /* final speed */
+  vtarget = (exposure_time * yres) / dev->motor.base_ydpi;
+
+  vstart = dev->motor.slopes[power_mode][step_type].maximum_start_speed;
+  vend = dev->motor.slopes[power_mode][step_type].maximum_speed;
+
+  vtarget >>= step_type;
+  if (vtarget > 65535)
+    vtarget = 65535;
+
+  vstart >>= step_type;
+  if (vstart > 65535)
+    vstart = 65535;
+
+  vend >>= step_type;
+  if (vend > 65535)
+    vend = 65535;
+
+  sum_time = sanei_genesys_generate_slope_table (slope_table,
+                                                 max_step,
+						 use_steps,
+						 vtarget,
+						 vstart,
+						 vend,
+						 dev->motor.slopes[power_mode][step_type].minimum_steps << step_type,
+						 dev->motor.slopes[power_mode][step_type].g,
+                                                 used_steps,
+						 &vfinal);
+
+  if (final_exposure)
+    *final_exposure = (vfinal * dev->motor.base_ydpi) / yres;
+
+  DBG(DBG_proc, "%s: returns sum_time=%d, completed\n", __func__, sum_time);
+
+  return sum_time;
+}
+
+
+/* alternate slope table creation function        */
+/* the hardcoded values (g and vstart) will go in a motor struct */
+static SANE_Int
+genesys_create_slope_table2 (Genesys_Device * dev,
+			     uint16_t * slope_table, int steps,
+			     int step_type, int exposure_time,
+			     SANE_Bool same_speed, double yres,
+			     int power_mode)
+{
+  double t, g;
+  SANE_Int sum = 0;
+  int vstart, vend;
+  int i;
+
+  DBG(DBG_proc, "%s: %d steps, step_type = %d, "
+      "exposure_time = %d, same_speed = %d, yres = %.2f, power_mode = %d\n", __func__, steps,
+      step_type, exposure_time, same_speed, yres, power_mode);
+
+  /* start speed */
+  if (dev->model->motor_type == MOTOR_5345)
+    {
+      if (yres < dev->motor.base_ydpi / 6)
+	vstart = 2500;
+      else
+	vstart = 2000;
+    }
+  else
+    {
+      if (steps == 2)
+	vstart = exposure_time;
+      else if (steps == 3)
+	vstart = 2 * exposure_time;
+      else if (steps == 4)
+	vstart = 1.5 * exposure_time;
+      else if (steps == 120)
+	vstart = 1.81674 * exposure_time;
+      else
+	vstart = exposure_time;
+    }
+
+  /* final speed */
+  vend = (exposure_time * yres) / (dev->motor.base_ydpi * (1 << step_type));
+
+  /*
+     type=1 : full
+     type=2 : half
+     type=4 : quarter
+     vend * type * base_ydpi / exposure = yres
+   */
+
+  /* acceleration */
+  switch (steps)
+    {
+    case 255:
+      /* test for special case: fast moving slope */
+      /* todo: a 'fast' boolean parameter should be better */
+      if (vstart == 2000)
+	g = 0.2013;
+      else
+	g = 0.1677;
+      break;
+    case 120:
+      g = 0.5;
+      break;
+    case 67:
+      g = 0.5;
+      break;
+    case 64:
+      g = 0.2555;
+      break;
+    case 44:
+      g = 0.5;
+      break;
+    case 4:
+      g = 0.5;
+      break;
+    case 3:
+      g = 1;
+      break;
+    case 2:
+      vstart = vend;
+      g = 1;
+      break;
+    default:
+      g = 0.2635;
+    }
+
+  /* if same speed, no 'g' */
+  sum = 0;
+  if (same_speed)
+    {
+      for (i = 0; i < 255; i++)
+	{
+	  slope_table[i] = vend;
+	  sum += slope_table[i];
+	  DBG (DBG_io, "slope_table[%3d] = %5d\n", i, slope_table[i]);
+	}
+    }
+  else
+    {
+      for (i = 0; i < steps; i++)
+	{
+	  t = pow (((double) i) / ((double) (steps - 1)), g);
+	  slope_table[i] = vstart * (1 - t) + t * vend;
+	  DBG (DBG_io, "slope_table[%3d] = %5d\n", i, slope_table[i]);
+	  sum += slope_table[i];
+	}
+      for (i = steps; i < 255; i++)
+	{
+	  slope_table[i] = vend;
+	  DBG (DBG_io, "slope_table[%3d] = %5d\n", i, slope_table[i]);
+	  sum += slope_table[i];
+	}
+    }
+
+  DBG(DBG_proc, "%s: returns sum=%d, completed\n", __func__, sum);
+
+  return sum;
+}
+
+/* Generate slope table for motor movement */
+/* todo: check details */
+SANE_Int
+sanei_genesys_create_slope_table (Genesys_Device * dev,
+				  uint16_t * slope_table, int steps,
+				  int step_type, int exposure_time,
+				  SANE_Bool same_speed, double yres,
+				  int power_mode)
+{
+  double t;
+  double start_speed;
+  double g;
+  uint32_t time_period;
+  int sum_time = 0;
+  int i, divider;
+  int same_step;
+
+  if (dev->model->motor_type == MOTOR_5345
+      || dev->model->motor_type == MOTOR_HP2300
+      || dev->model->motor_type == MOTOR_HP2400)
+    return genesys_create_slope_table2 (dev, slope_table, steps,
+					step_type, exposure_time,
+					same_speed, yres, power_mode);
+
+  DBG(DBG_proc, "%s: %d steps, step_type = %d, exposure_time = %d, same_speed =%d\n", __func__,
+      steps, step_type, exposure_time, same_speed);
+  DBG(DBG_proc, "%s: yres = %.2f\n", __func__, yres);
+
+  g = 0.6;
+  start_speed = 0.01;
+  same_step = 4;
+  divider = 1 << step_type;
+
+  time_period =
+    (uint32_t) (yres * exposure_time / dev->motor.base_ydpi /*MOTOR_GEAR */ );
+  if ((time_period < 2000) && (same_speed))
+    same_speed = SANE_FALSE;
+
+  time_period = time_period / divider;
+
+  if (same_speed)
+    {
+      for (i = 0; i < steps; i++)
+	{
+	  slope_table[i] = (uint16_t) time_period;
+	  sum_time += time_period;
+
+	  DBG (DBG_io, "slope_table[%d] = %d\n", i, time_period);
+	}
+      DBG(DBG_info, "%s: returns sum_time=%d, completed\n", __func__, sum_time);
+      return sum_time;
+    }
+
+  if (time_period > MOTOR_SPEED_MAX * 5)
+    {
+      g = 1.0;
+      start_speed = 0.05;
+      same_step = 2;
+    }
+  else if (time_period > MOTOR_SPEED_MAX * 4)
+    {
+      g = 0.8;
+      start_speed = 0.04;
+      same_step = 2;
+    }
+  else if (time_period > MOTOR_SPEED_MAX * 3)
+    {
+      g = 0.7;
+      start_speed = 0.03;
+      same_step = 2;
+    }
+  else if (time_period > MOTOR_SPEED_MAX * 2)
+    {
+      g = 0.6;
+      start_speed = 0.02;
+      same_step = 3;
+    }
+
+  if (dev->model->motor_type == MOTOR_ST24)
+    {
+      steps = 255;
+      switch ((int) yres)
+	{
+	case 2400:
+	  g = 0.1672;
+	  start_speed = 1.09;
+	  break;
+	case 1200:
+	  g = 1;
+	  start_speed = 6.4;
+	  break;
+	case 600:
+	  g = 0.1672;
+	  start_speed = 1.09;
+	  break;
+	case 400:
+	  g = 0.2005;
+	  start_speed = 20.0 / 3.0 /*7.5 */ ;
+	  break;
+	case 300:
+	  g = 0.253;
+	  start_speed = 2.182;
+	  break;
+	case 150:
+	  g = 0.253;
+	  start_speed = 4.367;
+	  break;
+	default:
+	  g = 0.262;
+	  start_speed = 7.29;
+	}
+      same_step = 1;
+    }
+
+  if (steps <= same_step)
+    {
+      time_period =
+	(uint32_t) (yres * exposure_time /
+		    dev->motor.base_ydpi /*MOTOR_GEAR */ );
+      time_period = time_period / divider;
+
+      if (time_period > 65535)
+	time_period = 65535;
+
+      for (i = 0; i < same_step; i++)
+	{
+	  slope_table[i] = (uint16_t) time_period;
+	  sum_time += time_period;
+
+	  DBG (DBG_io, "slope_table[%d] = %d\n", i, time_period);
+	}
+
+      DBG(DBG_proc, "%s: returns sum_time=%d, completed\n", __func__, sum_time);
+      return sum_time;
+    }
+
+  for (i = 0; i < steps; i++)
+    {
+      double j = ((double) i) - same_step + 1;	/* start from 1/16 speed */
+
+      if (j <= 0)
+	t = 0;
+      else
+	t = pow (j / (steps - same_step), g);
+
+      time_period =		/* time required for full steps */
+	(uint32_t) (yres * exposure_time /
+		    dev->motor.base_ydpi /*MOTOR_GEAR */  *
+		    (start_speed + (1 - start_speed) * t));
+
+      time_period = time_period / divider;
+      if (time_period > 65535)
+	time_period = 65535;
+
+      slope_table[i] = (uint16_t) time_period;
+      sum_time += time_period;
+
+      DBG (DBG_io, "slope_table[%d] = %d\n", i, slope_table[i]);
+    }
+
+  DBG(DBG_proc, "%s: returns sum_time=%d, completed\n", __func__, sum_time);
+
+  return sum_time;
+}
+
+/** @brief computes gamma table
+ * Generates a gamma table of the given length within 0 and the given
+ * maximum value
+ * @param gamma_table gamma table to fill
+ * @param size size of the table
+ * @param maximum value allowed for gamma
+ * @param gamma_max maximum gamma value
+ * @param gamma gamma to compute values
+ * @return a gamma table filled with the computed values
+ * */
+void
+sanei_genesys_create_gamma_table (std::vector<uint16_t>& gamma_table, int size,
+                                  float maximum, float gamma_max, float gamma)
+{
+    gamma_table.clear();
+    gamma_table.resize(size, 0);
+
+  int i;
+  float value;
+
+  DBG(DBG_proc, "%s: size = %d, ""maximum = %g, gamma_max = %g, gamma = %g\n", __func__, size,
+      maximum, gamma_max, gamma);
+  for (i = 0; i < size; i++)
+    {
+      value = gamma_max * pow ((float) i / size, 1.0 / gamma);
+      if (value > maximum)
+	value = maximum;
+      gamma_table[i] = value;
+    }
+  DBG(DBG_proc, "%s: completed\n", __func__);
+}
+
+void sanei_genesys_create_default_gamma_table(Genesys_Device* dev,
+                                              std::vector<uint16_t>& gamma_table, float gamma)
+{
+    int size = 0;
+    int max = 0;
+    if (dev->model->asic_type == GENESYS_GL646) {
+        if (dev->model->flags & GENESYS_FLAG_14BIT_GAMMA) {
+            size = 16384;
+        } else {
+            size = 4096;
+        }
+        max = size - 1;
+    } else {
+        size = 256;
+        max = 65535;
+    }
+    sanei_genesys_create_gamma_table(gamma_table, size, max, max, gamma);
+}
+
+/* computes the exposure_time on the basis of the given vertical dpi,
+   the number of pixels the ccd needs to send,
+   the step_type and the corresponding maximum speed from the motor struct */
+/*
+  Currently considers maximum motor speed at given step_type, minimum
+  line exposure needed for conversion and led exposure time.
+
+  TODO: Should also consider maximum transfer rate: ~6.5MB/s.
+    Note: The enhance option of the scanners does _not_ help. It only halves
+          the amount of pixels transfered.
+ */
+SANE_Int
+sanei_genesys_exposure_time2 (Genesys_Device * dev, float ydpi,
+			      int step_type, int endpixel,
+			      int exposure_by_led, int power_mode)
+{
+  int exposure_by_ccd = endpixel + 32;
+  int exposure_by_motor =
+    (dev->motor.slopes[power_mode][step_type].maximum_speed
+     * dev->motor.base_ydpi) / ydpi;
+
+  int exposure = exposure_by_ccd;
+
+  if (exposure < exposure_by_motor)
+    exposure = exposure_by_motor;
+
+  if (exposure < exposure_by_led && dev->model->is_cis)
+    exposure = exposure_by_led;
+
+  DBG(DBG_info, "%s: ydpi=%d, step=%d, endpixel=%d led=%d, power=%d => exposure=%d\n", __func__,
+      (int)ydpi, step_type, endpixel, exposure_by_led, power_mode, exposure);
+  return exposure;
+}
+
+/* computes the exposure_time on the basis of the given horizontal dpi */
+/* we will clean/simplify it by using constants from a future motor struct */
+SANE_Int
+sanei_genesys_exposure_time (Genesys_Device * dev, Genesys_Register_Set * reg,
+			     int xdpi)
+{
+  if (dev->model->motor_type == MOTOR_5345)
+    {
+      if (dev->model->cmd_set->get_filter_bit (reg))
+	{
+	  /* monochrome */
+	  switch (xdpi)
+	    {
+	    case 600:
+	      return 8500;
+	    case 500:
+	    case 400:
+	    case 300:
+	    case 250:
+	    case 200:
+	    case 150:
+	      return 5500;
+	    case 100:
+	      return 6500;
+	    case 50:
+	      return 12000;
+	    default:
+	      return 11000;
+	    }
+	}
+      else
+	{
+	  /* color scan */
+	  switch (xdpi)
+	    {
+	    case 300:
+	    case 250:
+	    case 200:
+	      return 5500;
+	    case 50:
+	      return 12000;
+	    default:
+	      return 11000;
+	    }
+	}
+    }
+  else if (dev->model->motor_type == MOTOR_HP2400)
+    {
+      if (dev->model->cmd_set->get_filter_bit (reg))
+	{
+	  /* monochrome */
+	  switch (xdpi)
+	    {
+	    case 200:
+	      return 7210;
+	    default:
+	      return 11111;
+	    }
+	}
+      else
+	{
+	  /* color scan */
+	  switch (xdpi)
+	    {
+	    case 600:
+	      return 8751;	/*11902; 19200 */
+	    default:
+	      return 11111;
+	    }
+	}
+    }
+  else if (dev->model->motor_type == MOTOR_HP2300)
+    {
+      if (dev->model->cmd_set->get_filter_bit (reg))
+	{
+	  /* monochrome */
+	  switch (xdpi)
+	    {
+	    case 600:
+	      return 8699;	/* 3200; */
+	    case 300:
+	      return 3200;	/*10000;, 3200 -> too dark */
+	    case 150:
+	      return 4480;	/* 3200 ???, warmup needs 4480 */
+	    case 75:
+	      return 5500;
+	    default:
+	      return 11111;
+	    }
+	}
+      else
+	{
+	  /* color scan */
+	  switch (xdpi)
+	    {
+	    case 600:
+	      return 8699;
+	    case 300:
+	      return 4349;
+	    case 150:
+	    case 75:
+	      return 4480;
+	    default:
+	      return 11111;
+	    }
+	}
+    }
+  return 11000;
+}
+
+
+
+/* Sends a block of shading information to the scanner.
+   The data is placed at address 0x0000 for color mode, gray mode and
+   unconditionally for the following CCD chips: HP2300, HP2400 and HP5345
+   In the other cases (lineart, halftone on ccd chips not mentioned) the
+   addresses are 0x2a00 for dpihw==0, 0x5500 for dpihw==1 and 0xa800 for
+   dpihw==2. //Note: why this?
+
+   The data needs to be of size "size", and in little endian byte order.
+ */
+static SANE_Status
+genesys_send_offset_and_shading (Genesys_Device * dev, const Genesys_Sensor& sensor,
+                                 uint8_t * data,
+				 int size)
+{
+  int dpihw;
+  int start_address;
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  DBG(DBG_proc, "%s: (size = %d)\n", __func__, size);
+
+  /* ASIC higher than gl843 doesn't have register 2A/2B, so we route to
+   * a per ASIC shading data loading function if available.
+   * It is also used for scanners using SHDAREA */
+  if(dev->model->cmd_set->send_shading_data!=NULL)
+    {
+        status=dev->model->cmd_set->send_shading_data(dev, sensor, data, size);
+        DBGCOMPLETED;
+        return status;
+    }
+
+  /* gl646, gl84[123] case */
+  dpihw = dev->reg.get8(0x05) >> 6;
+
+  /* TODO invert the test so only the 2 models behaving like that are
+   * tested instead of adding all the others */
+  /* many scanners send coefficient for lineart/gray like in color mode */
+  if ((dev->settings.scan_mode == ScanColorMode::LINEART ||
+       dev->settings.scan_mode == ScanColorMode::HALFTONE)
+      && dev->model->ccd_type != CCD_PLUSTEK3800
+      && dev->model->ccd_type != CCD_KVSS080
+      && dev->model->ccd_type != CCD_G4050
+      && dev->model->ccd_type != CCD_CS4400F
+      && dev->model->ccd_type != CCD_CS8400F
+      && dev->model->ccd_type != CCD_CS8600F
+      && dev->model->ccd_type != CCD_DSMOBILE600
+      && dev->model->ccd_type != CCD_XP300
+      && dev->model->ccd_type != CCD_DP665
+      && dev->model->ccd_type != CCD_DP685
+      && dev->model->ccd_type != CIS_CANONLIDE80
+      && dev->model->ccd_type != CCD_ROADWARRIOR
+      && dev->model->ccd_type != CCD_HP2300
+      && dev->model->ccd_type != CCD_HP2400
+      && dev->model->ccd_type != CCD_HP3670
+      && dev->model->ccd_type != CCD_5345)	/* lineart, halftone */
+    {
+      if (dpihw == 0)		/* 600 dpi */
+	start_address = 0x02a00;
+      else if (dpihw == 1)	/* 1200 dpi */
+	start_address = 0x05500;
+      else if (dpihw == 2)	/* 2400 dpi */
+	start_address = 0x0a800;
+      else			/* reserved */
+	return SANE_STATUS_INVAL;
+    }
+  else				/* color */
+    start_address = 0x00;
+
+  status = sanei_genesys_set_buffer_address (dev, start_address);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to set buffer address: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  status = dev->model->cmd_set->bulk_write_data (dev, 0x3c, data, size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to send shading table: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  DBGCOMPLETED;
+
+  return SANE_STATUS_GOOD;
+}
+
+/* ? */
+SANE_Status
+sanei_genesys_init_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
+                                 int pixels_per_line)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  int channels;
+  int i;
+
+  /* these models don't need to init shading data due to the use of specific send shading data
+     function */
+  if (dev->model->ccd_type==CCD_KVSS080
+   || dev->model->ccd_type==CCD_G4050
+   || dev->model->ccd_type==CCD_CS4400F
+   || dev->model->ccd_type==CCD_CS8400F
+   || dev->model->cmd_set->send_shading_data!=NULL)
+    return SANE_STATUS_GOOD;
+
+  DBG(DBG_proc, "%s (pixels_per_line = %d)\n", __func__, pixels_per_line);
+
+    // BUG: GRAY shouldn't probably be in the if condition below. Discovered when refactoring
+    if (dev->settings.scan_mode == ScanColorMode::GRAY ||
+        dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
+    {
+        channels = 3;
+    } else {
+        channels = 1;
+    }
+
+  // 16 bit black, 16 bit white
+  std::vector<uint8_t> shading_data(pixels_per_line * 4 * channels, 0);
+
+  uint8_t* shading_data_ptr = shading_data.data();
+
+  for (i = 0; i < pixels_per_line * channels; i++)
+    {
+      *shading_data_ptr++ = 0x00;	/* dark lo */
+      *shading_data_ptr++ = 0x00;	/* dark hi */
+      *shading_data_ptr++ = 0x00;	/* white lo */
+      *shading_data_ptr++ = 0x40;	/* white hi -> 0x4000 */
+    }
+
+  status = genesys_send_offset_and_shading (dev, sensor,
+                                            shading_data.data(),
+                                            pixels_per_line * 4 * channels);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to send shading data: %s\n", __func__,
+	  sane_strstatus (status));
+    }
+
+  DBGCOMPLETED;
+  return status;
+}
+
+
+/* Find the position of the reference point:
+   takes gray level 8 bits data and find
+   first CCD usable pixel and top of scanning area */
+SANE_Status
+sanei_genesys_search_reference_point (Genesys_Device * dev, Genesys_Sensor& sensor,
+                                      uint8_t * data,
+				      int start_pixel, int dpi, int width,
+				      int height)
+{
+  int x, y;
+  int current, left, top = 0;
+  int size, count;
+  int level = 80;		/* edge threshold level */
+
+  /*sanity check */
+  if ((width < 3) || (height < 3))
+    return SANE_STATUS_INVAL;
+
+  /* transformed image data */
+  size = width * height;
+  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
+  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] +
+	   data[(y - 1) * width + x - 1] + 2 * data[y * width + x + 1] +
+	   4 * data[y * width + x] + 2 * data[y * width + x - 1] +
+	   data[(y + 1) * width + x + 1] + 2 * data[(y + 1) * width + x] +
+	   data[(y + 1) * width + x - 1]) / 16;
+      }
+
+  memcpy (data, image.data(), size);
+  if (DBG_LEVEL >= DBG_data)
+    sanei_genesys_write_pnm_file("gl_laplace.pnm", image.data(), 8, 1, width, height);
+
+  /* apply X direction sobel filter
+     -1  0  1
+     -2  0  2
+     -1  0  1
+     and finds threshold level
+   */
+  level = 0;
+  for (y = 2; y < height - 2; y++)
+    for (x = 2; x < width - 2; x++)
+      {
+	current =
+	  data[(y - 1) * width + x + 1] - data[(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)
+	  current = 255;
+	image[y * width + x] = current;
+	if (current > level)
+	  level = current;
+      }
+  if (DBG_LEVEL >= DBG_data)
+    sanei_genesys_write_pnm_file("gl_xsobel.pnm", image.data(), 8, 1, width, height);
+
+  /* set up detection level */
+  level = level / 3;
+
+  /* find left black margin first
+     todo: search top before left
+     we average the result of N searches */
+  left = 0;
+  count = 0;
+  for (y = 2; y < 11; y++)
+    {
+      x = 8;
+      while ((x < width / 2) && (image[y * width + x] < level))
+	{
+	  image[y * width + x] = 255;
+	  x++;
+	}
+      count++;
+      left += x;
+    }
+  if (DBG_LEVEL >= DBG_data)
+    sanei_genesys_write_pnm_file("gl_detected-xsobel.pnm", image.data(), 8, 1, width, height);
+  left = left / count;
+
+  /* turn it in CCD pixel at full sensor optical resolution */
+  sensor.CCD_start_xoffset = start_pixel + (left * sensor.optical_res) / dpi;
+
+  /* find top edge by detecting black strip */
+  /* apply Y direction sobel filter
+     -1 -2 -1
+     0  0  0
+     1  2  1
+   */
+  level = 0;
+  for (y = 2; y < height - 2; y++)
+    for (x = 2; x < width - 2; x++)
+      {
+	current =
+	  -data[(y - 1) * width + x + 1] - 2 * data[(y - 1) * width + x] -
+	  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)
+	  current = 255;
+	image[y * width + x] = current;
+	if (current > level)
+	  level = current;
+      }
+  if (DBG_LEVEL >= DBG_data)
+    sanei_genesys_write_pnm_file("gl_ysobel.pnm", image.data(), 8, 1, width, height);
+
+  /* set up detection level */
+  level = level / 3;
+
+  /* search top of horizontal black stripe : TODO yet another flag */
+  if (dev->model->ccd_type == CCD_5345
+      && dev->model->motor_type == MOTOR_5345)
+    {
+      top = 0;
+      count = 0;
+      for (x = width / 2; x < width - 1; x++)
+	{
+	  y = 2;
+	  while ((y < height) && (image[x + y * width] < level))
+	    {
+	      image[y * width + x] = 255;
+	      y++;
+	    }
+	  count++;
+	  top += y;
+	}
+      if (DBG_LEVEL >= DBG_data)
+        sanei_genesys_write_pnm_file("gl_detected-ysobel.pnm", image.data(), 8, 1, width, height);
+      top = top / count;
+
+      /* bottom of black stripe is of fixed witdh, this hardcoded value
+       * will be moved into device struct if more such values are needed */
+      top += 10;
+      dev->model->y_offset_calib = SANE_FIX ((top * MM_PER_INCH) / dpi);
+      DBG(DBG_info, "%s: black stripe y_offset = %f mm \n", __func__,
+          SANE_UNFIX (dev->model->y_offset_calib));
+    }
+
+  /* find white corner in dark area : TODO yet another flag */
+  if ((dev->model->ccd_type == CCD_HP2300
+       && dev->model->motor_type == MOTOR_HP2300)
+      || (dev->model->ccd_type == CCD_HP2400
+	  && dev->model->motor_type == MOTOR_HP2400)
+      || (dev->model->ccd_type == CCD_HP3670
+	  && dev->model->motor_type == MOTOR_HP3670))
+    {
+      top = 0;
+      count = 0;
+      for (x = 10; x < 60; x++)
+	{
+	  y = 2;
+	  while ((y < height) && (image[x + y * width] < level))
+	    y++;
+	  top += y;
+	  count++;
+	}
+      top = top / count;
+      dev->model->y_offset_calib = SANE_FIX ((top * MM_PER_INCH) / dpi);
+      DBG(DBG_info, "%s: white corner y_offset = %f mm\n", __func__,
+          SANE_UNFIX (dev->model->y_offset_calib));
+    }
+
+  DBG(DBG_proc, "%s: CCD_start_xoffset = %d, left = %d, top = %d\n", __func__,
+      sensor.CCD_start_xoffset, left, top);
+
+  return SANE_STATUS_GOOD;
+}
+
+
+void
+sanei_genesys_calculate_zmode2 (SANE_Bool two_table,
+				uint32_t exposure_time,
+				uint16_t * slope_table,
+				int reg21,
+				int move, int reg22, uint32_t * z1,
+				uint32_t * z2)
+{
+  int i;
+  int sum;
+  DBG(DBG_info, "%s: two_table=%d\n", __func__, two_table);
+
+  /* acceleration total time */
+  sum = 0;
+  for (i = 0; i < reg21; i++)
+    sum += slope_table[i];
+
+  /* compute Z1MOD */
+  /* c=sum(slope_table;reg21)
+     d=reg22*cruising speed
+     Z1MOD=(c+d) % exposure_time */
+  *z1 = (sum + reg22 * slope_table[reg21 - 1]) % exposure_time;
+
+  /* compute Z2MOD */
+  /* a=sum(slope_table;reg21), b=move or 1 if 2 tables */
+  /* Z2MOD=(a+b) % exposure_time */
+  if (!two_table)
+    sum = sum + (move * slope_table[reg21 - 1]);
+  else
+    sum = sum + slope_table[reg21 - 1];
+  *z2 = sum % exposure_time;
+}
+
+
+/* huh? */
+/* todo: double check */
+/* Z1 and Z2 seem to be a time to synchronize with clock or a phase correction */
+/* steps_sum	is the result of create_slope_table 	*/
+/* last_speed	is the last entry of the slope_table 	*/
+/* feedl	is registers 3d,3e,3f 			 */
+/* fastfed	is register 02 bit 3		 	*/
+/* scanfed	is register 1f 				*/
+/* fwdstep	is register 22 				*/
+/* tgtime	is register 6c bit 6+7 >> 6 		*/
+
+void
+sanei_genesys_calculate_zmode (uint32_t exposure_time,
+			       uint32_t steps_sum, uint16_t last_speed,
+			       uint32_t feedl, uint8_t fastfed,
+			       uint8_t scanfed, uint8_t fwdstep,
+			       uint8_t tgtime, uint32_t * z1, uint32_t * z2)
+{
+  uint8_t exposure_factor;
+
+  exposure_factor = pow (2, tgtime);	/* todo: originally, this is always 2^0 ! */
+
+  /* Z1 is for buffer-full backward forward moving */
+  *z1 =
+    exposure_factor * ((steps_sum + fwdstep * last_speed) % exposure_time);
+
+  /* Z2 is for acceleration before scan */
+  if (fastfed)			/* two curve mode */
+    {
+      *z2 =
+	exposure_factor * ((steps_sum + scanfed * last_speed) %
+			   exposure_time);
+    }
+  else				/* one curve mode */
+    {
+      *z2 =
+	exposure_factor * ((steps_sum + feedl * last_speed) % exposure_time);
+    }
+}
+
+
+static uint8_t genesys_adjust_gain(double* applied_multi, double multi, uint8_t gain)
+{
+  double voltage, original_voltage;
+  uint8_t new_gain = 0;
+
+  DBG(DBG_proc, "%s: multi=%f, gain=%d\n", __func__, multi, gain);
+
+  voltage = 0.5 + gain * 0.25;
+  original_voltage = voltage;
+
+  voltage *= multi;
+
+  new_gain = (uint8_t) ((voltage - 0.5) * 4);
+  if (new_gain > 0x0e)
+    new_gain = 0x0e;
+
+  voltage = 0.5 + (new_gain) * 0.25;
+
+  *applied_multi = voltage / original_voltage;
+
+  DBG(DBG_proc, "%s: orig voltage=%.2f, new voltage=%.2f, *applied_multi=%f, new_gain=%d\n",
+      __func__, original_voltage, voltage, *applied_multi, new_gain);
+
+  return new_gain;
+}
+
+
+/* todo: is return status necessary (unchecked?) */
+static SANE_Status
+genesys_average_white (Genesys_Device * dev, Genesys_Sensor& sensor, int channels, int channel,
+		       uint8_t * data, int size, int *max_average)
+{
+  int gain_white_ref, sum, range;
+  int average;
+  int i;
+
+  DBG(DBG_proc, "%s: channels=%d, channel=%d, size=%d\n", __func__, channels, channel, size);
+
+  range = size / 50;
+
+  if (dev->settings.scan_method == ScanMethod::TRANSPARENCY)	/* transparency mode */
+    gain_white_ref = sensor.fau_gain_white_ref * 256;
+  else
+    gain_white_ref = sensor.gain_white_ref * 256;
+
+  if (range < 1)
+    range = 1;
+
+  size = size / (2 * range * channels);
+
+  data += (channel * 2);
+
+  *max_average = 0;
+
+  while (size--)
+    {
+      sum = 0;
+      for (i = 0; i < range; i++)
+	{
+	  sum += (*data);
+	  sum += *(data + 1) * 256;
+	  data += (2 * channels);	/* byte based */
+	}
+
+      average = (sum / range);
+      if (average > *max_average)
+	*max_average = average;
+    }
+
+  DBG(DBG_proc, "%s: max_average=%d, gain_white_ref = %d, finished\n", __func__, *max_average,
+      gain_white_ref);
+
+  if (*max_average >= gain_white_ref)
+    return SANE_STATUS_INVAL;
+
+  return SANE_STATUS_GOOD;
+}
+
+/* todo: understand, values are too high */
+static int
+genesys_average_black (Genesys_Device * dev, int channel,
+		       uint8_t * data, int pixels)
+{
+  int i;
+  int sum;
+  int pixel_step;
+
+  DBG(DBG_proc, "%s: channel=%d, pixels=%d\n", __func__, channel, pixels);
+
+  sum = 0;
+
+  if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
+    {
+      data += (channel * 2);
+      pixel_step = 3 * 2;
+    }
+  else
+    {
+      pixel_step = 2;
+    }
+
+  for (i = 0; i < pixels; i++)
+    {
+      sum += *data;
+      sum += *(data + 1) * 256;
+
+      data += pixel_step;
+    }
+
+  DBG(DBG_proc, "%s = %d\n", __func__, sum / pixels);
+
+  return (int) (sum / pixels);
+}
+
+
+/* todo: check; it works but the lines 1, 2, and 3 are too dark even with the
+   same offset and gain settings? */
+static SANE_Status genesys_coarse_calibration(Genesys_Device * dev, Genesys_Sensor& sensor)
+{
+  int size;
+  int black_pixels;
+  int white_average;
+  int channels;
+  SANE_Status status = SANE_STATUS_GOOD;
+  uint8_t offset[4] = { 0xa0, 0x00, 0xa0, 0x40 };	/* first value isn't used */
+  uint16_t white[12], dark[12];
+  int i, j;
+
+  DBG(DBG_info, "%s (scan_mode = %d)\n", __func__, static_cast<unsigned>(dev->settings.scan_mode));
+
+  black_pixels = sensor.black_pixels
+    * dev->settings.xres / sensor.optical_res;
+
+  if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
+    channels = 3;
+  else
+    channels = 1;
+
+  DBG(DBG_info, "channels %d y_size %d xres %d\n", channels, dev->model->y_size,
+      dev->settings.xres);
+  size =
+    channels * 2 * SANE_UNFIX (dev->model->y_size) * dev->settings.xres /
+    25.4;
+  /*       1        1               mm                      1/inch        inch/mm */
+
+  std::vector<uint8_t> calibration_data(size);
+  std::vector<uint8_t> all_data(size * 4, 1);
+
+  status = dev->model->cmd_set->set_fe(dev, sensor, AFE_INIT);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to set frontend: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  dev->frontend.set_gain(0, 2);
+  dev->frontend.set_gain(1, 2);
+  dev->frontend.set_gain(2, 2); // TODO: ?  was 2
+  dev->frontend.set_offset(0, offset[0]);
+  dev->frontend.set_offset(1, offset[0]);
+  dev->frontend.set_offset(2, offset[0]);
+
+  for (i = 0; i < 4; i++)	/* read 4 lines */
+    {
+      if (i < 3)		/* first 3 lines */
+        {
+          dev->frontend.set_offset(0, offset[i]);
+          dev->frontend.set_offset(1, offset[i]);
+          dev->frontend.set_offset(2, offset[i]);
+        }
+
+      if (i == 1)		/* second line */
+	{
+	  double applied_multi;
+	  double gain_white_ref;
+
+          if (dev->settings.scan_method == ScanMethod::TRANSPARENCY)	/* Transparency */
+            gain_white_ref = sensor.fau_gain_white_ref * 256;
+	  else
+            gain_white_ref = sensor.gain_white_ref * 256;
+	  /* white and black are defined downwards */
+
+            uint8_t gain0 = genesys_adjust_gain(&applied_multi,
+                                                gain_white_ref / (white[0] - dark[0]),
+                                                dev->frontend.get_gain(0));
+            uint8_t gain1 = genesys_adjust_gain(&applied_multi,
+                                                gain_white_ref / (white[1] - dark[1]),
+                                                dev->frontend.get_gain(1));
+            uint8_t gain2 = genesys_adjust_gain(&applied_multi,
+                                                gain_white_ref / (white[2] - dark[2]),
+                                                dev->frontend.get_gain(2));
+            // FIXME: looks like overwritten data. Are the above calculations doing
+            // anything at all?
+            dev->frontend.set_gain(0, gain0);
+            dev->frontend.set_gain(1, gain1);
+            dev->frontend.set_gain(2, gain2);
+            dev->frontend.set_gain(0, 2);
+            dev->frontend.set_gain(1, 2);
+            dev->frontend.set_gain(2, 2);
+
+	  status =
+            sanei_genesys_fe_write_data(dev, 0x28, dev->frontend.get_gain(0));
+	  if (status != SANE_STATUS_GOOD)	/* todo: this was 0x28 + 3 ? */
+	    {
+              DBG(DBG_error, "%s: Failed to write gain[0]: %s\n", __func__, sane_strstatus(status));
+	      return status;
+	    }
+
+	  status =
+            sanei_genesys_fe_write_data(dev, 0x29, dev->frontend.get_gain(1));
+	  if (status != SANE_STATUS_GOOD)
+	    {
+              DBG(DBG_error, "%s: Failed to write gain[1]: %s\n", __func__, sane_strstatus(status));
+	      return status;
+	    }
+
+	  status =
+            sanei_genesys_fe_write_data(dev, 0x2a, dev->frontend.get_gain(2));
+	  if (status != SANE_STATUS_GOOD)
+	    {
+              DBG(DBG_error, "%s: Failed to write gain[2]: %s\n", __func__, sane_strstatus(status));
+	      return status;
+	    }
+	}
+
+      if (i == 3)		/* last line */
+	{
+	  double x, y, rate;
+
+	  for (j = 0; j < 3; j++)
+	    {
+
+	      x =
+		(double) (dark[(i - 2) * 3 + j] -
+			  dark[(i - 1) * 3 + j]) * 254 / (offset[i - 1] / 2 -
+							  offset[i - 2] / 2);
+	      y = x - x * (offset[i - 1] / 2) / 254 - dark[(i - 1) * 3 + j];
+	      rate = (x - DARK_VALUE - y) * 254 / x + 0.5;
+
+                uint8_t curr_offset = static_cast<uint8_t>(rate);
+
+                if (curr_offset > 0x7f) {
+                    curr_offset = 0x7f;
+                }
+                curr_offset <<= 1;
+                dev->frontend.set_offset(j, curr_offset);
+	    }
+	}
+      status =
+        sanei_genesys_fe_write_data(dev, 0x20, dev->frontend.get_offset(0));
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: Failed to write offset[0]: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+      status =
+        sanei_genesys_fe_write_data(dev, 0x21, dev->frontend.get_offset(1));
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: Failed to write offset[1]: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+      status =
+        sanei_genesys_fe_write_data(dev, 0x22, dev->frontend.get_offset(2));
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: Failed to write offset[2]: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+      DBG(DBG_info,
+          "%s: doing scan: gain: %d/%d/%d, offset: %d/%d/%d\n", __func__,
+          dev->frontend.get_gain(0),
+          dev->frontend.get_gain(1),
+          dev->frontend.get_gain(2),
+          dev->frontend.get_offset(0),
+          dev->frontend.get_offset(1),
+          dev->frontend.get_offset(2));
+
+      status =
+        dev->model->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, SANE_FALSE);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: Failed to begin scan: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+      status =
+    sanei_genesys_read_data_from_scanner (dev, calibration_data.data(), size);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: Failed to read data: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+      std::memcpy(all_data.data() + i * size, calibration_data.data(), size);
+      if (i == 3)		/* last line */
+	{
+          std::vector<uint8_t> all_data_8(size * 4 / 2);
+	  unsigned int count;
+
+	  for (count = 0; count < (unsigned int) (size * 4 / 2); count++)
+	    all_data_8[count] = all_data[count * 2 + 1];
+	  status =
+            sanei_genesys_write_pnm_file("gl_coarse.pnm", all_data_8.data(), 8, channels, size / 6, 4);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+              DBG(DBG_error, "%s: failed: %s\n", __func__, sane_strstatus(status));
+	      return status;
+	    }
+	}
+
+      status = dev->model->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: Failed to end scan: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+      if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
+	{
+	  for (j = 0; j < 3; j++)
+	    {
+          genesys_average_white (dev, sensor, 3, j, calibration_data.data(), size,
+				     &white_average);
+	      white[i * 3 + j] = white_average;
+	      dark[i * 3 + j] =
+        genesys_average_black (dev, j, calibration_data.data(),
+				       black_pixels);
+              DBG(DBG_info, "%s: white[%d]=%d, black[%d]=%d\n", __func__,
+                  i * 3 + j, white[i * 3 + j], i * 3 + j, dark[i * 3 + j]);
+	    }
+	}
+      else			/* one color-component modes */
+	{
+      genesys_average_white (dev, sensor, 1, 0, calibration_data.data(), size,
+				 &white_average);
+	  white[i * 3 + 0] = white[i * 3 + 1] = white[i * 3 + 2] =
+	    white_average;
+	  dark[i * 3 + 0] = dark[i * 3 + 1] = dark[i * 3 + 2] =
+        genesys_average_black (dev, 0, calibration_data.data(), black_pixels);
+	}
+
+      if (i == 3)
+	{
+          if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
+	    {
+	      /* todo: huh? */
+	      dev->dark[0] =
+		(uint16_t) (1.6925 * dark[i * 3 + 0] + 0.1895 * 256);
+	      dev->dark[1] =
+		(uint16_t) (1.4013 * dark[i * 3 + 1] + 0.3147 * 256);
+	      dev->dark[2] =
+		(uint16_t) (1.2931 * dark[i * 3 + 2] + 0.1558 * 256);
+	    }
+	  else			/* one color-component modes */
+	    {
+	      switch (dev->settings.color_filter)
+		{
+                case ColorFilter::RED:
+		default:
+		  dev->dark[0] =
+		    (uint16_t) (1.6925 * dark[i * 3 + 0] +
+				(1.1895 - 1.0) * 256);
+		  dev->dark[1] = dev->dark[2] = dev->dark[0];
+		  break;
+
+                case ColorFilter::GREEN:
+		  dev->dark[1] =
+		    (uint16_t) (1.4013 * dark[i * 3 + 1] +
+				(1.3147 - 1.0) * 256);
+		  dev->dark[0] = dev->dark[2] = dev->dark[1];
+		  break;
+
+                case ColorFilter::BLUE:
+		  dev->dark[2] =
+		    (uint16_t) (1.2931 * dark[i * 3 + 2] +
+				(1.1558 - 1.0) * 256);
+		  dev->dark[0] = dev->dark[1] = dev->dark[2];
+		  break;
+		}
+	    }
+	}
+    }				/* for (i = 0; i < 4; i++) */
+
+  DBG(DBG_info, "%s: final: gain: %d/%d/%d, offset: %d/%d/%d\n", __func__,
+      dev->frontend.get_gain(0),
+      dev->frontend.get_gain(1),
+      dev->frontend.get_gain(2),
+      dev->frontend.get_offset(0),
+      dev->frontend.get_offset(1),
+      dev->frontend.get_offset(2));
+  DBGCOMPLETED;
+
+  return status;
+}
+
+/* Averages image data.
+   average_data and calibration_data are little endian 16 bit words.
+ */
+static void
+genesys_average_data (uint8_t * average_data,
+		      uint8_t * calibration_data,
+                      uint32_t lines,
+		      uint32_t pixel_components_per_line)
+{
+  uint32_t x, y;
+  uint32_t sum;
+
+  for (x = 0; x < pixel_components_per_line; x++)
+    {
+      sum = 0;
+      for (y = 0; y < lines; y++)
+	{
+	  sum += calibration_data[(x + y * pixel_components_per_line) * 2];
+	  sum +=
+	    calibration_data[(x + y * pixel_components_per_line) * 2 +
+			     1] * 256;
+	}
+      sum /= lines;
+      *average_data++ = sum & 255;
+      *average_data++ = sum / 256;
+    }
+}
+
+/**
+ * scans a white area with motor and lamp off to get the per CCD pixel offset
+ * that will be used to compute shading coefficient
+ * @param dev scanner's device
+ * @return SANE_STATUS_GOOD if OK, else an error
+ */
+static SANE_Status
+genesys_dark_shading_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  size_t size;
+  uint32_t pixels_per_line;
+  uint8_t channels;
+  SANE_Bool motor;
+
+  DBGSTART;
+
+  /* end pixel - start pixel */
+  pixels_per_line = dev->calib_pixels;
+  channels = dev->calib_channels;
+
+  uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset;
+  dev->average_size = channels * 2 * out_pixels_per_line;
+
+  dev->dark_average_data.clear();
+  dev->dark_average_data.resize(dev->average_size);
+
+    // FIXME: the current calculation is likely incorrect on non-GENESYS_GL843 implementations,
+    // but this needs checking
+    if (dev->calib_total_bytes_to_read > 0) {
+        size = dev->calib_total_bytes_to_read;
+    } else if (dev->model->asic_type == GENESYS_GL843) {
+        size = channels * 2 * pixels_per_line * dev->calib_lines;
+    } else {
+        size = channels * 2 * pixels_per_line * (dev->calib_lines + 1);
+    }
+
+  std::vector<uint8_t> calibration_data(size);
+
+  motor=SANE_TRUE;
+  if (dev->model->flags & GENESYS_FLAG_SHADING_NO_MOVE)
+    {
+      motor=SANE_FALSE;
+    }
+
+  /* turn off motor and lamp power for flatbed scanners, but not for sheetfed scanners
+   * because they have a calibration sheet with a sufficient black strip                */
+  if (dev->model->is_sheetfed == SANE_FALSE)
+    {
+        sanei_genesys_set_lamp_power(dev, sensor, dev->calib_reg, false);
+        sanei_genesys_set_motor_power(dev->calib_reg, motor);
+    }
+  else
+    {
+        sanei_genesys_set_lamp_power(dev, sensor, dev->calib_reg, true);
+        sanei_genesys_set_motor_power(dev->calib_reg, motor);
+    }
+
+  status =
+    dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  // wait some time to let lamp to get dark
+  sanei_genesys_sleep_ms(200);
+
+  status = dev->model->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, SANE_FALSE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: Failed to begin scan: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  status = sanei_genesys_read_data_from_scanner (dev, calibration_data.data(), size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to read data: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  status = dev->model->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  std::fill(dev->dark_average_data.begin(),
+            dev->dark_average_data.begin() + dev->calib_pixels_offset * channels,
+            0x00);
+
+  genesys_average_data(dev->dark_average_data.data() + dev->calib_pixels_offset * channels,
+                       calibration_data.data(),
+                       dev->calib_lines, pixels_per_line * channels);
+
+  if (DBG_LEVEL >= DBG_data)
+    {
+      sanei_genesys_write_pnm_file("gl_black_shading.pnm", calibration_data.data(), 16,
+                                   channels, pixels_per_line, dev->calib_lines);
+      sanei_genesys_write_pnm_file("gl_black_average.pnm", dev->dark_average_data.data(), 16,
+                                   channels, out_pixels_per_line, 1);
+    }
+
+  DBGCOMPLETED;
+
+  return SANE_STATUS_GOOD;
+}
+
+/*
+ * this function builds dummy dark calibration data so that we can
+ * compute shading coefficient in a clean way
+ *  todo: current values are hardcoded, we have to find if they
+ * can be computed from previous calibration data (when doing offset
+ * calibration ?)
+ */
+static SANE_Status
+genesys_dummy_dark_shading (Genesys_Device * dev, const Genesys_Sensor& sensor)
+{
+  uint32_t pixels_per_line;
+  uint8_t channels;
+  uint32_t x, skip, xend;
+  int dummy1, dummy2, dummy3;	/* dummy black average per channel */
+
+  DBGSTART;
+
+  pixels_per_line = dev->calib_pixels;
+  channels = dev->calib_channels;
+
+  uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset;
+
+  dev->average_size = channels * 2 * out_pixels_per_line;
+  dev->dark_average_data.clear();
+  dev->dark_average_data.resize(dev->average_size, 0);
+
+  /* we average values on 'the left' where CCD pixels are under casing and
+     give darkest values. We then use these as dummy dark calibration */
+  if (dev->settings.xres <= sensor.optical_res / 2)
+    {
+      skip = 4;
+      xend = 36;
+    }
+  else
+    {
+      skip = 4;
+      xend = 68;
+    }
+  if (dev->model->ccd_type==CCD_G4050
+   || dev->model->ccd_type==CCD_CS4400F
+   || dev->model->ccd_type==CCD_CS8400F
+   || dev->model->ccd_type==CCD_KVSS080)
+    {
+      skip = 2;
+      xend = sensor.black_pixels;
+    }
+
+  /* average each channels on half left margin */
+  dummy1 = 0;
+  dummy2 = 0;
+  dummy3 = 0;
+
+  for (x = skip + 1; x <= xend; x++)
+    {
+      dummy1 +=
+	dev->white_average_data[channels * 2 * x] +
+	256 * dev->white_average_data[channels * 2 * x + 1];
+      if (channels > 1)
+	{
+	  dummy2 +=
+	    (dev->white_average_data[channels * 2 * x + 2] +
+	     256 * dev->white_average_data[channels * 2 * x + 3]);
+	  dummy3 +=
+	    (dev->white_average_data[channels * 2 * x + 4] +
+	     256 * dev->white_average_data[channels * 2 * x + 5]);
+	}
+    }
+
+  dummy1 /= (xend - skip);
+  if (channels > 1)
+    {
+      dummy2 /= (xend - skip);
+      dummy3 /= (xend - skip);
+    }
+  DBG(DBG_proc, "%s: dummy1=%d, dummy2=%d, dummy3=%d \n", __func__, dummy1, dummy2, dummy3);
+
+  /* fill dark_average */
+  for (x = 0; x < out_pixels_per_line; x++)
+    {
+      dev->dark_average_data[channels * 2 * x] = dummy1 & 0xff;
+      dev->dark_average_data[channels * 2 * x + 1] = dummy1 >> 8;
+      if (channels > 1)
+	{
+	  dev->dark_average_data[channels * 2 * x + 2] = dummy2 & 0xff;
+	  dev->dark_average_data[channels * 2 * x + 3] = dummy2 >> 8;
+	  dev->dark_average_data[channels * 2 * x + 4] = dummy3 & 0xff;
+	  dev->dark_average_data[channels * 2 * x + 5] = dummy3 >> 8;
+	}
+    }
+
+  DBGCOMPLETED;
+  return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+genesys_white_shading_calibration (Genesys_Device * dev, const Genesys_Sensor& sensor)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  size_t size;
+  uint32_t pixels_per_line;
+  uint8_t channels;
+  SANE_Bool motor;
+
+  DBG(DBG_proc, "%s (lines = %d)\n", __func__, (unsigned int)dev->calib_lines);
+
+  pixels_per_line = dev->calib_pixels;
+  channels = dev->calib_channels;
+
+  uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset;
+
+  dev->white_average_data.clear();
+  dev->white_average_data.resize(channels * 2 * out_pixels_per_line);
+
+    // FIXME: the current calculation is likely incorrect on non-GENESYS_GL843 implementations,
+    // but this needs checking
+    if (dev->calib_total_bytes_to_read > 0) {
+        size = dev->calib_total_bytes_to_read;
+    } else if (dev->model->asic_type == GENESYS_GL843) {
+        size = channels * 2 * pixels_per_line * dev->calib_lines;
+    } else {
+        size = channels * 2 * pixels_per_line * (dev->calib_lines + 1);
+    }
+
+  std::vector<uint8_t> calibration_data(size);
+
+  motor=SANE_TRUE;
+  if (dev->model->flags & GENESYS_FLAG_SHADING_NO_MOVE)
+    {
+      motor=SANE_FALSE;
+    }
+
+    // turn on motor and lamp power
+    sanei_genesys_set_lamp_power(dev, sensor, dev->calib_reg, true);
+    sanei_genesys_set_motor_power(dev->calib_reg, motor);
+
+  /* if needed, go back before doing next scan */
+  if (dev->model->flags & GENESYS_FLAG_SHADING_REPARK)
+    {
+      /* rewind keeps registers and slopes table intact from previous
+         scan but is not available on all supported chipsets (or may
+         cause scan artifacts, see #7) */
+      status = (dev->model->cmd_set->rewind
+                ? dev->model->cmd_set->rewind (dev)
+                : dev->model->cmd_set->slow_back_home (dev, SANE_TRUE));
+      if (dev->settings.scan_method == ScanMethod::TRANSPARENCY)
+        {
+          dev->model->cmd_set->move_to_ta(dev);
+        }
+    }
+
+  status =
+    dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)
+    sanei_genesys_sleep_ms(500); // make sure lamp is bright again
+
+  status = dev->model->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, SANE_TRUE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: Failed to begin scan: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  status = sanei_genesys_read_data_from_scanner (dev, calibration_data.data(), size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to read data: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  status = dev->model->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  if (DBG_LEVEL >= DBG_data)
+    sanei_genesys_write_pnm_file("gl_white_shading.pnm", calibration_data.data(), 16,
+                                 channels, pixels_per_line, dev->calib_lines);
+
+  std::fill(dev->dark_average_data.begin(),
+            dev->dark_average_data.begin() + dev->calib_pixels_offset * channels,
+            0x00);
+
+  genesys_average_data (dev->white_average_data.data() + dev->calib_pixels_offset * channels,
+                        calibration_data.data(), dev->calib_lines,
+			pixels_per_line * channels);
+
+  if (DBG_LEVEL >= DBG_data)
+    sanei_genesys_write_pnm_file("gl_white_average.pnm", dev->white_average_data.data(), 16,
+                                 channels, out_pixels_per_line, 1);
+
+  /* in case we haven't done dark calibration, build dummy data from white_average */
+  if (!(dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION))
+    {
+      status = genesys_dummy_dark_shading(dev, sensor);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: failed to do dummy dark shading calibration: %s\n", __func__,
+              sane_strstatus(status));
+	  return status;
+	}
+    }
+
+  if (dev->model->flags & GENESYS_FLAG_SHADING_REPARK)
+    {
+	  status = dev->model->cmd_set->slow_back_home (dev, SANE_TRUE);
+    }
+
+  DBGCOMPLETED;
+
+  return status;
+}
+
+/* This calibration uses a scan over the calibration target, comprising a
+ * black and a white strip. (So the motor must be on.)
+ */
+static SANE_Status
+genesys_dark_white_shading_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  size_t size;
+  uint32_t pixels_per_line;
+  uint8_t *average_white, *average_dark;
+  uint8_t channels;
+  unsigned int x;
+  int y;
+  uint32_t dark, white, dark_sum, white_sum, dark_count, white_count, col,
+    dif;
+  SANE_Bool motor;
+
+
+  DBG(DBG_proc, "%s: (lines = %d)\n", __func__, (unsigned int)dev->calib_lines);
+
+  pixels_per_line = dev->calib_pixels;
+  channels = dev->calib_channels;
+
+  uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset;
+
+  dev->average_size = channels * 2 * out_pixels_per_line;
+
+  dev->white_average_data.clear();
+  dev->white_average_data.resize(dev->average_size);
+
+  dev->dark_average_data.clear();
+  dev->dark_average_data.resize(dev->average_size);
+
+  if (dev->calib_total_bytes_to_read > 0)
+    size = dev->calib_total_bytes_to_read;
+  else
+    size = channels * 2 * pixels_per_line * dev->calib_lines;
+
+  std::vector<uint8_t> calibration_data(size);
+
+  motor=SANE_TRUE;
+  if (dev->model->flags & GENESYS_FLAG_SHADING_NO_MOVE)
+    {
+      motor=SANE_FALSE;
+    }
+
+    // turn on motor and lamp power
+    sanei_genesys_set_lamp_power(dev, sensor, dev->calib_reg, true);
+    sanei_genesys_set_motor_power(dev->calib_reg, motor);
+
+  status =
+    dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  status = dev->model->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, SANE_FALSE);
+
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  status = sanei_genesys_read_data_from_scanner (dev, calibration_data.data(), size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to read data: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  status = dev->model->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: Failed to end scan: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  if (DBG_LEVEL >= DBG_data)
+    {
+      if (dev->model->is_cis)
+        {
+          sanei_genesys_write_pnm_file("gl_black_white_shading.pnm", calibration_data.data(),
+                                       16, 1, pixels_per_line*channels,
+                                       dev->calib_lines);
+        }
+      else
+        {
+          sanei_genesys_write_pnm_file("gl_black_white_shading.pnm", calibration_data.data(),
+                                       16, channels, pixels_per_line,
+                                       dev->calib_lines);
+        }
+    }
+
+
+  std::fill(dev->dark_average_data.begin(),
+            dev->dark_average_data.begin() + dev->calib_pixels_offset * channels,
+            0x00);
+  std::fill(dev->white_average_data.begin(),
+            dev->white_average_data.begin() + dev->calib_pixels_offset * channels,
+            0x00);
+
+  average_white = dev->white_average_data.data() + dev->calib_pixels_offset * channels;
+  average_dark = dev->dark_average_data.data() + dev->calib_pixels_offset * channels;
+
+  for (x = 0; x < pixels_per_line * channels; x++)
+    {
+      dark = 0xffff;
+      white = 0;
+
+      for (y = 0; y < (int)dev->calib_lines; y++)
+	{
+	  col = calibration_data[(x + y * pixels_per_line * channels) * 2];
+	  col |=
+	    calibration_data[(x + y * pixels_per_line * channels) * 2 +
+			     1] << 8;
+
+	  if (col > white)
+	    white = col;
+	  if (col < dark)
+	    dark = col;
+	}
+
+      dif = white - dark;
+
+      dark = dark + dif / 8;
+      white = white - dif / 8;
+
+      dark_count = 0;
+      dark_sum = 0;
+
+      white_count = 0;
+      white_sum = 0;
+
+      for (y = 0; y < (int)dev->calib_lines; y++)
+	{
+	  col = calibration_data[(x + y * pixels_per_line * channels) * 2];
+	  col |=
+	    calibration_data[(x + y * pixels_per_line * channels) * 2 +
+			     1] << 8;
+
+	  if (col >= white)
+	    {
+	      white_sum += col;
+	      white_count++;
+	    }
+	  if (col <= dark)
+	    {
+	      dark_sum += col;
+	      dark_count++;
+	    }
+
+	}
+
+      dark_sum /= dark_count;
+      white_sum /= white_count;
+
+      *average_dark++ = dark_sum & 255;
+      *average_dark++ = dark_sum >> 8;
+
+      *average_white++ = white_sum & 255;
+      *average_white++ = white_sum >> 8;
+    }
+
+  if (DBG_LEVEL >= DBG_data)
+    {
+      sanei_genesys_write_pnm_file("gl_white_average.pnm",
+                                   dev->white_average_data.data(), 16, channels,
+                                   out_pixels_per_line, 1);
+      sanei_genesys_write_pnm_file("gl_dark_average.pnm",
+                                   dev->dark_average_data.data(), 16, channels,
+                                   out_pixels_per_line, 1);
+    }
+
+  DBGCOMPLETED;
+
+  return SANE_STATUS_GOOD;
+}
+
+/* computes one coefficient given bright-dark value
+ * @param coeff factor giving 1.00 gain
+ * @param target desired target code
+ * @param value brght-dark value
+ * */
+static unsigned int
+compute_coefficient (unsigned int coeff, unsigned int target, unsigned int value)
+{
+  int result;
+
+  if (value > 0)
+    {
+      result = (coeff * target) / value;
+      if (result >= 65535)
+	{
+	  result = 65535;
+	}
+    }
+  else
+    {
+      result = coeff;
+    }
+  return result;
+}
+
+/** @brief compute shading coefficients for LiDE scanners
+ * The dark/white shading is actually performed _after_ reducing
+ * resolution via averaging. only dark/white shading data for what would be
+ * first pixel at full resolution is used.
+ *
+ * scanner raw input to output value calculation:
+ *   o=(i-off)*(gain/coeff)
+ *
+ * from datasheet:
+ *   off=dark_average
+ *   gain=coeff*bright_target/(bright_average-dark_average)
+ * works for dark_target==0
+ *
+ * what we want is these:
+ *   bright_target=(bright_average-off)*(gain/coeff)
+ *   dark_target=(dark_average-off)*(gain/coeff)
+ * leading to
+ *  off = (dark_average*bright_target - bright_average*dark_target)/(bright_target - dark_target)
+ *  gain = (bright_target - dark_target)/(bright_average - dark_average)*coeff
+ *
+ * @param dev scanner's device
+ * @param shading_data memory area where to store the computed shading coefficients
+ * @param pixels_per_line number of pixels per line
+ * @param words_per_color memory words per color channel
+ * @param channels number of color channels (actually 1 or 3)
+ * @param o shading coefficients left offset
+ * @param coeff 4000h or 2000h depending on fast scan mode or not (GAIN4 bit)
+ * @param target_bright value of the white target code
+ * @param target_dark value of the black target code
+*/
+static void
+compute_averaged_planar (Genesys_Device * dev, const Genesys_Sensor& sensor,
+			 uint8_t * shading_data,
+			 unsigned int pixels_per_line,
+			 unsigned int words_per_color,
+			 unsigned int channels,
+			 unsigned int o,
+			 unsigned int coeff,
+			 unsigned int target_bright,
+			 unsigned int target_dark)
+{
+  unsigned int x, i, j, br, dk, res, avgpixels, basepixels, val;
+  unsigned int fill,factor;
+
+  DBG(DBG_info, "%s: pixels=%d, offset=%d\n", __func__, pixels_per_line, o);
+
+  /* initialize result */
+  memset (shading_data, 0xff, words_per_color * 3 * 2);
+
+  /*
+     strangely i can write 0x20000 bytes beginning at 0x00000 without overwriting
+     slope tables - which begin at address 0x10000(for 1200dpi hw mode):
+     memory is organized in words(2 bytes) instead of single bytes. explains
+     quite some things
+   */
+/*
+  another one: the dark/white shading is actually performed _after_ reducing
+  resolution via averaging. only dark/white shading data for what would be
+  first pixel at full resolution is used.
+ */
+/*
+  scanner raw input to output value calculation:
+    o=(i-off)*(gain/coeff)
+
+  from datasheet:
+    off=dark_average
+    gain=coeff*bright_target/(bright_average-dark_average)
+  works for dark_target==0
+
+  what we want is these:
+    bright_target=(bright_average-off)*(gain/coeff)
+    dark_target=(dark_average-off)*(gain/coeff)
+  leading to
+    off = (dark_average*bright_target - bright_average*dark_target)/(bright_target - dark_target)
+    gain = (bright_target - dark_target)/(bright_average - dark_average)*coeff
+ */
+  res = dev->settings.xres;
+
+    if (sensor.get_ccd_size_divisor_for_dpi(dev->settings.xres) > 1)
+    {
+        res *= 2;
+    }
+
+  /* this should be evenly dividable */
+  basepixels = sensor.optical_res / res;
+
+  /* gl841 supports 1/1 1/2 1/3 1/4 1/5 1/6 1/8 1/10 1/12 1/15 averaging */
+  if (basepixels < 1)
+    avgpixels = 1;
+  else if (basepixels < 6)
+    avgpixels = basepixels;
+  else if (basepixels < 8)
+    avgpixels = 6;
+  else if (basepixels < 10)
+    avgpixels = 8;
+  else if (basepixels < 12)
+    avgpixels = 10;
+  else if (basepixels < 15)
+    avgpixels = 12;
+  else
+    avgpixels = 15;
+
+  /* LiDE80 packs shading data */
+  if(dev->model->ccd_type != CIS_CANONLIDE80)
+    {
+      factor=1;
+      fill=avgpixels;
+    }
+  else
+    {
+      factor=avgpixels;
+      fill=1;
+    }
+
+  DBG(DBG_info, "%s: averaging over %d pixels\n", __func__, avgpixels);
+  DBG(DBG_info, "%s: packing factor is %d\n", __func__, factor);
+  DBG(DBG_info, "%s: fill length is %d\n", __func__, fill);
+
+  for (x = 0; x <= pixels_per_line - avgpixels; x += avgpixels)
+    {
+      if ((x + o) * 2 * 2 + 3 > words_per_color * 2)
+	break;
+
+      for (j = 0; j < channels; j++)
+	{
+
+	  dk = 0;
+	  br = 0;
+	  for (i = 0; i < avgpixels; i++)
+	    {
+	      /* dark data */
+	      dk +=
+		(dev->dark_average_data[(x + i +
+					 pixels_per_line * j) *
+					2] |
+		 (dev->dark_average_data
+		  [(x + i + pixels_per_line * j) * 2 + 1] << 8));
+
+	      /* white data */
+	      br +=
+		(dev->white_average_data[(x + i +
+					  pixels_per_line * j) *
+					 2] |
+		 (dev->white_average_data
+		  [(x + i + pixels_per_line * j) * 2 + 1] << 8));
+	    }
+
+	  br /= avgpixels;
+	  dk /= avgpixels;
+
+	  if (br * target_dark > dk * target_bright)
+	    val = 0;
+	  else if (dk * target_bright - br * target_dark >
+		   65535 * (target_bright - target_dark))
+	    val = 65535;
+	  else
+            {
+	      val = (dk * target_bright - br * target_dark) / (target_bright - target_dark);
+            }
+
+          /*fill all pixels, even if only the last one is relevant*/
+	  for (i = 0; i < fill; i++)
+	    {
+	      shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j] = val & 0xff;
+	      shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 1] = val >> 8;
+	    }
+
+	  val = br - dk;
+
+	  if (65535 * val > (target_bright - target_dark) * coeff)
+            {
+	      val = (coeff * (target_bright - target_dark)) / val;
+            }
+	  else
+            {
+	      val = 65535;
+            }
+
+          /*fill all pixels, even if only the last one is relevant*/
+	  for (i = 0; i < fill; i++)
+	    {
+	      shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 2] = val & 0xff;
+	      shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 3] = val >> 8;
+	    }
+	}
+
+      /* fill remaining channels */
+      for (j = channels; j < 3; j++)
+	{
+	  for (i = 0; i < fill; i++)
+	    {
+	      shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j    ] = shading_data[(x/factor + o + i) * 2 * 2    ];
+	      shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 1] = shading_data[(x/factor + o + i) * 2 * 2 + 1];
+	      shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 2] = shading_data[(x/factor + o + i) * 2 * 2 + 2];
+	      shading_data[(x/factor + o + i) * 2 * 2 + words_per_color * 2 * j + 3] = shading_data[(x/factor + o + i) * 2 * 2 + 3];
+	    }
+	}
+    }
+}
+
+/**
+ * Computes shading coefficient using formula in data sheet. 16bit data values
+ * manipulated here are little endian. For now we assume deletion scanning type
+ * and that there is always 3 channels.
+ * @param dev scanner's device
+ * @param shading_data memory area where to store the computed shading coefficients
+ * @param pixels_per_line number of pixels per line
+ * @param channels number of color channels (actually 1 or 3)
+ * @param cmat color transposition matrix
+ * @param offset shading coefficients left offset
+ * @param coeff 4000h or 2000h depending on fast scan mode or not
+ * @param target value of the target code
+ */
+static void
+compute_coefficients (Genesys_Device * dev,
+		      uint8_t * shading_data,
+		      unsigned int pixels_per_line,
+		      unsigned int channels,
+		      unsigned int cmat[3],
+		      int offset,
+		      unsigned int coeff,
+		      unsigned int target)
+{
+  uint8_t *ptr;			/* contain 16bit words in little endian */
+  unsigned int x, c;
+  unsigned int val, br, dk;
+  unsigned int start, end;
+
+  DBG(DBG_io, "%s: pixels_per_line=%d,  coeff=0x%04x\n", __func__, pixels_per_line, coeff);
+
+  /* compute start & end values depending of the offset */
+  if (offset < 0)
+   {
+      start = -1 * offset;
+      end = pixels_per_line;
+   }
+  else
+   {
+     start = 0;
+     end = pixels_per_line - offset;
+   }
+
+  for (c = 0; c < channels; c++)
+    {
+      for (x = start; x < end; x++)
+	{
+	  /* TODO if channels=1 , use filter to know the base addr */
+	  ptr = shading_data + 4 * ((x + offset) * channels + cmat[c]);
+
+	  /* dark data */
+	  dk = dev->dark_average_data[x * 2 * channels + c * 2];
+	  dk += 256 * dev->dark_average_data[x * 2 * channels + c * 2 + 1];
+
+	  /* white data */
+	  br = dev->white_average_data[x * 2 * channels + c * 2];
+	  br += 256 * dev->white_average_data[x * 2 * channels + c * 2 + 1];
+
+	  /* compute coeff */
+	  val=compute_coefficient(coeff,target,br-dk);
+
+	  /* assign it */
+	  ptr[0] = dk & 255;
+	  ptr[1] = dk / 256;
+	  ptr[2] = val & 0xff;
+	  ptr[3] = val / 256;
+
+	}
+    }
+}
+
+/**
+ * Computes shading coefficient using formula in data sheet. 16bit data values
+ * manipulated here are little endian. Data is in planar form, ie grouped by
+ * lines of the same color component.
+ * @param dev scanner's device
+ * @param shading_data memory area where to store the computed shading coefficients
+ * @param factor averaging factor when the calibration scan is done at a higher resolution
+ * than the final scan
+ * @param pixels_per_line number of pixels per line
+ * @param words_per_color total number of shading data words for one color element
+ * @param channels number of color channels (actually 1 or 3)
+ * @param cmat transcoding matrix for color channel order
+ * @param offset shading coefficients left offset
+ * @param coeff 4000h or 2000h depending on fast scan mode or not
+ * @param target white target value
+ */
+static void
+compute_planar_coefficients (Genesys_Device * dev,
+			     uint8_t * shading_data,
+			     unsigned int factor,
+			     unsigned int pixels_per_line,
+			     unsigned int words_per_color,
+			     unsigned int channels,
+			     unsigned int cmat[3],
+			     unsigned int offset,
+			     unsigned int coeff,
+			     unsigned int target)
+{
+  uint8_t *ptr;			/* contains 16bit words in little endian */
+  uint32_t x, c, i;
+  uint32_t val, dk, br;
+
+  DBG(DBG_io, "%s: factor=%d, pixels_per_line=%d, words=0x%X, coeff=0x%04x\n", __func__, factor,
+      pixels_per_line, words_per_color, coeff);
+  for (c = 0; c < channels; c++)
+    {
+      /* shading data is larger than pixels_per_line so offset can be neglected */
+      for (x = 0; x < pixels_per_line; x+=factor)
+	{
+	  /* x2 because of 16 bit values, and x2 since one coeff for dark
+	   * and another for white */
+	  ptr = shading_data + words_per_color * cmat[c] * 2 + (x + offset) * 4;
+
+	  dk = 0;
+	  br = 0;
+
+	  /* average case */
+	  for(i=0;i<factor;i++)
+	  {
+	  dk +=
+	    256 * dev->dark_average_data[((x+i) + pixels_per_line * c) * 2 + 1];
+	  dk += dev->dark_average_data[((x+i) + pixels_per_line * c) * 2];
+	  br +=
+	    256 * dev->white_average_data[((x+i) + pixels_per_line * c) * 2 + 1];
+	  br += dev->white_average_data[((x+i) + pixels_per_line * c) * 2];
+	  }
+	  dk /= factor;
+	  br /= factor;
+
+	  val = compute_coefficient (coeff, target, br - dk);
+
+	  /* we duplicate the information to have calibration data at optical resolution */
+	  for (i = 0; i < factor; i++)
+	    {
+	      ptr[0 + 4 * i] = dk & 255;
+	      ptr[1 + 4 * i] = dk / 256;
+	      ptr[2 + 4 * i] = val & 0xff;
+	      ptr[3 + 4 * i] = val / 256;
+	    }
+	}
+    }
+  /* in case of gray level scan, we duplicate shading information on all
+   * three color channels */
+  if(channels==1)
+  {
+	  memcpy(shading_data+cmat[1]*2*words_per_color,
+	         shading_data+cmat[0]*2*words_per_color,
+		 words_per_color*2);
+	  memcpy(shading_data+cmat[2]*2*words_per_color,
+	         shading_data+cmat[0]*2*words_per_color,
+		 words_per_color*2);
+  }
+}
+
+static void
+compute_shifted_coefficients (Genesys_Device * dev,
+                              const Genesys_Sensor& sensor,
+			      uint8_t * shading_data,
+			      unsigned int pixels_per_line,
+			      unsigned int channels,
+			      unsigned int cmat[3],
+			      int offset,
+			      unsigned int coeff,
+			      unsigned int target_dark,
+			      unsigned int target_bright,
+			      unsigned int patch_size)		/* contigous extent */
+{
+  unsigned int x, avgpixels, basepixels, i, j, val1, val2;
+  unsigned int br_tmp [3], dk_tmp [3];
+  uint8_t *ptr = shading_data + offset * 3 * 4;                 /* contain 16bit words in little endian */
+  unsigned int patch_cnt = offset * 3;                          /* at start, offset of first patch */
+
+  x = dev->settings.xres;
+  if (sensor.get_ccd_size_divisor_for_dpi(dev->settings.xres) > 1)
+    x *= 2;							/* scanner is using half-ccd mode */
+  basepixels = sensor.optical_res / x;			/*this should be evenly dividable */
+
+      /* gl841 supports 1/1 1/2 1/3 1/4 1/5 1/6 1/8 1/10 1/12 1/15 averaging */
+      if (basepixels < 1)
+        avgpixels = 1;
+      else if (basepixels < 6)
+        avgpixels = basepixels;
+      else if (basepixels < 8)
+        avgpixels = 6;
+      else if (basepixels < 10)
+        avgpixels = 8;
+      else if (basepixels < 12)
+        avgpixels = 10;
+      else if (basepixels < 15)
+        avgpixels = 12;
+      else
+        avgpixels = 15;
+  DBG(DBG_info, "%s: pixels_per_line=%d,  coeff=0x%04x,  averaging over %d pixels\n", __func__,
+      pixels_per_line, coeff, avgpixels);
+
+  for (x = 0; x <= pixels_per_line - avgpixels; x += avgpixels) {
+    memset (&br_tmp, 0, sizeof(br_tmp));
+    memset (&dk_tmp, 0, sizeof(dk_tmp));
+
+    for (i = 0; i < avgpixels; i++) {
+      for (j = 0; j < channels; j++) {
+        br_tmp[j]  += (dev->white_average_data[((x + i) * channels + j) * 2] |
+                      (dev->white_average_data[((x + i) * channels + j) * 2 + 1] << 8));
+        dk_tmp[i] += (dev->dark_average_data[((x + i) * channels + j) * 2] |
+                     (dev->dark_average_data[((x + i) * channels + j) * 2 + 1] << 8));
+      }
+    }
+    for (j = 0; j < channels; j++) {
+      br_tmp[j] /= avgpixels;
+      dk_tmp[j] /= avgpixels;
+
+      if (br_tmp[j] * target_dark > dk_tmp[j] * target_bright)
+        val1 = 0;
+      else if (dk_tmp[j] * target_bright - br_tmp[j] * target_dark > 65535 * (target_bright - target_dark))
+        val1 = 65535;
+      else
+        val1 = (dk_tmp[j] * target_bright - br_tmp[j] * target_dark) / (target_bright - target_dark);
+
+      val2 = br_tmp[j] - dk_tmp[j];
+      if (65535 * val2 > (target_bright - target_dark) * coeff)
+        val2 = (coeff * (target_bright - target_dark)) / val2;
+      else
+        val2 = 65535;
+
+      br_tmp[j] = val1;
+      dk_tmp[j] = val2;
+    }
+    for (i = 0; i < avgpixels; i++) {
+      for (j = 0; j < channels; j++) {
+        * ptr++ = br_tmp[ cmat[j] ] & 0xff;
+        * ptr++ = br_tmp[ cmat[j] ] >> 8;
+        * ptr++ = dk_tmp[ cmat[j] ] & 0xff;
+        * ptr++ = dk_tmp[ cmat[j] ] >> 8;
+        patch_cnt++;
+        if (patch_cnt == patch_size) {
+          patch_cnt = 0;
+          val1 = cmat[2];
+          cmat[2] = cmat[1];
+          cmat[1] = cmat[0];
+          cmat[0] = val1;
+        }
+      }
+    }
+  }
+}
+
+static SANE_Status
+genesys_send_shading_coefficient(Genesys_Device * dev, const Genesys_Sensor& sensor)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  uint32_t pixels_per_line;
+  uint8_t channels;
+  int o;
+  unsigned int length;		/**> number of shading calibration data words */
+  unsigned int factor;
+  unsigned int cmat[3];		/**> matrix of color channels */
+  unsigned int coeff, target_code, words_per_color = 0;
+
+  DBGSTART;
+
+  pixels_per_line = dev->calib_pixels + dev->calib_pixels_offset;
+  channels = dev->calib_channels;
+
+  /* we always build data for three channels, even for gray
+   * we make the shading data such that each color channel data line is contiguous
+   * to the next one, which allow to write the 3 channels in 1 write
+   * during genesys_send_shading_coefficient, some values are words, other bytes
+   * hence the x2 factor */
+  switch (dev->reg.get8(0x05) >> 6)
+    {
+      /* 600 dpi */
+    case 0:
+      words_per_color = 0x2a00;
+      break;
+      /* 1200 dpi */
+    case 1:
+      words_per_color = 0x5500;
+      break;
+      /* 2400 dpi */
+    case 2:
+      words_per_color = 0xa800;
+      break;
+      /* 4800 dpi */
+    case 3:
+      words_per_color = 0x15000;
+      break;
+    }
+
+  /* special case, memory is aligned on 0x5400, this has yet to be explained */
+  /* could be 0xa800 because sensor is truly 2400 dpi, then halved because
+   * we only set 1200 dpi */
+  if(dev->model->ccd_type==CIS_CANONLIDE80)
+    {
+      words_per_color = 0x5400;
+    }
+
+  length = words_per_color * 3 * 2;
+
+  /* allocate computed size */
+  // contains 16bit words in little endian
+  std::vector<uint8_t> shading_data(length, 0);
+
+  /* TARGET/(Wn-Dn) = white gain -> ~1.xxx then it is multiplied by 0x2000
+     or 0x4000 to give an integer
+     Wn = white average for column n
+     Dn = dark average for column n
+   */
+  if (dev->model->cmd_set->get_gain4_bit(&dev->calib_reg))
+    coeff = 0x4000;
+  else
+    coeff = 0x2000;
+
+  /* compute avg factor */
+  if(dev->settings.xres>sensor.optical_res)
+    {
+      factor=1;
+    }
+  else
+    {
+      factor=sensor.optical_res/dev->settings.xres;
+    }
+
+  /* for GL646, shading data is planar if REG01_FASTMOD is set and
+   * chunky if not. For now we rely on the fact that we know that
+   * each sensor is used only in one mode. Currently only the CIS_XP200
+   * sets REG01_FASTMOD.
+   */
+
+  /* TODO setup a struct in genesys_devices that
+   * will handle these settings instead of having this switch growing up */
+  cmat[0] = 0;
+  cmat[1] = 1;
+  cmat[2] = 2;
+  switch (dev->model->ccd_type)
+    {
+    case CCD_XP300:
+    case CCD_ROADWARRIOR:
+    case CCD_DP665:
+    case CCD_DP685:
+    case CCD_DSMOBILE600:
+      target_code = 0xdc00;
+      o = 4;
+      compute_planar_coefficients (dev,
+                   shading_data.data(),
+				   factor,
+				   pixels_per_line,
+				   words_per_color,
+				   channels,
+				   cmat,
+				   o,
+				   coeff,
+				   target_code);
+      break;
+    case CIS_XP200:
+      target_code = 0xdc00;
+      o = 2;
+      cmat[0] = 2;		/* red is last    */
+      cmat[1] = 0;		/* green is first */
+      cmat[2] = 1;		/* blue is second */
+      compute_planar_coefficients (dev,
+                   shading_data.data(),
+				   1,
+				   pixels_per_line,
+				   words_per_color,
+				   channels,
+				   cmat,
+				   o,
+				   coeff,
+				   target_code);
+      break;
+    case CCD_HP2300:
+      target_code = 0xdc00;
+      o = 2;
+      if(dev->settings.xres<=sensor.optical_res/2)
+       {
+          o = o - sensor.dummy_pixel / 2;
+       }
+      compute_coefficients (dev,
+                shading_data.data(),
+			    pixels_per_line,
+			    3,
+                            cmat,
+                            o,
+                            coeff,
+                            target_code);
+      break;
+    case CCD_5345:
+      target_code = 0xe000;
+      o = 4;
+      if(dev->settings.xres<=sensor.optical_res/2)
+       {
+          o = o - sensor.dummy_pixel;
+       }
+      compute_coefficients (dev,
+                shading_data.data(),
+			    pixels_per_line,
+			    3,
+                            cmat,
+                            o,
+                            coeff,
+                            target_code);
+      break;
+    case CCD_HP3670:
+    case CCD_HP2400:
+      target_code = 0xe000;
+      /* offset is cksel dependent, but we can't use this in common code */
+      if(dev->settings.xres<=300)
+        {
+          o = -10; /* OK for <=300 */
+        }
+      else if(dev->settings.xres<=600)
+        {
+          o = -6;  /* ok at 600 */
+        }
+      else
+        {
+          o = +2;
+        }
+      compute_coefficients (dev,
+                shading_data.data(),
+			    pixels_per_line,
+			    3,
+                            cmat,
+                            o,
+                            coeff,
+                            target_code);
+      break;
+    case CCD_KVSS080:
+    case CCD_PLUSTEK3800:
+    case CCD_G4050:
+    case CCD_CS4400F:
+    case CCD_CS8400F:
+    case CCD_CS8600F:
+      target_code = 0xe000;
+      o = 0;
+      compute_coefficients (dev,
+                shading_data.data(),
+			    pixels_per_line,
+			    3,
+                            cmat,
+                            o,
+                            coeff,
+                            target_code);
+      break;
+    case CIS_CANONLIDE700:
+    case CIS_CANONLIDE100:
+    case CIS_CANONLIDE200:
+    case CIS_CANONLIDE110:
+    case CIS_CANONLIDE120:
+    case CIS_CANONLIDE210:
+    case CIS_CANONLIDE220:
+        /* TODO store this in a data struct so we avoid
+         * growing this switch */
+        switch(dev->model->ccd_type)
+          {
+          case CIS_CANONLIDE110:
+          case CIS_CANONLIDE120:
+          case CIS_CANONLIDE210:
+          case CIS_CANONLIDE220:
+            target_code = 0xf000;
+            break;
+          case CIS_CANONLIDE700:
+            target_code = 0xc000; /* from experimentation */
+            break;
+          default:
+            target_code = 0xdc00;
+          }
+        words_per_color=pixels_per_line*2;
+        length = words_per_color * 3 * 2;
+        shading_data.clear();
+        shading_data.resize(length, 0);
+        compute_planar_coefficients (dev,
+                                     shading_data.data(),
+                                     1,
+                                     pixels_per_line,
+                                     words_per_color,
+                                     channels,
+                                     cmat,
+                                     0,
+                                     coeff,
+                                     target_code);
+      break;
+    case CCD_CANONLIDE35:
+      compute_averaged_planar (dev, sensor,
+                               shading_data.data(),
+                               pixels_per_line,
+                               words_per_color,
+                               channels,
+                               4,
+                               coeff,
+                               0xe000,
+                               0x0a00);
+      break;
+    case CIS_CANONLIDE80:
+      compute_averaged_planar (dev, sensor,
+                               shading_data.data(),
+                               pixels_per_line,
+                               words_per_color,
+                               channels,
+                               0,
+                               coeff,
+			       0xe000,
+                               0x0800);
+      break;
+    case CCD_PLUSTEK_3600:
+      compute_shifted_coefficients (dev, sensor,
+                        shading_data.data(),
+			            pixels_per_line,
+			            channels,
+			            cmat,
+			            12,         /* offset */
+			            coeff,
+ 			            0x0001,      /* target_dark */
+			            0xf900,      /* target_bright */
+			            256);        /* patch_size: contigous extent */
+      break;
+    default:
+      DBG (DBG_error, "%s: sensor %d not supported\n", __func__, dev->model->ccd_type);
+      return SANE_STATUS_UNSUPPORTED;
+      break;
+    }
+
+  /* do the actual write of shading calibration data to the scanner */
+  status = genesys_send_offset_and_shading (dev, sensor, shading_data.data(), length);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (DBG_error, "%s: failed to send shading data: %s\n", __func__,
+	  sane_strstatus (status));
+    }
+
+  DBGCOMPLETED;
+  return SANE_STATUS_GOOD;
+}
+
+
+/**
+ * search calibration cache list for an entry matching required scan.
+ * If one is found, set device calibration with it
+ * @param dev scanner's device
+ * @return false if no matching cache entry has been
+ * found, true if one has been found and used.
+ */
+static bool
+genesys_restore_calibration(Genesys_Device * dev, Genesys_Sensor& sensor)
+{
+  DBGSTART;
+
+  /* if no cache or no function to evaluate cache entry ther can be no match */
+  if (!dev->model->cmd_set->is_compatible_calibration
+      || dev->calibration_cache.empty())
+    return false;
+
+  /* we walk the link list of calibration cache in search for a
+   * matching one */
+  for (auto& cache : dev->calibration_cache)
+    {
+      if (dev->model->cmd_set->is_compatible_calibration(dev, sensor, &cache, SANE_FALSE))
+	{
+          dev->frontend = cache.frontend;
+          /* we don't restore the gamma fields */
+          sensor.exposure = cache.sensor.exposure;
+
+          dev->average_size = cache.average_size;
+          dev->calib_pixels = cache.calib_pixels;
+          dev->calib_channels = cache.calib_channels;
+
+          dev->dark_average_data = cache.dark_average_data;
+          dev->white_average_data = cache.white_average_data;
+
+        if(dev->model->cmd_set->send_shading_data==NULL)
+          {
+            TIE(genesys_send_shading_coefficient(dev, sensor));
+          }
+
+          DBG(DBG_proc, "%s: restored\n", __func__);
+          return true;
+	}
+    }
+  DBG(DBG_proc, "%s: completed(nothing found)\n", __func__);
+  return false;
+}
+
+
+static SANE_Status
+genesys_save_calibration (Genesys_Device * dev, const Genesys_Sensor& sensor)
+{
+#ifdef HAVE_SYS_TIME_H
+  struct timeval time;
+#endif
+
+  DBGSTART;
+
+  if (!dev->model->cmd_set->is_compatible_calibration)
+    return SANE_STATUS_UNSUPPORTED;
+
+  auto found_cache_it = dev->calibration_cache.end();
+  for (auto cache_it = dev->calibration_cache.begin(); cache_it != dev->calibration_cache.end();
+       cache_it++)
+    {
+      if (dev->model->cmd_set->is_compatible_calibration(dev, sensor, &*cache_it, SANE_TRUE))
+        {
+          found_cache_it = cache_it;
+          break;
+        }
+    }
+
+  /* if we found on overridable cache, we reuse it */
+  if (found_cache_it == dev->calibration_cache.end())
+    {
+      /* create a new cache entry and insert it in the linked list */
+      dev->calibration_cache.push_back(Genesys_Calibration_Cache());
+      found_cache_it = std::prev(dev->calibration_cache.end());
+    }
+
+  found_cache_it->average_size = dev->average_size;
+
+  found_cache_it->dark_average_data = dev->dark_average_data;
+  found_cache_it->white_average_data = dev->white_average_data;
+
+  found_cache_it->used_setup = dev->current_setup;
+  found_cache_it->frontend = dev->frontend;
+  found_cache_it->sensor = sensor;
+
+  found_cache_it->calib_pixels = dev->calib_pixels;
+  found_cache_it->calib_channels = dev->calib_channels;
+
+#ifdef HAVE_SYS_TIME_H
+  gettimeofday(&time,NULL);
+  found_cache_it->last_calibration = time.tv_sec;
+#endif
+
+  DBGCOMPLETED;
+  return SANE_STATUS_GOOD;
+}
+
+/**
+ * does the calibration process for a flatbed scanner
+ * - offset calibration
+ * - gain calibration
+ * - shading calibration
+ * @param dev device to calibrate
+ * @return SANE_STATUS_GOOD if everything when all right, else the error code.
+ */
+static SANE_Status
+genesys_flatbed_calibration(Genesys_Device * dev, Genesys_Sensor& sensor)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  uint32_t pixels_per_line;
+  int yres;
+
+  DBG(DBG_info, "%s\n", __func__);
+
+  yres = sensor.optical_res;
+  if (dev->settings.yres <= sensor.optical_res / 2)
+    yres /= 2;
+
+  if (dev->model->model_id == MODEL_CANON_CANOSCAN_8600F)
+    yres = 1200;
+
+  /* do offset calibration if needed */
+  if (dev->model->flags & GENESYS_FLAG_OFFSET_CALIBRATION)
+    {
+      status = dev->model->cmd_set->offset_calibration(dev, sensor, dev->calib_reg);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: offset calibration failed: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+      /* since all the registers are set up correctly, just use them */
+      status = dev->model->cmd_set->coarse_gain_calibration(dev, sensor, dev->calib_reg, yres);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: coarse gain calibration: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+    }
+  else
+    /* since we have 2 gain calibration proc, skip second if first one was
+       used. */
+    {
+      status = dev->model->cmd_set->init_regs_for_coarse_calibration(dev, sensor, dev->calib_reg);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: failed to send calibration registers: %s\n", __func__,
+              sane_strstatus(status));
+	  return status;
+	}
+
+      status = genesys_coarse_calibration(dev, sensor);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: failed to do coarse gain calibration: %s\n", __func__,
+              sane_strstatus(status));
+	  return status;
+	}
+
+    }
+
+  if (dev->model->is_cis)
+    {
+      /* the afe now sends valid data for doing led calibration */
+      status = dev->model->cmd_set->led_calibration(dev, sensor, dev->calib_reg);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: led calibration failed: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+      /* calibrate afe again to match new exposure */
+      if (dev->model->flags & GENESYS_FLAG_OFFSET_CALIBRATION)
+	{
+          status = dev->model->cmd_set->offset_calibration(dev, sensor, dev->calib_reg);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+              DBG(DBG_error, "%s: offset calibration failed: %s\n", __func__, sane_strstatus(status));
+	      return status;
+	    }
+
+	  /* since all the registers are set up correctly, just use them */
+
+          status = dev->model->cmd_set->coarse_gain_calibration(dev, sensor, dev->calib_reg, yres);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+              DBG(DBG_error, "%s: coarse gain calibration: %s\n", __func__, sane_strstatus(status));
+	      return status;
+	    }
+	}
+      else
+	/* since we have 2 gain calibration proc, skip second if first one was
+	   used. */
+	{
+          status = dev->model->cmd_set->init_regs_for_coarse_calibration(dev, sensor,
+                                                                         dev->calib_reg);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to send calibration registers: %s\n", __func__,
+		  sane_strstatus(status));
+	      return status;
+	    }
+
+          status = genesys_coarse_calibration(dev, sensor);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+              DBG(DBG_error, "%s: failed to do static calibration: %s\n", __func__,
+                  sane_strstatus(status));
+	      return status;
+	    }
+	}
+    }
+
+  /* we always use sensor pixel number when the ASIC can't handle multi-segments sensor */
+  if (!(dev->model->flags & GENESYS_FLAG_SIS_SENSOR))
+    {
+      pixels_per_line = (SANE_UNFIX (dev->model->x_size) * dev->settings.xres) / MM_PER_INCH;
+    }
+  else
+    {
+      pixels_per_line = sensor.sensor_pixels;
+    }
+
+  /* send default shading data */
+  status = sanei_genesys_init_shading_data(dev, sensor, pixels_per_line);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to init shading process: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  if (dev->settings.scan_method == ScanMethod::TRANSPARENCY) {
+      RIE(dev->model->cmd_set->move_to_ta(dev));
+  }
+
+  /* shading calibration */
+  status = dev->model->cmd_set->init_regs_for_shading(dev, sensor, dev->calib_reg);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to send shading registers: %s\n", __func__,
+          sane_strstatus(status));
+      return status;
+    }
+
+  if (dev->model->flags & GENESYS_FLAG_DARK_WHITE_CALIBRATION)
+    {
+      status = genesys_dark_white_shading_calibration (dev, sensor);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: failed to do dark+white shading calibration: %s\n", __func__,
+              sane_strstatus(status));
+	  return status;
+	}
+    }
+  else
+    {
+      if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)
+	{
+          status = genesys_dark_shading_calibration(dev, sensor);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+              DBG(DBG_error, "%s: failed to do dark shading calibration: %s\n", __func__,
+                  sane_strstatus(status));
+              return status;
+	    }
+	}
+
+      status = genesys_white_shading_calibration (dev, sensor);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: failed to do white shading calibration: %s\n", __func__,
+              sane_strstatus(status));
+	  return status;
+	}
+    }
+
+  if(dev->model->cmd_set->send_shading_data==NULL)
+    {
+      status = genesys_send_shading_coefficient(dev, sensor);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: failed to send shading calibration coefficients: %s\n", __func__,
+              sane_strstatus(status));
+          return status;
+        }
+    }
+
+  DBG(DBG_info, "%s: completed\n", __func__);
+
+  return SANE_STATUS_GOOD;
+}
+
+/**
+ * Does the calibration process for a sheetfed scanner
+ * - offset calibration
+ * - gain calibration
+ * - shading calibration
+ * During calibration a predefined calibration sheet with specific black and white
+ * areas is used.
+ * @param dev device to calibrate
+ * @return SANE_STATUS_GOOD if everything when all right, else the error code.
+ */
+static SANE_Status genesys_sheetfed_calibration(Genesys_Device * dev, Genesys_Sensor& sensor)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  SANE_Bool forward = SANE_TRUE;
+  int xres;
+
+  DBGSTART;
+  if (dev->model->cmd_set->search_strip == NULL)
+    {
+      DBG(DBG_error, "%s: no strip searching function available\n", __func__);
+      return SANE_STATUS_UNSUPPORTED;
+    }
+
+  /* first step, load document */
+  status = dev->model->cmd_set->load_document (dev);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to load document: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+
+  DBG(DBG_info, "%s\n", __func__);
+
+  /* led, offset and gain calibration are influenced by scan
+   * settings. So we set it to sensor resolution */
+  xres = sensor.optical_res;
+  dev->settings.xres = sensor.optical_res;
+  /* XP200 needs to calibrate a full and half sensor's resolution */
+  if (dev->model->ccd_type == CIS_XP200
+   && dev->settings.xres <= sensor.optical_res / 2)
+    dev->settings.xres /= 2;
+
+  /* the afe needs to sends valid data even before calibration */
+
+  /* go to a white area */
+    try {
+        status = dev->model->cmd_set->search_strip(dev, sensor, forward, SANE_FALSE);
+        if (status != SANE_STATUS_GOOD) {
+            DBG(DBG_error, "%s: failed to find white strip: %s\n", __func__,
+                sane_strstatus(status));
+            dev->model->cmd_set->eject_document (dev);
+            return status;
+        }
+    } catch (...) {
+        dev->model->cmd_set->eject_document(dev);
+        throw;
+    }
+
+  if (dev->model->is_cis)
+    {
+      status = dev->model->cmd_set->led_calibration(dev, sensor, dev->calib_reg);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: led calibration failed: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+    }
+
+  /* calibrate afe */
+  if (dev->model->flags & GENESYS_FLAG_OFFSET_CALIBRATION)
+    {
+      status = dev->model->cmd_set->offset_calibration(dev, sensor, dev->calib_reg);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: offset calibration failed: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+
+      /* since all the registers are set up correctly, just use them */
+
+      status = dev->model->cmd_set->coarse_gain_calibration(dev, sensor, dev->calib_reg, xres);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: coarse gain calibration: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+    }
+  else
+    /* since we have 2 gain calibration proc, skip second if first one was
+       used. */
+    {
+      status = dev->model->cmd_set->init_regs_for_coarse_calibration(dev, sensor, dev->calib_reg);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: failed to send calibration registers: %s\n", __func__,
+              sane_strstatus(status));
+	  return status;
+	}
+
+      status = genesys_coarse_calibration(dev, sensor);
+      if (status != SANE_STATUS_GOOD)
+	{
+          DBG(DBG_error, "%s: failed to do static calibration: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+    }
+
+  /* search for a full width black strip and then do a 16 bit scan to
+   * gather black shading data */
+  if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)
+    {
+      /* seek black/white reverse/forward */
+        try {
+            status = dev->model->cmd_set->search_strip(dev, sensor, forward, SANE_TRUE);
+            if (status != SANE_STATUS_GOOD) {
+                DBG(DBG_error, "%s: failed to find black strip: %s\n", __func__,
+                    sane_strstatus(status));
+                dev->model->cmd_set->eject_document(dev);
+                return status;
+            }
+        } catch (...) {
+            dev->model->cmd_set->eject_document(dev);
+            throw;
+        }
+
+      status = dev->model->cmd_set->init_regs_for_shading(dev, sensor, dev->calib_reg);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG(DBG_error, "%s: failed to do set up registers for shading calibration: %s\n",
+	      __func__, sane_strstatus(status));
+	  return status;
+	}
+        try {
+            status = genesys_dark_shading_calibration(dev, sensor);
+            if (status != SANE_STATUS_GOOD) {
+                dev->model->cmd_set->eject_document(dev);
+                DBG(DBG_error, "%s: failed to do dark shading calibration: %s\n", __func__,
+                    sane_strstatus(status));
+                return status;
+            }
+        } catch (...) {
+            dev->model->cmd_set->eject_document(dev);
+            throw;
+        }
+      forward = SANE_FALSE;
+    }
+
+
+  /* go to a white area */
+    try {
+        status = dev->model->cmd_set->search_strip(dev, sensor, forward, SANE_FALSE);
+        if (status != SANE_STATUS_GOOD) {
+            DBG(DBG_error, "%s: failed to find white strip: %s\n", __func__,
+                sane_strstatus(status));
+            dev->model->cmd_set->eject_document (dev);
+            return status;
+        }
+    } catch (...) {
+        dev->model->cmd_set->eject_document (dev);
+        throw;
+    }
+
+  status = dev->model->cmd_set->init_regs_for_shading(dev, sensor, dev->calib_reg);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to do set up registers for shading calibration: %s\n", __func__,
+          sane_strstatus(status));
+      return status;
+    }
+
+    try {
+        status = genesys_white_shading_calibration(dev, sensor);
+        if (status != SANE_STATUS_GOOD) {
+            dev->model->cmd_set->eject_document(dev);
+            DBG(DBG_error, "%s: failed eject target: %s\n", __func__, sane_strstatus(status));
+            return status;
+        }
+    } catch (...) {
+        dev->model->cmd_set->eject_document (dev);
+        throw;
+    }
+
+  /* in case we haven't black shading data, build it from black pixels
+   * of white calibration */
+  if (!(dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION))
+    {
+      dev->dark_average_data.clear();
+      dev->dark_average_data.resize(dev->average_size, 0x0f);
+      /* XXX STEF XXX
+       * with black point in white shading, build an average black
+       * pixel and use it to fill the dark_average
+       * dev->calib_pixels
+       (sensor.sensor_pixels * dev->settings.xres) / sensor.optical_res,
+       dev->calib_lines,
+       */
+    }
+
+  /* send the shading coefficient when doing whole line shading
+   * but not when using SHDAREA like GL124 */
+  if(dev->model->cmd_set->send_shading_data==NULL)
+    {
+      status = genesys_send_shading_coefficient(dev, sensor);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: failed to send shading calibration coefficients: %s\n", __func__,
+              sane_strstatus(status));
+          return status;
+        }
+    }
+
+  /* save the calibration data */
+  genesys_save_calibration (dev, sensor);
+
+  /* and finally eject calibration sheet */
+  status = dev->model->cmd_set->eject_document (dev);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to eject document: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  /* resotre settings */
+  dev->settings.xres = xres;
+  DBGCOMPLETED;
+  return SANE_STATUS_GOOD;
+}
+
+/**
+ * does the calibration process for a device
+ * @param dev device to calibrate
+ */
+static SANE_Status
+genesys_scanner_calibration(Genesys_Device * dev, Genesys_Sensor& sensor)
+{
+  if (dev->model->is_sheetfed == SANE_FALSE)
+    {
+      return genesys_flatbed_calibration (dev, sensor);
+    }
+  return genesys_sheetfed_calibration(dev, sensor);
+}
+
+/* unused function kept in case it may be usefull in the futur */
+#if 0
+static SANE_Status
+genesys_wait_not_moving (Genesys_Device * dev, int mseconds)
+{
+  uint8_t value;
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  DBG(DBG_proc, "%s: waiting %d mseconds for motor to stop\n", __func__, mseconds);
+  while (mseconds > 0)
+    {
+      RIE (sanei_genesys_get_status (dev, &value));
+
+      if (dev->model->cmd_set->test_motor_flag_bit (value))
+	{
+          sanei_genesys_sleep_ms(100);
+	  mseconds -= 100;
+	  DBG(DBG_io, "%s: motor is moving, %d mseconds to go\n", __func__, mseconds);
+	}
+      else
+	{
+	  DBG(DBG_info, "%s: motor is not moving, exiting\n", __func__);
+	  return SANE_STATUS_GOOD;
+	}
+
+    }
+  DBG(DBG_error, "%s: motor is still moving, timeout exceeded\n", __func__);
+  return SANE_STATUS_DEVICE_BUSY;
+}
+#endif
+
+
+/* ------------------------------------------------------------------------ */
+/*                  High level (exported) functions                         */
+/* ------------------------------------------------------------------------ */
+
+/*
+ * wait lamp to be warm enough by scanning the same line until
+ * differences between two scans are below a threshold
+ */
+static SANE_Status
+genesys_warmup_lamp (Genesys_Device * dev)
+{
+  int seconds = 0;
+  int pixel;
+  int channels, total_size;
+  double first_average = 0;
+  double second_average = 0;
+  int difference = 255;
+  int empty, lines = 3;
+  SANE_Status status = SANE_STATUS_IO_ERROR;
+
+  DBGSTART;
+
+  /* check if the current chipset implements warmup */
+  if(dev->model->cmd_set->init_regs_for_warmup==NULL)
+    {
+      DBG(DBG_error,"%s: init_regs_for_warmup not implemented\n", __func__);
+      return status;
+    }
+
+  const auto& sensor = sanei_genesys_find_sensor_any(dev);
+
+  dev->model->cmd_set->init_regs_for_warmup(dev, sensor, &dev->reg, &channels, &total_size);
+  std::vector<uint8_t> first_line(total_size);
+  std::vector<uint8_t> second_line(total_size);
+
+  do
+    {
+      DBG(DBG_info, "%s: one more loop\n", __func__);
+      RIE(dev->model->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_FALSE));
+      do
+	{
+	  sanei_genesys_test_buffer_empty (dev, &empty);
+	}
+      while (empty);
+
+        try {
+            status = sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
+            if (status != SANE_STATUS_GOOD) {
+                RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
+            }
+        } catch (...) {
+            RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
+        }
+
+      RIE(dev->model->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE));
+
+      sanei_genesys_sleep_ms(1000);
+      seconds++;
+
+      RIE(dev->model->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_FALSE));
+      do
+	{
+	  sanei_genesys_test_buffer_empty (dev, &empty);
+          sanei_genesys_sleep_ms(100);
+	}
+      while (empty);
+      RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
+      RIE(dev->model->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE));
+
+      /* compute difference between the two scans */
+      for (pixel = 0; pixel < total_size; pixel++)
+	{
+          /* 16 bit data */
+          if (dev->model->cmd_set->get_bitset_bit(&dev->reg))
+	    {
+	      first_average += (first_line[pixel] + first_line[pixel + 1] * 256);
+	      second_average += (second_line[pixel] + second_line[pixel + 1] * 256);
+	      pixel++;
+	    }
+	  else
+	    {
+	      first_average += first_line[pixel];
+	      second_average += second_line[pixel];
+	    }
+	}
+      if (dev->model->cmd_set->get_bitset_bit(&dev->reg))
+	{
+	  first_average /= pixel;
+	  second_average /= pixel;
+	  difference = fabs (first_average - second_average);
+	  DBG(DBG_info, "%s: average = %.2f, diff = %.3f\n", __func__,
+	      100 * ((second_average) / (256 * 256)),
+	      100 * (difference / second_average));
+
+	  if (second_average > (100 * 256)
+	      && (difference / second_average) < 0.002)
+	    break;
+	}
+      else
+	{
+	  first_average /= pixel;
+	  second_average /= pixel;
+	  if (DBG_LEVEL >= DBG_data)
+	    {
+              sanei_genesys_write_pnm_file("gl_warmup1.pnm", first_line.data(), 8, channels,
+                                           total_size / (lines * channels), lines);
+              sanei_genesys_write_pnm_file("gl_warmup2.pnm", second_line.data(), 8, channels,
+                                           total_size / (lines * channels), lines);
+	    }
+	  DBG(DBG_info, "%s: average 1 = %.2f, average 2 = %.2f\n", __func__, first_average,
+	      second_average);
+          /* if delta below 15/255 ~= 5.8%, lamp is considred warm enough */
+	  if (fabs (first_average - second_average) < 15
+	      && second_average > 55)
+	    break;
+	}
+
+      /* sleep another second before next loop */
+      sanei_genesys_sleep_ms(1000);
+      seconds++;
+    }
+  while (seconds < WARMUP_TIME);
+
+  if (seconds >= WARMUP_TIME)
+    {
+      DBG(DBG_error, "%s: warmup timed out after %d seconds. Lamp defective?\n", __func__, seconds);
+      status = SANE_STATUS_IO_ERROR;
+    }
+  else
+    {
+      DBG(DBG_info, "%s: warmup succeeded after %d seconds\n", __func__, seconds);
+    }
+
+  DBGCOMPLETED;
+
+  return status;
+}
+
+
+/* High-level start of scanning */
+static SANE_Status
+genesys_start_scan (Genesys_Device * dev, SANE_Bool lamp_off)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  unsigned int steps, expected;
+  SANE_Bool empty;
+
+  DBGSTART;
+
+  /* since not all scanners are set ot wait for head to park
+   * we check we are not still parking before starting a new scan */
+  if (dev->parking == SANE_TRUE)
+    {
+      status = sanei_genesys_wait_for_home (dev);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: failed to wait for head to park: %s\n", __func__,
+              sane_strstatus(status));
+          return status;
+        }
+    }
+
+  /* disable power saving*/
+  status = dev->model->cmd_set->save_power (dev, SANE_FALSE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to disable power saving mode: %s\n", __func__,
+          sane_strstatus(status));
+      return status;
+    }
+
+  /* wait for lamp warmup : until a warmup for TRANSPARENCY is designed, skip
+   * it when scanning from XPA. */
+  if (!(dev->model->flags & GENESYS_FLAG_SKIP_WARMUP)
+    && (dev->settings.scan_method == ScanMethod::FLATBED))
+    {
+      RIE (genesys_warmup_lamp (dev));
+    }
+
+  /* set top left x and y values by scanning the internals if flatbed scanners */
+  if (dev->model->is_sheetfed == SANE_FALSE)
+    {
+      /* do the geometry detection only once */
+      if ((dev->model->flags & GENESYS_FLAG_SEARCH_START)
+	  && (dev->model->y_offset_calib == 0))
+	{
+	  status = dev->model->cmd_set->search_start_position (dev);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to search start position: %s\n", __func__,
+		  sane_strstatus(status));
+	      return status;
+	    }
+
+          dev->parking = SANE_FALSE;
+	  status = dev->model->cmd_set->slow_back_home (dev, SANE_TRUE);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to move scanhead to home position: %s\n", __func__,
+                  sane_strstatus(status));
+	      return status;
+	    }
+	  dev->scanhead_position_in_steps = 0;
+	}
+      else
+	{
+	  /* Go home */
+	  /* TODO: check we can drop this since we cannot have the
+	     scanner's head wandering here */
+          dev->parking = SANE_FALSE;
+	  status = dev->model->cmd_set->slow_back_home (dev, SANE_TRUE);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to move scanhead to home position: %s\n", __func__,
+		  sane_strstatus(status));
+	      return status;
+	    }
+	  dev->scanhead_position_in_steps = 0;
+	}
+    }
+
+  /* move to calibration area for transparency adapter */
+  if ((dev->settings.scan_method == ScanMethod::TRANSPARENCY)
+      && dev->model->cmd_set->move_to_ta != NULL)
+    {
+      status=dev->model->cmd_set->move_to_ta(dev);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG(DBG_error, "%s: failed to move to start of transparency adapter: %s\n", __func__,
+	      sane_strstatus(status));
+	  return status;
+	}
+    }
+
+  /* load document if needed (for sheetfed scanner for instance) */
+  if (dev->model->is_sheetfed == SANE_TRUE
+      && dev->model->cmd_set->load_document != NULL)
+    {
+      status = dev->model->cmd_set->load_document (dev);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG(DBG_error, "%s: failed to load document: %s\n", __func__, sane_strstatus(status));
+	  return status;
+	}
+    }
+
+    auto& sensor = sanei_genesys_find_sensor_for_write(dev, dev->settings.xres,
+                                                       dev->settings.scan_method);
+
+  /* send gamma tables. They have been set to device or user value
+   * when setting option value */
+  status = dev->model->cmd_set->send_gamma_table(dev, sensor);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to init gamma table: %s\n", __func__, sane_strstatus(status));
+      return status;
+    }
+
+  /* try to use cached calibration first */
+  if (!genesys_restore_calibration (dev, sensor))
+    {
+       /* calibration : sheetfed scanners can't calibrate before each scan */
+       /* and also those who have the NO_CALIBRATION flag                  */
+       if (!(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION)
+           &&dev->model->is_sheetfed == SANE_FALSE)
+	{
+          status = genesys_scanner_calibration(dev, sensor);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to do scanner calibration: %s\n", __func__,
+		  sane_strstatus(status));
+	      return status;
+	    }
+
+          genesys_save_calibration (dev, sensor);
+	}
+      else
+	{
+          DBG(DBG_warn, "%s: no calibration done\n", __func__);
+	}
+    }
+
+  /* build look up table for dynamic lineart */
+  if(dev->settings.dynamic_lineart==SANE_TRUE)
+    {
+      status = sanei_genesys_load_lut(dev->lineart_lut, 8, 8, 50, 205,
+                        dev->settings.threshold_curve,
+                        dev->settings.threshold-127);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: failed to build lut\n", __func__);
+          return status;
+        }
+    }
+
+    if (dev->model->cmd_set->wait_for_motor_stop) {
+        dev->model->cmd_set->wait_for_motor_stop(dev);
+    }
+
+    if (dev->model->cmd_set->needs_home_before_init_regs_for_scan &&
+        dev->model->cmd_set->needs_home_before_init_regs_for_scan(dev) &&
+        dev->model->cmd_set->slow_back_home)
+    {
+        RIE(dev->model->cmd_set->slow_back_home(dev, SANE_TRUE));
+    }
+
+    if (dev->settings.scan_method == ScanMethod::TRANSPARENCY) {
+        RIE(dev->model->cmd_set->move_to_ta(dev));
+    }
+
+  status = dev->model->cmd_set->init_regs_for_scan(dev, sensor);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to do init registers for scan: %s\n", __func__,
+          sane_strstatus(status));
+      return status;
+    }
+
+  /* no lamp during scan */
+  if(lamp_off == SANE_TRUE)
+    {
+        sanei_genesys_set_lamp_power(dev, sensor, dev->reg, false);
+    }
+
+  /* GL124 is using SHDAREA, so we have to wait for scan to be set up before
+   * sending shading data */
+  if(  (dev->model->cmd_set->send_shading_data!=NULL)
+   && !(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION))
+    {
+      status = genesys_send_shading_coefficient(dev, sensor);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: failed to send shading calibration coefficients: %s\n", __func__,
+              sane_strstatus(status));
+          return status;
+        }
+    }
+
+  /* now send registers for scan */
+  status =
+    dev->model->cmd_set->bulk_write_register(dev, dev->reg);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to bulk write registers, status = %d\n", __func__, status);
+      return status;
+    }
+
+  /* start effective scan */
+  status = dev->model->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_TRUE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
+      return SANE_STATUS_IO_ERROR;
+    }
+
+  /*do we really need this? the valid data check should be sufficent -- pierre*/
+  /* waits for head to reach scanning position */
+  expected = dev->reg.get8(0x3d) * 65536
+           + dev->reg.get8(0x3e) * 256
+           + dev->reg.get8(0x3f);
+  do
+    {
+      // wait some time between each test to avoid overloading USB and CPU
+      sanei_genesys_sleep_ms(100);
+      status = sanei_genesys_read_feed_steps (dev, &steps);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: Failed to read feed steps: %s\n", __func__, sane_strstatus(status));
+          return status;
+        }
+    }
+  while (steps < expected);
+
+  /* wait for buffers to be filled */
+  do
+    {
+      RIE (sanei_genesys_test_buffer_empty (dev, &empty));
+    }
+  while (empty);
+
+  /* when doing one or two-table movement, let the motor settle to scanning speed */
+  /* and scanning start before reading data                                        */
+/* the valid data check already waits until the scanner delivers data. this here leads to unnecessary buffer full conditions in the scanner.
+  if (dev->model->cmd_set->get_fast_feed_bit (dev->reg))
+    sanei_genesys_sleep_ms(1000);
+  else
+    sanei_genesys_sleep_ms(500);
+*/
+  /* then we wait for at least one word of valid scan data
+
+     this is also done in sanei_genesys_read_data_from_scanner -- pierre */
+  if (dev->model->is_sheetfed == SANE_FALSE)
+    {
+      do
+	{
+          sanei_genesys_sleep_ms(100);
+	  status = sanei_genesys_read_valid_words (dev, &steps);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to read valid words: %s\n", __func__,
+		  sane_strstatus(status));
+	      return status;
+	    }
+	}
+      while (steps < 1);
+    }
+
+  DBGCOMPLETED;
+  return SANE_STATUS_GOOD;
+}
+
+/* this is _not_ a ringbuffer.
+   if we need a block which does not fit at the end of our available data,
+   we move the available data to the beginning.
+ */
+
+void Genesys_Buffer::alloc(size_t size)
+{
+    buffer_.resize(size);
+    avail_ = 0;
+    pos_ = 0;
+}
+
+void Genesys_Buffer::clear()
+{
+    buffer_.clear();
+    avail_ = 0;
+    pos_ = 0;
+}
+
+void Genesys_Buffer::reset()
+{
+    avail_ = 0;
+    pos_ = 0;
+}
+
+uint8_t* Genesys_Buffer::get_write_pos(size_t size)
+{
+    if (avail_ + size > buffer_.size())
+        return nullptr;
+    if (pos_ + avail_ + size > buffer_.size())
+    {
+        std::memmove(buffer_.data(), buffer_.data() + pos_, avail_);
+        pos_ = 0;
+    }
+    return buffer_.data() + pos_ + avail_;
+}
+
+uint8_t* Genesys_Buffer::get_read_pos()
+{
+    return buffer_.data() + pos_;
+}
+
+void Genesys_Buffer::produce(size_t size)
+{
+    if (size > buffer_.size() - avail_)
+        throw std::runtime_error("buffer size exceeded");
+    avail_ += size;
+}
+
+void Genesys_Buffer::consume(size_t size)
+{
+  if (size > avail_)
+      throw std::runtime_error("no more data in buffer");
+    avail_ -= size;
+    pos_ += size;
+}
+
+
+#include "genesys_conv.cc"
+
+static SANE_Status accurate_line_read(Genesys_Device * dev,
+                                      Genesys_Buffer& buffer)
+{
+    buffer.reset();
+
+  SANE_Status status = SANE_STATUS_GOOD;
+  status = dev->model->cmd_set->bulk_read_data(dev, 0x45, buffer.get_write_pos(buffer.size()),
+                                               buffer.size());
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to read %lu bytes (%s)\n", __func__, (u_long) buffer.size(),
+          sane_strstatus(status));
+      return SANE_STATUS_IO_ERROR;
+    }
+
+    buffer.produce(buffer.size());
+  return status;
+}
+
+/** @brief fill buffer while reducing vertical resolution
+ * This function fills a read buffer with scanned data from a sensor
+ * which puts odd and even pixels in 2 different data segment. So a complete
+ * must be read and bytes interleaved to get usable by the other stages
+ * of the backend
+ */
+static SANE_Status
+genesys_fill_line_interp_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, size_t size)
+{
+  size_t count;
+  SANE_Status status = SANE_STATUS_GOOD;
+
+      /* fill buffer if needed */
+      if (dev->oe_buffer.avail() == 0)
+	{
+          status = accurate_line_read(dev, dev->oe_buffer);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to read %lu bytes (%s)\n", __func__,
+                  (u_long) dev->oe_buffer.size(), sane_strstatus(status));
+	      return SANE_STATUS_IO_ERROR;
+	    }
+	}
+
+      /* copy size bytes of data, copying from a line when line count matches */
+      count = 0;
+      while (count < size)
+	{
+          /* line counter */
+          /* dev->line_interp holds the number of lines scanned for one line of data sent */
+          if(((dev->line_count/dev->current_setup.channels) % dev->line_interp)==0)
+            {
+	      /* copy pixel when line matches */
+              work_buffer_dst[count] = dev->oe_buffer.get_read_pos()[dev->cur];
+              count++;
+            }
+
+          /* always update pointer so we skip uncopied data */
+          dev->cur++;
+
+	  /* go to next line if needed */
+	  if (dev->cur == dev->len)
+	    {
+              dev->oe_buffer.set_pos(dev->oe_buffer.pos() + dev->bpl);
+	      dev->cur = 0;
+              dev->line_count++;
+	    }
+
+	  /* read a new buffer if needed */
+          if (dev->oe_buffer.pos() >= dev->oe_buffer.avail())
+	    {
+              status = accurate_line_read(dev, dev->oe_buffer);
+              if (status != SANE_STATUS_GOOD)
+                {
+                  DBG(DBG_error, "%s: failed to read %lu bytes (%s)\n", __func__,
+                      (u_long) dev->oe_buffer.size(), sane_strstatus(status));
+                  return SANE_STATUS_IO_ERROR;
+                }
+	    }
+	}
+
+    return SANE_STATUS_GOOD;
+}
+
+/** @brief fill buffer for segmented sensors
+ * This function fills a read buffer with scanned data from a sensor segmented
+ * in several parts (multi-lines sensors). Data of the same valid area is read
+ * back to back and must be interleaved to get usable by the other stages
+ * of the backend
+ */
+static SANE_Status
+genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, size_t size)
+{
+  size_t count;
+  SANE_Status status = SANE_STATUS_GOOD;
+  int depth,i,n,k;
+
+  depth = dev->settings.depth;
+  if (dev->settings.scan_mode == ScanColorMode::LINEART && dev->settings.dynamic_lineart==SANE_FALSE)
+    depth = 1;
+
+      /* fill buffer if needed */
+      if (dev->oe_buffer.avail() == 0)
+	{
+          status = accurate_line_read(dev, dev->oe_buffer);
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to read %lu bytes (%s)\n", __func__,
+                  (u_long) dev->oe_buffer.size(), sane_strstatus(status));
+	      return SANE_STATUS_IO_ERROR;
+	    }
+	}
+
+      /* copy size bytes of data, copying from a subwindow of each line
+       * when last line of buffer is exhausted, read another one */
+      count = 0;
+      while (count < size)
+	{
+            if (depth==1) {
+                while (dev->cur < dev->len && count < size) {
+                    for (n=0; n<dev->segnb; n++) {
+                        work_buffer_dst[count+n] = 0;
+                    }
+                    /* interleaving is at bit level */
+                    for (i=0;i<8;i++) {
+                        k=count+(i*dev->segnb)/8;
+                        for (n=0;n<dev->segnb;n++) {
+                            work_buffer_dst[k] = work_buffer_dst[k] << 1;
+                            if ((dev->oe_buffer.get_read_pos()[dev->cur + dev->skip + dev->dist*dev->order[n]])&(128>>i)) {
+                                work_buffer_dst[k] |= 1;
+                            }
+                        }
+                    }
+
+                    /* update counter and pointer */
+                    count += dev->segnb;
+                    dev->cur++;
+                }
+            }
+            if (depth==8) {
+                 while (dev->cur < dev->len && count < size) {
+                    for (n=0;n<dev->segnb;n++) {
+                        work_buffer_dst[count+n] = dev->oe_buffer.get_read_pos()[dev->cur + dev->skip + dev->dist*dev->order[n]];
+                    }
+                    /* update counter and pointer */
+                    count += dev->segnb;
+                    dev->cur++;
+                }
+            }
+            if (depth==16) {
+                while (dev->cur < dev->len && count < size) {
+                    for (n=0;n<dev->segnb;n++) {
+                        work_buffer_dst[count+n*2] = dev->oe_buffer.get_read_pos()[dev->cur + dev->skip + dev->dist*dev->order[n]];
+                        work_buffer_dst[count+n*2+1] = dev->oe_buffer.get_read_pos()[dev->cur + dev->skip + dev->dist*dev->order[n] + 1];
+                    }
+                    /* update counter and pointer */
+                    count += dev->segnb*2;
+                    dev->cur+=2;
+                }
+            }
+
+	  /* go to next line if needed */
+	  if (dev->cur == dev->len)
+	    {
+              dev->oe_buffer.set_pos(dev->oe_buffer.pos() + dev->bpl);
+	      dev->cur = 0;
+	    }
+
+	  /* read a new buffer if needed */
+          if (dev->oe_buffer.pos() >= dev->oe_buffer.avail())
+	    {
+              status = accurate_line_read(dev, dev->oe_buffer);
+              if (status != SANE_STATUS_GOOD)
+                {
+                  DBG(DBG_error, "%s: failed to read %lu bytes (%s)\n", __func__,
+                      (u_long) dev->oe_buffer.size(), sane_strstatus(status));
+                  return SANE_STATUS_IO_ERROR;
+                }
+	    }
+	}
+
+    return SANE_STATUS_GOOD;
+}
+
+/**
+ *
+ */
+static SANE_Status
+genesys_fill_read_buffer (Genesys_Device * dev)
+{
+  size_t size;
+  size_t space;
+  SANE_Status status = SANE_STATUS_GOOD;
+  uint8_t *work_buffer_dst;
+
+  DBGSTART;
+
+  /* for sheetfed scanner, we must check is document is shorter than
+   * the requested scan */
+  if (dev->model->is_sheetfed == SANE_TRUE)
+    {
+      status = dev->model->cmd_set->detect_document_end (dev);
+      if (status != SANE_STATUS_GOOD)
+	return status;
+    }
+
+  space = dev->read_buffer.size() - dev->read_buffer.avail();
+
+  work_buffer_dst = dev->read_buffer.get_write_pos(space);
+
+  size = space;
+
+  /* never read an odd number. exception: last read
+     the chip internal counter does not count half words. */
+  size &= ~1;
+  /* Some setups need the reads to be multiples of 256 bytes */
+  size &= ~0xff;
+
+  if (dev->read_bytes_left < size)
+    {
+      size = dev->read_bytes_left;
+      /*round up to a multiple of 256 bytes */
+      size += (size & 0xff) ? 0x100 : 0x00;
+      size &= ~0xff;
+    }
+
+  /* early out if our remaining buffer capacity is too low */
+  if (size == 0)
+    return SANE_STATUS_GOOD;
+
+  DBG(DBG_io, "%s: reading %lu bytes\n", __func__, (u_long) size);
+
+  /* size is already maxed to our needs. for most models bulk_read_data
+     will read as much data as requested. */
+
+  /* due to sensors and motors, not all data can be directly used. It
+   * may have to be read from another intermediate buffer and then processed.
+   * There are currently 3 intermediate stages:
+   * - handling of odd/even sensors
+   * - handling of line interpolation for motors that can't have low
+   *   enough dpi
+   * - handling of multi-segments sensors
+   *
+   * This is also the place where full duplex data will be handled.
+   */
+  if (dev->line_interp>0)
+    {
+      /* line interpolation */
+      status = genesys_fill_line_interp_buffer (dev, work_buffer_dst, size);
+    }
+  else if (dev->segnb>1)
+    {
+      /* multi-segment sensors processing */
+      status = genesys_fill_segmented_buffer (dev, work_buffer_dst, size);
+    }
+  else /* regular case with no extra copy */
+    {
+      status = dev->model->cmd_set->bulk_read_data (dev, 0x45, work_buffer_dst, size);
+    }
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to read %lu bytes (%s)\n", __func__, (u_long) size,
+          sane_strstatus(status));
+      return SANE_STATUS_IO_ERROR;
+    }
+
+  if (size > dev->read_bytes_left)
+    size = dev->read_bytes_left;
+
+  dev->read_bytes_left -= size;
+
+  dev->read_buffer.produce(size);
+
+  DBGCOMPLETED;
+
+  return SANE_STATUS_GOOD;
+}
+
+/* this function does the effective data read in a manner that suits
+   the scanner. It does data reordering and resizing if need.
+   It also manages EOF and I/O errors, and line distance correction.
+   */
+static SANE_Status
+genesys_read_ordered_data (Genesys_Device * dev, SANE_Byte * destination,
+			   size_t * len)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  size_t bytes, extra;
+  unsigned int channels, depth, src_pixels;
+  unsigned int ccd_shift[12], shift_count;
+  uint8_t *work_buffer_src;
+  uint8_t *work_buffer_dst;
+  unsigned int dst_lines;
+  unsigned int step_1_mode;
+  unsigned int needs_reorder;
+  unsigned int needs_ccd;
+  unsigned int needs_shrink;
+  unsigned int needs_reverse;
+  Genesys_Buffer *src_buffer;
+  Genesys_Buffer *dst_buffer;
+
+  DBGSTART;
+  if (dev->read_active != SANE_TRUE)
+    {
+      DBG(DBG_error, "%s: read not active!\n", __func__);
+      *len = 0;
+      return SANE_STATUS_INVAL;
+    }
+
+    DBG(DBG_info, "%s: ", __func__);
+    debug_dump(DBG_info, dev->current_setup);
+
+  /* prepare conversion */
+  /* current settings */
+  channels = dev->current_setup.channels;
+  depth = dev->current_setup.depth;
+
+  src_pixels = dev->current_setup.pixels;
+
+  needs_reorder = 1;
+  if (channels != 3 && depth != 16)
+    needs_reorder = 0;
+#ifndef WORDS_BIGENDIAN
+  if (channels != 3 && depth == 16)
+    needs_reorder = 0;
+  if (channels == 3 && depth == 16 && !dev->model->is_cis &&
+      dev->model->line_mode_color_order == COLOR_ORDER_RGB)
+    needs_reorder = 0;
+#endif
+  if (channels == 3 && depth == 8 && !dev->model->is_cis &&
+      dev->model->line_mode_color_order == COLOR_ORDER_RGB)
+    needs_reorder = 0;
+
+  needs_ccd = dev->current_setup.max_shift > 0;
+  needs_shrink = dev->settings.pixels != src_pixels;
+  needs_reverse = depth == 1;
+
+  DBG(DBG_info, "%s: using filters:%s%s%s%s\n", __func__,
+      needs_reorder ? " reorder" : "",
+      needs_ccd ? " ccd" : "",
+      needs_shrink ? " shrink" : "",
+      needs_reverse ? " reverse" : "");
+
+  DBG(DBG_info, "%s: frontend requested %lu bytes\n", __func__, (u_long) * len);
+
+  DBG(DBG_info, "%s: bytes_to_read=%lu, total_bytes_read=%lu\n", __func__,
+      (u_long) dev->total_bytes_to_read, (u_long) dev->total_bytes_read);
+  /* is there data left to scan */
+  if (dev->total_bytes_read >= dev->total_bytes_to_read)
+    {
+      DBG(DBG_proc, "%s: nothing more to scan: EOF\n", __func__);
+      *len = 0;
+
+      /* issue park command immediatly in case scanner can handle it
+       * so we save time */
+      if (dev->model->is_sheetfed == SANE_FALSE
+       && !(dev->model->flags & GENESYS_FLAG_MUST_WAIT)
+       && dev->parking == SANE_FALSE)
+        {
+          dev->model->cmd_set->slow_back_home (dev, SANE_FALSE);
+          dev->parking = SANE_TRUE;
+        }
+      return SANE_STATUS_EOF;
+    }
+
+  DBG(DBG_info, "%s: %lu lines left by output\n", __func__,
+       ((dev->total_bytes_to_read - dev->total_bytes_read) * 8UL) /
+       (dev->settings.pixels * channels * depth));
+  DBG(DBG_info, "%s: %lu lines left by input\n", __func__,
+       ((dev->read_bytes_left + dev->read_buffer.avail()) * 8UL) /
+       (src_pixels * channels * depth));
+
+  if (channels == 1)
+    {
+      ccd_shift[0] = 0;
+      ccd_shift[1] = dev->current_setup.stagger;
+      shift_count = 2;
+    }
+  else
+    {
+      ccd_shift[0] =
+	((dev->ld_shift_r * dev->settings.yres) /
+	 dev->motor.base_ydpi);
+      ccd_shift[1] =
+	((dev->ld_shift_g * dev->settings.yres) /
+	 dev->motor.base_ydpi);
+      ccd_shift[2] =
+	((dev->ld_shift_b * dev->settings.yres) /
+	 dev->motor.base_ydpi);
+
+      ccd_shift[3] = ccd_shift[0] + dev->current_setup.stagger;
+      ccd_shift[4] = ccd_shift[1] + dev->current_setup.stagger;
+      ccd_shift[5] = ccd_shift[2] + dev->current_setup.stagger;
+
+      shift_count = 6;
+    }
+
+
+/* convert data */
+/*
+  0. fill_read_buffer
+-------------- read_buffer ----------------------
+  1a). (opt)uncis                    (assumes color components to be laid out
+                                    planar)
+  1b). (opt)reverse_RGB              (assumes pixels to be BGR or BBGGRR))
+-------------- lines_buffer ----------------------
+  2a). (opt)line_distance_correction (assumes RGB or RRGGBB)
+  2b). (opt)unstagger                (assumes pixels to be depth*channels/8
+                                      bytes long, unshrinked)
+------------- shrink_buffer ---------------------
+  3. (opt)shrink_lines             (assumes component separation in pixels)
+-------------- out_buffer -----------------------
+  4. memcpy to destination (for lineart with bit reversal)
+*/
+/*FIXME: for lineart we need sub byte addressing in buffers, or conversion to
+  bytes at 0. and back to bits at 4.
+Problems with the first approach:
+  - its not clear how to check if we need to output an incomplete byte
+    because it is the last one.
+ */
+/*FIXME: add lineart support for gl646. in the meantime add logic to convert
+  from gray to lineart at the end? would suffer the above problem,
+  total_bytes_to_read and total_bytes_read help in that case.
+ */
+
+  status = genesys_fill_read_buffer (dev);
+
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: genesys_fill_read_buffer failed\n", __func__);
+      return status;
+    }
+
+  src_buffer = &(dev->read_buffer);
+
+/* maybe reorder components/bytes */
+  if (needs_reorder)
+    {
+/*not implemented for depth == 1.*/
+      if (depth == 1)
+	{
+	  DBG(DBG_error, "Can't reorder single bit data\n");
+	  return SANE_STATUS_INVAL;
+	}
+
+      dst_buffer = &(dev->lines_buffer);
+
+      work_buffer_src = src_buffer->get_read_pos();
+      bytes = src_buffer->avail();
+
+/*how many bytes can be processed here?*/
+/*we are greedy. we work as much as possible*/
+      if (bytes > dst_buffer->size() - dst_buffer->avail())
+        bytes = dst_buffer->size() - dst_buffer->avail();
+
+      dst_lines = (bytes * 8) / (src_pixels * channels * depth);
+      bytes = (dst_lines * src_pixels * channels * depth) / 8;
+
+      work_buffer_dst = dst_buffer->get_write_pos(bytes);
+
+      DBG(DBG_info, "%s: reordering %d lines\n", __func__, dst_lines);
+
+      if (dst_lines != 0)
+	{
+
+	  if (channels == 3)
+	    {
+	      step_1_mode = 0;
+
+	      if (depth == 16)
+		step_1_mode |= 1;
+
+	      if (dev->model->is_cis)
+		step_1_mode |= 2;
+
+	      if (dev->model->line_mode_color_order == COLOR_ORDER_BGR)
+		step_1_mode |= 4;
+
+	      switch (step_1_mode)
+		{
+		case 1:	/* RGB, chunky, 16 bit */
+#ifdef WORDS_BIGENDIAN
+		  status =
+		    genesys_reorder_components_endian_16 (work_buffer_src,
+							  work_buffer_dst,
+							  dst_lines,
+							  src_pixels, 3);
+		  break;
+#endif /*WORDS_BIGENDIAN */
+		case 0:	/* RGB, chunky, 8 bit */
+		  status = SANE_STATUS_GOOD;
+		  break;
+		case 2:	/* RGB, cis, 8 bit */
+		  status =
+		    genesys_reorder_components_cis_8 (work_buffer_src,
+						      work_buffer_dst,
+						      dst_lines, src_pixels);
+		  break;
+		case 3:	/* RGB, cis, 16 bit */
+		  status =
+		    genesys_reorder_components_cis_16 (work_buffer_src,
+						       work_buffer_dst,
+						       dst_lines, src_pixels);
+		  break;
+		case 4:	/* BGR, chunky, 8 bit */
+		  status =
+		    genesys_reorder_components_bgr_8 (work_buffer_src,
+						      work_buffer_dst,
+						      dst_lines, src_pixels);
+		  break;
+		case 5:	/* BGR, chunky, 16 bit */
+		  status =
+		    genesys_reorder_components_bgr_16 (work_buffer_src,
+						       work_buffer_dst,
+						       dst_lines, src_pixels);
+		  break;
+		case 6:	/* BGR, cis, 8 bit */
+		  status =
+		    genesys_reorder_components_cis_bgr_8 (work_buffer_src,
+							  work_buffer_dst,
+							  dst_lines,
+							  src_pixels);
+		  break;
+		case 7:	/* BGR, cis, 16 bit */
+		  status =
+		    genesys_reorder_components_cis_bgr_16 (work_buffer_src,
+							   work_buffer_dst,
+							   dst_lines,
+							   src_pixels);
+		  break;
+		}
+	    }
+	  else
+	    {
+#ifdef WORDS_BIGENDIAN
+	      if (depth == 16)
+		{
+		  status =
+		    genesys_reorder_components_endian_16 (work_buffer_src,
+							  work_buffer_dst,
+							  dst_lines,
+							  src_pixels, 1);
+		}
+	      else
+		{
+		  status = SANE_STATUS_GOOD;
+		}
+#else /*!WORDS_BIGENDIAN */
+	      status = SANE_STATUS_GOOD;
+#endif /*WORDS_BIGENDIAN */
+	    }
+
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to convert byte ordering(%s)\n", __func__,
+		  sane_strstatus(status));
+	      return SANE_STATUS_IO_ERROR;
+	    }
+
+            dst_buffer->produce(bytes);
+            src_buffer->consume(bytes);
+	}
+      src_buffer = dst_buffer;
+    }
+
+/* maybe reverse effects of ccd layout */
+  if (needs_ccd)
+    {
+/*should not happen with depth == 1.*/
+      if (depth == 1)
+	{
+	  DBG(DBG_error, "Can't reverse ccd for single bit data\n");
+	  return SANE_STATUS_INVAL;
+	}
+
+      dst_buffer = &(dev->shrink_buffer);
+
+      work_buffer_src = src_buffer->get_read_pos();
+      bytes = src_buffer->avail();
+
+      extra =
+	(dev->current_setup.max_shift * src_pixels * channels * depth) / 8;
+
+/*extra bytes are reserved, and should not be consumed*/
+      if (bytes < extra)
+	bytes = 0;
+      else
+	bytes -= extra;
+
+/*how many bytes can be processed here?*/
+/*we are greedy. we work as much as possible*/
+      if (bytes > dst_buffer->size() - dst_buffer->avail())
+        bytes = dst_buffer->size() - dst_buffer->avail();
+
+      dst_lines = (bytes * 8) / (src_pixels * channels * depth);
+      bytes = (dst_lines * src_pixels * channels * depth) / 8;
+
+      work_buffer_dst = dst_buffer->get_write_pos(bytes);
+
+      DBG(DBG_info, "%s: un-ccd-ing %d lines\n", __func__, dst_lines);
+
+      if (dst_lines != 0)
+	{
+
+	  if (depth == 8)
+	    status = genesys_reverse_ccd_8 (work_buffer_src, work_buffer_dst,
+					    dst_lines,
+					    src_pixels * channels,
+					    ccd_shift, shift_count);
+	  else
+	    status = genesys_reverse_ccd_16 (work_buffer_src, work_buffer_dst,
+					     dst_lines,
+					     src_pixels * channels,
+					     ccd_shift, shift_count);
+
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to reverse ccd effects(%s)\n", __func__,
+		  sane_strstatus(status));
+	      return SANE_STATUS_IO_ERROR;
+	    }
+
+            dst_buffer->produce(bytes);
+            src_buffer->consume(bytes);
+	}
+      src_buffer = dst_buffer;
+    }
+
+/* maybe shrink(or enlarge) lines */
+  if (needs_shrink)
+    {
+
+      dst_buffer = &(dev->out_buffer);
+
+      work_buffer_src = src_buffer->get_read_pos();
+      bytes = src_buffer->avail();
+
+/*lines in input*/
+      dst_lines = (bytes * 8) / (src_pixels * channels * depth);
+
+      /* how many lines can be processed here?      */
+      /* we are greedy. we work as much as possible */
+      bytes = dst_buffer->size() - dst_buffer->avail();
+
+      if (dst_lines > (bytes * 8) / (dev->settings.pixels * channels * depth))
+	dst_lines = (bytes * 8) / (dev->settings.pixels * channels * depth);
+
+      bytes = (dst_lines * dev->settings.pixels * channels * depth) / 8;
+
+      work_buffer_dst = dst_buffer->get_write_pos(bytes);
+
+      DBG(DBG_info, "%s: shrinking %d lines\n", __func__, dst_lines);
+
+      if (dst_lines != 0)
+	{
+	  if (depth == 1)
+	    status = genesys_shrink_lines_1 (work_buffer_src,
+					     work_buffer_dst,
+					     dst_lines,
+					     src_pixels,
+					     dev->settings.pixels,
+                                             channels);
+	  else if (depth == 8)
+	    status = genesys_shrink_lines_8 (work_buffer_src,
+					     work_buffer_dst,
+					     dst_lines,
+					     src_pixels,
+					     dev->settings.pixels, channels);
+	  else
+	    status = genesys_shrink_lines_16 (work_buffer_src,
+					      work_buffer_dst,
+					      dst_lines,
+					      src_pixels,
+					      dev->settings.pixels, channels);
+
+	  if (status != SANE_STATUS_GOOD)
+	    {
+	      DBG(DBG_error, "%s: failed to shrink lines(%s)\n", __func__, sane_strstatus(status));
+	      return SANE_STATUS_IO_ERROR;
+	    }
+
+          /* we just consumed this many bytes*/
+	  bytes = (dst_lines * src_pixels * channels * depth) / 8;
+            src_buffer->consume(bytes);
+
+          /* we just created this many bytes*/
+	  bytes = (dst_lines * dev->settings.pixels * channels * depth) / 8;
+            dst_buffer->produce(bytes);
+	}
+      src_buffer = dst_buffer;
+    }
+
+  /* move data to destination */
+  bytes = src_buffer->avail();
+  if (bytes > *len)
+    bytes = *len;
+  work_buffer_src = src_buffer->get_read_pos();
+
+  if (needs_reverse)
+    {
+      status = genesys_reverse_bits (work_buffer_src, destination, bytes);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG(DBG_error, "%s: failed to reverse bits(%s)\n", __func__, sane_strstatus(status));
+	  return SANE_STATUS_IO_ERROR;
+	}
+      *len = bytes;
+    }
+  else
+    {
+      memcpy (destination, work_buffer_src, bytes);
+      *len = bytes;
+    }
+
+  /* avoid signaling some extra data because we have treated a full block
+   * on the last block */
+  if (dev->total_bytes_read + *len > dev->total_bytes_to_read)
+    *len = dev->total_bytes_to_read - dev->total_bytes_read;
+
+  /* count bytes sent to frontend */
+  dev->total_bytes_read += *len;
+
+    src_buffer->consume(bytes);
+
+  /* end scan if all needed data have been read */
+   if(dev->total_bytes_read >= dev->total_bytes_to_read)
+    {
+      dev->model->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE);
+      if (dev->model->is_sheetfed == SANE_TRUE)
+        {
+          dev->model->cmd_set->eject_document (dev);
+        }
+    }
+
+  DBG(DBG_proc, "%s: completed, %lu bytes read\n", __func__, (u_long) bytes);
+  return SANE_STATUS_GOOD;
+}
+
+
+
+/* ------------------------------------------------------------------------ */
+/*                  Start of higher level functions                         */
+/* ------------------------------------------------------------------------ */
+
+static size_t
+max_string_size (const SANE_String_Const strings[])
+{
+  size_t size, max_size = 0;
+  SANE_Int i;
+
+  for (i = 0; strings[i]; ++i)
+    {
+      size = strlen (strings[i]) + 1;
+      if (size > max_size)
+	max_size = size;
+    }
+  return max_size;
+}
+
+static SANE_Status
+calc_parameters (Genesys_Scanner * s)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  double tl_x = 0, tl_y = 0, br_x = 0, br_y = 0;
+
+    tl_x = SANE_UNFIX(s->pos_top_left_x);
+    tl_y = SANE_UNFIX(s->pos_top_left_y);
+    br_x = SANE_UNFIX(s->pos_bottom_right_x);
+    br_y = SANE_UNFIX(s->pos_bottom_right_y);
+
+  s->params.last_frame = SANE_TRUE;	/* only single pass scanning supported */
+
+    if (s->mode == SANE_VALUE_SCAN_MODE_GRAY || s->mode == SANE_VALUE_SCAN_MODE_LINEART) {
+        s->params.format = SANE_FRAME_GRAY;
+    } else {
+        s->params.format = SANE_FRAME_RGB;
+    }
+
+    if (s->mode == SANE_VALUE_SCAN_MODE_LINEART) {
+        s->params.depth = 1;
+    } else {
+        s->params.depth = s->bit_depth;
+    }
+
+    s->dev->settings.depth = s->bit_depth;
+
+  /* interpolation */
+  s->dev->settings.disable_interpolation = s->disable_interpolation;
+
+  // FIXME: use correct sensor
+  const auto& sensor = sanei_genesys_find_sensor_any(s->dev);
+
+    // hardware settings
+    if (s->resolution > sensor.optical_res && s->dev->settings.disable_interpolation) {
+        s->dev->settings.xres = sensor.optical_res;
+    } else {
+        s->dev->settings.xres = s->resolution;
+    }
+    s->dev->settings.yres = s->resolution;
+
+    s->params.lines = ((br_y - tl_y) * s->dev->settings.yres) / MM_PER_INCH;
+    s->params.pixels_per_line = ((br_x - tl_x) * s->resolution) / MM_PER_INCH;
+
+  /* we need an even pixels number
+   * TODO invert test logic or generalize behaviour across all ASICs */
+  if ((s->dev->model->flags & GENESYS_FLAG_SIS_SENSOR)
+      || s->dev->model->asic_type == GENESYS_GL847
+      || s->dev->model->asic_type == GENESYS_GL124
+      || s->dev->model->asic_type == GENESYS_GL845
+      || s->dev->model->asic_type == GENESYS_GL846
+      || s->dev->model->asic_type == GENESYS_GL843)
+    {
+      if (s->dev->settings.xres <= 1200)
+        s->params.pixels_per_line = (s->params.pixels_per_line/4)*4;
+      else
+        s->params.pixels_per_line = (s->params.pixels_per_line/16)*16;
+    }
+
+  /* corner case for true lineart for sensor with several segments
+   * or when xres is doubled to match yres */
+  if (s->dev->settings.xres >= 1200
+      && (    s->dev->model->asic_type == GENESYS_GL124
+           || s->dev->model->asic_type == GENESYS_GL847
+           || s->dev->current_setup.xres < s->dev->current_setup.yres
+         )
+     )
+    {
+      s->params.pixels_per_line = (s->params.pixels_per_line/16)*16;
+    }
+
+  s->params.bytes_per_line = s->params.pixels_per_line;
+  if (s->params.depth > 8)
+    {
+      s->params.depth = 16;
+      s->params.bytes_per_line *= 2;
+    }
+  else if (s->params.depth == 1)
+    {
+      s->params.bytes_per_line /= 8;
+      /* round down pixel number
+         really? rounding down means loss of at most 7 pixels! -- pierre */
+      s->params.pixels_per_line = 8 * s->params.bytes_per_line;
+    }
+
+    if (s->params.format == SANE_FRAME_RGB) {
+        s->params.bytes_per_line *= 3;
+    }
+
+    if (s->mode == SANE_VALUE_SCAN_MODE_COLOR) {
+        s->dev->settings.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
+    } else if (s->mode == SANE_VALUE_SCAN_MODE_GRAY) {
+        s->dev->settings.scan_mode = ScanColorMode::GRAY;
+    } else if (s->mode == SANE_TITLE_HALFTONE) {
+        s->dev->settings.scan_mode = ScanColorMode::HALFTONE;
+    } else {				/* Lineart */
+        s->dev->settings.scan_mode = ScanColorMode::LINEART;
+    }
+
+    if (s->source == STR_FLATBED) {
+        s->dev->settings.scan_method = ScanMethod::FLATBED;
+    } else if (s->source == STR_TRANSPARENCY_ADAPTER) {
+        s->dev->settings.scan_method = ScanMethod::TRANSPARENCY;
+    } else if (s->source == STR_TRANSPARENCY_ADAPTER_INFRARED) {
+        s->dev->settings.scan_method = ScanMethod::TRANSPARENCY_INFRARED;
+    }
+
+  s->dev->settings.lines = s->params.lines;
+  s->dev->settings.pixels = s->params.pixels_per_line;
+  s->dev->settings.tl_x = tl_x;
+  s->dev->settings.tl_y = tl_y;
+
+    // threshold setting
+    s->dev->settings.threshold = 2.55 * (SANE_UNFIX(s->threshold));
+
+    // color filter
+    if (s->color_filter == "Red") {
+        s->dev->settings.color_filter = ColorFilter::RED;
+    } else if (s->color_filter == "Green") {
+        s->dev->settings.color_filter = ColorFilter::GREEN;
+    } else if (s->color_filter == "Blue") {
+        s->dev->settings.color_filter = ColorFilter::BLUE;
+    } else {
+        s->dev->settings.color_filter = ColorFilter::NONE;
+    }
+
+    // true gray
+    if (s->color_filter == "None") {
+        s->dev->settings.true_gray = 1;
+    } else {
+        s->dev->settings.true_gray = 0;
+    }
+
+  /* dynamic lineart */
+  s->dev->settings.dynamic_lineart = SANE_FALSE;
+  s->dev->settings.threshold_curve=0;
+    if (!s->disable_dynamic_lineart && s->dev->settings.scan_mode == ScanColorMode::LINEART) {
+        s->dev->settings.dynamic_lineart = SANE_TRUE;
+    }
+
+  /* hardware lineart works only when we don't have interleave data
+   * for GL847 scanners, ie up to 600 DPI, then we have to rely on
+   * dynamic_lineart */
+  if(s->dev->settings.xres > 600
+     && s->dev->model->asic_type==GENESYS_GL847
+     && s->dev->settings.scan_mode == ScanColorMode::LINEART)
+   {
+      s->dev->settings.dynamic_lineart = SANE_TRUE;
+   }
+
+    // threshold curve for dynamic rasterization
+    s->dev->settings.threshold_curve = s->threshold_curve;
+
+  /* some digital processing requires the whole picture to be buffered */
+  /* no digital processing takes place when doing preview, or when bit depth is
+   * higher than 8 bits */
+  if ((s->swdespeck || s->swcrop || s->swdeskew || s->swderotate ||(SANE_UNFIX(s->swskip)>0))
+    && (!s->preview)
+    && (s->bit_depth <= 8))
+    {
+      s->dev->buffer_image=SANE_TRUE;
+    }
+  else
+    {
+      s->dev->buffer_image=SANE_FALSE;
+    }
+
+  /* brigthness and contrast only for for 8 bit scans */
+  if(s->bit_depth <= 8)
+    {
+      s->dev->settings.contrast = (s->contrast * 127) / 100;
+      s->dev->settings.brightness = (s->brightness * 127) / 100;
+    }
+  else
+    {
+      s->dev->settings.contrast=0;
+      s->dev->settings.brightness=0;
+    }
+
+  /* cache expiration time */
+   s->dev->settings.expiration_time = s->expiration_time;
+
+  return status;
+}
+
+
+static SANE_Status
+create_bpp_list (Genesys_Scanner * s, SANE_Int * bpp)
+{
+  int count;
+
+  for (count = 0; bpp[count] != 0; count++)
+    ;
+  s->bpp_list[0] = count;
+  for (count = 0; bpp[count] != 0; count++)
+    {
+      s->bpp_list[s->bpp_list[0] - count] = bpp[count];
+    }
+  return SANE_STATUS_GOOD;
+}
+
+/** @brief this function initialize a gamma vector based on the ASIC:
+ * Set up a default gamma table vector based on device description
+ * gl646: 12 or 14 bits gamma table depending on GENESYS_FLAG_14BIT_GAMMA
+ * gl84x: 16 bits
+ * gl12x: 16 bits
+ * @param scanner pointer to scanner session to get options
+ * @param option option number of the gamma table to set
+ */
+static void
+init_gamma_vector_option (Genesys_Scanner * scanner, int option)
+{
+  /* the option is inactive until the custom gamma control
+   * is enabled */
+  scanner->opt[option].type = SANE_TYPE_INT;
+  scanner->opt[option].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
+  scanner->opt[option].unit = SANE_UNIT_NONE;
+  scanner->opt[option].constraint_type = SANE_CONSTRAINT_RANGE;
+  if (scanner->dev->model->asic_type == GENESYS_GL646)
+    {
+      if ((scanner->dev->model->flags & GENESYS_FLAG_14BIT_GAMMA) != 0)
+	{
+	  scanner->opt[option].size = 16384 * sizeof (SANE_Word);
+	  scanner->opt[option].constraint.range = &u14_range;
+	}
+      else
+	{			/* 12 bits gamma tables */
+	  scanner->opt[option].size = 4096 * sizeof (SANE_Word);
+	  scanner->opt[option].constraint.range = &u12_range;
+	}
+    }
+  else
+    {				/* other asics have 16 bits words gamma table */
+      scanner->opt[option].size = 256 * sizeof (SANE_Word);
+      scanner->opt[option].constraint.range = &u16_range;
+    }
+}
+
+/**
+ * allocate a geometry range
+ * @param size maximum size of the range
+ * @return a pointer to a valid range or NULL
+ */
+static SANE_Range *create_range(SANE_Fixed size)
+{
+SANE_Range *range=NULL;
+
+  range=(SANE_Range *)malloc(sizeof(SANE_Range));
+  if(range!=NULL)
+    {
+      range->min = SANE_FIX (0.0);
+      range->max = size;
+      range->quant = SANE_FIX (0.0);
+    }
+  return range;
+}
+
+/** @brief generate calibration cache file nam
+ * Generates the calibration cache file name to use.
+ * Tries to store the chache in $HOME/.sane or
+ * then fallbacks to $TMPDIR or TMP. The filename
+ * uses the model name if only one scanner is plugged
+ * else is uses the device name when several identical
+ * scanners are in use.
+ * @param currdev current scanner device
+ * @return an allocated string containing a file name
+ */
+static char *calibration_filename(Genesys_Device *currdev)
+{
+  char *tmpstr;
+  char *ptr;
+  char filename[80];
+  unsigned int count;
+  unsigned int i;
+
+  /* allocate space for result */
+  tmpstr = (char*) malloc(PATH_MAX);
+  if(tmpstr==NULL)
+    {
+      return NULL;
+    }
+
+  /* first compute the DIR where we can store cache:
+   * 1 - home dir
+   * 2 - $TMPDIR
+   * 3 - $TMP
+   * 4 - tmp dir
+   * 5 - temp dir
+   * 6 - then resort to current dir
+   */
+  ptr = getenv ("HOME");
+  if(ptr==NULL)
+    {
+      ptr = getenv ("USERPROFILE");
+    }
+  if(ptr==NULL)
+    {
+      ptr = getenv ("TMPDIR");
+    }
+  if(ptr==NULL)
+    {
+      ptr = getenv ("TMP");
+    }
+
+  /* now choose filename:
+   * 1 - if only one scanner, name of the model
+   * 2 - if several scanners of the same model, use device name,
+   *     replacing special chars
+   */
+  count=0;
+  /* count models of the same names if several scanners attached */
+    if(s_devices->size() > 1) {
+        for (const auto& dev : *s_devices) {
+            if (dev.model->model_id == currdev->model->model_id) {
+                count++;
+            }
+        }
+    }
+  if(count>1)
+    {
+      snprintf(filename,sizeof(filename),"%s.cal",currdev->file_name);
+      for(i=0;i<strlen(filename);i++)
+        {
+          if(filename[i]==':'||filename[i]==PATH_SEP)
+            {
+              filename[i]='_';
+            }
+        }
+    }
+  else
+    {
+      snprintf(filename,sizeof(filename),"%s.cal",currdev->model->name);
+    }
+
+  /* build final final name : store dir + filename */
+  if (NULL == ptr)
+    {
+      snprintf (tmpstr, PATH_MAX, "%s", filename);
+    }
+  else
+    {
+#ifdef HAVE_MKDIR
+      /* make sure .sane directory exists in existing store dir */
+      snprintf (tmpstr, PATH_MAX, "%s%c.sane", ptr, PATH_SEP);
+      mkdir(tmpstr,0700);
+#endif
+      snprintf (tmpstr, PATH_MAX, "%s%c.sane%c%s", ptr, PATH_SEP, PATH_SEP, filename);
+    }
+
+  DBG(DBG_info, "%s: calibration filename >%s<\n", __func__, tmpstr);
+
+  return tmpstr;
+}
+
+
+static SANE_Status
+init_options (Genesys_Scanner * s)
+{
+  SANE_Int option, count, min_dpi;
+  SANE_Status status = SANE_STATUS_GOOD;
+  SANE_Word *dpi_list;
+  Genesys_Model *model = s->dev->model;
+  SANE_Range *x_range, *y_range;
+
+  DBGSTART;
+
+  memset (s->opt, 0, sizeof (s->opt));
+
+  for (option = 0; option < NUM_OPTIONS; ++option)
+    {
+      s->opt[option].size = sizeof (SANE_Word);
+      s->opt[option].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+    }
+  s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+  s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+
+  /* "Mode" group: */
+  s->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
+  s->opt[OPT_MODE_GROUP].desc = "";
+  s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_MODE_GROUP].size = 0;
+  s->opt[OPT_MODE_GROUP].cap = 0;
+  s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* scan mode */
+  s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
+  s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
+  s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
+  s->opt[OPT_MODE].type = SANE_TYPE_STRING;
+  s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_MODE].size = max_string_size (mode_list);
+  s->opt[OPT_MODE].constraint.string_list = mode_list;
+  s->mode = SANE_VALUE_SCAN_MODE_GRAY;
+
+  /* scan source */
+  s->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].type = SANE_TYPE_STRING;
+  s->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_SOURCE].size = max_string_size (source_list);
+  s->opt[OPT_SOURCE].constraint.string_list = source_list;
+  s->source = STR_FLATBED;
+  if (model->flags & GENESYS_FLAG_HAS_UTA)
+    {
+        ENABLE (OPT_SOURCE);
+        if (model->flags & GENESYS_FLAG_HAS_UTA_INFRARED) {
+            s->opt[OPT_SOURCE].size = max_string_size(source_list_infrared);
+            s->opt[OPT_SOURCE].constraint.string_list = source_list_infrared;
+        }
+    }
+  else
+    {
+      DISABLE (OPT_SOURCE);
+    }
+
+  /* preview */
+  s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
+  s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+  s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
+  s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_PREVIEW].unit = SANE_UNIT_NONE;
+  s->opt[OPT_PREVIEW].constraint_type = SANE_CONSTRAINT_NONE;
+  s->preview = false;
+
+  /* bit depth */
+  s->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH;
+  s->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
+  s->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH;
+  s->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT;
+  s->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  s->opt[OPT_BIT_DEPTH].size = sizeof (SANE_Word);
+  s->opt[OPT_BIT_DEPTH].constraint.word_list = 0;
+  s->opt[OPT_BIT_DEPTH].constraint.word_list = s->bpp_list;
+  create_bpp_list (s, model->bpp_gray_values);
+  s->bit_depth = 8;
+  if (s->opt[OPT_BIT_DEPTH].constraint.word_list[0] < 2)
+    DISABLE (OPT_BIT_DEPTH);
+
+  /* resolution */
+  min_dpi=200000;
+  for (count = 0; model->xdpi_values[count] != 0; count++)
+    {
+      if(model->xdpi_values[count]<min_dpi)
+        {
+          min_dpi=model->xdpi_values[count];
+        }
+    }
+  dpi_list = (SANE_Word*) malloc((count + 1) * sizeof(SANE_Word));
+  if (!dpi_list)
+    return SANE_STATUS_NO_MEM;
+  dpi_list[0] = count;
+  for (count = 0; model->xdpi_values[count] != 0; count++)
+    dpi_list[count + 1] = model->xdpi_values[count];
+  s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
+  s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
+  s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  s->opt[OPT_RESOLUTION].constraint.word_list = dpi_list;
+  s->resolution = min_dpi;
+
+  /* "Geometry" group: */
+  s->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
+  s->opt[OPT_GEOMETRY_GROUP].desc = "";
+  s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
+  s->opt[OPT_GEOMETRY_GROUP].size = 0;
+  s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  x_range=create_range(model->x_size);
+  if(x_range==NULL)
+    {
+      return SANE_STATUS_NO_MEM;
+    }
+
+  y_range=create_range(model->y_size);
+  if(y_range==NULL)
+    {
+      return SANE_STATUS_NO_MEM;
+    }
+
+  /* top-left x */
+  s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+  s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+  s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+  s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+  s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+  s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_X].constraint.range = x_range;
+  s->pos_top_left_x = 0;
+
+  /* top-left y */
+  s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+  s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+  s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_Y].constraint.range = y_range;
+  s->pos_top_left_y = 0;
+
+  /* bottom-right x */
+  s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+  s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+  s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+  s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+  s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+  s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_X].constraint.range = x_range;
+  s->pos_bottom_right_x = x_range->max;
+
+  /* bottom-right y */
+  s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+  s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+  s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_Y].constraint.range = y_range;
+  s->pos_bottom_right_y = y_range->max;
+
+  /* "Enhancement" group: */
+  s->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
+  s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
+  s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
+  s->opt[OPT_ENHANCEMENT_GROUP].size = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* custom-gamma table */
+  s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
+  s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
+  s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
+  s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
+  s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_ADVANCED;
+  s->custom_gamma = false;
+
+  /* grayscale gamma vector */
+  s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
+  s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
+  s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
+  init_gamma_vector_option (s, OPT_GAMMA_VECTOR);
+
+  /* red gamma vector */
+  s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
+  s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
+  s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
+  init_gamma_vector_option (s, OPT_GAMMA_VECTOR_R);
+
+  /* green gamma vector */
+  s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
+  s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
+  s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
+  init_gamma_vector_option (s, OPT_GAMMA_VECTOR_G);
+
+  /* blue gamma vector */
+  s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
+  s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
+  s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
+  init_gamma_vector_option (s, OPT_GAMMA_VECTOR_B);
+
+  /* currently, there are only gamma table options in this group,
+   * so if the scanner doesn't support gamma table, disable the
+   * whole group */
+  if (!(model->flags & GENESYS_FLAG_CUSTOM_GAMMA))
+    {
+      s->opt[OPT_ENHANCEMENT_GROUP].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
+      DBG(DBG_info, "%s: custom gamma disabled\n", __func__);
+    }
+
+  /* software base image enhancements, these are consuming as many
+   * memory than used by the full scanned image and may fail at high
+   * resolution
+   */
+  /* software deskew */
+  s->opt[OPT_SWDESKEW].name = "swdeskew";
+  s->opt[OPT_SWDESKEW].title = "Software deskew";
+  s->opt[OPT_SWDESKEW].desc = "Request backend to rotate skewed pages digitally";
+  s->opt[OPT_SWDESKEW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_SWDESKEW].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+  s->swdeskew = false;
+
+  /* software deskew */
+  s->opt[OPT_SWDESPECK].name = "swdespeck";
+  s->opt[OPT_SWDESPECK].title = "Software despeck";
+  s->opt[OPT_SWDESPECK].desc = "Request backend to remove lone dots digitally";
+  s->opt[OPT_SWDESPECK].type = SANE_TYPE_BOOL;
+  s->opt[OPT_SWDESPECK].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+  s->swdespeck = false;
+
+  /* software despeckle radius */
+  s->opt[OPT_DESPECK].name = "despeck";
+  s->opt[OPT_DESPECK].title = "Software despeckle diameter";
+  s->opt[OPT_DESPECK].desc = "Maximum diameter of lone dots to remove from scan";
+  s->opt[OPT_DESPECK].type = SANE_TYPE_INT;
+  s->opt[OPT_DESPECK].unit = SANE_UNIT_NONE;
+  s->opt[OPT_DESPECK].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_DESPECK].constraint.range = &swdespeck_range;
+  s->opt[OPT_DESPECK].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED | SANE_CAP_INACTIVE;
+  s->despeck = 1;
+
+  /* crop by software */
+  s->opt[OPT_SWCROP].name = "swcrop";
+  s->opt[OPT_SWCROP].title = SANE_I18N ("Software crop");
+  s->opt[OPT_SWCROP].desc = SANE_I18N ("Request backend to remove border from pages digitally");
+  s->opt[OPT_SWCROP].type = SANE_TYPE_BOOL;
+  s->opt[OPT_SWCROP].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+  s->opt[OPT_SWCROP].unit = SANE_UNIT_NONE;
+  s->swcrop = false;
+
+  /* Software blank page skip */
+  s->opt[OPT_SWSKIP].name = "swskip";
+  s->opt[OPT_SWSKIP].title = SANE_I18N ("Software blank skip percentage");
+  s->opt[OPT_SWSKIP].desc = SANE_I18N("Request driver to discard pages with low numbers of dark pixels");
+  s->opt[OPT_SWSKIP].type = SANE_TYPE_FIXED;
+  s->opt[OPT_SWSKIP].unit = SANE_UNIT_PERCENT;
+  s->opt[OPT_SWSKIP].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_SWSKIP].constraint.range = &(percentage_range);
+  s->opt[OPT_SWSKIP].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+  s->swskip = 0;    // disable by default
+
+  /* Software Derotate */
+  s->opt[OPT_SWDEROTATE].name = "swderotate";
+  s->opt[OPT_SWDEROTATE].title = SANE_I18N ("Software derotate");
+  s->opt[OPT_SWDEROTATE].desc = SANE_I18N("Request driver to detect and correct 90 degree image rotation");
+  s->opt[OPT_SWDEROTATE].type = SANE_TYPE_BOOL;
+  s->opt[OPT_SWDEROTATE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+  s->opt[OPT_SWDEROTATE].unit = SANE_UNIT_NONE;
+  s->swderotate = false;
+
+  /* Software brightness */
+  s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
+  s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
+  s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BRIGHTNESS].constraint.range = &(enhance_range);
+  s->opt[OPT_BRIGHTNESS].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->brightness = 0;    // disable by default
+
+  /* Sowftware contrast */
+  s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
+  s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
+  s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
+  s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
+  s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
+  s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_CONTRAST].constraint.range = &(enhance_range);
+  s->opt[OPT_CONTRAST].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->contrast = 0;  // disable by default
+
+  /* "Extras" group: */
+  s->opt[OPT_EXTRAS_GROUP].title = SANE_I18N ("Extras");
+  s->opt[OPT_EXTRAS_GROUP].desc = "";
+  s->opt[OPT_EXTRAS_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_EXTRAS_GROUP].cap = SANE_CAP_ADVANCED;
+  s->opt[OPT_EXTRAS_GROUP].size = 0;
+  s->opt[OPT_EXTRAS_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* BW threshold */
+  s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
+  s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
+  s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
+  s->opt[OPT_THRESHOLD].type = SANE_TYPE_FIXED;
+  s->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT;
+  s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_THRESHOLD].constraint.range = &percentage_range;
+  s->threshold = SANE_FIX(50);
+
+  /* BW threshold curve */
+  s->opt[OPT_THRESHOLD_CURVE].name = "threshold-curve";
+  s->opt[OPT_THRESHOLD_CURVE].title = SANE_I18N ("Threshold curve");
+  s->opt[OPT_THRESHOLD_CURVE].desc = SANE_I18N ("Dynamic threshold curve, from light to dark, normally 50-65");
+  s->opt[OPT_THRESHOLD_CURVE].type = SANE_TYPE_INT;
+  s->opt[OPT_THRESHOLD_CURVE].unit = SANE_UNIT_NONE;
+  s->opt[OPT_THRESHOLD_CURVE].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_THRESHOLD_CURVE].constraint.range = &threshold_curve_range;
+  s->threshold_curve = 50;
+
+  /* dynamic linart */
+  s->opt[OPT_DISABLE_DYNAMIC_LINEART].name = "disable-dynamic-lineart";
+  s->opt[OPT_DISABLE_DYNAMIC_LINEART].title = SANE_I18N ("Disable dynamic lineart");
+  s->opt[OPT_DISABLE_DYNAMIC_LINEART].desc =
+    SANE_I18N ("Disable use of a software adaptive algorithm to generate lineart relying instead on hardware lineart.");
+  s->opt[OPT_DISABLE_DYNAMIC_LINEART].type = SANE_TYPE_BOOL;
+  s->opt[OPT_DISABLE_DYNAMIC_LINEART].unit = SANE_UNIT_NONE;
+  s->opt[OPT_DISABLE_DYNAMIC_LINEART].constraint_type = SANE_CONSTRAINT_NONE;
+  s->disable_dynamic_lineart = false;
+
+  /* fastmod is required for hw lineart to work */
+  if ((s->dev->model->asic_type == GENESYS_GL646)
+    &&(s->dev->model->motor_type != MOTOR_XP200))
+    {
+      s->opt[OPT_DISABLE_DYNAMIC_LINEART].cap = SANE_CAP_INACTIVE;
+    }
+
+  /* disable_interpolation */
+  s->opt[OPT_DISABLE_INTERPOLATION].name = "disable-interpolation";
+  s->opt[OPT_DISABLE_INTERPOLATION].title =
+    SANE_I18N ("Disable interpolation");
+  s->opt[OPT_DISABLE_INTERPOLATION].desc =
+    SANE_I18N
+    ("When using high resolutions where the horizontal resolution is smaller "
+     "than the vertical resolution this disables horizontal interpolation.");
+  s->opt[OPT_DISABLE_INTERPOLATION].type = SANE_TYPE_BOOL;
+  s->opt[OPT_DISABLE_INTERPOLATION].unit = SANE_UNIT_NONE;
+  s->opt[OPT_DISABLE_INTERPOLATION].constraint_type = SANE_CONSTRAINT_NONE;
+  s->disable_interpolation = false;
+
+  /* color filter */
+  s->opt[OPT_COLOR_FILTER].name = "color-filter";
+  s->opt[OPT_COLOR_FILTER].title = SANE_I18N ("Color filter");
+  s->opt[OPT_COLOR_FILTER].desc =
+    SANE_I18N
+    ("When using gray or lineart this option selects the used color.");
+  s->opt[OPT_COLOR_FILTER].type = SANE_TYPE_STRING;
+  s->opt[OPT_COLOR_FILTER].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  /* true gray not yet supported for GL847 and GL124 scanners */
+  if(!model->is_cis || model->asic_type==GENESYS_GL847 || model->asic_type==GENESYS_GL124)
+    {
+      s->opt[OPT_COLOR_FILTER].size = max_string_size (color_filter_list);
+      s->opt[OPT_COLOR_FILTER].constraint.string_list = color_filter_list;
+      s->color_filter = s->opt[OPT_COLOR_FILTER].constraint.string_list[1];
+    }
+  else
+    {
+      s->opt[OPT_COLOR_FILTER].size = max_string_size (cis_color_filter_list);
+      s->opt[OPT_COLOR_FILTER].constraint.string_list = cis_color_filter_list;
+      /* default to "None" ie true gray */
+      s->color_filter = s->opt[OPT_COLOR_FILTER].constraint.string_list[3];
+    }
+
+  /* no support for color filter for cis+gl646 scanners */
+  if (model->asic_type == GENESYS_GL646 && model->is_cis)
+    {
+      DISABLE (OPT_COLOR_FILTER);
+    }
+
+  /* calibration store file name */
+  s->opt[OPT_CALIBRATION_FILE].name = "calibration-file";
+  s->opt[OPT_CALIBRATION_FILE].title = SANE_I18N ("Calibration file");
+  s->opt[OPT_CALIBRATION_FILE].desc = SANE_I18N ("Specify the calibration file to use");
+  s->opt[OPT_CALIBRATION_FILE].type = SANE_TYPE_STRING;
+  s->opt[OPT_CALIBRATION_FILE].unit = SANE_UNIT_NONE;
+  s->opt[OPT_CALIBRATION_FILE].size = PATH_MAX;
+  s->opt[OPT_CALIBRATION_FILE].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED;
+  s->opt[OPT_CALIBRATION_FILE].constraint_type = SANE_CONSTRAINT_NONE;
+  s->calibration_file.clear();
+  /* disable option if ran as root */
+#ifdef HAVE_GETUID
+  if(geteuid()==0)
+    {
+      DISABLE (OPT_CALIBRATION_FILE);
+    }
+#endif
+
+  /* expiration time for calibration cache entries */
+  s->opt[OPT_EXPIRATION_TIME].name = "expiration-time";
+  s->opt[OPT_EXPIRATION_TIME].title = SANE_I18N ("Calibration cache expiration time");
+  s->opt[OPT_EXPIRATION_TIME].desc = SANE_I18N ("Time (in minutes) before a cached calibration expires. "
+     "A value of 0 means cache is not used. A negative value means cache never expires.");
+  s->opt[OPT_EXPIRATION_TIME].type = SANE_TYPE_INT;
+  s->opt[OPT_EXPIRATION_TIME].unit = SANE_UNIT_NONE;
+  s->opt[OPT_EXPIRATION_TIME].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_EXPIRATION_TIME].constraint.range = &expiration_range;
+  s->expiration_time = 60;  // 60 minutes by default
+
+  /* Powersave time (turn lamp off) */
+  s->opt[OPT_LAMP_OFF_TIME].name = "lamp-off-time";
+  s->opt[OPT_LAMP_OFF_TIME].title = SANE_I18N ("Lamp off time");
+  s->opt[OPT_LAMP_OFF_TIME].desc =
+    SANE_I18N
+    ("The lamp will be turned off after the given time (in minutes). "
+     "A value of 0 means, that the lamp won't be turned off.");
+  s->opt[OPT_LAMP_OFF_TIME].type = SANE_TYPE_INT;
+  s->opt[OPT_LAMP_OFF_TIME].unit = SANE_UNIT_NONE;
+  s->opt[OPT_LAMP_OFF_TIME].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_LAMP_OFF_TIME].constraint.range = &time_range;
+  s->lamp_off_time = 15;    // 15 minutes
+
+  /* turn lamp off during scan */
+  s->opt[OPT_LAMP_OFF].name = "lamp-off-scan";
+  s->opt[OPT_LAMP_OFF].title = SANE_I18N ("Lamp off during scan");
+  s->opt[OPT_LAMP_OFF].desc = SANE_I18N ("The lamp will be turned off during scan. ");
+  s->opt[OPT_LAMP_OFF].type = SANE_TYPE_BOOL;
+  s->opt[OPT_LAMP_OFF].unit = SANE_UNIT_NONE;
+  s->opt[OPT_LAMP_OFF].constraint_type = SANE_CONSTRAINT_NONE;
+  s->lamp_off = false;
+
+  s->opt[OPT_SENSOR_GROUP].title = SANE_TITLE_SENSORS;
+  s->opt[OPT_SENSOR_GROUP].desc = SANE_DESC_SENSORS;
+  s->opt[OPT_SENSOR_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_SENSOR_GROUP].cap = SANE_CAP_ADVANCED;
+  s->opt[OPT_SENSOR_GROUP].size = 0;
+  s->opt[OPT_SENSOR_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  s->opt[OPT_SCAN_SW].name = SANE_NAME_SCAN;
+  s->opt[OPT_SCAN_SW].title = SANE_TITLE_SCAN;
+  s->opt[OPT_SCAN_SW].desc = SANE_DESC_SCAN;
+  s->opt[OPT_SCAN_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_SCAN_SW].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_SCAN_SW)
+    s->opt[OPT_SCAN_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_SCAN_SW].cap = SANE_CAP_INACTIVE;
+
+  /* SANE_NAME_FILE is not for buttons */
+  s->opt[OPT_FILE_SW].name = "file";
+  s->opt[OPT_FILE_SW].title = SANE_I18N ("File button");
+  s->opt[OPT_FILE_SW].desc = SANE_I18N ("File button");
+  s->opt[OPT_FILE_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_FILE_SW].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_FILE_SW)
+    s->opt[OPT_FILE_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_FILE_SW].cap = SANE_CAP_INACTIVE;
+
+  s->opt[OPT_EMAIL_SW].name = SANE_NAME_EMAIL;
+  s->opt[OPT_EMAIL_SW].title = SANE_TITLE_EMAIL;
+  s->opt[OPT_EMAIL_SW].desc = SANE_DESC_EMAIL;
+  s->opt[OPT_EMAIL_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_EMAIL_SW].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_EMAIL_SW)
+    s->opt[OPT_EMAIL_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_EMAIL_SW].cap = SANE_CAP_INACTIVE;
+
+  s->opt[OPT_COPY_SW].name = SANE_NAME_COPY;
+  s->opt[OPT_COPY_SW].title = SANE_TITLE_COPY;
+  s->opt[OPT_COPY_SW].desc = SANE_DESC_COPY;
+  s->opt[OPT_COPY_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_COPY_SW].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_COPY_SW)
+    s->opt[OPT_COPY_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_COPY_SW].cap = SANE_CAP_INACTIVE;
+
+  s->opt[OPT_PAGE_LOADED_SW].name = SANE_NAME_PAGE_LOADED;
+  s->opt[OPT_PAGE_LOADED_SW].title = SANE_TITLE_PAGE_LOADED;
+  s->opt[OPT_PAGE_LOADED_SW].desc = SANE_DESC_PAGE_LOADED;
+  s->opt[OPT_PAGE_LOADED_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_PAGE_LOADED_SW].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_PAGE_LOADED_SW)
+    s->opt[OPT_PAGE_LOADED_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_PAGE_LOADED_SW].cap = SANE_CAP_INACTIVE;
+
+  /* OCR button */
+  s->opt[OPT_OCR_SW].name = "ocr";
+  s->opt[OPT_OCR_SW].title = SANE_I18N ("OCR button");
+  s->opt[OPT_OCR_SW].desc = SANE_I18N ("OCR button");
+  s->opt[OPT_OCR_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_OCR_SW].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_OCR_SW)
+    s->opt[OPT_OCR_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_OCR_SW].cap = SANE_CAP_INACTIVE;
+
+  /* power button */
+  s->opt[OPT_POWER_SW].name = "power";
+  s->opt[OPT_POWER_SW].title = SANE_I18N ("Power button");
+  s->opt[OPT_POWER_SW].desc = SANE_I18N ("Power button");
+  s->opt[OPT_POWER_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_POWER_SW].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_POWER_SW)
+    s->opt[OPT_POWER_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    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;
+
+  /* calibration needed */
+  s->opt[OPT_NEED_CALIBRATION_SW].name = "need-calibration";
+  s->opt[OPT_NEED_CALIBRATION_SW].title = SANE_I18N ("Need calibration");
+  s->opt[OPT_NEED_CALIBRATION_SW].desc = SANE_I18N ("The scanner needs calibration for the current settings");
+  s->opt[OPT_NEED_CALIBRATION_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_NEED_CALIBRATION_SW].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_CALIBRATE)
+    s->opt[OPT_NEED_CALIBRATION_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_NEED_CALIBRATION_SW].cap = SANE_CAP_INACTIVE;
+
+  /* button group */
+  s->opt[OPT_BUTTON_GROUP].title = SANE_I18N ("Buttons");
+  s->opt[OPT_BUTTON_GROUP].desc = "";
+  s->opt[OPT_BUTTON_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_BUTTON_GROUP].cap = SANE_CAP_ADVANCED;
+  s->opt[OPT_BUTTON_GROUP].size = 0;
+  s->opt[OPT_BUTTON_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* calibrate button */
+  s->opt[OPT_CALIBRATE].name = "calibrate";
+  s->opt[OPT_CALIBRATE].title = SANE_I18N ("Calibrate");
+  s->opt[OPT_CALIBRATE].desc =
+    SANE_I18N ("Start calibration using special sheet");
+  s->opt[OPT_CALIBRATE].type = SANE_TYPE_BUTTON;
+  s->opt[OPT_CALIBRATE].unit = SANE_UNIT_NONE;
+  if (model->buttons & GENESYS_HAS_CALIBRATE)
+    s->opt[OPT_CALIBRATE].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED |
+      SANE_CAP_AUTOMATIC;
+  else
+    s->opt[OPT_CALIBRATE].cap = SANE_CAP_INACTIVE;
+
+  /* clear calibration cache button */
+  s->opt[OPT_CLEAR_CALIBRATION].name = "clear-calibration";
+  s->opt[OPT_CLEAR_CALIBRATION].title = SANE_I18N ("Clear calibration");
+  s->opt[OPT_CLEAR_CALIBRATION].desc = SANE_I18N ("Clear calibration cache");
+  s->opt[OPT_CLEAR_CALIBRATION].type = SANE_TYPE_BUTTON;
+  s->opt[OPT_CLEAR_CALIBRATION].unit = SANE_UNIT_NONE;
+  s->opt[OPT_CLEAR_CALIBRATION].size = 0;
+  s->opt[OPT_CLEAR_CALIBRATION].constraint_type = SANE_CONSTRAINT_NONE;
+  s->opt[OPT_CLEAR_CALIBRATION].cap =
+    SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED;
+
+  /* force calibration cache button */
+  s->opt[OPT_FORCE_CALIBRATION].name = "force-calibration";
+  s->opt[OPT_FORCE_CALIBRATION].title = SANE_I18N("Force calibration");
+  s->opt[OPT_FORCE_CALIBRATION].desc = SANE_I18N("Force calibration ignoring all and any calibration caches");
+  s->opt[OPT_FORCE_CALIBRATION].type = SANE_TYPE_BUTTON;
+  s->opt[OPT_FORCE_CALIBRATION].unit = SANE_UNIT_NONE;
+  s->opt[OPT_FORCE_CALIBRATION].size = 0;
+  s->opt[OPT_FORCE_CALIBRATION].constraint_type = SANE_CONSTRAINT_NONE;
+  s->opt[OPT_FORCE_CALIBRATION].cap =
+    SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED;
+
+  RIE (calc_parameters (s));
+
+  DBGCOMPLETED;
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Bool present;
+
+// this function is passed to C API, it must not throw
+static SANE_Status
+check_present (SANE_String_Const devname) noexcept
+{
+  present=SANE_TRUE;
+  DBG(DBG_io, "%s: %s detected.\n", __func__, devname);
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach (SANE_String_Const devname, Genesys_Device ** devp, SANE_Bool may_wait)
+{
+    DBG_HELPER(dbg);
+
+  Genesys_Device *dev = 0;
+  unsigned int i;
+
+
+  DBG(DBG_proc, "%s: start: devp %s NULL, may_wait = %d\n", __func__, devp ? "!=" : "==", may_wait);
+
+  if (devp)
+    *devp = 0;
+
+  if (!devname)
+    {
+      DBG(DBG_error, "%s: devname == NULL\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+
+    for (auto& dev : *s_devices) {
+        if (strcmp(dev.file_name, devname) == 0) {
+	  if (devp)
+                *devp = &dev;
+	  DBG(DBG_info, "%s: device `%s' was already in device list\n", __func__, devname);
+	  return SANE_STATUS_GOOD;
+	}
+    }
+
+  DBG(DBG_info, "%s: trying to open device `%s'\n", __func__, devname);
+
+    UsbDevice usb_dev;
+
+    usb_dev.open(devname);
+    DBG(DBG_info, "%s: device `%s' successfully opened\n", __func__, devname);
+
+    int vendor, product;
+    usb_dev.get_vendor_product(vendor, product);
+
+  /* KV-SS080 is an auxiliary device which requires a master device to be here */
+  if(vendor == 0x04da && product == 0x100f)
+    {
+      present=SANE_FALSE;
+      sanei_usb_find_devices (vendor, 0x1006, check_present);
+      sanei_usb_find_devices (vendor, 0x1007, check_present);
+      sanei_usb_find_devices (vendor, 0x1010, check_present);
+        if (present == SANE_FALSE) {
+            throw SaneException("master device not present");
+        }
+    }
+
+  bool found_dev = false;
+  for (i = 0; i < MAX_SCANNERS && genesys_usb_device_list[i].model != 0; i++)
+    {
+      if (vendor == genesys_usb_device_list[i].vendor &&
+	  product == genesys_usb_device_list[i].product)
+	{
+            found_dev = true;
+            break;
+	}
+    }
+
+    if (!found_dev) {
+      DBG(DBG_error, "%s: vendor 0x%xd product 0x%xd is not supported by this backend\n", __func__,
+	   vendor, product);
+      return SANE_STATUS_INVAL;
+    }
+
+    char* new_devname = strdup (devname);
+    if (!new_devname) {
+        return SANE_STATUS_NO_MEM;
+    }
+
+    s_devices->emplace_back();
+    dev = &s_devices->back();
+    dev->file_name = new_devname;
+
+  dev->model = genesys_usb_device_list[i].model;
+  dev->vendorId = genesys_usb_device_list[i].vendor;
+  dev->productId = genesys_usb_device_list[i].product;
+  dev->usb_mode = 0;            /* i.e. unset */
+  dev->already_initialized = SANE_FALSE;
+
+  DBG(DBG_info, "%s: found %s flatbed scanner %s at %s\n", __func__, dev->model->vendor,
+      dev->model->model, dev->file_name);
+
+    if (devp) {
+        *devp = dev;
+    }
+
+    usb_dev.close();
+    return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach_one_device_impl(SANE_String_Const devname)
+{
+  Genesys_Device *dev;
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  RIE (attach (devname, &dev, SANE_FALSE));
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status attach_one_device(SANE_String_Const devname)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return attach_one_device_impl(devname);
+    });
+}
+
+/* configuration framework functions */
+
+// this function is passed to C API, it must not throw
+static SANE_Status
+config_attach_genesys(SANEI_Config __sane_unused__ *config, const char *devname) noexcept
+{
+  /* the devname has been processed and is ready to be used
+   * directly. Since the backend is an USB only one, we can
+   * call sanei_usb_attach_matching_devices straight */
+  sanei_usb_attach_matching_devices (devname, attach_one_device);
+
+  return SANE_STATUS_GOOD;
+}
+
+/* probes for scanner to attach to the backend */
+static SANE_Status
+probe_genesys_devices (void)
+{
+  SANEI_Config config;
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  DBGSTART;
+
+  /* set configuration options structure : no option for this backend */
+  config.descriptors = NULL;
+  config.values = NULL;
+  config.count = 0;
+
+  /* generic configure and attach function */
+  status = sanei_configure_attach (GENESYS_CONFIG_FILE, &config,
+				   config_attach_genesys);
+
+  DBG(DBG_info, "%s: %d devices currently attached\n", __func__, (int) s_devices->size());
+
+  DBGCOMPLETED;
+
+  return status;
+}
+
+/**
+ * This should be changed if one of the substructures of
+   Genesys_Calibration_Cache change, but it must be changed if there are
+   changes that don't change size -- at least for now, as we store most
+   of Genesys_Calibration_Cache as is.
+*/
+static const char* CALIBRATION_IDENT = "sane_genesys";
+static const int CALIBRATION_VERSION = 2;
+
+bool read_calibration(std::istream& str, Genesys_Device::Calibration& calibration,
+                      const std::string& path)
+{
+    std::string ident;
+    serialize(str, ident);
+
+    if (ident != CALIBRATION_IDENT) {
+        DBG(DBG_info, "%s: Incorrect calibration file '%s' header\n", __func__, path.c_str());
+        return false;
+    }
+
+    size_t version;
+    serialize(str, version);
+
+    if (version != CALIBRATION_VERSION) {
+        DBG(DBG_info, "%s: Incorrect calibration file '%s' version\n", __func__, path.c_str());
+        return false;
+    }
+
+    calibration.clear();
+    serialize(str, calibration);
+    return true;
+}
+
+/**
+ * reads previously cached calibration data
+ * from file defined in dev->calib_file
+ */
+static bool sanei_genesys_read_calibration(Genesys_Device::Calibration& calibration,
+                                           const std::string& path)
+{
+    DBG_HELPER(dbg);
+
+    std::ifstream str;
+    str.open(path);
+    if (!str.is_open()) {
+        DBG(DBG_info, "%s: Cannot open %s\n", __func__, path.c_str());
+        return false;
+    }
+
+    return read_calibration(str, calibration, path);
+}
+
+void write_calibration(std::ostream& str, Genesys_Device::Calibration& calibration)
+{
+    std::string ident = CALIBRATION_IDENT;
+    serialize(str, ident);
+    size_t version = CALIBRATION_VERSION;
+    serialize(str, version);
+    serialize_newline(str);
+    serialize(str, calibration);
+}
+
+static void write_calibration(Genesys_Device::Calibration& calibration, const std::string& path)
+{
+    DBG_HELPER(dbg);
+
+    std::ofstream str;
+    str.open(path);
+    if (!str.is_open()) {
+        throw SaneException("Cannot open calibration for writing");
+    }
+    write_calibration(str, calibration);
+}
+
+/** @brief buffer scanned picture
+ * In order to allow digital processing, we must be able to put all the
+ * scanned picture in a buffer.
+ */
+static SANE_Status
+genesys_buffer_image(Genesys_Scanner *s)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  size_t maximum;     /**> maximum bytes size of the scan */
+  size_t len;	      /**> length of scanned data read */
+  size_t total;	      /**> total of butes read */
+  size_t size;	      /**> size of image buffer */
+  size_t read_size;   /**> size of reads */
+  int lines;	      /** number of lines of the scan */
+  Genesys_Device *dev = s->dev;
+
+  /* compute maximum number of lines for the scan */
+  if (s->params.lines > 0)
+    {
+      lines = s->params.lines;
+    }
+  else
+    {
+      lines =
+	(SANE_UNFIX (dev->model->y_size) * dev->settings.yres) / MM_PER_INCH;
+    }
+  DBG(DBG_info, "%s: buffering %d lines of %d bytes\n", __func__, lines,
+      s->params.bytes_per_line);
+
+  /* maximum bytes to read */
+  maximum = s->params.bytes_per_line * lines;
+  if(s->dev->settings.dynamic_lineart==SANE_TRUE)
+    {
+      maximum *= 8;
+    }
+
+  /* initial size of the read buffer */
+  size =
+    ((2048 * 2048) / s->params.bytes_per_line) * s->params.bytes_per_line;
+
+  /* read size */
+  read_size = size / 2;
+
+  dev->img_buffer.resize(size);
+
+  /* loop reading data until we reach maximum or EOF */
+  total = 0;
+  while (total < maximum && status != SANE_STATUS_EOF)
+    {
+      len = size - maximum;
+      if (len > read_size)
+	{
+	  len = read_size;
+	}
+
+      status = genesys_read_ordered_data(dev, dev->img_buffer.data() + total, &len);
+      if (status != SANE_STATUS_EOF && status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: %s buffering failed\n", __func__, sane_strstatus(status));
+          return status;
+	}
+      total += len;
+
+      /* do we need to enlarge read buffer ? */
+      if (total + read_size > size && status != SANE_STATUS_EOF)
+	{
+	  size += read_size;
+          dev->img_buffer.resize(size);
+	}
+    }
+
+  /* since digital processing is going to take place,
+   * issue head parking command so that the head move while
+   * computing so we can save time
+   */
+  if (dev->model->is_sheetfed == SANE_FALSE &&
+      dev->parking == SANE_FALSE)
+    {
+      dev->model->cmd_set->slow_back_home (dev, dev->model->flags & GENESYS_FLAG_MUST_WAIT);
+      dev->parking = !(s->dev->model->flags & GENESYS_FLAG_MUST_WAIT);
+    }
+
+  /* in case of dynamic lineart, we have buffered gray data which
+   * must be converted to lineart first */
+  if(s->dev->settings.dynamic_lineart==SANE_TRUE)
+    {
+      total/=8;
+      std::vector<uint8_t> lineart(total);
+
+      genesys_gray_lineart (dev,
+                            dev->img_buffer.data(),
+                            lineart.data(),
+                            dev->settings.pixels,
+                            (total*8)/dev->settings.pixels,
+                            dev->settings.threshold);
+      dev->img_buffer = lineart;
+    }
+
+  /* update counters */
+  dev->total_bytes_to_read = total;
+  dev->total_bytes_read = 0;
+
+  /* update params */
+  s->params.lines = total / s->params.bytes_per_line;
+  if (DBG_LEVEL >= DBG_io2)
+    {
+      sanei_genesys_write_pnm_file("gl_unprocessed.pnm", dev->img_buffer.data(), s->params.depth,
+                                   s->params.format==SANE_FRAME_RGB ? 3 : 1,
+                                   s->params.pixels_per_line, s->params.lines);
+    }
+
+  return SANE_STATUS_GOOD;
+}
+
+/* -------------------------- SANE API functions ------------------------- */
+
+SANE_Status
+sane_init_impl(SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  DBG_INIT ();
+  DBG(DBG_init, "SANE Genesys backend version %d.%d from %s\n",
+      SANE_CURRENT_MAJOR, V_MINOR, PACKAGE_STRING);
+#ifdef HAVE_LIBUSB
+  DBG(DBG_init, "SANE Genesys backend built with libusb-1.0\n");
+#endif
+#ifdef HAVE_LIBUSB_LEGACY
+  DBG(DBG_init, "SANE Genesys backend built with libusb\n");
+#endif
+
+  if (version_code)
+    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+
+  DBG(DBG_proc, "%s: authorize %s null\n", __func__, authorize ? "!=" : "==");
+
+  /* init usb use */
+  sanei_usb_init ();
+
+  /* init sanei_magic */
+  sanei_magic_init();
+
+  s_scanners.init();
+  s_devices.init();
+  s_sane_devices.init();
+  s_sane_devices_ptrs.init();
+  genesys_init_sensor_tables();
+  genesys_init_frontend_tables();
+
+  DBG(DBG_info, "%s: %s endian machine\n", __func__,
+#ifdef WORDS_BIGENDIAN
+       "big"
+#else
+       "little"
+#endif
+    );
+
+  /* cold-plug case :detection of allready connected scanners */
+  status = probe_genesys_devices ();
+
+  DBGCOMPLETED;
+
+  return status;
+}
+
+
+extern "C" SANE_Status sane_init(SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_init_impl(version_code, authorize);
+    });
+}
+
+void
+sane_exit_impl(void)
+{
+  DBGSTART;
+
+  sanei_usb_exit();
+
+  run_functions_at_backend_exit();
+
+  DBGCOMPLETED;
+}
+
+void sane_exit()
+{
+    catch_all_exceptions(__func__, [](){ sane_exit_impl(); });
+}
+
+SANE_Status
+sane_get_devices_impl(const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  DBG(DBG_proc, "%s: start: local_only = %s\n", __func__,
+      local_only == SANE_TRUE ? "true" : "false");
+
+  /* hot-plug case : detection of newly connected scanners */
+  sanei_usb_scan_devices ();
+  probe_genesys_devices ();
+
+    s_sane_devices->clear();
+    s_sane_devices_ptrs->clear();
+    s_sane_devices->reserve(s_devices->size());
+    s_sane_devices_ptrs->reserve(s_devices->size() + 1);
+
+    for (auto dev_it = s_devices->begin(); dev_it != s_devices->end();) {
+        present = SANE_FALSE;
+        sanei_usb_find_devices(dev_it->vendorId, dev_it->productId, check_present);
+        if (present) {
+            s_sane_devices->emplace_back();
+            auto& sane_device = s_sane_devices->back();
+            sane_device.name = dev_it->file_name;
+            sane_device.vendor = dev_it->model->vendor;
+            sane_device.model = dev_it->model->model;
+            sane_device.type = "flatbed scanner";
+            s_sane_devices_ptrs->push_back(&sane_device);
+            dev_it++;
+        } else {
+            dev_it = s_devices->erase(dev_it);
+        }
+    }
+    s_sane_devices_ptrs->push_back(nullptr);
+
+    *((SANE_Device ***)device_list) = s_sane_devices_ptrs->data();
+
+  DBGCOMPLETED;
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status sane_get_devices(const SANE_Device *** device_list, SANE_Bool local_only)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_get_devices_impl(device_list, local_only);
+    });
+}
+
+SANE_Status
+sane_open_impl(SANE_String_Const devicename, SANE_Handle * handle)
+{
+    DBG_HELPER(dbg);
+  Genesys_Device *dev = nullptr;
+  SANE_Status status = SANE_STATUS_GOOD;
+  char *tmpstr;
+
+    DBG(DBG_proc, "%s: devicename = `%s')\n", __func__, devicename);
+
+  /* devicename="" or devicename="genesys" are default values that use
+   * first available device
+   */
+  if (devicename[0] && strcmp ("genesys", devicename) != 0)
+    {
+      /* search for the given devicename in the device list */
+        for (auto& d : *s_devices) {
+            if (strcmp(d.file_name, devicename) == 0) {
+                dev = &d;
+                break;
+            }
+        }
+
+      if (!dev)
+	{
+	  DBG(DBG_info, "%s: couldn't find `%s' in devlist, trying attach\n", __func__, devicename);
+	  RIE (attach (devicename, &dev, SANE_TRUE));
+	}
+      else
+        DBG(DBG_info, "%s: found `%s' in devlist\n", __func__, dev->model->name);
+    }
+  else
+    {
+        // empty devicename or "genesys" -> use first device
+        if (!s_devices->empty()) {
+            dev = &s_devices->front();
+            devicename = dev->file_name;
+            DBG(DBG_info, "%s: empty devicename, trying `%s'\n", __func__, devicename);
+	}
+    }
+
+  if (!dev)
+    return SANE_STATUS_INVAL;
+
+  if (dev->model->flags & GENESYS_FLAG_UNTESTED)
+    {
+      DBG(DBG_error0, "WARNING: Your scanner is not fully supported or at least \n");
+      DBG(DBG_error0, "         had only limited testing. Please be careful and \n");
+      DBG(DBG_error0, "         report any failure/success to \n");
+      DBG(DBG_error0, "         sane-devel@alioth-lists.debian.net. Please provide as many\n");
+      DBG(DBG_error0, "         details as possible, e.g. the exact name of your\n");
+      DBG(DBG_error0, "         scanner and what does (not) work.\n");
+    }
+
+    dbg.vstatus("open device '%s'", dev->file_name);
+    dev->usb_dev.open(dev->file_name);
+    dbg.clear();
+
+
+  s_scanners->push_back(Genesys_Scanner());
+  auto* s = &s_scanners->back();
+
+  s->dev = dev;
+  s->scanning = SANE_FALSE;
+  s->dev->parking = SANE_FALSE;
+  s->dev->read_active = SANE_FALSE;
+  s->dev->force_calibration = 0;
+  s->dev->line_interp = 0;
+  s->dev->line_count = 0;
+  s->dev->segnb = 0;
+  s->dev->binary=NULL;
+
+  *handle = s;
+
+  if (!dev->already_initialized)
+    sanei_genesys_init_structs (dev);
+
+  RIE (init_options (s));
+
+  if (sanei_genesys_init_cmd_set (s->dev) != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error0, "This device doesn't have a valid command set!!\n");
+      return SANE_STATUS_IO_ERROR;
+    }
+
+  // FIXME: we create sensor tables for the sensor, this should happen when we know which sensor
+  // we will select
+  RIE (dev->model->cmd_set->init(dev));
+
+  /* some hardware capabilities are detected through sensors */
+  RIE (s->dev->model->cmd_set->update_hardware_sensors (s));
+
+  /* here is the place to fetch a stored calibration cache */
+  if (s->dev->force_calibration == 0)
+    {
+      tmpstr=calibration_filename(s->dev);
+      s->calibration_file = tmpstr;
+      s->dev->calib_file = tmpstr;
+      DBG(DBG_info, "%s: Calibration filename set to:\n", __func__);
+      DBG(DBG_info, "%s: >%s<\n", __func__, s->dev->calib_file.c_str());
+      free(tmpstr);
+
+        catch_all_exceptions(__func__, [&]()
+        {
+            sanei_genesys_read_calibration(s->dev->calibration_cache, s->dev->calib_file);
+        });
+    }
+
+    return SANE_STATUS_GOOD;
+}
+
+SANE_Status sane_open(SANE_String_Const devicename, SANE_Handle* handle)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_open_impl(devicename, handle);
+    });
+}
+
+void
+sane_close_impl(SANE_Handle handle)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  DBGSTART;
+
+  /* remove handle from list of open handles: */
+  auto it = s_scanners->end();
+  for (auto it2 = s_scanners->begin(); it2 != s_scanners->end(); it2++)
+    {
+      if (&*it2 == handle) {
+          it = it2;
+          break;
+        }
+    }
+  if (it == s_scanners->end())
+    {
+      DBG(DBG_error, "%s: invalid handle %p\n", __func__, handle);
+      return;			/* oops, not a handle we know about */
+    }
+
+  Genesys_Scanner* s = &*it;
+
+  /* eject document for sheetfed scanners */
+  if (s->dev->model->is_sheetfed == SANE_TRUE)
+    {
+      s->dev->model->cmd_set->eject_document (s->dev);
+    }
+  else
+    {
+      /* in case scanner is parking, wait for the head
+       * to reach home position */
+      if(s->dev->parking==SANE_TRUE)
+        {
+          status = sanei_genesys_wait_for_home (s->dev);
+          if (status != SANE_STATUS_GOOD)
+            {
+              DBG(DBG_error, "%s: failed to wait for head to park: %s\n", __func__,
+                  sane_strstatus(status));
+            }
+        }
+    }
+
+  /* enable power saving before leaving */
+  status = s->dev->model->cmd_set->save_power (s->dev, SANE_TRUE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "%s: failed to enable power saving mode: %s\n", __func__,
+          sane_strstatus(status));
+    }
+
+    // here is the place to store calibration cache
+    if (s->dev->force_calibration == 0) {
+        catch_all_exceptions(__func__, [&](){ write_calibration(s->dev->calibration_cache,
+                                                                s->dev->calib_file); });
+    }
+
+  s->dev->already_initialized = SANE_FALSE;
+
+   /* for an handful of bytes .. */
+  free ((void *)(size_t)s->opt[OPT_RESOLUTION].constraint.word_list);
+  free ((void *)(size_t)s->opt[OPT_TL_X].constraint.range);
+  free ((void *)(size_t)s->opt[OPT_TL_Y].constraint.range);
+
+  s->dev->clear();
+
+  /* LAMP OFF : same register across all the ASICs */
+  sanei_genesys_write_register (s->dev, 0x03, 0x00);
+
+    catch_all_exceptions(__func__, [&](){ s->dev->usb_dev.clear_halt(); });
+
+    // we need this to avoid these ASIC getting stuck in bulk writes
+    catch_all_exceptions(__func__, [&](){ s->dev->usb_dev.reset(); });
+
+    // not freeing s->dev because it's in the dev list
+    catch_all_exceptions(__func__, [&](){ s->dev->usb_dev.close(); });
+
+  s_scanners->erase(it);
+
+  DBGCOMPLETED;
+}
+
+void sane_close(SANE_Handle handle)
+{
+    catch_all_exceptions(__func__, [=]()
+    {
+        sane_close_impl(handle);
+    });
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor_impl(SANE_Handle handle, SANE_Int option)
+{
+  Genesys_Scanner *s = (Genesys_Scanner*) handle;
+
+  if ((unsigned) option >= NUM_OPTIONS)
+    return 0;
+  DBG(DBG_io2, "%s: option = %s (%d)\n", __func__, s->opt[option].name, option);
+  return s->opt + option;
+}
+
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor(SANE_Handle handle, SANE_Int option)
+{
+    const SANE_Option_Descriptor* ret = NULL;
+    catch_all_exceptions(__func__, [&]()
+    {
+        ret = sane_get_option_descriptor_impl(handle, option);
+    });
+    return ret;
+}
+
+/* gets an option , called by sane_control_option */
+static SANE_Status
+get_option_value (Genesys_Scanner * s, int option, void *val)
+{
+  unsigned int i;
+  SANE_Word* table = nullptr;
+  std::vector<uint16_t> gamma_table;
+  unsigned option_size = 0;
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  // FIXME: we should pick correct sensor here
+  const Genesys_Sensor& sensor = sanei_genesys_find_sensor_any(s->dev);
+
+  switch (option)
+    {
+      /* geometry */
+    case OPT_TL_X:
+        *reinterpret_cast<SANE_Word*>(val) = s->pos_top_left_x;
+        break;
+    case OPT_TL_Y:
+        *reinterpret_cast<SANE_Word*>(val) = s->pos_top_left_y;
+        break;
+    case OPT_BR_X:
+        *reinterpret_cast<SANE_Word*>(val) = s->pos_bottom_right_x;
+        break;
+    case OPT_BR_Y:
+        *reinterpret_cast<SANE_Word*>(val) = s->pos_bottom_right_y;
+        break;
+      /* word options: */
+    case OPT_NUM_OPTS:
+        *reinterpret_cast<SANE_Word*>(val) = NUM_OPTIONS;
+        break;
+    case OPT_RESOLUTION:
+        *reinterpret_cast<SANE_Word*>(val) = s->resolution;
+        break;
+    case OPT_BIT_DEPTH:
+        *reinterpret_cast<SANE_Word*>(val) = s->bit_depth;
+        break;
+    case OPT_PREVIEW:
+        *reinterpret_cast<SANE_Word*>(val) = s->preview;
+        break;
+    case OPT_THRESHOLD:
+        *reinterpret_cast<SANE_Word*>(val) = s->threshold;
+        break;
+    case OPT_THRESHOLD_CURVE:
+        *reinterpret_cast<SANE_Word*>(val) = s->threshold_curve;
+        break;
+    case OPT_DISABLE_DYNAMIC_LINEART:
+        *reinterpret_cast<SANE_Word*>(val) = s->disable_dynamic_lineart;
+        break;
+    case OPT_DISABLE_INTERPOLATION:
+        *reinterpret_cast<SANE_Word*>(val) = s->disable_interpolation;
+        break;
+    case OPT_LAMP_OFF:
+        *reinterpret_cast<SANE_Word*>(val) = s->lamp_off;
+        break;
+    case OPT_LAMP_OFF_TIME:
+        *reinterpret_cast<SANE_Word*>(val) = s->lamp_off_time;
+        break;
+    case OPT_SWDESKEW:
+        *reinterpret_cast<SANE_Word*>(val) = s->swdeskew;
+        break;
+    case OPT_SWCROP:
+        *reinterpret_cast<SANE_Word*>(val) = s->swcrop;
+        break;
+    case OPT_SWDESPECK:
+        *reinterpret_cast<SANE_Word*>(val) = s->swdespeck;
+        break;
+    case OPT_SWDEROTATE:
+        *reinterpret_cast<SANE_Word*>(val) = s->swderotate;
+        break;
+    case OPT_SWSKIP:
+        *reinterpret_cast<SANE_Word*>(val) = s->swskip;
+        break;
+    case OPT_DESPECK:
+        *reinterpret_cast<SANE_Word*>(val) = s->despeck;
+        break;
+    case OPT_CONTRAST:
+        *reinterpret_cast<SANE_Word*>(val) = s->contrast;
+        break;
+    case OPT_BRIGHTNESS:
+        *reinterpret_cast<SANE_Word*>(val) = s->brightness;
+        break;
+    case OPT_EXPIRATION_TIME:
+        *reinterpret_cast<SANE_Word*>(val) = s->expiration_time;
+        break;
+    case OPT_CUSTOM_GAMMA:
+        *reinterpret_cast<SANE_Word*>(val) = s->custom_gamma;
+        break;
+
+      /* string options: */
+    case OPT_MODE:
+        std::strcpy(reinterpret_cast<char*>(val), s->mode.c_str());
+        break;
+    case OPT_COLOR_FILTER:
+        std::strcpy(reinterpret_cast<char*>(val), s->color_filter.c_str());
+        break;
+    case OPT_CALIBRATION_FILE:
+        std::strcpy(reinterpret_cast<char*>(val), s->calibration_file.c_str());
+        break;
+    case OPT_SOURCE:
+        std::strcpy(reinterpret_cast<char*>(val), s->source.c_str());
+        break;
+
+      /* word array options */
+    case OPT_GAMMA_VECTOR:
+      table = (SANE_Word *) val;
+        if (s->color_filter == "Red") {
+            gamma_table = get_gamma_table(s->dev, sensor, GENESYS_RED);
+        } else if (s->color_filter == "Blue") {
+            gamma_table = get_gamma_table(s->dev, sensor, GENESYS_BLUE);
+        } else {
+            gamma_table = get_gamma_table(s->dev, sensor, GENESYS_GREEN);
+        }
+        option_size = s->opt[option].size / sizeof (SANE_Word);
+        if (gamma_table.size() != option_size) {
+            throw std::runtime_error("The size of the gamma tables does not match");
+        }
+        for (i = 0; i < option_size; i++) {
+            table[i] = gamma_table[i];
+        }
+        break;
+    case OPT_GAMMA_VECTOR_R:
+      table = (SANE_Word *) val;
+        gamma_table = get_gamma_table(s->dev, sensor, GENESYS_RED);
+        option_size = s->opt[option].size / sizeof (SANE_Word);
+        if (gamma_table.size() != option_size) {
+            throw std::runtime_error("The size of the gamma tables does not match");
+        }
+        for (i = 0; i < option_size; i++) {
+            table[i] = gamma_table[i];
+	}
+      break;
+    case OPT_GAMMA_VECTOR_G:
+      table = (SANE_Word *) val;
+        gamma_table = get_gamma_table(s->dev, sensor, GENESYS_GREEN);
+        option_size = s->opt[option].size / sizeof (SANE_Word);
+        if (gamma_table.size() != option_size) {
+            throw std::runtime_error("The size of the gamma tables does not match");
+        }
+        for (i = 0; i < option_size; i++) {
+            table[i] = gamma_table[i];
+        }
+      break;
+    case OPT_GAMMA_VECTOR_B:
+      table = (SANE_Word *) val;
+        gamma_table = get_gamma_table(s->dev, sensor, GENESYS_BLUE);
+        option_size = s->opt[option].size / sizeof (SANE_Word);
+        if (gamma_table.size() != option_size) {
+            throw std::runtime_error("The size of the gamma tables does not match");
+        }
+        for (i = 0; i < option_size; i++) {
+            table[i] = gamma_table[i];
+        }
+      break;
+      /* sensors */
+    case OPT_SCAN_SW:
+    case OPT_FILE_SW:
+    case OPT_EMAIL_SW:
+    case OPT_COPY_SW:
+    case OPT_PAGE_LOADED_SW:
+    case OPT_OCR_SW:
+    case OPT_POWER_SW:
+    case OPT_EXTRA_SW:
+      RIE (s->dev->model->cmd_set->update_hardware_sensors (s));
+      *(SANE_Bool *) val = s->buttons[genesys_option_to_button(option)].read();
+      break;
+    case OPT_NEED_CALIBRATION_SW:
+      /* scanner needs calibration for current mode unless a matching
+       * calibration cache is found */
+      *(SANE_Bool *) val = SANE_TRUE;
+      for (auto& cache : s->dev->calibration_cache)
+	{
+	  if (s->dev->model->cmd_set->is_compatible_calibration(s->dev, sensor, &cache, SANE_FALSE))
+	    {
+	      *(SANE_Bool *) val = SANE_FALSE;
+	    }
+	}
+      break;
+    default:
+      DBG(DBG_warn, "%s: can't get unknown option %d\n", __func__, option);
+    }
+  return status;
+}
+
+/** @brief set calibration file value
+ * Set calibration file value. Load new cache values from file if it exists,
+ * else creates the file*/
+static void set_calibration_value(Genesys_Scanner* s, const char* val)
+{
+    DBG_HELPER(dbg);
+
+    std::string new_calib_path = val;
+    Genesys_Device::Calibration new_calibration;
+
+    bool is_calib_success = false;
+    catch_all_exceptions(__func__, [&]()
+    {
+        is_calib_success = sanei_genesys_read_calibration(new_calibration, new_calib_path);
+    });
+
+    if (!is_calib_success) {
+        return;
+    }
+
+    s->dev->calibration_cache = std::move(new_calibration);
+    s->dev->calib_file = new_calib_path;
+    s->calibration_file = new_calib_path;
+    DBG(DBG_info, "%s: Calibration filename set to '%s':\n", __func__, new_calib_path.c_str());
+}
+
+/* sets an option , called by sane_control_option */
+static SANE_Status
+set_option_value (Genesys_Scanner * s, int option, void *val,
+		  SANE_Int * myinfo)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  SANE_Word *table;
+  unsigned int i;
+  SANE_Range *x_range, *y_range;
+  unsigned option_size = 0;
+
+    // FIXME: we should modify device-specific sensor
+    auto& sensor = sanei_genesys_find_sensor_any_for_write(s->dev);
+
+  switch (option)
+    {
+    case OPT_TL_X:
+        s->pos_top_left_x = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_TL_Y:
+        s->pos_top_left_y = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_BR_X:
+        s->pos_bottom_right_x = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_BR_Y:
+        s->pos_bottom_right_y = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_RESOLUTION:
+        s->resolution = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_THRESHOLD:
+        s->threshold = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_THRESHOLD_CURVE:
+        s->threshold_curve = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_DISABLE_DYNAMIC_LINEART:
+        s->disable_dynamic_lineart = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_SWCROP:
+        s->swcrop = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_SWDESKEW:
+        s->swdeskew = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_DESPECK:
+        s->despeck = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_SWDEROTATE:
+        s->swderotate = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_SWSKIP:
+        s->swskip = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_DISABLE_INTERPOLATION:
+        s->disable_interpolation = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_LAMP_OFF:
+        s->lamp_off = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_PREVIEW:
+        s->preview = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_BRIGHTNESS:
+        s->brightness = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_CONTRAST:
+        s->contrast = *reinterpret_cast<SANE_Word*>(val);
+        RIE (calc_parameters(s));
+        *myinfo |= SANE_INFO_RELOAD_PARAMS;
+        break;
+    case OPT_SWDESPECK:
+        s->swdespeck = *reinterpret_cast<SANE_Word*>(val);
+        if (s->swdespeck) {
+            ENABLE(OPT_DESPECK);
+        } else {
+            DISABLE(OPT_DESPECK);
+        }
+      RIE (calc_parameters (s));
+      *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+      break;
+    /* software enhancement functions only apply to 8 or 1 bits data */
+    case OPT_BIT_DEPTH:
+        s->bit_depth = *reinterpret_cast<SANE_Word*>(val);
+        if(s->bit_depth>8)
+        {
+          DISABLE(OPT_SWDESKEW);
+          DISABLE(OPT_SWDESPECK);
+          DISABLE(OPT_SWCROP);
+          DISABLE(OPT_DESPECK);
+          DISABLE(OPT_SWDEROTATE);
+          DISABLE(OPT_SWSKIP);
+          DISABLE(OPT_CONTRAST);
+          DISABLE(OPT_BRIGHTNESS);
+        }
+      else
+        {
+          ENABLE(OPT_SWDESKEW);
+          ENABLE(OPT_SWDESPECK);
+          ENABLE(OPT_SWCROP);
+          ENABLE(OPT_DESPECK);
+          ENABLE(OPT_SWDEROTATE);
+          ENABLE(OPT_SWSKIP);
+          ENABLE(OPT_CONTRAST);
+          ENABLE(OPT_BRIGHTNESS);
+        }
+      RIE (calc_parameters (s));
+      *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+      break;
+    case OPT_SOURCE:
+        if (s->source != reinterpret_cast<const char*>(val)) {
+            s->source = reinterpret_cast<const char*>(val);
+
+            // change geometry constraint to the new source value
+            if (s->source == STR_FLATBED)
+            {
+              x_range=create_range(s->dev->model->x_size);
+              y_range=create_range(s->dev->model->y_size);
+            }
+          else
+            {
+              x_range=create_range(s->dev->model->x_size_ta);
+              y_range=create_range(s->dev->model->y_size_ta);
+            }
+          if(x_range==NULL || y_range==NULL)
+            {
+              return SANE_STATUS_NO_MEM;
+            }
+
+          /* assign new values */
+          free((void *)(size_t)s->opt[OPT_TL_X].constraint.range);
+          free((void *)(size_t)s->opt[OPT_TL_Y].constraint.range);
+          s->opt[OPT_TL_X].constraint.range = x_range;
+          s->pos_top_left_x = 0;
+          s->opt[OPT_TL_Y].constraint.range = y_range;
+          s->pos_top_left_y = 0;
+          s->opt[OPT_BR_X].constraint.range = x_range;
+          s->pos_bottom_right_x = x_range->max;
+          s->opt[OPT_BR_Y].constraint.range = y_range;
+          s->pos_bottom_right_y = y_range->max;
+
+          /* signals reload */
+	  *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+	}
+      break;
+    case OPT_MODE:
+      s->mode = reinterpret_cast<const char*>(val);
+
+      if (s->mode == SANE_VALUE_SCAN_MODE_LINEART)
+	{
+	  ENABLE (OPT_THRESHOLD);
+	  ENABLE (OPT_THRESHOLD_CURVE);
+	  DISABLE (OPT_BIT_DEPTH);
+          if (s->dev->model->asic_type != GENESYS_GL646 || !s->dev->model->is_cis)
+            {
+	      ENABLE (OPT_COLOR_FILTER);
+            }
+	  ENABLE (OPT_DISABLE_DYNAMIC_LINEART);
+	}
+      else
+	{
+	  DISABLE (OPT_THRESHOLD);
+	  DISABLE (OPT_THRESHOLD_CURVE);
+	  DISABLE (OPT_DISABLE_DYNAMIC_LINEART);
+          if (s->mode == SANE_VALUE_SCAN_MODE_GRAY)
+	    {
+              if (s->dev->model->asic_type != GENESYS_GL646 || !s->dev->model->is_cis)
+                {
+	          ENABLE (OPT_COLOR_FILTER);
+                }
+	      create_bpp_list (s, s->dev->model->bpp_gray_values);
+	    }
+	  else
+	    {
+	      DISABLE (OPT_COLOR_FILTER);
+	      create_bpp_list (s, s->dev->model->bpp_color_values);
+	    }
+	  if (s->bpp_list[0] < 2)
+	    DISABLE (OPT_BIT_DEPTH);
+	  else
+	    ENABLE (OPT_BIT_DEPTH);
+	}
+      RIE (calc_parameters (s));
+
+      /* if custom gamma, toggle gamma table options according to the mode */
+      if (s->custom_gamma)
+	{
+          if (s->mode == SANE_VALUE_SCAN_MODE_COLOR)
+	    {
+	      DISABLE (OPT_GAMMA_VECTOR);
+	      ENABLE (OPT_GAMMA_VECTOR_R);
+	      ENABLE (OPT_GAMMA_VECTOR_G);
+	      ENABLE (OPT_GAMMA_VECTOR_B);
+	    }
+	  else
+	    {
+	      ENABLE (OPT_GAMMA_VECTOR);
+	      DISABLE (OPT_GAMMA_VECTOR_R);
+	      DISABLE (OPT_GAMMA_VECTOR_G);
+	      DISABLE (OPT_GAMMA_VECTOR_B);
+	    }
+	}
+
+      *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+      break;
+    case OPT_COLOR_FILTER:
+      s->color_filter = reinterpret_cast<const char*>(val);
+      RIE (calc_parameters (s));
+      break;
+    case OPT_CALIBRATION_FILE:
+            if (s->dev->force_calibration == 0) {
+                set_calibration_value(s, reinterpret_cast<const char*>(val));
+            }
+            break;
+    case OPT_LAMP_OFF_TIME:
+        if (*reinterpret_cast<SANE_Word*>(val) != s->lamp_off_time) {
+            s->lamp_off_time = *reinterpret_cast<SANE_Word*>(val);
+            RIE(s->dev->model->cmd_set->set_powersaving(s->dev, s->lamp_off_time));
+        }
+        break;
+    case OPT_EXPIRATION_TIME:
+        if (*reinterpret_cast<SANE_Word*>(val) != s->expiration_time) {
+            s->expiration_time = *reinterpret_cast<SANE_Word*>(val);
+            // BUG: this is most likely not intended behavior, found out during refactor
+            RIE(s->dev->model->cmd_set->set_powersaving(s->dev, s->expiration_time));
+	}
+        break;
+
+    case OPT_CUSTOM_GAMMA:
+      *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+        s->custom_gamma = *reinterpret_cast<SANE_Bool*>(val);
+
+        if (s->custom_gamma) {
+          if (s->mode == SANE_VALUE_SCAN_MODE_COLOR)
+	    {
+	      DISABLE (OPT_GAMMA_VECTOR);
+	      ENABLE (OPT_GAMMA_VECTOR_R);
+	      ENABLE (OPT_GAMMA_VECTOR_G);
+	      ENABLE (OPT_GAMMA_VECTOR_B);
+	    }
+	  else
+	    {
+	      ENABLE (OPT_GAMMA_VECTOR);
+	      DISABLE (OPT_GAMMA_VECTOR_R);
+	      DISABLE (OPT_GAMMA_VECTOR_G);
+	      DISABLE (OPT_GAMMA_VECTOR_B);
+	    }
+	}
+      else
+	{
+	  DISABLE (OPT_GAMMA_VECTOR);
+	  DISABLE (OPT_GAMMA_VECTOR_R);
+	  DISABLE (OPT_GAMMA_VECTOR_G);
+	  DISABLE (OPT_GAMMA_VECTOR_B);
+            for (auto& table : s->dev->gamma_override_tables) {
+                table.clear();
+            }
+	}
+      break;
+
+    case OPT_GAMMA_VECTOR:
+      table = (SANE_Word *) val;
+        option_size = s->opt[option].size / sizeof (SANE_Word);
+
+        s->dev->gamma_override_tables[GENESYS_RED].resize(option_size);
+        s->dev->gamma_override_tables[GENESYS_GREEN].resize(option_size);
+        s->dev->gamma_override_tables[GENESYS_BLUE].resize(option_size);
+        for (i = 0; i < option_size; i++) {
+            s->dev->gamma_override_tables[GENESYS_RED][i] = table[i];
+            s->dev->gamma_override_tables[GENESYS_GREEN][i] = table[i];
+            s->dev->gamma_override_tables[GENESYS_BLUE][i] = table[i];
+        }
+      break;
+    case OPT_GAMMA_VECTOR_R:
+      table = (SANE_Word *) val;
+        option_size = s->opt[option].size / sizeof (SANE_Word);
+        s->dev->gamma_override_tables[GENESYS_RED].resize(option_size);
+        for (i = 0; i < option_size; i++) {
+            s->dev->gamma_override_tables[GENESYS_RED][i] = table[i];
+        }
+      break;
+    case OPT_GAMMA_VECTOR_G:
+      table = (SANE_Word *) val;
+        option_size = s->opt[option].size / sizeof (SANE_Word);
+        s->dev->gamma_override_tables[GENESYS_GREEN].resize(option_size);
+        for (i = 0; i < option_size; i++) {
+            s->dev->gamma_override_tables[GENESYS_GREEN][i] = table[i];
+        }
+      break;
+    case OPT_GAMMA_VECTOR_B:
+      table = (SANE_Word *) val;
+        option_size = s->opt[option].size / sizeof (SANE_Word);
+        s->dev->gamma_override_tables[GENESYS_BLUE].resize(option_size);
+        for (i = 0; i < option_size; i++) {
+            s->dev->gamma_override_tables[GENESYS_BLUE][i] = table[i];
+        }
+      break;
+    case OPT_CALIBRATE:
+      status = s->dev->model->cmd_set->save_power (s->dev, SANE_FALSE);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG(DBG_error, "%s: failed to disable power saving mode: %s\n", __func__,
+	      sane_strstatus(status));
+	}
+      else
+        status = genesys_scanner_calibration(s->dev, sensor);
+      /* not critical if this fails*/
+      s->dev->model->cmd_set->save_power (s->dev, SANE_TRUE);
+      /* signals that sensors will have to be read again */
+      *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+      break;
+    case OPT_CLEAR_CALIBRATION:
+      s->dev->calibration_cache.clear();
+
+      /* remove file */
+      unlink(s->dev->calib_file.c_str());
+      /* signals that sensors will have to be read again */
+      *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+      break;
+    case OPT_FORCE_CALIBRATION:
+      s->dev->force_calibration = 1;
+      s->dev->calibration_cache.clear();
+      s->dev->calib_file.clear();
+
+      /* signals that sensors will have to be read again */
+      *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+      break;
+
+    default:
+      DBG(DBG_warn, "%s: can't set unknown option %d\n", __func__, option);
+    }
+  return status;
+}
+
+
+/* sets and gets scanner option values */
+SANE_Status
+sane_control_option_impl(SANE_Handle handle, SANE_Int option,
+                         SANE_Action action, void *val, SANE_Int * info)
+{
+  Genesys_Scanner *s = (Genesys_Scanner*) handle;
+  SANE_Status status = SANE_STATUS_GOOD;
+  SANE_Word cap;
+  SANE_Int myinfo = 0;
+
+  DBG(DBG_io2, "%s: start: action = %s, option = %s (%d)\n", __func__,
+      (action == SANE_ACTION_GET_VALUE) ? "get" : (action == SANE_ACTION_SET_VALUE) ?
+       "set" : (action == SANE_ACTION_SET_AUTO) ? "set_auto" : "unknown",
+       s->opt[option].name, option);
+
+  if (info)
+    *info = 0;
+
+  if (s->scanning)
+    {
+      DBG(DBG_warn, "%s: don't call this function while scanning (option = %s (%d))\n", __func__,
+          s->opt[option].name, option);
+
+      return SANE_STATUS_DEVICE_BUSY;
+    }
+  if (option >= NUM_OPTIONS || option < 0)
+    {
+      DBG(DBG_warn, "%s: option %d >= NUM_OPTIONS || option < 0\n", __func__, option);
+      return SANE_STATUS_INVAL;
+    }
+
+  cap = s->opt[option].cap;
+
+  if (!SANE_OPTION_IS_ACTIVE (cap))
+    {
+      DBG(DBG_warn, "%s: option %d is inactive\n", __func__, option);
+      return SANE_STATUS_INVAL;
+    }
+
+  switch (action)
+    {
+    case SANE_ACTION_GET_VALUE:
+      status = get_option_value (s, option, val);
+      break;
+
+    case SANE_ACTION_SET_VALUE:
+      if (!SANE_OPTION_IS_SETTABLE (cap))
+	{
+	  DBG(DBG_warn, "%s: option %d is not settable\n", __func__, option);
+	  return SANE_STATUS_INVAL;
+	}
+
+      status = sanei_constrain_value (s->opt + option, val, &myinfo);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG(DBG_warn, "%s: sanei_constrain_value returned %s\n", __func__,
+	      sane_strstatus(status));
+	  return status;
+	}
+
+      status = set_option_value (s, option, val, &myinfo);
+      break;
+
+    case SANE_ACTION_SET_AUTO:
+      DBG(DBG_error,
+          "%s: SANE_ACTION_SET_AUTO unsupported since no option has SANE_CAP_AUTOMATIC\n",
+          __func__);
+      status = SANE_STATUS_INVAL;
+      break;
+
+    default:
+      DBG(DBG_warn, "%s: unknown action %d for option %d\n", __func__, action, option);
+      status = SANE_STATUS_INVAL;
+      break;
+    }
+
+  if (info)
+    *info = myinfo;
+
+  DBG(DBG_io2, "%s: exit\n", __func__);
+  return status;
+}
+
+SANE_Status sane_control_option(SANE_Handle handle, SANE_Int option,
+                                SANE_Action action, void *val, SANE_Int * info)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_control_option_impl(handle, option, action, val, info);
+    });
+}
+
+SANE_Status sane_get_parameters_impl(SANE_Handle handle, SANE_Parameters* params)
+{
+  Genesys_Scanner *s = (Genesys_Scanner*) handle;
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  DBGSTART;
+
+  /* don't recompute parameters once data reading is active, ie during scan */
+  if(s->dev->read_active == SANE_FALSE)
+    {
+      RIE (calc_parameters (s));
+    }
+  if (params)
+    {
+      *params = s->params;
+
+      /* in the case of a sheetfed scanner, when full height is specified
+       * we override the computed line number with -1 to signal that we
+       * don't know the real document height.
+       * We don't do that doing buffering image for digital processing
+       */
+      if (s->dev->model->is_sheetfed == SANE_TRUE
+          && s->dev->buffer_image == SANE_FALSE
+          && s->pos_bottom_right_y == s->opt[OPT_BR_Y].constraint.range->max)
+	{
+	  params->lines = -1;
+	}
+    }
+
+  DBGCOMPLETED;
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status sane_get_parameters(SANE_Handle handle, SANE_Parameters* params)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_get_parameters_impl(handle, params);
+    });
+}
+
+SANE_Status sane_start_impl(SANE_Handle handle)
+{
+  Genesys_Scanner *s = (Genesys_Scanner*) handle;
+  SANE_Status status=SANE_STATUS_GOOD;
+
+  DBGSTART;
+
+  if (s->pos_top_left_x >= s->pos_bottom_right_x)
+    {
+      DBG(DBG_error0, "%s: top left x >= bottom right x --- exiting\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+  if (s->pos_top_left_y >= s->pos_bottom_right_y)
+    {
+      DBG(DBG_error0, "%s: top left y >= bottom right y --- exiting\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+
+  /* First make sure we have a current parameter set.  Some of the
+     parameters will be overwritten below, but that's OK.  */
+
+  RIE (calc_parameters (s));
+  RIE(genesys_start_scan(s->dev, s->lamp_off));
+
+  s->scanning = SANE_TRUE;
+
+  /* allocate intermediate buffer when doing dynamic lineart */
+  if(s->dev->settings.dynamic_lineart==SANE_TRUE)
+    {
+        s->dev->binarize_buffer.clear();
+        s->dev->binarize_buffer.alloc(s->dev->settings.pixels);
+        s->dev->local_buffer.clear();
+        s->dev->local_buffer.alloc(s->dev->binarize_buffer.size() * 8);
+    }
+
+  /* if one of the software enhancement option is selected,
+   * we do the scan internally, process picture then put it an internal
+   * buffer. Since cropping may change scan parameters, we recompute them
+   * at the end */
+  if (s->dev->buffer_image)
+    {
+      RIE(genesys_buffer_image(s));
+
+      /* check if we need to skip this page, sheetfed scanners
+       * can go to next doc while flatbed ones can't */
+        if (s->swskip > 0 && IS_ACTIVE(OPT_SWSKIP)) {
+          status = sanei_magic_isBlank(&s->params,
+                                       s->dev->img_buffer.data(),
+                                       SANE_UNFIX(s->swskip));
+          if(status == SANE_STATUS_NO_DOCS)
+            {
+              if (s->dev->model->is_sheetfed == SANE_TRUE)
+                {
+                  DBG(DBG_info, "%s: blank page, recurse\n", __func__);
+                  return sane_start(handle);
+                }
+              return status;
+            }
+        }
+
+        if (s->swdeskew) {
+          const auto& sensor = sanei_genesys_find_sensor(s->dev, s->dev->settings.xres,
+                                                         s->dev->settings.scan_method);
+          RIE(genesys_deskew(s, sensor));
+        }
+
+        if (s->swdespeck) {
+            RIE(genesys_despeck(s));
+        }
+
+        if(s->swcrop) {
+            RIE(genesys_crop(s));
+        }
+
+        if(s->swderotate) {
+            RIE(genesys_derotate(s));
+        }
+    }
+
+  DBGCOMPLETED;
+  return status;
+}
+
+SANE_Status sane_start(SANE_Handle handle)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_start_impl(handle);
+    });
+}
+
+SANE_Status
+sane_read_impl(SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int* len)
+{
+  Genesys_Scanner *s = (Genesys_Scanner*) handle;
+  Genesys_Device *dev;
+  SANE_Status status=SANE_STATUS_GOOD;
+  size_t local_len;
+
+  if (!s)
+    {
+      DBG(DBG_error, "%s: handle is null!\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+
+  dev=s->dev;
+  if (!dev)
+    {
+      DBG(DBG_error, "%s: dev is null!\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+
+  if (!buf)
+    {
+      DBG(DBG_error, "%s: buf is null!\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+
+  if (!len)
+    {
+      DBG(DBG_error, "%s: len is null!\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+
+  *len = 0;
+
+  if (!s->scanning)
+    {
+      DBG(DBG_warn, "%s: scan was cancelled, is over or has not been initiated yet\n", __func__);
+      return SANE_STATUS_CANCELLED;
+    }
+
+  DBG(DBG_proc, "%s: start, %d maximum bytes required\n", __func__, max_len);
+  DBG(DBG_io2, "%s: bytes_to_read=%lu, total_bytes_read=%lu\n", __func__,
+      (u_long) dev->total_bytes_to_read, (u_long) dev->total_bytes_read);
+  DBG(DBG_io2, "%s: physical bytes to read = %lu\n", __func__, (u_long) dev->read_bytes_left);
+
+  if(dev->total_bytes_read>=dev->total_bytes_to_read)
+    {
+      DBG(DBG_proc, "%s: nothing more to scan: EOF\n", __func__);
+
+      /* issue park command immediatly in case scanner can handle it
+       * so we save time */
+      if (dev->model->is_sheetfed == SANE_FALSE
+       && !(dev->model->flags & GENESYS_FLAG_MUST_WAIT)
+       && dev->parking == SANE_FALSE)
+        {
+          dev->model->cmd_set->slow_back_home (dev, SANE_FALSE);
+          dev->parking = SANE_TRUE;
+        }
+      return SANE_STATUS_EOF;
+    }
+
+  local_len = max_len;
+
+  /* in case of image processing, all data has been stored in
+   * buffer_image. So read data from it if it exists, else from scanner */
+  if(!dev->buffer_image)
+    {
+      /* dynamic lineart is another kind of digital processing that needs
+       * another layer of buffering on top of genesys_read_ordered_data */
+      if(dev->settings.dynamic_lineart==SANE_TRUE)
+        {
+          /* if buffer is empty, fill it with genesys_read_ordered_data */
+          if(dev->binarize_buffer.avail() == 0)
+            {
+              /* store gray data */
+              local_len=dev->local_buffer.size();
+              dev->local_buffer.reset();
+              status = genesys_read_ordered_data (dev, dev->local_buffer.get_write_pos(local_len),
+                                                  &local_len);
+              dev->local_buffer.produce(local_len);
+
+              /* binarize data is read successful */
+              if(status==SANE_STATUS_GOOD)
+                {
+                    dev->binarize_buffer.reset();
+                  genesys_gray_lineart (dev,
+                                        dev->local_buffer.get_read_pos(),
+                                        dev->binarize_buffer.get_write_pos(local_len / 8),
+                                        dev->settings.pixels,
+                                        local_len/dev->settings.pixels,
+                                        dev->settings.threshold);
+                    dev->binarize_buffer.produce(local_len / 8);
+                }
+
+            }
+
+          /* return data from lineart buffer if any, up to the available amount */
+          local_len = max_len;
+          if((size_t)max_len>dev->binarize_buffer.avail())
+            {
+              local_len=dev->binarize_buffer.avail();
+            }
+          if(local_len)
+            {
+              memcpy(buf, dev->binarize_buffer.get_read_pos(), local_len);
+              dev->binarize_buffer.consume(local_len);
+            }
+        }
+      else
+        {
+          /* most usual case, direct read of data from scanner */
+          status = genesys_read_ordered_data (dev, buf, &local_len);
+        }
+    }
+  else /* read data from buffer */
+    {
+      if(dev->total_bytes_read+local_len>dev->total_bytes_to_read)
+        {
+          local_len=dev->total_bytes_to_read-dev->total_bytes_read;
+        }
+      memcpy(buf, dev->img_buffer.data() + dev->total_bytes_read, local_len);
+      dev->total_bytes_read+=local_len;
+    }
+
+  *len = local_len;
+  if(local_len>(size_t)max_len)
+    {
+      fprintf (stderr, "[genesys] sane_read: returning incorrect length!!\n");
+    }
+  DBG(DBG_proc, "%s: %d bytes returned\n", __func__, *len);
+  return status;
+}
+
+SANE_Status sane_read(SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int* len)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_read_impl(handle, buf, max_len, len);
+    });
+}
+
+void sane_cancel_impl(SANE_Handle handle)
+{
+  Genesys_Scanner *s = (Genesys_Scanner*) handle;
+  SANE_Status status = SANE_STATUS_GOOD;
+
+  DBGSTART;
+
+  /* end binary logging if needed */
+  if (s->dev->binary!=NULL)
+    {
+      fclose(s->dev->binary);
+      s->dev->binary=NULL;
+    }
+
+  s->scanning = SANE_FALSE;
+  s->dev->read_active = SANE_FALSE;
+  s->dev->img_buffer.clear();
+
+  /* no need to end scan if we are parking the head */
+  if(s->dev->parking==SANE_FALSE)
+    {
+      status = s->dev->model->cmd_set->end_scan(s->dev, &s->dev->reg, SANE_TRUE);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
+          return;
+        }
+    }
+
+  /* park head if flatbed scanner */
+  if (s->dev->model->is_sheetfed == SANE_FALSE)
+    {
+      if(s->dev->parking==SANE_FALSE)
+        {
+          status = s->dev->model->cmd_set->slow_back_home (s->dev, s->dev->model->flags & GENESYS_FLAG_MUST_WAIT);
+          if (status != SANE_STATUS_GOOD)
+            {
+              DBG(DBG_error, "%s: failed to move scanhead to home position: %s\n", __func__,
+                  sane_strstatus(status));
+              return;
+            }
+          s->dev->parking = !(s->dev->model->flags & GENESYS_FLAG_MUST_WAIT);
+        }
+    }
+  else
+    {				/* in case of sheetfed scanners, we have to eject the document if still present */
+      status = s->dev->model->cmd_set->eject_document (s->dev);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG(DBG_error, "%s: failed to eject document: %s\n", __func__, sane_strstatus(status));
+	  return;
+	}
+    }
+
+  /* enable power saving mode unless we are parking .... */
+  if(s->dev->parking==SANE_FALSE)
+    {
+      status = s->dev->model->cmd_set->save_power (s->dev, SANE_TRUE);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(DBG_error, "%s: failed to enable power saving mode: %s\n", __func__,
+              sane_strstatus(status));
+          return;
+        }
+    }
+
+  DBGCOMPLETED;
+  return;
+}
+
+void sane_cancel(SANE_Handle handle)
+{
+    catch_all_exceptions(__func__, [=]() { sane_cancel_impl(handle); });
+}
+
+SANE_Status
+sane_set_io_mode_impl(SANE_Handle handle, SANE_Bool non_blocking)
+{
+  Genesys_Scanner *s = (Genesys_Scanner*) handle;
+
+  DBG(DBG_proc, "%s: handle = %p, non_blocking = %s\n", __func__, handle,
+      non_blocking == SANE_TRUE ? "true" : "false");
+
+  if (!s->scanning)
+    {
+      DBG(DBG_error, "%s: not scanning\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+  if (non_blocking)
+    return SANE_STATUS_UNSUPPORTED;
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_set_io_mode(SANE_Handle handle, SANE_Bool non_blocking)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_set_io_mode_impl(handle, non_blocking);
+    });
+}
+
+SANE_Status
+sane_get_select_fd_impl(SANE_Handle handle, SANE_Int * fd)
+{
+  Genesys_Scanner *s = (Genesys_Scanner*) handle;
+
+  DBG(DBG_proc, "%s: handle = %p, fd = %p\n", __func__, handle, (void *) fd);
+
+  if (!s->scanning)
+    {
+      DBG(DBG_error, "%s: not scanning\n", __func__);
+      return SANE_STATUS_INVAL;
+    }
+  return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd(SANE_Handle handle, SANE_Int * fd)
+{
+    return wrap_exceptions_to_status_code(__func__, [=]()
+    {
+        return sane_get_select_fd_impl(handle, fd);
+    });
+}
+
+GenesysButtonName genesys_option_to_button(int option)
+{
+    switch (option) {
+    case OPT_SCAN_SW: return BUTTON_SCAN_SW;
+    case OPT_FILE_SW: return BUTTON_FILE_SW;
+    case OPT_EMAIL_SW: return BUTTON_EMAIL_SW;
+    case OPT_COPY_SW: return BUTTON_COPY_SW;
+    case OPT_PAGE_LOADED_SW: return BUTTON_PAGE_LOADED_SW;
+    case OPT_OCR_SW: return BUTTON_OCR_SW;
+    case OPT_POWER_SW: return BUTTON_POWER_SW;
+    case OPT_EXTRA_SW: return BUTTON_EXTRA_SW;
+    default: throw std::runtime_error("Unknown option to convert to button index");
+    }
+}