@desklink/host 0.1.0

package/engine/vendor/inputtino/src/c-bindings/joypad_switch.cpp

@@ -0,0 +1,63 @@
+#include "helpers.hpp"
+#include <inputtino/input.h>
+
+InputtinoSwitchJoypad *inputtino_joypad_switch_create(const InputtinoDeviceDefinition *device,
+                                                      const InputtinoErrorHandler *eh) {
+  auto joypad_ = inputtino::SwitchJoypad::create({
+      .name = device->name ? device->name : "Inputtino virtual device",
+      .vendor_id = device->vendor_id,
+      .product_id = device->product_id,
+      .version = device->version,
+      .device_phys = device->device_phys ? device->device_phys : "00:11:22:33:44:55",
+      .device_uniq = device->device_uniq ? device->device_uniq : "00:11:22:33:44:55",
+  });
+  if (joypad_) {
+    return reinterpret_cast<InputtinoSwitchJoypad *>(new inputtino::SwitchJoypad(std::move(*joypad_)));
+  } else {
+    eh->eh(joypad_.getErrorMessage().c_str(), eh->user_data);
+    return nullptr;
+  }
+}
+
+char **inputtino_joypad_switch_get_nodes(InputtinoSwitchJoypad *joypad, int *num_nodes) {
+  return c_get_nodes(joypad, num_nodes);
+}
+
+void inputtino_joypad_switch_set_pressed_buttons(InputtinoSwitchJoypad *joypad, int newly_pressed) {
+  if (joypad) {
+    reinterpret_cast<inputtino::SwitchJoypad *>(joypad)->set_pressed_buttons(newly_pressed);
+  }
+}
+
+void inputtino_joypad_switch_set_triggers(InputtinoSwitchJoypad *joypad, short left_trigger, short right_trigger) {
+  if (joypad) {
+    reinterpret_cast<inputtino::SwitchJoypad *>(joypad)->set_triggers(left_trigger, right_trigger);
+  }
+}
+
+void inputtino_joypad_switch_set_stick(InputtinoSwitchJoypad *joypad,
+                                       enum INPUTTINO_JOYPAD_STICK_POSITION stick_type,
+                                       short x,
+                                       short y) {
+  if (joypad) {
+    reinterpret_cast<inputtino::SwitchJoypad *>(joypad)->set_stick(inputtino::Joypad::STICK_POSITION(stick_type),
+                                                                    x,
+                                                                    y);
+  }
+}
+
+void inputtino_joypad_switch_set_on_rumble(InputtinoSwitchJoypad *joypad,
+                                           InputtinoJoypadRumbleFn rumble_fn,
+                                           void *user_data) {
+  if (joypad) {
+    reinterpret_cast<inputtino::SwitchJoypad *>(joypad)->set_on_rumble(
+        [user_data, rumble_fn](short left, short right) { rumble_fn(left, right, user_data); });
+  }
+}
+
+void inputtino_joypad_switch_destroy(InputtinoSwitchJoypad *joypad) {
+  if (joypad) {
+    auto joypad_ptr = reinterpret_cast<inputtino::SwitchJoypad *>(joypad);
+    delete joypad_ptr;
+  }
+}

package/engine/vendor/inputtino/src/c-bindings/joypad_xone.cpp

@@ -0,0 +1,62 @@
+#include "helpers.hpp"
+#include <inputtino/input.h>
+
+InputtinoXOneJoypad *inputtino_joypad_xone_create(const InputtinoDeviceDefinition *device, const InputtinoErrorHandler *eh) {
+  auto joypad_ = inputtino::XboxOneJoypad::create({
+      .name = device->name ? device->name : "Inputtino virtual device",
+      .vendor_id = device->vendor_id,
+      .product_id = device->product_id,
+      .version = device->version,
+      .device_phys = device->device_phys ? device->device_phys : "00:11:22:33:44:55",
+      .device_uniq = device->device_uniq ? device->device_uniq : "00:11:22:33:44:55",
+  });
+  if (joypad_) {
+    return reinterpret_cast<InputtinoXOneJoypad *>(new inputtino::XboxOneJoypad(std::move(*joypad_)));
+  } else {
+    eh->eh(joypad_.getErrorMessage().c_str(), eh->user_data);
+    return nullptr;
+  }
+}
+
+char **inputtino_joypad_xone_get_nodes(InputtinoXOneJoypad *joypad, int *num_nodes) {
+  return c_get_nodes(joypad, num_nodes);
+}
+
+void inputtino_joypad_xone_set_pressed_buttons(InputtinoXOneJoypad *joypad, int newly_pressed) {
+  if (joypad) {
+    reinterpret_cast<inputtino::XboxOneJoypad *>(joypad)->set_pressed_buttons(newly_pressed);
+  }
+}
+
+void inputtino_joypad_xone_set_triggers(InputtinoXOneJoypad *joypad, short left_trigger, short right_trigger) {
+  if (joypad) {
+    reinterpret_cast<inputtino::XboxOneJoypad *>(joypad)->set_triggers(left_trigger, right_trigger);
+  }
+}
+
+void inputtino_joypad_xone_set_stick(InputtinoXOneJoypad *joypad,
+                                     enum INPUTTINO_JOYPAD_STICK_POSITION stick_type,
+                                     short x,
+                                     short y) {
+  if (joypad) {
+    reinterpret_cast<inputtino::XboxOneJoypad *>(joypad)->set_stick(inputtino::Joypad::STICK_POSITION(stick_type),
+                                                                    x,
+                                                                    y);
+  }
+}
+
+void inputtino_joypad_xone_set_on_rumble(InputtinoXOneJoypad *joypad,
+                                         InputtinoJoypadRumbleFn rumble_fn,
+                                         void *user_data) {
+  if (joypad) {
+    reinterpret_cast<inputtino::XboxOneJoypad *>(joypad)->set_on_rumble(
+        [user_data, rumble_fn](short left, short right) { rumble_fn(left, right, user_data); });
+  }
+}
+
+void inputtino_joypad_xone_destroy(InputtinoXOneJoypad *joypad) {
+  if (joypad) {
+    auto joypad_ptr = reinterpret_cast<inputtino::XboxOneJoypad *>(joypad);
+    delete joypad_ptr;
+  }
+}

package/engine/vendor/inputtino/src/c-bindings/keyboard.cpp

@@ -0,0 +1,42 @@
+#include "helpers.hpp"
+#include <inputtino/input.h>
+
+InputtinoKeyboard *inputtino_keyboard_create(const InputtinoDeviceDefinition *device, const InputtinoErrorHandler *eh) {
+  auto keyboard_ = inputtino::Keyboard::create({
+      .name = device->name ? device->name : "Inputtino virtual device",
+      .vendor_id = device->vendor_id,
+      .product_id = device->product_id,
+      .version = device->version,
+      .device_phys = device->device_phys ? device->device_phys : "00:11:22:33:44:55",
+      .device_uniq = device->device_uniq ? device->device_uniq : "00:11:22:33:44:55",
+  });
+  if (keyboard_) {
+    return reinterpret_cast<InputtinoKeyboard *>(new inputtino::Keyboard(std::move(*keyboard_)));
+  } else {
+    eh->eh(keyboard_.getErrorMessage().c_str(), eh->user_data);
+    return nullptr;
+  }
+}
+
+char **inputtino_keyboard_get_nodes(InputtinoKeyboard *keyboard, int *num_nodes) {
+  return c_get_nodes(keyboard, num_nodes);
+}
+
+void inputtino_keyboard_press(InputtinoKeyboard *keyboard, short key_code) {
+  if (keyboard) {
+    reinterpret_cast<inputtino::Keyboard *>(keyboard)->press(key_code);
+  }
+}
+
+void inputtino_keyboard_release(InputtinoKeyboard *keyboard, short key_code) {
+  if (keyboard) {
+    reinterpret_cast<inputtino::Keyboard *>(keyboard)->release(key_code);
+  }
+}
+
+void inputtino_keyboard_destroy(InputtinoKeyboard *keyboard) {
+  if (keyboard) {
+    auto ptr = reinterpret_cast<inputtino::Keyboard *>(keyboard);
+    delete ptr;
+  }
+}

package/engine/vendor/inputtino/src/c-bindings/mouse.cpp

@@ -0,0 +1,67 @@
+#include "helpers.hpp"
+#include <inputtino/input.h>
+#include <inputtino/input.hpp>
+
+InputtinoMouse *inputtino_mouse_create(const InputtinoDeviceDefinition *device, const InputtinoErrorHandler *eh) {
+  auto mouse_ = inputtino::Mouse::create({
+      .name = device->name ? device->name : "Inputtino virtual device",
+      .vendor_id = device->vendor_id,
+      .product_id = device->product_id,
+      .version = device->version,
+      .device_phys = device->device_phys ? device->device_phys : "00:11:22:33:44:55",
+      .device_uniq = device->device_uniq ? device->device_uniq : "00:11:22:33:44:55",
+  });
+  if (mouse_) {
+    return reinterpret_cast<InputtinoMouse *>(new inputtino::Mouse(std::move(*mouse_)));
+  } else {
+    eh->eh(mouse_.getErrorMessage().c_str(), eh->user_data);
+    return nullptr;
+  }
+}
+
+char **inputtino_mouse_get_nodes(InputtinoMouse *mouse, int *num_nodes) {
+  return c_get_nodes(mouse, num_nodes);
+}
+
+void inputtino_mouse_move(InputtinoMouse *mouse, int delta_x, int delta_y) {
+  if (mouse) {
+    reinterpret_cast<inputtino::Mouse *>(mouse)->move(delta_x, delta_y);
+  }
+}
+
+void inputtino_mouse_move_absolute(InputtinoMouse *mouse, int x, int y, int screen_width, int screen_height) {
+  if (mouse) {
+    reinterpret_cast<inputtino::Mouse *>(mouse)->move_abs(x, y, screen_width, screen_height);
+  }
+}
+
+void inputtino_mouse_press_button(InputtinoMouse *mouse, enum INPUTTINO_MOUSE_BUTTON button) {
+  if (mouse) {
+    reinterpret_cast<inputtino::Mouse *>(mouse)->press(inputtino::Mouse::MOUSE_BUTTON(button));
+  }
+}
+
+void inputtino_mouse_release_button(InputtinoMouse *mouse, enum INPUTTINO_MOUSE_BUTTON button) {
+  if (mouse) {
+    reinterpret_cast<inputtino::Mouse *>(mouse)->release(inputtino::Mouse::MOUSE_BUTTON(button));
+  }
+}
+
+void inputtino_mouse_scroll_vertical(InputtinoMouse *mouse, int high_res_distance) {
+  if (mouse) {
+    reinterpret_cast<inputtino::Mouse *>(mouse)->vertical_scroll(high_res_distance);
+  }
+}
+
+void inputtino_mouse_scroll_horizontal(InputtinoMouse *mouse, int high_res_distance) {
+  if (mouse) {
+    reinterpret_cast<inputtino::Mouse *>(mouse)->horizontal_scroll(high_res_distance);
+  }
+}
+
+void inputtino_mouse_destroy(InputtinoMouse *mouse) {
+  if (mouse) {
+    inputtino::Mouse *mouse_ptr = reinterpret_cast<inputtino::Mouse *>(mouse);
+    delete mouse_ptr;
+  }
+}

package/engine/vendor/inputtino/src/c-bindings/pen_tablet.cpp

@@ -0,0 +1,50 @@
+#include "helpers.hpp"
+#include <inputtino/input.h>
+
+InputtinoPenTablet *inputtino_pen_tablet_create(const InputtinoDeviceDefinition *device, const InputtinoErrorHandler *eh) {
+  auto pen_tablet_ = inputtino::PenTablet::create({
+      .name = device->name ? device->name : "Inputtino virtual device",
+      .vendor_id = device->vendor_id,
+      .product_id = device->product_id,
+      .version = device->version,
+      .device_phys = device->device_phys ? device->device_phys : "00:11:22:33:44:55",
+      .device_uniq = device->device_uniq ? device->device_uniq : "00:11:22:33:44:55",
+  });
+  if (pen_tablet_) {
+    return reinterpret_cast<InputtinoPenTablet *>(new inputtino::PenTablet(std::move(*pen_tablet_)));
+  } else {
+    eh->eh(pen_tablet_.getErrorMessage().c_str(), eh->user_data);
+    return nullptr;
+  }
+}
+
+char **inputtino_pen_tablet_get_nodes(InputtinoPenTablet *pen_tablet, int *num_nodes) {
+  return c_get_nodes(pen_tablet, num_nodes);
+}
+
+void inputtino_pen_tablet_place_tool(InputtinoPenTablet *pen_tablet,
+                                     enum INPUTTINO_PEN_TOOL_TYPE tool_type,
+                                     float x,
+                                     float y,
+                                     float pressure,
+                                     float distance,
+                                     float tilt_x,
+                                     float tilt_y) {
+  if (pen_tablet) {
+    reinterpret_cast<inputtino::PenTablet *>(pen_tablet)
+        ->place_tool(inputtino::PenTablet::TOOL_TYPE(tool_type), x, y, pressure, distance, tilt_x, tilt_y);
+  }
+}
+
+void inputtino_pen_tablet_set_button(InputtinoPenTablet *pen_tablet, enum INPUTTINO_PEN_BTN_TYPE button, bool pressed) {
+  if (pen_tablet) {
+    reinterpret_cast<inputtino::PenTablet *>(pen_tablet)->set_btn(inputtino::PenTablet::BTN_TYPE(button), pressed);
+  }
+}
+
+void inputtino_pen_tablet_destroy(InputtinoPenTablet *pen_tablet) {
+  if(pen_tablet){
+    inputtino::PenTablet *pen_tablet_ = reinterpret_cast<inputtino::PenTablet *>(pen_tablet);
+    delete pen_tablet_;
+  }
+}

package/engine/vendor/inputtino/src/c-bindings/touchscreen.cpp

@@ -0,0 +1,43 @@
+#include "helpers.hpp"
+#include <inputtino/input.h>
+
+InputtinoTouchscreen *inputtino_touchscreen_create(const InputtinoDeviceDefinition *device, const InputtinoErrorHandler *eh) {
+  auto touchscreen_ = inputtino::TouchScreen::create({
+      .name = device->name ? device->name : "Inputtino virtual device",
+      .vendor_id = device->vendor_id,
+      .product_id = device->product_id,
+      .version = device->version,
+      .device_phys = device->device_phys ? device->device_phys : "00:11:22:33:44:55",
+      .device_uniq = device->device_uniq ? device->device_uniq : "00:11:22:33:44:55",
+  });
+  if (touchscreen_) {
+    return reinterpret_cast<InputtinoTouchscreen *>(new inputtino::TouchScreen(std::move(*touchscreen_)));
+  } else {
+    eh->eh(touchscreen_.getErrorMessage().c_str(), eh->user_data);
+    return nullptr;
+  }
+}
+
+char **inputtino_touchscreen_get_nodes(InputtinoTouchscreen *touchscreen, int *num_nodes) {
+  return c_get_nodes(touchscreen, num_nodes);
+}
+
+void inputtino_touchscreen_place_finger(
+    InputtinoTouchscreen *touchscreen, int finger_nr, float x, float y, float pressure, int orientation) {
+  if (touchscreen) {
+    reinterpret_cast<inputtino::TouchScreen *>(touchscreen)->place_finger(finger_nr, x, y, pressure, orientation);
+  }
+}
+
+void inputtino_touchscreen_release_finger(InputtinoTouchscreen *touchscreen, int finger_nr) {
+  if (touchscreen) {
+    reinterpret_cast<inputtino::TouchScreen *>(touchscreen)->release_finger(finger_nr);
+  }
+}
+
+void inputtino_touchscreen_destroy(InputtinoTouchscreen *touchscreen) {
+  if (touchscreen) {
+    inputtino::TouchScreen *touch_ptr = reinterpret_cast<inputtino::TouchScreen *>(touchscreen);
+    delete touch_ptr;
+  }
+}

package/engine/vendor/inputtino/src/c-bindings/trackpad.cpp

@@ -0,0 +1,49 @@
+#include "helpers.hpp"
+#include <inputtino/input.h>
+
+InputtinoTrackpad *inputtino_trackpad_create(const InputtinoDeviceDefinition *device, const InputtinoErrorHandler *eh) {
+  auto trackpad_ = inputtino::Trackpad::create({
+      .name = device->name ? device->name : "Inputtino virtual device",
+      .vendor_id = device->vendor_id,
+      .product_id = device->product_id,
+      .version = device->version,
+      .device_phys = device->device_phys ? device->device_phys : "00:11:22:33:44:55",
+      .device_uniq = device->device_uniq ? device->device_uniq : "00:11:22:33:44:55",
+  });
+  if (trackpad_) {
+    return reinterpret_cast<InputtinoTrackpad *>(new inputtino::Trackpad(std::move(*trackpad_)));
+  } else {
+    eh->eh(trackpad_.getErrorMessage().c_str(), eh->user_data);
+    return nullptr;
+  }
+}
+
+char **inputtino_trackpad_get_nodes(InputtinoTrackpad *trackpad, int *num_nodes) {
+  return c_get_nodes(trackpad, num_nodes);
+}
+
+void inputtino_trackpad_place_finger(
+    InputtinoTrackpad *trackpad, int finger_nr, float x, float y, float pressure, int orientation) {
+  if (trackpad) {
+    reinterpret_cast<inputtino::Trackpad *>(trackpad)->place_finger(finger_nr, x, y, pressure, orientation);
+  }
+}
+
+void inputtino_trackpad_release_finger(InputtinoTrackpad *trackpad, int finger_nr) {
+  if (trackpad) {
+    reinterpret_cast<inputtino::Trackpad *>(trackpad)->release_finger(finger_nr);
+  }
+}
+
+void inputtino_trackpad_set_left_btn(InputtinoTrackpad *trackpad, bool pressed) {
+  if (trackpad) {
+    reinterpret_cast<inputtino::Trackpad *>(trackpad)->set_left_btn(pressed);
+  }
+}
+
+void inputtino_trackpad_destroy(InputtinoTrackpad *trackpad) {
+  if (trackpad) {
+    inputtino::Trackpad *trackpad_ptr = reinterpret_cast<inputtino::Trackpad *>(trackpad);
+    delete trackpad_ptr;
+  }
+}

package/engine/vendor/inputtino/src/uhid/README.adoc

@@ -0,0 +1,63 @@
+== What's this?
+
+Here we implement virtual devices using the low level https://dri.freedesktop.org/docs/drm/hid/uhid.html[uhid]
+
+== Why can't we use udev?
+
+To answer this question we need to dive deeper into how the DualSense controller works, bear with me..
+
+The PS4 and PS5 controllers also include a Gyroscope, Accelerometer and a Touchpad.
+The DualSense controller also includes a microphone and a speaker.
+The open source driver `hid-playstation` exposes these features as 3 separate input devices:
+
+----
+/dev/input/event20:	Sony Interactive Entertainment Wireless Controller
+/dev/input/event21:	Sony Interactive Entertainment Wireless Controller Motion Sensors
+/dev/input/event22:	Sony Interactive Entertainment Wireless Controller Touchpad
+----
+
+Ideally we should be able to use udev to create these devices independently, unfortunately the issue is in linking these 3 devices together.
+
+=== How SDL2 links these 3 devices into a single joypad?
+
+First off, SDL2 assumes that every `/dev/input/event*` device might be a joypad, so it opens them all to check if they are based on some heuristics.
+Normally, the motion sensor device that you create with udev will be opened by SDL2 and it will be recognized as a joypad.
+To get around this you can hardcode the device name to end with one of the https://github.com/libsdl-org/SDL/blob/d4f4aa745a9d9c280d5016322a2473c9d2e077a0/src/joystick/SDL_gamepad.c#L2575-L2589[SDL_ShouldIgnoreGamepad] hardcoded strings.
+This will get around the first hurdle and actually recognize the udev created motion sensor as an actual sensor.
+
+The main issue seems to be in linking these 3 devices together: the way SDL2 does this is to match the `uniq` identifier (`EVIOCGUNIQ` https://github.com/libsdl-org/SDL/blob/4189edaeb7ce4da9ab420b98904fa22196fb3dca/src/joystick/linux/SDL_sysjoystick.c#L1508[in this method]) between what is recognised as sensor and what is recognised as joypad.
+Unfortunately, there's no way to set the `uniq` for an uinput device; there's https://lore.kernel.org/linux-bluetooth/20191201145357.ybq5gfty4ulnfasq@pali/t/#u[a proposal] to add this to the Linux kernel but as of March 2024 this has still not being merged.
+So what happens in practice is that SDL ends up discarding that sensor and just using the joypad instead.
+
+== How UHID solves this?
+
+UHID allows us to completely replicate the DualSense controller at a lower level.
+The device that we'll create via UHID will be picked up by `hid-playstation` just like a USB connected DualSense controller would be, which in turn will create the `/dev/input/event` devices and downstream applications will see the 3 devices as they should be.
+
+== What are the requirements to use UHID?
+
+You need additional permission in order to access `/dev/uhid` (normally exposed as `root` only). +
+
+First we'll add our user to the `input` group:
+
+----
+sudo usermod -a -G input $USER
+----
+
+Then we add an udev rule to allow access to `/dev/uhid`:
+
+----
+echo 'KERNEL=="uhid", GROUP="input", MODE="0660"' | sudo tee /etc/udev/rules.d/99-uhid.rules
+----
+
+Finally, we have to make sure that the `uhid` kernel module is loaded at boot:
+
+----
+echo "uhid" | sudo tee /etc/modules-load.d/uhid.conf
+----
+
+=== Useful resources (?)
+
+- https://github.com/nondebug/dualsense
+- https://github.com/torvalds/linux/blob/master/drivers/hid/hid-playstation.c
+- https://gitlab.freedesktop.org/libevdev/hid-tools/

package/engine/vendor/inputtino/src/uhid/include/crc32.hpp

@@ -0,0 +1,38 @@
+/**
+ * Adapted from https://gist.github.com/timepp/1f678e200d9e0f2a043a9ec6b3690635
+ * uses constexpr to generate a CRC32 table at compile time
+ */
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+static constexpr auto generate_table(std::uint32_t polynomial = 0xEDB88320) {
+  std::array<std::uint32_t, 256> table{};
+  for (std::uint32_t i = 0; i < 256; i++) {
+    std::uint32_t c = i;
+    for (std::size_t j = 0; j < 8; j++) {
+      if (c & 1) {
+        c = polynomial ^ (c >> 1);
+      } else {
+        c >>= 1;
+      }
+    }
+    table[i] = c;
+  }
+  return table;
+}
+
+// Static lookup table generated at compile time
+static constexpr auto lookup_table = generate_table();
+
+/**
+ * Calculate the CRC32 of a buffer
+ */
+static constexpr uint32_t CRC32(const unsigned char *buffer, uint32_t length, uint32_t seed = 0) {
+  uint32_t c = seed ^ 0xFFFFFFFF;
+  for (size_t i = 0; i < length; ++i) {
+    c = lookup_table[(c ^ buffer[i]) & 0xFF] ^ (c >> 8);
+  }
+  return c ^ 0xFFFFFFFF;
+}

package/engine/vendor/inputtino/src/uhid/include/uhid/protected_types.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include <functional>
+#include <inputtino/input.hpp>
+#include <optional>
+#include <uhid/ps5.hpp>
+#include <uhid/uhid.hpp>
+
+namespace inputtino {
+struct PS5JoypadState {
+  std::shared_ptr<uhid::Device> dev;
+  /**
+   * This will be the MAC address of the device
+   *
+   * IMPORTANT: this needs to be unique for each virtual device,
+   * otherwise the kernel driver will return an error:
+   * "Duplicate device found for MAC address XX:XX:XX:XX"
+   *
+   * We also use this information internally to unique match a device with the
+   * /dev/input/devXX files; see get_nodes()
+   */
+  unsigned char mac_address[6] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
+  uint16_t vendor_id;
+
+  uhid::dualsense_input_report current_state = {};
+  uint8_t last_touch_id = 0;
+
+  std::optional<std::function<void(int, int)>> on_rumble = std::nullopt;
+  std::optional<std::function<void(int, int, int)>> on_led = std::nullopt;
+  std::optional<std::function<void(const PS5Joypad::TriggerEffect &)>> on_trigger_effect = std::nullopt;
+  uint32_t last_left_trigger_event = 0;
+  uint32_t last_right_trigger_event = 0;
+
+  bool stop_repeat_thread = false;
+  bool is_bluetooth = true;
+};
+} // namespace inputtino