move sunshine to src

- this will allow for common cpp workflow files within org
2022-08-07 23:37:57 -04:00 · 2022-08-07 23:37:57 -04:00 · a4acaf15b0
commit a4acaf15b0
parent 0de52efdb1
86 changed files with 3031 additions and 3031 deletions
--- a/src/input.cpp
+++ b/src/input.cpp
@ -0,0 +1,686 @@
+//
+// Created by loki on 6/20/19.
+//
+
+// define uint32_t for <moonlight-common-c/src/Input.h>
+#include <cstdint>
+extern "C" {
+#include <moonlight-common-c/src/Input.h>
+}
+
+#include <bitset>
+#include <unordered_map>
+
+#include "config.h"
+#include "input.h"
+#include "main.h"
+#include "platform/common.h"
+#include "thread_pool.h"
+#include "utility.h"
+
+using namespace std::literals;
+namespace input {
+
+constexpr auto MAX_GAMEPADS = std::min((std::size_t)platf::MAX_GAMEPADS, sizeof(std::int16_t) * 8);
+#define DISABLE_LEFT_BUTTON_DELAY ((util::ThreadPool::task_id_t)0x01)
+#define ENABLE_LEFT_BUTTON_DELAY nullptr
+
+constexpr auto VKEY_SHIFT    = 0x10;
+constexpr auto VKEY_LSHIFT   = 0xA0;
+constexpr auto VKEY_RSHIFT   = 0xA1;
+constexpr auto VKEY_CONTROL  = 0x11;
+constexpr auto VKEY_LCONTROL = 0xA2;
+constexpr auto VKEY_RCONTROL = 0xA3;
+constexpr auto VKEY_MENU     = 0x12;
+constexpr auto VKEY_LMENU    = 0xA4;
+constexpr auto VKEY_RMENU    = 0xA5;
+
+enum class button_state_e {
+  NONE,
+  DOWN,
+  UP
+};
+
+template<std::size_t N>
+int alloc_id(std::bitset<N> &gamepad_mask) {
+  for(int x = 0; x < gamepad_mask.size(); ++x) {
+    if(!gamepad_mask[x]) {
+      gamepad_mask[x] = true;
+      return x;
+    }
+  }
+
+  return -1;
+}
+
+template<std::size_t N>
+void free_id(std::bitset<N> &gamepad_mask, int id) {
+  gamepad_mask[id] = false;
+}
+
+static util::TaskPool::task_id_t key_press_repeat_id {};
+static std::unordered_map<short, bool> key_press {};
+static std::array<std::uint8_t, 5> mouse_press {};
+
+static platf::input_t platf_input;
+static std::bitset<platf::MAX_GAMEPADS> gamepadMask {};
+
+void free_gamepad(platf::input_t &platf_input, int id) {
+  platf::gamepad(platf_input, id, platf::gamepad_state_t {});
+  platf::free_gamepad(platf_input, id);
+
+  free_id(gamepadMask, id);
+}
+struct gamepad_t {
+  gamepad_t() : gamepad_state {}, back_timeout_id {}, id { -1 }, back_button_state { button_state_e::NONE } {}
+  ~gamepad_t() {
+    if(id >= 0) {
+      task_pool.push([id = this->id]() {
+        free_gamepad(platf_input, id);
+      });
+    }
+  }
+
+  platf::gamepad_state_t gamepad_state;
+
+  util::ThreadPool::task_id_t back_timeout_id;
+
+  int id;
+
+  // When emulating the HOME button, we may need to artificially release the back button.
+  // Afterwards, the gamepad state on sunshine won't match the state on Moonlight.
+  // To prevent Sunshine from sending erronious input data to the active application,
+  // Sunshine forces the button to be in a specific state until the gamepad state matches that of
+  // Moonlight once more.
+  button_state_e back_button_state;
+};
+
+struct input_t {
+  enum shortkey_e {
+    CTRL  = 0x1,
+    ALT   = 0x2,
+    SHIFT = 0x4,
+
+    SHORTCUT = CTRL | ALT | SHIFT
+  };
+
+  input_t(
+    safe::mail_raw_t::event_t<input::touch_port_t> touch_port_event,
+    platf::rumble_queue_t rumble_queue)
+      : shortcutFlags {},
+        active_gamepad_state {},
+        gamepads(MAX_GAMEPADS),
+        touch_port_event { std::move(touch_port_event) },
+        rumble_queue { std::move(rumble_queue) },
+        mouse_left_button_timeout {},
+        touch_port { 0, 0, 0, 0, 0, 0, 1.0f } {}
+
+  // Keep track of alt+ctrl+shift key combo
+  int shortcutFlags;
+
+  std::uint16_t active_gamepad_state;
+  std::vector<gamepad_t> gamepads;
+
+  safe::mail_raw_t::event_t<input::touch_port_t> touch_port_event;
+  platf::rumble_queue_t rumble_queue;
+
+  util::ThreadPool::task_id_t mouse_left_button_timeout;
+
+  input::touch_port_t touch_port;
+};
+
+/**
+ * Apply shortcut based on VKEY
+ * On success
+ *    return > 0
+ * On nothing
+ *    return 0
+ */
+inline int apply_shortcut(short keyCode) {
+  constexpr auto VK_F1  = 0x70;
+  constexpr auto VK_F13 = 0x7C;
+
+  BOOST_LOG(debug) << "Apply Shortcut: 0x"sv << util::hex((std::uint8_t)keyCode).to_string_view();
+
+  if(keyCode >= VK_F1 && keyCode <= VK_F13) {
+    mail::man->event<int>(mail::switch_display)->raise(keyCode - VK_F1);
+    return 1;
+  }
+
+  switch(keyCode) {
+  case 0x4E /* VKEY_N */:
+    display_cursor = !display_cursor;
+    return 1;
+  }
+
+  return 0;
+}
+
+void print(PNV_REL_MOUSE_MOVE_PACKET packet) {
+  BOOST_LOG(debug)
+    << "--begin relative mouse move packet--"sv << std::endl
+    << "deltaX ["sv << util::endian::big(packet->deltaX) << ']' << std::endl
+    << "deltaY ["sv << util::endian::big(packet->deltaY) << ']' << std::endl
+    << "--end relative mouse move packet--"sv;
+}
+
+void print(PNV_ABS_MOUSE_MOVE_PACKET packet) {
+  BOOST_LOG(debug)
+    << "--begin absolute mouse move packet--"sv << std::endl
+    << "x      ["sv << util::endian::big(packet->x) << ']' << std::endl
+    << "y      ["sv << util::endian::big(packet->y) << ']' << std::endl
+    << "width  ["sv << util::endian::big(packet->width) << ']' << std::endl
+    << "height ["sv << util::endian::big(packet->height) << ']' << std::endl
+    << "--end absolute mouse move packet--"sv;
+}
+
+void print(PNV_MOUSE_BUTTON_PACKET packet) {
+  BOOST_LOG(debug)
+    << "--begin mouse button packet--"sv << std::endl
+    << "action ["sv << util::hex(packet->action).to_string_view() << ']' << std::endl
+    << "button ["sv << util::hex(packet->button).to_string_view() << ']' << std::endl
+    << "--end mouse button packet--"sv;
+}
+
+void print(PNV_SCROLL_PACKET packet) {
+  BOOST_LOG(debug)
+    << "--begin mouse scroll packet--"sv << std::endl
+    << "scrollAmt1 ["sv << util::endian::big(packet->scrollAmt1) << ']' << std::endl
+    << "--end mouse scroll packet--"sv;
+}
+
+void print(PNV_KEYBOARD_PACKET packet) {
+  BOOST_LOG(debug)
+    << "--begin keyboard packet--"sv << std::endl
+    << "keyAction ["sv << util::hex(packet->keyAction).to_string_view() << ']' << std::endl
+    << "keyCode ["sv << util::hex(packet->keyCode).to_string_view() << ']' << std::endl
+    << "modifiers ["sv << util::hex(packet->modifiers).to_string_view() << ']' << std::endl
+    << "--end keyboard packet--"sv;
+}
+
+void print(PNV_MULTI_CONTROLLER_PACKET packet) {
+  // Moonlight spams controller packet even when not necessary
+  BOOST_LOG(verbose)
+    << "--begin controller packet--"sv << std::endl
+    << "controllerNumber ["sv << packet->controllerNumber << ']' << std::endl
+    << "activeGamepadMask ["sv << util::hex(packet->activeGamepadMask).to_string_view() << ']' << std::endl
+    << "buttonFlags ["sv << util::hex(packet->buttonFlags).to_string_view() << ']' << std::endl
+    << "leftTrigger ["sv << util::hex(packet->leftTrigger).to_string_view() << ']' << std::endl
+    << "rightTrigger ["sv << util::hex(packet->rightTrigger).to_string_view() << ']' << std::endl
+    << "leftStickX ["sv << packet->leftStickX << ']' << std::endl
+    << "leftStickY ["sv << packet->leftStickY << ']' << std::endl
+    << "rightStickX ["sv << packet->rightStickX << ']' << std::endl
+    << "rightStickY ["sv << packet->rightStickY << ']' << std::endl
+    << "--end controller packet--"sv;
+}
+
+constexpr int PACKET_TYPE_SCROLL_OR_KEYBOARD = PACKET_TYPE_SCROLL;
+void print(void *input) {
+  int input_type = util::endian::big(*(int *)input);
+
+  switch(input_type) {
+  case PACKET_TYPE_REL_MOUSE_MOVE:
+    print((PNV_REL_MOUSE_MOVE_PACKET)input);
+    break;
+  case PACKET_TYPE_ABS_MOUSE_MOVE:
+    print((PNV_ABS_MOUSE_MOVE_PACKET)input);
+    break;
+  case PACKET_TYPE_MOUSE_BUTTON:
+    print((PNV_MOUSE_BUTTON_PACKET)input);
+    break;
+  case PACKET_TYPE_SCROLL_OR_KEYBOARD: {
+    char *tmp_input = (char *)input + 4;
+    if(tmp_input[0] == 0x0A) {
+      print((PNV_SCROLL_PACKET)input);
+    }
+    else {
+      print((PNV_KEYBOARD_PACKET)input);
+    }
+
+    break;
+  }
+  case PACKET_TYPE_MULTI_CONTROLLER:
+    print((PNV_MULTI_CONTROLLER_PACKET)input);
+    break;
+  }
+}
+
+void passthrough(std::shared_ptr<input_t> &input, PNV_REL_MOUSE_MOVE_PACKET packet) {
+  input->mouse_left_button_timeout = DISABLE_LEFT_BUTTON_DELAY;
+  platf::move_mouse(platf_input, util::endian::big(packet->deltaX), util::endian::big(packet->deltaY));
+}
+
+void passthrough(std::shared_ptr<input_t> &input, PNV_ABS_MOUSE_MOVE_PACKET packet) {
+  if(input->mouse_left_button_timeout == DISABLE_LEFT_BUTTON_DELAY) {
+    input->mouse_left_button_timeout = ENABLE_LEFT_BUTTON_DELAY;
+  }
+
+  auto &touch_port_event = input->touch_port_event;
+  auto &touch_port       = input->touch_port;
+  if(touch_port_event->peek()) {
+    touch_port = *touch_port_event->pop();
+  }
+
+  float x = util::endian::big(packet->x);
+  float y = util::endian::big(packet->y);
+
+  // Prevent divide by zero
+  // Don't expect it to happen, but just in case
+  if(!packet->width || !packet->height) {
+    BOOST_LOG(warning) << "Moonlight passed invalid dimensions"sv;
+
+    return;
+  }
+
+  auto width  = (float)util::endian::big(packet->width);
+  auto height = (float)util::endian::big(packet->height);
+
+  auto scalarX = touch_port.width / width;
+  auto scalarY = touch_port.height / height;
+
+  x *= scalarX;
+  y *= scalarY;
+
+  auto offsetX = touch_port.client_offsetX;
+  auto offsetY = touch_port.client_offsetY;
+
+  std::clamp(x, offsetX, width - offsetX);
+  std::clamp(y, offsetY, height - offsetY);
+
+  platf::touch_port_t abs_port {
+    touch_port.offset_x, touch_port.offset_y,
+    touch_port.env_width, touch_port.env_height
+  };
+
+  platf::abs_mouse(platf_input, abs_port, (x - offsetX) * touch_port.scalar_inv, (y - offsetY) * touch_port.scalar_inv);
+}
+
+void passthrough(std::shared_ptr<input_t> &input, PNV_MOUSE_BUTTON_PACKET packet) {
+  auto constexpr BUTTON_RELEASED = 0x09;
+
+  auto constexpr BUTTON_LEFT  = 0x01;
+  auto constexpr BUTTON_RIGHT = 0x03;
+
+  auto release = packet->action == BUTTON_RELEASED;
+
+  auto button = util::endian::big(packet->button);
+  if(button > 0 && button < mouse_press.size()) {
+    if(mouse_press[button] != release) {
+      // button state is already what we want
+      return;
+    }
+
+    mouse_press[button] = !release;
+  }
+  ///////////////////////////////////
+  /*/
+    * When Moonlight sends mouse input through absolute coordinates,
+    * it's possible that BUTTON_RIGHT is pressed down immediately after releasing BUTTON_LEFT.
+    * As a result, Sunshine will left click on hyperlinks in the browser before right clicking
+    *
+    * This can be solved by delaying BUTTON_LEFT, however, any delay on input is undesirable during gaming
+    * As a compromise, Sunshine will only put delays on BUTTON_LEFT when
+    * absolute mouse coordinates have been send.
+    *
+    * Try to make sure BUTTON_RIGHT gets called before BUTTON_LEFT is released.
+    *
+    * input->mouse_left_button_timeout can only be nullptr
+    * when the last mouse coordinates were absolute
+   /*/
+  if(button == BUTTON_LEFT && release && !input->mouse_left_button_timeout) {
+    auto f = [=]() {
+      auto left_released = mouse_press[BUTTON_LEFT];
+      if(left_released) {
+        // Already released left button
+        return;
+      }
+      platf::button_mouse(platf_input, BUTTON_LEFT, release);
+
+      mouse_press[BUTTON_LEFT]         = false;
+      input->mouse_left_button_timeout = nullptr;
+    };
+
+    input->mouse_left_button_timeout = task_pool.pushDelayed(std::move(f), 10ms).task_id;
+
+    return;
+  }
+  if(
+    button == BUTTON_RIGHT && !release &&
+    input->mouse_left_button_timeout > DISABLE_LEFT_BUTTON_DELAY) {
+    platf::button_mouse(platf_input, BUTTON_RIGHT, false);
+    platf::button_mouse(platf_input, BUTTON_RIGHT, true);
+
+    mouse_press[BUTTON_RIGHT] = false;
+
+    return;
+  }
+  ///////////////////////////////////
+
+  platf::button_mouse(platf_input, button, release);
+}
+
+short map_keycode(short keycode) {
+  auto it = config::input.keybindings.find(keycode);
+  if(it != std::end(config::input.keybindings)) {
+    return it->second;
+  }
+
+  return keycode;
+}
+
+/**
+ * Update flags for keyboard shortcut combo's
+ */
+inline void update_shortcutFlags(int *flags, short keyCode, bool release) {
+  switch(keyCode) {
+  case VKEY_SHIFT:
+  case VKEY_LSHIFT:
+  case VKEY_RSHIFT:
+    if(release) {
+      *flags &= ~input_t::SHIFT;
+    }
+    else {
+      *flags |= input_t::SHIFT;
+    }
+    break;
+  case VKEY_CONTROL:
+  case VKEY_LCONTROL:
+  case VKEY_RCONTROL:
+    if(release) {
+      *flags &= ~input_t::CTRL;
+    }
+    else {
+      *flags |= input_t::CTRL;
+    }
+    break;
+  case VKEY_MENU:
+  case VKEY_LMENU:
+  case VKEY_RMENU:
+    if(release) {
+      *flags &= ~input_t::ALT;
+    }
+    else {
+      *flags |= input_t::ALT;
+    }
+    break;
+  }
+}
+
+void repeat_key(short key_code) {
+  // If key no longer pressed, stop repeating
+  if(!key_press[key_code]) {
+    key_press_repeat_id = nullptr;
+    return;
+  }
+
+  platf::keyboard(platf_input, map_keycode(key_code), false);
+
+  key_press_repeat_id = task_pool.pushDelayed(repeat_key, config::input.key_repeat_period, key_code).task_id;
+}
+
+void passthrough(std::shared_ptr<input_t> &input, PNV_KEYBOARD_PACKET packet) {
+  auto constexpr BUTTON_RELEASED = 0x04;
+
+  auto release = packet->keyAction == BUTTON_RELEASED;
+  auto keyCode = packet->keyCode & 0x00FF;
+
+  auto &pressed = key_press[keyCode];
+  if(!pressed) {
+    if(!release) {
+      // A new key has been pressed down, we need to check for key combo's
+      // If a keycombo has been pressed down, don't pass it through
+      if(input->shortcutFlags == input_t::SHORTCUT && apply_shortcut(keyCode) > 0) {
+        return;
+      }
+
+      if(key_press_repeat_id) {
+        task_pool.cancel(key_press_repeat_id);
+      }
+
+      if(config::input.key_repeat_delay.count() > 0) {
+        key_press_repeat_id = task_pool.pushDelayed(repeat_key, config::input.key_repeat_delay, keyCode).task_id;
+      }
+    }
+    else {
+      // Already released
+      return;
+    }
+  }
+  else if(!release) {
+    // Already pressed down key
+    return;
+  }
+
+  pressed = !release;
+
+  update_shortcutFlags(&input->shortcutFlags, map_keycode(keyCode), release);
+  platf::keyboard(platf_input, map_keycode(keyCode), release);
+}
+
+void passthrough(PNV_SCROLL_PACKET packet) {
+  platf::scroll(platf_input, util::endian::big(packet->scrollAmt1));
+}
+
+int updateGamepads(std::vector<gamepad_t> &gamepads, std::int16_t old_state, std::int16_t new_state, const platf::rumble_queue_t &rumble_queue) {
+  auto xorGamepadMask = old_state ^ new_state;
+  if(!xorGamepadMask) {
+    return 0;
+  }
+
+  for(int x = 0; x < sizeof(std::int16_t) * 8; ++x) {
+    if((xorGamepadMask >> x) & 1) {
+      auto &gamepad = gamepads[x];
+
+      if((old_state >> x) & 1) {
+        if(gamepad.id < 0) {
+          return -1;
+        }
+
+        free_gamepad(platf_input, gamepad.id);
+        gamepad.id = -1;
+      }
+      else {
+        auto id = alloc_id(gamepadMask);
+
+        if(id < 0) {
+          // Out of gamepads
+          return -1;
+        }
+
+        if(platf::alloc_gamepad(platf_input, id, rumble_queue)) {
+          free_id(gamepadMask, id);
+          // allocating a gamepad failed: solution: ignore gamepads
+          // The implementations of platf::alloc_gamepad already has logging
+          return -1;
+        }
+
+        gamepad.id = id;
+      }
+    }
+  }
+
+  return 0;
+}
+
+void passthrough(std::shared_ptr<input_t> &input, PNV_MULTI_CONTROLLER_PACKET packet) {
+  if(updateGamepads(input->gamepads, input->active_gamepad_state, packet->activeGamepadMask, input->rumble_queue)) {
+    return;
+  }
+
+  input->active_gamepad_state = packet->activeGamepadMask;
+
+  if(packet->controllerNumber < 0 || packet->controllerNumber >= input->gamepads.size()) {
+    BOOST_LOG(warning) << "ControllerNumber out of range ["sv << packet->controllerNumber << ']';
+
+    return;
+  }
+
+  if(!((input->active_gamepad_state >> packet->controllerNumber) & 1)) {
+    BOOST_LOG(warning) << "ControllerNumber ["sv << packet->controllerNumber << "] not allocated"sv;
+
+    return;
+  }
+
+  auto &gamepad = input->gamepads[packet->controllerNumber];
+
+  // If this gamepad has not been initialized, ignore it.
+  // This could happen when platf::alloc_gamepad fails
+  if(gamepad.id < 0) {
+    return;
+  }
+
+  std::uint16_t bf = packet->buttonFlags;
+  platf::gamepad_state_t gamepad_state {
+    bf,
+    packet->leftTrigger,
+    packet->rightTrigger,
+    packet->leftStickX,
+    packet->leftStickY,
+    packet->rightStickX,
+    packet->rightStickY
+  };
+
+  auto bf_new = gamepad_state.buttonFlags;
+  switch(gamepad.back_button_state) {
+  case button_state_e::UP:
+    if(!(platf::BACK & bf_new)) {
+      gamepad.back_button_state = button_state_e::NONE;
+    }
+    gamepad_state.buttonFlags &= ~platf::BACK;
+    break;
+  case button_state_e::DOWN:
+    if(platf::BACK & bf_new) {
+      gamepad.back_button_state = button_state_e::NONE;
+    }
+    gamepad_state.buttonFlags |= platf::BACK;
+    break;
+  case button_state_e::NONE:
+    break;
+  }
+
+  bf     = gamepad_state.buttonFlags ^ gamepad.gamepad_state.buttonFlags;
+  bf_new = gamepad_state.buttonFlags;
+
+  if(platf::BACK & bf) {
+    if(platf::BACK & bf_new) {
+      // Don't emulate home button if timeout < 0
+      if(config::input.back_button_timeout >= 0ms) {
+        auto f = [input, controller = packet->controllerNumber]() {
+          auto &gamepad = input->gamepads[controller];
+
+          auto &state = gamepad.gamepad_state;
+
+          // Force the back button up
+          gamepad.back_button_state = button_state_e::UP;
+          state.buttonFlags &= ~platf::BACK;
+          platf::gamepad(platf_input, gamepad.id, state);
+
+          // Press Home button
+          state.buttonFlags |= platf::HOME;
+          platf::gamepad(platf_input, gamepad.id, state);
+
+          // Release Home button
+          state.buttonFlags &= ~platf::HOME;
+          platf::gamepad(platf_input, gamepad.id, state);
+
+          gamepad.back_timeout_id = nullptr;
+        };
+
+        gamepad.back_timeout_id = task_pool.pushDelayed(std::move(f), config::input.back_button_timeout).task_id;
+      }
+    }
+    else if(gamepad.back_timeout_id) {
+      task_pool.cancel(gamepad.back_timeout_id);
+      gamepad.back_timeout_id = nullptr;
+    }
+  }
+
+  platf::gamepad(platf_input, gamepad.id, gamepad_state);
+
+  gamepad.gamepad_state = gamepad_state;
+}
+
+void passthrough_helper(std::shared_ptr<input_t> input, std::vector<std::uint8_t> &&input_data) {
+  void *payload = input_data.data();
+
+  int input_type = util::endian::big(*(int *)payload);
+
+  switch(input_type) {
+  case PACKET_TYPE_REL_MOUSE_MOVE:
+    passthrough(input, (PNV_REL_MOUSE_MOVE_PACKET)payload);
+    break;
+  case PACKET_TYPE_ABS_MOUSE_MOVE:
+    passthrough(input, (PNV_ABS_MOUSE_MOVE_PACKET)payload);
+    break;
+  case PACKET_TYPE_MOUSE_BUTTON:
+    passthrough(input, (PNV_MOUSE_BUTTON_PACKET)payload);
+    break;
+  case PACKET_TYPE_SCROLL_OR_KEYBOARD: {
+    char *tmp_input = (char *)payload + 4;
+    if(tmp_input[0] == 0x0A) {
+      passthrough((PNV_SCROLL_PACKET)payload);
+    }
+    else {
+      passthrough(input, (PNV_KEYBOARD_PACKET)payload);
+    }
+
+    break;
+  }
+  case PACKET_TYPE_MULTI_CONTROLLER:
+    passthrough(input, (PNV_MULTI_CONTROLLER_PACKET)payload);
+    break;
+  }
+}
+
+void passthrough(std::shared_ptr<input_t> &input, std::vector<std::uint8_t> &&input_data) {
+  task_pool.push(passthrough_helper, input, util::cmove(input_data));
+}
+
+void reset(std::shared_ptr<input_t> &input) {
+  task_pool.cancel(key_press_repeat_id);
+  task_pool.cancel(input->mouse_left_button_timeout);
+
+  // Ensure input is synchronous, by using the task_pool
+  task_pool.push([]() {
+    for(int x = 0; x < mouse_press.size(); ++x) {
+      if(mouse_press[x]) {
+        platf::button_mouse(platf_input, x, true);
+        mouse_press[x] = false;
+      }
+    }
+
+    for(auto &kp : key_press) {
+      platf::keyboard(platf_input, kp.first & 0x00FF, true);
+      key_press[kp.first] = false;
+    }
+  });
+}
+
+class deinit_t : public platf::deinit_t {
+public:
+  ~deinit_t() override {
+    platf_input.reset();
+  }
+};
+
+[[nodiscard]] std::unique_ptr<platf::deinit_t> init() {
+  platf_input = platf::input();
+
+  return std::make_unique<deinit_t>();
+}
+
+std::shared_ptr<input_t> alloc(safe::mail_t mail) {
+  auto input = std::make_shared<input_t>(
+    mail->event<input::touch_port_t>(mail::touch_port),
+    mail->queue<platf::rumble_t>(mail::rumble));
+
+  // Workaround to ensure new frames will be captured when a client connects
+  task_pool.pushDelayed([]() {
+    platf::move_mouse(platf_input, 1, 1);
+    platf::move_mouse(platf_input, -1, -1);
+  },
+    100ms);
+
+  return input;
+}
+} // namespace input