MPP v2+, Slim Pen 2, Surface Pro 9 improvements

etc/presets/surface-pro-9.conf

@@ -0,0 +1,11 @@
+[Device]
+Vendor = 0x045E
+Product = 0x0C52
+
+[Stylus]
+MPPVersion = v2
+
+[DFT]
+ButtonMinMag = 50000
+ContactMinMag = 50000
+PositionMinMag = 500

src/core/generic/config.hpp

@@ -17,6 +17,14 @@ namespace iptsd::core {
 
 class Config {
 public:
+	// Enum to denote which Pen Protocol is being used.
+	enum class MPPVersion {
+		// Used for Microsoft Pen Protocol v1 compliant pens.
+		V1,
+		// Used for Microsoft Pen Protocol v2 compliant pens.
+		V2,
+	};
+
 	// [Config]
 	bool invert_x = false;
 	bool invert_y = false;
@@ -49,6 +57,7 @@ class Config {
 	// [Stylus]
 	bool stylus_disable = false;
 	f64 stylus_tip_distance = 0;
+	MPPVersion stylus_mpp_version = MPPVersion::V1;
 
 	// [DFT]
 	usize dft_position_min_amp = 50;
@@ -57,6 +66,7 @@ class Config {
 	usize dft_button_min_mag = 1000;
 	usize dft_freq_min_mag = 10000;
 	usize dft_tilt_min_mag = 10000;
+	usize dft_contact_min_mag = 10000;
 	f64 dft_tilt_distance = 0.6;
 
 public:

src/core/generic/dft.hpp

@@ -28,6 +28,17 @@ class DftStylus {
 	i32 m_imag = 0;
 	std::optional<u32> m_group = std::nullopt;
 
+	// This is a bit of a hack, for the MPP v2 button detection we only
+	// care about the first 0x0a dft window, but there's two in the frame,
+	// here we keep track of the group when 0x0a was encountered, this
+	// allows comparing against this group and only using the first 0x0a
+	// frame.
+	std::optional<u32> m_dft_0x0a_group = std::nullopt;
+
+	// Boolean to track whether the pen is in contact, used by the method
+	// that processes the pressure frame.
+	bool m_mppv2_in_contact {false};
+
 public:
 	DftStylus(Config config, const std::optional<const ipts::Metadata> &metadata)
 		: m_config {std::move(config)},
@@ -50,6 +61,12 @@ class DftStylus {
 		case ipts::protocol::dft::Type::Pressure:
 			this->handle_pressure(dft);
 			break;
+		case ipts::protocol::dft::Type::Position2:
+			this->handle_position2(dft);
+			break;
+		case ipts::protocol::dft::Type::Dft0x0a:
+			this->handle_dft_0x0a(dft);
+			break;
 		default:
 			// Ignored
 			break;
@@ -185,7 +202,10 @@ class DftStylus {
 			rubber = val > 0;
 		}
 
-		m_stylus.button = button;
+		// Only set the button value if we're using a v1 pen.
+		if (m_config.stylus_mpp_version == Config::MPPVersion::V1) {
+			m_stylus.button = button;
+		}
 		m_stylus.rubber = rubber;
 	}
 
@@ -206,11 +226,79 @@ class DftStylus {
 			m_stylus.contact = true;
 			m_stylus.pressure = std::clamp(p, 0.0, 1.0);
 		} else {
-			m_stylus.contact = false;
+			m_stylus.contact = false || m_mppv2_in_contact; // NOLINT
 			m_stylus.pressure = 0;
 		}
 	}
 
+	/*!
+	 * Determines the current button state from the 0x0a frame, it can
+	 * only be used for MPP v2 pens. The eraser is still obtained from the
+	 * phase using the button frame.
+	 */
+	void handle_dft_0x0a(const ipts::DftWindow &dft)
+	{
+		if (m_config.stylus_mpp_version != Config::MPPVersion::V2) {
+			return;
+		}
+
+		if (dft.x.size() <= 5) { // not sure if this can happen?
+			m_stylus.button = false;
+			return;
+		}
+
+		// Second time we see the 0x0a frame in this group, skip it.
+		if (!dft.group.has_value() || m_dft_0x0a_group == dft.group)
+			return;
+
+		m_dft_0x0a_group = dft.group;
+
+		// Now, we can process the frame to determine button state.
+		// First, collapse x and y, they convey the same information.
+		const auto mag_4 = dft.x[4].magnitude + dft.y[4].magnitude;
+		const auto mag_5 = dft.x[5].magnitude + dft.y[5].magnitude;
+		const auto threshold = 2 * m_config.dft_button_min_mag;
+
+		if (mag_4 < threshold && mag_5 < threshold) {
+			// Not enough signal, lets disable the button
+			m_stylus.button = false;
+			return;
+		}
+
+		// One of them is above the threshold, if 5 is higher than 4, button
+		// is held.
+		m_stylus.button = mag_4 < mag_5;
+	}
+
+	/*!
+	 * Determines whether the pen is making contact with the screen, it can
+	 * only be used for MPP v2 pens.
+	 */
+	void handle_position2(const ipts::DftWindow &dft)
+	{
+		if (m_config.stylus_mpp_version != Config::MPPVersion::V2) {
+			return;
+		}
+
+		// Set to false in case we return early.
+		m_mppv2_in_contact = false;
+
+		if (dft.x.size() <= 3) { // not sure if this can happen?
+			return;
+		}
+
+		const auto mag_2 = dft.x[2].magnitude + dft.y[2].magnitude;
+		const auto mag_3 = dft.x[3].magnitude + dft.y[3].magnitude;
+
+		const auto threshold = 2 * m_config.dft_contact_min_mag;
+		if (mag_2 < threshold && mag_3 < threshold) {
+			return;
+		}
+
+		// The pen switches the row from two to three when there's contact.
+		m_mppv2_in_contact = mag_2 < mag_3;
+	}
+
 	/*!
 	 * Interpolates the current stylus position from a list of antenna measurements.
 	 *

src/core/linux/config-loader.hpp

@@ -27,6 +27,8 @@ class ConfigLoader {
 	Config m_config {};
 	DeviceInfo m_info;
 
+	bool m_loaded_config {false};
+
 public:
 	ConfigLoader(const DeviceInfo &info, const std::optional<const ipts::Metadata> &metadata)
 		: m_info {info}
@@ -48,14 +50,21 @@ class ConfigLoader {
 		 * known working main system configuration.
 		 */
 		if (const char *config_file_path = std::getenv("IPTSD_CONFIG_FILE")) {
+			spdlog::info("Loading config {}, specified with IPTSD_CONFIG_FILE.",
+			             config_file_path);
 			this->load_file(config_file_path);
 			return;
 		}
 
-		if (std::filesystem::exists(common::buildopts::ConfigFile))
+		if (std::filesystem::exists(common::buildopts::ConfigFile)) {
+			spdlog::info("Loading config {}.", common::buildopts::ConfigFile);
 			this->load_file(common::buildopts::ConfigFile);
+		}
 
 		this->load_dir(common::buildopts::ConfigDir, false);
+
+		if (!m_loaded_config)
+			spdlog::warn("No config file loaded at all, this is not good.");
 	}
 
 	/*!
@@ -95,6 +104,7 @@ class ConfigLoader {
 					continue;
 			}
 
+			spdlog::info("Loading config {}.", p.path().c_str());
 			this->load_file(p.path());
 		}
 	}
@@ -161,10 +171,12 @@ class ConfigLoader {
 
 		this->get(ini, "Stylus", "Disable", m_config.stylus_disable);
 		this->get(ini, "Stylus", "TipDistance", m_config.stylus_tip_distance);
+		this->get(ini, "Stylus", "MPPVersion", m_config.stylus_mpp_version);
 
 		this->get(ini, "DFT", "PositionMinAmp", m_config.dft_position_min_amp);
 		this->get(ini, "DFT", "PositionMinMag", m_config.dft_position_min_mag);
 		this->get(ini, "DFT", "PositionExp", m_config.dft_position_exp);
+		this->get(ini, "DFT", "ContactMinMag", m_config.dft_contact_min_mag);
 		this->get(ini, "DFT", "ButtonMinMag", m_config.dft_button_min_mag);
 		this->get(ini, "DFT", "FreqMinMag", m_config.dft_freq_min_mag);
 		this->get(ini, "DFT", "TiltMinMag", m_config.dft_tilt_min_mag);
@@ -175,6 +187,7 @@ class ConfigLoader {
 		this->get(ini, "Contacts", "SizeThreshold", m_config.contacts_size_thresh_max);
 
 		// clang-format on
+		m_loaded_config = true;
 	}
 
 	/*!
@@ -199,7 +212,21 @@ class ConfigLoader {
 			value = gsl::narrow_cast<T>(ini.GetReal(section, name, value));
 		else if constexpr (std::is_same_v<T, std::string>)
 			value = ini.GetString(section, name, value);
-		else
+		else if constexpr (std::is_same_v<T, Config::MPPVersion>) {
+			// Parse the pen protocol verison by first reading into a string.
+			const auto mpp_version = ini.GetString(section, name, "");
+			if (!mpp_version.empty()) {
+				if (mpp_version == "v1") {
+					value = Config::MPPVersion::V1;
+				} else if (mpp_version == "v2") {
+					value = Config::MPPVersion::V2;
+				} else {
+					throw common::Error<Error::ParsingInvalidValue> {
+						"Stylus mpp_version was not 'v1' or 'v2', got: " +
+						mpp_version};
+				}
+			}
+		} else
 			throw common::Error<Error::ParsingTypeNotImplemented> {typeid(T).name()};
 	}
 };

src/core/linux/errors.hpp

@@ -9,6 +9,7 @@ namespace iptsd::core::linux {
 
 enum class Error {
 	ParsingFailed,
+	ParsingInvalidValue,
 	ParsingTypeNotImplemented,
 	RunnerInitError,
 
@@ -25,6 +26,8 @@ inline std::string format_as(Error err)
 	switch (err) {
 	case Error::ParsingFailed:
 		return "core: linux: Failed to parse INI file {}!";
+	case Error::ParsingInvalidValue:
+		return "core: linux: Parsing encountered invalid value {}!";
 	case Error::ParsingTypeNotImplemented:
 		return "core: linux: Parsing not implemented for type {}!";
 	case Error::RunnerInitError:

src/ipts/parser.hpp

@@ -71,7 +71,6 @@ class Parser {
 	{
 		Reader reader(data);
 		reader.skip(header);
-
 		this->parse_hid_frame(reader);
 	}
 

src/ipts/protocol/dft.hpp

@@ -15,8 +15,10 @@ constexpr u8 PRESSURE_ROWS = 6;
 
 enum class Type : u8 {
 	Position = 6,
+	Position2 = 7,
 	Button = 9,
 	Pressure = 11,
+	Dft0x0a = 0x0a,
 };
 
 struct [[gnu::packed]] Metadata {