path: root/backend/genesys/low.cpp

/* 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