summaryrefslogtreecommitdiff
path: root/backend/genesys/sensor.h
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2020-02-02 17:13:42 +0100
committerJörg Frings-Fürst <debian@jff-webhosting.net>2020-02-02 17:13:42 +0100
commit3dade5db2a37543f19f0967901d8d80a52a1e459 (patch)
tree808b2499b54563b3290f34d70d159b1024310873 /backend/genesys/sensor.h
parent5bb4cf12855ec0151de15d6c5a2354ff08766957 (diff)
parentffa8801644a7d53cc1c785e3450f794c07a14eb0 (diff)
Update upstream source from tag 'upstream/1.0.29'
Update to upstream version '1.0.29' with Debian dir 2d358af604988ebe4348e38096245d66036fe5ed
Diffstat (limited to 'backend/genesys/sensor.h')
-rw-r--r--backend/genesys/sensor.h470
1 files changed, 470 insertions, 0 deletions
diff --git a/backend/genesys/sensor.h b/backend/genesys/sensor.h
new file mode 100644
index 0000000..e70728e
--- /dev/null
+++ b/backend/genesys/sensor.h
@@ -0,0 +1,470 @@
+/* sane - Scanner Access Now Easy.
+
+ Copyright (C) 2019 Povilas Kanapickas <povilas@radix.lt>
+
+ 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.
+*/
+
+#ifndef BACKEND_GENESYS_SENSOR_H
+#define BACKEND_GENESYS_SENSOR_H
+
+#include "enums.h"
+#include "register.h"
+#include "serialize.h"
+#include <array>
+#include <functional>
+
+namespace genesys {
+
+template<class T, size_t Size>
+struct AssignableArray : public std::array<T, Size> {
+ AssignableArray() = default;
+ AssignableArray(const AssignableArray&) = default;
+ AssignableArray& operator=(const AssignableArray&) = default;
+
+ AssignableArray& operator=(std::initializer_list<T> init)
+ {
+ if (init.size() != std::array<T, Size>::size())
+ throw std::runtime_error("An array of incorrect size assigned");
+ std::copy(init.begin(), init.end(), std::array<T, Size>::begin());
+ return *this;
+ }
+};
+
+
+class StaggerConfig
+{
+public:
+ StaggerConfig() = default;
+ StaggerConfig(unsigned min_resolution, unsigned lines_at_min) :
+ min_resolution_{min_resolution},
+ lines_at_min_{lines_at_min}
+ {
+ }
+
+ unsigned stagger_at_resolution(unsigned xresolution, unsigned yresolution) const
+ {
+ if (min_resolution_ == 0 || xresolution < min_resolution_)
+ return 0;
+ return yresolution / min_resolution_ * lines_at_min_;
+ }
+
+ unsigned min_resolution() const { return min_resolution_; }
+ unsigned lines_at_min() const { return lines_at_min_; }
+
+ bool operator==(const StaggerConfig& other) const
+ {
+ return min_resolution_ == other.min_resolution_ &&
+ lines_at_min_ == other.lines_at_min_;
+ }
+
+private:
+ unsigned min_resolution_ = 0;
+ unsigned lines_at_min_ = 0;
+
+ template<class Stream>
+ friend void serialize(Stream& str, StaggerConfig& x);
+};
+
+template<class Stream>
+void serialize(Stream& str, StaggerConfig& x)
+{
+ serialize(str, x.min_resolution_);
+ serialize(str, x.lines_at_min_);
+}
+
+std::ostream& operator<<(std::ostream& out, const StaggerConfig& config);
+
+
+enum class FrontendType : unsigned
+{
+ UNKNOWN,
+ WOLFSON,
+ ANALOG_DEVICES
+};
+
+inline void serialize(std::istream& str, FrontendType& x)
+{
+ unsigned value;
+ serialize(str, value);
+ x = static_cast<FrontendType>(value);
+}
+
+inline void serialize(std::ostream& str, FrontendType& x)
+{
+ unsigned value = static_cast<unsigned>(x);
+ serialize(str, value);
+}
+
+std::ostream& operator<<(std::ostream& out, const FrontendType& type);
+
+struct GenesysFrontendLayout
+{
+ FrontendType type = FrontendType::UNKNOWN;
+ std::array<std::uint16_t, 3> offset_addr = {};
+ std::array<std::uint16_t, 3> gain_addr = {};
+
+ bool operator==(const GenesysFrontendLayout& other) const
+ {
+ return type == other.type &&
+ offset_addr == other.offset_addr &&
+ gain_addr == other.gain_addr;
+ }
+};
+
+template<class Stream>
+void serialize(Stream& str, GenesysFrontendLayout& x)
+{
+ serialize(str, x.type);
+ serialize_newline(str);
+ serialize(str, x.offset_addr);
+ serialize_newline(str);
+ serialize(str, x.gain_addr);
+}
+
+std::ostream& operator<<(std::ostream& out, const GenesysFrontendLayout& layout);
+
+/** @brief Data structure to set up analog frontend.
+ The analog frontend converts analog value from image sensor to digital value. It has its own
+ control registers which are set up with this structure. The values are written using
+ fe_write_data.
+ */
+struct Genesys_Frontend
+{
+ Genesys_Frontend() = default;
+
+ // id of the frontend description
+ AdcId id = AdcId::UNKNOWN;
+
+ // all registers of the frontend. Note that the registers can hold 9-bit values
+ RegisterSettingSet<std::uint16_t> regs;
+
+ // extra control registers
+ std::array<std::uint16_t, 3> reg2 = {};
+
+ GenesysFrontendLayout layout;
+
+ void set_offset(unsigned which, std::uint16_t value)
+ {
+ regs.set_value(layout.offset_addr[which], value);
+ }
+
+ void set_gain(unsigned which, std::uint16_t value)
+ {
+ regs.set_value(layout.gain_addr[which], value);
+ }
+
+ std::uint16_t get_offset(unsigned which) const
+ {
+ return regs.get_value(layout.offset_addr[which]);
+ }
+
+ std::uint16_t get_gain(unsigned which) const
+ {
+ return regs.get_value(layout.gain_addr[which]);
+ }
+
+ bool operator==(const Genesys_Frontend& other) const
+ {
+ return id == other.id &&
+ regs == other.regs &&
+ reg2 == other.reg2 &&
+ layout == other.layout;
+ }
+};
+
+std::ostream& operator<<(std::ostream& out, const Genesys_Frontend& frontend);
+
+template<class Stream>
+void serialize(Stream& str, Genesys_Frontend& x)
+{
+ serialize(str, x.id);
+ serialize_newline(str);
+ serialize(str, x.regs);
+ serialize_newline(str);
+ serialize(str, x.reg2);
+ serialize_newline(str);
+ serialize(str, x.layout);
+}
+
+struct SensorExposure {
+ std::uint16_t red = 0;
+ std::uint16_t green = 0;
+ std::uint16_t blue = 0;
+
+ SensorExposure() = default;
+ SensorExposure(std::uint16_t r, std::uint16_t g, std::uint16_t b) :
+ red{r}, green{g}, blue{b}
+ {}
+
+ bool operator==(const SensorExposure& other) const
+ {
+ return red == other.red && green == other.green && blue == other.blue;
+ }
+};
+
+std::ostream& operator<<(std::ostream& out, const SensorExposure& exposure);
+
+
+class ResolutionFilter
+{
+public:
+ struct Any {};
+ static constexpr Any ANY{};
+
+ ResolutionFilter() : matches_any_{false} {}
+ ResolutionFilter(Any) : matches_any_{true} {}
+ ResolutionFilter(std::initializer_list<unsigned> resolutions) :
+ matches_any_{false},
+ resolutions_{resolutions}
+ {}
+
+ bool matches(unsigned resolution) const
+ {
+ if (matches_any_)
+ return true;
+ auto it = std::find(resolutions_.begin(), resolutions_.end(), resolution);
+ return it != resolutions_.end();
+ }
+
+ bool operator==(const ResolutionFilter& other) const
+ {
+ return matches_any_ == other.matches_any_ && resolutions_ == other.resolutions_;
+ }
+
+ bool matches_any() const { return matches_any_; }
+ const std::vector<unsigned>& resolutions() const { return resolutions_; }
+
+private:
+ bool matches_any_ = false;
+ std::vector<unsigned> resolutions_;
+
+ template<class Stream>
+ friend void serialize(Stream& str, ResolutionFilter& x);
+};
+
+std::ostream& operator<<(std::ostream& out, const ResolutionFilter& resolutions);
+
+template<class Stream>
+void serialize(Stream& str, ResolutionFilter& x)
+{
+ serialize(str, x.matches_any_);
+ serialize_newline(str);
+ serialize(str, x.resolutions_);
+}
+
+
+struct Genesys_Sensor {
+
+ Genesys_Sensor() = default;
+ ~Genesys_Sensor() = default;
+
+ // id of the sensor description
+ SensorId sensor_id = SensorId::UNKNOWN;
+
+ // sensor resolution in CCD pixels. Note that we may read more than one CCD pixel per logical
+ // pixel, see ccd_pixels_per_system_pixel()
+ unsigned optical_res = 0;
+
+ // the resolution list that the sensor is usable at.
+ ResolutionFilter resolutions = ResolutionFilter::ANY;
+
+ // the channel list that the sensor is usable at
+ std::vector<unsigned> channels = { 1, 3 };
+
+ // the scan method used with the sensor
+ ScanMethod method = ScanMethod::FLATBED;
+
+ // The scanner may be setup to use a custom dpihw that does not correspond to any actual
+ // resolution. The value zero does not set the override.
+ unsigned register_dpihw_override = 0;
+
+ // The scanner may be setup to use a custom logical dpihw that does not correspond to any actual
+ // resolution. The value zero does not set the override.
+ unsigned logical_dpihw_override = 0;
+
+ // The scanner may be setup to use a custom dpiset value that does not correspond to any actual
+ // resolution. The value zero does not set the override.
+ unsigned dpiset_override = 0;
+
+ // CCD may present itself as half or quarter-size CCD on certain resolutions
+ int ccd_size_divisor = 1;
+
+ // Some scanners need an additional multiplier over the scan coordinates
+ int pixel_count_multiplier = 1;
+
+ int black_pixels = 0;
+ // value of the dummy register
+ int dummy_pixel = 0;
+ // last pixel of CCD margin at optical resolution
+ int ccd_start_xoffset = 0;
+ // total pixels used by the sensor
+ int sensor_pixels = 0;
+ // TA CCD target code (reference gain)
+ int fau_gain_white_ref = 0;
+ // CCD target code (reference gain)
+ int gain_white_ref = 0;
+
+ // red, green and blue initial exposure values
+ SensorExposure exposure;
+
+ int exposure_lperiod = -1;
+
+ // the number of pixels in a single segment.
+ // only on gl843
+ unsigned segment_size = 0;
+
+ // the order of the segments, if any, for the sensor. If the sensor is not segmented or uses
+ // only single segment, this array can be empty
+ // only on gl843
+ std::vector<unsigned> segment_order;
+
+ // some CCDs use two arrays of pixels for double resolution. On such CCDs when scanning at
+ // high-enough resolution, every other pixel column is shifted
+ StaggerConfig stagger_config;
+
+ GenesysRegisterSettingSet custom_base_regs; // gl646-specific
+ GenesysRegisterSettingSet custom_regs;
+ GenesysRegisterSettingSet custom_fe_regs;
+
+ // red, green and blue gamma coefficient for default gamma tables
+ AssignableArray<float, 3> gamma;
+
+ std::function<unsigned(const Genesys_Sensor&, unsigned)> get_logical_hwdpi_fun;
+ std::function<unsigned(const Genesys_Sensor&, unsigned)> get_register_hwdpi_fun;
+ std::function<unsigned(const Genesys_Sensor&, unsigned)> get_ccd_size_divisor_fun;
+ std::function<unsigned(const Genesys_Sensor&, unsigned)> get_hwdpi_divisor_fun;
+
+ unsigned get_logical_hwdpi(unsigned xres) const { return get_logical_hwdpi_fun(*this, xres); }
+ unsigned get_register_hwdpi(unsigned xres) const { return get_register_hwdpi_fun(*this, xres); }
+ unsigned get_ccd_size_divisor_for_dpi(unsigned xres) const
+ {
+ return get_ccd_size_divisor_fun(*this, xres);
+ }
+ unsigned get_hwdpi_divisor_for_dpi(unsigned xres) const
+ {
+ return get_hwdpi_divisor_fun(*this, xres);
+ }
+
+ // how many CCD pixels are processed per system pixel time. This corresponds to CKSEL + 1
+ unsigned ccd_pixels_per_system_pixel() const
+ {
+ // same on GL646, GL841, GL843, GL846, GL847, GL124
+ constexpr unsigned REG_CKSEL = 0x03;
+ return (custom_regs.get_value(0x18) & REG_CKSEL) + 1;
+ }
+
+ bool matches_channel_count(unsigned count) const
+ {
+ return std::find(channels.begin(), channels.end(), count) != channels.end();
+ }
+
+ unsigned get_segment_count() const
+ {
+ if (segment_order.size() < 2)
+ return 1;
+ return segment_order.size();
+ }
+
+ bool operator==(const Genesys_Sensor& other) const
+ {
+ return sensor_id == other.sensor_id &&
+ optical_res == other.optical_res &&
+ resolutions == other.resolutions &&
+ method == other.method &&
+ ccd_size_divisor == other.ccd_size_divisor &&
+ black_pixels == other.black_pixels &&
+ dummy_pixel == other.dummy_pixel &&
+ ccd_start_xoffset == other.ccd_start_xoffset &&
+ sensor_pixels == other.sensor_pixels &&
+ fau_gain_white_ref == other.fau_gain_white_ref &&
+ gain_white_ref == other.gain_white_ref &&
+ exposure == other.exposure &&
+ exposure_lperiod == other.exposure_lperiod &&
+ segment_size == other.segment_size &&
+ segment_order == other.segment_order &&
+ stagger_config == other.stagger_config &&
+ custom_base_regs == other.custom_base_regs &&
+ custom_regs == other.custom_regs &&
+ custom_fe_regs == other.custom_fe_regs &&
+ gamma == other.gamma;
+ }
+};
+
+template<class Stream>
+void serialize(Stream& str, Genesys_Sensor& x)
+{
+ serialize(str, x.sensor_id);
+ serialize(str, x.optical_res);
+ serialize(str, x.resolutions);
+ serialize(str, x.method);
+ serialize(str, x.ccd_size_divisor);
+ serialize(str, x.black_pixels);
+ serialize(str, x.dummy_pixel);
+ serialize(str, x.ccd_start_xoffset);
+ serialize(str, x.sensor_pixels);
+ serialize(str, x.fau_gain_white_ref);
+ serialize(str, x.gain_white_ref);
+ serialize_newline(str);
+ serialize(str, x.exposure.blue);
+ serialize(str, x.exposure.green);
+ serialize(str, x.exposure.red);
+ serialize(str, x.exposure_lperiod);
+ serialize_newline(str);
+ serialize(str, x.segment_size);
+ serialize_newline(str);
+ serialize(str, x.segment_order);
+ serialize_newline(str);
+ serialize(str, x.stagger_config);
+ serialize_newline(str);
+ serialize(str, x.custom_base_regs);
+ serialize_newline(str);
+ serialize(str, x.custom_regs);
+ serialize_newline(str);
+ serialize(str, x.custom_fe_regs);
+ serialize_newline(str);
+ serialize(str, x.gamma);
+ serialize_newline(str);
+}
+
+std::ostream& operator<<(std::ostream& out, const Genesys_Sensor& sensor);
+
+} // namespace genesys
+
+#endif // BACKEND_GENESYS_SENSOR_H