Update upstream source from tag 'upstream/1.0.29'

Update to upstream version '1.0.29'
with Debian dir 2d358af604988ebe4348e38096245d66036fe5ed

1 files changed, 1994 insertions, 0 deletions

diff --git a/backend/genesys/low.cpp b/backend/genesys/low.cpp
new file mode 100644
index 0000000..7937fcc
--- /dev/null
+++ b/backend/genesys/low.cpp
@@ -0,0 +1,1994 @@
+/* sane - Scanner Access Now Easy.
+
+   Copyright (C) 2010-2013 Stéphane Voltz <stef.dev@free.fr>
+
+
+   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.
+*/
+
+#define DEBUG_DECLARE_ONLY
+
+#include "low.h"
+#include "assert.h"
+#include "test_settings.h"
+
+#include "gl124_registers.h"
+#include "gl646_registers.h"
+#include "gl841_registers.h"
+#include "gl843_registers.h"
+#include "gl846_registers.h"
+#include "gl847_registers.h"
+#include "gl646_registers.h"
+
+#include <cstdio>
+#include <cmath>
+#include <vector>
+
+/* ------------------------------------------------------------------------ */
+/*                  functions calling ASIC specific functions               */
+/* ------------------------------------------------------------------------ */
+
+namespace genesys {
+
+/**
+ * setup the hardware dependent functions
+ */
+
+namespace gl124 { std::unique_ptr<CommandSet> create_gl124_cmd_set(); }
+namespace gl646 { std::unique_ptr<CommandSet> create_gl646_cmd_set(); }
+namespace gl841 { std::unique_ptr<CommandSet> create_gl841_cmd_set(); }
+namespace gl843 { std::unique_ptr<CommandSet> create_gl843_cmd_set(); }
+namespace gl846 { std::unique_ptr<CommandSet> create_gl846_cmd_set(); }
+namespace gl847 { std::unique_ptr<CommandSet> create_gl847_cmd_set(); }
+
+void sanei_genesys_init_cmd_set(Genesys_Device* dev)
+{
+  DBG_INIT ();
+    DBG_HELPER(dbg);
+    switch (dev->model->asic_type) {
+        case AsicType::GL646: dev->cmd_set = gl646::create_gl646_cmd_set(); break;
+        case AsicType::GL841: dev->cmd_set = gl841::create_gl841_cmd_set(); break;
+        case AsicType::GL843: dev->cmd_set = gl843::create_gl843_cmd_set(); break;
+        case AsicType::GL845: // since only a few reg bits differs we handle both together
+        case AsicType::GL846: dev->cmd_set = gl846::create_gl846_cmd_set(); break;
+        case AsicType::GL847: dev->cmd_set = gl847::create_gl847_cmd_set(); break;
+        case AsicType::GL124: dev->cmd_set = gl124::create_gl124_cmd_set(); break;
+        default: throw SaneException(SANE_STATUS_INVAL, "unknown ASIC type");
+    }
+}
+
+/* ------------------------------------------------------------------------ */
+/*                  General IO and debugging functions                      */
+/* ------------------------------------------------------------------------ */
+
+void sanei_genesys_write_file(const char* filename, const std::uint8_t* data, std::size_t length)
+{
+    DBG_HELPER(dbg);
+    std::FILE* out = std::fopen(filename, "w");
+    if (!out) {
+        throw SaneException("could not open %s for writing: %s", filename, strerror(errno));
+    }
+    std::fwrite(data, 1, length, out);
+    std::fclose(out);
+}
+
+// Write data to a pnm file (e.g. calibration). For debugging only
+// data is RGB or grey, with little endian byte order
+void sanei_genesys_write_pnm_file(const char* filename, const std::uint8_t* data, int depth,
+                                  int channels, int pixels_per_line, int lines)
+{
+    DBG_HELPER_ARGS(dbg, "depth=%d, channels=%d, ppl=%d, lines=%d", depth, channels,
+                    pixels_per_line, lines);
+  int count;
+
+    std::FILE* out = std::fopen(filename, "w");
+  if (!out)
+    {
+        throw SaneException("could not open %s for writing: %s\n", filename, strerror(errno));
+    }
+  if(depth==1)
+    {
+      fprintf (out, "P4\n%d\n%d\n", pixels_per_line, lines);
+    }
+  else
+    {
+        std::fprintf(out, "P%c\n%d\n%d\n%d\n", channels == 1 ? '5' : '6', pixels_per_line, lines,
+                     static_cast<int>(std::pow(static_cast<double>(2),
+                                               static_cast<double>(depth - 1))));
+    }
+  if (channels == 3)
+    {
+      for (count = 0; count < (pixels_per_line * lines * 3); count++)
+	{
+	  if (depth == 16)
+	    fputc (*(data + 1), out);
+	  fputc (*(data++), out);
+	  if (depth == 16)
+	    data++;
+	}
+    }
+  else
+    {
+      if (depth==1)
+        {
+          pixels_per_line/=8;
+        }
+      for (count = 0; count < (pixels_per_line * lines); count++)
+	{
+          switch (depth)
+            {
+              case 8:
+	        fputc (*(data + count), out);
+                break;
+              case 16:
+	        fputc (*(data + 1), out);
+	        fputc (*(data), out);
+	        data += 2;
+                break;
+              default:
+                fputc(data[count], out);
+                break;
+            }
+	}
+    }
+    std::fclose(out);
+}
+
+void sanei_genesys_write_pnm_file16(const char* filename, const uint16_t* data, unsigned channels,
+                                    unsigned pixels_per_line, unsigned lines)
+{
+    DBG_HELPER_ARGS(dbg, "channels=%d, ppl=%d, lines=%d", channels,
+                    pixels_per_line, lines);
+
+    std::FILE* out = std::fopen(filename, "w");
+    if (!out) {
+        throw SaneException("could not open %s for writing: %s\n", filename, strerror(errno));
+    }
+    std::fprintf(out, "P%c\n%d\n%d\n%d\n", channels == 1 ? '5' : '6',
+                 pixels_per_line, lines, 256 * 256 - 1);
+
+    for (unsigned count = 0; count < (pixels_per_line * lines * channels); count++) {
+        fputc(*data >> 8, out);
+        fputc(*data & 0xff, out);
+        data++;
+    }
+    std::fclose(out);
+}
+
+bool is_supported_write_pnm_file_image_format(PixelFormat format)
+{
+    switch (format) {
+        case PixelFormat::I1:
+        case PixelFormat::RGB111:
+        case PixelFormat::I8:
+        case PixelFormat::RGB888:
+        case PixelFormat::I16:
+        case PixelFormat::RGB161616:
+            return true;
+        default:
+            return false;
+    }
+}
+
+void sanei_genesys_write_pnm_file(const char* filename, const Image& image)
+{
+    if (!is_supported_write_pnm_file_image_format(image.get_format())) {
+        throw SaneException("Unsupported format %d", static_cast<unsigned>(image.get_format()));
+    }
+
+    sanei_genesys_write_pnm_file(filename, image.get_row_ptr(0),
+                                 get_pixel_format_depth(image.get_format()),
+                                 get_pixel_channels(image.get_format()),
+                                 image.get_width(), image.get_height());
+}
+
+/* ------------------------------------------------------------------------ */
+/*                  Read and write RAM, registers and AFE                   */
+/* ------------------------------------------------------------------------ */
+
+unsigned sanei_genesys_get_bulk_max_size(AsicType asic_type)
+{
+    /*  Genesys supports 0xFE00 maximum size in general, wheraus GL646 supports
+        0xFFC0. We use 0xF000 because that's the packet limit in the Linux usbmon
+        USB capture stack. By default it limits packet size to b_size / 5 where
+        b_size is the size of the ring buffer. By default it's 300*1024, so the
+        packet is limited 61440 without any visibility to acquiring software.
+    */
+    if (asic_type == AsicType::GL124 ||
+        asic_type == AsicType::GL846 ||
+        asic_type == AsicType::GL847)
+    {
+        return 0xeff0;
+    }
+    return 0xf000;
+}
+
+// Set address for writing data
+void sanei_genesys_set_buffer_address(Genesys_Device* dev, uint32_t addr)
+{
+    DBG_HELPER(dbg);
+
+    if (dev->model->asic_type==AsicType::GL847 ||
+        dev->model->asic_type==AsicType::GL845 ||
+        dev->model->asic_type==AsicType::GL846 ||
+        dev->model->asic_type==AsicType::GL124)
+    {
+      DBG(DBG_warn, "%s: shouldn't be used for GL846+ ASICs\n", __func__);
+      return;
+    }
+
+  DBG(DBG_io, "%s: setting address to 0x%05x\n", __func__, addr & 0xfffffff0);
+
+  addr = addr >> 4;
+
+    dev->interface->write_register(0x2b, (addr & 0xff));
+
+  addr = addr >> 8;
+    dev->interface->write_register(0x2a, (addr & 0xff));
+}
+
+/* ------------------------------------------------------------------------ */
+/*                       Medium level functions                             */
+/* ------------------------------------------------------------------------ */
+
+Status scanner_read_status(Genesys_Device& dev)
+{
+    DBG_HELPER(dbg);
+    std::uint16_t address = 0;
+
+    switch (dev.model->asic_type) {
+        case AsicType::GL124: address = 0x101; break;
+        case AsicType::GL646:
+        case AsicType::GL841:
+        case AsicType::GL843:
+        case AsicType::GL845:
+        case AsicType::GL846:
+        case AsicType::GL847: address = 0x41; break;
+        default: throw SaneException("Unsupported asic type");
+    }
+
+    // same for all chips
+    constexpr std::uint8_t PWRBIT = 0x80;
+    constexpr std::uint8_t BUFEMPTY	= 0x40;
+    constexpr std::uint8_t FEEDFSH = 0x20;
+    constexpr std::uint8_t SCANFSH = 0x10;
+    constexpr std::uint8_t HOMESNR = 0x08;
+    constexpr std::uint8_t LAMPSTS = 0x04;
+    constexpr std::uint8_t FEBUSY = 0x02;
+    constexpr std::uint8_t MOTORENB	= 0x01;
+
+    auto value = dev.interface->read_register(address);
+    Status status;
+    status.is_replugged = !(value & PWRBIT);
+    status.is_buffer_empty = value & BUFEMPTY;
+    status.is_feeding_finished = value & FEEDFSH;
+    status.is_scanning_finished = value & SCANFSH;
+    status.is_at_home = value & HOMESNR;
+    status.is_lamp_on = value & LAMPSTS;
+    status.is_front_end_busy = value & FEBUSY;
+    status.is_motor_enabled = value & MOTORENB;
+
+    if (DBG_LEVEL >= DBG_io) {
+        debug_print_status(dbg, status);
+    }
+
+    return status;
+}
+
+Status scanner_read_reliable_status(Genesys_Device& dev)
+{
+    DBG_HELPER(dbg);
+
+    scanner_read_status(dev);
+    dev.interface->sleep_ms(100);
+    return scanner_read_status(dev);
+}
+
+void scanner_read_print_status(Genesys_Device& dev)
+{
+    scanner_read_status(dev);
+}
+
+/**
+ * decodes and prints content of status register
+ * @param val value read from status register
+ */
+void debug_print_status(DebugMessageHelper& dbg, Status val)
+{
+    std::stringstream str;
+    str << val;
+    dbg.vlog(DBG_info, "status=%s\n", str.str().c_str());
+}
+
+#if 0
+/* returns pixels per line from register set */
+/*candidate for moving into chip specific files?*/
+static int
+genesys_pixels_per_line (Genesys_Register_Set * reg)
+{
+    int pixels_per_line;
+
+    pixels_per_line = reg->get8(0x32) * 256 + reg->get8(0x33);
+    pixels_per_line -= (reg->get8(0x30) * 256 + reg->get8(0x31));
+
+    return pixels_per_line;
+}
+
+/* returns dpiset from register set */
+/*candidate for moving into chip specific files?*/
+static int
+genesys_dpiset (Genesys_Register_Set * reg)
+{
+    return reg->get8(0x2c) * 256 + reg->get8(0x2d);
+}
+#endif
+
+/** read the number of valid words in scanner's RAM
+ * ie registers 42-43-44
+ */
+// candidate for moving into chip specific files?
+void sanei_genesys_read_valid_words(Genesys_Device* dev, unsigned int* words)
+{
+    DBG_HELPER(dbg);
+
+  switch (dev->model->asic_type)
+    {
+    case AsicType::GL124:
+            *words = dev->interface->read_register(0x102) & 0x03;
+            *words = *words * 256 + dev->interface->read_register(0x103);
+            *words = *words * 256 + dev->interface->read_register(0x104);
+            *words = *words * 256 + dev->interface->read_register(0x105);
+            break;
+
+    case AsicType::GL845:
+    case AsicType::GL846:
+            *words = dev->interface->read_register(0x42) & 0x02;
+            *words = *words * 256 + dev->interface->read_register(0x43);
+            *words = *words * 256 + dev->interface->read_register(0x44);
+            *words = *words * 256 + dev->interface->read_register(0x45);
+            break;
+
+    case AsicType::GL847:
+            *words = dev->interface->read_register(0x42) & 0x03;
+            *words = *words * 256 + dev->interface->read_register(0x43);
+            *words = *words * 256 + dev->interface->read_register(0x44);
+            *words = *words * 256 + dev->interface->read_register(0x45);
+            break;
+
+    default:
+            *words = dev->interface->read_register(0x44);
+            *words += dev->interface->read_register(0x43) * 256;
+            if (dev->model->asic_type == AsicType::GL646) {
+                *words += ((dev->interface->read_register(0x42) & 0x03) * 256 * 256);
+            } else {
+                *words += ((dev->interface->read_register(0x42) & 0x0f) * 256 * 256);
+            }
+    }
+
+  DBG(DBG_proc, "%s: %d words\n", __func__, *words);
+}
+
+/** read the number of lines scanned
+ * ie registers 4b-4c-4d
+ */
+void sanei_genesys_read_scancnt(Genesys_Device* dev, unsigned int* words)
+{
+    DBG_HELPER(dbg);
+
+    if (dev->model->asic_type == AsicType::GL124) {
+        *words = (dev->interface->read_register(0x10b) & 0x0f) << 16;
+        *words += (dev->interface->read_register(0x10c) << 8);
+        *words += dev->interface->read_register(0x10d);
+    }
+  else
+    {
+        *words = dev->interface->read_register(0x4d);
+        *words += dev->interface->read_register(0x4c) * 256;
+        if (dev->model->asic_type == AsicType::GL646) {
+            *words += ((dev->interface->read_register(0x4b) & 0x03) * 256 * 256);
+        } else {
+            *words += ((dev->interface->read_register(0x4b) & 0x0f) * 256 * 256);
+        }
+    }
+
+  DBG(DBG_proc, "%s: %d lines\n", __func__, *words);
+}
+
+/** @brief Check if the scanner's internal data buffer is empty
+ * @param *dev device to test for data
+ * @param *empty return value
+ * @return empty will be set to true if there is no scanned data.
+ **/
+bool sanei_genesys_is_buffer_empty(Genesys_Device* dev)
+{
+    DBG_HELPER(dbg);
+
+    dev->interface->sleep_ms(1);
+
+    auto status = scanner_read_status(*dev);
+
+    if (status.is_buffer_empty) {
+      /* fix timing issue on USB3 (or just may be too fast) hardware
+       * spotted by John S. Weber <jweber53@gmail.com>
+       */
+        dev->interface->sleep_ms(1);
+      DBG(DBG_io2, "%s: buffer is empty\n", __func__);
+        return true;
+    }
+
+
+  DBG(DBG_io, "%s: buffer is filled\n", __func__);
+    return false;
+}
+
+void wait_until_buffer_non_empty(Genesys_Device* dev, bool check_status_twice)
+{
+    // FIXME: reduce MAX_RETRIES once tests are updated
+    const unsigned MAX_RETRIES = 100000;
+    for (unsigned i = 0; i < MAX_RETRIES; ++i) {
+
+        if (check_status_twice) {
+            // FIXME: this only to preserve previous behavior, can be removed
+            scanner_read_status(*dev);
+        }
+
+        bool empty = sanei_genesys_is_buffer_empty(dev);
+        dev->interface->sleep_ms(10);
+        if (!empty)
+            return;
+    }
+    throw SaneException(SANE_STATUS_IO_ERROR, "failed to read data");
+}
+
+void wait_until_has_valid_words(Genesys_Device* dev)
+{
+    unsigned words = 0;
+    unsigned sleep_time_ms = 10;
+
+    for (unsigned wait_ms = 0; wait_ms < 50000; wait_ms += sleep_time_ms) {
+        sanei_genesys_read_valid_words(dev, &words);
+        if (words != 0)
+            break;
+        dev->interface->sleep_ms(sleep_time_ms);
+    }
+
+    if (words == 0) {
+        throw SaneException(SANE_STATUS_IO_ERROR, "timeout, buffer does not get filled");
+    }
+}
+
+// Read data (e.g scanned image) from scan buffer
+void sanei_genesys_read_data_from_scanner(Genesys_Device* dev, uint8_t* data, size_t size)
+{
+    DBG_HELPER_ARGS(dbg, "size = %zu bytes", size);
+
+  if (size & 1)
+    DBG(DBG_info, "WARNING %s: odd number of bytes\n", __func__);
+
+    wait_until_has_valid_words(dev);
+
+    dev->interface->bulk_read_data(0x45, data, size);
+}
+
+Image read_unshuffled_image_from_scanner(Genesys_Device* dev, const ScanSession& session,
+                                         std::size_t total_bytes)
+{
+    DBG_HELPER(dbg);
+
+    auto format = create_pixel_format(session.params.depth,
+                                      dev->model->is_cis ? 1 : session.params.channels,
+                                      dev->model->line_mode_color_order);
+
+    auto width = get_pixels_from_row_bytes(format, session.output_line_bytes_raw);
+    auto height = session.output_line_count * (dev->model->is_cis ? session.params.channels : 1);
+
+    Image image(width, height, format);
+
+    auto max_bytes = image.get_row_bytes() * height;
+    if (total_bytes > max_bytes) {
+        throw SaneException("Trying to read too much data %zu (max %zu)", total_bytes, max_bytes);
+    }
+    if (total_bytes != max_bytes) {
+        DBG(DBG_info, "WARNING %s: trying to read not enough data (%zu, full fill %zu\n", __func__,
+            total_bytes, max_bytes);
+    }
+
+    sanei_genesys_read_data_from_scanner(dev, image.get_row_ptr(0), total_bytes);
+
+    ImagePipelineStack pipeline;
+    pipeline.push_first_node<ImagePipelineNodeImageSource>(image);
+
+    if ((dev->model->flags & GENESYS_FLAG_16BIT_DATA_INVERTED) && session.params.depth == 16) {
+        dev->pipeline.push_node<ImagePipelineNodeSwap16BitEndian>();
+    }
+
+#ifdef WORDS_BIGENDIAN
+    if (depth == 16) {
+        dev->pipeline.push_node<ImagePipelineNodeSwap16BitEndian>();
+    }
+#endif
+
+    if (dev->model->is_cis && session.params.channels == 3) {
+        dev->pipeline.push_node<ImagePipelineNodeMergeMonoLines>(dev->model->line_mode_color_order);
+    }
+
+    if (dev->pipeline.get_output_format() == PixelFormat::BGR888) {
+        dev->pipeline.push_node<ImagePipelineNodeFormatConvert>(PixelFormat::RGB888);
+    }
+
+    if (dev->pipeline.get_output_format() == PixelFormat::BGR161616) {
+        dev->pipeline.push_node<ImagePipelineNodeFormatConvert>(PixelFormat::RGB161616);
+    }
+
+    return pipeline.get_image();
+}
+
+void sanei_genesys_read_feed_steps(Genesys_Device* dev, unsigned int* steps)
+{
+    DBG_HELPER(dbg);
+
+    if (dev->model->asic_type == AsicType::GL124) {
+        *steps = (dev->interface->read_register(0x108) & 0x1f) << 16;
+        *steps += (dev->interface->read_register(0x109) << 8);
+        *steps += dev->interface->read_register(0x10a);
+    }
+  else
+    {
+        *steps = dev->interface->read_register(0x4a);
+        *steps += dev->interface->read_register(0x49) * 256;
+        if (dev->model->asic_type == AsicType::GL646) {
+            *steps += ((dev->interface->read_register(0x48) & 0x03) * 256 * 256);
+        } else if (dev->model->asic_type == AsicType::GL841) {
+            *steps += ((dev->interface->read_register(0x48) & 0x0f) * 256 * 256);
+        } else {
+            *steps += ((dev->interface->read_register(0x48) & 0x1f) * 256 * 256);
+        }
+    }
+
+  DBG(DBG_proc, "%s: %d steps\n", __func__, *steps);
+}
+
+void sanei_genesys_set_lamp_power(Genesys_Device* dev, const Genesys_Sensor& sensor,
+                                  Genesys_Register_Set& regs, bool set)
+{
+    static const uint8_t REG_0x03_LAMPPWR = 0x10;
+
+    if (set) {
+        regs.find_reg(0x03).value |= REG_0x03_LAMPPWR;
+
+        if (dev->model->asic_type == AsicType::GL841) {
+            regs_set_exposure(dev->model->asic_type, regs,
+                              sanei_genesys_fixup_exposure(sensor.exposure));
+            regs.set8(0x19, 0x50);
+        }
+
+        if (dev->model->asic_type == AsicType::GL843) {
+            regs_set_exposure(dev->model->asic_type, regs, sensor.exposure);
+
+            // we don't actually turn on lamp on infrared scan
+            if ((dev->model->model_id == ModelId::CANON_8400F ||
+                 dev->model->model_id == ModelId::CANON_8600F ||
+                 dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7200I ||
+                 dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7500I) &&
+                dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
+            {
+                regs.find_reg(0x03).value &= ~REG_0x03_LAMPPWR;
+            }
+        }
+    } else {
+        regs.find_reg(0x03).value &= ~REG_0x03_LAMPPWR;
+
+        if (dev->model->asic_type == AsicType::GL841) {
+            regs_set_exposure(dev->model->asic_type, regs, {0x0101, 0x0101, 0x0101});
+            regs.set8(0x19, 0xff);
+        }
+
+        if (dev->model->asic_type == AsicType::GL843) {
+            if (dev->model->model_id == ModelId::PANASONIC_KV_SS080 ||
+                dev->model->model_id == ModelId::HP_SCANJET_4850C ||
+                dev->model->model_id == ModelId::HP_SCANJET_G4010 ||
+                dev->model->model_id == ModelId::HP_SCANJET_G4050)
+            {
+                // BUG: datasheet says we shouldn't set exposure to zero
+                regs_set_exposure(dev->model->asic_type, regs, {0, 0, 0});
+            }
+        }
+    }
+    regs.state.is_lamp_on = set;
+}
+
+void sanei_genesys_set_motor_power(Genesys_Register_Set& regs, bool set)
+{
+    static const uint8_t REG_0x02_MTRPWR = 0x10;
+
+    if (set) {
+        regs.find_reg(0x02).value |= REG_0x02_MTRPWR;
+    } else {
+        regs.find_reg(0x02).value &= ~REG_0x02_MTRPWR;
+    }
+    regs.state.is_motor_on = set;
+}
+
+bool should_enable_gamma(const ScanSession& session, const Genesys_Sensor& sensor)
+{
+    if ((session.params.flags & ScanFlag::DISABLE_GAMMA) != ScanFlag::NONE) {
+        return false;
+    }
+    if (sensor.gamma[0] == 1.0f || sensor.gamma[1] == 1.0f || sensor.gamma[2] == 1.0f) {
+        return false;
+    }
+    if (session.params.depth == 16)
+        return false;
+
+    return true;
+}
+
+std::vector<uint16_t> get_gamma_table(Genesys_Device* dev, const Genesys_Sensor& sensor,
+                                      int color)
+{
+    if (!dev->gamma_override_tables[color].empty()) {
+        return dev->gamma_override_tables[color];
+    } else {
+        std::vector<uint16_t> ret;
+        sanei_genesys_create_default_gamma_table(dev, ret, sensor.gamma[color]);
+        return ret;
+    }
+}
+
+/** @brief generates gamma buffer to transfer
+ * Generates gamma table buffer to send to ASIC. Applies
+ * contrast and brightness if set.
+ * @param dev device to set up
+ * @param bits number of bits used by gamma
+ * @param max value for gamma
+ * @param size of the gamma table
+ * @param gamma allocated gamma buffer to fill
+ */
+void sanei_genesys_generate_gamma_buffer(Genesys_Device* dev,
+                                                const Genesys_Sensor& sensor,
+                                                int bits,
+                                                int max,
+                                                int size,
+                                                uint8_t* gamma)
+{
+    DBG_HELPER(dbg);
+    std::vector<uint16_t> rgamma = get_gamma_table(dev, sensor, GENESYS_RED);
+    std::vector<uint16_t> ggamma = get_gamma_table(dev, sensor, GENESYS_GREEN);
+    std::vector<uint16_t> bgamma = get_gamma_table(dev, sensor, GENESYS_BLUE);
+
+  if(dev->settings.contrast!=0 || dev->settings.brightness!=0)
+    {
+      std::vector<uint16_t> lut(65536);
+      sanei_genesys_load_lut(reinterpret_cast<unsigned char *>(lut.data()),
+                             bits,
+                             bits,
+                             0,
+                             max,
+                             dev->settings.contrast,
+                             dev->settings.brightness);
+      for (int i = 0; i < size; i++)
+        {
+          uint16_t value=rgamma[i];
+          value=lut[value];
+          gamma[i * 2 + size * 0 + 0] = value & 0xff;
+          gamma[i * 2 + size * 0 + 1] = (value >> 8) & 0xff;
+
+          value=ggamma[i];
+          value=lut[value];
+          gamma[i * 2 + size * 2 + 0] = value & 0xff;
+          gamma[i * 2 + size * 2 + 1] = (value >> 8) & 0xff;
+
+          value=bgamma[i];
+          value=lut[value];
+          gamma[i * 2 + size * 4 + 0] = value & 0xff;
+          gamma[i * 2 + size * 4 + 1] = (value >> 8) & 0xff;
+        }
+    }
+  else
+    {
+      for (int i = 0; i < size; i++)
+        {
+          uint16_t value=rgamma[i];
+          gamma[i * 2 + size * 0 + 0] = value & 0xff;
+          gamma[i * 2 + size * 0 + 1] = (value >> 8) & 0xff;
+
+          value=ggamma[i];
+          gamma[i * 2 + size * 2 + 0] = value & 0xff;
+          gamma[i * 2 + size * 2 + 1] = (value >> 8) & 0xff;
+
+          value=bgamma[i];
+          gamma[i * 2 + size * 4 + 0] = value & 0xff;
+          gamma[i * 2 + size * 4 + 1] = (value >> 8) & 0xff;
+        }
+    }
+}
+
+
+/** @brief send gamma table to scanner
+ * This function sends generic gamma table (ie ones built with
+ * provided gamma) or the user defined one if provided by
+ * fontend. Used by gl846+ ASICs
+ * @param dev device to write to
+ */
+void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& sensor)
+{
+    DBG_HELPER(dbg);
+  int size;
+  int i;
+
+  size = 256 + 1;
+
+  /* allocate temporary gamma tables: 16 bits words, 3 channels */
+  std::vector<uint8_t> gamma(size * 2 * 3, 255);
+
+    sanei_genesys_generate_gamma_buffer(dev, sensor, 16, 65535, size, gamma.data());
+
+    // loop sending gamma tables NOTE: 0x01000000 not 0x10000000
+    for (i = 0; i < 3; i++) {
+        // clear corresponding GMM_N bit
+        uint8_t val = dev->interface->read_register(0xbd);
+        val &= ~(0x01 << i);
+        dev->interface->write_register(0xbd, val);
+
+        // clear corresponding GMM_F bit
+        val = dev->interface->read_register(0xbe);
+      val &= ~(0x01 << i);
+        dev->interface->write_register(0xbe, val);
+
+      // FIXME: currently the last word of each gamma table is not initialied, so to work around
+      // unstable data, just set it to 0 which is the most likely value of uninitialized memory
+      // (proper value is probably 0xff)
+      gamma[size * 2 * i + size * 2 - 2] = 0;
+      gamma[size * 2 * i + size * 2 - 1] = 0;
+
+      /* set GMM_Z */
+        dev->interface->write_register(0xc5+2*i, gamma[size*2*i+1]);
+        dev->interface->write_register(0xc6+2*i, gamma[size*2*i]);
+
+        dev->interface->write_ahb(0x01000000 + 0x200 * i, (size-1) * 2,
+                                  gamma.data() + i * size * 2+2);
+    }
+}
+
+static unsigned align_int_up(unsigned num, unsigned alignment)
+{
+    unsigned mask = alignment - 1;
+    if (num & mask)
+        num = (num & ~mask) + alignment;
+    return num;
+}
+
+void compute_session_buffer_sizes(AsicType asic, ScanSession& s)
+{
+    size_t line_bytes = s.output_line_bytes;
+    size_t line_bytes_stagger = s.output_line_bytes;
+
+    if (asic != AsicType::GL646) {
+        // BUG: this is historical artifact and should be removed. Note that buffer sizes affect
+        // how often we request the scanner for data and thus change the USB traffic.
+        line_bytes_stagger =
+                multiply_by_depth_ceil(s.optical_pixels, s.params.depth) * s.params.channels;
+    }
+
+    struct BufferConfig {
+        size_t* result_size = nullptr;
+        size_t lines = 0;
+        size_t lines_mult = 0;
+        size_t max_size = 0; // does not apply if 0
+        size_t stagger_lines = 0;
+
+        BufferConfig() = default;
+        BufferConfig(std::size_t* rs, std::size_t l, std::size_t lm, std::size_t ms,
+                     std::size_t sl) :
+            result_size{rs},
+            lines{l},
+            lines_mult{lm},
+            max_size{ms},
+            stagger_lines{sl}
+        {}
+    };
+
+    std::array<BufferConfig, 4> configs;
+    if (asic == AsicType::GL124 || asic == AsicType::GL843) {
+        configs = { {
+            { &s.buffer_size_read, 32, 1, 0, s.max_color_shift_lines + s.num_staggered_lines },
+            { &s.buffer_size_lines, 32, 1, 0, s.max_color_shift_lines + s.num_staggered_lines },
+            { &s.buffer_size_shrink, 16, 1, 0, 0 },
+            { &s.buffer_size_out, 8, 1, 0, 0 },
+        } };
+    } else if (asic == AsicType::GL841) {
+        size_t max_buf = sanei_genesys_get_bulk_max_size(asic);
+        configs = { {
+            { &s.buffer_size_read, 8, 2, max_buf, s.max_color_shift_lines + s.num_staggered_lines },
+            { &s.buffer_size_lines, 8, 2, max_buf, s.max_color_shift_lines + s.num_staggered_lines },
+            { &s.buffer_size_shrink, 8, 1, max_buf, 0 },
+            { &s.buffer_size_out, 8, 1, 0, 0 },
+        } };
+    } else {
+        configs = { {
+            { &s.buffer_size_read, 16, 1, 0, s.max_color_shift_lines + s.num_staggered_lines },
+            { &s.buffer_size_lines, 16, 1, 0, s.max_color_shift_lines + s.num_staggered_lines },
+            { &s.buffer_size_shrink, 8, 1, 0, 0 },
+            { &s.buffer_size_out, 8, 1, 0, 0 },
+        } };
+    }
+
+    for (BufferConfig& config : configs) {
+        size_t buf_size = line_bytes * config.lines;
+        if (config.max_size > 0 && buf_size > config.max_size) {
+            buf_size = (config.max_size / line_bytes) * line_bytes;
+        }
+        buf_size *= config.lines_mult;
+        buf_size += line_bytes_stagger * config.stagger_lines;
+        *config.result_size = buf_size;
+    }
+}
+
+void compute_session_pipeline(const Genesys_Device* dev, ScanSession& s)
+{
+    auto channels = s.params.channels;
+    auto depth = s.params.depth;
+
+    s.pipeline_needs_reorder = true;
+    if (channels != 3 && depth != 16) {
+        s.pipeline_needs_reorder = false;
+    }
+#ifndef WORDS_BIGENDIAN
+    if (channels != 3 && depth == 16) {
+        s.pipeline_needs_reorder = false;
+    }
+    if (channels == 3 && depth == 16 && !dev->model->is_cis &&
+        dev->model->line_mode_color_order == ColorOrder::RGB)
+    {
+        s.pipeline_needs_reorder = false;
+    }
+#endif
+    if (channels == 3 && depth == 8 && !dev->model->is_cis &&
+        dev->model->line_mode_color_order == ColorOrder::RGB)
+    {
+        s.pipeline_needs_reorder = false;
+    }
+    s.pipeline_needs_ccd = s.max_color_shift_lines + s.num_staggered_lines > 0;
+    s.pipeline_needs_shrink = dev->settings.requested_pixels != s.output_pixels;
+}
+
+void compute_session_pixel_offsets(const Genesys_Device* dev, ScanSession& s,
+                                   const Genesys_Sensor& sensor)
+{
+    unsigned ccd_pixels_per_system_pixel = sensor.ccd_pixels_per_system_pixel();
+
+    if (dev->model->asic_type == AsicType::GL646) {
+
+        // startx cannot be below dummy pixel value
+        s.pixel_startx = sensor.dummy_pixel;
+        if (has_flag(s.params.flags, ScanFlag::USE_XCORRECTION) && sensor.ccd_start_xoffset > 0) {
+            s.pixel_startx = sensor.ccd_start_xoffset;
+        }
+        s.pixel_startx += s.params.startx;
+
+        if (sensor.stagger_config.stagger_at_resolution(s.params.xres, s.params.yres) > 0) {
+            s.pixel_startx |= 1;
+        }
+
+        s.pixel_endx = s.pixel_startx + s.optical_pixels;
+
+        s.pixel_startx /= sensor.ccd_pixels_per_system_pixel() * s.ccd_size_divisor;
+        s.pixel_endx /= sensor.ccd_pixels_per_system_pixel() * s.ccd_size_divisor;
+
+    } else if (dev->model->asic_type == AsicType::GL841) {
+        s.pixel_startx = ((sensor.ccd_start_xoffset + s.params.startx) * s.optical_resolution)
+                                / sensor.optical_res;
+
+        s.pixel_startx += sensor.dummy_pixel + 1;
+
+        if (s.num_staggered_lines > 0 && (s.pixel_startx & 1) == 0) {
+            s.pixel_startx++;
+        }
+
+        /*  In case of SHDAREA, we need to align start on pixel average factor, startx is
+            different than 0 only when calling for function to setup for scan, where shading data
+            needs to be align.
+
+            NOTE: we can check the value of the register here, because we don't set this bit
+            anywhere except in initialization.
+        */
+        const uint8_t REG_0x01_SHDAREA = 0x02;
+        if ((dev->reg.find_reg(0x01).value & REG_0x01_SHDAREA) != 0) {
+            unsigned average_factor = s.optical_resolution / s.params.xres;
+            s.pixel_startx = align_multiple_floor(s.pixel_startx, average_factor);
+        }
+
+        s.pixel_endx = s.pixel_startx + s.optical_pixels;
+
+    } else if (dev->model->asic_type == AsicType::GL843) {
+
+        s.pixel_startx = (s.params.startx + sensor.dummy_pixel) / ccd_pixels_per_system_pixel;
+        s.pixel_endx = s.pixel_startx + s.optical_pixels / ccd_pixels_per_system_pixel;
+
+        s.pixel_startx /= s.hwdpi_divisor;
+        s.pixel_endx /= s.hwdpi_divisor;
+
+        // in case of stagger we have to start at an odd coordinate
+        bool stagger_starts_even = dev->model->model_id == ModelId::CANON_8400F;
+        if (s.num_staggered_lines > 0) {
+            if (!stagger_starts_even && (s.pixel_startx & 1) == 0) {
+                s.pixel_startx++;
+                s.pixel_endx++;
+            } else if (stagger_starts_even && (s.pixel_startx & 1) != 0) {
+                s.pixel_startx++;
+                s.pixel_endx++;
+            }
+        }
+
+    } else if (dev->model->asic_type == AsicType::GL845 ||
+               dev->model->asic_type == AsicType::GL846 ||
+               dev->model->asic_type == AsicType::GL847)
+    {
+        s.pixel_startx = s.params.startx;
+
+        if (s.num_staggered_lines > 0) {
+            s.pixel_startx |= 1;
+        }
+
+        s.pixel_startx += sensor.ccd_start_xoffset * ccd_pixels_per_system_pixel;
+        s.pixel_endx = s.pixel_startx + s.optical_pixels_raw;
+
+        s.pixel_startx /= s.hwdpi_divisor * s.segment_count * ccd_pixels_per_system_pixel;
+        s.pixel_endx /= s.hwdpi_divisor * s.segment_count * ccd_pixels_per_system_pixel;
+
+    } else if (dev->model->asic_type == AsicType::GL124) {
+        s.pixel_startx = s.params.startx;
+
+        if (s.num_staggered_lines > 0) {
+            s.pixel_startx |= 1;
+        }
+
+        s.pixel_startx /= ccd_pixels_per_system_pixel;
+        // FIXME: should we add sensor.dummy_pxel to pixel_startx at this point?
+        s.pixel_endx = s.pixel_startx + s.optical_pixels / ccd_pixels_per_system_pixel;
+
+        s.pixel_startx /= s.hwdpi_divisor * s.segment_count;
+        s.pixel_endx /= s.hwdpi_divisor * s.segment_count;
+
+        std::uint32_t segcnt = (sensor.custom_regs.get_value(gl124::REG_SEGCNT) << 16) +
+                               (sensor.custom_regs.get_value(gl124::REG_SEGCNT + 1) << 8) +
+                                sensor.custom_regs.get_value(gl124::REG_SEGCNT + 2);
+        if (s.pixel_endx == segcnt) {
+            s.pixel_endx = 0;
+        }
+    }
+
+    s.pixel_count_multiplier = sensor.pixel_count_multiplier;
+
+    s.pixel_startx *= sensor.pixel_count_multiplier;
+    s.pixel_endx *= sensor.pixel_count_multiplier;
+}
+
+void compute_session(const Genesys_Device* dev, ScanSession& s, const Genesys_Sensor& sensor)
+{
+    DBG_HELPER(dbg);
+
+    (void) dev;
+    s.params.assert_valid();
+
+    if (s.params.depth != 8 && s.params.depth != 16) {
+        throw SaneException("Unsupported depth setting %d", s.params.depth);
+    }
+
+    unsigned ccd_pixels_per_system_pixel = sensor.ccd_pixels_per_system_pixel();
+
+    // compute optical and output resolutions
+
+    if (dev->model->asic_type == AsicType::GL843) {
+        // FIXME: this may be incorrect, but need more scanners to test
+        s.hwdpi_divisor = sensor.get_hwdpi_divisor_for_dpi(s.params.xres);
+    } else {
+        s.hwdpi_divisor = sensor.get_hwdpi_divisor_for_dpi(s.params.xres * ccd_pixels_per_system_pixel);
+    }
+
+    s.ccd_size_divisor = sensor.get_ccd_size_divisor_for_dpi(s.params.xres);
+
+    if (dev->model->asic_type == AsicType::GL646) {
+        s.optical_resolution = sensor.optical_res;
+    } else {
+        s.optical_resolution = sensor.optical_res / s.ccd_size_divisor;
+    }
+    s.output_resolution = s.params.xres;
+
+    if (s.output_resolution > s.optical_resolution) {
+        throw std::runtime_error("output resolution higher than optical resolution");
+    }
+
+    // compute the number of optical pixels that will be acquired by the chip
+    s.optical_pixels = (s.params.pixels * s.optical_resolution) / s.output_resolution;
+    if (s.optical_pixels * s.output_resolution < s.params.pixels * s.optical_resolution) {
+        s.optical_pixels++;
+    }
+
+    if (dev->model->asic_type == AsicType::GL841) {
+        if (s.optical_pixels & 1)
+            s.optical_pixels++;
+    }
+
+    if (dev->model->asic_type == AsicType::GL646 && s.params.xres == 400) {
+        s.optical_pixels = (s.optical_pixels / 6) * 6;
+    }
+
+    if (dev->model->asic_type == AsicType::GL843) {
+        // ensure the number of optical pixels is divisible by 2.
+        // In quarter-CCD mode optical_pixels is 4x larger than the actual physical number
+        s.optical_pixels = align_int_up(s.optical_pixels, 2 * s.ccd_size_divisor);
+
+        if (dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7200I ||
+            dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7300 ||
+            dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7500I)
+        {
+            s.optical_pixels = align_int_up(s.optical_pixels, 16);
+        }
+    }
+
+    // after all adjustments on the optical pixels have been made, compute the number of pixels
+    // to retrieve from the chip
+    s.output_pixels = (s.optical_pixels * s.output_resolution) / s.optical_resolution;
+
+    // Note: staggering is not applied for calibration. Staggering starts at 2400 dpi
+    s.num_staggered_lines = 0;
+    if (!has_flag(s.params.flags, ScanFlag::IGNORE_LINE_DISTANCE))
+    {
+        s.num_staggered_lines = sensor.stagger_config.stagger_at_resolution(s.params.xres,
+                                                                            s.params.yres);
+    }
+
+    s.color_shift_lines_r = dev->model->ld_shift_r;
+    s.color_shift_lines_g = dev->model->ld_shift_g;
+    s.color_shift_lines_b = dev->model->ld_shift_b;
+
+    if (dev->model->motor_id == MotorId::G4050 && s.params.yres > 600) {
+        // it seems base_dpi of the G4050 motor is changed above 600 dpi
+        s.color_shift_lines_r = (s.color_shift_lines_r * 3800) / dev->motor.base_ydpi;
+        s.color_shift_lines_g = (s.color_shift_lines_g * 3800) / dev->motor.base_ydpi;
+        s.color_shift_lines_b = (s.color_shift_lines_b * 3800) / dev->motor.base_ydpi;
+    }
+
+    s.color_shift_lines_r = (s.color_shift_lines_r * s.params.yres) / dev->motor.base_ydpi;
+    s.color_shift_lines_g = (s.color_shift_lines_g * s.params.yres) / dev->motor.base_ydpi;
+    s.color_shift_lines_b = (s.color_shift_lines_b * s.params.yres) / dev->motor.base_ydpi;
+
+    s.max_color_shift_lines = 0;
+    if (s.params.channels > 1 && !has_flag(s.params.flags, ScanFlag::IGNORE_LINE_DISTANCE)) {
+        s.max_color_shift_lines = std::max(s.color_shift_lines_r, std::max(s.color_shift_lines_g,
+                                                                           s.color_shift_lines_b));
+    }
+
+    s.output_line_count = s.params.lines + s.max_color_shift_lines + s.num_staggered_lines;
+
+    s.output_channel_bytes = multiply_by_depth_ceil(s.output_pixels, s.params.depth);
+    s.output_line_bytes = s.output_channel_bytes * s.params.channels;
+
+    s.segment_count = sensor.get_segment_count();
+
+    s.optical_pixels_raw = s.optical_pixels;
+    s.output_line_bytes_raw = s.output_line_bytes;
+    s.conseq_pixel_dist = 0;
+
+    if (dev->model->asic_type == AsicType::GL845 ||
+        dev->model->asic_type == AsicType::GL846 ||
+        dev->model->asic_type == AsicType::GL847)
+    {
+        if (s.segment_count > 1) {
+            s.conseq_pixel_dist = sensor.segment_size;
+
+            // in case of multi-segments sensor, we have to add the width of the sensor crossed by
+            // the scan area
+            unsigned extra_segment_scan_area = align_multiple_ceil(s.conseq_pixel_dist, 2);
+            extra_segment_scan_area *= s.segment_count - 1;
+            extra_segment_scan_area *= s.hwdpi_divisor * s.segment_count;
+            extra_segment_scan_area *= ccd_pixels_per_system_pixel;
+
+            s.optical_pixels_raw += extra_segment_scan_area;
+        }
+
+        s.output_line_bytes_raw = multiply_by_depth_ceil(
+                    (s.optical_pixels_raw * s.output_resolution) / sensor.optical_res / s.segment_count,
+                    s.params.depth);
+    }
+
+    if (dev->model->asic_type == AsicType::GL841) {
+        if (dev->model->is_cis) {
+            s.output_line_bytes_raw = s.output_channel_bytes;
+        }
+    }
+
+    if (dev->model->asic_type == AsicType::GL124) {
+        if (dev->model->is_cis) {
+            s.output_line_bytes_raw = s.output_channel_bytes;
+        }
+        s.conseq_pixel_dist = s.output_pixels / s.ccd_size_divisor / s.segment_count;
+    }
+
+    if (dev->model->asic_type == AsicType::GL843) {
+        s.conseq_pixel_dist = s.output_pixels / s.segment_count;
+    }
+
+    s.output_segment_pixel_group_count = 0;
+    if (dev->model->asic_type == AsicType::GL124 ||
+        dev->model->asic_type == AsicType::GL843)
+    {
+        s.output_segment_pixel_group_count = multiply_by_depth_ceil(
+            s.output_pixels / s.ccd_size_divisor / s.segment_count, s.params.depth);
+    }
+    if (dev->model->asic_type == AsicType::GL845 ||
+        dev->model->asic_type == AsicType::GL846 ||
+        dev->model->asic_type == AsicType::GL847)
+    {
+        s.output_segment_pixel_group_count = multiply_by_depth_ceil(
+            s.optical_pixels / (s.hwdpi_divisor * s.segment_count * ccd_pixels_per_system_pixel),
+            s.params.depth);
+    }
+
+    s.output_line_bytes_requested = multiply_by_depth_ceil(
+            s.params.get_requested_pixels() * s.params.channels, s.params.depth);
+
+    s.output_total_bytes_raw = s.output_line_bytes_raw * s.output_line_count;
+    s.output_total_bytes = s.output_line_bytes * s.output_line_count;
+
+    compute_session_buffer_sizes(dev->model->asic_type, s);
+    compute_session_pipeline(dev, s);
+    compute_session_pixel_offsets(dev, s, sensor);
+
+    if (dev->model->asic_type == AsicType::GL124 ||
+        dev->model->asic_type == AsicType::GL845 ||
+        dev->model->asic_type == AsicType::GL846)
+    {
+        s.enable_ledadd = (s.params.channels == 1 && dev->model->is_cis && dev->settings.true_gray);
+    }
+
+    if (dev->model->asic_type == AsicType::GL841 ||
+        dev->model->asic_type == AsicType::GL843)
+    {
+        // no 16 bit gamma for this ASIC
+        if (s.params.depth == 16) {
+            s.params.flags |= ScanFlag::DISABLE_GAMMA;
+        }
+    }
+
+    s.computed = true;
+
+    DBG(DBG_info, "%s ", __func__);
+    debug_dump(DBG_info, s);
+}
+
+static std::size_t get_usb_buffer_read_size(AsicType asic, const ScanSession& session)
+{
+    switch (asic) {
+        case AsicType::GL646:
+            // buffer not used on this chip set
+            return 1;
+
+        case AsicType::GL124:
+            // BUG: we shouldn't multiply by channels here nor divide by ccd_size_divisor
+            return session.output_line_bytes_raw / session.ccd_size_divisor * session.params.channels;
+
+        case AsicType::GL845:
+        case AsicType::GL846:
+        case AsicType::GL847:
+            // BUG: we shouldn't multiply by channels here
+            return session.output_line_bytes_raw * session.params.channels;
+
+        case AsicType::GL843:
+            return session.output_line_bytes_raw * 2;
+
+        default:
+            throw SaneException("Unknown asic type");
+    }
+}
+
+static FakeBufferModel get_fake_usb_buffer_model(const ScanSession& session)
+{
+    FakeBufferModel model;
+    model.push_step(session.buffer_size_read, 1);
+
+    if (session.pipeline_needs_reorder) {
+        model.push_step(session.buffer_size_lines, session.output_line_bytes);
+    }
+    if (session.pipeline_needs_ccd) {
+        model.push_step(session.buffer_size_shrink, session.output_line_bytes);
+    }
+    if (session.pipeline_needs_shrink) {
+        model.push_step(session.buffer_size_out, session.output_line_bytes);
+    }
+
+    return model;
+}
+
+void build_image_pipeline(Genesys_Device* dev, const ScanSession& session)
+{
+    static unsigned s_pipeline_index = 0;
+
+    s_pipeline_index++;
+
+    auto format = create_pixel_format(session.params.depth,
+                                      dev->model->is_cis ? 1 : session.params.channels,
+                                      dev->model->line_mode_color_order);
+    auto depth = get_pixel_format_depth(format);
+    auto width = get_pixels_from_row_bytes(format, session.output_line_bytes_raw);
+
+    auto read_data_from_usb = [dev](std::size_t size, std::uint8_t* data)
+    {
+        dev->interface->bulk_read_data(0x45, data, size);
+        return true;
+    };
+
+    auto lines = session.output_line_count * (dev->model->is_cis ? session.params.channels : 1);
+
+    dev->pipeline.clear();
+
+    // FIXME: here we are complicating things for the time being to preserve the existing behaviour
+    // This allows to be sure that the changes to the image pipeline have not introduced
+    // regressions.
+
+    if (session.segment_count > 1) {
+        // BUG: we're reading one line too much
+        dev->pipeline.push_first_node<ImagePipelineNodeBufferedCallableSource>(
+                width, lines + 1, format,
+                get_usb_buffer_read_size(dev->model->asic_type, session), read_data_from_usb);
+
+        auto output_width = session.output_segment_pixel_group_count * session.segment_count;
+        dev->pipeline.push_node<ImagePipelineNodeDesegment>(output_width, dev->segment_order,
+                                                            session.conseq_pixel_dist,
+                                                            1, 1);
+    } else {
+        auto read_bytes_left_after_deseg = session.output_line_bytes * session.output_line_count;
+        if (dev->model->asic_type == AsicType::GL646) {
+            read_bytes_left_after_deseg *= dev->model->is_cis ? session.params.channels : 1;
+        }
+
+        dev->pipeline.push_first_node<ImagePipelineNodeBufferedGenesysUsb>(
+                width, lines, format, read_bytes_left_after_deseg,
+                get_fake_usb_buffer_model(session), read_data_from_usb);
+    }
+
+    if (DBG_LEVEL >= DBG_io2) {
+        dev->pipeline.push_node<ImagePipelineNodeDebug>("gl_pipeline_" +
+                                                        std::to_string(s_pipeline_index) +
+                                                        "_0_before_swap.pnm");
+    }
+
+    if ((dev->model->flags & GENESYS_FLAG_16BIT_DATA_INVERTED) && depth == 16) {
+        dev->pipeline.push_node<ImagePipelineNodeSwap16BitEndian>();
+    }
+
+#ifdef WORDS_BIGENDIAN
+    if (depth == 16) {
+        dev->pipeline.push_node<ImagePipelineNodeSwap16BitEndian>();
+    }
+#endif
+
+    if (DBG_LEVEL >= DBG_io2) {
+        dev->pipeline.push_node<ImagePipelineNodeDebug>("gl_pipeline_" +
+                                                        std::to_string(s_pipeline_index) +
+                                                        "_1_after_swap.pnm");
+    }
+
+    if (dev->model->is_cis && session.params.channels == 3) {
+        dev->pipeline.push_node<ImagePipelineNodeMergeMonoLines>(dev->model->line_mode_color_order);
+    }
+
+    if (dev->pipeline.get_output_format() == PixelFormat::BGR888) {
+        dev->pipeline.push_node<ImagePipelineNodeFormatConvert>(PixelFormat::RGB888);
+    }
+
+    if (dev->pipeline.get_output_format() == PixelFormat::BGR161616) {
+        dev->pipeline.push_node<ImagePipelineNodeFormatConvert>(PixelFormat::RGB161616);
+    }
+
+    if (session.max_color_shift_lines > 0 && session.params.channels == 3) {
+        dev->pipeline.push_node<ImagePipelineNodeComponentShiftLines>(
+                    session.color_shift_lines_r,
+                    session.color_shift_lines_g,
+                    session.color_shift_lines_b);
+    }
+
+    if (DBG_LEVEL >= DBG_io2) {
+        dev->pipeline.push_node<ImagePipelineNodeDebug>("gl_pipeline_" +
+                                                        std::to_string(s_pipeline_index) +
+                                                        "_2_after_shift.pnm");
+    }
+
+    if (session.num_staggered_lines > 0) {
+        std::vector<std::size_t> shifts{0, session.num_staggered_lines};
+        dev->pipeline.push_node<ImagePipelineNodePixelShiftLines>(shifts);
+    }
+
+    if (DBG_LEVEL >= DBG_io2) {
+        dev->pipeline.push_node<ImagePipelineNodeDebug>("gl_pipeline_" +
+                                                        std::to_string(s_pipeline_index) +
+                                                        "_3_after_stagger.pnm");
+    }
+
+    if ((dev->model->flags & GENESYS_FLAG_CALIBRATION_HOST_SIDE) &&
+        !(dev->model->flags & GENESYS_FLAG_NO_CALIBRATION))
+    {
+        dev->pipeline.push_node<ImagePipelineNodeCalibrate>(dev->dark_average_data,
+                                                            dev->white_average_data);
+
+        if (DBG_LEVEL >= DBG_io2) {
+            dev->pipeline.push_node<ImagePipelineNodeDebug>("gl_pipeline_" +
+                                                            std::to_string(s_pipeline_index) +
+                                                            "_4_after_calibrate.pnm");
+        }
+    }
+
+    if (session.output_pixels != session.params.get_requested_pixels()) {
+        dev->pipeline.push_node<ImagePipelineNodeScaleRows>(session.params.get_requested_pixels());
+    }
+
+    auto read_from_pipeline = [dev](std::size_t size, std::uint8_t* out_data)
+    {
+        (void) size; // will be always equal to dev->pipeline.get_output_row_bytes()
+        return dev->pipeline.get_next_row_data(out_data);
+    };
+    dev->pipeline_buffer = ImageBuffer{dev->pipeline.get_output_row_bytes(),
+                                       read_from_pipeline};
+}
+
+std::uint8_t compute_frontend_gain_wolfson(float value, float target_value)
+{
+    /*  the flow of data through the frontend ADC is as follows (see e.g. WM8192 datasheet)
+        input
+        -> apply offset (o = i + 260mV * (DAC[7:0]-127.5)/127.5) ->
+        -> apply gain (o = i * 208/(283-PGA[7:0])
+        -> ADC
+
+        Here we have some input data that was acquired with zero gain (PGA==0).
+        We want to compute gain such that the output would approach full ADC range (controlled by
+        target_value).
+
+        We want to solve the following for {PGA}:
+
+        {value}         = {input} * 208 / (283 - 0)
+        {target_value}  = {input} * 208 / (283 - {PGA})
+
+        The solution is the following equation:
+
+        {PGA} = 283 * (1 - {value} / {target_value})
+    */
+    float gain = value / target_value;
+    int code = static_cast<int>(283 * (1 - gain));
+    return clamp(code, 0, 255);
+}
+
+std::uint8_t compute_frontend_gain_analog_devices(float value, float target_value)
+{
+    /*  The flow of data through the frontend ADC is as follows (see e.g. AD9826 datasheet)
+        input
+        -> apply offset (o = i + 300mV * (OFFSET[8] ? 1 : -1) * (OFFSET[7:0] / 127)
+        -> apply gain (o = i * 6 / (1 + 5 * ( 63 - PGA[5:0] ) / 63 ) )
+        -> ADC
+
+        We want to solve the following for {PGA}:
+
+        {value}         = {input} * 6 / (1 + 5 * ( 63 - 0) / 63 ) )
+        {target_value}  = {input} * 6 / (1 + 5 * ( 63 - {PGA}) / 63 ) )
+
+        The solution is the following equation:
+
+        {PGA} = (378 / 5) * ({target_value} - {value} / {target_value})
+    */
+    int code = static_cast<int>((378.0f / 5.0f) * ((target_value - value) / target_value));
+    return clamp(code, 0, 63);
+}
+
+std::uint8_t compute_frontend_gain(float value, float target_value,
+                                   FrontendType frontend_type)
+{
+    if (frontend_type == FrontendType::WOLFSON) {
+        return compute_frontend_gain_wolfson(value, target_value);
+    }
+    if (frontend_type == FrontendType::ANALOG_DEVICES) {
+        return compute_frontend_gain_analog_devices(value, target_value);
+    }
+    throw SaneException("Unknown frontend to compute gain for");
+}
+
+/** @brief initialize device
+ * Initialize backend and ASIC : registers, motor tables, and gamma tables
+ * then ensure scanner's head is at home. Designed for gl846+ ASICs.
+ * Detects cold boot (ie first boot since device plugged) in this case
+ * an extensice setup up is done at hardware level.
+ *
+ * @param dev device to initialize
+ * @param max_regs umber of maximum used registers
+ */
+void sanei_genesys_asic_init(Genesys_Device* dev, bool /*max_regs*/)
+{
+    DBG_HELPER(dbg);
+
+  uint8_t val;
+    bool cold = true;
+
+    // URB    16  control  0xc0 0x0c 0x8e 0x0b len     1 read  0x00 */
+    dev->interface->get_usb_device().control_msg(REQUEST_TYPE_IN, REQUEST_REGISTER,
+                                                 VALUE_GET_REGISTER, 0x00, 1, &val);
+
+  DBG (DBG_io2, "%s: value=0x%02x\n", __func__, val);
+  DBG (DBG_info, "%s: device is %s\n", __func__, (val & 0x08) ? "USB 1.0" : "USB2.0");
+  if (val & 0x08)
+    {
+      dev->usb_mode = 1;
+    }
+  else
+    {
+      dev->usb_mode = 2;
+    }
+
+    /*  Check if the device has already been initialized and powered up. We read register 0x06 and
+        check PWRBIT, if reset scanner has been freshly powered up. This bit will be set to later
+        so that following reads can detect power down/up cycle
+    */
+    if (!is_testing_mode()) {
+        if (dev->interface->read_register(0x06) & 0x10) {
+            cold = false;
+        }
+    }
+  DBG (DBG_info, "%s: device is %s\n", __func__, cold ? "cold" : "warm");
+
+  /* don't do anything if backend is initialized and hardware hasn't been
+   * replug */
+  if (dev->already_initialized && !cold)
+    {
+      DBG (DBG_info, "%s: already initialized, nothing to do\n", __func__);
+        return;
+    }
+
+    // set up hardware and registers
+    dev->cmd_set->asic_boot(dev, cold);
+
+  /* now hardware part is OK, set up device struct */
+  dev->white_average_data.clear();
+  dev->dark_average_data.clear();
+
+  dev->settings.color_filter = ColorFilter::RED;
+
+  /* duplicate initial values into calibration registers */
+  dev->calib_reg = dev->reg;
+
+  const auto& sensor = sanei_genesys_find_sensor_any(dev);
+
+    // Set analog frontend
+    dev->cmd_set->set_fe(dev, sensor, AFE_INIT);
+
+    dev->already_initialized = true;
+
+    // Move to home if needed
+    dev->cmd_set->move_back_home(dev, true);
+    dev->set_head_pos_zero(ScanHeadId::PRIMARY);
+
+    // Set powersaving (default = 15 minutes)
+    dev->cmd_set->set_powersaving(dev, 15);
+}
+
+void scanner_start_action(Genesys_Device& dev, bool start_motor)
+{
+    DBG_HELPER(dbg);
+    switch (dev.model->asic_type) {
+        case AsicType::GL646:
+        case AsicType::GL841:
+        case AsicType::GL843:
+        case AsicType::GL845:
+        case AsicType::GL846:
+        case AsicType::GL847:
+        case AsicType::GL124:
+            break;
+        default:
+            throw SaneException("Unsupported chip");
+    }
+
+    if (start_motor) {
+        dev.interface->write_register(0x0f, 0x01);
+    } else {
+        dev.interface->write_register(0x0f, 0);
+    }
+}
+
+void sanei_genesys_set_dpihw(Genesys_Register_Set& regs, const Genesys_Sensor& sensor,
+                             unsigned dpihw)
+{
+    // same across GL646, GL841, GL843, GL846, GL847, GL124
+    const uint8_t REG_0x05_DPIHW_MASK = 0xc0;
+    const uint8_t REG_0x05_DPIHW_600 = 0x00;
+    const uint8_t REG_0x05_DPIHW_1200 = 0x40;
+    const uint8_t REG_0x05_DPIHW_2400 = 0x80;
+    const uint8_t REG_0x05_DPIHW_4800 = 0xc0;
+
+    if (sensor.register_dpihw_override != 0) {
+        dpihw = sensor.register_dpihw_override;
+    }
+
+    uint8_t dpihw_setting;
+    switch (dpihw) {
+        case 600:
+            dpihw_setting = REG_0x05_DPIHW_600;
+            break;
+        case 1200:
+            dpihw_setting = REG_0x05_DPIHW_1200;
+            break;
+        case 2400:
+            dpihw_setting = REG_0x05_DPIHW_2400;
+            break;
+        case 4800:
+            dpihw_setting = REG_0x05_DPIHW_4800;
+            break;
+        default:
+            throw SaneException("Unknown dpihw value: %d", dpihw);
+    }
+    regs.set8_mask(0x05, dpihw_setting, REG_0x05_DPIHW_MASK);
+}
+
+void regs_set_exposure(AsicType asic_type, Genesys_Register_Set& regs,
+                       const SensorExposure& exposure)
+{
+    switch (asic_type) {
+        case AsicType::GL124: {
+            regs.set24(gl124::REG_EXPR, exposure.red);
+            regs.set24(gl124::REG_EXPG, exposure.green);
+            regs.set24(gl124::REG_EXPB, exposure.blue);
+            break;
+        }
+        case AsicType::GL646: {
+            regs.set16(gl646::REG_EXPR, exposure.red);
+            regs.set16(gl646::REG_EXPG, exposure.green);
+            regs.set16(gl646::REG_EXPB, exposure.blue);
+            break;
+        }
+        case AsicType::GL841: {
+            regs.set16(gl841::REG_EXPR, exposure.red);
+            regs.set16(gl841::REG_EXPG, exposure.green);
+            regs.set16(gl841::REG_EXPB, exposure.blue);
+            break;
+        }
+        case AsicType::GL843: {
+            regs.set16(gl843::REG_EXPR, exposure.red);
+            regs.set16(gl843::REG_EXPG, exposure.green);
+            regs.set16(gl843::REG_EXPB, exposure.blue);
+            break;
+        }
+        case AsicType::GL845:
+        case AsicType::GL846: {
+            regs.set16(gl846::REG_EXPR, exposure.red);
+            regs.set16(gl846::REG_EXPG, exposure.green);
+            regs.set16(gl846::REG_EXPB, exposure.blue);
+            break;
+        }
+        case AsicType::GL847: {
+            regs.set16(gl847::REG_EXPR, exposure.red);
+            regs.set16(gl847::REG_EXPG, exposure.green);
+            regs.set16(gl847::REG_EXPB, exposure.blue);
+            break;
+        }
+        default:
+            throw SaneException("Unsupported asic");
+    }
+}
+
+void regs_set_optical_off(AsicType asic_type, Genesys_Register_Set& regs)
+{
+    DBG_HELPER(dbg);
+    switch (asic_type) {
+        case AsicType::GL646: {
+            regs.find_reg(gl646::REG_0x01).value &= ~gl646::REG_0x01_SCAN;
+            break;
+        }
+        case AsicType::GL841: {
+            regs.find_reg(gl841::REG_0x01).value &= ~gl841::REG_0x01_SCAN;
+            break;
+        }
+        case AsicType::GL843: {
+            regs.find_reg(gl843::REG_0x01).value &= ~gl843::REG_0x01_SCAN;
+            break;
+        }
+        case AsicType::GL845:
+        case AsicType::GL846: {
+            regs.find_reg(gl846::REG_0x01).value &= ~gl846::REG_0x01_SCAN;
+            break;
+        }
+        case AsicType::GL847: {
+            regs.find_reg(gl847::REG_0x01).value &= ~gl847::REG_0x01_SCAN;
+            break;
+        }
+        case AsicType::GL124: {
+            regs.find_reg(gl124::REG_0x01).value &= ~gl124::REG_0x01_SCAN;
+            break;
+        }
+        default:
+            throw SaneException("Unsupported asic");
+    }
+}
+
+bool get_registers_gain4_bit(AsicType asic_type, const Genesys_Register_Set& regs)
+{
+    switch (asic_type) {
+        case AsicType::GL646:
+            return static_cast<bool>(regs.get8(gl646::REG_0x06) & gl646::REG_0x06_GAIN4);
+        case AsicType::GL841:
+            return static_cast<bool>(regs.get8(gl841::REG_0x06) & gl841::REG_0x06_GAIN4);
+        case AsicType::GL843:
+            return static_cast<bool>(regs.get8(gl843::REG_0x06) & gl843::REG_0x06_GAIN4);
+        case AsicType::GL845:
+        case AsicType::GL846:
+            return static_cast<bool>(regs.get8(gl846::REG_0x06) & gl846::REG_0x06_GAIN4);
+        case AsicType::GL847:
+            return static_cast<bool>(regs.get8(gl847::REG_0x06) & gl847::REG_0x06_GAIN4);
+        case AsicType::GL124:
+            return static_cast<bool>(regs.get8(gl124::REG_0x06) & gl124::REG_0x06_GAIN4);
+        default:
+            throw SaneException("Unsupported chipset");
+    }
+}
+
+/**
+ * Wait for the scanning head to park
+ */
+void sanei_genesys_wait_for_home(Genesys_Device* dev)
+{
+    DBG_HELPER(dbg);
+
+  /* clear the parking status whatever the outcome of the function */
+    dev->parking = false;
+
+    if (is_testing_mode()) {
+        return;
+    }
+
+    // read initial status, if head isn't at home and motor is on we are parking, so we wait.
+    // gl847/gl124 need 2 reads for reliable results
+    auto status = scanner_read_status(*dev);
+    dev->interface->sleep_ms(10);
+    status = scanner_read_status(*dev);
+
+    if (status.is_at_home) {
+	  DBG (DBG_info,
+	       "%s: already at home\n", __func__);
+        return;
+    }
+
+    unsigned timeout_ms = 200000;
+    unsigned elapsed_ms = 0;
+  do
+    {
+      dev->interface->sleep_ms(100);
+        elapsed_ms += 100;
+
+        status = scanner_read_status(*dev);
+    } while (elapsed_ms < timeout_ms && !status.is_at_home);
+
+  /* if after the timeout, head is still not parked, error out */
+    if (elapsed_ms >= timeout_ms && !status.is_at_home) {
+        DBG (DBG_error, "%s: failed to reach park position in %dseconds\n", __func__,
+             timeout_ms / 1000);
+        throw SaneException(SANE_STATUS_IO_ERROR, "failed to reach park position");
+    }
+}
+
+/** @brief motor profile
+ * search for the database of motor profiles and get the best one. Each
+ * profile is at full step and at a reference exposure. Use first entry
+ * by default.
+ * @param motors motor profile database
+ * @param motor_type motor id
+ * @param exposure exposure time
+ * @return a pointer to a Motor_Profile struct
+ */
+const Motor_Profile& sanei_genesys_get_motor_profile(const std::vector<Motor_Profile>& motors,
+                                                     MotorId motor_id, int exposure)
+{
+  int idx;
+
+  idx=-1;
+    for (std::size_t i = 0; i < motors.size(); ++i) {
+        // exact match
+        if (motors[i].motor_id == motor_id && motors[i].exposure==exposure) {
+            return motors[i];
+        }
+
+        // closest match
+        if (motors[i].motor_id == motor_id) {
+          /* if profile exposure is higher than the required one,
+           * the entry is a candidate for the closest match */
+            if (motors[i].exposure == 0 || motors[i].exposure >= exposure)
+            {
+              if(idx<0)
+                {
+                  /* no match found yet */
+                  idx=i;
+                }
+              else
+                {
+                  /* test for better match */
+                  if(motors[i].exposure<motors[idx].exposure)
+                    {
+                      idx=i;
+                    }
+                }
+            }
+        }
+    }
+
+  /* default fallback */
+  if(idx<0)
+    {
+      DBG (DBG_warn,"%s: using default motor profile\n",__func__);
+      idx=0;
+    }
+
+    return motors[idx];
+}
+
+MotorSlopeTable sanei_genesys_slope_table(AsicType asic_type, int dpi, int exposure, int base_dpi,
+                                          unsigned step_multiplier,
+                                          const Motor_Profile& motor_profile)
+{
+    unsigned target_speed_w = ((exposure * dpi) / base_dpi);
+
+    auto table = create_slope_table(motor_profile.slope, target_speed_w, motor_profile.step_type,
+                                    step_multiplier, 2 * step_multiplier,
+                                    get_slope_table_max_size(asic_type));
+    return table;
+}
+
+MotorSlopeTable create_slope_table_fastest(AsicType asic_type, unsigned step_multiplier,
+                                           const Motor_Profile& motor_profile)
+{
+    return create_slope_table(motor_profile.slope, motor_profile.slope.max_speed_w,
+                              motor_profile.step_type,
+                              step_multiplier, 2 * step_multiplier,
+                              get_slope_table_max_size(asic_type));
+}
+
+/** @brief returns the lowest possible ydpi for the device
+ * Parses device entry to find lowest motor dpi.
+ * @param dev device description
+ * @return lowest motor resolution
+ */
+int sanei_genesys_get_lowest_ydpi(Genesys_Device *dev)
+{
+    const auto& resolution_settings = dev->model->get_resolution_settings(dev->settings.scan_method);
+    return resolution_settings.get_min_resolution_y();
+}
+
+/** @brief returns the lowest possible dpi for the device
+ * Parses device entry to find lowest motor or sensor dpi.
+ * @param dev device description
+ * @return lowest motor resolution
+ */
+int sanei_genesys_get_lowest_dpi(Genesys_Device *dev)
+{
+    const auto& resolution_settings = dev->model->get_resolution_settings(dev->settings.scan_method);
+    return std::min(resolution_settings.get_min_resolution_x(),
+                    resolution_settings.get_min_resolution_y());
+}
+
+/** @brief check is a cache entry may be used
+ * Compares current settings with the cache entry and return
+ * true if they are compatible.
+ * A calibration cache is compatible if color mode and x dpi match the user
+ * requested scan. In the case of CIS scanners, dpi isn't a criteria.
+ * flatbed cache entries are considred too old and then expires if they
+ * are older than the expiration time option, forcing calibration at least once
+ * then given time. */
+bool sanei_genesys_is_compatible_calibration(Genesys_Device* dev,
+                                             const ScanSession& session,
+                                             const Genesys_Calibration_Cache* cache,
+                                             bool for_overwrite)
+{
+    DBG_HELPER(dbg);
+#ifdef HAVE_SYS_TIME_H
+  struct timeval time;
+#endif
+
+    bool compatible = true;
+
+    const auto& dev_params = session.params;
+
+    if (dev_params.scan_method != cache->params.scan_method) {
+        dbg.vlog(DBG_io, "incompatible: scan_method %d vs. %d\n",
+                 static_cast<unsigned>(dev_params.scan_method),
+                 static_cast<unsigned>(cache->params.scan_method));
+        compatible = false;
+    }
+
+    if (dev_params.xres != cache->params.xres) {
+        dbg.vlog(DBG_io, "incompatible: params.xres %d vs. %d\n",
+                 dev_params.xres, cache->params.xres);
+        compatible = false;
+    }
+
+    if (dev_params.yres != cache->params.yres) {
+        // exposure depends on selected sensor and we select the sensor according to yres
+        dbg.vlog(DBG_io, "incompatible: params.yres %d vs. %d\n",
+                 dev_params.yres, cache->params.yres);
+        compatible = false;
+    }
+
+    if (dev_params.channels != cache->params.channels) {
+        // exposure depends on total number of pixels at least on gl841
+        dbg.vlog(DBG_io, "incompatible: params.channels %d vs. %d\n",
+                 dev_params.channels, cache->params.channels);
+        compatible = false;
+    }
+
+    if (dev_params.startx != cache->params.startx) {
+        // exposure depends on total number of pixels at least on gl841
+        dbg.vlog(DBG_io, "incompatible: params.startx %d vs. %d\n",
+                 dev_params.startx, cache->params.startx);
+        compatible = false;
+    }
+
+    if (dev_params.pixels != cache->params.pixels) {
+        // exposure depends on total number of pixels at least on gl841
+        dbg.vlog(DBG_io, "incompatible: params.pixels %d vs. %d\n",
+                 dev_params.pixels, cache->params.pixels);
+        compatible = false;
+    }
+
+  if (!compatible)
+    {
+      DBG (DBG_proc, "%s: completed, non compatible cache\n", __func__);
+      return false;
+    }
+
+  /* a cache entry expires after afetr expiration time for non sheetfed scanners */
+  /* this is not taken into account when overwriting cache entries    */
+#ifdef HAVE_SYS_TIME_H
+    if (!for_overwrite && dev->settings.expiration_time >=0)
+    {
+        gettimeofday(&time, nullptr);
+      if ((time.tv_sec - cache->last_calibration > dev->settings.expiration_time*60)
+          && !dev->model->is_sheetfed
+          && (dev->settings.scan_method == ScanMethod::FLATBED))
+        {
+          DBG (DBG_proc, "%s: expired entry, non compatible cache\n", __func__);
+          return false;
+        }
+    }
+#endif
+
+  return true;
+}
+
+/** @brief build lookup table for digital enhancements
+ * Function to build a lookup table (LUT), often
+   used by scanners to implement brightness/contrast/gamma
+   or by backends to speed binarization/thresholding
+
+   offset and slope inputs are -127 to +127
+
+   slope rotates line around central input/output val,
+   0 makes horizontal line
+
+       pos           zero          neg
+       .       x     .             .  x
+       .      x      .             .   x
+   out .     x       .xxxxxxxxxxx  .    x
+       .    x        .             .     x
+       ....x.......  ............  .......x....
+            in            in            in
+
+   offset moves line vertically, and clamps to output range
+   0 keeps the line crossing the center of the table
+
+       high           low
+       .   xxxxxxxx   .
+       . x            .
+   out x              .          x
+       .              .        x
+       ............   xxxxxxxx....
+            in             in
+
+   out_min/max provide bounds on output values,
+   useful when building thresholding lut.
+   0 and 255 are good defaults otherwise.
+  * @param lut pointer where to store the generated lut
+  * @param in_bits number of bits for in values
+  * @param out_bits number of bits of out values
+  * @param out_min minimal out value
+  * @param out_max maximal out value
+  * @param slope slope of the generated data
+  * @param offset offset of the generated data
+  */
+void sanei_genesys_load_lut(unsigned char* lut,
+                            int in_bits, int out_bits,
+                            int out_min, int out_max,
+                            int slope, int offset)
+{
+    DBG_HELPER(dbg);
+  int i, j;
+  double shift, rise;
+  int max_in_val = (1 << in_bits) - 1;
+  int max_out_val = (1 << out_bits) - 1;
+  uint8_t *lut_p8 = lut;
+    uint16_t* lut_p16 = reinterpret_cast<std::uint16_t*>(lut);
+
+  /* slope is converted to rise per unit run:
+   * first [-127,127] to [-.999,.999]
+   * then to [-PI/4,PI/4] then [0,PI/2]
+   * then take the tangent (T.O.A)
+   * then multiply by the normal linear slope
+   * because the table may not be square, i.e. 1024x256*/
+    auto pi_4 = M_PI / 4.0;
+    rise = std::tan(static_cast<double>(slope) / 128 * pi_4 + pi_4) * max_out_val / max_in_val;
+
+  /* line must stay vertically centered, so figure
+   * out vertical offset at central input value */
+    shift = static_cast<double>(max_out_val) / 2 - (rise * max_in_val / 2);
+
+  /* convert the user offset setting to scale of output
+   * first [-127,127] to [-1,1]
+   * then to [-max_out_val/2,max_out_val/2]*/
+    shift += static_cast<double>(offset) / 127 * max_out_val / 2;
+
+  for (i = 0; i <= max_in_val; i++)
+    {
+        j = static_cast<int>(rise * i + shift);
+
+      /* cap data to required range */
+      if (j < out_min)
+	{
+	  j = out_min;
+	}
+      else if (j > out_max)
+	{
+	  j = out_max;
+	}
+
+      /* copy result according to bit depth */
+      if (out_bits <= 8)
+	{
+	  *lut_p8 = j;
+	  lut_p8++;
+	}
+      else
+	{
+	  *lut_p16 = j;
+	  lut_p16++;
+	}
+    }
+}
+
+} // namespace genesys